1457c8996SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * sysctl.c: General linux system control interface 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Begun 24 March 1995, Stephen Tweedie 61da177e4SLinus Torvalds * Added /proc support, Dec 1995 71da177e4SLinus Torvalds * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas. 81da177e4SLinus Torvalds * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver. 91da177e4SLinus Torvalds * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver. 101da177e4SLinus Torvalds * Dynamic registration fixes, Stephen Tweedie. 111da177e4SLinus Torvalds * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn. 121da177e4SLinus Torvalds * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris 131da177e4SLinus Torvalds * Horn. 141da177e4SLinus Torvalds * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer. 151da177e4SLinus Torvalds * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer. 161da177e4SLinus Torvalds * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill 171da177e4SLinus Torvalds * Wendling. 181da177e4SLinus Torvalds * The list_for_each() macro wasn't appropriate for the sysctl loop. 191da177e4SLinus Torvalds * Removed it and replaced it with older style, 03/23/00, Bill Wendling 201da177e4SLinus Torvalds */ 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #include <linux/module.h> 23e2e40f2cSChristoph Hellwig #include <linux/aio.h> 241da177e4SLinus Torvalds #include <linux/mm.h> 251da177e4SLinus Torvalds #include <linux/swap.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/sysctl.h> 285a04cca6SAkinobu Mita #include <linux/bitmap.h> 29d33ed52dSDave Young #include <linux/signal.h> 30455cd5abSDan Rosenberg #include <linux/printk.h> 311da177e4SLinus Torvalds #include <linux/proc_fs.h> 3272c2d582SAndrew Morgan #include <linux/security.h> 331da177e4SLinus Torvalds #include <linux/ctype.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> 66f7ccbae4SIngo Molnar #include <linux/sched/coredump.h> 677984754bSKees Cook #include <linux/kexec.h> 681be7f75dSAlexei Starovoitov #include <linux/bpf.h> 69d2921684SEric W. Biederman #include <linux/mount.h> 70cefdca0aSPeter Xu #include <linux/userfaultfd_k.h> 712374c09bSChristoph Hellwig #include <linux/coredump.h> 722374c09bSChristoph Hellwig #include <linux/latencytop.h> 732374c09bSChristoph Hellwig #include <linux/pid.h> 741da177e4SLinus Torvalds 757f2923c4SChristian Brauner #include "../lib/kstrtox.h" 767f2923c4SChristian Brauner 777c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 781da177e4SLinus Torvalds #include <asm/processor.h> 791da177e4SLinus Torvalds 8029cbc78bSAndi Kleen #ifdef CONFIG_X86 8129cbc78bSAndi Kleen #include <asm/nmi.h> 820741f4d2SChuck Ebbert #include <asm/stacktrace.h> 836e7c4025SIngo Molnar #include <asm/io.h> 8429cbc78bSAndi Kleen #endif 85d550bbd4SDavid Howells #ifdef CONFIG_SPARC 86d550bbd4SDavid Howells #include <asm/setup.h> 87d550bbd4SDavid Howells #endif 88c55b7c3eSDave Young #ifdef CONFIG_BSD_PROCESS_ACCT 89c55b7c3eSDave Young #include <linux/acct.h> 90c55b7c3eSDave Young #endif 914f0e056fSDave Young #ifdef CONFIG_RT_MUTEXES 924f0e056fSDave Young #include <linux/rtmutex.h> 934f0e056fSDave Young #endif 942edf5e49SDave Young #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT) 952edf5e49SDave Young #include <linux/lockdep.h> 962edf5e49SDave Young #endif 9715485a46SDave Young #ifdef CONFIG_CHR_DEV_SG 9815485a46SDave Young #include <scsi/sg.h> 9915485a46SDave Young #endif 100964c9dffSAlexander Popov #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE 101964c9dffSAlexander Popov #include <linux/stackleak.h> 102964c9dffSAlexander Popov #endif 10358687acbSDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR 104504d7cf1SDon Zickus #include <linux/nmi.h> 105504d7cf1SDon Zickus #endif 106504d7cf1SDon Zickus 1071da177e4SLinus Torvalds #if defined(CONFIG_SYSCTL) 1081da177e4SLinus Torvalds 109c4f3b63fSRavikiran G Thirumalai /* Constants used for minimum and maximum */ 1102508ce18SDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR 111c4f3b63fSRavikiran G Thirumalai static int sixty = 60; 112c4f3b63fSRavikiran G Thirumalai #endif 113c4f3b63fSRavikiran G Thirumalai 114270750dbSAaron Tomlin static int __maybe_unused neg_one = -1; 115cd5f9a4cSLinus Torvalds static int __maybe_unused two = 2; 1165509a5d2SDave Hansen static int __maybe_unused four = 4; 1179002b214SWill Deacon static unsigned long zero_ul; 118fc3501d4SSven Wegener static unsigned long one_ul = 1; 11932a5ad9cSChristian Brauner static unsigned long long_max = LONG_MAX; 120c4f3b63fSRavikiran G Thirumalai static int one_hundred = 100; 121c843966cSJohannes Weiner static int two_hundred = 200; 122795ae7a0SJohannes Weiner static int one_thousand = 1000; 123af91322eSDave Young #ifdef CONFIG_PRINTK 124af91322eSDave Young static int ten_thousand = 10000; 125af91322eSDave Young #endif 126c5dfd78eSArnaldo Carvalho de Melo #ifdef CONFIG_PERF_EVENTS 127c5dfd78eSArnaldo Carvalho de Melo static int six_hundred_forty_kb = 640 * 1024; 128c5dfd78eSArnaldo Carvalho de Melo #endif 129c4f3b63fSRavikiran G Thirumalai 1309e4a5bdaSAndrea Righi /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */ 1319e4a5bdaSAndrea Righi static unsigned long dirty_bytes_min = 2 * PAGE_SIZE; 1329e4a5bdaSAndrea Righi 1331da177e4SLinus Torvalds /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */ 1341da177e4SLinus Torvalds static int maxolduid = 65535; 1351da177e4SLinus Torvalds static int minolduid; 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds static int ngroups_max = NGROUPS_MAX; 13873efc039SDan Ballard static const int cap_last_cap = CAP_LAST_CAP; 1391da177e4SLinus Torvalds 140a2e51445SDmitry Vyukov /* 141a2e51445SDmitry Vyukov * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs 142a2e51445SDmitry Vyukov * and hung_task_check_interval_secs 143a2e51445SDmitry Vyukov */ 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 151b6fca725SVineet Gupta 152d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL 153f4aacea2SKees Cook 154a19ac337SLuis R. Rodriguez /** 155a19ac337SLuis R. Rodriguez * enum sysctl_writes_mode - supported sysctl write modes 156a19ac337SLuis R. Rodriguez * 157a19ac337SLuis R. Rodriguez * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value 158a19ac337SLuis R. Rodriguez * to be written, and multiple writes on the same sysctl file descriptor 159a19ac337SLuis R. Rodriguez * will rewrite the sysctl value, regardless of file position. No warning 160a19ac337SLuis R. Rodriguez * is issued when the initial position is not 0. 161a19ac337SLuis R. Rodriguez * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is 162a19ac337SLuis R. Rodriguez * not 0. 163a19ac337SLuis R. Rodriguez * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at 164a19ac337SLuis R. Rodriguez * file position 0 and the value must be fully contained in the buffer 165a19ac337SLuis R. Rodriguez * sent to the write syscall. If dealing with strings respect the file 166a19ac337SLuis R. Rodriguez * position, but restrict this to the max length of the buffer, anything 16765f50f25SWeitao Hou * passed the max length will be ignored. Multiple writes will append 168a19ac337SLuis R. Rodriguez * to the buffer. 169a19ac337SLuis R. Rodriguez * 170a19ac337SLuis R. Rodriguez * These write modes control how current file position affects the behavior of 171a19ac337SLuis R. Rodriguez * updating sysctl values through the proc interface on each write. 172a19ac337SLuis R. Rodriguez */ 173a19ac337SLuis R. Rodriguez enum sysctl_writes_mode { 174a19ac337SLuis R. Rodriguez SYSCTL_WRITES_LEGACY = -1, 175a19ac337SLuis R. Rodriguez SYSCTL_WRITES_WARN = 0, 176a19ac337SLuis R. Rodriguez SYSCTL_WRITES_STRICT = 1, 177a19ac337SLuis R. Rodriguez }; 178f4aacea2SKees Cook 179a19ac337SLuis R. Rodriguez static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT; 180f461d2dcSChristoph Hellwig #endif /* CONFIG_PROC_SYSCTL */ 181ceb18132SLuis R. Rodriguez 18267f3977fSAlexandre Ghiti #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \ 18367f3977fSAlexandre Ghiti defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT) 1841da177e4SLinus Torvalds int sysctl_legacy_va_layout; 1851da177e4SLinus Torvalds #endif 1861da177e4SLinus Torvalds 18777e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 18873c4efd2SEric Dumazet static int min_sched_granularity_ns = 100000; /* 100 usecs */ 18973c4efd2SEric Dumazet static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */ 19073c4efd2SEric Dumazet static int min_wakeup_granularity_ns; /* 0 usecs */ 19173c4efd2SEric Dumazet static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */ 192cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP 1931983a922SChristian Ehrhardt static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE; 1941983a922SChristian Ehrhardt static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1; 195cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */ 196cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */ 19777e54a1fSIngo Molnar 1985e771905SMel Gorman #ifdef CONFIG_COMPACTION 1995e771905SMel Gorman static int min_extfrag_threshold; 2005e771905SMel Gorman static int max_extfrag_threshold = 1000; 2015e771905SMel Gorman #endif 2025e771905SMel Gorman 203f461d2dcSChristoph Hellwig #endif /* CONFIG_SYSCTL */ 204f461d2dcSChristoph Hellwig 2055447e8e0SArnd Bergmann #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_SYSCTL) 206d46edd67SSong Liu static int bpf_stats_handler(struct ctl_table *table, int write, 207d46edd67SSong Liu void __user *buffer, size_t *lenp, 208d46edd67SSong Liu loff_t *ppos) 209d46edd67SSong Liu { 210d46edd67SSong Liu struct static_key *key = (struct static_key *)table->data; 211d46edd67SSong Liu static int saved_val; 212d46edd67SSong Liu int val, ret; 213d46edd67SSong Liu struct ctl_table tmp = { 214d46edd67SSong Liu .data = &val, 215d46edd67SSong Liu .maxlen = sizeof(val), 216d46edd67SSong Liu .mode = table->mode, 217d46edd67SSong Liu .extra1 = SYSCTL_ZERO, 218d46edd67SSong Liu .extra2 = SYSCTL_ONE, 219d46edd67SSong Liu }; 220d46edd67SSong Liu 221d46edd67SSong Liu if (write && !capable(CAP_SYS_ADMIN)) 222d46edd67SSong Liu return -EPERM; 223d46edd67SSong Liu 224d46edd67SSong Liu mutex_lock(&bpf_stats_enabled_mutex); 225d46edd67SSong Liu val = saved_val; 226d46edd67SSong Liu ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 227d46edd67SSong Liu if (write && !ret && val != saved_val) { 228d46edd67SSong Liu if (val) 229d46edd67SSong Liu static_key_slow_inc(key); 230d46edd67SSong Liu else 231d46edd67SSong Liu static_key_slow_dec(key); 232d46edd67SSong Liu saved_val = val; 233d46edd67SSong Liu } 234d46edd67SSong Liu mutex_unlock(&bpf_stats_enabled_mutex); 235d46edd67SSong Liu return ret; 236d46edd67SSong Liu } 237d46edd67SSong Liu #endif 238d46edd67SSong Liu 239f461d2dcSChristoph Hellwig /* 240f461d2dcSChristoph Hellwig * /proc/sys support 241f461d2dcSChristoph Hellwig */ 242f461d2dcSChristoph Hellwig 243f461d2dcSChristoph Hellwig #ifdef CONFIG_PROC_SYSCTL 244f461d2dcSChristoph Hellwig 245f461d2dcSChristoph Hellwig static int _proc_do_string(char *data, int maxlen, int write, 24632927393SChristoph Hellwig char *buffer, size_t *lenp, loff_t *ppos) 247f461d2dcSChristoph Hellwig { 248f461d2dcSChristoph Hellwig size_t len; 24932927393SChristoph Hellwig char c, *p; 250f461d2dcSChristoph Hellwig 251f461d2dcSChristoph Hellwig if (!data || !maxlen || !*lenp) { 252f461d2dcSChristoph Hellwig *lenp = 0; 253f461d2dcSChristoph Hellwig return 0; 254f461d2dcSChristoph Hellwig } 255f461d2dcSChristoph Hellwig 256f461d2dcSChristoph Hellwig if (write) { 257f461d2dcSChristoph Hellwig if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) { 258f461d2dcSChristoph Hellwig /* Only continue writes not past the end of buffer. */ 259f461d2dcSChristoph Hellwig len = strlen(data); 260f461d2dcSChristoph Hellwig if (len > maxlen - 1) 261f461d2dcSChristoph Hellwig len = maxlen - 1; 262f461d2dcSChristoph Hellwig 263f461d2dcSChristoph Hellwig if (*ppos > len) 264f461d2dcSChristoph Hellwig return 0; 265f461d2dcSChristoph Hellwig len = *ppos; 266f461d2dcSChristoph Hellwig } else { 267f461d2dcSChristoph Hellwig /* Start writing from beginning of buffer. */ 268f461d2dcSChristoph Hellwig len = 0; 269f461d2dcSChristoph Hellwig } 270f461d2dcSChristoph Hellwig 271f461d2dcSChristoph Hellwig *ppos += *lenp; 272f461d2dcSChristoph Hellwig p = buffer; 273f461d2dcSChristoph Hellwig while ((p - buffer) < *lenp && len < maxlen - 1) { 27432927393SChristoph Hellwig c = *(p++); 275f461d2dcSChristoph Hellwig if (c == 0 || c == '\n') 276f461d2dcSChristoph Hellwig break; 277f461d2dcSChristoph Hellwig data[len++] = c; 278f461d2dcSChristoph Hellwig } 279f461d2dcSChristoph Hellwig data[len] = 0; 280f461d2dcSChristoph Hellwig } else { 281f461d2dcSChristoph Hellwig len = strlen(data); 282f461d2dcSChristoph Hellwig if (len > maxlen) 283f461d2dcSChristoph Hellwig len = maxlen; 284f461d2dcSChristoph Hellwig 285f461d2dcSChristoph Hellwig if (*ppos > len) { 286f461d2dcSChristoph Hellwig *lenp = 0; 287f461d2dcSChristoph Hellwig return 0; 288f461d2dcSChristoph Hellwig } 289f461d2dcSChristoph Hellwig 290f461d2dcSChristoph Hellwig data += *ppos; 291f461d2dcSChristoph Hellwig len -= *ppos; 292f461d2dcSChristoph Hellwig 293f461d2dcSChristoph Hellwig if (len > *lenp) 294f461d2dcSChristoph Hellwig len = *lenp; 295f461d2dcSChristoph Hellwig if (len) 29632927393SChristoph Hellwig memcpy(buffer, data, len); 297f461d2dcSChristoph Hellwig if (len < *lenp) { 29832927393SChristoph Hellwig buffer[len] = '\n'; 299f461d2dcSChristoph Hellwig len++; 300f461d2dcSChristoph Hellwig } 301f461d2dcSChristoph Hellwig *lenp = len; 302f461d2dcSChristoph Hellwig *ppos += len; 303f461d2dcSChristoph Hellwig } 304f461d2dcSChristoph Hellwig return 0; 305f461d2dcSChristoph Hellwig } 306f461d2dcSChristoph Hellwig 307f461d2dcSChristoph Hellwig static void warn_sysctl_write(struct ctl_table *table) 308f461d2dcSChristoph Hellwig { 309f461d2dcSChristoph Hellwig pr_warn_once("%s wrote to %s when file position was not 0!\n" 310f461d2dcSChristoph Hellwig "This will not be supported in the future. To silence this\n" 311f461d2dcSChristoph Hellwig "warning, set kernel.sysctl_writes_strict = -1\n", 312f461d2dcSChristoph Hellwig current->comm, table->procname); 313f461d2dcSChristoph Hellwig } 314f461d2dcSChristoph Hellwig 315f461d2dcSChristoph Hellwig /** 316f461d2dcSChristoph Hellwig * proc_first_pos_non_zero_ignore - check if first position is allowed 317f461d2dcSChristoph Hellwig * @ppos: file position 318f461d2dcSChristoph Hellwig * @table: the sysctl table 319f461d2dcSChristoph Hellwig * 320f461d2dcSChristoph Hellwig * Returns true if the first position is non-zero and the sysctl_writes_strict 321f461d2dcSChristoph Hellwig * mode indicates this is not allowed for numeric input types. String proc 322f461d2dcSChristoph Hellwig * handlers can ignore the return value. 323f461d2dcSChristoph Hellwig */ 324f461d2dcSChristoph Hellwig static bool proc_first_pos_non_zero_ignore(loff_t *ppos, 325f461d2dcSChristoph Hellwig struct ctl_table *table) 326f461d2dcSChristoph Hellwig { 327f461d2dcSChristoph Hellwig if (!*ppos) 328f461d2dcSChristoph Hellwig return false; 329f461d2dcSChristoph Hellwig 330f461d2dcSChristoph Hellwig switch (sysctl_writes_strict) { 331f461d2dcSChristoph Hellwig case SYSCTL_WRITES_STRICT: 332f461d2dcSChristoph Hellwig return true; 333f461d2dcSChristoph Hellwig case SYSCTL_WRITES_WARN: 334f461d2dcSChristoph Hellwig warn_sysctl_write(table); 335f461d2dcSChristoph Hellwig return false; 336f461d2dcSChristoph Hellwig default: 337f461d2dcSChristoph Hellwig return false; 338f461d2dcSChristoph Hellwig } 339f461d2dcSChristoph Hellwig } 340f461d2dcSChristoph Hellwig 341f461d2dcSChristoph Hellwig /** 342f461d2dcSChristoph Hellwig * proc_dostring - read a string sysctl 343f461d2dcSChristoph Hellwig * @table: the sysctl table 344f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 345f461d2dcSChristoph Hellwig * @buffer: the user buffer 346f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 347f461d2dcSChristoph Hellwig * @ppos: file position 348f461d2dcSChristoph Hellwig * 349f461d2dcSChristoph Hellwig * Reads/writes a string from/to the user buffer. If the kernel 350f461d2dcSChristoph Hellwig * buffer provided is not large enough to hold the string, the 351f461d2dcSChristoph Hellwig * string is truncated. The copied string is %NULL-terminated. 352f461d2dcSChristoph Hellwig * If the string is being read by the user process, it is copied 353f461d2dcSChristoph Hellwig * and a newline '\n' is added. It is truncated if the buffer is 354f461d2dcSChristoph Hellwig * not large enough. 355f461d2dcSChristoph Hellwig * 356f461d2dcSChristoph Hellwig * Returns 0 on success. 357f461d2dcSChristoph Hellwig */ 358f461d2dcSChristoph Hellwig int proc_dostring(struct ctl_table *table, int write, 35932927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 360f461d2dcSChristoph Hellwig { 361f461d2dcSChristoph Hellwig if (write) 362f461d2dcSChristoph Hellwig proc_first_pos_non_zero_ignore(ppos, table); 363f461d2dcSChristoph Hellwig 36432927393SChristoph Hellwig return _proc_do_string(table->data, table->maxlen, write, buffer, lenp, 36532927393SChristoph Hellwig ppos); 366f461d2dcSChristoph Hellwig } 367f461d2dcSChristoph Hellwig 368f461d2dcSChristoph Hellwig static size_t proc_skip_spaces(char **buf) 369f461d2dcSChristoph Hellwig { 370f461d2dcSChristoph Hellwig size_t ret; 371f461d2dcSChristoph Hellwig char *tmp = skip_spaces(*buf); 372f461d2dcSChristoph Hellwig ret = tmp - *buf; 373f461d2dcSChristoph Hellwig *buf = tmp; 374f461d2dcSChristoph Hellwig return ret; 375f461d2dcSChristoph Hellwig } 376f461d2dcSChristoph Hellwig 377f461d2dcSChristoph Hellwig static void proc_skip_char(char **buf, size_t *size, const char v) 378f461d2dcSChristoph Hellwig { 379f461d2dcSChristoph Hellwig while (*size) { 380f461d2dcSChristoph Hellwig if (**buf != v) 381f461d2dcSChristoph Hellwig break; 382f461d2dcSChristoph Hellwig (*size)--; 383f461d2dcSChristoph Hellwig (*buf)++; 384f461d2dcSChristoph Hellwig } 385f461d2dcSChristoph Hellwig } 386f461d2dcSChristoph Hellwig 387f461d2dcSChristoph Hellwig /** 388f461d2dcSChristoph Hellwig * strtoul_lenient - parse an ASCII formatted integer from a buffer and only 389f461d2dcSChristoph Hellwig * fail on overflow 390f461d2dcSChristoph Hellwig * 391f461d2dcSChristoph Hellwig * @cp: kernel buffer containing the string to parse 392f461d2dcSChristoph Hellwig * @endp: pointer to store the trailing characters 393f461d2dcSChristoph Hellwig * @base: the base to use 394f461d2dcSChristoph Hellwig * @res: where the parsed integer will be stored 395f461d2dcSChristoph Hellwig * 396f461d2dcSChristoph Hellwig * In case of success 0 is returned and @res will contain the parsed integer, 397f461d2dcSChristoph Hellwig * @endp will hold any trailing characters. 398f461d2dcSChristoph Hellwig * This function will fail the parse on overflow. If there wasn't an overflow 399f461d2dcSChristoph Hellwig * the function will defer the decision what characters count as invalid to the 400f461d2dcSChristoph Hellwig * caller. 401f461d2dcSChristoph Hellwig */ 402f461d2dcSChristoph Hellwig static int strtoul_lenient(const char *cp, char **endp, unsigned int base, 403f461d2dcSChristoph Hellwig unsigned long *res) 404f461d2dcSChristoph Hellwig { 405f461d2dcSChristoph Hellwig unsigned long long result; 406f461d2dcSChristoph Hellwig unsigned int rv; 407f461d2dcSChristoph Hellwig 408f461d2dcSChristoph Hellwig cp = _parse_integer_fixup_radix(cp, &base); 409f461d2dcSChristoph Hellwig rv = _parse_integer(cp, base, &result); 410f461d2dcSChristoph Hellwig if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result)) 411f461d2dcSChristoph Hellwig return -ERANGE; 412f461d2dcSChristoph Hellwig 413f461d2dcSChristoph Hellwig cp += rv; 414f461d2dcSChristoph Hellwig 415f461d2dcSChristoph Hellwig if (endp) 416f461d2dcSChristoph Hellwig *endp = (char *)cp; 417f461d2dcSChristoph Hellwig 418f461d2dcSChristoph Hellwig *res = (unsigned long)result; 419f461d2dcSChristoph Hellwig return 0; 420f461d2dcSChristoph Hellwig } 421f461d2dcSChristoph Hellwig 422f461d2dcSChristoph Hellwig #define TMPBUFLEN 22 423f461d2dcSChristoph Hellwig /** 424f461d2dcSChristoph Hellwig * proc_get_long - reads an ASCII formatted integer from a user buffer 425f461d2dcSChristoph Hellwig * 426f461d2dcSChristoph Hellwig * @buf: a kernel buffer 427f461d2dcSChristoph Hellwig * @size: size of the kernel buffer 428f461d2dcSChristoph Hellwig * @val: this is where the number will be stored 429f461d2dcSChristoph Hellwig * @neg: set to %TRUE if number is negative 430f461d2dcSChristoph Hellwig * @perm_tr: a vector which contains the allowed trailers 431f461d2dcSChristoph Hellwig * @perm_tr_len: size of the perm_tr vector 432f461d2dcSChristoph Hellwig * @tr: pointer to store the trailer character 433f461d2dcSChristoph Hellwig * 434f461d2dcSChristoph Hellwig * In case of success %0 is returned and @buf and @size are updated with 435f461d2dcSChristoph Hellwig * the amount of bytes read. If @tr is non-NULL and a trailing 436f461d2dcSChristoph Hellwig * character exists (size is non-zero after returning from this 437f461d2dcSChristoph Hellwig * function), @tr is updated with the trailing character. 438f461d2dcSChristoph Hellwig */ 439f461d2dcSChristoph Hellwig static int proc_get_long(char **buf, size_t *size, 440f461d2dcSChristoph Hellwig unsigned long *val, bool *neg, 441f461d2dcSChristoph Hellwig const char *perm_tr, unsigned perm_tr_len, char *tr) 442f461d2dcSChristoph Hellwig { 443f461d2dcSChristoph Hellwig int len; 444f461d2dcSChristoph Hellwig char *p, tmp[TMPBUFLEN]; 445f461d2dcSChristoph Hellwig 446f461d2dcSChristoph Hellwig if (!*size) 447f461d2dcSChristoph Hellwig return -EINVAL; 448f461d2dcSChristoph Hellwig 449f461d2dcSChristoph Hellwig len = *size; 450f461d2dcSChristoph Hellwig if (len > TMPBUFLEN - 1) 451f461d2dcSChristoph Hellwig len = TMPBUFLEN - 1; 452f461d2dcSChristoph Hellwig 453f461d2dcSChristoph Hellwig memcpy(tmp, *buf, len); 454f461d2dcSChristoph Hellwig 455f461d2dcSChristoph Hellwig tmp[len] = 0; 456f461d2dcSChristoph Hellwig p = tmp; 457f461d2dcSChristoph Hellwig if (*p == '-' && *size > 1) { 458f461d2dcSChristoph Hellwig *neg = true; 459f461d2dcSChristoph Hellwig p++; 460f461d2dcSChristoph Hellwig } else 461f461d2dcSChristoph Hellwig *neg = false; 462f461d2dcSChristoph Hellwig if (!isdigit(*p)) 463f461d2dcSChristoph Hellwig return -EINVAL; 464f461d2dcSChristoph Hellwig 465f461d2dcSChristoph Hellwig if (strtoul_lenient(p, &p, 0, val)) 466f461d2dcSChristoph Hellwig return -EINVAL; 467f461d2dcSChristoph Hellwig 468f461d2dcSChristoph Hellwig len = p - tmp; 469f461d2dcSChristoph Hellwig 470f461d2dcSChristoph Hellwig /* We don't know if the next char is whitespace thus we may accept 471f461d2dcSChristoph Hellwig * invalid integers (e.g. 1234...a) or two integers instead of one 472f461d2dcSChristoph Hellwig * (e.g. 123...1). So lets not allow such large numbers. */ 473f461d2dcSChristoph Hellwig if (len == TMPBUFLEN - 1) 474f461d2dcSChristoph Hellwig return -EINVAL; 475f461d2dcSChristoph Hellwig 476f461d2dcSChristoph Hellwig if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len)) 477f461d2dcSChristoph Hellwig return -EINVAL; 478f461d2dcSChristoph Hellwig 479f461d2dcSChristoph Hellwig if (tr && (len < *size)) 480f461d2dcSChristoph Hellwig *tr = *p; 481f461d2dcSChristoph Hellwig 482f461d2dcSChristoph Hellwig *buf += len; 483f461d2dcSChristoph Hellwig *size -= len; 484f461d2dcSChristoph Hellwig 485f461d2dcSChristoph Hellwig return 0; 486f461d2dcSChristoph Hellwig } 487f461d2dcSChristoph Hellwig 488f461d2dcSChristoph Hellwig /** 489f461d2dcSChristoph Hellwig * proc_put_long - converts an integer to a decimal ASCII formatted string 490f461d2dcSChristoph Hellwig * 491f461d2dcSChristoph Hellwig * @buf: the user buffer 492f461d2dcSChristoph Hellwig * @size: the size of the user buffer 493f461d2dcSChristoph Hellwig * @val: the integer to be converted 494f461d2dcSChristoph Hellwig * @neg: sign of the number, %TRUE for negative 495f461d2dcSChristoph Hellwig * 49632927393SChristoph Hellwig * In case of success @buf and @size are updated with the amount of bytes 49732927393SChristoph Hellwig * written. 498f461d2dcSChristoph Hellwig */ 49932927393SChristoph Hellwig static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg) 500f461d2dcSChristoph Hellwig { 501f461d2dcSChristoph Hellwig int len; 502f461d2dcSChristoph Hellwig char tmp[TMPBUFLEN], *p = tmp; 503f461d2dcSChristoph Hellwig 504f461d2dcSChristoph Hellwig sprintf(p, "%s%lu", neg ? "-" : "", val); 505f461d2dcSChristoph Hellwig len = strlen(tmp); 506f461d2dcSChristoph Hellwig if (len > *size) 507f461d2dcSChristoph Hellwig len = *size; 50832927393SChristoph Hellwig memcpy(*buf, tmp, len); 509f461d2dcSChristoph Hellwig *size -= len; 510f461d2dcSChristoph Hellwig *buf += len; 511f461d2dcSChristoph Hellwig } 512f461d2dcSChristoph Hellwig #undef TMPBUFLEN 513f461d2dcSChristoph Hellwig 51432927393SChristoph Hellwig static void proc_put_char(void **buf, size_t *size, char c) 515f461d2dcSChristoph Hellwig { 516f461d2dcSChristoph Hellwig if (*size) { 51732927393SChristoph Hellwig char **buffer = (char **)buf; 51832927393SChristoph Hellwig **buffer = c; 51932927393SChristoph Hellwig 52032927393SChristoph Hellwig (*size)--; 52132927393SChristoph Hellwig (*buffer)++; 522f461d2dcSChristoph Hellwig *buf = *buffer; 523f461d2dcSChristoph Hellwig } 524f461d2dcSChristoph Hellwig } 525f461d2dcSChristoph Hellwig 526f461d2dcSChristoph Hellwig static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp, 527f461d2dcSChristoph Hellwig int *valp, 528f461d2dcSChristoph Hellwig int write, void *data) 529f461d2dcSChristoph Hellwig { 530f461d2dcSChristoph Hellwig if (write) { 531f461d2dcSChristoph Hellwig if (*negp) { 532f461d2dcSChristoph Hellwig if (*lvalp > (unsigned long) INT_MAX + 1) 533f461d2dcSChristoph Hellwig return -EINVAL; 534f461d2dcSChristoph Hellwig *valp = -*lvalp; 535f461d2dcSChristoph Hellwig } else { 536f461d2dcSChristoph Hellwig if (*lvalp > (unsigned long) INT_MAX) 537f461d2dcSChristoph Hellwig return -EINVAL; 538f461d2dcSChristoph Hellwig *valp = *lvalp; 539f461d2dcSChristoph Hellwig } 540f461d2dcSChristoph Hellwig } else { 541f461d2dcSChristoph Hellwig int val = *valp; 542f461d2dcSChristoph Hellwig if (val < 0) { 543f461d2dcSChristoph Hellwig *negp = true; 544f461d2dcSChristoph Hellwig *lvalp = -(unsigned long)val; 545f461d2dcSChristoph Hellwig } else { 546f461d2dcSChristoph Hellwig *negp = false; 547f461d2dcSChristoph Hellwig *lvalp = (unsigned long)val; 548f461d2dcSChristoph Hellwig } 549f461d2dcSChristoph Hellwig } 550f461d2dcSChristoph Hellwig return 0; 551f461d2dcSChristoph Hellwig } 552f461d2dcSChristoph Hellwig 553f461d2dcSChristoph Hellwig static int do_proc_douintvec_conv(unsigned long *lvalp, 554f461d2dcSChristoph Hellwig unsigned int *valp, 555f461d2dcSChristoph Hellwig int write, void *data) 556f461d2dcSChristoph Hellwig { 557f461d2dcSChristoph Hellwig if (write) { 558f461d2dcSChristoph Hellwig if (*lvalp > UINT_MAX) 559f461d2dcSChristoph Hellwig return -EINVAL; 560f461d2dcSChristoph Hellwig *valp = *lvalp; 561f461d2dcSChristoph Hellwig } else { 562f461d2dcSChristoph Hellwig unsigned int val = *valp; 563f461d2dcSChristoph Hellwig *lvalp = (unsigned long)val; 564f461d2dcSChristoph Hellwig } 565f461d2dcSChristoph Hellwig return 0; 566f461d2dcSChristoph Hellwig } 567f461d2dcSChristoph Hellwig 568f461d2dcSChristoph Hellwig static const char proc_wspace_sep[] = { ' ', '\t', '\n' }; 569f461d2dcSChristoph Hellwig 570f461d2dcSChristoph Hellwig static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table, 57132927393SChristoph Hellwig int write, void *buffer, 572f461d2dcSChristoph Hellwig size_t *lenp, loff_t *ppos, 573f461d2dcSChristoph Hellwig int (*conv)(bool *negp, unsigned long *lvalp, int *valp, 574f461d2dcSChristoph Hellwig int write, void *data), 575f461d2dcSChristoph Hellwig void *data) 576f461d2dcSChristoph Hellwig { 577f461d2dcSChristoph Hellwig int *i, vleft, first = 1, err = 0; 578f461d2dcSChristoph Hellwig size_t left; 57932927393SChristoph Hellwig char *p; 580f461d2dcSChristoph Hellwig 581f461d2dcSChristoph Hellwig if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) { 582f461d2dcSChristoph Hellwig *lenp = 0; 583f461d2dcSChristoph Hellwig return 0; 584f461d2dcSChristoph Hellwig } 585f461d2dcSChristoph Hellwig 586f461d2dcSChristoph Hellwig i = (int *) tbl_data; 587f461d2dcSChristoph Hellwig vleft = table->maxlen / sizeof(*i); 588f461d2dcSChristoph Hellwig left = *lenp; 589f461d2dcSChristoph Hellwig 590f461d2dcSChristoph Hellwig if (!conv) 591f461d2dcSChristoph Hellwig conv = do_proc_dointvec_conv; 592f461d2dcSChristoph Hellwig 593f461d2dcSChristoph Hellwig if (write) { 594f461d2dcSChristoph Hellwig if (proc_first_pos_non_zero_ignore(ppos, table)) 595f461d2dcSChristoph Hellwig goto out; 596f461d2dcSChristoph Hellwig 597f461d2dcSChristoph Hellwig if (left > PAGE_SIZE - 1) 598f461d2dcSChristoph Hellwig left = PAGE_SIZE - 1; 59932927393SChristoph Hellwig p = buffer; 600f461d2dcSChristoph Hellwig } 601f461d2dcSChristoph Hellwig 602f461d2dcSChristoph Hellwig for (; left && vleft--; i++, first=0) { 603f461d2dcSChristoph Hellwig unsigned long lval; 604f461d2dcSChristoph Hellwig bool neg; 605f461d2dcSChristoph Hellwig 606f461d2dcSChristoph Hellwig if (write) { 607f461d2dcSChristoph Hellwig left -= proc_skip_spaces(&p); 608f461d2dcSChristoph Hellwig 609f461d2dcSChristoph Hellwig if (!left) 610f461d2dcSChristoph Hellwig break; 611f461d2dcSChristoph Hellwig err = proc_get_long(&p, &left, &lval, &neg, 612f461d2dcSChristoph Hellwig proc_wspace_sep, 613f461d2dcSChristoph Hellwig sizeof(proc_wspace_sep), NULL); 614f461d2dcSChristoph Hellwig if (err) 615f461d2dcSChristoph Hellwig break; 616f461d2dcSChristoph Hellwig if (conv(&neg, &lval, i, 1, data)) { 617f461d2dcSChristoph Hellwig err = -EINVAL; 618f461d2dcSChristoph Hellwig break; 619f461d2dcSChristoph Hellwig } 620f461d2dcSChristoph Hellwig } else { 621f461d2dcSChristoph Hellwig if (conv(&neg, &lval, i, 0, data)) { 622f461d2dcSChristoph Hellwig err = -EINVAL; 623f461d2dcSChristoph Hellwig break; 624f461d2dcSChristoph Hellwig } 625f461d2dcSChristoph Hellwig if (!first) 62632927393SChristoph Hellwig proc_put_char(&buffer, &left, '\t'); 62732927393SChristoph Hellwig proc_put_long(&buffer, &left, lval, neg); 628f461d2dcSChristoph Hellwig } 629f461d2dcSChristoph Hellwig } 630f461d2dcSChristoph Hellwig 631f461d2dcSChristoph Hellwig if (!write && !first && left && !err) 63232927393SChristoph Hellwig proc_put_char(&buffer, &left, '\n'); 633f461d2dcSChristoph Hellwig if (write && !err && left) 634f461d2dcSChristoph Hellwig left -= proc_skip_spaces(&p); 63532927393SChristoph Hellwig if (write && first) 636f461d2dcSChristoph Hellwig return err ? : -EINVAL; 637f461d2dcSChristoph Hellwig *lenp -= left; 638f461d2dcSChristoph Hellwig out: 639f461d2dcSChristoph Hellwig *ppos += *lenp; 640f461d2dcSChristoph Hellwig return err; 641f461d2dcSChristoph Hellwig } 642f461d2dcSChristoph Hellwig 643f461d2dcSChristoph Hellwig static int do_proc_dointvec(struct ctl_table *table, int write, 64432927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos, 645f461d2dcSChristoph Hellwig int (*conv)(bool *negp, unsigned long *lvalp, int *valp, 646f461d2dcSChristoph Hellwig int write, void *data), 647f461d2dcSChristoph Hellwig void *data) 648f461d2dcSChristoph Hellwig { 649f461d2dcSChristoph Hellwig return __do_proc_dointvec(table->data, table, write, 650f461d2dcSChristoph Hellwig buffer, lenp, ppos, conv, data); 651f461d2dcSChristoph Hellwig } 652f461d2dcSChristoph Hellwig 653f461d2dcSChristoph Hellwig static int do_proc_douintvec_w(unsigned int *tbl_data, 654f461d2dcSChristoph Hellwig struct ctl_table *table, 65532927393SChristoph Hellwig void *buffer, 656f461d2dcSChristoph Hellwig size_t *lenp, loff_t *ppos, 657f461d2dcSChristoph Hellwig int (*conv)(unsigned long *lvalp, 658f461d2dcSChristoph Hellwig unsigned int *valp, 659f461d2dcSChristoph Hellwig int write, void *data), 660f461d2dcSChristoph Hellwig void *data) 661f461d2dcSChristoph Hellwig { 662f461d2dcSChristoph Hellwig unsigned long lval; 663f461d2dcSChristoph Hellwig int err = 0; 664f461d2dcSChristoph Hellwig size_t left; 665f461d2dcSChristoph Hellwig bool neg; 66632927393SChristoph Hellwig char *p = buffer; 667f461d2dcSChristoph Hellwig 668f461d2dcSChristoph Hellwig left = *lenp; 669f461d2dcSChristoph Hellwig 670f461d2dcSChristoph Hellwig if (proc_first_pos_non_zero_ignore(ppos, table)) 671f461d2dcSChristoph Hellwig goto bail_early; 672f461d2dcSChristoph Hellwig 673f461d2dcSChristoph Hellwig if (left > PAGE_SIZE - 1) 674f461d2dcSChristoph Hellwig left = PAGE_SIZE - 1; 675f461d2dcSChristoph Hellwig 676f461d2dcSChristoph Hellwig left -= proc_skip_spaces(&p); 677f461d2dcSChristoph Hellwig if (!left) { 678f461d2dcSChristoph Hellwig err = -EINVAL; 679f461d2dcSChristoph Hellwig goto out_free; 680f461d2dcSChristoph Hellwig } 681f461d2dcSChristoph Hellwig 682f461d2dcSChristoph Hellwig err = proc_get_long(&p, &left, &lval, &neg, 683f461d2dcSChristoph Hellwig proc_wspace_sep, 684f461d2dcSChristoph Hellwig sizeof(proc_wspace_sep), NULL); 685f461d2dcSChristoph Hellwig if (err || neg) { 686f461d2dcSChristoph Hellwig err = -EINVAL; 687f461d2dcSChristoph Hellwig goto out_free; 688f461d2dcSChristoph Hellwig } 689f461d2dcSChristoph Hellwig 690f461d2dcSChristoph Hellwig if (conv(&lval, tbl_data, 1, data)) { 691f461d2dcSChristoph Hellwig err = -EINVAL; 692f461d2dcSChristoph Hellwig goto out_free; 693f461d2dcSChristoph Hellwig } 694f461d2dcSChristoph Hellwig 695f461d2dcSChristoph Hellwig if (!err && left) 696f461d2dcSChristoph Hellwig left -= proc_skip_spaces(&p); 697f461d2dcSChristoph Hellwig 698f461d2dcSChristoph Hellwig out_free: 699f461d2dcSChristoph Hellwig if (err) 700f461d2dcSChristoph Hellwig return -EINVAL; 701f461d2dcSChristoph Hellwig 702f461d2dcSChristoph Hellwig return 0; 703f461d2dcSChristoph Hellwig 704f461d2dcSChristoph Hellwig /* This is in keeping with old __do_proc_dointvec() */ 705f461d2dcSChristoph Hellwig bail_early: 706f461d2dcSChristoph Hellwig *ppos += *lenp; 707f461d2dcSChristoph Hellwig return err; 708f461d2dcSChristoph Hellwig } 709f461d2dcSChristoph Hellwig 71032927393SChristoph Hellwig static int do_proc_douintvec_r(unsigned int *tbl_data, void *buffer, 711f461d2dcSChristoph Hellwig size_t *lenp, loff_t *ppos, 712f461d2dcSChristoph Hellwig int (*conv)(unsigned long *lvalp, 713f461d2dcSChristoph Hellwig unsigned int *valp, 714f461d2dcSChristoph Hellwig int write, void *data), 715f461d2dcSChristoph Hellwig void *data) 716f461d2dcSChristoph Hellwig { 717f461d2dcSChristoph Hellwig unsigned long lval; 718f461d2dcSChristoph Hellwig int err = 0; 719f461d2dcSChristoph Hellwig size_t left; 720f461d2dcSChristoph Hellwig 721f461d2dcSChristoph Hellwig left = *lenp; 722f461d2dcSChristoph Hellwig 723f461d2dcSChristoph Hellwig if (conv(&lval, tbl_data, 0, data)) { 724f461d2dcSChristoph Hellwig err = -EINVAL; 725f461d2dcSChristoph Hellwig goto out; 726f461d2dcSChristoph Hellwig } 727f461d2dcSChristoph Hellwig 72832927393SChristoph Hellwig proc_put_long(&buffer, &left, lval, false); 72932927393SChristoph Hellwig if (!left) 730f461d2dcSChristoph Hellwig goto out; 731f461d2dcSChristoph Hellwig 73232927393SChristoph Hellwig proc_put_char(&buffer, &left, '\n'); 733f461d2dcSChristoph Hellwig 734f461d2dcSChristoph Hellwig out: 735f461d2dcSChristoph Hellwig *lenp -= left; 736f461d2dcSChristoph Hellwig *ppos += *lenp; 737f461d2dcSChristoph Hellwig 738f461d2dcSChristoph Hellwig return err; 739f461d2dcSChristoph Hellwig } 740f461d2dcSChristoph Hellwig 741f461d2dcSChristoph Hellwig static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table, 74232927393SChristoph Hellwig int write, void *buffer, 743f461d2dcSChristoph Hellwig size_t *lenp, loff_t *ppos, 744f461d2dcSChristoph Hellwig int (*conv)(unsigned long *lvalp, 745f461d2dcSChristoph Hellwig unsigned int *valp, 746f461d2dcSChristoph Hellwig int write, void *data), 747f461d2dcSChristoph Hellwig void *data) 748f461d2dcSChristoph Hellwig { 749f461d2dcSChristoph Hellwig unsigned int *i, vleft; 750f461d2dcSChristoph Hellwig 751f461d2dcSChristoph Hellwig if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) { 752f461d2dcSChristoph Hellwig *lenp = 0; 753f461d2dcSChristoph Hellwig return 0; 754f461d2dcSChristoph Hellwig } 755f461d2dcSChristoph Hellwig 756f461d2dcSChristoph Hellwig i = (unsigned int *) tbl_data; 757f461d2dcSChristoph Hellwig vleft = table->maxlen / sizeof(*i); 758f461d2dcSChristoph Hellwig 759f461d2dcSChristoph Hellwig /* 760f461d2dcSChristoph Hellwig * Arrays are not supported, keep this simple. *Do not* add 761f461d2dcSChristoph Hellwig * support for them. 762f461d2dcSChristoph Hellwig */ 763f461d2dcSChristoph Hellwig if (vleft != 1) { 764f461d2dcSChristoph Hellwig *lenp = 0; 765f461d2dcSChristoph Hellwig return -EINVAL; 766f461d2dcSChristoph Hellwig } 767f461d2dcSChristoph Hellwig 768f461d2dcSChristoph Hellwig if (!conv) 769f461d2dcSChristoph Hellwig conv = do_proc_douintvec_conv; 770f461d2dcSChristoph Hellwig 771f461d2dcSChristoph Hellwig if (write) 772f461d2dcSChristoph Hellwig return do_proc_douintvec_w(i, table, buffer, lenp, ppos, 773f461d2dcSChristoph Hellwig conv, data); 774f461d2dcSChristoph Hellwig return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data); 775f461d2dcSChristoph Hellwig } 776f461d2dcSChristoph Hellwig 777f461d2dcSChristoph Hellwig static int do_proc_douintvec(struct ctl_table *table, int write, 77832927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos, 779f461d2dcSChristoph Hellwig int (*conv)(unsigned long *lvalp, 780f461d2dcSChristoph Hellwig unsigned int *valp, 781f461d2dcSChristoph Hellwig int write, void *data), 782f461d2dcSChristoph Hellwig void *data) 783f461d2dcSChristoph Hellwig { 784f461d2dcSChristoph Hellwig return __do_proc_douintvec(table->data, table, write, 785f461d2dcSChristoph Hellwig buffer, lenp, ppos, conv, data); 786f461d2dcSChristoph Hellwig } 787f461d2dcSChristoph Hellwig 788f461d2dcSChristoph Hellwig /** 789f461d2dcSChristoph Hellwig * proc_dointvec - read a vector of integers 790f461d2dcSChristoph Hellwig * @table: the sysctl table 791f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 792f461d2dcSChristoph Hellwig * @buffer: the user buffer 793f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 794f461d2dcSChristoph Hellwig * @ppos: file position 795f461d2dcSChristoph Hellwig * 796f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 797f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 798f461d2dcSChristoph Hellwig * 799f461d2dcSChristoph Hellwig * Returns 0 on success. 800f461d2dcSChristoph Hellwig */ 80132927393SChristoph Hellwig int proc_dointvec(struct ctl_table *table, int write, void *buffer, 80232927393SChristoph Hellwig size_t *lenp, loff_t *ppos) 803f461d2dcSChristoph Hellwig { 804f461d2dcSChristoph Hellwig return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL); 805f461d2dcSChristoph Hellwig } 806f461d2dcSChristoph Hellwig 807f461d2dcSChristoph Hellwig #ifdef CONFIG_COMPACTION 808f461d2dcSChristoph Hellwig static int proc_dointvec_minmax_warn_RT_change(struct ctl_table *table, 80932927393SChristoph Hellwig int write, void *buffer, size_t *lenp, loff_t *ppos) 810f461d2dcSChristoph Hellwig { 811f461d2dcSChristoph Hellwig int ret, old; 812f461d2dcSChristoph Hellwig 813f461d2dcSChristoph Hellwig if (!IS_ENABLED(CONFIG_PREEMPT_RT) || !write) 814f461d2dcSChristoph Hellwig return proc_dointvec_minmax(table, write, buffer, lenp, ppos); 815f461d2dcSChristoph Hellwig 816f461d2dcSChristoph Hellwig old = *(int *)table->data; 817f461d2dcSChristoph Hellwig ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 818f461d2dcSChristoph Hellwig if (ret) 819f461d2dcSChristoph Hellwig return ret; 820f461d2dcSChristoph Hellwig if (old != *(int *)table->data) 821f461d2dcSChristoph Hellwig pr_warn_once("sysctl attribute %s changed by %s[%d]\n", 822f461d2dcSChristoph Hellwig table->procname, current->comm, 823f461d2dcSChristoph Hellwig task_pid_nr(current)); 824f461d2dcSChristoph Hellwig return ret; 825f461d2dcSChristoph Hellwig } 826f461d2dcSChristoph Hellwig #endif 827f461d2dcSChristoph Hellwig 828f461d2dcSChristoph Hellwig /** 829f461d2dcSChristoph Hellwig * proc_douintvec - read a vector of unsigned integers 830f461d2dcSChristoph Hellwig * @table: the sysctl table 831f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 832f461d2dcSChristoph Hellwig * @buffer: the user buffer 833f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 834f461d2dcSChristoph Hellwig * @ppos: file position 835f461d2dcSChristoph Hellwig * 836f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer 837f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 838f461d2dcSChristoph Hellwig * 839f461d2dcSChristoph Hellwig * Returns 0 on success. 840f461d2dcSChristoph Hellwig */ 84132927393SChristoph Hellwig int proc_douintvec(struct ctl_table *table, int write, void *buffer, 84232927393SChristoph Hellwig size_t *lenp, loff_t *ppos) 843f461d2dcSChristoph Hellwig { 844f461d2dcSChristoph Hellwig return do_proc_douintvec(table, write, buffer, lenp, ppos, 845f461d2dcSChristoph Hellwig do_proc_douintvec_conv, NULL); 846f461d2dcSChristoph Hellwig } 847f461d2dcSChristoph Hellwig 848f461d2dcSChristoph Hellwig /* 849f461d2dcSChristoph Hellwig * Taint values can only be increased 850f461d2dcSChristoph Hellwig * This means we can safely use a temporary. 851f461d2dcSChristoph Hellwig */ 852f461d2dcSChristoph Hellwig static int proc_taint(struct ctl_table *table, int write, 85332927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 854f461d2dcSChristoph Hellwig { 855f461d2dcSChristoph Hellwig struct ctl_table t; 856f461d2dcSChristoph Hellwig unsigned long tmptaint = get_taint(); 857f461d2dcSChristoph Hellwig int err; 858f461d2dcSChristoph Hellwig 859f461d2dcSChristoph Hellwig if (write && !capable(CAP_SYS_ADMIN)) 860f461d2dcSChristoph Hellwig return -EPERM; 861f461d2dcSChristoph Hellwig 862f461d2dcSChristoph Hellwig t = *table; 863f461d2dcSChristoph Hellwig t.data = &tmptaint; 864f461d2dcSChristoph Hellwig err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos); 865f461d2dcSChristoph Hellwig if (err < 0) 866f461d2dcSChristoph Hellwig return err; 867f461d2dcSChristoph Hellwig 868f461d2dcSChristoph Hellwig if (write) { 869db38d5c1SRafael Aquini int i; 870db38d5c1SRafael Aquini 871db38d5c1SRafael Aquini /* 872db38d5c1SRafael Aquini * If we are relying on panic_on_taint not producing 873db38d5c1SRafael Aquini * false positives due to userspace input, bail out 874db38d5c1SRafael Aquini * before setting the requested taint flags. 875db38d5c1SRafael Aquini */ 876db38d5c1SRafael Aquini if (panic_on_taint_nousertaint && (tmptaint & panic_on_taint)) 877db38d5c1SRafael Aquini return -EINVAL; 878db38d5c1SRafael Aquini 879f461d2dcSChristoph Hellwig /* 880f461d2dcSChristoph Hellwig * Poor man's atomic or. Not worth adding a primitive 881f461d2dcSChristoph Hellwig * to everyone's atomic.h for this 882f461d2dcSChristoph Hellwig */ 883f461d2dcSChristoph Hellwig for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) { 884f461d2dcSChristoph Hellwig if ((tmptaint >> i) & 1) 885f461d2dcSChristoph Hellwig add_taint(i, LOCKDEP_STILL_OK); 886f461d2dcSChristoph Hellwig } 887f461d2dcSChristoph Hellwig } 888f461d2dcSChristoph Hellwig 889f461d2dcSChristoph Hellwig return err; 890f461d2dcSChristoph Hellwig } 891f461d2dcSChristoph Hellwig 892f461d2dcSChristoph Hellwig #ifdef CONFIG_PRINTK 893f461d2dcSChristoph Hellwig static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write, 89432927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 895f461d2dcSChristoph Hellwig { 896f461d2dcSChristoph Hellwig if (write && !capable(CAP_SYS_ADMIN)) 897f461d2dcSChristoph Hellwig return -EPERM; 898f461d2dcSChristoph Hellwig 899f461d2dcSChristoph Hellwig return proc_dointvec_minmax(table, write, buffer, lenp, ppos); 900f461d2dcSChristoph Hellwig } 901f461d2dcSChristoph Hellwig #endif 902f461d2dcSChristoph Hellwig 903f461d2dcSChristoph Hellwig /** 904f461d2dcSChristoph Hellwig * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure 905f461d2dcSChristoph Hellwig * @min: pointer to minimum allowable value 906f461d2dcSChristoph Hellwig * @max: pointer to maximum allowable value 907f461d2dcSChristoph Hellwig * 908f461d2dcSChristoph Hellwig * The do_proc_dointvec_minmax_conv_param structure provides the 909f461d2dcSChristoph Hellwig * minimum and maximum values for doing range checking for those sysctl 910f461d2dcSChristoph Hellwig * parameters that use the proc_dointvec_minmax() handler. 911f461d2dcSChristoph Hellwig */ 912f461d2dcSChristoph Hellwig struct do_proc_dointvec_minmax_conv_param { 913f461d2dcSChristoph Hellwig int *min; 914f461d2dcSChristoph Hellwig int *max; 915f461d2dcSChristoph Hellwig }; 916f461d2dcSChristoph Hellwig 917f461d2dcSChristoph Hellwig static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp, 918f461d2dcSChristoph Hellwig int *valp, 919f461d2dcSChristoph Hellwig int write, void *data) 920f461d2dcSChristoph Hellwig { 921f461d2dcSChristoph Hellwig int tmp, ret; 922f461d2dcSChristoph Hellwig struct do_proc_dointvec_minmax_conv_param *param = data; 923f461d2dcSChristoph Hellwig /* 924f461d2dcSChristoph Hellwig * If writing, first do so via a temporary local int so we can 925f461d2dcSChristoph Hellwig * bounds-check it before touching *valp. 926f461d2dcSChristoph Hellwig */ 927f461d2dcSChristoph Hellwig int *ip = write ? &tmp : valp; 928f461d2dcSChristoph Hellwig 929f461d2dcSChristoph Hellwig ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data); 930f461d2dcSChristoph Hellwig if (ret) 931f461d2dcSChristoph Hellwig return ret; 932f461d2dcSChristoph Hellwig 933f461d2dcSChristoph Hellwig if (write) { 934f461d2dcSChristoph Hellwig if ((param->min && *param->min > tmp) || 935f461d2dcSChristoph Hellwig (param->max && *param->max < tmp)) 936f461d2dcSChristoph Hellwig return -EINVAL; 937f461d2dcSChristoph Hellwig *valp = tmp; 938f461d2dcSChristoph Hellwig } 939f461d2dcSChristoph Hellwig 940f461d2dcSChristoph Hellwig return 0; 941f461d2dcSChristoph Hellwig } 942f461d2dcSChristoph Hellwig 943f461d2dcSChristoph Hellwig /** 944f461d2dcSChristoph Hellwig * proc_dointvec_minmax - read a vector of integers with min/max values 945f461d2dcSChristoph Hellwig * @table: the sysctl table 946f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 947f461d2dcSChristoph Hellwig * @buffer: the user buffer 948f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 949f461d2dcSChristoph Hellwig * @ppos: file position 950f461d2dcSChristoph Hellwig * 951f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 952f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 953f461d2dcSChristoph Hellwig * 954f461d2dcSChristoph Hellwig * This routine will ensure the values are within the range specified by 955f461d2dcSChristoph Hellwig * table->extra1 (min) and table->extra2 (max). 956f461d2dcSChristoph Hellwig * 957f461d2dcSChristoph Hellwig * Returns 0 on success or -EINVAL on write when the range check fails. 958f461d2dcSChristoph Hellwig */ 959f461d2dcSChristoph Hellwig int proc_dointvec_minmax(struct ctl_table *table, int write, 96032927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 961f461d2dcSChristoph Hellwig { 962f461d2dcSChristoph Hellwig struct do_proc_dointvec_minmax_conv_param param = { 963f461d2dcSChristoph Hellwig .min = (int *) table->extra1, 964f461d2dcSChristoph Hellwig .max = (int *) table->extra2, 965f461d2dcSChristoph Hellwig }; 966f461d2dcSChristoph Hellwig return do_proc_dointvec(table, write, buffer, lenp, ppos, 967f461d2dcSChristoph Hellwig do_proc_dointvec_minmax_conv, ¶m); 968f461d2dcSChristoph Hellwig } 969f461d2dcSChristoph Hellwig 970f461d2dcSChristoph Hellwig /** 971f461d2dcSChristoph Hellwig * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure 972f461d2dcSChristoph Hellwig * @min: pointer to minimum allowable value 973f461d2dcSChristoph Hellwig * @max: pointer to maximum allowable value 974f461d2dcSChristoph Hellwig * 975f461d2dcSChristoph Hellwig * The do_proc_douintvec_minmax_conv_param structure provides the 976f461d2dcSChristoph Hellwig * minimum and maximum values for doing range checking for those sysctl 977f461d2dcSChristoph Hellwig * parameters that use the proc_douintvec_minmax() handler. 978f461d2dcSChristoph Hellwig */ 979f461d2dcSChristoph Hellwig struct do_proc_douintvec_minmax_conv_param { 980f461d2dcSChristoph Hellwig unsigned int *min; 981f461d2dcSChristoph Hellwig unsigned int *max; 982f461d2dcSChristoph Hellwig }; 983f461d2dcSChristoph Hellwig 984f461d2dcSChristoph Hellwig static int do_proc_douintvec_minmax_conv(unsigned long *lvalp, 985f461d2dcSChristoph Hellwig unsigned int *valp, 986f461d2dcSChristoph Hellwig int write, void *data) 987f461d2dcSChristoph Hellwig { 988f461d2dcSChristoph Hellwig int ret; 989f461d2dcSChristoph Hellwig unsigned int tmp; 990f461d2dcSChristoph Hellwig struct do_proc_douintvec_minmax_conv_param *param = data; 991f461d2dcSChristoph Hellwig /* write via temporary local uint for bounds-checking */ 992f461d2dcSChristoph Hellwig unsigned int *up = write ? &tmp : valp; 993f461d2dcSChristoph Hellwig 994f461d2dcSChristoph Hellwig ret = do_proc_douintvec_conv(lvalp, up, write, data); 995f461d2dcSChristoph Hellwig if (ret) 996f461d2dcSChristoph Hellwig return ret; 997f461d2dcSChristoph Hellwig 998f461d2dcSChristoph Hellwig if (write) { 999f461d2dcSChristoph Hellwig if ((param->min && *param->min > tmp) || 1000f461d2dcSChristoph Hellwig (param->max && *param->max < tmp)) 1001f461d2dcSChristoph Hellwig return -ERANGE; 1002f461d2dcSChristoph Hellwig 1003f461d2dcSChristoph Hellwig *valp = tmp; 1004f461d2dcSChristoph Hellwig } 1005f461d2dcSChristoph Hellwig 1006f461d2dcSChristoph Hellwig return 0; 1007f461d2dcSChristoph Hellwig } 1008f461d2dcSChristoph Hellwig 1009f461d2dcSChristoph Hellwig /** 1010f461d2dcSChristoph Hellwig * proc_douintvec_minmax - read a vector of unsigned ints with min/max values 1011f461d2dcSChristoph Hellwig * @table: the sysctl table 1012f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1013f461d2dcSChristoph Hellwig * @buffer: the user buffer 1014f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1015f461d2dcSChristoph Hellwig * @ppos: file position 1016f461d2dcSChristoph Hellwig * 1017f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer 1018f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. Negative 1019f461d2dcSChristoph Hellwig * strings are not allowed. 1020f461d2dcSChristoph Hellwig * 1021f461d2dcSChristoph Hellwig * This routine will ensure the values are within the range specified by 1022f461d2dcSChristoph Hellwig * table->extra1 (min) and table->extra2 (max). There is a final sanity 1023f461d2dcSChristoph Hellwig * check for UINT_MAX to avoid having to support wrap around uses from 1024f461d2dcSChristoph Hellwig * userspace. 1025f461d2dcSChristoph Hellwig * 1026f461d2dcSChristoph Hellwig * Returns 0 on success or -ERANGE on write when the range check fails. 1027f461d2dcSChristoph Hellwig */ 1028f461d2dcSChristoph Hellwig int proc_douintvec_minmax(struct ctl_table *table, int write, 102932927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1030f461d2dcSChristoph Hellwig { 1031f461d2dcSChristoph Hellwig struct do_proc_douintvec_minmax_conv_param param = { 1032f461d2dcSChristoph Hellwig .min = (unsigned int *) table->extra1, 1033f461d2dcSChristoph Hellwig .max = (unsigned int *) table->extra2, 1034f461d2dcSChristoph Hellwig }; 1035f461d2dcSChristoph Hellwig return do_proc_douintvec(table, write, buffer, lenp, ppos, 1036f461d2dcSChristoph Hellwig do_proc_douintvec_minmax_conv, ¶m); 1037f461d2dcSChristoph Hellwig } 1038f461d2dcSChristoph Hellwig 1039f461d2dcSChristoph Hellwig static int do_proc_dopipe_max_size_conv(unsigned long *lvalp, 1040f461d2dcSChristoph Hellwig unsigned int *valp, 1041f461d2dcSChristoph Hellwig int write, void *data) 1042f461d2dcSChristoph Hellwig { 1043f461d2dcSChristoph Hellwig if (write) { 1044f461d2dcSChristoph Hellwig unsigned int val; 1045f461d2dcSChristoph Hellwig 1046f461d2dcSChristoph Hellwig val = round_pipe_size(*lvalp); 1047f461d2dcSChristoph Hellwig if (val == 0) 1048f461d2dcSChristoph Hellwig return -EINVAL; 1049f461d2dcSChristoph Hellwig 1050f461d2dcSChristoph Hellwig *valp = val; 1051f461d2dcSChristoph Hellwig } else { 1052f461d2dcSChristoph Hellwig unsigned int val = *valp; 1053f461d2dcSChristoph Hellwig *lvalp = (unsigned long) val; 1054f461d2dcSChristoph Hellwig } 1055f461d2dcSChristoph Hellwig 1056f461d2dcSChristoph Hellwig return 0; 1057f461d2dcSChristoph Hellwig } 1058f461d2dcSChristoph Hellwig 1059f461d2dcSChristoph Hellwig static int proc_dopipe_max_size(struct ctl_table *table, int write, 106032927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1061f461d2dcSChristoph Hellwig { 1062f461d2dcSChristoph Hellwig return do_proc_douintvec(table, write, buffer, lenp, ppos, 1063f461d2dcSChristoph Hellwig do_proc_dopipe_max_size_conv, NULL); 1064f461d2dcSChristoph Hellwig } 1065f461d2dcSChristoph Hellwig 1066f461d2dcSChristoph Hellwig static void validate_coredump_safety(void) 1067f461d2dcSChristoph Hellwig { 1068f461d2dcSChristoph Hellwig #ifdef CONFIG_COREDUMP 1069f461d2dcSChristoph Hellwig if (suid_dumpable == SUID_DUMP_ROOT && 1070f461d2dcSChristoph Hellwig core_pattern[0] != '/' && core_pattern[0] != '|') { 1071f461d2dcSChristoph Hellwig printk(KERN_WARNING 1072f461d2dcSChristoph Hellwig "Unsafe core_pattern used with fs.suid_dumpable=2.\n" 1073f461d2dcSChristoph Hellwig "Pipe handler or fully qualified core dump path required.\n" 1074f461d2dcSChristoph Hellwig "Set kernel.core_pattern before fs.suid_dumpable.\n" 1075f461d2dcSChristoph Hellwig ); 1076f461d2dcSChristoph Hellwig } 1077f461d2dcSChristoph Hellwig #endif 1078f461d2dcSChristoph Hellwig } 1079f461d2dcSChristoph Hellwig 1080f461d2dcSChristoph Hellwig static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write, 108132927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1082f461d2dcSChristoph Hellwig { 1083f461d2dcSChristoph Hellwig int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 1084f461d2dcSChristoph Hellwig if (!error) 1085f461d2dcSChristoph Hellwig validate_coredump_safety(); 1086f461d2dcSChristoph Hellwig return error; 1087f461d2dcSChristoph Hellwig } 1088f461d2dcSChristoph Hellwig 1089f461d2dcSChristoph Hellwig #ifdef CONFIG_COREDUMP 1090f461d2dcSChristoph Hellwig static int proc_dostring_coredump(struct ctl_table *table, int write, 109132927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1092f461d2dcSChristoph Hellwig { 1093f461d2dcSChristoph Hellwig int error = proc_dostring(table, write, buffer, lenp, ppos); 1094f461d2dcSChristoph Hellwig if (!error) 1095f461d2dcSChristoph Hellwig validate_coredump_safety(); 1096f461d2dcSChristoph Hellwig return error; 1097f461d2dcSChristoph Hellwig } 1098f461d2dcSChristoph Hellwig #endif 1099f461d2dcSChristoph Hellwig 1100f461d2dcSChristoph Hellwig #ifdef CONFIG_MAGIC_SYSRQ 1101f461d2dcSChristoph Hellwig static int sysrq_sysctl_handler(struct ctl_table *table, int write, 110232927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1103f461d2dcSChristoph Hellwig { 1104f461d2dcSChristoph Hellwig int tmp, ret; 1105f461d2dcSChristoph Hellwig 1106f461d2dcSChristoph Hellwig tmp = sysrq_mask(); 1107f461d2dcSChristoph Hellwig 1108f461d2dcSChristoph Hellwig ret = __do_proc_dointvec(&tmp, table, write, buffer, 1109f461d2dcSChristoph Hellwig lenp, ppos, NULL, NULL); 1110f461d2dcSChristoph Hellwig if (ret || !write) 1111f461d2dcSChristoph Hellwig return ret; 1112f461d2dcSChristoph Hellwig 1113f461d2dcSChristoph Hellwig if (write) 1114f461d2dcSChristoph Hellwig sysrq_toggle_support(tmp); 1115f461d2dcSChristoph Hellwig 1116f461d2dcSChristoph Hellwig return 0; 1117f461d2dcSChristoph Hellwig } 1118f461d2dcSChristoph Hellwig #endif 1119f461d2dcSChristoph Hellwig 112032927393SChristoph Hellwig static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, 112132927393SChristoph Hellwig int write, void *buffer, size_t *lenp, loff_t *ppos, 112232927393SChristoph Hellwig unsigned long convmul, unsigned long convdiv) 1123f461d2dcSChristoph Hellwig { 1124f461d2dcSChristoph Hellwig unsigned long *i, *min, *max; 1125f461d2dcSChristoph Hellwig int vleft, first = 1, err = 0; 1126f461d2dcSChristoph Hellwig size_t left; 112732927393SChristoph Hellwig char *p; 1128f461d2dcSChristoph Hellwig 1129f461d2dcSChristoph Hellwig if (!data || !table->maxlen || !*lenp || (*ppos && !write)) { 1130f461d2dcSChristoph Hellwig *lenp = 0; 1131f461d2dcSChristoph Hellwig return 0; 1132f461d2dcSChristoph Hellwig } 1133f461d2dcSChristoph Hellwig 1134f461d2dcSChristoph Hellwig i = (unsigned long *) data; 1135f461d2dcSChristoph Hellwig min = (unsigned long *) table->extra1; 1136f461d2dcSChristoph Hellwig max = (unsigned long *) table->extra2; 1137f461d2dcSChristoph Hellwig vleft = table->maxlen / sizeof(unsigned long); 1138f461d2dcSChristoph Hellwig left = *lenp; 1139f461d2dcSChristoph Hellwig 1140f461d2dcSChristoph Hellwig if (write) { 1141f461d2dcSChristoph Hellwig if (proc_first_pos_non_zero_ignore(ppos, table)) 1142f461d2dcSChristoph Hellwig goto out; 1143f461d2dcSChristoph Hellwig 1144f461d2dcSChristoph Hellwig if (left > PAGE_SIZE - 1) 1145f461d2dcSChristoph Hellwig left = PAGE_SIZE - 1; 114632927393SChristoph Hellwig p = buffer; 1147f461d2dcSChristoph Hellwig } 1148f461d2dcSChristoph Hellwig 1149f461d2dcSChristoph Hellwig for (; left && vleft--; i++, first = 0) { 1150f461d2dcSChristoph Hellwig unsigned long val; 1151f461d2dcSChristoph Hellwig 1152f461d2dcSChristoph Hellwig if (write) { 1153f461d2dcSChristoph Hellwig bool neg; 1154f461d2dcSChristoph Hellwig 1155f461d2dcSChristoph Hellwig left -= proc_skip_spaces(&p); 1156f461d2dcSChristoph Hellwig if (!left) 1157f461d2dcSChristoph Hellwig break; 1158f461d2dcSChristoph Hellwig 1159f461d2dcSChristoph Hellwig err = proc_get_long(&p, &left, &val, &neg, 1160f461d2dcSChristoph Hellwig proc_wspace_sep, 1161f461d2dcSChristoph Hellwig sizeof(proc_wspace_sep), NULL); 1162f461d2dcSChristoph Hellwig if (err) 1163f461d2dcSChristoph Hellwig break; 1164f461d2dcSChristoph Hellwig if (neg) 1165f461d2dcSChristoph Hellwig continue; 1166f461d2dcSChristoph Hellwig val = convmul * val / convdiv; 1167f461d2dcSChristoph Hellwig if ((min && val < *min) || (max && val > *max)) { 1168f461d2dcSChristoph Hellwig err = -EINVAL; 1169f461d2dcSChristoph Hellwig break; 1170f461d2dcSChristoph Hellwig } 1171f461d2dcSChristoph Hellwig *i = val; 1172f461d2dcSChristoph Hellwig } else { 1173f461d2dcSChristoph Hellwig val = convdiv * (*i) / convmul; 117432927393SChristoph Hellwig if (!first) 117532927393SChristoph Hellwig proc_put_char(&buffer, &left, '\t'); 117632927393SChristoph Hellwig proc_put_long(&buffer, &left, val, false); 1177f461d2dcSChristoph Hellwig } 1178f461d2dcSChristoph Hellwig } 1179f461d2dcSChristoph Hellwig 1180f461d2dcSChristoph Hellwig if (!write && !first && left && !err) 118132927393SChristoph Hellwig proc_put_char(&buffer, &left, '\n'); 1182f461d2dcSChristoph Hellwig if (write && !err) 1183f461d2dcSChristoph Hellwig left -= proc_skip_spaces(&p); 118432927393SChristoph Hellwig if (write && first) 1185f461d2dcSChristoph Hellwig return err ? : -EINVAL; 1186f461d2dcSChristoph Hellwig *lenp -= left; 1187f461d2dcSChristoph Hellwig out: 1188f461d2dcSChristoph Hellwig *ppos += *lenp; 1189f461d2dcSChristoph Hellwig return err; 1190f461d2dcSChristoph Hellwig } 1191f461d2dcSChristoph Hellwig 1192f461d2dcSChristoph Hellwig static int do_proc_doulongvec_minmax(struct ctl_table *table, int write, 119332927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos, unsigned long convmul, 1194f461d2dcSChristoph Hellwig unsigned long convdiv) 1195f461d2dcSChristoph Hellwig { 1196f461d2dcSChristoph Hellwig return __do_proc_doulongvec_minmax(table->data, table, write, 1197f461d2dcSChristoph Hellwig buffer, lenp, ppos, convmul, convdiv); 1198f461d2dcSChristoph Hellwig } 1199f461d2dcSChristoph Hellwig 1200f461d2dcSChristoph Hellwig /** 1201f461d2dcSChristoph Hellwig * proc_doulongvec_minmax - read a vector of long integers with min/max values 1202f461d2dcSChristoph Hellwig * @table: the sysctl table 1203f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1204f461d2dcSChristoph Hellwig * @buffer: the user buffer 1205f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1206f461d2dcSChristoph Hellwig * @ppos: file position 1207f461d2dcSChristoph Hellwig * 1208f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long 1209f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 1210f461d2dcSChristoph Hellwig * 1211f461d2dcSChristoph Hellwig * This routine will ensure the values are within the range specified by 1212f461d2dcSChristoph Hellwig * table->extra1 (min) and table->extra2 (max). 1213f461d2dcSChristoph Hellwig * 1214f461d2dcSChristoph Hellwig * Returns 0 on success. 1215f461d2dcSChristoph Hellwig */ 1216f461d2dcSChristoph Hellwig int proc_doulongvec_minmax(struct ctl_table *table, int write, 121732927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1218f461d2dcSChristoph Hellwig { 1219f461d2dcSChristoph Hellwig return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l); 1220f461d2dcSChristoph Hellwig } 1221f461d2dcSChristoph Hellwig 1222f461d2dcSChristoph Hellwig /** 1223f461d2dcSChristoph Hellwig * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values 1224f461d2dcSChristoph Hellwig * @table: the sysctl table 1225f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1226f461d2dcSChristoph Hellwig * @buffer: the user buffer 1227f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1228f461d2dcSChristoph Hellwig * @ppos: file position 1229f461d2dcSChristoph Hellwig * 1230f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long 1231f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. The values 1232f461d2dcSChristoph Hellwig * are treated as milliseconds, and converted to jiffies when they are stored. 1233f461d2dcSChristoph Hellwig * 1234f461d2dcSChristoph Hellwig * This routine will ensure the values are within the range specified by 1235f461d2dcSChristoph Hellwig * table->extra1 (min) and table->extra2 (max). 1236f461d2dcSChristoph Hellwig * 1237f461d2dcSChristoph Hellwig * Returns 0 on success. 1238f461d2dcSChristoph Hellwig */ 1239f461d2dcSChristoph Hellwig int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 124032927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1241f461d2dcSChristoph Hellwig { 1242f461d2dcSChristoph Hellwig return do_proc_doulongvec_minmax(table, write, buffer, 1243f461d2dcSChristoph Hellwig lenp, ppos, HZ, 1000l); 1244f461d2dcSChristoph Hellwig } 1245f461d2dcSChristoph Hellwig 1246f461d2dcSChristoph Hellwig 1247f461d2dcSChristoph Hellwig static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp, 1248f461d2dcSChristoph Hellwig int *valp, 1249f461d2dcSChristoph Hellwig int write, void *data) 1250f461d2dcSChristoph Hellwig { 1251f461d2dcSChristoph Hellwig if (write) { 1252f461d2dcSChristoph Hellwig if (*lvalp > INT_MAX / HZ) 1253f461d2dcSChristoph Hellwig return 1; 1254f461d2dcSChristoph Hellwig *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ); 1255f461d2dcSChristoph Hellwig } else { 1256f461d2dcSChristoph Hellwig int val = *valp; 1257f461d2dcSChristoph Hellwig unsigned long lval; 1258f461d2dcSChristoph Hellwig if (val < 0) { 1259f461d2dcSChristoph Hellwig *negp = true; 1260f461d2dcSChristoph Hellwig lval = -(unsigned long)val; 1261f461d2dcSChristoph Hellwig } else { 1262f461d2dcSChristoph Hellwig *negp = false; 1263f461d2dcSChristoph Hellwig lval = (unsigned long)val; 1264f461d2dcSChristoph Hellwig } 1265f461d2dcSChristoph Hellwig *lvalp = lval / HZ; 1266f461d2dcSChristoph Hellwig } 1267f461d2dcSChristoph Hellwig return 0; 1268f461d2dcSChristoph Hellwig } 1269f461d2dcSChristoph Hellwig 1270f461d2dcSChristoph Hellwig static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp, 1271f461d2dcSChristoph Hellwig int *valp, 1272f461d2dcSChristoph Hellwig int write, void *data) 1273f461d2dcSChristoph Hellwig { 1274f461d2dcSChristoph Hellwig if (write) { 1275f461d2dcSChristoph Hellwig if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ) 1276f461d2dcSChristoph Hellwig return 1; 1277f461d2dcSChristoph Hellwig *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp); 1278f461d2dcSChristoph Hellwig } else { 1279f461d2dcSChristoph Hellwig int val = *valp; 1280f461d2dcSChristoph Hellwig unsigned long lval; 1281f461d2dcSChristoph Hellwig if (val < 0) { 1282f461d2dcSChristoph Hellwig *negp = true; 1283f461d2dcSChristoph Hellwig lval = -(unsigned long)val; 1284f461d2dcSChristoph Hellwig } else { 1285f461d2dcSChristoph Hellwig *negp = false; 1286f461d2dcSChristoph Hellwig lval = (unsigned long)val; 1287f461d2dcSChristoph Hellwig } 1288f461d2dcSChristoph Hellwig *lvalp = jiffies_to_clock_t(lval); 1289f461d2dcSChristoph Hellwig } 1290f461d2dcSChristoph Hellwig return 0; 1291f461d2dcSChristoph Hellwig } 1292f461d2dcSChristoph Hellwig 1293f461d2dcSChristoph Hellwig static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp, 1294f461d2dcSChristoph Hellwig int *valp, 1295f461d2dcSChristoph Hellwig int write, void *data) 1296f461d2dcSChristoph Hellwig { 1297f461d2dcSChristoph Hellwig if (write) { 1298f461d2dcSChristoph Hellwig unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp); 1299f461d2dcSChristoph Hellwig 1300f461d2dcSChristoph Hellwig if (jif > INT_MAX) 1301f461d2dcSChristoph Hellwig return 1; 1302f461d2dcSChristoph Hellwig *valp = (int)jif; 1303f461d2dcSChristoph Hellwig } else { 1304f461d2dcSChristoph Hellwig int val = *valp; 1305f461d2dcSChristoph Hellwig unsigned long lval; 1306f461d2dcSChristoph Hellwig if (val < 0) { 1307f461d2dcSChristoph Hellwig *negp = true; 1308f461d2dcSChristoph Hellwig lval = -(unsigned long)val; 1309f461d2dcSChristoph Hellwig } else { 1310f461d2dcSChristoph Hellwig *negp = false; 1311f461d2dcSChristoph Hellwig lval = (unsigned long)val; 1312f461d2dcSChristoph Hellwig } 1313f461d2dcSChristoph Hellwig *lvalp = jiffies_to_msecs(lval); 1314f461d2dcSChristoph Hellwig } 1315f461d2dcSChristoph Hellwig return 0; 1316f461d2dcSChristoph Hellwig } 1317f461d2dcSChristoph Hellwig 1318f461d2dcSChristoph Hellwig /** 1319f461d2dcSChristoph Hellwig * proc_dointvec_jiffies - read a vector of integers as seconds 1320f461d2dcSChristoph Hellwig * @table: the sysctl table 1321f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1322f461d2dcSChristoph Hellwig * @buffer: the user buffer 1323f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1324f461d2dcSChristoph Hellwig * @ppos: file position 1325f461d2dcSChristoph Hellwig * 1326f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1327f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 1328f461d2dcSChristoph Hellwig * The values read are assumed to be in seconds, and are converted into 1329f461d2dcSChristoph Hellwig * jiffies. 1330f461d2dcSChristoph Hellwig * 1331f461d2dcSChristoph Hellwig * Returns 0 on success. 1332f461d2dcSChristoph Hellwig */ 1333f461d2dcSChristoph Hellwig int proc_dointvec_jiffies(struct ctl_table *table, int write, 133432927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1335f461d2dcSChristoph Hellwig { 1336f461d2dcSChristoph Hellwig return do_proc_dointvec(table,write,buffer,lenp,ppos, 1337f461d2dcSChristoph Hellwig do_proc_dointvec_jiffies_conv,NULL); 1338f461d2dcSChristoph Hellwig } 1339f461d2dcSChristoph Hellwig 1340f461d2dcSChristoph Hellwig /** 1341f461d2dcSChristoph Hellwig * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds 1342f461d2dcSChristoph Hellwig * @table: the sysctl table 1343f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1344f461d2dcSChristoph Hellwig * @buffer: the user buffer 1345f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1346f461d2dcSChristoph Hellwig * @ppos: pointer to the file position 1347f461d2dcSChristoph Hellwig * 1348f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1349f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 1350f461d2dcSChristoph Hellwig * The values read are assumed to be in 1/USER_HZ seconds, and 1351f461d2dcSChristoph Hellwig * are converted into jiffies. 1352f461d2dcSChristoph Hellwig * 1353f461d2dcSChristoph Hellwig * Returns 0 on success. 1354f461d2dcSChristoph Hellwig */ 1355f461d2dcSChristoph Hellwig int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 135632927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1357f461d2dcSChristoph Hellwig { 1358f461d2dcSChristoph Hellwig return do_proc_dointvec(table,write,buffer,lenp,ppos, 1359f461d2dcSChristoph Hellwig do_proc_dointvec_userhz_jiffies_conv,NULL); 1360f461d2dcSChristoph Hellwig } 1361f461d2dcSChristoph Hellwig 1362f461d2dcSChristoph Hellwig /** 1363f461d2dcSChristoph Hellwig * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds 1364f461d2dcSChristoph Hellwig * @table: the sysctl table 1365f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1366f461d2dcSChristoph Hellwig * @buffer: the user buffer 1367f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1368f461d2dcSChristoph Hellwig * @ppos: file position 1369f461d2dcSChristoph Hellwig * @ppos: the current position in the file 1370f461d2dcSChristoph Hellwig * 1371f461d2dcSChristoph Hellwig * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1372f461d2dcSChristoph Hellwig * values from/to the user buffer, treated as an ASCII string. 1373f461d2dcSChristoph Hellwig * The values read are assumed to be in 1/1000 seconds, and 1374f461d2dcSChristoph Hellwig * are converted into jiffies. 1375f461d2dcSChristoph Hellwig * 1376f461d2dcSChristoph Hellwig * Returns 0 on success. 1377f461d2dcSChristoph Hellwig */ 137832927393SChristoph Hellwig int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer, 137932927393SChristoph Hellwig size_t *lenp, loff_t *ppos) 1380f461d2dcSChristoph Hellwig { 1381f461d2dcSChristoph Hellwig return do_proc_dointvec(table, write, buffer, lenp, ppos, 1382f461d2dcSChristoph Hellwig do_proc_dointvec_ms_jiffies_conv, NULL); 1383f461d2dcSChristoph Hellwig } 1384f461d2dcSChristoph Hellwig 138532927393SChristoph Hellwig static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer, 138632927393SChristoph Hellwig size_t *lenp, loff_t *ppos) 1387f461d2dcSChristoph Hellwig { 1388f461d2dcSChristoph Hellwig struct pid *new_pid; 1389f461d2dcSChristoph Hellwig pid_t tmp; 1390f461d2dcSChristoph Hellwig int r; 1391f461d2dcSChristoph Hellwig 1392f461d2dcSChristoph Hellwig tmp = pid_vnr(cad_pid); 1393f461d2dcSChristoph Hellwig 1394f461d2dcSChristoph Hellwig r = __do_proc_dointvec(&tmp, table, write, buffer, 1395f461d2dcSChristoph Hellwig lenp, ppos, NULL, NULL); 1396f461d2dcSChristoph Hellwig if (r || !write) 1397f461d2dcSChristoph Hellwig return r; 1398f461d2dcSChristoph Hellwig 1399f461d2dcSChristoph Hellwig new_pid = find_get_pid(tmp); 1400f461d2dcSChristoph Hellwig if (!new_pid) 1401f461d2dcSChristoph Hellwig return -ESRCH; 1402f461d2dcSChristoph Hellwig 1403f461d2dcSChristoph Hellwig put_pid(xchg(&cad_pid, new_pid)); 1404f461d2dcSChristoph Hellwig return 0; 1405f461d2dcSChristoph Hellwig } 1406f461d2dcSChristoph Hellwig 1407f461d2dcSChristoph Hellwig /** 1408f461d2dcSChristoph Hellwig * proc_do_large_bitmap - read/write from/to a large bitmap 1409f461d2dcSChristoph Hellwig * @table: the sysctl table 1410f461d2dcSChristoph Hellwig * @write: %TRUE if this is a write to the sysctl file 1411f461d2dcSChristoph Hellwig * @buffer: the user buffer 1412f461d2dcSChristoph Hellwig * @lenp: the size of the user buffer 1413f461d2dcSChristoph Hellwig * @ppos: file position 1414f461d2dcSChristoph Hellwig * 1415f461d2dcSChristoph Hellwig * The bitmap is stored at table->data and the bitmap length (in bits) 1416f461d2dcSChristoph Hellwig * in table->maxlen. 1417f461d2dcSChristoph Hellwig * 1418f461d2dcSChristoph Hellwig * We use a range comma separated format (e.g. 1,3-4,10-10) so that 1419f461d2dcSChristoph Hellwig * large bitmaps may be represented in a compact manner. Writing into 1420f461d2dcSChristoph Hellwig * the file will clear the bitmap then update it with the given input. 1421f461d2dcSChristoph Hellwig * 1422f461d2dcSChristoph Hellwig * Returns 0 on success. 1423f461d2dcSChristoph Hellwig */ 1424f461d2dcSChristoph Hellwig int proc_do_large_bitmap(struct ctl_table *table, int write, 142532927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1426f461d2dcSChristoph Hellwig { 1427f461d2dcSChristoph Hellwig int err = 0; 1428f461d2dcSChristoph Hellwig bool first = 1; 1429f461d2dcSChristoph Hellwig size_t left = *lenp; 1430f461d2dcSChristoph Hellwig unsigned long bitmap_len = table->maxlen; 1431f461d2dcSChristoph Hellwig unsigned long *bitmap = *(unsigned long **) table->data; 1432f461d2dcSChristoph Hellwig unsigned long *tmp_bitmap = NULL; 1433f461d2dcSChristoph Hellwig char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c; 1434f461d2dcSChristoph Hellwig 1435f461d2dcSChristoph Hellwig if (!bitmap || !bitmap_len || !left || (*ppos && !write)) { 1436f461d2dcSChristoph Hellwig *lenp = 0; 1437f461d2dcSChristoph Hellwig return 0; 1438f461d2dcSChristoph Hellwig } 1439f461d2dcSChristoph Hellwig 1440f461d2dcSChristoph Hellwig if (write) { 144132927393SChristoph Hellwig char *p = buffer; 1442f461d2dcSChristoph Hellwig size_t skipped = 0; 1443f461d2dcSChristoph Hellwig 1444f461d2dcSChristoph Hellwig if (left > PAGE_SIZE - 1) { 1445f461d2dcSChristoph Hellwig left = PAGE_SIZE - 1; 1446f461d2dcSChristoph Hellwig /* How much of the buffer we'll skip this pass */ 1447f461d2dcSChristoph Hellwig skipped = *lenp - left; 1448f461d2dcSChristoph Hellwig } 1449f461d2dcSChristoph Hellwig 1450f461d2dcSChristoph Hellwig tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL); 145132927393SChristoph Hellwig if (!tmp_bitmap) 1452f461d2dcSChristoph Hellwig return -ENOMEM; 1453f461d2dcSChristoph Hellwig proc_skip_char(&p, &left, '\n'); 1454f461d2dcSChristoph Hellwig while (!err && left) { 1455f461d2dcSChristoph Hellwig unsigned long val_a, val_b; 1456f461d2dcSChristoph Hellwig bool neg; 1457f461d2dcSChristoph Hellwig size_t saved_left; 1458f461d2dcSChristoph Hellwig 1459f461d2dcSChristoph Hellwig /* In case we stop parsing mid-number, we can reset */ 1460f461d2dcSChristoph Hellwig saved_left = left; 1461f461d2dcSChristoph Hellwig err = proc_get_long(&p, &left, &val_a, &neg, tr_a, 1462f461d2dcSChristoph Hellwig sizeof(tr_a), &c); 1463f461d2dcSChristoph Hellwig /* 1464f461d2dcSChristoph Hellwig * If we consumed the entirety of a truncated buffer or 1465f461d2dcSChristoph Hellwig * only one char is left (may be a "-"), then stop here, 1466f461d2dcSChristoph Hellwig * reset, & come back for more. 1467f461d2dcSChristoph Hellwig */ 1468f461d2dcSChristoph Hellwig if ((left <= 1) && skipped) { 1469f461d2dcSChristoph Hellwig left = saved_left; 1470f461d2dcSChristoph Hellwig break; 1471f461d2dcSChristoph Hellwig } 1472f461d2dcSChristoph Hellwig 1473f461d2dcSChristoph Hellwig if (err) 1474f461d2dcSChristoph Hellwig break; 1475f461d2dcSChristoph Hellwig if (val_a >= bitmap_len || neg) { 1476f461d2dcSChristoph Hellwig err = -EINVAL; 1477f461d2dcSChristoph Hellwig break; 1478f461d2dcSChristoph Hellwig } 1479f461d2dcSChristoph Hellwig 1480f461d2dcSChristoph Hellwig val_b = val_a; 1481f461d2dcSChristoph Hellwig if (left) { 1482f461d2dcSChristoph Hellwig p++; 1483f461d2dcSChristoph Hellwig left--; 1484f461d2dcSChristoph Hellwig } 1485f461d2dcSChristoph Hellwig 1486f461d2dcSChristoph Hellwig if (c == '-') { 1487f461d2dcSChristoph Hellwig err = proc_get_long(&p, &left, &val_b, 1488f461d2dcSChristoph Hellwig &neg, tr_b, sizeof(tr_b), 1489f461d2dcSChristoph Hellwig &c); 1490f461d2dcSChristoph Hellwig /* 1491f461d2dcSChristoph Hellwig * If we consumed all of a truncated buffer or 1492f461d2dcSChristoph Hellwig * then stop here, reset, & come back for more. 1493f461d2dcSChristoph Hellwig */ 1494f461d2dcSChristoph Hellwig if (!left && skipped) { 1495f461d2dcSChristoph Hellwig left = saved_left; 1496f461d2dcSChristoph Hellwig break; 1497f461d2dcSChristoph Hellwig } 1498f461d2dcSChristoph Hellwig 1499f461d2dcSChristoph Hellwig if (err) 1500f461d2dcSChristoph Hellwig break; 1501f461d2dcSChristoph Hellwig if (val_b >= bitmap_len || neg || 1502f461d2dcSChristoph Hellwig val_a > val_b) { 1503f461d2dcSChristoph Hellwig err = -EINVAL; 1504f461d2dcSChristoph Hellwig break; 1505f461d2dcSChristoph Hellwig } 1506f461d2dcSChristoph Hellwig if (left) { 1507f461d2dcSChristoph Hellwig p++; 1508f461d2dcSChristoph Hellwig left--; 1509f461d2dcSChristoph Hellwig } 1510f461d2dcSChristoph Hellwig } 1511f461d2dcSChristoph Hellwig 1512f461d2dcSChristoph Hellwig bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); 1513f461d2dcSChristoph Hellwig first = 0; 1514f461d2dcSChristoph Hellwig proc_skip_char(&p, &left, '\n'); 1515f461d2dcSChristoph Hellwig } 1516f461d2dcSChristoph Hellwig left += skipped; 1517f461d2dcSChristoph Hellwig } else { 1518f461d2dcSChristoph Hellwig unsigned long bit_a, bit_b = 0; 1519f461d2dcSChristoph Hellwig 1520f461d2dcSChristoph Hellwig while (left) { 1521f461d2dcSChristoph Hellwig bit_a = find_next_bit(bitmap, bitmap_len, bit_b); 1522f461d2dcSChristoph Hellwig if (bit_a >= bitmap_len) 1523f461d2dcSChristoph Hellwig break; 1524f461d2dcSChristoph Hellwig bit_b = find_next_zero_bit(bitmap, bitmap_len, 1525f461d2dcSChristoph Hellwig bit_a + 1) - 1; 1526f461d2dcSChristoph Hellwig 152732927393SChristoph Hellwig if (!first) 152832927393SChristoph Hellwig proc_put_char(&buffer, &left, ','); 152932927393SChristoph Hellwig proc_put_long(&buffer, &left, bit_a, false); 1530f461d2dcSChristoph Hellwig if (bit_a != bit_b) { 153132927393SChristoph Hellwig proc_put_char(&buffer, &left, '-'); 153232927393SChristoph Hellwig proc_put_long(&buffer, &left, bit_b, false); 1533f461d2dcSChristoph Hellwig } 1534f461d2dcSChristoph Hellwig 1535f461d2dcSChristoph Hellwig first = 0; bit_b++; 1536f461d2dcSChristoph Hellwig } 153732927393SChristoph Hellwig proc_put_char(&buffer, &left, '\n'); 1538f461d2dcSChristoph Hellwig } 1539f461d2dcSChristoph Hellwig 1540f461d2dcSChristoph Hellwig if (!err) { 1541f461d2dcSChristoph Hellwig if (write) { 1542f461d2dcSChristoph Hellwig if (*ppos) 1543f461d2dcSChristoph Hellwig bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len); 1544f461d2dcSChristoph Hellwig else 1545f461d2dcSChristoph Hellwig bitmap_copy(bitmap, tmp_bitmap, bitmap_len); 1546f461d2dcSChristoph Hellwig } 1547f461d2dcSChristoph Hellwig *lenp -= left; 1548f461d2dcSChristoph Hellwig *ppos += *lenp; 1549f461d2dcSChristoph Hellwig } 1550f461d2dcSChristoph Hellwig 1551f461d2dcSChristoph Hellwig bitmap_free(tmp_bitmap); 1552f461d2dcSChristoph Hellwig return err; 1553f461d2dcSChristoph Hellwig } 1554f461d2dcSChristoph Hellwig 1555f461d2dcSChristoph Hellwig #else /* CONFIG_PROC_SYSCTL */ 1556f461d2dcSChristoph Hellwig 1557f461d2dcSChristoph Hellwig int proc_dostring(struct ctl_table *table, int write, 155832927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1559f461d2dcSChristoph Hellwig { 1560f461d2dcSChristoph Hellwig return -ENOSYS; 1561f461d2dcSChristoph Hellwig } 1562f461d2dcSChristoph Hellwig 1563f461d2dcSChristoph Hellwig int proc_dointvec(struct ctl_table *table, int write, 156432927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1565f461d2dcSChristoph Hellwig { 1566f461d2dcSChristoph Hellwig return -ENOSYS; 1567f461d2dcSChristoph Hellwig } 1568f461d2dcSChristoph Hellwig 1569f461d2dcSChristoph Hellwig int proc_douintvec(struct ctl_table *table, int write, 157032927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1571f461d2dcSChristoph Hellwig { 1572f461d2dcSChristoph Hellwig return -ENOSYS; 1573f461d2dcSChristoph Hellwig } 1574f461d2dcSChristoph Hellwig 1575f461d2dcSChristoph Hellwig int proc_dointvec_minmax(struct ctl_table *table, int write, 157632927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1577f461d2dcSChristoph Hellwig { 1578f461d2dcSChristoph Hellwig return -ENOSYS; 1579f461d2dcSChristoph Hellwig } 1580f461d2dcSChristoph Hellwig 1581f461d2dcSChristoph Hellwig int proc_douintvec_minmax(struct ctl_table *table, int write, 158232927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1583f461d2dcSChristoph Hellwig { 1584f461d2dcSChristoph Hellwig return -ENOSYS; 1585f461d2dcSChristoph Hellwig } 1586f461d2dcSChristoph Hellwig 1587f461d2dcSChristoph Hellwig int proc_dointvec_jiffies(struct ctl_table *table, int write, 158832927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1589f461d2dcSChristoph Hellwig { 1590f461d2dcSChristoph Hellwig return -ENOSYS; 1591f461d2dcSChristoph Hellwig } 1592f461d2dcSChristoph Hellwig 1593f461d2dcSChristoph Hellwig int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 159432927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1595f461d2dcSChristoph Hellwig { 1596f461d2dcSChristoph Hellwig return -ENOSYS; 1597f461d2dcSChristoph Hellwig } 1598f461d2dcSChristoph Hellwig 1599f461d2dcSChristoph Hellwig int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, 160032927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1601f461d2dcSChristoph Hellwig { 1602f461d2dcSChristoph Hellwig return -ENOSYS; 1603f461d2dcSChristoph Hellwig } 1604f461d2dcSChristoph Hellwig 1605f461d2dcSChristoph Hellwig int proc_doulongvec_minmax(struct ctl_table *table, int write, 160632927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1607f461d2dcSChristoph Hellwig { 1608f461d2dcSChristoph Hellwig return -ENOSYS; 1609f461d2dcSChristoph Hellwig } 1610f461d2dcSChristoph Hellwig 1611f461d2dcSChristoph Hellwig int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 161232927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1613f461d2dcSChristoph Hellwig { 1614f461d2dcSChristoph Hellwig return -ENOSYS; 1615f461d2dcSChristoph Hellwig } 1616f461d2dcSChristoph Hellwig 1617f461d2dcSChristoph Hellwig int proc_do_large_bitmap(struct ctl_table *table, int write, 161832927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1619f461d2dcSChristoph Hellwig { 1620f461d2dcSChristoph Hellwig return -ENOSYS; 1621f461d2dcSChristoph Hellwig } 1622f461d2dcSChristoph Hellwig 1623f461d2dcSChristoph Hellwig #endif /* CONFIG_PROC_SYSCTL */ 1624f461d2dcSChristoph Hellwig 1625f461d2dcSChristoph Hellwig #if defined(CONFIG_SYSCTL) 1626f461d2dcSChristoph Hellwig int proc_do_static_key(struct ctl_table *table, int write, 162732927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 1628f461d2dcSChristoph Hellwig { 1629f461d2dcSChristoph Hellwig struct static_key *key = (struct static_key *)table->data; 1630f461d2dcSChristoph Hellwig static DEFINE_MUTEX(static_key_mutex); 1631f461d2dcSChristoph Hellwig int val, ret; 1632f461d2dcSChristoph Hellwig struct ctl_table tmp = { 1633f461d2dcSChristoph Hellwig .data = &val, 1634f461d2dcSChristoph Hellwig .maxlen = sizeof(val), 1635f461d2dcSChristoph Hellwig .mode = table->mode, 1636f461d2dcSChristoph Hellwig .extra1 = SYSCTL_ZERO, 1637f461d2dcSChristoph Hellwig .extra2 = SYSCTL_ONE, 1638f461d2dcSChristoph Hellwig }; 1639f461d2dcSChristoph Hellwig 1640f461d2dcSChristoph Hellwig if (write && !capable(CAP_SYS_ADMIN)) 1641f461d2dcSChristoph Hellwig return -EPERM; 1642f461d2dcSChristoph Hellwig 1643f461d2dcSChristoph Hellwig mutex_lock(&static_key_mutex); 1644f461d2dcSChristoph Hellwig val = static_key_enabled(key); 1645f461d2dcSChristoph Hellwig ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 1646f461d2dcSChristoph Hellwig if (write && !ret) { 1647f461d2dcSChristoph Hellwig if (val) 1648f461d2dcSChristoph Hellwig static_key_enable(key); 1649f461d2dcSChristoph Hellwig else 1650f461d2dcSChristoph Hellwig static_key_disable(key); 1651f461d2dcSChristoph Hellwig } 1652f461d2dcSChristoph Hellwig mutex_unlock(&static_key_mutex); 1653f461d2dcSChristoph Hellwig return ret; 1654f461d2dcSChristoph Hellwig } 1655f461d2dcSChristoph Hellwig 1656d8217f07SEric W. Biederman static struct ctl_table kern_table[] = { 16572bba22c5SMike Galbraith { 16582bba22c5SMike Galbraith .procname = "sched_child_runs_first", 16592bba22c5SMike Galbraith .data = &sysctl_sched_child_runs_first, 16602bba22c5SMike Galbraith .maxlen = sizeof(unsigned int), 16612bba22c5SMike Galbraith .mode = 0644, 16626d456111SEric W. Biederman .proc_handler = proc_dointvec, 16632bba22c5SMike Galbraith }, 166477e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 166577e54a1fSIngo Molnar { 1666b2be5e96SPeter Zijlstra .procname = "sched_min_granularity_ns", 1667b2be5e96SPeter Zijlstra .data = &sysctl_sched_min_granularity, 166877e54a1fSIngo Molnar .maxlen = sizeof(unsigned int), 166977e54a1fSIngo Molnar .mode = 0644, 1670702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 1671b2be5e96SPeter Zijlstra .extra1 = &min_sched_granularity_ns, 1672b2be5e96SPeter Zijlstra .extra2 = &max_sched_granularity_ns, 167377e54a1fSIngo Molnar }, 167477e54a1fSIngo Molnar { 167521805085SPeter Zijlstra .procname = "sched_latency_ns", 167621805085SPeter Zijlstra .data = &sysctl_sched_latency, 167721805085SPeter Zijlstra .maxlen = sizeof(unsigned int), 167821805085SPeter Zijlstra .mode = 0644, 1679702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 168021805085SPeter Zijlstra .extra1 = &min_sched_granularity_ns, 168121805085SPeter Zijlstra .extra2 = &max_sched_granularity_ns, 168221805085SPeter Zijlstra }, 168321805085SPeter Zijlstra { 168477e54a1fSIngo Molnar .procname = "sched_wakeup_granularity_ns", 168577e54a1fSIngo Molnar .data = &sysctl_sched_wakeup_granularity, 168677e54a1fSIngo Molnar .maxlen = sizeof(unsigned int), 168777e54a1fSIngo Molnar .mode = 0644, 1688702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 168977e54a1fSIngo Molnar .extra1 = &min_wakeup_granularity_ns, 169077e54a1fSIngo Molnar .extra2 = &max_wakeup_granularity_ns, 169177e54a1fSIngo Molnar }, 1692cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP 169377e54a1fSIngo Molnar { 16941983a922SChristian Ehrhardt .procname = "sched_tunable_scaling", 16951983a922SChristian Ehrhardt .data = &sysctl_sched_tunable_scaling, 16961983a922SChristian Ehrhardt .maxlen = sizeof(enum sched_tunable_scaling), 16971983a922SChristian Ehrhardt .mode = 0644, 1698702a7c76SLinus Torvalds .proc_handler = sched_proc_update_handler, 16991983a922SChristian Ehrhardt .extra1 = &min_sched_tunable_scaling, 17001983a922SChristian Ehrhardt .extra2 = &max_sched_tunable_scaling, 17012398f2c6SPeter Zijlstra }, 17022398f2c6SPeter Zijlstra { 1703d00535dbSNamhyung Kim .procname = "sched_migration_cost_ns", 1704da84d961SIngo Molnar .data = &sysctl_sched_migration_cost, 1705da84d961SIngo Molnar .maxlen = sizeof(unsigned int), 1706da84d961SIngo Molnar .mode = 0644, 17076d456111SEric W. Biederman .proc_handler = proc_dointvec, 1708da84d961SIngo Molnar }, 1709b82d9fddSPeter Zijlstra { 1710b82d9fddSPeter Zijlstra .procname = "sched_nr_migrate", 1711b82d9fddSPeter Zijlstra .data = &sysctl_sched_nr_migrate, 1712b82d9fddSPeter Zijlstra .maxlen = sizeof(unsigned int), 1713fa85ae24SPeter Zijlstra .mode = 0644, 17146d456111SEric W. Biederman .proc_handler = proc_dointvec, 1715fa85ae24SPeter Zijlstra }, 1716cb251765SMel Gorman #ifdef CONFIG_SCHEDSTATS 1717cb251765SMel Gorman { 1718cb251765SMel Gorman .procname = "sched_schedstats", 1719cb251765SMel Gorman .data = NULL, 1720cb251765SMel Gorman .maxlen = sizeof(unsigned int), 1721cb251765SMel Gorman .mode = 0644, 1722cb251765SMel Gorman .proc_handler = sysctl_schedstats, 1723eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 1724eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 1725cb251765SMel Gorman }, 1726cb251765SMel Gorman #endif /* CONFIG_SCHEDSTATS */ 1727cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */ 1728cbee9f88SPeter Zijlstra #ifdef CONFIG_NUMA_BALANCING 1729cbee9f88SPeter Zijlstra { 17304b96a29bSPeter Zijlstra .procname = "numa_balancing_scan_delay_ms", 17314b96a29bSPeter Zijlstra .data = &sysctl_numa_balancing_scan_delay, 17324b96a29bSPeter Zijlstra .maxlen = sizeof(unsigned int), 17334b96a29bSPeter Zijlstra .mode = 0644, 17344b96a29bSPeter Zijlstra .proc_handler = proc_dointvec, 17354b96a29bSPeter Zijlstra }, 17364b96a29bSPeter Zijlstra { 1737cbee9f88SPeter Zijlstra .procname = "numa_balancing_scan_period_min_ms", 1738cbee9f88SPeter Zijlstra .data = &sysctl_numa_balancing_scan_period_min, 1739cbee9f88SPeter Zijlstra .maxlen = sizeof(unsigned int), 1740cbee9f88SPeter Zijlstra .mode = 0644, 1741cbee9f88SPeter Zijlstra .proc_handler = proc_dointvec, 1742cbee9f88SPeter Zijlstra }, 1743cbee9f88SPeter Zijlstra { 1744cbee9f88SPeter Zijlstra .procname = "numa_balancing_scan_period_max_ms", 1745cbee9f88SPeter Zijlstra .data = &sysctl_numa_balancing_scan_period_max, 1746cbee9f88SPeter Zijlstra .maxlen = sizeof(unsigned int), 1747cbee9f88SPeter Zijlstra .mode = 0644, 1748cbee9f88SPeter Zijlstra .proc_handler = proc_dointvec, 1749cbee9f88SPeter Zijlstra }, 17506e5fb223SPeter Zijlstra { 17516e5fb223SPeter Zijlstra .procname = "numa_balancing_scan_size_mb", 17526e5fb223SPeter Zijlstra .data = &sysctl_numa_balancing_scan_size, 17536e5fb223SPeter Zijlstra .maxlen = sizeof(unsigned int), 17546e5fb223SPeter Zijlstra .mode = 0644, 175564192658SKirill Tkhai .proc_handler = proc_dointvec_minmax, 1756eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 17576e5fb223SPeter Zijlstra }, 17583a7053b3SMel Gorman { 175954a43d54SAndi Kleen .procname = "numa_balancing", 176054a43d54SAndi Kleen .data = NULL, /* filled in by handler */ 176154a43d54SAndi Kleen .maxlen = sizeof(unsigned int), 176254a43d54SAndi Kleen .mode = 0644, 176354a43d54SAndi Kleen .proc_handler = sysctl_numa_balancing, 1764eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 1765eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 176654a43d54SAndi Kleen }, 1767cbee9f88SPeter Zijlstra #endif /* CONFIG_NUMA_BALANCING */ 1768cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */ 17691799e35dSIngo Molnar { 17709f0c1e56SPeter Zijlstra .procname = "sched_rt_period_us", 17719f0c1e56SPeter Zijlstra .data = &sysctl_sched_rt_period, 17729f0c1e56SPeter Zijlstra .maxlen = sizeof(unsigned int), 17739f0c1e56SPeter Zijlstra .mode = 0644, 17746d456111SEric W. Biederman .proc_handler = sched_rt_handler, 17759f0c1e56SPeter Zijlstra }, 17769f0c1e56SPeter Zijlstra { 17779f0c1e56SPeter Zijlstra .procname = "sched_rt_runtime_us", 17789f0c1e56SPeter Zijlstra .data = &sysctl_sched_rt_runtime, 17799f0c1e56SPeter Zijlstra .maxlen = sizeof(int), 17809f0c1e56SPeter Zijlstra .mode = 0644, 17816d456111SEric W. Biederman .proc_handler = sched_rt_handler, 17829f0c1e56SPeter Zijlstra }, 1783ce0dbbbbSClark Williams { 1784ce0dbbbbSClark Williams .procname = "sched_rr_timeslice_ms", 1785975e155eSShile Zhang .data = &sysctl_sched_rr_timeslice, 1786ce0dbbbbSClark Williams .maxlen = sizeof(int), 1787ce0dbbbbSClark Williams .mode = 0644, 1788ce0dbbbbSClark Williams .proc_handler = sched_rr_handler, 1789ce0dbbbbSClark Williams }, 1790e8f14172SPatrick Bellasi #ifdef CONFIG_UCLAMP_TASK 1791e8f14172SPatrick Bellasi { 1792e8f14172SPatrick Bellasi .procname = "sched_util_clamp_min", 1793e8f14172SPatrick Bellasi .data = &sysctl_sched_uclamp_util_min, 1794e8f14172SPatrick Bellasi .maxlen = sizeof(unsigned int), 1795e8f14172SPatrick Bellasi .mode = 0644, 1796e8f14172SPatrick Bellasi .proc_handler = sysctl_sched_uclamp_handler, 1797e8f14172SPatrick Bellasi }, 1798e8f14172SPatrick Bellasi { 1799e8f14172SPatrick Bellasi .procname = "sched_util_clamp_max", 1800e8f14172SPatrick Bellasi .data = &sysctl_sched_uclamp_util_max, 1801e8f14172SPatrick Bellasi .maxlen = sizeof(unsigned int), 1802e8f14172SPatrick Bellasi .mode = 0644, 1803e8f14172SPatrick Bellasi .proc_handler = sysctl_sched_uclamp_handler, 1804e8f14172SPatrick Bellasi }, 1805e8f14172SPatrick Bellasi #endif 18065091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 18075091faa4SMike Galbraith { 18085091faa4SMike Galbraith .procname = "sched_autogroup_enabled", 18095091faa4SMike Galbraith .data = &sysctl_sched_autogroup_enabled, 18105091faa4SMike Galbraith .maxlen = sizeof(unsigned int), 18115091faa4SMike Galbraith .mode = 0644, 18121747b21fSYong Zhang .proc_handler = proc_dointvec_minmax, 1813eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 1814eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 18155091faa4SMike Galbraith }, 18165091faa4SMike Galbraith #endif 1817ec12cb7fSPaul Turner #ifdef CONFIG_CFS_BANDWIDTH 1818ec12cb7fSPaul Turner { 1819ec12cb7fSPaul Turner .procname = "sched_cfs_bandwidth_slice_us", 1820ec12cb7fSPaul Turner .data = &sysctl_sched_cfs_bandwidth_slice, 1821ec12cb7fSPaul Turner .maxlen = sizeof(unsigned int), 1822ec12cb7fSPaul Turner .mode = 0644, 1823ec12cb7fSPaul Turner .proc_handler = proc_dointvec_minmax, 1824eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 1825ec12cb7fSPaul Turner }, 1826ec12cb7fSPaul Turner #endif 18278d5d0cfbSQuentin Perret #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL) 18288d5d0cfbSQuentin Perret { 18298d5d0cfbSQuentin Perret .procname = "sched_energy_aware", 18308d5d0cfbSQuentin Perret .data = &sysctl_sched_energy_aware, 18318d5d0cfbSQuentin Perret .maxlen = sizeof(unsigned int), 18328d5d0cfbSQuentin Perret .mode = 0644, 18338d5d0cfbSQuentin Perret .proc_handler = sched_energy_aware_handler, 1834eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 1835eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 18368d5d0cfbSQuentin Perret }, 18378d5d0cfbSQuentin Perret #endif 1838f20786ffSPeter Zijlstra #ifdef CONFIG_PROVE_LOCKING 1839f20786ffSPeter Zijlstra { 1840f20786ffSPeter Zijlstra .procname = "prove_locking", 1841f20786ffSPeter Zijlstra .data = &prove_locking, 1842f20786ffSPeter Zijlstra .maxlen = sizeof(int), 1843f20786ffSPeter Zijlstra .mode = 0644, 18446d456111SEric W. Biederman .proc_handler = proc_dointvec, 1845f20786ffSPeter Zijlstra }, 1846f20786ffSPeter Zijlstra #endif 1847f20786ffSPeter Zijlstra #ifdef CONFIG_LOCK_STAT 1848f20786ffSPeter Zijlstra { 1849f20786ffSPeter Zijlstra .procname = "lock_stat", 1850f20786ffSPeter Zijlstra .data = &lock_stat, 1851f20786ffSPeter Zijlstra .maxlen = sizeof(int), 1852f20786ffSPeter Zijlstra .mode = 0644, 18536d456111SEric W. Biederman .proc_handler = proc_dointvec, 1854f20786ffSPeter Zijlstra }, 1855f20786ffSPeter Zijlstra #endif 185677e54a1fSIngo Molnar { 18571da177e4SLinus Torvalds .procname = "panic", 18581da177e4SLinus Torvalds .data = &panic_timeout, 18591da177e4SLinus Torvalds .maxlen = sizeof(int), 18601da177e4SLinus Torvalds .mode = 0644, 18616d456111SEric W. Biederman .proc_handler = proc_dointvec, 18621da177e4SLinus Torvalds }, 1863046d662fSAlex Kelly #ifdef CONFIG_COREDUMP 18641da177e4SLinus Torvalds { 18651da177e4SLinus Torvalds .procname = "core_uses_pid", 18661da177e4SLinus Torvalds .data = &core_uses_pid, 18671da177e4SLinus Torvalds .maxlen = sizeof(int), 18681da177e4SLinus Torvalds .mode = 0644, 18696d456111SEric W. Biederman .proc_handler = proc_dointvec, 18701da177e4SLinus Torvalds }, 18711da177e4SLinus Torvalds { 18721da177e4SLinus Torvalds .procname = "core_pattern", 18731da177e4SLinus Torvalds .data = core_pattern, 187471ce92f3SDan Aloni .maxlen = CORENAME_MAX_SIZE, 18751da177e4SLinus Torvalds .mode = 0644, 187654b50199SKees Cook .proc_handler = proc_dostring_coredump, 18771da177e4SLinus Torvalds }, 1878a293980cSNeil Horman { 1879a293980cSNeil Horman .procname = "core_pipe_limit", 1880a293980cSNeil Horman .data = &core_pipe_limit, 1881a293980cSNeil Horman .maxlen = sizeof(unsigned int), 1882a293980cSNeil Horman .mode = 0644, 18836d456111SEric W. Biederman .proc_handler = proc_dointvec, 1884a293980cSNeil Horman }, 1885046d662fSAlex Kelly #endif 188634f5a398STheodore Ts'o #ifdef CONFIG_PROC_SYSCTL 18871da177e4SLinus Torvalds { 18881da177e4SLinus Torvalds .procname = "tainted", 188925ddbb18SAndi Kleen .maxlen = sizeof(long), 189034f5a398STheodore Ts'o .mode = 0644, 18916d456111SEric W. Biederman .proc_handler = proc_taint, 18921da177e4SLinus Torvalds }, 1893f4aacea2SKees Cook { 1894f4aacea2SKees Cook .procname = "sysctl_writes_strict", 1895f4aacea2SKees Cook .data = &sysctl_writes_strict, 1896f4aacea2SKees Cook .maxlen = sizeof(int), 1897f4aacea2SKees Cook .mode = 0644, 1898f4aacea2SKees Cook .proc_handler = proc_dointvec_minmax, 1899f4aacea2SKees Cook .extra1 = &neg_one, 1900eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 1901f4aacea2SKees Cook }, 190234f5a398STheodore Ts'o #endif 19039745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 19049745512cSArjan van de Ven { 19059745512cSArjan van de Ven .procname = "latencytop", 19069745512cSArjan van de Ven .data = &latencytop_enabled, 19079745512cSArjan van de Ven .maxlen = sizeof(int), 19089745512cSArjan van de Ven .mode = 0644, 1909cb251765SMel Gorman .proc_handler = sysctl_latencytop, 19109745512cSArjan van de Ven }, 19119745512cSArjan van de Ven #endif 19121da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD 19131da177e4SLinus Torvalds { 19141da177e4SLinus Torvalds .procname = "real-root-dev", 19151da177e4SLinus Torvalds .data = &real_root_dev, 19161da177e4SLinus Torvalds .maxlen = sizeof(int), 19171da177e4SLinus Torvalds .mode = 0644, 19186d456111SEric W. Biederman .proc_handler = proc_dointvec, 19191da177e4SLinus Torvalds }, 19201da177e4SLinus Torvalds #endif 192145807a1dSIngo Molnar { 192245807a1dSIngo Molnar .procname = "print-fatal-signals", 192345807a1dSIngo Molnar .data = &print_fatal_signals, 192445807a1dSIngo Molnar .maxlen = sizeof(int), 192545807a1dSIngo Molnar .mode = 0644, 19266d456111SEric W. Biederman .proc_handler = proc_dointvec, 192745807a1dSIngo Molnar }, 192872c57ed5SDavid S. Miller #ifdef CONFIG_SPARC 19291da177e4SLinus Torvalds { 19301da177e4SLinus Torvalds .procname = "reboot-cmd", 19311da177e4SLinus Torvalds .data = reboot_command, 19321da177e4SLinus Torvalds .maxlen = 256, 19331da177e4SLinus Torvalds .mode = 0644, 19346d456111SEric W. Biederman .proc_handler = proc_dostring, 19351da177e4SLinus Torvalds }, 19361da177e4SLinus Torvalds { 19371da177e4SLinus Torvalds .procname = "stop-a", 19381da177e4SLinus Torvalds .data = &stop_a_enabled, 19391da177e4SLinus Torvalds .maxlen = sizeof (int), 19401da177e4SLinus Torvalds .mode = 0644, 19416d456111SEric W. Biederman .proc_handler = proc_dointvec, 19421da177e4SLinus Torvalds }, 19431da177e4SLinus Torvalds { 19441da177e4SLinus Torvalds .procname = "scons-poweroff", 19451da177e4SLinus Torvalds .data = &scons_pwroff, 19461da177e4SLinus Torvalds .maxlen = sizeof (int), 19471da177e4SLinus Torvalds .mode = 0644, 19486d456111SEric W. Biederman .proc_handler = proc_dointvec, 19491da177e4SLinus Torvalds }, 19501da177e4SLinus Torvalds #endif 19510871420fSDavid S. Miller #ifdef CONFIG_SPARC64 19520871420fSDavid S. Miller { 19530871420fSDavid S. Miller .procname = "tsb-ratio", 19540871420fSDavid S. Miller .data = &sysctl_tsb_ratio, 19550871420fSDavid S. Miller .maxlen = sizeof (int), 19560871420fSDavid S. Miller .mode = 0644, 19576d456111SEric W. Biederman .proc_handler = proc_dointvec, 19580871420fSDavid S. Miller }, 19590871420fSDavid S. Miller #endif 1960b67114dbSHelge Deller #ifdef CONFIG_PARISC 19611da177e4SLinus Torvalds { 19621da177e4SLinus Torvalds .procname = "soft-power", 19631da177e4SLinus Torvalds .data = &pwrsw_enabled, 19641da177e4SLinus Torvalds .maxlen = sizeof (int), 19651da177e4SLinus Torvalds .mode = 0644, 19666d456111SEric W. Biederman .proc_handler = proc_dointvec, 19671da177e4SLinus Torvalds }, 1968bf14e3b9SVineet Gupta #endif 1969bf14e3b9SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW 19701da177e4SLinus Torvalds { 19711da177e4SLinus Torvalds .procname = "unaligned-trap", 19721da177e4SLinus Torvalds .data = &unaligned_enabled, 19731da177e4SLinus Torvalds .maxlen = sizeof (int), 19741da177e4SLinus Torvalds .mode = 0644, 19756d456111SEric W. Biederman .proc_handler = proc_dointvec, 19761da177e4SLinus Torvalds }, 19771da177e4SLinus Torvalds #endif 19781da177e4SLinus Torvalds { 19791da177e4SLinus Torvalds .procname = "ctrl-alt-del", 19801da177e4SLinus Torvalds .data = &C_A_D, 19811da177e4SLinus Torvalds .maxlen = sizeof(int), 19821da177e4SLinus Torvalds .mode = 0644, 19836d456111SEric W. Biederman .proc_handler = proc_dointvec, 19841da177e4SLinus Torvalds }, 1985606576ceSSteven Rostedt #ifdef CONFIG_FUNCTION_TRACER 1986b0fc494fSSteven Rostedt { 1987b0fc494fSSteven Rostedt .procname = "ftrace_enabled", 1988b0fc494fSSteven Rostedt .data = &ftrace_enabled, 1989b0fc494fSSteven Rostedt .maxlen = sizeof(int), 1990b0fc494fSSteven Rostedt .mode = 0644, 19916d456111SEric W. Biederman .proc_handler = ftrace_enable_sysctl, 1992b0fc494fSSteven Rostedt }, 1993b0fc494fSSteven Rostedt #endif 1994f38f1d2aSSteven Rostedt #ifdef CONFIG_STACK_TRACER 1995f38f1d2aSSteven Rostedt { 1996f38f1d2aSSteven Rostedt .procname = "stack_tracer_enabled", 1997f38f1d2aSSteven Rostedt .data = &stack_tracer_enabled, 1998f38f1d2aSSteven Rostedt .maxlen = sizeof(int), 1999f38f1d2aSSteven Rostedt .mode = 0644, 20006d456111SEric W. Biederman .proc_handler = stack_trace_sysctl, 2001f38f1d2aSSteven Rostedt }, 2002f38f1d2aSSteven Rostedt #endif 2003944ac425SSteven Rostedt #ifdef CONFIG_TRACING 2004944ac425SSteven Rostedt { 20053299b4ddSPeter Zijlstra .procname = "ftrace_dump_on_oops", 2006944ac425SSteven Rostedt .data = &ftrace_dump_on_oops, 2007944ac425SSteven Rostedt .maxlen = sizeof(int), 2008944ac425SSteven Rostedt .mode = 0644, 20096d456111SEric W. Biederman .proc_handler = proc_dointvec, 2010944ac425SSteven Rostedt }, 2011de7edd31SSteven Rostedt (Red Hat) { 2012de7edd31SSteven Rostedt (Red Hat) .procname = "traceoff_on_warning", 2013de7edd31SSteven Rostedt (Red Hat) .data = &__disable_trace_on_warning, 2014de7edd31SSteven Rostedt (Red Hat) .maxlen = sizeof(__disable_trace_on_warning), 2015de7edd31SSteven Rostedt (Red Hat) .mode = 0644, 2016de7edd31SSteven Rostedt (Red Hat) .proc_handler = proc_dointvec, 2017de7edd31SSteven Rostedt (Red Hat) }, 20180daa2302SSteven Rostedt (Red Hat) { 20190daa2302SSteven Rostedt (Red Hat) .procname = "tracepoint_printk", 20200daa2302SSteven Rostedt (Red Hat) .data = &tracepoint_printk, 20210daa2302SSteven Rostedt (Red Hat) .maxlen = sizeof(tracepoint_printk), 20220daa2302SSteven Rostedt (Red Hat) .mode = 0644, 202342391745SSteven Rostedt (Red Hat) .proc_handler = tracepoint_printk_sysctl, 20240daa2302SSteven Rostedt (Red Hat) }, 2025944ac425SSteven Rostedt #endif 20262965faa5SDave Young #ifdef CONFIG_KEXEC_CORE 20277984754bSKees Cook { 20287984754bSKees Cook .procname = "kexec_load_disabled", 20297984754bSKees Cook .data = &kexec_load_disabled, 20307984754bSKees Cook .maxlen = sizeof(int), 20317984754bSKees Cook .mode = 0644, 20327984754bSKees Cook /* only handle a transition from default "0" to "1" */ 20337984754bSKees Cook .proc_handler = proc_dointvec_minmax, 2034eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 2035eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 20367984754bSKees Cook }, 20377984754bSKees Cook #endif 2038a1ef5adbSJohannes Berg #ifdef CONFIG_MODULES 20391da177e4SLinus Torvalds { 20401da177e4SLinus Torvalds .procname = "modprobe", 20411da177e4SLinus Torvalds .data = &modprobe_path, 20421da177e4SLinus Torvalds .maxlen = KMOD_PATH_LEN, 20431da177e4SLinus Torvalds .mode = 0644, 20446d456111SEric W. Biederman .proc_handler = proc_dostring, 20451da177e4SLinus Torvalds }, 20463d43321bSKees Cook { 20473d43321bSKees Cook .procname = "modules_disabled", 20483d43321bSKees Cook .data = &modules_disabled, 20493d43321bSKees Cook .maxlen = sizeof(int), 20503d43321bSKees Cook .mode = 0644, 20513d43321bSKees Cook /* only handle a transition from default "0" to "1" */ 20526d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 2053eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 2054eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 20553d43321bSKees Cook }, 20561da177e4SLinus Torvalds #endif 205786d56134SMichael Marineau #ifdef CONFIG_UEVENT_HELPER 20581da177e4SLinus Torvalds { 20591da177e4SLinus Torvalds .procname = "hotplug", 2060312c004dSKay Sievers .data = &uevent_helper, 2061312c004dSKay Sievers .maxlen = UEVENT_HELPER_PATH_LEN, 20621da177e4SLinus Torvalds .mode = 0644, 20636d456111SEric W. Biederman .proc_handler = proc_dostring, 20641da177e4SLinus Torvalds }, 206586d56134SMichael Marineau #endif 20661da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG 20671da177e4SLinus Torvalds { 20681da177e4SLinus Torvalds .procname = "sg-big-buff", 20691da177e4SLinus Torvalds .data = &sg_big_buff, 20701da177e4SLinus Torvalds .maxlen = sizeof (int), 20711da177e4SLinus Torvalds .mode = 0444, 20726d456111SEric W. Biederman .proc_handler = proc_dointvec, 20731da177e4SLinus Torvalds }, 20741da177e4SLinus Torvalds #endif 20751da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT 20761da177e4SLinus Torvalds { 20771da177e4SLinus Torvalds .procname = "acct", 20781da177e4SLinus Torvalds .data = &acct_parm, 20791da177e4SLinus Torvalds .maxlen = 3*sizeof(int), 20801da177e4SLinus Torvalds .mode = 0644, 20816d456111SEric W. Biederman .proc_handler = proc_dointvec, 20821da177e4SLinus Torvalds }, 20831da177e4SLinus Torvalds #endif 20841da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ 20851da177e4SLinus Torvalds { 20861da177e4SLinus Torvalds .procname = "sysrq", 2087eaee4172SDmitry Safonov .data = NULL, 20881da177e4SLinus Torvalds .maxlen = sizeof (int), 20891da177e4SLinus Torvalds .mode = 0644, 209097f5f0cdSDmitry Torokhov .proc_handler = sysrq_sysctl_handler, 20911da177e4SLinus Torvalds }, 20921da177e4SLinus Torvalds #endif 2093d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL 20941da177e4SLinus Torvalds { 20951da177e4SLinus Torvalds .procname = "cad_pid", 20969ec52099SCedric Le Goater .data = NULL, 20971da177e4SLinus Torvalds .maxlen = sizeof (int), 20981da177e4SLinus Torvalds .mode = 0600, 20996d456111SEric W. Biederman .proc_handler = proc_do_cad_pid, 21001da177e4SLinus Torvalds }, 2101d6f8ff73SRandy Dunlap #endif 21021da177e4SLinus Torvalds { 21031da177e4SLinus Torvalds .procname = "threads-max", 210416db3d3fSHeinrich Schuchardt .data = NULL, 21051da177e4SLinus Torvalds .maxlen = sizeof(int), 21061da177e4SLinus Torvalds .mode = 0644, 210716db3d3fSHeinrich Schuchardt .proc_handler = sysctl_max_threads, 21081da177e4SLinus Torvalds }, 21091da177e4SLinus Torvalds { 21101da177e4SLinus Torvalds .procname = "random", 21111da177e4SLinus Torvalds .mode = 0555, 21121da177e4SLinus Torvalds .child = random_table, 21131da177e4SLinus Torvalds }, 21141da177e4SLinus Torvalds { 211517f60a7dSEric Paris .procname = "usermodehelper", 211617f60a7dSEric Paris .mode = 0555, 211717f60a7dSEric Paris .child = usermodehelper_table, 211817f60a7dSEric Paris }, 2119ceb18132SLuis R. Rodriguez #ifdef CONFIG_FW_LOADER_USER_HELPER 2120ceb18132SLuis R. Rodriguez { 2121ceb18132SLuis R. Rodriguez .procname = "firmware_config", 2122ceb18132SLuis R. Rodriguez .mode = 0555, 2123ceb18132SLuis R. Rodriguez .child = firmware_config_table, 2124ceb18132SLuis R. Rodriguez }, 2125ceb18132SLuis R. Rodriguez #endif 212617f60a7dSEric Paris { 21271da177e4SLinus Torvalds .procname = "overflowuid", 21281da177e4SLinus Torvalds .data = &overflowuid, 21291da177e4SLinus Torvalds .maxlen = sizeof(int), 21301da177e4SLinus Torvalds .mode = 0644, 21316d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 21321da177e4SLinus Torvalds .extra1 = &minolduid, 21331da177e4SLinus Torvalds .extra2 = &maxolduid, 21341da177e4SLinus Torvalds }, 21351da177e4SLinus Torvalds { 21361da177e4SLinus Torvalds .procname = "overflowgid", 21371da177e4SLinus Torvalds .data = &overflowgid, 21381da177e4SLinus Torvalds .maxlen = sizeof(int), 21391da177e4SLinus Torvalds .mode = 0644, 21406d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 21411da177e4SLinus Torvalds .extra1 = &minolduid, 21421da177e4SLinus Torvalds .extra2 = &maxolduid, 21431da177e4SLinus Torvalds }, 2144347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390 21451da177e4SLinus Torvalds { 21461da177e4SLinus Torvalds .procname = "userprocess_debug", 2147ab3c68eeSHeiko Carstens .data = &show_unhandled_signals, 21481da177e4SLinus Torvalds .maxlen = sizeof(int), 21491da177e4SLinus Torvalds .mode = 0644, 21506d456111SEric W. Biederman .proc_handler = proc_dointvec, 21511da177e4SLinus Torvalds }, 21521da177e4SLinus Torvalds #endif 21531da177e4SLinus Torvalds { 21541da177e4SLinus Torvalds .procname = "pid_max", 21551da177e4SLinus Torvalds .data = &pid_max, 21561da177e4SLinus Torvalds .maxlen = sizeof (int), 21571da177e4SLinus Torvalds .mode = 0644, 21586d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 21591da177e4SLinus Torvalds .extra1 = &pid_max_min, 21601da177e4SLinus Torvalds .extra2 = &pid_max_max, 21611da177e4SLinus Torvalds }, 21621da177e4SLinus Torvalds { 21631da177e4SLinus Torvalds .procname = "panic_on_oops", 21641da177e4SLinus Torvalds .data = &panic_on_oops, 21651da177e4SLinus Torvalds .maxlen = sizeof(int), 21661da177e4SLinus Torvalds .mode = 0644, 21676d456111SEric W. Biederman .proc_handler = proc_dointvec, 21681da177e4SLinus Torvalds }, 216981c9d43fSFeng Tang { 217081c9d43fSFeng Tang .procname = "panic_print", 217181c9d43fSFeng Tang .data = &panic_print, 217281c9d43fSFeng Tang .maxlen = sizeof(unsigned long), 217381c9d43fSFeng Tang .mode = 0644, 217481c9d43fSFeng Tang .proc_handler = proc_doulongvec_minmax, 217581c9d43fSFeng Tang }, 21767ef3d2fdSJoe Perches #if defined CONFIG_PRINTK 21777ef3d2fdSJoe Perches { 21787ef3d2fdSJoe Perches .procname = "printk", 21797ef3d2fdSJoe Perches .data = &console_loglevel, 21807ef3d2fdSJoe Perches .maxlen = 4*sizeof(int), 21817ef3d2fdSJoe Perches .mode = 0644, 21826d456111SEric W. Biederman .proc_handler = proc_dointvec, 21837ef3d2fdSJoe Perches }, 21841da177e4SLinus Torvalds { 21851da177e4SLinus Torvalds .procname = "printk_ratelimit", 2186717115e1SDave Young .data = &printk_ratelimit_state.interval, 21871da177e4SLinus Torvalds .maxlen = sizeof(int), 21881da177e4SLinus Torvalds .mode = 0644, 21896d456111SEric W. Biederman .proc_handler = proc_dointvec_jiffies, 21901da177e4SLinus Torvalds }, 21911da177e4SLinus Torvalds { 21921da177e4SLinus Torvalds .procname = "printk_ratelimit_burst", 2193717115e1SDave Young .data = &printk_ratelimit_state.burst, 21941da177e4SLinus Torvalds .maxlen = sizeof(int), 21951da177e4SLinus Torvalds .mode = 0644, 21966d456111SEric W. Biederman .proc_handler = proc_dointvec, 21971da177e4SLinus Torvalds }, 2198af91322eSDave Young { 2199af91322eSDave Young .procname = "printk_delay", 2200af91322eSDave Young .data = &printk_delay_msec, 2201af91322eSDave Young .maxlen = sizeof(int), 2202af91322eSDave Young .mode = 0644, 22036d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 2204eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2205af91322eSDave Young .extra2 = &ten_thousand, 2206af91322eSDave Young }, 22071da177e4SLinus Torvalds { 2208750afe7bSBorislav Petkov .procname = "printk_devkmsg", 2209750afe7bSBorislav Petkov .data = devkmsg_log_str, 2210750afe7bSBorislav Petkov .maxlen = DEVKMSG_STR_MAX_SIZE, 2211750afe7bSBorislav Petkov .mode = 0644, 2212750afe7bSBorislav Petkov .proc_handler = devkmsg_sysctl_set_loglvl, 2213750afe7bSBorislav Petkov }, 2214750afe7bSBorislav Petkov { 2215eaf06b24SDan Rosenberg .procname = "dmesg_restrict", 2216eaf06b24SDan Rosenberg .data = &dmesg_restrict, 2217eaf06b24SDan Rosenberg .maxlen = sizeof(int), 2218eaf06b24SDan Rosenberg .mode = 0644, 2219620f6e8eSKees Cook .proc_handler = proc_dointvec_minmax_sysadmin, 2220eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2221eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2222eaf06b24SDan Rosenberg }, 2223455cd5abSDan Rosenberg { 2224455cd5abSDan Rosenberg .procname = "kptr_restrict", 2225455cd5abSDan Rosenberg .data = &kptr_restrict, 2226455cd5abSDan Rosenberg .maxlen = sizeof(int), 2227455cd5abSDan Rosenberg .mode = 0644, 2228620f6e8eSKees Cook .proc_handler = proc_dointvec_minmax_sysadmin, 2229eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2230455cd5abSDan Rosenberg .extra2 = &two, 2231455cd5abSDan Rosenberg }, 2232df6e61d4SJoe Perches #endif 2233eaf06b24SDan Rosenberg { 22341da177e4SLinus Torvalds .procname = "ngroups_max", 22351da177e4SLinus Torvalds .data = &ngroups_max, 22361da177e4SLinus Torvalds .maxlen = sizeof (int), 22371da177e4SLinus Torvalds .mode = 0444, 22386d456111SEric W. Biederman .proc_handler = proc_dointvec, 22391da177e4SLinus Torvalds }, 224073efc039SDan Ballard { 224173efc039SDan Ballard .procname = "cap_last_cap", 224273efc039SDan Ballard .data = (void *)&cap_last_cap, 224373efc039SDan Ballard .maxlen = sizeof(int), 224473efc039SDan Ballard .mode = 0444, 224573efc039SDan Ballard .proc_handler = proc_dointvec, 224673efc039SDan Ballard }, 224758687acbSDon Zickus #if defined(CONFIG_LOCKUP_DETECTOR) 2248504d7cf1SDon Zickus { 224958687acbSDon Zickus .procname = "watchdog", 22503c00ea82SFrederic Weisbecker .data = &watchdog_user_enabled, 2251504d7cf1SDon Zickus .maxlen = sizeof(int), 2252504d7cf1SDon Zickus .mode = 0644, 2253195daf66SUlrich Obergfell .proc_handler = proc_watchdog, 2254eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2255eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 225658687acbSDon Zickus }, 225758687acbSDon Zickus { 225858687acbSDon Zickus .procname = "watchdog_thresh", 2259586692a5SMandeep Singh Baines .data = &watchdog_thresh, 226058687acbSDon Zickus .maxlen = sizeof(int), 226158687acbSDon Zickus .mode = 0644, 2262195daf66SUlrich Obergfell .proc_handler = proc_watchdog_thresh, 2263eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 226458687acbSDon Zickus .extra2 = &sixty, 2265504d7cf1SDon Zickus }, 22662508ce18SDon Zickus { 2267195daf66SUlrich Obergfell .procname = "nmi_watchdog", 22687feeb9cdSThomas Gleixner .data = &nmi_watchdog_user_enabled, 2269195daf66SUlrich Obergfell .maxlen = sizeof(int), 227051d4052bSThomas Gleixner .mode = NMI_WATCHDOG_SYSCTL_PERM, 2271195daf66SUlrich Obergfell .proc_handler = proc_nmi_watchdog, 2272eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2273eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2274195daf66SUlrich Obergfell }, 2275195daf66SUlrich Obergfell { 227605a4a952SNicholas Piggin .procname = "watchdog_cpumask", 227705a4a952SNicholas Piggin .data = &watchdog_cpumask_bits, 227805a4a952SNicholas Piggin .maxlen = NR_CPUS, 227905a4a952SNicholas Piggin .mode = 0644, 228005a4a952SNicholas Piggin .proc_handler = proc_watchdog_cpumask, 228105a4a952SNicholas Piggin }, 228205a4a952SNicholas Piggin #ifdef CONFIG_SOFTLOCKUP_DETECTOR 228305a4a952SNicholas Piggin { 2284195daf66SUlrich Obergfell .procname = "soft_watchdog", 22857feeb9cdSThomas Gleixner .data = &soft_watchdog_user_enabled, 2286195daf66SUlrich Obergfell .maxlen = sizeof(int), 2287195daf66SUlrich Obergfell .mode = 0644, 2288195daf66SUlrich Obergfell .proc_handler = proc_soft_watchdog, 2289eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2290eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2291195daf66SUlrich Obergfell }, 2292195daf66SUlrich Obergfell { 22932508ce18SDon Zickus .procname = "softlockup_panic", 22942508ce18SDon Zickus .data = &softlockup_panic, 22952508ce18SDon Zickus .maxlen = sizeof(int), 22962508ce18SDon Zickus .mode = 0644, 22972508ce18SDon Zickus .proc_handler = proc_dointvec_minmax, 2298eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2299eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 23002508ce18SDon Zickus }, 2301ed235875SAaron Tomlin #ifdef CONFIG_SMP 2302ed235875SAaron Tomlin { 2303ed235875SAaron Tomlin .procname = "softlockup_all_cpu_backtrace", 2304ed235875SAaron Tomlin .data = &sysctl_softlockup_all_cpu_backtrace, 2305ed235875SAaron Tomlin .maxlen = sizeof(int), 2306ed235875SAaron Tomlin .mode = 0644, 2307ed235875SAaron Tomlin .proc_handler = proc_dointvec_minmax, 2308eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2309eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2310ed235875SAaron Tomlin }, 231105a4a952SNicholas Piggin #endif /* CONFIG_SMP */ 231205a4a952SNicholas Piggin #endif 231305a4a952SNicholas Piggin #ifdef CONFIG_HARDLOCKUP_DETECTOR 231405a4a952SNicholas Piggin { 231505a4a952SNicholas Piggin .procname = "hardlockup_panic", 231605a4a952SNicholas Piggin .data = &hardlockup_panic, 231705a4a952SNicholas Piggin .maxlen = sizeof(int), 231805a4a952SNicholas Piggin .mode = 0644, 231905a4a952SNicholas Piggin .proc_handler = proc_dointvec_minmax, 2320eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2321eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 232205a4a952SNicholas Piggin }, 232305a4a952SNicholas Piggin #ifdef CONFIG_SMP 232455537871SJiri Kosina { 232555537871SJiri Kosina .procname = "hardlockup_all_cpu_backtrace", 232655537871SJiri Kosina .data = &sysctl_hardlockup_all_cpu_backtrace, 232755537871SJiri Kosina .maxlen = sizeof(int), 232855537871SJiri Kosina .mode = 0644, 232955537871SJiri Kosina .proc_handler = proc_dointvec_minmax, 2330eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2331eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 233255537871SJiri Kosina }, 2333ed235875SAaron Tomlin #endif /* CONFIG_SMP */ 23345dc30558SDon Zickus #endif 233505a4a952SNicholas Piggin #endif 233605a4a952SNicholas Piggin 23375dc30558SDon Zickus #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) 23385dc30558SDon Zickus { 23395dc30558SDon Zickus .procname = "unknown_nmi_panic", 23405dc30558SDon Zickus .data = &unknown_nmi_panic, 23415dc30558SDon Zickus .maxlen = sizeof (int), 23425dc30558SDon Zickus .mode = 0644, 23435dc30558SDon Zickus .proc_handler = proc_dointvec, 23445dc30558SDon Zickus }, 2345504d7cf1SDon Zickus #endif 2346b6522fa4SXiaoming Ni 2347b6522fa4SXiaoming Ni #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \ 2348b6522fa4SXiaoming Ni defined(CONFIG_DEBUG_STACKOVERFLOW) 2349b6522fa4SXiaoming Ni { 2350b6522fa4SXiaoming Ni .procname = "panic_on_stackoverflow", 2351b6522fa4SXiaoming Ni .data = &sysctl_panic_on_stackoverflow, 2352b6522fa4SXiaoming Ni .maxlen = sizeof(int), 2353b6522fa4SXiaoming Ni .mode = 0644, 2354b6522fa4SXiaoming Ni .proc_handler = proc_dointvec, 2355b6522fa4SXiaoming Ni }, 2356b6522fa4SXiaoming Ni #endif 23571da177e4SLinus Torvalds #if defined(CONFIG_X86) 23581da177e4SLinus Torvalds { 23598da5addaSDon Zickus .procname = "panic_on_unrecovered_nmi", 23608da5addaSDon Zickus .data = &panic_on_unrecovered_nmi, 23618da5addaSDon Zickus .maxlen = sizeof(int), 23628da5addaSDon Zickus .mode = 0644, 23636d456111SEric W. Biederman .proc_handler = proc_dointvec, 23648da5addaSDon Zickus }, 23658da5addaSDon Zickus { 23665211a242SKurt Garloff .procname = "panic_on_io_nmi", 23675211a242SKurt Garloff .data = &panic_on_io_nmi, 23685211a242SKurt Garloff .maxlen = sizeof(int), 23695211a242SKurt Garloff .mode = 0644, 23706d456111SEric W. Biederman .proc_handler = proc_dointvec, 23715211a242SKurt Garloff }, 23725211a242SKurt Garloff { 23731da177e4SLinus Torvalds .procname = "bootloader_type", 23741da177e4SLinus Torvalds .data = &bootloader_type, 23751da177e4SLinus Torvalds .maxlen = sizeof (int), 23761da177e4SLinus Torvalds .mode = 0444, 23776d456111SEric W. Biederman .proc_handler = proc_dointvec, 23781da177e4SLinus Torvalds }, 23790741f4d2SChuck Ebbert { 23805031296cSH. Peter Anvin .procname = "bootloader_version", 23815031296cSH. Peter Anvin .data = &bootloader_version, 23825031296cSH. Peter Anvin .maxlen = sizeof (int), 23835031296cSH. Peter Anvin .mode = 0444, 23846d456111SEric W. Biederman .proc_handler = proc_dointvec, 23855031296cSH. Peter Anvin }, 23865031296cSH. Peter Anvin { 23876e7c4025SIngo Molnar .procname = "io_delay_type", 23886e7c4025SIngo Molnar .data = &io_delay_type, 23896e7c4025SIngo Molnar .maxlen = sizeof(int), 23906e7c4025SIngo Molnar .mode = 0644, 23916d456111SEric W. Biederman .proc_handler = proc_dointvec, 23926e7c4025SIngo Molnar }, 23931da177e4SLinus Torvalds #endif 23947a9166e3SLuke Yang #if defined(CONFIG_MMU) 23951da177e4SLinus Torvalds { 23961da177e4SLinus Torvalds .procname = "randomize_va_space", 23971da177e4SLinus Torvalds .data = &randomize_va_space, 23981da177e4SLinus Torvalds .maxlen = sizeof(int), 23991da177e4SLinus Torvalds .mode = 0644, 24006d456111SEric W. Biederman .proc_handler = proc_dointvec, 24011da177e4SLinus Torvalds }, 24027a9166e3SLuke Yang #endif 24030152fb37SMartin Schwidefsky #if defined(CONFIG_S390) && defined(CONFIG_SMP) 2404951f22d5SMartin Schwidefsky { 2405951f22d5SMartin Schwidefsky .procname = "spin_retry", 2406951f22d5SMartin Schwidefsky .data = &spin_retry, 2407951f22d5SMartin Schwidefsky .maxlen = sizeof (int), 2408951f22d5SMartin Schwidefsky .mode = 0644, 24096d456111SEric W. Biederman .proc_handler = proc_dointvec, 2410951f22d5SMartin Schwidefsky }, 2411951f22d5SMartin Schwidefsky #endif 2412673d5b43SLen Brown #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86) 2413c255d844SPavel Machek { 2414c255d844SPavel Machek .procname = "acpi_video_flags", 241577afcf78SPavel Machek .data = &acpi_realmode_flags, 2416c255d844SPavel Machek .maxlen = sizeof (unsigned long), 2417c255d844SPavel Machek .mode = 0644, 24186d456111SEric W. Biederman .proc_handler = proc_doulongvec_minmax, 2419c255d844SPavel Machek }, 2420c255d844SPavel Machek #endif 2421b6fca725SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN 2422d2b176edSJes Sorensen { 2423d2b176edSJes Sorensen .procname = "ignore-unaligned-usertrap", 2424d2b176edSJes Sorensen .data = &no_unaligned_warning, 2425d2b176edSJes Sorensen .maxlen = sizeof (int), 2426d2b176edSJes Sorensen .mode = 0644, 24276d456111SEric W. Biederman .proc_handler = proc_dointvec, 2428d2b176edSJes Sorensen }, 2429b6fca725SVineet Gupta #endif 2430b6fca725SVineet Gupta #ifdef CONFIG_IA64 243188fc241fSDoug Chapman { 243288fc241fSDoug Chapman .procname = "unaligned-dump-stack", 243388fc241fSDoug Chapman .data = &unaligned_dump_stack, 243488fc241fSDoug Chapman .maxlen = sizeof (int), 243588fc241fSDoug Chapman .mode = 0644, 24366d456111SEric W. Biederman .proc_handler = proc_dointvec, 243788fc241fSDoug Chapman }, 2438d2b176edSJes Sorensen #endif 2439e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK 2440*0ec9dc9bSGuilherme G. Piccoli #ifdef CONFIG_SMP 2441*0ec9dc9bSGuilherme G. Piccoli { 2442*0ec9dc9bSGuilherme G. Piccoli .procname = "hung_task_all_cpu_backtrace", 2443*0ec9dc9bSGuilherme G. Piccoli .data = &sysctl_hung_task_all_cpu_backtrace, 2444*0ec9dc9bSGuilherme G. Piccoli .maxlen = sizeof(int), 2445*0ec9dc9bSGuilherme G. Piccoli .mode = 0644, 2446*0ec9dc9bSGuilherme G. Piccoli .proc_handler = proc_dointvec_minmax, 2447*0ec9dc9bSGuilherme G. Piccoli .extra1 = SYSCTL_ZERO, 2448*0ec9dc9bSGuilherme G. Piccoli .extra2 = SYSCTL_ONE, 2449*0ec9dc9bSGuilherme G. Piccoli }, 2450*0ec9dc9bSGuilherme G. Piccoli #endif /* CONFIG_SMP */ 2451e162b39aSMandeep Singh Baines { 2452e162b39aSMandeep Singh Baines .procname = "hung_task_panic", 2453e162b39aSMandeep Singh Baines .data = &sysctl_hung_task_panic, 2454e162b39aSMandeep Singh Baines .maxlen = sizeof(int), 2455e162b39aSMandeep Singh Baines .mode = 0644, 24566d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 2457eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2458eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2459e162b39aSMandeep Singh Baines }, 246082a1fcb9SIngo Molnar { 246182a1fcb9SIngo Molnar .procname = "hung_task_check_count", 246282a1fcb9SIngo Molnar .data = &sysctl_hung_task_check_count, 2463cd64647fSLi Zefan .maxlen = sizeof(int), 246482a1fcb9SIngo Molnar .mode = 0644, 2465cd64647fSLi Zefan .proc_handler = proc_dointvec_minmax, 2466eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 246782a1fcb9SIngo Molnar }, 246882a1fcb9SIngo Molnar { 246982a1fcb9SIngo Molnar .procname = "hung_task_timeout_secs", 247082a1fcb9SIngo Molnar .data = &sysctl_hung_task_timeout_secs, 247190739081SIngo Molnar .maxlen = sizeof(unsigned long), 247282a1fcb9SIngo Molnar .mode = 0644, 24736d456111SEric W. Biederman .proc_handler = proc_dohung_task_timeout_secs, 247480df2847SLiu Hua .extra2 = &hung_task_timeout_max, 247582a1fcb9SIngo Molnar }, 247682a1fcb9SIngo Molnar { 2477a2e51445SDmitry Vyukov .procname = "hung_task_check_interval_secs", 2478a2e51445SDmitry Vyukov .data = &sysctl_hung_task_check_interval_secs, 2479a2e51445SDmitry Vyukov .maxlen = sizeof(unsigned long), 2480a2e51445SDmitry Vyukov .mode = 0644, 2481a2e51445SDmitry Vyukov .proc_handler = proc_dohung_task_timeout_secs, 2482a2e51445SDmitry Vyukov .extra2 = &hung_task_timeout_max, 2483a2e51445SDmitry Vyukov }, 2484a2e51445SDmitry Vyukov { 248582a1fcb9SIngo Molnar .procname = "hung_task_warnings", 248682a1fcb9SIngo Molnar .data = &sysctl_hung_task_warnings, 2487270750dbSAaron Tomlin .maxlen = sizeof(int), 248882a1fcb9SIngo Molnar .mode = 0644, 2489270750dbSAaron Tomlin .proc_handler = proc_dointvec_minmax, 2490270750dbSAaron Tomlin .extra1 = &neg_one, 249182a1fcb9SIngo Molnar }, 2492c4f3b63fSRavikiran G Thirumalai #endif 249323f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES 249423f78d4aSIngo Molnar { 249523f78d4aSIngo Molnar .procname = "max_lock_depth", 249623f78d4aSIngo Molnar .data = &max_lock_depth, 249723f78d4aSIngo Molnar .maxlen = sizeof(int), 249823f78d4aSIngo Molnar .mode = 0644, 24996d456111SEric W. Biederman .proc_handler = proc_dointvec, 250023f78d4aSIngo Molnar }, 250123f78d4aSIngo Molnar #endif 250210a0a8d4SJeremy Fitzhardinge { 250310a0a8d4SJeremy Fitzhardinge .procname = "poweroff_cmd", 250410a0a8d4SJeremy Fitzhardinge .data = &poweroff_cmd, 250510a0a8d4SJeremy Fitzhardinge .maxlen = POWEROFF_CMD_PATH_LEN, 250610a0a8d4SJeremy Fitzhardinge .mode = 0644, 25076d456111SEric W. Biederman .proc_handler = proc_dostring, 250810a0a8d4SJeremy Fitzhardinge }, 25090b77f5bfSDavid Howells #ifdef CONFIG_KEYS 25100b77f5bfSDavid Howells { 25110b77f5bfSDavid Howells .procname = "keys", 25120b77f5bfSDavid Howells .mode = 0555, 25130b77f5bfSDavid Howells .child = key_sysctls, 25140b77f5bfSDavid Howells }, 25150b77f5bfSDavid Howells #endif 2516cdd6c482SIngo Molnar #ifdef CONFIG_PERF_EVENTS 2517aa4a2218SVince Weaver /* 2518aa4a2218SVince Weaver * User-space scripts rely on the existence of this file 2519aa4a2218SVince Weaver * as a feature check for perf_events being enabled. 2520aa4a2218SVince Weaver * 2521aa4a2218SVince Weaver * So it's an ABI, do not remove! 2522aa4a2218SVince Weaver */ 25231ccd1549SPeter Zijlstra { 2524cdd6c482SIngo Molnar .procname = "perf_event_paranoid", 2525cdd6c482SIngo Molnar .data = &sysctl_perf_event_paranoid, 2526cdd6c482SIngo Molnar .maxlen = sizeof(sysctl_perf_event_paranoid), 25271ccd1549SPeter Zijlstra .mode = 0644, 25286d456111SEric W. Biederman .proc_handler = proc_dointvec, 25291ccd1549SPeter Zijlstra }, 2530c5078f78SPeter Zijlstra { 2531cdd6c482SIngo Molnar .procname = "perf_event_mlock_kb", 2532cdd6c482SIngo Molnar .data = &sysctl_perf_event_mlock, 2533cdd6c482SIngo Molnar .maxlen = sizeof(sysctl_perf_event_mlock), 2534c5078f78SPeter Zijlstra .mode = 0644, 25356d456111SEric W. Biederman .proc_handler = proc_dointvec, 2536c5078f78SPeter Zijlstra }, 2537a78ac325SPeter Zijlstra { 2538cdd6c482SIngo Molnar .procname = "perf_event_max_sample_rate", 2539cdd6c482SIngo Molnar .data = &sysctl_perf_event_sample_rate, 2540cdd6c482SIngo Molnar .maxlen = sizeof(sysctl_perf_event_sample_rate), 2541a78ac325SPeter Zijlstra .mode = 0644, 2542163ec435SPeter Zijlstra .proc_handler = perf_proc_update_handler, 2543eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 2544a78ac325SPeter Zijlstra }, 254514c63f17SDave Hansen { 254614c63f17SDave Hansen .procname = "perf_cpu_time_max_percent", 254714c63f17SDave Hansen .data = &sysctl_perf_cpu_time_max_percent, 254814c63f17SDave Hansen .maxlen = sizeof(sysctl_perf_cpu_time_max_percent), 254914c63f17SDave Hansen .mode = 0644, 255014c63f17SDave Hansen .proc_handler = perf_cpu_time_max_percent_handler, 2551eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 255214c63f17SDave Hansen .extra2 = &one_hundred, 255314c63f17SDave Hansen }, 2554c5dfd78eSArnaldo Carvalho de Melo { 2555c5dfd78eSArnaldo Carvalho de Melo .procname = "perf_event_max_stack", 2556a831100aSArnaldo Carvalho de Melo .data = &sysctl_perf_event_max_stack, 2557c5dfd78eSArnaldo Carvalho de Melo .maxlen = sizeof(sysctl_perf_event_max_stack), 2558c5dfd78eSArnaldo Carvalho de Melo .mode = 0644, 2559c5dfd78eSArnaldo Carvalho de Melo .proc_handler = perf_event_max_stack_handler, 2560eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2561c5dfd78eSArnaldo Carvalho de Melo .extra2 = &six_hundred_forty_kb, 2562c5dfd78eSArnaldo Carvalho de Melo }, 2563c85b0334SArnaldo Carvalho de Melo { 2564c85b0334SArnaldo Carvalho de Melo .procname = "perf_event_max_contexts_per_stack", 2565c85b0334SArnaldo Carvalho de Melo .data = &sysctl_perf_event_max_contexts_per_stack, 2566c85b0334SArnaldo Carvalho de Melo .maxlen = sizeof(sysctl_perf_event_max_contexts_per_stack), 2567c85b0334SArnaldo Carvalho de Melo .mode = 0644, 2568c85b0334SArnaldo Carvalho de Melo .proc_handler = perf_event_max_stack_handler, 2569eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2570c85b0334SArnaldo Carvalho de Melo .extra2 = &one_thousand, 2571c85b0334SArnaldo Carvalho de Melo }, 25721ccd1549SPeter Zijlstra #endif 25739e3961a0SPrarit Bhargava { 25749e3961a0SPrarit Bhargava .procname = "panic_on_warn", 25759e3961a0SPrarit Bhargava .data = &panic_on_warn, 25769e3961a0SPrarit Bhargava .maxlen = sizeof(int), 25779e3961a0SPrarit Bhargava .mode = 0644, 25789e3961a0SPrarit Bhargava .proc_handler = proc_dointvec_minmax, 2579eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2580eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 25819e3961a0SPrarit Bhargava }, 2582bc7a34b8SThomas Gleixner #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 2583bc7a34b8SThomas Gleixner { 2584bc7a34b8SThomas Gleixner .procname = "timer_migration", 2585bc7a34b8SThomas Gleixner .data = &sysctl_timer_migration, 2586bc7a34b8SThomas Gleixner .maxlen = sizeof(unsigned int), 2587bc7a34b8SThomas Gleixner .mode = 0644, 2588bc7a34b8SThomas Gleixner .proc_handler = timer_migration_handler, 2589eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2590eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2591bc7a34b8SThomas Gleixner }, 2592bc7a34b8SThomas Gleixner #endif 25931be7f75dSAlexei Starovoitov #ifdef CONFIG_BPF_SYSCALL 25941be7f75dSAlexei Starovoitov { 25951be7f75dSAlexei Starovoitov .procname = "unprivileged_bpf_disabled", 25961be7f75dSAlexei Starovoitov .data = &sysctl_unprivileged_bpf_disabled, 25971be7f75dSAlexei Starovoitov .maxlen = sizeof(sysctl_unprivileged_bpf_disabled), 25981be7f75dSAlexei Starovoitov .mode = 0644, 25991be7f75dSAlexei Starovoitov /* only handle a transition from default "0" to "1" */ 26001be7f75dSAlexei Starovoitov .proc_handler = proc_dointvec_minmax, 2601eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 2602eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 26031be7f75dSAlexei Starovoitov }, 2604492ecee8SAlexei Starovoitov { 2605492ecee8SAlexei Starovoitov .procname = "bpf_stats_enabled", 2606a8e11e5cSEric Dumazet .data = &bpf_stats_enabled_key.key, 2607a8e11e5cSEric Dumazet .maxlen = sizeof(bpf_stats_enabled_key), 2608492ecee8SAlexei Starovoitov .mode = 0644, 2609d46edd67SSong Liu .proc_handler = bpf_stats_handler, 2610492ecee8SAlexei Starovoitov }, 26113fcc5530SAlexei Starovoitov #endif 2612b3e627d3SLai Jiangshan #if defined(CONFIG_TREE_RCU) 2613088e9d25SDaniel Bristot de Oliveira { 2614088e9d25SDaniel Bristot de Oliveira .procname = "panic_on_rcu_stall", 2615088e9d25SDaniel Bristot de Oliveira .data = &sysctl_panic_on_rcu_stall, 2616088e9d25SDaniel Bristot de Oliveira .maxlen = sizeof(sysctl_panic_on_rcu_stall), 2617088e9d25SDaniel Bristot de Oliveira .mode = 0644, 2618088e9d25SDaniel Bristot de Oliveira .proc_handler = proc_dointvec_minmax, 2619eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2620eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2621088e9d25SDaniel Bristot de Oliveira }, 2622088e9d25SDaniel Bristot de Oliveira #endif 2623964c9dffSAlexander Popov #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE 2624964c9dffSAlexander Popov { 2625964c9dffSAlexander Popov .procname = "stack_erasing", 2626964c9dffSAlexander Popov .data = NULL, 2627964c9dffSAlexander Popov .maxlen = sizeof(int), 2628964c9dffSAlexander Popov .mode = 0600, 2629964c9dffSAlexander Popov .proc_handler = stack_erasing_sysctl, 2630eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2631eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 2632964c9dffSAlexander Popov }, 2633964c9dffSAlexander Popov #endif 26346fce56ecSEric W. Biederman { } 26351da177e4SLinus Torvalds }; 26361da177e4SLinus Torvalds 2637d8217f07SEric W. Biederman static struct ctl_table vm_table[] = { 26381da177e4SLinus Torvalds { 26391da177e4SLinus Torvalds .procname = "overcommit_memory", 26401da177e4SLinus Torvalds .data = &sysctl_overcommit_memory, 26411da177e4SLinus Torvalds .maxlen = sizeof(sysctl_overcommit_memory), 26421da177e4SLinus Torvalds .mode = 0644, 2643cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 2644eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2645cb16e95fSPetr Holasek .extra2 = &two, 26461da177e4SLinus Torvalds }, 26471da177e4SLinus Torvalds { 2648fadd8fbdSKAMEZAWA Hiroyuki .procname = "panic_on_oom", 2649fadd8fbdSKAMEZAWA Hiroyuki .data = &sysctl_panic_on_oom, 2650fadd8fbdSKAMEZAWA Hiroyuki .maxlen = sizeof(sysctl_panic_on_oom), 2651fadd8fbdSKAMEZAWA Hiroyuki .mode = 0644, 2652cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 2653eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2654cb16e95fSPetr Holasek .extra2 = &two, 2655fadd8fbdSKAMEZAWA Hiroyuki }, 2656fadd8fbdSKAMEZAWA Hiroyuki { 2657fe071d7eSDavid Rientjes .procname = "oom_kill_allocating_task", 2658fe071d7eSDavid Rientjes .data = &sysctl_oom_kill_allocating_task, 2659fe071d7eSDavid Rientjes .maxlen = sizeof(sysctl_oom_kill_allocating_task), 2660fe071d7eSDavid Rientjes .mode = 0644, 26616d456111SEric W. Biederman .proc_handler = proc_dointvec, 2662fe071d7eSDavid Rientjes }, 2663fe071d7eSDavid Rientjes { 2664fef1bdd6SDavid Rientjes .procname = "oom_dump_tasks", 2665fef1bdd6SDavid Rientjes .data = &sysctl_oom_dump_tasks, 2666fef1bdd6SDavid Rientjes .maxlen = sizeof(sysctl_oom_dump_tasks), 2667fef1bdd6SDavid Rientjes .mode = 0644, 26686d456111SEric W. Biederman .proc_handler = proc_dointvec, 2669fef1bdd6SDavid Rientjes }, 2670fef1bdd6SDavid Rientjes { 26711da177e4SLinus Torvalds .procname = "overcommit_ratio", 26721da177e4SLinus Torvalds .data = &sysctl_overcommit_ratio, 26731da177e4SLinus Torvalds .maxlen = sizeof(sysctl_overcommit_ratio), 26741da177e4SLinus Torvalds .mode = 0644, 267549f0ce5fSJerome Marchand .proc_handler = overcommit_ratio_handler, 267649f0ce5fSJerome Marchand }, 267749f0ce5fSJerome Marchand { 267849f0ce5fSJerome Marchand .procname = "overcommit_kbytes", 267949f0ce5fSJerome Marchand .data = &sysctl_overcommit_kbytes, 268049f0ce5fSJerome Marchand .maxlen = sizeof(sysctl_overcommit_kbytes), 268149f0ce5fSJerome Marchand .mode = 0644, 268249f0ce5fSJerome Marchand .proc_handler = overcommit_kbytes_handler, 26831da177e4SLinus Torvalds }, 26841da177e4SLinus Torvalds { 26851da177e4SLinus Torvalds .procname = "page-cluster", 26861da177e4SLinus Torvalds .data = &page_cluster, 26871da177e4SLinus Torvalds .maxlen = sizeof(int), 26881da177e4SLinus Torvalds .mode = 0644, 2689cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 2690eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 26911da177e4SLinus Torvalds }, 26921da177e4SLinus Torvalds { 26931da177e4SLinus Torvalds .procname = "dirty_background_ratio", 26941da177e4SLinus Torvalds .data = &dirty_background_ratio, 26951da177e4SLinus Torvalds .maxlen = sizeof(dirty_background_ratio), 26961da177e4SLinus Torvalds .mode = 0644, 26976d456111SEric W. Biederman .proc_handler = dirty_background_ratio_handler, 2698eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 26991da177e4SLinus Torvalds .extra2 = &one_hundred, 27001da177e4SLinus Torvalds }, 27011da177e4SLinus Torvalds { 27022da02997SDavid Rientjes .procname = "dirty_background_bytes", 27032da02997SDavid Rientjes .data = &dirty_background_bytes, 27042da02997SDavid Rientjes .maxlen = sizeof(dirty_background_bytes), 27052da02997SDavid Rientjes .mode = 0644, 27066d456111SEric W. Biederman .proc_handler = dirty_background_bytes_handler, 2707fc3501d4SSven Wegener .extra1 = &one_ul, 27082da02997SDavid Rientjes }, 27092da02997SDavid Rientjes { 27101da177e4SLinus Torvalds .procname = "dirty_ratio", 27111da177e4SLinus Torvalds .data = &vm_dirty_ratio, 27121da177e4SLinus Torvalds .maxlen = sizeof(vm_dirty_ratio), 27131da177e4SLinus Torvalds .mode = 0644, 27146d456111SEric W. Biederman .proc_handler = dirty_ratio_handler, 2715eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 27161da177e4SLinus Torvalds .extra2 = &one_hundred, 27171da177e4SLinus Torvalds }, 27181da177e4SLinus Torvalds { 27192da02997SDavid Rientjes .procname = "dirty_bytes", 27202da02997SDavid Rientjes .data = &vm_dirty_bytes, 27212da02997SDavid Rientjes .maxlen = sizeof(vm_dirty_bytes), 27222da02997SDavid Rientjes .mode = 0644, 27236d456111SEric W. Biederman .proc_handler = dirty_bytes_handler, 27249e4a5bdaSAndrea Righi .extra1 = &dirty_bytes_min, 27252da02997SDavid Rientjes }, 27262da02997SDavid Rientjes { 27271da177e4SLinus Torvalds .procname = "dirty_writeback_centisecs", 2728f6ef9438SBart Samwel .data = &dirty_writeback_interval, 2729f6ef9438SBart Samwel .maxlen = sizeof(dirty_writeback_interval), 27301da177e4SLinus Torvalds .mode = 0644, 27316d456111SEric W. Biederman .proc_handler = dirty_writeback_centisecs_handler, 27321da177e4SLinus Torvalds }, 27331da177e4SLinus Torvalds { 27341da177e4SLinus Torvalds .procname = "dirty_expire_centisecs", 2735f6ef9438SBart Samwel .data = &dirty_expire_interval, 2736f6ef9438SBart Samwel .maxlen = sizeof(dirty_expire_interval), 27371da177e4SLinus Torvalds .mode = 0644, 2738cb16e95fSPetr Holasek .proc_handler = proc_dointvec_minmax, 2739eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 27401da177e4SLinus Torvalds }, 27411da177e4SLinus Torvalds { 27421efff914STheodore Ts'o .procname = "dirtytime_expire_seconds", 27431efff914STheodore Ts'o .data = &dirtytime_expire_interval, 27442d87b309SRandy Dunlap .maxlen = sizeof(dirtytime_expire_interval), 27451efff914STheodore Ts'o .mode = 0644, 27461efff914STheodore Ts'o .proc_handler = dirtytime_interval_handler, 2747eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 27481efff914STheodore Ts'o }, 27491efff914STheodore Ts'o { 27501da177e4SLinus Torvalds .procname = "swappiness", 27511da177e4SLinus Torvalds .data = &vm_swappiness, 27521da177e4SLinus Torvalds .maxlen = sizeof(vm_swappiness), 27531da177e4SLinus Torvalds .mode = 0644, 27546d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 2755eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2756c843966cSJohannes Weiner .extra2 = &two_hundred, 27571da177e4SLinus Torvalds }, 27581da177e4SLinus Torvalds #ifdef CONFIG_HUGETLB_PAGE 27591da177e4SLinus Torvalds { 27601da177e4SLinus Torvalds .procname = "nr_hugepages", 2761e5ff2159SAndi Kleen .data = NULL, 27621da177e4SLinus Torvalds .maxlen = sizeof(unsigned long), 27631da177e4SLinus Torvalds .mode = 0644, 27646d456111SEric W. Biederman .proc_handler = hugetlb_sysctl_handler, 27651da177e4SLinus Torvalds }, 276606808b08SLee Schermerhorn #ifdef CONFIG_NUMA 276706808b08SLee Schermerhorn { 276806808b08SLee Schermerhorn .procname = "nr_hugepages_mempolicy", 276906808b08SLee Schermerhorn .data = NULL, 277006808b08SLee Schermerhorn .maxlen = sizeof(unsigned long), 277106808b08SLee Schermerhorn .mode = 0644, 277206808b08SLee Schermerhorn .proc_handler = &hugetlb_mempolicy_sysctl_handler, 277306808b08SLee Schermerhorn }, 27744518085eSKemi Wang { 27754518085eSKemi Wang .procname = "numa_stat", 27764518085eSKemi Wang .data = &sysctl_vm_numa_stat, 27774518085eSKemi Wang .maxlen = sizeof(int), 27784518085eSKemi Wang .mode = 0644, 27794518085eSKemi Wang .proc_handler = sysctl_vm_numa_stat_handler, 2780eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2781eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 27824518085eSKemi Wang }, 278306808b08SLee Schermerhorn #endif 27841da177e4SLinus Torvalds { 27851da177e4SLinus Torvalds .procname = "hugetlb_shm_group", 27861da177e4SLinus Torvalds .data = &sysctl_hugetlb_shm_group, 27871da177e4SLinus Torvalds .maxlen = sizeof(gid_t), 27881da177e4SLinus Torvalds .mode = 0644, 27896d456111SEric W. Biederman .proc_handler = proc_dointvec, 27901da177e4SLinus Torvalds }, 2791396faf03SMel Gorman { 2792d1c3fb1fSNishanth Aravamudan .procname = "nr_overcommit_hugepages", 2793e5ff2159SAndi Kleen .data = NULL, 2794e5ff2159SAndi Kleen .maxlen = sizeof(unsigned long), 2795d1c3fb1fSNishanth Aravamudan .mode = 0644, 27966d456111SEric W. Biederman .proc_handler = hugetlb_overcommit_handler, 2797d1c3fb1fSNishanth Aravamudan }, 27981da177e4SLinus Torvalds #endif 27991da177e4SLinus Torvalds { 28001da177e4SLinus Torvalds .procname = "lowmem_reserve_ratio", 28011da177e4SLinus Torvalds .data = &sysctl_lowmem_reserve_ratio, 28021da177e4SLinus Torvalds .maxlen = sizeof(sysctl_lowmem_reserve_ratio), 28031da177e4SLinus Torvalds .mode = 0644, 28046d456111SEric W. Biederman .proc_handler = lowmem_reserve_ratio_sysctl_handler, 28051da177e4SLinus Torvalds }, 28061da177e4SLinus Torvalds { 28079d0243bcSAndrew Morton .procname = "drop_caches", 28089d0243bcSAndrew Morton .data = &sysctl_drop_caches, 28099d0243bcSAndrew Morton .maxlen = sizeof(int), 2810204cb79aSJohannes Weiner .mode = 0200, 28119d0243bcSAndrew Morton .proc_handler = drop_caches_sysctl_handler, 2812eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 28135509a5d2SDave Hansen .extra2 = &four, 28149d0243bcSAndrew Morton }, 281576ab0f53SMel Gorman #ifdef CONFIG_COMPACTION 281676ab0f53SMel Gorman { 281776ab0f53SMel Gorman .procname = "compact_memory", 281876ab0f53SMel Gorman .data = &sysctl_compact_memory, 281976ab0f53SMel Gorman .maxlen = sizeof(int), 282076ab0f53SMel Gorman .mode = 0200, 282176ab0f53SMel Gorman .proc_handler = sysctl_compaction_handler, 282276ab0f53SMel Gorman }, 28235e771905SMel Gorman { 28245e771905SMel Gorman .procname = "extfrag_threshold", 28255e771905SMel Gorman .data = &sysctl_extfrag_threshold, 28265e771905SMel Gorman .maxlen = sizeof(int), 28275e771905SMel Gorman .mode = 0644, 28286b7e5cadSMatthew Wilcox .proc_handler = proc_dointvec_minmax, 28295e771905SMel Gorman .extra1 = &min_extfrag_threshold, 28305e771905SMel Gorman .extra2 = &max_extfrag_threshold, 28315e771905SMel Gorman }, 28325bbe3547SEric B Munson { 28335bbe3547SEric B Munson .procname = "compact_unevictable_allowed", 28345bbe3547SEric B Munson .data = &sysctl_compact_unevictable_allowed, 28355bbe3547SEric B Munson .maxlen = sizeof(int), 28365bbe3547SEric B Munson .mode = 0644, 28376923aa0dSSebastian Andrzej Siewior .proc_handler = proc_dointvec_minmax_warn_RT_change, 2838eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2839eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 28405bbe3547SEric B Munson }, 28415e771905SMel Gorman 284276ab0f53SMel Gorman #endif /* CONFIG_COMPACTION */ 28439d0243bcSAndrew Morton { 28441da177e4SLinus Torvalds .procname = "min_free_kbytes", 28451da177e4SLinus Torvalds .data = &min_free_kbytes, 28461da177e4SLinus Torvalds .maxlen = sizeof(min_free_kbytes), 28471da177e4SLinus Torvalds .mode = 0644, 28486d456111SEric W. Biederman .proc_handler = min_free_kbytes_sysctl_handler, 2849eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 28501da177e4SLinus Torvalds }, 28518ad4b1fbSRohit Seth { 28521c30844dSMel Gorman .procname = "watermark_boost_factor", 28531c30844dSMel Gorman .data = &watermark_boost_factor, 28541c30844dSMel Gorman .maxlen = sizeof(watermark_boost_factor), 28551c30844dSMel Gorman .mode = 0644, 285626363af5SChristoph Hellwig .proc_handler = proc_dointvec_minmax, 2857eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 28581c30844dSMel Gorman }, 28591c30844dSMel Gorman { 2860795ae7a0SJohannes Weiner .procname = "watermark_scale_factor", 2861795ae7a0SJohannes Weiner .data = &watermark_scale_factor, 2862795ae7a0SJohannes Weiner .maxlen = sizeof(watermark_scale_factor), 2863795ae7a0SJohannes Weiner .mode = 0644, 2864795ae7a0SJohannes Weiner .proc_handler = watermark_scale_factor_sysctl_handler, 2865eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 2866795ae7a0SJohannes Weiner .extra2 = &one_thousand, 2867795ae7a0SJohannes Weiner }, 2868795ae7a0SJohannes Weiner { 28698ad4b1fbSRohit Seth .procname = "percpu_pagelist_fraction", 28708ad4b1fbSRohit Seth .data = &percpu_pagelist_fraction, 28718ad4b1fbSRohit Seth .maxlen = sizeof(percpu_pagelist_fraction), 28728ad4b1fbSRohit Seth .mode = 0644, 28736d456111SEric W. Biederman .proc_handler = percpu_pagelist_fraction_sysctl_handler, 2874eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 28758ad4b1fbSRohit Seth }, 28761da177e4SLinus Torvalds #ifdef CONFIG_MMU 28771da177e4SLinus Torvalds { 28781da177e4SLinus Torvalds .procname = "max_map_count", 28791da177e4SLinus Torvalds .data = &sysctl_max_map_count, 28801da177e4SLinus Torvalds .maxlen = sizeof(sysctl_max_map_count), 28811da177e4SLinus Torvalds .mode = 0644, 28823e26120cSWANG Cong .proc_handler = proc_dointvec_minmax, 2883eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 28841da177e4SLinus Torvalds }, 2885dd8632a1SPaul Mundt #else 2886dd8632a1SPaul Mundt { 2887dd8632a1SPaul Mundt .procname = "nr_trim_pages", 2888dd8632a1SPaul Mundt .data = &sysctl_nr_trim_pages, 2889dd8632a1SPaul Mundt .maxlen = sizeof(sysctl_nr_trim_pages), 2890dd8632a1SPaul Mundt .mode = 0644, 28916d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 2892eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 2893dd8632a1SPaul Mundt }, 28941da177e4SLinus Torvalds #endif 28951da177e4SLinus Torvalds { 28961da177e4SLinus Torvalds .procname = "laptop_mode", 28971da177e4SLinus Torvalds .data = &laptop_mode, 28981da177e4SLinus Torvalds .maxlen = sizeof(laptop_mode), 28991da177e4SLinus Torvalds .mode = 0644, 29006d456111SEric W. Biederman .proc_handler = proc_dointvec_jiffies, 29011da177e4SLinus Torvalds }, 29021da177e4SLinus Torvalds { 29031da177e4SLinus Torvalds .procname = "block_dump", 29041da177e4SLinus Torvalds .data = &block_dump, 29051da177e4SLinus Torvalds .maxlen = sizeof(block_dump), 29061da177e4SLinus Torvalds .mode = 0644, 29076d456111SEric W. Biederman .proc_handler = proc_dointvec, 2908eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 29091da177e4SLinus Torvalds }, 29101da177e4SLinus Torvalds { 29111da177e4SLinus Torvalds .procname = "vfs_cache_pressure", 29121da177e4SLinus Torvalds .data = &sysctl_vfs_cache_pressure, 29131da177e4SLinus Torvalds .maxlen = sizeof(sysctl_vfs_cache_pressure), 29141da177e4SLinus Torvalds .mode = 0644, 29156d456111SEric W. Biederman .proc_handler = proc_dointvec, 2916eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 29171da177e4SLinus Torvalds }, 291867f3977fSAlexandre Ghiti #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \ 291967f3977fSAlexandre Ghiti defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT) 29201da177e4SLinus Torvalds { 29211da177e4SLinus Torvalds .procname = "legacy_va_layout", 29221da177e4SLinus Torvalds .data = &sysctl_legacy_va_layout, 29231da177e4SLinus Torvalds .maxlen = sizeof(sysctl_legacy_va_layout), 29241da177e4SLinus Torvalds .mode = 0644, 29256d456111SEric W. Biederman .proc_handler = proc_dointvec, 2926eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 29271da177e4SLinus Torvalds }, 29281da177e4SLinus Torvalds #endif 29291743660bSChristoph Lameter #ifdef CONFIG_NUMA 29301743660bSChristoph Lameter { 29311743660bSChristoph Lameter .procname = "zone_reclaim_mode", 2932a5f5f91dSMel Gorman .data = &node_reclaim_mode, 2933a5f5f91dSMel Gorman .maxlen = sizeof(node_reclaim_mode), 29341743660bSChristoph Lameter .mode = 0644, 29356d456111SEric W. Biederman .proc_handler = proc_dointvec, 2936eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 29371743660bSChristoph Lameter }, 29389614634fSChristoph Lameter { 29399614634fSChristoph Lameter .procname = "min_unmapped_ratio", 29409614634fSChristoph Lameter .data = &sysctl_min_unmapped_ratio, 29419614634fSChristoph Lameter .maxlen = sizeof(sysctl_min_unmapped_ratio), 29429614634fSChristoph Lameter .mode = 0644, 29436d456111SEric W. Biederman .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler, 2944eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 29459614634fSChristoph Lameter .extra2 = &one_hundred, 29469614634fSChristoph Lameter }, 29470ff38490SChristoph Lameter { 29480ff38490SChristoph Lameter .procname = "min_slab_ratio", 29490ff38490SChristoph Lameter .data = &sysctl_min_slab_ratio, 29500ff38490SChristoph Lameter .maxlen = sizeof(sysctl_min_slab_ratio), 29510ff38490SChristoph Lameter .mode = 0644, 29526d456111SEric W. Biederman .proc_handler = sysctl_min_slab_ratio_sysctl_handler, 2953eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 29540ff38490SChristoph Lameter .extra2 = &one_hundred, 29550ff38490SChristoph Lameter }, 29561743660bSChristoph Lameter #endif 295777461ab3SChristoph Lameter #ifdef CONFIG_SMP 295877461ab3SChristoph Lameter { 295977461ab3SChristoph Lameter .procname = "stat_interval", 296077461ab3SChristoph Lameter .data = &sysctl_stat_interval, 296177461ab3SChristoph Lameter .maxlen = sizeof(sysctl_stat_interval), 296277461ab3SChristoph Lameter .mode = 0644, 29636d456111SEric W. Biederman .proc_handler = proc_dointvec_jiffies, 296477461ab3SChristoph Lameter }, 296552b6f46bSHugh Dickins { 296652b6f46bSHugh Dickins .procname = "stat_refresh", 296752b6f46bSHugh Dickins .data = NULL, 296852b6f46bSHugh Dickins .maxlen = 0, 296952b6f46bSHugh Dickins .mode = 0600, 297052b6f46bSHugh Dickins .proc_handler = vmstat_refresh, 297152b6f46bSHugh Dickins }, 297277461ab3SChristoph Lameter #endif 29736e141546SDavid Howells #ifdef CONFIG_MMU 2974ed032189SEric Paris { 2975ed032189SEric Paris .procname = "mmap_min_addr", 2976788084abSEric Paris .data = &dac_mmap_min_addr, 2977ed032189SEric Paris .maxlen = sizeof(unsigned long), 2978ed032189SEric Paris .mode = 0644, 29796d456111SEric W. Biederman .proc_handler = mmap_min_addr_handler, 2980ed032189SEric Paris }, 29816e141546SDavid Howells #endif 2982f0c0b2b8SKAMEZAWA Hiroyuki #ifdef CONFIG_NUMA 2983f0c0b2b8SKAMEZAWA Hiroyuki { 2984f0c0b2b8SKAMEZAWA Hiroyuki .procname = "numa_zonelist_order", 2985f0c0b2b8SKAMEZAWA Hiroyuki .data = &numa_zonelist_order, 2986f0c0b2b8SKAMEZAWA Hiroyuki .maxlen = NUMA_ZONELIST_ORDER_LEN, 2987f0c0b2b8SKAMEZAWA Hiroyuki .mode = 0644, 29886d456111SEric W. Biederman .proc_handler = numa_zonelist_order_handler, 2989f0c0b2b8SKAMEZAWA Hiroyuki }, 2990f0c0b2b8SKAMEZAWA Hiroyuki #endif 29912b8232ceSAl Viro #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \ 29925c36e657SPaul Mundt (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL)) 2993e6e5494cSIngo Molnar { 2994e6e5494cSIngo Molnar .procname = "vdso_enabled", 29953d7ee969SAndy Lutomirski #ifdef CONFIG_X86_32 29963d7ee969SAndy Lutomirski .data = &vdso32_enabled, 29973d7ee969SAndy Lutomirski .maxlen = sizeof(vdso32_enabled), 29983d7ee969SAndy Lutomirski #else 2999e6e5494cSIngo Molnar .data = &vdso_enabled, 3000e6e5494cSIngo Molnar .maxlen = sizeof(vdso_enabled), 30013d7ee969SAndy Lutomirski #endif 3002e6e5494cSIngo Molnar .mode = 0644, 30036d456111SEric W. Biederman .proc_handler = proc_dointvec, 3004eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3005e6e5494cSIngo Molnar }, 3006e6e5494cSIngo Molnar #endif 3007195cf453SBron Gondwana #ifdef CONFIG_HIGHMEM 3008195cf453SBron Gondwana { 3009195cf453SBron Gondwana .procname = "highmem_is_dirtyable", 3010195cf453SBron Gondwana .data = &vm_highmem_is_dirtyable, 3011195cf453SBron Gondwana .maxlen = sizeof(vm_highmem_is_dirtyable), 3012195cf453SBron Gondwana .mode = 0644, 30136d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 3014eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3015eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 3016195cf453SBron Gondwana }, 3017195cf453SBron Gondwana #endif 30186a46079cSAndi Kleen #ifdef CONFIG_MEMORY_FAILURE 30196a46079cSAndi Kleen { 30206a46079cSAndi Kleen .procname = "memory_failure_early_kill", 30216a46079cSAndi Kleen .data = &sysctl_memory_failure_early_kill, 30226a46079cSAndi Kleen .maxlen = sizeof(sysctl_memory_failure_early_kill), 30236a46079cSAndi Kleen .mode = 0644, 30246d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 3025eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3026eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 30276a46079cSAndi Kleen }, 30286a46079cSAndi Kleen { 30296a46079cSAndi Kleen .procname = "memory_failure_recovery", 30306a46079cSAndi Kleen .data = &sysctl_memory_failure_recovery, 30316a46079cSAndi Kleen .maxlen = sizeof(sysctl_memory_failure_recovery), 30326a46079cSAndi Kleen .mode = 0644, 30336d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 3034eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3035eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 30366a46079cSAndi Kleen }, 30376a46079cSAndi Kleen #endif 3038c9b1d098SAndrew Shewmaker { 3039c9b1d098SAndrew Shewmaker .procname = "user_reserve_kbytes", 3040c9b1d098SAndrew Shewmaker .data = &sysctl_user_reserve_kbytes, 3041c9b1d098SAndrew Shewmaker .maxlen = sizeof(sysctl_user_reserve_kbytes), 3042c9b1d098SAndrew Shewmaker .mode = 0644, 3043c9b1d098SAndrew Shewmaker .proc_handler = proc_doulongvec_minmax, 3044c9b1d098SAndrew Shewmaker }, 30454eeab4f5SAndrew Shewmaker { 30464eeab4f5SAndrew Shewmaker .procname = "admin_reserve_kbytes", 30474eeab4f5SAndrew Shewmaker .data = &sysctl_admin_reserve_kbytes, 30484eeab4f5SAndrew Shewmaker .maxlen = sizeof(sysctl_admin_reserve_kbytes), 30494eeab4f5SAndrew Shewmaker .mode = 0644, 30504eeab4f5SAndrew Shewmaker .proc_handler = proc_doulongvec_minmax, 30514eeab4f5SAndrew Shewmaker }, 3052d07e2259SDaniel Cashman #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS 3053d07e2259SDaniel Cashman { 3054d07e2259SDaniel Cashman .procname = "mmap_rnd_bits", 3055d07e2259SDaniel Cashman .data = &mmap_rnd_bits, 3056d07e2259SDaniel Cashman .maxlen = sizeof(mmap_rnd_bits), 3057d07e2259SDaniel Cashman .mode = 0600, 3058d07e2259SDaniel Cashman .proc_handler = proc_dointvec_minmax, 3059d07e2259SDaniel Cashman .extra1 = (void *)&mmap_rnd_bits_min, 3060d07e2259SDaniel Cashman .extra2 = (void *)&mmap_rnd_bits_max, 3061d07e2259SDaniel Cashman }, 3062d07e2259SDaniel Cashman #endif 3063d07e2259SDaniel Cashman #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS 3064d07e2259SDaniel Cashman { 3065d07e2259SDaniel Cashman .procname = "mmap_rnd_compat_bits", 3066d07e2259SDaniel Cashman .data = &mmap_rnd_compat_bits, 3067d07e2259SDaniel Cashman .maxlen = sizeof(mmap_rnd_compat_bits), 3068d07e2259SDaniel Cashman .mode = 0600, 3069d07e2259SDaniel Cashman .proc_handler = proc_dointvec_minmax, 3070d07e2259SDaniel Cashman .extra1 = (void *)&mmap_rnd_compat_bits_min, 3071d07e2259SDaniel Cashman .extra2 = (void *)&mmap_rnd_compat_bits_max, 3072d07e2259SDaniel Cashman }, 3073d07e2259SDaniel Cashman #endif 3074cefdca0aSPeter Xu #ifdef CONFIG_USERFAULTFD 3075cefdca0aSPeter Xu { 3076cefdca0aSPeter Xu .procname = "unprivileged_userfaultfd", 3077cefdca0aSPeter Xu .data = &sysctl_unprivileged_userfaultfd, 3078cefdca0aSPeter Xu .maxlen = sizeof(sysctl_unprivileged_userfaultfd), 3079cefdca0aSPeter Xu .mode = 0644, 3080cefdca0aSPeter Xu .proc_handler = proc_dointvec_minmax, 3081eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3082eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 3083cefdca0aSPeter Xu }, 3084cefdca0aSPeter Xu #endif 30856fce56ecSEric W. Biederman { } 30861da177e4SLinus Torvalds }; 30871da177e4SLinus Torvalds 3088d8217f07SEric W. Biederman static struct ctl_table fs_table[] = { 30891da177e4SLinus Torvalds { 30901da177e4SLinus Torvalds .procname = "inode-nr", 30911da177e4SLinus Torvalds .data = &inodes_stat, 30923942c07cSGlauber Costa .maxlen = 2*sizeof(long), 30931da177e4SLinus Torvalds .mode = 0444, 3094cffbc8aaSDave Chinner .proc_handler = proc_nr_inodes, 30951da177e4SLinus Torvalds }, 30961da177e4SLinus Torvalds { 30971da177e4SLinus Torvalds .procname = "inode-state", 30981da177e4SLinus Torvalds .data = &inodes_stat, 30993942c07cSGlauber Costa .maxlen = 7*sizeof(long), 31001da177e4SLinus Torvalds .mode = 0444, 3101cffbc8aaSDave Chinner .proc_handler = proc_nr_inodes, 31021da177e4SLinus Torvalds }, 31031da177e4SLinus Torvalds { 31041da177e4SLinus Torvalds .procname = "file-nr", 31051da177e4SLinus Torvalds .data = &files_stat, 3106518de9b3SEric Dumazet .maxlen = sizeof(files_stat), 31071da177e4SLinus Torvalds .mode = 0444, 31086d456111SEric W. Biederman .proc_handler = proc_nr_files, 31091da177e4SLinus Torvalds }, 31101da177e4SLinus Torvalds { 31111da177e4SLinus Torvalds .procname = "file-max", 31121da177e4SLinus Torvalds .data = &files_stat.max_files, 3113518de9b3SEric Dumazet .maxlen = sizeof(files_stat.max_files), 31141da177e4SLinus Torvalds .mode = 0644, 3115518de9b3SEric Dumazet .proc_handler = proc_doulongvec_minmax, 31169002b214SWill Deacon .extra1 = &zero_ul, 311732a5ad9cSChristian Brauner .extra2 = &long_max, 31181da177e4SLinus Torvalds }, 31191da177e4SLinus Torvalds { 31209cfe015aSEric Dumazet .procname = "nr_open", 31219cfe015aSEric Dumazet .data = &sysctl_nr_open, 31229b80a184SAlexey Dobriyan .maxlen = sizeof(unsigned int), 31239cfe015aSEric Dumazet .mode = 0644, 31246d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 3125eceea0b3SAl Viro .extra1 = &sysctl_nr_open_min, 3126eceea0b3SAl Viro .extra2 = &sysctl_nr_open_max, 31279cfe015aSEric Dumazet }, 31289cfe015aSEric Dumazet { 31291da177e4SLinus Torvalds .procname = "dentry-state", 31301da177e4SLinus Torvalds .data = &dentry_stat, 31313942c07cSGlauber Costa .maxlen = 6*sizeof(long), 31321da177e4SLinus Torvalds .mode = 0444, 3133312d3ca8SChristoph Hellwig .proc_handler = proc_nr_dentry, 31341da177e4SLinus Torvalds }, 31351da177e4SLinus Torvalds { 31361da177e4SLinus Torvalds .procname = "overflowuid", 31371da177e4SLinus Torvalds .data = &fs_overflowuid, 31381da177e4SLinus Torvalds .maxlen = sizeof(int), 31391da177e4SLinus Torvalds .mode = 0644, 31406d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 31411da177e4SLinus Torvalds .extra1 = &minolduid, 31421da177e4SLinus Torvalds .extra2 = &maxolduid, 31431da177e4SLinus Torvalds }, 31441da177e4SLinus Torvalds { 31451da177e4SLinus Torvalds .procname = "overflowgid", 31461da177e4SLinus Torvalds .data = &fs_overflowgid, 31471da177e4SLinus Torvalds .maxlen = sizeof(int), 31481da177e4SLinus Torvalds .mode = 0644, 31496d456111SEric W. Biederman .proc_handler = proc_dointvec_minmax, 31501da177e4SLinus Torvalds .extra1 = &minolduid, 31511da177e4SLinus Torvalds .extra2 = &maxolduid, 31521da177e4SLinus Torvalds }, 3153bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING 31541da177e4SLinus Torvalds { 31551da177e4SLinus Torvalds .procname = "leases-enable", 31561da177e4SLinus Torvalds .data = &leases_enable, 31571da177e4SLinus Torvalds .maxlen = sizeof(int), 31581da177e4SLinus Torvalds .mode = 0644, 31596d456111SEric W. Biederman .proc_handler = proc_dointvec, 31601da177e4SLinus Torvalds }, 3161bfcd17a6SThomas Petazzoni #endif 31621da177e4SLinus Torvalds #ifdef CONFIG_DNOTIFY 31631da177e4SLinus Torvalds { 31641da177e4SLinus Torvalds .procname = "dir-notify-enable", 31651da177e4SLinus Torvalds .data = &dir_notify_enable, 31661da177e4SLinus Torvalds .maxlen = sizeof(int), 31671da177e4SLinus Torvalds .mode = 0644, 31686d456111SEric W. Biederman .proc_handler = proc_dointvec, 31691da177e4SLinus Torvalds }, 31701da177e4SLinus Torvalds #endif 31711da177e4SLinus Torvalds #ifdef CONFIG_MMU 3172bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING 31731da177e4SLinus Torvalds { 31741da177e4SLinus Torvalds .procname = "lease-break-time", 31751da177e4SLinus Torvalds .data = &lease_break_time, 31761da177e4SLinus Torvalds .maxlen = sizeof(int), 31771da177e4SLinus Torvalds .mode = 0644, 31786d456111SEric W. Biederman .proc_handler = proc_dointvec, 31791da177e4SLinus Torvalds }, 3180bfcd17a6SThomas Petazzoni #endif 3181ebf3f09cSThomas Petazzoni #ifdef CONFIG_AIO 31821da177e4SLinus Torvalds { 31831da177e4SLinus Torvalds .procname = "aio-nr", 31841da177e4SLinus Torvalds .data = &aio_nr, 31851da177e4SLinus Torvalds .maxlen = sizeof(aio_nr), 31861da177e4SLinus Torvalds .mode = 0444, 31876d456111SEric W. Biederman .proc_handler = proc_doulongvec_minmax, 31881da177e4SLinus Torvalds }, 31891da177e4SLinus Torvalds { 31901da177e4SLinus Torvalds .procname = "aio-max-nr", 31911da177e4SLinus Torvalds .data = &aio_max_nr, 31921da177e4SLinus Torvalds .maxlen = sizeof(aio_max_nr), 31931da177e4SLinus Torvalds .mode = 0644, 31946d456111SEric W. Biederman .proc_handler = proc_doulongvec_minmax, 31951da177e4SLinus Torvalds }, 3196ebf3f09cSThomas Petazzoni #endif /* CONFIG_AIO */ 31972d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER 31980399cb08SRobert Love { 31990399cb08SRobert Love .procname = "inotify", 32000399cb08SRobert Love .mode = 0555, 32010399cb08SRobert Love .child = inotify_table, 32020399cb08SRobert Love }, 32030399cb08SRobert Love #endif 32047ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL 32057ef9964eSDavide Libenzi { 32067ef9964eSDavide Libenzi .procname = "epoll", 32077ef9964eSDavide Libenzi .mode = 0555, 32087ef9964eSDavide Libenzi .child = epoll_table, 32097ef9964eSDavide Libenzi }, 32107ef9964eSDavide Libenzi #endif 32111da177e4SLinus Torvalds #endif 3212d6e71144SAlan Cox { 3213800179c9SKees Cook .procname = "protected_symlinks", 3214800179c9SKees Cook .data = &sysctl_protected_symlinks, 3215800179c9SKees Cook .maxlen = sizeof(int), 3216800179c9SKees Cook .mode = 0600, 3217800179c9SKees Cook .proc_handler = proc_dointvec_minmax, 3218eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3219eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 3220800179c9SKees Cook }, 3221800179c9SKees Cook { 3222800179c9SKees Cook .procname = "protected_hardlinks", 3223800179c9SKees Cook .data = &sysctl_protected_hardlinks, 3224800179c9SKees Cook .maxlen = sizeof(int), 3225800179c9SKees Cook .mode = 0600, 3226800179c9SKees Cook .proc_handler = proc_dointvec_minmax, 3227eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3228eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 3229800179c9SKees Cook }, 3230800179c9SKees Cook { 323130aba665SSalvatore Mesoraca .procname = "protected_fifos", 323230aba665SSalvatore Mesoraca .data = &sysctl_protected_fifos, 323330aba665SSalvatore Mesoraca .maxlen = sizeof(int), 323430aba665SSalvatore Mesoraca .mode = 0600, 323530aba665SSalvatore Mesoraca .proc_handler = proc_dointvec_minmax, 3236eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 323730aba665SSalvatore Mesoraca .extra2 = &two, 323830aba665SSalvatore Mesoraca }, 323930aba665SSalvatore Mesoraca { 324030aba665SSalvatore Mesoraca .procname = "protected_regular", 324130aba665SSalvatore Mesoraca .data = &sysctl_protected_regular, 324230aba665SSalvatore Mesoraca .maxlen = sizeof(int), 324330aba665SSalvatore Mesoraca .mode = 0600, 324430aba665SSalvatore Mesoraca .proc_handler = proc_dointvec_minmax, 3245eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 324630aba665SSalvatore Mesoraca .extra2 = &two, 324730aba665SSalvatore Mesoraca }, 324830aba665SSalvatore Mesoraca { 3249d6e71144SAlan Cox .procname = "suid_dumpable", 3250d6e71144SAlan Cox .data = &suid_dumpable, 3251d6e71144SAlan Cox .maxlen = sizeof(int), 3252d6e71144SAlan Cox .mode = 0644, 325354b50199SKees Cook .proc_handler = proc_dointvec_minmax_coredump, 3254eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 32558e654fbaSMatthew Wilcox .extra2 = &two, 3256d6e71144SAlan Cox }, 32572abc26fcSEric W. Biederman #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE) 32582abc26fcSEric W. Biederman { 32592abc26fcSEric W. Biederman .procname = "binfmt_misc", 32602abc26fcSEric W. Biederman .mode = 0555, 3261f9bd6733SEric W. Biederman .child = sysctl_mount_point, 32622abc26fcSEric W. Biederman }, 32632abc26fcSEric W. Biederman #endif 3264b492e95bSJens Axboe { 3265ff9da691SJens Axboe .procname = "pipe-max-size", 3266ff9da691SJens Axboe .data = &pipe_max_size, 326798159d97SJoe Lawrence .maxlen = sizeof(pipe_max_size), 3268b492e95bSJens Axboe .mode = 0644, 3269319e0a21SEric Biggers .proc_handler = proc_dopipe_max_size, 3270b492e95bSJens Axboe }, 3271759c0114SWilly Tarreau { 3272759c0114SWilly Tarreau .procname = "pipe-user-pages-hard", 3273759c0114SWilly Tarreau .data = &pipe_user_pages_hard, 3274759c0114SWilly Tarreau .maxlen = sizeof(pipe_user_pages_hard), 3275759c0114SWilly Tarreau .mode = 0644, 3276759c0114SWilly Tarreau .proc_handler = proc_doulongvec_minmax, 3277759c0114SWilly Tarreau }, 3278759c0114SWilly Tarreau { 3279759c0114SWilly Tarreau .procname = "pipe-user-pages-soft", 3280759c0114SWilly Tarreau .data = &pipe_user_pages_soft, 3281759c0114SWilly Tarreau .maxlen = sizeof(pipe_user_pages_soft), 3282759c0114SWilly Tarreau .mode = 0644, 3283759c0114SWilly Tarreau .proc_handler = proc_doulongvec_minmax, 3284759c0114SWilly Tarreau }, 3285d2921684SEric W. Biederman { 3286d2921684SEric W. Biederman .procname = "mount-max", 3287d2921684SEric W. Biederman .data = &sysctl_mount_max, 3288d2921684SEric W. Biederman .maxlen = sizeof(unsigned int), 3289d2921684SEric W. Biederman .mode = 0644, 3290d2921684SEric W. Biederman .proc_handler = proc_dointvec_minmax, 3291eec4844fSMatteo Croce .extra1 = SYSCTL_ONE, 3292d2921684SEric W. Biederman }, 32936fce56ecSEric W. Biederman { } 32941da177e4SLinus Torvalds }; 32951da177e4SLinus Torvalds 3296d8217f07SEric W. Biederman static struct ctl_table debug_table[] = { 32977ac57a89SCatalin Marinas #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE 3298abd4f750SMasoud Asgharifard Sharbiani { 3299abd4f750SMasoud Asgharifard Sharbiani .procname = "exception-trace", 3300abd4f750SMasoud Asgharifard Sharbiani .data = &show_unhandled_signals, 3301abd4f750SMasoud Asgharifard Sharbiani .maxlen = sizeof(int), 3302abd4f750SMasoud Asgharifard Sharbiani .mode = 0644, 3303abd4f750SMasoud Asgharifard Sharbiani .proc_handler = proc_dointvec 3304abd4f750SMasoud Asgharifard Sharbiani }, 3305abd4f750SMasoud Asgharifard Sharbiani #endif 3306b2be84dfSMasami Hiramatsu #if defined(CONFIG_OPTPROBES) 3307b2be84dfSMasami Hiramatsu { 3308b2be84dfSMasami Hiramatsu .procname = "kprobes-optimization", 3309b2be84dfSMasami Hiramatsu .data = &sysctl_kprobes_optimization, 3310b2be84dfSMasami Hiramatsu .maxlen = sizeof(int), 3311b2be84dfSMasami Hiramatsu .mode = 0644, 3312b2be84dfSMasami Hiramatsu .proc_handler = proc_kprobes_optimization_handler, 3313eec4844fSMatteo Croce .extra1 = SYSCTL_ZERO, 3314eec4844fSMatteo Croce .extra2 = SYSCTL_ONE, 3315b2be84dfSMasami Hiramatsu }, 3316b2be84dfSMasami Hiramatsu #endif 33176fce56ecSEric W. Biederman { } 33181da177e4SLinus Torvalds }; 33191da177e4SLinus Torvalds 3320d8217f07SEric W. Biederman static struct ctl_table dev_table[] = { 33216fce56ecSEric W. Biederman { } 33221da177e4SLinus Torvalds }; 33231da177e4SLinus Torvalds 3324f461d2dcSChristoph Hellwig static struct ctl_table sysctl_base_table[] = { 3325f461d2dcSChristoph Hellwig { 3326f461d2dcSChristoph Hellwig .procname = "kernel", 3327f461d2dcSChristoph Hellwig .mode = 0555, 3328f461d2dcSChristoph Hellwig .child = kern_table, 3329f461d2dcSChristoph Hellwig }, 3330f461d2dcSChristoph Hellwig { 3331f461d2dcSChristoph Hellwig .procname = "vm", 3332f461d2dcSChristoph Hellwig .mode = 0555, 3333f461d2dcSChristoph Hellwig .child = vm_table, 3334f461d2dcSChristoph Hellwig }, 3335f461d2dcSChristoph Hellwig { 3336f461d2dcSChristoph Hellwig .procname = "fs", 3337f461d2dcSChristoph Hellwig .mode = 0555, 3338f461d2dcSChristoph Hellwig .child = fs_table, 3339f461d2dcSChristoph Hellwig }, 3340f461d2dcSChristoph Hellwig { 3341f461d2dcSChristoph Hellwig .procname = "debug", 3342f461d2dcSChristoph Hellwig .mode = 0555, 3343f461d2dcSChristoph Hellwig .child = debug_table, 3344f461d2dcSChristoph Hellwig }, 3345f461d2dcSChristoph Hellwig { 3346f461d2dcSChristoph Hellwig .procname = "dev", 3347f461d2dcSChristoph Hellwig .mode = 0555, 3348f461d2dcSChristoph Hellwig .child = dev_table, 3349f461d2dcSChristoph Hellwig }, 3350f461d2dcSChristoph Hellwig { } 3351f461d2dcSChristoph Hellwig }; 3352f461d2dcSChristoph Hellwig 3353de4e83bdSEric W. Biederman int __init sysctl_init(void) 3354330d57fbSAl Viro { 3355fd4b616bSSteven Rostedt struct ctl_table_header *hdr; 3356fd4b616bSSteven Rostedt 3357fd4b616bSSteven Rostedt hdr = register_sysctl_table(sysctl_base_table); 3358fd4b616bSSteven Rostedt kmemleak_not_leak(hdr); 3359330d57fbSAl Viro return 0; 3360f7e6ced4SAl Viro } 3361b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL */ 33621da177e4SLinus Torvalds /* 33631da177e4SLinus Torvalds * No sense putting this after each symbol definition, twice, 33641da177e4SLinus Torvalds * exception granted :-) 33651da177e4SLinus Torvalds */ 33661da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec); 3367e7d316a0SSubash Abhinov Kasiviswanathan EXPORT_SYMBOL(proc_douintvec); 33681da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_jiffies); 33691da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_minmax); 337061d9b56aSLuis R. Rodriguez EXPORT_SYMBOL_GPL(proc_douintvec_minmax); 33711da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_userhz_jiffies); 33721da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_ms_jiffies); 33731da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dostring); 33741da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_minmax); 33751da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax); 33760bc19985SStephen Suryaputra EXPORT_SYMBOL(proc_do_large_bitmap); 3377