fs/kernfs/inode.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * fs/kernfs/inode.c - kernfs inode implementation
0004  *
0005  * Copyright (c) 2001-3 Patrick Mochel
0006  * Copyright (c) 2007 SUSE Linux Products GmbH
0007  * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
0008  */
0009
0010 #include <linux/pagemap.h>
0011 #include <linux/backing-dev.h>
0012 #include <linux/capability.h>
0013 #include <linux/errno.h>
0014 #include <linux/slab.h>
0015 #include <linux/xattr.h>
0016 #include <linux/security.h>
0017
0018 #include "kernfs-internal.h"
0019
0020 static const struct inode_operations kernfs_iops = {
0021     .permission = kernfs_iop_permission,
0022     .setattr    = kernfs_iop_setattr,
0023     .getattr    = kernfs_iop_getattr,
0024     .listxattr  = kernfs_iop_listxattr,
0025 };
0026
0027 static struct kernfs_iattrs *__kernfs_iattrs(struct kernfs_node *kn, int alloc)
0028 {
0029     static DEFINE_MUTEX(iattr_mutex);
0030     struct kernfs_iattrs *ret;
0031
0032     mutex_lock(&iattr_mutex);
0033
0034     if (kn->iattr || !alloc)
0035         goto out_unlock;
0036
0037     kn->iattr = kmem_cache_zalloc(kernfs_iattrs_cache, GFP_KERNEL);
0038     if (!kn->iattr)
0039         goto out_unlock;
0040
0041     /* assign default attributes */
0042     kn->iattr->ia_uid = GLOBAL_ROOT_UID;
0043     kn->iattr->ia_gid = GLOBAL_ROOT_GID;
0044
0045     ktime_get_real_ts64(&kn->iattr->ia_atime);
0046     kn->iattr->ia_mtime = kn->iattr->ia_atime;
0047     kn->iattr->ia_ctime = kn->iattr->ia_atime;
0048
0049     simple_xattrs_init(&kn->iattr->xattrs);
0050     atomic_set(&kn->iattr->nr_user_xattrs, 0);
0051     atomic_set(&kn->iattr->user_xattr_size, 0);
0052 out_unlock:
0053     ret = kn->iattr;
0054     mutex_unlock(&iattr_mutex);
0055     return ret;
0056 }
0057
0058 static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn)
0059 {
0060     return __kernfs_iattrs(kn, 1);
0061 }
0062
0063 static struct kernfs_iattrs *kernfs_iattrs_noalloc(struct kernfs_node *kn)
0064 {
0065     return __kernfs_iattrs(kn, 0);
0066 }
0067
0068 int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
0069 {
0070     struct kernfs_iattrs *attrs;
0071     unsigned int ia_valid = iattr->ia_valid;
0072
0073     attrs = kernfs_iattrs(kn);
0074     if (!attrs)
0075         return -ENOMEM;
0076
0077     if (ia_valid & ATTR_UID)
0078         attrs->ia_uid = iattr->ia_uid;
0079     if (ia_valid & ATTR_GID)
0080         attrs->ia_gid = iattr->ia_gid;
0081     if (ia_valid & ATTR_ATIME)
0082         attrs->ia_atime = iattr->ia_atime;
0083     if (ia_valid & ATTR_MTIME)
0084         attrs->ia_mtime = iattr->ia_mtime;
0085     if (ia_valid & ATTR_CTIME)
0086         attrs->ia_ctime = iattr->ia_ctime;
0087     if (ia_valid & ATTR_MODE)
0088         kn->mode = iattr->ia_mode;
0089     return 0;
0090 }
0091
0092 /**
0093  * kernfs_setattr - set iattr on a node
0094  * @kn: target node
0095  * @iattr: iattr to set
0096  *
0097  * Returns 0 on success, -errno on failure.
0098  */
0099 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
0100 {
0101     int ret;
0102     struct kernfs_root *root = kernfs_root(kn);
0103
0104     down_write(&root->kernfs_rwsem);
0105     ret = __kernfs_setattr(kn, iattr);
0106     up_write(&root->kernfs_rwsem);
0107     return ret;
0108 }
0109
0110 int kernfs_iop_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
0111                struct iattr *iattr)
0112 {
0113     struct inode *inode = d_inode(dentry);
0114     struct kernfs_node *kn = inode->i_private;
0115     struct kernfs_root *root;
0116     int error;
0117
0118     if (!kn)
0119         return -EINVAL;
0120
0121     root = kernfs_root(kn);
0122     down_write(&root->kernfs_rwsem);
0123     error = setattr_prepare(&init_user_ns, dentry, iattr);
0124     if (error)
0125         goto out;
0126
0127     error = __kernfs_setattr(kn, iattr);
0128     if (error)
0129         goto out;
0130
0131     /* this ignores size changes */
0132     setattr_copy(&init_user_ns, inode, iattr);
0133
0134 out:
0135     up_write(&root->kernfs_rwsem);
0136     return error;
0137 }
0138
0139 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size)
0140 {
0141     struct kernfs_node *kn = kernfs_dentry_node(dentry);
0142     struct kernfs_iattrs *attrs;
0143
0144     attrs = kernfs_iattrs(kn);
0145     if (!attrs)
0146         return -ENOMEM;
0147
0148     return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size);
0149 }
0150
0151 static inline void set_default_inode_attr(struct inode *inode, umode_t mode)
0152 {
0153     inode->i_mode = mode;
0154     inode->i_atime = inode->i_mtime =
0155         inode->i_ctime = current_time(inode);
0156 }
0157
0158 static inline void set_inode_attr(struct inode *inode,
0159                   struct kernfs_iattrs *attrs)
0160 {
0161     inode->i_uid = attrs->ia_uid;
0162     inode->i_gid = attrs->ia_gid;
0163     inode->i_atime = attrs->ia_atime;
0164     inode->i_mtime = attrs->ia_mtime;
0165     inode->i_ctime = attrs->ia_ctime;
0166 }
0167
0168 static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
0169 {
0170     struct kernfs_iattrs *attrs = kn->iattr;
0171
0172     inode->i_mode = kn->mode;
0173     if (attrs)
0174         /*
0175          * kernfs_node has non-default attributes get them from
0176          * persistent copy in kernfs_node.
0177          */
0178         set_inode_attr(inode, attrs);
0179
0180     if (kernfs_type(kn) == KERNFS_DIR)
0181         set_nlink(inode, kn->dir.subdirs + 2);
0182 }
0183
0184 int kernfs_iop_getattr(struct user_namespace *mnt_userns,
0185                const struct path *path, struct kstat *stat,
0186                u32 request_mask, unsigned int query_flags)
0187 {
0188     struct inode *inode = d_inode(path->dentry);
0189     struct kernfs_node *kn = inode->i_private;
0190     struct kernfs_root *root = kernfs_root(kn);
0191
0192     down_read(&root->kernfs_rwsem);
0193     spin_lock(&inode->i_lock);
0194     kernfs_refresh_inode(kn, inode);
0195     generic_fillattr(&init_user_ns, inode, stat);
0196     spin_unlock(&inode->i_lock);
0197     up_read(&root->kernfs_rwsem);
0198
0199     return 0;
0200 }
0201
0202 static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode)
0203 {
0204     kernfs_get(kn);
0205     inode->i_private = kn;
0206     inode->i_mapping->a_ops = &ram_aops;
0207     inode->i_op = &kernfs_iops;
0208     inode->i_generation = kernfs_gen(kn);
0209
0210     set_default_inode_attr(inode, kn->mode);
0211     kernfs_refresh_inode(kn, inode);
0212
0213     /* initialize inode according to type */
0214     switch (kernfs_type(kn)) {
0215     case KERNFS_DIR:
0216         inode->i_op = &kernfs_dir_iops;
0217         inode->i_fop = &kernfs_dir_fops;
0218         if (kn->flags & KERNFS_EMPTY_DIR)
0219             make_empty_dir_inode(inode);
0220         break;
0221     case KERNFS_FILE:
0222         inode->i_size = kn->attr.size;
0223         inode->i_fop = &kernfs_file_fops;
0224         break;
0225     case KERNFS_LINK:
0226         inode->i_op = &kernfs_symlink_iops;
0227         break;
0228     default:
0229         BUG();
0230     }
0231
0232     unlock_new_inode(inode);
0233 }
0234
0235 /**
0236  *  kernfs_get_inode - get inode for kernfs_node
0237  *  @sb: super block
0238  *  @kn: kernfs_node to allocate inode for
0239  *
0240  *  Get inode for @kn.  If such inode doesn't exist, a new inode is
0241  *  allocated and basics are initialized.  New inode is returned
0242  *  locked.
0243  *
0244  *  LOCKING:
0245  *  Kernel thread context (may sleep).
0246  *
0247  *  RETURNS:
0248  *  Pointer to allocated inode on success, NULL on failure.
0249  */
0250 struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
0251 {
0252     struct inode *inode;
0253
0254     inode = iget_locked(sb, kernfs_ino(kn));
0255     if (inode && (inode->i_state & I_NEW))
0256         kernfs_init_inode(kn, inode);
0257
0258     return inode;
0259 }
0260
0261 /*
0262  * The kernfs_node serves as both an inode and a directory entry for
0263  * kernfs.  To prevent the kernfs inode numbers from being freed
0264  * prematurely we take a reference to kernfs_node from the kernfs inode.  A
0265  * super_operations.evict_inode() implementation is needed to drop that
0266  * reference upon inode destruction.
0267  */
0268 void kernfs_evict_inode(struct inode *inode)
0269 {
0270     struct kernfs_node *kn = inode->i_private;
0271
0272     truncate_inode_pages_final(&inode->i_data);
0273     clear_inode(inode);
0274     kernfs_put(kn);
0275 }
0276
0277 int kernfs_iop_permission(struct user_namespace *mnt_userns,
0278               struct inode *inode, int mask)
0279 {
0280     struct kernfs_node *kn;
0281     struct kernfs_root *root;
0282     int ret;
0283
0284     if (mask & MAY_NOT_BLOCK)
0285         return -ECHILD;
0286
0287     kn = inode->i_private;
0288     root = kernfs_root(kn);
0289
0290     down_read(&root->kernfs_rwsem);
0291     spin_lock(&inode->i_lock);
0292     kernfs_refresh_inode(kn, inode);
0293     ret = generic_permission(&init_user_ns, inode, mask);
0294     spin_unlock(&inode->i_lock);
0295     up_read(&root->kernfs_rwsem);
0296
0297     return ret;
0298 }
0299
0300 int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
0301              void *value, size_t size)
0302 {
0303     struct kernfs_iattrs *attrs = kernfs_iattrs_noalloc(kn);
0304     if (!attrs)
0305         return -ENODATA;
0306
0307     return simple_xattr_get(&attrs->xattrs, name, value, size);
0308 }
0309
0310 int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
0311              const void *value, size_t size, int flags)
0312 {
0313     struct kernfs_iattrs *attrs = kernfs_iattrs(kn);
0314     if (!attrs)
0315         return -ENOMEM;
0316
0317     return simple_xattr_set(&attrs->xattrs, name, value, size, flags, NULL);
0318 }
0319
0320 static int kernfs_vfs_xattr_get(const struct xattr_handler *handler,
0321                 struct dentry *unused, struct inode *inode,
0322                 const char *suffix, void *value, size_t size)
0323 {
0324     const char *name = xattr_full_name(handler, suffix);
0325     struct kernfs_node *kn = inode->i_private;
0326
0327     return kernfs_xattr_get(kn, name, value, size);
0328 }
0329
0330 static int kernfs_vfs_xattr_set(const struct xattr_handler *handler,
0331                 struct user_namespace *mnt_userns,
0332                 struct dentry *unused, struct inode *inode,
0333                 const char *suffix, const void *value,
0334                 size_t size, int flags)
0335 {
0336     const char *name = xattr_full_name(handler, suffix);
0337     struct kernfs_node *kn = inode->i_private;
0338
0339     return kernfs_xattr_set(kn, name, value, size, flags);
0340 }
0341
0342 static int kernfs_vfs_user_xattr_add(struct kernfs_node *kn,
0343                      const char *full_name,
0344                      struct simple_xattrs *xattrs,
0345                      const void *value, size_t size, int flags)
0346 {
0347     atomic_t *sz = &kn->iattr->user_xattr_size;
0348     atomic_t *nr = &kn->iattr->nr_user_xattrs;
0349     ssize_t removed_size;
0350     int ret;
0351
0352     if (atomic_inc_return(nr) > KERNFS_MAX_USER_XATTRS) {
0353         ret = -ENOSPC;
0354         goto dec_count_out;
0355     }
0356
0357     if (atomic_add_return(size, sz) > KERNFS_USER_XATTR_SIZE_LIMIT) {
0358         ret = -ENOSPC;
0359         goto dec_size_out;
0360     }
0361
0362     ret = simple_xattr_set(xattrs, full_name, value, size, flags,
0363                    &removed_size);
0364
0365     if (!ret && removed_size >= 0)
0366         size = removed_size;
0367     else if (!ret)
0368         return 0;
0369 dec_size_out:
0370     atomic_sub(size, sz);
0371 dec_count_out:
0372     atomic_dec(nr);
0373     return ret;
0374 }
0375
0376 static int kernfs_vfs_user_xattr_rm(struct kernfs_node *kn,
0377                     const char *full_name,
0378                     struct simple_xattrs *xattrs,
0379                     const void *value, size_t size, int flags)
0380 {
0381     atomic_t *sz = &kn->iattr->user_xattr_size;
0382     atomic_t *nr = &kn->iattr->nr_user_xattrs;
0383     ssize_t removed_size;
0384     int ret;
0385
0386     ret = simple_xattr_set(xattrs, full_name, value, size, flags,
0387                    &removed_size);
0388
0389     if (removed_size >= 0) {
0390         atomic_sub(removed_size, sz);
0391         atomic_dec(nr);
0392     }
0393
0394     return ret;
0395 }
0396
0397 static int kernfs_vfs_user_xattr_set(const struct xattr_handler *handler,
0398                      struct user_namespace *mnt_userns,
0399                      struct dentry *unused, struct inode *inode,
0400                      const char *suffix, const void *value,
0401                      size_t size, int flags)
0402 {
0403     const char *full_name = xattr_full_name(handler, suffix);
0404     struct kernfs_node *kn = inode->i_private;
0405     struct kernfs_iattrs *attrs;
0406
0407     if (!(kernfs_root(kn)->flags & KERNFS_ROOT_SUPPORT_USER_XATTR))
0408         return -EOPNOTSUPP;
0409
0410     attrs = kernfs_iattrs(kn);
0411     if (!attrs)
0412         return -ENOMEM;
0413
0414     if (value)
0415         return kernfs_vfs_user_xattr_add(kn, full_name, &attrs->xattrs,
0416                          value, size, flags);
0417     else
0418         return kernfs_vfs_user_xattr_rm(kn, full_name, &attrs->xattrs,
0419                         value, size, flags);
0420
0421 }
0422
0423 static const struct xattr_handler kernfs_trusted_xattr_handler = {
0424     .prefix = XATTR_TRUSTED_PREFIX,
0425     .get = kernfs_vfs_xattr_get,
0426     .set = kernfs_vfs_xattr_set,
0427 };
0428
0429 static const struct xattr_handler kernfs_security_xattr_handler = {
0430     .prefix = XATTR_SECURITY_PREFIX,
0431     .get = kernfs_vfs_xattr_get,
0432     .set = kernfs_vfs_xattr_set,
0433 };
0434
0435 static const struct xattr_handler kernfs_user_xattr_handler = {
0436     .prefix = XATTR_USER_PREFIX,
0437     .get = kernfs_vfs_xattr_get,
0438     .set = kernfs_vfs_user_xattr_set,
0439 };
0440
0441 const struct xattr_handler *kernfs_xattr_handlers[] = {
0442     &kernfs_trusted_xattr_handler,
0443     &kernfs_security_xattr_handler,
0444     &kernfs_user_xattr_handler,
0445     NULL
0446 };