1 /* 2 * 3 * Copyright (C) 2011 Novell Inc. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 as published by 7 * the Free Software Foundation. 8 */ 9 10 #include <linux/module.h> 11 #include <linux/fs.h> 12 #include <linux/slab.h> 13 #include <linux/file.h> 14 #include <linux/splice.h> 15 #include <linux/xattr.h> 16 #include <linux/security.h> 17 #include <linux/uaccess.h> 18 #include <linux/sched.h> 19 #include <linux/namei.h> 20 #include <linux/fdtable.h> 21 #include <linux/ratelimit.h> 22 #include "overlayfs.h" 23 24 #define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 25 26 static bool __read_mostly ovl_check_copy_up; 27 module_param_named(check_copy_up, ovl_check_copy_up, bool, 28 S_IWUSR | S_IRUGO); 29 MODULE_PARM_DESC(ovl_check_copy_up, 30 "Warn on copy-up when causing process also has a R/O fd open"); 31 32 static int ovl_check_fd(const void *data, struct file *f, unsigned int fd) 33 { 34 const struct dentry *dentry = data; 35 36 if (file_inode(f) == d_inode(dentry)) 37 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", 38 f, fd, current->pid, current->comm); 39 return 0; 40 } 41 42 /* 43 * Check the fds open by this process and warn if something like the following 44 * scenario is about to occur: 45 * 46 * fd1 = open("foo", O_RDONLY); 47 * fd2 = open("foo", O_RDWR); 48 */ 49 static void ovl_do_check_copy_up(struct dentry *dentry) 50 { 51 if (ovl_check_copy_up) 52 iterate_fd(current->files, 0, ovl_check_fd, dentry); 53 } 54 55 int ovl_copy_xattr(struct dentry *old, struct dentry *new) 56 { 57 ssize_t list_size, size, value_size = 0; 58 char *buf, *name, *value = NULL; 59 int uninitialized_var(error); 60 size_t slen; 61 62 if (!(old->d_inode->i_opflags & IOP_XATTR) || 63 !(new->d_inode->i_opflags & IOP_XATTR)) 64 return 0; 65 66 list_size = vfs_listxattr(old, NULL, 0); 67 if (list_size <= 0) { 68 if (list_size == -EOPNOTSUPP) 69 return 0; 70 return list_size; 71 } 72 73 buf = kzalloc(list_size, GFP_KERNEL); 74 if (!buf) 75 return -ENOMEM; 76 77 list_size = vfs_listxattr(old, buf, list_size); 78 if (list_size <= 0) { 79 error = list_size; 80 goto out; 81 } 82 83 for (name = buf; list_size; name += slen) { 84 slen = strnlen(name, list_size) + 1; 85 86 /* underlying fs providing us with an broken xattr list? */ 87 if (WARN_ON(slen > list_size)) { 88 error = -EIO; 89 break; 90 } 91 list_size -= slen; 92 93 if (ovl_is_private_xattr(name)) 94 continue; 95 retry: 96 size = vfs_getxattr(old, name, value, value_size); 97 if (size == -ERANGE) 98 size = vfs_getxattr(old, name, NULL, 0); 99 100 if (size < 0) { 101 error = size; 102 break; 103 } 104 105 if (size > value_size) { 106 void *new; 107 108 new = krealloc(value, size, GFP_KERNEL); 109 if (!new) { 110 error = -ENOMEM; 111 break; 112 } 113 value = new; 114 value_size = size; 115 goto retry; 116 } 117 118 error = security_inode_copy_up_xattr(name); 119 if (error < 0 && error != -EOPNOTSUPP) 120 break; 121 if (error == 1) { 122 error = 0; 123 continue; /* Discard */ 124 } 125 error = vfs_setxattr(new, name, value, size, 0); 126 if (error) 127 break; 128 } 129 kfree(value); 130 out: 131 kfree(buf); 132 return error; 133 } 134 135 static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 136 { 137 struct file *old_file; 138 struct file *new_file; 139 loff_t old_pos = 0; 140 loff_t new_pos = 0; 141 int error = 0; 142 143 if (len == 0) 144 return 0; 145 146 old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY); 147 if (IS_ERR(old_file)) 148 return PTR_ERR(old_file); 149 150 new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY); 151 if (IS_ERR(new_file)) { 152 error = PTR_ERR(new_file); 153 goto out_fput; 154 } 155 156 /* Try to use clone_file_range to clone up within the same fs */ 157 error = vfs_clone_file_range(old_file, 0, new_file, 0, len); 158 if (!error) 159 goto out; 160 /* Couldn't clone, so now we try to copy the data */ 161 error = 0; 162 163 /* FIXME: copy up sparse files efficiently */ 164 while (len) { 165 size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 166 long bytes; 167 168 if (len < this_len) 169 this_len = len; 170 171 if (signal_pending_state(TASK_KILLABLE, current)) { 172 error = -EINTR; 173 break; 174 } 175 176 bytes = do_splice_direct(old_file, &old_pos, 177 new_file, &new_pos, 178 this_len, SPLICE_F_MOVE); 179 if (bytes <= 0) { 180 error = bytes; 181 break; 182 } 183 WARN_ON(old_pos != new_pos); 184 185 len -= bytes; 186 } 187 out: 188 if (!error) 189 error = vfs_fsync(new_file, 0); 190 fput(new_file); 191 out_fput: 192 fput(old_file); 193 return error; 194 } 195 196 static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 197 { 198 struct iattr attr = { 199 .ia_valid = 200 ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 201 .ia_atime = stat->atime, 202 .ia_mtime = stat->mtime, 203 }; 204 205 return notify_change(upperdentry, &attr, NULL); 206 } 207 208 int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat) 209 { 210 int err = 0; 211 212 if (!S_ISLNK(stat->mode)) { 213 struct iattr attr = { 214 .ia_valid = ATTR_MODE, 215 .ia_mode = stat->mode, 216 }; 217 err = notify_change(upperdentry, &attr, NULL); 218 } 219 if (!err) { 220 struct iattr attr = { 221 .ia_valid = ATTR_UID | ATTR_GID, 222 .ia_uid = stat->uid, 223 .ia_gid = stat->gid, 224 }; 225 err = notify_change(upperdentry, &attr, NULL); 226 } 227 if (!err) 228 ovl_set_timestamps(upperdentry, stat); 229 230 return err; 231 } 232 233 static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir, 234 struct dentry *dentry, struct path *lowerpath, 235 struct kstat *stat, const char *link) 236 { 237 struct inode *wdir = workdir->d_inode; 238 struct inode *udir = upperdir->d_inode; 239 struct dentry *newdentry = NULL; 240 struct dentry *upper = NULL; 241 int err; 242 const struct cred *old_creds = NULL; 243 struct cred *new_creds = NULL; 244 struct cattr cattr = { 245 /* Can't properly set mode on creation because of the umask */ 246 .mode = stat->mode & S_IFMT, 247 .rdev = stat->rdev, 248 .link = link 249 }; 250 251 newdentry = ovl_lookup_temp(workdir, dentry); 252 err = PTR_ERR(newdentry); 253 if (IS_ERR(newdentry)) 254 goto out; 255 256 upper = lookup_one_len(dentry->d_name.name, upperdir, 257 dentry->d_name.len); 258 err = PTR_ERR(upper); 259 if (IS_ERR(upper)) 260 goto out1; 261 262 err = security_inode_copy_up(dentry, &new_creds); 263 if (err < 0) 264 goto out2; 265 266 if (new_creds) 267 old_creds = override_creds(new_creds); 268 269 err = ovl_create_real(wdir, newdentry, &cattr, NULL, true); 270 271 if (new_creds) { 272 revert_creds(old_creds); 273 put_cred(new_creds); 274 } 275 276 if (err) 277 goto out2; 278 279 if (S_ISREG(stat->mode)) { 280 struct path upperpath; 281 282 ovl_path_upper(dentry, &upperpath); 283 BUG_ON(upperpath.dentry != NULL); 284 upperpath.dentry = newdentry; 285 286 err = ovl_copy_up_data(lowerpath, &upperpath, stat->size); 287 if (err) 288 goto out_cleanup; 289 } 290 291 err = ovl_copy_xattr(lowerpath->dentry, newdentry); 292 if (err) 293 goto out_cleanup; 294 295 inode_lock(newdentry->d_inode); 296 err = ovl_set_attr(newdentry, stat); 297 inode_unlock(newdentry->d_inode); 298 if (err) 299 goto out_cleanup; 300 301 err = ovl_do_rename(wdir, newdentry, udir, upper, 0); 302 if (err) 303 goto out_cleanup; 304 305 ovl_dentry_update(dentry, newdentry); 306 ovl_inode_update(d_inode(dentry), d_inode(newdentry)); 307 newdentry = NULL; 308 out2: 309 dput(upper); 310 out1: 311 dput(newdentry); 312 out: 313 return err; 314 315 out_cleanup: 316 ovl_cleanup(wdir, newdentry); 317 goto out2; 318 } 319 320 /* 321 * Copy up a single dentry 322 * 323 * All renames start with copy up of source if necessary. The actual 324 * rename will only proceed once the copy up was successful. Copy up uses 325 * upper parent i_mutex for exclusion. Since rename can change d_parent it 326 * is possible that the copy up will lock the old parent. At that point 327 * the file will have already been copied up anyway. 328 */ 329 static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 330 struct path *lowerpath, struct kstat *stat) 331 { 332 DEFINE_DELAYED_CALL(done); 333 struct dentry *workdir = ovl_workdir(dentry); 334 int err; 335 struct kstat pstat; 336 struct path parentpath; 337 struct dentry *lowerdentry = lowerpath->dentry; 338 struct dentry *upperdir; 339 const char *link = NULL; 340 341 if (WARN_ON(!workdir)) 342 return -EROFS; 343 344 ovl_do_check_copy_up(lowerdentry); 345 346 ovl_path_upper(parent, &parentpath); 347 upperdir = parentpath.dentry; 348 349 err = vfs_getattr(&parentpath, &pstat); 350 if (err) 351 return err; 352 353 if (S_ISLNK(stat->mode)) { 354 link = vfs_get_link(lowerdentry, &done); 355 if (IS_ERR(link)) 356 return PTR_ERR(link); 357 } 358 359 err = -EIO; 360 if (lock_rename(workdir, upperdir) != NULL) { 361 pr_err("overlayfs: failed to lock workdir+upperdir\n"); 362 goto out_unlock; 363 } 364 if (ovl_dentry_upper(dentry)) { 365 /* Raced with another copy-up? Nothing to do, then... */ 366 err = 0; 367 goto out_unlock; 368 } 369 370 err = ovl_copy_up_locked(workdir, upperdir, dentry, lowerpath, 371 stat, link); 372 if (!err) { 373 /* Restore timestamps on parent (best effort) */ 374 ovl_set_timestamps(upperdir, &pstat); 375 } 376 out_unlock: 377 unlock_rename(workdir, upperdir); 378 do_delayed_call(&done); 379 380 return err; 381 } 382 383 int ovl_copy_up_flags(struct dentry *dentry, int flags) 384 { 385 int err = 0; 386 const struct cred *old_cred = ovl_override_creds(dentry->d_sb); 387 388 while (!err) { 389 struct dentry *next; 390 struct dentry *parent; 391 struct path lowerpath; 392 struct kstat stat; 393 enum ovl_path_type type = ovl_path_type(dentry); 394 395 if (OVL_TYPE_UPPER(type)) 396 break; 397 398 next = dget(dentry); 399 /* find the topmost dentry not yet copied up */ 400 for (;;) { 401 parent = dget_parent(next); 402 403 type = ovl_path_type(parent); 404 if (OVL_TYPE_UPPER(type)) 405 break; 406 407 dput(next); 408 next = parent; 409 } 410 411 ovl_path_lower(next, &lowerpath); 412 err = vfs_getattr(&lowerpath, &stat); 413 /* maybe truncate regular file. this has no effect on dirs */ 414 if (flags & O_TRUNC) 415 stat.size = 0; 416 if (!err) 417 err = ovl_copy_up_one(parent, next, &lowerpath, &stat); 418 419 dput(parent); 420 dput(next); 421 } 422 revert_creds(old_cred); 423 424 return err; 425 } 426 427 int ovl_copy_up(struct dentry *dentry) 428 { 429 return ovl_copy_up_flags(dentry, 0); 430 } 431