fs/overlayfs/inode.c

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