projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc
[linux-block.git] / kernel / sysctl.c
CommitLineData
1da177e4
LT		 1/*
2 * sysctl.c: General linux system control interface
3 *
4 * Begun 24 March 1995, Stephen Tweedie
5 * Added /proc support, Dec 1995
6 * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
7 * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
8 * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
9 * Dynamic registration fixes, Stephen Tweedie.
10 * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
11 * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
12 * Horn.
13 * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
14 * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
15 * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
16 * Wendling.
17 * The list_for_each() macro wasn't appropriate for the sysctl loop.
18 * Removed it and replaced it with older style, 03/23/00, Bill Wendling
19 */
20
1da177e4 21#include <linux/module.h>
e2e40f2c 22#include <linux/aio.h>
1da177e4
LT		 23#include <linux/mm.h>
24#include <linux/swap.h>
25#include <linux/slab.h>
26#include <linux/sysctl.h>
5a04cca6 27#include <linux/bitmap.h>
d33ed52d 28#include <linux/signal.h>
455cd5ab 29#include <linux/printk.h>
1da177e4 30#include <linux/proc_fs.h>
72c2d582 31#include <linux/security.h>
1da177e4 32#include <linux/ctype.h>
dfec072e 33#include <linux/kmemcheck.h>
fd4b616b 34#include <linux/kmemleak.h>
62239ac2 35#include <linux/fs.h>
1da177e4
LT		 36#include <linux/init.h>
37#include <linux/kernel.h>
0296b228 38#include <linux/kobject.h>
20380731 39#include <linux/net.h>
1da177e4
LT		 40#include <linux/sysrq.h>
41#include <linux/highuid.h>
42#include <linux/writeback.h>
3fff4c42 43#include <linux/ratelimit.h>
76ab0f53 44#include <linux/compaction.h>
1da177e4 45#include <linux/hugetlb.h>
1da177e4 46#include <linux/initrd.h>
0b77f5bf 47#include <linux/key.h>
1da177e4
LT		 48#include <linux/times.h>
49#include <linux/limits.h>
50#include <linux/dcache.h>
6e006701 51#include <linux/dnotify.h>
1da177e4 52#include <linux/syscalls.h>
c748e134 53#include <linux/vmstat.h>
c255d844
PM		 54#include <linux/nfs_fs.h>
55#include <linux/acpi.h>
10a0a8d4 56#include <linux/reboot.h>
b0fc494f 57#include <linux/ftrace.h>
cdd6c482 58#include <linux/perf_event.h>
b2be84df 59#include <linux/kprobes.h>
b492e95b 60#include <linux/pipe_fs_i.h>
8e4228e1 61#include <linux/oom.h>
17f60a7d 62#include <linux/kmod.h>
73efc039 63#include <linux/capability.h>
40401530 64#include <linux/binfmts.h>
cf4aebc2 65#include <linux/sched/sysctl.h>
f7ccbae4 66#include <linux/sched/coredump.h>
7984754b 67#include <linux/kexec.h>
1be7f75d 68#include <linux/bpf.h>
d2921684 69#include <linux/mount.h>
1da177e4 70
7c0f6ba6 71#include <linux/uaccess.h>
1da177e4
LT		 72#include <asm/processor.h>
73
29cbc78b
AK		 74#ifdef CONFIG_X86
75#include <asm/nmi.h>
0741f4d2 76#include <asm/stacktrace.h>
6e7c4025 77#include <asm/io.h>
29cbc78b 78#endif
d550bbd4
DH		 79#ifdef CONFIG_SPARC
80#include <asm/setup.h>
81#endif
c55b7c3e
DY		 82#ifdef CONFIG_BSD_PROCESS_ACCT
83#include <linux/acct.h>
84#endif
4f0e056f
DY		 85#ifdef CONFIG_RT_MUTEXES
86#include <linux/rtmutex.h>
87#endif
2edf5e49
DY		 88#if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
89#include <linux/lockdep.h>
90#endif
15485a46
DY		 91#ifdef CONFIG_CHR_DEV_SG
92#include <scsi/sg.h>
93#endif
29cbc78b 94
58687acb 95#ifdef CONFIG_LOCKUP_DETECTOR
504d7cf1
DZ		 96#include <linux/nmi.h>
97#endif
98
1da177e4
LT		 99#if defined(CONFIG_SYSCTL)
100
101/* External variables not in a header file. */
d6e71144 102extern int suid_dumpable;
046d662f
AK		 103#ifdef CONFIG_COREDUMP
104extern int core_uses_pid;
1da177e4 105extern char core_pattern[];
a293980c 106extern unsigned int core_pipe_limit;
046d662f 107#endif
1da177e4 108extern int pid_max;
1da177e4 109extern int pid_max_min, pid_max_max;
8ad4b1fb 110extern int percpu_pagelist_fraction;
9745512c 111extern int latencytop_enabled;
9b80a184 112extern unsigned int sysctl_nr_open_min, sysctl_nr_open_max;
dd8632a1
PM		 113#ifndef CONFIG_MMU
114extern int sysctl_nr_trim_pages;
115#endif
1da177e4 116
c4f3b63f 117/* Constants used for minimum and maximum */
2508ce18 118#ifdef CONFIG_LOCKUP_DETECTOR
c4f3b63f
RT		 119static int sixty = 60;
120#endif
121
270750db
AT		 122static int __maybe_unused neg_one = -1;
123
c4f3b63f 124static int zero;
cd5f9a4c
LT		 125static int __maybe_unused one = 1;
126static int __maybe_unused two = 2;
5509a5d2 127static int __maybe_unused four = 4;
fc3501d4 128static unsigned long one_ul = 1;
c4f3b63f 129static int one_hundred = 100;
795ae7a0 130static int one_thousand = 1000;
af91322e
DY		 131#ifdef CONFIG_PRINTK
132static int ten_thousand = 10000;
133#endif
c5dfd78e
ACM		 134#ifdef CONFIG_PERF_EVENTS
135static int six_hundred_forty_kb = 640 * 1024;
136#endif
c4f3b63f 137
9e4a5bda
AR		 138/* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
139static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
140
1da177e4
LT		 141/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
142static int maxolduid = 65535;
143static int minolduid;
144
145static int ngroups_max = NGROUPS_MAX;
73efc039 146static const int cap_last_cap = CAP_LAST_CAP;
1da177e4 147
80df2847
LH		 148/*this is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs */
149#ifdef CONFIG_DETECT_HUNG_TASK
150static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
151#endif
152
d14f1729
DY		 153#ifdef CONFIG_INOTIFY_USER
154#include <linux/inotify.h>
155#endif
72c57ed5 156#ifdef CONFIG_SPARC
1da177e4
LT		 157#endif
158
159#ifdef __hppa__
160extern int pwrsw_enabled;
bf14e3b9
VG		 161#endif
162
163#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1da177e4
LT		 164extern int unaligned_enabled;
165#endif
1da177e4 166
d2b176ed 167#ifdef CONFIG_IA64
88fc241f 168extern int unaligned_dump_stack;
d2b176ed
JS		 169#endif
170
b6fca725
VG		 171#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
172extern int no_unaligned_warning;
173#endif
174
d6f8ff73 175#ifdef CONFIG_PROC_SYSCTL
f4aacea2
KC		 176
177#define SYSCTL_WRITES_LEGACY -1
178#define SYSCTL_WRITES_WARN 0
179#define SYSCTL_WRITES_STRICT 1
180
41662f5c 181static int sysctl_writes_strict = SYSCTL_WRITES_STRICT;
f4aacea2 182
8d65af78 183static int proc_do_cad_pid(struct ctl_table *table, int write,
9ec52099 184 void __user *buffer, size_t *lenp, loff_t *ppos);
8d65af78 185static int proc_taint(struct ctl_table *table, int write,
34f5a398 186 void __user *buffer, size_t *lenp, loff_t *ppos);
d6f8ff73 187#endif
9ec52099 188
bfdc0b49 189#ifdef CONFIG_PRINTK
620f6e8e 190static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
bfdc0b49
RW		 191 void __user *buffer, size_t *lenp, loff_t *ppos);
192#endif
193
54b50199
KC		 194static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
195 void __user *buffer, size_t *lenp, loff_t *ppos);
046d662f 196#ifdef CONFIG_COREDUMP
54b50199
KC		 197static int proc_dostring_coredump(struct ctl_table *table, int write,
198 void __user *buffer, size_t *lenp, loff_t *ppos);
046d662f 199#endif
54b50199 200
97f5f0cd 201#ifdef CONFIG_MAGIC_SYSRQ
8c6a98b2 202/* Note: sysrq code uses it's own private copy */
8eaede49 203static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
97f5f0cd 204
6f8fd1d7 205static int sysrq_sysctl_handler(struct ctl_table *table, int write,
97f5f0cd
DT		 206 void __user *buffer, size_t *lenp,
207 loff_t *ppos)
208{
209 int error;
210
211 error = proc_dointvec(table, write, buffer, lenp, ppos);
212 if (error)
213 return error;
214
215 if (write)
216 sysrq_toggle_support(__sysrq_enabled);
217
218 return 0;
219}
220
221#endif
222
d8217f07
EB		 223static struct ctl_table kern_table[];
224static struct ctl_table vm_table[];
225static struct ctl_table fs_table[];
226static struct ctl_table debug_table[];
227static struct ctl_table dev_table[];
228extern struct ctl_table random_table[];
7ef9964e
DL		 229#ifdef CONFIG_EPOLL
230extern struct ctl_table epoll_table[];
231#endif
1da177e4
LT		 232
233#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
234int sysctl_legacy_va_layout;
235#endif
236
1da177e4
LT		 237/* The default sysctl tables: */
238
de4e83bd 239static struct ctl_table sysctl_base_table[] = {
1da177e4 240 {
1da177e4
LT		 241 .procname = "kernel",
242 .mode = 0555,
243 .child = kern_table,
244 },
245 {
1da177e4
LT		 246 .procname = "vm",
247 .mode = 0555,
248 .child = vm_table,
249 },
1da177e4 250 {
1da177e4
LT		 251 .procname = "fs",
252 .mode = 0555,
253 .child = fs_table,
254 },
255 {
1da177e4
LT		 256 .procname = "debug",
257 .mode = 0555,
258 .child = debug_table,
259 },
260 {
1da177e4
LT		 261 .procname = "dev",
262 .mode = 0555,
263 .child = dev_table,
264 },
6fce56ec 265 { }
1da177e4
LT		 266};
267
77e54a1f 268#ifdef CONFIG_SCHED_DEBUG
73c4efd2
ED		 269static int min_sched_granularity_ns = 100000; /* 100 usecs */
270static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */
271static int min_wakeup_granularity_ns; /* 0 usecs */
272static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */
cbee9f88 273#ifdef CONFIG_SMP
1983a922
CE		 274static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
275static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
cbee9f88
PZ		 276#endif /* CONFIG_SMP */
277#endif /* CONFIG_SCHED_DEBUG */
77e54a1f 278
5e771905
MG		 279#ifdef CONFIG_COMPACTION
280static int min_extfrag_threshold;
281static int max_extfrag_threshold = 1000;
282#endif
283
d8217f07 284static struct ctl_table kern_table[] = {
2bba22c5 285 {
2bba22c5
MG		 286 .procname = "sched_child_runs_first",
287 .data = &sysctl_sched_child_runs_first,
288 .maxlen = sizeof(unsigned int),
289 .mode = 0644,
6d456111 290 .proc_handler = proc_dointvec,
2bba22c5 291 },
77e54a1f
IM		 292#ifdef CONFIG_SCHED_DEBUG
293 {
b2be5e96
PZ		 294 .procname = "sched_min_granularity_ns",
295 .data = &sysctl_sched_min_granularity,
77e54a1f
IM		 296 .maxlen = sizeof(unsigned int),
297 .mode = 0644,
702a7c76 298 .proc_handler = sched_proc_update_handler,
b2be5e96
PZ		 299 .extra1 = &min_sched_granularity_ns,
300 .extra2 = &max_sched_granularity_ns,
77e54a1f 301 },
21805085 302 {
21805085
PZ		 303 .procname = "sched_latency_ns",
304 .data = &sysctl_sched_latency,
305 .maxlen = sizeof(unsigned int),
306 .mode = 0644,
702a7c76 307 .proc_handler = sched_proc_update_handler,
21805085
PZ		 308 .extra1 = &min_sched_granularity_ns,
309 .extra2 = &max_sched_granularity_ns,
310 },
77e54a1f 311 {
77e54a1f
IM		 312 .procname = "sched_wakeup_granularity_ns",
313 .data = &sysctl_sched_wakeup_granularity,
314 .maxlen = sizeof(unsigned int),
315 .mode = 0644,
702a7c76 316 .proc_handler = sched_proc_update_handler,
77e54a1f
IM		 317 .extra1 = &min_wakeup_granularity_ns,
318 .extra2 = &max_wakeup_granularity_ns,
319 },
cbee9f88 320#ifdef CONFIG_SMP
1983a922 321 {
1983a922
CE		 322 .procname = "sched_tunable_scaling",
323 .data = &sysctl_sched_tunable_scaling,
324 .maxlen = sizeof(enum sched_tunable_scaling),
325 .mode = 0644,
702a7c76 326 .proc_handler = sched_proc_update_handler,
1983a922
CE		 327 .extra1 = &min_sched_tunable_scaling,
328 .extra2 = &max_sched_tunable_scaling,
2398f2c6 329 },
da84d961 330 {
d00535db 331 .procname = "sched_migration_cost_ns",
da84d961
IM		 332 .data = &sysctl_sched_migration_cost,
333 .maxlen = sizeof(unsigned int),
334 .mode = 0644,
6d456111 335 .proc_handler = proc_dointvec,
da84d961 336 },
b82d9fdd 337 {
b82d9fdd
PZ		 338 .procname = "sched_nr_migrate",
339 .data = &sysctl_sched_nr_migrate,
340 .maxlen = sizeof(unsigned int),
fa85ae24 341 .mode = 0644,
6d456111 342 .proc_handler = proc_dointvec,
fa85ae24 343 },
e9e9250b 344 {
d00535db 345 .procname = "sched_time_avg_ms",
e9e9250b
PZ		 346 .data = &sysctl_sched_time_avg,
347 .maxlen = sizeof(unsigned int),
348 .mode = 0644,
6d456111 349 .proc_handler = proc_dointvec,
e9e9250b 350 },
cb251765
MG		 351#ifdef CONFIG_SCHEDSTATS
352 {
353 .procname = "sched_schedstats",
354 .data = NULL,
355 .maxlen = sizeof(unsigned int),
356 .mode = 0644,
357 .proc_handler = sysctl_schedstats,
358 .extra1 = &zero,
359 .extra2 = &one,
360 },
361#endif /* CONFIG_SCHEDSTATS */
cbee9f88
PZ		 362#endif /* CONFIG_SMP */
363#ifdef CONFIG_NUMA_BALANCING
4b96a29b
PZ		 364 {
365 .procname = "numa_balancing_scan_delay_ms",
366 .data = &sysctl_numa_balancing_scan_delay,
367 .maxlen = sizeof(unsigned int),
368 .mode = 0644,
369 .proc_handler = proc_dointvec,
370 },
cbee9f88
PZ		 371 {
372 .procname = "numa_balancing_scan_period_min_ms",
373 .data = &sysctl_numa_balancing_scan_period_min,
374 .maxlen = sizeof(unsigned int),
375 .mode = 0644,
376 .proc_handler = proc_dointvec,
377 },
378 {
379 .procname = "numa_balancing_scan_period_max_ms",
380 .data = &sysctl_numa_balancing_scan_period_max,
381 .maxlen = sizeof(unsigned int),
382 .mode = 0644,
383 .proc_handler = proc_dointvec,
384 },
6e5fb223
PZ		 385 {
386 .procname = "numa_balancing_scan_size_mb",
387 .data = &sysctl_numa_balancing_scan_size,
388 .maxlen = sizeof(unsigned int),
389 .mode = 0644,
64192658
KT		 390 .proc_handler = proc_dointvec_minmax,
391 .extra1 = &one,
6e5fb223 392 },
54a43d54
AK		 393 {
394 .procname = "numa_balancing",
395 .data = NULL, /* filled in by handler */
396 .maxlen = sizeof(unsigned int),
397 .mode = 0644,
398 .proc_handler = sysctl_numa_balancing,
399 .extra1 = &zero,
400 .extra2 = &one,
401 },
cbee9f88
PZ		 402#endif /* CONFIG_NUMA_BALANCING */
403#endif /* CONFIG_SCHED_DEBUG */
9f0c1e56 404 {
9f0c1e56
PZ		 405 .procname = "sched_rt_period_us",
406 .data = &sysctl_sched_rt_period,
407 .maxlen = sizeof(unsigned int),
408 .mode = 0644,
6d456111 409 .proc_handler = sched_rt_handler,
9f0c1e56
PZ		 410 },
411 {
9f0c1e56
PZ		 412 .procname = "sched_rt_runtime_us",
413 .data = &sysctl_sched_rt_runtime,
414 .maxlen = sizeof(int),
415 .mode = 0644,
6d456111 416 .proc_handler = sched_rt_handler,
9f0c1e56 417 },
ce0dbbbb
CW		 418 {
419 .procname = "sched_rr_timeslice_ms",
975e155e 420 .data = &sysctl_sched_rr_timeslice,
ce0dbbbb
CW		 421 .maxlen = sizeof(int),
422 .mode = 0644,
423 .proc_handler = sched_rr_handler,
424 },
5091faa4
MG		 425#ifdef CONFIG_SCHED_AUTOGROUP
426 {
427 .procname = "sched_autogroup_enabled",
428 .data = &sysctl_sched_autogroup_enabled,
429 .maxlen = sizeof(unsigned int),
430 .mode = 0644,
1747b21f 431 .proc_handler = proc_dointvec_minmax,
5091faa4
MG		 432 .extra1 = &zero,
433 .extra2 = &one,
434 },
435#endif
ec12cb7f
PT		 436#ifdef CONFIG_CFS_BANDWIDTH
437 {
438 .procname = "sched_cfs_bandwidth_slice_us",
439 .data = &sysctl_sched_cfs_bandwidth_slice,
440 .maxlen = sizeof(unsigned int),
441 .mode = 0644,
442 .proc_handler = proc_dointvec_minmax,
443 .extra1 = &one,
444 },
445#endif
f20786ff
PZ		 446#ifdef CONFIG_PROVE_LOCKING
447 {
f20786ff
PZ		 448 .procname = "prove_locking",
449 .data = &prove_locking,
450 .maxlen = sizeof(int),
451 .mode = 0644,
6d456111 452 .proc_handler = proc_dointvec,
f20786ff
PZ		 453 },
454#endif
455#ifdef CONFIG_LOCK_STAT
456 {
f20786ff
PZ		 457 .procname = "lock_stat",
458 .data = &lock_stat,
459 .maxlen = sizeof(int),
460 .mode = 0644,
6d456111 461 .proc_handler = proc_dointvec,
f20786ff 462 },
77e54a1f 463#endif
1da177e4 464 {
1da177e4
LT		 465 .procname = "panic",
466 .data = &panic_timeout,
467 .maxlen = sizeof(int),
468 .mode = 0644,
6d456111 469 .proc_handler = proc_dointvec,
1da177e4 470 },
046d662f 471#ifdef CONFIG_COREDUMP
1da177e4 472 {
1da177e4
LT		 473 .procname = "core_uses_pid",
474 .data = &core_uses_pid,
475 .maxlen = sizeof(int),
476 .mode = 0644,
6d456111 477 .proc_handler = proc_dointvec,
1da177e4
LT		 478 },
479 {
1da177e4
LT		 480 .procname = "core_pattern",
481 .data = core_pattern,
71ce92f3 482 .maxlen = CORENAME_MAX_SIZE,
1da177e4 483 .mode = 0644,
54b50199 484 .proc_handler = proc_dostring_coredump,
1da177e4 485 },
a293980c 486 {
a293980c
NH		 487 .procname = "core_pipe_limit",
488 .data = &core_pipe_limit,
489 .maxlen = sizeof(unsigned int),
490 .mode = 0644,
6d456111 491 .proc_handler = proc_dointvec,
a293980c 492 },
046d662f 493#endif
34f5a398 494#ifdef CONFIG_PROC_SYSCTL
1da177e4 495 {
1da177e4 496 .procname = "tainted",
25ddbb18 497 .maxlen = sizeof(long),
34f5a398 498 .mode = 0644,
6d456111 499 .proc_handler = proc_taint,
1da177e4 500 },
f4aacea2
KC		 501 {
502 .procname = "sysctl_writes_strict",
503 .data = &sysctl_writes_strict,
504 .maxlen = sizeof(int),
505 .mode = 0644,
506 .proc_handler = proc_dointvec_minmax,
507 .extra1 = &neg_one,
508 .extra2 = &one,
509 },
34f5a398 510#endif
9745512c
AV		 511#ifdef CONFIG_LATENCYTOP
512 {
513 .procname = "latencytop",
514 .data = &latencytop_enabled,
515 .maxlen = sizeof(int),
516 .mode = 0644,
cb251765 517 .proc_handler = sysctl_latencytop,
9745512c
AV		 518 },
519#endif
1da177e4
LT		 520#ifdef CONFIG_BLK_DEV_INITRD
521 {
1da177e4
LT		 522 .procname = "real-root-dev",
523 .data = &real_root_dev,
524 .maxlen = sizeof(int),
525 .mode = 0644,
6d456111 526 .proc_handler = proc_dointvec,
1da177e4
LT		 527 },
528#endif
45807a1d 529 {
45807a1d
IM		 530 .procname = "print-fatal-signals",
531 .data = &print_fatal_signals,
532 .maxlen = sizeof(int),
533 .mode = 0644,
6d456111 534 .proc_handler = proc_dointvec,
45807a1d 535 },
72c57ed5 536#ifdef CONFIG_SPARC
1da177e4 537 {
1da177e4
LT		 538 .procname = "reboot-cmd",
539 .data = reboot_command,
540 .maxlen = 256,
541 .mode = 0644,
6d456111 542 .proc_handler = proc_dostring,
1da177e4
LT		 543 },
544 {
1da177e4
LT		 545 .procname = "stop-a",
546 .data = &stop_a_enabled,
547 .maxlen = sizeof (int),
548 .mode = 0644,
6d456111 549 .proc_handler = proc_dointvec,
1da177e4
LT		 550 },
551 {
1da177e4
LT		 552 .procname = "scons-poweroff",
553 .data = &scons_pwroff,
554 .maxlen = sizeof (int),
555 .mode = 0644,
6d456111 556 .proc_handler = proc_dointvec,
1da177e4
LT		 557 },
558#endif
0871420f
DM		 559#ifdef CONFIG_SPARC64
560 {
0871420f
DM		 561 .procname = "tsb-ratio",
562 .data = &sysctl_tsb_ratio,
563 .maxlen = sizeof (int),
564 .mode = 0644,
6d456111 565 .proc_handler = proc_dointvec,
0871420f
DM		 566 },
567#endif
1da177e4
LT		 568#ifdef __hppa__
569 {
1da177e4
LT		 570 .procname = "soft-power",
571 .data = &pwrsw_enabled,
572 .maxlen = sizeof (int),
573 .mode = 0644,
6d456111 574 .proc_handler = proc_dointvec,
1da177e4 575 },
bf14e3b9
VG		 576#endif
577#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1da177e4 578 {
1da177e4
LT		 579 .procname = "unaligned-trap",
580 .data = &unaligned_enabled,
581 .maxlen = sizeof (int),
582 .mode = 0644,
6d456111 583 .proc_handler = proc_dointvec,
1da177e4
LT		 584 },
585#endif
586 {
1da177e4
LT		 587 .procname = "ctrl-alt-del",
588 .data = &C_A_D,
589 .maxlen = sizeof(int),
590 .mode = 0644,
6d456111 591 .proc_handler = proc_dointvec,
1da177e4 592 },
606576ce 593#ifdef CONFIG_FUNCTION_TRACER
b0fc494f 594 {
b0fc494f
SR		 595 .procname = "ftrace_enabled",
596 .data = &ftrace_enabled,
597 .maxlen = sizeof(int),
598 .mode = 0644,
6d456111 599 .proc_handler = ftrace_enable_sysctl,
b0fc494f
SR		 600 },
601#endif
f38f1d2a
SR		 602#ifdef CONFIG_STACK_TRACER
603 {
f38f1d2a
SR		 604 .procname = "stack_tracer_enabled",
605 .data = &stack_tracer_enabled,
606 .maxlen = sizeof(int),
607 .mode = 0644,
6d456111 608 .proc_handler = stack_trace_sysctl,
f38f1d2a
SR		 609 },
610#endif
944ac425
SR		 611#ifdef CONFIG_TRACING
612 {
3299b4dd 613 .procname = "ftrace_dump_on_oops",
944ac425
SR		 614 .data = &ftrace_dump_on_oops,
615 .maxlen = sizeof(int),
616 .mode = 0644,
6d456111 617 .proc_handler = proc_dointvec,
944ac425 618 },
de7edd31
SRRH		 619 {
620 .procname = "traceoff_on_warning",
621 .data = &__disable_trace_on_warning,
622 .maxlen = sizeof(__disable_trace_on_warning),
623 .mode = 0644,
624 .proc_handler = proc_dointvec,
625 },
0daa2302
SRRH		 626 {
627 .procname = "tracepoint_printk",
628 .data = &tracepoint_printk,
629 .maxlen = sizeof(tracepoint_printk),
630 .mode = 0644,
42391745 631 .proc_handler = tracepoint_printk_sysctl,
0daa2302 632 },
944ac425 633#endif
2965faa5 634#ifdef CONFIG_KEXEC_CORE
7984754b
KC		 635 {
636 .procname = "kexec_load_disabled",
637 .data = &kexec_load_disabled,
638 .maxlen = sizeof(int),
639 .mode = 0644,
640 /* only handle a transition from default "0" to "1" */
641 .proc_handler = proc_dointvec_minmax,
642 .extra1 = &one,
643 .extra2 = &one,
644 },
645#endif
a1ef5adb 646#ifdef CONFIG_MODULES
1da177e4 647 {
1da177e4
LT		 648 .procname = "modprobe",
649 .data = &modprobe_path,
650 .maxlen = KMOD_PATH_LEN,
651 .mode = 0644,
6d456111 652 .proc_handler = proc_dostring,
1da177e4 653 },
3d43321b 654 {
3d43321b
KC		 655 .procname = "modules_disabled",
656 .data = &modules_disabled,
657 .maxlen = sizeof(int),
658 .mode = 0644,
659 /* only handle a transition from default "0" to "1" */
6d456111 660 .proc_handler = proc_dointvec_minmax,
3d43321b
KC		 661 .extra1 = &one,
662 .extra2 = &one,
663 },
1da177e4 664#endif
86d56134 665#ifdef CONFIG_UEVENT_HELPER
1da177e4 666 {
1da177e4 667 .procname = "hotplug",
312c004d
KS		 668 .data = &uevent_helper,
669 .maxlen = UEVENT_HELPER_PATH_LEN,
1da177e4 670 .mode = 0644,
6d456111 671 .proc_handler = proc_dostring,
1da177e4 672 },
86d56134 673#endif
1da177e4
LT		 674#ifdef CONFIG_CHR_DEV_SG
675 {
1da177e4
LT		 676 .procname = "sg-big-buff",
677 .data = &sg_big_buff,
678 .maxlen = sizeof (int),
679 .mode = 0444,
6d456111 680 .proc_handler = proc_dointvec,
1da177e4
LT		 681 },
682#endif
683#ifdef CONFIG_BSD_PROCESS_ACCT
684 {
1da177e4
LT		 685 .procname = "acct",
686 .data = &acct_parm,
687 .maxlen = 3*sizeof(int),
688 .mode = 0644,
6d456111 689 .proc_handler = proc_dointvec,
1da177e4
LT		 690 },
691#endif
1da177e4
LT		 692#ifdef CONFIG_MAGIC_SYSRQ
693 {
1da177e4 694 .procname = "sysrq",
5d6f647f 695 .data = &__sysrq_enabled,
1da177e4
LT		 696 .maxlen = sizeof (int),
697 .mode = 0644,
97f5f0cd 698 .proc_handler = sysrq_sysctl_handler,
1da177e4
LT		 699 },
700#endif
d6f8ff73 701#ifdef CONFIG_PROC_SYSCTL
1da177e4 702 {
1da177e4 703 .procname = "cad_pid",
9ec52099 704 .data = NULL,
1da177e4
LT		 705 .maxlen = sizeof (int),
706 .mode = 0600,
6d456111 707 .proc_handler = proc_do_cad_pid,
1da177e4 708 },
d6f8ff73 709#endif
1da177e4 710 {
1da177e4 711 .procname = "threads-max",
16db3d3f 712 .data = NULL,
1da177e4
LT		 713 .maxlen = sizeof(int),
714 .mode = 0644,
16db3d3f 715 .proc_handler = sysctl_max_threads,
1da177e4
LT		 716 },
717 {
1da177e4
LT		 718 .procname = "random",
719 .mode = 0555,
720 .child = random_table,
721 },
17f60a7d
EP		 722 {
723 .procname = "usermodehelper",
724 .mode = 0555,
725 .child = usermodehelper_table,
726 },
1da177e4 727 {
1da177e4
LT		 728 .procname = "overflowuid",
729 .data = &overflowuid,
730 .maxlen = sizeof(int),
731 .mode = 0644,
6d456111 732 .proc_handler = proc_dointvec_minmax,
1da177e4
LT		 733 .extra1 = &minolduid,
734 .extra2 = &maxolduid,
735 },
736 {
1da177e4
LT		 737 .procname = "overflowgid",
738 .data = &overflowgid,
739 .maxlen = sizeof(int),
740 .mode = 0644,
6d456111 741 .proc_handler = proc_dointvec_minmax,
1da177e4
LT		 742 .extra1 = &minolduid,
743 .extra2 = &maxolduid,
744 },
347a8dc3 745#ifdef CONFIG_S390
1da177e4
LT		 746#ifdef CONFIG_MATHEMU
747 {
1da177e4
LT		 748 .procname = "ieee_emulation_warnings",
749 .data = &sysctl_ieee_emulation_warnings,
750 .maxlen = sizeof(int),
751 .mode = 0644,
6d456111 752 .proc_handler = proc_dointvec,
1da177e4 753 },
1da177e4
LT		 754#endif
755 {
1da177e4 756 .procname = "userprocess_debug",
ab3c68ee 757 .data = &show_unhandled_signals,
1da177e4
LT		 758 .maxlen = sizeof(int),
759 .mode = 0644,
6d456111 760 .proc_handler = proc_dointvec,
1da177e4
LT		 761 },
762#endif
763 {
1da177e4
LT		 764 .procname = "pid_max",
765 .data = &pid_max,
766 .maxlen = sizeof (int),
767 .mode = 0644,
6d456111 768 .proc_handler = proc_dointvec_minmax,
1da177e4
LT		 769 .extra1 = &pid_max_min,
770 .extra2 = &pid_max_max,
771 },
772 {
1da177e4
LT		 773 .procname = "panic_on_oops",
774 .data = &panic_on_oops,
775 .maxlen = sizeof(int),
776 .mode = 0644,
6d456111 777 .proc_handler = proc_dointvec,
1da177e4 778 },
7ef3d2fd
JP		 779#if defined CONFIG_PRINTK
780 {
7ef3d2fd
JP		 781 .procname = "printk",
782 .data = &console_loglevel,
783 .maxlen = 4*sizeof(int),
784 .mode = 0644,
6d456111 785 .proc_handler = proc_dointvec,
7ef3d2fd 786 },
1da177e4 787 {
1da177e4 788 .procname = "printk_ratelimit",
717115e1 789 .data = &printk_ratelimit_state.interval,
1da177e4
LT		 790 .maxlen = sizeof(int),
791 .mode = 0644,
6d456111 792 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 793 },
794 {
1da177e4 795 .procname = "printk_ratelimit_burst",
717115e1 796 .data = &printk_ratelimit_state.burst,
1da177e4
LT		 797 .maxlen = sizeof(int),
798 .mode = 0644,
6d456111 799 .proc_handler = proc_dointvec,
1da177e4 800 },
af91322e 801 {
af91322e
DY		 802 .procname = "printk_delay",
803 .data = &printk_delay_msec,
804 .maxlen = sizeof(int),
805 .mode = 0644,
6d456111 806 .proc_handler = proc_dointvec_minmax,
af91322e
DY		 807 .extra1 = &zero,
808 .extra2 = &ten_thousand,
809 },
750afe7b
BP		 810 {
811 .procname = "printk_devkmsg",
812 .data = devkmsg_log_str,
813 .maxlen = DEVKMSG_STR_MAX_SIZE,
814 .mode = 0644,
815 .proc_handler = devkmsg_sysctl_set_loglvl,
816 },
eaf06b24
DR		 817 {
818 .procname = "dmesg_restrict",
819 .data = &dmesg_restrict,
820 .maxlen = sizeof(int),
821 .mode = 0644,
620f6e8e 822 .proc_handler = proc_dointvec_minmax_sysadmin,
eaf06b24
DR		 823 .extra1 = &zero,
824 .extra2 = &one,
825 },
455cd5ab
DR		 826 {
827 .procname = "kptr_restrict",
828 .data = &kptr_restrict,
829 .maxlen = sizeof(int),
830 .mode = 0644,
620f6e8e 831 .proc_handler = proc_dointvec_minmax_sysadmin,
455cd5ab
DR		 832 .extra1 = &zero,
833 .extra2 = &two,
834 },
df6e61d4 835#endif
1da177e4 836 {
1da177e4
LT		 837 .procname = "ngroups_max",
838 .data = &ngroups_max,
839 .maxlen = sizeof (int),
840 .mode = 0444,
6d456111 841 .proc_handler = proc_dointvec,
1da177e4 842 },
73efc039
DB		 843 {
844 .procname = "cap_last_cap",
845 .data = (void *)&cap_last_cap,
846 .maxlen = sizeof(int),
847 .mode = 0444,
848 .proc_handler = proc_dointvec,
849 },
58687acb 850#if defined(CONFIG_LOCKUP_DETECTOR)
504d7cf1 851 {
58687acb 852 .procname = "watchdog",
3c00ea82 853 .data = &watchdog_user_enabled,
504d7cf1
DZ		 854 .maxlen = sizeof (int),
855 .mode = 0644,
195daf66 856 .proc_handler = proc_watchdog,
586692a5
MSB		 857 .extra1 = &zero,
858 .extra2 = &one,
58687acb
DZ		 859 },
860 {
861 .procname = "watchdog_thresh",
586692a5 862 .data = &watchdog_thresh,
58687acb
DZ		 863 .maxlen = sizeof(int),
864 .mode = 0644,
195daf66 865 .proc_handler = proc_watchdog_thresh,
a6572f84 866 .extra1 = &zero,
58687acb 867 .extra2 = &sixty,
504d7cf1 868 },
195daf66
UO		 869 {
870 .procname = "nmi_watchdog",
871 .data = &nmi_watchdog_enabled,
872 .maxlen = sizeof (int),
873 .mode = 0644,
874 .proc_handler = proc_nmi_watchdog,
875 .extra1 = &zero,
876#if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
877 .extra2 = &one,
878#else
879 .extra2 = &zero,
880#endif
881 },
882 {
883 .procname = "soft_watchdog",
884 .data = &soft_watchdog_enabled,
885 .maxlen = sizeof (int),
886 .mode = 0644,
887 .proc_handler = proc_soft_watchdog,
888 .extra1 = &zero,
889 .extra2 = &one,
890 },
fe4ba3c3
CM		 891 {
892 .procname = "watchdog_cpumask",
893 .data = &watchdog_cpumask_bits,
894 .maxlen = NR_CPUS,
895 .mode = 0644,
896 .proc_handler = proc_watchdog_cpumask,
897 },
2508ce18
DZ		 898 {
899 .procname = "softlockup_panic",
900 .data = &softlockup_panic,
901 .maxlen = sizeof(int),
902 .mode = 0644,
903 .proc_handler = proc_dointvec_minmax,
904 .extra1 = &zero,
905 .extra2 = &one,
906 },
ac1f5912
DZ		 907#ifdef CONFIG_HARDLOCKUP_DETECTOR
908 {
909 .procname = "hardlockup_panic",
910 .data = &hardlockup_panic,
911 .maxlen = sizeof(int),
912 .mode = 0644,
913 .proc_handler = proc_dointvec_minmax,
914 .extra1 = &zero,
915 .extra2 = &one,
916 },
917#endif
ed235875
AT		 918#ifdef CONFIG_SMP
919 {
920 .procname = "softlockup_all_cpu_backtrace",
921 .data = &sysctl_softlockup_all_cpu_backtrace,
922 .maxlen = sizeof(int),
923 .mode = 0644,
924 .proc_handler = proc_dointvec_minmax,
925 .extra1 = &zero,
926 .extra2 = &one,
927 },
55537871
JK		 928 {
929 .procname = "hardlockup_all_cpu_backtrace",
930 .data = &sysctl_hardlockup_all_cpu_backtrace,
931 .maxlen = sizeof(int),
932 .mode = 0644,
933 .proc_handler = proc_dointvec_minmax,
934 .extra1 = &zero,
935 .extra2 = &one,
936 },
ed235875 937#endif /* CONFIG_SMP */
5dc30558
DZ		 938#endif
939#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
940 {
941 .procname = "unknown_nmi_panic",
942 .data = &unknown_nmi_panic,
943 .maxlen = sizeof (int),
944 .mode = 0644,
945 .proc_handler = proc_dointvec,
946 },
504d7cf1 947#endif
1da177e4 948#if defined(CONFIG_X86)
8da5adda 949 {
8da5adda
DZ		 950 .procname = "panic_on_unrecovered_nmi",
951 .data = &panic_on_unrecovered_nmi,
952 .maxlen = sizeof(int),
953 .mode = 0644,
6d456111 954 .proc_handler = proc_dointvec,
8da5adda 955 },
5211a242 956 {
5211a242
KG		 957 .procname = "panic_on_io_nmi",
958 .data = &panic_on_io_nmi,
959 .maxlen = sizeof(int),
960 .mode = 0644,
6d456111 961 .proc_handler = proc_dointvec,
5211a242 962 },
55af7796
MH		 963#ifdef CONFIG_DEBUG_STACKOVERFLOW
964 {
965 .procname = "panic_on_stackoverflow",
966 .data = &sysctl_panic_on_stackoverflow,
967 .maxlen = sizeof(int),
968 .mode = 0644,
969 .proc_handler = proc_dointvec,
970 },
971#endif
1da177e4 972 {
1da177e4
LT		 973 .procname = "bootloader_type",
974 .data = &bootloader_type,
975 .maxlen = sizeof (int),
976 .mode = 0444,
6d456111 977 .proc_handler = proc_dointvec,
1da177e4 978 },
5031296c 979 {
5031296c
PA		 980 .procname = "bootloader_version",
981 .data = &bootloader_version,
982 .maxlen = sizeof (int),
983 .mode = 0444,
6d456111 984 .proc_handler = proc_dointvec,
5031296c 985 },
6e7c4025 986 {
6e7c4025
IM		 987 .procname = "io_delay_type",
988 .data = &io_delay_type,
989 .maxlen = sizeof(int),
990 .mode = 0644,
6d456111 991 .proc_handler = proc_dointvec,
6e7c4025 992 },
1da177e4 993#endif
7a9166e3 994#if defined(CONFIG_MMU)
1da177e4 995 {
1da177e4
LT		 996 .procname = "randomize_va_space",
997 .data = &randomize_va_space,
998 .maxlen = sizeof(int),
999 .mode = 0644,
6d456111 1000 .proc_handler = proc_dointvec,
1da177e4 1001 },
7a9166e3 1002#endif
0152fb37 1003#if defined(CONFIG_S390) && defined(CONFIG_SMP)
951f22d5 1004 {
951f22d5
MS		 1005 .procname = "spin_retry",
1006 .data = &spin_retry,
1007 .maxlen = sizeof (int),
1008 .mode = 0644,
6d456111 1009 .proc_handler = proc_dointvec,
951f22d5 1010 },
c255d844 1011#endif
673d5b43 1012#if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
c255d844 1013 {
c255d844 1014 .procname = "acpi_video_flags",
77afcf78 1015 .data = &acpi_realmode_flags,
c255d844
PM		 1016 .maxlen = sizeof (unsigned long),
1017 .mode = 0644,
6d456111 1018 .proc_handler = proc_doulongvec_minmax,
c255d844 1019 },
d2b176ed 1020#endif
b6fca725 1021#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
d2b176ed 1022 {
d2b176ed
JS		 1023 .procname = "ignore-unaligned-usertrap",
1024 .data = &no_unaligned_warning,
1025 .maxlen = sizeof (int),
1026 .mode = 0644,
6d456111 1027 .proc_handler = proc_dointvec,
d2b176ed 1028 },
b6fca725
VG		 1029#endif
1030#ifdef CONFIG_IA64
88fc241f 1031 {
88fc241f
DC		 1032 .procname = "unaligned-dump-stack",
1033 .data = &unaligned_dump_stack,
1034 .maxlen = sizeof (int),
1035 .mode = 0644,
6d456111 1036 .proc_handler = proc_dointvec,
88fc241f 1037 },
bebfa101 1038#endif
e162b39a
MSB		 1039#ifdef CONFIG_DETECT_HUNG_TASK
1040 {
e162b39a
MSB		 1041 .procname = "hung_task_panic",
1042 .data = &sysctl_hung_task_panic,
1043 .maxlen = sizeof(int),
1044 .mode = 0644,
6d456111 1045 .proc_handler = proc_dointvec_minmax,
e162b39a
MSB		 1046 .extra1 = &zero,
1047 .extra2 = &one,
1048 },
82a1fcb9 1049 {
82a1fcb9
IM		 1050 .procname = "hung_task_check_count",
1051 .data = &sysctl_hung_task_check_count,
cd64647f 1052 .maxlen = sizeof(int),
82a1fcb9 1053 .mode = 0644,
cd64647f
LZ		 1054 .proc_handler = proc_dointvec_minmax,
1055 .extra1 = &zero,
82a1fcb9
IM		 1056 },
1057 {
82a1fcb9
IM		 1058 .procname = "hung_task_timeout_secs",
1059 .data = &sysctl_hung_task_timeout_secs,
90739081 1060 .maxlen = sizeof(unsigned long),
82a1fcb9 1061 .mode = 0644,
6d456111 1062 .proc_handler = proc_dohung_task_timeout_secs,
80df2847 1063 .extra2 = &hung_task_timeout_max,
82a1fcb9
IM		 1064 },
1065 {
82a1fcb9
IM		 1066 .procname = "hung_task_warnings",
1067 .data = &sysctl_hung_task_warnings,
270750db 1068 .maxlen = sizeof(int),
82a1fcb9 1069 .mode = 0644,
270750db
AT		 1070 .proc_handler = proc_dointvec_minmax,
1071 .extra1 = &neg_one,
82a1fcb9 1072 },
c4f3b63f 1073#endif
23f78d4a
IM		 1074#ifdef CONFIG_RT_MUTEXES
1075 {
23f78d4a
IM		 1076 .procname = "max_lock_depth",
1077 .data = &max_lock_depth,
1078 .maxlen = sizeof(int),
1079 .mode = 0644,
6d456111 1080 .proc_handler = proc_dointvec,
23f78d4a 1081 },
5096add8 1082#endif
10a0a8d4 1083 {
10a0a8d4
JF		 1084 .procname = "poweroff_cmd",
1085 .data = &poweroff_cmd,
1086 .maxlen = POWEROFF_CMD_PATH_LEN,
1087 .mode = 0644,
6d456111 1088 .proc_handler = proc_dostring,
10a0a8d4 1089 },
0b77f5bf
DH		 1090#ifdef CONFIG_KEYS
1091 {
0b77f5bf
DH		 1092 .procname = "keys",
1093 .mode = 0555,
1094 .child = key_sysctls,
1095 },
1096#endif
cdd6c482 1097#ifdef CONFIG_PERF_EVENTS
aa4a2218
VW		 1098 /*
1099 * User-space scripts rely on the existence of this file
1100 * as a feature check for perf_events being enabled.
1101 *
1102 * So it's an ABI, do not remove!
1103 */
1ccd1549 1104 {
cdd6c482
IM		 1105 .procname = "perf_event_paranoid",
1106 .data = &sysctl_perf_event_paranoid,
1107 .maxlen = sizeof(sysctl_perf_event_paranoid),
1ccd1549 1108 .mode = 0644,
6d456111 1109 .proc_handler = proc_dointvec,
1ccd1549 1110 },
c5078f78 1111 {
cdd6c482
IM		 1112 .procname = "perf_event_mlock_kb",
1113 .data = &sysctl_perf_event_mlock,
1114 .maxlen = sizeof(sysctl_perf_event_mlock),
c5078f78 1115 .mode = 0644,
6d456111 1116 .proc_handler = proc_dointvec,
c5078f78 1117 },
a78ac325 1118 {
cdd6c482
IM		 1119 .procname = "perf_event_max_sample_rate",
1120 .data = &sysctl_perf_event_sample_rate,
1121 .maxlen = sizeof(sysctl_perf_event_sample_rate),
a78ac325 1122 .mode = 0644,
163ec435 1123 .proc_handler = perf_proc_update_handler,
723478c8 1124 .extra1 = &one,
a78ac325 1125 },
14c63f17
DH		 1126 {
1127 .procname = "perf_cpu_time_max_percent",
1128 .data = &sysctl_perf_cpu_time_max_percent,
1129 .maxlen = sizeof(sysctl_perf_cpu_time_max_percent),
1130 .mode = 0644,
1131 .proc_handler = perf_cpu_time_max_percent_handler,
1132 .extra1 = &zero,
1133 .extra2 = &one_hundred,
1134 },
c5dfd78e
ACM		 1135 {
1136 .procname = "perf_event_max_stack",
a831100a 1137 .data = &sysctl_perf_event_max_stack,
c5dfd78e
ACM		 1138 .maxlen = sizeof(sysctl_perf_event_max_stack),
1139 .mode = 0644,
1140 .proc_handler = perf_event_max_stack_handler,
1141 .extra1 = &zero,
1142 .extra2 = &six_hundred_forty_kb,
1143 },
c85b0334
ACM		 1144 {
1145 .procname = "perf_event_max_contexts_per_stack",
1146 .data = &sysctl_perf_event_max_contexts_per_stack,
1147 .maxlen = sizeof(sysctl_perf_event_max_contexts_per_stack),
1148 .mode = 0644,
1149 .proc_handler = perf_event_max_stack_handler,
1150 .extra1 = &zero,
1151 .extra2 = &one_thousand,
1152 },
1ccd1549 1153#endif
dfec072e
VN		 1154#ifdef CONFIG_KMEMCHECK
1155 {
dfec072e
VN		 1156 .procname = "kmemcheck",
1157 .data = &kmemcheck_enabled,
1158 .maxlen = sizeof(int),
1159 .mode = 0644,
6d456111 1160 .proc_handler = proc_dointvec,
dfec072e 1161 },
cb684b5b 1162#endif
9e3961a0
PB		 1163 {
1164 .procname = "panic_on_warn",
1165 .data = &panic_on_warn,
1166 .maxlen = sizeof(int),
1167 .mode = 0644,
1168 .proc_handler = proc_dointvec_minmax,
1169 .extra1 = &zero,
1170 .extra2 = &one,
1171 },
bc7a34b8
TG		 1172#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
1173 {
1174 .procname = "timer_migration",
1175 .data = &sysctl_timer_migration,
1176 .maxlen = sizeof(unsigned int),
1177 .mode = 0644,
1178 .proc_handler = timer_migration_handler,
1179 },
1be7f75d
AS		 1180#endif
1181#ifdef CONFIG_BPF_SYSCALL
1182 {
1183 .procname = "unprivileged_bpf_disabled",
1184 .data = &sysctl_unprivileged_bpf_disabled,
1185 .maxlen = sizeof(sysctl_unprivileged_bpf_disabled),
1186 .mode = 0644,
1187 /* only handle a transition from default "0" to "1" */
1188 .proc_handler = proc_dointvec_minmax,
1189 .extra1 = &one,
1190 .extra2 = &one,
1191 },
088e9d25
DBO		 1192#endif
1193#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
1194 {
1195 .procname = "panic_on_rcu_stall",
1196 .data = &sysctl_panic_on_rcu_stall,
1197 .maxlen = sizeof(sysctl_panic_on_rcu_stall),
1198 .mode = 0644,
1199 .proc_handler = proc_dointvec_minmax,
1200 .extra1 = &zero,
1201 .extra2 = &one,
1202 },
bc7a34b8 1203#endif
6fce56ec 1204 { }
1da177e4
LT		 1205};
1206
d8217f07 1207static struct ctl_table vm_table[] = {
1da177e4 1208 {
1da177e4
LT		 1209 .procname = "overcommit_memory",
1210 .data = &sysctl_overcommit_memory,
1211 .maxlen = sizeof(sysctl_overcommit_memory),
1212 .mode = 0644,
cb16e95f
PH		 1213 .proc_handler = proc_dointvec_minmax,
1214 .extra1 = &zero,
1215 .extra2 = &two,
1da177e4 1216 },
fadd8fbd 1217 {
fadd8fbd
KH		 1218 .procname = "panic_on_oom",
1219 .data = &sysctl_panic_on_oom,
1220 .maxlen = sizeof(sysctl_panic_on_oom),
1221 .mode = 0644,
cb16e95f
PH		 1222 .proc_handler = proc_dointvec_minmax,
1223 .extra1 = &zero,
1224 .extra2 = &two,
fadd8fbd 1225 },
fe071d7e 1226 {
fe071d7e
DR		 1227 .procname = "oom_kill_allocating_task",
1228 .data = &sysctl_oom_kill_allocating_task,
1229 .maxlen = sizeof(sysctl_oom_kill_allocating_task),
1230 .mode = 0644,
6d456111 1231 .proc_handler = proc_dointvec,
fe071d7e 1232 },
fef1bdd6 1233 {
fef1bdd6
DR		 1234 .procname = "oom_dump_tasks",
1235 .data = &sysctl_oom_dump_tasks,
1236 .maxlen = sizeof(sysctl_oom_dump_tasks),
1237 .mode = 0644,
6d456111 1238 .proc_handler = proc_dointvec,
fef1bdd6 1239 },
1da177e4 1240 {
1da177e4
LT		 1241 .procname = "overcommit_ratio",
1242 .data = &sysctl_overcommit_ratio,
1243 .maxlen = sizeof(sysctl_overcommit_ratio),
1244 .mode = 0644,
49f0ce5f
JM		 1245 .proc_handler = overcommit_ratio_handler,
1246 },
1247 {
1248 .procname = "overcommit_kbytes",
1249 .data = &sysctl_overcommit_kbytes,
1250 .maxlen = sizeof(sysctl_overcommit_kbytes),
1251 .mode = 0644,
1252 .proc_handler = overcommit_kbytes_handler,
1da177e4
LT		 1253 },
1254 {
1da177e4
LT		 1255 .procname = "page-cluster",
1256 .data = &page_cluster,
1257 .maxlen = sizeof(int),
1258 .mode = 0644,
cb16e95f
PH		 1259 .proc_handler = proc_dointvec_minmax,
1260 .extra1 = &zero,
1da177e4
LT		 1261 },
1262 {
1da177e4
LT		 1263 .procname = "dirty_background_ratio",
1264 .data = &dirty_background_ratio,
1265 .maxlen = sizeof(dirty_background_ratio),
1266 .mode = 0644,
6d456111 1267 .proc_handler = dirty_background_ratio_handler,
1da177e4
LT		 1268 .extra1 = &zero,
1269 .extra2 = &one_hundred,
1270 },
2da02997 1271 {
2da02997
DR		 1272 .procname = "dirty_background_bytes",
1273 .data = &dirty_background_bytes,
1274 .maxlen = sizeof(dirty_background_bytes),
1275 .mode = 0644,
6d456111 1276 .proc_handler = dirty_background_bytes_handler,
fc3501d4 1277 .extra1 = &one_ul,
2da02997 1278 },
1da177e4 1279 {
1da177e4
LT		 1280 .procname = "dirty_ratio",
1281 .data = &vm_dirty_ratio,
1282 .maxlen = sizeof(vm_dirty_ratio),
1283 .mode = 0644,
6d456111 1284 .proc_handler = dirty_ratio_handler,
1da177e4
LT		 1285 .extra1 = &zero,
1286 .extra2 = &one_hundred,
1287 },
2da02997 1288 {
2da02997
DR		 1289 .procname = "dirty_bytes",
1290 .data = &vm_dirty_bytes,
1291 .maxlen = sizeof(vm_dirty_bytes),
1292 .mode = 0644,
6d456111 1293 .proc_handler = dirty_bytes_handler,
9e4a5bda 1294 .extra1 = &dirty_bytes_min,
2da02997 1295 },
1da177e4 1296 {
1da177e4 1297 .procname = "dirty_writeback_centisecs",
f6ef9438
BS		 1298 .data = &dirty_writeback_interval,
1299 .maxlen = sizeof(dirty_writeback_interval),
1da177e4 1300 .mode = 0644,
6d456111 1301 .proc_handler = dirty_writeback_centisecs_handler,
1da177e4
LT		 1302 },
1303 {
1da177e4 1304 .procname = "dirty_expire_centisecs",
f6ef9438
BS		 1305 .data = &dirty_expire_interval,
1306 .maxlen = sizeof(dirty_expire_interval),
1da177e4 1307 .mode = 0644,
cb16e95f
PH		 1308 .proc_handler = proc_dointvec_minmax,
1309 .extra1 = &zero,
1da177e4 1310 },
1efff914
TT		 1311 {
1312 .procname = "dirtytime_expire_seconds",
1313 .data = &dirtytime_expire_interval,
1314 .maxlen = sizeof(dirty_expire_interval),
1315 .mode = 0644,
1316 .proc_handler = dirtytime_interval_handler,
1317 .extra1 = &zero,
1318 },
1da177e4 1319 {
3965c9ae
WL		 1320 .procname = "nr_pdflush_threads",
1321 .mode = 0444 /* read-only */,
1322 .proc_handler = pdflush_proc_obsolete,
1da177e4
LT		 1323 },
1324 {
1da177e4
LT		 1325 .procname = "swappiness",
1326 .data = &vm_swappiness,
1327 .maxlen = sizeof(vm_swappiness),
1328 .mode = 0644,
6d456111 1329 .proc_handler = proc_dointvec_minmax,
1da177e4
LT		 1330 .extra1 = &zero,
1331 .extra2 = &one_hundred,
1332 },
1333#ifdef CONFIG_HUGETLB_PAGE
06808b08 1334 {
1da177e4 1335 .procname = "nr_hugepages",
e5ff2159 1336 .data = NULL,
1da177e4
LT		 1337 .maxlen = sizeof(unsigned long),
1338 .mode = 0644,
6d456111 1339 .proc_handler = hugetlb_sysctl_handler,
06808b08
LS		 1340 },
1341#ifdef CONFIG_NUMA
1342 {
1343 .procname = "nr_hugepages_mempolicy",
1344 .data = NULL,
1345 .maxlen = sizeof(unsigned long),
1346 .mode = 0644,
1347 .proc_handler = &hugetlb_mempolicy_sysctl_handler,
06808b08
LS		 1348 },
1349#endif
1da177e4 1350 {
1da177e4
LT		 1351 .procname = "hugetlb_shm_group",
1352 .data = &sysctl_hugetlb_shm_group,
1353 .maxlen = sizeof(gid_t),
1354 .mode = 0644,
6d456111 1355 .proc_handler = proc_dointvec,
1da177e4 1356 },
396faf03 1357 {
396faf03
MG		 1358 .procname = "hugepages_treat_as_movable",
1359 .data = &hugepages_treat_as_movable,
1360 .maxlen = sizeof(int),
1361 .mode = 0644,
86cdb465 1362 .proc_handler = proc_dointvec,
396faf03 1363 },
d1c3fb1f 1364 {
d1c3fb1f 1365 .procname = "nr_overcommit_hugepages",
e5ff2159
AK		 1366 .data = NULL,
1367 .maxlen = sizeof(unsigned long),
d1c3fb1f 1368 .mode = 0644,
6d456111 1369 .proc_handler = hugetlb_overcommit_handler,
d1c3fb1f 1370 },
1da177e4
LT		 1371#endif
1372 {
1da177e4
LT		 1373 .procname = "lowmem_reserve_ratio",
1374 .data = &sysctl_lowmem_reserve_ratio,
1375 .maxlen = sizeof(sysctl_lowmem_reserve_ratio),
1376 .mode = 0644,
6d456111 1377 .proc_handler = lowmem_reserve_ratio_sysctl_handler,
1da177e4 1378 },
9d0243bc 1379 {
9d0243bc
AM		 1380 .procname = "drop_caches",
1381 .data = &sysctl_drop_caches,
1382 .maxlen = sizeof(int),
1383 .mode = 0644,
1384 .proc_handler = drop_caches_sysctl_handler,
cb16e95f 1385 .extra1 = &one,
5509a5d2 1386 .extra2 = &four,
9d0243bc 1387 },
76ab0f53
MG		 1388#ifdef CONFIG_COMPACTION
1389 {
1390 .procname = "compact_memory",
1391 .data = &sysctl_compact_memory,
1392 .maxlen = sizeof(int),
1393 .mode = 0200,
1394 .proc_handler = sysctl_compaction_handler,
1395 },
5e771905
MG		 1396 {
1397 .procname = "extfrag_threshold",
1398 .data = &sysctl_extfrag_threshold,
1399 .maxlen = sizeof(int),
1400 .mode = 0644,
1401 .proc_handler = sysctl_extfrag_handler,
1402 .extra1 = &min_extfrag_threshold,
1403 .extra2 = &max_extfrag_threshold,
1404 },
5bbe3547
EM		 1405 {
1406 .procname = "compact_unevictable_allowed",
1407 .data = &sysctl_compact_unevictable_allowed,
1408 .maxlen = sizeof(int),
1409 .mode = 0644,
1410 .proc_handler = proc_dointvec,
1411 .extra1 = &zero,
1412 .extra2 = &one,
1413 },
5e771905 1414
76ab0f53 1415#endif /* CONFIG_COMPACTION */
1da177e4 1416 {
1da177e4
LT		 1417 .procname = "min_free_kbytes",
1418 .data = &min_free_kbytes,
1419 .maxlen = sizeof(min_free_kbytes),
1420 .mode = 0644,
6d456111 1421 .proc_handler = min_free_kbytes_sysctl_handler,
1da177e4
LT		 1422 .extra1 = &zero,
1423 },
795ae7a0
JW		 1424 {
1425 .procname = "watermark_scale_factor",
1426 .data = &watermark_scale_factor,
1427 .maxlen = sizeof(watermark_scale_factor),
1428 .mode = 0644,
1429 .proc_handler = watermark_scale_factor_sysctl_handler,
1430 .extra1 = &one,
1431 .extra2 = &one_thousand,
1432 },
8ad4b1fb 1433 {
8ad4b1fb
RS		 1434 .procname = "percpu_pagelist_fraction",
1435 .data = &percpu_pagelist_fraction,
1436 .maxlen = sizeof(percpu_pagelist_fraction),
1437 .mode = 0644,
6d456111 1438 .proc_handler = percpu_pagelist_fraction_sysctl_handler,
7cd2b0a3 1439 .extra1 = &zero,
8ad4b1fb 1440 },
1da177e4
LT		 1441#ifdef CONFIG_MMU
1442 {
1da177e4
LT		 1443 .procname = "max_map_count",
1444 .data = &sysctl_max_map_count,
1445 .maxlen = sizeof(sysctl_max_map_count),
1446 .mode = 0644,
3e26120c 1447 .proc_handler = proc_dointvec_minmax,
70da2340 1448 .extra1 = &zero,
1da177e4 1449 },
dd8632a1
PM		 1450#else
1451 {
dd8632a1
PM		 1452 .procname = "nr_trim_pages",
1453 .data = &sysctl_nr_trim_pages,
1454 .maxlen = sizeof(sysctl_nr_trim_pages),
1455 .mode = 0644,
6d456111 1456 .proc_handler = proc_dointvec_minmax,
dd8632a1
PM		 1457 .extra1 = &zero,
1458 },
1da177e4
LT		 1459#endif
1460 {
1da177e4
LT		 1461 .procname = "laptop_mode",
1462 .data = &laptop_mode,
1463 .maxlen = sizeof(laptop_mode),
1464 .mode = 0644,
6d456111 1465 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 1466 },
1467 {
1da177e4
LT		 1468 .procname = "block_dump",
1469 .data = &block_dump,
1470 .maxlen = sizeof(block_dump),
1471 .mode = 0644,
6d456111 1472 .proc_handler = proc_dointvec,
1da177e4
LT		 1473 .extra1 = &zero,
1474 },
1475 {
1da177e4
LT		 1476 .procname = "vfs_cache_pressure",
1477 .data = &sysctl_vfs_cache_pressure,
1478 .maxlen = sizeof(sysctl_vfs_cache_pressure),
1479 .mode = 0644,
6d456111 1480 .proc_handler = proc_dointvec,
1da177e4
LT		 1481 .extra1 = &zero,
1482 },
1483#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1484 {
1da177e4
LT		 1485 .procname = "legacy_va_layout",
1486 .data = &sysctl_legacy_va_layout,
1487 .maxlen = sizeof(sysctl_legacy_va_layout),
1488 .mode = 0644,
6d456111 1489 .proc_handler = proc_dointvec,
1da177e4
LT		 1490 .extra1 = &zero,
1491 },
1492#endif
1743660b
CL		 1493#ifdef CONFIG_NUMA
1494 {
1743660b 1495 .procname = "zone_reclaim_mode",
a5f5f91d
MG		 1496 .data = &node_reclaim_mode,
1497 .maxlen = sizeof(node_reclaim_mode),
1743660b 1498 .mode = 0644,
6d456111 1499 .proc_handler = proc_dointvec,
c84db23c 1500 .extra1 = &zero,
1743660b 1501 },
9614634f 1502 {
9614634f
CL		 1503 .procname = "min_unmapped_ratio",
1504 .data = &sysctl_min_unmapped_ratio,
1505 .maxlen = sizeof(sysctl_min_unmapped_ratio),
1506 .mode = 0644,
6d456111 1507 .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler,
9614634f
CL		 1508 .extra1 = &zero,
1509 .extra2 = &one_hundred,
1510 },
0ff38490 1511 {
0ff38490
CL		 1512 .procname = "min_slab_ratio",
1513 .data = &sysctl_min_slab_ratio,
1514 .maxlen = sizeof(sysctl_min_slab_ratio),
1515 .mode = 0644,
6d456111 1516 .proc_handler = sysctl_min_slab_ratio_sysctl_handler,
0ff38490
CL		 1517 .extra1 = &zero,
1518 .extra2 = &one_hundred,
1519 },
e6e5494c 1520#endif
77461ab3
CL		 1521#ifdef CONFIG_SMP
1522 {
77461ab3
CL		 1523 .procname = "stat_interval",
1524 .data = &sysctl_stat_interval,
1525 .maxlen = sizeof(sysctl_stat_interval),
1526 .mode = 0644,
6d456111 1527 .proc_handler = proc_dointvec_jiffies,
77461ab3 1528 },
52b6f46b
HD		 1529 {
1530 .procname = "stat_refresh",
1531 .data = NULL,
1532 .maxlen = 0,
1533 .mode = 0600,
1534 .proc_handler = vmstat_refresh,
1535 },
77461ab3 1536#endif
6e141546 1537#ifdef CONFIG_MMU
ed032189 1538 {
ed032189 1539 .procname = "mmap_min_addr",
788084ab
EP		 1540 .data = &dac_mmap_min_addr,
1541 .maxlen = sizeof(unsigned long),
ed032189 1542 .mode = 0644,
6d456111 1543 .proc_handler = mmap_min_addr_handler,
ed032189 1544 },
6e141546 1545#endif
f0c0b2b8
KH		 1546#ifdef CONFIG_NUMA
1547 {
f0c0b2b8
KH		 1548 .procname = "numa_zonelist_order",
1549 .data = &numa_zonelist_order,
1550 .maxlen = NUMA_ZONELIST_ORDER_LEN,
1551 .mode = 0644,
6d456111 1552 .proc_handler = numa_zonelist_order_handler,
f0c0b2b8
KH		 1553 },
1554#endif
2b8232ce 1555#if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
5c36e657 1556 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
e6e5494c 1557 {
e6e5494c 1558 .procname = "vdso_enabled",
3d7ee969
AL		 1559#ifdef CONFIG_X86_32
1560 .data = &vdso32_enabled,
1561 .maxlen = sizeof(vdso32_enabled),
1562#else
e6e5494c
IM		 1563 .data = &vdso_enabled,
1564 .maxlen = sizeof(vdso_enabled),
3d7ee969 1565#endif
e6e5494c 1566 .mode = 0644,
6d456111 1567 .proc_handler = proc_dointvec,
e6e5494c
IM		 1568 .extra1 = &zero,
1569 },
1da177e4 1570#endif
195cf453
BG		 1571#ifdef CONFIG_HIGHMEM
1572 {
195cf453
BG		 1573 .procname = "highmem_is_dirtyable",
1574 .data = &vm_highmem_is_dirtyable,
1575 .maxlen = sizeof(vm_highmem_is_dirtyable),
1576 .mode = 0644,
6d456111 1577 .proc_handler = proc_dointvec_minmax,
195cf453
BG		 1578 .extra1 = &zero,
1579 .extra2 = &one,
1580 },
1581#endif
6a46079c
AK		 1582#ifdef CONFIG_MEMORY_FAILURE
1583 {
6a46079c
AK		 1584 .procname = "memory_failure_early_kill",
1585 .data = &sysctl_memory_failure_early_kill,
1586 .maxlen = sizeof(sysctl_memory_failure_early_kill),
1587 .mode = 0644,
6d456111 1588 .proc_handler = proc_dointvec_minmax,
6a46079c
AK		 1589 .extra1 = &zero,
1590 .extra2 = &one,
1591 },
1592 {
6a46079c
AK		 1593 .procname = "memory_failure_recovery",
1594 .data = &sysctl_memory_failure_recovery,
1595 .maxlen = sizeof(sysctl_memory_failure_recovery),
1596 .mode = 0644,
6d456111 1597 .proc_handler = proc_dointvec_minmax,
6a46079c
AK		 1598 .extra1 = &zero,
1599 .extra2 = &one,
1600 },
1601#endif
c9b1d098
AS		 1602 {
1603 .procname = "user_reserve_kbytes",
1604 .data = &sysctl_user_reserve_kbytes,
1605 .maxlen = sizeof(sysctl_user_reserve_kbytes),
1606 .mode = 0644,
1607 .proc_handler = proc_doulongvec_minmax,
1608 },
4eeab4f5
AS		 1609 {
1610 .procname = "admin_reserve_kbytes",
1611 .data = &sysctl_admin_reserve_kbytes,
1612 .maxlen = sizeof(sysctl_admin_reserve_kbytes),
1613 .mode = 0644,
1614 .proc_handler = proc_doulongvec_minmax,
1615 },
d07e2259
DC		 1616#ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
1617 {
1618 .procname = "mmap_rnd_bits",
1619 .data = &mmap_rnd_bits,
1620 .maxlen = sizeof(mmap_rnd_bits),
1621 .mode = 0600,
1622 .proc_handler = proc_dointvec_minmax,
1623 .extra1 = (void *)&mmap_rnd_bits_min,
1624 .extra2 = (void *)&mmap_rnd_bits_max,
1625 },
1626#endif
1627#ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
1628 {
1629 .procname = "mmap_rnd_compat_bits",
1630 .data = &mmap_rnd_compat_bits,
1631 .maxlen = sizeof(mmap_rnd_compat_bits),
1632 .mode = 0600,
1633 .proc_handler = proc_dointvec_minmax,
1634 .extra1 = (void *)&mmap_rnd_compat_bits_min,
1635 .extra2 = (void *)&mmap_rnd_compat_bits_max,
1636 },
1637#endif
6fce56ec 1638 { }
1da177e4
LT		 1639};
1640
d8217f07 1641static struct ctl_table fs_table[] = {
1da177e4 1642 {
1da177e4
LT		 1643 .procname = "inode-nr",
1644 .data = &inodes_stat,
3942c07c 1645 .maxlen = 2*sizeof(long),
1da177e4 1646 .mode = 0444,
cffbc8aa 1647 .proc_handler = proc_nr_inodes,
1da177e4
LT		 1648 },
1649 {
1da177e4
LT		 1650 .procname = "inode-state",
1651 .data = &inodes_stat,
3942c07c 1652 .maxlen = 7*sizeof(long),
1da177e4 1653 .mode = 0444,
cffbc8aa 1654 .proc_handler = proc_nr_inodes,
1da177e4
LT		 1655 },
1656 {
1da177e4
LT		 1657 .procname = "file-nr",
1658 .data = &files_stat,
518de9b3 1659 .maxlen = sizeof(files_stat),
1da177e4 1660 .mode = 0444,
6d456111 1661 .proc_handler = proc_nr_files,
1da177e4
LT		 1662 },
1663 {
1da177e4
LT		 1664 .procname = "file-max",
1665 .data = &files_stat.max_files,
518de9b3 1666 .maxlen = sizeof(files_stat.max_files),
1da177e4 1667 .mode = 0644,
518de9b3 1668 .proc_handler = proc_doulongvec_minmax,
1da177e4 1669 },
9cfe015a 1670 {
9cfe015a
ED		 1671 .procname = "nr_open",
1672 .data = &sysctl_nr_open,
9b80a184 1673 .maxlen = sizeof(unsigned int),
9cfe015a 1674 .mode = 0644,
6d456111 1675 .proc_handler = proc_dointvec_minmax,
eceea0b3
AV		 1676 .extra1 = &sysctl_nr_open_min,
1677 .extra2 = &sysctl_nr_open_max,
9cfe015a 1678 },
1da177e4 1679 {
1da177e4
LT		 1680 .procname = "dentry-state",
1681 .data = &dentry_stat,
3942c07c 1682 .maxlen = 6*sizeof(long),
1da177e4 1683 .mode = 0444,
312d3ca8 1684 .proc_handler = proc_nr_dentry,
1da177e4
LT		 1685 },
1686 {
1da177e4
LT		 1687 .procname = "overflowuid",
1688 .data = &fs_overflowuid,
1689 .maxlen = sizeof(int),
1690 .mode = 0644,
6d456111 1691 .proc_handler = proc_dointvec_minmax,
1da177e4
LT		 1692 .extra1 = &minolduid,
1693 .extra2 = &maxolduid,
1694 },
1695 {
1da177e4
LT		 1696 .procname = "overflowgid",
1697 .data = &fs_overflowgid,
1698 .maxlen = sizeof(int),
1699 .mode = 0644,
6d456111 1700 .proc_handler = proc_dointvec_minmax,
1da177e4
LT		 1701 .extra1 = &minolduid,
1702 .extra2 = &maxolduid,
1703 },
bfcd17a6 1704#ifdef CONFIG_FILE_LOCKING
1da177e4 1705 {
1da177e4
LT		 1706 .procname = "leases-enable",
1707 .data = &leases_enable,
1708 .maxlen = sizeof(int),
1709 .mode = 0644,
6d456111 1710 .proc_handler = proc_dointvec,
1da177e4 1711 },
bfcd17a6 1712#endif
1da177e4
LT		 1713#ifdef CONFIG_DNOTIFY
1714 {
1da177e4
LT		 1715 .procname = "dir-notify-enable",
1716 .data = &dir_notify_enable,
1717 .maxlen = sizeof(int),
1718 .mode = 0644,
6d456111 1719 .proc_handler = proc_dointvec,
1da177e4
LT		 1720 },
1721#endif
1722#ifdef CONFIG_MMU
bfcd17a6 1723#ifdef CONFIG_FILE_LOCKING
1da177e4 1724 {
1da177e4
LT		 1725 .procname = "lease-break-time",
1726 .data = &lease_break_time,
1727 .maxlen = sizeof(int),
1728 .mode = 0644,
6d456111 1729 .proc_handler = proc_dointvec,
1da177e4 1730 },
bfcd17a6 1731#endif
ebf3f09c 1732#ifdef CONFIG_AIO
1da177e4 1733 {
1da177e4
LT		 1734 .procname = "aio-nr",
1735 .data = &aio_nr,
1736 .maxlen = sizeof(aio_nr),
1737 .mode = 0444,
6d456111 1738 .proc_handler = proc_doulongvec_minmax,
1da177e4
LT		 1739 },
1740 {
1da177e4
LT		 1741 .procname = "aio-max-nr",
1742 .data = &aio_max_nr,
1743 .maxlen = sizeof(aio_max_nr),
1744 .mode = 0644,
6d456111 1745 .proc_handler = proc_doulongvec_minmax,
1da177e4 1746 },
ebf3f09c 1747#endif /* CONFIG_AIO */
2d9048e2 1748#ifdef CONFIG_INOTIFY_USER
0399cb08 1749 {
0399cb08
RL		 1750 .procname = "inotify",
1751 .mode = 0555,
1752 .child = inotify_table,
1753 },
1754#endif
7ef9964e
DL		 1755#ifdef CONFIG_EPOLL
1756 {
1757 .procname = "epoll",
1758 .mode = 0555,
1759 .child = epoll_table,
1760 },
1761#endif
1da177e4 1762#endif
800179c9
KC		 1763 {
1764 .procname = "protected_symlinks",
1765 .data = &sysctl_protected_symlinks,
1766 .maxlen = sizeof(int),
1767 .mode = 0600,
1768 .proc_handler = proc_dointvec_minmax,
1769 .extra1 = &zero,
1770 .extra2 = &one,
1771 },
1772 {
1773 .procname = "protected_hardlinks",
1774 .data = &sysctl_protected_hardlinks,
1775 .maxlen = sizeof(int),
1776 .mode = 0600,
1777 .proc_handler = proc_dointvec_minmax,
1778 .extra1 = &zero,
1779 .extra2 = &one,
1780 },
d6e71144 1781 {
d6e71144
AC		 1782 .procname = "suid_dumpable",
1783 .data = &suid_dumpable,
1784 .maxlen = sizeof(int),
1785 .mode = 0644,
54b50199 1786 .proc_handler = proc_dointvec_minmax_coredump,
8e654fba
MW		 1787 .extra1 = &zero,
1788 .extra2 = &two,
d6e71144 1789 },
2abc26fc
EB		 1790#if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1791 {
2abc26fc
EB		 1792 .procname = "binfmt_misc",
1793 .mode = 0555,
f9bd6733 1794 .child = sysctl_mount_point,
2abc26fc
EB		 1795 },
1796#endif
b492e95b 1797 {
ff9da691
JA		 1798 .procname = "pipe-max-size",
1799 .data = &pipe_max_size,
b492e95b
JA		 1800 .maxlen = sizeof(int),
1801 .mode = 0644,
ff9da691
JA		 1802 .proc_handler = &pipe_proc_fn,
1803 .extra1 = &pipe_min_size,
b492e95b 1804 },
759c0114
WT		 1805 {
1806 .procname = "pipe-user-pages-hard",
1807 .data = &pipe_user_pages_hard,
1808 .maxlen = sizeof(pipe_user_pages_hard),
1809 .mode = 0644,
1810 .proc_handler = proc_doulongvec_minmax,
1811 },
1812 {
1813 .procname = "pipe-user-pages-soft",
1814 .data = &pipe_user_pages_soft,
1815 .maxlen = sizeof(pipe_user_pages_soft),
1816 .mode = 0644,
1817 .proc_handler = proc_doulongvec_minmax,
1818 },
d2921684
EB		 1819 {
1820 .procname = "mount-max",
1821 .data = &sysctl_mount_max,
1822 .maxlen = sizeof(unsigned int),
1823 .mode = 0644,
1824 .proc_handler = proc_dointvec_minmax,
1825 .extra1 = &one,
1826 },
6fce56ec 1827 { }
1da177e4
LT		 1828};
1829
d8217f07 1830static struct ctl_table debug_table[] = {
7ac57a89 1831#ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
abd4f750 1832 {
abd4f750
MAS		 1833 .procname = "exception-trace",
1834 .data = &show_unhandled_signals,
1835 .maxlen = sizeof(int),
1836 .mode = 0644,
1837 .proc_handler = proc_dointvec
1838 },
b2be84df
MH		 1839#endif
1840#if defined(CONFIG_OPTPROBES)
1841 {
1842 .procname = "kprobes-optimization",
1843 .data = &sysctl_kprobes_optimization,
1844 .maxlen = sizeof(int),
1845 .mode = 0644,
1846 .proc_handler = proc_kprobes_optimization_handler,
1847 .extra1 = &zero,
1848 .extra2 = &one,
1849 },
abd4f750 1850#endif
6fce56ec 1851 { }
1da177e4
LT		 1852};
1853
d8217f07 1854static struct ctl_table dev_table[] = {
6fce56ec 1855 { }
0eeca283 1856};
1da177e4 1857
de4e83bd 1858int __init sysctl_init(void)
d912b0cc 1859{
fd4b616b
SR		 1860 struct ctl_table_header *hdr;
1861
1862 hdr = register_sysctl_table(sysctl_base_table);
1863 kmemleak_not_leak(hdr);
d912b0cc
EB		 1864 return 0;
1865}
1866
b89a8171
EB		 1867#endif /* CONFIG_SYSCTL */
1868
1da177e4
LT		 1869/*
1870 * /proc/sys support
1871 */
1872
b89a8171 1873#ifdef CONFIG_PROC_SYSCTL
1da177e4 1874
f8808300
KC		 1875static int _proc_do_string(char *data, int maxlen, int write,
1876 char __user *buffer,
b1ba4ddd 1877 size_t *lenp, loff_t *ppos)
1da177e4
LT		 1878{
1879 size_t len;
1880 char __user *p;
1881 char c;
8d060877
ON		 1882
1883 if (!data || !maxlen || !*lenp) {
1da177e4
LT		 1884 *lenp = 0;
1885 return 0;
1886 }
8d060877 1887
1da177e4 1888 if (write) {
f4aacea2
KC		 1889 if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
1890 /* Only continue writes not past the end of buffer. */
1891 len = strlen(data);
1892 if (len > maxlen - 1)
1893 len = maxlen - 1;
1894
1895 if (*ppos > len)
1896 return 0;
1897 len = *ppos;
1898 } else {
1899 /* Start writing from beginning of buffer. */
1900 len = 0;
1901 }
1902
2ca9bb45 1903 *ppos += *lenp;
1da177e4 1904 p = buffer;
2ca9bb45 1905 while ((p - buffer) < *lenp && len < maxlen - 1) {
1da177e4
LT		 1906 if (get_user(c, p++))
1907 return -EFAULT;
1908 if (c == 0 || c == '\n')
1909 break;
2ca9bb45 1910 data[len++] = c;
1da177e4 1911 }
f8808300 1912 data[len] = 0;
1da177e4 1913 } else {
f5dd3d6f
SV		 1914 len = strlen(data);
1915 if (len > maxlen)
1916 len = maxlen;
8d060877
ON		 1917
1918 if (*ppos > len) {
1919 *lenp = 0;
1920 return 0;
1921 }
1922
1923 data += *ppos;
1924 len -= *ppos;
1925
1da177e4
LT		 1926 if (len > *lenp)
1927 len = *lenp;
1928 if (len)
f8808300 1929 if (copy_to_user(buffer, data, len))
1da177e4
LT		 1930 return -EFAULT;
1931 if (len < *lenp) {
f8808300 1932 if (put_user('\n', buffer + len))
1da177e4
LT		 1933 return -EFAULT;
1934 len++;
1935 }
1936 *lenp = len;
1937 *ppos += len;
1938 }
1939 return 0;
1940}
1941
f4aacea2
KC		 1942static void warn_sysctl_write(struct ctl_table *table)
1943{
1944 pr_warn_once("%s wrote to %s when file position was not 0!\n"
1945 "This will not be supported in the future. To silence this\n"
1946 "warning, set kernel.sysctl_writes_strict = -1\n",
1947 current->comm, table->procname);
1948}
1949
f5dd3d6f
SV		 1950/**
1951 * proc_dostring - read a string sysctl
1952 * @table: the sysctl table
1953 * @write: %TRUE if this is a write to the sysctl file
f5dd3d6f
SV		 1954 * @buffer: the user buffer
1955 * @lenp: the size of the user buffer
1956 * @ppos: file position
1957 *
1958 * Reads/writes a string from/to the user buffer. If the kernel
1959 * buffer provided is not large enough to hold the string, the
1960 * string is truncated. The copied string is %NULL-terminated.
1961 * If the string is being read by the user process, it is copied
1962 * and a newline '\n' is added. It is truncated if the buffer is
1963 * not large enough.
1964 *
1965 * Returns 0 on success.
1966 */
8d65af78 1967int proc_dostring(struct ctl_table *table, int write,
f5dd3d6f
SV		 1968 void __user *buffer, size_t *lenp, loff_t *ppos)
1969{
f4aacea2
KC		 1970 if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
1971 warn_sysctl_write(table);
1972
f8808300
KC		 1973 return _proc_do_string((char *)(table->data), table->maxlen, write,
1974 (char __user *)buffer, lenp, ppos);
f5dd3d6f
SV		 1975}
1976
00b7c339
AW		 1977static size_t proc_skip_spaces(char **buf)
1978{
1979 size_t ret;
1980 char *tmp = skip_spaces(*buf);
1981 ret = tmp - *buf;
1982 *buf = tmp;
1983 return ret;
1984}
1985
9f977fb7
OP		 1986static void proc_skip_char(char **buf, size_t *size, const char v)
1987{
1988 while (*size) {
1989 if (**buf != v)
1990 break;
1991 (*size)--;
1992 (*buf)++;
1993 }
1994}
1995
00b7c339
AW		 1996#define TMPBUFLEN 22
1997/**
0fc377bd 1998 * proc_get_long - reads an ASCII formatted integer from a user buffer
00b7c339 1999 *
0fc377bd
RD		 2000 * @buf: a kernel buffer
2001 * @size: size of the kernel buffer
2002 * @val: this is where the number will be stored
2003 * @neg: set to %TRUE if number is negative
2004 * @perm_tr: a vector which contains the allowed trailers
2005 * @perm_tr_len: size of the perm_tr vector
2006 * @tr: pointer to store the trailer character
00b7c339 2007 *
0fc377bd
RD		 2008 * In case of success %0 is returned and @buf and @size are updated with
2009 * the amount of bytes read. If @tr is non-NULL and a trailing
2010 * character exists (size is non-zero after returning from this
2011 * function), @tr is updated with the trailing character.
00b7c339
AW		 2012 */
2013static int proc_get_long(char **buf, size_t *size,
2014 unsigned long *val, bool *neg,
2015 const char *perm_tr, unsigned perm_tr_len, char *tr)
2016{
2017 int len;
2018 char *p, tmp[TMPBUFLEN];
2019
2020 if (!*size)
2021 return -EINVAL;
2022
2023 len = *size;
2024 if (len > TMPBUFLEN - 1)
2025 len = TMPBUFLEN - 1;
2026
2027 memcpy(tmp, *buf, len);
2028
2029 tmp[len] = 0;
2030 p = tmp;
2031 if (*p == '-' && *size > 1) {
2032 *neg = true;
2033 p++;
2034 } else
2035 *neg = false;
2036 if (!isdigit(*p))
2037 return -EINVAL;
2038
2039 *val = simple_strtoul(p, &p, 0);
2040
2041 len = p - tmp;
2042
2043 /* We don't know if the next char is whitespace thus we may accept
2044 * invalid integers (e.g. 1234...a) or two integers instead of one
2045 * (e.g. 123...1). So lets not allow such large numbers. */
2046 if (len == TMPBUFLEN - 1)
2047 return -EINVAL;
2048
2049 if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
2050 return -EINVAL;
1da177e4 2051
00b7c339
AW		 2052 if (tr && (len < *size))
2053 *tr = *p;
2054
2055 *buf += len;
2056 *size -= len;
2057
2058 return 0;
2059}
2060
2061/**
0fc377bd 2062 * proc_put_long - converts an integer to a decimal ASCII formatted string
00b7c339 2063 *
0fc377bd
RD		 2064 * @buf: the user buffer
2065 * @size: the size of the user buffer
2066 * @val: the integer to be converted
2067 * @neg: sign of the number, %TRUE for negative
00b7c339 2068 *
0fc377bd
RD		 2069 * In case of success %0 is returned and @buf and @size are updated with
2070 * the amount of bytes written.
00b7c339
AW		 2071 */
2072static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
2073 bool neg)
2074{
2075 int len;
2076 char tmp[TMPBUFLEN], *p = tmp;
2077
2078 sprintf(p, "%s%lu", neg ? "-" : "", val);
2079 len = strlen(tmp);
2080 if (len > *size)
2081 len = *size;
2082 if (copy_to_user(*buf, tmp, len))
2083 return -EFAULT;
2084 *size -= len;
2085 *buf += len;
2086 return 0;
2087}
2088#undef TMPBUFLEN
2089
2090static int proc_put_char(void __user **buf, size_t *size, char c)
2091{
2092 if (*size) {
2093 char __user **buffer = (char __user **)buf;
2094 if (put_user(c, *buffer))
2095 return -EFAULT;
2096 (*size)--, (*buffer)++;
2097 *buf = *buffer;
2098 }
2099 return 0;
2100}
1da177e4 2101
00b7c339 2102static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
1da177e4
LT		 2103 int *valp,
2104 int write, void *data)
2105{
2106 if (write) {
230633d1
HS		 2107 if (*negp) {
2108 if (*lvalp > (unsigned long) INT_MAX + 1)
2109 return -EINVAL;
2110 *valp = -*lvalp;
2111 } else {
2112 if (*lvalp > (unsigned long) INT_MAX)
2113 return -EINVAL;
2114 *valp = *lvalp;
2115 }
1da177e4
LT		 2116 } else {
2117 int val = *valp;
2118 if (val < 0) {
00b7c339 2119 *negp = true;
9a5bc726 2120 *lvalp = -(unsigned long)val;
1da177e4 2121 } else {
00b7c339 2122 *negp = false;
1da177e4
LT		 2123 *lvalp = (unsigned long)val;
2124 }
2125 }
2126 return 0;
2127}
2128
e7d316a0
SAK		 2129static int do_proc_douintvec_conv(bool *negp, unsigned long *lvalp,
2130 int *valp,
2131 int write, void *data)
2132{
2133 if (write) {
2134 if (*negp)
2135 return -EINVAL;
2136 *valp = *lvalp;
2137 } else {
2138 unsigned int val = *valp;
5380e564 2139 *negp = false;
e7d316a0
SAK		 2140 *lvalp = (unsigned long)val;
2141 }
2142 return 0;
2143}
2144
00b7c339
AW		 2145static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
2146
d8217f07 2147static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
8d65af78 2148 int write, void __user *buffer,
fcfbd547 2149 size_t *lenp, loff_t *ppos,
00b7c339 2150 int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
1da177e4
LT		 2151 int write, void *data),
2152 void *data)
2153{
00b7c339 2154 int *i, vleft, first = 1, err = 0;
00b7c339 2155 size_t left;
70f6cbb6 2156 char *kbuf = NULL, *p;
1da177e4 2157
00b7c339 2158 if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
1da177e4
LT		 2159 *lenp = 0;
2160 return 0;
2161 }
2162
fcfbd547 2163 i = (int *) tbl_data;
1da177e4
LT		 2164 vleft = table->maxlen / sizeof(*i);
2165 left = *lenp;
2166
2167 if (!conv)
2168 conv = do_proc_dointvec_conv;
2169
00b7c339 2170 if (write) {
f4aacea2
KC		 2171 if (*ppos) {
2172 switch (sysctl_writes_strict) {
2173 case SYSCTL_WRITES_STRICT:
2174 goto out;
2175 case SYSCTL_WRITES_WARN:
2176 warn_sysctl_write(table);
2177 break;
2178 default:
2179 break;
2180 }
2181 }
2182
00b7c339
AW		 2183 if (left > PAGE_SIZE - 1)
2184 left = PAGE_SIZE - 1;
70f6cbb6
AV		 2185 p = kbuf = memdup_user_nul(buffer, left);
2186 if (IS_ERR(kbuf))
2187 return PTR_ERR(kbuf);
00b7c339
AW		 2188 }
2189
1da177e4 2190 for (; left && vleft--; i++, first=0) {
00b7c339
AW		 2191 unsigned long lval;
2192 bool neg;
1da177e4 2193
00b7c339 2194 if (write) {
70f6cbb6 2195 left -= proc_skip_spaces(&p);
1da177e4 2196
563b0467
O		 2197 if (!left)
2198 break;
70f6cbb6 2199 err = proc_get_long(&p, &left, &lval, &neg,
00b7c339
AW		 2200 proc_wspace_sep,
2201 sizeof(proc_wspace_sep), NULL);
2202 if (err)
1da177e4 2203 break;
00b7c339
AW		 2204 if (conv(&neg, &lval, i, 1, data)) {
2205 err = -EINVAL;
1da177e4 2206 break;
00b7c339 2207 }
1da177e4 2208 } else {
00b7c339
AW		 2209 if (conv(&neg, &lval, i, 0, data)) {
2210 err = -EINVAL;
2211 break;
2212 }
1da177e4 2213 if (!first)
00b7c339
AW		 2214 err = proc_put_char(&buffer, &left, '\t');
2215 if (err)
2216 break;
2217 err = proc_put_long(&buffer, &left, lval, neg);
2218 if (err)
1da177e4 2219 break;
1da177e4
LT		 2220 }
2221 }
2222
00b7c339
AW		 2223 if (!write && !first && left && !err)
2224 err = proc_put_char(&buffer, &left, '\n');
563b0467 2225 if (write && !err && left)
70f6cbb6 2226 left -= proc_skip_spaces(&p);
1da177e4 2227 if (write) {
70f6cbb6 2228 kfree(kbuf);
00b7c339
AW		 2229 if (first)
2230 return err ? : -EINVAL;
1da177e4 2231 }
1da177e4 2232 *lenp -= left;
f4aacea2 2233out:
1da177e4 2234 *ppos += *lenp;
00b7c339 2235 return err;
1da177e4
LT		 2236}
2237
8d65af78 2238static int do_proc_dointvec(struct ctl_table *table, int write,
fcfbd547 2239 void __user *buffer, size_t *lenp, loff_t *ppos,
00b7c339 2240 int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
fcfbd547
KK		 2241 int write, void *data),
2242 void *data)
2243{
8d65af78 2244 return __do_proc_dointvec(table->data, table, write,
fcfbd547
KK		 2245 buffer, lenp, ppos, conv, data);
2246}
2247
1da177e4
LT		 2248/**
2249 * proc_dointvec - read a vector of integers
2250 * @table: the sysctl table
2251 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2252 * @buffer: the user buffer
2253 * @lenp: the size of the user buffer
2254 * @ppos: file position
2255 *
2256 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2257 * values from/to the user buffer, treated as an ASCII string.
2258 *
2259 * Returns 0 on success.
2260 */
8d65af78 2261int proc_dointvec(struct ctl_table *table, int write,
1da177e4
LT		 2262 void __user *buffer, size_t *lenp, loff_t *ppos)
2263{
e7d316a0
SAK		 2264 return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
2265}
2266
2267/**
2268 * proc_douintvec - read a vector of unsigned integers
2269 * @table: the sysctl table
2270 * @write: %TRUE if this is a write to the sysctl file
2271 * @buffer: the user buffer
2272 * @lenp: the size of the user buffer
2273 * @ppos: file position
2274 *
2275 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
2276 * values from/to the user buffer, treated as an ASCII string.
2277 *
2278 * Returns 0 on success.
2279 */
2280int proc_douintvec(struct ctl_table *table, int write,
2281 void __user *buffer, size_t *lenp, loff_t *ppos)
2282{
2283 return do_proc_dointvec(table, write, buffer, lenp, ppos,
2284 do_proc_douintvec_conv, NULL);
1da177e4
LT		 2285}
2286
34f5a398 2287/*
25ddbb18
AK		 2288 * Taint values can only be increased
2289 * This means we can safely use a temporary.
34f5a398 2290 */
8d65af78 2291static int proc_taint(struct ctl_table *table, int write,
34f5a398
TT		 2292 void __user *buffer, size_t *lenp, loff_t *ppos)
2293{
25ddbb18
AK		 2294 struct ctl_table t;
2295 unsigned long tmptaint = get_taint();
2296 int err;
34f5a398 2297
91fcd412 2298 if (write && !capable(CAP_SYS_ADMIN))
34f5a398
TT		 2299 return -EPERM;
2300
25ddbb18
AK		 2301 t = *table;
2302 t.data = &tmptaint;
8d65af78 2303 err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
25ddbb18
AK		 2304 if (err < 0)
2305 return err;
2306
2307 if (write) {
2308 /*
2309 * Poor man's atomic or. Not worth adding a primitive
2310 * to everyone's atomic.h for this
2311 */
2312 int i;
2313 for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2314 if ((tmptaint >> i) & 1)
373d4d09 2315 add_taint(i, LOCKDEP_STILL_OK);
25ddbb18
AK		 2316 }
2317 }
2318
2319 return err;
34f5a398
TT		 2320}
2321
bfdc0b49 2322#ifdef CONFIG_PRINTK
620f6e8e 2323static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
bfdc0b49
RW		 2324 void __user *buffer, size_t *lenp, loff_t *ppos)
2325{
2326 if (write && !capable(CAP_SYS_ADMIN))
2327 return -EPERM;
2328
2329 return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2330}
2331#endif
2332
1da177e4
LT		 2333struct do_proc_dointvec_minmax_conv_param {
2334 int *min;
2335 int *max;
2336};
2337
00b7c339
AW		 2338static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
2339 int *valp,
1da177e4
LT		 2340 int write, void *data)
2341{
2342 struct do_proc_dointvec_minmax_conv_param *param = data;
2343 if (write) {
2344 int val = *negp ? -*lvalp : *lvalp;
2345 if ((param->min && *param->min > val) ||
2346 (param->max && *param->max < val))
2347 return -EINVAL;
2348 *valp = val;
2349 } else {
2350 int val = *valp;
2351 if (val < 0) {
00b7c339 2352 *negp = true;
9a5bc726 2353 *lvalp = -(unsigned long)val;
1da177e4 2354 } else {
00b7c339 2355 *negp = false;
1da177e4
LT		 2356 *lvalp = (unsigned long)val;
2357 }
2358 }
2359 return 0;
2360}
2361
2362/**
2363 * proc_dointvec_minmax - read a vector of integers with min/max values
2364 * @table: the sysctl table
2365 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2366 * @buffer: the user buffer
2367 * @lenp: the size of the user buffer
2368 * @ppos: file position
2369 *
2370 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2371 * values from/to the user buffer, treated as an ASCII string.
2372 *
2373 * This routine will ensure the values are within the range specified by
2374 * table->extra1 (min) and table->extra2 (max).
2375 *
2376 * Returns 0 on success.
2377 */
8d65af78 2378int proc_dointvec_minmax(struct ctl_table *table, int write,
1da177e4
LT		 2379 void __user *buffer, size_t *lenp, loff_t *ppos)
2380{
2381 struct do_proc_dointvec_minmax_conv_param param = {
2382 .min = (int *) table->extra1,
2383 .max = (int *) table->extra2,
2384 };
8d65af78 2385 return do_proc_dointvec(table, write, buffer, lenp, ppos,
1da177e4
LT		 2386 do_proc_dointvec_minmax_conv, &param);
2387}
2388
54b50199
KC		 2389static void validate_coredump_safety(void)
2390{
046d662f 2391#ifdef CONFIG_COREDUMP
e579d2c2 2392 if (suid_dumpable == SUID_DUMP_ROOT &&
54b50199 2393 core_pattern[0] != '/' && core_pattern[0] != '|') {
760c6a91
AD		 2394 printk(KERN_WARNING
2395"Unsafe core_pattern used with fs.suid_dumpable=2.\n"
2396"Pipe handler or fully qualified core dump path required.\n"
2397"Set kernel.core_pattern before fs.suid_dumpable.\n"
2398 );
54b50199 2399 }
046d662f 2400#endif
54b50199
KC		 2401}
2402
2403static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
2404 void __user *buffer, size_t *lenp, loff_t *ppos)
2405{
2406 int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2407 if (!error)
2408 validate_coredump_safety();
2409 return error;
2410}
2411
046d662f 2412#ifdef CONFIG_COREDUMP
54b50199
KC		 2413static int proc_dostring_coredump(struct ctl_table *table, int write,
2414 void __user *buffer, size_t *lenp, loff_t *ppos)
2415{
2416 int error = proc_dostring(table, write, buffer, lenp, ppos);
2417 if (!error)
2418 validate_coredump_safety();
2419 return error;
2420}
046d662f 2421#endif
54b50199 2422
d8217f07 2423static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
1da177e4
LT		 2424 void __user *buffer,
2425 size_t *lenp, loff_t *ppos,
2426 unsigned long convmul,
2427 unsigned long convdiv)
2428{
00b7c339
AW		 2429 unsigned long *i, *min, *max;
2430 int vleft, first = 1, err = 0;
00b7c339 2431 size_t left;
70f6cbb6 2432 char *kbuf = NULL, *p;
00b7c339
AW		 2433
2434 if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1da177e4
LT		 2435 *lenp = 0;
2436 return 0;
2437 }
00b7c339 2438
fcfbd547 2439 i = (unsigned long *) data;
1da177e4
LT		 2440 min = (unsigned long *) table->extra1;
2441 max = (unsigned long *) table->extra2;
2442 vleft = table->maxlen / sizeof(unsigned long);
2443 left = *lenp;
00b7c339
AW		 2444
2445 if (write) {
f4aacea2
KC		 2446 if (*ppos) {
2447 switch (sysctl_writes_strict) {
2448 case SYSCTL_WRITES_STRICT:
2449 goto out;
2450 case SYSCTL_WRITES_WARN:
2451 warn_sysctl_write(table);
2452 break;
2453 default:
2454 break;
2455 }
2456 }
2457
00b7c339
AW		 2458 if (left > PAGE_SIZE - 1)
2459 left = PAGE_SIZE - 1;
70f6cbb6
AV		 2460 p = kbuf = memdup_user_nul(buffer, left);
2461 if (IS_ERR(kbuf))
2462 return PTR_ERR(kbuf);
00b7c339
AW		 2463 }
2464
27b3d80a 2465 for (; left && vleft--; i++, first = 0) {
00b7c339
AW		 2466 unsigned long val;
2467
1da177e4 2468 if (write) {
00b7c339
AW		 2469 bool neg;
2470
70f6cbb6 2471 left -= proc_skip_spaces(&p);
00b7c339 2472
70f6cbb6 2473 err = proc_get_long(&p, &left, &val, &neg,
00b7c339
AW		 2474 proc_wspace_sep,
2475 sizeof(proc_wspace_sep), NULL);
2476 if (err)
1da177e4
LT		 2477 break;
2478 if (neg)
1da177e4 2479 continue;
ff9f8a7c 2480 val = convmul * val / convdiv;
1da177e4
LT		 2481 if ((min && val < *min) || (max && val > *max))
2482 continue;
2483 *i = val;
2484 } else {
00b7c339 2485 val = convdiv * (*i) / convmul;
7833819d 2486 if (!first) {
00b7c339 2487 err = proc_put_char(&buffer, &left, '\t');
7833819d
CG		 2488 if (err)
2489 break;
2490 }
00b7c339
AW		 2491 err = proc_put_long(&buffer, &left, val, false);
2492 if (err)
2493 break;
1da177e4
LT		 2494 }
2495 }
2496
00b7c339
AW		 2497 if (!write && !first && left && !err)
2498 err = proc_put_char(&buffer, &left, '\n');
2499 if (write && !err)
70f6cbb6 2500 left -= proc_skip_spaces(&p);
1da177e4 2501 if (write) {
70f6cbb6 2502 kfree(kbuf);
00b7c339
AW		 2503 if (first)
2504 return err ? : -EINVAL;
1da177e4 2505 }
1da177e4 2506 *lenp -= left;
f4aacea2 2507out:
1da177e4 2508 *ppos += *lenp;
00b7c339 2509 return err;
1da177e4
LT		 2510}
2511
d8217f07 2512static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
fcfbd547
KK		 2513 void __user *buffer,
2514 size_t *lenp, loff_t *ppos,
2515 unsigned long convmul,
2516 unsigned long convdiv)
2517{
2518 return __do_proc_doulongvec_minmax(table->data, table, write,
8d65af78 2519 buffer, lenp, ppos, convmul, convdiv);
fcfbd547
KK		 2520}
2521
1da177e4
LT		 2522/**
2523 * proc_doulongvec_minmax - read a vector of long integers with min/max values
2524 * @table: the sysctl table
2525 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2526 * @buffer: the user buffer
2527 * @lenp: the size of the user buffer
2528 * @ppos: file position
2529 *
2530 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2531 * values from/to the user buffer, treated as an ASCII string.
2532 *
2533 * This routine will ensure the values are within the range specified by
2534 * table->extra1 (min) and table->extra2 (max).
2535 *
2536 * Returns 0 on success.
2537 */
8d65af78 2538int proc_doulongvec_minmax(struct ctl_table *table, int write,
1da177e4
LT		 2539 void __user *buffer, size_t *lenp, loff_t *ppos)
2540{
8d65af78 2541 return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
1da177e4
LT		 2542}
2543
2544/**
2545 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2546 * @table: the sysctl table
2547 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2548 * @buffer: the user buffer
2549 * @lenp: the size of the user buffer
2550 * @ppos: file position
2551 *
2552 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2553 * values from/to the user buffer, treated as an ASCII string. The values
2554 * are treated as milliseconds, and converted to jiffies when they are stored.
2555 *
2556 * This routine will ensure the values are within the range specified by
2557 * table->extra1 (min) and table->extra2 (max).
2558 *
2559 * Returns 0 on success.
2560 */
d8217f07 2561int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1da177e4
LT		 2562 void __user *buffer,
2563 size_t *lenp, loff_t *ppos)
2564{
8d65af78 2565 return do_proc_doulongvec_minmax(table, write, buffer,
1da177e4
LT		 2566 lenp, ppos, HZ, 1000l);
2567}
2568
2569
00b7c339 2570static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
1da177e4
LT		 2571 int *valp,
2572 int write, void *data)
2573{
2574 if (write) {
cba9f33d
BS		 2575 if (*lvalp > LONG_MAX / HZ)
2576 return 1;
1da177e4
LT		 2577 *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2578 } else {
2579 int val = *valp;
2580 unsigned long lval;
2581 if (val < 0) {
00b7c339 2582 *negp = true;
9a5bc726 2583 lval = -(unsigned long)val;
1da177e4 2584 } else {
00b7c339 2585 *negp = false;
1da177e4
LT		 2586 lval = (unsigned long)val;
2587 }
2588 *lvalp = lval / HZ;
2589 }
2590 return 0;
2591}
2592
00b7c339 2593static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
1da177e4
LT		 2594 int *valp,
2595 int write, void *data)
2596{
2597 if (write) {
cba9f33d
BS		 2598 if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2599 return 1;
1da177e4
LT		 2600 *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
2601 } else {
2602 int val = *valp;
2603 unsigned long lval;
2604 if (val < 0) {
00b7c339 2605 *negp = true;
9a5bc726 2606 lval = -(unsigned long)val;
1da177e4 2607 } else {
00b7c339 2608 *negp = false;
1da177e4
LT		 2609 lval = (unsigned long)val;
2610 }
2611 *lvalp = jiffies_to_clock_t(lval);
2612 }
2613 return 0;
2614}
2615
00b7c339 2616static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
1da177e4
LT		 2617 int *valp,
2618 int write, void *data)
2619{
2620 if (write) {
d738ce8f
FF		 2621 unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2622
2623 if (jif > INT_MAX)
2624 return 1;
2625 *valp = (int)jif;
1da177e4
LT		 2626 } else {
2627 int val = *valp;
2628 unsigned long lval;
2629 if (val < 0) {
00b7c339 2630 *negp = true;
9a5bc726 2631 lval = -(unsigned long)val;
1da177e4 2632 } else {
00b7c339 2633 *negp = false;
1da177e4
LT		 2634 lval = (unsigned long)val;
2635 }
2636 *lvalp = jiffies_to_msecs(lval);
2637 }
2638 return 0;
2639}
2640
2641/**
2642 * proc_dointvec_jiffies - read a vector of integers as seconds
2643 * @table: the sysctl table
2644 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2645 * @buffer: the user buffer
2646 * @lenp: the size of the user buffer
2647 * @ppos: file position
2648 *
2649 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2650 * values from/to the user buffer, treated as an ASCII string.
2651 * The values read are assumed to be in seconds, and are converted into
2652 * jiffies.
2653 *
2654 * Returns 0 on success.
2655 */
8d65af78 2656int proc_dointvec_jiffies(struct ctl_table *table, int write,
1da177e4
LT		 2657 void __user *buffer, size_t *lenp, loff_t *ppos)
2658{
8d65af78 2659 return do_proc_dointvec(table,write,buffer,lenp,ppos,
1da177e4
LT		 2660 do_proc_dointvec_jiffies_conv,NULL);
2661}
2662
2663/**
2664 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2665 * @table: the sysctl table
2666 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2667 * @buffer: the user buffer
2668 * @lenp: the size of the user buffer
1e5d5331 2669 * @ppos: pointer to the file position
1da177e4
LT		 2670 *
2671 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2672 * values from/to the user buffer, treated as an ASCII string.
2673 * The values read are assumed to be in 1/USER_HZ seconds, and
2674 * are converted into jiffies.
2675 *
2676 * Returns 0 on success.
2677 */
8d65af78 2678int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1da177e4
LT		 2679 void __user *buffer, size_t *lenp, loff_t *ppos)
2680{
8d65af78 2681 return do_proc_dointvec(table,write,buffer,lenp,ppos,
1da177e4
LT		 2682 do_proc_dointvec_userhz_jiffies_conv,NULL);
2683}
2684
2685/**
2686 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2687 * @table: the sysctl table
2688 * @write: %TRUE if this is a write to the sysctl file
1da177e4
LT		 2689 * @buffer: the user buffer
2690 * @lenp: the size of the user buffer
67be2dd1
MW		 2691 * @ppos: file position
2692 * @ppos: the current position in the file
1da177e4
LT		 2693 *
2694 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2695 * values from/to the user buffer, treated as an ASCII string.
2696 * The values read are assumed to be in 1/1000 seconds, and
2697 * are converted into jiffies.
2698 *
2699 * Returns 0 on success.
2700 */
8d65af78 2701int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
1da177e4
LT		 2702 void __user *buffer, size_t *lenp, loff_t *ppos)
2703{
8d65af78 2704 return do_proc_dointvec(table, write, buffer, lenp, ppos,
1da177e4
LT		 2705 do_proc_dointvec_ms_jiffies_conv, NULL);
2706}
2707
8d65af78 2708static int proc_do_cad_pid(struct ctl_table *table, int write,
9ec52099
CLG		 2709 void __user *buffer, size_t *lenp, loff_t *ppos)
2710{
2711 struct pid *new_pid;
2712 pid_t tmp;
2713 int r;
2714
6c5f3e7b 2715 tmp = pid_vnr(cad_pid);
9ec52099 2716
8d65af78 2717 r = __do_proc_dointvec(&tmp, table, write, buffer,
9ec52099
CLG		 2718 lenp, ppos, NULL, NULL);
2719 if (r || !write)
2720 return r;
2721
2722 new_pid = find_get_pid(tmp);
2723 if (!new_pid)
2724 return -ESRCH;
2725
2726 put_pid(xchg(&cad_pid, new_pid));
2727 return 0;
2728}
2729
9f977fb7
OP		 2730/**
2731 * proc_do_large_bitmap - read/write from/to a large bitmap
2732 * @table: the sysctl table
2733 * @write: %TRUE if this is a write to the sysctl file
2734 * @buffer: the user buffer
2735 * @lenp: the size of the user buffer
2736 * @ppos: file position
2737 *
2738 * The bitmap is stored at table->data and the bitmap length (in bits)
2739 * in table->maxlen.
2740 *
2741 * We use a range comma separated format (e.g. 1,3-4,10-10) so that
2742 * large bitmaps may be represented in a compact manner. Writing into
2743 * the file will clear the bitmap then update it with the given input.
2744 *
2745 * Returns 0 on success.
2746 */
2747int proc_do_large_bitmap(struct ctl_table *table, int write,
2748 void __user *buffer, size_t *lenp, loff_t *ppos)
2749{
2750 int err = 0;
2751 bool first = 1;
2752 size_t left = *lenp;
2753 unsigned long bitmap_len = table->maxlen;
122ff243 2754 unsigned long *bitmap = *(unsigned long **) table->data;
9f977fb7
OP		 2755 unsigned long *tmp_bitmap = NULL;
2756 char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
2757
122ff243 2758 if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
9f977fb7
OP		 2759 *lenp = 0;
2760 return 0;
2761 }
2762
2763 if (write) {
70f6cbb6 2764 char *kbuf, *p;
9f977fb7
OP		 2765
2766 if (left > PAGE_SIZE - 1)
2767 left = PAGE_SIZE - 1;
2768
70f6cbb6
AV		 2769 p = kbuf = memdup_user_nul(buffer, left);
2770 if (IS_ERR(kbuf))
2771 return PTR_ERR(kbuf);
9f977fb7
OP		 2772
2773 tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
2774 GFP_KERNEL);
2775 if (!tmp_bitmap) {
70f6cbb6 2776 kfree(kbuf);
9f977fb7
OP		 2777 return -ENOMEM;
2778 }
70f6cbb6 2779 proc_skip_char(&p, &left, '\n');
9f977fb7
OP		 2780 while (!err && left) {
2781 unsigned long val_a, val_b;
2782 bool neg;
2783
70f6cbb6 2784 err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
9f977fb7
OP		 2785 sizeof(tr_a), &c);
2786 if (err)
2787 break;
2788 if (val_a >= bitmap_len || neg) {
2789 err = -EINVAL;
2790 break;
2791 }
2792
2793 val_b = val_a;
2794 if (left) {
70f6cbb6 2795 p++;
9f977fb7
OP		 2796 left--;
2797 }
2798
2799 if (c == '-') {
70f6cbb6 2800 err = proc_get_long(&p, &left, &val_b,
9f977fb7
OP		 2801 &neg, tr_b, sizeof(tr_b),
2802 &c);
2803 if (err)
2804 break;
2805 if (val_b >= bitmap_len || neg ||
2806 val_a > val_b) {
2807 err = -EINVAL;
2808 break;
2809 }
2810 if (left) {
70f6cbb6 2811 p++;
9f977fb7
OP		 2812 left--;
2813 }
2814 }
2815
5a04cca6 2816 bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
9f977fb7 2817 first = 0;
70f6cbb6 2818 proc_skip_char(&p, &left, '\n');
9f977fb7 2819 }
70f6cbb6 2820 kfree(kbuf);
9f977fb7
OP		 2821 } else {
2822 unsigned long bit_a, bit_b = 0;
2823
2824 while (left) {
2825 bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
2826 if (bit_a >= bitmap_len)
2827 break;
2828 bit_b = find_next_zero_bit(bitmap, bitmap_len,
2829 bit_a + 1) - 1;
2830
2831 if (!first) {
2832 err = proc_put_char(&buffer, &left, ',');
2833 if (err)
2834 break;
2835 }
2836 err = proc_put_long(&buffer, &left, bit_a, false);
2837 if (err)
2838 break;
2839 if (bit_a != bit_b) {
2840 err = proc_put_char(&buffer, &left, '-');
2841 if (err)
2842 break;
2843 err = proc_put_long(&buffer, &left, bit_b, false);
2844 if (err)
2845 break;
2846 }
2847
2848 first = 0; bit_b++;
2849 }
2850 if (!err)
2851 err = proc_put_char(&buffer, &left, '\n');
2852 }
2853
2854 if (!err) {
2855 if (write) {
2856 if (*ppos)
2857 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
2858 else
5a04cca6 2859 bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
9f977fb7
OP		 2860 }
2861 kfree(tmp_bitmap);
2862 *lenp -= left;
2863 *ppos += *lenp;
2864 return 0;
2865 } else {
2866 kfree(tmp_bitmap);
2867 return err;
2868 }
2869}
2870
55610500 2871#else /* CONFIG_PROC_SYSCTL */
1da177e4 2872
8d65af78 2873int proc_dostring(struct ctl_table *table, int write,
1da177e4
LT		 2874 void __user *buffer, size_t *lenp, loff_t *ppos)
2875{
2876 return -ENOSYS;
2877}
2878
8d65af78 2879int proc_dointvec(struct ctl_table *table, int write,
1da177e4 2880 void __user *buffer, size_t *lenp, loff_t *ppos)
1da177e4
LT		 2881{
2882 return -ENOSYS;
2883}
2884
e7d316a0
SAK		 2885int proc_douintvec(struct ctl_table *table, int write,
2886 void __user *buffer, size_t *lenp, loff_t *ppos)
2887{
2888 return -ENOSYS;
2889}
2890
8d65af78 2891int proc_dointvec_minmax(struct ctl_table *table, int write,
1da177e4
LT		 2892 void __user *buffer, size_t *lenp, loff_t *ppos)
2893{
2894 return -ENOSYS;
2895}
2896
8d65af78 2897int proc_dointvec_jiffies(struct ctl_table *table, int write,
1da177e4
LT		 2898 void __user *buffer, size_t *lenp, loff_t *ppos)
2899{
2900 return -ENOSYS;
2901}
2902
8d65af78 2903int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1da177e4
LT		 2904 void __user *buffer, size_t *lenp, loff_t *ppos)
2905{
2906 return -ENOSYS;
2907}
2908
8d65af78 2909int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
1da177e4
LT		 2910 void __user *buffer, size_t *lenp, loff_t *ppos)
2911{
2912 return -ENOSYS;
2913}
2914
8d65af78 2915int proc_doulongvec_minmax(struct ctl_table *table, int write,
1da177e4
LT		 2916 void __user *buffer, size_t *lenp, loff_t *ppos)
2917{
2918 return -ENOSYS;
2919}
2920
d8217f07 2921int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1da177e4
LT		 2922 void __user *buffer,
2923 size_t *lenp, loff_t *ppos)
2924{
2925 return -ENOSYS;
2926}
2927
2928
55610500 2929#endif /* CONFIG_PROC_SYSCTL */
1da177e4 2930
1da177e4
LT		 2931/*
2932 * No sense putting this after each symbol definition, twice,
2933 * exception granted :-)
2934 */
2935EXPORT_SYMBOL(proc_dointvec);
e7d316a0 2936EXPORT_SYMBOL(proc_douintvec);
1da177e4
LT		 2937EXPORT_SYMBOL(proc_dointvec_jiffies);
2938EXPORT_SYMBOL(proc_dointvec_minmax);
2939EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2940EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2941EXPORT_SYMBOL(proc_dostring);
2942EXPORT_SYMBOL(proc_doulongvec_minmax);
2943EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
Linux 6.x block layer and io_uring tree(s)