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, ¶m); 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