xref: /openbmc/linux/kernel/sysctl.c (revision 529bf6be5c04f2e869d07bfdb122e9fd98ade714)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * sysctl.c: General linux system control interface
31da177e4SLinus Torvalds  *
41da177e4SLinus Torvalds  * Begun 24 March 1995, Stephen Tweedie
51da177e4SLinus Torvalds  * Added /proc support, Dec 1995
61da177e4SLinus Torvalds  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
71da177e4SLinus Torvalds  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
81da177e4SLinus Torvalds  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
91da177e4SLinus Torvalds  * Dynamic registration fixes, Stephen Tweedie.
101da177e4SLinus Torvalds  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
111da177e4SLinus Torvalds  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
121da177e4SLinus Torvalds  *  Horn.
131da177e4SLinus Torvalds  * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
141da177e4SLinus Torvalds  * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
151da177e4SLinus Torvalds  * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
161da177e4SLinus Torvalds  *  Wendling.
171da177e4SLinus Torvalds  * The list_for_each() macro wasn't appropriate for the sysctl loop.
181da177e4SLinus Torvalds  *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
191da177e4SLinus Torvalds  */
201da177e4SLinus Torvalds 
211da177e4SLinus Torvalds #include <linux/config.h>
221da177e4SLinus Torvalds #include <linux/module.h>
231da177e4SLinus Torvalds #include <linux/mm.h>
241da177e4SLinus Torvalds #include <linux/swap.h>
251da177e4SLinus Torvalds #include <linux/slab.h>
261da177e4SLinus Torvalds #include <linux/sysctl.h>
271da177e4SLinus Torvalds #include <linux/proc_fs.h>
28c59ede7bSRandy.Dunlap #include <linux/capability.h>
291da177e4SLinus Torvalds #include <linux/ctype.h>
301da177e4SLinus Torvalds #include <linux/utsname.h>
311da177e4SLinus Torvalds #include <linux/capability.h>
321da177e4SLinus Torvalds #include <linux/smp_lock.h>
331da177e4SLinus Torvalds #include <linux/init.h>
341da177e4SLinus Torvalds #include <linux/kernel.h>
350296b228SKay Sievers #include <linux/kobject.h>
3620380731SArnaldo Carvalho de Melo #include <linux/net.h>
371da177e4SLinus Torvalds #include <linux/sysrq.h>
381da177e4SLinus Torvalds #include <linux/highuid.h>
391da177e4SLinus Torvalds #include <linux/writeback.h>
401da177e4SLinus Torvalds #include <linux/hugetlb.h>
411da177e4SLinus Torvalds #include <linux/security.h>
421da177e4SLinus Torvalds #include <linux/initrd.h>
431da177e4SLinus Torvalds #include <linux/times.h>
441da177e4SLinus Torvalds #include <linux/limits.h>
451da177e4SLinus Torvalds #include <linux/dcache.h>
461da177e4SLinus Torvalds #include <linux/syscalls.h>
47c255d844SPavel Machek #include <linux/nfs_fs.h>
48c255d844SPavel Machek #include <linux/acpi.h>
491da177e4SLinus Torvalds 
501da177e4SLinus Torvalds #include <asm/uaccess.h>
511da177e4SLinus Torvalds #include <asm/processor.h>
521da177e4SLinus Torvalds 
53*529bf6beSDipankar Sarma extern int proc_nr_files(ctl_table *table, int write, struct file *filp,
54*529bf6beSDipankar Sarma                      void __user *buffer, size_t *lenp, loff_t *ppos);
55*529bf6beSDipankar Sarma 
561da177e4SLinus Torvalds #if defined(CONFIG_SYSCTL)
571da177e4SLinus Torvalds 
581da177e4SLinus Torvalds /* External variables not in a header file. */
591da177e4SLinus Torvalds extern int C_A_D;
601da177e4SLinus Torvalds extern int sysctl_overcommit_memory;
611da177e4SLinus Torvalds extern int sysctl_overcommit_ratio;
621da177e4SLinus Torvalds extern int max_threads;
631da177e4SLinus Torvalds extern int sysrq_enabled;
641da177e4SLinus Torvalds extern int core_uses_pid;
65d6e71144SAlan Cox extern int suid_dumpable;
661da177e4SLinus Torvalds extern char core_pattern[];
671da177e4SLinus Torvalds extern int cad_pid;
681da177e4SLinus Torvalds extern int pid_max;
691da177e4SLinus Torvalds extern int min_free_kbytes;
701da177e4SLinus Torvalds extern int printk_ratelimit_jiffies;
711da177e4SLinus Torvalds extern int printk_ratelimit_burst;
721da177e4SLinus Torvalds extern int pid_max_min, pid_max_max;
739d0243bcSAndrew Morton extern int sysctl_drop_caches;
748ad4b1fbSRohit Seth extern int percpu_pagelist_fraction;
751da177e4SLinus Torvalds 
761da177e4SLinus Torvalds #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
771da177e4SLinus Torvalds int unknown_nmi_panic;
781da177e4SLinus Torvalds extern int proc_unknown_nmi_panic(ctl_table *, int, struct file *,
791da177e4SLinus Torvalds 				  void __user *, size_t *, loff_t *);
801da177e4SLinus Torvalds #endif
811da177e4SLinus Torvalds 
821da177e4SLinus Torvalds /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
831da177e4SLinus Torvalds static int maxolduid = 65535;
841da177e4SLinus Torvalds static int minolduid;
858ad4b1fbSRohit Seth static int min_percpu_pagelist_fract = 8;
861da177e4SLinus Torvalds 
871da177e4SLinus Torvalds static int ngroups_max = NGROUPS_MAX;
881da177e4SLinus Torvalds 
891da177e4SLinus Torvalds #ifdef CONFIG_KMOD
901da177e4SLinus Torvalds extern char modprobe_path[];
911da177e4SLinus Torvalds #endif
921da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG
931da177e4SLinus Torvalds extern int sg_big_buff;
941da177e4SLinus Torvalds #endif
951da177e4SLinus Torvalds #ifdef CONFIG_SYSVIPC
961da177e4SLinus Torvalds extern size_t shm_ctlmax;
971da177e4SLinus Torvalds extern size_t shm_ctlall;
981da177e4SLinus Torvalds extern int shm_ctlmni;
991da177e4SLinus Torvalds extern int msg_ctlmax;
1001da177e4SLinus Torvalds extern int msg_ctlmnb;
1011da177e4SLinus Torvalds extern int msg_ctlmni;
1021da177e4SLinus Torvalds extern int sem_ctls[];
1031da177e4SLinus Torvalds #endif
1041da177e4SLinus Torvalds 
1051da177e4SLinus Torvalds #ifdef __sparc__
1061da177e4SLinus Torvalds extern char reboot_command [];
1071da177e4SLinus Torvalds extern int stop_a_enabled;
1081da177e4SLinus Torvalds extern int scons_pwroff;
1091da177e4SLinus Torvalds #endif
1101da177e4SLinus Torvalds 
1111da177e4SLinus Torvalds #ifdef __hppa__
1121da177e4SLinus Torvalds extern int pwrsw_enabled;
1131da177e4SLinus Torvalds extern int unaligned_enabled;
1141da177e4SLinus Torvalds #endif
1151da177e4SLinus Torvalds 
116347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390
1171da177e4SLinus Torvalds #ifdef CONFIG_MATHEMU
1181da177e4SLinus Torvalds extern int sysctl_ieee_emulation_warnings;
1191da177e4SLinus Torvalds #endif
1201da177e4SLinus Torvalds extern int sysctl_userprocess_debug;
121951f22d5SMartin Schwidefsky extern int spin_retry;
1221da177e4SLinus Torvalds #endif
1231da177e4SLinus Torvalds 
1241da177e4SLinus Torvalds extern int sysctl_hz_timer;
1251da177e4SLinus Torvalds 
1261da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT
1271da177e4SLinus Torvalds extern int acct_parm[];
1281da177e4SLinus Torvalds #endif
1291da177e4SLinus Torvalds 
130d2b176edSJes Sorensen #ifdef CONFIG_IA64
131d2b176edSJes Sorensen extern int no_unaligned_warning;
132d2b176edSJes Sorensen #endif
133d2b176edSJes Sorensen 
1341da177e4SLinus Torvalds static int parse_table(int __user *, int, void __user *, size_t __user *, void __user *, size_t,
1351da177e4SLinus Torvalds 		       ctl_table *, void **);
1361da177e4SLinus Torvalds static int proc_doutsstring(ctl_table *table, int write, struct file *filp,
1371da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos);
1381da177e4SLinus Torvalds 
1391da177e4SLinus Torvalds static ctl_table root_table[];
1401da177e4SLinus Torvalds static struct ctl_table_header root_table_header =
1411da177e4SLinus Torvalds 	{ root_table, LIST_HEAD_INIT(root_table_header.ctl_entry) };
1421da177e4SLinus Torvalds 
1431da177e4SLinus Torvalds static ctl_table kern_table[];
1441da177e4SLinus Torvalds static ctl_table vm_table[];
1451da177e4SLinus Torvalds static ctl_table proc_table[];
1461da177e4SLinus Torvalds static ctl_table fs_table[];
1471da177e4SLinus Torvalds static ctl_table debug_table[];
1481da177e4SLinus Torvalds static ctl_table dev_table[];
1491da177e4SLinus Torvalds extern ctl_table random_table[];
1501da177e4SLinus Torvalds #ifdef CONFIG_UNIX98_PTYS
1511da177e4SLinus Torvalds extern ctl_table pty_table[];
1521da177e4SLinus Torvalds #endif
1530399cb08SRobert Love #ifdef CONFIG_INOTIFY
1540399cb08SRobert Love extern ctl_table inotify_table[];
1550399cb08SRobert Love #endif
1561da177e4SLinus Torvalds 
1571da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1581da177e4SLinus Torvalds int sysctl_legacy_va_layout;
1591da177e4SLinus Torvalds #endif
1601da177e4SLinus Torvalds 
1611da177e4SLinus Torvalds /* /proc declarations: */
1621da177e4SLinus Torvalds 
1631da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
1641da177e4SLinus Torvalds 
1651da177e4SLinus Torvalds static ssize_t proc_readsys(struct file *, char __user *, size_t, loff_t *);
1661da177e4SLinus Torvalds static ssize_t proc_writesys(struct file *, const char __user *, size_t, loff_t *);
1671da177e4SLinus Torvalds static int proc_opensys(struct inode *, struct file *);
1681da177e4SLinus Torvalds 
1691da177e4SLinus Torvalds struct file_operations proc_sys_file_operations = {
1701da177e4SLinus Torvalds 	.open		= proc_opensys,
1711da177e4SLinus Torvalds 	.read		= proc_readsys,
1721da177e4SLinus Torvalds 	.write		= proc_writesys,
1731da177e4SLinus Torvalds };
1741da177e4SLinus Torvalds 
1751da177e4SLinus Torvalds extern struct proc_dir_entry *proc_sys_root;
1761da177e4SLinus Torvalds 
177330d57fbSAl Viro static void register_proc_table(ctl_table *, struct proc_dir_entry *, void *);
1781da177e4SLinus Torvalds static void unregister_proc_table(ctl_table *, struct proc_dir_entry *);
1791da177e4SLinus Torvalds #endif
1801da177e4SLinus Torvalds 
1811da177e4SLinus Torvalds /* The default sysctl tables: */
1821da177e4SLinus Torvalds 
1831da177e4SLinus Torvalds static ctl_table root_table[] = {
1841da177e4SLinus Torvalds 	{
1851da177e4SLinus Torvalds 		.ctl_name	= CTL_KERN,
1861da177e4SLinus Torvalds 		.procname	= "kernel",
1871da177e4SLinus Torvalds 		.mode		= 0555,
1881da177e4SLinus Torvalds 		.child		= kern_table,
1891da177e4SLinus Torvalds 	},
1901da177e4SLinus Torvalds 	{
1911da177e4SLinus Torvalds 		.ctl_name	= CTL_VM,
1921da177e4SLinus Torvalds 		.procname	= "vm",
1931da177e4SLinus Torvalds 		.mode		= 0555,
1941da177e4SLinus Torvalds 		.child		= vm_table,
1951da177e4SLinus Torvalds 	},
1961da177e4SLinus Torvalds #ifdef CONFIG_NET
1971da177e4SLinus Torvalds 	{
1981da177e4SLinus Torvalds 		.ctl_name	= CTL_NET,
1991da177e4SLinus Torvalds 		.procname	= "net",
2001da177e4SLinus Torvalds 		.mode		= 0555,
2011da177e4SLinus Torvalds 		.child		= net_table,
2021da177e4SLinus Torvalds 	},
2031da177e4SLinus Torvalds #endif
2041da177e4SLinus Torvalds 	{
2051da177e4SLinus Torvalds 		.ctl_name	= CTL_PROC,
2061da177e4SLinus Torvalds 		.procname	= "proc",
2071da177e4SLinus Torvalds 		.mode		= 0555,
2081da177e4SLinus Torvalds 		.child		= proc_table,
2091da177e4SLinus Torvalds 	},
2101da177e4SLinus Torvalds 	{
2111da177e4SLinus Torvalds 		.ctl_name	= CTL_FS,
2121da177e4SLinus Torvalds 		.procname	= "fs",
2131da177e4SLinus Torvalds 		.mode		= 0555,
2141da177e4SLinus Torvalds 		.child		= fs_table,
2151da177e4SLinus Torvalds 	},
2161da177e4SLinus Torvalds 	{
2171da177e4SLinus Torvalds 		.ctl_name	= CTL_DEBUG,
2181da177e4SLinus Torvalds 		.procname	= "debug",
2191da177e4SLinus Torvalds 		.mode		= 0555,
2201da177e4SLinus Torvalds 		.child		= debug_table,
2211da177e4SLinus Torvalds 	},
2221da177e4SLinus Torvalds 	{
2231da177e4SLinus Torvalds 		.ctl_name	= CTL_DEV,
2241da177e4SLinus Torvalds 		.procname	= "dev",
2251da177e4SLinus Torvalds 		.mode		= 0555,
2261da177e4SLinus Torvalds 		.child		= dev_table,
2271da177e4SLinus Torvalds 	},
2280eeca283SRobert Love 
2291da177e4SLinus Torvalds 	{ .ctl_name = 0 }
2301da177e4SLinus Torvalds };
2311da177e4SLinus Torvalds 
2321da177e4SLinus Torvalds static ctl_table kern_table[] = {
2331da177e4SLinus Torvalds 	{
2341da177e4SLinus Torvalds 		.ctl_name	= KERN_OSTYPE,
2351da177e4SLinus Torvalds 		.procname	= "ostype",
2361da177e4SLinus Torvalds 		.data		= system_utsname.sysname,
2371da177e4SLinus Torvalds 		.maxlen		= sizeof(system_utsname.sysname),
2381da177e4SLinus Torvalds 		.mode		= 0444,
2391da177e4SLinus Torvalds 		.proc_handler	= &proc_doutsstring,
2401da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
2411da177e4SLinus Torvalds 	},
2421da177e4SLinus Torvalds 	{
2431da177e4SLinus Torvalds 		.ctl_name	= KERN_OSRELEASE,
2441da177e4SLinus Torvalds 		.procname	= "osrelease",
2451da177e4SLinus Torvalds 		.data		= system_utsname.release,
2461da177e4SLinus Torvalds 		.maxlen		= sizeof(system_utsname.release),
2471da177e4SLinus Torvalds 		.mode		= 0444,
2481da177e4SLinus Torvalds 		.proc_handler	= &proc_doutsstring,
2491da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
2501da177e4SLinus Torvalds 	},
2511da177e4SLinus Torvalds 	{
2521da177e4SLinus Torvalds 		.ctl_name	= KERN_VERSION,
2531da177e4SLinus Torvalds 		.procname	= "version",
2541da177e4SLinus Torvalds 		.data		= system_utsname.version,
2551da177e4SLinus Torvalds 		.maxlen		= sizeof(system_utsname.version),
2561da177e4SLinus Torvalds 		.mode		= 0444,
2571da177e4SLinus Torvalds 		.proc_handler	= &proc_doutsstring,
2581da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
2591da177e4SLinus Torvalds 	},
2601da177e4SLinus Torvalds 	{
2611da177e4SLinus Torvalds 		.ctl_name	= KERN_NODENAME,
2621da177e4SLinus Torvalds 		.procname	= "hostname",
2631da177e4SLinus Torvalds 		.data		= system_utsname.nodename,
2641da177e4SLinus Torvalds 		.maxlen		= sizeof(system_utsname.nodename),
2651da177e4SLinus Torvalds 		.mode		= 0644,
2661da177e4SLinus Torvalds 		.proc_handler	= &proc_doutsstring,
2671da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
2681da177e4SLinus Torvalds 	},
2691da177e4SLinus Torvalds 	{
2701da177e4SLinus Torvalds 		.ctl_name	= KERN_DOMAINNAME,
2711da177e4SLinus Torvalds 		.procname	= "domainname",
2721da177e4SLinus Torvalds 		.data		= system_utsname.domainname,
2731da177e4SLinus Torvalds 		.maxlen		= sizeof(system_utsname.domainname),
2741da177e4SLinus Torvalds 		.mode		= 0644,
2751da177e4SLinus Torvalds 		.proc_handler	= &proc_doutsstring,
2761da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
2771da177e4SLinus Torvalds 	},
2781da177e4SLinus Torvalds 	{
2791da177e4SLinus Torvalds 		.ctl_name	= KERN_PANIC,
2801da177e4SLinus Torvalds 		.procname	= "panic",
2811da177e4SLinus Torvalds 		.data		= &panic_timeout,
2821da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
2831da177e4SLinus Torvalds 		.mode		= 0644,
2841da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
2851da177e4SLinus Torvalds 	},
2861da177e4SLinus Torvalds 	{
2871da177e4SLinus Torvalds 		.ctl_name	= KERN_CORE_USES_PID,
2881da177e4SLinus Torvalds 		.procname	= "core_uses_pid",
2891da177e4SLinus Torvalds 		.data		= &core_uses_pid,
2901da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
2911da177e4SLinus Torvalds 		.mode		= 0644,
2921da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
2931da177e4SLinus Torvalds 	},
2941da177e4SLinus Torvalds 	{
2951da177e4SLinus Torvalds 		.ctl_name	= KERN_CORE_PATTERN,
2961da177e4SLinus Torvalds 		.procname	= "core_pattern",
2971da177e4SLinus Torvalds 		.data		= core_pattern,
2981da177e4SLinus Torvalds 		.maxlen		= 64,
2991da177e4SLinus Torvalds 		.mode		= 0644,
3001da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
3011da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
3021da177e4SLinus Torvalds 	},
3031da177e4SLinus Torvalds 	{
3041da177e4SLinus Torvalds 		.ctl_name	= KERN_TAINTED,
3051da177e4SLinus Torvalds 		.procname	= "tainted",
3061da177e4SLinus Torvalds 		.data		= &tainted,
3071da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
3081da177e4SLinus Torvalds 		.mode		= 0444,
3091da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3101da177e4SLinus Torvalds 	},
3111da177e4SLinus Torvalds 	{
3121da177e4SLinus Torvalds 		.ctl_name	= KERN_CAP_BSET,
3131da177e4SLinus Torvalds 		.procname	= "cap-bound",
3141da177e4SLinus Torvalds 		.data		= &cap_bset,
3151da177e4SLinus Torvalds 		.maxlen		= sizeof(kernel_cap_t),
3161da177e4SLinus Torvalds 		.mode		= 0600,
3171da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_bset,
3181da177e4SLinus Torvalds 	},
3191da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD
3201da177e4SLinus Torvalds 	{
3211da177e4SLinus Torvalds 		.ctl_name	= KERN_REALROOTDEV,
3221da177e4SLinus Torvalds 		.procname	= "real-root-dev",
3231da177e4SLinus Torvalds 		.data		= &real_root_dev,
3241da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
3251da177e4SLinus Torvalds 		.mode		= 0644,
3261da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3271da177e4SLinus Torvalds 	},
3281da177e4SLinus Torvalds #endif
3291da177e4SLinus Torvalds #ifdef __sparc__
3301da177e4SLinus Torvalds 	{
3311da177e4SLinus Torvalds 		.ctl_name	= KERN_SPARC_REBOOT,
3321da177e4SLinus Torvalds 		.procname	= "reboot-cmd",
3331da177e4SLinus Torvalds 		.data		= reboot_command,
3341da177e4SLinus Torvalds 		.maxlen		= 256,
3351da177e4SLinus Torvalds 		.mode		= 0644,
3361da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
3371da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
3381da177e4SLinus Torvalds 	},
3391da177e4SLinus Torvalds 	{
3401da177e4SLinus Torvalds 		.ctl_name	= KERN_SPARC_STOP_A,
3411da177e4SLinus Torvalds 		.procname	= "stop-a",
3421da177e4SLinus Torvalds 		.data		= &stop_a_enabled,
3431da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
3441da177e4SLinus Torvalds 		.mode		= 0644,
3451da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3461da177e4SLinus Torvalds 	},
3471da177e4SLinus Torvalds 	{
3481da177e4SLinus Torvalds 		.ctl_name	= KERN_SPARC_SCONS_PWROFF,
3491da177e4SLinus Torvalds 		.procname	= "scons-poweroff",
3501da177e4SLinus Torvalds 		.data		= &scons_pwroff,
3511da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
3521da177e4SLinus Torvalds 		.mode		= 0644,
3531da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3541da177e4SLinus Torvalds 	},
3551da177e4SLinus Torvalds #endif
3561da177e4SLinus Torvalds #ifdef __hppa__
3571da177e4SLinus Torvalds 	{
3581da177e4SLinus Torvalds 		.ctl_name	= KERN_HPPA_PWRSW,
3591da177e4SLinus Torvalds 		.procname	= "soft-power",
3601da177e4SLinus Torvalds 		.data		= &pwrsw_enabled,
3611da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
3621da177e4SLinus Torvalds 	 	.mode		= 0644,
3631da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3641da177e4SLinus Torvalds 	},
3651da177e4SLinus Torvalds 	{
3661da177e4SLinus Torvalds 		.ctl_name	= KERN_HPPA_UNALIGNED,
3671da177e4SLinus Torvalds 		.procname	= "unaligned-trap",
3681da177e4SLinus Torvalds 		.data		= &unaligned_enabled,
3691da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
3701da177e4SLinus Torvalds 		.mode		= 0644,
3711da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3721da177e4SLinus Torvalds 	},
3731da177e4SLinus Torvalds #endif
3741da177e4SLinus Torvalds 	{
3751da177e4SLinus Torvalds 		.ctl_name	= KERN_CTLALTDEL,
3761da177e4SLinus Torvalds 		.procname	= "ctrl-alt-del",
3771da177e4SLinus Torvalds 		.data		= &C_A_D,
3781da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
3791da177e4SLinus Torvalds 		.mode		= 0644,
3801da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3811da177e4SLinus Torvalds 	},
3821da177e4SLinus Torvalds 	{
3831da177e4SLinus Torvalds 		.ctl_name	= KERN_PRINTK,
3841da177e4SLinus Torvalds 		.procname	= "printk",
3851da177e4SLinus Torvalds 		.data		= &console_loglevel,
3861da177e4SLinus Torvalds 		.maxlen		= 4*sizeof(int),
3871da177e4SLinus Torvalds 		.mode		= 0644,
3881da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3891da177e4SLinus Torvalds 	},
3901da177e4SLinus Torvalds #ifdef CONFIG_KMOD
3911da177e4SLinus Torvalds 	{
3921da177e4SLinus Torvalds 		.ctl_name	= KERN_MODPROBE,
3931da177e4SLinus Torvalds 		.procname	= "modprobe",
3941da177e4SLinus Torvalds 		.data		= &modprobe_path,
3951da177e4SLinus Torvalds 		.maxlen		= KMOD_PATH_LEN,
3961da177e4SLinus Torvalds 		.mode		= 0644,
3971da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
3981da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
3991da177e4SLinus Torvalds 	},
4001da177e4SLinus Torvalds #endif
4011da177e4SLinus Torvalds #ifdef CONFIG_HOTPLUG
4021da177e4SLinus Torvalds 	{
4031da177e4SLinus Torvalds 		.ctl_name	= KERN_HOTPLUG,
4041da177e4SLinus Torvalds 		.procname	= "hotplug",
405312c004dSKay Sievers 		.data		= &uevent_helper,
406312c004dSKay Sievers 		.maxlen		= UEVENT_HELPER_PATH_LEN,
4071da177e4SLinus Torvalds 		.mode		= 0644,
4081da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
4091da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
4101da177e4SLinus Torvalds 	},
4111da177e4SLinus Torvalds #endif
4121da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG
4131da177e4SLinus Torvalds 	{
4141da177e4SLinus Torvalds 		.ctl_name	= KERN_SG_BIG_BUFF,
4151da177e4SLinus Torvalds 		.procname	= "sg-big-buff",
4161da177e4SLinus Torvalds 		.data		= &sg_big_buff,
4171da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4181da177e4SLinus Torvalds 		.mode		= 0444,
4191da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4201da177e4SLinus Torvalds 	},
4211da177e4SLinus Torvalds #endif
4221da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT
4231da177e4SLinus Torvalds 	{
4241da177e4SLinus Torvalds 		.ctl_name	= KERN_ACCT,
4251da177e4SLinus Torvalds 		.procname	= "acct",
4261da177e4SLinus Torvalds 		.data		= &acct_parm,
4271da177e4SLinus Torvalds 		.maxlen		= 3*sizeof(int),
4281da177e4SLinus Torvalds 		.mode		= 0644,
4291da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4301da177e4SLinus Torvalds 	},
4311da177e4SLinus Torvalds #endif
4321da177e4SLinus Torvalds #ifdef CONFIG_SYSVIPC
4331da177e4SLinus Torvalds 	{
4341da177e4SLinus Torvalds 		.ctl_name	= KERN_SHMMAX,
4351da177e4SLinus Torvalds 		.procname	= "shmmax",
4361da177e4SLinus Torvalds 		.data		= &shm_ctlmax,
4371da177e4SLinus Torvalds 		.maxlen		= sizeof (size_t),
4381da177e4SLinus Torvalds 		.mode		= 0644,
4391da177e4SLinus Torvalds 		.proc_handler	= &proc_doulongvec_minmax,
4401da177e4SLinus Torvalds 	},
4411da177e4SLinus Torvalds 	{
4421da177e4SLinus Torvalds 		.ctl_name	= KERN_SHMALL,
4431da177e4SLinus Torvalds 		.procname	= "shmall",
4441da177e4SLinus Torvalds 		.data		= &shm_ctlall,
4451da177e4SLinus Torvalds 		.maxlen		= sizeof (size_t),
4461da177e4SLinus Torvalds 		.mode		= 0644,
4471da177e4SLinus Torvalds 		.proc_handler	= &proc_doulongvec_minmax,
4481da177e4SLinus Torvalds 	},
4491da177e4SLinus Torvalds 	{
4501da177e4SLinus Torvalds 		.ctl_name	= KERN_SHMMNI,
4511da177e4SLinus Torvalds 		.procname	= "shmmni",
4521da177e4SLinus Torvalds 		.data		= &shm_ctlmni,
4531da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4541da177e4SLinus Torvalds 		.mode		= 0644,
4551da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4561da177e4SLinus Torvalds 	},
4571da177e4SLinus Torvalds 	{
4581da177e4SLinus Torvalds 		.ctl_name	= KERN_MSGMAX,
4591da177e4SLinus Torvalds 		.procname	= "msgmax",
4601da177e4SLinus Torvalds 		.data		= &msg_ctlmax,
4611da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4621da177e4SLinus Torvalds 		.mode		= 0644,
4631da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4641da177e4SLinus Torvalds 	},
4651da177e4SLinus Torvalds 	{
4661da177e4SLinus Torvalds 		.ctl_name	= KERN_MSGMNI,
4671da177e4SLinus Torvalds 		.procname	= "msgmni",
4681da177e4SLinus Torvalds 		.data		= &msg_ctlmni,
4691da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4701da177e4SLinus Torvalds 		.mode		= 0644,
4711da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4721da177e4SLinus Torvalds 	},
4731da177e4SLinus Torvalds 	{
4741da177e4SLinus Torvalds 		.ctl_name	= KERN_MSGMNB,
4751da177e4SLinus Torvalds 		.procname	=  "msgmnb",
4761da177e4SLinus Torvalds 		.data		= &msg_ctlmnb,
4771da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4781da177e4SLinus Torvalds 		.mode		= 0644,
4791da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4801da177e4SLinus Torvalds 	},
4811da177e4SLinus Torvalds 	{
4821da177e4SLinus Torvalds 		.ctl_name	= KERN_SEM,
4831da177e4SLinus Torvalds 		.procname	= "sem",
4841da177e4SLinus Torvalds 		.data		= &sem_ctls,
4851da177e4SLinus Torvalds 		.maxlen		= 4*sizeof (int),
4861da177e4SLinus Torvalds 		.mode		= 0644,
4871da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4881da177e4SLinus Torvalds 	},
4891da177e4SLinus Torvalds #endif
4901da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ
4911da177e4SLinus Torvalds 	{
4921da177e4SLinus Torvalds 		.ctl_name	= KERN_SYSRQ,
4931da177e4SLinus Torvalds 		.procname	= "sysrq",
4941da177e4SLinus Torvalds 		.data		= &sysrq_enabled,
4951da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4961da177e4SLinus Torvalds 		.mode		= 0644,
4971da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4981da177e4SLinus Torvalds 	},
4991da177e4SLinus Torvalds #endif
5001da177e4SLinus Torvalds 	{
5011da177e4SLinus Torvalds 		.ctl_name	= KERN_CADPID,
5021da177e4SLinus Torvalds 		.procname	= "cad_pid",
5031da177e4SLinus Torvalds 		.data		= &cad_pid,
5041da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5051da177e4SLinus Torvalds 		.mode		= 0600,
5061da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5071da177e4SLinus Torvalds 	},
5081da177e4SLinus Torvalds 	{
5091da177e4SLinus Torvalds 		.ctl_name	= KERN_MAX_THREADS,
5101da177e4SLinus Torvalds 		.procname	= "threads-max",
5111da177e4SLinus Torvalds 		.data		= &max_threads,
5121da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5131da177e4SLinus Torvalds 		.mode		= 0644,
5141da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5151da177e4SLinus Torvalds 	},
5161da177e4SLinus Torvalds 	{
5171da177e4SLinus Torvalds 		.ctl_name	= KERN_RANDOM,
5181da177e4SLinus Torvalds 		.procname	= "random",
5191da177e4SLinus Torvalds 		.mode		= 0555,
5201da177e4SLinus Torvalds 		.child		= random_table,
5211da177e4SLinus Torvalds 	},
5221da177e4SLinus Torvalds #ifdef CONFIG_UNIX98_PTYS
5231da177e4SLinus Torvalds 	{
5241da177e4SLinus Torvalds 		.ctl_name	= KERN_PTY,
5251da177e4SLinus Torvalds 		.procname	= "pty",
5261da177e4SLinus Torvalds 		.mode		= 0555,
5271da177e4SLinus Torvalds 		.child		= pty_table,
5281da177e4SLinus Torvalds 	},
5291da177e4SLinus Torvalds #endif
5301da177e4SLinus Torvalds 	{
5311da177e4SLinus Torvalds 		.ctl_name	= KERN_OVERFLOWUID,
5321da177e4SLinus Torvalds 		.procname	= "overflowuid",
5331da177e4SLinus Torvalds 		.data		= &overflowuid,
5341da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5351da177e4SLinus Torvalds 		.mode		= 0644,
5361da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
5371da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
5381da177e4SLinus Torvalds 		.extra1		= &minolduid,
5391da177e4SLinus Torvalds 		.extra2		= &maxolduid,
5401da177e4SLinus Torvalds 	},
5411da177e4SLinus Torvalds 	{
5421da177e4SLinus Torvalds 		.ctl_name	= KERN_OVERFLOWGID,
5431da177e4SLinus Torvalds 		.procname	= "overflowgid",
5441da177e4SLinus Torvalds 		.data		= &overflowgid,
5451da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5461da177e4SLinus Torvalds 		.mode		= 0644,
5471da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
5481da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
5491da177e4SLinus Torvalds 		.extra1		= &minolduid,
5501da177e4SLinus Torvalds 		.extra2		= &maxolduid,
5511da177e4SLinus Torvalds 	},
552347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390
5531da177e4SLinus Torvalds #ifdef CONFIG_MATHEMU
5541da177e4SLinus Torvalds 	{
5551da177e4SLinus Torvalds 		.ctl_name	= KERN_IEEE_EMULATION_WARNINGS,
5561da177e4SLinus Torvalds 		.procname	= "ieee_emulation_warnings",
5571da177e4SLinus Torvalds 		.data		= &sysctl_ieee_emulation_warnings,
5581da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5591da177e4SLinus Torvalds 		.mode		= 0644,
5601da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5611da177e4SLinus Torvalds 	},
5621da177e4SLinus Torvalds #endif
5631da177e4SLinus Torvalds #ifdef CONFIG_NO_IDLE_HZ
5641da177e4SLinus Torvalds 	{
5651da177e4SLinus Torvalds 		.ctl_name       = KERN_HZ_TIMER,
5661da177e4SLinus Torvalds 		.procname       = "hz_timer",
5671da177e4SLinus Torvalds 		.data           = &sysctl_hz_timer,
5681da177e4SLinus Torvalds 		.maxlen         = sizeof(int),
5691da177e4SLinus Torvalds 		.mode           = 0644,
5701da177e4SLinus Torvalds 		.proc_handler   = &proc_dointvec,
5711da177e4SLinus Torvalds 	},
5721da177e4SLinus Torvalds #endif
5731da177e4SLinus Torvalds 	{
5741da177e4SLinus Torvalds 		.ctl_name	= KERN_S390_USER_DEBUG_LOGGING,
5751da177e4SLinus Torvalds 		.procname	= "userprocess_debug",
5761da177e4SLinus Torvalds 		.data		= &sysctl_userprocess_debug,
5771da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5781da177e4SLinus Torvalds 		.mode		= 0644,
5791da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5801da177e4SLinus Torvalds 	},
5811da177e4SLinus Torvalds #endif
5821da177e4SLinus Torvalds 	{
5831da177e4SLinus Torvalds 		.ctl_name	= KERN_PIDMAX,
5841da177e4SLinus Torvalds 		.procname	= "pid_max",
5851da177e4SLinus Torvalds 		.data		= &pid_max,
5861da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5871da177e4SLinus Torvalds 		.mode		= 0644,
5881da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
5891da177e4SLinus Torvalds 		.strategy	= sysctl_intvec,
5901da177e4SLinus Torvalds 		.extra1		= &pid_max_min,
5911da177e4SLinus Torvalds 		.extra2		= &pid_max_max,
5921da177e4SLinus Torvalds 	},
5931da177e4SLinus Torvalds 	{
5941da177e4SLinus Torvalds 		.ctl_name	= KERN_PANIC_ON_OOPS,
5951da177e4SLinus Torvalds 		.procname	= "panic_on_oops",
5961da177e4SLinus Torvalds 		.data		= &panic_on_oops,
5971da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5981da177e4SLinus Torvalds 		.mode		= 0644,
5991da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6001da177e4SLinus Torvalds 	},
6011da177e4SLinus Torvalds 	{
6021da177e4SLinus Torvalds 		.ctl_name	= KERN_PRINTK_RATELIMIT,
6031da177e4SLinus Torvalds 		.procname	= "printk_ratelimit",
6041da177e4SLinus Torvalds 		.data		= &printk_ratelimit_jiffies,
6051da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6061da177e4SLinus Torvalds 		.mode		= 0644,
6071da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_jiffies,
6081da177e4SLinus Torvalds 		.strategy	= &sysctl_jiffies,
6091da177e4SLinus Torvalds 	},
6101da177e4SLinus Torvalds 	{
6111da177e4SLinus Torvalds 		.ctl_name	= KERN_PRINTK_RATELIMIT_BURST,
6121da177e4SLinus Torvalds 		.procname	= "printk_ratelimit_burst",
6131da177e4SLinus Torvalds 		.data		= &printk_ratelimit_burst,
6141da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6151da177e4SLinus Torvalds 		.mode		= 0644,
6161da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6171da177e4SLinus Torvalds 	},
6181da177e4SLinus Torvalds 	{
6191da177e4SLinus Torvalds 		.ctl_name	= KERN_NGROUPS_MAX,
6201da177e4SLinus Torvalds 		.procname	= "ngroups_max",
6211da177e4SLinus Torvalds 		.data		= &ngroups_max,
6221da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6231da177e4SLinus Torvalds 		.mode		= 0444,
6241da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6251da177e4SLinus Torvalds 	},
6261da177e4SLinus Torvalds #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
6271da177e4SLinus Torvalds 	{
6281da177e4SLinus Torvalds 		.ctl_name       = KERN_UNKNOWN_NMI_PANIC,
6291da177e4SLinus Torvalds 		.procname       = "unknown_nmi_panic",
6301da177e4SLinus Torvalds 		.data           = &unknown_nmi_panic,
6311da177e4SLinus Torvalds 		.maxlen         = sizeof (int),
6321da177e4SLinus Torvalds 		.mode           = 0644,
6331da177e4SLinus Torvalds 		.proc_handler   = &proc_unknown_nmi_panic,
6341da177e4SLinus Torvalds 	},
6351da177e4SLinus Torvalds #endif
6361da177e4SLinus Torvalds #if defined(CONFIG_X86)
6371da177e4SLinus Torvalds 	{
6381da177e4SLinus Torvalds 		.ctl_name	= KERN_BOOTLOADER_TYPE,
6391da177e4SLinus Torvalds 		.procname	= "bootloader_type",
6401da177e4SLinus Torvalds 		.data		= &bootloader_type,
6411da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6421da177e4SLinus Torvalds 		.mode		= 0444,
6431da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6441da177e4SLinus Torvalds 	},
6451da177e4SLinus Torvalds #endif
6467a9166e3SLuke Yang #if defined(CONFIG_MMU)
6471da177e4SLinus Torvalds 	{
6481da177e4SLinus Torvalds 		.ctl_name	= KERN_RANDOMIZE,
6491da177e4SLinus Torvalds 		.procname	= "randomize_va_space",
6501da177e4SLinus Torvalds 		.data		= &randomize_va_space,
6511da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6521da177e4SLinus Torvalds 		.mode		= 0644,
6531da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6541da177e4SLinus Torvalds 	},
6557a9166e3SLuke Yang #endif
6560152fb37SMartin Schwidefsky #if defined(CONFIG_S390) && defined(CONFIG_SMP)
657951f22d5SMartin Schwidefsky 	{
658951f22d5SMartin Schwidefsky 		.ctl_name	= KERN_SPIN_RETRY,
659951f22d5SMartin Schwidefsky 		.procname	= "spin_retry",
660951f22d5SMartin Schwidefsky 		.data		= &spin_retry,
661951f22d5SMartin Schwidefsky 		.maxlen		= sizeof (int),
662951f22d5SMartin Schwidefsky 		.mode		= 0644,
663951f22d5SMartin Schwidefsky 		.proc_handler	= &proc_dointvec,
664951f22d5SMartin Schwidefsky 	},
665951f22d5SMartin Schwidefsky #endif
666c255d844SPavel Machek #ifdef CONFIG_ACPI_SLEEP
667c255d844SPavel Machek 	{
668c255d844SPavel Machek 		.ctl_name	= KERN_ACPI_VIDEO_FLAGS,
669c255d844SPavel Machek 		.procname	= "acpi_video_flags",
670c255d844SPavel Machek 		.data		= &acpi_video_flags,
671c255d844SPavel Machek 		.maxlen		= sizeof (unsigned long),
672c255d844SPavel Machek 		.mode		= 0644,
6737f99f06fSStefan Seyfried 		.proc_handler	= &proc_doulongvec_minmax,
674c255d844SPavel Machek 	},
675c255d844SPavel Machek #endif
676d2b176edSJes Sorensen #ifdef CONFIG_IA64
677d2b176edSJes Sorensen 	{
678d2b176edSJes Sorensen 		.ctl_name	= KERN_IA64_UNALIGNED,
679d2b176edSJes Sorensen 		.procname	= "ignore-unaligned-usertrap",
680d2b176edSJes Sorensen 		.data		= &no_unaligned_warning,
681d2b176edSJes Sorensen 		.maxlen		= sizeof (int),
682d2b176edSJes Sorensen 	 	.mode		= 0644,
683d2b176edSJes Sorensen 		.proc_handler	= &proc_dointvec,
684d2b176edSJes Sorensen 	},
685d2b176edSJes Sorensen #endif
6861da177e4SLinus Torvalds 	{ .ctl_name = 0 }
6871da177e4SLinus Torvalds };
6881da177e4SLinus Torvalds 
6891da177e4SLinus Torvalds /* Constants for minimum and maximum testing in vm_table.
6901da177e4SLinus Torvalds    We use these as one-element integer vectors. */
6911da177e4SLinus Torvalds static int zero;
6921da177e4SLinus Torvalds static int one_hundred = 100;
6931da177e4SLinus Torvalds 
6941da177e4SLinus Torvalds 
6951da177e4SLinus Torvalds static ctl_table vm_table[] = {
6961da177e4SLinus Torvalds 	{
6971da177e4SLinus Torvalds 		.ctl_name	= VM_OVERCOMMIT_MEMORY,
6981da177e4SLinus Torvalds 		.procname	= "overcommit_memory",
6991da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_memory,
7001da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_memory),
7011da177e4SLinus Torvalds 		.mode		= 0644,
7021da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7031da177e4SLinus Torvalds 	},
7041da177e4SLinus Torvalds 	{
7051da177e4SLinus Torvalds 		.ctl_name	= VM_OVERCOMMIT_RATIO,
7061da177e4SLinus Torvalds 		.procname	= "overcommit_ratio",
7071da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_ratio,
7081da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_ratio),
7091da177e4SLinus Torvalds 		.mode		= 0644,
7101da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7111da177e4SLinus Torvalds 	},
7121da177e4SLinus Torvalds 	{
7131da177e4SLinus Torvalds 		.ctl_name	= VM_PAGE_CLUSTER,
7141da177e4SLinus Torvalds 		.procname	= "page-cluster",
7151da177e4SLinus Torvalds 		.data		= &page_cluster,
7161da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7171da177e4SLinus Torvalds 		.mode		= 0644,
7181da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7191da177e4SLinus Torvalds 	},
7201da177e4SLinus Torvalds 	{
7211da177e4SLinus Torvalds 		.ctl_name	= VM_DIRTY_BACKGROUND,
7221da177e4SLinus Torvalds 		.procname	= "dirty_background_ratio",
7231da177e4SLinus Torvalds 		.data		= &dirty_background_ratio,
7241da177e4SLinus Torvalds 		.maxlen		= sizeof(dirty_background_ratio),
7251da177e4SLinus Torvalds 		.mode		= 0644,
7261da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
7271da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
7281da177e4SLinus Torvalds 		.extra1		= &zero,
7291da177e4SLinus Torvalds 		.extra2		= &one_hundred,
7301da177e4SLinus Torvalds 	},
7311da177e4SLinus Torvalds 	{
7321da177e4SLinus Torvalds 		.ctl_name	= VM_DIRTY_RATIO,
7331da177e4SLinus Torvalds 		.procname	= "dirty_ratio",
7341da177e4SLinus Torvalds 		.data		= &vm_dirty_ratio,
7351da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_dirty_ratio),
7361da177e4SLinus Torvalds 		.mode		= 0644,
7371da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
7381da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
7391da177e4SLinus Torvalds 		.extra1		= &zero,
7401da177e4SLinus Torvalds 		.extra2		= &one_hundred,
7411da177e4SLinus Torvalds 	},
7421da177e4SLinus Torvalds 	{
7431da177e4SLinus Torvalds 		.ctl_name	= VM_DIRTY_WB_CS,
7441da177e4SLinus Torvalds 		.procname	= "dirty_writeback_centisecs",
7451da177e4SLinus Torvalds 		.data		= &dirty_writeback_centisecs,
7461da177e4SLinus Torvalds 		.maxlen		= sizeof(dirty_writeback_centisecs),
7471da177e4SLinus Torvalds 		.mode		= 0644,
7481da177e4SLinus Torvalds 		.proc_handler	= &dirty_writeback_centisecs_handler,
7491da177e4SLinus Torvalds 	},
7501da177e4SLinus Torvalds 	{
7511da177e4SLinus Torvalds 		.ctl_name	= VM_DIRTY_EXPIRE_CS,
7521da177e4SLinus Torvalds 		.procname	= "dirty_expire_centisecs",
7531da177e4SLinus Torvalds 		.data		= &dirty_expire_centisecs,
7541da177e4SLinus Torvalds 		.maxlen		= sizeof(dirty_expire_centisecs),
7551da177e4SLinus Torvalds 		.mode		= 0644,
7561da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7571da177e4SLinus Torvalds 	},
7581da177e4SLinus Torvalds 	{
7591da177e4SLinus Torvalds 		.ctl_name	= VM_NR_PDFLUSH_THREADS,
7601da177e4SLinus Torvalds 		.procname	= "nr_pdflush_threads",
7611da177e4SLinus Torvalds 		.data		= &nr_pdflush_threads,
7621da177e4SLinus Torvalds 		.maxlen		= sizeof nr_pdflush_threads,
7631da177e4SLinus Torvalds 		.mode		= 0444 /* read-only*/,
7641da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7651da177e4SLinus Torvalds 	},
7661da177e4SLinus Torvalds 	{
7671da177e4SLinus Torvalds 		.ctl_name	= VM_SWAPPINESS,
7681da177e4SLinus Torvalds 		.procname	= "swappiness",
7691da177e4SLinus Torvalds 		.data		= &vm_swappiness,
7701da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_swappiness),
7711da177e4SLinus Torvalds 		.mode		= 0644,
7721da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
7731da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
7741da177e4SLinus Torvalds 		.extra1		= &zero,
7751da177e4SLinus Torvalds 		.extra2		= &one_hundred,
7761da177e4SLinus Torvalds 	},
7771da177e4SLinus Torvalds #ifdef CONFIG_HUGETLB_PAGE
7781da177e4SLinus Torvalds 	 {
7791da177e4SLinus Torvalds 		.ctl_name	= VM_HUGETLB_PAGES,
7801da177e4SLinus Torvalds 		.procname	= "nr_hugepages",
7811da177e4SLinus Torvalds 		.data		= &max_huge_pages,
7821da177e4SLinus Torvalds 		.maxlen		= sizeof(unsigned long),
7831da177e4SLinus Torvalds 		.mode		= 0644,
7841da177e4SLinus Torvalds 		.proc_handler	= &hugetlb_sysctl_handler,
7851da177e4SLinus Torvalds 		.extra1		= (void *)&hugetlb_zero,
7861da177e4SLinus Torvalds 		.extra2		= (void *)&hugetlb_infinity,
7871da177e4SLinus Torvalds 	 },
7881da177e4SLinus Torvalds 	 {
7891da177e4SLinus Torvalds 		.ctl_name	= VM_HUGETLB_GROUP,
7901da177e4SLinus Torvalds 		.procname	= "hugetlb_shm_group",
7911da177e4SLinus Torvalds 		.data		= &sysctl_hugetlb_shm_group,
7921da177e4SLinus Torvalds 		.maxlen		= sizeof(gid_t),
7931da177e4SLinus Torvalds 		.mode		= 0644,
7941da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7951da177e4SLinus Torvalds 	 },
7961da177e4SLinus Torvalds #endif
7971da177e4SLinus Torvalds 	{
7981da177e4SLinus Torvalds 		.ctl_name	= VM_LOWMEM_RESERVE_RATIO,
7991da177e4SLinus Torvalds 		.procname	= "lowmem_reserve_ratio",
8001da177e4SLinus Torvalds 		.data		= &sysctl_lowmem_reserve_ratio,
8011da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
8021da177e4SLinus Torvalds 		.mode		= 0644,
8031da177e4SLinus Torvalds 		.proc_handler	= &lowmem_reserve_ratio_sysctl_handler,
8041da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
8051da177e4SLinus Torvalds 	},
8061da177e4SLinus Torvalds 	{
8079d0243bcSAndrew Morton 		.ctl_name	= VM_DROP_PAGECACHE,
8089d0243bcSAndrew Morton 		.procname	= "drop_caches",
8099d0243bcSAndrew Morton 		.data		= &sysctl_drop_caches,
8109d0243bcSAndrew Morton 		.maxlen		= sizeof(int),
8119d0243bcSAndrew Morton 		.mode		= 0644,
8129d0243bcSAndrew Morton 		.proc_handler	= drop_caches_sysctl_handler,
8139d0243bcSAndrew Morton 		.strategy	= &sysctl_intvec,
8149d0243bcSAndrew Morton 	},
8159d0243bcSAndrew Morton 	{
8161da177e4SLinus Torvalds 		.ctl_name	= VM_MIN_FREE_KBYTES,
8171da177e4SLinus Torvalds 		.procname	= "min_free_kbytes",
8181da177e4SLinus Torvalds 		.data		= &min_free_kbytes,
8191da177e4SLinus Torvalds 		.maxlen		= sizeof(min_free_kbytes),
8201da177e4SLinus Torvalds 		.mode		= 0644,
8211da177e4SLinus Torvalds 		.proc_handler	= &min_free_kbytes_sysctl_handler,
8221da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
8231da177e4SLinus Torvalds 		.extra1		= &zero,
8241da177e4SLinus Torvalds 	},
8258ad4b1fbSRohit Seth 	{
8268ad4b1fbSRohit Seth 		.ctl_name	= VM_PERCPU_PAGELIST_FRACTION,
8278ad4b1fbSRohit Seth 		.procname	= "percpu_pagelist_fraction",
8288ad4b1fbSRohit Seth 		.data		= &percpu_pagelist_fraction,
8298ad4b1fbSRohit Seth 		.maxlen		= sizeof(percpu_pagelist_fraction),
8308ad4b1fbSRohit Seth 		.mode		= 0644,
8318ad4b1fbSRohit Seth 		.proc_handler	= &percpu_pagelist_fraction_sysctl_handler,
8328ad4b1fbSRohit Seth 		.strategy	= &sysctl_intvec,
8338ad4b1fbSRohit Seth 		.extra1		= &min_percpu_pagelist_fract,
8348ad4b1fbSRohit Seth 	},
8351da177e4SLinus Torvalds #ifdef CONFIG_MMU
8361da177e4SLinus Torvalds 	{
8371da177e4SLinus Torvalds 		.ctl_name	= VM_MAX_MAP_COUNT,
8381da177e4SLinus Torvalds 		.procname	= "max_map_count",
8391da177e4SLinus Torvalds 		.data		= &sysctl_max_map_count,
8401da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_max_map_count),
8411da177e4SLinus Torvalds 		.mode		= 0644,
8421da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec
8431da177e4SLinus Torvalds 	},
8441da177e4SLinus Torvalds #endif
8451da177e4SLinus Torvalds 	{
8461da177e4SLinus Torvalds 		.ctl_name	= VM_LAPTOP_MODE,
8471da177e4SLinus Torvalds 		.procname	= "laptop_mode",
8481da177e4SLinus Torvalds 		.data		= &laptop_mode,
8491da177e4SLinus Torvalds 		.maxlen		= sizeof(laptop_mode),
8501da177e4SLinus Torvalds 		.mode		= 0644,
8511da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
8521da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
8531da177e4SLinus Torvalds 		.extra1		= &zero,
8541da177e4SLinus Torvalds 	},
8551da177e4SLinus Torvalds 	{
8561da177e4SLinus Torvalds 		.ctl_name	= VM_BLOCK_DUMP,
8571da177e4SLinus Torvalds 		.procname	= "block_dump",
8581da177e4SLinus Torvalds 		.data		= &block_dump,
8591da177e4SLinus Torvalds 		.maxlen		= sizeof(block_dump),
8601da177e4SLinus Torvalds 		.mode		= 0644,
8611da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
8621da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
8631da177e4SLinus Torvalds 		.extra1		= &zero,
8641da177e4SLinus Torvalds 	},
8651da177e4SLinus Torvalds 	{
8661da177e4SLinus Torvalds 		.ctl_name	= VM_VFS_CACHE_PRESSURE,
8671da177e4SLinus Torvalds 		.procname	= "vfs_cache_pressure",
8681da177e4SLinus Torvalds 		.data		= &sysctl_vfs_cache_pressure,
8691da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
8701da177e4SLinus Torvalds 		.mode		= 0644,
8711da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
8721da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
8731da177e4SLinus Torvalds 		.extra1		= &zero,
8741da177e4SLinus Torvalds 	},
8751da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
8761da177e4SLinus Torvalds 	{
8771da177e4SLinus Torvalds 		.ctl_name	= VM_LEGACY_VA_LAYOUT,
8781da177e4SLinus Torvalds 		.procname	= "legacy_va_layout",
8791da177e4SLinus Torvalds 		.data		= &sysctl_legacy_va_layout,
8801da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_legacy_va_layout),
8811da177e4SLinus Torvalds 		.mode		= 0644,
8821da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
8831da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
8841da177e4SLinus Torvalds 		.extra1		= &zero,
8851da177e4SLinus Torvalds 	},
8861da177e4SLinus Torvalds #endif
8871da177e4SLinus Torvalds #ifdef CONFIG_SWAP
8881da177e4SLinus Torvalds 	{
8891da177e4SLinus Torvalds 		.ctl_name	= VM_SWAP_TOKEN_TIMEOUT,
8901da177e4SLinus Torvalds 		.procname	= "swap_token_timeout",
8911da177e4SLinus Torvalds 		.data		= &swap_token_default_timeout,
8921da177e4SLinus Torvalds 		.maxlen		= sizeof(swap_token_default_timeout),
8931da177e4SLinus Torvalds 		.mode		= 0644,
8941da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_jiffies,
8951da177e4SLinus Torvalds 		.strategy	= &sysctl_jiffies,
8961da177e4SLinus Torvalds 	},
8971da177e4SLinus Torvalds #endif
8981743660bSChristoph Lameter #ifdef CONFIG_NUMA
8991743660bSChristoph Lameter 	{
9001743660bSChristoph Lameter 		.ctl_name	= VM_ZONE_RECLAIM_MODE,
9011743660bSChristoph Lameter 		.procname	= "zone_reclaim_mode",
9021743660bSChristoph Lameter 		.data		= &zone_reclaim_mode,
9031743660bSChristoph Lameter 		.maxlen		= sizeof(zone_reclaim_mode),
9041743660bSChristoph Lameter 		.mode		= 0644,
9051743660bSChristoph Lameter 		.proc_handler	= &proc_dointvec,
906c84db23cSChristoph Lameter 		.strategy	= &sysctl_intvec,
907c84db23cSChristoph Lameter 		.extra1		= &zero,
9081743660bSChristoph Lameter 	},
9092a11ff06SChristoph Lameter 	{
9102a11ff06SChristoph Lameter 		.ctl_name	= VM_ZONE_RECLAIM_INTERVAL,
9112a11ff06SChristoph Lameter 		.procname	= "zone_reclaim_interval",
9122a11ff06SChristoph Lameter 		.data		= &zone_reclaim_interval,
9132a11ff06SChristoph Lameter 		.maxlen		= sizeof(zone_reclaim_interval),
9142a11ff06SChristoph Lameter 		.mode		= 0644,
9152a11ff06SChristoph Lameter 		.proc_handler	= &proc_dointvec_jiffies,
9162a11ff06SChristoph Lameter 		.strategy	= &sysctl_jiffies,
9172a11ff06SChristoph Lameter 	},
9181743660bSChristoph Lameter #endif
9191da177e4SLinus Torvalds 	{ .ctl_name = 0 }
9201da177e4SLinus Torvalds };
9211da177e4SLinus Torvalds 
9221da177e4SLinus Torvalds static ctl_table proc_table[] = {
9231da177e4SLinus Torvalds 	{ .ctl_name = 0 }
9241da177e4SLinus Torvalds };
9251da177e4SLinus Torvalds 
9261da177e4SLinus Torvalds static ctl_table fs_table[] = {
9271da177e4SLinus Torvalds 	{
9281da177e4SLinus Torvalds 		.ctl_name	= FS_NRINODE,
9291da177e4SLinus Torvalds 		.procname	= "inode-nr",
9301da177e4SLinus Torvalds 		.data		= &inodes_stat,
9311da177e4SLinus Torvalds 		.maxlen		= 2*sizeof(int),
9321da177e4SLinus Torvalds 		.mode		= 0444,
9331da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9341da177e4SLinus Torvalds 	},
9351da177e4SLinus Torvalds 	{
9361da177e4SLinus Torvalds 		.ctl_name	= FS_STATINODE,
9371da177e4SLinus Torvalds 		.procname	= "inode-state",
9381da177e4SLinus Torvalds 		.data		= &inodes_stat,
9391da177e4SLinus Torvalds 		.maxlen		= 7*sizeof(int),
9401da177e4SLinus Torvalds 		.mode		= 0444,
9411da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9421da177e4SLinus Torvalds 	},
9431da177e4SLinus Torvalds 	{
9441da177e4SLinus Torvalds 		.ctl_name	= FS_NRFILE,
9451da177e4SLinus Torvalds 		.procname	= "file-nr",
9461da177e4SLinus Torvalds 		.data		= &files_stat,
9471da177e4SLinus Torvalds 		.maxlen		= 3*sizeof(int),
9481da177e4SLinus Torvalds 		.mode		= 0444,
949*529bf6beSDipankar Sarma 		.proc_handler	= &proc_nr_files,
9501da177e4SLinus Torvalds 	},
9511da177e4SLinus Torvalds 	{
9521da177e4SLinus Torvalds 		.ctl_name	= FS_MAXFILE,
9531da177e4SLinus Torvalds 		.procname	= "file-max",
9541da177e4SLinus Torvalds 		.data		= &files_stat.max_files,
9551da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
9561da177e4SLinus Torvalds 		.mode		= 0644,
9571da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9581da177e4SLinus Torvalds 	},
9591da177e4SLinus Torvalds 	{
9601da177e4SLinus Torvalds 		.ctl_name	= FS_DENTRY,
9611da177e4SLinus Torvalds 		.procname	= "dentry-state",
9621da177e4SLinus Torvalds 		.data		= &dentry_stat,
9631da177e4SLinus Torvalds 		.maxlen		= 6*sizeof(int),
9641da177e4SLinus Torvalds 		.mode		= 0444,
9651da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9661da177e4SLinus Torvalds 	},
9671da177e4SLinus Torvalds 	{
9681da177e4SLinus Torvalds 		.ctl_name	= FS_OVERFLOWUID,
9691da177e4SLinus Torvalds 		.procname	= "overflowuid",
9701da177e4SLinus Torvalds 		.data		= &fs_overflowuid,
9711da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
9721da177e4SLinus Torvalds 		.mode		= 0644,
9731da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
9741da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
9751da177e4SLinus Torvalds 		.extra1		= &minolduid,
9761da177e4SLinus Torvalds 		.extra2		= &maxolduid,
9771da177e4SLinus Torvalds 	},
9781da177e4SLinus Torvalds 	{
9791da177e4SLinus Torvalds 		.ctl_name	= FS_OVERFLOWGID,
9801da177e4SLinus Torvalds 		.procname	= "overflowgid",
9811da177e4SLinus Torvalds 		.data		= &fs_overflowgid,
9821da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
9831da177e4SLinus Torvalds 		.mode		= 0644,
9841da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
9851da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
9861da177e4SLinus Torvalds 		.extra1		= &minolduid,
9871da177e4SLinus Torvalds 		.extra2		= &maxolduid,
9881da177e4SLinus Torvalds 	},
9891da177e4SLinus Torvalds 	{
9901da177e4SLinus Torvalds 		.ctl_name	= FS_LEASES,
9911da177e4SLinus Torvalds 		.procname	= "leases-enable",
9921da177e4SLinus Torvalds 		.data		= &leases_enable,
9931da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
9941da177e4SLinus Torvalds 		.mode		= 0644,
9951da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9961da177e4SLinus Torvalds 	},
9971da177e4SLinus Torvalds #ifdef CONFIG_DNOTIFY
9981da177e4SLinus Torvalds 	{
9991da177e4SLinus Torvalds 		.ctl_name	= FS_DIR_NOTIFY,
10001da177e4SLinus Torvalds 		.procname	= "dir-notify-enable",
10011da177e4SLinus Torvalds 		.data		= &dir_notify_enable,
10021da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
10031da177e4SLinus Torvalds 		.mode		= 0644,
10041da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
10051da177e4SLinus Torvalds 	},
10061da177e4SLinus Torvalds #endif
10071da177e4SLinus Torvalds #ifdef CONFIG_MMU
10081da177e4SLinus Torvalds 	{
10091da177e4SLinus Torvalds 		.ctl_name	= FS_LEASE_TIME,
10101da177e4SLinus Torvalds 		.procname	= "lease-break-time",
10111da177e4SLinus Torvalds 		.data		= &lease_break_time,
10121da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
10131da177e4SLinus Torvalds 		.mode		= 0644,
10141da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
10151da177e4SLinus Torvalds 	},
10161da177e4SLinus Torvalds 	{
10171da177e4SLinus Torvalds 		.ctl_name	= FS_AIO_NR,
10181da177e4SLinus Torvalds 		.procname	= "aio-nr",
10191da177e4SLinus Torvalds 		.data		= &aio_nr,
10201da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_nr),
10211da177e4SLinus Torvalds 		.mode		= 0444,
1022d55b5fdaSZach Brown 		.proc_handler	= &proc_doulongvec_minmax,
10231da177e4SLinus Torvalds 	},
10241da177e4SLinus Torvalds 	{
10251da177e4SLinus Torvalds 		.ctl_name	= FS_AIO_MAX_NR,
10261da177e4SLinus Torvalds 		.procname	= "aio-max-nr",
10271da177e4SLinus Torvalds 		.data		= &aio_max_nr,
10281da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_max_nr),
10291da177e4SLinus Torvalds 		.mode		= 0644,
1030d55b5fdaSZach Brown 		.proc_handler	= &proc_doulongvec_minmax,
10311da177e4SLinus Torvalds 	},
10320399cb08SRobert Love #ifdef CONFIG_INOTIFY
10330399cb08SRobert Love 	{
10340399cb08SRobert Love 		.ctl_name	= FS_INOTIFY,
10350399cb08SRobert Love 		.procname	= "inotify",
10360399cb08SRobert Love 		.mode		= 0555,
10370399cb08SRobert Love 		.child		= inotify_table,
10380399cb08SRobert Love 	},
10390399cb08SRobert Love #endif
10401da177e4SLinus Torvalds #endif
1041d6e71144SAlan Cox 	{
1042d6e71144SAlan Cox 		.ctl_name	= KERN_SETUID_DUMPABLE,
1043d6e71144SAlan Cox 		.procname	= "suid_dumpable",
1044d6e71144SAlan Cox 		.data		= &suid_dumpable,
1045d6e71144SAlan Cox 		.maxlen		= sizeof(int),
1046d6e71144SAlan Cox 		.mode		= 0644,
1047d6e71144SAlan Cox 		.proc_handler	= &proc_dointvec,
1048d6e71144SAlan Cox 	},
10491da177e4SLinus Torvalds 	{ .ctl_name = 0 }
10501da177e4SLinus Torvalds };
10511da177e4SLinus Torvalds 
10521da177e4SLinus Torvalds static ctl_table debug_table[] = {
10531da177e4SLinus Torvalds 	{ .ctl_name = 0 }
10541da177e4SLinus Torvalds };
10551da177e4SLinus Torvalds 
10561da177e4SLinus Torvalds static ctl_table dev_table[] = {
10571da177e4SLinus Torvalds 	{ .ctl_name = 0 }
10581da177e4SLinus Torvalds };
10591da177e4SLinus Torvalds 
10601da177e4SLinus Torvalds extern void init_irq_proc (void);
10611da177e4SLinus Torvalds 
1062330d57fbSAl Viro static DEFINE_SPINLOCK(sysctl_lock);
1063330d57fbSAl Viro 
1064330d57fbSAl Viro /* called under sysctl_lock */
1065330d57fbSAl Viro static int use_table(struct ctl_table_header *p)
1066330d57fbSAl Viro {
1067330d57fbSAl Viro 	if (unlikely(p->unregistering))
1068330d57fbSAl Viro 		return 0;
1069330d57fbSAl Viro 	p->used++;
1070330d57fbSAl Viro 	return 1;
1071330d57fbSAl Viro }
1072330d57fbSAl Viro 
1073330d57fbSAl Viro /* called under sysctl_lock */
1074330d57fbSAl Viro static void unuse_table(struct ctl_table_header *p)
1075330d57fbSAl Viro {
1076330d57fbSAl Viro 	if (!--p->used)
1077330d57fbSAl Viro 		if (unlikely(p->unregistering))
1078330d57fbSAl Viro 			complete(p->unregistering);
1079330d57fbSAl Viro }
1080330d57fbSAl Viro 
1081330d57fbSAl Viro /* called under sysctl_lock, will reacquire if has to wait */
1082330d57fbSAl Viro static void start_unregistering(struct ctl_table_header *p)
1083330d57fbSAl Viro {
1084330d57fbSAl Viro 	/*
1085330d57fbSAl Viro 	 * if p->used is 0, nobody will ever touch that entry again;
1086330d57fbSAl Viro 	 * we'll eliminate all paths to it before dropping sysctl_lock
1087330d57fbSAl Viro 	 */
1088330d57fbSAl Viro 	if (unlikely(p->used)) {
1089330d57fbSAl Viro 		struct completion wait;
1090330d57fbSAl Viro 		init_completion(&wait);
1091330d57fbSAl Viro 		p->unregistering = &wait;
1092330d57fbSAl Viro 		spin_unlock(&sysctl_lock);
1093330d57fbSAl Viro 		wait_for_completion(&wait);
1094330d57fbSAl Viro 		spin_lock(&sysctl_lock);
1095330d57fbSAl Viro 	}
1096330d57fbSAl Viro 	/*
1097330d57fbSAl Viro 	 * do not remove from the list until nobody holds it; walking the
1098330d57fbSAl Viro 	 * list in do_sysctl() relies on that.
1099330d57fbSAl Viro 	 */
1100330d57fbSAl Viro 	list_del_init(&p->ctl_entry);
1101330d57fbSAl Viro }
1102330d57fbSAl Viro 
11031da177e4SLinus Torvalds void __init sysctl_init(void)
11041da177e4SLinus Torvalds {
11051da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
1106330d57fbSAl Viro 	register_proc_table(root_table, proc_sys_root, &root_table_header);
11071da177e4SLinus Torvalds 	init_irq_proc();
11081da177e4SLinus Torvalds #endif
11091da177e4SLinus Torvalds }
11101da177e4SLinus Torvalds 
11111da177e4SLinus Torvalds int do_sysctl(int __user *name, int nlen, void __user *oldval, size_t __user *oldlenp,
11121da177e4SLinus Torvalds 	       void __user *newval, size_t newlen)
11131da177e4SLinus Torvalds {
11141da177e4SLinus Torvalds 	struct list_head *tmp;
1115330d57fbSAl Viro 	int error = -ENOTDIR;
11161da177e4SLinus Torvalds 
11171da177e4SLinus Torvalds 	if (nlen <= 0 || nlen >= CTL_MAXNAME)
11181da177e4SLinus Torvalds 		return -ENOTDIR;
11191da177e4SLinus Torvalds 	if (oldval) {
11201da177e4SLinus Torvalds 		int old_len;
11211da177e4SLinus Torvalds 		if (!oldlenp || get_user(old_len, oldlenp))
11221da177e4SLinus Torvalds 			return -EFAULT;
11231da177e4SLinus Torvalds 	}
1124330d57fbSAl Viro 	spin_lock(&sysctl_lock);
11251da177e4SLinus Torvalds 	tmp = &root_table_header.ctl_entry;
11261da177e4SLinus Torvalds 	do {
11271da177e4SLinus Torvalds 		struct ctl_table_header *head =
11281da177e4SLinus Torvalds 			list_entry(tmp, struct ctl_table_header, ctl_entry);
11291da177e4SLinus Torvalds 		void *context = NULL;
1130330d57fbSAl Viro 
1131330d57fbSAl Viro 		if (!use_table(head))
1132330d57fbSAl Viro 			continue;
1133330d57fbSAl Viro 
1134330d57fbSAl Viro 		spin_unlock(&sysctl_lock);
1135330d57fbSAl Viro 
1136330d57fbSAl Viro 		error = parse_table(name, nlen, oldval, oldlenp,
11371da177e4SLinus Torvalds 					newval, newlen, head->ctl_table,
11381da177e4SLinus Torvalds 					&context);
11391da177e4SLinus Torvalds 		kfree(context);
1140330d57fbSAl Viro 
1141330d57fbSAl Viro 		spin_lock(&sysctl_lock);
1142330d57fbSAl Viro 		unuse_table(head);
11431da177e4SLinus Torvalds 		if (error != -ENOTDIR)
1144330d57fbSAl Viro 			break;
1145330d57fbSAl Viro 	} while ((tmp = tmp->next) != &root_table_header.ctl_entry);
1146330d57fbSAl Viro 	spin_unlock(&sysctl_lock);
11471da177e4SLinus Torvalds 	return error;
11481da177e4SLinus Torvalds }
11491da177e4SLinus Torvalds 
11501da177e4SLinus Torvalds asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
11511da177e4SLinus Torvalds {
11521da177e4SLinus Torvalds 	struct __sysctl_args tmp;
11531da177e4SLinus Torvalds 	int error;
11541da177e4SLinus Torvalds 
11551da177e4SLinus Torvalds 	if (copy_from_user(&tmp, args, sizeof(tmp)))
11561da177e4SLinus Torvalds 		return -EFAULT;
11571da177e4SLinus Torvalds 
11581da177e4SLinus Torvalds 	lock_kernel();
11591da177e4SLinus Torvalds 	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
11601da177e4SLinus Torvalds 			  tmp.newval, tmp.newlen);
11611da177e4SLinus Torvalds 	unlock_kernel();
11621da177e4SLinus Torvalds 	return error;
11631da177e4SLinus Torvalds }
11641da177e4SLinus Torvalds 
11651da177e4SLinus Torvalds /*
11661da177e4SLinus Torvalds  * ctl_perm does NOT grant the superuser all rights automatically, because
11671da177e4SLinus Torvalds  * some sysctl variables are readonly even to root.
11681da177e4SLinus Torvalds  */
11691da177e4SLinus Torvalds 
11701da177e4SLinus Torvalds static int test_perm(int mode, int op)
11711da177e4SLinus Torvalds {
11721da177e4SLinus Torvalds 	if (!current->euid)
11731da177e4SLinus Torvalds 		mode >>= 6;
11741da177e4SLinus Torvalds 	else if (in_egroup_p(0))
11751da177e4SLinus Torvalds 		mode >>= 3;
11761da177e4SLinus Torvalds 	if ((mode & op & 0007) == op)
11771da177e4SLinus Torvalds 		return 0;
11781da177e4SLinus Torvalds 	return -EACCES;
11791da177e4SLinus Torvalds }
11801da177e4SLinus Torvalds 
11811da177e4SLinus Torvalds static inline int ctl_perm(ctl_table *table, int op)
11821da177e4SLinus Torvalds {
11831da177e4SLinus Torvalds 	int error;
11841da177e4SLinus Torvalds 	error = security_sysctl(table, op);
11851da177e4SLinus Torvalds 	if (error)
11861da177e4SLinus Torvalds 		return error;
11871da177e4SLinus Torvalds 	return test_perm(table->mode, op);
11881da177e4SLinus Torvalds }
11891da177e4SLinus Torvalds 
11901da177e4SLinus Torvalds static int parse_table(int __user *name, int nlen,
11911da177e4SLinus Torvalds 		       void __user *oldval, size_t __user *oldlenp,
11921da177e4SLinus Torvalds 		       void __user *newval, size_t newlen,
11931da177e4SLinus Torvalds 		       ctl_table *table, void **context)
11941da177e4SLinus Torvalds {
11951da177e4SLinus Torvalds 	int n;
11961da177e4SLinus Torvalds repeat:
11971da177e4SLinus Torvalds 	if (!nlen)
11981da177e4SLinus Torvalds 		return -ENOTDIR;
11991da177e4SLinus Torvalds 	if (get_user(n, name))
12001da177e4SLinus Torvalds 		return -EFAULT;
12011da177e4SLinus Torvalds 	for ( ; table->ctl_name; table++) {
12021da177e4SLinus Torvalds 		if (n == table->ctl_name || table->ctl_name == CTL_ANY) {
12031da177e4SLinus Torvalds 			int error;
12041da177e4SLinus Torvalds 			if (table->child) {
12051da177e4SLinus Torvalds 				if (ctl_perm(table, 001))
12061da177e4SLinus Torvalds 					return -EPERM;
12071da177e4SLinus Torvalds 				if (table->strategy) {
12081da177e4SLinus Torvalds 					error = table->strategy(
12091da177e4SLinus Torvalds 						table, name, nlen,
12101da177e4SLinus Torvalds 						oldval, oldlenp,
12111da177e4SLinus Torvalds 						newval, newlen, context);
12121da177e4SLinus Torvalds 					if (error)
12131da177e4SLinus Torvalds 						return error;
12141da177e4SLinus Torvalds 				}
12151da177e4SLinus Torvalds 				name++;
12161da177e4SLinus Torvalds 				nlen--;
12171da177e4SLinus Torvalds 				table = table->child;
12181da177e4SLinus Torvalds 				goto repeat;
12191da177e4SLinus Torvalds 			}
12201da177e4SLinus Torvalds 			error = do_sysctl_strategy(table, name, nlen,
12211da177e4SLinus Torvalds 						   oldval, oldlenp,
12221da177e4SLinus Torvalds 						   newval, newlen, context);
12231da177e4SLinus Torvalds 			return error;
12241da177e4SLinus Torvalds 		}
12251da177e4SLinus Torvalds 	}
12261da177e4SLinus Torvalds 	return -ENOTDIR;
12271da177e4SLinus Torvalds }
12281da177e4SLinus Torvalds 
12291da177e4SLinus Torvalds /* Perform the actual read/write of a sysctl table entry. */
12301da177e4SLinus Torvalds int do_sysctl_strategy (ctl_table *table,
12311da177e4SLinus Torvalds 			int __user *name, int nlen,
12321da177e4SLinus Torvalds 			void __user *oldval, size_t __user *oldlenp,
12331da177e4SLinus Torvalds 			void __user *newval, size_t newlen, void **context)
12341da177e4SLinus Torvalds {
12351da177e4SLinus Torvalds 	int op = 0, rc;
12361da177e4SLinus Torvalds 	size_t len;
12371da177e4SLinus Torvalds 
12381da177e4SLinus Torvalds 	if (oldval)
12391da177e4SLinus Torvalds 		op |= 004;
12401da177e4SLinus Torvalds 	if (newval)
12411da177e4SLinus Torvalds 		op |= 002;
12421da177e4SLinus Torvalds 	if (ctl_perm(table, op))
12431da177e4SLinus Torvalds 		return -EPERM;
12441da177e4SLinus Torvalds 
12451da177e4SLinus Torvalds 	if (table->strategy) {
12461da177e4SLinus Torvalds 		rc = table->strategy(table, name, nlen, oldval, oldlenp,
12471da177e4SLinus Torvalds 				     newval, newlen, context);
12481da177e4SLinus Torvalds 		if (rc < 0)
12491da177e4SLinus Torvalds 			return rc;
12501da177e4SLinus Torvalds 		if (rc > 0)
12511da177e4SLinus Torvalds 			return 0;
12521da177e4SLinus Torvalds 	}
12531da177e4SLinus Torvalds 
12541da177e4SLinus Torvalds 	/* If there is no strategy routine, or if the strategy returns
12551da177e4SLinus Torvalds 	 * zero, proceed with automatic r/w */
12561da177e4SLinus Torvalds 	if (table->data && table->maxlen) {
12571da177e4SLinus Torvalds 		if (oldval && oldlenp) {
12581da177e4SLinus Torvalds 			if (get_user(len, oldlenp))
12591da177e4SLinus Torvalds 				return -EFAULT;
12601da177e4SLinus Torvalds 			if (len) {
12611da177e4SLinus Torvalds 				if (len > table->maxlen)
12621da177e4SLinus Torvalds 					len = table->maxlen;
12631da177e4SLinus Torvalds 				if(copy_to_user(oldval, table->data, len))
12641da177e4SLinus Torvalds 					return -EFAULT;
12651da177e4SLinus Torvalds 				if(put_user(len, oldlenp))
12661da177e4SLinus Torvalds 					return -EFAULT;
12671da177e4SLinus Torvalds 			}
12681da177e4SLinus Torvalds 		}
12691da177e4SLinus Torvalds 		if (newval && newlen) {
12701da177e4SLinus Torvalds 			len = newlen;
12711da177e4SLinus Torvalds 			if (len > table->maxlen)
12721da177e4SLinus Torvalds 				len = table->maxlen;
12731da177e4SLinus Torvalds 			if(copy_from_user(table->data, newval, len))
12741da177e4SLinus Torvalds 				return -EFAULT;
12751da177e4SLinus Torvalds 		}
12761da177e4SLinus Torvalds 	}
12771da177e4SLinus Torvalds 	return 0;
12781da177e4SLinus Torvalds }
12791da177e4SLinus Torvalds 
12801da177e4SLinus Torvalds /**
12811da177e4SLinus Torvalds  * register_sysctl_table - register a sysctl hierarchy
12821da177e4SLinus Torvalds  * @table: the top-level table structure
12831da177e4SLinus Torvalds  * @insert_at_head: whether the entry should be inserted in front or at the end
12841da177e4SLinus Torvalds  *
12851da177e4SLinus Torvalds  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
12861da177e4SLinus Torvalds  * array. An entry with a ctl_name of 0 terminates the table.
12871da177e4SLinus Torvalds  *
12881da177e4SLinus Torvalds  * The members of the &ctl_table structure are used as follows:
12891da177e4SLinus Torvalds  *
12901da177e4SLinus Torvalds  * ctl_name - This is the numeric sysctl value used by sysctl(2). The number
12911da177e4SLinus Torvalds  *            must be unique within that level of sysctl
12921da177e4SLinus Torvalds  *
12931da177e4SLinus Torvalds  * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
12941da177e4SLinus Torvalds  *            enter a sysctl file
12951da177e4SLinus Torvalds  *
12961da177e4SLinus Torvalds  * data - a pointer to data for use by proc_handler
12971da177e4SLinus Torvalds  *
12981da177e4SLinus Torvalds  * maxlen - the maximum size in bytes of the data
12991da177e4SLinus Torvalds  *
13001da177e4SLinus Torvalds  * mode - the file permissions for the /proc/sys file, and for sysctl(2)
13011da177e4SLinus Torvalds  *
13021da177e4SLinus Torvalds  * child - a pointer to the child sysctl table if this entry is a directory, or
13031da177e4SLinus Torvalds  *         %NULL.
13041da177e4SLinus Torvalds  *
13051da177e4SLinus Torvalds  * proc_handler - the text handler routine (described below)
13061da177e4SLinus Torvalds  *
13071da177e4SLinus Torvalds  * strategy - the strategy routine (described below)
13081da177e4SLinus Torvalds  *
13091da177e4SLinus Torvalds  * de - for internal use by the sysctl routines
13101da177e4SLinus Torvalds  *
13111da177e4SLinus Torvalds  * extra1, extra2 - extra pointers usable by the proc handler routines
13121da177e4SLinus Torvalds  *
13131da177e4SLinus Torvalds  * Leaf nodes in the sysctl tree will be represented by a single file
13141da177e4SLinus Torvalds  * under /proc; non-leaf nodes will be represented by directories.
13151da177e4SLinus Torvalds  *
13161da177e4SLinus Torvalds  * sysctl(2) can automatically manage read and write requests through
13171da177e4SLinus Torvalds  * the sysctl table.  The data and maxlen fields of the ctl_table
13181da177e4SLinus Torvalds  * struct enable minimal validation of the values being written to be
13191da177e4SLinus Torvalds  * performed, and the mode field allows minimal authentication.
13201da177e4SLinus Torvalds  *
13211da177e4SLinus Torvalds  * More sophisticated management can be enabled by the provision of a
13221da177e4SLinus Torvalds  * strategy routine with the table entry.  This will be called before
13231da177e4SLinus Torvalds  * any automatic read or write of the data is performed.
13241da177e4SLinus Torvalds  *
13251da177e4SLinus Torvalds  * The strategy routine may return
13261da177e4SLinus Torvalds  *
13271da177e4SLinus Torvalds  * < 0 - Error occurred (error is passed to user process)
13281da177e4SLinus Torvalds  *
13291da177e4SLinus Torvalds  * 0   - OK - proceed with automatic read or write.
13301da177e4SLinus Torvalds  *
13311da177e4SLinus Torvalds  * > 0 - OK - read or write has been done by the strategy routine, so
13321da177e4SLinus Torvalds  *       return immediately.
13331da177e4SLinus Torvalds  *
13341da177e4SLinus Torvalds  * There must be a proc_handler routine for any terminal nodes
13351da177e4SLinus Torvalds  * mirrored under /proc/sys (non-terminals are handled by a built-in
13361da177e4SLinus Torvalds  * directory handler).  Several default handlers are available to
13371da177e4SLinus Torvalds  * cover common cases -
13381da177e4SLinus Torvalds  *
13391da177e4SLinus Torvalds  * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
13401da177e4SLinus Torvalds  * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
13411da177e4SLinus Torvalds  * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
13421da177e4SLinus Torvalds  *
13431da177e4SLinus Torvalds  * It is the handler's job to read the input buffer from user memory
13441da177e4SLinus Torvalds  * and process it. The handler should return 0 on success.
13451da177e4SLinus Torvalds  *
13461da177e4SLinus Torvalds  * This routine returns %NULL on a failure to register, and a pointer
13471da177e4SLinus Torvalds  * to the table header on success.
13481da177e4SLinus Torvalds  */
13491da177e4SLinus Torvalds struct ctl_table_header *register_sysctl_table(ctl_table * table,
13501da177e4SLinus Torvalds 					       int insert_at_head)
13511da177e4SLinus Torvalds {
13521da177e4SLinus Torvalds 	struct ctl_table_header *tmp;
13531da177e4SLinus Torvalds 	tmp = kmalloc(sizeof(struct ctl_table_header), GFP_KERNEL);
13541da177e4SLinus Torvalds 	if (!tmp)
13551da177e4SLinus Torvalds 		return NULL;
13561da177e4SLinus Torvalds 	tmp->ctl_table = table;
13571da177e4SLinus Torvalds 	INIT_LIST_HEAD(&tmp->ctl_entry);
1358330d57fbSAl Viro 	tmp->used = 0;
1359330d57fbSAl Viro 	tmp->unregistering = NULL;
1360330d57fbSAl Viro 	spin_lock(&sysctl_lock);
13611da177e4SLinus Torvalds 	if (insert_at_head)
13621da177e4SLinus Torvalds 		list_add(&tmp->ctl_entry, &root_table_header.ctl_entry);
13631da177e4SLinus Torvalds 	else
13641da177e4SLinus Torvalds 		list_add_tail(&tmp->ctl_entry, &root_table_header.ctl_entry);
1365330d57fbSAl Viro 	spin_unlock(&sysctl_lock);
13661da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
1367330d57fbSAl Viro 	register_proc_table(table, proc_sys_root, tmp);
13681da177e4SLinus Torvalds #endif
13691da177e4SLinus Torvalds 	return tmp;
13701da177e4SLinus Torvalds }
13711da177e4SLinus Torvalds 
13721da177e4SLinus Torvalds /**
13731da177e4SLinus Torvalds  * unregister_sysctl_table - unregister a sysctl table hierarchy
13741da177e4SLinus Torvalds  * @header: the header returned from register_sysctl_table
13751da177e4SLinus Torvalds  *
13761da177e4SLinus Torvalds  * Unregisters the sysctl table and all children. proc entries may not
13771da177e4SLinus Torvalds  * actually be removed until they are no longer used by anyone.
13781da177e4SLinus Torvalds  */
13791da177e4SLinus Torvalds void unregister_sysctl_table(struct ctl_table_header * header)
13801da177e4SLinus Torvalds {
1381330d57fbSAl Viro 	might_sleep();
1382330d57fbSAl Viro 	spin_lock(&sysctl_lock);
1383330d57fbSAl Viro 	start_unregistering(header);
13841da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
13851da177e4SLinus Torvalds 	unregister_proc_table(header->ctl_table, proc_sys_root);
13861da177e4SLinus Torvalds #endif
1387330d57fbSAl Viro 	spin_unlock(&sysctl_lock);
13881da177e4SLinus Torvalds 	kfree(header);
13891da177e4SLinus Torvalds }
13901da177e4SLinus Torvalds 
13911da177e4SLinus Torvalds /*
13921da177e4SLinus Torvalds  * /proc/sys support
13931da177e4SLinus Torvalds  */
13941da177e4SLinus Torvalds 
13951da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
13961da177e4SLinus Torvalds 
13971da177e4SLinus Torvalds /* Scan the sysctl entries in table and add them all into /proc */
1398330d57fbSAl Viro static void register_proc_table(ctl_table * table, struct proc_dir_entry *root, void *set)
13991da177e4SLinus Torvalds {
14001da177e4SLinus Torvalds 	struct proc_dir_entry *de;
14011da177e4SLinus Torvalds 	int len;
14021da177e4SLinus Torvalds 	mode_t mode;
14031da177e4SLinus Torvalds 
14041da177e4SLinus Torvalds 	for (; table->ctl_name; table++) {
14051da177e4SLinus Torvalds 		/* Can't do anything without a proc name. */
14061da177e4SLinus Torvalds 		if (!table->procname)
14071da177e4SLinus Torvalds 			continue;
14081da177e4SLinus Torvalds 		/* Maybe we can't do anything with it... */
14091da177e4SLinus Torvalds 		if (!table->proc_handler && !table->child) {
14101da177e4SLinus Torvalds 			printk(KERN_WARNING "SYSCTL: Can't register %s\n",
14111da177e4SLinus Torvalds 				table->procname);
14121da177e4SLinus Torvalds 			continue;
14131da177e4SLinus Torvalds 		}
14141da177e4SLinus Torvalds 
14151da177e4SLinus Torvalds 		len = strlen(table->procname);
14161da177e4SLinus Torvalds 		mode = table->mode;
14171da177e4SLinus Torvalds 
14181da177e4SLinus Torvalds 		de = NULL;
14191da177e4SLinus Torvalds 		if (table->proc_handler)
14201da177e4SLinus Torvalds 			mode |= S_IFREG;
14211da177e4SLinus Torvalds 		else {
14221da177e4SLinus Torvalds 			mode |= S_IFDIR;
14231da177e4SLinus Torvalds 			for (de = root->subdir; de; de = de->next) {
14241da177e4SLinus Torvalds 				if (proc_match(len, table->procname, de))
14251da177e4SLinus Torvalds 					break;
14261da177e4SLinus Torvalds 			}
14271da177e4SLinus Torvalds 			/* If the subdir exists already, de is non-NULL */
14281da177e4SLinus Torvalds 		}
14291da177e4SLinus Torvalds 
14301da177e4SLinus Torvalds 		if (!de) {
14311da177e4SLinus Torvalds 			de = create_proc_entry(table->procname, mode, root);
14321da177e4SLinus Torvalds 			if (!de)
14331da177e4SLinus Torvalds 				continue;
1434330d57fbSAl Viro 			de->set = set;
14351da177e4SLinus Torvalds 			de->data = (void *) table;
14361da177e4SLinus Torvalds 			if (table->proc_handler)
14371da177e4SLinus Torvalds 				de->proc_fops = &proc_sys_file_operations;
14381da177e4SLinus Torvalds 		}
14391da177e4SLinus Torvalds 		table->de = de;
14401da177e4SLinus Torvalds 		if (de->mode & S_IFDIR)
1441330d57fbSAl Viro 			register_proc_table(table->child, de, set);
14421da177e4SLinus Torvalds 	}
14431da177e4SLinus Torvalds }
14441da177e4SLinus Torvalds 
14451da177e4SLinus Torvalds /*
14461da177e4SLinus Torvalds  * Unregister a /proc sysctl table and any subdirectories.
14471da177e4SLinus Torvalds  */
14481da177e4SLinus Torvalds static void unregister_proc_table(ctl_table * table, struct proc_dir_entry *root)
14491da177e4SLinus Torvalds {
14501da177e4SLinus Torvalds 	struct proc_dir_entry *de;
14511da177e4SLinus Torvalds 	for (; table->ctl_name; table++) {
14521da177e4SLinus Torvalds 		if (!(de = table->de))
14531da177e4SLinus Torvalds 			continue;
14541da177e4SLinus Torvalds 		if (de->mode & S_IFDIR) {
14551da177e4SLinus Torvalds 			if (!table->child) {
14561da177e4SLinus Torvalds 				printk (KERN_ALERT "Help - malformed sysctl tree on free\n");
14571da177e4SLinus Torvalds 				continue;
14581da177e4SLinus Torvalds 			}
14591da177e4SLinus Torvalds 			unregister_proc_table(table->child, de);
14601da177e4SLinus Torvalds 
14611da177e4SLinus Torvalds 			/* Don't unregister directories which still have entries.. */
14621da177e4SLinus Torvalds 			if (de->subdir)
14631da177e4SLinus Torvalds 				continue;
14641da177e4SLinus Torvalds 		}
14651da177e4SLinus Torvalds 
1466330d57fbSAl Viro 		/*
1467330d57fbSAl Viro 		 * In any case, mark the entry as goner; we'll keep it
1468330d57fbSAl Viro 		 * around if it's busy, but we'll know to do nothing with
1469330d57fbSAl Viro 		 * its fields.  We are under sysctl_lock here.
1470330d57fbSAl Viro 		 */
1471330d57fbSAl Viro 		de->data = NULL;
1472330d57fbSAl Viro 
14731da177e4SLinus Torvalds 		/* Don't unregister proc entries that are still being used.. */
14741da177e4SLinus Torvalds 		if (atomic_read(&de->count))
14751da177e4SLinus Torvalds 			continue;
14761da177e4SLinus Torvalds 
14771da177e4SLinus Torvalds 		table->de = NULL;
14781da177e4SLinus Torvalds 		remove_proc_entry(table->procname, root);
14791da177e4SLinus Torvalds 	}
14801da177e4SLinus Torvalds }
14811da177e4SLinus Torvalds 
14821da177e4SLinus Torvalds static ssize_t do_rw_proc(int write, struct file * file, char __user * buf,
14831da177e4SLinus Torvalds 			  size_t count, loff_t *ppos)
14841da177e4SLinus Torvalds {
14851da177e4SLinus Torvalds 	int op;
1486330d57fbSAl Viro 	struct proc_dir_entry *de = PDE(file->f_dentry->d_inode);
14871da177e4SLinus Torvalds 	struct ctl_table *table;
14881da177e4SLinus Torvalds 	size_t res;
1489330d57fbSAl Viro 	ssize_t error = -ENOTDIR;
14901da177e4SLinus Torvalds 
1491330d57fbSAl Viro 	spin_lock(&sysctl_lock);
1492330d57fbSAl Viro 	if (de && de->data && use_table(de->set)) {
1493330d57fbSAl Viro 		/*
1494330d57fbSAl Viro 		 * at that point we know that sysctl was not unregistered
1495330d57fbSAl Viro 		 * and won't be until we finish
1496330d57fbSAl Viro 		 */
1497330d57fbSAl Viro 		spin_unlock(&sysctl_lock);
14981da177e4SLinus Torvalds 		table = (struct ctl_table *) de->data;
14991da177e4SLinus Torvalds 		if (!table || !table->proc_handler)
1500330d57fbSAl Viro 			goto out;
1501330d57fbSAl Viro 		error = -EPERM;
15021da177e4SLinus Torvalds 		op = (write ? 002 : 004);
15031da177e4SLinus Torvalds 		if (ctl_perm(table, op))
1504330d57fbSAl Viro 			goto out;
15051da177e4SLinus Torvalds 
1506330d57fbSAl Viro 		/* careful: calling conventions are nasty here */
15071da177e4SLinus Torvalds 		res = count;
1508330d57fbSAl Viro 		error = (*table->proc_handler)(table, write, file,
1509330d57fbSAl Viro 						buf, &res, ppos);
1510330d57fbSAl Viro 		if (!error)
1511330d57fbSAl Viro 			error = res;
1512330d57fbSAl Viro 	out:
1513330d57fbSAl Viro 		spin_lock(&sysctl_lock);
1514330d57fbSAl Viro 		unuse_table(de->set);
1515330d57fbSAl Viro 	}
1516330d57fbSAl Viro 	spin_unlock(&sysctl_lock);
15171da177e4SLinus Torvalds 	return error;
15181da177e4SLinus Torvalds }
15191da177e4SLinus Torvalds 
15201da177e4SLinus Torvalds static int proc_opensys(struct inode *inode, struct file *file)
15211da177e4SLinus Torvalds {
15221da177e4SLinus Torvalds 	if (file->f_mode & FMODE_WRITE) {
15231da177e4SLinus Torvalds 		/*
15241da177e4SLinus Torvalds 		 * sysctl entries that are not writable,
15251da177e4SLinus Torvalds 		 * are _NOT_ writable, capabilities or not.
15261da177e4SLinus Torvalds 		 */
15271da177e4SLinus Torvalds 		if (!(inode->i_mode & S_IWUSR))
15281da177e4SLinus Torvalds 			return -EPERM;
15291da177e4SLinus Torvalds 	}
15301da177e4SLinus Torvalds 
15311da177e4SLinus Torvalds 	return 0;
15321da177e4SLinus Torvalds }
15331da177e4SLinus Torvalds 
15341da177e4SLinus Torvalds static ssize_t proc_readsys(struct file * file, char __user * buf,
15351da177e4SLinus Torvalds 			    size_t count, loff_t *ppos)
15361da177e4SLinus Torvalds {
15371da177e4SLinus Torvalds 	return do_rw_proc(0, file, buf, count, ppos);
15381da177e4SLinus Torvalds }
15391da177e4SLinus Torvalds 
15401da177e4SLinus Torvalds static ssize_t proc_writesys(struct file * file, const char __user * buf,
15411da177e4SLinus Torvalds 			     size_t count, loff_t *ppos)
15421da177e4SLinus Torvalds {
15431da177e4SLinus Torvalds 	return do_rw_proc(1, file, (char __user *) buf, count, ppos);
15441da177e4SLinus Torvalds }
15451da177e4SLinus Torvalds 
15461da177e4SLinus Torvalds /**
15471da177e4SLinus Torvalds  * proc_dostring - read a string sysctl
15481da177e4SLinus Torvalds  * @table: the sysctl table
15491da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
15501da177e4SLinus Torvalds  * @filp: the file structure
15511da177e4SLinus Torvalds  * @buffer: the user buffer
15521da177e4SLinus Torvalds  * @lenp: the size of the user buffer
15531da177e4SLinus Torvalds  * @ppos: file position
15541da177e4SLinus Torvalds  *
15551da177e4SLinus Torvalds  * Reads/writes a string from/to the user buffer. If the kernel
15561da177e4SLinus Torvalds  * buffer provided is not large enough to hold the string, the
15571da177e4SLinus Torvalds  * string is truncated. The copied string is %NULL-terminated.
15581da177e4SLinus Torvalds  * If the string is being read by the user process, it is copied
15591da177e4SLinus Torvalds  * and a newline '\n' is added. It is truncated if the buffer is
15601da177e4SLinus Torvalds  * not large enough.
15611da177e4SLinus Torvalds  *
15621da177e4SLinus Torvalds  * Returns 0 on success.
15631da177e4SLinus Torvalds  */
15641da177e4SLinus Torvalds int proc_dostring(ctl_table *table, int write, struct file *filp,
15651da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
15661da177e4SLinus Torvalds {
15671da177e4SLinus Torvalds 	size_t len;
15681da177e4SLinus Torvalds 	char __user *p;
15691da177e4SLinus Torvalds 	char c;
15701da177e4SLinus Torvalds 
15711da177e4SLinus Torvalds 	if (!table->data || !table->maxlen || !*lenp ||
15721da177e4SLinus Torvalds 	    (*ppos && !write)) {
15731da177e4SLinus Torvalds 		*lenp = 0;
15741da177e4SLinus Torvalds 		return 0;
15751da177e4SLinus Torvalds 	}
15761da177e4SLinus Torvalds 
15771da177e4SLinus Torvalds 	if (write) {
15781da177e4SLinus Torvalds 		len = 0;
15791da177e4SLinus Torvalds 		p = buffer;
15801da177e4SLinus Torvalds 		while (len < *lenp) {
15811da177e4SLinus Torvalds 			if (get_user(c, p++))
15821da177e4SLinus Torvalds 				return -EFAULT;
15831da177e4SLinus Torvalds 			if (c == 0 || c == '\n')
15841da177e4SLinus Torvalds 				break;
15851da177e4SLinus Torvalds 			len++;
15861da177e4SLinus Torvalds 		}
15871da177e4SLinus Torvalds 		if (len >= table->maxlen)
15881da177e4SLinus Torvalds 			len = table->maxlen-1;
15891da177e4SLinus Torvalds 		if(copy_from_user(table->data, buffer, len))
15901da177e4SLinus Torvalds 			return -EFAULT;
15911da177e4SLinus Torvalds 		((char *) table->data)[len] = 0;
15921da177e4SLinus Torvalds 		*ppos += *lenp;
15931da177e4SLinus Torvalds 	} else {
15941da177e4SLinus Torvalds 		len = strlen(table->data);
15951da177e4SLinus Torvalds 		if (len > table->maxlen)
15961da177e4SLinus Torvalds 			len = table->maxlen;
15971da177e4SLinus Torvalds 		if (len > *lenp)
15981da177e4SLinus Torvalds 			len = *lenp;
15991da177e4SLinus Torvalds 		if (len)
16001da177e4SLinus Torvalds 			if(copy_to_user(buffer, table->data, len))
16011da177e4SLinus Torvalds 				return -EFAULT;
16021da177e4SLinus Torvalds 		if (len < *lenp) {
16031da177e4SLinus Torvalds 			if(put_user('\n', ((char __user *) buffer) + len))
16041da177e4SLinus Torvalds 				return -EFAULT;
16051da177e4SLinus Torvalds 			len++;
16061da177e4SLinus Torvalds 		}
16071da177e4SLinus Torvalds 		*lenp = len;
16081da177e4SLinus Torvalds 		*ppos += len;
16091da177e4SLinus Torvalds 	}
16101da177e4SLinus Torvalds 	return 0;
16111da177e4SLinus Torvalds }
16121da177e4SLinus Torvalds 
16131da177e4SLinus Torvalds /*
16141da177e4SLinus Torvalds  *	Special case of dostring for the UTS structure. This has locks
16151da177e4SLinus Torvalds  *	to observe. Should this be in kernel/sys.c ????
16161da177e4SLinus Torvalds  */
16171da177e4SLinus Torvalds 
16181da177e4SLinus Torvalds static int proc_doutsstring(ctl_table *table, int write, struct file *filp,
16191da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
16201da177e4SLinus Torvalds {
16211da177e4SLinus Torvalds 	int r;
16221da177e4SLinus Torvalds 
16231da177e4SLinus Torvalds 	if (!write) {
16241da177e4SLinus Torvalds 		down_read(&uts_sem);
16251da177e4SLinus Torvalds 		r=proc_dostring(table,0,filp,buffer,lenp, ppos);
16261da177e4SLinus Torvalds 		up_read(&uts_sem);
16271da177e4SLinus Torvalds 	} else {
16281da177e4SLinus Torvalds 		down_write(&uts_sem);
16291da177e4SLinus Torvalds 		r=proc_dostring(table,1,filp,buffer,lenp, ppos);
16301da177e4SLinus Torvalds 		up_write(&uts_sem);
16311da177e4SLinus Torvalds 	}
16321da177e4SLinus Torvalds 	return r;
16331da177e4SLinus Torvalds }
16341da177e4SLinus Torvalds 
16351da177e4SLinus Torvalds static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
16361da177e4SLinus Torvalds 				 int *valp,
16371da177e4SLinus Torvalds 				 int write, void *data)
16381da177e4SLinus Torvalds {
16391da177e4SLinus Torvalds 	if (write) {
16401da177e4SLinus Torvalds 		*valp = *negp ? -*lvalp : *lvalp;
16411da177e4SLinus Torvalds 	} else {
16421da177e4SLinus Torvalds 		int val = *valp;
16431da177e4SLinus Torvalds 		if (val < 0) {
16441da177e4SLinus Torvalds 			*negp = -1;
16451da177e4SLinus Torvalds 			*lvalp = (unsigned long)-val;
16461da177e4SLinus Torvalds 		} else {
16471da177e4SLinus Torvalds 			*negp = 0;
16481da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
16491da177e4SLinus Torvalds 		}
16501da177e4SLinus Torvalds 	}
16511da177e4SLinus Torvalds 	return 0;
16521da177e4SLinus Torvalds }
16531da177e4SLinus Torvalds 
16541da177e4SLinus Torvalds static int do_proc_dointvec(ctl_table *table, int write, struct file *filp,
16551da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos,
16561da177e4SLinus Torvalds 		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
16571da177e4SLinus Torvalds 			      int write, void *data),
16581da177e4SLinus Torvalds 		  void *data)
16591da177e4SLinus Torvalds {
16601da177e4SLinus Torvalds #define TMPBUFLEN 21
16611da177e4SLinus Torvalds 	int *i, vleft, first=1, neg, val;
16621da177e4SLinus Torvalds 	unsigned long lval;
16631da177e4SLinus Torvalds 	size_t left, len;
16641da177e4SLinus Torvalds 
16651da177e4SLinus Torvalds 	char buf[TMPBUFLEN], *p;
16661da177e4SLinus Torvalds 	char __user *s = buffer;
16671da177e4SLinus Torvalds 
16681da177e4SLinus Torvalds 	if (!table->data || !table->maxlen || !*lenp ||
16691da177e4SLinus Torvalds 	    (*ppos && !write)) {
16701da177e4SLinus Torvalds 		*lenp = 0;
16711da177e4SLinus Torvalds 		return 0;
16721da177e4SLinus Torvalds 	}
16731da177e4SLinus Torvalds 
16741da177e4SLinus Torvalds 	i = (int *) table->data;
16751da177e4SLinus Torvalds 	vleft = table->maxlen / sizeof(*i);
16761da177e4SLinus Torvalds 	left = *lenp;
16771da177e4SLinus Torvalds 
16781da177e4SLinus Torvalds 	if (!conv)
16791da177e4SLinus Torvalds 		conv = do_proc_dointvec_conv;
16801da177e4SLinus Torvalds 
16811da177e4SLinus Torvalds 	for (; left && vleft--; i++, first=0) {
16821da177e4SLinus Torvalds 		if (write) {
16831da177e4SLinus Torvalds 			while (left) {
16841da177e4SLinus Torvalds 				char c;
16851da177e4SLinus Torvalds 				if (get_user(c, s))
16861da177e4SLinus Torvalds 					return -EFAULT;
16871da177e4SLinus Torvalds 				if (!isspace(c))
16881da177e4SLinus Torvalds 					break;
16891da177e4SLinus Torvalds 				left--;
16901da177e4SLinus Torvalds 				s++;
16911da177e4SLinus Torvalds 			}
16921da177e4SLinus Torvalds 			if (!left)
16931da177e4SLinus Torvalds 				break;
16941da177e4SLinus Torvalds 			neg = 0;
16951da177e4SLinus Torvalds 			len = left;
16961da177e4SLinus Torvalds 			if (len > sizeof(buf) - 1)
16971da177e4SLinus Torvalds 				len = sizeof(buf) - 1;
16981da177e4SLinus Torvalds 			if (copy_from_user(buf, s, len))
16991da177e4SLinus Torvalds 				return -EFAULT;
17001da177e4SLinus Torvalds 			buf[len] = 0;
17011da177e4SLinus Torvalds 			p = buf;
17021da177e4SLinus Torvalds 			if (*p == '-' && left > 1) {
17031da177e4SLinus Torvalds 				neg = 1;
17041da177e4SLinus Torvalds 				left--, p++;
17051da177e4SLinus Torvalds 			}
17061da177e4SLinus Torvalds 			if (*p < '0' || *p > '9')
17071da177e4SLinus Torvalds 				break;
17081da177e4SLinus Torvalds 
17091da177e4SLinus Torvalds 			lval = simple_strtoul(p, &p, 0);
17101da177e4SLinus Torvalds 
17111da177e4SLinus Torvalds 			len = p-buf;
17121da177e4SLinus Torvalds 			if ((len < left) && *p && !isspace(*p))
17131da177e4SLinus Torvalds 				break;
17141da177e4SLinus Torvalds 			if (neg)
17151da177e4SLinus Torvalds 				val = -val;
17161da177e4SLinus Torvalds 			s += len;
17171da177e4SLinus Torvalds 			left -= len;
17181da177e4SLinus Torvalds 
17191da177e4SLinus Torvalds 			if (conv(&neg, &lval, i, 1, data))
17201da177e4SLinus Torvalds 				break;
17211da177e4SLinus Torvalds 		} else {
17221da177e4SLinus Torvalds 			p = buf;
17231da177e4SLinus Torvalds 			if (!first)
17241da177e4SLinus Torvalds 				*p++ = '\t';
17251da177e4SLinus Torvalds 
17261da177e4SLinus Torvalds 			if (conv(&neg, &lval, i, 0, data))
17271da177e4SLinus Torvalds 				break;
17281da177e4SLinus Torvalds 
17291da177e4SLinus Torvalds 			sprintf(p, "%s%lu", neg ? "-" : "", lval);
17301da177e4SLinus Torvalds 			len = strlen(buf);
17311da177e4SLinus Torvalds 			if (len > left)
17321da177e4SLinus Torvalds 				len = left;
17331da177e4SLinus Torvalds 			if(copy_to_user(s, buf, len))
17341da177e4SLinus Torvalds 				return -EFAULT;
17351da177e4SLinus Torvalds 			left -= len;
17361da177e4SLinus Torvalds 			s += len;
17371da177e4SLinus Torvalds 		}
17381da177e4SLinus Torvalds 	}
17391da177e4SLinus Torvalds 
17401da177e4SLinus Torvalds 	if (!write && !first && left) {
17411da177e4SLinus Torvalds 		if(put_user('\n', s))
17421da177e4SLinus Torvalds 			return -EFAULT;
17431da177e4SLinus Torvalds 		left--, s++;
17441da177e4SLinus Torvalds 	}
17451da177e4SLinus Torvalds 	if (write) {
17461da177e4SLinus Torvalds 		while (left) {
17471da177e4SLinus Torvalds 			char c;
17481da177e4SLinus Torvalds 			if (get_user(c, s++))
17491da177e4SLinus Torvalds 				return -EFAULT;
17501da177e4SLinus Torvalds 			if (!isspace(c))
17511da177e4SLinus Torvalds 				break;
17521da177e4SLinus Torvalds 			left--;
17531da177e4SLinus Torvalds 		}
17541da177e4SLinus Torvalds 	}
17551da177e4SLinus Torvalds 	if (write && first)
17561da177e4SLinus Torvalds 		return -EINVAL;
17571da177e4SLinus Torvalds 	*lenp -= left;
17581da177e4SLinus Torvalds 	*ppos += *lenp;
17591da177e4SLinus Torvalds 	return 0;
17601da177e4SLinus Torvalds #undef TMPBUFLEN
17611da177e4SLinus Torvalds }
17621da177e4SLinus Torvalds 
17631da177e4SLinus Torvalds /**
17641da177e4SLinus Torvalds  * proc_dointvec - read a vector of integers
17651da177e4SLinus Torvalds  * @table: the sysctl table
17661da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
17671da177e4SLinus Torvalds  * @filp: the file structure
17681da177e4SLinus Torvalds  * @buffer: the user buffer
17691da177e4SLinus Torvalds  * @lenp: the size of the user buffer
17701da177e4SLinus Torvalds  * @ppos: file position
17711da177e4SLinus Torvalds  *
17721da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
17731da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
17741da177e4SLinus Torvalds  *
17751da177e4SLinus Torvalds  * Returns 0 on success.
17761da177e4SLinus Torvalds  */
17771da177e4SLinus Torvalds int proc_dointvec(ctl_table *table, int write, struct file *filp,
17781da177e4SLinus Torvalds 		     void __user *buffer, size_t *lenp, loff_t *ppos)
17791da177e4SLinus Torvalds {
17801da177e4SLinus Torvalds     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
17811da177e4SLinus Torvalds 		    	    NULL,NULL);
17821da177e4SLinus Torvalds }
17831da177e4SLinus Torvalds 
17841da177e4SLinus Torvalds #define OP_SET	0
17851da177e4SLinus Torvalds #define OP_AND	1
17861da177e4SLinus Torvalds #define OP_OR	2
17871da177e4SLinus Torvalds #define OP_MAX	3
17881da177e4SLinus Torvalds #define OP_MIN	4
17891da177e4SLinus Torvalds 
17901da177e4SLinus Torvalds static int do_proc_dointvec_bset_conv(int *negp, unsigned long *lvalp,
17911da177e4SLinus Torvalds 				      int *valp,
17921da177e4SLinus Torvalds 				      int write, void *data)
17931da177e4SLinus Torvalds {
17941da177e4SLinus Torvalds 	int op = *(int *)data;
17951da177e4SLinus Torvalds 	if (write) {
17961da177e4SLinus Torvalds 		int val = *negp ? -*lvalp : *lvalp;
17971da177e4SLinus Torvalds 		switch(op) {
17981da177e4SLinus Torvalds 		case OP_SET:	*valp = val; break;
17991da177e4SLinus Torvalds 		case OP_AND:	*valp &= val; break;
18001da177e4SLinus Torvalds 		case OP_OR:	*valp |= val; break;
18011da177e4SLinus Torvalds 		case OP_MAX:	if(*valp < val)
18021da177e4SLinus Torvalds 					*valp = val;
18031da177e4SLinus Torvalds 				break;
18041da177e4SLinus Torvalds 		case OP_MIN:	if(*valp > val)
18051da177e4SLinus Torvalds 				*valp = val;
18061da177e4SLinus Torvalds 				break;
18071da177e4SLinus Torvalds 		}
18081da177e4SLinus Torvalds 	} else {
18091da177e4SLinus Torvalds 		int val = *valp;
18101da177e4SLinus Torvalds 		if (val < 0) {
18111da177e4SLinus Torvalds 			*negp = -1;
18121da177e4SLinus Torvalds 			*lvalp = (unsigned long)-val;
18131da177e4SLinus Torvalds 		} else {
18141da177e4SLinus Torvalds 			*negp = 0;
18151da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
18161da177e4SLinus Torvalds 		}
18171da177e4SLinus Torvalds 	}
18181da177e4SLinus Torvalds 	return 0;
18191da177e4SLinus Torvalds }
18201da177e4SLinus Torvalds 
18211da177e4SLinus Torvalds /*
18221da177e4SLinus Torvalds  *	init may raise the set.
18231da177e4SLinus Torvalds  */
18241da177e4SLinus Torvalds 
18251da177e4SLinus Torvalds int proc_dointvec_bset(ctl_table *table, int write, struct file *filp,
18261da177e4SLinus Torvalds 			void __user *buffer, size_t *lenp, loff_t *ppos)
18271da177e4SLinus Torvalds {
18281da177e4SLinus Torvalds 	int op;
18291da177e4SLinus Torvalds 
18301da177e4SLinus Torvalds 	if (!capable(CAP_SYS_MODULE)) {
18311da177e4SLinus Torvalds 		return -EPERM;
18321da177e4SLinus Torvalds 	}
18331da177e4SLinus Torvalds 
18341da177e4SLinus Torvalds 	op = (current->pid == 1) ? OP_SET : OP_AND;
18351da177e4SLinus Torvalds 	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
18361da177e4SLinus Torvalds 				do_proc_dointvec_bset_conv,&op);
18371da177e4SLinus Torvalds }
18381da177e4SLinus Torvalds 
18391da177e4SLinus Torvalds struct do_proc_dointvec_minmax_conv_param {
18401da177e4SLinus Torvalds 	int *min;
18411da177e4SLinus Torvalds 	int *max;
18421da177e4SLinus Torvalds };
18431da177e4SLinus Torvalds 
18441da177e4SLinus Torvalds static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp,
18451da177e4SLinus Torvalds 					int *valp,
18461da177e4SLinus Torvalds 					int write, void *data)
18471da177e4SLinus Torvalds {
18481da177e4SLinus Torvalds 	struct do_proc_dointvec_minmax_conv_param *param = data;
18491da177e4SLinus Torvalds 	if (write) {
18501da177e4SLinus Torvalds 		int val = *negp ? -*lvalp : *lvalp;
18511da177e4SLinus Torvalds 		if ((param->min && *param->min > val) ||
18521da177e4SLinus Torvalds 		    (param->max && *param->max < val))
18531da177e4SLinus Torvalds 			return -EINVAL;
18541da177e4SLinus Torvalds 		*valp = val;
18551da177e4SLinus Torvalds 	} else {
18561da177e4SLinus Torvalds 		int val = *valp;
18571da177e4SLinus Torvalds 		if (val < 0) {
18581da177e4SLinus Torvalds 			*negp = -1;
18591da177e4SLinus Torvalds 			*lvalp = (unsigned long)-val;
18601da177e4SLinus Torvalds 		} else {
18611da177e4SLinus Torvalds 			*negp = 0;
18621da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
18631da177e4SLinus Torvalds 		}
18641da177e4SLinus Torvalds 	}
18651da177e4SLinus Torvalds 	return 0;
18661da177e4SLinus Torvalds }
18671da177e4SLinus Torvalds 
18681da177e4SLinus Torvalds /**
18691da177e4SLinus Torvalds  * proc_dointvec_minmax - read a vector of integers with min/max values
18701da177e4SLinus Torvalds  * @table: the sysctl table
18711da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
18721da177e4SLinus Torvalds  * @filp: the file structure
18731da177e4SLinus Torvalds  * @buffer: the user buffer
18741da177e4SLinus Torvalds  * @lenp: the size of the user buffer
18751da177e4SLinus Torvalds  * @ppos: file position
18761da177e4SLinus Torvalds  *
18771da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
18781da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
18791da177e4SLinus Torvalds  *
18801da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
18811da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
18821da177e4SLinus Torvalds  *
18831da177e4SLinus Torvalds  * Returns 0 on success.
18841da177e4SLinus Torvalds  */
18851da177e4SLinus Torvalds int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
18861da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
18871da177e4SLinus Torvalds {
18881da177e4SLinus Torvalds 	struct do_proc_dointvec_minmax_conv_param param = {
18891da177e4SLinus Torvalds 		.min = (int *) table->extra1,
18901da177e4SLinus Torvalds 		.max = (int *) table->extra2,
18911da177e4SLinus Torvalds 	};
18921da177e4SLinus Torvalds 	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
18931da177e4SLinus Torvalds 				do_proc_dointvec_minmax_conv, &param);
18941da177e4SLinus Torvalds }
18951da177e4SLinus Torvalds 
18961da177e4SLinus Torvalds static int do_proc_doulongvec_minmax(ctl_table *table, int write,
18971da177e4SLinus Torvalds 				     struct file *filp,
18981da177e4SLinus Torvalds 				     void __user *buffer,
18991da177e4SLinus Torvalds 				     size_t *lenp, loff_t *ppos,
19001da177e4SLinus Torvalds 				     unsigned long convmul,
19011da177e4SLinus Torvalds 				     unsigned long convdiv)
19021da177e4SLinus Torvalds {
19031da177e4SLinus Torvalds #define TMPBUFLEN 21
19041da177e4SLinus Torvalds 	unsigned long *i, *min, *max, val;
19051da177e4SLinus Torvalds 	int vleft, first=1, neg;
19061da177e4SLinus Torvalds 	size_t len, left;
19071da177e4SLinus Torvalds 	char buf[TMPBUFLEN], *p;
19081da177e4SLinus Torvalds 	char __user *s = buffer;
19091da177e4SLinus Torvalds 
19101da177e4SLinus Torvalds 	if (!table->data || !table->maxlen || !*lenp ||
19111da177e4SLinus Torvalds 	    (*ppos && !write)) {
19121da177e4SLinus Torvalds 		*lenp = 0;
19131da177e4SLinus Torvalds 		return 0;
19141da177e4SLinus Torvalds 	}
19151da177e4SLinus Torvalds 
19161da177e4SLinus Torvalds 	i = (unsigned long *) table->data;
19171da177e4SLinus Torvalds 	min = (unsigned long *) table->extra1;
19181da177e4SLinus Torvalds 	max = (unsigned long *) table->extra2;
19191da177e4SLinus Torvalds 	vleft = table->maxlen / sizeof(unsigned long);
19201da177e4SLinus Torvalds 	left = *lenp;
19211da177e4SLinus Torvalds 
19221da177e4SLinus Torvalds 	for (; left && vleft--; i++, min++, max++, first=0) {
19231da177e4SLinus Torvalds 		if (write) {
19241da177e4SLinus Torvalds 			while (left) {
19251da177e4SLinus Torvalds 				char c;
19261da177e4SLinus Torvalds 				if (get_user(c, s))
19271da177e4SLinus Torvalds 					return -EFAULT;
19281da177e4SLinus Torvalds 				if (!isspace(c))
19291da177e4SLinus Torvalds 					break;
19301da177e4SLinus Torvalds 				left--;
19311da177e4SLinus Torvalds 				s++;
19321da177e4SLinus Torvalds 			}
19331da177e4SLinus Torvalds 			if (!left)
19341da177e4SLinus Torvalds 				break;
19351da177e4SLinus Torvalds 			neg = 0;
19361da177e4SLinus Torvalds 			len = left;
19371da177e4SLinus Torvalds 			if (len > TMPBUFLEN-1)
19381da177e4SLinus Torvalds 				len = TMPBUFLEN-1;
19391da177e4SLinus Torvalds 			if (copy_from_user(buf, s, len))
19401da177e4SLinus Torvalds 				return -EFAULT;
19411da177e4SLinus Torvalds 			buf[len] = 0;
19421da177e4SLinus Torvalds 			p = buf;
19431da177e4SLinus Torvalds 			if (*p == '-' && left > 1) {
19441da177e4SLinus Torvalds 				neg = 1;
19451da177e4SLinus Torvalds 				left--, p++;
19461da177e4SLinus Torvalds 			}
19471da177e4SLinus Torvalds 			if (*p < '0' || *p > '9')
19481da177e4SLinus Torvalds 				break;
19491da177e4SLinus Torvalds 			val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
19501da177e4SLinus Torvalds 			len = p-buf;
19511da177e4SLinus Torvalds 			if ((len < left) && *p && !isspace(*p))
19521da177e4SLinus Torvalds 				break;
19531da177e4SLinus Torvalds 			if (neg)
19541da177e4SLinus Torvalds 				val = -val;
19551da177e4SLinus Torvalds 			s += len;
19561da177e4SLinus Torvalds 			left -= len;
19571da177e4SLinus Torvalds 
19581da177e4SLinus Torvalds 			if(neg)
19591da177e4SLinus Torvalds 				continue;
19601da177e4SLinus Torvalds 			if ((min && val < *min) || (max && val > *max))
19611da177e4SLinus Torvalds 				continue;
19621da177e4SLinus Torvalds 			*i = val;
19631da177e4SLinus Torvalds 		} else {
19641da177e4SLinus Torvalds 			p = buf;
19651da177e4SLinus Torvalds 			if (!first)
19661da177e4SLinus Torvalds 				*p++ = '\t';
19671da177e4SLinus Torvalds 			sprintf(p, "%lu", convdiv * (*i) / convmul);
19681da177e4SLinus Torvalds 			len = strlen(buf);
19691da177e4SLinus Torvalds 			if (len > left)
19701da177e4SLinus Torvalds 				len = left;
19711da177e4SLinus Torvalds 			if(copy_to_user(s, buf, len))
19721da177e4SLinus Torvalds 				return -EFAULT;
19731da177e4SLinus Torvalds 			left -= len;
19741da177e4SLinus Torvalds 			s += len;
19751da177e4SLinus Torvalds 		}
19761da177e4SLinus Torvalds 	}
19771da177e4SLinus Torvalds 
19781da177e4SLinus Torvalds 	if (!write && !first && left) {
19791da177e4SLinus Torvalds 		if(put_user('\n', s))
19801da177e4SLinus Torvalds 			return -EFAULT;
19811da177e4SLinus Torvalds 		left--, s++;
19821da177e4SLinus Torvalds 	}
19831da177e4SLinus Torvalds 	if (write) {
19841da177e4SLinus Torvalds 		while (left) {
19851da177e4SLinus Torvalds 			char c;
19861da177e4SLinus Torvalds 			if (get_user(c, s++))
19871da177e4SLinus Torvalds 				return -EFAULT;
19881da177e4SLinus Torvalds 			if (!isspace(c))
19891da177e4SLinus Torvalds 				break;
19901da177e4SLinus Torvalds 			left--;
19911da177e4SLinus Torvalds 		}
19921da177e4SLinus Torvalds 	}
19931da177e4SLinus Torvalds 	if (write && first)
19941da177e4SLinus Torvalds 		return -EINVAL;
19951da177e4SLinus Torvalds 	*lenp -= left;
19961da177e4SLinus Torvalds 	*ppos += *lenp;
19971da177e4SLinus Torvalds 	return 0;
19981da177e4SLinus Torvalds #undef TMPBUFLEN
19991da177e4SLinus Torvalds }
20001da177e4SLinus Torvalds 
20011da177e4SLinus Torvalds /**
20021da177e4SLinus Torvalds  * proc_doulongvec_minmax - read a vector of long integers with min/max values
20031da177e4SLinus Torvalds  * @table: the sysctl table
20041da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
20051da177e4SLinus Torvalds  * @filp: the file structure
20061da177e4SLinus Torvalds  * @buffer: the user buffer
20071da177e4SLinus Torvalds  * @lenp: the size of the user buffer
20081da177e4SLinus Torvalds  * @ppos: file position
20091da177e4SLinus Torvalds  *
20101da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
20111da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
20121da177e4SLinus Torvalds  *
20131da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
20141da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
20151da177e4SLinus Torvalds  *
20161da177e4SLinus Torvalds  * Returns 0 on success.
20171da177e4SLinus Torvalds  */
20181da177e4SLinus Torvalds int proc_doulongvec_minmax(ctl_table *table, int write, struct file *filp,
20191da177e4SLinus Torvalds 			   void __user *buffer, size_t *lenp, loff_t *ppos)
20201da177e4SLinus Torvalds {
20211da177e4SLinus Torvalds     return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l);
20221da177e4SLinus Torvalds }
20231da177e4SLinus Torvalds 
20241da177e4SLinus Torvalds /**
20251da177e4SLinus Torvalds  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
20261da177e4SLinus Torvalds  * @table: the sysctl table
20271da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
20281da177e4SLinus Torvalds  * @filp: the file structure
20291da177e4SLinus Torvalds  * @buffer: the user buffer
20301da177e4SLinus Torvalds  * @lenp: the size of the user buffer
20311da177e4SLinus Torvalds  * @ppos: file position
20321da177e4SLinus Torvalds  *
20331da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
20341da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string. The values
20351da177e4SLinus Torvalds  * are treated as milliseconds, and converted to jiffies when they are stored.
20361da177e4SLinus Torvalds  *
20371da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
20381da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
20391da177e4SLinus Torvalds  *
20401da177e4SLinus Torvalds  * Returns 0 on success.
20411da177e4SLinus Torvalds  */
20421da177e4SLinus Torvalds int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int write,
20431da177e4SLinus Torvalds 				      struct file *filp,
20441da177e4SLinus Torvalds 				      void __user *buffer,
20451da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
20461da177e4SLinus Torvalds {
20471da177e4SLinus Torvalds     return do_proc_doulongvec_minmax(table, write, filp, buffer,
20481da177e4SLinus Torvalds 				     lenp, ppos, HZ, 1000l);
20491da177e4SLinus Torvalds }
20501da177e4SLinus Torvalds 
20511da177e4SLinus Torvalds 
20521da177e4SLinus Torvalds static int do_proc_dointvec_jiffies_conv(int *negp, unsigned long *lvalp,
20531da177e4SLinus Torvalds 					 int *valp,
20541da177e4SLinus Torvalds 					 int write, void *data)
20551da177e4SLinus Torvalds {
20561da177e4SLinus Torvalds 	if (write) {
20571da177e4SLinus Torvalds 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
20581da177e4SLinus Torvalds 	} else {
20591da177e4SLinus Torvalds 		int val = *valp;
20601da177e4SLinus Torvalds 		unsigned long lval;
20611da177e4SLinus Torvalds 		if (val < 0) {
20621da177e4SLinus Torvalds 			*negp = -1;
20631da177e4SLinus Torvalds 			lval = (unsigned long)-val;
20641da177e4SLinus Torvalds 		} else {
20651da177e4SLinus Torvalds 			*negp = 0;
20661da177e4SLinus Torvalds 			lval = (unsigned long)val;
20671da177e4SLinus Torvalds 		}
20681da177e4SLinus Torvalds 		*lvalp = lval / HZ;
20691da177e4SLinus Torvalds 	}
20701da177e4SLinus Torvalds 	return 0;
20711da177e4SLinus Torvalds }
20721da177e4SLinus Torvalds 
20731da177e4SLinus Torvalds static int do_proc_dointvec_userhz_jiffies_conv(int *negp, unsigned long *lvalp,
20741da177e4SLinus Torvalds 						int *valp,
20751da177e4SLinus Torvalds 						int write, void *data)
20761da177e4SLinus Torvalds {
20771da177e4SLinus Torvalds 	if (write) {
20781da177e4SLinus Torvalds 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
20791da177e4SLinus Torvalds 	} else {
20801da177e4SLinus Torvalds 		int val = *valp;
20811da177e4SLinus Torvalds 		unsigned long lval;
20821da177e4SLinus Torvalds 		if (val < 0) {
20831da177e4SLinus Torvalds 			*negp = -1;
20841da177e4SLinus Torvalds 			lval = (unsigned long)-val;
20851da177e4SLinus Torvalds 		} else {
20861da177e4SLinus Torvalds 			*negp = 0;
20871da177e4SLinus Torvalds 			lval = (unsigned long)val;
20881da177e4SLinus Torvalds 		}
20891da177e4SLinus Torvalds 		*lvalp = jiffies_to_clock_t(lval);
20901da177e4SLinus Torvalds 	}
20911da177e4SLinus Torvalds 	return 0;
20921da177e4SLinus Torvalds }
20931da177e4SLinus Torvalds 
20941da177e4SLinus Torvalds static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
20951da177e4SLinus Torvalds 					    int *valp,
20961da177e4SLinus Torvalds 					    int write, void *data)
20971da177e4SLinus Torvalds {
20981da177e4SLinus Torvalds 	if (write) {
20991da177e4SLinus Torvalds 		*valp = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
21001da177e4SLinus Torvalds 	} else {
21011da177e4SLinus Torvalds 		int val = *valp;
21021da177e4SLinus Torvalds 		unsigned long lval;
21031da177e4SLinus Torvalds 		if (val < 0) {
21041da177e4SLinus Torvalds 			*negp = -1;
21051da177e4SLinus Torvalds 			lval = (unsigned long)-val;
21061da177e4SLinus Torvalds 		} else {
21071da177e4SLinus Torvalds 			*negp = 0;
21081da177e4SLinus Torvalds 			lval = (unsigned long)val;
21091da177e4SLinus Torvalds 		}
21101da177e4SLinus Torvalds 		*lvalp = jiffies_to_msecs(lval);
21111da177e4SLinus Torvalds 	}
21121da177e4SLinus Torvalds 	return 0;
21131da177e4SLinus Torvalds }
21141da177e4SLinus Torvalds 
21151da177e4SLinus Torvalds /**
21161da177e4SLinus Torvalds  * proc_dointvec_jiffies - read a vector of integers as seconds
21171da177e4SLinus Torvalds  * @table: the sysctl table
21181da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
21191da177e4SLinus Torvalds  * @filp: the file structure
21201da177e4SLinus Torvalds  * @buffer: the user buffer
21211da177e4SLinus Torvalds  * @lenp: the size of the user buffer
21221da177e4SLinus Torvalds  * @ppos: file position
21231da177e4SLinus Torvalds  *
21241da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
21251da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
21261da177e4SLinus Torvalds  * The values read are assumed to be in seconds, and are converted into
21271da177e4SLinus Torvalds  * jiffies.
21281da177e4SLinus Torvalds  *
21291da177e4SLinus Torvalds  * Returns 0 on success.
21301da177e4SLinus Torvalds  */
21311da177e4SLinus Torvalds int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
21321da177e4SLinus Torvalds 			  void __user *buffer, size_t *lenp, loff_t *ppos)
21331da177e4SLinus Torvalds {
21341da177e4SLinus Torvalds     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
21351da177e4SLinus Torvalds 		    	    do_proc_dointvec_jiffies_conv,NULL);
21361da177e4SLinus Torvalds }
21371da177e4SLinus Torvalds 
21381da177e4SLinus Torvalds /**
21391da177e4SLinus Torvalds  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
21401da177e4SLinus Torvalds  * @table: the sysctl table
21411da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
21421da177e4SLinus Torvalds  * @filp: the file structure
21431da177e4SLinus Torvalds  * @buffer: the user buffer
21441da177e4SLinus Torvalds  * @lenp: the size of the user buffer
21451e5d5331SRandy Dunlap  * @ppos: pointer to the file position
21461da177e4SLinus Torvalds  *
21471da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
21481da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
21491da177e4SLinus Torvalds  * The values read are assumed to be in 1/USER_HZ seconds, and
21501da177e4SLinus Torvalds  * are converted into jiffies.
21511da177e4SLinus Torvalds  *
21521da177e4SLinus Torvalds  * Returns 0 on success.
21531da177e4SLinus Torvalds  */
21541da177e4SLinus Torvalds int proc_dointvec_userhz_jiffies(ctl_table *table, int write, struct file *filp,
21551da177e4SLinus Torvalds 				 void __user *buffer, size_t *lenp, loff_t *ppos)
21561da177e4SLinus Torvalds {
21571da177e4SLinus Torvalds     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
21581da177e4SLinus Torvalds 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
21591da177e4SLinus Torvalds }
21601da177e4SLinus Torvalds 
21611da177e4SLinus Torvalds /**
21621da177e4SLinus Torvalds  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
21631da177e4SLinus Torvalds  * @table: the sysctl table
21641da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
21651da177e4SLinus Torvalds  * @filp: the file structure
21661da177e4SLinus Torvalds  * @buffer: the user buffer
21671da177e4SLinus Torvalds  * @lenp: the size of the user buffer
216867be2dd1SMartin Waitz  * @ppos: file position
216967be2dd1SMartin Waitz  * @ppos: the current position in the file
21701da177e4SLinus Torvalds  *
21711da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
21721da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
21731da177e4SLinus Torvalds  * The values read are assumed to be in 1/1000 seconds, and
21741da177e4SLinus Torvalds  * are converted into jiffies.
21751da177e4SLinus Torvalds  *
21761da177e4SLinus Torvalds  * Returns 0 on success.
21771da177e4SLinus Torvalds  */
21781da177e4SLinus Torvalds int proc_dointvec_ms_jiffies(ctl_table *table, int write, struct file *filp,
21791da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
21801da177e4SLinus Torvalds {
21811da177e4SLinus Torvalds 	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
21821da177e4SLinus Torvalds 				do_proc_dointvec_ms_jiffies_conv, NULL);
21831da177e4SLinus Torvalds }
21841da177e4SLinus Torvalds 
21851da177e4SLinus Torvalds #else /* CONFIG_PROC_FS */
21861da177e4SLinus Torvalds 
21871da177e4SLinus Torvalds int proc_dostring(ctl_table *table, int write, struct file *filp,
21881da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
21891da177e4SLinus Torvalds {
21901da177e4SLinus Torvalds 	return -ENOSYS;
21911da177e4SLinus Torvalds }
21921da177e4SLinus Torvalds 
21931da177e4SLinus Torvalds static int proc_doutsstring(ctl_table *table, int write, struct file *filp,
21941da177e4SLinus Torvalds 			    void __user *buffer, size_t *lenp, loff_t *ppos)
21951da177e4SLinus Torvalds {
21961da177e4SLinus Torvalds 	return -ENOSYS;
21971da177e4SLinus Torvalds }
21981da177e4SLinus Torvalds 
21991da177e4SLinus Torvalds int proc_dointvec(ctl_table *table, int write, struct file *filp,
22001da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
22011da177e4SLinus Torvalds {
22021da177e4SLinus Torvalds 	return -ENOSYS;
22031da177e4SLinus Torvalds }
22041da177e4SLinus Torvalds 
22051da177e4SLinus Torvalds int proc_dointvec_bset(ctl_table *table, int write, struct file *filp,
22061da177e4SLinus Torvalds 			void __user *buffer, size_t *lenp, loff_t *ppos)
22071da177e4SLinus Torvalds {
22081da177e4SLinus Torvalds 	return -ENOSYS;
22091da177e4SLinus Torvalds }
22101da177e4SLinus Torvalds 
22111da177e4SLinus Torvalds int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
22121da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
22131da177e4SLinus Torvalds {
22141da177e4SLinus Torvalds 	return -ENOSYS;
22151da177e4SLinus Torvalds }
22161da177e4SLinus Torvalds 
22171da177e4SLinus Torvalds int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
22181da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
22191da177e4SLinus Torvalds {
22201da177e4SLinus Torvalds 	return -ENOSYS;
22211da177e4SLinus Torvalds }
22221da177e4SLinus Torvalds 
22231da177e4SLinus Torvalds int proc_dointvec_userhz_jiffies(ctl_table *table, int write, struct file *filp,
22241da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
22251da177e4SLinus Torvalds {
22261da177e4SLinus Torvalds 	return -ENOSYS;
22271da177e4SLinus Torvalds }
22281da177e4SLinus Torvalds 
22291da177e4SLinus Torvalds int proc_dointvec_ms_jiffies(ctl_table *table, int write, struct file *filp,
22301da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
22311da177e4SLinus Torvalds {
22321da177e4SLinus Torvalds 	return -ENOSYS;
22331da177e4SLinus Torvalds }
22341da177e4SLinus Torvalds 
22351da177e4SLinus Torvalds int proc_doulongvec_minmax(ctl_table *table, int write, struct file *filp,
22361da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
22371da177e4SLinus Torvalds {
22381da177e4SLinus Torvalds 	return -ENOSYS;
22391da177e4SLinus Torvalds }
22401da177e4SLinus Torvalds 
22411da177e4SLinus Torvalds int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int write,
22421da177e4SLinus Torvalds 				      struct file *filp,
22431da177e4SLinus Torvalds 				      void __user *buffer,
22441da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
22451da177e4SLinus Torvalds {
22461da177e4SLinus Torvalds     return -ENOSYS;
22471da177e4SLinus Torvalds }
22481da177e4SLinus Torvalds 
22491da177e4SLinus Torvalds 
22501da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */
22511da177e4SLinus Torvalds 
22521da177e4SLinus Torvalds 
22531da177e4SLinus Torvalds /*
22541da177e4SLinus Torvalds  * General sysctl support routines
22551da177e4SLinus Torvalds  */
22561da177e4SLinus Torvalds 
22571da177e4SLinus Torvalds /* The generic string strategy routine: */
22581da177e4SLinus Torvalds int sysctl_string(ctl_table *table, int __user *name, int nlen,
22591da177e4SLinus Torvalds 		  void __user *oldval, size_t __user *oldlenp,
22601da177e4SLinus Torvalds 		  void __user *newval, size_t newlen, void **context)
22611da177e4SLinus Torvalds {
22621da177e4SLinus Torvalds 	if (!table->data || !table->maxlen)
22631da177e4SLinus Torvalds 		return -ENOTDIR;
22641da177e4SLinus Torvalds 
22651da177e4SLinus Torvalds 	if (oldval && oldlenp) {
2266de9e007dSLinus Torvalds 		size_t bufsize;
2267de9e007dSLinus Torvalds 		if (get_user(bufsize, oldlenp))
22681da177e4SLinus Torvalds 			return -EFAULT;
2269de9e007dSLinus Torvalds 		if (bufsize) {
2270de9e007dSLinus Torvalds 			size_t len = strlen(table->data), copied;
2271de9e007dSLinus Torvalds 
2272de9e007dSLinus Torvalds 			/* This shouldn't trigger for a well-formed sysctl */
2273de9e007dSLinus Torvalds 			if (len > table->maxlen)
22741da177e4SLinus Torvalds 				len = table->maxlen;
2275de9e007dSLinus Torvalds 
2276de9e007dSLinus Torvalds 			/* Copy up to a max of bufsize-1 bytes of the string */
2277de9e007dSLinus Torvalds 			copied = (len >= bufsize) ? bufsize - 1 : len;
2278de9e007dSLinus Torvalds 
2279de9e007dSLinus Torvalds 			if (copy_to_user(oldval, table->data, copied) ||
2280de9e007dSLinus Torvalds 			    put_user(0, (char __user *)(oldval + copied)))
22811da177e4SLinus Torvalds 				return -EFAULT;
22821da177e4SLinus Torvalds 			if (put_user(len, oldlenp))
22831da177e4SLinus Torvalds 				return -EFAULT;
22841da177e4SLinus Torvalds 		}
22851da177e4SLinus Torvalds 	}
22861da177e4SLinus Torvalds 	if (newval && newlen) {
2287de9e007dSLinus Torvalds 		size_t len = newlen;
22881da177e4SLinus Torvalds 		if (len > table->maxlen)
22891da177e4SLinus Torvalds 			len = table->maxlen;
22901da177e4SLinus Torvalds 		if(copy_from_user(table->data, newval, len))
22911da177e4SLinus Torvalds 			return -EFAULT;
22921da177e4SLinus Torvalds 		if (len == table->maxlen)
22931da177e4SLinus Torvalds 			len--;
22941da177e4SLinus Torvalds 		((char *) table->data)[len] = 0;
22951da177e4SLinus Torvalds 	}
229682c9df82SYi Yang 	return 1;
22971da177e4SLinus Torvalds }
22981da177e4SLinus Torvalds 
22991da177e4SLinus Torvalds /*
23001da177e4SLinus Torvalds  * This function makes sure that all of the integers in the vector
23011da177e4SLinus Torvalds  * are between the minimum and maximum values given in the arrays
23021da177e4SLinus Torvalds  * table->extra1 and table->extra2, respectively.
23031da177e4SLinus Torvalds  */
23041da177e4SLinus Torvalds int sysctl_intvec(ctl_table *table, int __user *name, int nlen,
23051da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
23061da177e4SLinus Torvalds 		void __user *newval, size_t newlen, void **context)
23071da177e4SLinus Torvalds {
23081da177e4SLinus Torvalds 
23091da177e4SLinus Torvalds 	if (newval && newlen) {
23101da177e4SLinus Torvalds 		int __user *vec = (int __user *) newval;
23111da177e4SLinus Torvalds 		int *min = (int *) table->extra1;
23121da177e4SLinus Torvalds 		int *max = (int *) table->extra2;
23131da177e4SLinus Torvalds 		size_t length;
23141da177e4SLinus Torvalds 		int i;
23151da177e4SLinus Torvalds 
23161da177e4SLinus Torvalds 		if (newlen % sizeof(int) != 0)
23171da177e4SLinus Torvalds 			return -EINVAL;
23181da177e4SLinus Torvalds 
23191da177e4SLinus Torvalds 		if (!table->extra1 && !table->extra2)
23201da177e4SLinus Torvalds 			return 0;
23211da177e4SLinus Torvalds 
23221da177e4SLinus Torvalds 		if (newlen > table->maxlen)
23231da177e4SLinus Torvalds 			newlen = table->maxlen;
23241da177e4SLinus Torvalds 		length = newlen / sizeof(int);
23251da177e4SLinus Torvalds 
23261da177e4SLinus Torvalds 		for (i = 0; i < length; i++) {
23271da177e4SLinus Torvalds 			int value;
23281da177e4SLinus Torvalds 			if (get_user(value, vec + i))
23291da177e4SLinus Torvalds 				return -EFAULT;
23301da177e4SLinus Torvalds 			if (min && value < min[i])
23311da177e4SLinus Torvalds 				return -EINVAL;
23321da177e4SLinus Torvalds 			if (max && value > max[i])
23331da177e4SLinus Torvalds 				return -EINVAL;
23341da177e4SLinus Torvalds 		}
23351da177e4SLinus Torvalds 	}
23361da177e4SLinus Torvalds 	return 0;
23371da177e4SLinus Torvalds }
23381da177e4SLinus Torvalds 
23391da177e4SLinus Torvalds /* Strategy function to convert jiffies to seconds */
23401da177e4SLinus Torvalds int sysctl_jiffies(ctl_table *table, int __user *name, int nlen,
23411da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
23421da177e4SLinus Torvalds 		void __user *newval, size_t newlen, void **context)
23431da177e4SLinus Torvalds {
23441da177e4SLinus Torvalds 	if (oldval) {
23451da177e4SLinus Torvalds 		size_t olen;
23461da177e4SLinus Torvalds 		if (oldlenp) {
23471da177e4SLinus Torvalds 			if (get_user(olen, oldlenp))
23481da177e4SLinus Torvalds 				return -EFAULT;
23491da177e4SLinus Torvalds 			if (olen!=sizeof(int))
23501da177e4SLinus Torvalds 				return -EINVAL;
23511da177e4SLinus Torvalds 		}
23521da177e4SLinus Torvalds 		if (put_user(*(int *)(table->data)/HZ, (int __user *)oldval) ||
23531da177e4SLinus Torvalds 		    (oldlenp && put_user(sizeof(int),oldlenp)))
23541da177e4SLinus Torvalds 			return -EFAULT;
23551da177e4SLinus Torvalds 	}
23561da177e4SLinus Torvalds 	if (newval && newlen) {
23571da177e4SLinus Torvalds 		int new;
23581da177e4SLinus Torvalds 		if (newlen != sizeof(int))
23591da177e4SLinus Torvalds 			return -EINVAL;
23601da177e4SLinus Torvalds 		if (get_user(new, (int __user *)newval))
23611da177e4SLinus Torvalds 			return -EFAULT;
23621da177e4SLinus Torvalds 		*(int *)(table->data) = new*HZ;
23631da177e4SLinus Torvalds 	}
23641da177e4SLinus Torvalds 	return 1;
23651da177e4SLinus Torvalds }
23661da177e4SLinus Torvalds 
23671da177e4SLinus Torvalds /* Strategy function to convert jiffies to seconds */
23681da177e4SLinus Torvalds int sysctl_ms_jiffies(ctl_table *table, int __user *name, int nlen,
23691da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
23701da177e4SLinus Torvalds 		void __user *newval, size_t newlen, void **context)
23711da177e4SLinus Torvalds {
23721da177e4SLinus Torvalds 	if (oldval) {
23731da177e4SLinus Torvalds 		size_t olen;
23741da177e4SLinus Torvalds 		if (oldlenp) {
23751da177e4SLinus Torvalds 			if (get_user(olen, oldlenp))
23761da177e4SLinus Torvalds 				return -EFAULT;
23771da177e4SLinus Torvalds 			if (olen!=sizeof(int))
23781da177e4SLinus Torvalds 				return -EINVAL;
23791da177e4SLinus Torvalds 		}
23801da177e4SLinus Torvalds 		if (put_user(jiffies_to_msecs(*(int *)(table->data)), (int __user *)oldval) ||
23811da177e4SLinus Torvalds 		    (oldlenp && put_user(sizeof(int),oldlenp)))
23821da177e4SLinus Torvalds 			return -EFAULT;
23831da177e4SLinus Torvalds 	}
23841da177e4SLinus Torvalds 	if (newval && newlen) {
23851da177e4SLinus Torvalds 		int new;
23861da177e4SLinus Torvalds 		if (newlen != sizeof(int))
23871da177e4SLinus Torvalds 			return -EINVAL;
23881da177e4SLinus Torvalds 		if (get_user(new, (int __user *)newval))
23891da177e4SLinus Torvalds 			return -EFAULT;
23901da177e4SLinus Torvalds 		*(int *)(table->data) = msecs_to_jiffies(new);
23911da177e4SLinus Torvalds 	}
23921da177e4SLinus Torvalds 	return 1;
23931da177e4SLinus Torvalds }
23941da177e4SLinus Torvalds 
23951da177e4SLinus Torvalds #else /* CONFIG_SYSCTL */
23961da177e4SLinus Torvalds 
23971da177e4SLinus Torvalds 
23981da177e4SLinus Torvalds asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
23991da177e4SLinus Torvalds {
24001da177e4SLinus Torvalds 	return -ENOSYS;
24011da177e4SLinus Torvalds }
24021da177e4SLinus Torvalds 
24031da177e4SLinus Torvalds int sysctl_string(ctl_table *table, int __user *name, int nlen,
24041da177e4SLinus Torvalds 		  void __user *oldval, size_t __user *oldlenp,
24051da177e4SLinus Torvalds 		  void __user *newval, size_t newlen, void **context)
24061da177e4SLinus Torvalds {
24071da177e4SLinus Torvalds 	return -ENOSYS;
24081da177e4SLinus Torvalds }
24091da177e4SLinus Torvalds 
24101da177e4SLinus Torvalds int sysctl_intvec(ctl_table *table, int __user *name, int nlen,
24111da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
24121da177e4SLinus Torvalds 		void __user *newval, size_t newlen, void **context)
24131da177e4SLinus Torvalds {
24141da177e4SLinus Torvalds 	return -ENOSYS;
24151da177e4SLinus Torvalds }
24161da177e4SLinus Torvalds 
24171da177e4SLinus Torvalds int sysctl_jiffies(ctl_table *table, int __user *name, int nlen,
24181da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
24191da177e4SLinus Torvalds 		void __user *newval, size_t newlen, void **context)
24201da177e4SLinus Torvalds {
24211da177e4SLinus Torvalds 	return -ENOSYS;
24221da177e4SLinus Torvalds }
24231da177e4SLinus Torvalds 
24241da177e4SLinus Torvalds int sysctl_ms_jiffies(ctl_table *table, int __user *name, int nlen,
24251da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
24261da177e4SLinus Torvalds 		void __user *newval, size_t newlen, void **context)
24271da177e4SLinus Torvalds {
24281da177e4SLinus Torvalds 	return -ENOSYS;
24291da177e4SLinus Torvalds }
24301da177e4SLinus Torvalds 
24311da177e4SLinus Torvalds int proc_dostring(ctl_table *table, int write, struct file *filp,
24321da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
24331da177e4SLinus Torvalds {
24341da177e4SLinus Torvalds 	return -ENOSYS;
24351da177e4SLinus Torvalds }
24361da177e4SLinus Torvalds 
24371da177e4SLinus Torvalds int proc_dointvec(ctl_table *table, int write, struct file *filp,
24381da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
24391da177e4SLinus Torvalds {
24401da177e4SLinus Torvalds 	return -ENOSYS;
24411da177e4SLinus Torvalds }
24421da177e4SLinus Torvalds 
24431da177e4SLinus Torvalds int proc_dointvec_bset(ctl_table *table, int write, struct file *filp,
24441da177e4SLinus Torvalds 			void __user *buffer, size_t *lenp, loff_t *ppos)
24451da177e4SLinus Torvalds {
24461da177e4SLinus Torvalds 	return -ENOSYS;
24471da177e4SLinus Torvalds }
24481da177e4SLinus Torvalds 
24491da177e4SLinus Torvalds int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
24501da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
24511da177e4SLinus Torvalds {
24521da177e4SLinus Torvalds 	return -ENOSYS;
24531da177e4SLinus Torvalds }
24541da177e4SLinus Torvalds 
24551da177e4SLinus Torvalds int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
24561da177e4SLinus Torvalds 			  void __user *buffer, size_t *lenp, loff_t *ppos)
24571da177e4SLinus Torvalds {
24581da177e4SLinus Torvalds 	return -ENOSYS;
24591da177e4SLinus Torvalds }
24601da177e4SLinus Torvalds 
24611da177e4SLinus Torvalds int proc_dointvec_userhz_jiffies(ctl_table *table, int write, struct file *filp,
24621da177e4SLinus Torvalds 			  void __user *buffer, size_t *lenp, loff_t *ppos)
24631da177e4SLinus Torvalds {
24641da177e4SLinus Torvalds 	return -ENOSYS;
24651da177e4SLinus Torvalds }
24661da177e4SLinus Torvalds 
24671da177e4SLinus Torvalds int proc_dointvec_ms_jiffies(ctl_table *table, int write, struct file *filp,
24681da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
24691da177e4SLinus Torvalds {
24701da177e4SLinus Torvalds 	return -ENOSYS;
24711da177e4SLinus Torvalds }
24721da177e4SLinus Torvalds 
24731da177e4SLinus Torvalds int proc_doulongvec_minmax(ctl_table *table, int write, struct file *filp,
24741da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
24751da177e4SLinus Torvalds {
24761da177e4SLinus Torvalds 	return -ENOSYS;
24771da177e4SLinus Torvalds }
24781da177e4SLinus Torvalds 
24791da177e4SLinus Torvalds int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int write,
24801da177e4SLinus Torvalds 				      struct file *filp,
24811da177e4SLinus Torvalds 				      void __user *buffer,
24821da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
24831da177e4SLinus Torvalds {
24841da177e4SLinus Torvalds     return -ENOSYS;
24851da177e4SLinus Torvalds }
24861da177e4SLinus Torvalds 
24871da177e4SLinus Torvalds struct ctl_table_header * register_sysctl_table(ctl_table * table,
24881da177e4SLinus Torvalds 						int insert_at_head)
24891da177e4SLinus Torvalds {
24901da177e4SLinus Torvalds 	return NULL;
24911da177e4SLinus Torvalds }
24921da177e4SLinus Torvalds 
24931da177e4SLinus Torvalds void unregister_sysctl_table(struct ctl_table_header * table)
24941da177e4SLinus Torvalds {
24951da177e4SLinus Torvalds }
24961da177e4SLinus Torvalds 
24971da177e4SLinus Torvalds #endif /* CONFIG_SYSCTL */
24981da177e4SLinus Torvalds 
24991da177e4SLinus Torvalds /*
25001da177e4SLinus Torvalds  * No sense putting this after each symbol definition, twice,
25011da177e4SLinus Torvalds  * exception granted :-)
25021da177e4SLinus Torvalds  */
25031da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec);
25041da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_jiffies);
25051da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_minmax);
25061da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
25071da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
25081da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dostring);
25091da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_minmax);
25101da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
25111da177e4SLinus Torvalds EXPORT_SYMBOL(register_sysctl_table);
25121da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_intvec);
25131da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_jiffies);
25141da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_ms_jiffies);
25151da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_string);
25161da177e4SLinus Torvalds EXPORT_SYMBOL(unregister_sysctl_table);
2517