1 /* 2 * fs/kernfs/inode.c - kernfs inode implementation 3 * 4 * Copyright (c) 2001-3 Patrick Mochel 5 * Copyright (c) 2007 SUSE Linux Products GmbH 6 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 7 * 8 * This file is released under the GPLv2. 9 */ 10 11 #include <linux/pagemap.h> 12 #include <linux/backing-dev.h> 13 #include <linux/capability.h> 14 #include <linux/errno.h> 15 #include <linux/slab.h> 16 #include <linux/xattr.h> 17 #include <linux/security.h> 18 19 #include "kernfs-internal.h" 20 21 static const struct address_space_operations kernfs_aops = { 22 .readpage = simple_readpage, 23 .write_begin = simple_write_begin, 24 .write_end = simple_write_end, 25 }; 26 27 static struct backing_dev_info kernfs_bdi = { 28 .name = "kernfs", 29 .ra_pages = 0, /* No readahead */ 30 .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK, 31 }; 32 33 static const struct inode_operations kernfs_iops = { 34 .permission = kernfs_iop_permission, 35 .setattr = kernfs_iop_setattr, 36 .getattr = kernfs_iop_getattr, 37 .setxattr = kernfs_iop_setxattr, 38 .removexattr = kernfs_iop_removexattr, 39 .getxattr = kernfs_iop_getxattr, 40 .listxattr = kernfs_iop_listxattr, 41 }; 42 43 void __init kernfs_inode_init(void) 44 { 45 if (bdi_init(&kernfs_bdi)) 46 panic("failed to init kernfs_bdi"); 47 } 48 49 static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn) 50 { 51 static DEFINE_MUTEX(iattr_mutex); 52 struct kernfs_iattrs *ret; 53 struct iattr *iattrs; 54 55 mutex_lock(&iattr_mutex); 56 57 if (kn->iattr) 58 goto out_unlock; 59 60 kn->iattr = kzalloc(sizeof(struct kernfs_iattrs), GFP_KERNEL); 61 if (!kn->iattr) 62 goto out_unlock; 63 iattrs = &kn->iattr->ia_iattr; 64 65 /* assign default attributes */ 66 iattrs->ia_mode = kn->mode; 67 iattrs->ia_uid = GLOBAL_ROOT_UID; 68 iattrs->ia_gid = GLOBAL_ROOT_GID; 69 iattrs->ia_atime = iattrs->ia_mtime = iattrs->ia_ctime = CURRENT_TIME; 70 71 simple_xattrs_init(&kn->iattr->xattrs); 72 out_unlock: 73 ret = kn->iattr; 74 mutex_unlock(&iattr_mutex); 75 return ret; 76 } 77 78 static int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) 79 { 80 struct kernfs_iattrs *attrs; 81 struct iattr *iattrs; 82 unsigned int ia_valid = iattr->ia_valid; 83 84 attrs = kernfs_iattrs(kn); 85 if (!attrs) 86 return -ENOMEM; 87 88 iattrs = &attrs->ia_iattr; 89 90 if (ia_valid & ATTR_UID) 91 iattrs->ia_uid = iattr->ia_uid; 92 if (ia_valid & ATTR_GID) 93 iattrs->ia_gid = iattr->ia_gid; 94 if (ia_valid & ATTR_ATIME) 95 iattrs->ia_atime = iattr->ia_atime; 96 if (ia_valid & ATTR_MTIME) 97 iattrs->ia_mtime = iattr->ia_mtime; 98 if (ia_valid & ATTR_CTIME) 99 iattrs->ia_ctime = iattr->ia_ctime; 100 if (ia_valid & ATTR_MODE) { 101 umode_t mode = iattr->ia_mode; 102 iattrs->ia_mode = kn->mode = mode; 103 } 104 return 0; 105 } 106 107 /** 108 * kernfs_setattr - set iattr on a node 109 * @kn: target node 110 * @iattr: iattr to set 111 * 112 * Returns 0 on success, -errno on failure. 113 */ 114 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) 115 { 116 int ret; 117 118 mutex_lock(&kernfs_mutex); 119 ret = __kernfs_setattr(kn, iattr); 120 mutex_unlock(&kernfs_mutex); 121 return ret; 122 } 123 124 int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr) 125 { 126 struct inode *inode = dentry->d_inode; 127 struct kernfs_node *kn = dentry->d_fsdata; 128 int error; 129 130 if (!kn) 131 return -EINVAL; 132 133 mutex_lock(&kernfs_mutex); 134 error = inode_change_ok(inode, iattr); 135 if (error) 136 goto out; 137 138 error = __kernfs_setattr(kn, iattr); 139 if (error) 140 goto out; 141 142 /* this ignores size changes */ 143 setattr_copy(inode, iattr); 144 145 out: 146 mutex_unlock(&kernfs_mutex); 147 return error; 148 } 149 150 static int kernfs_node_setsecdata(struct kernfs_node *kn, void **secdata, 151 u32 *secdata_len) 152 { 153 struct kernfs_iattrs *attrs; 154 void *old_secdata; 155 size_t old_secdata_len; 156 157 attrs = kernfs_iattrs(kn); 158 if (!attrs) 159 return -ENOMEM; 160 161 old_secdata = attrs->ia_secdata; 162 old_secdata_len = attrs->ia_secdata_len; 163 164 attrs->ia_secdata = *secdata; 165 attrs->ia_secdata_len = *secdata_len; 166 167 *secdata = old_secdata; 168 *secdata_len = old_secdata_len; 169 return 0; 170 } 171 172 int kernfs_iop_setxattr(struct dentry *dentry, const char *name, 173 const void *value, size_t size, int flags) 174 { 175 struct kernfs_node *kn = dentry->d_fsdata; 176 struct kernfs_iattrs *attrs; 177 void *secdata; 178 int error; 179 u32 secdata_len = 0; 180 181 attrs = kernfs_iattrs(kn); 182 if (!attrs) 183 return -ENOMEM; 184 185 if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) { 186 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN; 187 error = security_inode_setsecurity(dentry->d_inode, suffix, 188 value, size, flags); 189 if (error) 190 return error; 191 error = security_inode_getsecctx(dentry->d_inode, 192 &secdata, &secdata_len); 193 if (error) 194 return error; 195 196 mutex_lock(&kernfs_mutex); 197 error = kernfs_node_setsecdata(kn, &secdata, &secdata_len); 198 mutex_unlock(&kernfs_mutex); 199 200 if (secdata) 201 security_release_secctx(secdata, secdata_len); 202 return error; 203 } else if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) { 204 return simple_xattr_set(&attrs->xattrs, name, value, size, 205 flags); 206 } 207 208 return -EINVAL; 209 } 210 211 int kernfs_iop_removexattr(struct dentry *dentry, const char *name) 212 { 213 struct kernfs_node *kn = dentry->d_fsdata; 214 struct kernfs_iattrs *attrs; 215 216 attrs = kernfs_iattrs(kn); 217 if (!attrs) 218 return -ENOMEM; 219 220 return simple_xattr_remove(&attrs->xattrs, name); 221 } 222 223 ssize_t kernfs_iop_getxattr(struct dentry *dentry, const char *name, void *buf, 224 size_t size) 225 { 226 struct kernfs_node *kn = dentry->d_fsdata; 227 struct kernfs_iattrs *attrs; 228 229 attrs = kernfs_iattrs(kn); 230 if (!attrs) 231 return -ENOMEM; 232 233 return simple_xattr_get(&attrs->xattrs, name, buf, size); 234 } 235 236 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size) 237 { 238 struct kernfs_node *kn = dentry->d_fsdata; 239 struct kernfs_iattrs *attrs; 240 241 attrs = kernfs_iattrs(kn); 242 if (!attrs) 243 return -ENOMEM; 244 245 return simple_xattr_list(&attrs->xattrs, buf, size); 246 } 247 248 static inline void set_default_inode_attr(struct inode *inode, umode_t mode) 249 { 250 inode->i_mode = mode; 251 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 252 } 253 254 static inline void set_inode_attr(struct inode *inode, struct iattr *iattr) 255 { 256 inode->i_uid = iattr->ia_uid; 257 inode->i_gid = iattr->ia_gid; 258 inode->i_atime = iattr->ia_atime; 259 inode->i_mtime = iattr->ia_mtime; 260 inode->i_ctime = iattr->ia_ctime; 261 } 262 263 static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode) 264 { 265 struct kernfs_iattrs *attrs = kn->iattr; 266 267 inode->i_mode = kn->mode; 268 if (attrs) { 269 /* 270 * kernfs_node has non-default attributes get them from 271 * persistent copy in kernfs_node. 272 */ 273 set_inode_attr(inode, &attrs->ia_iattr); 274 security_inode_notifysecctx(inode, attrs->ia_secdata, 275 attrs->ia_secdata_len); 276 } 277 278 if (kernfs_type(kn) == KERNFS_DIR) 279 set_nlink(inode, kn->dir.subdirs + 2); 280 } 281 282 int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry, 283 struct kstat *stat) 284 { 285 struct kernfs_node *kn = dentry->d_fsdata; 286 struct inode *inode = dentry->d_inode; 287 288 mutex_lock(&kernfs_mutex); 289 kernfs_refresh_inode(kn, inode); 290 mutex_unlock(&kernfs_mutex); 291 292 generic_fillattr(inode, stat); 293 return 0; 294 } 295 296 static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode) 297 { 298 kernfs_get(kn); 299 inode->i_private = kn; 300 inode->i_mapping->a_ops = &kernfs_aops; 301 inode->i_mapping->backing_dev_info = &kernfs_bdi; 302 inode->i_op = &kernfs_iops; 303 304 set_default_inode_attr(inode, kn->mode); 305 kernfs_refresh_inode(kn, inode); 306 307 /* initialize inode according to type */ 308 switch (kernfs_type(kn)) { 309 case KERNFS_DIR: 310 inode->i_op = &kernfs_dir_iops; 311 inode->i_fop = &kernfs_dir_fops; 312 break; 313 case KERNFS_FILE: 314 inode->i_size = kn->attr.size; 315 inode->i_fop = &kernfs_file_fops; 316 break; 317 case KERNFS_LINK: 318 inode->i_op = &kernfs_symlink_iops; 319 break; 320 default: 321 BUG(); 322 } 323 324 unlock_new_inode(inode); 325 } 326 327 /** 328 * kernfs_get_inode - get inode for kernfs_node 329 * @sb: super block 330 * @kn: kernfs_node to allocate inode for 331 * 332 * Get inode for @kn. If such inode doesn't exist, a new inode is 333 * allocated and basics are initialized. New inode is returned 334 * locked. 335 * 336 * LOCKING: 337 * Kernel thread context (may sleep). 338 * 339 * RETURNS: 340 * Pointer to allocated inode on success, NULL on failure. 341 */ 342 struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn) 343 { 344 struct inode *inode; 345 346 inode = iget_locked(sb, kn->ino); 347 if (inode && (inode->i_state & I_NEW)) 348 kernfs_init_inode(kn, inode); 349 350 return inode; 351 } 352 353 /* 354 * The kernfs_node serves as both an inode and a directory entry for 355 * kernfs. To prevent the kernfs inode numbers from being freed 356 * prematurely we take a reference to kernfs_node from the kernfs inode. A 357 * super_operations.evict_inode() implementation is needed to drop that 358 * reference upon inode destruction. 359 */ 360 void kernfs_evict_inode(struct inode *inode) 361 { 362 struct kernfs_node *kn = inode->i_private; 363 364 truncate_inode_pages_final(&inode->i_data); 365 clear_inode(inode); 366 kernfs_put(kn); 367 } 368 369 int kernfs_iop_permission(struct inode *inode, int mask) 370 { 371 struct kernfs_node *kn; 372 373 if (mask & MAY_NOT_BLOCK) 374 return -ECHILD; 375 376 kn = inode->i_private; 377 378 mutex_lock(&kernfs_mutex); 379 kernfs_refresh_inode(kn, inode); 380 mutex_unlock(&kernfs_mutex); 381 382 return generic_permission(inode, mask); 383 } 384