Commit | Line | Data |
---|---|---|
b8441ed2 TH |
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 | */ | |
ffed24e2 TH |
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 | ||
a797bfc3 | 21 | static const struct address_space_operations kernfs_aops = { |
ffed24e2 TH |
22 | .readpage = simple_readpage, |
23 | .write_begin = simple_write_begin, | |
24 | .write_end = simple_write_end, | |
25 | }; | |
26 | ||
a797bfc3 TH |
27 | static struct backing_dev_info kernfs_bdi = { |
28 | .name = "kernfs", | |
ffed24e2 TH |
29 | .ra_pages = 0, /* No readahead */ |
30 | .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK, | |
31 | }; | |
32 | ||
a797bfc3 | 33 | static const struct inode_operations kernfs_iops = { |
c637b8ac TH |
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, | |
ffed24e2 TH |
41 | }; |
42 | ||
c637b8ac | 43 | void __init kernfs_inode_init(void) |
ffed24e2 | 44 | { |
a797bfc3 TH |
45 | if (bdi_init(&kernfs_bdi)) |
46 | panic("failed to init kernfs_bdi"); | |
ffed24e2 TH |
47 | } |
48 | ||
c525aadd | 49 | static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn) |
ffed24e2 | 50 | { |
4afddd60 TH |
51 | static DEFINE_MUTEX(iattr_mutex); |
52 | struct kernfs_iattrs *ret; | |
ffed24e2 TH |
53 | struct iattr *iattrs; |
54 | ||
4afddd60 TH |
55 | mutex_lock(&iattr_mutex); |
56 | ||
adc5e8b5 | 57 | if (kn->iattr) |
4afddd60 | 58 | goto out_unlock; |
9a8049af | 59 | |
c525aadd | 60 | kn->iattr = kzalloc(sizeof(struct kernfs_iattrs), GFP_KERNEL); |
adc5e8b5 | 61 | if (!kn->iattr) |
4afddd60 | 62 | goto out_unlock; |
adc5e8b5 | 63 | iattrs = &kn->iattr->ia_iattr; |
ffed24e2 TH |
64 | |
65 | /* assign default attributes */ | |
adc5e8b5 | 66 | iattrs->ia_mode = kn->mode; |
ffed24e2 TH |
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 | ||
adc5e8b5 | 71 | simple_xattrs_init(&kn->iattr->xattrs); |
4afddd60 TH |
72 | out_unlock: |
73 | ret = kn->iattr; | |
74 | mutex_unlock(&iattr_mutex); | |
75 | return ret; | |
ffed24e2 TH |
76 | } |
77 | ||
324a56e1 | 78 | static int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) |
ffed24e2 | 79 | { |
c525aadd | 80 | struct kernfs_iattrs *attrs; |
ffed24e2 TH |
81 | struct iattr *iattrs; |
82 | unsigned int ia_valid = iattr->ia_valid; | |
83 | ||
c525aadd | 84 | attrs = kernfs_iattrs(kn); |
9a8049af TH |
85 | if (!attrs) |
86 | return -ENOMEM; | |
ffed24e2 | 87 | |
9a8049af | 88 | iattrs = &attrs->ia_iattr; |
ffed24e2 TH |
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; | |
adc5e8b5 | 102 | iattrs->ia_mode = kn->mode = mode; |
ffed24e2 TH |
103 | } |
104 | return 0; | |
105 | } | |
106 | ||
107 | /** | |
108 | * kernfs_setattr - set iattr on a node | |
324a56e1 | 109 | * @kn: target node |
ffed24e2 TH |
110 | * @iattr: iattr to set |
111 | * | |
112 | * Returns 0 on success, -errno on failure. | |
113 | */ | |
324a56e1 | 114 | int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) |
ffed24e2 TH |
115 | { |
116 | int ret; | |
117 | ||
a797bfc3 | 118 | mutex_lock(&kernfs_mutex); |
324a56e1 | 119 | ret = __kernfs_setattr(kn, iattr); |
a797bfc3 | 120 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
121 | return ret; |
122 | } | |
123 | ||
c637b8ac | 124 | int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr) |
ffed24e2 TH |
125 | { |
126 | struct inode *inode = dentry->d_inode; | |
324a56e1 | 127 | struct kernfs_node *kn = dentry->d_fsdata; |
ffed24e2 TH |
128 | int error; |
129 | ||
324a56e1 | 130 | if (!kn) |
ffed24e2 TH |
131 | return -EINVAL; |
132 | ||
a797bfc3 | 133 | mutex_lock(&kernfs_mutex); |
ffed24e2 TH |
134 | error = inode_change_ok(inode, iattr); |
135 | if (error) | |
136 | goto out; | |
137 | ||
324a56e1 | 138 | error = __kernfs_setattr(kn, iattr); |
ffed24e2 TH |
139 | if (error) |
140 | goto out; | |
141 | ||
142 | /* this ignores size changes */ | |
143 | setattr_copy(inode, iattr); | |
144 | ||
145 | out: | |
a797bfc3 | 146 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
147 | return error; |
148 | } | |
149 | ||
c637b8ac TH |
150 | static int kernfs_node_setsecdata(struct kernfs_node *kn, void **secdata, |
151 | u32 *secdata_len) | |
ffed24e2 | 152 | { |
c525aadd | 153 | struct kernfs_iattrs *attrs; |
ffed24e2 TH |
154 | void *old_secdata; |
155 | size_t old_secdata_len; | |
156 | ||
c525aadd | 157 | attrs = kernfs_iattrs(kn); |
9a8049af TH |
158 | if (!attrs) |
159 | return -ENOMEM; | |
ffed24e2 | 160 | |
9a8049af TH |
161 | old_secdata = attrs->ia_secdata; |
162 | old_secdata_len = attrs->ia_secdata_len; | |
ffed24e2 | 163 | |
9a8049af TH |
164 | attrs->ia_secdata = *secdata; |
165 | attrs->ia_secdata_len = *secdata_len; | |
ffed24e2 TH |
166 | |
167 | *secdata = old_secdata; | |
168 | *secdata_len = old_secdata_len; | |
169 | return 0; | |
170 | } | |
171 | ||
c637b8ac TH |
172 | int kernfs_iop_setxattr(struct dentry *dentry, const char *name, |
173 | const void *value, size_t size, int flags) | |
ffed24e2 | 174 | { |
324a56e1 | 175 | struct kernfs_node *kn = dentry->d_fsdata; |
c525aadd | 176 | struct kernfs_iattrs *attrs; |
ffed24e2 TH |
177 | void *secdata; |
178 | int error; | |
179 | u32 secdata_len = 0; | |
180 | ||
c525aadd | 181 | attrs = kernfs_iattrs(kn); |
2322392b TH |
182 | if (!attrs) |
183 | return -ENOMEM; | |
ffed24e2 TH |
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) | |
2322392b | 190 | return error; |
ffed24e2 TH |
191 | error = security_inode_getsecctx(dentry->d_inode, |
192 | &secdata, &secdata_len); | |
193 | if (error) | |
2322392b | 194 | return error; |
ffed24e2 | 195 | |
a797bfc3 | 196 | mutex_lock(&kernfs_mutex); |
c637b8ac | 197 | error = kernfs_node_setsecdata(kn, &secdata, &secdata_len); |
a797bfc3 | 198 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
199 | |
200 | if (secdata) | |
201 | security_release_secctx(secdata, secdata_len); | |
2322392b TH |
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 | ||
c637b8ac | 211 | int kernfs_iop_removexattr(struct dentry *dentry, const char *name) |
2322392b | 212 | { |
324a56e1 | 213 | struct kernfs_node *kn = dentry->d_fsdata; |
c525aadd | 214 | struct kernfs_iattrs *attrs; |
2322392b | 215 | |
c525aadd | 216 | attrs = kernfs_iattrs(kn); |
2322392b TH |
217 | if (!attrs) |
218 | return -ENOMEM; | |
219 | ||
220 | return simple_xattr_remove(&attrs->xattrs, name); | |
221 | } | |
222 | ||
c637b8ac TH |
223 | ssize_t kernfs_iop_getxattr(struct dentry *dentry, const char *name, void *buf, |
224 | size_t size) | |
2322392b | 225 | { |
324a56e1 | 226 | struct kernfs_node *kn = dentry->d_fsdata; |
c525aadd | 227 | struct kernfs_iattrs *attrs; |
2322392b | 228 | |
c525aadd | 229 | attrs = kernfs_iattrs(kn); |
2322392b TH |
230 | if (!attrs) |
231 | return -ENOMEM; | |
232 | ||
233 | return simple_xattr_get(&attrs->xattrs, name, buf, size); | |
234 | } | |
235 | ||
c637b8ac | 236 | ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size) |
2322392b | 237 | { |
324a56e1 | 238 | struct kernfs_node *kn = dentry->d_fsdata; |
c525aadd | 239 | struct kernfs_iattrs *attrs; |
2322392b | 240 | |
c525aadd | 241 | attrs = kernfs_iattrs(kn); |
2322392b TH |
242 | if (!attrs) |
243 | return -ENOMEM; | |
244 | ||
245 | return simple_xattr_list(&attrs->xattrs, buf, size); | |
ffed24e2 TH |
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 | ||
c637b8ac | 263 | static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode) |
ffed24e2 | 264 | { |
c525aadd | 265 | struct kernfs_iattrs *attrs = kn->iattr; |
ffed24e2 | 266 | |
adc5e8b5 | 267 | inode->i_mode = kn->mode; |
9a8049af | 268 | if (attrs) { |
324a56e1 TH |
269 | /* |
270 | * kernfs_node has non-default attributes get them from | |
271 | * persistent copy in kernfs_node. | |
ffed24e2 | 272 | */ |
9a8049af TH |
273 | set_inode_attr(inode, &attrs->ia_iattr); |
274 | security_inode_notifysecctx(inode, attrs->ia_secdata, | |
275 | attrs->ia_secdata_len); | |
ffed24e2 TH |
276 | } |
277 | ||
df23fc39 | 278 | if (kernfs_type(kn) == KERNFS_DIR) |
adc5e8b5 | 279 | set_nlink(inode, kn->dir.subdirs + 2); |
ffed24e2 TH |
280 | } |
281 | ||
c637b8ac TH |
282 | int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry, |
283 | struct kstat *stat) | |
ffed24e2 | 284 | { |
324a56e1 | 285 | struct kernfs_node *kn = dentry->d_fsdata; |
ffed24e2 TH |
286 | struct inode *inode = dentry->d_inode; |
287 | ||
a797bfc3 | 288 | mutex_lock(&kernfs_mutex); |
c637b8ac | 289 | kernfs_refresh_inode(kn, inode); |
a797bfc3 | 290 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
291 | |
292 | generic_fillattr(inode, stat); | |
293 | return 0; | |
294 | } | |
295 | ||
c637b8ac | 296 | static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode) |
ffed24e2 | 297 | { |
324a56e1 TH |
298 | kernfs_get(kn); |
299 | inode->i_private = kn; | |
a797bfc3 TH |
300 | inode->i_mapping->a_ops = &kernfs_aops; |
301 | inode->i_mapping->backing_dev_info = &kernfs_bdi; | |
302 | inode->i_op = &kernfs_iops; | |
ffed24e2 | 303 | |
adc5e8b5 | 304 | set_default_inode_attr(inode, kn->mode); |
c637b8ac | 305 | kernfs_refresh_inode(kn, inode); |
ffed24e2 TH |
306 | |
307 | /* initialize inode according to type */ | |
df23fc39 TH |
308 | switch (kernfs_type(kn)) { |
309 | case KERNFS_DIR: | |
a797bfc3 TH |
310 | inode->i_op = &kernfs_dir_iops; |
311 | inode->i_fop = &kernfs_dir_fops; | |
ffed24e2 | 312 | break; |
df23fc39 | 313 | case KERNFS_FILE: |
adc5e8b5 | 314 | inode->i_size = kn->attr.size; |
a797bfc3 | 315 | inode->i_fop = &kernfs_file_fops; |
ffed24e2 | 316 | break; |
df23fc39 | 317 | case KERNFS_LINK: |
a797bfc3 | 318 | inode->i_op = &kernfs_symlink_iops; |
ffed24e2 TH |
319 | break; |
320 | default: | |
321 | BUG(); | |
322 | } | |
323 | ||
324 | unlock_new_inode(inode); | |
325 | } | |
326 | ||
327 | /** | |
c637b8ac | 328 | * kernfs_get_inode - get inode for kernfs_node |
ffed24e2 | 329 | * @sb: super block |
324a56e1 | 330 | * @kn: kernfs_node to allocate inode for |
ffed24e2 | 331 | * |
324a56e1 TH |
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. | |
ffed24e2 TH |
335 | * |
336 | * LOCKING: | |
337 | * Kernel thread context (may sleep). | |
338 | * | |
339 | * RETURNS: | |
340 | * Pointer to allocated inode on success, NULL on failure. | |
341 | */ | |
c637b8ac | 342 | struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn) |
ffed24e2 TH |
343 | { |
344 | struct inode *inode; | |
345 | ||
adc5e8b5 | 346 | inode = iget_locked(sb, kn->ino); |
ffed24e2 | 347 | if (inode && (inode->i_state & I_NEW)) |
c637b8ac | 348 | kernfs_init_inode(kn, inode); |
ffed24e2 TH |
349 | |
350 | return inode; | |
351 | } | |
352 | ||
353 | /* | |
c637b8ac TH |
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 | |
ffed24e2 TH |
357 | * super_operations.evict_inode() implementation is needed to drop that |
358 | * reference upon inode destruction. | |
359 | */ | |
c637b8ac | 360 | void kernfs_evict_inode(struct inode *inode) |
ffed24e2 | 361 | { |
324a56e1 | 362 | struct kernfs_node *kn = inode->i_private; |
ffed24e2 | 363 | |
91b0abe3 | 364 | truncate_inode_pages_final(&inode->i_data); |
ffed24e2 | 365 | clear_inode(inode); |
324a56e1 | 366 | kernfs_put(kn); |
ffed24e2 TH |
367 | } |
368 | ||
c637b8ac | 369 | int kernfs_iop_permission(struct inode *inode, int mask) |
ffed24e2 | 370 | { |
324a56e1 | 371 | struct kernfs_node *kn; |
ffed24e2 TH |
372 | |
373 | if (mask & MAY_NOT_BLOCK) | |
374 | return -ECHILD; | |
375 | ||
324a56e1 | 376 | kn = inode->i_private; |
ffed24e2 | 377 | |
a797bfc3 | 378 | mutex_lock(&kernfs_mutex); |
c637b8ac | 379 | kernfs_refresh_inode(kn, inode); |
a797bfc3 | 380 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
381 | |
382 | return generic_permission(inode, mask); | |
383 | } |