Merge branch 'stable-3.14' of git://git.infradead.org/users/pcmoore/selinux into...
[platform/adaptation/renesas_rcar/renesas_kernel.git] / fs / kernfs / inode.c
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         struct iattr *iattrs;
52
53         if (kn->iattr)
54                 return kn->iattr;
55
56         kn->iattr = kzalloc(sizeof(struct kernfs_iattrs), GFP_KERNEL);
57         if (!kn->iattr)
58                 return NULL;
59         iattrs = &kn->iattr->ia_iattr;
60
61         /* assign default attributes */
62         iattrs->ia_mode = kn->mode;
63         iattrs->ia_uid = GLOBAL_ROOT_UID;
64         iattrs->ia_gid = GLOBAL_ROOT_GID;
65         iattrs->ia_atime = iattrs->ia_mtime = iattrs->ia_ctime = CURRENT_TIME;
66
67         simple_xattrs_init(&kn->iattr->xattrs);
68
69         return kn->iattr;
70 }
71
72 static int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
73 {
74         struct kernfs_iattrs *attrs;
75         struct iattr *iattrs;
76         unsigned int ia_valid = iattr->ia_valid;
77
78         attrs = kernfs_iattrs(kn);
79         if (!attrs)
80                 return -ENOMEM;
81
82         iattrs = &attrs->ia_iattr;
83
84         if (ia_valid & ATTR_UID)
85                 iattrs->ia_uid = iattr->ia_uid;
86         if (ia_valid & ATTR_GID)
87                 iattrs->ia_gid = iattr->ia_gid;
88         if (ia_valid & ATTR_ATIME)
89                 iattrs->ia_atime = iattr->ia_atime;
90         if (ia_valid & ATTR_MTIME)
91                 iattrs->ia_mtime = iattr->ia_mtime;
92         if (ia_valid & ATTR_CTIME)
93                 iattrs->ia_ctime = iattr->ia_ctime;
94         if (ia_valid & ATTR_MODE) {
95                 umode_t mode = iattr->ia_mode;
96                 iattrs->ia_mode = kn->mode = mode;
97         }
98         return 0;
99 }
100
101 /**
102  * kernfs_setattr - set iattr on a node
103  * @kn: target node
104  * @iattr: iattr to set
105  *
106  * Returns 0 on success, -errno on failure.
107  */
108 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
109 {
110         int ret;
111
112         mutex_lock(&kernfs_mutex);
113         ret = __kernfs_setattr(kn, iattr);
114         mutex_unlock(&kernfs_mutex);
115         return ret;
116 }
117
118 int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr)
119 {
120         struct inode *inode = dentry->d_inode;
121         struct kernfs_node *kn = dentry->d_fsdata;
122         int error;
123
124         if (!kn)
125                 return -EINVAL;
126
127         mutex_lock(&kernfs_mutex);
128         error = inode_change_ok(inode, iattr);
129         if (error)
130                 goto out;
131
132         error = __kernfs_setattr(kn, iattr);
133         if (error)
134                 goto out;
135
136         /* this ignores size changes */
137         setattr_copy(inode, iattr);
138
139 out:
140         mutex_unlock(&kernfs_mutex);
141         return error;
142 }
143
144 static int kernfs_node_setsecdata(struct kernfs_node *kn, void **secdata,
145                                   u32 *secdata_len)
146 {
147         struct kernfs_iattrs *attrs;
148         void *old_secdata;
149         size_t old_secdata_len;
150
151         attrs = kernfs_iattrs(kn);
152         if (!attrs)
153                 return -ENOMEM;
154
155         old_secdata = attrs->ia_secdata;
156         old_secdata_len = attrs->ia_secdata_len;
157
158         attrs->ia_secdata = *secdata;
159         attrs->ia_secdata_len = *secdata_len;
160
161         *secdata = old_secdata;
162         *secdata_len = old_secdata_len;
163         return 0;
164 }
165
166 int kernfs_iop_setxattr(struct dentry *dentry, const char *name,
167                         const void *value, size_t size, int flags)
168 {
169         struct kernfs_node *kn = dentry->d_fsdata;
170         struct kernfs_iattrs *attrs;
171         void *secdata;
172         int error;
173         u32 secdata_len = 0;
174
175         attrs = kernfs_iattrs(kn);
176         if (!attrs)
177                 return -ENOMEM;
178
179         if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) {
180                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
181                 error = security_inode_setsecurity(dentry->d_inode, suffix,
182                                                 value, size, flags);
183                 if (error)
184                         return error;
185                 error = security_inode_getsecctx(dentry->d_inode,
186                                                 &secdata, &secdata_len);
187                 if (error)
188                         return error;
189
190                 mutex_lock(&kernfs_mutex);
191                 error = kernfs_node_setsecdata(kn, &secdata, &secdata_len);
192                 mutex_unlock(&kernfs_mutex);
193
194                 if (secdata)
195                         security_release_secctx(secdata, secdata_len);
196                 return error;
197         } else if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
198                 return simple_xattr_set(&attrs->xattrs, name, value, size,
199                                         flags);
200         }
201
202         return -EINVAL;
203 }
204
205 int kernfs_iop_removexattr(struct dentry *dentry, const char *name)
206 {
207         struct kernfs_node *kn = dentry->d_fsdata;
208         struct kernfs_iattrs *attrs;
209
210         attrs = kernfs_iattrs(kn);
211         if (!attrs)
212                 return -ENOMEM;
213
214         return simple_xattr_remove(&attrs->xattrs, name);
215 }
216
217 ssize_t kernfs_iop_getxattr(struct dentry *dentry, const char *name, void *buf,
218                             size_t size)
219 {
220         struct kernfs_node *kn = dentry->d_fsdata;
221         struct kernfs_iattrs *attrs;
222
223         attrs = kernfs_iattrs(kn);
224         if (!attrs)
225                 return -ENOMEM;
226
227         return simple_xattr_get(&attrs->xattrs, name, buf, size);
228 }
229
230 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size)
231 {
232         struct kernfs_node *kn = dentry->d_fsdata;
233         struct kernfs_iattrs *attrs;
234
235         attrs = kernfs_iattrs(kn);
236         if (!attrs)
237                 return -ENOMEM;
238
239         return simple_xattr_list(&attrs->xattrs, buf, size);
240 }
241
242 static inline void set_default_inode_attr(struct inode *inode, umode_t mode)
243 {
244         inode->i_mode = mode;
245         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
246 }
247
248 static inline void set_inode_attr(struct inode *inode, struct iattr *iattr)
249 {
250         inode->i_uid = iattr->ia_uid;
251         inode->i_gid = iattr->ia_gid;
252         inode->i_atime = iattr->ia_atime;
253         inode->i_mtime = iattr->ia_mtime;
254         inode->i_ctime = iattr->ia_ctime;
255 }
256
257 static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
258 {
259         struct kernfs_iattrs *attrs = kn->iattr;
260
261         inode->i_mode = kn->mode;
262         if (attrs) {
263                 /*
264                  * kernfs_node has non-default attributes get them from
265                  * persistent copy in kernfs_node.
266                  */
267                 set_inode_attr(inode, &attrs->ia_iattr);
268                 security_inode_notifysecctx(inode, attrs->ia_secdata,
269                                             attrs->ia_secdata_len);
270         }
271
272         if (kernfs_type(kn) == KERNFS_DIR)
273                 set_nlink(inode, kn->dir.subdirs + 2);
274 }
275
276 int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry,
277                    struct kstat *stat)
278 {
279         struct kernfs_node *kn = dentry->d_fsdata;
280         struct inode *inode = dentry->d_inode;
281
282         mutex_lock(&kernfs_mutex);
283         kernfs_refresh_inode(kn, inode);
284         mutex_unlock(&kernfs_mutex);
285
286         generic_fillattr(inode, stat);
287         return 0;
288 }
289
290 static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode)
291 {
292         kernfs_get(kn);
293         inode->i_private = kn;
294         inode->i_mapping->a_ops = &kernfs_aops;
295         inode->i_mapping->backing_dev_info = &kernfs_bdi;
296         inode->i_op = &kernfs_iops;
297
298         set_default_inode_attr(inode, kn->mode);
299         kernfs_refresh_inode(kn, inode);
300
301         /* initialize inode according to type */
302         switch (kernfs_type(kn)) {
303         case KERNFS_DIR:
304                 inode->i_op = &kernfs_dir_iops;
305                 inode->i_fop = &kernfs_dir_fops;
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(&inode->i_data, 0);
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 }