1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2e9be9d5eSMiklos Szeredi /* 3e9be9d5eSMiklos Szeredi * 4e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 5e9be9d5eSMiklos Szeredi */ 6e9be9d5eSMiklos Szeredi 7fb5bb2c3SDavid Howells #include <linux/module.h> 8e9be9d5eSMiklos Szeredi #include <linux/fs.h> 9e9be9d5eSMiklos Szeredi #include <linux/slab.h> 10e9be9d5eSMiklos Szeredi #include <linux/file.h> 1172db8211SAmir Goldstein #include <linux/fileattr.h> 12e9be9d5eSMiklos Szeredi #include <linux/splice.h> 13e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 14e9be9d5eSMiklos Szeredi #include <linux/security.h> 15e9be9d5eSMiklos Szeredi #include <linux/uaccess.h> 16174cd4b1SIngo Molnar #include <linux/sched/signal.h> 175b825c3aSIngo Molnar #include <linux/cred.h> 18e9be9d5eSMiklos Szeredi #include <linux/namei.h> 19fb5bb2c3SDavid Howells #include <linux/fdtable.h> 20fb5bb2c3SDavid Howells #include <linux/ratelimit.h> 213a1e819bSAmir Goldstein #include <linux/exportfs.h> 22e9be9d5eSMiklos Szeredi #include "overlayfs.h" 23e9be9d5eSMiklos Szeredi 24e9be9d5eSMiklos Szeredi #define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 25e9be9d5eSMiklos Szeredi 26670c2324SMiklos Szeredi static int ovl_ccup_set(const char *buf, const struct kernel_param *param) 27fb5bb2c3SDavid Howells { 281bd0a3aeSlijiazi pr_warn("\"check_copy_up\" module option is obsolete\n"); 29fb5bb2c3SDavid Howells return 0; 30fb5bb2c3SDavid Howells } 31fb5bb2c3SDavid Howells 32670c2324SMiklos Szeredi static int ovl_ccup_get(char *buf, const struct kernel_param *param) 33fb5bb2c3SDavid Howells { 34670c2324SMiklos Szeredi return sprintf(buf, "N\n"); 35fb5bb2c3SDavid Howells } 36fb5bb2c3SDavid Howells 37670c2324SMiklos Szeredi module_param_call(check_copy_up, ovl_ccup_set, ovl_ccup_get, NULL, 0644); 38253e7483SNicolas Schier MODULE_PARM_DESC(check_copy_up, "Obsolete; does nothing"); 39670c2324SMiklos Szeredi 40c61ca557SMiklos Szeredi static bool ovl_must_copy_xattr(const char *name) 41c61ca557SMiklos Szeredi { 42c61ca557SMiklos Szeredi return !strcmp(name, XATTR_POSIX_ACL_ACCESS) || 43c61ca557SMiklos Szeredi !strcmp(name, XATTR_POSIX_ACL_DEFAULT) || 44c61ca557SMiklos Szeredi !strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN); 45c61ca557SMiklos Szeredi } 46c61ca557SMiklos Szeredi 4731acceb9SChristian Brauner static int ovl_copy_acl(struct ovl_fs *ofs, const struct path *path, 4831acceb9SChristian Brauner struct dentry *dentry, const char *acl_name) 4931acceb9SChristian Brauner { 5031acceb9SChristian Brauner int err; 5131acceb9SChristian Brauner struct posix_acl *clone, *real_acl = NULL; 5231acceb9SChristian Brauner 5331acceb9SChristian Brauner real_acl = ovl_get_acl_path(path, acl_name, false); 5431acceb9SChristian Brauner if (!real_acl) 5531acceb9SChristian Brauner return 0; 5631acceb9SChristian Brauner 5731acceb9SChristian Brauner if (IS_ERR(real_acl)) { 5831acceb9SChristian Brauner err = PTR_ERR(real_acl); 5931acceb9SChristian Brauner if (err == -ENODATA || err == -EOPNOTSUPP) 6031acceb9SChristian Brauner return 0; 6131acceb9SChristian Brauner return err; 6231acceb9SChristian Brauner } 6331acceb9SChristian Brauner 6431acceb9SChristian Brauner clone = posix_acl_clone(real_acl, GFP_KERNEL); 6531acceb9SChristian Brauner posix_acl_release(real_acl); /* release original acl */ 6631acceb9SChristian Brauner if (!clone) 6731acceb9SChristian Brauner return -ENOMEM; 6831acceb9SChristian Brauner 6931acceb9SChristian Brauner err = ovl_do_set_acl(ofs, dentry, acl_name, clone); 7031acceb9SChristian Brauner 7131acceb9SChristian Brauner /* release cloned acl */ 7231acceb9SChristian Brauner posix_acl_release(clone); 7331acceb9SChristian Brauner return err; 7431acceb9SChristian Brauner } 7531acceb9SChristian Brauner 762d343087SAl Viro int ovl_copy_xattr(struct super_block *sb, const struct path *oldpath, struct dentry *new) 77e9be9d5eSMiklos Szeredi { 78dad7017aSChristian Brauner struct dentry *old = oldpath->dentry; 79e4ad29faSVito Caputo ssize_t list_size, size, value_size = 0; 80e4ad29faSVito Caputo char *buf, *name, *value = NULL; 81520da69dSYuxuan Shui int error = 0; 828b326c61SMiklos Szeredi size_t slen; 83e9be9d5eSMiklos Szeredi 84a1fbb607SChristian Brauner if (!old->d_inode->i_op->listxattr || !new->d_inode->i_op->listxattr) 85e9be9d5eSMiklos Szeredi return 0; 86e9be9d5eSMiklos Szeredi 87e9be9d5eSMiklos Szeredi list_size = vfs_listxattr(old, NULL, 0); 88e9be9d5eSMiklos Szeredi if (list_size <= 0) { 89e9be9d5eSMiklos Szeredi if (list_size == -EOPNOTSUPP) 90e9be9d5eSMiklos Szeredi return 0; 91e9be9d5eSMiklos Szeredi return list_size; 92e9be9d5eSMiklos Szeredi } 93e9be9d5eSMiklos Szeredi 94f945ca19SMiklos Szeredi buf = kvzalloc(list_size, GFP_KERNEL); 95e9be9d5eSMiklos Szeredi if (!buf) 96e9be9d5eSMiklos Szeredi return -ENOMEM; 97e9be9d5eSMiklos Szeredi 98e9be9d5eSMiklos Szeredi list_size = vfs_listxattr(old, buf, list_size); 99e9be9d5eSMiklos Szeredi if (list_size <= 0) { 100e9be9d5eSMiklos Szeredi error = list_size; 101e4ad29faSVito Caputo goto out; 102e9be9d5eSMiklos Szeredi } 103e9be9d5eSMiklos Szeredi 1048b326c61SMiklos Szeredi for (name = buf; list_size; name += slen) { 1058b326c61SMiklos Szeredi slen = strnlen(name, list_size) + 1; 1068b326c61SMiklos Szeredi 1078b326c61SMiklos Szeredi /* underlying fs providing us with an broken xattr list? */ 1088b326c61SMiklos Szeredi if (WARN_ON(slen > list_size)) { 1098b326c61SMiklos Szeredi error = -EIO; 1108b326c61SMiklos Szeredi break; 1118b326c61SMiklos Szeredi } 1128b326c61SMiklos Szeredi list_size -= slen; 1138b326c61SMiklos Szeredi 114610afc0bSMiklos Szeredi if (ovl_is_private_xattr(sb, name)) 1150956254aSMiklos Szeredi continue; 11603fedf93SAmir Goldstein 11703fedf93SAmir Goldstein error = security_inode_copy_up_xattr(name); 11803fedf93SAmir Goldstein if (error < 0 && error != -EOPNOTSUPP) 11903fedf93SAmir Goldstein break; 12003fedf93SAmir Goldstein if (error == 1) { 12103fedf93SAmir Goldstein error = 0; 12203fedf93SAmir Goldstein continue; /* Discard */ 12303fedf93SAmir Goldstein } 12431acceb9SChristian Brauner 12531acceb9SChristian Brauner if (is_posix_acl_xattr(name)) { 12631acceb9SChristian Brauner error = ovl_copy_acl(OVL_FS(sb), oldpath, new, name); 12731acceb9SChristian Brauner if (!error) 12831acceb9SChristian Brauner continue; 12931acceb9SChristian Brauner /* POSIX ACLs must be copied. */ 13031acceb9SChristian Brauner break; 13131acceb9SChristian Brauner } 13231acceb9SChristian Brauner 133e4ad29faSVito Caputo retry: 134dad7017aSChristian Brauner size = ovl_do_getxattr(oldpath, name, value, value_size); 135e4ad29faSVito Caputo if (size == -ERANGE) 136dad7017aSChristian Brauner size = ovl_do_getxattr(oldpath, name, NULL, 0); 137e4ad29faSVito Caputo 13897daf8b9SMiklos Szeredi if (size < 0) { 139e9be9d5eSMiklos Szeredi error = size; 140e4ad29faSVito Caputo break; 141e9be9d5eSMiklos Szeredi } 142e9be9d5eSMiklos Szeredi 143e4ad29faSVito Caputo if (size > value_size) { 144e4ad29faSVito Caputo void *new; 145e4ad29faSVito Caputo 146f945ca19SMiklos Szeredi new = kvmalloc(size, GFP_KERNEL); 147e4ad29faSVito Caputo if (!new) { 148e4ad29faSVito Caputo error = -ENOMEM; 149e4ad29faSVito Caputo break; 150e4ad29faSVito Caputo } 151f945ca19SMiklos Szeredi kvfree(value); 152e4ad29faSVito Caputo value = new; 153e4ad29faSVito Caputo value_size = size; 154e4ad29faSVito Caputo goto retry; 155e4ad29faSVito Caputo } 156e4ad29faSVito Caputo 157c914c0e2SAmir Goldstein error = ovl_do_setxattr(OVL_FS(sb), new, name, value, size, 0); 158c61ca557SMiklos Szeredi if (error) { 159c61ca557SMiklos Szeredi if (error != -EOPNOTSUPP || ovl_must_copy_xattr(name)) 160e4ad29faSVito Caputo break; 161c61ca557SMiklos Szeredi 162c61ca557SMiklos Szeredi /* Ignore failure to copy unknown xattrs */ 163c61ca557SMiklos Szeredi error = 0; 164c61ca557SMiklos Szeredi } 165e4ad29faSVito Caputo } 166f945ca19SMiklos Szeredi kvfree(value); 167e9be9d5eSMiklos Szeredi out: 168f945ca19SMiklos Szeredi kvfree(buf); 169e9be9d5eSMiklos Szeredi return error; 170e9be9d5eSMiklos Szeredi } 171e9be9d5eSMiklos Szeredi 1722d343087SAl Viro static int ovl_copy_fileattr(struct inode *inode, const struct path *old, 1732d343087SAl Viro const struct path *new) 17472db8211SAmir Goldstein { 17572db8211SAmir Goldstein struct fileattr oldfa = { .flags_valid = true }; 17672db8211SAmir Goldstein struct fileattr newfa = { .flags_valid = true }; 17772db8211SAmir Goldstein int err; 17872db8211SAmir Goldstein 17972db8211SAmir Goldstein err = ovl_real_fileattr_get(old, &oldfa); 1805b0a414dSMiklos Szeredi if (err) { 1815b0a414dSMiklos Szeredi /* Ntfs-3g returns -EINVAL for "no fileattr support" */ 1825b0a414dSMiklos Szeredi if (err == -ENOTTY || err == -EINVAL) 1835b0a414dSMiklos Szeredi return 0; 1845b0a414dSMiklos Szeredi pr_warn("failed to retrieve lower fileattr (%pd2, err=%i)\n", 1854ee7e4a6SChristoph Fritz old->dentry, err); 18672db8211SAmir Goldstein return err; 1875b0a414dSMiklos Szeredi } 18872db8211SAmir Goldstein 189096a218aSAmir Goldstein /* 190096a218aSAmir Goldstein * We cannot set immutable and append-only flags on upper inode, 191096a218aSAmir Goldstein * because we would not be able to link upper inode to upper dir 192096a218aSAmir Goldstein * not set overlay private xattr on upper inode. 193096a218aSAmir Goldstein * Store these flags in overlay.protattr xattr instead. 194096a218aSAmir Goldstein */ 195096a218aSAmir Goldstein if (oldfa.flags & OVL_PROT_FS_FLAGS_MASK) { 196096a218aSAmir Goldstein err = ovl_set_protattr(inode, new->dentry, &oldfa); 19794fd1975SMiklos Szeredi if (err == -EPERM) 19894fd1975SMiklos Szeredi pr_warn_once("copying fileattr: no xattr on upper\n"); 19994fd1975SMiklos Szeredi else if (err) 200096a218aSAmir Goldstein return err; 201096a218aSAmir Goldstein } 202096a218aSAmir Goldstein 2035b0a414dSMiklos Szeredi /* Don't bother copying flags if none are set */ 2045b0a414dSMiklos Szeredi if (!(oldfa.flags & OVL_COPY_FS_FLAGS_MASK)) 2055b0a414dSMiklos Szeredi return 0; 2065b0a414dSMiklos Szeredi 2075b0a414dSMiklos Szeredi err = ovl_real_fileattr_get(new, &newfa); 2085b0a414dSMiklos Szeredi if (err) { 20994fd1975SMiklos Szeredi /* 21094fd1975SMiklos Szeredi * Returning an error if upper doesn't support fileattr will 21194fd1975SMiklos Szeredi * result in a regression, so revert to the old behavior. 21294fd1975SMiklos Szeredi */ 21394fd1975SMiklos Szeredi if (err == -ENOTTY || err == -EINVAL) { 21494fd1975SMiklos Szeredi pr_warn_once("copying fileattr: no support on upper\n"); 21594fd1975SMiklos Szeredi return 0; 21694fd1975SMiklos Szeredi } 2175b0a414dSMiklos Szeredi pr_warn("failed to retrieve upper fileattr (%pd2, err=%i)\n", 2184ee7e4a6SChristoph Fritz new->dentry, err); 2195b0a414dSMiklos Szeredi return err; 2205b0a414dSMiklos Szeredi } 2215b0a414dSMiklos Szeredi 22272db8211SAmir Goldstein BUILD_BUG_ON(OVL_COPY_FS_FLAGS_MASK & ~FS_COMMON_FL); 22372db8211SAmir Goldstein newfa.flags &= ~OVL_COPY_FS_FLAGS_MASK; 22472db8211SAmir Goldstein newfa.flags |= (oldfa.flags & OVL_COPY_FS_FLAGS_MASK); 22572db8211SAmir Goldstein 22672db8211SAmir Goldstein BUILD_BUG_ON(OVL_COPY_FSX_FLAGS_MASK & ~FS_XFLAG_COMMON); 22772db8211SAmir Goldstein newfa.fsx_xflags &= ~OVL_COPY_FSX_FLAGS_MASK; 22872db8211SAmir Goldstein newfa.fsx_xflags |= (oldfa.fsx_xflags & OVL_COPY_FSX_FLAGS_MASK); 22972db8211SAmir Goldstein 23072db8211SAmir Goldstein return ovl_real_fileattr_set(new, &newfa); 23172db8211SAmir Goldstein } 23272db8211SAmir Goldstein 2332b1a7746SMiklos Szeredi static int ovl_copy_up_file(struct ovl_fs *ofs, struct dentry *dentry, 2342b1a7746SMiklos Szeredi struct file *new_file, loff_t len) 235e9be9d5eSMiklos Szeredi { 2362b1a7746SMiklos Szeredi struct path datapath; 237e9be9d5eSMiklos Szeredi struct file *old_file; 238e9be9d5eSMiklos Szeredi loff_t old_pos = 0; 239e9be9d5eSMiklos Szeredi loff_t new_pos = 0; 24042ec3d4cSDarrick J. Wong loff_t cloned; 241b504c654SChengguang Xu loff_t data_pos = -1; 242b504c654SChengguang Xu loff_t hole_len; 243b504c654SChengguang Xu bool skip_hole = false; 244e9be9d5eSMiklos Szeredi int error = 0; 245e9be9d5eSMiklos Szeredi 2462b1a7746SMiklos Szeredi ovl_path_lowerdata(dentry, &datapath); 2472b1a7746SMiklos Szeredi if (WARN_ON(datapath.dentry == NULL)) 2482b1a7746SMiklos Szeredi return -EIO; 249e9be9d5eSMiklos Szeredi 2502b1a7746SMiklos Szeredi old_file = ovl_path_open(&datapath, O_LARGEFILE | O_RDONLY); 251e9be9d5eSMiklos Szeredi if (IS_ERR(old_file)) 252e9be9d5eSMiklos Szeredi return PTR_ERR(old_file); 253e9be9d5eSMiklos Szeredi 2542ea98466SAmir Goldstein /* Try to use clone_file_range to clone up within the same fs */ 255452ce659SDarrick J. Wong cloned = do_clone_file_range(old_file, 0, new_file, 0, len, 0); 25642ec3d4cSDarrick J. Wong if (cloned == len) 2572b1a7746SMiklos Szeredi goto out_fput; 2582ea98466SAmir Goldstein /* Couldn't clone, so now we try to copy the data */ 2592ea98466SAmir Goldstein 260b504c654SChengguang Xu /* Check if lower fs supports seek operation */ 2614e3299eaSJason A. Donenfeld if (old_file->f_mode & FMODE_LSEEK) 262b504c654SChengguang Xu skip_hole = true; 263b504c654SChengguang Xu 264e9be9d5eSMiklos Szeredi while (len) { 265e9be9d5eSMiklos Szeredi size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 266e9be9d5eSMiklos Szeredi long bytes; 267e9be9d5eSMiklos Szeredi 268e9be9d5eSMiklos Szeredi if (len < this_len) 269e9be9d5eSMiklos Szeredi this_len = len; 270e9be9d5eSMiklos Szeredi 271e9be9d5eSMiklos Szeredi if (signal_pending_state(TASK_KILLABLE, current)) { 272e9be9d5eSMiklos Szeredi error = -EINTR; 273e9be9d5eSMiklos Szeredi break; 274e9be9d5eSMiklos Szeredi } 275e9be9d5eSMiklos Szeredi 276b504c654SChengguang Xu /* 277b504c654SChengguang Xu * Fill zero for hole will cost unnecessary disk space 278b504c654SChengguang Xu * and meanwhile slow down the copy-up speed, so we do 279b504c654SChengguang Xu * an optimization for hole during copy-up, it relies 280b504c654SChengguang Xu * on SEEK_DATA implementation in lower fs so if lower 281b504c654SChengguang Xu * fs does not support it, copy-up will behave as before. 282b504c654SChengguang Xu * 283b504c654SChengguang Xu * Detail logic of hole detection as below: 284b504c654SChengguang Xu * When we detect next data position is larger than current 285b504c654SChengguang Xu * position we will skip that hole, otherwise we copy 286b504c654SChengguang Xu * data in the size of OVL_COPY_UP_CHUNK_SIZE. Actually, 287b504c654SChengguang Xu * it may not recognize all kind of holes and sometimes 288b504c654SChengguang Xu * only skips partial of hole area. However, it will be 289b504c654SChengguang Xu * enough for most of the use cases. 290b504c654SChengguang Xu */ 291b504c654SChengguang Xu 292b504c654SChengguang Xu if (skip_hole && data_pos < old_pos) { 293b504c654SChengguang Xu data_pos = vfs_llseek(old_file, old_pos, SEEK_DATA); 294b504c654SChengguang Xu if (data_pos > old_pos) { 295b504c654SChengguang Xu hole_len = data_pos - old_pos; 296b504c654SChengguang Xu len -= hole_len; 297b504c654SChengguang Xu old_pos = new_pos = data_pos; 298b504c654SChengguang Xu continue; 299b504c654SChengguang Xu } else if (data_pos == -ENXIO) { 300b504c654SChengguang Xu break; 301b504c654SChengguang Xu } else if (data_pos < 0) { 302b504c654SChengguang Xu skip_hole = false; 303b504c654SChengguang Xu } 304b504c654SChengguang Xu } 305b504c654SChengguang Xu 306e9be9d5eSMiklos Szeredi bytes = do_splice_direct(old_file, &old_pos, 307e9be9d5eSMiklos Szeredi new_file, &new_pos, 308e9be9d5eSMiklos Szeredi this_len, SPLICE_F_MOVE); 309e9be9d5eSMiklos Szeredi if (bytes <= 0) { 310e9be9d5eSMiklos Szeredi error = bytes; 311e9be9d5eSMiklos Szeredi break; 312e9be9d5eSMiklos Szeredi } 313e9be9d5eSMiklos Szeredi WARN_ON(old_pos != new_pos); 314e9be9d5eSMiklos Szeredi 315e9be9d5eSMiklos Szeredi len -= bytes; 316e9be9d5eSMiklos Szeredi } 317c86243b0SVivek Goyal if (!error && ovl_should_sync(ofs)) 318641089c1SMiklos Szeredi error = vfs_fsync(new_file, 0); 319e9be9d5eSMiklos Szeredi out_fput: 320e9be9d5eSMiklos Szeredi fput(old_file); 321e9be9d5eSMiklos Szeredi return error; 322e9be9d5eSMiklos Szeredi } 323e9be9d5eSMiklos Szeredi 3245272eaf3SChristian Brauner static int ovl_set_size(struct ovl_fs *ofs, 3255272eaf3SChristian Brauner struct dentry *upperdentry, struct kstat *stat) 3260c288874SVivek Goyal { 3270c288874SVivek Goyal struct iattr attr = { 3280c288874SVivek Goyal .ia_valid = ATTR_SIZE, 3290c288874SVivek Goyal .ia_size = stat->size, 3300c288874SVivek Goyal }; 3310c288874SVivek Goyal 332a15506eaSChristian Brauner return ovl_do_notify_change(ofs, upperdentry, &attr); 3330c288874SVivek Goyal } 3340c288874SVivek Goyal 3355272eaf3SChristian Brauner static int ovl_set_timestamps(struct ovl_fs *ofs, struct dentry *upperdentry, 3365272eaf3SChristian Brauner struct kstat *stat) 337e9be9d5eSMiklos Szeredi { 338e9be9d5eSMiklos Szeredi struct iattr attr = { 339e9be9d5eSMiklos Szeredi .ia_valid = 340e9be9d5eSMiklos Szeredi ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 341e9be9d5eSMiklos Szeredi .ia_atime = stat->atime, 342e9be9d5eSMiklos Szeredi .ia_mtime = stat->mtime, 343e9be9d5eSMiklos Szeredi }; 344e9be9d5eSMiklos Szeredi 345a15506eaSChristian Brauner return ovl_do_notify_change(ofs, upperdentry, &attr); 346e9be9d5eSMiklos Szeredi } 347e9be9d5eSMiklos Szeredi 3485272eaf3SChristian Brauner int ovl_set_attr(struct ovl_fs *ofs, struct dentry *upperdentry, 3495272eaf3SChristian Brauner struct kstat *stat) 350e9be9d5eSMiklos Szeredi { 351e9be9d5eSMiklos Szeredi int err = 0; 352e9be9d5eSMiklos Szeredi 353e9be9d5eSMiklos Szeredi if (!S_ISLNK(stat->mode)) { 354e9be9d5eSMiklos Szeredi struct iattr attr = { 355e9be9d5eSMiklos Szeredi .ia_valid = ATTR_MODE, 356e9be9d5eSMiklos Szeredi .ia_mode = stat->mode, 357e9be9d5eSMiklos Szeredi }; 358a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, upperdentry, &attr); 359e9be9d5eSMiklos Szeredi } 360e9be9d5eSMiklos Szeredi if (!err) { 361e9be9d5eSMiklos Szeredi struct iattr attr = { 362e9be9d5eSMiklos Szeredi .ia_valid = ATTR_UID | ATTR_GID, 363b27c82e1SChristian Brauner .ia_vfsuid = VFSUIDT_INIT(stat->uid), 364b27c82e1SChristian Brauner .ia_vfsgid = VFSGIDT_INIT(stat->gid), 365e9be9d5eSMiklos Szeredi }; 366a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, upperdentry, &attr); 367e9be9d5eSMiklos Szeredi } 368e9be9d5eSMiklos Szeredi if (!err) 3695272eaf3SChristian Brauner ovl_set_timestamps(ofs, upperdentry, stat); 370e9be9d5eSMiklos Szeredi 371e9be9d5eSMiklos Szeredi return err; 372e9be9d5eSMiklos Szeredi } 373e9be9d5eSMiklos Szeredi 3741cdb0cb6SPavel Tikhomirov struct ovl_fh *ovl_encode_real_fh(struct ovl_fs *ofs, struct dentry *real, 3751cdb0cb6SPavel Tikhomirov bool is_upper) 3763a1e819bSAmir Goldstein { 3773a1e819bSAmir Goldstein struct ovl_fh *fh; 378ec7bbb53SAmir Goldstein int fh_type, dwords; 3793a1e819bSAmir Goldstein int buflen = MAX_HANDLE_SZ; 38005122443SAmir Goldstein uuid_t *uuid = &real->d_sb->s_uuid; 381ec7bbb53SAmir Goldstein int err; 3823a1e819bSAmir Goldstein 383ec7bbb53SAmir Goldstein /* Make sure the real fid stays 32bit aligned */ 384ec7bbb53SAmir Goldstein BUILD_BUG_ON(OVL_FH_FID_OFFSET % 4); 385ec7bbb53SAmir Goldstein BUILD_BUG_ON(MAX_HANDLE_SZ + OVL_FH_FID_OFFSET > 255); 386ec7bbb53SAmir Goldstein 387ec7bbb53SAmir Goldstein fh = kzalloc(buflen + OVL_FH_FID_OFFSET, GFP_KERNEL); 388ec7bbb53SAmir Goldstein if (!fh) 3893a1e819bSAmir Goldstein return ERR_PTR(-ENOMEM); 3903a1e819bSAmir Goldstein 3913a1e819bSAmir Goldstein /* 3923a1e819bSAmir Goldstein * We encode a non-connectable file handle for non-dir, because we 3933a1e819bSAmir Goldstein * only need to find the lower inode number and we don't want to pay 3943a1e819bSAmir Goldstein * the price or reconnecting the dentry. 3953a1e819bSAmir Goldstein */ 3963a1e819bSAmir Goldstein dwords = buflen >> 2; 397ec7bbb53SAmir Goldstein fh_type = exportfs_encode_fh(real, (void *)fh->fb.fid, &dwords, 0); 3983a1e819bSAmir Goldstein buflen = (dwords << 2); 3993a1e819bSAmir Goldstein 400ec7bbb53SAmir Goldstein err = -EIO; 4013a1e819bSAmir Goldstein if (WARN_ON(fh_type < 0) || 4023a1e819bSAmir Goldstein WARN_ON(buflen > MAX_HANDLE_SZ) || 4033a1e819bSAmir Goldstein WARN_ON(fh_type == FILEID_INVALID)) 404ec7bbb53SAmir Goldstein goto out_err; 4053a1e819bSAmir Goldstein 406cbe7fba8SAmir Goldstein fh->fb.version = OVL_FH_VERSION; 407cbe7fba8SAmir Goldstein fh->fb.magic = OVL_FH_MAGIC; 408cbe7fba8SAmir Goldstein fh->fb.type = fh_type; 409cbe7fba8SAmir Goldstein fh->fb.flags = OVL_FH_FLAG_CPU_ENDIAN; 41054fb347eSAmir Goldstein /* 41154fb347eSAmir Goldstein * When we will want to decode an overlay dentry from this handle 41254fb347eSAmir Goldstein * and all layers are on the same fs, if we get a disconncted real 41354fb347eSAmir Goldstein * dentry when we decode fid, the only way to tell if we should assign 41454fb347eSAmir Goldstein * it to upperdentry or to lowerstack is by checking this flag. 41554fb347eSAmir Goldstein */ 41654fb347eSAmir Goldstein if (is_upper) 417cbe7fba8SAmir Goldstein fh->fb.flags |= OVL_FH_FLAG_PATH_UPPER; 418ec7bbb53SAmir Goldstein fh->fb.len = sizeof(fh->fb) + buflen; 419*b0504bfeSAmir Goldstein if (ovl_origin_uuid(ofs)) 420cbe7fba8SAmir Goldstein fh->fb.uuid = *uuid; 4213a1e819bSAmir Goldstein 4223a1e819bSAmir Goldstein return fh; 423ec7bbb53SAmir Goldstein 424ec7bbb53SAmir Goldstein out_err: 425ec7bbb53SAmir Goldstein kfree(fh); 426ec7bbb53SAmir Goldstein return ERR_PTR(err); 4273a1e819bSAmir Goldstein } 4283a1e819bSAmir Goldstein 429a0c236b1SAmir Goldstein int ovl_set_origin(struct ovl_fs *ofs, struct dentry *lower, 430a0c236b1SAmir Goldstein struct dentry *upper) 4313a1e819bSAmir Goldstein { 4323a1e819bSAmir Goldstein const struct ovl_fh *fh = NULL; 4333a1e819bSAmir Goldstein int err; 4343a1e819bSAmir Goldstein 4353a1e819bSAmir Goldstein /* 4363a1e819bSAmir Goldstein * When lower layer doesn't support export operations store a 'null' fh, 4373a1e819bSAmir Goldstein * so we can use the overlay.origin xattr to distignuish between a copy 4383a1e819bSAmir Goldstein * up and a pure upper inode. 4393a1e819bSAmir Goldstein */ 44002bcd157SAmir Goldstein if (ovl_can_decode_fh(lower->d_sb)) { 4411cdb0cb6SPavel Tikhomirov fh = ovl_encode_real_fh(ofs, lower, false); 4423a1e819bSAmir Goldstein if (IS_ERR(fh)) 4433a1e819bSAmir Goldstein return PTR_ERR(fh); 4443a1e819bSAmir Goldstein } 4453a1e819bSAmir Goldstein 4466266d465SMiklos Szeredi /* 4476266d465SMiklos Szeredi * Do not fail when upper doesn't support xattrs. 4486266d465SMiklos Szeredi */ 449a0c236b1SAmir Goldstein err = ovl_check_setxattr(ofs, upper, OVL_XATTR_ORIGIN, fh->buf, 450cbe7fba8SAmir Goldstein fh ? fh->fb.len : 0, 0); 4513a1e819bSAmir Goldstein kfree(fh); 4523a1e819bSAmir Goldstein 4536939f977SMiklos Szeredi /* Ignore -EPERM from setting "user.*" on symlink/special */ 4546939f977SMiklos Szeredi return err == -EPERM ? 0 : err; 4553a1e819bSAmir Goldstein } 4563a1e819bSAmir Goldstein 457016b720fSAmir Goldstein /* Store file handle of @upper dir in @index dir entry */ 458610afc0bSMiklos Szeredi static int ovl_set_upper_fh(struct ovl_fs *ofs, struct dentry *upper, 459610afc0bSMiklos Szeredi struct dentry *index) 460016b720fSAmir Goldstein { 461016b720fSAmir Goldstein const struct ovl_fh *fh; 462016b720fSAmir Goldstein int err; 463016b720fSAmir Goldstein 4641cdb0cb6SPavel Tikhomirov fh = ovl_encode_real_fh(ofs, upper, true); 465016b720fSAmir Goldstein if (IS_ERR(fh)) 466016b720fSAmir Goldstein return PTR_ERR(fh); 467016b720fSAmir Goldstein 468c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, index, OVL_XATTR_UPPER, fh->buf, fh->fb.len); 469016b720fSAmir Goldstein 470016b720fSAmir Goldstein kfree(fh); 471016b720fSAmir Goldstein return err; 472016b720fSAmir Goldstein } 473016b720fSAmir Goldstein 474016b720fSAmir Goldstein /* 475016b720fSAmir Goldstein * Create and install index entry. 476016b720fSAmir Goldstein * 477016b720fSAmir Goldstein * Caller must hold i_mutex on indexdir. 478016b720fSAmir Goldstein */ 479016b720fSAmir Goldstein static int ovl_create_index(struct dentry *dentry, struct dentry *origin, 480016b720fSAmir Goldstein struct dentry *upper) 481016b720fSAmir Goldstein { 4821cdb0cb6SPavel Tikhomirov struct ovl_fs *ofs = OVL_FS(dentry->d_sb); 483016b720fSAmir Goldstein struct dentry *indexdir = ovl_indexdir(dentry->d_sb); 484016b720fSAmir Goldstein struct inode *dir = d_inode(indexdir); 485016b720fSAmir Goldstein struct dentry *index = NULL; 486016b720fSAmir Goldstein struct dentry *temp = NULL; 487016b720fSAmir Goldstein struct qstr name = { }; 488016b720fSAmir Goldstein int err; 489016b720fSAmir Goldstein 490016b720fSAmir Goldstein /* 491016b720fSAmir Goldstein * For now this is only used for creating index entry for directories, 492016b720fSAmir Goldstein * because non-dir are copied up directly to index and then hardlinked 493016b720fSAmir Goldstein * to upper dir. 494016b720fSAmir Goldstein * 495016b720fSAmir Goldstein * TODO: implement create index for non-dir, so we can call it when 496016b720fSAmir Goldstein * encoding file handle for non-dir in case index does not exist. 497016b720fSAmir Goldstein */ 498016b720fSAmir Goldstein if (WARN_ON(!d_is_dir(dentry))) 499016b720fSAmir Goldstein return -EIO; 500016b720fSAmir Goldstein 501016b720fSAmir Goldstein /* Directory not expected to be indexed before copy up */ 502016b720fSAmir Goldstein if (WARN_ON(ovl_test_flag(OVL_INDEX, d_inode(dentry)))) 503016b720fSAmir Goldstein return -EIO; 504016b720fSAmir Goldstein 5051cdb0cb6SPavel Tikhomirov err = ovl_get_index_name(ofs, origin, &name); 506016b720fSAmir Goldstein if (err) 507016b720fSAmir Goldstein return err; 508016b720fSAmir Goldstein 509576bb263SChristian Brauner temp = ovl_create_temp(ofs, indexdir, OVL_CATTR(S_IFDIR | 0)); 510b148cba4SMiklos Szeredi err = PTR_ERR(temp); 511016b720fSAmir Goldstein if (IS_ERR(temp)) 512b148cba4SMiklos Szeredi goto free_name; 513016b720fSAmir Goldstein 5141cdb0cb6SPavel Tikhomirov err = ovl_set_upper_fh(ofs, upper, temp); 515016b720fSAmir Goldstein if (err) 516b148cba4SMiklos Szeredi goto out; 517016b720fSAmir Goldstein 51822f289ceSChristian Brauner index = ovl_lookup_upper(ofs, name.name, indexdir, name.len); 519016b720fSAmir Goldstein if (IS_ERR(index)) { 520016b720fSAmir Goldstein err = PTR_ERR(index); 521016b720fSAmir Goldstein } else { 522576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, index, 0); 523016b720fSAmir Goldstein dput(index); 524016b720fSAmir Goldstein } 525016b720fSAmir Goldstein out: 526b148cba4SMiklos Szeredi if (err) 527576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp); 528016b720fSAmir Goldstein dput(temp); 529b148cba4SMiklos Szeredi free_name: 530016b720fSAmir Goldstein kfree(name.name); 531016b720fSAmir Goldstein return err; 532016b720fSAmir Goldstein } 533016b720fSAmir Goldstein 53423f0ab13SMiklos Szeredi struct ovl_copy_up_ctx { 535a6fb235aSMiklos Szeredi struct dentry *parent; 53623f0ab13SMiklos Szeredi struct dentry *dentry; 53723f0ab13SMiklos Szeredi struct path lowerpath; 53823f0ab13SMiklos Szeredi struct kstat stat; 53923f0ab13SMiklos Szeredi struct kstat pstat; 54023f0ab13SMiklos Szeredi const char *link; 54159be0971SAmir Goldstein struct dentry *destdir; 54259be0971SAmir Goldstein struct qstr destname; 54323f0ab13SMiklos Szeredi struct dentry *workdir; 54459be0971SAmir Goldstein bool origin; 545016b720fSAmir Goldstein bool indexed; 54644d5bf10SVivek Goyal bool metacopy; 5470c71faf5SAlexander Larsson bool metacopy_digest; 54823f0ab13SMiklos Szeredi }; 54923f0ab13SMiklos Szeredi 550f4439de1SAmir Goldstein static int ovl_link_up(struct ovl_copy_up_ctx *c) 551f4439de1SAmir Goldstein { 552f4439de1SAmir Goldstein int err; 553f4439de1SAmir Goldstein struct dentry *upper; 554f4439de1SAmir Goldstein struct dentry *upperdir = ovl_dentry_upper(c->parent); 555576bb263SChristian Brauner struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 556f4439de1SAmir Goldstein struct inode *udir = d_inode(upperdir); 557f4439de1SAmir Goldstein 558f4439de1SAmir Goldstein /* Mark parent "impure" because it may now contain non-pure upper */ 559f4439de1SAmir Goldstein err = ovl_set_impure(c->parent, upperdir); 560f4439de1SAmir Goldstein if (err) 561f4439de1SAmir Goldstein return err; 562f4439de1SAmir Goldstein 563f4439de1SAmir Goldstein err = ovl_set_nlink_lower(c->dentry); 564f4439de1SAmir Goldstein if (err) 565f4439de1SAmir Goldstein return err; 566f4439de1SAmir Goldstein 567f4439de1SAmir Goldstein inode_lock_nested(udir, I_MUTEX_PARENT); 56822f289ceSChristian Brauner upper = ovl_lookup_upper(ofs, c->dentry->d_name.name, upperdir, 569f4439de1SAmir Goldstein c->dentry->d_name.len); 570f4439de1SAmir Goldstein err = PTR_ERR(upper); 571f4439de1SAmir Goldstein if (!IS_ERR(upper)) { 572576bb263SChristian Brauner err = ovl_do_link(ofs, ovl_dentry_upper(c->dentry), udir, upper); 573f4439de1SAmir Goldstein dput(upper); 574f4439de1SAmir Goldstein 575f4439de1SAmir Goldstein if (!err) { 576f4439de1SAmir Goldstein /* Restore timestamps on parent (best effort) */ 5775272eaf3SChristian Brauner ovl_set_timestamps(ofs, upperdir, &c->pstat); 578f4439de1SAmir Goldstein ovl_dentry_set_upper_alias(c->dentry); 579b07d5cc9SAmir Goldstein ovl_dentry_update_reval(c->dentry, upper); 580f4439de1SAmir Goldstein } 581f4439de1SAmir Goldstein } 582f4439de1SAmir Goldstein inode_unlock(udir); 583aa3ff3c1SAmir Goldstein if (err) 584aa3ff3c1SAmir Goldstein return err; 585aa3ff3c1SAmir Goldstein 586aa3ff3c1SAmir Goldstein err = ovl_set_nlink_upper(c->dentry); 587f4439de1SAmir Goldstein 588f4439de1SAmir Goldstein return err; 589f4439de1SAmir Goldstein } 590f4439de1SAmir Goldstein 5912b1a7746SMiklos Szeredi static int ovl_copy_up_data(struct ovl_copy_up_ctx *c, const struct path *temp) 5922b1a7746SMiklos Szeredi { 5932b1a7746SMiklos Szeredi struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 5942b1a7746SMiklos Szeredi struct file *new_file; 5952b1a7746SMiklos Szeredi int err; 5962b1a7746SMiklos Szeredi 5972b1a7746SMiklos Szeredi if (!S_ISREG(c->stat.mode) || c->metacopy || !c->stat.size) 5982b1a7746SMiklos Szeredi return 0; 5992b1a7746SMiklos Szeredi 6002b1a7746SMiklos Szeredi new_file = ovl_path_open(temp, O_LARGEFILE | O_WRONLY); 6012b1a7746SMiklos Szeredi if (IS_ERR(new_file)) 6022b1a7746SMiklos Szeredi return PTR_ERR(new_file); 6032b1a7746SMiklos Szeredi 6042b1a7746SMiklos Szeredi err = ovl_copy_up_file(ofs, c->dentry, new_file, c->stat.size); 6052b1a7746SMiklos Szeredi fput(new_file); 6062b1a7746SMiklos Szeredi 6072b1a7746SMiklos Szeredi return err; 6082b1a7746SMiklos Szeredi } 6092b1a7746SMiklos Szeredi 6102b1a7746SMiklos Szeredi static int ovl_copy_up_metadata(struct ovl_copy_up_ctx *c, struct dentry *temp) 61102209d10SAmir Goldstein { 612c86243b0SVivek Goyal struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 61372db8211SAmir Goldstein struct inode *inode = d_inode(c->dentry); 6142b1a7746SMiklos Szeredi struct path upperpath = { .mnt = ovl_upper_mnt(ofs), .dentry = temp }; 61502209d10SAmir Goldstein int err; 61602209d10SAmir Goldstein 617dad7017aSChristian Brauner err = ovl_copy_xattr(c->dentry->d_sb, &c->lowerpath, temp); 61802209d10SAmir Goldstein if (err) 61902209d10SAmir Goldstein return err; 62002209d10SAmir Goldstein 62172db8211SAmir Goldstein if (inode->i_flags & OVL_COPY_I_FLAGS_MASK) { 62272db8211SAmir Goldstein /* 62372db8211SAmir Goldstein * Copy the fileattr inode flags that are the source of already 62472db8211SAmir Goldstein * copied i_flags 62572db8211SAmir Goldstein */ 626096a218aSAmir Goldstein err = ovl_copy_fileattr(inode, &c->lowerpath, &upperpath); 62772db8211SAmir Goldstein if (err) 62872db8211SAmir Goldstein return err; 62972db8211SAmir Goldstein } 63072db8211SAmir Goldstein 63102209d10SAmir Goldstein /* 63202209d10SAmir Goldstein * Store identifier of lower inode in upper inode xattr to 63302209d10SAmir Goldstein * allow lookup of the copy up origin inode. 63402209d10SAmir Goldstein * 63502209d10SAmir Goldstein * Don't set origin when we are breaking the association with a lower 63602209d10SAmir Goldstein * hard link. 63702209d10SAmir Goldstein */ 63859be0971SAmir Goldstein if (c->origin) { 639a0c236b1SAmir Goldstein err = ovl_set_origin(ofs, c->lowerpath.dentry, temp); 64002209d10SAmir Goldstein if (err) 64102209d10SAmir Goldstein return err; 64202209d10SAmir Goldstein } 64302209d10SAmir Goldstein 6440c288874SVivek Goyal if (c->metacopy) { 6450c71faf5SAlexander Larsson struct path lowerdatapath; 6460c71faf5SAlexander Larsson struct ovl_metacopy metacopy_data = OVL_METACOPY_INIT; 6470c71faf5SAlexander Larsson 6480c71faf5SAlexander Larsson ovl_path_lowerdata(c->dentry, &lowerdatapath); 6490c71faf5SAlexander Larsson if (WARN_ON_ONCE(lowerdatapath.dentry == NULL)) 6500c71faf5SAlexander Larsson return -EIO; 6510c71faf5SAlexander Larsson err = ovl_get_verity_digest(ofs, &lowerdatapath, &metacopy_data); 6520c71faf5SAlexander Larsson if (err) 6530c71faf5SAlexander Larsson return err; 6540c71faf5SAlexander Larsson 6550c71faf5SAlexander Larsson if (metacopy_data.digest_algo) 6560c71faf5SAlexander Larsson c->metacopy_digest = true; 6570c71faf5SAlexander Larsson 6580c71faf5SAlexander Larsson err = ovl_set_metacopy_xattr(ofs, temp, &metacopy_data); 6590c288874SVivek Goyal if (err) 6600c288874SVivek Goyal return err; 6610c288874SVivek Goyal } 6620c288874SVivek Goyal 663bd64e575SVivek Goyal inode_lock(temp->d_inode); 664b504c654SChengguang Xu if (S_ISREG(c->stat.mode)) 6655272eaf3SChristian Brauner err = ovl_set_size(ofs, temp, &c->stat); 6660c288874SVivek Goyal if (!err) 6675272eaf3SChristian Brauner err = ovl_set_attr(ofs, temp, &c->stat); 668bd64e575SVivek Goyal inode_unlock(temp->d_inode); 669bd64e575SVivek Goyal 670bd64e575SVivek Goyal return err; 67102209d10SAmir Goldstein } 67202209d10SAmir Goldstein 6736b52243fSMiklos Szeredi struct ovl_cu_creds { 6746b52243fSMiklos Szeredi const struct cred *old; 6756b52243fSMiklos Szeredi struct cred *new; 676b10cdcdcSAmir Goldstein }; 677b10cdcdcSAmir Goldstein 6786b52243fSMiklos Szeredi static int ovl_prep_cu_creds(struct dentry *dentry, struct ovl_cu_creds *cc) 679b10cdcdcSAmir Goldstein { 680b10cdcdcSAmir Goldstein int err; 681b10cdcdcSAmir Goldstein 6826b52243fSMiklos Szeredi cc->old = cc->new = NULL; 6836b52243fSMiklos Szeredi err = security_inode_copy_up(dentry, &cc->new); 6846b52243fSMiklos Szeredi if (err < 0) 685b10cdcdcSAmir Goldstein return err; 6866b52243fSMiklos Szeredi 6876b52243fSMiklos Szeredi if (cc->new) 6886b52243fSMiklos Szeredi cc->old = override_creds(cc->new); 6896b52243fSMiklos Szeredi 6906b52243fSMiklos Szeredi return 0; 6916b52243fSMiklos Szeredi } 6926b52243fSMiklos Szeredi 6936b52243fSMiklos Szeredi static void ovl_revert_cu_creds(struct ovl_cu_creds *cc) 6946b52243fSMiklos Szeredi { 6956b52243fSMiklos Szeredi if (cc->new) { 6966b52243fSMiklos Szeredi revert_creds(cc->old); 6976b52243fSMiklos Szeredi put_cred(cc->new); 6986b52243fSMiklos Szeredi } 699b10cdcdcSAmir Goldstein } 700b10cdcdcSAmir Goldstein 701b10cdcdcSAmir Goldstein /* 702b10cdcdcSAmir Goldstein * Copyup using workdir to prepare temp file. Used when copying up directories, 703b10cdcdcSAmir Goldstein * special files or when upper fs doesn't support O_TMPFILE. 704b10cdcdcSAmir Goldstein */ 705b10cdcdcSAmir Goldstein static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c) 706b10cdcdcSAmir Goldstein { 707576bb263SChristian Brauner struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 708b79e05aaSAmir Goldstein struct inode *inode; 7096b52243fSMiklos Szeredi struct inode *udir = d_inode(c->destdir), *wdir = d_inode(c->workdir); 7102b1a7746SMiklos Szeredi struct path path = { .mnt = ovl_upper_mnt(ofs) }; 7116b52243fSMiklos Szeredi struct dentry *temp, *upper; 7126b52243fSMiklos Szeredi struct ovl_cu_creds cc; 7137d90b853SMiklos Szeredi int err; 7146b52243fSMiklos Szeredi struct ovl_cattr cattr = { 7156b52243fSMiklos Szeredi /* Can't properly set mode on creation because of the umask */ 7166b52243fSMiklos Szeredi .mode = c->stat.mode & S_IFMT, 7176b52243fSMiklos Szeredi .rdev = c->stat.rdev, 7186b52243fSMiklos Szeredi .link = c->link 7196b52243fSMiklos Szeredi }; 7207d90b853SMiklos Szeredi 721773cb4c5SAmir Goldstein /* workdir and destdir could be the same when copying up to indexdir */ 722773cb4c5SAmir Goldstein err = -EIO; 723773cb4c5SAmir Goldstein if (lock_rename(c->workdir, c->destdir) != NULL) 724773cb4c5SAmir Goldstein goto unlock; 725b10cdcdcSAmir Goldstein 7266b52243fSMiklos Szeredi err = ovl_prep_cu_creds(c->dentry, &cc); 7276b52243fSMiklos Szeredi if (err) 7286b52243fSMiklos Szeredi goto unlock; 7296b52243fSMiklos Szeredi 730576bb263SChristian Brauner temp = ovl_create_temp(ofs, c->workdir, &cattr); 7316b52243fSMiklos Szeredi ovl_revert_cu_creds(&cc); 7326b52243fSMiklos Szeredi 733b10cdcdcSAmir Goldstein err = PTR_ERR(temp); 734b10cdcdcSAmir Goldstein if (IS_ERR(temp)) 735b10cdcdcSAmir Goldstein goto unlock; 736b10cdcdcSAmir Goldstein 7372b1a7746SMiklos Szeredi /* 7382b1a7746SMiklos Szeredi * Copy up data first and then xattrs. Writing data after 7392b1a7746SMiklos Szeredi * xattrs will remove security.capability xattr automatically. 7402b1a7746SMiklos Szeredi */ 7412b1a7746SMiklos Szeredi path.dentry = temp; 7422b1a7746SMiklos Szeredi err = ovl_copy_up_data(c, &path); 7432b1a7746SMiklos Szeredi if (err) 7442b1a7746SMiklos Szeredi goto cleanup; 7452b1a7746SMiklos Szeredi 7462b1a7746SMiklos Szeredi err = ovl_copy_up_metadata(c, temp); 747b10cdcdcSAmir Goldstein if (err) 748b10cdcdcSAmir Goldstein goto cleanup; 749b10cdcdcSAmir Goldstein 750b10cdcdcSAmir Goldstein if (S_ISDIR(c->stat.mode) && c->indexed) { 751b10cdcdcSAmir Goldstein err = ovl_create_index(c->dentry, c->lowerpath.dentry, temp); 752b10cdcdcSAmir Goldstein if (err) 753b10cdcdcSAmir Goldstein goto cleanup; 754b10cdcdcSAmir Goldstein } 755b10cdcdcSAmir Goldstein 75622f289ceSChristian Brauner upper = ovl_lookup_upper(ofs, c->destname.name, c->destdir, 75722f289ceSChristian Brauner c->destname.len); 7586b52243fSMiklos Szeredi err = PTR_ERR(upper); 7596b52243fSMiklos Szeredi if (IS_ERR(upper)) 7606b52243fSMiklos Szeredi goto cleanup; 7616b52243fSMiklos Szeredi 762576bb263SChristian Brauner err = ovl_do_rename(ofs, wdir, temp, udir, upper, 0); 7636b52243fSMiklos Szeredi dput(upper); 764b10cdcdcSAmir Goldstein if (err) 765b10cdcdcSAmir Goldstein goto cleanup; 766b10cdcdcSAmir Goldstein 767b10cdcdcSAmir Goldstein inode = d_inode(c->dentry); 7680c71faf5SAlexander Larsson if (c->metacopy_digest) 7690c71faf5SAlexander Larsson ovl_set_flag(OVL_HAS_DIGEST, inode); 7700c71faf5SAlexander Larsson else 7710c71faf5SAlexander Larsson ovl_clear_flag(OVL_HAS_DIGEST, inode); 7720c71faf5SAlexander Larsson ovl_clear_flag(OVL_VERIFIED_DIGEST, inode); 7730c71faf5SAlexander Larsson 7740c71faf5SAlexander Larsson if (!c->metacopy) 7750c71faf5SAlexander Larsson ovl_set_upperdata(inode); 7766b52243fSMiklos Szeredi ovl_inode_update(inode, temp); 777b10cdcdcSAmir Goldstein if (S_ISDIR(inode->i_mode)) 778b10cdcdcSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, inode); 779b10cdcdcSAmir Goldstein unlock: 780b10cdcdcSAmir Goldstein unlock_rename(c->workdir, c->destdir); 781b10cdcdcSAmir Goldstein 782b10cdcdcSAmir Goldstein return err; 783b10cdcdcSAmir Goldstein 784b10cdcdcSAmir Goldstein cleanup: 785576bb263SChristian Brauner ovl_cleanup(ofs, wdir, temp); 7866b52243fSMiklos Szeredi dput(temp); 787b10cdcdcSAmir Goldstein goto unlock; 788b10cdcdcSAmir Goldstein } 789b10cdcdcSAmir Goldstein 790b10cdcdcSAmir Goldstein /* Copyup using O_TMPFILE which does not require cross dir locking */ 791b10cdcdcSAmir Goldstein static int ovl_copy_up_tmpfile(struct ovl_copy_up_ctx *c) 792b10cdcdcSAmir Goldstein { 793576bb263SChristian Brauner struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 7946b52243fSMiklos Szeredi struct inode *udir = d_inode(c->destdir); 7956b52243fSMiklos Szeredi struct dentry *temp, *upper; 7962b1a7746SMiklos Szeredi struct file *tmpfile; 7976b52243fSMiklos Szeredi struct ovl_cu_creds cc; 798b10cdcdcSAmir Goldstein int err; 799b10cdcdcSAmir Goldstein 8006b52243fSMiklos Szeredi err = ovl_prep_cu_creds(c->dentry, &cc); 8016b52243fSMiklos Szeredi if (err) 8026b52243fSMiklos Szeredi return err; 8036b52243fSMiklos Szeredi 8042b1a7746SMiklos Szeredi tmpfile = ovl_do_tmpfile(ofs, c->workdir, c->stat.mode); 8056b52243fSMiklos Szeredi ovl_revert_cu_creds(&cc); 8066b52243fSMiklos Szeredi 8072b1a7746SMiklos Szeredi if (IS_ERR(tmpfile)) 8082b1a7746SMiklos Szeredi return PTR_ERR(tmpfile); 809e9be9d5eSMiklos Szeredi 8102b1a7746SMiklos Szeredi temp = tmpfile->f_path.dentry; 8112b1a7746SMiklos Szeredi if (!c->metacopy && c->stat.size) { 8122b1a7746SMiklos Szeredi err = ovl_copy_up_file(ofs, c->dentry, tmpfile, c->stat.size); 813e9be9d5eSMiklos Szeredi if (err) 814baabaa50SMiklos Szeredi goto out_fput; 8152b1a7746SMiklos Szeredi } 8162b1a7746SMiklos Szeredi 8172b1a7746SMiklos Szeredi err = ovl_copy_up_metadata(c, temp); 8182b1a7746SMiklos Szeredi if (err) 8192b1a7746SMiklos Szeredi goto out_fput; 8203a1e819bSAmir Goldstein 8216b52243fSMiklos Szeredi inode_lock_nested(udir, I_MUTEX_PARENT); 8226b52243fSMiklos Szeredi 82322f289ceSChristian Brauner upper = ovl_lookup_upper(ofs, c->destname.name, c->destdir, 82422f289ceSChristian Brauner c->destname.len); 8256b52243fSMiklos Szeredi err = PTR_ERR(upper); 8266b52243fSMiklos Szeredi if (!IS_ERR(upper)) { 827576bb263SChristian Brauner err = ovl_do_link(ofs, temp, udir, upper); 8286b52243fSMiklos Szeredi dput(upper); 8296b52243fSMiklos Szeredi } 8306b52243fSMiklos Szeredi inode_unlock(udir); 8316b52243fSMiklos Szeredi 832e9be9d5eSMiklos Szeredi if (err) 8332b1a7746SMiklos Szeredi goto out_fput; 834e9be9d5eSMiklos Szeredi 8350c71faf5SAlexander Larsson if (c->metacopy_digest) 8360c71faf5SAlexander Larsson ovl_set_flag(OVL_HAS_DIGEST, d_inode(c->dentry)); 8370c71faf5SAlexander Larsson else 8380c71faf5SAlexander Larsson ovl_clear_flag(OVL_HAS_DIGEST, d_inode(c->dentry)); 8390c71faf5SAlexander Larsson ovl_clear_flag(OVL_VERIFIED_DIGEST, d_inode(c->dentry)); 8400c71faf5SAlexander Larsson 8410c288874SVivek Goyal if (!c->metacopy) 8420c288874SVivek Goyal ovl_set_upperdata(d_inode(c->dentry)); 8432b1a7746SMiklos Szeredi ovl_inode_update(d_inode(c->dentry), dget(temp)); 844b79e05aaSAmir Goldstein 8452b1a7746SMiklos Szeredi out_fput: 8462b1a7746SMiklos Szeredi fput(tmpfile); 847e9be9d5eSMiklos Szeredi return err; 848e9be9d5eSMiklos Szeredi } 849e9be9d5eSMiklos Szeredi 850e9be9d5eSMiklos Szeredi /* 851e9be9d5eSMiklos Szeredi * Copy up a single dentry 852e9be9d5eSMiklos Szeredi * 853a6c60655SMiklos Szeredi * All renames start with copy up of source if necessary. The actual 854a6c60655SMiklos Szeredi * rename will only proceed once the copy up was successful. Copy up uses 855a6c60655SMiklos Szeredi * upper parent i_mutex for exclusion. Since rename can change d_parent it 856a6c60655SMiklos Szeredi * is possible that the copy up will lock the old parent. At that point 857a6c60655SMiklos Szeredi * the file will have already been copied up anyway. 858e9be9d5eSMiklos Szeredi */ 859a6fb235aSMiklos Szeredi static int ovl_do_copy_up(struct ovl_copy_up_ctx *c) 860e9be9d5eSMiklos Szeredi { 861e9be9d5eSMiklos Szeredi int err; 8621cdb0cb6SPavel Tikhomirov struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 863016b720fSAmir Goldstein bool to_index = false; 86459be0971SAmir Goldstein 865016b720fSAmir Goldstein /* 866016b720fSAmir Goldstein * Indexed non-dir is copied up directly to the index entry and then 867016b720fSAmir Goldstein * hardlinked to upper dir. Indexed dir is copied up to indexdir, 868016b720fSAmir Goldstein * then index entry is created and then copied up dir installed. 869016b720fSAmir Goldstein * Copying dir up to indexdir instead of workdir simplifies locking. 870016b720fSAmir Goldstein */ 871016b720fSAmir Goldstein if (ovl_need_index(c->dentry)) { 872016b720fSAmir Goldstein c->indexed = true; 873016b720fSAmir Goldstein if (S_ISDIR(c->stat.mode)) 874016b720fSAmir Goldstein c->workdir = ovl_indexdir(c->dentry->d_sb); 875016b720fSAmir Goldstein else 876016b720fSAmir Goldstein to_index = true; 877016b720fSAmir Goldstein } 878016b720fSAmir Goldstein 879016b720fSAmir Goldstein if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1 || to_index) 88059be0971SAmir Goldstein c->origin = true; 88159be0971SAmir Goldstein 882016b720fSAmir Goldstein if (to_index) { 88359be0971SAmir Goldstein c->destdir = ovl_indexdir(c->dentry->d_sb); 8841cdb0cb6SPavel Tikhomirov err = ovl_get_index_name(ofs, c->lowerpath.dentry, &c->destname); 885f3a15685SAmir Goldstein if (err) 886f3a15685SAmir Goldstein return err; 887aa3ff3c1SAmir Goldstein } else if (WARN_ON(!c->parent)) { 888aa3ff3c1SAmir Goldstein /* Disconnected dentry must be copied up to index dir */ 889aa3ff3c1SAmir Goldstein return -EIO; 89059be0971SAmir Goldstein } else { 89159be0971SAmir Goldstein /* 89259be0971SAmir Goldstein * Mark parent "impure" because it may now contain non-pure 89359be0971SAmir Goldstein * upper 89459be0971SAmir Goldstein */ 89559be0971SAmir Goldstein err = ovl_set_impure(c->parent, c->destdir); 89659be0971SAmir Goldstein if (err) 89759be0971SAmir Goldstein return err; 89859be0971SAmir Goldstein } 899f3a15685SAmir Goldstein 90001ad3eb8SAmir Goldstein /* Should we copyup with O_TMPFILE or with workdir? */ 901b10cdcdcSAmir Goldstein if (S_ISREG(c->stat.mode) && ofs->tmpfile) 902b10cdcdcSAmir Goldstein err = ovl_copy_up_tmpfile(c); 903b10cdcdcSAmir Goldstein else 904b10cdcdcSAmir Goldstein err = ovl_copy_up_workdir(c); 905aa3ff3c1SAmir Goldstein if (err) 906aa3ff3c1SAmir Goldstein goto out; 907aa3ff3c1SAmir Goldstein 908aa3ff3c1SAmir Goldstein if (c->indexed) 90959be0971SAmir Goldstein ovl_set_flag(OVL_INDEX, d_inode(c->dentry)); 910016b720fSAmir Goldstein 911016b720fSAmir Goldstein if (to_index) { 912aa3ff3c1SAmir Goldstein /* Initialize nlink for copy up of disconnected dentry */ 913aa3ff3c1SAmir Goldstein err = ovl_set_nlink_upper(c->dentry); 914aa3ff3c1SAmir Goldstein } else { 91559be0971SAmir Goldstein struct inode *udir = d_inode(c->destdir); 91659be0971SAmir Goldstein 91759be0971SAmir Goldstein /* Restore timestamps on parent (best effort) */ 91859be0971SAmir Goldstein inode_lock(udir); 9195272eaf3SChristian Brauner ovl_set_timestamps(ofs, c->destdir, &c->pstat); 92059be0971SAmir Goldstein inode_unlock(udir); 92159be0971SAmir Goldstein 92259be0971SAmir Goldstein ovl_dentry_set_upper_alias(c->dentry); 923b07d5cc9SAmir Goldstein ovl_dentry_update_reval(c->dentry, ovl_dentry_upper(c->dentry)); 924fd210b7dSMiklos Szeredi } 925a6fb235aSMiklos Szeredi 926aa3ff3c1SAmir Goldstein out: 927aa3ff3c1SAmir Goldstein if (to_index) 928aa3ff3c1SAmir Goldstein kfree(c->destname.name); 929a6fb235aSMiklos Szeredi return err; 930a6fb235aSMiklos Szeredi } 931a6fb235aSMiklos Szeredi 93244d5bf10SVivek Goyal static bool ovl_need_meta_copy_up(struct dentry *dentry, umode_t mode, 93344d5bf10SVivek Goyal int flags) 93444d5bf10SVivek Goyal { 93544d5bf10SVivek Goyal struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 93644d5bf10SVivek Goyal 93744d5bf10SVivek Goyal if (!ofs->config.metacopy) 93844d5bf10SVivek Goyal return false; 93944d5bf10SVivek Goyal 94044d5bf10SVivek Goyal if (!S_ISREG(mode)) 94144d5bf10SVivek Goyal return false; 94244d5bf10SVivek Goyal 94344d5bf10SVivek Goyal if (flags && ((OPEN_FMODE(flags) & FMODE_WRITE) || (flags & O_TRUNC))) 94444d5bf10SVivek Goyal return false; 94544d5bf10SVivek Goyal 9460c71faf5SAlexander Larsson /* Fall back to full copy if no fsverity on source data and we require verity */ 9470c71faf5SAlexander Larsson if (ofs->config.verity_mode == OVL_VERITY_REQUIRE) { 9480c71faf5SAlexander Larsson struct path lowerdata; 9490c71faf5SAlexander Larsson 9500c71faf5SAlexander Larsson ovl_path_lowerdata(dentry, &lowerdata); 9510c71faf5SAlexander Larsson 9520c71faf5SAlexander Larsson if (WARN_ON_ONCE(lowerdata.dentry == NULL) || 9530c71faf5SAlexander Larsson ovl_ensure_verity_loaded(&lowerdata) || 9540c71faf5SAlexander Larsson !fsverity_active(d_inode(lowerdata.dentry))) { 9550c71faf5SAlexander Larsson return false; 9560c71faf5SAlexander Larsson } 9570c71faf5SAlexander Larsson } 9580c71faf5SAlexander Larsson 95944d5bf10SVivek Goyal return true; 96044d5bf10SVivek Goyal } 96144d5bf10SVivek Goyal 9622d343087SAl Viro static ssize_t ovl_getxattr_value(const struct path *path, char *name, char **value) 963fee0f298SMiklos Szeredi { 964fee0f298SMiklos Szeredi ssize_t res; 965de7a52c9SMiklos Szeredi char *buf; 966fee0f298SMiklos Szeredi 967dad7017aSChristian Brauner res = ovl_do_getxattr(path, name, NULL, 0); 968fee0f298SMiklos Szeredi if (res == -ENODATA || res == -EOPNOTSUPP) 969de7a52c9SMiklos Szeredi res = 0; 970fee0f298SMiklos Szeredi 971de7a52c9SMiklos Szeredi if (res > 0) { 972de7a52c9SMiklos Szeredi buf = kzalloc(res, GFP_KERNEL); 973fee0f298SMiklos Szeredi if (!buf) 974fee0f298SMiklos Szeredi return -ENOMEM; 975fee0f298SMiklos Szeredi 976dad7017aSChristian Brauner res = ovl_do_getxattr(path, name, buf, res); 977fee0f298SMiklos Szeredi if (res < 0) 978fee0f298SMiklos Szeredi kfree(buf); 979de7a52c9SMiklos Szeredi else 980de7a52c9SMiklos Szeredi *value = buf; 981de7a52c9SMiklos Szeredi } 982fee0f298SMiklos Szeredi return res; 983fee0f298SMiklos Szeredi } 984fee0f298SMiklos Szeredi 9850c288874SVivek Goyal /* Copy up data of an inode which was copied up metadata only in the past. */ 9860c288874SVivek Goyal static int ovl_copy_up_meta_inode_data(struct ovl_copy_up_ctx *c) 9870c288874SVivek Goyal { 988c86243b0SVivek Goyal struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); 9892b1a7746SMiklos Szeredi struct path upperpath; 9900c288874SVivek Goyal int err; 991993a0b2aSVivek Goyal char *capability = NULL; 9923f649ab7SKees Cook ssize_t cap_size; 9930c288874SVivek Goyal 9940c288874SVivek Goyal ovl_path_upper(c->dentry, &upperpath); 9950c288874SVivek Goyal if (WARN_ON(upperpath.dentry == NULL)) 9960c288874SVivek Goyal return -EIO; 9970c288874SVivek Goyal 998993a0b2aSVivek Goyal if (c->stat.size) { 999dad7017aSChristian Brauner err = cap_size = ovl_getxattr_value(&upperpath, XATTR_NAME_CAPS, 1000dad7017aSChristian Brauner &capability); 1001de7a52c9SMiklos Szeredi if (cap_size < 0) 1002993a0b2aSVivek Goyal goto out; 1003993a0b2aSVivek Goyal } 1004993a0b2aSVivek Goyal 10052b1a7746SMiklos Szeredi err = ovl_copy_up_data(c, &upperpath); 10060c288874SVivek Goyal if (err) 1007993a0b2aSVivek Goyal goto out_free; 1008993a0b2aSVivek Goyal 1009993a0b2aSVivek Goyal /* 1010993a0b2aSVivek Goyal * Writing to upper file will clear security.capability xattr. We 1011993a0b2aSVivek Goyal * don't want that to happen for normal copy-up operation. 1012993a0b2aSVivek Goyal */ 1013993a0b2aSVivek Goyal if (capability) { 1014c914c0e2SAmir Goldstein err = ovl_do_setxattr(ofs, upperpath.dentry, XATTR_NAME_CAPS, 1015c914c0e2SAmir Goldstein capability, cap_size, 0); 1016993a0b2aSVivek Goyal if (err) 1017993a0b2aSVivek Goyal goto out_free; 1018993a0b2aSVivek Goyal } 1019993a0b2aSVivek Goyal 10200c288874SVivek Goyal 1021c914c0e2SAmir Goldstein err = ovl_removexattr(ofs, upperpath.dentry, OVL_XATTR_METACOPY); 10220c288874SVivek Goyal if (err) 1023993a0b2aSVivek Goyal goto out_free; 10240c288874SVivek Goyal 10250c71faf5SAlexander Larsson ovl_clear_flag(OVL_HAS_DIGEST, d_inode(c->dentry)); 10260c71faf5SAlexander Larsson ovl_clear_flag(OVL_VERIFIED_DIGEST, d_inode(c->dentry)); 10270c288874SVivek Goyal ovl_set_upperdata(d_inode(c->dentry)); 1028993a0b2aSVivek Goyal out_free: 1029993a0b2aSVivek Goyal kfree(capability); 1030993a0b2aSVivek Goyal out: 10310c288874SVivek Goyal return err; 10320c288874SVivek Goyal } 10330c288874SVivek Goyal 1034a6fb235aSMiklos Szeredi static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 1035a6fb235aSMiklos Szeredi int flags) 1036a6fb235aSMiklos Szeredi { 1037a6fb235aSMiklos Szeredi int err; 1038a6fb235aSMiklos Szeredi DEFINE_DELAYED_CALL(done); 1039a6fb235aSMiklos Szeredi struct path parentpath; 1040a6fb235aSMiklos Szeredi struct ovl_copy_up_ctx ctx = { 1041a6fb235aSMiklos Szeredi .parent = parent, 1042a6fb235aSMiklos Szeredi .dentry = dentry, 1043a6fb235aSMiklos Szeredi .workdir = ovl_workdir(dentry), 1044a6fb235aSMiklos Szeredi }; 1045a6fb235aSMiklos Szeredi 1046a6fb235aSMiklos Szeredi if (WARN_ON(!ctx.workdir)) 1047a6fb235aSMiklos Szeredi return -EROFS; 1048a6fb235aSMiklos Szeredi 1049a6fb235aSMiklos Szeredi ovl_path_lower(dentry, &ctx.lowerpath); 1050a6fb235aSMiklos Szeredi err = vfs_getattr(&ctx.lowerpath, &ctx.stat, 1051a6fb235aSMiklos Szeredi STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT); 1052a6fb235aSMiklos Szeredi if (err) 1053a6fb235aSMiklos Szeredi return err; 1054a6fb235aSMiklos Szeredi 10554f11ada1SMiklos Szeredi if (!kuid_has_mapping(current_user_ns(), ctx.stat.uid) || 10564f11ada1SMiklos Szeredi !kgid_has_mapping(current_user_ns(), ctx.stat.gid)) 10574f11ada1SMiklos Szeredi return -EOVERFLOW; 10584f11ada1SMiklos Szeredi 105944d5bf10SVivek Goyal ctx.metacopy = ovl_need_meta_copy_up(dentry, ctx.stat.mode, flags); 106044d5bf10SVivek Goyal 1061aa3ff3c1SAmir Goldstein if (parent) { 1062a6fb235aSMiklos Szeredi ovl_path_upper(parent, &parentpath); 106359be0971SAmir Goldstein ctx.destdir = parentpath.dentry; 106459be0971SAmir Goldstein ctx.destname = dentry->d_name; 1065a6fb235aSMiklos Szeredi 1066a6fb235aSMiklos Szeredi err = vfs_getattr(&parentpath, &ctx.pstat, 1067aa3ff3c1SAmir Goldstein STATX_ATIME | STATX_MTIME, 1068aa3ff3c1SAmir Goldstein AT_STATX_SYNC_AS_STAT); 1069a6fb235aSMiklos Szeredi if (err) 1070a6fb235aSMiklos Szeredi return err; 1071aa3ff3c1SAmir Goldstein } 1072a6fb235aSMiklos Szeredi 1073a6fb235aSMiklos Szeredi /* maybe truncate regular file. this has no effect on dirs */ 1074a6fb235aSMiklos Szeredi if (flags & O_TRUNC) 1075a6fb235aSMiklos Szeredi ctx.stat.size = 0; 1076a6fb235aSMiklos Szeredi 1077a6fb235aSMiklos Szeredi if (S_ISLNK(ctx.stat.mode)) { 1078a6fb235aSMiklos Szeredi ctx.link = vfs_get_link(ctx.lowerpath.dentry, &done); 1079a6fb235aSMiklos Szeredi if (IS_ERR(ctx.link)) 1080a6fb235aSMiklos Szeredi return PTR_ERR(ctx.link); 1081a6fb235aSMiklos Szeredi } 1082a6fb235aSMiklos Szeredi 10830c288874SVivek Goyal err = ovl_copy_up_start(dentry, flags); 1084fd210b7dSMiklos Szeredi /* err < 0: interrupted, err > 0: raced with another copy-up */ 1085fd210b7dSMiklos Szeredi if (unlikely(err)) { 1086fd210b7dSMiklos Szeredi if (err > 0) 1087fd210b7dSMiklos Szeredi err = 0; 1088fd210b7dSMiklos Szeredi } else { 108959be0971SAmir Goldstein if (!ovl_dentry_upper(dentry)) 1090a6fb235aSMiklos Szeredi err = ovl_do_copy_up(&ctx); 1091aa3ff3c1SAmir Goldstein if (!err && parent && !ovl_dentry_has_upper_alias(dentry)) 1092f4439de1SAmir Goldstein err = ovl_link_up(&ctx); 10930c288874SVivek Goyal if (!err && ovl_dentry_needs_data_copy_up_locked(dentry, flags)) 10940c288874SVivek Goyal err = ovl_copy_up_meta_inode_data(&ctx); 1095fd210b7dSMiklos Szeredi ovl_copy_up_end(dentry); 1096fd210b7dSMiklos Szeredi } 10977764235bSMiklos Szeredi do_delayed_call(&done); 1098e9be9d5eSMiklos Szeredi 1099e9be9d5eSMiklos Szeredi return err; 1100e9be9d5eSMiklos Szeredi } 1101e9be9d5eSMiklos Szeredi 11025ac8e802Syoungjun static int ovl_copy_up_flags(struct dentry *dentry, int flags) 1103e9be9d5eSMiklos Szeredi { 11048eac98b8SVivek Goyal int err = 0; 11057b279bbfSDan Carpenter const struct cred *old_cred; 1106aa3ff3c1SAmir Goldstein bool disconnected = (dentry->d_flags & DCACHE_DISCONNECTED); 1107aa3ff3c1SAmir Goldstein 1108aa3ff3c1SAmir Goldstein /* 1109aa3ff3c1SAmir Goldstein * With NFS export, copy up can get called for a disconnected non-dir. 1110aa3ff3c1SAmir Goldstein * In this case, we will copy up lower inode to index dir without 1111aa3ff3c1SAmir Goldstein * linking it to upper dir. 1112aa3ff3c1SAmir Goldstein */ 1113aa3ff3c1SAmir Goldstein if (WARN_ON(disconnected && d_is_dir(dentry))) 1114aa3ff3c1SAmir Goldstein return -EIO; 1115e9be9d5eSMiklos Szeredi 111642dd69aeSAmir Goldstein /* 111742dd69aeSAmir Goldstein * We may not need lowerdata if we are only doing metacopy up, but it is 111842dd69aeSAmir Goldstein * not very important to optimize this case, so do lazy lowerdata lookup 111942dd69aeSAmir Goldstein * before any copy up, so we can do it before taking ovl_inode_lock(). 112042dd69aeSAmir Goldstein */ 1121184996e9SAlexander Larsson err = ovl_verify_lowerdata(dentry); 112242dd69aeSAmir Goldstein if (err) 112342dd69aeSAmir Goldstein return err; 112442dd69aeSAmir Goldstein 11257b279bbfSDan Carpenter old_cred = ovl_override_creds(dentry->d_sb); 1126e9be9d5eSMiklos Szeredi while (!err) { 1127e9be9d5eSMiklos Szeredi struct dentry *next; 1128aa3ff3c1SAmir Goldstein struct dentry *parent = NULL; 1129e9be9d5eSMiklos Szeredi 11300c288874SVivek Goyal if (ovl_already_copied_up(dentry, flags)) 1131e9be9d5eSMiklos Szeredi break; 1132e9be9d5eSMiklos Szeredi 1133e9be9d5eSMiklos Szeredi next = dget(dentry); 1134e9be9d5eSMiklos Szeredi /* find the topmost dentry not yet copied up */ 1135aa3ff3c1SAmir Goldstein for (; !disconnected;) { 1136e9be9d5eSMiklos Szeredi parent = dget_parent(next); 1137e9be9d5eSMiklos Szeredi 113859be0971SAmir Goldstein if (ovl_dentry_upper(parent)) 1139e9be9d5eSMiklos Szeredi break; 1140e9be9d5eSMiklos Szeredi 1141e9be9d5eSMiklos Szeredi dput(next); 1142e9be9d5eSMiklos Szeredi next = parent; 1143e9be9d5eSMiklos Szeredi } 1144e9be9d5eSMiklos Szeredi 1145a6fb235aSMiklos Szeredi err = ovl_copy_up_one(parent, next, flags); 1146e9be9d5eSMiklos Szeredi 1147e9be9d5eSMiklos Szeredi dput(parent); 1148e9be9d5eSMiklos Szeredi dput(next); 1149e9be9d5eSMiklos Szeredi } 11508eac98b8SVivek Goyal revert_creds(old_cred); 1151e9be9d5eSMiklos Szeredi 1152e9be9d5eSMiklos Szeredi return err; 1153e9be9d5eSMiklos Szeredi } 11549aba6521SAmir Goldstein 1155d6eac039SVivek Goyal static bool ovl_open_need_copy_up(struct dentry *dentry, int flags) 1156d6eac039SVivek Goyal { 1157d6eac039SVivek Goyal /* Copy up of disconnected dentry does not set upper alias */ 11580c288874SVivek Goyal if (ovl_already_copied_up(dentry, flags)) 1159d6eac039SVivek Goyal return false; 1160d6eac039SVivek Goyal 1161d6eac039SVivek Goyal if (special_file(d_inode(dentry)->i_mode)) 1162d6eac039SVivek Goyal return false; 1163d6eac039SVivek Goyal 11640c288874SVivek Goyal if (!ovl_open_flags_need_copy_up(flags)) 1165d6eac039SVivek Goyal return false; 1166d6eac039SVivek Goyal 1167d6eac039SVivek Goyal return true; 1168d6eac039SVivek Goyal } 1169d6eac039SVivek Goyal 11703428030dSAmir Goldstein int ovl_maybe_copy_up(struct dentry *dentry, int flags) 1171d6eac039SVivek Goyal { 1172d6eac039SVivek Goyal int err = 0; 1173d6eac039SVivek Goyal 11743428030dSAmir Goldstein if (ovl_open_need_copy_up(dentry, flags)) { 1175d6eac039SVivek Goyal err = ovl_want_write(dentry); 1176d6eac039SVivek Goyal if (!err) { 11773428030dSAmir Goldstein err = ovl_copy_up_flags(dentry, flags); 1178d6eac039SVivek Goyal ovl_drop_write(dentry); 1179d6eac039SVivek Goyal } 1180d6eac039SVivek Goyal } 1181d6eac039SVivek Goyal 1182d6eac039SVivek Goyal return err; 1183d6eac039SVivek Goyal } 1184d6eac039SVivek Goyal 1185d1e6f6a9SVivek Goyal int ovl_copy_up_with_data(struct dentry *dentry) 1186d1e6f6a9SVivek Goyal { 1187d1e6f6a9SVivek Goyal return ovl_copy_up_flags(dentry, O_WRONLY); 1188d1e6f6a9SVivek Goyal } 1189d1e6f6a9SVivek Goyal 11909aba6521SAmir Goldstein int ovl_copy_up(struct dentry *dentry) 11919aba6521SAmir Goldstein { 11929aba6521SAmir Goldstein return ovl_copy_up_flags(dentry, 0); 11939aba6521SAmir Goldstein } 1194