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/cred.h>
  13 #include <linux/xattr.h>
  14 #include <linux/posix_acl.h>
  15 #include "overlayfs.h"
  16
  17 int ovl_setattr(struct dentry *dentry, struct iattr *attr)
  18 {
  19         int err;
  20         struct dentry *upperdentry;
  21         const struct cred *old_cred;
  22
  23         /*
  24          * Check for permissions before trying to copy-up.  This is redundant
  25          * since it will be rechecked later by ->setattr() on upper dentry.  But
  26          * without this, copy-up can be triggered by just about anybody.
  27          *
  28          * We don't initialize inode->size, which just means that
  29          * inode_newsize_ok() will always check against MAX_LFS_FILESIZE and not
  30          * check for a swapfile (which this won't be anyway).
  31          */
  32         err = setattr_prepare(dentry, attr);
  33         if (err)
  34                 return err;
  35
  36         err = ovl_want_write(dentry);
  37         if (err)
  38                 goto out;
  39
  40         err = ovl_copy_up(dentry);
  41         if (!err) {
  42                 upperdentry = ovl_dentry_upper(dentry);
  43
  44                 if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
  45                         attr->ia_valid &= ~ATTR_MODE;
  46
  47                 inode_lock(upperdentry->d_inode);
  48                 old_cred = ovl_override_creds(dentry->d_sb);
  49                 err = notify_change(upperdentry, attr, NULL);
  50                 revert_creds(old_cred);
  51                 if (!err)
  52                         ovl_copyattr(upperdentry->d_inode, dentry->d_inode);
  53                 inode_unlock(upperdentry->d_inode);
  54         }
  55         ovl_drop_write(dentry);
  56 out:
  57         return err;
  58 }
  59
  60 static int ovl_getattr(const struct path *path, struct kstat *stat,
  61                        u32 request_mask, unsigned int flags)
  62 {
  63         struct dentry *dentry = path->dentry;
  64         enum ovl_path_type type;
  65         struct path realpath;
  66         const struct cred *old_cred;
  67         int err;
  68
  69         type = ovl_path_real(dentry, &realpath);
  70         old_cred = ovl_override_creds(dentry->d_sb);
  71         err = vfs_getattr(&realpath, stat, request_mask, flags);
  72         if (err)
  73                 goto out;
  74
  75         /*
  76          * When all layers are on the same fs, all real inode number are
  77          * unique, so we use the overlay st_dev, which is friendly to du -x.
  78          *
  79          * We also use st_ino of the copy up origin, if we know it.
  80          * This guaranties constant st_dev/st_ino across copy up.
  81          *
  82          * If filesystem supports NFS export ops, this also guaranties
  83          * persistent st_ino across mount cycle.
  84          */
  85         if (ovl_same_sb(dentry->d_sb)) {
  86                 if (OVL_TYPE_ORIGIN(type)) {
  87                         struct kstat lowerstat;
  88
  89                         ovl_path_lower(dentry, &realpath);
  90                         err = vfs_getattr(&realpath, &lowerstat,
  91                                           STATX_INO | STATX_NLINK, flags);
  92                         if (err)
  93                                 goto out;
  94
  95                         WARN_ON_ONCE(stat->dev != lowerstat.dev);
  96                         /*
  97                          * Lower hardlinks are broken on copy up to different
  98                          * upper files, so we cannot use the lower origin st_ino
  99                          * for those different files, even for the same fs case.
 100                          */
 101                         if (lowerstat.nlink == 1)
 102                                 stat->ino = lowerstat.ino;
 103                 }
 104                 stat->dev = dentry->d_sb->s_dev;
 105         }
 106 out:
 107         revert_creds(old_cred);
 108
 109         return err;
 110 }
 111
 112 int ovl_permission(struct inode *inode, int mask)
 113 {
 114         bool is_upper;
 115         struct inode *realinode = ovl_inode_real(inode, &is_upper);
 116         const struct cred *old_cred;
 117         int err;
 118
 119         /* Careful in RCU walk mode */
 120         if (!realinode) {
 121                 WARN_ON(!(mask & MAY_NOT_BLOCK));
 122                 return -ECHILD;
 123         }
 124
 125         /*
 126          * Check overlay inode with the creds of task and underlying inode
 127          * with creds of mounter
 128          */
 129         err = generic_permission(inode, mask);
 130         if (err)
 131                 return err;
 132
 133         old_cred = ovl_override_creds(inode->i_sb);
 134         if (!is_upper && !special_file(realinode->i_mode) && mask & MAY_WRITE) {
 135                 mask &= ~(MAY_WRITE | MAY_APPEND);
 136                 /* Make sure mounter can read file for copy up later */
 137                 mask |= MAY_READ;
 138         }
 139         err = inode_permission(realinode, mask);
 140         revert_creds(old_cred);
 141
 142         return err;
 143 }
 144
 145 static const char *ovl_get_link(struct dentry *dentry,
 146                                 struct inode *inode,
 147                                 struct delayed_call *done)
 148 {
 149         const struct cred *old_cred;
 150         const char *p;
 151
 152         if (!dentry)
 153                 return ERR_PTR(-ECHILD);
 154
 155         old_cred = ovl_override_creds(dentry->d_sb);
 156         p = vfs_get_link(ovl_dentry_real(dentry), done);
 157         revert_creds(old_cred);
 158         return p;
 159 }
 160
 161 bool ovl_is_private_xattr(const char *name)
 162 {
 163         return strncmp(name, OVL_XATTR_PREFIX,
 164                        sizeof(OVL_XATTR_PREFIX) - 1) == 0;
 165 }
 166
 167 int ovl_xattr_set(struct dentry *dentry, const char *name, const void *value,
 168                   size_t size, int flags)
 169 {
 170         int err;
 171         struct path realpath;
 172         enum ovl_path_type type = ovl_path_real(dentry, &realpath);
 173         const struct cred *old_cred;
 174
 175         err = ovl_want_write(dentry);
 176         if (err)
 177                 goto out;
 178
 179         if (!value && !OVL_TYPE_UPPER(type)) {
 180                 err = vfs_getxattr(realpath.dentry, name, NULL, 0);
 181                 if (err < 0)
 182                         goto out_drop_write;
 183         }
 184
 185         err = ovl_copy_up(dentry);
 186         if (err)
 187                 goto out_drop_write;
 188
 189         if (!OVL_TYPE_UPPER(type))
 190                 ovl_path_upper(dentry, &realpath);
 191
 192         old_cred = ovl_override_creds(dentry->d_sb);
 193         if (value)
 194                 err = vfs_setxattr(realpath.dentry, name, value, size, flags);
 195         else {
 196                 WARN_ON(flags != XATTR_REPLACE);
 197                 err = vfs_removexattr(realpath.dentry, name);
 198         }
 199         revert_creds(old_cred);
 200
 201 out_drop_write:
 202         ovl_drop_write(dentry);
 203 out:
 204         return err;
 205 }
 206
 207 int ovl_xattr_get(struct dentry *dentry, const char *name,
 208                   void *value, size_t size)
 209 {
 210         struct dentry *realdentry = ovl_dentry_real(dentry);
 211         ssize_t res;
 212         const struct cred *old_cred;
 213
 214         old_cred = ovl_override_creds(dentry->d_sb);
 215         res = vfs_getxattr(realdentry, name, value, size);
 216         revert_creds(old_cred);
 217         return res;
 218 }
 219
 220 ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
 221 {
 222         struct dentry *realdentry = ovl_dentry_real(dentry);
 223         ssize_t res;
 224         size_t len;
 225         char *s;
 226         const struct cred *old_cred;
 227
 228         old_cred = ovl_override_creds(dentry->d_sb);
 229         res = vfs_listxattr(realdentry, list, size);
 230         revert_creds(old_cred);
 231         if (res <= 0 || size == 0)
 232                 return res;
 233
 234         /* filter out private xattrs */
 235         for (s = list, len = res; len;) {
 236                 size_t slen = strnlen(s, len) + 1;
 237
 238                 /* underlying fs providing us with an broken xattr list? */
 239                 if (WARN_ON(slen > len))
 240                         return -EIO;
 241
 242                 len -= slen;
 243                 if (ovl_is_private_xattr(s)) {
 244                         res -= slen;
 245                         memmove(s, s + slen, len);
 246                 } else {
 247                         s += slen;
 248                 }
 249         }
 250
 251         return res;
 252 }
 253
 254 struct posix_acl *ovl_get_acl(struct inode *inode, int type)
 255 {
 256         struct inode *realinode = ovl_inode_real(inode, NULL);
 257         const struct cred *old_cred;
 258         struct posix_acl *acl;
 259
 260         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode))
 261                 return NULL;
 262
 263         old_cred = ovl_override_creds(inode->i_sb);
 264         acl = get_acl(realinode, type);
 265         revert_creds(old_cred);
 266
 267         return acl;
 268 }
 269
 270 static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
 271                                   struct dentry *realdentry)
 272 {
 273         if (OVL_TYPE_UPPER(type))
 274                 return false;
 275
 276         if (special_file(realdentry->d_inode->i_mode))
 277                 return false;
 278
 279         if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
 280                 return false;
 281
 282         return true;
 283 }
 284
 285 int ovl_open_maybe_copy_up(struct dentry *dentry, unsigned int file_flags)
 286 {
 287         int err = 0;
 288         struct path realpath;
 289         enum ovl_path_type type;
 290
 291         type = ovl_path_real(dentry, &realpath);
 292         if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) {
 293                 err = ovl_want_write(dentry);
 294                 if (!err) {
 295                         err = ovl_copy_up_flags(dentry, file_flags);
 296                         ovl_drop_write(dentry);
 297                 }
 298         }
 299
 300         return err;
 301 }
 302
 303 int ovl_update_time(struct inode *inode, struct timespec *ts, int flags)
 304 {
 305         struct dentry *alias;
 306         struct path upperpath;
 307
 308         if (!(flags & S_ATIME))
 309                 return 0;
 310
 311         alias = d_find_any_alias(inode);
 312         if (!alias)
 313                 return 0;
 314
 315         ovl_path_upper(alias, &upperpath);
 316         if (upperpath.dentry) {
 317                 touch_atime(&upperpath);
 318                 inode->i_atime = d_inode(upperpath.dentry)->i_atime;
 319         }
 320
 321         dput(alias);
 322
 323         return 0;
 324 }
 325
 326 static const struct inode_operations ovl_file_inode_operations = {
 327         .setattr        = ovl_setattr,
 328         .permission     = ovl_permission,
 329         .getattr        = ovl_getattr,
 330         .listxattr      = ovl_listxattr,
 331         .get_acl        = ovl_get_acl,
 332         .update_time    = ovl_update_time,
 333 };
 334
 335 static const struct inode_operations ovl_symlink_inode_operations = {
 336         .setattr        = ovl_setattr,
 337         .get_link       = ovl_get_link,
 338         .getattr        = ovl_getattr,
 339         .listxattr      = ovl_listxattr,
 340         .update_time    = ovl_update_time,
 341 };
 342
 343 /*
 344  * It is possible to stack overlayfs instance on top of another
 345  * overlayfs instance as lower layer. We need to annonate the
 346  * stackable i_mutex locks according to stack level of the super
 347  * block instance. An overlayfs instance can never be in stack
 348  * depth 0 (there is always a real fs below it).  An overlayfs
 349  * inode lock will use the lockdep annotaion ovl_i_mutex_key[depth].
 350  *
 351  * For example, here is a snip from /proc/lockdep_chains after
 352  * dir_iterate of nested overlayfs:
 353  *
 354  * [...] &ovl_i_mutex_dir_key[depth]   (stack_depth=2)
 355  * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1)
 356  * [...] &type->i_mutex_dir_key        (stack_depth=0)
 357  */
 358 #define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH
 359
 360 static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode)
 361 {
 362 #ifdef CONFIG_LOCKDEP
 363         static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING];
 364         static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING];
 365
 366         int depth = inode->i_sb->s_stack_depth - 1;
 367
 368         if (WARN_ON_ONCE(depth < 0 || depth >= OVL_MAX_NESTING))
 369                 depth = 0;
 370
 371         if (S_ISDIR(inode->i_mode))
 372                 lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]);
 373         else
 374                 lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]);
 375 #endif
 376 }
 377
 378 static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev)
 379 {
 380         inode->i_ino = get_next_ino();
 381         inode->i_mode = mode;
 382         inode->i_flags |= S_NOCMTIME;
 383 #ifdef CONFIG_FS_POSIX_ACL
 384         inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE;
 385 #endif
 386
 387         ovl_lockdep_annotate_inode_mutex_key(inode);
 388
 389         switch (mode & S_IFMT) {
 390         case S_IFREG:
 391                 inode->i_op = &ovl_file_inode_operations;
 392                 break;
 393
 394         case S_IFDIR:
 395                 inode->i_op = &ovl_dir_inode_operations;
 396                 inode->i_fop = &ovl_dir_operations;
 397                 break;
 398
 399         case S_IFLNK:
 400                 inode->i_op = &ovl_symlink_inode_operations;
 401                 break;
 402
 403         default:
 404                 inode->i_op = &ovl_file_inode_operations;
 405                 init_special_inode(inode, mode, rdev);
 406                 break;
 407         }
 408 }
 409
 410 struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev)
 411 {
 412         struct inode *inode;
 413
 414         inode = new_inode(sb);
 415         if (inode)
 416                 ovl_fill_inode(inode, mode, rdev);
 417
 418         return inode;
 419 }
 420
 421 static int ovl_inode_test(struct inode *inode, void *data)
 422 {
 423         return ovl_inode_real(inode, NULL) == data;
 424 }
 425
 426 static int ovl_inode_set(struct inode *inode, void *data)
 427 {
 428         inode->i_private = (void *) (((unsigned long) data) | OVL_ISUPPER_MASK);
 429         return 0;
 430 }
 431
 432 struct inode *ovl_get_inode(struct super_block *sb, struct inode *realinode)
 433
 434 {
 435         struct inode *inode;
 436
 437         inode = iget5_locked(sb, (unsigned long) realinode,
 438                              ovl_inode_test, ovl_inode_set, realinode);
 439         if (inode && inode->i_state & I_NEW) {
 440                 ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev);
 441                 set_nlink(inode, realinode->i_nlink);
 442                 unlock_new_inode(inode);
 443         }
 444
 445         return inode;
 446 }