1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * fs/kernfs/inode.c - kernfs inode implementation 4 * 5 * Copyright (c) 2001-3 Patrick Mochel 6 * Copyright (c) 2007 SUSE Linux Products GmbH 7 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 8 */ 9 10 #include <linux/pagemap.h> 11 #include <linux/backing-dev.h> 12 #include <linux/capability.h> 13 #include <linux/errno.h> 14 #include <linux/slab.h> 15 #include <linux/xattr.h> 16 #include <linux/security.h> 17 18 #include "kernfs-internal.h" 19 20 static const struct address_space_operations kernfs_aops = { 21 .readpage = simple_readpage, 22 .write_begin = simple_write_begin, 23 .write_end = simple_write_end, 24 }; 25 26 static const struct inode_operations kernfs_iops = { 27 .permission = kernfs_iop_permission, 28 .setattr = kernfs_iop_setattr, 29 .getattr = kernfs_iop_getattr, 30 .listxattr = kernfs_iop_listxattr, 31 }; 32 33 static struct kernfs_iattrs *__kernfs_iattrs(struct kernfs_node *kn, int alloc) 34 { 35 static DEFINE_MUTEX(iattr_mutex); 36 struct kernfs_iattrs *ret; 37 38 mutex_lock(&iattr_mutex); 39 40 if (kn->iattr || !alloc) 41 goto out_unlock; 42 43 kn->iattr = kmem_cache_zalloc(kernfs_iattrs_cache, GFP_KERNEL); 44 if (!kn->iattr) 45 goto out_unlock; 46 47 /* assign default attributes */ 48 kn->iattr->ia_uid = GLOBAL_ROOT_UID; 49 kn->iattr->ia_gid = GLOBAL_ROOT_GID; 50 51 ktime_get_real_ts64(&kn->iattr->ia_atime); 52 kn->iattr->ia_mtime = kn->iattr->ia_atime; 53 kn->iattr->ia_ctime = kn->iattr->ia_atime; 54 55 simple_xattrs_init(&kn->iattr->xattrs); 56 atomic_set(&kn->iattr->nr_user_xattrs, 0); 57 atomic_set(&kn->iattr->user_xattr_size, 0); 58 out_unlock: 59 ret = kn->iattr; 60 mutex_unlock(&iattr_mutex); 61 return ret; 62 } 63 64 static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn) 65 { 66 return __kernfs_iattrs(kn, 1); 67 } 68 69 static struct kernfs_iattrs *kernfs_iattrs_noalloc(struct kernfs_node *kn) 70 { 71 return __kernfs_iattrs(kn, 0); 72 } 73 74 int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) 75 { 76 struct kernfs_iattrs *attrs; 77 unsigned int ia_valid = iattr->ia_valid; 78 79 attrs = kernfs_iattrs(kn); 80 if (!attrs) 81 return -ENOMEM; 82 83 if (ia_valid & ATTR_UID) 84 attrs->ia_uid = iattr->ia_uid; 85 if (ia_valid & ATTR_GID) 86 attrs->ia_gid = iattr->ia_gid; 87 if (ia_valid & ATTR_ATIME) 88 attrs->ia_atime = iattr->ia_atime; 89 if (ia_valid & ATTR_MTIME) 90 attrs->ia_mtime = iattr->ia_mtime; 91 if (ia_valid & ATTR_CTIME) 92 attrs->ia_ctime = iattr->ia_ctime; 93 if (ia_valid & ATTR_MODE) 94 kn->mode = iattr->ia_mode; 95 return 0; 96 } 97 98 /** 99 * kernfs_setattr - set iattr on a node 100 * @kn: target node 101 * @iattr: iattr to set 102 * 103 * Returns 0 on success, -errno on failure. 104 */ 105 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) 106 { 107 int ret; 108 109 mutex_lock(&kernfs_mutex); 110 ret = __kernfs_setattr(kn, iattr); 111 mutex_unlock(&kernfs_mutex); 112 return ret; 113 } 114 115 int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr) 116 { 117 struct inode *inode = d_inode(dentry); 118 struct kernfs_node *kn = inode->i_private; 119 int error; 120 121 if (!kn) 122 return -EINVAL; 123 124 mutex_lock(&kernfs_mutex); 125 error = setattr_prepare(dentry, iattr); 126 if (error) 127 goto out; 128 129 error = __kernfs_setattr(kn, iattr); 130 if (error) 131 goto out; 132 133 /* this ignores size changes */ 134 setattr_copy(inode, iattr); 135 136 out: 137 mutex_unlock(&kernfs_mutex); 138 return error; 139 } 140 141 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size) 142 { 143 struct kernfs_node *kn = kernfs_dentry_node(dentry); 144 struct kernfs_iattrs *attrs; 145 146 attrs = kernfs_iattrs(kn); 147 if (!attrs) 148 return -ENOMEM; 149 150 return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size); 151 } 152 153 static inline void set_default_inode_attr(struct inode *inode, umode_t mode) 154 { 155 inode->i_mode = mode; 156 inode->i_atime = inode->i_mtime = 157 inode->i_ctime = current_time(inode); 158 } 159 160 static inline void set_inode_attr(struct inode *inode, 161 struct kernfs_iattrs *attrs) 162 { 163 inode->i_uid = attrs->ia_uid; 164 inode->i_gid = attrs->ia_gid; 165 inode->i_atime = attrs->ia_atime; 166 inode->i_mtime = attrs->ia_mtime; 167 inode->i_ctime = attrs->ia_ctime; 168 } 169 170 static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode) 171 { 172 struct kernfs_iattrs *attrs = kn->iattr; 173 174 inode->i_mode = kn->mode; 175 if (attrs) 176 /* 177 * kernfs_node has non-default attributes get them from 178 * persistent copy in kernfs_node. 179 */ 180 set_inode_attr(inode, attrs); 181 182 if (kernfs_type(kn) == KERNFS_DIR) 183 set_nlink(inode, kn->dir.subdirs + 2); 184 } 185 186 int kernfs_iop_getattr(const struct path *path, struct kstat *stat, 187 u32 request_mask, unsigned int query_flags) 188 { 189 struct inode *inode = d_inode(path->dentry); 190 struct kernfs_node *kn = inode->i_private; 191 192 mutex_lock(&kernfs_mutex); 193 kernfs_refresh_inode(kn, inode); 194 mutex_unlock(&kernfs_mutex); 195 196 generic_fillattr(inode, stat); 197 return 0; 198 } 199 200 static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode) 201 { 202 kernfs_get(kn); 203 inode->i_private = kn; 204 inode->i_mapping->a_ops = &kernfs_aops; 205 inode->i_op = &kernfs_iops; 206 inode->i_generation = kernfs_gen(kn); 207 208 set_default_inode_attr(inode, kn->mode); 209 kernfs_refresh_inode(kn, inode); 210 211 /* initialize inode according to type */ 212 switch (kernfs_type(kn)) { 213 case KERNFS_DIR: 214 inode->i_op = &kernfs_dir_iops; 215 inode->i_fop = &kernfs_dir_fops; 216 if (kn->flags & KERNFS_EMPTY_DIR) 217 make_empty_dir_inode(inode); 218 break; 219 case KERNFS_FILE: 220 inode->i_size = kn->attr.size; 221 inode->i_fop = &kernfs_file_fops; 222 break; 223 case KERNFS_LINK: 224 inode->i_op = &kernfs_symlink_iops; 225 break; 226 default: 227 BUG(); 228 } 229 230 unlock_new_inode(inode); 231 } 232 233 /** 234 * kernfs_get_inode - get inode for kernfs_node 235 * @sb: super block 236 * @kn: kernfs_node to allocate inode for 237 * 238 * Get inode for @kn. If such inode doesn't exist, a new inode is 239 * allocated and basics are initialized. New inode is returned 240 * locked. 241 * 242 * LOCKING: 243 * Kernel thread context (may sleep). 244 * 245 * RETURNS: 246 * Pointer to allocated inode on success, NULL on failure. 247 */ 248 struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn) 249 { 250 struct inode *inode; 251 252 inode = iget_locked(sb, kernfs_ino(kn)); 253 if (inode && (inode->i_state & I_NEW)) 254 kernfs_init_inode(kn, inode); 255 256 return inode; 257 } 258 259 /* 260 * The kernfs_node serves as both an inode and a directory entry for 261 * kernfs. To prevent the kernfs inode numbers from being freed 262 * prematurely we take a reference to kernfs_node from the kernfs inode. A 263 * super_operations.evict_inode() implementation is needed to drop that 264 * reference upon inode destruction. 265 */ 266 void kernfs_evict_inode(struct inode *inode) 267 { 268 struct kernfs_node *kn = inode->i_private; 269 270 truncate_inode_pages_final(&inode->i_data); 271 clear_inode(inode); 272 kernfs_put(kn); 273 } 274 275 int kernfs_iop_permission(struct inode *inode, int mask) 276 { 277 struct kernfs_node *kn; 278 279 if (mask & MAY_NOT_BLOCK) 280 return -ECHILD; 281 282 kn = inode->i_private; 283 284 mutex_lock(&kernfs_mutex); 285 kernfs_refresh_inode(kn, inode); 286 mutex_unlock(&kernfs_mutex); 287 288 return generic_permission(inode, mask); 289 } 290 291 int kernfs_xattr_get(struct kernfs_node *kn, const char *name, 292 void *value, size_t size) 293 { 294 struct kernfs_iattrs *attrs = kernfs_iattrs_noalloc(kn); 295 if (!attrs) 296 return -ENODATA; 297 298 return simple_xattr_get(&attrs->xattrs, name, value, size); 299 } 300 301 int kernfs_xattr_set(struct kernfs_node *kn, const char *name, 302 const void *value, size_t size, int flags) 303 { 304 struct kernfs_iattrs *attrs = kernfs_iattrs(kn); 305 if (!attrs) 306 return -ENOMEM; 307 308 return simple_xattr_set(&attrs->xattrs, name, value, size, flags, NULL); 309 } 310 311 static int kernfs_vfs_xattr_get(const struct xattr_handler *handler, 312 struct dentry *unused, struct inode *inode, 313 const char *suffix, void *value, size_t size) 314 { 315 const char *name = xattr_full_name(handler, suffix); 316 struct kernfs_node *kn = inode->i_private; 317 318 return kernfs_xattr_get(kn, name, value, size); 319 } 320 321 static int kernfs_vfs_xattr_set(const struct xattr_handler *handler, 322 struct dentry *unused, struct inode *inode, 323 const char *suffix, const void *value, 324 size_t size, int flags) 325 { 326 const char *name = xattr_full_name(handler, suffix); 327 struct kernfs_node *kn = inode->i_private; 328 329 return kernfs_xattr_set(kn, name, value, size, flags); 330 } 331 332 static int kernfs_vfs_user_xattr_add(struct kernfs_node *kn, 333 const char *full_name, 334 struct simple_xattrs *xattrs, 335 const void *value, size_t size, int flags) 336 { 337 atomic_t *sz = &kn->iattr->user_xattr_size; 338 atomic_t *nr = &kn->iattr->nr_user_xattrs; 339 ssize_t removed_size; 340 int ret; 341 342 if (atomic_inc_return(nr) > KERNFS_MAX_USER_XATTRS) { 343 ret = -ENOSPC; 344 goto dec_count_out; 345 } 346 347 if (atomic_add_return(size, sz) > KERNFS_USER_XATTR_SIZE_LIMIT) { 348 ret = -ENOSPC; 349 goto dec_size_out; 350 } 351 352 ret = simple_xattr_set(xattrs, full_name, value, size, flags, 353 &removed_size); 354 355 if (!ret && removed_size >= 0) 356 size = removed_size; 357 else if (!ret) 358 return 0; 359 dec_size_out: 360 atomic_sub(size, sz); 361 dec_count_out: 362 atomic_dec(nr); 363 return ret; 364 } 365 366 static int kernfs_vfs_user_xattr_rm(struct kernfs_node *kn, 367 const char *full_name, 368 struct simple_xattrs *xattrs, 369 const void *value, size_t size, int flags) 370 { 371 atomic_t *sz = &kn->iattr->user_xattr_size; 372 atomic_t *nr = &kn->iattr->nr_user_xattrs; 373 ssize_t removed_size; 374 int ret; 375 376 ret = simple_xattr_set(xattrs, full_name, value, size, flags, 377 &removed_size); 378 379 if (removed_size >= 0) { 380 atomic_sub(removed_size, sz); 381 atomic_dec(nr); 382 } 383 384 return ret; 385 } 386 387 static int kernfs_vfs_user_xattr_set(const struct xattr_handler *handler, 388 struct dentry *unused, struct inode *inode, 389 const char *suffix, const void *value, 390 size_t size, int flags) 391 { 392 const char *full_name = xattr_full_name(handler, suffix); 393 struct kernfs_node *kn = inode->i_private; 394 struct kernfs_iattrs *attrs; 395 396 if (!(kernfs_root(kn)->flags & KERNFS_ROOT_SUPPORT_USER_XATTR)) 397 return -EOPNOTSUPP; 398 399 attrs = kernfs_iattrs(kn); 400 if (!attrs) 401 return -ENOMEM; 402 403 if (value) 404 return kernfs_vfs_user_xattr_add(kn, full_name, &attrs->xattrs, 405 value, size, flags); 406 else 407 return kernfs_vfs_user_xattr_rm(kn, full_name, &attrs->xattrs, 408 value, size, flags); 409 410 } 411 412 static const struct xattr_handler kernfs_trusted_xattr_handler = { 413 .prefix = XATTR_TRUSTED_PREFIX, 414 .get = kernfs_vfs_xattr_get, 415 .set = kernfs_vfs_xattr_set, 416 }; 417 418 static const struct xattr_handler kernfs_security_xattr_handler = { 419 .prefix = XATTR_SECURITY_PREFIX, 420 .get = kernfs_vfs_xattr_get, 421 .set = kernfs_vfs_xattr_set, 422 }; 423 424 static const struct xattr_handler kernfs_user_xattr_handler = { 425 .prefix = XATTR_USER_PREFIX, 426 .get = kernfs_vfs_xattr_get, 427 .set = kernfs_vfs_user_xattr_set, 428 }; 429 430 const struct xattr_handler *kernfs_xattr_handlers[] = { 431 &kernfs_trusted_xattr_handler, 432 &kernfs_security_xattr_handler, 433 &kernfs_user_xattr_handler, 434 NULL 435 }; 436