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/xattr.h> 13 #include <linux/posix_acl.h> 14 #include "overlayfs.h" 15 16 static int ovl_copy_up_truncate(struct dentry *dentry) 17 { 18 int err; 19 struct dentry *parent; 20 struct kstat stat; 21 struct path lowerpath; 22 23 parent = dget_parent(dentry); 24 err = ovl_copy_up(parent); 25 if (err) 26 goto out_dput_parent; 27 28 ovl_path_lower(dentry, &lowerpath); 29 err = vfs_getattr(&lowerpath, &stat); 30 if (err) 31 goto out_dput_parent; 32 33 stat.size = 0; 34 err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat); 35 36 out_dput_parent: 37 dput(parent); 38 return err; 39 } 40 41 int ovl_setattr(struct dentry *dentry, struct iattr *attr) 42 { 43 int err; 44 struct dentry *upperdentry; 45 const struct cred *old_cred; 46 47 /* 48 * Check for permissions before trying to copy-up. This is redundant 49 * since it will be rechecked later by ->setattr() on upper dentry. But 50 * without this, copy-up can be triggered by just about anybody. 51 * 52 * We don't initialize inode->size, which just means that 53 * inode_newsize_ok() will always check against MAX_LFS_FILESIZE and not 54 * check for a swapfile (which this won't be anyway). 55 */ 56 err = inode_change_ok(dentry->d_inode, attr); 57 if (err) 58 return err; 59 60 err = ovl_want_write(dentry); 61 if (err) 62 goto out; 63 64 if (attr->ia_valid & ATTR_SIZE) { 65 struct inode *realinode = d_inode(ovl_dentry_real(dentry)); 66 67 err = -ETXTBSY; 68 if (atomic_read(&realinode->i_writecount) < 0) 69 goto out_drop_write; 70 } 71 72 err = ovl_copy_up(dentry); 73 if (!err) { 74 struct inode *winode = NULL; 75 76 upperdentry = ovl_dentry_upper(dentry); 77 78 if (attr->ia_valid & ATTR_SIZE) { 79 winode = d_inode(upperdentry); 80 err = get_write_access(winode); 81 if (err) 82 goto out_drop_write; 83 } 84 85 if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 86 attr->ia_valid &= ~ATTR_MODE; 87 88 inode_lock(upperdentry->d_inode); 89 old_cred = ovl_override_creds(dentry->d_sb); 90 err = notify_change(upperdentry, attr, NULL); 91 revert_creds(old_cred); 92 if (!err) 93 ovl_copyattr(upperdentry->d_inode, dentry->d_inode); 94 inode_unlock(upperdentry->d_inode); 95 96 if (winode) 97 put_write_access(winode); 98 } 99 out_drop_write: 100 ovl_drop_write(dentry); 101 out: 102 return err; 103 } 104 105 static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry, 106 struct kstat *stat) 107 { 108 struct path realpath; 109 const struct cred *old_cred; 110 int err; 111 112 ovl_path_real(dentry, &realpath); 113 old_cred = ovl_override_creds(dentry->d_sb); 114 err = vfs_getattr(&realpath, stat); 115 revert_creds(old_cred); 116 return err; 117 } 118 119 int ovl_permission(struct inode *inode, int mask) 120 { 121 bool is_upper; 122 struct inode *realinode = ovl_inode_real(inode, &is_upper); 123 const struct cred *old_cred; 124 int err; 125 126 /* Careful in RCU walk mode */ 127 if (!realinode) { 128 WARN_ON(!(mask & MAY_NOT_BLOCK)); 129 return -ECHILD; 130 } 131 132 /* 133 * Check overlay inode with the creds of task and underlying inode 134 * with creds of mounter 135 */ 136 err = generic_permission(inode, mask); 137 if (err) 138 return err; 139 140 old_cred = ovl_override_creds(inode->i_sb); 141 if (!is_upper && !special_file(realinode->i_mode) && mask & MAY_WRITE) { 142 mask &= ~(MAY_WRITE | MAY_APPEND); 143 /* Make sure mounter can read file for copy up later */ 144 mask |= MAY_READ; 145 } 146 err = inode_permission(realinode, mask); 147 revert_creds(old_cred); 148 149 return err; 150 } 151 152 static const char *ovl_get_link(struct dentry *dentry, 153 struct inode *inode, 154 struct delayed_call *done) 155 { 156 struct dentry *realdentry; 157 struct inode *realinode; 158 const struct cred *old_cred; 159 const char *p; 160 161 if (!dentry) 162 return ERR_PTR(-ECHILD); 163 164 realdentry = ovl_dentry_real(dentry); 165 realinode = realdentry->d_inode; 166 167 if (WARN_ON(!realinode->i_op->get_link)) 168 return ERR_PTR(-EPERM); 169 170 old_cred = ovl_override_creds(dentry->d_sb); 171 p = realinode->i_op->get_link(realdentry, realinode, done); 172 revert_creds(old_cred); 173 return p; 174 } 175 176 static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz) 177 { 178 struct path realpath; 179 struct inode *realinode; 180 const struct cred *old_cred; 181 int err; 182 183 ovl_path_real(dentry, &realpath); 184 realinode = realpath.dentry->d_inode; 185 186 if (!realinode->i_op->readlink) 187 return -EINVAL; 188 189 old_cred = ovl_override_creds(dentry->d_sb); 190 err = realinode->i_op->readlink(realpath.dentry, buf, bufsiz); 191 revert_creds(old_cred); 192 return err; 193 } 194 195 bool ovl_is_private_xattr(const char *name) 196 { 197 return strncmp(name, OVL_XATTR_PREFIX, 198 sizeof(OVL_XATTR_PREFIX) - 1) == 0; 199 } 200 201 int ovl_setxattr(struct dentry *dentry, struct inode *inode, 202 const char *name, const void *value, 203 size_t size, int flags) 204 { 205 int err; 206 struct dentry *upperdentry; 207 const struct cred *old_cred; 208 209 err = ovl_want_write(dentry); 210 if (err) 211 goto out; 212 213 err = ovl_copy_up(dentry); 214 if (err) 215 goto out_drop_write; 216 217 upperdentry = ovl_dentry_upper(dentry); 218 old_cred = ovl_override_creds(dentry->d_sb); 219 err = vfs_setxattr(upperdentry, name, value, size, flags); 220 revert_creds(old_cred); 221 222 out_drop_write: 223 ovl_drop_write(dentry); 224 out: 225 return err; 226 } 227 228 ssize_t ovl_getxattr(struct dentry *dentry, struct inode *inode, 229 const char *name, void *value, size_t size) 230 { 231 struct dentry *realdentry = ovl_dentry_real(dentry); 232 ssize_t res; 233 const struct cred *old_cred; 234 235 if (ovl_is_private_xattr(name)) 236 return -ENODATA; 237 238 old_cred = ovl_override_creds(dentry->d_sb); 239 res = vfs_getxattr(realdentry, name, value, size); 240 revert_creds(old_cred); 241 return res; 242 } 243 244 ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 245 { 246 struct dentry *realdentry = ovl_dentry_real(dentry); 247 ssize_t res; 248 int off; 249 const struct cred *old_cred; 250 251 old_cred = ovl_override_creds(dentry->d_sb); 252 res = vfs_listxattr(realdentry, list, size); 253 revert_creds(old_cred); 254 if (res <= 0 || size == 0) 255 return res; 256 257 /* filter out private xattrs */ 258 for (off = 0; off < res;) { 259 char *s = list + off; 260 size_t slen = strlen(s) + 1; 261 262 BUG_ON(off + slen > res); 263 264 if (ovl_is_private_xattr(s)) { 265 res -= slen; 266 memmove(s, s + slen, res - off); 267 } else { 268 off += slen; 269 } 270 } 271 272 return res; 273 } 274 275 int ovl_removexattr(struct dentry *dentry, const char *name) 276 { 277 int err; 278 struct path realpath; 279 enum ovl_path_type type = ovl_path_real(dentry, &realpath); 280 const struct cred *old_cred; 281 282 err = ovl_want_write(dentry); 283 if (err) 284 goto out; 285 286 err = -ENODATA; 287 if (ovl_is_private_xattr(name)) 288 goto out_drop_write; 289 290 if (!OVL_TYPE_UPPER(type)) { 291 err = vfs_getxattr(realpath.dentry, name, NULL, 0); 292 if (err < 0) 293 goto out_drop_write; 294 295 err = ovl_copy_up(dentry); 296 if (err) 297 goto out_drop_write; 298 299 ovl_path_upper(dentry, &realpath); 300 } 301 302 old_cred = ovl_override_creds(dentry->d_sb); 303 err = vfs_removexattr(realpath.dentry, name); 304 revert_creds(old_cred); 305 out_drop_write: 306 ovl_drop_write(dentry); 307 out: 308 return err; 309 } 310 311 struct posix_acl *ovl_get_acl(struct inode *inode, int type) 312 { 313 struct inode *realinode = ovl_inode_real(inode, NULL); 314 const struct cred *old_cred; 315 struct posix_acl *acl; 316 317 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode)) 318 return NULL; 319 320 if (!realinode->i_op->get_acl) 321 return NULL; 322 323 old_cred = ovl_override_creds(inode->i_sb); 324 acl = get_acl(realinode, type); 325 revert_creds(old_cred); 326 327 return acl; 328 } 329 330 static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, 331 struct dentry *realdentry) 332 { 333 if (OVL_TYPE_UPPER(type)) 334 return false; 335 336 if (special_file(realdentry->d_inode->i_mode)) 337 return false; 338 339 if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) 340 return false; 341 342 return true; 343 } 344 345 int ovl_open_maybe_copy_up(struct dentry *dentry, unsigned int file_flags) 346 { 347 int err = 0; 348 struct path realpath; 349 enum ovl_path_type type; 350 351 type = ovl_path_real(dentry, &realpath); 352 if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) { 353 err = ovl_want_write(dentry); 354 if (!err) { 355 if (file_flags & O_TRUNC) 356 err = ovl_copy_up_truncate(dentry); 357 else 358 err = ovl_copy_up(dentry); 359 ovl_drop_write(dentry); 360 } 361 } 362 363 return err; 364 } 365 366 int ovl_update_time(struct inode *inode, struct timespec *ts, int flags) 367 { 368 struct dentry *alias; 369 struct path upperpath; 370 371 if (!(flags & S_ATIME)) 372 return 0; 373 374 alias = d_find_any_alias(inode); 375 if (!alias) 376 return 0; 377 378 ovl_path_upper(alias, &upperpath); 379 if (upperpath.dentry) { 380 touch_atime(&upperpath); 381 inode->i_atime = d_inode(upperpath.dentry)->i_atime; 382 } 383 384 dput(alias); 385 386 return 0; 387 } 388 389 static const struct inode_operations ovl_file_inode_operations = { 390 .setattr = ovl_setattr, 391 .permission = ovl_permission, 392 .getattr = ovl_getattr, 393 .setxattr = generic_setxattr, 394 .getxattr = ovl_getxattr, 395 .listxattr = ovl_listxattr, 396 .removexattr = ovl_removexattr, 397 .get_acl = ovl_get_acl, 398 .update_time = ovl_update_time, 399 }; 400 401 static const struct inode_operations ovl_symlink_inode_operations = { 402 .setattr = ovl_setattr, 403 .get_link = ovl_get_link, 404 .readlink = ovl_readlink, 405 .getattr = ovl_getattr, 406 .setxattr = generic_setxattr, 407 .getxattr = ovl_getxattr, 408 .listxattr = ovl_listxattr, 409 .removexattr = ovl_removexattr, 410 .update_time = ovl_update_time, 411 }; 412 413 static void ovl_fill_inode(struct inode *inode, umode_t mode) 414 { 415 inode->i_ino = get_next_ino(); 416 inode->i_mode = mode; 417 inode->i_flags |= S_NOCMTIME; 418 #ifdef CONFIG_FS_POSIX_ACL 419 inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE; 420 #endif 421 422 mode &= S_IFMT; 423 switch (mode) { 424 case S_IFDIR: 425 inode->i_op = &ovl_dir_inode_operations; 426 inode->i_fop = &ovl_dir_operations; 427 break; 428 429 case S_IFLNK: 430 inode->i_op = &ovl_symlink_inode_operations; 431 break; 432 433 default: 434 WARN(1, "illegal file type: %i\n", mode); 435 /* Fall through */ 436 437 case S_IFREG: 438 case S_IFSOCK: 439 case S_IFBLK: 440 case S_IFCHR: 441 case S_IFIFO: 442 inode->i_op = &ovl_file_inode_operations; 443 break; 444 } 445 } 446 447 struct inode *ovl_new_inode(struct super_block *sb, umode_t mode) 448 { 449 struct inode *inode; 450 451 inode = new_inode(sb); 452 if (inode) 453 ovl_fill_inode(inode, mode); 454 455 return inode; 456 } 457 458 static int ovl_inode_test(struct inode *inode, void *data) 459 { 460 return ovl_inode_real(inode, NULL) == data; 461 } 462 463 static int ovl_inode_set(struct inode *inode, void *data) 464 { 465 inode->i_private = (void *) (((unsigned long) data) | OVL_ISUPPER_MASK); 466 return 0; 467 } 468 469 struct inode *ovl_get_inode(struct super_block *sb, struct inode *realinode) 470 471 { 472 struct inode *inode; 473 474 inode = iget5_locked(sb, (unsigned long) realinode, 475 ovl_inode_test, ovl_inode_set, realinode); 476 if (inode && inode->i_state & I_NEW) { 477 ovl_fill_inode(inode, realinode->i_mode); 478 set_nlink(inode, realinode->i_nlink); 479 unlock_new_inode(inode); 480 } 481 482 return inode; 483 } 484