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/module.h> 22e2e40f2cSChristoph Hellwig #include <linux/aio.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> 275a04cca6SAkinobu Mita #include <linux/bitmap.h> 28d33ed52dSDave Young #include <linux/signal.h> 29455cd5abSDan Rosenberg #include <linux/printk.h> 301da177e4SLinus Torvalds #include <linux/proc_fs.h> 3172c2d582SAndrew Morgan #include <linux/security.h> 321da177e4SLinus Torvalds #include <linux/ctype.h> 33dfec072eSVegard Nossum #include <linux/kmemcheck.h> 34fd4b616bSSteven Rostedt #include <linux/kmemleak.h> 3562239ac2SAdrian Bunk #include <linux/fs.h> 361da177e4SLinus Torvalds #include <linux/init.h> 371da177e4SLinus Torvalds #include <linux/kernel.h> 380296b228SKay Sievers #include <linux/kobject.h> 3920380731SArnaldo Carvalho de Melo #include <linux/net.h> 401da177e4SLinus Torvalds #include <linux/sysrq.h> 411da177e4SLinus Torvalds #include <linux/highuid.h> 421da177e4SLinus Torvalds #include <linux/writeback.h> 433fff4c42SIngo Molnar #include <linux/ratelimit.h> 4476ab0f53SMel Gorman #include <linux/compaction.h> 451da177e4SLinus Torvalds #include <linux/hugetlb.h> 461da177e4SLinus Torvalds #include <linux/initrd.h> 470b77f5bfSDavid Howells #include <linux/key.h> 481da177e4SLinus Torvalds #include <linux/times.h> 491da177e4SLinus Torvalds #include <linux/limits.h> 501da177e4SLinus Torvalds #include <linux/dcache.h> 516e006701SAlexey Dobriyan #include <linux/dnotify.h> 521da177e4SLinus Torvalds #include <linux/syscalls.h> 53c748e134SAdrian Bunk #include <linux/vmstat.h> 54c255d844SPavel Machek #include <linux/nfs_fs.h> 55c255d844SPavel Machek #include <linux/acpi.h> 5610a0a8d4SJeremy Fitzhardinge #include <linux/reboot.h> 57b0fc494fSSteven Rostedt #include <linux/ftrace.h> 58cdd6c482SIngo Molnar #include <linux/perf_event.h> 59b2be84dfSMasami Hiramatsu #include <linux/kprobes.h> 60b492e95bSJens Axboe #include <linux/pipe_fs_i.h> 618e4228e1SDavid Rientjes #include <linux/oom.h> 6217f60a7dSEric Paris #include <linux/kmod.h> 6373efc039SDan Ballard #include <linux/capability.h> 6440401530SAl Viro #include <linux/binfmts.h> 65cf4aebc2SClark Williams #include <linux/sched/sysctl.h> 667984754bSKees Cook #include <linux/kexec.h> 671be7f75dSAlexei Starovoitov #include <linux/bpf.h> 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds #include <asm/uaccess.h> 701da177e4SLinus Torvalds #include <asm/processor.h> 711da177e4SLinus Torvalds 7229cbc78bSAndi Kleen #ifdef CONFIG_X86 7329cbc78bSAndi Kleen #include <asm/nmi.h> 740741f4d2SChuck Ebbert #include <asm/stacktrace.h> 756e7c4025SIngo Molnar #include <asm/io.h> 7629cbc78bSAndi Kleen #endif 77d550bbd4SDavid Howells #ifdef CONFIG_SPARC 78d550bbd4SDavid Howells #include <asm/setup.h> 79d550bbd4SDavid Howells #endif 80c55b7c3eSDave Young #ifdef CONFIG_BSD_PROCESS_ACCT 81c55b7c3eSDave Young #include <linux/acct.h> 82c55b7c3eSDave Young #endif 834f0e056fSDave Young #ifdef CONFIG_RT_MUTEXES 844f0e056fSDave Young #include <linux/rtmutex.h> 854f0e056fSDave Young #endif 862edf5e49SDave Young #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT) 872edf5e49SDave Young #include <linux/lockdep.h> 882edf5e49SDave Young #endif 8915485a46SDave Young #ifdef CONFIG_CHR_DEV_SG 9015485a46SDave Young #include <scsi/sg.h> 9115485a46SDave Young #endif 9229cbc78bSAndi Kleen 9358687acbSDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR 94504d7cf1SDon Zickus #include <linux/nmi.h> 95504d7cf1SDon Zickus #endif 96504d7cf1SDon Zickus 971da177e4SLinus Torvalds #if defined(CONFIG_SYSCTL) 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds /* External variables not in a header file. */ 100d6e71144SAlan Cox extern int suid_dumpable; 101046d662fSAlex Kelly #ifdef CONFIG_COREDUMP 102046d662fSAlex Kelly extern int core_uses_pid; 1031da177e4SLinus Torvalds extern char core_pattern[]; 104a293980cSNeil Horman extern unsigned int core_pipe_limit; 105046d662fSAlex Kelly #endif 1061da177e4SLinus Torvalds extern int pid_max; 1071da177e4SLinus Torvalds extern int pid_max_min, pid_max_max; 1088ad4b1fbSRohit Seth extern int percpu_pagelist_fraction; 109bebfa101SAndi Kleen extern int compat_log; 1109745512cSArjan van de Ven extern int latencytop_enabled; 111eceea0b3SAl Viro extern int sysctl_nr_open_min, sysctl_nr_open_max; 112dd8632a1SPaul Mundt #ifndef CONFIG_MMU 113dd8632a1SPaul Mundt extern int sysctl_nr_trim_pages; 114dd8632a1SPaul Mundt #endif 1151da177e4SLinus Torvalds 116c4f3b63fSRavikiran G Thirumalai /* Constants used for minimum and maximum */ 1172508ce18SDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR 118c4f3b63fSRavikiran G Thirumalai static int sixty = 60; 119c4f3b63fSRavikiran G Thirumalai #endif 120c4f3b63fSRavikiran G Thirumalai 121270750dbSAaron Tomlin static int __maybe_unused neg_one = -1; 122270750dbSAaron Tomlin 123c4f3b63fSRavikiran G Thirumalai static int zero; 124cd5f9a4cSLinus Torvalds static int __maybe_unused one = 1; 125cd5f9a4cSLinus Torvalds static int __maybe_unused two = 2; 1265509a5d2SDave Hansen static int __maybe_unused four = 4; 127fc3501d4SSven Wegener static unsigned long one_ul = 1; 128c4f3b63fSRavikiran G Thirumalai static int one_hundred = 100; 129af91322eSDave Young #ifdef CONFIG_PRINTK 130af91322eSDave Young static int ten_thousand = 10000; 131af91322eSDave Young #endif 132c4f3b63fSRavikiran G Thirumalai 1339e4a5bdaSAndrea Righi /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */ 1349e4a5bdaSAndrea Righi static unsigned long dirty_bytes_min = 2 * PAGE_SIZE; 1359e4a5bdaSAndrea Righi 1361da177e4SLinus Torvalds /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */ 1371da177e4SLinus Torvalds static int maxolduid = 65535; 1381da177e4SLinus Torvalds static int minolduid; 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds static int ngroups_max = NGROUPS_MAX; 14173efc039SDan Ballard static const int cap_last_cap = CAP_LAST_CAP; 1421da177e4SLinus Torvalds 14380df2847SLiu Hua /*this is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs */ 14480df2847SLiu Hua #ifdef CONFIG_DETECT_HUNG_TASK 14580df2847SLiu Hua static unsigned long hung_task_timeout_max = (LONG_MAX/HZ); 14680df2847SLiu Hua #endif 14780df2847SLiu Hua 148d14f1729SDave Young #ifdef CONFIG_INOTIFY_USER 149d14f1729SDave Young #include <linux/inotify.h> 150d14f1729SDave Young #endif 15172c57ed5SDavid S. Miller #ifdef CONFIG_SPARC 1521da177e4SLinus Torvalds #endif 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds #ifdef __hppa__ 1551da177e4SLinus Torvalds extern int pwrsw_enabled; 156bf14e3b9SVineet Gupta #endif 157bf14e3b9SVineet Gupta 158bf14e3b9SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW 1591da177e4SLinus Torvalds extern int unaligned_enabled; 1601da177e4SLinus Torvalds #endif 1611da177e4SLinus Torvalds 162d2b176edSJes Sorensen #ifdef CONFIG_IA64 16388fc241fSDoug Chapman extern int unaligned_dump_stack; 164d2b176edSJes Sorensen #endif 165d2b176edSJes Sorensen 166b6fca725SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN 167b6fca725SVineet Gupta extern int no_unaligned_warning; 168b6fca725SVineet Gupta #endif 169b6fca725SVineet Gupta 170d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL 171f4aacea2SKees Cook 172f4aacea2SKees Cook #define SYSCTL_WRITES_LEGACY -1 173f4aacea2SKees Cook #define SYSCTL_WRITES_WARN 0 174f4aacea2SKees Cook #define SYSCTL_WRITES_STRICT 1 175f4aacea2SKees Cook 176f4aacea2SKees Cook static int sysctl_writes_strict = SYSCTL_WRITES_WARN; 177f4aacea2SKees Cook 1788d65af78SAlexey Dobriyan static int proc_do_cad_pid(struct ctl_table *table, int write, 1799ec52099SCedric Le Goater void __user *buffer, size_t *lenp, loff_t *ppos); 1808d65af78SAlexey Dobriyan static int proc_taint(struct ctl_table *table, int write, 18134f5a398STheodore Ts'o void __user *buffer, size_t *lenp, loff_t *ppos); 182d6f8ff73SRandy Dunlap #endif 1839ec52099SCedric Le Goater 184bfdc0b49SRichard Weinberger #ifdef CONFIG_PRINTK 185620f6e8eSKees Cook static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write, 186bfdc0b49SRichard Weinberger void __user *buffer, size_t *lenp, loff_t *ppos); 187bfdc0b49SRichard Weinberger #endif 188bfdc0b49SRichard Weinberger 18954b50199SKees Cook static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write, 19054b50199SKees Cook void __user *buffer, size_t *lenp, loff_t *ppos); 191046d662fSAlex Kelly #ifdef CONFIG_COREDUMP 19254b50199SKees Cook static int proc_dostring_coredump(struct ctl_table *table, int write, 19354b50199SKees Cook void __user *buffer, size_t *lenp, loff_t *ppos); 194046d662fSAlex Kelly #endif 19554b50199SKees Cook 19697f5f0cdSDmitry Torokhov #ifdef CONFIG_MAGIC_SYSRQ 1978c6a98b2SAndy Whitcroft /* Note: sysrq code uses it's own private copy */ 1988eaede49SBen Hutchings static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE; 19997f5f0cdSDmitry Torokhov 2006f8fd1d7SJoe Perches static int sysrq_sysctl_handler(struct ctl_table *table, int write, 20197f5f0cdSDmitry Torokhov void __user *buffer, size_t *lenp, 20297f5f0cdSDmitry Torokhov loff_t *ppos) 20397f5f0cdSDmitry Torokhov { 20497f5f0cdSDmitry Torokhov int error; 20597f5f0cdSDmitry Torokhov 20697f5f0cdSDmitry Torokhov error = proc_dointvec(table, write, buffer, lenp, ppos); 20797f5f0cdSDmitry Torokhov if (error) 20897f5f0cdSDmitry Torokhov return error; 20997f5f0cdSDmitry Torokhov 21097f5f0cdSDmitry Torokhov if (write) 21197f5f0cdSDmitry Torokhov sysrq_toggle_support(__sysrq_enabled); 21297f5f0cdSDmitry Torokhov 21397f5f0cdSDmitry Torokhov return 0; 21497f5f0cdSDmitry Torokhov } 21597f5f0cdSDmitry Torokhov 21697f5f0cdSDmitry Torokhov #endif 21797f5f0cdSDmitry Torokhov 218d8217f07SEric W. Biederman static struct ctl_table kern_table[]; 219d8217f07SEric W. Biederman static struct ctl_table vm_table[]; 220d8217f07SEric W. Biederman static struct ctl_table fs_table[]; 221d8217f07SEric W. Biederman static struct ctl_table debug_table[]; 222d8217f07SEric W. Biederman static struct ctl_table dev_table[]; 223d8217f07SEric W. Biederman extern struct ctl_table random_table[]; 2247ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL 2257ef9964eSDavide Libenzi extern struct ctl_table epoll_table[]; 2267ef9964eSDavide Libenzi #endif 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT 2291da177e4SLinus Torvalds int sysctl_legacy_va_layout; 2301da177e4SLinus Torvalds #endif 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds /* The default sysctl tables: */ 2331da177e4SLinus Torvalds 234de4e83bdSEric W. Biederman static struct ctl_table sysctl_base_table[] = { 2351da177e4SLinus Torvalds { 2361da177e4SLinus Torvalds .procname = "kernel", 2371da177e4SLinus Torvalds .mode = 0555, 2381da177e4SLinus Torvalds .child = kern_table, 2391da177e4SLinus Torvalds }, 2401da177e4SLinus Torvalds { 2411da177e4SLinus Torvalds .procname = "vm", 2421da177e4SLinus Torvalds .mode = 0555, 2431da177e4SLinus Torvalds .child = vm_table, 2441da177e4SLinus Torvalds }, 2451da177e4SLinus Torvalds { 2461da177e4SLinus Torvalds .procname = "fs", 2471da177e4SLinus Torvalds .mode = 0555, 2481da177e4SLinus Torvalds .child = fs_table, 2491da177e4SLinus Torvalds }, 2501da177e4SLinus Torvalds { 2511da177e4SLinus Torvalds .procname = "debug", 2521da177e4SLinus Torvalds .mode = 0555, 2531da177e4SLinus Torvalds .child = debug_table, 2541da177e4SLinus Torvalds }, 2551da177e4SLinus Torvalds { 2561da177e4SLinus Torvalds .procname = "dev", 2571da177e4SLinus Torvalds .mode = 0555, 2581da177e4SLinus Torvalds .child = dev_table, 2591da177e4SLinus Torvalds }, 2606fce56ecSEric W. Biederman { } 2611da177e4SLinus Torvalds }; 2621da177e4SLinus Torvalds 26377e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 26473c4efd2SEric Dumazet static int min_sched_granularity_ns = 100000; /* 100 usecs */ 26573c4efd2SEric Dumazet static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */ 26673c4efd2SEric Dumazet static int min_wakeup_granularity_ns; /* 0 usecs */ 26773c4efd2SEric Dumazet static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */ 268cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP 2691983a922SChristian Ehrhardt static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE; 2701983a922SChristian Ehrhardt static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1; 271cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */ 272cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */ 27377e54a1fSIngo Molnar 2745e771905SMel Gorman #ifdef CONFIG_COMPACTION 2755e771905SMel Gorman static int min_extfrag_threshold; 2765e771905SMel Gorman static int max_extfrag_threshold = 1000; 2775e771905SMel Gorman #endif 2785e771905SMel Gorman 279d8217f07SEric W. Biederman static struct ctl_table kern_table[] = { 2802bba22c5SMike Galbraith { 2812bba22c5SMike Galbraith .procname = "sched_child_runs_first", 2822bba22c5SMike Galbraith .data = &sysctl_sched_child_runs_first, 2832bba22c5SMike Galbraith .maxlen = sizeof(unsigned int), 2842bba22c5SMike Galbraith .mode = 0644, 2856d456111SEric W. Biederman .proc_handler = proc_dointvec, 2862bba22c5SMike Galbraith }, 28777e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 28877e54a1fSIngo Molnar { 289b2be5e96SPeter Zijlstra .procname = "sched_min_granularity_ns", 290b2be5e96SPeter Zijlstra .data = &sysctl_sched_min_granularity, 29177e54a1fSIngo Molnar .maxlen = sizeof(unsigned int), 29277e54a1fSIngo Molnar .mode = 0644, 293702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 294b2be5e96SPeter Zijlstra .extra1 = &min_sched_granularity_ns, 295b2be5e96SPeter Zijlstra .extra2 = &max_sched_granularity_ns, 29677e54a1fSIngo Molnar }, 29777e54a1fSIngo Molnar { 29821805085SPeter Zijlstra .procname = "sched_latency_ns", 29921805085SPeter Zijlstra .data = &sysctl_sched_latency, 30021805085SPeter Zijlstra .maxlen = sizeof(unsigned int), 30121805085SPeter Zijlstra .mode = 0644, 302702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 30321805085SPeter Zijlstra .extra1 = &min_sched_granularity_ns, 30421805085SPeter Zijlstra .extra2 = &max_sched_granularity_ns, 30521805085SPeter Zijlstra }, 30621805085SPeter Zijlstra { 30777e54a1fSIngo Molnar .procname = "sched_wakeup_granularity_ns", 30877e54a1fSIngo Molnar .data = &sysctl_sched_wakeup_granularity, 30977e54a1fSIngo Molnar .maxlen = sizeof(unsigned int), 31077e54a1fSIngo Molnar .mode = 0644, 311702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 31277e54a1fSIngo Molnar .extra1 = &min_wakeup_granularity_ns, 31377e54a1fSIngo Molnar .extra2 = &max_wakeup_granularity_ns, 31477e54a1fSIngo Molnar }, 315cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP 31677e54a1fSIngo Molnar { 3171983a922SChristian Ehrhardt .procname = "sched_tunable_scaling", 3181983a922SChristian Ehrhardt .data = &sysctl_sched_tunable_scaling, 3191983a922SChristian Ehrhardt .maxlen = sizeof(enum sched_tunable_scaling), 3201983a922SChristian Ehrhardt .mode = 0644, 321702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 3221983a922SChristian Ehrhardt .extra1 = &min_sched_tunable_scaling, 3231983a922SChristian Ehrhardt .extra2 = &max_sched_tunable_scaling, 3242398f2c6SPeter Zijlstra }, 3252398f2c6SPeter Zijlstra { 326d00535dbSNamhyung Kim .procname = "sched_migration_cost_ns", 327da84d961SIngo Molnar .data = &sysctl_sched_migration_cost, 328da84d961SIngo Molnar .maxlen = sizeof(unsigned int), 329da84d961SIngo Molnar .mode = 0644, 3306d456111SEric W. Biederman .proc_handler = proc_dointvec, 331da84d961SIngo Molnar }, 332b82d9fddSPeter Zijlstra { 333b82d9fddSPeter Zijlstra .procname = "sched_nr_migrate", 334b82d9fddSPeter Zijlstra .data = &sysctl_sched_nr_migrate, 335b82d9fddSPeter Zijlstra .maxlen = sizeof(unsigned int), 336fa85ae24SPeter Zijlstra .mode = 0644, 3376d456111SEric W. Biederman .proc_handler = proc_dointvec, 338fa85ae24SPeter Zijlstra }, 339cd1bb94bSArun R Bharadwaj { 340d00535dbSNamhyung Kim .procname = "sched_time_avg_ms", 341e9e9250bSPeter Zijlstra .data = &sysctl_sched_time_avg, 342e9e9250bSPeter Zijlstra .maxlen = sizeof(unsigned int), 343e9e9250bSPeter Zijlstra .mode = 0644, 3446d456111SEric W. Biederman .proc_handler = proc_dointvec, 345e9e9250bSPeter Zijlstra }, 346e9e9250bSPeter Zijlstra { 347d00535dbSNamhyung Kim .procname = "sched_shares_window_ns", 348a7a4f8a7SPaul Turner .data = &sysctl_sched_shares_window, 349a7a4f8a7SPaul Turner .maxlen = sizeof(unsigned int), 350a7a4f8a7SPaul Turner .mode = 0644, 351a7a4f8a7SPaul Turner .proc_handler = proc_dointvec, 352a7a4f8a7SPaul Turner }, 353cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */ 354cbee9f88SPeter Zijlstra #ifdef CONFIG_NUMA_BALANCING 355cbee9f88SPeter Zijlstra { 3564b96a29bSPeter Zijlstra .procname = "numa_balancing_scan_delay_ms", 3574b96a29bSPeter Zijlstra .data = &sysctl_numa_balancing_scan_delay, 3584b96a29bSPeter Zijlstra .maxlen = sizeof(unsigned int), 3594b96a29bSPeter Zijlstra .mode = 0644, 3604b96a29bSPeter Zijlstra .proc_handler = proc_dointvec, 3614b96a29bSPeter Zijlstra }, 3624b96a29bSPeter Zijlstra { 363cbee9f88SPeter Zijlstra .procname = "numa_balancing_scan_period_min_ms", 364cbee9f88SPeter Zijlstra .data = &sysctl_numa_balancing_scan_period_min, 365cbee9f88SPeter Zijlstra .maxlen = sizeof(unsigned int), 366cbee9f88SPeter Zijlstra .mode = 0644, 367cbee9f88SPeter Zijlstra .proc_handler = proc_dointvec, 368cbee9f88SPeter Zijlstra }, 369cbee9f88SPeter Zijlstra { 370cbee9f88SPeter Zijlstra .procname = "numa_balancing_scan_period_max_ms", 371cbee9f88SPeter Zijlstra .data = &sysctl_numa_balancing_scan_period_max, 372cbee9f88SPeter Zijlstra .maxlen = sizeof(unsigned int), 373cbee9f88SPeter Zijlstra .mode = 0644, 374cbee9f88SPeter Zijlstra .proc_handler = proc_dointvec, 375cbee9f88SPeter Zijlstra }, 3766e5fb223SPeter Zijlstra { 3776e5fb223SPeter Zijlstra .procname = "numa_balancing_scan_size_mb", 3786e5fb223SPeter Zijlstra .data = &sysctl_numa_balancing_scan_size, 3796e5fb223SPeter Zijlstra .maxlen = sizeof(unsigned int), 3806e5fb223SPeter Zijlstra .mode = 0644, 38164192658SKirill Tkhai .proc_handler = proc_dointvec_minmax, 38264192658SKirill Tkhai .extra1 = &one, 3836e5fb223SPeter Zijlstra }, 3843a7053b3SMel Gorman { 38554a43d54SAndi Kleen .procname = "numa_balancing", 38654a43d54SAndi Kleen .data = NULL, /* filled in by handler */ 38754a43d54SAndi Kleen .maxlen = sizeof(unsigned int), 38854a43d54SAndi Kleen .mode = 0644, 38954a43d54SAndi Kleen .proc_handler = sysctl_numa_balancing, 39054a43d54SAndi Kleen .extra1 = &zero, 39154a43d54SAndi Kleen .extra2 = &one, 39254a43d54SAndi Kleen }, 393cbee9f88SPeter Zijlstra #endif /* CONFIG_NUMA_BALANCING */ 394cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */ 3951799e35dSIngo Molnar { 3969f0c1e56SPeter Zijlstra .procname = "sched_rt_period_us", 3979f0c1e56SPeter Zijlstra .data = &sysctl_sched_rt_period, 3989f0c1e56SPeter Zijlstra .maxlen = sizeof(unsigned int), 3999f0c1e56SPeter Zijlstra .mode = 0644, 4006d456111SEric W. Biederman .proc_handler = sched_rt_handler, 4019f0c1e56SPeter Zijlstra }, 4029f0c1e56SPeter Zijlstra { 4039f0c1e56SPeter Zijlstra .procname = "sched_rt_runtime_us", 4049f0c1e56SPeter Zijlstra .data = &sysctl_sched_rt_runtime, 4059f0c1e56SPeter Zijlstra .maxlen = sizeof(int), 4069f0c1e56SPeter Zijlstra .mode = 0644, 4076d456111SEric W. Biederman .proc_handler = sched_rt_handler, 4089f0c1e56SPeter Zijlstra }, 409ce0dbbbbSClark Williams { 410ce0dbbbbSClark Williams .procname = "sched_rr_timeslice_ms", 411ce0dbbbbSClark Williams .data = &sched_rr_timeslice, 412ce0dbbbbSClark Williams .maxlen = sizeof(int), 413ce0dbbbbSClark Williams .mode = 0644, 414ce0dbbbbSClark Williams .proc_handler = sched_rr_handler, 415ce0dbbbbSClark Williams }, 4165091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 4175091faa4SMike Galbraith { 4185091faa4SMike Galbraith .procname = "sched_autogroup_enabled", 4195091faa4SMike Galbraith .data = &sysctl_sched_autogroup_enabled, 4205091faa4SMike Galbraith .maxlen = sizeof(unsigned int), 4215091faa4SMike Galbraith .mode = 0644, 4221747b21fSYong Zhang .proc_handler = proc_dointvec_minmax, 4235091faa4SMike Galbraith .extra1 = &zero, 4245091faa4SMike Galbraith .extra2 = &one, 4255091faa4SMike Galbraith }, 4265091faa4SMike Galbraith #endif 427ec12cb7fSPaul Turner #ifdef CONFIG_CFS_BANDWIDTH 428ec12cb7fSPaul Turner { 429ec12cb7fSPaul Turner .procname = "sched_cfs_bandwidth_slice_us", 430ec12cb7fSPaul Turner .data = &sysctl_sched_cfs_bandwidth_slice, 431ec12cb7fSPaul Turner .maxlen = sizeof(unsigned int), 432ec12cb7fSPaul Turner .mode = 0644, 433ec12cb7fSPaul Turner .proc_handler = proc_dointvec_minmax, 434ec12cb7fSPaul Turner .extra1 = &one, 435ec12cb7fSPaul Turner }, 436ec12cb7fSPaul Turner #endif 437f20786ffSPeter Zijlstra #ifdef CONFIG_PROVE_LOCKING 438f20786ffSPeter Zijlstra { 439f20786ffSPeter Zijlstra .procname = "prove_locking", 440f20786ffSPeter Zijlstra .data = &prove_locking, 441f20786ffSPeter Zijlstra .maxlen = sizeof(int), 442f20786ffSPeter Zijlstra .mode = 0644, 4436d456111SEric W. Biederman .proc_handler = proc_dointvec, 444f20786ffSPeter Zijlstra }, 445f20786ffSPeter Zijlstra #endif 446f20786ffSPeter Zijlstra #ifdef CONFIG_LOCK_STAT 447f20786ffSPeter Zijlstra { 448f20786ffSPeter Zijlstra .procname = "lock_stat", 449f20786ffSPeter Zijlstra .data = &lock_stat, 450f20786ffSPeter Zijlstra .maxlen = sizeof(int), 451f20786ffSPeter Zijlstra .mode = 0644, 4526d456111SEric W. Biederman .proc_handler = proc_dointvec, 453f20786ffSPeter Zijlstra }, 454f20786ffSPeter Zijlstra #endif 45577e54a1fSIngo Molnar { 4561da177e4SLinus Torvalds .procname = "panic", 4571da177e4SLinus Torvalds .data = &panic_timeout, 4581da177e4SLinus Torvalds .maxlen = sizeof(int), 4591da177e4SLinus Torvalds .mode = 0644, 4606d456111SEric W. Biederman .proc_handler = proc_dointvec, 4611da177e4SLinus Torvalds }, 462046d662fSAlex Kelly #ifdef CONFIG_COREDUMP 4631da177e4SLinus Torvalds { 4641da177e4SLinus Torvalds .procname = "core_uses_pid", 4651da177e4SLinus Torvalds .data = &core_uses_pid, 4661da177e4SLinus Torvalds .maxlen = sizeof(int), 4671da177e4SLinus Torvalds .mode = 0644, 4686d456111SEric W. Biederman .proc_handler = proc_dointvec, 4691da177e4SLinus Torvalds }, 4701da177e4SLinus Torvalds { 4711da177e4SLinus Torvalds .procname = "core_pattern", 4721da177e4SLinus Torvalds .data = core_pattern, 47371ce92f3SDan Aloni .maxlen = CORENAME_MAX_SIZE, 4741da177e4SLinus Torvalds .mode = 0644, 47554b50199SKees Cook .proc_handler = proc_dostring_coredump, 4761da177e4SLinus Torvalds }, 477a293980cSNeil Horman { 478a293980cSNeil Horman .procname = "core_pipe_limit", 479a293980cSNeil Horman .data = &core_pipe_limit, 480a293980cSNeil Horman .maxlen = sizeof(unsigned int), 481a293980cSNeil Horman .mode = 0644, 4826d456111SEric W. Biederman .proc_handler = proc_dointvec, 483a293980cSNeil Horman }, 484046d662fSAlex Kelly #endif 48534f5a398STheodore Ts'o #ifdef CONFIG_PROC_SYSCTL 4861da177e4SLinus Torvalds { 4871da177e4SLinus Torvalds .procname = "tainted", 48825ddbb18SAndi Kleen .maxlen = sizeof(long), 48934f5a398STheodore Ts'o .mode = 0644, 4906d456111SEric W. Biederman .proc_handler = proc_taint, 4911da177e4SLinus Torvalds }, 492f4aacea2SKees Cook { 493f4aacea2SKees Cook .procname = "sysctl_writes_strict", 494f4aacea2SKees Cook .data = &sysctl_writes_strict, 495f4aacea2SKees Cook .maxlen = sizeof(int), 496f4aacea2SKees Cook .mode = 0644, 497f4aacea2SKees Cook .proc_handler = proc_dointvec_minmax, 498f4aacea2SKees Cook .extra1 = &neg_one, 499f4aacea2SKees Cook .extra2 = &one, 500f4aacea2SKees Cook }, 50134f5a398STheodore Ts'o #endif 5029745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 5039745512cSArjan van de Ven { 5049745512cSArjan van de Ven .procname = "latencytop", 5059745512cSArjan van de Ven .data = &latencytop_enabled, 5069745512cSArjan van de Ven .maxlen = sizeof(int), 5079745512cSArjan van de Ven .mode = 0644, 5086d456111SEric W. Biederman .proc_handler = proc_dointvec, 5099745512cSArjan van de Ven }, 5109745512cSArjan van de Ven #endif 5111da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD 5121da177e4SLinus Torvalds { 5131da177e4SLinus Torvalds .procname = "real-root-dev", 5141da177e4SLinus Torvalds .data = &real_root_dev, 5151da177e4SLinus Torvalds .maxlen = sizeof(int), 5161da177e4SLinus Torvalds .mode = 0644, 5176d456111SEric W. Biederman .proc_handler = proc_dointvec, 5181da177e4SLinus Torvalds }, 5191da177e4SLinus Torvalds #endif 52045807a1dSIngo Molnar { 52145807a1dSIngo Molnar .procname = "print-fatal-signals", 52245807a1dSIngo Molnar .data = &print_fatal_signals, 52345807a1dSIngo Molnar .maxlen = sizeof(int), 52445807a1dSIngo Molnar .mode = 0644, 5256d456111SEric W. Biederman .proc_handler = proc_dointvec, 52645807a1dSIngo Molnar }, 52772c57ed5SDavid S. Miller #ifdef CONFIG_SPARC 5281da177e4SLinus Torvalds { 5291da177e4SLinus Torvalds .procname = "reboot-cmd", 5301da177e4SLinus Torvalds .data = reboot_command, 5311da177e4SLinus Torvalds .maxlen = 256, 5321da177e4SLinus Torvalds .mode = 0644, 5336d456111SEric W. Biederman .proc_handler = proc_dostring, 5341da177e4SLinus Torvalds }, 5351da177e4SLinus Torvalds { 5361da177e4SLinus Torvalds .procname = "stop-a", 5371da177e4SLinus Torvalds .data = &stop_a_enabled, 5381da177e4SLinus Torvalds .maxlen = sizeof (int), 5391da177e4SLinus Torvalds .mode = 0644, 5406d456111SEric W. Biederman .proc_handler = proc_dointvec, 5411da177e4SLinus Torvalds }, 5421da177e4SLinus Torvalds { 5431da177e4SLinus Torvalds .procname = "scons-poweroff", 5441da177e4SLinus Torvalds .data = &scons_pwroff, 5451da177e4SLinus Torvalds .maxlen = sizeof (int), 5461da177e4SLinus Torvalds .mode = 0644, 5476d456111SEric W. Biederman .proc_handler = proc_dointvec, 5481da177e4SLinus Torvalds }, 5491da177e4SLinus Torvalds #endif 5500871420fSDavid S. Miller #ifdef CONFIG_SPARC64 5510871420fSDavid S. Miller { 5520871420fSDavid S. Miller .procname = "tsb-ratio", 5530871420fSDavid S. Miller .data = &sysctl_tsb_ratio, 5540871420fSDavid S. Miller .maxlen = sizeof (int), 5550871420fSDavid S. Miller .mode = 0644, 5566d456111SEric W. Biederman .proc_handler = proc_dointvec, 5570871420fSDavid S. Miller }, 5580871420fSDavid S. Miller #endif 5591da177e4SLinus Torvalds #ifdef __hppa__ 5601da177e4SLinus Torvalds { 5611da177e4SLinus Torvalds .procname = "soft-power", 5621da177e4SLinus Torvalds .data = &pwrsw_enabled, 5631da177e4SLinus Torvalds .maxlen = sizeof (int), 5641da177e4SLinus Torvalds .mode = 0644, 5656d456111SEric W. Biederman .proc_handler = proc_dointvec, 5661da177e4SLinus Torvalds }, 567bf14e3b9SVineet Gupta #endif 568bf14e3b9SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW 5691da177e4SLinus Torvalds { 5701da177e4SLinus Torvalds .procname = "unaligned-trap", 5711da177e4SLinus Torvalds .data = &unaligned_enabled, 5721da177e4SLinus Torvalds .maxlen = sizeof (int), 5731da177e4SLinus Torvalds .mode = 0644, 5746d456111SEric W. Biederman .proc_handler = proc_dointvec, 5751da177e4SLinus Torvalds }, 5761da177e4SLinus Torvalds #endif 5771da177e4SLinus Torvalds { 5781da177e4SLinus Torvalds .procname = "ctrl-alt-del", 5791da177e4SLinus Torvalds .data = &C_A_D, 5801da177e4SLinus Torvalds .maxlen = sizeof(int), 5811da177e4SLinus Torvalds .mode = 0644, 5826d456111SEric W. Biederman .proc_handler = proc_dointvec, 5831da177e4SLinus Torvalds }, 584606576ceSSteven Rostedt #ifdef CONFIG_FUNCTION_TRACER 585b0fc494fSSteven Rostedt { 586b0fc494fSSteven Rostedt .procname = "ftrace_enabled", 587b0fc494fSSteven Rostedt .data = &ftrace_enabled, 588b0fc494fSSteven Rostedt .maxlen = sizeof(int), 589b0fc494fSSteven Rostedt .mode = 0644, 5906d456111SEric W. Biederman .proc_handler = ftrace_enable_sysctl, 591b0fc494fSSteven Rostedt }, 592b0fc494fSSteven Rostedt #endif 593f38f1d2aSSteven Rostedt #ifdef CONFIG_STACK_TRACER 594f38f1d2aSSteven Rostedt { 595f38f1d2aSSteven Rostedt .procname = "stack_tracer_enabled", 596f38f1d2aSSteven Rostedt .data = &stack_tracer_enabled, 597f38f1d2aSSteven Rostedt .maxlen = sizeof(int), 598f38f1d2aSSteven Rostedt .mode = 0644, 5996d456111SEric W. Biederman .proc_handler = stack_trace_sysctl, 600f38f1d2aSSteven Rostedt }, 601f38f1d2aSSteven Rostedt #endif 602944ac425SSteven Rostedt #ifdef CONFIG_TRACING 603944ac425SSteven Rostedt { 6043299b4ddSPeter Zijlstra .procname = "ftrace_dump_on_oops", 605944ac425SSteven Rostedt .data = &ftrace_dump_on_oops, 606944ac425SSteven Rostedt .maxlen = sizeof(int), 607944ac425SSteven Rostedt .mode = 0644, 6086d456111SEric W. Biederman .proc_handler = proc_dointvec, 609944ac425SSteven Rostedt }, 610de7edd31SSteven Rostedt (Red Hat) { 611de7edd31SSteven Rostedt (Red Hat) .procname = "traceoff_on_warning", 612de7edd31SSteven Rostedt (Red Hat) .data = &__disable_trace_on_warning, 613de7edd31SSteven Rostedt (Red Hat) .maxlen = sizeof(__disable_trace_on_warning), 614de7edd31SSteven Rostedt (Red Hat) .mode = 0644, 615de7edd31SSteven Rostedt (Red Hat) .proc_handler = proc_dointvec, 616de7edd31SSteven Rostedt (Red Hat) }, 6170daa2302SSteven Rostedt (Red Hat) { 6180daa2302SSteven Rostedt (Red Hat) .procname = "tracepoint_printk", 6190daa2302SSteven Rostedt (Red Hat) .data = &tracepoint_printk, 6200daa2302SSteven Rostedt (Red Hat) .maxlen = sizeof(tracepoint_printk), 6210daa2302SSteven Rostedt (Red Hat) .mode = 0644, 6220daa2302SSteven Rostedt (Red Hat) .proc_handler = proc_dointvec, 6230daa2302SSteven Rostedt (Red Hat) }, 624944ac425SSteven Rostedt #endif 6252965faa5SDave Young #ifdef CONFIG_KEXEC_CORE 6267984754bSKees Cook { 6277984754bSKees Cook .procname = "kexec_load_disabled", 6287984754bSKees Cook .data = &kexec_load_disabled, 6297984754bSKees Cook .maxlen = sizeof(int), 6307984754bSKees Cook .mode = 0644, 6317984754bSKees Cook /* only handle a transition from default "0" to "1" */ 6327984754bSKees Cook .proc_handler = proc_dointvec_minmax, 6337984754bSKees Cook .extra1 = &one, 6347984754bSKees Cook .extra2 = &one, 6357984754bSKees Cook }, 6367984754bSKees Cook #endif 637a1ef5adbSJohannes Berg #ifdef CONFIG_MODULES 6381da177e4SLinus Torvalds { 6391da177e4SLinus Torvalds .procname = "modprobe", 6401da177e4SLinus Torvalds .data = &modprobe_path, 6411da177e4SLinus Torvalds .maxlen = KMOD_PATH_LEN, 6421da177e4SLinus Torvalds .mode = 0644, 6436d456111SEric W. Biederman .proc_handler = proc_dostring, 6441da177e4SLinus Torvalds }, 6453d43321bSKees Cook { 6463d43321bSKees Cook .procname = "modules_disabled", 6473d43321bSKees Cook .data = &modules_disabled, 6483d43321bSKees Cook .maxlen = sizeof(int), 6493d43321bSKees Cook .mode = 0644, 6503d43321bSKees Cook /* only handle a transition from default "0" to "1" */ 6516d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 6523d43321bSKees Cook .extra1 = &one, 6533d43321bSKees Cook .extra2 = &one, 6543d43321bSKees Cook }, 6551da177e4SLinus Torvalds #endif 65686d56134SMichael Marineau #ifdef CONFIG_UEVENT_HELPER 6571da177e4SLinus Torvalds { 6581da177e4SLinus Torvalds .procname = "hotplug", 659312c004dSKay Sievers .data = &uevent_helper, 660312c004dSKay Sievers .maxlen = UEVENT_HELPER_PATH_LEN, 6611da177e4SLinus Torvalds .mode = 0644, 6626d456111SEric W. Biederman .proc_handler = proc_dostring, 6631da177e4SLinus Torvalds }, 66486d56134SMichael Marineau #endif 6651da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG 6661da177e4SLinus Torvalds { 6671da177e4SLinus Torvalds .procname = "sg-big-buff", 6681da177e4SLinus Torvalds .data = &sg_big_buff, 6691da177e4SLinus Torvalds .maxlen = sizeof (int), 6701da177e4SLinus Torvalds .mode = 0444, 6716d456111SEric W. Biederman .proc_handler = proc_dointvec, 6721da177e4SLinus Torvalds }, 6731da177e4SLinus Torvalds #endif 6741da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT 6751da177e4SLinus Torvalds { 6761da177e4SLinus Torvalds .procname = "acct", 6771da177e4SLinus Torvalds .data = &acct_parm, 6781da177e4SLinus Torvalds .maxlen = 3*sizeof(int), 6791da177e4SLinus Torvalds .mode = 0644, 6806d456111SEric W. Biederman .proc_handler = proc_dointvec, 6811da177e4SLinus Torvalds }, 6821da177e4SLinus Torvalds #endif 6831da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ 6841da177e4SLinus Torvalds { 6851da177e4SLinus Torvalds .procname = "sysrq", 6865d6f647fSIngo Molnar .data = &__sysrq_enabled, 6871da177e4SLinus Torvalds .maxlen = sizeof (int), 6881da177e4SLinus Torvalds .mode = 0644, 68997f5f0cdSDmitry Torokhov .proc_handler = sysrq_sysctl_handler, 6901da177e4SLinus Torvalds }, 6911da177e4SLinus Torvalds #endif 692d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL 6931da177e4SLinus Torvalds { 6941da177e4SLinus Torvalds .procname = "cad_pid", 6959ec52099SCedric Le Goater .data = NULL, 6961da177e4SLinus Torvalds .maxlen = sizeof (int), 6971da177e4SLinus Torvalds .mode = 0600, 6986d456111SEric W. Biederman .proc_handler = proc_do_cad_pid, 6991da177e4SLinus Torvalds }, 700d6f8ff73SRandy Dunlap #endif 7011da177e4SLinus Torvalds { 7021da177e4SLinus Torvalds .procname = "threads-max", 70316db3d3fSHeinrich Schuchardt .data = NULL, 7041da177e4SLinus Torvalds .maxlen = sizeof(int), 7051da177e4SLinus Torvalds .mode = 0644, 70616db3d3fSHeinrich Schuchardt .proc_handler = sysctl_max_threads, 7071da177e4SLinus Torvalds }, 7081da177e4SLinus Torvalds { 7091da177e4SLinus Torvalds .procname = "random", 7101da177e4SLinus Torvalds .mode = 0555, 7111da177e4SLinus Torvalds .child = random_table, 7121da177e4SLinus Torvalds }, 7131da177e4SLinus Torvalds { 71417f60a7dSEric Paris .procname = "usermodehelper", 71517f60a7dSEric Paris .mode = 0555, 71617f60a7dSEric Paris .child = usermodehelper_table, 71717f60a7dSEric Paris }, 71817f60a7dSEric Paris { 7191da177e4SLinus Torvalds .procname = "overflowuid", 7201da177e4SLinus Torvalds .data = &overflowuid, 7211da177e4SLinus Torvalds .maxlen = sizeof(int), 7221da177e4SLinus Torvalds .mode = 0644, 7236d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 7241da177e4SLinus Torvalds .extra1 = &minolduid, 7251da177e4SLinus Torvalds .extra2 = &maxolduid, 7261da177e4SLinus Torvalds }, 7271da177e4SLinus Torvalds { 7281da177e4SLinus Torvalds .procname = "overflowgid", 7291da177e4SLinus Torvalds .data = &overflowgid, 7301da177e4SLinus Torvalds .maxlen = sizeof(int), 7311da177e4SLinus Torvalds .mode = 0644, 7326d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 7331da177e4SLinus Torvalds .extra1 = &minolduid, 7341da177e4SLinus Torvalds .extra2 = &maxolduid, 7351da177e4SLinus Torvalds }, 736347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390 7371da177e4SLinus Torvalds #ifdef CONFIG_MATHEMU 7381da177e4SLinus Torvalds { 7391da177e4SLinus Torvalds .procname = "ieee_emulation_warnings", 7401da177e4SLinus Torvalds .data = &sysctl_ieee_emulation_warnings, 7411da177e4SLinus Torvalds .maxlen = sizeof(int), 7421da177e4SLinus Torvalds .mode = 0644, 7436d456111SEric W. Biederman .proc_handler = proc_dointvec, 7441da177e4SLinus Torvalds }, 7451da177e4SLinus Torvalds #endif 7461da177e4SLinus Torvalds { 7471da177e4SLinus Torvalds .procname = "userprocess_debug", 748ab3c68eeSHeiko Carstens .data = &show_unhandled_signals, 7491da177e4SLinus Torvalds .maxlen = sizeof(int), 7501da177e4SLinus Torvalds .mode = 0644, 7516d456111SEric W. Biederman .proc_handler = proc_dointvec, 7521da177e4SLinus Torvalds }, 7531da177e4SLinus Torvalds #endif 7541da177e4SLinus Torvalds { 7551da177e4SLinus Torvalds .procname = "pid_max", 7561da177e4SLinus Torvalds .data = &pid_max, 7571da177e4SLinus Torvalds .maxlen = sizeof (int), 7581da177e4SLinus Torvalds .mode = 0644, 7596d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 7601da177e4SLinus Torvalds .extra1 = &pid_max_min, 7611da177e4SLinus Torvalds .extra2 = &pid_max_max, 7621da177e4SLinus Torvalds }, 7631da177e4SLinus Torvalds { 7641da177e4SLinus Torvalds .procname = "panic_on_oops", 7651da177e4SLinus Torvalds .data = &panic_on_oops, 7661da177e4SLinus Torvalds .maxlen = sizeof(int), 7671da177e4SLinus Torvalds .mode = 0644, 7686d456111SEric W. Biederman .proc_handler = proc_dointvec, 7691da177e4SLinus Torvalds }, 7707ef3d2fdSJoe Perches #if defined CONFIG_PRINTK 7717ef3d2fdSJoe Perches { 7727ef3d2fdSJoe Perches .procname = "printk", 7737ef3d2fdSJoe Perches .data = &console_loglevel, 7747ef3d2fdSJoe Perches .maxlen = 4*sizeof(int), 7757ef3d2fdSJoe Perches .mode = 0644, 7766d456111SEric W. Biederman .proc_handler = proc_dointvec, 7777ef3d2fdSJoe Perches }, 7781da177e4SLinus Torvalds { 7791da177e4SLinus Torvalds .procname = "printk_ratelimit", 780717115e1SDave Young .data = &printk_ratelimit_state.interval, 7811da177e4SLinus Torvalds .maxlen = sizeof(int), 7821da177e4SLinus Torvalds .mode = 0644, 7836d456111SEric W. Biederman .proc_handler = proc_dointvec_jiffies, 7841da177e4SLinus Torvalds }, 7851da177e4SLinus Torvalds { 7861da177e4SLinus Torvalds .procname = "printk_ratelimit_burst", 787717115e1SDave Young .data = &printk_ratelimit_state.burst, 7881da177e4SLinus Torvalds .maxlen = sizeof(int), 7891da177e4SLinus Torvalds .mode = 0644, 7906d456111SEric W. Biederman .proc_handler = proc_dointvec, 7911da177e4SLinus Torvalds }, 792af91322eSDave Young { 793af91322eSDave Young .procname = "printk_delay", 794af91322eSDave Young .data = &printk_delay_msec, 795af91322eSDave Young .maxlen = sizeof(int), 796af91322eSDave Young .mode = 0644, 7976d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 798af91322eSDave Young .extra1 = &zero, 799af91322eSDave Young .extra2 = &ten_thousand, 800af91322eSDave Young }, 8011da177e4SLinus Torvalds { 802eaf06b24SDan Rosenberg .procname = "dmesg_restrict", 803eaf06b24SDan Rosenberg .data = &dmesg_restrict, 804eaf06b24SDan Rosenberg .maxlen = sizeof(int), 805eaf06b24SDan Rosenberg .mode = 0644, 806620f6e8eSKees Cook .proc_handler = proc_dointvec_minmax_sysadmin, 807eaf06b24SDan Rosenberg .extra1 = &zero, 808eaf06b24SDan Rosenberg .extra2 = &one, 809eaf06b24SDan Rosenberg }, 810455cd5abSDan Rosenberg { 811455cd5abSDan Rosenberg .procname = "kptr_restrict", 812455cd5abSDan Rosenberg .data = &kptr_restrict, 813455cd5abSDan Rosenberg .maxlen = sizeof(int), 814455cd5abSDan Rosenberg .mode = 0644, 815620f6e8eSKees Cook .proc_handler = proc_dointvec_minmax_sysadmin, 816455cd5abSDan Rosenberg .extra1 = &zero, 817455cd5abSDan Rosenberg .extra2 = &two, 818455cd5abSDan Rosenberg }, 819df6e61d4SJoe Perches #endif 820eaf06b24SDan Rosenberg { 8211da177e4SLinus Torvalds .procname = "ngroups_max", 8221da177e4SLinus Torvalds .data = &ngroups_max, 8231da177e4SLinus Torvalds .maxlen = sizeof (int), 8241da177e4SLinus Torvalds .mode = 0444, 8256d456111SEric W. Biederman .proc_handler = proc_dointvec, 8261da177e4SLinus Torvalds }, 82773efc039SDan Ballard { 82873efc039SDan Ballard .procname = "cap_last_cap", 82973efc039SDan Ballard .data = (void *)&cap_last_cap, 83073efc039SDan Ballard .maxlen = sizeof(int), 83173efc039SDan Ballard .mode = 0444, 83273efc039SDan Ballard .proc_handler = proc_dointvec, 83373efc039SDan Ballard }, 83458687acbSDon Zickus #if defined(CONFIG_LOCKUP_DETECTOR) 835504d7cf1SDon Zickus { 83658687acbSDon Zickus .procname = "watchdog", 8373c00ea82SFrederic Weisbecker .data = &watchdog_user_enabled, 838504d7cf1SDon Zickus .maxlen = sizeof (int), 839504d7cf1SDon Zickus .mode = 0644, 840195daf66SUlrich Obergfell .proc_handler = proc_watchdog, 841586692a5SMandeep Singh Baines .extra1 = &zero, 842586692a5SMandeep Singh Baines .extra2 = &one, 84358687acbSDon Zickus }, 84458687acbSDon Zickus { 84558687acbSDon Zickus .procname = "watchdog_thresh", 846586692a5SMandeep Singh Baines .data = &watchdog_thresh, 84758687acbSDon Zickus .maxlen = sizeof(int), 84858687acbSDon Zickus .mode = 0644, 849195daf66SUlrich Obergfell .proc_handler = proc_watchdog_thresh, 850a6572f84SLi Zefan .extra1 = &zero, 85158687acbSDon Zickus .extra2 = &sixty, 852504d7cf1SDon Zickus }, 8532508ce18SDon Zickus { 854195daf66SUlrich Obergfell .procname = "nmi_watchdog", 855195daf66SUlrich Obergfell .data = &nmi_watchdog_enabled, 856195daf66SUlrich Obergfell .maxlen = sizeof (int), 857195daf66SUlrich Obergfell .mode = 0644, 858195daf66SUlrich Obergfell .proc_handler = proc_nmi_watchdog, 859195daf66SUlrich Obergfell .extra1 = &zero, 860195daf66SUlrich Obergfell #if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR) 861195daf66SUlrich Obergfell .extra2 = &one, 862195daf66SUlrich Obergfell #else 863195daf66SUlrich Obergfell .extra2 = &zero, 864195daf66SUlrich Obergfell #endif 865195daf66SUlrich Obergfell }, 866195daf66SUlrich Obergfell { 867195daf66SUlrich Obergfell .procname = "soft_watchdog", 868195daf66SUlrich Obergfell .data = &soft_watchdog_enabled, 869195daf66SUlrich Obergfell .maxlen = sizeof (int), 870195daf66SUlrich Obergfell .mode = 0644, 871195daf66SUlrich Obergfell .proc_handler = proc_soft_watchdog, 872195daf66SUlrich Obergfell .extra1 = &zero, 873195daf66SUlrich Obergfell .extra2 = &one, 874195daf66SUlrich Obergfell }, 875195daf66SUlrich Obergfell { 876fe4ba3c3SChris Metcalf .procname = "watchdog_cpumask", 877fe4ba3c3SChris Metcalf .data = &watchdog_cpumask_bits, 878fe4ba3c3SChris Metcalf .maxlen = NR_CPUS, 879fe4ba3c3SChris Metcalf .mode = 0644, 880fe4ba3c3SChris Metcalf .proc_handler = proc_watchdog_cpumask, 881fe4ba3c3SChris Metcalf }, 882fe4ba3c3SChris Metcalf { 8832508ce18SDon Zickus .procname = "softlockup_panic", 8842508ce18SDon Zickus .data = &softlockup_panic, 8852508ce18SDon Zickus .maxlen = sizeof(int), 8862508ce18SDon Zickus .mode = 0644, 8872508ce18SDon Zickus .proc_handler = proc_dointvec_minmax, 8882508ce18SDon Zickus .extra1 = &zero, 8892508ce18SDon Zickus .extra2 = &one, 8902508ce18SDon Zickus }, 891ed235875SAaron Tomlin #ifdef CONFIG_SMP 892ed235875SAaron Tomlin { 893ed235875SAaron Tomlin .procname = "softlockup_all_cpu_backtrace", 894ed235875SAaron Tomlin .data = &sysctl_softlockup_all_cpu_backtrace, 895ed235875SAaron Tomlin .maxlen = sizeof(int), 896ed235875SAaron Tomlin .mode = 0644, 897ed235875SAaron Tomlin .proc_handler = proc_dointvec_minmax, 898ed235875SAaron Tomlin .extra1 = &zero, 899ed235875SAaron Tomlin .extra2 = &one, 900ed235875SAaron Tomlin }, 901*55537871SJiri Kosina { 902*55537871SJiri Kosina .procname = "hardlockup_all_cpu_backtrace", 903*55537871SJiri Kosina .data = &sysctl_hardlockup_all_cpu_backtrace, 904*55537871SJiri Kosina .maxlen = sizeof(int), 905*55537871SJiri Kosina .mode = 0644, 906*55537871SJiri Kosina .proc_handler = proc_dointvec_minmax, 907*55537871SJiri Kosina .extra1 = &zero, 908*55537871SJiri Kosina .extra2 = &one, 909*55537871SJiri Kosina }, 910ed235875SAaron Tomlin #endif /* CONFIG_SMP */ 9115dc30558SDon Zickus #endif 9125dc30558SDon Zickus #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) 9135dc30558SDon Zickus { 9145dc30558SDon Zickus .procname = "unknown_nmi_panic", 9155dc30558SDon Zickus .data = &unknown_nmi_panic, 9165dc30558SDon Zickus .maxlen = sizeof (int), 9175dc30558SDon Zickus .mode = 0644, 9185dc30558SDon Zickus .proc_handler = proc_dointvec, 9195dc30558SDon Zickus }, 920504d7cf1SDon Zickus #endif 9211da177e4SLinus Torvalds #if defined(CONFIG_X86) 9221da177e4SLinus Torvalds { 9238da5addaSDon Zickus .procname = "panic_on_unrecovered_nmi", 9248da5addaSDon Zickus .data = &panic_on_unrecovered_nmi, 9258da5addaSDon Zickus .maxlen = sizeof(int), 9268da5addaSDon Zickus .mode = 0644, 9276d456111SEric W. Biederman .proc_handler = proc_dointvec, 9288da5addaSDon Zickus }, 9298da5addaSDon Zickus { 9305211a242SKurt Garloff .procname = "panic_on_io_nmi", 9315211a242SKurt Garloff .data = &panic_on_io_nmi, 9325211a242SKurt Garloff .maxlen = sizeof(int), 9335211a242SKurt Garloff .mode = 0644, 9346d456111SEric W. Biederman .proc_handler = proc_dointvec, 9355211a242SKurt Garloff }, 93655af7796SMitsuo Hayasaka #ifdef CONFIG_DEBUG_STACKOVERFLOW 93755af7796SMitsuo Hayasaka { 93855af7796SMitsuo Hayasaka .procname = "panic_on_stackoverflow", 93955af7796SMitsuo Hayasaka .data = &sysctl_panic_on_stackoverflow, 94055af7796SMitsuo Hayasaka .maxlen = sizeof(int), 94155af7796SMitsuo Hayasaka .mode = 0644, 94255af7796SMitsuo Hayasaka .proc_handler = proc_dointvec, 94355af7796SMitsuo Hayasaka }, 94455af7796SMitsuo Hayasaka #endif 9455211a242SKurt Garloff { 9461da177e4SLinus Torvalds .procname = "bootloader_type", 9471da177e4SLinus Torvalds .data = &bootloader_type, 9481da177e4SLinus Torvalds .maxlen = sizeof (int), 9491da177e4SLinus Torvalds .mode = 0444, 9506d456111SEric W. Biederman .proc_handler = proc_dointvec, 9511da177e4SLinus Torvalds }, 9520741f4d2SChuck Ebbert { 9535031296cSH. Peter Anvin .procname = "bootloader_version", 9545031296cSH. Peter Anvin .data = &bootloader_version, 9555031296cSH. Peter Anvin .maxlen = sizeof (int), 9565031296cSH. Peter Anvin .mode = 0444, 9576d456111SEric W. Biederman .proc_handler = proc_dointvec, 9585031296cSH. Peter Anvin }, 9595031296cSH. Peter Anvin { 9600741f4d2SChuck Ebbert .procname = "kstack_depth_to_print", 9610741f4d2SChuck Ebbert .data = &kstack_depth_to_print, 9620741f4d2SChuck Ebbert .maxlen = sizeof(int), 9630741f4d2SChuck Ebbert .mode = 0644, 9646d456111SEric W. Biederman .proc_handler = proc_dointvec, 9650741f4d2SChuck Ebbert }, 9666e7c4025SIngo Molnar { 9676e7c4025SIngo Molnar .procname = "io_delay_type", 9686e7c4025SIngo Molnar .data = &io_delay_type, 9696e7c4025SIngo Molnar .maxlen = sizeof(int), 9706e7c4025SIngo Molnar .mode = 0644, 9716d456111SEric W. Biederman .proc_handler = proc_dointvec, 9726e7c4025SIngo Molnar }, 9731da177e4SLinus Torvalds #endif 9747a9166e3SLuke Yang #if defined(CONFIG_MMU) 9751da177e4SLinus Torvalds { 9761da177e4SLinus Torvalds .procname = "randomize_va_space", 9771da177e4SLinus Torvalds .data = &randomize_va_space, 9781da177e4SLinus Torvalds .maxlen = sizeof(int), 9791da177e4SLinus Torvalds .mode = 0644, 9806d456111SEric W. Biederman .proc_handler = proc_dointvec, 9811da177e4SLinus Torvalds }, 9827a9166e3SLuke Yang #endif 9830152fb37SMartin Schwidefsky #if defined(CONFIG_S390) && defined(CONFIG_SMP) 984951f22d5SMartin Schwidefsky { 985951f22d5SMartin Schwidefsky .procname = "spin_retry", 986951f22d5SMartin Schwidefsky .data = &spin_retry, 987951f22d5SMartin Schwidefsky .maxlen = sizeof (int), 988951f22d5SMartin Schwidefsky .mode = 0644, 9896d456111SEric W. Biederman .proc_handler = proc_dointvec, 990951f22d5SMartin Schwidefsky }, 991951f22d5SMartin Schwidefsky #endif 992673d5b43SLen Brown #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86) 993c255d844SPavel Machek { 994c255d844SPavel Machek .procname = "acpi_video_flags", 99577afcf78SPavel Machek .data = &acpi_realmode_flags, 996c255d844SPavel Machek .maxlen = sizeof (unsigned long), 997c255d844SPavel Machek .mode = 0644, 9986d456111SEric W. Biederman .proc_handler = proc_doulongvec_minmax, 999c255d844SPavel Machek }, 1000c255d844SPavel Machek #endif 1001b6fca725SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN 1002d2b176edSJes Sorensen { 1003d2b176edSJes Sorensen .procname = "ignore-unaligned-usertrap", 1004d2b176edSJes Sorensen .data = &no_unaligned_warning, 1005d2b176edSJes Sorensen .maxlen = sizeof (int), 1006d2b176edSJes Sorensen .mode = 0644, 10076d456111SEric W. Biederman .proc_handler = proc_dointvec, 1008d2b176edSJes Sorensen }, 1009b6fca725SVineet Gupta #endif 1010b6fca725SVineet Gupta #ifdef CONFIG_IA64 101188fc241fSDoug Chapman { 101288fc241fSDoug Chapman .procname = "unaligned-dump-stack", 101388fc241fSDoug Chapman .data = &unaligned_dump_stack, 101488fc241fSDoug Chapman .maxlen = sizeof (int), 101588fc241fSDoug Chapman .mode = 0644, 10166d456111SEric W. Biederman .proc_handler = proc_dointvec, 101788fc241fSDoug Chapman }, 1018d2b176edSJes Sorensen #endif 1019e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK 1020e162b39aSMandeep Singh Baines { 1021e162b39aSMandeep Singh Baines .procname = "hung_task_panic", 1022e162b39aSMandeep Singh Baines .data = &sysctl_hung_task_panic, 1023e162b39aSMandeep Singh Baines .maxlen = sizeof(int), 1024e162b39aSMandeep Singh Baines .mode = 0644, 10256d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 1026e162b39aSMandeep Singh Baines .extra1 = &zero, 1027e162b39aSMandeep Singh Baines .extra2 = &one, 1028e162b39aSMandeep Singh Baines }, 102982a1fcb9SIngo Molnar { 103082a1fcb9SIngo Molnar .procname = "hung_task_check_count", 103182a1fcb9SIngo Molnar .data = &sysctl_hung_task_check_count, 1032cd64647fSLi Zefan .maxlen = sizeof(int), 103382a1fcb9SIngo Molnar .mode = 0644, 1034cd64647fSLi Zefan .proc_handler = proc_dointvec_minmax, 1035cd64647fSLi Zefan .extra1 = &zero, 103682a1fcb9SIngo Molnar }, 103782a1fcb9SIngo Molnar { 103882a1fcb9SIngo Molnar .procname = "hung_task_timeout_secs", 103982a1fcb9SIngo Molnar .data = &sysctl_hung_task_timeout_secs, 104090739081SIngo Molnar .maxlen = sizeof(unsigned long), 104182a1fcb9SIngo Molnar .mode = 0644, 10426d456111SEric W. Biederman .proc_handler = proc_dohung_task_timeout_secs, 104380df2847SLiu Hua .extra2 = &hung_task_timeout_max, 104482a1fcb9SIngo Molnar }, 104582a1fcb9SIngo Molnar { 104682a1fcb9SIngo Molnar .procname = "hung_task_warnings", 104782a1fcb9SIngo Molnar .data = &sysctl_hung_task_warnings, 1048270750dbSAaron Tomlin .maxlen = sizeof(int), 104982a1fcb9SIngo Molnar .mode = 0644, 1050270750dbSAaron Tomlin .proc_handler = proc_dointvec_minmax, 1051270750dbSAaron Tomlin .extra1 = &neg_one, 105282a1fcb9SIngo Molnar }, 1053c4f3b63fSRavikiran G Thirumalai #endif 1054bebfa101SAndi Kleen #ifdef CONFIG_COMPAT 1055bebfa101SAndi Kleen { 1056bebfa101SAndi Kleen .procname = "compat-log", 1057bebfa101SAndi Kleen .data = &compat_log, 1058bebfa101SAndi Kleen .maxlen = sizeof (int), 1059bebfa101SAndi Kleen .mode = 0644, 10606d456111SEric W. Biederman .proc_handler = proc_dointvec, 1061bebfa101SAndi Kleen }, 1062bebfa101SAndi Kleen #endif 106323f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES 106423f78d4aSIngo Molnar { 106523f78d4aSIngo Molnar .procname = "max_lock_depth", 106623f78d4aSIngo Molnar .data = &max_lock_depth, 106723f78d4aSIngo Molnar .maxlen = sizeof(int), 106823f78d4aSIngo Molnar .mode = 0644, 10696d456111SEric W. Biederman .proc_handler = proc_dointvec, 107023f78d4aSIngo Molnar }, 107123f78d4aSIngo Molnar #endif 107210a0a8d4SJeremy Fitzhardinge { 107310a0a8d4SJeremy Fitzhardinge .procname = "poweroff_cmd", 107410a0a8d4SJeremy Fitzhardinge .data = &poweroff_cmd, 107510a0a8d4SJeremy Fitzhardinge .maxlen = POWEROFF_CMD_PATH_LEN, 107610a0a8d4SJeremy Fitzhardinge .mode = 0644, 10776d456111SEric W. Biederman .proc_handler = proc_dostring, 107810a0a8d4SJeremy Fitzhardinge }, 10790b77f5bfSDavid Howells #ifdef CONFIG_KEYS 10800b77f5bfSDavid Howells { 10810b77f5bfSDavid Howells .procname = "keys", 10820b77f5bfSDavid Howells .mode = 0555, 10830b77f5bfSDavid Howells .child = key_sysctls, 10840b77f5bfSDavid Howells }, 10850b77f5bfSDavid Howells #endif 1086cdd6c482SIngo Molnar #ifdef CONFIG_PERF_EVENTS 1087aa4a2218SVince Weaver /* 1088aa4a2218SVince Weaver * User-space scripts rely on the existence of this file 1089aa4a2218SVince Weaver * as a feature check for perf_events being enabled. 1090aa4a2218SVince Weaver * 1091aa4a2218SVince Weaver * So it's an ABI, do not remove! 1092aa4a2218SVince Weaver */ 10931ccd1549SPeter Zijlstra { 1094cdd6c482SIngo Molnar .procname = "perf_event_paranoid", 1095cdd6c482SIngo Molnar .data = &sysctl_perf_event_paranoid, 1096cdd6c482SIngo Molnar .maxlen = sizeof(sysctl_perf_event_paranoid), 10971ccd1549SPeter Zijlstra .mode = 0644, 10986d456111SEric W. Biederman .proc_handler = proc_dointvec, 10991ccd1549SPeter Zijlstra }, 1100c5078f78SPeter Zijlstra { 1101cdd6c482SIngo Molnar .procname = "perf_event_mlock_kb", 1102cdd6c482SIngo Molnar .data = &sysctl_perf_event_mlock, 1103cdd6c482SIngo Molnar .maxlen = sizeof(sysctl_perf_event_mlock), 1104c5078f78SPeter Zijlstra .mode = 0644, 11056d456111SEric W. Biederman .proc_handler = proc_dointvec, 1106c5078f78SPeter Zijlstra }, 1107a78ac325SPeter Zijlstra { 1108cdd6c482SIngo Molnar .procname = "perf_event_max_sample_rate", 1109cdd6c482SIngo Molnar .data = &sysctl_perf_event_sample_rate, 1110cdd6c482SIngo Molnar .maxlen = sizeof(sysctl_perf_event_sample_rate), 1111a78ac325SPeter Zijlstra .mode = 0644, 1112163ec435SPeter Zijlstra .proc_handler = perf_proc_update_handler, 1113723478c8SKnut Petersen .extra1 = &one, 1114a78ac325SPeter Zijlstra }, 111514c63f17SDave Hansen { 111614c63f17SDave Hansen .procname = "perf_cpu_time_max_percent", 111714c63f17SDave Hansen .data = &sysctl_perf_cpu_time_max_percent, 111814c63f17SDave Hansen .maxlen = sizeof(sysctl_perf_cpu_time_max_percent), 111914c63f17SDave Hansen .mode = 0644, 112014c63f17SDave Hansen .proc_handler = perf_cpu_time_max_percent_handler, 112114c63f17SDave Hansen .extra1 = &zero, 112214c63f17SDave Hansen .extra2 = &one_hundred, 112314c63f17SDave Hansen }, 11241ccd1549SPeter Zijlstra #endif 1125dfec072eSVegard Nossum #ifdef CONFIG_KMEMCHECK 1126dfec072eSVegard Nossum { 1127dfec072eSVegard Nossum .procname = "kmemcheck", 1128dfec072eSVegard Nossum .data = &kmemcheck_enabled, 1129dfec072eSVegard Nossum .maxlen = sizeof(int), 1130dfec072eSVegard Nossum .mode = 0644, 11316d456111SEric W. Biederman .proc_handler = proc_dointvec, 1132dfec072eSVegard Nossum }, 1133dfec072eSVegard Nossum #endif 11349e3961a0SPrarit Bhargava { 11359e3961a0SPrarit Bhargava .procname = "panic_on_warn", 11369e3961a0SPrarit Bhargava .data = &panic_on_warn, 11379e3961a0SPrarit Bhargava .maxlen = sizeof(int), 11389e3961a0SPrarit Bhargava .mode = 0644, 11399e3961a0SPrarit Bhargava .proc_handler = proc_dointvec_minmax, 11409e3961a0SPrarit Bhargava .extra1 = &zero, 11419e3961a0SPrarit Bhargava .extra2 = &one, 11429e3961a0SPrarit Bhargava }, 1143bc7a34b8SThomas Gleixner #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 1144bc7a34b8SThomas Gleixner { 1145bc7a34b8SThomas Gleixner .procname = "timer_migration", 1146bc7a34b8SThomas Gleixner .data = &sysctl_timer_migration, 1147bc7a34b8SThomas Gleixner .maxlen = sizeof(unsigned int), 1148bc7a34b8SThomas Gleixner .mode = 0644, 1149bc7a34b8SThomas Gleixner .proc_handler = timer_migration_handler, 1150bc7a34b8SThomas Gleixner }, 1151bc7a34b8SThomas Gleixner #endif 11521be7f75dSAlexei Starovoitov #ifdef CONFIG_BPF_SYSCALL 11531be7f75dSAlexei Starovoitov { 11541be7f75dSAlexei Starovoitov .procname = "unprivileged_bpf_disabled", 11551be7f75dSAlexei Starovoitov .data = &sysctl_unprivileged_bpf_disabled, 11561be7f75dSAlexei Starovoitov .maxlen = sizeof(sysctl_unprivileged_bpf_disabled), 11571be7f75dSAlexei Starovoitov .mode = 0644, 11581be7f75dSAlexei Starovoitov /* only handle a transition from default "0" to "1" */ 11591be7f75dSAlexei Starovoitov .proc_handler = proc_dointvec_minmax, 11601be7f75dSAlexei Starovoitov .extra1 = &one, 11611be7f75dSAlexei Starovoitov .extra2 = &one, 11621be7f75dSAlexei Starovoitov }, 11631be7f75dSAlexei Starovoitov #endif 11646fce56ecSEric W. Biederman { } 11651da177e4SLinus Torvalds }; 11661da177e4SLinus Torvalds 1167d8217f07SEric W. Biederman static struct ctl_table vm_table[] = { 11681da177e4SLinus Torvalds { 11691da177e4SLinus Torvalds .procname = "overcommit_memory", 11701da177e4SLinus Torvalds .data = &sysctl_overcommit_memory, 11711da177e4SLinus Torvalds .maxlen = sizeof(sysctl_overcommit_memory), 11721da177e4SLinus Torvalds .mode = 0644, 1173cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 1174cb16e95fSPetr Holasek .extra1 = &zero, 1175cb16e95fSPetr Holasek .extra2 = &two, 11761da177e4SLinus Torvalds }, 11771da177e4SLinus Torvalds { 1178fadd8fbdSKAMEZAWA Hiroyuki .procname = "panic_on_oom", 1179fadd8fbdSKAMEZAWA Hiroyuki .data = &sysctl_panic_on_oom, 1180fadd8fbdSKAMEZAWA Hiroyuki .maxlen = sizeof(sysctl_panic_on_oom), 1181fadd8fbdSKAMEZAWA Hiroyuki .mode = 0644, 1182cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 1183cb16e95fSPetr Holasek .extra1 = &zero, 1184cb16e95fSPetr Holasek .extra2 = &two, 1185fadd8fbdSKAMEZAWA Hiroyuki }, 1186fadd8fbdSKAMEZAWA Hiroyuki { 1187fe071d7eSDavid Rientjes .procname = "oom_kill_allocating_task", 1188fe071d7eSDavid Rientjes .data = &sysctl_oom_kill_allocating_task, 1189fe071d7eSDavid Rientjes .maxlen = sizeof(sysctl_oom_kill_allocating_task), 1190fe071d7eSDavid Rientjes .mode = 0644, 11916d456111SEric W. Biederman .proc_handler = proc_dointvec, 1192fe071d7eSDavid Rientjes }, 1193fe071d7eSDavid Rientjes { 1194fef1bdd6SDavid Rientjes .procname = "oom_dump_tasks", 1195fef1bdd6SDavid Rientjes .data = &sysctl_oom_dump_tasks, 1196fef1bdd6SDavid Rientjes .maxlen = sizeof(sysctl_oom_dump_tasks), 1197fef1bdd6SDavid Rientjes .mode = 0644, 11986d456111SEric W. Biederman .proc_handler = proc_dointvec, 1199fef1bdd6SDavid Rientjes }, 1200fef1bdd6SDavid Rientjes { 12011da177e4SLinus Torvalds .procname = "overcommit_ratio", 12021da177e4SLinus Torvalds .data = &sysctl_overcommit_ratio, 12031da177e4SLinus Torvalds .maxlen = sizeof(sysctl_overcommit_ratio), 12041da177e4SLinus Torvalds .mode = 0644, 120549f0ce5fSJerome Marchand .proc_handler = overcommit_ratio_handler, 120649f0ce5fSJerome Marchand }, 120749f0ce5fSJerome Marchand { 120849f0ce5fSJerome Marchand .procname = "overcommit_kbytes", 120949f0ce5fSJerome Marchand .data = &sysctl_overcommit_kbytes, 121049f0ce5fSJerome Marchand .maxlen = sizeof(sysctl_overcommit_kbytes), 121149f0ce5fSJerome Marchand .mode = 0644, 121249f0ce5fSJerome Marchand .proc_handler = overcommit_kbytes_handler, 12131da177e4SLinus Torvalds }, 12141da177e4SLinus Torvalds { 12151da177e4SLinus Torvalds .procname = "page-cluster", 12161da177e4SLinus Torvalds .data = &page_cluster, 12171da177e4SLinus Torvalds .maxlen = sizeof(int), 12181da177e4SLinus Torvalds .mode = 0644, 1219cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 1220cb16e95fSPetr Holasek .extra1 = &zero, 12211da177e4SLinus Torvalds }, 12221da177e4SLinus Torvalds { 12231da177e4SLinus Torvalds .procname = "dirty_background_ratio", 12241da177e4SLinus Torvalds .data = &dirty_background_ratio, 12251da177e4SLinus Torvalds .maxlen = sizeof(dirty_background_ratio), 12261da177e4SLinus Torvalds .mode = 0644, 12276d456111SEric W. Biederman .proc_handler = dirty_background_ratio_handler, 12281da177e4SLinus Torvalds .extra1 = &zero, 12291da177e4SLinus Torvalds .extra2 = &one_hundred, 12301da177e4SLinus Torvalds }, 12311da177e4SLinus Torvalds { 12322da02997SDavid Rientjes .procname = "dirty_background_bytes", 12332da02997SDavid Rientjes .data = &dirty_background_bytes, 12342da02997SDavid Rientjes .maxlen = sizeof(dirty_background_bytes), 12352da02997SDavid Rientjes .mode = 0644, 12366d456111SEric W. Biederman .proc_handler = dirty_background_bytes_handler, 1237fc3501d4SSven Wegener .extra1 = &one_ul, 12382da02997SDavid Rientjes }, 12392da02997SDavid Rientjes { 12401da177e4SLinus Torvalds .procname = "dirty_ratio", 12411da177e4SLinus Torvalds .data = &vm_dirty_ratio, 12421da177e4SLinus Torvalds .maxlen = sizeof(vm_dirty_ratio), 12431da177e4SLinus Torvalds .mode = 0644, 12446d456111SEric W. Biederman .proc_handler = dirty_ratio_handler, 12451da177e4SLinus Torvalds .extra1 = &zero, 12461da177e4SLinus Torvalds .extra2 = &one_hundred, 12471da177e4SLinus Torvalds }, 12481da177e4SLinus Torvalds { 12492da02997SDavid Rientjes .procname = "dirty_bytes", 12502da02997SDavid Rientjes .data = &vm_dirty_bytes, 12512da02997SDavid Rientjes .maxlen = sizeof(vm_dirty_bytes), 12522da02997SDavid Rientjes .mode = 0644, 12536d456111SEric W. Biederman .proc_handler = dirty_bytes_handler, 12549e4a5bdaSAndrea Righi .extra1 = &dirty_bytes_min, 12552da02997SDavid Rientjes }, 12562da02997SDavid Rientjes { 12571da177e4SLinus Torvalds .procname = "dirty_writeback_centisecs", 1258f6ef9438SBart Samwel .data = &dirty_writeback_interval, 1259f6ef9438SBart Samwel .maxlen = sizeof(dirty_writeback_interval), 12601da177e4SLinus Torvalds .mode = 0644, 12616d456111SEric W. Biederman .proc_handler = dirty_writeback_centisecs_handler, 12621da177e4SLinus Torvalds }, 12631da177e4SLinus Torvalds { 12641da177e4SLinus Torvalds .procname = "dirty_expire_centisecs", 1265f6ef9438SBart Samwel .data = &dirty_expire_interval, 1266f6ef9438SBart Samwel .maxlen = sizeof(dirty_expire_interval), 12671da177e4SLinus Torvalds .mode = 0644, 1268cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 1269cb16e95fSPetr Holasek .extra1 = &zero, 12701da177e4SLinus Torvalds }, 12711da177e4SLinus Torvalds { 12721efff914STheodore Ts'o .procname = "dirtytime_expire_seconds", 12731efff914STheodore Ts'o .data = &dirtytime_expire_interval, 12741efff914STheodore Ts'o .maxlen = sizeof(dirty_expire_interval), 12751efff914STheodore Ts'o .mode = 0644, 12761efff914STheodore Ts'o .proc_handler = dirtytime_interval_handler, 12771efff914STheodore Ts'o .extra1 = &zero, 12781efff914STheodore Ts'o }, 12791efff914STheodore Ts'o { 12801da177e4SLinus Torvalds .procname = "nr_pdflush_threads", 12811da177e4SLinus Torvalds .mode = 0444 /* read-only */, 12823965c9aeSWanpeng Li .proc_handler = pdflush_proc_obsolete, 12831da177e4SLinus Torvalds }, 12841da177e4SLinus Torvalds { 12851da177e4SLinus Torvalds .procname = "swappiness", 12861da177e4SLinus Torvalds .data = &vm_swappiness, 12871da177e4SLinus Torvalds .maxlen = sizeof(vm_swappiness), 12881da177e4SLinus Torvalds .mode = 0644, 12896d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 12901da177e4SLinus Torvalds .extra1 = &zero, 12911da177e4SLinus Torvalds .extra2 = &one_hundred, 12921da177e4SLinus Torvalds }, 12931da177e4SLinus Torvalds #ifdef CONFIG_HUGETLB_PAGE 12941da177e4SLinus Torvalds { 12951da177e4SLinus Torvalds .procname = "nr_hugepages", 1296e5ff2159SAndi Kleen .data = NULL, 12971da177e4SLinus Torvalds .maxlen = sizeof(unsigned long), 12981da177e4SLinus Torvalds .mode = 0644, 12996d456111SEric W. Biederman .proc_handler = hugetlb_sysctl_handler, 13001da177e4SLinus Torvalds }, 130106808b08SLee Schermerhorn #ifdef CONFIG_NUMA 130206808b08SLee Schermerhorn { 130306808b08SLee Schermerhorn .procname = "nr_hugepages_mempolicy", 130406808b08SLee Schermerhorn .data = NULL, 130506808b08SLee Schermerhorn .maxlen = sizeof(unsigned long), 130606808b08SLee Schermerhorn .mode = 0644, 130706808b08SLee Schermerhorn .proc_handler = &hugetlb_mempolicy_sysctl_handler, 130806808b08SLee Schermerhorn }, 130906808b08SLee Schermerhorn #endif 13101da177e4SLinus Torvalds { 13111da177e4SLinus Torvalds .procname = "hugetlb_shm_group", 13121da177e4SLinus Torvalds .data = &sysctl_hugetlb_shm_group, 13131da177e4SLinus Torvalds .maxlen = sizeof(gid_t), 13141da177e4SLinus Torvalds .mode = 0644, 13156d456111SEric W. Biederman .proc_handler = proc_dointvec, 13161da177e4SLinus Torvalds }, 1317396faf03SMel Gorman { 1318396faf03SMel Gorman .procname = "hugepages_treat_as_movable", 1319396faf03SMel Gorman .data = &hugepages_treat_as_movable, 1320396faf03SMel Gorman .maxlen = sizeof(int), 1321396faf03SMel Gorman .mode = 0644, 132286cdb465SNaoya Horiguchi .proc_handler = proc_dointvec, 1323396faf03SMel Gorman }, 132454f9f80dSAdam Litke { 1325d1c3fb1fSNishanth Aravamudan .procname = "nr_overcommit_hugepages", 1326e5ff2159SAndi Kleen .data = NULL, 1327e5ff2159SAndi Kleen .maxlen = sizeof(unsigned long), 1328d1c3fb1fSNishanth Aravamudan .mode = 0644, 13296d456111SEric W. Biederman .proc_handler = hugetlb_overcommit_handler, 1330d1c3fb1fSNishanth Aravamudan }, 13311da177e4SLinus Torvalds #endif 13321da177e4SLinus Torvalds { 13331da177e4SLinus Torvalds .procname = "lowmem_reserve_ratio", 13341da177e4SLinus Torvalds .data = &sysctl_lowmem_reserve_ratio, 13351da177e4SLinus Torvalds .maxlen = sizeof(sysctl_lowmem_reserve_ratio), 13361da177e4SLinus Torvalds .mode = 0644, 13376d456111SEric W. Biederman .proc_handler = lowmem_reserve_ratio_sysctl_handler, 13381da177e4SLinus Torvalds }, 13391da177e4SLinus Torvalds { 13409d0243bcSAndrew Morton .procname = "drop_caches", 13419d0243bcSAndrew Morton .data = &sysctl_drop_caches, 13429d0243bcSAndrew Morton .maxlen = sizeof(int), 13439d0243bcSAndrew Morton .mode = 0644, 13449d0243bcSAndrew Morton .proc_handler = drop_caches_sysctl_handler, 1345cb16e95fSPetr Holasek .extra1 = &one, 13465509a5d2SDave Hansen .extra2 = &four, 13479d0243bcSAndrew Morton }, 134876ab0f53SMel Gorman #ifdef CONFIG_COMPACTION 134976ab0f53SMel Gorman { 135076ab0f53SMel Gorman .procname = "compact_memory", 135176ab0f53SMel Gorman .data = &sysctl_compact_memory, 135276ab0f53SMel Gorman .maxlen = sizeof(int), 135376ab0f53SMel Gorman .mode = 0200, 135476ab0f53SMel Gorman .proc_handler = sysctl_compaction_handler, 135576ab0f53SMel Gorman }, 13565e771905SMel Gorman { 13575e771905SMel Gorman .procname = "extfrag_threshold", 13585e771905SMel Gorman .data = &sysctl_extfrag_threshold, 13595e771905SMel Gorman .maxlen = sizeof(int), 13605e771905SMel Gorman .mode = 0644, 13615e771905SMel Gorman .proc_handler = sysctl_extfrag_handler, 13625e771905SMel Gorman .extra1 = &min_extfrag_threshold, 13635e771905SMel Gorman .extra2 = &max_extfrag_threshold, 13645e771905SMel Gorman }, 13655bbe3547SEric B Munson { 13665bbe3547SEric B Munson .procname = "compact_unevictable_allowed", 13675bbe3547SEric B Munson .data = &sysctl_compact_unevictable_allowed, 13685bbe3547SEric B Munson .maxlen = sizeof(int), 13695bbe3547SEric B Munson .mode = 0644, 13705bbe3547SEric B Munson .proc_handler = proc_dointvec, 13715bbe3547SEric B Munson .extra1 = &zero, 13725bbe3547SEric B Munson .extra2 = &one, 13735bbe3547SEric B Munson }, 13745e771905SMel Gorman 137576ab0f53SMel Gorman #endif /* CONFIG_COMPACTION */ 13769d0243bcSAndrew Morton { 13771da177e4SLinus Torvalds .procname = "min_free_kbytes", 13781da177e4SLinus Torvalds .data = &min_free_kbytes, 13791da177e4SLinus Torvalds .maxlen = sizeof(min_free_kbytes), 13801da177e4SLinus Torvalds .mode = 0644, 13816d456111SEric W. Biederman .proc_handler = min_free_kbytes_sysctl_handler, 13821da177e4SLinus Torvalds .extra1 = &zero, 13831da177e4SLinus Torvalds }, 13848ad4b1fbSRohit Seth { 13858ad4b1fbSRohit Seth .procname = "percpu_pagelist_fraction", 13868ad4b1fbSRohit Seth .data = &percpu_pagelist_fraction, 13878ad4b1fbSRohit Seth .maxlen = sizeof(percpu_pagelist_fraction), 13888ad4b1fbSRohit Seth .mode = 0644, 13896d456111SEric W. Biederman .proc_handler = percpu_pagelist_fraction_sysctl_handler, 13907cd2b0a3SDavid Rientjes .extra1 = &zero, 13918ad4b1fbSRohit Seth }, 13921da177e4SLinus Torvalds #ifdef CONFIG_MMU 13931da177e4SLinus Torvalds { 13941da177e4SLinus Torvalds .procname = "max_map_count", 13951da177e4SLinus Torvalds .data = &sysctl_max_map_count, 13961da177e4SLinus Torvalds .maxlen = sizeof(sysctl_max_map_count), 13971da177e4SLinus Torvalds .mode = 0644, 13983e26120cSWANG Cong .proc_handler = proc_dointvec_minmax, 139970da2340SAmerigo Wang .extra1 = &zero, 14001da177e4SLinus Torvalds }, 1401dd8632a1SPaul Mundt #else 1402dd8632a1SPaul Mundt { 1403dd8632a1SPaul Mundt .procname = "nr_trim_pages", 1404dd8632a1SPaul Mundt .data = &sysctl_nr_trim_pages, 1405dd8632a1SPaul Mundt .maxlen = sizeof(sysctl_nr_trim_pages), 1406dd8632a1SPaul Mundt .mode = 0644, 14076d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 1408dd8632a1SPaul Mundt .extra1 = &zero, 1409dd8632a1SPaul Mundt }, 14101da177e4SLinus Torvalds #endif 14111da177e4SLinus Torvalds { 14121da177e4SLinus Torvalds .procname = "laptop_mode", 14131da177e4SLinus Torvalds .data = &laptop_mode, 14141da177e4SLinus Torvalds .maxlen = sizeof(laptop_mode), 14151da177e4SLinus Torvalds .mode = 0644, 14166d456111SEric W. Biederman .proc_handler = proc_dointvec_jiffies, 14171da177e4SLinus Torvalds }, 14181da177e4SLinus Torvalds { 14191da177e4SLinus Torvalds .procname = "block_dump", 14201da177e4SLinus Torvalds .data = &block_dump, 14211da177e4SLinus Torvalds .maxlen = sizeof(block_dump), 14221da177e4SLinus Torvalds .mode = 0644, 14236d456111SEric W. Biederman .proc_handler = proc_dointvec, 14241da177e4SLinus Torvalds .extra1 = &zero, 14251da177e4SLinus Torvalds }, 14261da177e4SLinus Torvalds { 14271da177e4SLinus Torvalds .procname = "vfs_cache_pressure", 14281da177e4SLinus Torvalds .data = &sysctl_vfs_cache_pressure, 14291da177e4SLinus Torvalds .maxlen = sizeof(sysctl_vfs_cache_pressure), 14301da177e4SLinus Torvalds .mode = 0644, 14316d456111SEric W. Biederman .proc_handler = proc_dointvec, 14321da177e4SLinus Torvalds .extra1 = &zero, 14331da177e4SLinus Torvalds }, 14341da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT 14351da177e4SLinus Torvalds { 14361da177e4SLinus Torvalds .procname = "legacy_va_layout", 14371da177e4SLinus Torvalds .data = &sysctl_legacy_va_layout, 14381da177e4SLinus Torvalds .maxlen = sizeof(sysctl_legacy_va_layout), 14391da177e4SLinus Torvalds .mode = 0644, 14406d456111SEric W. Biederman .proc_handler = proc_dointvec, 14411da177e4SLinus Torvalds .extra1 = &zero, 14421da177e4SLinus Torvalds }, 14431da177e4SLinus Torvalds #endif 14441743660bSChristoph Lameter #ifdef CONFIG_NUMA 14451743660bSChristoph Lameter { 14461743660bSChristoph Lameter .procname = "zone_reclaim_mode", 14471743660bSChristoph Lameter .data = &zone_reclaim_mode, 14481743660bSChristoph Lameter .maxlen = sizeof(zone_reclaim_mode), 14491743660bSChristoph Lameter .mode = 0644, 14506d456111SEric W. Biederman .proc_handler = proc_dointvec, 1451c84db23cSChristoph Lameter .extra1 = &zero, 14521743660bSChristoph Lameter }, 14539614634fSChristoph Lameter { 14549614634fSChristoph Lameter .procname = "min_unmapped_ratio", 14559614634fSChristoph Lameter .data = &sysctl_min_unmapped_ratio, 14569614634fSChristoph Lameter .maxlen = sizeof(sysctl_min_unmapped_ratio), 14579614634fSChristoph Lameter .mode = 0644, 14586d456111SEric W. Biederman .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler, 14599614634fSChristoph Lameter .extra1 = &zero, 14609614634fSChristoph Lameter .extra2 = &one_hundred, 14619614634fSChristoph Lameter }, 14620ff38490SChristoph Lameter { 14630ff38490SChristoph Lameter .procname = "min_slab_ratio", 14640ff38490SChristoph Lameter .data = &sysctl_min_slab_ratio, 14650ff38490SChristoph Lameter .maxlen = sizeof(sysctl_min_slab_ratio), 14660ff38490SChristoph Lameter .mode = 0644, 14676d456111SEric W. Biederman .proc_handler = sysctl_min_slab_ratio_sysctl_handler, 14680ff38490SChristoph Lameter .extra1 = &zero, 14690ff38490SChristoph Lameter .extra2 = &one_hundred, 14700ff38490SChristoph Lameter }, 14711743660bSChristoph Lameter #endif 147277461ab3SChristoph Lameter #ifdef CONFIG_SMP 147377461ab3SChristoph Lameter { 147477461ab3SChristoph Lameter .procname = "stat_interval", 147577461ab3SChristoph Lameter .data = &sysctl_stat_interval, 147677461ab3SChristoph Lameter .maxlen = sizeof(sysctl_stat_interval), 147777461ab3SChristoph Lameter .mode = 0644, 14786d456111SEric W. Biederman .proc_handler = proc_dointvec_jiffies, 147977461ab3SChristoph Lameter }, 148077461ab3SChristoph Lameter #endif 14816e141546SDavid Howells #ifdef CONFIG_MMU 1482ed032189SEric Paris { 1483ed032189SEric Paris .procname = "mmap_min_addr", 1484788084abSEric Paris .data = &dac_mmap_min_addr, 1485ed032189SEric Paris .maxlen = sizeof(unsigned long), 1486ed032189SEric Paris .mode = 0644, 14876d456111SEric W. Biederman .proc_handler = mmap_min_addr_handler, 1488ed032189SEric Paris }, 14896e141546SDavid Howells #endif 1490f0c0b2b8SKAMEZAWA Hiroyuki #ifdef CONFIG_NUMA 1491f0c0b2b8SKAMEZAWA Hiroyuki { 1492f0c0b2b8SKAMEZAWA Hiroyuki .procname = "numa_zonelist_order", 1493f0c0b2b8SKAMEZAWA Hiroyuki .data = &numa_zonelist_order, 1494f0c0b2b8SKAMEZAWA Hiroyuki .maxlen = NUMA_ZONELIST_ORDER_LEN, 1495f0c0b2b8SKAMEZAWA Hiroyuki .mode = 0644, 14966d456111SEric W. Biederman .proc_handler = numa_zonelist_order_handler, 1497f0c0b2b8SKAMEZAWA Hiroyuki }, 1498f0c0b2b8SKAMEZAWA Hiroyuki #endif 14992b8232ceSAl Viro #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \ 15005c36e657SPaul Mundt (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL)) 1501e6e5494cSIngo Molnar { 1502e6e5494cSIngo Molnar .procname = "vdso_enabled", 15033d7ee969SAndy Lutomirski #ifdef CONFIG_X86_32 15043d7ee969SAndy Lutomirski .data = &vdso32_enabled, 15053d7ee969SAndy Lutomirski .maxlen = sizeof(vdso32_enabled), 15063d7ee969SAndy Lutomirski #else 1507e6e5494cSIngo Molnar .data = &vdso_enabled, 1508e6e5494cSIngo Molnar .maxlen = sizeof(vdso_enabled), 15093d7ee969SAndy Lutomirski #endif 1510e6e5494cSIngo Molnar .mode = 0644, 15116d456111SEric W. Biederman .proc_handler = proc_dointvec, 1512e6e5494cSIngo Molnar .extra1 = &zero, 1513e6e5494cSIngo Molnar }, 1514e6e5494cSIngo Molnar #endif 1515195cf453SBron Gondwana #ifdef CONFIG_HIGHMEM 1516195cf453SBron Gondwana { 1517195cf453SBron Gondwana .procname = "highmem_is_dirtyable", 1518195cf453SBron Gondwana .data = &vm_highmem_is_dirtyable, 1519195cf453SBron Gondwana .maxlen = sizeof(vm_highmem_is_dirtyable), 1520195cf453SBron Gondwana .mode = 0644, 15216d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 1522195cf453SBron Gondwana .extra1 = &zero, 1523195cf453SBron Gondwana .extra2 = &one, 1524195cf453SBron Gondwana }, 1525195cf453SBron Gondwana #endif 15266a46079cSAndi Kleen #ifdef CONFIG_MEMORY_FAILURE 15276a46079cSAndi Kleen { 15286a46079cSAndi Kleen .procname = "memory_failure_early_kill", 15296a46079cSAndi Kleen .data = &sysctl_memory_failure_early_kill, 15306a46079cSAndi Kleen .maxlen = sizeof(sysctl_memory_failure_early_kill), 15316a46079cSAndi Kleen .mode = 0644, 15326d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 15336a46079cSAndi Kleen .extra1 = &zero, 15346a46079cSAndi Kleen .extra2 = &one, 15356a46079cSAndi Kleen }, 15366a46079cSAndi Kleen { 15376a46079cSAndi Kleen .procname = "memory_failure_recovery", 15386a46079cSAndi Kleen .data = &sysctl_memory_failure_recovery, 15396a46079cSAndi Kleen .maxlen = sizeof(sysctl_memory_failure_recovery), 15406a46079cSAndi Kleen .mode = 0644, 15416d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 15426a46079cSAndi Kleen .extra1 = &zero, 15436a46079cSAndi Kleen .extra2 = &one, 15446a46079cSAndi Kleen }, 15456a46079cSAndi Kleen #endif 1546c9b1d098SAndrew Shewmaker { 1547c9b1d098SAndrew Shewmaker .procname = "user_reserve_kbytes", 1548c9b1d098SAndrew Shewmaker .data = &sysctl_user_reserve_kbytes, 1549c9b1d098SAndrew Shewmaker .maxlen = sizeof(sysctl_user_reserve_kbytes), 1550c9b1d098SAndrew Shewmaker .mode = 0644, 1551c9b1d098SAndrew Shewmaker .proc_handler = proc_doulongvec_minmax, 1552c9b1d098SAndrew Shewmaker }, 15534eeab4f5SAndrew Shewmaker { 15544eeab4f5SAndrew Shewmaker .procname = "admin_reserve_kbytes", 15554eeab4f5SAndrew Shewmaker .data = &sysctl_admin_reserve_kbytes, 15564eeab4f5SAndrew Shewmaker .maxlen = sizeof(sysctl_admin_reserve_kbytes), 15574eeab4f5SAndrew Shewmaker .mode = 0644, 15584eeab4f5SAndrew Shewmaker .proc_handler = proc_doulongvec_minmax, 15594eeab4f5SAndrew Shewmaker }, 15606fce56ecSEric W. Biederman { } 15611da177e4SLinus Torvalds }; 15621da177e4SLinus Torvalds 1563d8217f07SEric W. Biederman static struct ctl_table fs_table[] = { 15641da177e4SLinus Torvalds { 15651da177e4SLinus Torvalds .procname = "inode-nr", 15661da177e4SLinus Torvalds .data = &inodes_stat, 15673942c07cSGlauber Costa .maxlen = 2*sizeof(long), 15681da177e4SLinus Torvalds .mode = 0444, 1569cffbc8aaSDave Chinner .proc_handler = proc_nr_inodes, 15701da177e4SLinus Torvalds }, 15711da177e4SLinus Torvalds { 15721da177e4SLinus Torvalds .procname = "inode-state", 15731da177e4SLinus Torvalds .data = &inodes_stat, 15743942c07cSGlauber Costa .maxlen = 7*sizeof(long), 15751da177e4SLinus Torvalds .mode = 0444, 1576cffbc8aaSDave Chinner .proc_handler = proc_nr_inodes, 15771da177e4SLinus Torvalds }, 15781da177e4SLinus Torvalds { 15791da177e4SLinus Torvalds .procname = "file-nr", 15801da177e4SLinus Torvalds .data = &files_stat, 1581518de9b3SEric Dumazet .maxlen = sizeof(files_stat), 15821da177e4SLinus Torvalds .mode = 0444, 15836d456111SEric W. Biederman .proc_handler = proc_nr_files, 15841da177e4SLinus Torvalds }, 15851da177e4SLinus Torvalds { 15861da177e4SLinus Torvalds .procname = "file-max", 15871da177e4SLinus Torvalds .data = &files_stat.max_files, 1588518de9b3SEric Dumazet .maxlen = sizeof(files_stat.max_files), 15891da177e4SLinus Torvalds .mode = 0644, 1590518de9b3SEric Dumazet .proc_handler = proc_doulongvec_minmax, 15911da177e4SLinus Torvalds }, 15921da177e4SLinus Torvalds { 15939cfe015aSEric Dumazet .procname = "nr_open", 15949cfe015aSEric Dumazet .data = &sysctl_nr_open, 15959cfe015aSEric Dumazet .maxlen = sizeof(int), 15969cfe015aSEric Dumazet .mode = 0644, 15976d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 1598eceea0b3SAl Viro .extra1 = &sysctl_nr_open_min, 1599eceea0b3SAl Viro .extra2 = &sysctl_nr_open_max, 16009cfe015aSEric Dumazet }, 16019cfe015aSEric Dumazet { 16021da177e4SLinus Torvalds .procname = "dentry-state", 16031da177e4SLinus Torvalds .data = &dentry_stat, 16043942c07cSGlauber Costa .maxlen = 6*sizeof(long), 16051da177e4SLinus Torvalds .mode = 0444, 1606312d3ca8SChristoph Hellwig .proc_handler = proc_nr_dentry, 16071da177e4SLinus Torvalds }, 16081da177e4SLinus Torvalds { 16091da177e4SLinus Torvalds .procname = "overflowuid", 16101da177e4SLinus Torvalds .data = &fs_overflowuid, 16111da177e4SLinus Torvalds .maxlen = sizeof(int), 16121da177e4SLinus Torvalds .mode = 0644, 16136d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 16141da177e4SLinus Torvalds .extra1 = &minolduid, 16151da177e4SLinus Torvalds .extra2 = &maxolduid, 16161da177e4SLinus Torvalds }, 16171da177e4SLinus Torvalds { 16181da177e4SLinus Torvalds .procname = "overflowgid", 16191da177e4SLinus Torvalds .data = &fs_overflowgid, 16201da177e4SLinus Torvalds .maxlen = sizeof(int), 16211da177e4SLinus Torvalds .mode = 0644, 16226d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 16231da177e4SLinus Torvalds .extra1 = &minolduid, 16241da177e4SLinus Torvalds .extra2 = &maxolduid, 16251da177e4SLinus Torvalds }, 1626bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING 16271da177e4SLinus Torvalds { 16281da177e4SLinus Torvalds .procname = "leases-enable", 16291da177e4SLinus Torvalds .data = &leases_enable, 16301da177e4SLinus Torvalds .maxlen = sizeof(int), 16311da177e4SLinus Torvalds .mode = 0644, 16326d456111SEric W. Biederman .proc_handler = proc_dointvec, 16331da177e4SLinus Torvalds }, 1634bfcd17a6SThomas Petazzoni #endif 16351da177e4SLinus Torvalds #ifdef CONFIG_DNOTIFY 16361da177e4SLinus Torvalds { 16371da177e4SLinus Torvalds .procname = "dir-notify-enable", 16381da177e4SLinus Torvalds .data = &dir_notify_enable, 16391da177e4SLinus Torvalds .maxlen = sizeof(int), 16401da177e4SLinus Torvalds .mode = 0644, 16416d456111SEric W. Biederman .proc_handler = proc_dointvec, 16421da177e4SLinus Torvalds }, 16431da177e4SLinus Torvalds #endif 16441da177e4SLinus Torvalds #ifdef CONFIG_MMU 1645bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING 16461da177e4SLinus Torvalds { 16471da177e4SLinus Torvalds .procname = "lease-break-time", 16481da177e4SLinus Torvalds .data = &lease_break_time, 16491da177e4SLinus Torvalds .maxlen = sizeof(int), 16501da177e4SLinus Torvalds .mode = 0644, 16516d456111SEric W. Biederman .proc_handler = proc_dointvec, 16521da177e4SLinus Torvalds }, 1653bfcd17a6SThomas Petazzoni #endif 1654ebf3f09cSThomas Petazzoni #ifdef CONFIG_AIO 16551da177e4SLinus Torvalds { 16561da177e4SLinus Torvalds .procname = "aio-nr", 16571da177e4SLinus Torvalds .data = &aio_nr, 16581da177e4SLinus Torvalds .maxlen = sizeof(aio_nr), 16591da177e4SLinus Torvalds .mode = 0444, 16606d456111SEric W. Biederman .proc_handler = proc_doulongvec_minmax, 16611da177e4SLinus Torvalds }, 16621da177e4SLinus Torvalds { 16631da177e4SLinus Torvalds .procname = "aio-max-nr", 16641da177e4SLinus Torvalds .data = &aio_max_nr, 16651da177e4SLinus Torvalds .maxlen = sizeof(aio_max_nr), 16661da177e4SLinus Torvalds .mode = 0644, 16676d456111SEric W. Biederman .proc_handler = proc_doulongvec_minmax, 16681da177e4SLinus Torvalds }, 1669ebf3f09cSThomas Petazzoni #endif /* CONFIG_AIO */ 16702d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER 16710399cb08SRobert Love { 16720399cb08SRobert Love .procname = "inotify", 16730399cb08SRobert Love .mode = 0555, 16740399cb08SRobert Love .child = inotify_table, 16750399cb08SRobert Love }, 16760399cb08SRobert Love #endif 16777ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL 16787ef9964eSDavide Libenzi { 16797ef9964eSDavide Libenzi .procname = "epoll", 16807ef9964eSDavide Libenzi .mode = 0555, 16817ef9964eSDavide Libenzi .child = epoll_table, 16827ef9964eSDavide Libenzi }, 16837ef9964eSDavide Libenzi #endif 16841da177e4SLinus Torvalds #endif 1685d6e71144SAlan Cox { 1686800179c9SKees Cook .procname = "protected_symlinks", 1687800179c9SKees Cook .data = &sysctl_protected_symlinks, 1688800179c9SKees Cook .maxlen = sizeof(int), 1689800179c9SKees Cook .mode = 0600, 1690800179c9SKees Cook .proc_handler = proc_dointvec_minmax, 1691800179c9SKees Cook .extra1 = &zero, 1692800179c9SKees Cook .extra2 = &one, 1693800179c9SKees Cook }, 1694800179c9SKees Cook { 1695800179c9SKees Cook .procname = "protected_hardlinks", 1696800179c9SKees Cook .data = &sysctl_protected_hardlinks, 1697800179c9SKees Cook .maxlen = sizeof(int), 1698800179c9SKees Cook .mode = 0600, 1699800179c9SKees Cook .proc_handler = proc_dointvec_minmax, 1700800179c9SKees Cook .extra1 = &zero, 1701800179c9SKees Cook .extra2 = &one, 1702800179c9SKees Cook }, 1703800179c9SKees Cook { 1704d6e71144SAlan Cox .procname = "suid_dumpable", 1705d6e71144SAlan Cox .data = &suid_dumpable, 1706d6e71144SAlan Cox .maxlen = sizeof(int), 1707d6e71144SAlan Cox .mode = 0644, 170854b50199SKees Cook .proc_handler = proc_dointvec_minmax_coredump, 17098e654fbaSMatthew Wilcox .extra1 = &zero, 17108e654fbaSMatthew Wilcox .extra2 = &two, 1711d6e71144SAlan Cox }, 17122abc26fcSEric W. Biederman #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE) 17132abc26fcSEric W. Biederman { 17142abc26fcSEric W. Biederman .procname = "binfmt_misc", 17152abc26fcSEric W. Biederman .mode = 0555, 1716f9bd6733SEric W. Biederman .child = sysctl_mount_point, 17172abc26fcSEric W. Biederman }, 17182abc26fcSEric W. Biederman #endif 1719b492e95bSJens Axboe { 1720ff9da691SJens Axboe .procname = "pipe-max-size", 1721ff9da691SJens Axboe .data = &pipe_max_size, 1722b492e95bSJens Axboe .maxlen = sizeof(int), 1723b492e95bSJens Axboe .mode = 0644, 1724ff9da691SJens Axboe .proc_handler = &pipe_proc_fn, 1725ff9da691SJens Axboe .extra1 = &pipe_min_size, 1726b492e95bSJens Axboe }, 17276fce56ecSEric W. Biederman { } 17281da177e4SLinus Torvalds }; 17291da177e4SLinus Torvalds 1730d8217f07SEric W. Biederman static struct ctl_table debug_table[] = { 17317ac57a89SCatalin Marinas #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE 1732abd4f750SMasoud Asgharifard Sharbiani { 1733abd4f750SMasoud Asgharifard Sharbiani .procname = "exception-trace", 1734abd4f750SMasoud Asgharifard Sharbiani .data = &show_unhandled_signals, 1735abd4f750SMasoud Asgharifard Sharbiani .maxlen = sizeof(int), 1736abd4f750SMasoud Asgharifard Sharbiani .mode = 0644, 1737abd4f750SMasoud Asgharifard Sharbiani .proc_handler = proc_dointvec 1738abd4f750SMasoud Asgharifard Sharbiani }, 1739abd4f750SMasoud Asgharifard Sharbiani #endif 1740b2be84dfSMasami Hiramatsu #if defined(CONFIG_OPTPROBES) 1741b2be84dfSMasami Hiramatsu { 1742b2be84dfSMasami Hiramatsu .procname = "kprobes-optimization", 1743b2be84dfSMasami Hiramatsu .data = &sysctl_kprobes_optimization, 1744b2be84dfSMasami Hiramatsu .maxlen = sizeof(int), 1745b2be84dfSMasami Hiramatsu .mode = 0644, 1746b2be84dfSMasami Hiramatsu .proc_handler = proc_kprobes_optimization_handler, 1747b2be84dfSMasami Hiramatsu .extra1 = &zero, 1748b2be84dfSMasami Hiramatsu .extra2 = &one, 1749b2be84dfSMasami Hiramatsu }, 1750b2be84dfSMasami Hiramatsu #endif 17516fce56ecSEric W. Biederman { } 17521da177e4SLinus Torvalds }; 17531da177e4SLinus Torvalds 1754d8217f07SEric W. Biederman static struct ctl_table dev_table[] = { 17556fce56ecSEric W. Biederman { } 17561da177e4SLinus Torvalds }; 17571da177e4SLinus Torvalds 1758de4e83bdSEric W. Biederman int __init sysctl_init(void) 1759330d57fbSAl Viro { 1760fd4b616bSSteven Rostedt struct ctl_table_header *hdr; 1761fd4b616bSSteven Rostedt 1762fd4b616bSSteven Rostedt hdr = register_sysctl_table(sysctl_base_table); 1763fd4b616bSSteven Rostedt kmemleak_not_leak(hdr); 1764330d57fbSAl Viro return 0; 1765f7e6ced4SAl Viro } 1766f7e6ced4SAl Viro 1767b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL */ 1768b89a8171SEric W. Biederman 17691da177e4SLinus Torvalds /* 17701da177e4SLinus Torvalds * /proc/sys support 17711da177e4SLinus Torvalds */ 17721da177e4SLinus Torvalds 1773b89a8171SEric W. Biederman #ifdef CONFIG_PROC_SYSCTL 17741da177e4SLinus Torvalds 1775f8808300SKees Cook static int _proc_do_string(char *data, int maxlen, int write, 1776f8808300SKees Cook char __user *buffer, 1777b1ba4dddSAdrian Bunk size_t *lenp, loff_t *ppos) 1778f5dd3d6fSSam Vilain { 1779f5dd3d6fSSam Vilain size_t len; 1780f5dd3d6fSSam Vilain char __user *p; 1781f5dd3d6fSSam Vilain char c; 1782f5dd3d6fSSam Vilain 17838d060877SOleg Nesterov if (!data || !maxlen || !*lenp) { 1784f5dd3d6fSSam Vilain *lenp = 0; 1785f5dd3d6fSSam Vilain return 0; 1786f5dd3d6fSSam Vilain } 1787f5dd3d6fSSam Vilain 1788f5dd3d6fSSam Vilain if (write) { 1789f4aacea2SKees Cook if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) { 1790f4aacea2SKees Cook /* Only continue writes not past the end of buffer. */ 1791f4aacea2SKees Cook len = strlen(data); 1792f4aacea2SKees Cook if (len > maxlen - 1) 1793f4aacea2SKees Cook len = maxlen - 1; 1794f4aacea2SKees Cook 1795f4aacea2SKees Cook if (*ppos > len) 1796f4aacea2SKees Cook return 0; 1797f4aacea2SKees Cook len = *ppos; 1798f4aacea2SKees Cook } else { 17992ca9bb45SKees Cook /* Start writing from beginning of buffer. */ 1800f5dd3d6fSSam Vilain len = 0; 1801f4aacea2SKees Cook } 1802f4aacea2SKees Cook 18032ca9bb45SKees Cook *ppos += *lenp; 1804f5dd3d6fSSam Vilain p = buffer; 18052ca9bb45SKees Cook while ((p - buffer) < *lenp && len < maxlen - 1) { 1806f5dd3d6fSSam Vilain if (get_user(c, p++)) 1807f5dd3d6fSSam Vilain return -EFAULT; 1808f5dd3d6fSSam Vilain if (c == 0 || c == '\n') 1809f5dd3d6fSSam Vilain break; 18102ca9bb45SKees Cook data[len++] = c; 1811f5dd3d6fSSam Vilain } 1812f8808300SKees Cook data[len] = 0; 1813f5dd3d6fSSam Vilain } else { 1814f5dd3d6fSSam Vilain len = strlen(data); 1815f5dd3d6fSSam Vilain if (len > maxlen) 1816f5dd3d6fSSam Vilain len = maxlen; 18178d060877SOleg Nesterov 18188d060877SOleg Nesterov if (*ppos > len) { 18198d060877SOleg Nesterov *lenp = 0; 18208d060877SOleg Nesterov return 0; 18218d060877SOleg Nesterov } 18228d060877SOleg Nesterov 18238d060877SOleg Nesterov data += *ppos; 18248d060877SOleg Nesterov len -= *ppos; 18258d060877SOleg Nesterov 1826f5dd3d6fSSam Vilain if (len > *lenp) 1827f5dd3d6fSSam Vilain len = *lenp; 1828f5dd3d6fSSam Vilain if (len) 1829f5dd3d6fSSam Vilain if (copy_to_user(buffer, data, len)) 1830f5dd3d6fSSam Vilain return -EFAULT; 1831f5dd3d6fSSam Vilain if (len < *lenp) { 1832f8808300SKees Cook if (put_user('\n', buffer + len)) 1833f5dd3d6fSSam Vilain return -EFAULT; 1834f5dd3d6fSSam Vilain len++; 1835f5dd3d6fSSam Vilain } 1836f5dd3d6fSSam Vilain *lenp = len; 1837f5dd3d6fSSam Vilain *ppos += len; 1838f5dd3d6fSSam Vilain } 1839f5dd3d6fSSam Vilain return 0; 1840f5dd3d6fSSam Vilain } 1841f5dd3d6fSSam Vilain 1842f4aacea2SKees Cook static void warn_sysctl_write(struct ctl_table *table) 1843f4aacea2SKees Cook { 1844f4aacea2SKees Cook pr_warn_once("%s wrote to %s when file position was not 0!\n" 1845f4aacea2SKees Cook "This will not be supported in the future. To silence this\n" 1846f4aacea2SKees Cook "warning, set kernel.sysctl_writes_strict = -1\n", 1847f4aacea2SKees Cook current->comm, table->procname); 1848f4aacea2SKees Cook } 1849f4aacea2SKees Cook 18501da177e4SLinus Torvalds /** 18511da177e4SLinus Torvalds * proc_dostring - read a string sysctl 18521da177e4SLinus Torvalds * @table: the sysctl table 18531da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 18541da177e4SLinus Torvalds * @buffer: the user buffer 18551da177e4SLinus Torvalds * @lenp: the size of the user buffer 18561da177e4SLinus Torvalds * @ppos: file position 18571da177e4SLinus Torvalds * 18581da177e4SLinus Torvalds * Reads/writes a string from/to the user buffer. If the kernel 18591da177e4SLinus Torvalds * buffer provided is not large enough to hold the string, the 18601da177e4SLinus Torvalds * string is truncated. The copied string is %NULL-terminated. 18611da177e4SLinus Torvalds * If the string is being read by the user process, it is copied 18621da177e4SLinus Torvalds * and a newline '\n' is added. It is truncated if the buffer is 18631da177e4SLinus Torvalds * not large enough. 18641da177e4SLinus Torvalds * 18651da177e4SLinus Torvalds * Returns 0 on success. 18661da177e4SLinus Torvalds */ 18678d65af78SAlexey Dobriyan int proc_dostring(struct ctl_table *table, int write, 18681da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 18691da177e4SLinus Torvalds { 1870f4aacea2SKees Cook if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN) 1871f4aacea2SKees Cook warn_sysctl_write(table); 1872f4aacea2SKees Cook 1873f8808300SKees Cook return _proc_do_string((char *)(table->data), table->maxlen, write, 1874f8808300SKees Cook (char __user *)buffer, lenp, ppos); 18751da177e4SLinus Torvalds } 18761da177e4SLinus Torvalds 187700b7c339SAmerigo Wang static size_t proc_skip_spaces(char **buf) 187800b7c339SAmerigo Wang { 187900b7c339SAmerigo Wang size_t ret; 188000b7c339SAmerigo Wang char *tmp = skip_spaces(*buf); 188100b7c339SAmerigo Wang ret = tmp - *buf; 188200b7c339SAmerigo Wang *buf = tmp; 188300b7c339SAmerigo Wang return ret; 188400b7c339SAmerigo Wang } 18851da177e4SLinus Torvalds 18869f977fb7SOctavian Purdila static void proc_skip_char(char **buf, size_t *size, const char v) 18879f977fb7SOctavian Purdila { 18889f977fb7SOctavian Purdila while (*size) { 18899f977fb7SOctavian Purdila if (**buf != v) 18909f977fb7SOctavian Purdila break; 18919f977fb7SOctavian Purdila (*size)--; 18929f977fb7SOctavian Purdila (*buf)++; 18939f977fb7SOctavian Purdila } 18949f977fb7SOctavian Purdila } 18959f977fb7SOctavian Purdila 189600b7c339SAmerigo Wang #define TMPBUFLEN 22 189700b7c339SAmerigo Wang /** 18980fc377bdSRandy Dunlap * proc_get_long - reads an ASCII formatted integer from a user buffer 189900b7c339SAmerigo Wang * 19000fc377bdSRandy Dunlap * @buf: a kernel buffer 19010fc377bdSRandy Dunlap * @size: size of the kernel buffer 19020fc377bdSRandy Dunlap * @val: this is where the number will be stored 19030fc377bdSRandy Dunlap * @neg: set to %TRUE if number is negative 19040fc377bdSRandy Dunlap * @perm_tr: a vector which contains the allowed trailers 19050fc377bdSRandy Dunlap * @perm_tr_len: size of the perm_tr vector 19060fc377bdSRandy Dunlap * @tr: pointer to store the trailer character 190700b7c339SAmerigo Wang * 19080fc377bdSRandy Dunlap * In case of success %0 is returned and @buf and @size are updated with 19090fc377bdSRandy Dunlap * the amount of bytes read. If @tr is non-NULL and a trailing 19100fc377bdSRandy Dunlap * character exists (size is non-zero after returning from this 19110fc377bdSRandy Dunlap * function), @tr is updated with the trailing character. 191200b7c339SAmerigo Wang */ 191300b7c339SAmerigo Wang static int proc_get_long(char **buf, size_t *size, 191400b7c339SAmerigo Wang unsigned long *val, bool *neg, 191500b7c339SAmerigo Wang const char *perm_tr, unsigned perm_tr_len, char *tr) 191600b7c339SAmerigo Wang { 191700b7c339SAmerigo Wang int len; 191800b7c339SAmerigo Wang char *p, tmp[TMPBUFLEN]; 191900b7c339SAmerigo Wang 192000b7c339SAmerigo Wang if (!*size) 192100b7c339SAmerigo Wang return -EINVAL; 192200b7c339SAmerigo Wang 192300b7c339SAmerigo Wang len = *size; 192400b7c339SAmerigo Wang if (len > TMPBUFLEN - 1) 192500b7c339SAmerigo Wang len = TMPBUFLEN - 1; 192600b7c339SAmerigo Wang 192700b7c339SAmerigo Wang memcpy(tmp, *buf, len); 192800b7c339SAmerigo Wang 192900b7c339SAmerigo Wang tmp[len] = 0; 193000b7c339SAmerigo Wang p = tmp; 193100b7c339SAmerigo Wang if (*p == '-' && *size > 1) { 193200b7c339SAmerigo Wang *neg = true; 193300b7c339SAmerigo Wang p++; 193400b7c339SAmerigo Wang } else 193500b7c339SAmerigo Wang *neg = false; 193600b7c339SAmerigo Wang if (!isdigit(*p)) 193700b7c339SAmerigo Wang return -EINVAL; 193800b7c339SAmerigo Wang 193900b7c339SAmerigo Wang *val = simple_strtoul(p, &p, 0); 194000b7c339SAmerigo Wang 194100b7c339SAmerigo Wang len = p - tmp; 194200b7c339SAmerigo Wang 194300b7c339SAmerigo Wang /* We don't know if the next char is whitespace thus we may accept 194400b7c339SAmerigo Wang * invalid integers (e.g. 1234...a) or two integers instead of one 194500b7c339SAmerigo Wang * (e.g. 123...1). So lets not allow such large numbers. */ 194600b7c339SAmerigo Wang if (len == TMPBUFLEN - 1) 194700b7c339SAmerigo Wang return -EINVAL; 194800b7c339SAmerigo Wang 194900b7c339SAmerigo Wang if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len)) 195000b7c339SAmerigo Wang return -EINVAL; 195100b7c339SAmerigo Wang 195200b7c339SAmerigo Wang if (tr && (len < *size)) 195300b7c339SAmerigo Wang *tr = *p; 195400b7c339SAmerigo Wang 195500b7c339SAmerigo Wang *buf += len; 195600b7c339SAmerigo Wang *size -= len; 195700b7c339SAmerigo Wang 195800b7c339SAmerigo Wang return 0; 195900b7c339SAmerigo Wang } 196000b7c339SAmerigo Wang 196100b7c339SAmerigo Wang /** 19620fc377bdSRandy Dunlap * proc_put_long - converts an integer to a decimal ASCII formatted string 196300b7c339SAmerigo Wang * 19640fc377bdSRandy Dunlap * @buf: the user buffer 19650fc377bdSRandy Dunlap * @size: the size of the user buffer 19660fc377bdSRandy Dunlap * @val: the integer to be converted 19670fc377bdSRandy Dunlap * @neg: sign of the number, %TRUE for negative 196800b7c339SAmerigo Wang * 19690fc377bdSRandy Dunlap * In case of success %0 is returned and @buf and @size are updated with 19700fc377bdSRandy Dunlap * the amount of bytes written. 197100b7c339SAmerigo Wang */ 197200b7c339SAmerigo Wang static int proc_put_long(void __user **buf, size_t *size, unsigned long val, 197300b7c339SAmerigo Wang bool neg) 197400b7c339SAmerigo Wang { 197500b7c339SAmerigo Wang int len; 197600b7c339SAmerigo Wang char tmp[TMPBUFLEN], *p = tmp; 197700b7c339SAmerigo Wang 197800b7c339SAmerigo Wang sprintf(p, "%s%lu", neg ? "-" : "", val); 197900b7c339SAmerigo Wang len = strlen(tmp); 198000b7c339SAmerigo Wang if (len > *size) 198100b7c339SAmerigo Wang len = *size; 198200b7c339SAmerigo Wang if (copy_to_user(*buf, tmp, len)) 198300b7c339SAmerigo Wang return -EFAULT; 198400b7c339SAmerigo Wang *size -= len; 198500b7c339SAmerigo Wang *buf += len; 198600b7c339SAmerigo Wang return 0; 198700b7c339SAmerigo Wang } 198800b7c339SAmerigo Wang #undef TMPBUFLEN 198900b7c339SAmerigo Wang 199000b7c339SAmerigo Wang static int proc_put_char(void __user **buf, size_t *size, char c) 199100b7c339SAmerigo Wang { 199200b7c339SAmerigo Wang if (*size) { 199300b7c339SAmerigo Wang char __user **buffer = (char __user **)buf; 199400b7c339SAmerigo Wang if (put_user(c, *buffer)) 199500b7c339SAmerigo Wang return -EFAULT; 199600b7c339SAmerigo Wang (*size)--, (*buffer)++; 199700b7c339SAmerigo Wang *buf = *buffer; 199800b7c339SAmerigo Wang } 199900b7c339SAmerigo Wang return 0; 200000b7c339SAmerigo Wang } 200100b7c339SAmerigo Wang 200200b7c339SAmerigo Wang static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp, 20031da177e4SLinus Torvalds int *valp, 20041da177e4SLinus Torvalds int write, void *data) 20051da177e4SLinus Torvalds { 20061da177e4SLinus Torvalds if (write) { 2007230633d1SHeinrich Schuchardt if (*negp) { 2008230633d1SHeinrich Schuchardt if (*lvalp > (unsigned long) INT_MAX + 1) 2009230633d1SHeinrich Schuchardt return -EINVAL; 2010230633d1SHeinrich Schuchardt *valp = -*lvalp; 2011230633d1SHeinrich Schuchardt } else { 2012230633d1SHeinrich Schuchardt if (*lvalp > (unsigned long) INT_MAX) 2013230633d1SHeinrich Schuchardt return -EINVAL; 2014230633d1SHeinrich Schuchardt *valp = *lvalp; 2015230633d1SHeinrich Schuchardt } 20161da177e4SLinus Torvalds } else { 20171da177e4SLinus Torvalds int val = *valp; 20181da177e4SLinus Torvalds if (val < 0) { 201900b7c339SAmerigo Wang *negp = true; 20209a5bc726SIlya Dryomov *lvalp = -(unsigned long)val; 20211da177e4SLinus Torvalds } else { 202200b7c339SAmerigo Wang *negp = false; 20231da177e4SLinus Torvalds *lvalp = (unsigned long)val; 20241da177e4SLinus Torvalds } 20251da177e4SLinus Torvalds } 20261da177e4SLinus Torvalds return 0; 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds 202900b7c339SAmerigo Wang static const char proc_wspace_sep[] = { ' ', '\t', '\n' }; 203000b7c339SAmerigo Wang 2031d8217f07SEric W. Biederman static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table, 20328d65af78SAlexey Dobriyan int write, void __user *buffer, 2033fcfbd547SKirill Korotaev size_t *lenp, loff_t *ppos, 203400b7c339SAmerigo Wang int (*conv)(bool *negp, unsigned long *lvalp, int *valp, 20351da177e4SLinus Torvalds int write, void *data), 20361da177e4SLinus Torvalds void *data) 20371da177e4SLinus Torvalds { 203800b7c339SAmerigo Wang int *i, vleft, first = 1, err = 0; 203900b7c339SAmerigo Wang unsigned long page = 0; 204000b7c339SAmerigo Wang size_t left; 204100b7c339SAmerigo Wang char *kbuf; 20421da177e4SLinus Torvalds 204300b7c339SAmerigo Wang if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) { 20441da177e4SLinus Torvalds *lenp = 0; 20451da177e4SLinus Torvalds return 0; 20461da177e4SLinus Torvalds } 20471da177e4SLinus Torvalds 2048fcfbd547SKirill Korotaev i = (int *) tbl_data; 20491da177e4SLinus Torvalds vleft = table->maxlen / sizeof(*i); 20501da177e4SLinus Torvalds left = *lenp; 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds if (!conv) 20531da177e4SLinus Torvalds conv = do_proc_dointvec_conv; 20541da177e4SLinus Torvalds 205500b7c339SAmerigo Wang if (write) { 2056f4aacea2SKees Cook if (*ppos) { 2057f4aacea2SKees Cook switch (sysctl_writes_strict) { 2058f4aacea2SKees Cook case SYSCTL_WRITES_STRICT: 2059f4aacea2SKees Cook goto out; 2060f4aacea2SKees Cook case SYSCTL_WRITES_WARN: 2061f4aacea2SKees Cook warn_sysctl_write(table); 2062f4aacea2SKees Cook break; 2063f4aacea2SKees Cook default: 2064f4aacea2SKees Cook break; 2065f4aacea2SKees Cook } 2066f4aacea2SKees Cook } 2067f4aacea2SKees Cook 206800b7c339SAmerigo Wang if (left > PAGE_SIZE - 1) 206900b7c339SAmerigo Wang left = PAGE_SIZE - 1; 207000b7c339SAmerigo Wang page = __get_free_page(GFP_TEMPORARY); 207100b7c339SAmerigo Wang kbuf = (char *) page; 207200b7c339SAmerigo Wang if (!kbuf) 207300b7c339SAmerigo Wang return -ENOMEM; 207400b7c339SAmerigo Wang if (copy_from_user(kbuf, buffer, left)) { 207500b7c339SAmerigo Wang err = -EFAULT; 207600b7c339SAmerigo Wang goto free; 207700b7c339SAmerigo Wang } 207800b7c339SAmerigo Wang kbuf[left] = 0; 207900b7c339SAmerigo Wang } 208000b7c339SAmerigo Wang 20811da177e4SLinus Torvalds for (; left && vleft--; i++, first=0) { 208200b7c339SAmerigo Wang unsigned long lval; 208300b7c339SAmerigo Wang bool neg; 208400b7c339SAmerigo Wang 20851da177e4SLinus Torvalds if (write) { 208600b7c339SAmerigo Wang left -= proc_skip_spaces(&kbuf); 208700b7c339SAmerigo Wang 2088563b0467SJ. R. Okajima if (!left) 2089563b0467SJ. R. Okajima break; 209000b7c339SAmerigo Wang err = proc_get_long(&kbuf, &left, &lval, &neg, 209100b7c339SAmerigo Wang proc_wspace_sep, 209200b7c339SAmerigo Wang sizeof(proc_wspace_sep), NULL); 209300b7c339SAmerigo Wang if (err) 20941da177e4SLinus Torvalds break; 209500b7c339SAmerigo Wang if (conv(&neg, &lval, i, 1, data)) { 209600b7c339SAmerigo Wang err = -EINVAL; 209700b7c339SAmerigo Wang break; 20981da177e4SLinus Torvalds } 20991da177e4SLinus Torvalds } else { 210000b7c339SAmerigo Wang if (conv(&neg, &lval, i, 0, data)) { 210100b7c339SAmerigo Wang err = -EINVAL; 210200b7c339SAmerigo Wang break; 210300b7c339SAmerigo Wang } 21041da177e4SLinus Torvalds if (!first) 210500b7c339SAmerigo Wang err = proc_put_char(&buffer, &left, '\t'); 210600b7c339SAmerigo Wang if (err) 21071da177e4SLinus Torvalds break; 210800b7c339SAmerigo Wang err = proc_put_long(&buffer, &left, lval, neg); 210900b7c339SAmerigo Wang if (err) 211000b7c339SAmerigo Wang break; 21111da177e4SLinus Torvalds } 21121da177e4SLinus Torvalds } 21131da177e4SLinus Torvalds 211400b7c339SAmerigo Wang if (!write && !first && left && !err) 211500b7c339SAmerigo Wang err = proc_put_char(&buffer, &left, '\n'); 2116563b0467SJ. R. Okajima if (write && !err && left) 211700b7c339SAmerigo Wang left -= proc_skip_spaces(&kbuf); 211800b7c339SAmerigo Wang free: 21191da177e4SLinus Torvalds if (write) { 212000b7c339SAmerigo Wang free_page(page); 212100b7c339SAmerigo Wang if (first) 212200b7c339SAmerigo Wang return err ? : -EINVAL; 21231da177e4SLinus Torvalds } 21241da177e4SLinus Torvalds *lenp -= left; 2125f4aacea2SKees Cook out: 21261da177e4SLinus Torvalds *ppos += *lenp; 212700b7c339SAmerigo Wang return err; 21281da177e4SLinus Torvalds } 21291da177e4SLinus Torvalds 21308d65af78SAlexey Dobriyan static int do_proc_dointvec(struct ctl_table *table, int write, 2131fcfbd547SKirill Korotaev void __user *buffer, size_t *lenp, loff_t *ppos, 213200b7c339SAmerigo Wang int (*conv)(bool *negp, unsigned long *lvalp, int *valp, 2133fcfbd547SKirill Korotaev int write, void *data), 2134fcfbd547SKirill Korotaev void *data) 2135fcfbd547SKirill Korotaev { 21368d65af78SAlexey Dobriyan return __do_proc_dointvec(table->data, table, write, 2137fcfbd547SKirill Korotaev buffer, lenp, ppos, conv, data); 2138fcfbd547SKirill Korotaev } 2139fcfbd547SKirill Korotaev 21401da177e4SLinus Torvalds /** 21411da177e4SLinus Torvalds * proc_dointvec - read a vector of integers 21421da177e4SLinus Torvalds * @table: the sysctl table 21431da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 21441da177e4SLinus Torvalds * @buffer: the user buffer 21451da177e4SLinus Torvalds * @lenp: the size of the user buffer 21461da177e4SLinus Torvalds * @ppos: file position 21471da177e4SLinus Torvalds * 21481da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 21491da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. 21501da177e4SLinus Torvalds * 21511da177e4SLinus Torvalds * Returns 0 on success. 21521da177e4SLinus Torvalds */ 21538d65af78SAlexey Dobriyan int proc_dointvec(struct ctl_table *table, int write, 21541da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 21551da177e4SLinus Torvalds { 21568d65af78SAlexey Dobriyan return do_proc_dointvec(table,write,buffer,lenp,ppos, 21571da177e4SLinus Torvalds NULL,NULL); 21581da177e4SLinus Torvalds } 21591da177e4SLinus Torvalds 216034f5a398STheodore Ts'o /* 216134f5a398STheodore Ts'o * Taint values can only be increased 216225ddbb18SAndi Kleen * This means we can safely use a temporary. 216334f5a398STheodore Ts'o */ 21648d65af78SAlexey Dobriyan static int proc_taint(struct ctl_table *table, int write, 216534f5a398STheodore Ts'o void __user *buffer, size_t *lenp, loff_t *ppos) 216634f5a398STheodore Ts'o { 216725ddbb18SAndi Kleen struct ctl_table t; 216825ddbb18SAndi Kleen unsigned long tmptaint = get_taint(); 216925ddbb18SAndi Kleen int err; 217034f5a398STheodore Ts'o 217191fcd412SBastian Blank if (write && !capable(CAP_SYS_ADMIN)) 217234f5a398STheodore Ts'o return -EPERM; 217334f5a398STheodore Ts'o 217425ddbb18SAndi Kleen t = *table; 217525ddbb18SAndi Kleen t.data = &tmptaint; 21768d65af78SAlexey Dobriyan err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos); 217725ddbb18SAndi Kleen if (err < 0) 217825ddbb18SAndi Kleen return err; 217925ddbb18SAndi Kleen 218025ddbb18SAndi Kleen if (write) { 218125ddbb18SAndi Kleen /* 218225ddbb18SAndi Kleen * Poor man's atomic or. Not worth adding a primitive 218325ddbb18SAndi Kleen * to everyone's atomic.h for this 218425ddbb18SAndi Kleen */ 218525ddbb18SAndi Kleen int i; 218625ddbb18SAndi Kleen for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) { 218725ddbb18SAndi Kleen if ((tmptaint >> i) & 1) 2188373d4d09SRusty Russell add_taint(i, LOCKDEP_STILL_OK); 218925ddbb18SAndi Kleen } 219025ddbb18SAndi Kleen } 219125ddbb18SAndi Kleen 219225ddbb18SAndi Kleen return err; 219334f5a398STheodore Ts'o } 219434f5a398STheodore Ts'o 2195bfdc0b49SRichard Weinberger #ifdef CONFIG_PRINTK 2196620f6e8eSKees Cook static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write, 2197bfdc0b49SRichard Weinberger void __user *buffer, size_t *lenp, loff_t *ppos) 2198bfdc0b49SRichard Weinberger { 2199bfdc0b49SRichard Weinberger if (write && !capable(CAP_SYS_ADMIN)) 2200bfdc0b49SRichard Weinberger return -EPERM; 2201bfdc0b49SRichard Weinberger 2202bfdc0b49SRichard Weinberger return proc_dointvec_minmax(table, write, buffer, lenp, ppos); 2203bfdc0b49SRichard Weinberger } 2204bfdc0b49SRichard Weinberger #endif 2205bfdc0b49SRichard Weinberger 22061da177e4SLinus Torvalds struct do_proc_dointvec_minmax_conv_param { 22071da177e4SLinus Torvalds int *min; 22081da177e4SLinus Torvalds int *max; 22091da177e4SLinus Torvalds }; 22101da177e4SLinus Torvalds 221100b7c339SAmerigo Wang static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp, 22121da177e4SLinus Torvalds int *valp, 22131da177e4SLinus Torvalds int write, void *data) 22141da177e4SLinus Torvalds { 22151da177e4SLinus Torvalds struct do_proc_dointvec_minmax_conv_param *param = data; 22161da177e4SLinus Torvalds if (write) { 22171da177e4SLinus Torvalds int val = *negp ? -*lvalp : *lvalp; 22181da177e4SLinus Torvalds if ((param->min && *param->min > val) || 22191da177e4SLinus Torvalds (param->max && *param->max < val)) 22201da177e4SLinus Torvalds return -EINVAL; 22211da177e4SLinus Torvalds *valp = val; 22221da177e4SLinus Torvalds } else { 22231da177e4SLinus Torvalds int val = *valp; 22241da177e4SLinus Torvalds if (val < 0) { 222500b7c339SAmerigo Wang *negp = true; 22269a5bc726SIlya Dryomov *lvalp = -(unsigned long)val; 22271da177e4SLinus Torvalds } else { 222800b7c339SAmerigo Wang *negp = false; 22291da177e4SLinus Torvalds *lvalp = (unsigned long)val; 22301da177e4SLinus Torvalds } 22311da177e4SLinus Torvalds } 22321da177e4SLinus Torvalds return 0; 22331da177e4SLinus Torvalds } 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds /** 22361da177e4SLinus Torvalds * proc_dointvec_minmax - read a vector of integers with min/max values 22371da177e4SLinus Torvalds * @table: the sysctl table 22381da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 22391da177e4SLinus Torvalds * @buffer: the user buffer 22401da177e4SLinus Torvalds * @lenp: the size of the user buffer 22411da177e4SLinus Torvalds * @ppos: file position 22421da177e4SLinus Torvalds * 22431da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 22441da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. 22451da177e4SLinus Torvalds * 22461da177e4SLinus Torvalds * This routine will ensure the values are within the range specified by 22471da177e4SLinus Torvalds * table->extra1 (min) and table->extra2 (max). 22481da177e4SLinus Torvalds * 22491da177e4SLinus Torvalds * Returns 0 on success. 22501da177e4SLinus Torvalds */ 22518d65af78SAlexey Dobriyan int proc_dointvec_minmax(struct ctl_table *table, int write, 22521da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 22531da177e4SLinus Torvalds { 22541da177e4SLinus Torvalds struct do_proc_dointvec_minmax_conv_param param = { 22551da177e4SLinus Torvalds .min = (int *) table->extra1, 22561da177e4SLinus Torvalds .max = (int *) table->extra2, 22571da177e4SLinus Torvalds }; 22588d65af78SAlexey Dobriyan return do_proc_dointvec(table, write, buffer, lenp, ppos, 22591da177e4SLinus Torvalds do_proc_dointvec_minmax_conv, ¶m); 22601da177e4SLinus Torvalds } 22611da177e4SLinus Torvalds 226254b50199SKees Cook static void validate_coredump_safety(void) 226354b50199SKees Cook { 2264046d662fSAlex Kelly #ifdef CONFIG_COREDUMP 2265e579d2c2SKees Cook if (suid_dumpable == SUID_DUMP_ROOT && 226654b50199SKees Cook core_pattern[0] != '/' && core_pattern[0] != '|') { 226754b50199SKees Cook printk(KERN_WARNING "Unsafe core_pattern used with "\ 226854b50199SKees Cook "suid_dumpable=2. Pipe handler or fully qualified "\ 226954b50199SKees Cook "core dump path required.\n"); 227054b50199SKees Cook } 2271046d662fSAlex Kelly #endif 227254b50199SKees Cook } 227354b50199SKees Cook 227454b50199SKees Cook static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write, 227554b50199SKees Cook void __user *buffer, size_t *lenp, loff_t *ppos) 227654b50199SKees Cook { 227754b50199SKees Cook int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 227854b50199SKees Cook if (!error) 227954b50199SKees Cook validate_coredump_safety(); 228054b50199SKees Cook return error; 228154b50199SKees Cook } 228254b50199SKees Cook 2283046d662fSAlex Kelly #ifdef CONFIG_COREDUMP 228454b50199SKees Cook static int proc_dostring_coredump(struct ctl_table *table, int write, 228554b50199SKees Cook void __user *buffer, size_t *lenp, loff_t *ppos) 228654b50199SKees Cook { 228754b50199SKees Cook int error = proc_dostring(table, write, buffer, lenp, ppos); 228854b50199SKees Cook if (!error) 228954b50199SKees Cook validate_coredump_safety(); 229054b50199SKees Cook return error; 229154b50199SKees Cook } 2292046d662fSAlex Kelly #endif 229354b50199SKees Cook 2294d8217f07SEric W. Biederman static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write, 22951da177e4SLinus Torvalds void __user *buffer, 22961da177e4SLinus Torvalds size_t *lenp, loff_t *ppos, 22971da177e4SLinus Torvalds unsigned long convmul, 22981da177e4SLinus Torvalds unsigned long convdiv) 22991da177e4SLinus Torvalds { 230000b7c339SAmerigo Wang unsigned long *i, *min, *max; 230100b7c339SAmerigo Wang int vleft, first = 1, err = 0; 230200b7c339SAmerigo Wang unsigned long page = 0; 230300b7c339SAmerigo Wang size_t left; 230400b7c339SAmerigo Wang char *kbuf; 23051da177e4SLinus Torvalds 230600b7c339SAmerigo Wang if (!data || !table->maxlen || !*lenp || (*ppos && !write)) { 23071da177e4SLinus Torvalds *lenp = 0; 23081da177e4SLinus Torvalds return 0; 23091da177e4SLinus Torvalds } 23101da177e4SLinus Torvalds 2311fcfbd547SKirill Korotaev i = (unsigned long *) data; 23121da177e4SLinus Torvalds min = (unsigned long *) table->extra1; 23131da177e4SLinus Torvalds max = (unsigned long *) table->extra2; 23141da177e4SLinus Torvalds vleft = table->maxlen / sizeof(unsigned long); 23151da177e4SLinus Torvalds left = *lenp; 23161da177e4SLinus Torvalds 23171da177e4SLinus Torvalds if (write) { 2318f4aacea2SKees Cook if (*ppos) { 2319f4aacea2SKees Cook switch (sysctl_writes_strict) { 2320f4aacea2SKees Cook case SYSCTL_WRITES_STRICT: 2321f4aacea2SKees Cook goto out; 2322f4aacea2SKees Cook case SYSCTL_WRITES_WARN: 2323f4aacea2SKees Cook warn_sysctl_write(table); 2324f4aacea2SKees Cook break; 2325f4aacea2SKees Cook default: 2326f4aacea2SKees Cook break; 2327f4aacea2SKees Cook } 2328f4aacea2SKees Cook } 2329f4aacea2SKees Cook 233000b7c339SAmerigo Wang if (left > PAGE_SIZE - 1) 233100b7c339SAmerigo Wang left = PAGE_SIZE - 1; 233200b7c339SAmerigo Wang page = __get_free_page(GFP_TEMPORARY); 233300b7c339SAmerigo Wang kbuf = (char *) page; 233400b7c339SAmerigo Wang if (!kbuf) 233500b7c339SAmerigo Wang return -ENOMEM; 233600b7c339SAmerigo Wang if (copy_from_user(kbuf, buffer, left)) { 233700b7c339SAmerigo Wang err = -EFAULT; 233800b7c339SAmerigo Wang goto free; 23391da177e4SLinus Torvalds } 234000b7c339SAmerigo Wang kbuf[left] = 0; 23411da177e4SLinus Torvalds } 23421da177e4SLinus Torvalds 234327b3d80aSEric Dumazet for (; left && vleft--; i++, first = 0) { 234400b7c339SAmerigo Wang unsigned long val; 234500b7c339SAmerigo Wang 234600b7c339SAmerigo Wang if (write) { 234700b7c339SAmerigo Wang bool neg; 234800b7c339SAmerigo Wang 234900b7c339SAmerigo Wang left -= proc_skip_spaces(&kbuf); 235000b7c339SAmerigo Wang 235100b7c339SAmerigo Wang err = proc_get_long(&kbuf, &left, &val, &neg, 235200b7c339SAmerigo Wang proc_wspace_sep, 235300b7c339SAmerigo Wang sizeof(proc_wspace_sep), NULL); 235400b7c339SAmerigo Wang if (err) 235500b7c339SAmerigo Wang break; 23561da177e4SLinus Torvalds if (neg) 23571da177e4SLinus Torvalds continue; 23581da177e4SLinus Torvalds if ((min && val < *min) || (max && val > *max)) 23591da177e4SLinus Torvalds continue; 23601da177e4SLinus Torvalds *i = val; 23611da177e4SLinus Torvalds } else { 236200b7c339SAmerigo Wang val = convdiv * (*i) / convmul; 23637833819dSChen Gang if (!first) { 236400b7c339SAmerigo Wang err = proc_put_char(&buffer, &left, '\t'); 23657833819dSChen Gang if (err) 23667833819dSChen Gang break; 23677833819dSChen Gang } 236800b7c339SAmerigo Wang err = proc_put_long(&buffer, &left, val, false); 236900b7c339SAmerigo Wang if (err) 237000b7c339SAmerigo Wang break; 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds } 23731da177e4SLinus Torvalds 237400b7c339SAmerigo Wang if (!write && !first && left && !err) 237500b7c339SAmerigo Wang err = proc_put_char(&buffer, &left, '\n'); 237600b7c339SAmerigo Wang if (write && !err) 237700b7c339SAmerigo Wang left -= proc_skip_spaces(&kbuf); 237800b7c339SAmerigo Wang free: 23791da177e4SLinus Torvalds if (write) { 238000b7c339SAmerigo Wang free_page(page); 238100b7c339SAmerigo Wang if (first) 238200b7c339SAmerigo Wang return err ? : -EINVAL; 23831da177e4SLinus Torvalds } 23841da177e4SLinus Torvalds *lenp -= left; 2385f4aacea2SKees Cook out: 23861da177e4SLinus Torvalds *ppos += *lenp; 238700b7c339SAmerigo Wang return err; 23881da177e4SLinus Torvalds } 23891da177e4SLinus Torvalds 2390d8217f07SEric W. Biederman static int do_proc_doulongvec_minmax(struct ctl_table *table, int write, 2391fcfbd547SKirill Korotaev void __user *buffer, 2392fcfbd547SKirill Korotaev size_t *lenp, loff_t *ppos, 2393fcfbd547SKirill Korotaev unsigned long convmul, 2394fcfbd547SKirill Korotaev unsigned long convdiv) 2395fcfbd547SKirill Korotaev { 2396fcfbd547SKirill Korotaev return __do_proc_doulongvec_minmax(table->data, table, write, 23978d65af78SAlexey Dobriyan buffer, lenp, ppos, convmul, convdiv); 2398fcfbd547SKirill Korotaev } 2399fcfbd547SKirill Korotaev 24001da177e4SLinus Torvalds /** 24011da177e4SLinus Torvalds * proc_doulongvec_minmax - read a vector of long integers with min/max values 24021da177e4SLinus Torvalds * @table: the sysctl table 24031da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 24041da177e4SLinus Torvalds * @buffer: the user buffer 24051da177e4SLinus Torvalds * @lenp: the size of the user buffer 24061da177e4SLinus Torvalds * @ppos: file position 24071da177e4SLinus Torvalds * 24081da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long 24091da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. 24101da177e4SLinus Torvalds * 24111da177e4SLinus Torvalds * This routine will ensure the values are within the range specified by 24121da177e4SLinus Torvalds * table->extra1 (min) and table->extra2 (max). 24131da177e4SLinus Torvalds * 24141da177e4SLinus Torvalds * Returns 0 on success. 24151da177e4SLinus Torvalds */ 24168d65af78SAlexey Dobriyan int proc_doulongvec_minmax(struct ctl_table *table, int write, 24171da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 24181da177e4SLinus Torvalds { 24198d65af78SAlexey Dobriyan return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l); 24201da177e4SLinus Torvalds } 24211da177e4SLinus Torvalds 24221da177e4SLinus Torvalds /** 24231da177e4SLinus Torvalds * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values 24241da177e4SLinus Torvalds * @table: the sysctl table 24251da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 24261da177e4SLinus Torvalds * @buffer: the user buffer 24271da177e4SLinus Torvalds * @lenp: the size of the user buffer 24281da177e4SLinus Torvalds * @ppos: file position 24291da177e4SLinus Torvalds * 24301da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long 24311da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. The values 24321da177e4SLinus Torvalds * are treated as milliseconds, and converted to jiffies when they are stored. 24331da177e4SLinus Torvalds * 24341da177e4SLinus Torvalds * This routine will ensure the values are within the range specified by 24351da177e4SLinus Torvalds * table->extra1 (min) and table->extra2 (max). 24361da177e4SLinus Torvalds * 24371da177e4SLinus Torvalds * Returns 0 on success. 24381da177e4SLinus Torvalds */ 2439d8217f07SEric W. Biederman int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 24401da177e4SLinus Torvalds void __user *buffer, 24411da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 24421da177e4SLinus Torvalds { 24438d65af78SAlexey Dobriyan return do_proc_doulongvec_minmax(table, write, buffer, 24441da177e4SLinus Torvalds lenp, ppos, HZ, 1000l); 24451da177e4SLinus Torvalds } 24461da177e4SLinus Torvalds 24471da177e4SLinus Torvalds 244800b7c339SAmerigo Wang static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp, 24491da177e4SLinus Torvalds int *valp, 24501da177e4SLinus Torvalds int write, void *data) 24511da177e4SLinus Torvalds { 24521da177e4SLinus Torvalds if (write) { 2453cba9f33dSBart Samwel if (*lvalp > LONG_MAX / HZ) 2454cba9f33dSBart Samwel return 1; 24551da177e4SLinus Torvalds *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ); 24561da177e4SLinus Torvalds } else { 24571da177e4SLinus Torvalds int val = *valp; 24581da177e4SLinus Torvalds unsigned long lval; 24591da177e4SLinus Torvalds if (val < 0) { 246000b7c339SAmerigo Wang *negp = true; 24619a5bc726SIlya Dryomov lval = -(unsigned long)val; 24621da177e4SLinus Torvalds } else { 246300b7c339SAmerigo Wang *negp = false; 24641da177e4SLinus Torvalds lval = (unsigned long)val; 24651da177e4SLinus Torvalds } 24661da177e4SLinus Torvalds *lvalp = lval / HZ; 24671da177e4SLinus Torvalds } 24681da177e4SLinus Torvalds return 0; 24691da177e4SLinus Torvalds } 24701da177e4SLinus Torvalds 247100b7c339SAmerigo Wang static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp, 24721da177e4SLinus Torvalds int *valp, 24731da177e4SLinus Torvalds int write, void *data) 24741da177e4SLinus Torvalds { 24751da177e4SLinus Torvalds if (write) { 2476cba9f33dSBart Samwel if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ) 2477cba9f33dSBart Samwel return 1; 24781da177e4SLinus Torvalds *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp); 24791da177e4SLinus Torvalds } else { 24801da177e4SLinus Torvalds int val = *valp; 24811da177e4SLinus Torvalds unsigned long lval; 24821da177e4SLinus Torvalds if (val < 0) { 248300b7c339SAmerigo Wang *negp = true; 24849a5bc726SIlya Dryomov lval = -(unsigned long)val; 24851da177e4SLinus Torvalds } else { 248600b7c339SAmerigo Wang *negp = false; 24871da177e4SLinus Torvalds lval = (unsigned long)val; 24881da177e4SLinus Torvalds } 24891da177e4SLinus Torvalds *lvalp = jiffies_to_clock_t(lval); 24901da177e4SLinus Torvalds } 24911da177e4SLinus Torvalds return 0; 24921da177e4SLinus Torvalds } 24931da177e4SLinus Torvalds 249400b7c339SAmerigo Wang static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp, 24951da177e4SLinus Torvalds int *valp, 24961da177e4SLinus Torvalds int write, void *data) 24971da177e4SLinus Torvalds { 24981da177e4SLinus Torvalds if (write) { 2499d738ce8fSFrancesco Fusco unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp); 2500d738ce8fSFrancesco Fusco 2501d738ce8fSFrancesco Fusco if (jif > INT_MAX) 2502d738ce8fSFrancesco Fusco return 1; 2503d738ce8fSFrancesco Fusco *valp = (int)jif; 25041da177e4SLinus Torvalds } else { 25051da177e4SLinus Torvalds int val = *valp; 25061da177e4SLinus Torvalds unsigned long lval; 25071da177e4SLinus Torvalds if (val < 0) { 250800b7c339SAmerigo Wang *negp = true; 25099a5bc726SIlya Dryomov lval = -(unsigned long)val; 25101da177e4SLinus Torvalds } else { 251100b7c339SAmerigo Wang *negp = false; 25121da177e4SLinus Torvalds lval = (unsigned long)val; 25131da177e4SLinus Torvalds } 25141da177e4SLinus Torvalds *lvalp = jiffies_to_msecs(lval); 25151da177e4SLinus Torvalds } 25161da177e4SLinus Torvalds return 0; 25171da177e4SLinus Torvalds } 25181da177e4SLinus Torvalds 25191da177e4SLinus Torvalds /** 25201da177e4SLinus Torvalds * proc_dointvec_jiffies - read a vector of integers as seconds 25211da177e4SLinus Torvalds * @table: the sysctl table 25221da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 25231da177e4SLinus Torvalds * @buffer: the user buffer 25241da177e4SLinus Torvalds * @lenp: the size of the user buffer 25251da177e4SLinus Torvalds * @ppos: file position 25261da177e4SLinus Torvalds * 25271da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 25281da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. 25291da177e4SLinus Torvalds * The values read are assumed to be in seconds, and are converted into 25301da177e4SLinus Torvalds * jiffies. 25311da177e4SLinus Torvalds * 25321da177e4SLinus Torvalds * Returns 0 on success. 25331da177e4SLinus Torvalds */ 25348d65af78SAlexey Dobriyan int proc_dointvec_jiffies(struct ctl_table *table, int write, 25351da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 25361da177e4SLinus Torvalds { 25378d65af78SAlexey Dobriyan return do_proc_dointvec(table,write,buffer,lenp,ppos, 25381da177e4SLinus Torvalds do_proc_dointvec_jiffies_conv,NULL); 25391da177e4SLinus Torvalds } 25401da177e4SLinus Torvalds 25411da177e4SLinus Torvalds /** 25421da177e4SLinus Torvalds * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds 25431da177e4SLinus Torvalds * @table: the sysctl table 25441da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 25451da177e4SLinus Torvalds * @buffer: the user buffer 25461da177e4SLinus Torvalds * @lenp: the size of the user buffer 25471e5d5331SRandy Dunlap * @ppos: pointer to the file position 25481da177e4SLinus Torvalds * 25491da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 25501da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. 25511da177e4SLinus Torvalds * The values read are assumed to be in 1/USER_HZ seconds, and 25521da177e4SLinus Torvalds * are converted into jiffies. 25531da177e4SLinus Torvalds * 25541da177e4SLinus Torvalds * Returns 0 on success. 25551da177e4SLinus Torvalds */ 25568d65af78SAlexey Dobriyan int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 25571da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 25581da177e4SLinus Torvalds { 25598d65af78SAlexey Dobriyan return do_proc_dointvec(table,write,buffer,lenp,ppos, 25601da177e4SLinus Torvalds do_proc_dointvec_userhz_jiffies_conv,NULL); 25611da177e4SLinus Torvalds } 25621da177e4SLinus Torvalds 25631da177e4SLinus Torvalds /** 25641da177e4SLinus Torvalds * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds 25651da177e4SLinus Torvalds * @table: the sysctl table 25661da177e4SLinus Torvalds * @write: %TRUE if this is a write to the sysctl file 25671da177e4SLinus Torvalds * @buffer: the user buffer 25681da177e4SLinus Torvalds * @lenp: the size of the user buffer 256967be2dd1SMartin Waitz * @ppos: file position 257067be2dd1SMartin Waitz * @ppos: the current position in the file 25711da177e4SLinus Torvalds * 25721da177e4SLinus Torvalds * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 25731da177e4SLinus Torvalds * values from/to the user buffer, treated as an ASCII string. 25741da177e4SLinus Torvalds * The values read are assumed to be in 1/1000 seconds, and 25751da177e4SLinus Torvalds * are converted into jiffies. 25761da177e4SLinus Torvalds * 25771da177e4SLinus Torvalds * Returns 0 on success. 25781da177e4SLinus Torvalds */ 25798d65af78SAlexey Dobriyan int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, 25801da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 25811da177e4SLinus Torvalds { 25828d65af78SAlexey Dobriyan return do_proc_dointvec(table, write, buffer, lenp, ppos, 25831da177e4SLinus Torvalds do_proc_dointvec_ms_jiffies_conv, NULL); 25841da177e4SLinus Torvalds } 25851da177e4SLinus Torvalds 25868d65af78SAlexey Dobriyan static int proc_do_cad_pid(struct ctl_table *table, int write, 25879ec52099SCedric Le Goater void __user *buffer, size_t *lenp, loff_t *ppos) 25889ec52099SCedric Le Goater { 25899ec52099SCedric Le Goater struct pid *new_pid; 25909ec52099SCedric Le Goater pid_t tmp; 25919ec52099SCedric Le Goater int r; 25929ec52099SCedric Le Goater 25936c5f3e7bSPavel Emelyanov tmp = pid_vnr(cad_pid); 25949ec52099SCedric Le Goater 25958d65af78SAlexey Dobriyan r = __do_proc_dointvec(&tmp, table, write, buffer, 25969ec52099SCedric Le Goater lenp, ppos, NULL, NULL); 25979ec52099SCedric Le Goater if (r || !write) 25989ec52099SCedric Le Goater return r; 25999ec52099SCedric Le Goater 26009ec52099SCedric Le Goater new_pid = find_get_pid(tmp); 26019ec52099SCedric Le Goater if (!new_pid) 26029ec52099SCedric Le Goater return -ESRCH; 26039ec52099SCedric Le Goater 26049ec52099SCedric Le Goater put_pid(xchg(&cad_pid, new_pid)); 26059ec52099SCedric Le Goater return 0; 26069ec52099SCedric Le Goater } 26079ec52099SCedric Le Goater 26089f977fb7SOctavian Purdila /** 26099f977fb7SOctavian Purdila * proc_do_large_bitmap - read/write from/to a large bitmap 26109f977fb7SOctavian Purdila * @table: the sysctl table 26119f977fb7SOctavian Purdila * @write: %TRUE if this is a write to the sysctl file 26129f977fb7SOctavian Purdila * @buffer: the user buffer 26139f977fb7SOctavian Purdila * @lenp: the size of the user buffer 26149f977fb7SOctavian Purdila * @ppos: file position 26159f977fb7SOctavian Purdila * 26169f977fb7SOctavian Purdila * The bitmap is stored at table->data and the bitmap length (in bits) 26179f977fb7SOctavian Purdila * in table->maxlen. 26189f977fb7SOctavian Purdila * 26199f977fb7SOctavian Purdila * We use a range comma separated format (e.g. 1,3-4,10-10) so that 26209f977fb7SOctavian Purdila * large bitmaps may be represented in a compact manner. Writing into 26219f977fb7SOctavian Purdila * the file will clear the bitmap then update it with the given input. 26229f977fb7SOctavian Purdila * 26239f977fb7SOctavian Purdila * Returns 0 on success. 26249f977fb7SOctavian Purdila */ 26259f977fb7SOctavian Purdila int proc_do_large_bitmap(struct ctl_table *table, int write, 26269f977fb7SOctavian Purdila void __user *buffer, size_t *lenp, loff_t *ppos) 26279f977fb7SOctavian Purdila { 26289f977fb7SOctavian Purdila int err = 0; 26299f977fb7SOctavian Purdila bool first = 1; 26309f977fb7SOctavian Purdila size_t left = *lenp; 26319f977fb7SOctavian Purdila unsigned long bitmap_len = table->maxlen; 2632122ff243SWANG Cong unsigned long *bitmap = *(unsigned long **) table->data; 26339f977fb7SOctavian Purdila unsigned long *tmp_bitmap = NULL; 26349f977fb7SOctavian Purdila char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c; 26359f977fb7SOctavian Purdila 2636122ff243SWANG Cong if (!bitmap || !bitmap_len || !left || (*ppos && !write)) { 26379f977fb7SOctavian Purdila *lenp = 0; 26389f977fb7SOctavian Purdila return 0; 26399f977fb7SOctavian Purdila } 26409f977fb7SOctavian Purdila 26419f977fb7SOctavian Purdila if (write) { 26429f977fb7SOctavian Purdila unsigned long page = 0; 26439f977fb7SOctavian Purdila char *kbuf; 26449f977fb7SOctavian Purdila 26459f977fb7SOctavian Purdila if (left > PAGE_SIZE - 1) 26469f977fb7SOctavian Purdila left = PAGE_SIZE - 1; 26479f977fb7SOctavian Purdila 26489f977fb7SOctavian Purdila page = __get_free_page(GFP_TEMPORARY); 26499f977fb7SOctavian Purdila kbuf = (char *) page; 26509f977fb7SOctavian Purdila if (!kbuf) 26519f977fb7SOctavian Purdila return -ENOMEM; 26529f977fb7SOctavian Purdila if (copy_from_user(kbuf, buffer, left)) { 26539f977fb7SOctavian Purdila free_page(page); 26549f977fb7SOctavian Purdila return -EFAULT; 26559f977fb7SOctavian Purdila } 26569f977fb7SOctavian Purdila kbuf[left] = 0; 26579f977fb7SOctavian Purdila 26589f977fb7SOctavian Purdila tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long), 26599f977fb7SOctavian Purdila GFP_KERNEL); 26609f977fb7SOctavian Purdila if (!tmp_bitmap) { 26619f977fb7SOctavian Purdila free_page(page); 26629f977fb7SOctavian Purdila return -ENOMEM; 26639f977fb7SOctavian Purdila } 26649f977fb7SOctavian Purdila proc_skip_char(&kbuf, &left, '\n'); 26659f977fb7SOctavian Purdila while (!err && left) { 26669f977fb7SOctavian Purdila unsigned long val_a, val_b; 26679f977fb7SOctavian Purdila bool neg; 26689f977fb7SOctavian Purdila 26699f977fb7SOctavian Purdila err = proc_get_long(&kbuf, &left, &val_a, &neg, tr_a, 26709f977fb7SOctavian Purdila sizeof(tr_a), &c); 26719f977fb7SOctavian Purdila if (err) 26729f977fb7SOctavian Purdila break; 26739f977fb7SOctavian Purdila if (val_a >= bitmap_len || neg) { 26749f977fb7SOctavian Purdila err = -EINVAL; 26759f977fb7SOctavian Purdila break; 26769f977fb7SOctavian Purdila } 26779f977fb7SOctavian Purdila 26789f977fb7SOctavian Purdila val_b = val_a; 26799f977fb7SOctavian Purdila if (left) { 26809f977fb7SOctavian Purdila kbuf++; 26819f977fb7SOctavian Purdila left--; 26829f977fb7SOctavian Purdila } 26839f977fb7SOctavian Purdila 26849f977fb7SOctavian Purdila if (c == '-') { 26859f977fb7SOctavian Purdila err = proc_get_long(&kbuf, &left, &val_b, 26869f977fb7SOctavian Purdila &neg, tr_b, sizeof(tr_b), 26879f977fb7SOctavian Purdila &c); 26889f977fb7SOctavian Purdila if (err) 26899f977fb7SOctavian Purdila break; 26909f977fb7SOctavian Purdila if (val_b >= bitmap_len || neg || 26919f977fb7SOctavian Purdila val_a > val_b) { 26929f977fb7SOctavian Purdila err = -EINVAL; 26939f977fb7SOctavian Purdila break; 26949f977fb7SOctavian Purdila } 26959f977fb7SOctavian Purdila if (left) { 26969f977fb7SOctavian Purdila kbuf++; 26979f977fb7SOctavian Purdila left--; 26989f977fb7SOctavian Purdila } 26999f977fb7SOctavian Purdila } 27009f977fb7SOctavian Purdila 27015a04cca6SAkinobu Mita bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); 27029f977fb7SOctavian Purdila first = 0; 27039f977fb7SOctavian Purdila proc_skip_char(&kbuf, &left, '\n'); 27049f977fb7SOctavian Purdila } 27059f977fb7SOctavian Purdila free_page(page); 27069f977fb7SOctavian Purdila } else { 27079f977fb7SOctavian Purdila unsigned long bit_a, bit_b = 0; 27089f977fb7SOctavian Purdila 27099f977fb7SOctavian Purdila while (left) { 27109f977fb7SOctavian Purdila bit_a = find_next_bit(bitmap, bitmap_len, bit_b); 27119f977fb7SOctavian Purdila if (bit_a >= bitmap_len) 27129f977fb7SOctavian Purdila break; 27139f977fb7SOctavian Purdila bit_b = find_next_zero_bit(bitmap, bitmap_len, 27149f977fb7SOctavian Purdila bit_a + 1) - 1; 27159f977fb7SOctavian Purdila 27169f977fb7SOctavian Purdila if (!first) { 27179f977fb7SOctavian Purdila err = proc_put_char(&buffer, &left, ','); 27189f977fb7SOctavian Purdila if (err) 27199f977fb7SOctavian Purdila break; 27209f977fb7SOctavian Purdila } 27219f977fb7SOctavian Purdila err = proc_put_long(&buffer, &left, bit_a, false); 27229f977fb7SOctavian Purdila if (err) 27239f977fb7SOctavian Purdila break; 27249f977fb7SOctavian Purdila if (bit_a != bit_b) { 27259f977fb7SOctavian Purdila err = proc_put_char(&buffer, &left, '-'); 27269f977fb7SOctavian Purdila if (err) 27279f977fb7SOctavian Purdila break; 27289f977fb7SOctavian Purdila err = proc_put_long(&buffer, &left, bit_b, false); 27299f977fb7SOctavian Purdila if (err) 27309f977fb7SOctavian Purdila break; 27319f977fb7SOctavian Purdila } 27329f977fb7SOctavian Purdila 27339f977fb7SOctavian Purdila first = 0; bit_b++; 27349f977fb7SOctavian Purdila } 27359f977fb7SOctavian Purdila if (!err) 27369f977fb7SOctavian Purdila err = proc_put_char(&buffer, &left, '\n'); 27379f977fb7SOctavian Purdila } 27389f977fb7SOctavian Purdila 27399f977fb7SOctavian Purdila if (!err) { 27409f977fb7SOctavian Purdila if (write) { 27419f977fb7SOctavian Purdila if (*ppos) 27429f977fb7SOctavian Purdila bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len); 27439f977fb7SOctavian Purdila else 27445a04cca6SAkinobu Mita bitmap_copy(bitmap, tmp_bitmap, bitmap_len); 27459f977fb7SOctavian Purdila } 27469f977fb7SOctavian Purdila kfree(tmp_bitmap); 27479f977fb7SOctavian Purdila *lenp -= left; 27489f977fb7SOctavian Purdila *ppos += *lenp; 27499f977fb7SOctavian Purdila return 0; 27509f977fb7SOctavian Purdila } else { 27519f977fb7SOctavian Purdila kfree(tmp_bitmap); 27529f977fb7SOctavian Purdila return err; 27539f977fb7SOctavian Purdila } 27549f977fb7SOctavian Purdila } 27559f977fb7SOctavian Purdila 275655610500SJovi Zhang #else /* CONFIG_PROC_SYSCTL */ 27571da177e4SLinus Torvalds 27588d65af78SAlexey Dobriyan int proc_dostring(struct ctl_table *table, int write, 27591da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27601da177e4SLinus Torvalds { 27611da177e4SLinus Torvalds return -ENOSYS; 27621da177e4SLinus Torvalds } 27631da177e4SLinus Torvalds 27648d65af78SAlexey Dobriyan int proc_dointvec(struct ctl_table *table, int write, 27651da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27661da177e4SLinus Torvalds { 27671da177e4SLinus Torvalds return -ENOSYS; 27681da177e4SLinus Torvalds } 27691da177e4SLinus Torvalds 27708d65af78SAlexey Dobriyan int proc_dointvec_minmax(struct ctl_table *table, int write, 27711da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27721da177e4SLinus Torvalds { 27731da177e4SLinus Torvalds return -ENOSYS; 27741da177e4SLinus Torvalds } 27751da177e4SLinus Torvalds 27768d65af78SAlexey Dobriyan int proc_dointvec_jiffies(struct ctl_table *table, int write, 27771da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27781da177e4SLinus Torvalds { 27791da177e4SLinus Torvalds return -ENOSYS; 27801da177e4SLinus Torvalds } 27811da177e4SLinus Torvalds 27828d65af78SAlexey Dobriyan int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 27831da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27841da177e4SLinus Torvalds { 27851da177e4SLinus Torvalds return -ENOSYS; 27861da177e4SLinus Torvalds } 27871da177e4SLinus Torvalds 27888d65af78SAlexey Dobriyan int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, 27891da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27901da177e4SLinus Torvalds { 27911da177e4SLinus Torvalds return -ENOSYS; 27921da177e4SLinus Torvalds } 27931da177e4SLinus Torvalds 27948d65af78SAlexey Dobriyan int proc_doulongvec_minmax(struct ctl_table *table, int write, 27951da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 27961da177e4SLinus Torvalds { 27971da177e4SLinus Torvalds return -ENOSYS; 27981da177e4SLinus Torvalds } 27991da177e4SLinus Torvalds 2800d8217f07SEric W. Biederman int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 28011da177e4SLinus Torvalds void __user *buffer, 28021da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 28031da177e4SLinus Torvalds { 28041da177e4SLinus Torvalds return -ENOSYS; 28051da177e4SLinus Torvalds } 28061da177e4SLinus Torvalds 28071da177e4SLinus Torvalds 280855610500SJovi Zhang #endif /* CONFIG_PROC_SYSCTL */ 28091da177e4SLinus Torvalds 28101da177e4SLinus Torvalds /* 28111da177e4SLinus Torvalds * No sense putting this after each symbol definition, twice, 28121da177e4SLinus Torvalds * exception granted :-) 28131da177e4SLinus Torvalds */ 28141da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec); 28151da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_jiffies); 28161da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_minmax); 28171da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_userhz_jiffies); 28181da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_ms_jiffies); 28191da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dostring); 28201da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_minmax); 28211da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax); 2822