blob: 945a81043ba223cd92206077be7847563243f89e [file] [log] [blame]
Eric W. Biederman77b14db2007-02-14 00:34:12 -08001/*
2 * /proc/sys support
3 */
4
5#include <linux/sysctl.h>
6#include <linux/proc_fs.h>
7#include <linux/security.h>
8#include "internal.h"
9
10static struct dentry_operations proc_sys_dentry_operations;
11static 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 */
Al Viro9043476f2008-07-15 08:54:06 -0400301 struct ctl_table_header *head = grab_header(inode);
302 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800303 int error;
304
Al Viro9043476f2008-07-15 08:54:06 -0400305 if (IS_ERR(head))
306 return PTR_ERR(head);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800307
Al Viro9043476f2008-07-15 08:54:06 -0400308 if (!table) /* global root - r-xr-xr-x */
309 error = mask & MAY_WRITE ? -EACCES : 0;
310 else /* Use the permissions on the sysctl table entry */
311 error = sysctl_perm(head->root, table, mask);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800312
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800313 sysctl_head_finish(head);
314 return error;
315}
316
317static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
318{
319 struct inode *inode = dentry->d_inode;
320 int error;
321
322 if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
323 return -EPERM;
324
325 error = inode_change_ok(inode, attr);
John Johansen9d0633c2007-05-08 00:29:44 -0700326 if (!error)
327 error = inode_setattr(inode, attr);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800328
329 return error;
330}
331
Al Viro9043476f2008-07-15 08:54:06 -0400332static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
333{
334 struct inode *inode = dentry->d_inode;
335 struct ctl_table_header *head = grab_header(inode);
336 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
337
338 if (IS_ERR(head))
339 return PTR_ERR(head);
340
341 generic_fillattr(inode, stat);
342 if (table)
343 stat->mode = (stat->mode & S_IFMT) | table->mode;
344
345 sysctl_head_finish(head);
346 return 0;
347}
348
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800349static const struct file_operations proc_sys_file_operations = {
350 .read = proc_sys_read,
351 .write = proc_sys_write,
Al Viro9043476f2008-07-15 08:54:06 -0400352};
353
354static const struct file_operations proc_sys_dir_file_operations = {
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800355 .readdir = proc_sys_readdir,
356};
357
Jan Engelhardt03a44822008-02-08 04:21:19 -0800358static const struct inode_operations proc_sys_inode_operations = {
Al Viro9043476f2008-07-15 08:54:06 -0400359 .permission = proc_sys_permission,
360 .setattr = proc_sys_setattr,
361 .getattr = proc_sys_getattr,
362};
363
364static const struct inode_operations proc_sys_dir_operations = {
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800365 .lookup = proc_sys_lookup,
366 .permission = proc_sys_permission,
367 .setattr = proc_sys_setattr,
Al Viro9043476f2008-07-15 08:54:06 -0400368 .getattr = proc_sys_getattr,
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800369};
370
371static int proc_sys_revalidate(struct dentry *dentry, struct nameidata *nd)
372{
Al Viro9043476f2008-07-15 08:54:06 -0400373 return !PROC_I(dentry->d_inode)->sysctl->unregistering;
374}
375
376static int proc_sys_delete(struct dentry *dentry)
377{
378 return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
379}
380
381static int proc_sys_compare(struct dentry *dir, struct qstr *qstr,
382 struct qstr *name)
383{
384 struct dentry *dentry = container_of(qstr, struct dentry, d_name);
385 if (qstr->len != name->len)
386 return 1;
387 if (memcmp(qstr->name, name->name, name->len))
388 return 1;
389 return !sysctl_is_seen(PROC_I(dentry->d_inode)->sysctl);
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800390}
391
392static struct dentry_operations proc_sys_dentry_operations = {
393 .d_revalidate = proc_sys_revalidate,
Al Viro9043476f2008-07-15 08:54:06 -0400394 .d_delete = proc_sys_delete,
395 .d_compare = proc_sys_compare,
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800396};
397
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800398int proc_sys_init(void)
399{
Alexey Dobriyane1675232008-10-03 00:23:32 +0400400 struct proc_dir_entry *proc_sys_root;
401
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800402 proc_sys_root = proc_mkdir("sys", NULL);
Al Viro9043476f2008-07-15 08:54:06 -0400403 proc_sys_root->proc_iops = &proc_sys_dir_operations;
404 proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
Eric W. Biederman77b14db2007-02-14 00:34:12 -0800405 proc_sys_root->nlink = 0;
406 return 0;
407}