blob: 9b1e4e9a16bfd0f1ee07f109b1964f5700c1a577 [file] [log] [blame]
Eric W. Biederman77b14db2007-02-14 00:34:12 -08001/*
2 * /proc/sys support
3 */
Alexey Dobriyan1e0edd32008-10-17 05:07:44 +04004#include <linux/init.h>
Eric W. Biederman77b14db2007-02-14 00:34:12 -08005#include <linux/sysctl.h>
6#include <linux/proc_fs.h>
7#include <linux/security.h>
8#include "internal.h"
9
Al Virod72f71e2009-02-20 05:58:47 +000010static const struct dentry_operations proc_sys_dentry_operations;
Eric W. Biederman77b14db2007-02-14 00:34:12 -080011static const struct file_operations proc_sys_file_operations;
Jan Engelhardt03a44822008-02-08 04:21:19 -080012static const struct inode_operations proc_sys_inode_operations;
Al Viro9043476f2008-07-15 08:54:06 -040013static const struct file_operations proc_sys_dir_file_operations;
14static const struct inode_operations proc_sys_dir_operations;
Eric W. Biederman77b14db2007-02-14 00:34:12 -080015
Al Viro9043476f2008-07-15 08:54:06 -040016static struct inode *proc_sys_make_inode(struct super_block *sb,
17 struct ctl_table_header *head, struct ctl_table *table)
Eric W. Biederman77b14db2007-02-14 00:34:12 -080018{
19 struct inode *inode;
Al Viro9043476f2008-07-15 08:54:06 -040020 struct proc_inode *ei;
Eric W. Biederman77b14db2007-02-14 00:34:12 -080021
Al Viro9043476f2008-07-15 08:54:06 -040022 inode = new_inode(sb);
Eric W. Biederman77b14db2007-02-14 00:34:12 -080023 if (!inode)
24 goto out;
25
Al Viro9043476f2008-07-15 08:54:06 -040026 sysctl_head_get(head);
Eric W. Biederman77b14db2007-02-14 00:34:12 -080027 ei = PROC_I(inode);
Al Viro9043476f2008-07-15 08:54:06 -040028 ei->sysctl = head;
29 ei->sysctl_entry = table;
30
Eric W. Biederman77b14db2007-02-14 00:34:12 -080031 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
Eric W. Biederman86a71dbd2007-02-14 00:34:16 -080032 inode->i_flags |= S_PRIVATE; /* tell selinux to ignore this inode */
Al Viro9043476f2008-07-15 08:54:06 -040033 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 }
Eric W. Biederman77b14db2007-02-14 00:34:12 -080044out:
45 return inode;
46}
47
Al Viro9043476f2008-07-15 08:54:06 -040048static struct ctl_table *find_in_table(struct ctl_table *p, struct qstr *name)
Eric W. Biederman77b14db2007-02-14 00:34:12 -080049{
50 int len;
Al Viro9043476f2008-07-15 08:54:06 -040051 for ( ; p->ctl_name || p->procname; p++) {
Eric W. Biederman77b14db2007-02-14 00:34:12 -080052
Al Viro9043476f2008-07-15 08:54:06 -040053 if (!p->procname)
Eric W. Biederman77b14db2007-02-14 00:34:12 -080054 continue;
55
Al Viro9043476f2008-07-15 08:54:06 -040056 len = strlen(p->procname);
Eric W. Biederman77b14db2007-02-14 00:34:12 -080057 if (len != name->len)
58 continue;
59
Al Viro9043476f2008-07-15 08:54:06 -040060 if (memcmp(p->procname, name->name, len) != 0)
Eric W. Biederman77b14db2007-02-14 00:34:12 -080061 continue;
62
63 /* I have a match */
Al Viro9043476f2008-07-15 08:54:06 -040064 return p;
Eric W. Biederman77b14db2007-02-14 00:34:12 -080065 }
66 return NULL;
67}
68
Adrian Bunk81324362008-10-03 00:33:54 +040069static struct ctl_table_header *grab_header(struct inode *inode)
Eric W. Biederman77b14db2007-02-14 00:34:12 -080070{
Al Viro9043476f2008-07-15 08:54:06 -040071 if (PROC_I(inode)->sysctl)
72 return sysctl_head_grab(PROC_I(inode)->sysctl);
73 else
74 return sysctl_head_next(NULL);
Eric W. Biederman77b14db2007-02-14 00:34:12 -080075}
76
77static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
78 struct nameidata *nd)
79{
Al Viro9043476f2008-07-15 08:54:06 -040080 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;
Eric W. Biederman77b14db2007-02-14 00:34:12 -080085 struct inode *inode;
Al Viro9043476f2008-07-15 08:54:06 -040086 struct dentry *err = ERR_PTR(-ENOENT);
Eric W. Biederman77b14db2007-02-14 00:34:12 -080087
Al Viro9043476f2008-07-15 08:54:06 -040088 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)
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800110 goto out;
111
112 err = ERR_PTR(-ENOMEM);
Al Viro9043476f2008-07-15 08:54:06 -0400113 inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
114 if (h)
115 sysctl_head_finish(h);
116
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800117 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
Pavel Emelyanov7708bfb2008-04-29 01:02:40 -0700129static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
130 size_t count, loff_t *ppos, int write)
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800131{
Al Viro9043476f2008-07-15 08:54:06 -0400132 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;
David Howells2a2da532007-10-25 15:27:40 +0100135 ssize_t error;
136 size_t res;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800137
Al Viro9043476f2008-07-15 08:54:06 -0400138 if (IS_ERR(head))
139 return PTR_ERR(head);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800140
141 /*
142 * At this point we know that the sysctl was not unregistered
143 * and won't be until we finish.
144 */
145 error = -EPERM;
Pavel Emelyanovd7321cd2008-04-29 01:02:44 -0700146 if (sysctl_perm(head->root, table, write ? MAY_WRITE : MAY_READ))
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800147 goto out;
148
Al Viro9043476f2008-07-15 08:54:06 -0400149 /* if that can happen at all, it should be -EINVAL, not -EISDIR */
150 error = -EINVAL;
151 if (!table->proc_handler)
152 goto out;
153
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800154 /* careful: calling conventions are nasty here */
155 res = count;
Pavel Emelyanov7708bfb2008-04-29 01:02:40 -0700156 error = table->proc_handler(table, write, filp, buf, &res, ppos);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800157 if (!error)
158 error = res;
159out:
160 sysctl_head_finish(head);
161
162 return error;
163}
164
Pavel Emelyanov7708bfb2008-04-29 01:02:40 -0700165static 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
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800171static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
172 size_t count, loff_t *ppos)
173{
Pavel Emelyanov7708bfb2008-04-29 01:02:40 -0700174 return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800175}
176
177
178static int proc_sys_fill_cache(struct file *filp, void *dirent,
Al Viro9043476f2008-07-15 08:54:06 -0400179 filldir_t filldir,
180 struct ctl_table_header *head,
181 struct ctl_table *table)
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800182{
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800183 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;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800188
189 qname.name = table->procname;
190 qname.len = strlen(table->procname);
191 qname.hash = full_name_hash(qname.name, qname.len);
192
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800193 child = d_lookup(dir, &qname);
194 if (!child) {
Al Viro9043476f2008-07-15 08:54:06 -0400195 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);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800204 }
Al Viro9043476f2008-07-15 08:54:06 -0400205 } else {
206 return -ENOMEM;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800207 }
208 }
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800209 inode = child->d_inode;
Al Viro9043476f2008-07-15 08:54:06 -0400210 ino = inode->i_ino;
211 type = inode->i_mode >> 12;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800212 dput(child);
Al Viro9043476f2008-07-15 08:54:06 -0400213 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 /* Can't do anything without a proc name */
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;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800238}
239
240static int proc_sys_readdir(struct file *filp, void *dirent, filldir_t filldir)
241{
Al Viro9043476f2008-07-15 08:54:06 -0400242 struct dentry *dentry = filp->f_path.dentry;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800243 struct inode *inode = dentry->d_inode;
Al Viro9043476f2008-07-15 08:54:06 -0400244 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;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800247 unsigned long pos;
Al Viro9043476f2008-07-15 08:54:06 -0400248 int ret = -EINVAL;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800249
Al Viro9043476f2008-07-15 08:54:06 -0400250 if (IS_ERR(head))
251 return PTR_ERR(head);
252
253 if (table && !table->child) {
254 WARN_ON(1);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800255 goto out;
Al Viro9043476f2008-07-15 08:54:06 -0400256 }
257
258 table = table ? table->child : head->ctl_table;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800259
260 ret = 0;
261 /* Avoid a switch here: arm builds fail with missing __cmpdi2 */
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
Al Viro9043476f2008-07-15 08:54:06 -0400276 ret = scan(head, table, &pos, filp, dirent, filldir);
277 if (ret)
278 goto out;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800279
Al Viro9043476f2008-07-15 08:54:06 -0400280 for (h = sysctl_head_next(NULL); h; h = sysctl_head_next(h)) {
281 if (h->attached_to != table)
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800282 continue;
Al Viro9043476f2008-07-15 08:54:06 -0400283 ret = scan(h, h->attached_by, &pos, filp, dirent, filldir);
284 if (ret) {
285 sysctl_head_finish(h);
286 break;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800287 }
288 }
289 ret = 1;
290out:
291 sysctl_head_finish(head);
292 return ret;
293}
294
Al Viroe6305c42008-07-15 21:03:57 -0400295static int proc_sys_permission(struct inode *inode, int mask)
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800296{
297 /*
298 * sysctl entries that are not writeable,
299 * are _NOT_ writeable, capabilities or not.
300 */
Miklos Szeredif696a362008-07-31 13:41:58 +0200301 struct ctl_table_header *head;
302 struct ctl_table *table;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800303 int error;
304
Miklos Szeredif696a362008-07-31 13:41:58 +0200305 /* Executable files are not allowed under /proc/sys/ */
306 if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
307 return -EACCES;
308
309 head = grab_header(inode);
Al Viro9043476f2008-07-15 08:54:06 -0400310 if (IS_ERR(head))
311 return PTR_ERR(head);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800312
Miklos Szeredif696a362008-07-31 13:41:58 +0200313 table = PROC_I(inode)->sysctl_entry;
Al Viro9043476f2008-07-15 08:54:06 -0400314 if (!table) /* global root - r-xr-xr-x */
315 error = mask & MAY_WRITE ? -EACCES : 0;
316 else /* Use the permissions on the sysctl table entry */
317 error = sysctl_perm(head->root, table, mask);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800318
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800319 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);
John Johansen9d0633c2007-05-08 00:29:44 -0700332 if (!error)
333 error = inode_setattr(inode, attr);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800334
335 return error;
336}
337
Al Viro9043476f2008-07-15 08:54:06 -0400338static 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
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800355static const struct file_operations proc_sys_file_operations = {
356 .read = proc_sys_read,
357 .write = proc_sys_write,
Al Viro9043476f2008-07-15 08:54:06 -0400358};
359
360static const struct file_operations proc_sys_dir_file_operations = {
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800361 .readdir = proc_sys_readdir,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +0200362 .llseek = generic_file_llseek,
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800363};
364
Jan Engelhardt03a44822008-02-08 04:21:19 -0800365static const struct inode_operations proc_sys_inode_operations = {
Al Viro9043476f2008-07-15 08:54:06 -0400366 .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 = {
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800372 .lookup = proc_sys_lookup,
373 .permission = proc_sys_permission,
374 .setattr = proc_sys_setattr,
Al Viro9043476f2008-07-15 08:54:06 -0400375 .getattr = proc_sys_getattr,
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800376};
377
378static int proc_sys_revalidate(struct dentry *dentry, struct nameidata *nd)
379{
Al Viro9043476f2008-07-15 08:54:06 -0400380 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);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800397}
398
Al Virod72f71e2009-02-20 05:58:47 +0000399static const struct dentry_operations proc_sys_dentry_operations = {
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800400 .d_revalidate = proc_sys_revalidate,
Al Viro9043476f2008-07-15 08:54:06 -0400401 .d_delete = proc_sys_delete,
402 .d_compare = proc_sys_compare,
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800403};
404
Alexey Dobriyan1e0edd32008-10-17 05:07:44 +0400405int __init proc_sys_init(void)
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800406{
Alexey Dobriyane1675232008-10-03 00:23:32 +0400407 struct proc_dir_entry *proc_sys_root;
408
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800409 proc_sys_root = proc_mkdir("sys", NULL);
Al Viro9043476f2008-07-15 08:54:06 -0400410 proc_sys_root->proc_iops = &proc_sys_dir_operations;
411 proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800412 proc_sys_root->nlink = 0;
413 return 0;
414}