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 <linux/posix_acl.h>
  14 #include "overlayfs.h"
  15
  16 int ovl_setattr(struct dentry *dentry, struct iattr *attr)
  17 {
  18         int err;
  19         struct dentry *upperdentry;
  20         const struct cred *old_cred;
  21
  22         /*
  23          * Check for permissions before trying to copy-up.  This is redundant
  24          * since it will be rechecked later by ->setattr() on upper dentry.  But
  25          * without this, copy-up can be triggered by just about anybody.
  26          *
  27          * We don't initialize inode->size, which just means that
  28          * inode_newsize_ok() will always check against MAX_LFS_FILESIZE and not
  29          * check for a swapfile (which this won't be anyway).
  30          */
  31         err = setattr_prepare(dentry, attr);
  32         if (err)
  33                 return err;
  34
  35         err = ovl_want_write(dentry);
  36         if (err)
  37                 goto out;
  38
  39         err = ovl_copy_up(dentry);
  40         if (!err) {
  41                 upperdentry = ovl_dentry_upper(dentry);
  42
  43                 if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
  44                         attr->ia_valid &= ~ATTR_MODE;
  45
  46                 inode_lock(upperdentry->d_inode);
  47                 old_cred = ovl_override_creds(dentry->d_sb);
  48                 err = notify_change(upperdentry, attr, NULL);
  49                 revert_creds(old_cred);
  50                 if (!err)
  51                         ovl_copyattr(upperdentry->d_inode, dentry->d_inode);
  52                 inode_unlock(upperdentry->d_inode);
  53         }
  54         ovl_drop_write(dentry);
  55 out:
  56         return err;
  57 }
  58
  59 static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,
  60                          struct kstat *stat)
  61 {
  62         struct path realpath;
  63         const struct cred *old_cred;
  64         int err;
  65
  66         ovl_path_real(dentry, &realpath);
  67         old_cred = ovl_override_creds(dentry->d_sb);
  68         err = vfs_getattr(&realpath, stat);
  69         revert_creds(old_cred);
  70         return err;
  71 }
  72
  73 int ovl_permission(struct inode *inode, int mask)
  74 {
  75         bool is_upper;
  76         struct inode *realinode = ovl_inode_real(inode, &is_upper);
  77         const struct cred *old_cred;
  78         int err;
  79
  80         /* Careful in RCU walk mode */
  81         if (!realinode) {
  82                 WARN_ON(!(mask & MAY_NOT_BLOCK));
  83                 return -ECHILD;
  84         }
  85
  86         /*
  87          * Check overlay inode with the creds of task and underlying inode
  88          * with creds of mounter
  89          */
  90         err = generic_permission(inode, mask);
  91         if (err)
  92                 return err;
  93
  94         old_cred = ovl_override_creds(inode->i_sb);
  95         if (!is_upper && !special_file(realinode->i_mode) && mask & MAY_WRITE) {
  96                 mask &= ~(MAY_WRITE | MAY_APPEND);
  97                 /* Make sure mounter can read file for copy up later */
  98                 mask |= MAY_READ;
  99         }
 100         err = inode_permission(realinode, mask);
 101         revert_creds(old_cred);
 102
 103         return err;
 104 }
 105
 106 static const char *ovl_get_link(struct dentry *dentry,
 107                                 struct inode *inode,
 108                                 struct delayed_call *done)
 109 {
 110         const struct cred *old_cred;
 111         const char *p;
 112
 113         if (!dentry)
 114                 return ERR_PTR(-ECHILD);
 115
 116         old_cred = ovl_override_creds(dentry->d_sb);
 117         p = vfs_get_link(ovl_dentry_real(dentry), done);
 118         revert_creds(old_cred);
 119         return p;
 120 }
 121
 122 bool ovl_is_private_xattr(const char *name)
 123 {
 124         return strncmp(name, OVL_XATTR_PREFIX,
 125                        sizeof(OVL_XATTR_PREFIX) - 1) == 0;
 126 }
 127
 128 int ovl_xattr_set(struct dentry *dentry, const char *name, const void *value,
 129                   size_t size, int flags)
 130 {
 131         int err;
 132         struct path realpath;
 133         enum ovl_path_type type = ovl_path_real(dentry, &realpath);
 134         const struct cred *old_cred;
 135
 136         err = ovl_want_write(dentry);
 137         if (err)
 138                 goto out;
 139
 140         if (!value && !OVL_TYPE_UPPER(type)) {
 141                 err = vfs_getxattr(realpath.dentry, name, NULL, 0);
 142                 if (err < 0)
 143                         goto out_drop_write;
 144         }
 145
 146         err = ovl_copy_up(dentry);
 147         if (err)
 148                 goto out_drop_write;
 149
 150         if (!OVL_TYPE_UPPER(type))
 151                 ovl_path_upper(dentry, &realpath);
 152
 153         old_cred = ovl_override_creds(dentry->d_sb);
 154         if (value)
 155                 err = vfs_setxattr(realpath.dentry, name, value, size, flags);
 156         else {
 157                 WARN_ON(flags != XATTR_REPLACE);
 158                 err = vfs_removexattr(realpath.dentry, name);
 159         }
 160         revert_creds(old_cred);
 161
 162 out_drop_write:
 163         ovl_drop_write(dentry);
 164 out:
 165         return err;
 166 }
 167
 168 int ovl_xattr_get(struct dentry *dentry, const char *name,
 169                   void *value, size_t size)
 170 {
 171         struct dentry *realdentry = ovl_dentry_real(dentry);
 172         ssize_t res;
 173         const struct cred *old_cred;
 174
 175         old_cred = ovl_override_creds(dentry->d_sb);
 176         res = vfs_getxattr(realdentry, name, value, size);
 177         revert_creds(old_cred);
 178         return res;
 179 }
 180
 181 ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
 182 {
 183         struct dentry *realdentry = ovl_dentry_real(dentry);
 184         ssize_t res;
 185         size_t len;
 186         char *s;
 187         const struct cred *old_cred;
 188
 189         old_cred = ovl_override_creds(dentry->d_sb);
 190         res = vfs_listxattr(realdentry, list, size);
 191         revert_creds(old_cred);
 192         if (res <= 0 || size == 0)
 193                 return res;
 194
 195         /* filter out private xattrs */
 196         for (s = list, len = res; len;) {
 197                 size_t slen = strnlen(s, len) + 1;
 198
 199                 /* underlying fs providing us with an broken xattr list? */
 200                 if (WARN_ON(slen > len))
 201                         return -EIO;
 202
 203                 len -= slen;
 204                 if (ovl_is_private_xattr(s)) {
 205                         res -= slen;
 206                         memmove(s, s + slen, len);
 207                 } else {
 208                         s += slen;
 209                 }
 210         }
 211
 212         return res;
 213 }
 214
 215 struct posix_acl *ovl_get_acl(struct inode *inode, int type)
 216 {
 217         struct inode *realinode = ovl_inode_real(inode, NULL);
 218         const struct cred *old_cred;
 219         struct posix_acl *acl;
 220
 221         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode))
 222                 return NULL;
 223
 224         old_cred = ovl_override_creds(inode->i_sb);
 225         acl = get_acl(realinode, type);
 226         revert_creds(old_cred);
 227
 228         return acl;
 229 }
 230
 231 static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
 232                                   struct dentry *realdentry)
 233 {
 234         if (OVL_TYPE_UPPER(type))
 235                 return false;
 236
 237         if (special_file(realdentry->d_inode->i_mode))
 238                 return false;
 239
 240         if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
 241                 return false;
 242
 243         return true;
 244 }
 245
 246 int ovl_open_maybe_copy_up(struct dentry *dentry, unsigned int file_flags)
 247 {
 248         int err = 0;
 249         struct path realpath;
 250         enum ovl_path_type type;
 251
 252         type = ovl_path_real(dentry, &realpath);
 253         if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) {
 254                 err = ovl_want_write(dentry);
 255                 if (!err) {
 256                         err = ovl_copy_up_flags(dentry, file_flags);
 257                         ovl_drop_write(dentry);
 258                 }
 259         }
 260
 261         return err;
 262 }
 263
 264 int ovl_update_time(struct inode *inode, struct timespec *ts, int flags)
 265 {
 266         struct dentry *alias;
 267         struct path upperpath;
 268
 269         if (!(flags & S_ATIME))
 270                 return 0;
 271
 272         alias = d_find_any_alias(inode);
 273         if (!alias)
 274                 return 0;
 275
 276         ovl_path_upper(alias, &upperpath);
 277         if (upperpath.dentry) {
 278                 touch_atime(&upperpath);
 279                 inode->i_atime = d_inode(upperpath.dentry)->i_atime;
 280         }
 281
 282         dput(alias);
 283
 284         return 0;
 285 }
 286
 287 static const struct inode_operations ovl_file_inode_operations = {
 288         .setattr        = ovl_setattr,
 289         .permission     = ovl_permission,
 290         .getattr        = ovl_getattr,
 291         .listxattr      = ovl_listxattr,
 292         .get_acl        = ovl_get_acl,
 293         .update_time    = ovl_update_time,
 294 };
 295
 296 static const struct inode_operations ovl_symlink_inode_operations = {
 297         .setattr        = ovl_setattr,
 298         .get_link       = ovl_get_link,
 299         .getattr        = ovl_getattr,
 300         .listxattr      = ovl_listxattr,
 301         .update_time    = ovl_update_time,
 302 };
 303
 304 static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev)
 305 {
 306         inode->i_ino = get_next_ino();
 307         inode->i_mode = mode;
 308         inode->i_flags |= S_NOCMTIME;
 309 #ifdef CONFIG_FS_POSIX_ACL
 310         inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE;
 311 #endif
 312
 313         switch (mode & S_IFMT) {
 314         case S_IFREG:
 315                 inode->i_op = &ovl_file_inode_operations;
 316                 break;
 317
 318         case S_IFDIR:
 319                 inode->i_op = &ovl_dir_inode_operations;
 320                 inode->i_fop = &ovl_dir_operations;
 321                 break;
 322
 323         case S_IFLNK:
 324                 inode->i_op = &ovl_symlink_inode_operations;
 325                 break;
 326
 327         default:
 328                 inode->i_op = &ovl_file_inode_operations;
 329                 init_special_inode(inode, mode, rdev);
 330                 break;
 331         }
 332 }
 333
 334 struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev)
 335 {
 336         struct inode *inode;
 337
 338         inode = new_inode(sb);
 339         if (inode)
 340                 ovl_fill_inode(inode, mode, rdev);
 341
 342         return inode;
 343 }
 344
 345 static int ovl_inode_test(struct inode *inode, void *data)
 346 {
 347         return ovl_inode_real(inode, NULL) == data;
 348 }
 349
 350 static int ovl_inode_set(struct inode *inode, void *data)
 351 {
 352         inode->i_private = (void *) (((unsigned long) data) | OVL_ISUPPER_MASK);
 353         return 0;
 354 }
 355
 356 struct inode *ovl_get_inode(struct super_block *sb, struct inode *realinode)
 357
 358 {
 359         struct inode *inode;
 360
 361         inode = iget5_locked(sb, (unsigned long) realinode,
 362                              ovl_inode_test, ovl_inode_set, realinode);
 363         if (inode && inode->i_state & I_NEW) {
 364                 ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev);
 365                 set_nlink(inode, realinode->i_nlink);
 366                 unlock_new_inode(inode);
 367         }
 368
 369         return inode;
 370 }