blob: b4531f2be0f1bb17af411b519ea94e5f8433111e
1 | /* |
2 | * inode.c - securityfs |
3 | * |
4 | * Copyright (C) 2005 Greg Kroah-Hartman <gregkh@suse.de> |
5 | * |
6 | * This program is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU General Public License version |
8 | * 2 as published by the Free Software Foundation. |
9 | * |
10 | * Based on fs/debugfs/inode.c which had the following copyright notice: |
11 | * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com> |
12 | * Copyright (C) 2004 IBM Inc. |
13 | */ |
14 | |
15 | /* #define DEBUG */ |
16 | #include <linux/module.h> |
17 | #include <linux/fs.h> |
18 | #include <linux/mount.h> |
19 | #include <linux/pagemap.h> |
20 | #include <linux/init.h> |
21 | #include <linux/namei.h> |
22 | #include <linux/security.h> |
23 | #include <linux/magic.h> |
24 | |
25 | static struct vfsmount *mount; |
26 | static int mount_count; |
27 | |
28 | static int fill_super(struct super_block *sb, void *data, int silent) |
29 | { |
30 | static struct tree_descr files[] = {{""}}; |
31 | |
32 | return simple_fill_super(sb, SECURITYFS_MAGIC, files); |
33 | } |
34 | |
35 | static struct dentry *get_sb(struct file_system_type *fs_type, |
36 | int flags, const char *dev_name, |
37 | void *data) |
38 | { |
39 | return mount_single(fs_type, flags, data, fill_super); |
40 | } |
41 | |
42 | static struct file_system_type fs_type = { |
43 | .owner = THIS_MODULE, |
44 | .name = "securityfs", |
45 | .mount = get_sb, |
46 | .kill_sb = kill_litter_super, |
47 | }; |
48 | |
49 | /** |
50 | * securityfs_create_file - create a file in the securityfs filesystem |
51 | * |
52 | * @name: a pointer to a string containing the name of the file to create. |
53 | * @mode: the permission that the file should have |
54 | * @parent: a pointer to the parent dentry for this file. This should be a |
55 | * directory dentry if set. If this parameter is %NULL, then the |
56 | * file will be created in the root of the securityfs filesystem. |
57 | * @data: a pointer to something that the caller will want to get to later |
58 | * on. The inode.i_private pointer will point to this value on |
59 | * the open() call. |
60 | * @fops: a pointer to a struct file_operations that should be used for |
61 | * this file. |
62 | * |
63 | * This is the basic "create a file" function for securityfs. It allows for a |
64 | * wide range of flexibility in creating a file, or a directory (if you |
65 | * want to create a directory, the securityfs_create_dir() function is |
66 | * recommended to be used instead). |
67 | * |
68 | * This function returns a pointer to a dentry if it succeeds. This |
69 | * pointer must be passed to the securityfs_remove() function when the file is |
70 | * to be removed (no automatic cleanup happens if your module is unloaded, |
71 | * you are responsible here). If an error occurs, the function will return |
72 | * the error value (via ERR_PTR). |
73 | * |
74 | * If securityfs is not enabled in the kernel, the value %-ENODEV is |
75 | * returned. |
76 | */ |
77 | struct dentry *securityfs_create_file(const char *name, umode_t mode, |
78 | struct dentry *parent, void *data, |
79 | const struct file_operations *fops) |
80 | { |
81 | struct dentry *dentry; |
82 | int is_dir = S_ISDIR(mode); |
83 | struct inode *dir, *inode; |
84 | int error; |
85 | |
86 | if (!is_dir) { |
87 | BUG_ON(!fops); |
88 | mode = (mode & S_IALLUGO) | S_IFREG; |
89 | } |
90 | |
91 | pr_debug("securityfs: creating file '%s'\n",name); |
92 | |
93 | error = simple_pin_fs(&fs_type, &mount, &mount_count); |
94 | if (error) |
95 | return ERR_PTR(error); |
96 | |
97 | if (!parent) |
98 | parent = mount->mnt_root; |
99 | |
100 | dir = d_inode(parent); |
101 | |
102 | inode_lock(dir); |
103 | dentry = lookup_one_len2(name, mount, parent, strlen(name)); |
104 | if (IS_ERR(dentry)) |
105 | goto out; |
106 | |
107 | if (d_really_is_positive(dentry)) { |
108 | error = -EEXIST; |
109 | goto out1; |
110 | } |
111 | |
112 | inode = new_inode(dir->i_sb); |
113 | if (!inode) { |
114 | error = -ENOMEM; |
115 | goto out1; |
116 | } |
117 | |
118 | inode->i_ino = get_next_ino(); |
119 | inode->i_mode = mode; |
120 | inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); |
121 | inode->i_private = data; |
122 | if (is_dir) { |
123 | inode->i_op = &simple_dir_inode_operations; |
124 | inode->i_fop = &simple_dir_operations; |
125 | inc_nlink(inode); |
126 | inc_nlink(dir); |
127 | } else { |
128 | inode->i_fop = fops; |
129 | } |
130 | d_instantiate(dentry, inode); |
131 | dget(dentry); |
132 | inode_unlock(dir); |
133 | return dentry; |
134 | |
135 | out1: |
136 | dput(dentry); |
137 | dentry = ERR_PTR(error); |
138 | out: |
139 | inode_unlock(dir); |
140 | simple_release_fs(&mount, &mount_count); |
141 | return dentry; |
142 | } |
143 | EXPORT_SYMBOL_GPL(securityfs_create_file); |
144 | |
145 | /** |
146 | * securityfs_create_dir - create a directory in the securityfs filesystem |
147 | * |
148 | * @name: a pointer to a string containing the name of the directory to |
149 | * create. |
150 | * @parent: a pointer to the parent dentry for this file. This should be a |
151 | * directory dentry if set. If this parameter is %NULL, then the |
152 | * directory will be created in the root of the securityfs filesystem. |
153 | * |
154 | * This function creates a directory in securityfs with the given @name. |
155 | * |
156 | * This function returns a pointer to a dentry if it succeeds. This |
157 | * pointer must be passed to the securityfs_remove() function when the file is |
158 | * to be removed (no automatic cleanup happens if your module is unloaded, |
159 | * you are responsible here). If an error occurs, the function will return |
160 | * the error value (via ERR_PTR). |
161 | * |
162 | * If securityfs is not enabled in the kernel, the value %-ENODEV is |
163 | * returned. |
164 | */ |
165 | struct dentry *securityfs_create_dir(const char *name, struct dentry *parent) |
166 | { |
167 | return securityfs_create_file(name, |
168 | S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO, |
169 | parent, NULL, NULL); |
170 | } |
171 | EXPORT_SYMBOL_GPL(securityfs_create_dir); |
172 | |
173 | /** |
174 | * securityfs_remove - removes a file or directory from the securityfs filesystem |
175 | * |
176 | * @dentry: a pointer to a the dentry of the file or directory to be removed. |
177 | * |
178 | * This function removes a file or directory in securityfs that was previously |
179 | * created with a call to another securityfs function (like |
180 | * securityfs_create_file() or variants thereof.) |
181 | * |
182 | * This function is required to be called in order for the file to be |
183 | * removed. No automatic cleanup of files will happen when a module is |
184 | * removed; you are responsible here. |
185 | */ |
186 | void securityfs_remove(struct dentry *dentry) |
187 | { |
188 | struct inode *dir; |
189 | |
190 | if (!dentry || IS_ERR(dentry)) |
191 | return; |
192 | |
193 | dir = d_inode(dentry->d_parent); |
194 | inode_lock(dir); |
195 | if (simple_positive(dentry)) { |
196 | if (d_is_dir(dentry)) |
197 | simple_rmdir(dir, dentry); |
198 | else |
199 | simple_unlink(dir, dentry); |
200 | dput(dentry); |
201 | } |
202 | inode_unlock(dir); |
203 | simple_release_fs(&mount, &mount_count); |
204 | } |
205 | EXPORT_SYMBOL_GPL(securityfs_remove); |
206 | |
207 | static int __init securityfs_init(void) |
208 | { |
209 | int retval; |
210 | |
211 | retval = sysfs_create_mount_point(kernel_kobj, "security"); |
212 | if (retval) |
213 | return retval; |
214 | |
215 | retval = register_filesystem(&fs_type); |
216 | if (retval) |
217 | sysfs_remove_mount_point(kernel_kobj, "security"); |
218 | return retval; |
219 | } |
220 | |
221 | core_initcall(securityfs_init); |
222 | MODULE_LICENSE("GPL"); |
223 | |
224 |