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