1
2
3
4#include <linux/init.h>
5#include <linux/sysctl.h>
6#include <linux/proc_fs.h>
7#include <linux/security.h>
8#include "internal.h"
9
10static const struct dentry_operations proc_sys_dentry_operations;
11static const struct file_operations proc_sys_file_operations;
12static const struct inode_operations proc_sys_inode_operations;
13static const struct file_operations proc_sys_dir_file_operations;
14static const struct inode_operations proc_sys_dir_operations;
15
16static struct inode *proc_sys_make_inode(struct super_block *sb,
17 struct ctl_table_header *head, struct ctl_table *table)
18{
19 struct inode *inode;
20 struct proc_inode *ei;
21
22 inode = new_inode(sb);
23 if (!inode)
24 goto out;
25
26 sysctl_head_get(head);
27 ei = PROC_I(inode);
28 ei->sysctl = head;
29 ei->sysctl_entry = table;
30
31 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
32 inode->i_flags |= S_PRIVATE;
33 inode->i_mode = table->mode;
34 if (!table->child) {
35 inode->i_mode |= S_IFREG;
36 inode->i_op = &proc_sys_inode_operations;
37 inode->i_fop = &proc_sys_file_operations;
38 } else {
39 inode->i_mode |= S_IFDIR;
40 inode->i_nlink = 0;
41 inode->i_op = &proc_sys_dir_operations;
42 inode->i_fop = &proc_sys_dir_file_operations;
43 }
44out:
45 return inode;
46}
47
48static struct ctl_table *find_in_table(struct ctl_table *p, struct qstr *name)
49{
50 int len;
51 for ( ; p->ctl_name || p->procname; p++) {
52
53 if (!p->procname)
54 continue;
55
56 len = strlen(p->procname);
57 if (len != name->len)
58 continue;
59
60 if (memcmp(p->procname, name->name, len) != 0)
61 continue;
62
63
64 return p;
65 }
66 return NULL;
67}
68
69static struct ctl_table_header *grab_header(struct inode *inode)
70{
71 if (PROC_I(inode)->sysctl)
72 return sysctl_head_grab(PROC_I(inode)->sysctl);
73 else
74 return sysctl_head_next(NULL);
75}
76
77static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
78 struct nameidata *nd)
79{
80 struct ctl_table_header *head = grab_header(dir);
81 struct ctl_table *table = PROC_I(dir)->sysctl_entry;
82 struct ctl_table_header *h = NULL;
83 struct qstr *name = &dentry->d_name;
84 struct ctl_table *p;
85 struct inode *inode;
86 struct dentry *err = ERR_PTR(-ENOENT);
87
88 if (IS_ERR(head))
89 return ERR_CAST(head);
90
91 if (table && !table->child) {
92 WARN_ON(1);
93 goto out;
94 }
95
96 table = table ? table->child : head->ctl_table;
97
98 p = find_in_table(table, name);
99 if (!p) {
100 for (h = sysctl_head_next(NULL); h; h = sysctl_head_next(h)) {
101 if (h->attached_to != table)
102 continue;
103 p = find_in_table(h->attached_by, name);
104 if (p)
105 break;
106 }
107 }
108
109 if (!p)
110 goto out;
111
112 err = ERR_PTR(-ENOMEM);
113 inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
114 if (h)
115 sysctl_head_finish(h);
116
117 if (!inode)
118 goto out;
119
120 err = NULL;
121 dentry->d_op = &proc_sys_dentry_operations;
122 d_add(dentry, inode);
123
124out:
125 sysctl_head_finish(head);
126 return err;
127}
128
129static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
130 size_t count, loff_t *ppos, int write)
131{
132 struct inode *inode = filp->f_path.dentry->d_inode;
133 struct ctl_table_header *head = grab_header(inode);
134 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
135 ssize_t error;
136 size_t res;
137
138 if (IS_ERR(head))
139 return PTR_ERR(head);
140
141
142
143
144
145 error = -EPERM;
146 if (sysctl_perm(head->root, table, write ? MAY_WRITE : MAY_READ))
147 goto out;
148
149
150 error = -EINVAL;
151 if (!table->proc_handler)
152 goto out;
153
154
155 res = count;
156 error = table->proc_handler(table, write, buf, &res, ppos);
157 if (!error)
158 error = res;
159out:
160 sysctl_head_finish(head);
161
162 return error;
163}
164
165static ssize_t proc_sys_read(struct file *filp, char __user *buf,
166 size_t count, loff_t *ppos)
167{
168 return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 0);
169}
170
171static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
172 size_t count, loff_t *ppos)
173{
174 return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
175}
176
177
178static int proc_sys_fill_cache(struct file *filp, void *dirent,
179 filldir_t filldir,
180 struct ctl_table_header *head,
181 struct ctl_table *table)
182{
183 struct dentry *child, *dir = filp->f_path.dentry;
184 struct inode *inode;
185 struct qstr qname;
186 ino_t ino = 0;
187 unsigned type = DT_UNKNOWN;
188
189 qname.name = table->procname;
190 qname.len = strlen(table->procname);
191 qname.hash = full_name_hash(qname.name, qname.len);
192
193 child = d_lookup(dir, &qname);
194 if (!child) {
195 child = d_alloc(dir, &qname);
196 if (child) {
197 inode = proc_sys_make_inode(dir->d_sb, head, table);
198 if (!inode) {
199 dput(child);
200 return -ENOMEM;
201 } else {
202 child->d_op = &proc_sys_dentry_operations;
203 d_add(child, inode);
204 }
205 } else {
206 return -ENOMEM;
207 }
208 }
209 inode = child->d_inode;
210 ino = inode->i_ino;
211 type = inode->i_mode >> 12;
212 dput(child);
213 return !!filldir(dirent, qname.name, qname.len, filp->f_pos, ino, type);
214}
215
216static int scan(struct ctl_table_header *head, ctl_table *table,
217 unsigned long *pos, struct file *file,
218 void *dirent, filldir_t filldir)
219{
220
221 for (; table->ctl_name || table->procname; table++, (*pos)++) {
222 int res;
223
224
225 if (!table->procname)
226 continue;
227
228 if (*pos < file->f_pos)
229 continue;
230
231 res = proc_sys_fill_cache(file, dirent, filldir, head, table);
232 if (res)
233 return res;
234
235 file->f_pos = *pos + 1;
236 }
237 return 0;
238}
239
240static int proc_sys_readdir(struct file *filp, void *dirent, filldir_t filldir)
241{
242 struct dentry *dentry = filp->f_path.dentry;
243 struct inode *inode = dentry->d_inode;
244 struct ctl_table_header *head = grab_header(inode);
245 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
246 struct ctl_table_header *h = NULL;
247 unsigned long pos;
248 int ret = -EINVAL;
249
250 if (IS_ERR(head))
251 return PTR_ERR(head);
252
253 if (table && !table->child) {
254 WARN_ON(1);
255 goto out;
256 }
257
258 table = table ? table->child : head->ctl_table;
259
260 ret = 0;
261
262 if (filp->f_pos == 0) {
263 if (filldir(dirent, ".", 1, filp->f_pos,
264 inode->i_ino, DT_DIR) < 0)
265 goto out;
266 filp->f_pos++;
267 }
268 if (filp->f_pos == 1) {
269 if (filldir(dirent, "..", 2, filp->f_pos,
270 parent_ino(dentry), DT_DIR) < 0)
271 goto out;
272 filp->f_pos++;
273 }
274 pos = 2;
275
276 ret = scan(head, table, &pos, filp, dirent, filldir);
277 if (ret)
278 goto out;
279
280 for (h = sysctl_head_next(NULL); h; h = sysctl_head_next(h)) {
281 if (h->attached_to != table)
282 continue;
283 ret = scan(h, h->attached_by, &pos, filp, dirent, filldir);
284 if (ret) {
285 sysctl_head_finish(h);
286 break;
287 }
288 }
289 ret = 1;
290out:
291 sysctl_head_finish(head);
292 return ret;
293}
294
295static int proc_sys_permission(struct inode *inode, int mask)
296{
297
298
299
300
301 struct ctl_table_header *head;
302 struct ctl_table *table;
303 int error;
304
305
306 if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
307 return -EACCES;
308
309 head = grab_header(inode);
310 if (IS_ERR(head))
311 return PTR_ERR(head);
312
313 table = PROC_I(inode)->sysctl_entry;
314 if (!table)
315 error = mask & MAY_WRITE ? -EACCES : 0;
316 else
317 error = sysctl_perm(head->root, table, mask);
318
319 sysctl_head_finish(head);
320 return error;
321}
322
323static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
324{
325 struct inode *inode = dentry->d_inode;
326 int error;
327
328 if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
329 return -EPERM;
330
331 error = inode_change_ok(inode, attr);
332 if (!error)
333 error = inode_setattr(inode, attr);
334
335 return error;
336}
337
338static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
339{
340 struct inode *inode = dentry->d_inode;
341 struct ctl_table_header *head = grab_header(inode);
342 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
343
344 if (IS_ERR(head))
345 return PTR_ERR(head);
346
347 generic_fillattr(inode, stat);
348 if (table)
349 stat->mode = (stat->mode & S_IFMT) | table->mode;
350
351 sysctl_head_finish(head);
352 return 0;
353}
354
355static const struct file_operations proc_sys_file_operations = {
356 .read = proc_sys_read,
357 .write = proc_sys_write,
358};
359
360static const struct file_operations proc_sys_dir_file_operations = {
361 .readdir = proc_sys_readdir,
362 .llseek = generic_file_llseek,
363};
364
365static const struct inode_operations proc_sys_inode_operations = {
366 .permission = proc_sys_permission,
367 .setattr = proc_sys_setattr,
368 .getattr = proc_sys_getattr,
369};
370
371static const struct inode_operations proc_sys_dir_operations = {
372 .lookup = proc_sys_lookup,
373 .permission = proc_sys_permission,
374 .setattr = proc_sys_setattr,
375 .getattr = proc_sys_getattr,
376};
377
378static int proc_sys_revalidate(struct dentry *dentry, struct nameidata *nd)
379{
380 return !PROC_I(dentry->d_inode)->sysctl->unregistering;
381}
382
383static int proc_sys_delete(struct dentry *dentry)
384{
385 return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
386}
387
388static int proc_sys_compare(struct dentry *dir, struct qstr *qstr,
389 struct qstr *name)
390{
391 struct dentry *dentry = container_of(qstr, struct dentry, d_name);
392 if (qstr->len != name->len)
393 return 1;
394 if (memcmp(qstr->name, name->name, name->len))
395 return 1;
396 return !sysctl_is_seen(PROC_I(dentry->d_inode)->sysctl);
397}
398
399static const struct dentry_operations proc_sys_dentry_operations = {
400 .d_revalidate = proc_sys_revalidate,
401 .d_delete = proc_sys_delete,
402 .d_compare = proc_sys_compare,
403};
404
405int __init proc_sys_init(void)
406{
407 struct proc_dir_entry *proc_sys_root;
408
409 proc_sys_root = proc_mkdir("sys", NULL);
410 proc_sys_root->proc_iops = &proc_sys_dir_operations;
411 proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
412 proc_sys_root->nlink = 0;
413 return 0;
414}
415
