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