1e9be9d5eSMiklos Szeredi /* 2e9be9d5eSMiklos Szeredi * 3e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 4e9be9d5eSMiklos Szeredi * 5e9be9d5eSMiklos Szeredi * This program is free software; you can redistribute it and/or modify it 6e9be9d5eSMiklos Szeredi * under the terms of the GNU General Public License version 2 as published by 7e9be9d5eSMiklos Szeredi * the Free Software Foundation. 8e9be9d5eSMiklos Szeredi */ 9e9be9d5eSMiklos Szeredi 10fb5bb2c3SDavid Howells #include <linux/module.h> 11e9be9d5eSMiklos Szeredi #include <linux/fs.h> 12e9be9d5eSMiklos Szeredi #include <linux/slab.h> 13e9be9d5eSMiklos Szeredi #include <linux/file.h> 14e9be9d5eSMiklos Szeredi #include <linux/splice.h> 15e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 16e9be9d5eSMiklos Szeredi #include <linux/security.h> 17e9be9d5eSMiklos Szeredi #include <linux/uaccess.h> 18174cd4b1SIngo Molnar #include <linux/sched/signal.h> 195b825c3aSIngo Molnar #include <linux/cred.h> 20e9be9d5eSMiklos Szeredi #include <linux/namei.h> 21fb5bb2c3SDavid Howells #include <linux/fdtable.h> 22fb5bb2c3SDavid Howells #include <linux/ratelimit.h> 233a1e819bSAmir Goldstein #include <linux/exportfs.h> 24e9be9d5eSMiklos Szeredi #include "overlayfs.h" 25d8514d8eSAmir Goldstein #include "ovl_entry.h" 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi #define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 28e9be9d5eSMiklos Szeredi 29fb5bb2c3SDavid Howells static bool __read_mostly ovl_check_copy_up; 30fb5bb2c3SDavid Howells module_param_named(check_copy_up, ovl_check_copy_up, bool, 31fb5bb2c3SDavid Howells S_IWUSR | S_IRUGO); 32fb5bb2c3SDavid Howells MODULE_PARM_DESC(ovl_check_copy_up, 33fb5bb2c3SDavid Howells "Warn on copy-up when causing process also has a R/O fd open"); 34fb5bb2c3SDavid Howells 35fb5bb2c3SDavid Howells static int ovl_check_fd(const void *data, struct file *f, unsigned int fd) 36fb5bb2c3SDavid Howells { 37fb5bb2c3SDavid Howells const struct dentry *dentry = data; 38fb5bb2c3SDavid Howells 3945063097SAl Viro if (file_inode(f) == d_inode(dentry)) 40fb5bb2c3SDavid Howells 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", 41fb5bb2c3SDavid Howells f, fd, current->pid, current->comm); 42fb5bb2c3SDavid Howells return 0; 43fb5bb2c3SDavid Howells } 44fb5bb2c3SDavid Howells 45fb5bb2c3SDavid Howells /* 46fb5bb2c3SDavid Howells * Check the fds open by this process and warn if something like the following 47fb5bb2c3SDavid Howells * scenario is about to occur: 48fb5bb2c3SDavid Howells * 49fb5bb2c3SDavid Howells * fd1 = open("foo", O_RDONLY); 50fb5bb2c3SDavid Howells * fd2 = open("foo", O_RDWR); 51fb5bb2c3SDavid Howells */ 52fb5bb2c3SDavid Howells static void ovl_do_check_copy_up(struct dentry *dentry) 53fb5bb2c3SDavid Howells { 54fb5bb2c3SDavid Howells if (ovl_check_copy_up) 55fb5bb2c3SDavid Howells iterate_fd(current->files, 0, ovl_check_fd, dentry); 56fb5bb2c3SDavid Howells } 57fb5bb2c3SDavid Howells 58e9be9d5eSMiklos Szeredi int ovl_copy_xattr(struct dentry *old, struct dentry *new) 59e9be9d5eSMiklos Szeredi { 60e4ad29faSVito Caputo ssize_t list_size, size, value_size = 0; 61e4ad29faSVito Caputo char *buf, *name, *value = NULL; 62e4ad29faSVito Caputo int uninitialized_var(error); 638b326c61SMiklos Szeredi size_t slen; 64e9be9d5eSMiklos Szeredi 655d6c3191SAndreas Gruenbacher if (!(old->d_inode->i_opflags & IOP_XATTR) || 665d6c3191SAndreas Gruenbacher !(new->d_inode->i_opflags & IOP_XATTR)) 67e9be9d5eSMiklos Szeredi return 0; 68e9be9d5eSMiklos Szeredi 69e9be9d5eSMiklos Szeredi list_size = vfs_listxattr(old, NULL, 0); 70e9be9d5eSMiklos Szeredi if (list_size <= 0) { 71e9be9d5eSMiklos Szeredi if (list_size == -EOPNOTSUPP) 72e9be9d5eSMiklos Szeredi return 0; 73e9be9d5eSMiklos Szeredi return list_size; 74e9be9d5eSMiklos Szeredi } 75e9be9d5eSMiklos Szeredi 76e9be9d5eSMiklos Szeredi buf = kzalloc(list_size, GFP_KERNEL); 77e9be9d5eSMiklos Szeredi if (!buf) 78e9be9d5eSMiklos Szeredi return -ENOMEM; 79e9be9d5eSMiklos Szeredi 80e9be9d5eSMiklos Szeredi list_size = vfs_listxattr(old, buf, list_size); 81e9be9d5eSMiklos Szeredi if (list_size <= 0) { 82e9be9d5eSMiklos Szeredi error = list_size; 83e4ad29faSVito Caputo goto out; 84e9be9d5eSMiklos Szeredi } 85e9be9d5eSMiklos Szeredi 868b326c61SMiklos Szeredi for (name = buf; list_size; name += slen) { 878b326c61SMiklos Szeredi slen = strnlen(name, list_size) + 1; 888b326c61SMiklos Szeredi 898b326c61SMiklos Szeredi /* underlying fs providing us with an broken xattr list? */ 908b326c61SMiklos Szeredi if (WARN_ON(slen > list_size)) { 918b326c61SMiklos Szeredi error = -EIO; 928b326c61SMiklos Szeredi break; 938b326c61SMiklos Szeredi } 948b326c61SMiklos Szeredi list_size -= slen; 958b326c61SMiklos Szeredi 960956254aSMiklos Szeredi if (ovl_is_private_xattr(name)) 970956254aSMiklos Szeredi continue; 98e4ad29faSVito Caputo retry: 99e4ad29faSVito Caputo size = vfs_getxattr(old, name, value, value_size); 100e4ad29faSVito Caputo if (size == -ERANGE) 101e4ad29faSVito Caputo size = vfs_getxattr(old, name, NULL, 0); 102e4ad29faSVito Caputo 10397daf8b9SMiklos Szeredi if (size < 0) { 104e9be9d5eSMiklos Szeredi error = size; 105e4ad29faSVito Caputo break; 106e9be9d5eSMiklos Szeredi } 107e9be9d5eSMiklos Szeredi 108e4ad29faSVito Caputo if (size > value_size) { 109e4ad29faSVito Caputo void *new; 110e4ad29faSVito Caputo 111e4ad29faSVito Caputo new = krealloc(value, size, GFP_KERNEL); 112e4ad29faSVito Caputo if (!new) { 113e4ad29faSVito Caputo error = -ENOMEM; 114e4ad29faSVito Caputo break; 115e4ad29faSVito Caputo } 116e4ad29faSVito Caputo value = new; 117e4ad29faSVito Caputo value_size = size; 118e4ad29faSVito Caputo goto retry; 119e4ad29faSVito Caputo } 120e4ad29faSVito Caputo 121121ab822SVivek Goyal error = security_inode_copy_up_xattr(name); 122121ab822SVivek Goyal if (error < 0 && error != -EOPNOTSUPP) 123121ab822SVivek Goyal break; 124121ab822SVivek Goyal if (error == 1) { 125121ab822SVivek Goyal error = 0; 126121ab822SVivek Goyal continue; /* Discard */ 127121ab822SVivek Goyal } 128e4ad29faSVito Caputo error = vfs_setxattr(new, name, value, size, 0); 129e4ad29faSVito Caputo if (error) 130e4ad29faSVito Caputo break; 131e4ad29faSVito Caputo } 132e9be9d5eSMiklos Szeredi kfree(value); 133e9be9d5eSMiklos Szeredi out: 134e9be9d5eSMiklos Szeredi kfree(buf); 135e9be9d5eSMiklos Szeredi return error; 136e9be9d5eSMiklos Szeredi } 137e9be9d5eSMiklos Szeredi 138e9be9d5eSMiklos Szeredi static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 139e9be9d5eSMiklos Szeredi { 140e9be9d5eSMiklos Szeredi struct file *old_file; 141e9be9d5eSMiklos Szeredi struct file *new_file; 142e9be9d5eSMiklos Szeredi loff_t old_pos = 0; 143e9be9d5eSMiklos Szeredi loff_t new_pos = 0; 144e9be9d5eSMiklos Szeredi int error = 0; 145e9be9d5eSMiklos Szeredi 146e9be9d5eSMiklos Szeredi if (len == 0) 147e9be9d5eSMiklos Szeredi return 0; 148e9be9d5eSMiklos Szeredi 1490480334fSDavid Howells old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY); 150e9be9d5eSMiklos Szeredi if (IS_ERR(old_file)) 151e9be9d5eSMiklos Szeredi return PTR_ERR(old_file); 152e9be9d5eSMiklos Szeredi 1530480334fSDavid Howells new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY); 154e9be9d5eSMiklos Szeredi if (IS_ERR(new_file)) { 155e9be9d5eSMiklos Szeredi error = PTR_ERR(new_file); 156e9be9d5eSMiklos Szeredi goto out_fput; 157e9be9d5eSMiklos Szeredi } 158e9be9d5eSMiklos Szeredi 1592ea98466SAmir Goldstein /* Try to use clone_file_range to clone up within the same fs */ 1602ea98466SAmir Goldstein error = vfs_clone_file_range(old_file, 0, new_file, 0, len); 1612ea98466SAmir Goldstein if (!error) 1622ea98466SAmir Goldstein goto out; 1632ea98466SAmir Goldstein /* Couldn't clone, so now we try to copy the data */ 1642ea98466SAmir Goldstein error = 0; 1652ea98466SAmir Goldstein 166e9be9d5eSMiklos Szeredi /* FIXME: copy up sparse files efficiently */ 167e9be9d5eSMiklos Szeredi while (len) { 168e9be9d5eSMiklos Szeredi size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 169e9be9d5eSMiklos Szeredi long bytes; 170e9be9d5eSMiklos Szeredi 171e9be9d5eSMiklos Szeredi if (len < this_len) 172e9be9d5eSMiklos Szeredi this_len = len; 173e9be9d5eSMiklos Szeredi 174e9be9d5eSMiklos Szeredi if (signal_pending_state(TASK_KILLABLE, current)) { 175e9be9d5eSMiklos Szeredi error = -EINTR; 176e9be9d5eSMiklos Szeredi break; 177e9be9d5eSMiklos Szeredi } 178e9be9d5eSMiklos Szeredi 179e9be9d5eSMiklos Szeredi bytes = do_splice_direct(old_file, &old_pos, 180e9be9d5eSMiklos Szeredi new_file, &new_pos, 181e9be9d5eSMiklos Szeredi this_len, SPLICE_F_MOVE); 182e9be9d5eSMiklos Szeredi if (bytes <= 0) { 183e9be9d5eSMiklos Szeredi error = bytes; 184e9be9d5eSMiklos Szeredi break; 185e9be9d5eSMiklos Szeredi } 186e9be9d5eSMiklos Szeredi WARN_ON(old_pos != new_pos); 187e9be9d5eSMiklos Szeredi 188e9be9d5eSMiklos Szeredi len -= bytes; 189e9be9d5eSMiklos Szeredi } 1902ea98466SAmir Goldstein out: 191641089c1SMiklos Szeredi if (!error) 192641089c1SMiklos Szeredi error = vfs_fsync(new_file, 0); 193e9be9d5eSMiklos Szeredi fput(new_file); 194e9be9d5eSMiklos Szeredi out_fput: 195e9be9d5eSMiklos Szeredi fput(old_file); 196e9be9d5eSMiklos Szeredi return error; 197e9be9d5eSMiklos Szeredi } 198e9be9d5eSMiklos Szeredi 199e9be9d5eSMiklos Szeredi static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 200e9be9d5eSMiklos Szeredi { 201e9be9d5eSMiklos Szeredi struct iattr attr = { 202e9be9d5eSMiklos Szeredi .ia_valid = 203e9be9d5eSMiklos Szeredi ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 204e9be9d5eSMiklos Szeredi .ia_atime = stat->atime, 205e9be9d5eSMiklos Szeredi .ia_mtime = stat->mtime, 206e9be9d5eSMiklos Szeredi }; 207e9be9d5eSMiklos Szeredi 208e9be9d5eSMiklos Szeredi return notify_change(upperdentry, &attr, NULL); 209e9be9d5eSMiklos Szeredi } 210e9be9d5eSMiklos Szeredi 211e9be9d5eSMiklos Szeredi int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat) 212e9be9d5eSMiklos Szeredi { 213e9be9d5eSMiklos Szeredi int err = 0; 214e9be9d5eSMiklos Szeredi 215e9be9d5eSMiklos Szeredi if (!S_ISLNK(stat->mode)) { 216e9be9d5eSMiklos Szeredi struct iattr attr = { 217e9be9d5eSMiklos Szeredi .ia_valid = ATTR_MODE, 218e9be9d5eSMiklos Szeredi .ia_mode = stat->mode, 219e9be9d5eSMiklos Szeredi }; 220e9be9d5eSMiklos Szeredi err = notify_change(upperdentry, &attr, NULL); 221e9be9d5eSMiklos Szeredi } 222e9be9d5eSMiklos Szeredi if (!err) { 223e9be9d5eSMiklos Szeredi struct iattr attr = { 224e9be9d5eSMiklos Szeredi .ia_valid = ATTR_UID | ATTR_GID, 225e9be9d5eSMiklos Szeredi .ia_uid = stat->uid, 226e9be9d5eSMiklos Szeredi .ia_gid = stat->gid, 227e9be9d5eSMiklos Szeredi }; 228e9be9d5eSMiklos Szeredi err = notify_change(upperdentry, &attr, NULL); 229e9be9d5eSMiklos Szeredi } 230e9be9d5eSMiklos Szeredi if (!err) 231e9be9d5eSMiklos Szeredi ovl_set_timestamps(upperdentry, stat); 232e9be9d5eSMiklos Szeredi 233e9be9d5eSMiklos Szeredi return err; 234e9be9d5eSMiklos Szeredi } 235e9be9d5eSMiklos Szeredi 23654fb347eSAmir Goldstein struct ovl_fh *ovl_encode_fh(struct dentry *lower, bool is_upper) 2373a1e819bSAmir Goldstein { 2383a1e819bSAmir Goldstein struct ovl_fh *fh; 2393a1e819bSAmir Goldstein int fh_type, fh_len, dwords; 2403a1e819bSAmir Goldstein void *buf; 2413a1e819bSAmir Goldstein int buflen = MAX_HANDLE_SZ; 24202bcd157SAmir Goldstein uuid_t *uuid = &lower->d_sb->s_uuid; 2433a1e819bSAmir Goldstein 2443a1e819bSAmir Goldstein buf = kmalloc(buflen, GFP_TEMPORARY); 2453a1e819bSAmir Goldstein if (!buf) 2463a1e819bSAmir Goldstein return ERR_PTR(-ENOMEM); 2473a1e819bSAmir Goldstein 2483a1e819bSAmir Goldstein /* 2493a1e819bSAmir Goldstein * We encode a non-connectable file handle for non-dir, because we 2503a1e819bSAmir Goldstein * only need to find the lower inode number and we don't want to pay 2513a1e819bSAmir Goldstein * the price or reconnecting the dentry. 2523a1e819bSAmir Goldstein */ 2533a1e819bSAmir Goldstein dwords = buflen >> 2; 2543a1e819bSAmir Goldstein fh_type = exportfs_encode_fh(lower, buf, &dwords, 0); 2553a1e819bSAmir Goldstein buflen = (dwords << 2); 2563a1e819bSAmir Goldstein 2573a1e819bSAmir Goldstein fh = ERR_PTR(-EIO); 2583a1e819bSAmir Goldstein if (WARN_ON(fh_type < 0) || 2593a1e819bSAmir Goldstein WARN_ON(buflen > MAX_HANDLE_SZ) || 2603a1e819bSAmir Goldstein WARN_ON(fh_type == FILEID_INVALID)) 2613a1e819bSAmir Goldstein goto out; 2623a1e819bSAmir Goldstein 2633a1e819bSAmir Goldstein BUILD_BUG_ON(MAX_HANDLE_SZ + offsetof(struct ovl_fh, fid) > 255); 2643a1e819bSAmir Goldstein fh_len = offsetof(struct ovl_fh, fid) + buflen; 2653a1e819bSAmir Goldstein fh = kmalloc(fh_len, GFP_KERNEL); 2663a1e819bSAmir Goldstein if (!fh) { 2673a1e819bSAmir Goldstein fh = ERR_PTR(-ENOMEM); 2683a1e819bSAmir Goldstein goto out; 2693a1e819bSAmir Goldstein } 2703a1e819bSAmir Goldstein 2713a1e819bSAmir Goldstein fh->version = OVL_FH_VERSION; 2723a1e819bSAmir Goldstein fh->magic = OVL_FH_MAGIC; 2733a1e819bSAmir Goldstein fh->type = fh_type; 2743a1e819bSAmir Goldstein fh->flags = OVL_FH_FLAG_CPU_ENDIAN; 27554fb347eSAmir Goldstein /* 27654fb347eSAmir Goldstein * When we will want to decode an overlay dentry from this handle 27754fb347eSAmir Goldstein * and all layers are on the same fs, if we get a disconncted real 27854fb347eSAmir Goldstein * dentry when we decode fid, the only way to tell if we should assign 27954fb347eSAmir Goldstein * it to upperdentry or to lowerstack is by checking this flag. 28054fb347eSAmir Goldstein */ 28154fb347eSAmir Goldstein if (is_upper) 28254fb347eSAmir Goldstein fh->flags |= OVL_FH_FLAG_PATH_UPPER; 2833a1e819bSAmir Goldstein fh->len = fh_len; 2843a1e819bSAmir Goldstein fh->uuid = *uuid; 2853a1e819bSAmir Goldstein memcpy(fh->fid, buf, buflen); 2863a1e819bSAmir Goldstein 2873a1e819bSAmir Goldstein out: 2883a1e819bSAmir Goldstein kfree(buf); 2893a1e819bSAmir Goldstein return fh; 2903a1e819bSAmir Goldstein } 2913a1e819bSAmir Goldstein 2923a1e819bSAmir Goldstein static int ovl_set_origin(struct dentry *dentry, struct dentry *lower, 2933a1e819bSAmir Goldstein struct dentry *upper) 2943a1e819bSAmir Goldstein { 2953a1e819bSAmir Goldstein const struct ovl_fh *fh = NULL; 2963a1e819bSAmir Goldstein int err; 2973a1e819bSAmir Goldstein 2983a1e819bSAmir Goldstein /* 2993a1e819bSAmir Goldstein * When lower layer doesn't support export operations store a 'null' fh, 3003a1e819bSAmir Goldstein * so we can use the overlay.origin xattr to distignuish between a copy 3013a1e819bSAmir Goldstein * up and a pure upper inode. 3023a1e819bSAmir Goldstein */ 30302bcd157SAmir Goldstein if (ovl_can_decode_fh(lower->d_sb)) { 30454fb347eSAmir Goldstein fh = ovl_encode_fh(lower, false); 3053a1e819bSAmir Goldstein if (IS_ERR(fh)) 3063a1e819bSAmir Goldstein return PTR_ERR(fh); 3073a1e819bSAmir Goldstein } 3083a1e819bSAmir Goldstein 3096266d465SMiklos Szeredi /* 3106266d465SMiklos Szeredi * Do not fail when upper doesn't support xattrs. 3116266d465SMiklos Szeredi */ 3126266d465SMiklos Szeredi err = ovl_check_setxattr(dentry, upper, OVL_XATTR_ORIGIN, fh, 3136266d465SMiklos Szeredi fh ? fh->len : 0, 0); 3143a1e819bSAmir Goldstein kfree(fh); 3153a1e819bSAmir Goldstein 3163a1e819bSAmir Goldstein return err; 3173a1e819bSAmir Goldstein } 3183a1e819bSAmir Goldstein 31923f0ab13SMiklos Szeredi struct ovl_copy_up_ctx { 320a6fb235aSMiklos Szeredi struct dentry *parent; 32123f0ab13SMiklos Szeredi struct dentry *dentry; 32223f0ab13SMiklos Szeredi struct path lowerpath; 32323f0ab13SMiklos Szeredi struct kstat stat; 32423f0ab13SMiklos Szeredi struct kstat pstat; 32523f0ab13SMiklos Szeredi const char *link; 32623f0ab13SMiklos Szeredi struct dentry *upperdir; 32723f0ab13SMiklos Szeredi struct dentry *workdir; 32823f0ab13SMiklos Szeredi bool tmpfile; 32923f0ab13SMiklos Szeredi }; 33023f0ab13SMiklos Szeredi 33123f0ab13SMiklos Szeredi static int ovl_install_temp(struct ovl_copy_up_ctx *c, struct dentry *temp, 33223f0ab13SMiklos Szeredi struct dentry **newdentry) 33315932c41SAmir Goldstein { 33415932c41SAmir Goldstein int err; 33515932c41SAmir Goldstein struct dentry *upper; 33623f0ab13SMiklos Szeredi struct inode *udir = d_inode(c->upperdir); 33715932c41SAmir Goldstein 33823f0ab13SMiklos Szeredi upper = lookup_one_len(c->dentry->d_name.name, c->upperdir, 33923f0ab13SMiklos Szeredi c->dentry->d_name.len); 34015932c41SAmir Goldstein if (IS_ERR(upper)) 34115932c41SAmir Goldstein return PTR_ERR(upper); 34215932c41SAmir Goldstein 34323f0ab13SMiklos Szeredi if (c->tmpfile) 34415932c41SAmir Goldstein err = ovl_do_link(temp, udir, upper, true); 34515932c41SAmir Goldstein else 34623f0ab13SMiklos Szeredi err = ovl_do_rename(d_inode(c->workdir), temp, udir, upper, 0); 34715932c41SAmir Goldstein 34815932c41SAmir Goldstein /* Restore timestamps on parent (best effort) */ 34915932c41SAmir Goldstein if (!err) { 35023f0ab13SMiklos Szeredi ovl_set_timestamps(c->upperdir, &c->pstat); 35123f0ab13SMiklos Szeredi *newdentry = dget(c->tmpfile ? upper : temp); 35215932c41SAmir Goldstein } 35315932c41SAmir Goldstein dput(upper); 35415932c41SAmir Goldstein 35515932c41SAmir Goldstein return err; 35615932c41SAmir Goldstein } 35715932c41SAmir Goldstein 35823f0ab13SMiklos Szeredi static int ovl_get_tmpfile(struct ovl_copy_up_ctx *c, struct dentry **tempp) 359e9be9d5eSMiklos Szeredi { 360e9be9d5eSMiklos Szeredi int err; 3617d90b853SMiklos Szeredi struct dentry *temp; 362d8ad8b49SVivek Goyal const struct cred *old_creds = NULL; 363d8ad8b49SVivek Goyal struct cred *new_creds = NULL; 36432a3d848SAl Viro struct cattr cattr = { 36532a3d848SAl Viro /* Can't properly set mode on creation because of the umask */ 36623f0ab13SMiklos Szeredi .mode = c->stat.mode & S_IFMT, 36723f0ab13SMiklos Szeredi .rdev = c->stat.rdev, 36823f0ab13SMiklos Szeredi .link = c->link 36932a3d848SAl Viro }; 370e9be9d5eSMiklos Szeredi 37123f0ab13SMiklos Szeredi err = security_inode_copy_up(c->dentry, &new_creds); 372d8ad8b49SVivek Goyal if (err < 0) 373e85f82ffSMiklos Szeredi goto out; 374d8ad8b49SVivek Goyal 375d8ad8b49SVivek Goyal if (new_creds) 376d8ad8b49SVivek Goyal old_creds = override_creds(new_creds); 377d8ad8b49SVivek Goyal 37823f0ab13SMiklos Szeredi if (c->tmpfile) { 37923f0ab13SMiklos Szeredi temp = ovl_do_tmpfile(c->workdir, c->stat.mode); 3807d90b853SMiklos Szeredi if (IS_ERR(temp)) 3817d90b853SMiklos Szeredi goto temp_err; 3827d90b853SMiklos Szeredi } else { 38323f0ab13SMiklos Szeredi temp = ovl_lookup_temp(c->workdir); 3847d90b853SMiklos Szeredi if (IS_ERR(temp)) 3857d90b853SMiklos Szeredi goto temp_err; 3867d90b853SMiklos Szeredi 38723f0ab13SMiklos Szeredi err = ovl_create_real(d_inode(c->workdir), temp, &cattr, 3887d90b853SMiklos Szeredi NULL, true); 3897d90b853SMiklos Szeredi if (err) { 3907d90b853SMiklos Szeredi dput(temp); 3917d90b853SMiklos Szeredi goto out; 3928137ae26SAmir Goldstein } 3937d90b853SMiklos Szeredi } 3947d90b853SMiklos Szeredi err = 0; 3957d90b853SMiklos Szeredi *tempp = temp; 3967d90b853SMiklos Szeredi out: 397d8ad8b49SVivek Goyal if (new_creds) { 398d8ad8b49SVivek Goyal revert_creds(old_creds); 399d8ad8b49SVivek Goyal put_cred(new_creds); 400d8ad8b49SVivek Goyal } 401d8ad8b49SVivek Goyal 4027d90b853SMiklos Szeredi return err; 4037d90b853SMiklos Szeredi 4047d90b853SMiklos Szeredi temp_err: 4057d90b853SMiklos Szeredi err = PTR_ERR(temp); 4067d90b853SMiklos Szeredi goto out; 4077d90b853SMiklos Szeredi } 4087d90b853SMiklos Szeredi 40923f0ab13SMiklos Szeredi static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp) 41002209d10SAmir Goldstein { 41102209d10SAmir Goldstein int err; 41202209d10SAmir Goldstein 41323f0ab13SMiklos Szeredi if (S_ISREG(c->stat.mode)) { 41402209d10SAmir Goldstein struct path upperpath; 41502209d10SAmir Goldstein 41623f0ab13SMiklos Szeredi ovl_path_upper(c->dentry, &upperpath); 41702209d10SAmir Goldstein BUG_ON(upperpath.dentry != NULL); 41802209d10SAmir Goldstein upperpath.dentry = temp; 41902209d10SAmir Goldstein 42023f0ab13SMiklos Szeredi err = ovl_copy_up_data(&c->lowerpath, &upperpath, c->stat.size); 42102209d10SAmir Goldstein if (err) 42202209d10SAmir Goldstein return err; 42302209d10SAmir Goldstein } 42402209d10SAmir Goldstein 42523f0ab13SMiklos Szeredi err = ovl_copy_xattr(c->lowerpath.dentry, temp); 42602209d10SAmir Goldstein if (err) 42702209d10SAmir Goldstein return err; 42802209d10SAmir Goldstein 42902209d10SAmir Goldstein inode_lock(temp->d_inode); 43023f0ab13SMiklos Szeredi err = ovl_set_attr(temp, &c->stat); 43102209d10SAmir Goldstein inode_unlock(temp->d_inode); 43202209d10SAmir Goldstein if (err) 43302209d10SAmir Goldstein return err; 43402209d10SAmir Goldstein 43502209d10SAmir Goldstein /* 43602209d10SAmir Goldstein * Store identifier of lower inode in upper inode xattr to 43702209d10SAmir Goldstein * allow lookup of the copy up origin inode. 43802209d10SAmir Goldstein * 43902209d10SAmir Goldstein * Don't set origin when we are breaking the association with a lower 44002209d10SAmir Goldstein * hard link. 44102209d10SAmir Goldstein */ 44223f0ab13SMiklos Szeredi if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1) { 44323f0ab13SMiklos Szeredi err = ovl_set_origin(c->dentry, c->lowerpath.dentry, temp); 44402209d10SAmir Goldstein if (err) 44502209d10SAmir Goldstein return err; 44602209d10SAmir Goldstein } 44702209d10SAmir Goldstein 44802209d10SAmir Goldstein return 0; 44902209d10SAmir Goldstein } 45002209d10SAmir Goldstein 45123f0ab13SMiklos Szeredi static int ovl_copy_up_locked(struct ovl_copy_up_ctx *c) 4527d90b853SMiklos Szeredi { 45323f0ab13SMiklos Szeredi struct inode *udir = c->upperdir->d_inode; 4547d90b853SMiklos Szeredi struct dentry *newdentry = NULL; 4557d90b853SMiklos Szeredi struct dentry *temp = NULL; 4567d90b853SMiklos Szeredi int err; 4577d90b853SMiklos Szeredi 45823f0ab13SMiklos Szeredi err = ovl_get_tmpfile(c, &temp); 459e9be9d5eSMiklos Szeredi if (err) 460e85f82ffSMiklos Szeredi goto out; 461e9be9d5eSMiklos Szeredi 46223f0ab13SMiklos Szeredi err = ovl_copy_up_inode(c, temp); 463e9be9d5eSMiklos Szeredi if (err) 464e9be9d5eSMiklos Szeredi goto out_cleanup; 4653a1e819bSAmir Goldstein 46623f0ab13SMiklos Szeredi if (c->tmpfile) { 46715932c41SAmir Goldstein inode_lock_nested(udir, I_MUTEX_PARENT); 46823f0ab13SMiklos Szeredi err = ovl_install_temp(c, temp, &newdentry); 46915932c41SAmir Goldstein inode_unlock(udir); 47015932c41SAmir Goldstein } else { 47123f0ab13SMiklos Szeredi err = ovl_install_temp(c, temp, &newdentry); 472e85f82ffSMiklos Szeredi } 473e9be9d5eSMiklos Szeredi if (err) 474e9be9d5eSMiklos Szeredi goto out_cleanup; 475e9be9d5eSMiklos Szeredi 47655acc661SMiklos Szeredi ovl_dentry_set_upper_alias(c->dentry); 47723f0ab13SMiklos Szeredi ovl_inode_update(d_inode(c->dentry), newdentry); 478e9be9d5eSMiklos Szeredi out: 479e85f82ffSMiklos Szeredi dput(temp); 480e9be9d5eSMiklos Szeredi return err; 481e9be9d5eSMiklos Szeredi 482e9be9d5eSMiklos Szeredi out_cleanup: 48323f0ab13SMiklos Szeredi if (!c->tmpfile) 48423f0ab13SMiklos Szeredi ovl_cleanup(d_inode(c->workdir), temp); 485e85f82ffSMiklos Szeredi goto out; 486e9be9d5eSMiklos Szeredi } 487e9be9d5eSMiklos Szeredi 488e9be9d5eSMiklos Szeredi /* 489e9be9d5eSMiklos Szeredi * Copy up a single dentry 490e9be9d5eSMiklos Szeredi * 491a6c60655SMiklos Szeredi * All renames start with copy up of source if necessary. The actual 492a6c60655SMiklos Szeredi * rename will only proceed once the copy up was successful. Copy up uses 493a6c60655SMiklos Szeredi * upper parent i_mutex for exclusion. Since rename can change d_parent it 494a6c60655SMiklos Szeredi * is possible that the copy up will lock the old parent. At that point 495a6c60655SMiklos Szeredi * the file will have already been copied up anyway. 496e9be9d5eSMiklos Szeredi */ 497a6fb235aSMiklos Szeredi static int ovl_do_copy_up(struct ovl_copy_up_ctx *c) 498e9be9d5eSMiklos Szeredi { 499e9be9d5eSMiklos Szeredi int err; 50023f0ab13SMiklos Szeredi struct ovl_fs *ofs = c->dentry->d_sb->s_fs_info; 501e9be9d5eSMiklos Szeredi 502f3a15685SAmir Goldstein /* Mark parent "impure" because it may now contain non-pure upper */ 503a6fb235aSMiklos Szeredi err = ovl_set_impure(c->parent, c->upperdir); 504f3a15685SAmir Goldstein if (err) 505f3a15685SAmir Goldstein return err; 506f3a15685SAmir Goldstein 50701ad3eb8SAmir Goldstein /* Should we copyup with O_TMPFILE or with workdir? */ 50823f0ab13SMiklos Szeredi if (S_ISREG(c->stat.mode) && ofs->tmpfile) { 50923f0ab13SMiklos Szeredi err = ovl_copy_up_start(c->dentry); 51001ad3eb8SAmir Goldstein /* err < 0: interrupted, err > 0: raced with another copy-up */ 51101ad3eb8SAmir Goldstein if (unlikely(err)) { 51223f0ab13SMiklos Szeredi pr_debug("ovl_copy_up_start(%pd2) = %i\n", c->dentry, 51323f0ab13SMiklos Szeredi err); 51401ad3eb8SAmir Goldstein if (err > 0) 51501ad3eb8SAmir Goldstein err = 0; 51601ad3eb8SAmir Goldstein goto out_done; 51701ad3eb8SAmir Goldstein } 51823f0ab13SMiklos Szeredi c->tmpfile = true; 51923f0ab13SMiklos Szeredi err = ovl_copy_up_locked(c); 52023f0ab13SMiklos Szeredi ovl_copy_up_end(c->dentry); 52101ad3eb8SAmir Goldstein goto out_done; 52201ad3eb8SAmir Goldstein } 52301ad3eb8SAmir Goldstein 524e9be9d5eSMiklos Szeredi err = -EIO; 52523f0ab13SMiklos Szeredi if (lock_rename(c->workdir, c->upperdir) != NULL) { 526e9be9d5eSMiklos Szeredi pr_err("overlayfs: failed to lock workdir+upperdir\n"); 527e9be9d5eSMiklos Szeredi goto out_unlock; 528e9be9d5eSMiklos Szeredi } 52923f0ab13SMiklos Szeredi if (ovl_dentry_upper(c->dentry)) { 5300f7ff2daSAl Viro /* Raced with another copy-up? Nothing to do, then... */ 531e9be9d5eSMiklos Szeredi err = 0; 5320f7ff2daSAl Viro goto out_unlock; 533e9be9d5eSMiklos Szeredi } 534e9be9d5eSMiklos Szeredi 53523f0ab13SMiklos Szeredi err = ovl_copy_up_locked(c); 536e9be9d5eSMiklos Szeredi out_unlock: 53723f0ab13SMiklos Szeredi unlock_rename(c->workdir, c->upperdir); 53801ad3eb8SAmir Goldstein out_done: 539a6fb235aSMiklos Szeredi 540a6fb235aSMiklos Szeredi return err; 541a6fb235aSMiklos Szeredi } 542a6fb235aSMiklos Szeredi 543a6fb235aSMiklos Szeredi static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 544a6fb235aSMiklos Szeredi int flags) 545a6fb235aSMiklos Szeredi { 546a6fb235aSMiklos Szeredi int err; 547a6fb235aSMiklos Szeredi DEFINE_DELAYED_CALL(done); 548a6fb235aSMiklos Szeredi struct path parentpath; 549a6fb235aSMiklos Szeredi struct ovl_copy_up_ctx ctx = { 550a6fb235aSMiklos Szeredi .parent = parent, 551a6fb235aSMiklos Szeredi .dentry = dentry, 552a6fb235aSMiklos Szeredi .workdir = ovl_workdir(dentry), 553a6fb235aSMiklos Szeredi }; 554a6fb235aSMiklos Szeredi 555a6fb235aSMiklos Szeredi if (WARN_ON(!ctx.workdir)) 556a6fb235aSMiklos Szeredi return -EROFS; 557a6fb235aSMiklos Szeredi 558a6fb235aSMiklos Szeredi ovl_path_lower(dentry, &ctx.lowerpath); 559a6fb235aSMiklos Szeredi err = vfs_getattr(&ctx.lowerpath, &ctx.stat, 560a6fb235aSMiklos Szeredi STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT); 561a6fb235aSMiklos Szeredi if (err) 562a6fb235aSMiklos Szeredi return err; 563a6fb235aSMiklos Szeredi 564a6fb235aSMiklos Szeredi ovl_path_upper(parent, &parentpath); 565a6fb235aSMiklos Szeredi ctx.upperdir = parentpath.dentry; 566a6fb235aSMiklos Szeredi 567a6fb235aSMiklos Szeredi err = vfs_getattr(&parentpath, &ctx.pstat, 568a6fb235aSMiklos Szeredi STATX_ATIME | STATX_MTIME, AT_STATX_SYNC_AS_STAT); 569a6fb235aSMiklos Szeredi if (err) 570a6fb235aSMiklos Szeredi return err; 571a6fb235aSMiklos Szeredi 572a6fb235aSMiklos Szeredi /* maybe truncate regular file. this has no effect on dirs */ 573a6fb235aSMiklos Szeredi if (flags & O_TRUNC) 574a6fb235aSMiklos Szeredi ctx.stat.size = 0; 575a6fb235aSMiklos Szeredi 576a6fb235aSMiklos Szeredi if (S_ISLNK(ctx.stat.mode)) { 577a6fb235aSMiklos Szeredi ctx.link = vfs_get_link(ctx.lowerpath.dentry, &done); 578a6fb235aSMiklos Szeredi if (IS_ERR(ctx.link)) 579a6fb235aSMiklos Szeredi return PTR_ERR(ctx.link); 580a6fb235aSMiklos Szeredi } 581a6fb235aSMiklos Szeredi ovl_do_check_copy_up(ctx.lowerpath.dentry); 582a6fb235aSMiklos Szeredi 583a6fb235aSMiklos Szeredi err = ovl_do_copy_up(&ctx); 584a6fb235aSMiklos Szeredi 5857764235bSMiklos Szeredi do_delayed_call(&done); 586e9be9d5eSMiklos Szeredi 587e9be9d5eSMiklos Szeredi return err; 588e9be9d5eSMiklos Szeredi } 589e9be9d5eSMiklos Szeredi 5909aba6521SAmir Goldstein int ovl_copy_up_flags(struct dentry *dentry, int flags) 591e9be9d5eSMiklos Szeredi { 5928eac98b8SVivek Goyal int err = 0; 5938eac98b8SVivek Goyal const struct cred *old_cred = ovl_override_creds(dentry->d_sb); 594e9be9d5eSMiklos Szeredi 595e9be9d5eSMiklos Szeredi while (!err) { 596e9be9d5eSMiklos Szeredi struct dentry *next; 597e9be9d5eSMiklos Szeredi struct dentry *parent; 598e9be9d5eSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 599e9be9d5eSMiklos Szeredi 6001afaba1eSMiklos Szeredi if (OVL_TYPE_UPPER(type)) 601e9be9d5eSMiklos Szeredi break; 602e9be9d5eSMiklos Szeredi 603e9be9d5eSMiklos Szeredi next = dget(dentry); 604e9be9d5eSMiklos Szeredi /* find the topmost dentry not yet copied up */ 605e9be9d5eSMiklos Szeredi for (;;) { 606e9be9d5eSMiklos Szeredi parent = dget_parent(next); 607e9be9d5eSMiklos Szeredi 608e9be9d5eSMiklos Szeredi type = ovl_path_type(parent); 6091afaba1eSMiklos Szeredi if (OVL_TYPE_UPPER(type)) 610e9be9d5eSMiklos Szeredi break; 611e9be9d5eSMiklos Szeredi 612e9be9d5eSMiklos Szeredi dput(next); 613e9be9d5eSMiklos Szeredi next = parent; 614e9be9d5eSMiklos Szeredi } 615e9be9d5eSMiklos Szeredi 616a6fb235aSMiklos Szeredi err = ovl_copy_up_one(parent, next, flags); 617e9be9d5eSMiklos Szeredi 618e9be9d5eSMiklos Szeredi dput(parent); 619e9be9d5eSMiklos Szeredi dput(next); 620e9be9d5eSMiklos Szeredi } 6218eac98b8SVivek Goyal revert_creds(old_cred); 622e9be9d5eSMiklos Szeredi 623e9be9d5eSMiklos Szeredi return err; 624e9be9d5eSMiklos Szeredi } 6259aba6521SAmir Goldstein 6269aba6521SAmir Goldstein int ovl_copy_up(struct dentry *dentry) 6279aba6521SAmir Goldstein { 6289aba6521SAmir Goldstein return ovl_copy_up_flags(dentry, 0); 6299aba6521SAmir Goldstein } 630