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