5 #include <linux/sysctl.h>
6 #include <linux/proc_fs.h>
7 #include <linux/security.h>
10 static struct dentry_operations proc_sys_dentry_operations
;
11 static const struct file_operations proc_sys_file_operations
;
12 static struct inode_operations proc_sys_inode_operations
;
14 static void proc_sys_refresh_inode(struct inode
*inode
, struct ctl_table
*table
)
16 /* Refresh the cached information bits in the inode */
20 inode
->i_mode
= table
->mode
;
21 if (table
->proc_handler
) {
22 inode
->i_mode
|= S_IFREG
;
25 inode
->i_mode
|= S_IFDIR
;
26 inode
->i_nlink
= 0; /* It is too hard to figure out */
31 static struct inode
*proc_sys_make_inode(struct inode
*dir
, struct ctl_table
*table
)
34 struct proc_inode
*dir_ei
, *ei
;
37 inode
= new_inode(dir
->i_sb
);
41 /* A directory is always one deeper than it's parent */
43 depth
= dir_ei
->fd
+ 1;
47 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
48 inode
->i_op
= &proc_sys_inode_operations
;
49 inode
->i_fop
= &proc_sys_file_operations
;
50 proc_sys_refresh_inode(inode
, table
);
55 static struct dentry
*proc_sys_ancestor(struct dentry
*dentry
, int depth
)
58 struct proc_inode
*ei
;
60 ei
= PROC_I(dentry
->d_inode
);
64 dentry
= dentry
->d_parent
;
69 static struct ctl_table
*proc_sys_lookup_table_one(struct ctl_table
*table
,
73 for ( ; table
->ctl_name
|| table
->procname
; table
++) {
78 len
= strlen(table
->procname
);
82 if (memcmp(table
->procname
, name
->name
, len
) != 0)
91 static struct ctl_table
*proc_sys_lookup_table(struct dentry
*dentry
,
92 struct ctl_table
*table
)
94 struct dentry
*ancestor
;
95 struct proc_inode
*ei
;
98 ei
= PROC_I(dentry
->d_inode
);
104 for (i
= 1; table
&& (i
<= depth
); i
++) {
105 ancestor
= proc_sys_ancestor(dentry
, i
);
106 table
= proc_sys_lookup_table_one(table
, &ancestor
->d_name
);
108 table
= table
->child
;
113 static struct ctl_table
*proc_sys_lookup_entry(struct dentry
*dparent
,
115 struct ctl_table
*table
)
117 table
= proc_sys_lookup_table(dparent
, table
);
119 table
= proc_sys_lookup_table_one(table
, name
);
123 static struct ctl_table
*do_proc_sys_lookup(struct dentry
*parent
,
125 struct ctl_table_header
**ptr
)
127 struct ctl_table_header
*head
;
128 struct ctl_table
*table
= NULL
;
130 for (head
= sysctl_head_next(NULL
); head
;
131 head
= sysctl_head_next(head
)) {
132 table
= proc_sys_lookup_entry(parent
, name
, head
->ctl_table
);
140 static struct dentry
*proc_sys_lookup(struct inode
*dir
, struct dentry
*dentry
,
141 struct nameidata
*nd
)
143 struct ctl_table_header
*head
;
146 struct ctl_table
*table
;
148 err
= ERR_PTR(-ENOENT
);
149 table
= do_proc_sys_lookup(dentry
->d_parent
, &dentry
->d_name
, &head
);
153 err
= ERR_PTR(-ENOMEM
);
154 inode
= proc_sys_make_inode(dir
, table
);
159 dentry
->d_op
= &proc_sys_dentry_operations
;
160 d_add(dentry
, inode
);
163 sysctl_head_finish(head
);
167 static ssize_t
proc_sys_read(struct file
*filp
, char __user
*buf
,
168 size_t count
, loff_t
*ppos
)
170 struct dentry
*dentry
= filp
->f_dentry
;
171 struct ctl_table_header
*head
;
172 struct ctl_table
*table
;
175 table
= do_proc_sys_lookup(dentry
->d_parent
, &dentry
->d_name
, &head
);
176 /* Has the sysctl entry disappeared on us? */
181 /* Has the sysctl entry been replaced by a directory? */
183 if (!table
->proc_handler
)
187 * At this point we know that the sysctl was not unregistered
188 * and won't be until we finish.
191 if (sysctl_perm(table
, MAY_READ
))
194 /* careful: calling conventions are nasty here */
196 error
= table
->proc_handler(table
, 0, filp
, buf
, &res
, ppos
);
200 sysctl_head_finish(head
);
205 static ssize_t
proc_sys_write(struct file
*filp
, const char __user
*buf
,
206 size_t count
, loff_t
*ppos
)
208 struct dentry
*dentry
= filp
->f_dentry
;
209 struct ctl_table_header
*head
;
210 struct ctl_table
*table
;
213 table
= do_proc_sys_lookup(dentry
->d_parent
, &dentry
->d_name
, &head
);
214 /* Has the sysctl entry disappeared on us? */
219 /* Has the sysctl entry been replaced by a directory? */
221 if (!table
->proc_handler
)
225 * At this point we know that the sysctl was not unregistered
226 * and won't be until we finish.
229 if (sysctl_perm(table
, MAY_WRITE
))
232 /* careful: calling conventions are nasty here */
234 error
= table
->proc_handler(table
, 1, filp
, (char __user
*)buf
,
239 sysctl_head_finish(head
);
245 static int proc_sys_fill_cache(struct file
*filp
, void *dirent
,
246 filldir_t filldir
, struct ctl_table
*table
)
248 struct ctl_table_header
*head
;
249 struct ctl_table
*child_table
= NULL
;
250 struct dentry
*child
, *dir
= filp
->f_path
.dentry
;
254 unsigned type
= DT_UNKNOWN
;
257 qname
.name
= table
->procname
;
258 qname
.len
= strlen(table
->procname
);
259 qname
.hash
= full_name_hash(qname
.name
, qname
.len
);
261 /* Suppress duplicates.
262 * Only fill a directory entry if it is the value that
263 * an ordinary lookup of that name returns. Hide all
266 * If we ever cache this translation in the dcache
267 * I should do a dcache lookup first. But for now
268 * it is just simpler not to.
271 child_table
= do_proc_sys_lookup(dir
, &qname
, &head
);
272 sysctl_head_finish(head
);
273 if (child_table
!= table
)
276 child
= d_lookup(dir
, &qname
);
279 new = d_alloc(dir
, &qname
);
281 inode
= proc_sys_make_inode(dir
->d_inode
, table
);
283 child
= ERR_PTR(-ENOMEM
);
285 new->d_op
= &proc_sys_dentry_operations
;
294 if (!child
|| IS_ERR(child
) || !child
->d_inode
)
295 goto end_instantiate
;
296 inode
= child
->d_inode
;
299 type
= inode
->i_mode
>> 12;
304 ino
= find_inode_number(dir
, &qname
);
307 return filldir(dirent
, qname
.name
, qname
.len
, filp
->f_pos
, ino
, type
);
310 static int proc_sys_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
312 struct dentry
*dentry
= filp
->f_dentry
;
313 struct inode
*inode
= dentry
->d_inode
;
314 struct ctl_table_header
*head
= NULL
;
315 struct ctl_table
*table
;
320 if (!S_ISDIR(inode
->i_mode
))
324 /* Avoid a switch here: arm builds fail with missing __cmpdi2 */
325 if (filp
->f_pos
== 0) {
326 if (filldir(dirent
, ".", 1, filp
->f_pos
,
327 inode
->i_ino
, DT_DIR
) < 0)
331 if (filp
->f_pos
== 1) {
332 if (filldir(dirent
, "..", 2, filp
->f_pos
,
333 parent_ino(dentry
), DT_DIR
) < 0)
339 /* - Find each instance of the directory
340 * - Read all entries in each instance
341 * - Before returning an entry to user space lookup the entry
342 * by name and if I find a different entry don't return
343 * this one because it means it is a buried dup.
344 * For sysctl this should only happen for directory entries.
346 for (head
= sysctl_head_next(NULL
); head
; head
= sysctl_head_next(head
)) {
347 table
= proc_sys_lookup_table(dentry
, head
->ctl_table
);
352 for (; table
->ctl_name
|| table
->procname
; table
++, pos
++) {
353 /* Can't do anything without a proc name */
354 if (!table
->procname
)
357 if (pos
< filp
->f_pos
)
360 if (proc_sys_fill_cache(filp
, dirent
, filldir
, table
) < 0)
362 filp
->f_pos
= pos
+ 1;
367 sysctl_head_finish(head
);
371 static int proc_sys_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
374 * sysctl entries that are not writeable,
375 * are _NOT_ writeable, capabilities or not.
377 struct ctl_table_header
*head
;
378 struct ctl_table
*table
;
379 struct dentry
*dentry
;
385 depth
= PROC_I(inode
)->fd
;
387 /* First check the cached permissions, in case we don't have
388 * enough information to lookup the sysctl table entry.
391 mode
= inode
->i_mode
;
393 if (current
->euid
== 0)
395 else if (in_group_p(0))
398 if ((mode
& mask
& (MAY_READ
|MAY_WRITE
|MAY_EXEC
)) == mask
)
401 /* If we can't get a sysctl table entry the permission
402 * checks on the cached mode will have to be enough.
408 table
= do_proc_sys_lookup(dentry
->d_parent
, &dentry
->d_name
, &head
);
410 /* If the entry does not exist deny permission */
415 /* Use the permissions on the sysctl table entry */
416 error
= sysctl_perm(table
, mask
);
418 sysctl_head_finish(head
);
422 static int proc_sys_setattr(struct dentry
*dentry
, struct iattr
*attr
)
424 struct inode
*inode
= dentry
->d_inode
;
427 if (attr
->ia_valid
& (ATTR_MODE
| ATTR_UID
| ATTR_GID
))
430 error
= inode_change_ok(inode
, attr
);
432 error
= security_inode_setattr(dentry
, attr
);
434 error
= inode_setattr(inode
, attr
);
440 /* I'm lazy and don't distinguish between files and directories,
443 static const struct file_operations proc_sys_file_operations
= {
444 .read
= proc_sys_read
,
445 .write
= proc_sys_write
,
446 .readdir
= proc_sys_readdir
,
449 static struct inode_operations proc_sys_inode_operations
= {
450 .lookup
= proc_sys_lookup
,
451 .permission
= proc_sys_permission
,
452 .setattr
= proc_sys_setattr
,
455 static int proc_sys_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
457 struct ctl_table_header
*head
;
458 struct ctl_table
*table
;
459 table
= do_proc_sys_lookup(dentry
->d_parent
, &dentry
->d_name
, &head
);
460 proc_sys_refresh_inode(dentry
->d_inode
, table
);
461 sysctl_head_finish(head
);
465 static struct dentry_operations proc_sys_dentry_operations
= {
466 .d_revalidate
= proc_sys_revalidate
,
469 static struct proc_dir_entry
*proc_sys_root
;
471 int proc_sys_init(void)
473 proc_sys_root
= proc_mkdir("sys", NULL
);
474 proc_sys_root
->proc_iops
= &proc_sys_inode_operations
;
475 proc_sys_root
->proc_fops
= &proc_sys_file_operations
;
476 proc_sys_root
->nlink
= 0;