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 | 27 | static const struct inode_operations kernfs_iops = { |
c637b8ac TH |
28 | .permission = kernfs_iop_permission, |
29 | .setattr = kernfs_iop_setattr, | |
30 | .getattr = kernfs_iop_getattr, | |
c637b8ac | 31 | .listxattr = kernfs_iop_listxattr, |
ffed24e2 TH |
32 | }; |
33 | ||
d0c9c153 | 34 | static struct kernfs_iattrs *__kernfs_iattrs(struct kernfs_node *kn, int alloc) |
ffed24e2 | 35 | { |
4afddd60 TH |
36 | static DEFINE_MUTEX(iattr_mutex); |
37 | struct kernfs_iattrs *ret; | |
ffed24e2 | 38 | |
4afddd60 TH |
39 | mutex_lock(&iattr_mutex); |
40 | ||
d0c9c153 | 41 | if (kn->iattr || !alloc) |
4afddd60 | 42 | goto out_unlock; |
9a8049af | 43 | |
26e28d68 | 44 | kn->iattr = kmem_cache_zalloc(kernfs_iattrs_cache, GFP_KERNEL); |
adc5e8b5 | 45 | if (!kn->iattr) |
4afddd60 | 46 | goto out_unlock; |
ffed24e2 TH |
47 | |
48 | /* assign default attributes */ | |
05895219 OM |
49 | kn->iattr->ia_uid = GLOBAL_ROOT_UID; |
50 | kn->iattr->ia_gid = GLOBAL_ROOT_GID; | |
3a3a5fec | 51 | |
05895219 OM |
52 | ktime_get_real_ts64(&kn->iattr->ia_atime); |
53 | kn->iattr->ia_mtime = kn->iattr->ia_atime; | |
54 | kn->iattr->ia_ctime = kn->iattr->ia_atime; | |
ffed24e2 | 55 | |
adc5e8b5 | 56 | simple_xattrs_init(&kn->iattr->xattrs); |
4afddd60 TH |
57 | out_unlock: |
58 | ret = kn->iattr; | |
59 | mutex_unlock(&iattr_mutex); | |
60 | return ret; | |
ffed24e2 TH |
61 | } |
62 | ||
d0c9c153 OM |
63 | static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn) |
64 | { | |
65 | return __kernfs_iattrs(kn, 1); | |
66 | } | |
67 | ||
68 | static struct kernfs_iattrs *kernfs_iattrs_noalloc(struct kernfs_node *kn) | |
69 | { | |
70 | return __kernfs_iattrs(kn, 0); | |
71 | } | |
72 | ||
488dee96 | 73 | int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) |
ffed24e2 | 74 | { |
c525aadd | 75 | struct kernfs_iattrs *attrs; |
ffed24e2 TH |
76 | unsigned int ia_valid = iattr->ia_valid; |
77 | ||
c525aadd | 78 | attrs = kernfs_iattrs(kn); |
9a8049af TH |
79 | if (!attrs) |
80 | return -ENOMEM; | |
ffed24e2 | 81 | |
ffed24e2 | 82 | if (ia_valid & ATTR_UID) |
05895219 | 83 | attrs->ia_uid = iattr->ia_uid; |
ffed24e2 | 84 | if (ia_valid & ATTR_GID) |
05895219 | 85 | attrs->ia_gid = iattr->ia_gid; |
ffed24e2 | 86 | if (ia_valid & ATTR_ATIME) |
05895219 | 87 | attrs->ia_atime = iattr->ia_atime; |
ffed24e2 | 88 | if (ia_valid & ATTR_MTIME) |
05895219 | 89 | attrs->ia_mtime = iattr->ia_mtime; |
ffed24e2 | 90 | if (ia_valid & ATTR_CTIME) |
05895219 OM |
91 | attrs->ia_ctime = iattr->ia_ctime; |
92 | if (ia_valid & ATTR_MODE) | |
93 | kn->mode = iattr->ia_mode; | |
ffed24e2 TH |
94 | return 0; |
95 | } | |
96 | ||
97 | /** | |
98 | * kernfs_setattr - set iattr on a node | |
324a56e1 | 99 | * @kn: target node |
ffed24e2 TH |
100 | * @iattr: iattr to set |
101 | * | |
102 | * Returns 0 on success, -errno on failure. | |
103 | */ | |
324a56e1 | 104 | int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr) |
ffed24e2 TH |
105 | { |
106 | int ret; | |
107 | ||
a797bfc3 | 108 | mutex_lock(&kernfs_mutex); |
324a56e1 | 109 | ret = __kernfs_setattr(kn, iattr); |
a797bfc3 | 110 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
111 | return ret; |
112 | } | |
113 | ||
c637b8ac | 114 | int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr) |
ffed24e2 | 115 | { |
2b0143b5 | 116 | struct inode *inode = d_inode(dentry); |
319ba91d | 117 | struct kernfs_node *kn = inode->i_private; |
ffed24e2 TH |
118 | int error; |
119 | ||
324a56e1 | 120 | if (!kn) |
ffed24e2 TH |
121 | return -EINVAL; |
122 | ||
a797bfc3 | 123 | mutex_lock(&kernfs_mutex); |
31051c85 | 124 | error = setattr_prepare(dentry, iattr); |
ffed24e2 TH |
125 | if (error) |
126 | goto out; | |
127 | ||
324a56e1 | 128 | error = __kernfs_setattr(kn, iattr); |
ffed24e2 TH |
129 | if (error) |
130 | goto out; | |
131 | ||
132 | /* this ignores size changes */ | |
133 | setattr_copy(inode, iattr); | |
134 | ||
135 | out: | |
a797bfc3 | 136 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
137 | return error; |
138 | } | |
139 | ||
c637b8ac | 140 | ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size) |
2322392b | 141 | { |
319ba91d | 142 | struct kernfs_node *kn = kernfs_dentry_node(dentry); |
c525aadd | 143 | struct kernfs_iattrs *attrs; |
2322392b | 144 | |
c525aadd | 145 | attrs = kernfs_iattrs(kn); |
2322392b TH |
146 | if (!attrs) |
147 | return -ENOMEM; | |
148 | ||
786534b9 | 149 | return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size); |
ffed24e2 TH |
150 | } |
151 | ||
152 | static inline void set_default_inode_attr(struct inode *inode, umode_t mode) | |
153 | { | |
154 | inode->i_mode = mode; | |
3a3a5fec | 155 | inode->i_atime = inode->i_mtime = |
c2050a45 | 156 | inode->i_ctime = current_time(inode); |
ffed24e2 TH |
157 | } |
158 | ||
05895219 OM |
159 | static inline void set_inode_attr(struct inode *inode, |
160 | struct kernfs_iattrs *attrs) | |
ffed24e2 | 161 | { |
3a3a5fec | 162 | struct super_block *sb = inode->i_sb; |
05895219 OM |
163 | inode->i_uid = attrs->ia_uid; |
164 | inode->i_gid = attrs->ia_gid; | |
165 | inode->i_atime = timespec64_trunc(attrs->ia_atime, sb->s_time_gran); | |
166 | inode->i_mtime = timespec64_trunc(attrs->ia_mtime, sb->s_time_gran); | |
167 | inode->i_ctime = timespec64_trunc(attrs->ia_ctime, sb->s_time_gran); | |
ffed24e2 TH |
168 | } |
169 | ||
c637b8ac | 170 | static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode) |
ffed24e2 | 171 | { |
c525aadd | 172 | struct kernfs_iattrs *attrs = kn->iattr; |
ffed24e2 | 173 | |
adc5e8b5 | 174 | inode->i_mode = kn->mode; |
0ac6075a | 175 | if (attrs) |
324a56e1 TH |
176 | /* |
177 | * kernfs_node has non-default attributes get them from | |
178 | * persistent copy in kernfs_node. | |
ffed24e2 | 179 | */ |
05895219 | 180 | set_inode_attr(inode, attrs); |
ffed24e2 | 181 | |
df23fc39 | 182 | if (kernfs_type(kn) == KERNFS_DIR) |
adc5e8b5 | 183 | set_nlink(inode, kn->dir.subdirs + 2); |
ffed24e2 TH |
184 | } |
185 | ||
a528d35e DH |
186 | int kernfs_iop_getattr(const struct path *path, struct kstat *stat, |
187 | u32 request_mask, unsigned int query_flags) | |
ffed24e2 | 188 | { |
a528d35e | 189 | struct inode *inode = d_inode(path->dentry); |
319ba91d | 190 | struct kernfs_node *kn = inode->i_private; |
ffed24e2 | 191 | |
a797bfc3 | 192 | mutex_lock(&kernfs_mutex); |
c637b8ac | 193 | kernfs_refresh_inode(kn, inode); |
a797bfc3 | 194 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
195 | |
196 | generic_fillattr(inode, stat); | |
197 | return 0; | |
198 | } | |
199 | ||
c637b8ac | 200 | static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode) |
ffed24e2 | 201 | { |
324a56e1 TH |
202 | kernfs_get(kn); |
203 | inode->i_private = kn; | |
a797bfc3 | 204 | inode->i_mapping->a_ops = &kernfs_aops; |
a797bfc3 | 205 | inode->i_op = &kernfs_iops; |
c53cd490 | 206 | inode->i_generation = kn->id.generation; |
ffed24e2 | 207 | |
adc5e8b5 | 208 | set_default_inode_attr(inode, kn->mode); |
c637b8ac | 209 | kernfs_refresh_inode(kn, inode); |
ffed24e2 TH |
210 | |
211 | /* initialize inode according to type */ | |
df23fc39 TH |
212 | switch (kernfs_type(kn)) { |
213 | case KERNFS_DIR: | |
a797bfc3 TH |
214 | inode->i_op = &kernfs_dir_iops; |
215 | inode->i_fop = &kernfs_dir_fops; | |
ea015218 EB |
216 | if (kn->flags & KERNFS_EMPTY_DIR) |
217 | make_empty_dir_inode(inode); | |
ffed24e2 | 218 | break; |
df23fc39 | 219 | case KERNFS_FILE: |
adc5e8b5 | 220 | inode->i_size = kn->attr.size; |
a797bfc3 | 221 | inode->i_fop = &kernfs_file_fops; |
ffed24e2 | 222 | break; |
df23fc39 | 223 | case KERNFS_LINK: |
a797bfc3 | 224 | inode->i_op = &kernfs_symlink_iops; |
ffed24e2 TH |
225 | break; |
226 | default: | |
227 | BUG(); | |
228 | } | |
229 | ||
230 | unlock_new_inode(inode); | |
231 | } | |
232 | ||
233 | /** | |
c637b8ac | 234 | * kernfs_get_inode - get inode for kernfs_node |
ffed24e2 | 235 | * @sb: super block |
324a56e1 | 236 | * @kn: kernfs_node to allocate inode for |
ffed24e2 | 237 | * |
324a56e1 TH |
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. | |
ffed24e2 TH |
241 | * |
242 | * LOCKING: | |
243 | * Kernel thread context (may sleep). | |
244 | * | |
245 | * RETURNS: | |
246 | * Pointer to allocated inode on success, NULL on failure. | |
247 | */ | |
c637b8ac | 248 | struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn) |
ffed24e2 TH |
249 | { |
250 | struct inode *inode; | |
251 | ||
c53cd490 | 252 | inode = iget_locked(sb, kn->id.ino); |
ffed24e2 | 253 | if (inode && (inode->i_state & I_NEW)) |
c637b8ac | 254 | kernfs_init_inode(kn, inode); |
ffed24e2 TH |
255 | |
256 | return inode; | |
257 | } | |
258 | ||
259 | /* | |
c637b8ac TH |
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 | |
ffed24e2 TH |
263 | * super_operations.evict_inode() implementation is needed to drop that |
264 | * reference upon inode destruction. | |
265 | */ | |
c637b8ac | 266 | void kernfs_evict_inode(struct inode *inode) |
ffed24e2 | 267 | { |
324a56e1 | 268 | struct kernfs_node *kn = inode->i_private; |
ffed24e2 | 269 | |
91b0abe3 | 270 | truncate_inode_pages_final(&inode->i_data); |
ffed24e2 | 271 | clear_inode(inode); |
324a56e1 | 272 | kernfs_put(kn); |
ffed24e2 TH |
273 | } |
274 | ||
c637b8ac | 275 | int kernfs_iop_permission(struct inode *inode, int mask) |
ffed24e2 | 276 | { |
324a56e1 | 277 | struct kernfs_node *kn; |
ffed24e2 TH |
278 | |
279 | if (mask & MAY_NOT_BLOCK) | |
280 | return -ECHILD; | |
281 | ||
324a56e1 | 282 | kn = inode->i_private; |
ffed24e2 | 283 | |
a797bfc3 | 284 | mutex_lock(&kernfs_mutex); |
c637b8ac | 285 | kernfs_refresh_inode(kn, inode); |
a797bfc3 | 286 | mutex_unlock(&kernfs_mutex); |
ffed24e2 TH |
287 | |
288 | return generic_permission(inode, mask); | |
289 | } | |
e72a1a8b | 290 | |
b230d5ab OM |
291 | static int kernfs_node_xattr_get(const struct xattr_handler *handler, |
292 | struct kernfs_node *kn, const char *suffix, | |
293 | void *value, size_t size) | |
e72a1a8b AG |
294 | { |
295 | const char *name = xattr_full_name(handler, suffix); | |
e72a1a8b AG |
296 | struct kernfs_iattrs *attrs; |
297 | ||
d0c9c153 | 298 | attrs = kernfs_iattrs_noalloc(kn); |
e72a1a8b | 299 | if (!attrs) |
d0c9c153 | 300 | return -ENODATA; |
e72a1a8b AG |
301 | |
302 | return simple_xattr_get(&attrs->xattrs, name, value, size); | |
303 | } | |
304 | ||
b230d5ab OM |
305 | static int kernfs_node_xattr_set(const struct xattr_handler *handler, |
306 | struct kernfs_node *kn, const char *suffix, | |
307 | const void *value, size_t size, int flags) | |
e72a1a8b AG |
308 | { |
309 | const char *name = xattr_full_name(handler, suffix); | |
e72a1a8b AG |
310 | struct kernfs_iattrs *attrs; |
311 | ||
312 | attrs = kernfs_iattrs(kn); | |
313 | if (!attrs) | |
314 | return -ENOMEM; | |
315 | ||
316 | return simple_xattr_set(&attrs->xattrs, name, value, size, flags); | |
317 | } | |
318 | ||
b230d5ab OM |
319 | static int kernfs_xattr_get(const struct xattr_handler *handler, |
320 | struct dentry *unused, struct inode *inode, | |
321 | const char *suffix, void *value, size_t size) | |
322 | { | |
323 | struct kernfs_node *kn = inode->i_private; | |
324 | ||
325 | return kernfs_node_xattr_get(handler, kn, suffix, value, size); | |
326 | } | |
327 | ||
328 | static int kernfs_xattr_set(const struct xattr_handler *handler, | |
329 | struct dentry *unused, struct inode *inode, | |
330 | const char *suffix, const void *value, | |
331 | size_t size, int flags) | |
332 | { | |
333 | struct kernfs_node *kn = inode->i_private; | |
334 | ||
335 | return kernfs_node_xattr_set(handler, kn, suffix, value, size, flags); | |
336 | } | |
337 | ||
b5a06234 | 338 | static const struct xattr_handler kernfs_trusted_xattr_handler = { |
e72a1a8b AG |
339 | .prefix = XATTR_TRUSTED_PREFIX, |
340 | .get = kernfs_xattr_get, | |
341 | .set = kernfs_xattr_set, | |
342 | }; | |
343 | ||
b5a06234 | 344 | static const struct xattr_handler kernfs_security_xattr_handler = { |
e72a1a8b AG |
345 | .prefix = XATTR_SECURITY_PREFIX, |
346 | .get = kernfs_xattr_get, | |
0ac6075a | 347 | .set = kernfs_xattr_set, |
e72a1a8b AG |
348 | }; |
349 | ||
350 | const struct xattr_handler *kernfs_xattr_handlers[] = { | |
351 | &kernfs_trusted_xattr_handler, | |
352 | &kernfs_security_xattr_handler, | |
353 | NULL | |
354 | }; | |
b230d5ab OM |
355 | |
356 | int kernfs_security_xattr_get(struct kernfs_node *kn, const char *suffix, | |
357 | void *value, size_t size) | |
358 | { | |
359 | return kernfs_node_xattr_get(&kernfs_security_xattr_handler, | |
360 | kn, suffix, value, size); | |
361 | } | |
362 | ||
363 | int kernfs_security_xattr_set(struct kernfs_node *kn, const char *suffix, | |
364 | void *value, size_t size, int flags) | |
365 | { | |
366 | return kernfs_node_xattr_set(&kernfs_security_xattr_handler, | |
367 | kn, suffix, value, size, flags); | |
368 | } |