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