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 (f->f_inode == 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 61 if (!old->d_inode->i_op->getxattr || 62 !new->d_inode->i_op->getxattr) 63 return 0; 64 65 list_size = vfs_listxattr(old, NULL, 0); 66 if (list_size <= 0) { 67 if (list_size == -EOPNOTSUPP) 68 return 0; 69 return list_size; 70 } 71 72 buf = kzalloc(list_size, GFP_KERNEL); 73 if (!buf) 74 return -ENOMEM; 75 76 list_size = vfs_listxattr(old, buf, list_size); 77 if (list_size <= 0) { 78 error = list_size; 79 goto out; 80 } 81 82 for (name = buf; name < (buf + list_size); name += strlen(name) + 1) { 83 retry: 84 size = vfs_getxattr(old, name, value, value_size); 85 if (size == -ERANGE) 86 size = vfs_getxattr(old, name, NULL, 0); 87 88 if (size < 0) { 89 error = size; 90 break; 91 } 92 93 if (size > value_size) { 94 void *new; 95 96 new = krealloc(value, size, GFP_KERNEL); 97 if (!new) { 98 error = -ENOMEM; 99 break; 100 } 101 value = new; 102 value_size = size; 103 goto retry; 104 } 105 106 error = vfs_setxattr(new, name, value, size, 0); 107 if (error) 108 break; 109 } 110 kfree(value); 111 out: 112 kfree(buf); 113 return error; 114 } 115 116 static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 117 { 118 struct file *old_file; 119 struct file *new_file; 120 loff_t old_pos = 0; 121 loff_t new_pos = 0; 122 int error = 0; 123 124 if (len == 0) 125 return 0; 126 127 old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY); 128 if (IS_ERR(old_file)) 129 return PTR_ERR(old_file); 130 131 new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY); 132 if (IS_ERR(new_file)) { 133 error = PTR_ERR(new_file); 134 goto out_fput; 135 } 136 137 /* FIXME: copy up sparse files efficiently */ 138 while (len) { 139 size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 140 long bytes; 141 142 if (len < this_len) 143 this_len = len; 144 145 if (signal_pending_state(TASK_KILLABLE, current)) { 146 error = -EINTR; 147 break; 148 } 149 150 bytes = do_splice_direct(old_file, &old_pos, 151 new_file, &new_pos, 152 this_len, SPLICE_F_MOVE); 153 if (bytes <= 0) { 154 error = bytes; 155 break; 156 } 157 WARN_ON(old_pos != new_pos); 158 159 len -= bytes; 160 } 161 162 fput(new_file); 163 out_fput: 164 fput(old_file); 165 return error; 166 } 167 168 static char *ovl_read_symlink(struct dentry *realdentry) 169 { 170 int res; 171 char *buf; 172 struct inode *inode = realdentry->d_inode; 173 mm_segment_t old_fs; 174 175 res = -EINVAL; 176 if (!inode->i_op->readlink) 177 goto err; 178 179 res = -ENOMEM; 180 buf = (char *) __get_free_page(GFP_KERNEL); 181 if (!buf) 182 goto err; 183 184 old_fs = get_fs(); 185 set_fs(get_ds()); 186 /* The cast to a user pointer is valid due to the set_fs() */ 187 res = inode->i_op->readlink(realdentry, 188 (char __user *)buf, PAGE_SIZE - 1); 189 set_fs(old_fs); 190 if (res < 0) { 191 free_page((unsigned long) buf); 192 goto err; 193 } 194 buf[res] = '\0'; 195 196 return buf; 197 198 err: 199 return ERR_PTR(res); 200 } 201 202 static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 203 { 204 struct iattr attr = { 205 .ia_valid = 206 ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 207 .ia_atime = stat->atime, 208 .ia_mtime = stat->mtime, 209 }; 210 211 return notify_change(upperdentry, &attr, NULL); 212 } 213 214 int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat) 215 { 216 int err = 0; 217 218 if (!S_ISLNK(stat->mode)) { 219 struct iattr attr = { 220 .ia_valid = ATTR_MODE, 221 .ia_mode = stat->mode, 222 }; 223 err = notify_change(upperdentry, &attr, NULL); 224 } 225 if (!err) { 226 struct iattr attr = { 227 .ia_valid = ATTR_UID | ATTR_GID, 228 .ia_uid = stat->uid, 229 .ia_gid = stat->gid, 230 }; 231 err = notify_change(upperdentry, &attr, NULL); 232 } 233 if (!err) 234 ovl_set_timestamps(upperdentry, stat); 235 236 return err; 237 } 238 239 static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir, 240 struct dentry *dentry, struct path *lowerpath, 241 struct kstat *stat, const char *link) 242 { 243 struct inode *wdir = workdir->d_inode; 244 struct inode *udir = upperdir->d_inode; 245 struct dentry *newdentry = NULL; 246 struct dentry *upper = NULL; 247 umode_t mode = stat->mode; 248 int err; 249 250 newdentry = ovl_lookup_temp(workdir, dentry); 251 err = PTR_ERR(newdentry); 252 if (IS_ERR(newdentry)) 253 goto out; 254 255 upper = lookup_one_len(dentry->d_name.name, upperdir, 256 dentry->d_name.len); 257 err = PTR_ERR(upper); 258 if (IS_ERR(upper)) 259 goto out1; 260 261 /* Can't properly set mode on creation because of the umask */ 262 stat->mode &= S_IFMT; 263 err = ovl_create_real(wdir, newdentry, stat, link, NULL, true); 264 stat->mode = mode; 265 if (err) 266 goto out2; 267 268 if (S_ISREG(stat->mode)) { 269 struct path upperpath; 270 271 ovl_path_upper(dentry, &upperpath); 272 BUG_ON(upperpath.dentry != NULL); 273 upperpath.dentry = newdentry; 274 275 err = ovl_copy_up_data(lowerpath, &upperpath, stat->size); 276 if (err) 277 goto out_cleanup; 278 } 279 280 err = ovl_copy_xattr(lowerpath->dentry, newdentry); 281 if (err) 282 goto out_cleanup; 283 284 inode_lock(newdentry->d_inode); 285 err = ovl_set_attr(newdentry, stat); 286 inode_unlock(newdentry->d_inode); 287 if (err) 288 goto out_cleanup; 289 290 err = ovl_do_rename(wdir, newdentry, udir, upper, 0); 291 if (err) 292 goto out_cleanup; 293 294 ovl_dentry_update(dentry, newdentry); 295 newdentry = NULL; 296 297 /* 298 * Non-directores become opaque when copied up. 299 */ 300 if (!S_ISDIR(stat->mode)) 301 ovl_dentry_set_opaque(dentry, true); 302 out2: 303 dput(upper); 304 out1: 305 dput(newdentry); 306 out: 307 return err; 308 309 out_cleanup: 310 ovl_cleanup(wdir, newdentry); 311 goto out2; 312 } 313 314 /* 315 * Copy up a single dentry 316 * 317 * Directory renames only allowed on "pure upper" (already created on 318 * upper filesystem, never copied up). Directories which are on lower or 319 * are merged may not be renamed. For these -EXDEV is returned and 320 * userspace has to deal with it. This means, when copying up a 321 * directory we can rely on it and ancestors being stable. 322 * 323 * Non-directory renames start with copy up of source if necessary. The 324 * actual rename will only proceed once the copy up was successful. Copy 325 * up uses upper parent i_mutex for exclusion. Since rename can change 326 * d_parent it is possible that the copy up will lock the old parent. At 327 * that point the file will have already been copied up anyway. 328 */ 329 int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 330 struct path *lowerpath, struct kstat *stat) 331 { 332 struct dentry *workdir = ovl_workdir(dentry); 333 int err; 334 struct kstat pstat; 335 struct path parentpath; 336 struct dentry *upperdir; 337 struct dentry *upperdentry; 338 const struct cred *old_cred; 339 struct cred *override_cred; 340 char *link = NULL; 341 342 if (WARN_ON(!workdir)) 343 return -EROFS; 344 345 ovl_do_check_copy_up(lowerpath->dentry); 346 347 ovl_path_upper(parent, &parentpath); 348 upperdir = parentpath.dentry; 349 350 err = vfs_getattr(&parentpath, &pstat); 351 if (err) 352 return err; 353 354 if (S_ISLNK(stat->mode)) { 355 link = ovl_read_symlink(lowerpath->dentry); 356 if (IS_ERR(link)) 357 return PTR_ERR(link); 358 } 359 360 err = -ENOMEM; 361 override_cred = prepare_creds(); 362 if (!override_cred) 363 goto out_free_link; 364 365 override_cred->fsuid = stat->uid; 366 override_cred->fsgid = stat->gid; 367 /* 368 * CAP_SYS_ADMIN for copying up extended attributes 369 * CAP_DAC_OVERRIDE for create 370 * CAP_FOWNER for chmod, timestamp update 371 * CAP_FSETID for chmod 372 * CAP_CHOWN for chown 373 * CAP_MKNOD for mknod 374 */ 375 cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 376 cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 377 cap_raise(override_cred->cap_effective, CAP_FOWNER); 378 cap_raise(override_cred->cap_effective, CAP_FSETID); 379 cap_raise(override_cred->cap_effective, CAP_CHOWN); 380 cap_raise(override_cred->cap_effective, CAP_MKNOD); 381 old_cred = override_creds(override_cred); 382 383 err = -EIO; 384 if (lock_rename(workdir, upperdir) != NULL) { 385 pr_err("overlayfs: failed to lock workdir+upperdir\n"); 386 goto out_unlock; 387 } 388 upperdentry = ovl_dentry_upper(dentry); 389 if (upperdentry) { 390 /* Raced with another copy-up? Nothing to do, then... */ 391 err = 0; 392 goto out_unlock; 393 } 394 395 err = ovl_copy_up_locked(workdir, upperdir, dentry, lowerpath, 396 stat, link); 397 if (!err) { 398 /* Restore timestamps on parent (best effort) */ 399 ovl_set_timestamps(upperdir, &pstat); 400 } 401 out_unlock: 402 unlock_rename(workdir, upperdir); 403 revert_creds(old_cred); 404 put_cred(override_cred); 405 406 out_free_link: 407 if (link) 408 free_page((unsigned long) link); 409 410 return err; 411 } 412 413 int ovl_copy_up(struct dentry *dentry) 414 { 415 int err; 416 417 err = 0; 418 while (!err) { 419 struct dentry *next; 420 struct dentry *parent; 421 struct path lowerpath; 422 struct kstat stat; 423 enum ovl_path_type type = ovl_path_type(dentry); 424 425 if (OVL_TYPE_UPPER(type)) 426 break; 427 428 next = dget(dentry); 429 /* find the topmost dentry not yet copied up */ 430 for (;;) { 431 parent = dget_parent(next); 432 433 type = ovl_path_type(parent); 434 if (OVL_TYPE_UPPER(type)) 435 break; 436 437 dput(next); 438 next = parent; 439 } 440 441 ovl_path_lower(next, &lowerpath); 442 err = vfs_getattr(&lowerpath, &stat); 443 if (!err) 444 err = ovl_copy_up_one(parent, next, &lowerpath, &stat); 445 446 dput(parent); 447 dput(next); 448 } 449 450 return err; 451 } 452