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