blob: 9327a26765c57da2ec22d8c5b7be03b21dbb4f62 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * sysctl.c: General linux system control interface
3 *
4 * Begun 24 March 1995, Stephen Tweedie
5 * Added /proc support, Dec 1995
6 * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
7 * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
8 * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
9 * Dynamic registration fixes, Stephen Tweedie.
10 * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
11 * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
12 * Horn.
13 * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
14 * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
15 * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
16 * Wendling.
17 * The list_for_each() macro wasn't appropriate for the sysctl loop.
18 * Removed it and replaced it with older style, 03/23/00, Bill Wendling
19 */
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/module.h>
22#include <linux/mm.h>
23#include <linux/swap.h>
24#include <linux/slab.h>
25#include <linux/sysctl.h>
26#include <linux/proc_fs.h>
Andrew Morgan72c2d582007-10-18 03:05:59 -070027#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/ctype.h>
Vegard Nossumdfec0722008-04-04 00:51:41 +020029#include <linux/kmemcheck.h>
Adrian Bunk62239ac2007-07-17 04:03:45 -070030#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/init.h>
32#include <linux/kernel.h>
Kay Sievers0296b222005-11-11 05:33:52 +010033#include <linux/kobject.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030034#include <linux/net.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/sysrq.h>
36#include <linux/highuid.h>
37#include <linux/writeback.h>
Ingo Molnar3fff4c42009-09-22 16:18:09 +020038#include <linux/ratelimit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/hugetlb.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/initrd.h>
David Howells0b77f5b2008-04-29 01:01:32 -070041#include <linux/key.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/times.h>
43#include <linux/limits.h>
44#include <linux/dcache.h>
45#include <linux/syscalls.h>
Adrian Bunkc748e132008-07-23 21:27:03 -070046#include <linux/vmstat.h>
Pavel Machekc255d842006-02-20 18:27:58 -080047#include <linux/nfs_fs.h>
48#include <linux/acpi.h>
Jeremy Fitzhardinge10a0a8d2007-07-17 18:37:02 -070049#include <linux/reboot.h>
Steven Rostedtb0fc4942008-05-12 21:20:43 +020050#include <linux/ftrace.h>
David Howells12e22c52009-04-03 16:42:35 +010051#include <linux/slow-work.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +020052#include <linux/perf_event.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54#include <asm/uaccess.h>
55#include <asm/processor.h>
56
Andi Kleen29cbc782006-09-30 01:47:55 +020057#ifdef CONFIG_X86
58#include <asm/nmi.h>
Chuck Ebbert0741f4d2006-12-07 02:14:11 +010059#include <asm/stacktrace.h>
Ingo Molnar6e7c4022008-01-30 13:30:05 +010060#include <asm/io.h>
Andi Kleen29cbc782006-09-30 01:47:55 +020061#endif
62
Eric W. Biederman7058cb02007-10-18 03:05:58 -070063
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#if defined(CONFIG_SYSCTL)
65
66/* External variables not in a header file. */
67extern int C_A_D;
Ingo Molnar45807a12007-07-15 23:40:10 -070068extern int print_fatal_signals;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069extern int sysctl_overcommit_memory;
70extern int sysctl_overcommit_ratio;
KAMEZAWA Hiroyukifadd8fb2006-06-23 02:03:13 -070071extern int sysctl_panic_on_oom;
David Rientjesfe071d72007-10-16 23:25:56 -070072extern int sysctl_oom_kill_allocating_task;
David Rientjesfef1bdd2008-02-07 00:14:07 -080073extern int sysctl_oom_dump_tasks;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074extern int max_threads;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075extern int core_uses_pid;
Alan Coxd6e71142005-06-23 00:09:43 -070076extern int suid_dumpable;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077extern char core_pattern[];
Neil Hormana2939802009-09-23 15:56:56 -070078extern unsigned int core_pipe_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079extern int pid_max;
80extern int min_free_kbytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081extern int pid_max_min, pid_max_max;
Andrew Morton9d0243b2006-01-08 01:00:39 -080082extern int sysctl_drop_caches;
Rohit Seth8ad4b1f2006-01-08 01:00:40 -080083extern int percpu_pagelist_fraction;
Andi Kleenbebfa102006-06-26 13:56:52 +020084extern int compat_log;
Arjan van de Ven97455122008-01-25 21:08:34 +010085extern int latencytop_enabled;
Al Viroeceea0b2008-05-10 10:08:32 -040086extern int sysctl_nr_open_min, sysctl_nr_open_max;
Paul Mundtdd8632a2009-01-08 12:04:47 +000087#ifndef CONFIG_MMU
88extern int sysctl_nr_trim_pages;
89#endif
Paul E. McKenney31a72bc2008-06-18 09:26:49 -070090#ifdef CONFIG_RCU_TORTURE_TEST
91extern int rcutorture_runnable;
92#endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
Jens Axboecb684b52009-09-15 21:53:11 +020093#ifdef CONFIG_BLOCK
Jens Axboe5e605b62009-08-05 09:07:21 +020094extern int blk_iopoll_enabled;
Jens Axboecb684b52009-09-15 21:53:11 +020095#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -070097/* Constants used for minimum and maximum */
Bron Gondwana195cf4532008-02-04 22:29:20 -080098#ifdef CONFIG_DETECT_SOFTLOCKUP
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -070099static int sixty = 60;
Dimitri Sivanich9383d962008-05-12 21:21:14 +0200100static int neg_one = -1;
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700101#endif
102
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700103static int zero;
Linus Torvaldscd5f9a42009-04-06 13:38:46 -0700104static int __maybe_unused one = 1;
105static int __maybe_unused two = 2;
Sven Wegenerfc3501d2009-02-11 13:04:23 -0800106static unsigned long one_ul = 1;
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700107static int one_hundred = 100;
Dave Youngaf913222009-09-22 16:43:33 -0700108#ifdef CONFIG_PRINTK
109static int ten_thousand = 10000;
110#endif
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700111
Andrea Righi9e4a5bd2009-04-30 15:08:57 -0700112/* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
113static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
116static int maxolduid = 65535;
117static int minolduid;
Rohit Seth8ad4b1f2006-01-08 01:00:40 -0800118static int min_percpu_pagelist_fract = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120static int ngroups_max = NGROUPS_MAX;
121
Johannes Berga1ef5ad2008-07-08 19:00:17 +0200122#ifdef CONFIG_MODULES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123extern char modprobe_path[];
Kees Cook3d433212009-04-02 15:49:29 -0700124extern int modules_disabled;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126#ifdef CONFIG_CHR_DEV_SG
127extern int sg_big_buff;
128#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
David S. Miller72c57ed2008-09-11 23:29:54 -0700130#ifdef CONFIG_SPARC
David S. Miller17f04fb2008-09-11 23:33:53 -0700131#include <asm/system.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132#endif
133
David S. Miller08714202008-11-16 23:49:24 -0800134#ifdef CONFIG_SPARC64
135extern int sysctl_tsb_ratio;
136#endif
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138#ifdef __hppa__
139extern int pwrsw_enabled;
140extern int unaligned_enabled;
141#endif
142
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800143#ifdef CONFIG_S390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144#ifdef CONFIG_MATHEMU
145extern int sysctl_ieee_emulation_warnings;
146#endif
147extern int sysctl_userprocess_debug;
Martin Schwidefsky951f22d2005-07-27 11:44:57 -0700148extern int spin_retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#endif
150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#ifdef CONFIG_BSD_PROCESS_ACCT
152extern int acct_parm[];
153#endif
154
Jes Sorensend2b176e2006-02-28 09:42:23 -0800155#ifdef CONFIG_IA64
156extern int no_unaligned_warning;
Doug Chapman88fc2412009-01-15 10:38:56 -0800157extern int unaligned_dump_stack;
Jes Sorensend2b176e2006-02-28 09:42:23 -0800158#endif
159
Ingo Molnar3fff4c42009-09-22 16:18:09 +0200160extern struct ratelimit_state printk_ratelimit_state;
161
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700162#ifdef CONFIG_RT_MUTEXES
163extern int max_lock_depth;
164#endif
165
Randy Dunlapd6f8ff72006-10-19 23:28:34 -0700166#ifdef CONFIG_PROC_SYSCTL
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700167static int proc_do_cad_pid(struct ctl_table *table, int write,
Cedric Le Goater9ec52092006-10-02 02:19:00 -0700168 void __user *buffer, size_t *lenp, loff_t *ppos);
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700169static int proc_taint(struct ctl_table *table, int write,
Theodore Ts'o34f5a392007-02-10 01:45:24 -0800170 void __user *buffer, size_t *lenp, loff_t *ppos);
Randy Dunlapd6f8ff72006-10-19 23:28:34 -0700171#endif
Cedric Le Goater9ec52092006-10-02 02:19:00 -0700172
Eric W. Biedermand8217f02007-10-18 03:05:22 -0700173static struct ctl_table root_table[];
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +1100174static struct ctl_table_root sysctl_table_root;
175static struct ctl_table_header root_table_header = {
Al Virob380b0d2008-09-04 17:05:57 +0100176 .count = 1,
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +1100177 .ctl_table = root_table,
Al Viro73455092008-07-14 21:22:20 -0400178 .ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +1100179 .root = &sysctl_table_root,
Al Viro73455092008-07-14 21:22:20 -0400180 .set = &sysctl_table_root.default_set,
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +1100181};
182static struct ctl_table_root sysctl_table_root = {
183 .root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),
Al Viro73455092008-07-14 21:22:20 -0400184 .default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +1100185};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Eric W. Biedermand8217f02007-10-18 03:05:22 -0700187static struct ctl_table kern_table[];
188static struct ctl_table vm_table[];
189static struct ctl_table fs_table[];
190static struct ctl_table debug_table[];
191static struct ctl_table dev_table[];
192extern struct ctl_table random_table[];
Amy Griffis2d9048e2006-06-01 13:10:59 -0700193#ifdef CONFIG_INOTIFY_USER
Eric W. Biedermand8217f02007-10-18 03:05:22 -0700194extern struct ctl_table inotify_table[];
Robert Love0399cb02005-07-13 12:38:18 -0400195#endif
Davide Libenzi7ef99642008-12-01 13:13:55 -0800196#ifdef CONFIG_EPOLL
197extern struct ctl_table epoll_table[];
198#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
201int sysctl_legacy_va_layout;
202#endif
203
Peter Zijlstraf20786f2007-07-19 01:48:56 -0700204extern int prove_locking;
205extern int lock_stat;
Eric W. Biederman9bc9a6b2006-12-08 02:39:56 -0800206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207/* The default sysctl tables: */
208
Eric W. Biedermand8217f02007-10-18 03:05:22 -0700209static struct ctl_table root_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 .procname = "kernel",
212 .mode = 0555,
213 .child = kern_table,
214 },
215 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 .procname = "vm",
217 .mode = 0555,
218 .child = vm_table,
219 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 .procname = "fs",
222 .mode = 0555,
223 .child = fs_table,
224 },
225 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 .procname = "debug",
227 .mode = 0555,
228 .child = debug_table,
229 },
230 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 .procname = "dev",
232 .mode = 0555,
233 .child = dev_table,
234 },
Andrew Morton2be7fe02007-07-15 23:41:21 -0700235/*
236 * NOTE: do not add new entries to this table unless you have read
237 * Documentation/sysctl/ctl_unnumbered.txt
238 */
Eric W. Biederman6fce56e2009-04-03 02:30:53 -0700239 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240};
241
Ingo Molnar77e54a12007-07-09 18:52:00 +0200242#ifdef CONFIG_SCHED_DEBUG
Eric Dumazet73c4efd2007-12-18 15:21:13 +0100243static int min_sched_granularity_ns = 100000; /* 100 usecs */
244static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */
245static int min_wakeup_granularity_ns; /* 0 usecs */
246static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */
Ingo Molnar77e54a12007-07-09 18:52:00 +0200247#endif
248
Eric W. Biedermand8217f02007-10-18 03:05:22 -0700249static struct ctl_table kern_table[] = {
Mike Galbraith2bba22c2009-09-09 15:41:37 +0200250 {
Mike Galbraith2bba22c2009-09-09 15:41:37 +0200251 .procname = "sched_child_runs_first",
252 .data = &sysctl_sched_child_runs_first,
253 .maxlen = sizeof(unsigned int),
254 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800255 .proc_handler = proc_dointvec,
Mike Galbraith2bba22c2009-09-09 15:41:37 +0200256 },
Ingo Molnar77e54a12007-07-09 18:52:00 +0200257#ifdef CONFIG_SCHED_DEBUG
258 {
Peter Zijlstrab2be5e92007-11-09 22:39:37 +0100259 .procname = "sched_min_granularity_ns",
260 .data = &sysctl_sched_min_granularity,
Ingo Molnar77e54a12007-07-09 18:52:00 +0200261 .maxlen = sizeof(unsigned int),
262 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800263 .proc_handler = sched_nr_latency_handler,
Peter Zijlstrab2be5e92007-11-09 22:39:37 +0100264 .extra1 = &min_sched_granularity_ns,
265 .extra2 = &max_sched_granularity_ns,
Ingo Molnar77e54a12007-07-09 18:52:00 +0200266 },
267 {
Peter Zijlstra21805082007-08-25 18:41:53 +0200268 .procname = "sched_latency_ns",
269 .data = &sysctl_sched_latency,
270 .maxlen = sizeof(unsigned int),
271 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800272 .proc_handler = sched_nr_latency_handler,
Peter Zijlstra21805082007-08-25 18:41:53 +0200273 .extra1 = &min_sched_granularity_ns,
274 .extra2 = &max_sched_granularity_ns,
275 },
276 {
Ingo Molnar77e54a12007-07-09 18:52:00 +0200277 .procname = "sched_wakeup_granularity_ns",
278 .data = &sysctl_sched_wakeup_granularity,
279 .maxlen = sizeof(unsigned int),
280 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800281 .proc_handler = proc_dointvec_minmax,
Ingo Molnar77e54a12007-07-09 18:52:00 +0200282 .extra1 = &min_wakeup_granularity_ns,
283 .extra2 = &max_wakeup_granularity_ns,
284 },
285 {
Peter Zijlstra2398f2c2008-06-27 13:41:35 +0200286 .procname = "sched_shares_ratelimit",
287 .data = &sysctl_sched_shares_ratelimit,
288 .maxlen = sizeof(unsigned int),
289 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800290 .proc_handler = proc_dointvec,
Peter Zijlstra2398f2c2008-06-27 13:41:35 +0200291 },
292 {
Peter Zijlstraffda12a2008-10-17 19:27:02 +0200293 .procname = "sched_shares_thresh",
294 .data = &sysctl_sched_shares_thresh,
295 .maxlen = sizeof(unsigned int),
296 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800297 .proc_handler = proc_dointvec_minmax,
Peter Zijlstraffda12a2008-10-17 19:27:02 +0200298 .extra1 = &zero,
299 },
300 {
Peter Zijlstra1fc84aa2007-08-25 18:41:52 +0200301 .procname = "sched_features",
302 .data = &sysctl_sched_features,
303 .maxlen = sizeof(unsigned int),
304 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800305 .proc_handler = proc_dointvec,
Peter Zijlstra1fc84aa2007-08-25 18:41:52 +0200306 },
Ingo Molnarda84d962007-10-15 17:00:18 +0200307 {
Ingo Molnarda84d962007-10-15 17:00:18 +0200308 .procname = "sched_migration_cost",
309 .data = &sysctl_sched_migration_cost,
310 .maxlen = sizeof(unsigned int),
311 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800312 .proc_handler = proc_dointvec,
Ingo Molnarda84d962007-10-15 17:00:18 +0200313 },
Peter Zijlstrab82d9fd2007-11-09 22:39:39 +0100314 {
Peter Zijlstrab82d9fd2007-11-09 22:39:39 +0100315 .procname = "sched_nr_migrate",
316 .data = &sysctl_sched_nr_migrate,
317 .maxlen = sizeof(unsigned int),
Peter Zijlstrafa85ae22008-01-25 21:08:29 +0100318 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800319 .proc_handler = proc_dointvec,
Peter Zijlstrafa85ae22008-01-25 21:08:29 +0100320 },
Arun R Bharadwajcd1bb942009-04-16 12:15:34 +0530321 {
Peter Zijlstrae9e92502009-09-01 10:34:37 +0200322 .procname = "sched_time_avg",
323 .data = &sysctl_sched_time_avg,
324 .maxlen = sizeof(unsigned int),
325 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800326 .proc_handler = proc_dointvec,
Peter Zijlstrae9e92502009-09-01 10:34:37 +0200327 },
328 {
Arun R Bharadwajcd1bb942009-04-16 12:15:34 +0530329 .procname = "timer_migration",
330 .data = &sysctl_timer_migration,
331 .maxlen = sizeof(unsigned int),
332 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800333 .proc_handler = proc_dointvec_minmax,
Arun R Bharadwajbfdb4d92009-06-23 10:00:58 +0530334 .extra1 = &zero,
335 .extra2 = &one,
Arun R Bharadwajcd1bb942009-04-16 12:15:34 +0530336 },
Peter Zijlstra1fc84aa2007-08-25 18:41:52 +0200337#endif
Ingo Molnar1799e352007-09-19 23:34:46 +0200338 {
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +0100339 .procname = "sched_rt_period_us",
340 .data = &sysctl_sched_rt_period,
341 .maxlen = sizeof(unsigned int),
342 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800343 .proc_handler = sched_rt_handler,
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +0100344 },
345 {
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +0100346 .procname = "sched_rt_runtime_us",
347 .data = &sysctl_sched_rt_runtime,
348 .maxlen = sizeof(int),
349 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800350 .proc_handler = sched_rt_handler,
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +0100351 },
352 {
Ingo Molnar1799e352007-09-19 23:34:46 +0200353 .procname = "sched_compat_yield",
354 .data = &sysctl_sched_compat_yield,
355 .maxlen = sizeof(unsigned int),
356 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800357 .proc_handler = proc_dointvec,
Ingo Molnar1799e352007-09-19 23:34:46 +0200358 },
Peter Zijlstraf20786f2007-07-19 01:48:56 -0700359#ifdef CONFIG_PROVE_LOCKING
360 {
Peter Zijlstraf20786f2007-07-19 01:48:56 -0700361 .procname = "prove_locking",
362 .data = &prove_locking,
363 .maxlen = sizeof(int),
364 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800365 .proc_handler = proc_dointvec,
Peter Zijlstraf20786f2007-07-19 01:48:56 -0700366 },
367#endif
368#ifdef CONFIG_LOCK_STAT
369 {
Peter Zijlstraf20786f2007-07-19 01:48:56 -0700370 .procname = "lock_stat",
371 .data = &lock_stat,
372 .maxlen = sizeof(int),
373 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800374 .proc_handler = proc_dointvec,
Peter Zijlstraf20786f2007-07-19 01:48:56 -0700375 },
376#endif
Ingo Molnar77e54a12007-07-09 18:52:00 +0200377 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 .procname = "panic",
379 .data = &panic_timeout,
380 .maxlen = sizeof(int),
381 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800382 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 },
384 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 .procname = "core_uses_pid",
386 .data = &core_uses_pid,
387 .maxlen = sizeof(int),
388 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800389 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 },
391 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 .procname = "core_pattern",
393 .data = core_pattern,
Dan Aloni71ce92f2007-05-16 22:11:16 -0700394 .maxlen = CORENAME_MAX_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800396 .proc_handler = proc_dostring,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 },
Neil Hormana2939802009-09-23 15:56:56 -0700398 {
Neil Hormana2939802009-09-23 15:56:56 -0700399 .procname = "core_pipe_limit",
400 .data = &core_pipe_limit,
401 .maxlen = sizeof(unsigned int),
402 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800403 .proc_handler = proc_dointvec,
Neil Hormana2939802009-09-23 15:56:56 -0700404 },
Theodore Ts'o34f5a392007-02-10 01:45:24 -0800405#ifdef CONFIG_PROC_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 .procname = "tainted",
Andi Kleen25ddbb12008-10-15 22:01:41 -0700408 .maxlen = sizeof(long),
Theodore Ts'o34f5a392007-02-10 01:45:24 -0800409 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800410 .proc_handler = proc_taint,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 },
Theodore Ts'o34f5a392007-02-10 01:45:24 -0800412#endif
Arjan van de Ven97455122008-01-25 21:08:34 +0100413#ifdef CONFIG_LATENCYTOP
414 {
415 .procname = "latencytop",
416 .data = &latencytop_enabled,
417 .maxlen = sizeof(int),
418 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800419 .proc_handler = proc_dointvec,
Arjan van de Ven97455122008-01-25 21:08:34 +0100420 },
421#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422#ifdef CONFIG_BLK_DEV_INITRD
423 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 .procname = "real-root-dev",
425 .data = &real_root_dev,
426 .maxlen = sizeof(int),
427 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800428 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 },
430#endif
Ingo Molnar45807a12007-07-15 23:40:10 -0700431 {
Ingo Molnar45807a12007-07-15 23:40:10 -0700432 .procname = "print-fatal-signals",
433 .data = &print_fatal_signals,
434 .maxlen = sizeof(int),
435 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800436 .proc_handler = proc_dointvec,
Ingo Molnar45807a12007-07-15 23:40:10 -0700437 },
David S. Miller72c57ed2008-09-11 23:29:54 -0700438#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 .procname = "reboot-cmd",
441 .data = reboot_command,
442 .maxlen = 256,
443 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800444 .proc_handler = proc_dostring,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 },
446 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 .procname = "stop-a",
448 .data = &stop_a_enabled,
449 .maxlen = sizeof (int),
450 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800451 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 },
453 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 .procname = "scons-poweroff",
455 .data = &scons_pwroff,
456 .maxlen = sizeof (int),
457 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800458 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 },
460#endif
David S. Miller08714202008-11-16 23:49:24 -0800461#ifdef CONFIG_SPARC64
462 {
David S. Miller08714202008-11-16 23:49:24 -0800463 .procname = "tsb-ratio",
464 .data = &sysctl_tsb_ratio,
465 .maxlen = sizeof (int),
466 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800467 .proc_handler = proc_dointvec,
David S. Miller08714202008-11-16 23:49:24 -0800468 },
469#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470#ifdef __hppa__
471 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 .procname = "soft-power",
473 .data = &pwrsw_enabled,
474 .maxlen = sizeof (int),
475 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800476 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 },
478 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 .procname = "unaligned-trap",
480 .data = &unaligned_enabled,
481 .maxlen = sizeof (int),
482 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800483 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 },
485#endif
486 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 .procname = "ctrl-alt-del",
488 .data = &C_A_D,
489 .maxlen = sizeof(int),
490 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800491 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 },
Steven Rostedt606576c2008-10-06 19:06:12 -0400493#ifdef CONFIG_FUNCTION_TRACER
Steven Rostedtb0fc4942008-05-12 21:20:43 +0200494 {
Steven Rostedtb0fc4942008-05-12 21:20:43 +0200495 .procname = "ftrace_enabled",
496 .data = &ftrace_enabled,
497 .maxlen = sizeof(int),
498 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800499 .proc_handler = ftrace_enable_sysctl,
Steven Rostedtb0fc4942008-05-12 21:20:43 +0200500 },
501#endif
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500502#ifdef CONFIG_STACK_TRACER
503 {
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500504 .procname = "stack_tracer_enabled",
505 .data = &stack_tracer_enabled,
506 .maxlen = sizeof(int),
507 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800508 .proc_handler = stack_trace_sysctl,
Steven Rostedtf38f1d22008-12-16 23:06:40 -0500509 },
510#endif
Steven Rostedt944ac422008-10-23 19:26:08 -0400511#ifdef CONFIG_TRACING
512 {
Peter Zijlstra3299b4d2008-11-04 11:58:21 +0100513 .procname = "ftrace_dump_on_oops",
Steven Rostedt944ac422008-10-23 19:26:08 -0400514 .data = &ftrace_dump_on_oops,
515 .maxlen = sizeof(int),
516 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800517 .proc_handler = proc_dointvec,
Steven Rostedt944ac422008-10-23 19:26:08 -0400518 },
519#endif
Johannes Berga1ef5ad2008-07-08 19:00:17 +0200520#ifdef CONFIG_MODULES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 .procname = "modprobe",
523 .data = &modprobe_path,
524 .maxlen = KMOD_PATH_LEN,
525 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800526 .proc_handler = proc_dostring,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 },
Kees Cook3d433212009-04-02 15:49:29 -0700528 {
Kees Cook3d433212009-04-02 15:49:29 -0700529 .procname = "modules_disabled",
530 .data = &modules_disabled,
531 .maxlen = sizeof(int),
532 .mode = 0644,
533 /* only handle a transition from default "0" to "1" */
Eric W. Biederman6d456112009-11-16 03:11:48 -0800534 .proc_handler = proc_dointvec_minmax,
Kees Cook3d433212009-04-02 15:49:29 -0700535 .extra1 = &one,
536 .extra2 = &one,
537 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538#endif
Andrew Morton57ae2502006-06-23 02:05:47 -0700539#if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 .procname = "hotplug",
Kay Sievers312c0042005-11-16 09:00:00 +0100542 .data = &uevent_helper,
543 .maxlen = UEVENT_HELPER_PATH_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800545 .proc_handler = proc_dostring,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 },
547#endif
548#ifdef CONFIG_CHR_DEV_SG
549 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 .procname = "sg-big-buff",
551 .data = &sg_big_buff,
552 .maxlen = sizeof (int),
553 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800554 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 },
556#endif
557#ifdef CONFIG_BSD_PROCESS_ACCT
558 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 .procname = "acct",
560 .data = &acct_parm,
561 .maxlen = 3*sizeof(int),
562 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800563 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 },
565#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566#ifdef CONFIG_MAGIC_SYSRQ
567 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 .procname = "sysrq",
Ingo Molnar5d6f6472006-12-13 00:34:36 -0800569 .data = &__sysrq_enabled,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 .maxlen = sizeof (int),
571 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800572 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 },
574#endif
Randy Dunlapd6f8ff72006-10-19 23:28:34 -0700575#ifdef CONFIG_PROC_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 .procname = "cad_pid",
Cedric Le Goater9ec52092006-10-02 02:19:00 -0700578 .data = NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 .maxlen = sizeof (int),
580 .mode = 0600,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800581 .proc_handler = proc_do_cad_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 },
Randy Dunlapd6f8ff72006-10-19 23:28:34 -0700583#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 .procname = "threads-max",
586 .data = &max_threads,
587 .maxlen = sizeof(int),
588 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800589 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 },
591 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 .procname = "random",
593 .mode = 0555,
594 .child = random_table,
595 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 .procname = "overflowuid",
598 .data = &overflowuid,
599 .maxlen = sizeof(int),
600 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800601 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 .extra1 = &minolduid,
603 .extra2 = &maxolduid,
604 },
605 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 .procname = "overflowgid",
607 .data = &overflowgid,
608 .maxlen = sizeof(int),
609 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800610 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 .extra1 = &minolduid,
612 .extra2 = &maxolduid,
613 },
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800614#ifdef CONFIG_S390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615#ifdef CONFIG_MATHEMU
616 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 .procname = "ieee_emulation_warnings",
618 .data = &sysctl_ieee_emulation_warnings,
619 .maxlen = sizeof(int),
620 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800621 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 },
623#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 .procname = "userprocess_debug",
626 .data = &sysctl_userprocess_debug,
627 .maxlen = sizeof(int),
628 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800629 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 },
631#endif
632 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 .procname = "pid_max",
634 .data = &pid_max,
635 .maxlen = sizeof (int),
636 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800637 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 .extra1 = &pid_max_min,
639 .extra2 = &pid_max_max,
640 },
641 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 .procname = "panic_on_oops",
643 .data = &panic_on_oops,
644 .maxlen = sizeof(int),
645 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800646 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 },
Joe Perches7ef3d2f2008-02-08 04:21:25 -0800648#if defined CONFIG_PRINTK
649 {
Joe Perches7ef3d2f2008-02-08 04:21:25 -0800650 .procname = "printk",
651 .data = &console_loglevel,
652 .maxlen = 4*sizeof(int),
653 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800654 .proc_handler = proc_dointvec,
Joe Perches7ef3d2f2008-02-08 04:21:25 -0800655 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 .procname = "printk_ratelimit",
Dave Young717115e2008-07-25 01:45:58 -0700658 .data = &printk_ratelimit_state.interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 .maxlen = sizeof(int),
660 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800661 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 },
663 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 .procname = "printk_ratelimit_burst",
Dave Young717115e2008-07-25 01:45:58 -0700665 .data = &printk_ratelimit_state.burst,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 .maxlen = sizeof(int),
667 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800668 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 },
Dave Youngaf913222009-09-22 16:43:33 -0700670 {
Dave Youngaf913222009-09-22 16:43:33 -0700671 .procname = "printk_delay",
672 .data = &printk_delay_msec,
673 .maxlen = sizeof(int),
674 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800675 .proc_handler = proc_dointvec_minmax,
Dave Youngaf913222009-09-22 16:43:33 -0700676 .extra1 = &zero,
677 .extra2 = &ten_thousand,
678 },
Joe Perches7ef3d2f2008-02-08 04:21:25 -0800679#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 .procname = "ngroups_max",
682 .data = &ngroups_max,
683 .maxlen = sizeof (int),
684 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800685 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 },
687#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
688 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 .procname = "unknown_nmi_panic",
690 .data = &unknown_nmi_panic,
691 .maxlen = sizeof (int),
692 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800693 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 },
Don Zickus407984f2006-09-26 10:52:27 +0200695 {
Don Zickus407984f2006-09-26 10:52:27 +0200696 .procname = "nmi_watchdog",
697 .data = &nmi_watchdog_enabled,
698 .maxlen = sizeof (int),
699 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800700 .proc_handler = proc_nmi_enabled,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 },
702#endif
703#if defined(CONFIG_X86)
704 {
Don Zickus8da5add2006-09-26 10:52:27 +0200705 .procname = "panic_on_unrecovered_nmi",
706 .data = &panic_on_unrecovered_nmi,
707 .maxlen = sizeof(int),
708 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800709 .proc_handler = proc_dointvec,
Don Zickus8da5add2006-09-26 10:52:27 +0200710 },
711 {
Kurt Garloff5211a242009-06-24 14:32:11 -0700712 .procname = "panic_on_io_nmi",
713 .data = &panic_on_io_nmi,
714 .maxlen = sizeof(int),
715 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800716 .proc_handler = proc_dointvec,
Kurt Garloff5211a242009-06-24 14:32:11 -0700717 },
718 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 .procname = "bootloader_type",
720 .data = &bootloader_type,
721 .maxlen = sizeof (int),
722 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800723 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 },
Chuck Ebbert0741f4d2006-12-07 02:14:11 +0100725 {
H. Peter Anvin50312962009-05-07 16:54:11 -0700726 .procname = "bootloader_version",
727 .data = &bootloader_version,
728 .maxlen = sizeof (int),
729 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800730 .proc_handler = proc_dointvec,
H. Peter Anvin50312962009-05-07 16:54:11 -0700731 },
732 {
Chuck Ebbert0741f4d2006-12-07 02:14:11 +0100733 .procname = "kstack_depth_to_print",
734 .data = &kstack_depth_to_print,
735 .maxlen = sizeof(int),
736 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800737 .proc_handler = proc_dointvec,
Chuck Ebbert0741f4d2006-12-07 02:14:11 +0100738 },
Ingo Molnar6e7c4022008-01-30 13:30:05 +0100739 {
Ingo Molnar6e7c4022008-01-30 13:30:05 +0100740 .procname = "io_delay_type",
741 .data = &io_delay_type,
742 .maxlen = sizeof(int),
743 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800744 .proc_handler = proc_dointvec,
Ingo Molnar6e7c4022008-01-30 13:30:05 +0100745 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746#endif
Luke Yang7a9166e2006-02-20 18:28:07 -0800747#if defined(CONFIG_MMU)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 .procname = "randomize_va_space",
750 .data = &randomize_va_space,
751 .maxlen = sizeof(int),
752 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800753 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 },
Luke Yang7a9166e2006-02-20 18:28:07 -0800755#endif
Martin Schwidefsky0152fb32006-01-14 13:21:00 -0800756#if defined(CONFIG_S390) && defined(CONFIG_SMP)
Martin Schwidefsky951f22d2005-07-27 11:44:57 -0700757 {
Martin Schwidefsky951f22d2005-07-27 11:44:57 -0700758 .procname = "spin_retry",
759 .data = &spin_retry,
760 .maxlen = sizeof (int),
761 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800762 .proc_handler = proc_dointvec,
Martin Schwidefsky951f22d2005-07-27 11:44:57 -0700763 },
764#endif
Len Brown673d5b42007-07-28 03:33:16 -0400765#if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
Pavel Machekc255d842006-02-20 18:27:58 -0800766 {
Pavel Machekc255d842006-02-20 18:27:58 -0800767 .procname = "acpi_video_flags",
Pavel Machek77afcf72007-07-19 01:47:41 -0700768 .data = &acpi_realmode_flags,
Pavel Machekc255d842006-02-20 18:27:58 -0800769 .maxlen = sizeof (unsigned long),
770 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800771 .proc_handler = proc_doulongvec_minmax,
Pavel Machekc255d842006-02-20 18:27:58 -0800772 },
773#endif
Jes Sorensend2b176e2006-02-28 09:42:23 -0800774#ifdef CONFIG_IA64
775 {
Jes Sorensend2b176e2006-02-28 09:42:23 -0800776 .procname = "ignore-unaligned-usertrap",
777 .data = &no_unaligned_warning,
778 .maxlen = sizeof (int),
779 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800780 .proc_handler = proc_dointvec,
Jes Sorensend2b176e2006-02-28 09:42:23 -0800781 },
Doug Chapman88fc2412009-01-15 10:38:56 -0800782 {
Doug Chapman88fc2412009-01-15 10:38:56 -0800783 .procname = "unaligned-dump-stack",
784 .data = &unaligned_dump_stack,
785 .maxlen = sizeof (int),
786 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800787 .proc_handler = proc_dointvec,
Doug Chapman88fc2412009-01-15 10:38:56 -0800788 },
Jes Sorensend2b176e2006-02-28 09:42:23 -0800789#endif
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700790#ifdef CONFIG_DETECT_SOFTLOCKUP
791 {
Ingo Molnar9c44bc02008-05-12 21:21:04 +0200792 .procname = "softlockup_panic",
793 .data = &softlockup_panic,
794 .maxlen = sizeof(int),
795 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800796 .proc_handler = proc_dointvec_minmax,
Ingo Molnar9c44bc02008-05-12 21:21:04 +0200797 .extra1 = &zero,
798 .extra2 = &one,
799 },
800 {
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700801 .procname = "softlockup_thresh",
802 .data = &softlockup_thresh,
Dimitri Sivanich9383d962008-05-12 21:21:14 +0200803 .maxlen = sizeof(int),
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700804 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800805 .proc_handler = proc_dosoftlockup_thresh,
Dimitri Sivanich9383d962008-05-12 21:21:14 +0200806 .extra1 = &neg_one,
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700807 .extra2 = &sixty,
808 },
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800809#endif
810#ifdef CONFIG_DETECT_HUNG_TASK
811 {
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800812 .procname = "hung_task_panic",
813 .data = &sysctl_hung_task_panic,
814 .maxlen = sizeof(int),
815 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800816 .proc_handler = proc_dointvec_minmax,
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800817 .extra1 = &zero,
818 .extra2 = &one,
819 },
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100820 {
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100821 .procname = "hung_task_check_count",
822 .data = &sysctl_hung_task_check_count,
Ingo Molnar90739082008-01-25 21:08:34 +0100823 .maxlen = sizeof(unsigned long),
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100824 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800825 .proc_handler = proc_doulongvec_minmax,
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100826 },
827 {
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100828 .procname = "hung_task_timeout_secs",
829 .data = &sysctl_hung_task_timeout_secs,
Ingo Molnar90739082008-01-25 21:08:34 +0100830 .maxlen = sizeof(unsigned long),
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100831 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800832 .proc_handler = proc_dohung_task_timeout_secs,
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100833 },
834 {
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100835 .procname = "hung_task_warnings",
836 .data = &sysctl_hung_task_warnings,
Ingo Molnar90739082008-01-25 21:08:34 +0100837 .maxlen = sizeof(unsigned long),
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100838 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800839 .proc_handler = proc_doulongvec_minmax,
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100840 },
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700841#endif
Andi Kleenbebfa102006-06-26 13:56:52 +0200842#ifdef CONFIG_COMPAT
843 {
Andi Kleenbebfa102006-06-26 13:56:52 +0200844 .procname = "compat-log",
845 .data = &compat_log,
846 .maxlen = sizeof (int),
847 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800848 .proc_handler = proc_dointvec,
Andi Kleenbebfa102006-06-26 13:56:52 +0200849 },
850#endif
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700851#ifdef CONFIG_RT_MUTEXES
852 {
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700853 .procname = "max_lock_depth",
854 .data = &max_lock_depth,
855 .maxlen = sizeof(int),
856 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800857 .proc_handler = proc_dointvec,
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700858 },
859#endif
Jeremy Fitzhardinge10a0a8d2007-07-17 18:37:02 -0700860 {
Jeremy Fitzhardinge10a0a8d2007-07-17 18:37:02 -0700861 .procname = "poweroff_cmd",
862 .data = &poweroff_cmd,
863 .maxlen = POWEROFF_CMD_PATH_LEN,
864 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800865 .proc_handler = proc_dostring,
Jeremy Fitzhardinge10a0a8d2007-07-17 18:37:02 -0700866 },
David Howells0b77f5b2008-04-29 01:01:32 -0700867#ifdef CONFIG_KEYS
868 {
David Howells0b77f5b2008-04-29 01:01:32 -0700869 .procname = "keys",
870 .mode = 0555,
871 .child = key_sysctls,
872 },
873#endif
Paul E. McKenney31a72bc2008-06-18 09:26:49 -0700874#ifdef CONFIG_RCU_TORTURE_TEST
875 {
Paul E. McKenney31a72bc2008-06-18 09:26:49 -0700876 .procname = "rcutorture_runnable",
877 .data = &rcutorture_runnable,
878 .maxlen = sizeof(int),
879 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800880 .proc_handler = proc_dointvec,
Paul E. McKenney31a72bc2008-06-18 09:26:49 -0700881 },
882#endif
David Howells12e22c52009-04-03 16:42:35 +0100883#ifdef CONFIG_SLOW_WORK
884 {
David Howells12e22c52009-04-03 16:42:35 +0100885 .procname = "slow-work",
886 .mode = 0555,
887 .child = slow_work_sysctls,
888 },
889#endif
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200890#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra1ccd1542009-04-09 10:53:45 +0200891 {
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200892 .procname = "perf_event_paranoid",
893 .data = &sysctl_perf_event_paranoid,
894 .maxlen = sizeof(sysctl_perf_event_paranoid),
Peter Zijlstra1ccd1542009-04-09 10:53:45 +0200895 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800896 .proc_handler = proc_dointvec,
Peter Zijlstra1ccd1542009-04-09 10:53:45 +0200897 },
Peter Zijlstrac5078f72009-05-05 17:50:24 +0200898 {
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200899 .procname = "perf_event_mlock_kb",
900 .data = &sysctl_perf_event_mlock,
901 .maxlen = sizeof(sysctl_perf_event_mlock),
Peter Zijlstrac5078f72009-05-05 17:50:24 +0200902 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800903 .proc_handler = proc_dointvec,
Peter Zijlstrac5078f72009-05-05 17:50:24 +0200904 },
Peter Zijlstraa78ac322009-05-25 17:39:05 +0200905 {
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200906 .procname = "perf_event_max_sample_rate",
907 .data = &sysctl_perf_event_sample_rate,
908 .maxlen = sizeof(sysctl_perf_event_sample_rate),
Peter Zijlstraa78ac322009-05-25 17:39:05 +0200909 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800910 .proc_handler = proc_dointvec,
Peter Zijlstraa78ac322009-05-25 17:39:05 +0200911 },
Peter Zijlstra1ccd1542009-04-09 10:53:45 +0200912#endif
Vegard Nossumdfec0722008-04-04 00:51:41 +0200913#ifdef CONFIG_KMEMCHECK
914 {
Vegard Nossumdfec0722008-04-04 00:51:41 +0200915 .procname = "kmemcheck",
916 .data = &kmemcheck_enabled,
917 .maxlen = sizeof(int),
918 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800919 .proc_handler = proc_dointvec,
Vegard Nossumdfec0722008-04-04 00:51:41 +0200920 },
921#endif
Jens Axboecb684b52009-09-15 21:53:11 +0200922#ifdef CONFIG_BLOCK
Jens Axboe5e605b62009-08-05 09:07:21 +0200923 {
Jens Axboe5e605b62009-08-05 09:07:21 +0200924 .procname = "blk_iopoll",
925 .data = &blk_iopoll_enabled,
926 .maxlen = sizeof(int),
927 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800928 .proc_handler = proc_dointvec,
Jens Axboe5e605b62009-08-05 09:07:21 +0200929 },
Jens Axboecb684b52009-09-15 21:53:11 +0200930#endif
Andrew Mortoned2c12f2007-07-19 01:50:35 -0700931/*
932 * NOTE: do not add new entries to this table unless you have read
933 * Documentation/sysctl/ctl_unnumbered.txt
934 */
Eric W. Biederman6fce56e2009-04-03 02:30:53 -0700935 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936};
937
Eric W. Biedermand8217f02007-10-18 03:05:22 -0700938static struct ctl_table vm_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 .procname = "overcommit_memory",
941 .data = &sysctl_overcommit_memory,
942 .maxlen = sizeof(sysctl_overcommit_memory),
943 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800944 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 },
946 {
KAMEZAWA Hiroyukifadd8fb2006-06-23 02:03:13 -0700947 .procname = "panic_on_oom",
948 .data = &sysctl_panic_on_oom,
949 .maxlen = sizeof(sysctl_panic_on_oom),
950 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800951 .proc_handler = proc_dointvec,
KAMEZAWA Hiroyukifadd8fb2006-06-23 02:03:13 -0700952 },
953 {
David Rientjesfe071d72007-10-16 23:25:56 -0700954 .procname = "oom_kill_allocating_task",
955 .data = &sysctl_oom_kill_allocating_task,
956 .maxlen = sizeof(sysctl_oom_kill_allocating_task),
957 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800958 .proc_handler = proc_dointvec,
David Rientjesfe071d72007-10-16 23:25:56 -0700959 },
960 {
David Rientjesfef1bdd2008-02-07 00:14:07 -0800961 .procname = "oom_dump_tasks",
962 .data = &sysctl_oom_dump_tasks,
963 .maxlen = sizeof(sysctl_oom_dump_tasks),
964 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800965 .proc_handler = proc_dointvec,
David Rientjesfef1bdd2008-02-07 00:14:07 -0800966 },
967 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 .procname = "overcommit_ratio",
969 .data = &sysctl_overcommit_ratio,
970 .maxlen = sizeof(sysctl_overcommit_ratio),
971 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800972 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 },
974 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 .procname = "page-cluster",
976 .data = &page_cluster,
977 .maxlen = sizeof(int),
978 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800979 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 },
981 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 .procname = "dirty_background_ratio",
983 .data = &dirty_background_ratio,
984 .maxlen = sizeof(dirty_background_ratio),
985 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800986 .proc_handler = dirty_background_ratio_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 .extra1 = &zero,
988 .extra2 = &one_hundred,
989 },
990 {
David Rientjes2da02992009-01-06 14:39:31 -0800991 .procname = "dirty_background_bytes",
992 .data = &dirty_background_bytes,
993 .maxlen = sizeof(dirty_background_bytes),
994 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800995 .proc_handler = dirty_background_bytes_handler,
Sven Wegenerfc3501d2009-02-11 13:04:23 -0800996 .extra1 = &one_ul,
David Rientjes2da02992009-01-06 14:39:31 -0800997 },
998 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 .procname = "dirty_ratio",
1000 .data = &vm_dirty_ratio,
1001 .maxlen = sizeof(vm_dirty_ratio),
1002 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001003 .proc_handler = dirty_ratio_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 .extra1 = &zero,
1005 .extra2 = &one_hundred,
1006 },
1007 {
David Rientjes2da02992009-01-06 14:39:31 -08001008 .procname = "dirty_bytes",
1009 .data = &vm_dirty_bytes,
1010 .maxlen = sizeof(vm_dirty_bytes),
1011 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001012 .proc_handler = dirty_bytes_handler,
Andrea Righi9e4a5bd2009-04-30 15:08:57 -07001013 .extra1 = &dirty_bytes_min,
David Rientjes2da02992009-01-06 14:39:31 -08001014 },
1015 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 .procname = "dirty_writeback_centisecs",
Bart Samwelf6ef9432006-03-24 03:15:48 -08001017 .data = &dirty_writeback_interval,
1018 .maxlen = sizeof(dirty_writeback_interval),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001020 .proc_handler = dirty_writeback_centisecs_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 },
1022 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 .procname = "dirty_expire_centisecs",
Bart Samwelf6ef9432006-03-24 03:15:48 -08001024 .data = &dirty_expire_interval,
1025 .maxlen = sizeof(dirty_expire_interval),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001027 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 },
1029 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 .procname = "nr_pdflush_threads",
1031 .data = &nr_pdflush_threads,
1032 .maxlen = sizeof nr_pdflush_threads,
1033 .mode = 0444 /* read-only*/,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001034 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 },
1036 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 .procname = "swappiness",
1038 .data = &vm_swappiness,
1039 .maxlen = sizeof(vm_swappiness),
1040 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001041 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 .extra1 = &zero,
1043 .extra2 = &one_hundred,
1044 },
1045#ifdef CONFIG_HUGETLB_PAGE
1046 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 .procname = "nr_hugepages",
Andi Kleene5ff2152008-07-23 21:27:42 -07001048 .data = NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 .maxlen = sizeof(unsigned long),
1050 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001051 .proc_handler = hugetlb_sysctl_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 .extra1 = (void *)&hugetlb_zero,
1053 .extra2 = (void *)&hugetlb_infinity,
1054 },
1055 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 .procname = "hugetlb_shm_group",
1057 .data = &sysctl_hugetlb_shm_group,
1058 .maxlen = sizeof(gid_t),
1059 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001060 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 },
Mel Gorman396faf02007-07-17 04:03:13 -07001062 {
Mel Gorman396faf02007-07-17 04:03:13 -07001063 .procname = "hugepages_treat_as_movable",
1064 .data = &hugepages_treat_as_movable,
1065 .maxlen = sizeof(int),
1066 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001067 .proc_handler = hugetlb_treat_movable_handler,
Mel Gorman396faf02007-07-17 04:03:13 -07001068 },
Adam Litke54f9f802007-10-16 01:26:20 -07001069 {
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001070 .procname = "nr_overcommit_hugepages",
Andi Kleene5ff2152008-07-23 21:27:42 -07001071 .data = NULL,
1072 .maxlen = sizeof(unsigned long),
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001073 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001074 .proc_handler = hugetlb_overcommit_handler,
Andi Kleene5ff2152008-07-23 21:27:42 -07001075 .extra1 = (void *)&hugetlb_zero,
1076 .extra2 = (void *)&hugetlb_infinity,
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001077 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078#endif
1079 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 .procname = "lowmem_reserve_ratio",
1081 .data = &sysctl_lowmem_reserve_ratio,
1082 .maxlen = sizeof(sysctl_lowmem_reserve_ratio),
1083 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001084 .proc_handler = lowmem_reserve_ratio_sysctl_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 },
1086 {
Andrew Morton9d0243b2006-01-08 01:00:39 -08001087 .procname = "drop_caches",
1088 .data = &sysctl_drop_caches,
1089 .maxlen = sizeof(int),
1090 .mode = 0644,
1091 .proc_handler = drop_caches_sysctl_handler,
Andrew Morton9d0243b2006-01-08 01:00:39 -08001092 },
1093 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 .procname = "min_free_kbytes",
1095 .data = &min_free_kbytes,
1096 .maxlen = sizeof(min_free_kbytes),
1097 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001098 .proc_handler = min_free_kbytes_sysctl_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 .extra1 = &zero,
1100 },
Rohit Seth8ad4b1f2006-01-08 01:00:40 -08001101 {
Rohit Seth8ad4b1f2006-01-08 01:00:40 -08001102 .procname = "percpu_pagelist_fraction",
1103 .data = &percpu_pagelist_fraction,
1104 .maxlen = sizeof(percpu_pagelist_fraction),
1105 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001106 .proc_handler = percpu_pagelist_fraction_sysctl_handler,
Rohit Seth8ad4b1f2006-01-08 01:00:40 -08001107 .extra1 = &min_percpu_pagelist_fract,
1108 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109#ifdef CONFIG_MMU
1110 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 .procname = "max_map_count",
1112 .data = &sysctl_max_map_count,
1113 .maxlen = sizeof(sysctl_max_map_count),
1114 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001115 .proc_handler = proc_dointvec
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 },
Paul Mundtdd8632a2009-01-08 12:04:47 +00001117#else
1118 {
Paul Mundtdd8632a2009-01-08 12:04:47 +00001119 .procname = "nr_trim_pages",
1120 .data = &sysctl_nr_trim_pages,
1121 .maxlen = sizeof(sysctl_nr_trim_pages),
1122 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001123 .proc_handler = proc_dointvec_minmax,
Paul Mundtdd8632a2009-01-08 12:04:47 +00001124 .extra1 = &zero,
1125 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126#endif
1127 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 .procname = "laptop_mode",
1129 .data = &laptop_mode,
1130 .maxlen = sizeof(laptop_mode),
1131 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001132 .proc_handler = proc_dointvec_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 },
1134 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 .procname = "block_dump",
1136 .data = &block_dump,
1137 .maxlen = sizeof(block_dump),
1138 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001139 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 .extra1 = &zero,
1141 },
1142 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 .procname = "vfs_cache_pressure",
1144 .data = &sysctl_vfs_cache_pressure,
1145 .maxlen = sizeof(sysctl_vfs_cache_pressure),
1146 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001147 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 .extra1 = &zero,
1149 },
1150#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1151 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 .procname = "legacy_va_layout",
1153 .data = &sysctl_legacy_va_layout,
1154 .maxlen = sizeof(sysctl_legacy_va_layout),
1155 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001156 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 .extra1 = &zero,
1158 },
1159#endif
Christoph Lameter17436602006-01-18 17:42:32 -08001160#ifdef CONFIG_NUMA
1161 {
Christoph Lameter17436602006-01-18 17:42:32 -08001162 .procname = "zone_reclaim_mode",
1163 .data = &zone_reclaim_mode,
1164 .maxlen = sizeof(zone_reclaim_mode),
1165 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001166 .proc_handler = proc_dointvec,
Christoph Lameterc84db232006-02-01 03:05:29 -08001167 .extra1 = &zero,
Christoph Lameter17436602006-01-18 17:42:32 -08001168 },
Christoph Lameter96146342006-07-03 00:24:13 -07001169 {
Christoph Lameter96146342006-07-03 00:24:13 -07001170 .procname = "min_unmapped_ratio",
1171 .data = &sysctl_min_unmapped_ratio,
1172 .maxlen = sizeof(sysctl_min_unmapped_ratio),
1173 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001174 .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler,
Christoph Lameter96146342006-07-03 00:24:13 -07001175 .extra1 = &zero,
1176 .extra2 = &one_hundred,
1177 },
Christoph Lameter0ff38492006-09-25 23:31:52 -07001178 {
Christoph Lameter0ff38492006-09-25 23:31:52 -07001179 .procname = "min_slab_ratio",
1180 .data = &sysctl_min_slab_ratio,
1181 .maxlen = sizeof(sysctl_min_slab_ratio),
1182 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001183 .proc_handler = sysctl_min_slab_ratio_sysctl_handler,
Christoph Lameter0ff38492006-09-25 23:31:52 -07001184 .extra1 = &zero,
1185 .extra2 = &one_hundred,
1186 },
Christoph Lameter17436602006-01-18 17:42:32 -08001187#endif
Christoph Lameter77461ab2007-05-09 02:35:13 -07001188#ifdef CONFIG_SMP
1189 {
Christoph Lameter77461ab2007-05-09 02:35:13 -07001190 .procname = "stat_interval",
1191 .data = &sysctl_stat_interval,
1192 .maxlen = sizeof(sysctl_stat_interval),
1193 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001194 .proc_handler = proc_dointvec_jiffies,
Christoph Lameter77461ab2007-05-09 02:35:13 -07001195 },
1196#endif
Eric Parised032182007-06-28 15:55:21 -04001197 {
Eric Parised032182007-06-28 15:55:21 -04001198 .procname = "mmap_min_addr",
Eric Paris788084a2009-07-31 12:54:11 -04001199 .data = &dac_mmap_min_addr,
1200 .maxlen = sizeof(unsigned long),
Eric Parised032182007-06-28 15:55:21 -04001201 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001202 .proc_handler = mmap_min_addr_handler,
Eric Parised032182007-06-28 15:55:21 -04001203 },
KAMEZAWA Hiroyukif0c0b2b2007-07-15 23:38:01 -07001204#ifdef CONFIG_NUMA
1205 {
KAMEZAWA Hiroyukif0c0b2b2007-07-15 23:38:01 -07001206 .procname = "numa_zonelist_order",
1207 .data = &numa_zonelist_order,
1208 .maxlen = NUMA_ZONELIST_ORDER_LEN,
1209 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001210 .proc_handler = numa_zonelist_order_handler,
KAMEZAWA Hiroyukif0c0b2b2007-07-15 23:38:01 -07001211 },
1212#endif
Al Viro2b8232c2007-10-13 08:16:04 +01001213#if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
Paul Mundt5c36e652007-03-01 10:07:42 +09001214 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
Ingo Molnare6e54942006-06-27 02:53:50 -07001215 {
Ingo Molnare6e54942006-06-27 02:53:50 -07001216 .procname = "vdso_enabled",
1217 .data = &vdso_enabled,
1218 .maxlen = sizeof(vdso_enabled),
1219 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001220 .proc_handler = proc_dointvec,
Ingo Molnare6e54942006-06-27 02:53:50 -07001221 .extra1 = &zero,
1222 },
1223#endif
Bron Gondwana195cf4532008-02-04 22:29:20 -08001224#ifdef CONFIG_HIGHMEM
1225 {
Bron Gondwana195cf4532008-02-04 22:29:20 -08001226 .procname = "highmem_is_dirtyable",
1227 .data = &vm_highmem_is_dirtyable,
1228 .maxlen = sizeof(vm_highmem_is_dirtyable),
1229 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001230 .proc_handler = proc_dointvec_minmax,
Bron Gondwana195cf4532008-02-04 22:29:20 -08001231 .extra1 = &zero,
1232 .extra2 = &one,
1233 },
1234#endif
Peter Zijlstra4be6f6b2009-04-13 14:39:33 -07001235 {
Peter Zijlstra4be6f6b2009-04-13 14:39:33 -07001236 .procname = "scan_unevictable_pages",
1237 .data = &scan_unevictable_pages,
1238 .maxlen = sizeof(scan_unevictable_pages),
1239 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001240 .proc_handler = scan_unevictable_handler,
Peter Zijlstra4be6f6b2009-04-13 14:39:33 -07001241 },
Andi Kleen6a460792009-09-16 11:50:15 +02001242#ifdef CONFIG_MEMORY_FAILURE
1243 {
Andi Kleen6a460792009-09-16 11:50:15 +02001244 .procname = "memory_failure_early_kill",
1245 .data = &sysctl_memory_failure_early_kill,
1246 .maxlen = sizeof(sysctl_memory_failure_early_kill),
1247 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001248 .proc_handler = proc_dointvec_minmax,
Andi Kleen6a460792009-09-16 11:50:15 +02001249 .extra1 = &zero,
1250 .extra2 = &one,
1251 },
1252 {
Andi Kleen6a460792009-09-16 11:50:15 +02001253 .procname = "memory_failure_recovery",
1254 .data = &sysctl_memory_failure_recovery,
1255 .maxlen = sizeof(sysctl_memory_failure_recovery),
1256 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001257 .proc_handler = proc_dointvec_minmax,
Andi Kleen6a460792009-09-16 11:50:15 +02001258 .extra1 = &zero,
1259 .extra2 = &one,
1260 },
1261#endif
1262
Andrew Morton2be7fe02007-07-15 23:41:21 -07001263/*
1264 * NOTE: do not add new entries to this table unless you have read
1265 * Documentation/sysctl/ctl_unnumbered.txt
1266 */
Eric W. Biederman6fce56e2009-04-03 02:30:53 -07001267 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268};
1269
Eric W. Biederman2abc26f2007-02-14 00:34:07 -08001270#if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
Eric W. Biedermand8217f02007-10-18 03:05:22 -07001271static struct ctl_table binfmt_misc_table[] = {
Eric W. Biederman6fce56e2009-04-03 02:30:53 -07001272 { }
Eric W. Biederman2abc26f2007-02-14 00:34:07 -08001273};
1274#endif
1275
Eric W. Biedermand8217f02007-10-18 03:05:22 -07001276static struct ctl_table fs_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 .procname = "inode-nr",
1279 .data = &inodes_stat,
1280 .maxlen = 2*sizeof(int),
1281 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001282 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 },
1284 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 .procname = "inode-state",
1286 .data = &inodes_stat,
1287 .maxlen = 7*sizeof(int),
1288 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001289 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 },
1291 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 .procname = "file-nr",
1293 .data = &files_stat,
1294 .maxlen = 3*sizeof(int),
1295 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001296 .proc_handler = proc_nr_files,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 },
1298 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 .procname = "file-max",
1300 .data = &files_stat.max_files,
1301 .maxlen = sizeof(int),
1302 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001303 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 },
1305 {
Eric Dumazet9cfe0152008-02-06 01:37:16 -08001306 .procname = "nr_open",
1307 .data = &sysctl_nr_open,
1308 .maxlen = sizeof(int),
1309 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001310 .proc_handler = proc_dointvec_minmax,
Al Viroeceea0b2008-05-10 10:08:32 -04001311 .extra1 = &sysctl_nr_open_min,
1312 .extra2 = &sysctl_nr_open_max,
Eric Dumazet9cfe0152008-02-06 01:37:16 -08001313 },
1314 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 .procname = "dentry-state",
1316 .data = &dentry_stat,
1317 .maxlen = 6*sizeof(int),
1318 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001319 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 },
1321 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 .procname = "overflowuid",
1323 .data = &fs_overflowuid,
1324 .maxlen = sizeof(int),
1325 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001326 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 .extra1 = &minolduid,
1328 .extra2 = &maxolduid,
1329 },
1330 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 .procname = "overflowgid",
1332 .data = &fs_overflowgid,
1333 .maxlen = sizeof(int),
1334 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001335 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 .extra1 = &minolduid,
1337 .extra2 = &maxolduid,
1338 },
Thomas Petazzonibfcd17a2008-08-06 15:12:22 +02001339#ifdef CONFIG_FILE_LOCKING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 .procname = "leases-enable",
1342 .data = &leases_enable,
1343 .maxlen = sizeof(int),
1344 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001345 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 },
Thomas Petazzonibfcd17a2008-08-06 15:12:22 +02001347#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348#ifdef CONFIG_DNOTIFY
1349 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 .procname = "dir-notify-enable",
1351 .data = &dir_notify_enable,
1352 .maxlen = sizeof(int),
1353 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001354 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 },
1356#endif
1357#ifdef CONFIG_MMU
Thomas Petazzonibfcd17a2008-08-06 15:12:22 +02001358#ifdef CONFIG_FILE_LOCKING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 .procname = "lease-break-time",
1361 .data = &lease_break_time,
1362 .maxlen = sizeof(int),
1363 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001364 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 },
Thomas Petazzonibfcd17a2008-08-06 15:12:22 +02001366#endif
Thomas Petazzoniebf3f092008-10-15 22:05:12 -07001367#ifdef CONFIG_AIO
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 .procname = "aio-nr",
1370 .data = &aio_nr,
1371 .maxlen = sizeof(aio_nr),
1372 .mode = 0444,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001373 .proc_handler = proc_doulongvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 },
1375 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 .procname = "aio-max-nr",
1377 .data = &aio_max_nr,
1378 .maxlen = sizeof(aio_max_nr),
1379 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001380 .proc_handler = proc_doulongvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 },
Thomas Petazzoniebf3f092008-10-15 22:05:12 -07001382#endif /* CONFIG_AIO */
Amy Griffis2d9048e2006-06-01 13:10:59 -07001383#ifdef CONFIG_INOTIFY_USER
Robert Love0399cb02005-07-13 12:38:18 -04001384 {
Robert Love0399cb02005-07-13 12:38:18 -04001385 .procname = "inotify",
1386 .mode = 0555,
1387 .child = inotify_table,
1388 },
1389#endif
Davide Libenzi7ef99642008-12-01 13:13:55 -08001390#ifdef CONFIG_EPOLL
1391 {
1392 .procname = "epoll",
1393 .mode = 0555,
1394 .child = epoll_table,
1395 },
1396#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397#endif
Alan Coxd6e71142005-06-23 00:09:43 -07001398 {
Alan Coxd6e71142005-06-23 00:09:43 -07001399 .procname = "suid_dumpable",
1400 .data = &suid_dumpable,
1401 .maxlen = sizeof(int),
1402 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08001403 .proc_handler = proc_dointvec_minmax,
Matthew Wilcox8e654fb2009-04-02 16:58:33 -07001404 .extra1 = &zero,
1405 .extra2 = &two,
Alan Coxd6e71142005-06-23 00:09:43 -07001406 },
Eric W. Biederman2abc26f2007-02-14 00:34:07 -08001407#if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1408 {
Eric W. Biederman2abc26f2007-02-14 00:34:07 -08001409 .procname = "binfmt_misc",
1410 .mode = 0555,
1411 .child = binfmt_misc_table,
1412 },
1413#endif
Andrew Morton2be7fe02007-07-15 23:41:21 -07001414/*
1415 * NOTE: do not add new entries to this table unless you have read
1416 * Documentation/sysctl/ctl_unnumbered.txt
1417 */
Eric W. Biederman6fce56e2009-04-03 02:30:53 -07001418 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419};
1420
Eric W. Biedermand8217f02007-10-18 03:05:22 -07001421static struct ctl_table debug_table[] = {
Olof Johanssond0c3d532007-10-12 10:20:07 +10001422#if defined(CONFIG_X86) || defined(CONFIG_PPC)
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +02001423 {
Masoud Asgharifard Sharbianiabd4f752007-07-22 11:12:28 +02001424 .procname = "exception-trace",
1425 .data = &show_unhandled_signals,
1426 .maxlen = sizeof(int),
1427 .mode = 0644,
1428 .proc_handler = proc_dointvec
1429 },
1430#endif
Eric W. Biederman6fce56e2009-04-03 02:30:53 -07001431 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432};
1433
Eric W. Biedermand8217f02007-10-18 03:05:22 -07001434static struct ctl_table dev_table[] = {
Eric W. Biederman6fce56e2009-04-03 02:30:53 -07001435 { }
Robert Love0eeca282005-07-12 17:06:03 -04001436};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
Al Viro330d57f2005-11-04 10:18:40 +00001438static DEFINE_SPINLOCK(sysctl_lock);
1439
1440/* called under sysctl_lock */
1441static int use_table(struct ctl_table_header *p)
1442{
1443 if (unlikely(p->unregistering))
1444 return 0;
1445 p->used++;
1446 return 1;
1447}
1448
1449/* called under sysctl_lock */
1450static void unuse_table(struct ctl_table_header *p)
1451{
1452 if (!--p->used)
1453 if (unlikely(p->unregistering))
1454 complete(p->unregistering);
1455}
1456
1457/* called under sysctl_lock, will reacquire if has to wait */
1458static void start_unregistering(struct ctl_table_header *p)
1459{
1460 /*
1461 * if p->used is 0, nobody will ever touch that entry again;
1462 * we'll eliminate all paths to it before dropping sysctl_lock
1463 */
1464 if (unlikely(p->used)) {
1465 struct completion wait;
1466 init_completion(&wait);
1467 p->unregistering = &wait;
1468 spin_unlock(&sysctl_lock);
1469 wait_for_completion(&wait);
1470 spin_lock(&sysctl_lock);
Al Virof7e6ced2008-07-15 01:44:23 -04001471 } else {
1472 /* anything non-NULL; we'll never dereference it */
1473 p->unregistering = ERR_PTR(-EINVAL);
Al Viro330d57f2005-11-04 10:18:40 +00001474 }
1475 /*
1476 * do not remove from the list until nobody holds it; walking the
1477 * list in do_sysctl() relies on that.
1478 */
1479 list_del_init(&p->ctl_entry);
1480}
1481
Al Virof7e6ced2008-07-15 01:44:23 -04001482void sysctl_head_get(struct ctl_table_header *head)
1483{
1484 spin_lock(&sysctl_lock);
1485 head->count++;
1486 spin_unlock(&sysctl_lock);
1487}
1488
1489void sysctl_head_put(struct ctl_table_header *head)
1490{
1491 spin_lock(&sysctl_lock);
1492 if (!--head->count)
1493 kfree(head);
1494 spin_unlock(&sysctl_lock);
1495}
1496
1497struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *head)
1498{
1499 if (!head)
1500 BUG();
1501 spin_lock(&sysctl_lock);
1502 if (!use_table(head))
1503 head = ERR_PTR(-ENOENT);
1504 spin_unlock(&sysctl_lock);
1505 return head;
1506}
1507
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001508void sysctl_head_finish(struct ctl_table_header *head)
1509{
1510 if (!head)
1511 return;
1512 spin_lock(&sysctl_lock);
1513 unuse_table(head);
1514 spin_unlock(&sysctl_lock);
1515}
1516
Al Viro73455092008-07-14 21:22:20 -04001517static struct ctl_table_set *
1518lookup_header_set(struct ctl_table_root *root, struct nsproxy *namespaces)
1519{
1520 struct ctl_table_set *set = &root->default_set;
1521 if (root->lookup)
1522 set = root->lookup(root, namespaces);
1523 return set;
1524}
1525
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001526static struct list_head *
1527lookup_header_list(struct ctl_table_root *root, struct nsproxy *namespaces)
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001528{
Al Viro73455092008-07-14 21:22:20 -04001529 struct ctl_table_set *set = lookup_header_set(root, namespaces);
1530 return &set->list;
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001531}
1532
1533struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
1534 struct ctl_table_header *prev)
1535{
1536 struct ctl_table_root *root;
1537 struct list_head *header_list;
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001538 struct ctl_table_header *head;
1539 struct list_head *tmp;
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001540
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001541 spin_lock(&sysctl_lock);
1542 if (prev) {
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001543 head = prev;
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001544 tmp = &prev->ctl_entry;
1545 unuse_table(prev);
1546 goto next;
1547 }
1548 tmp = &root_table_header.ctl_entry;
1549 for (;;) {
1550 head = list_entry(tmp, struct ctl_table_header, ctl_entry);
1551
1552 if (!use_table(head))
1553 goto next;
1554 spin_unlock(&sysctl_lock);
1555 return head;
1556 next:
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001557 root = head->root;
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001558 tmp = tmp->next;
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001559 header_list = lookup_header_list(root, namespaces);
1560 if (tmp != header_list)
1561 continue;
1562
1563 do {
1564 root = list_entry(root->root_list.next,
1565 struct ctl_table_root, root_list);
1566 if (root == &sysctl_table_root)
1567 goto out;
1568 header_list = lookup_header_list(root, namespaces);
1569 } while (list_empty(header_list));
1570 tmp = header_list->next;
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001571 }
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001572out:
Eric W. Biederman805b5d52007-02-14 00:34:11 -08001573 spin_unlock(&sysctl_lock);
1574 return NULL;
1575}
1576
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001577struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev)
1578{
1579 return __sysctl_head_next(current->nsproxy, prev);
1580}
1581
1582void register_sysctl_root(struct ctl_table_root *root)
1583{
1584 spin_lock(&sysctl_lock);
1585 list_add_tail(&root->root_list, &sysctl_table_root.root_list);
1586 spin_unlock(&sysctl_lock);
1587}
1588
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589/*
Eric W. Biederman1ff007e2007-02-14 00:34:11 -08001590 * sysctl_perm does NOT grant the superuser all rights automatically, because
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 * some sysctl variables are readonly even to root.
1592 */
1593
1594static int test_perm(int mode, int op)
1595{
David Howells76aac0e2008-11-14 10:39:12 +11001596 if (!current_euid())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 mode >>= 6;
1598 else if (in_egroup_p(0))
1599 mode >>= 3;
Al Viroe6305c42008-07-15 21:03:57 -04001600 if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 return 0;
1602 return -EACCES;
1603}
1604
Pavel Emelyanovd7321cd2008-04-29 01:02:44 -07001605int sysctl_perm(struct ctl_table_root *root, struct ctl_table *table, int op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
1607 int error;
Pavel Emelyanovd7321cd2008-04-29 01:02:44 -07001608 int mode;
1609
Al Viroe6305c42008-07-15 21:03:57 -04001610 error = security_sysctl(table, op & (MAY_READ | MAY_WRITE | MAY_EXEC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 if (error)
1612 return error;
Pavel Emelyanovd7321cd2008-04-29 01:02:44 -07001613
1614 if (root->permissions)
1615 mode = root->permissions(root, current->nsproxy, table);
1616 else
1617 mode = table->mode;
1618
1619 return test_perm(mode, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620}
1621
Eric W. Biedermand912b0c2007-02-14 00:34:13 -08001622static void sysctl_set_parent(struct ctl_table *parent, struct ctl_table *table)
1623{
Eric W. Biederman2315ffa2009-04-03 03:18:02 -07001624 for (; table->procname; table++) {
Eric W. Biedermand912b0c2007-02-14 00:34:13 -08001625 table->parent = parent;
1626 if (table->child)
1627 sysctl_set_parent(table, table->child);
1628 }
1629}
1630
1631static __init int sysctl_init(void)
1632{
1633 sysctl_set_parent(NULL, root_table);
Holger Schurig88f458e2008-04-29 01:02:36 -07001634#ifdef CONFIG_SYSCTL_SYSCALL_CHECK
1635 {
1636 int err;
1637 err = sysctl_check_table(current->nsproxy, root_table);
1638 }
1639#endif
Eric W. Biedermand912b0c2007-02-14 00:34:13 -08001640 return 0;
1641}
1642
1643core_initcall(sysctl_init);
1644
Al Virobfbcf032008-07-27 06:31:22 +01001645static struct ctl_table *is_branch_in(struct ctl_table *branch,
1646 struct ctl_table *table)
Al Viroae7edec2008-07-15 06:33:31 -04001647{
1648 struct ctl_table *p;
1649 const char *s = branch->procname;
1650
1651 /* branch should have named subdirectory as its first element */
1652 if (!s || !branch->child)
Al Virobfbcf032008-07-27 06:31:22 +01001653 return NULL;
Al Viroae7edec2008-07-15 06:33:31 -04001654
1655 /* ... and nothing else */
Eric W. Biederman2315ffa2009-04-03 03:18:02 -07001656 if (branch[1].procname)
Al Virobfbcf032008-07-27 06:31:22 +01001657 return NULL;
Al Viroae7edec2008-07-15 06:33:31 -04001658
1659 /* table should contain subdirectory with the same name */
Eric W. Biederman2315ffa2009-04-03 03:18:02 -07001660 for (p = table; p->procname; p++) {
Al Viroae7edec2008-07-15 06:33:31 -04001661 if (!p->child)
1662 continue;
1663 if (p->procname && strcmp(p->procname, s) == 0)
Al Virobfbcf032008-07-27 06:31:22 +01001664 return p;
Al Viroae7edec2008-07-15 06:33:31 -04001665 }
Al Virobfbcf032008-07-27 06:31:22 +01001666 return NULL;
Al Viroae7edec2008-07-15 06:33:31 -04001667}
1668
1669/* see if attaching q to p would be an improvement */
1670static void try_attach(struct ctl_table_header *p, struct ctl_table_header *q)
1671{
1672 struct ctl_table *to = p->ctl_table, *by = q->ctl_table;
Al Virobfbcf032008-07-27 06:31:22 +01001673 struct ctl_table *next;
Al Viroae7edec2008-07-15 06:33:31 -04001674 int is_better = 0;
1675 int not_in_parent = !p->attached_by;
1676
Al Virobfbcf032008-07-27 06:31:22 +01001677 while ((next = is_branch_in(by, to)) != NULL) {
Al Viroae7edec2008-07-15 06:33:31 -04001678 if (by == q->attached_by)
1679 is_better = 1;
1680 if (to == p->attached_by)
1681 not_in_parent = 1;
1682 by = by->child;
Al Virobfbcf032008-07-27 06:31:22 +01001683 to = next->child;
Al Viroae7edec2008-07-15 06:33:31 -04001684 }
1685
1686 if (is_better && not_in_parent) {
1687 q->attached_by = by;
1688 q->attached_to = to;
1689 q->parent = p;
1690 }
1691}
1692
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693/**
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001694 * __register_sysctl_paths - register a sysctl hierarchy
1695 * @root: List of sysctl headers to register on
1696 * @namespaces: Data to compute which lists of sysctl entries are visible
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001697 * @path: The path to the directory the sysctl table is in.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 * @table: the top-level table structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 *
1700 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001701 * array. A completely 0 filled entry terminates the table.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 *
Eric W. Biedermand8217f02007-10-18 03:05:22 -07001703 * The members of the &struct ctl_table structure are used as follows:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
1706 * enter a sysctl file
1707 *
1708 * data - a pointer to data for use by proc_handler
1709 *
1710 * maxlen - the maximum size in bytes of the data
1711 *
1712 * mode - the file permissions for the /proc/sys file, and for sysctl(2)
1713 *
1714 * child - a pointer to the child sysctl table if this entry is a directory, or
1715 * %NULL.
1716 *
1717 * proc_handler - the text handler routine (described below)
1718 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 * de - for internal use by the sysctl routines
1720 *
1721 * extra1, extra2 - extra pointers usable by the proc handler routines
1722 *
1723 * Leaf nodes in the sysctl tree will be represented by a single file
1724 * under /proc; non-leaf nodes will be represented by directories.
1725 *
1726 * sysctl(2) can automatically manage read and write requests through
1727 * the sysctl table. The data and maxlen fields of the ctl_table
1728 * struct enable minimal validation of the values being written to be
1729 * performed, and the mode field allows minimal authentication.
1730 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 * There must be a proc_handler routine for any terminal nodes
1732 * mirrored under /proc/sys (non-terminals are handled by a built-in
1733 * directory handler). Several default handlers are available to
1734 * cover common cases -
1735 *
1736 * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
1737 * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
1738 * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
1739 *
1740 * It is the handler's job to read the input buffer from user memory
1741 * and process it. The handler should return 0 on success.
1742 *
1743 * This routine returns %NULL on a failure to register, and a pointer
1744 * to the table header on success.
1745 */
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001746struct ctl_table_header *__register_sysctl_paths(
1747 struct ctl_table_root *root,
1748 struct nsproxy *namespaces,
1749 const struct ctl_path *path, struct ctl_table *table)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750{
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001751 struct ctl_table_header *header;
1752 struct ctl_table *new, **prevp;
1753 unsigned int n, npath;
Al Viroae7edec2008-07-15 06:33:31 -04001754 struct ctl_table_set *set;
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001755
1756 /* Count the path components */
Eric W. Biederman2315ffa2009-04-03 03:18:02 -07001757 for (npath = 0; path[npath].procname; ++npath)
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001758 ;
1759
1760 /*
1761 * For each path component, allocate a 2-element ctl_table array.
1762 * The first array element will be filled with the sysctl entry
Eric W. Biederman2315ffa2009-04-03 03:18:02 -07001763 * for this, the second will be the sentinel (procname == 0).
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001764 *
1765 * We allocate everything in one go so that we don't have to
1766 * worry about freeing additional memory in unregister_sysctl_table.
1767 */
1768 header = kzalloc(sizeof(struct ctl_table_header) +
1769 (2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);
1770 if (!header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 return NULL;
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001772
1773 new = (struct ctl_table *) (header + 1);
1774
1775 /* Now connect the dots */
1776 prevp = &header->ctl_table;
1777 for (n = 0; n < npath; ++n, ++path) {
1778 /* Copy the procname */
1779 new->procname = path->procname;
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001780 new->mode = 0555;
1781
1782 *prevp = new;
1783 prevp = &new->child;
1784
1785 new += 2;
1786 }
1787 *prevp = table;
Eric W. Biederman23eb06d2007-11-30 23:52:10 +11001788 header->ctl_table_arg = table;
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001789
1790 INIT_LIST_HEAD(&header->ctl_entry);
1791 header->used = 0;
1792 header->unregistering = NULL;
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001793 header->root = root;
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001794 sysctl_set_parent(NULL, header->ctl_table);
Al Virof7e6ced2008-07-15 01:44:23 -04001795 header->count = 1;
Holger Schurig88f458e2008-04-29 01:02:36 -07001796#ifdef CONFIG_SYSCTL_SYSCALL_CHECK
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001797 if (sysctl_check_table(namespaces, header->ctl_table)) {
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001798 kfree(header);
Eric W. Biedermanfc6cd252007-10-18 03:05:54 -07001799 return NULL;
1800 }
Holger Schurig88f458e2008-04-29 01:02:36 -07001801#endif
Al Viro330d57f2005-11-04 10:18:40 +00001802 spin_lock(&sysctl_lock);
Al Viro73455092008-07-14 21:22:20 -04001803 header->set = lookup_header_set(root, namespaces);
Al Viroae7edec2008-07-15 06:33:31 -04001804 header->attached_by = header->ctl_table;
1805 header->attached_to = root_table;
1806 header->parent = &root_table_header;
1807 for (set = header->set; set; set = set->parent) {
1808 struct ctl_table_header *p;
1809 list_for_each_entry(p, &set->list, ctl_entry) {
1810 if (p->unregistering)
1811 continue;
1812 try_attach(p, header);
1813 }
1814 }
1815 header->parent->count++;
Al Viro73455092008-07-14 21:22:20 -04001816 list_add_tail(&header->ctl_entry, &header->set->list);
Al Viro330d57f2005-11-04 10:18:40 +00001817 spin_unlock(&sysctl_lock);
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001818
1819 return header;
1820}
1821
1822/**
Eric W. Biedermane51b6ba2007-11-30 23:54:00 +11001823 * register_sysctl_table_path - register a sysctl table hierarchy
1824 * @path: The path to the directory the sysctl table is in.
1825 * @table: the top-level table structure
1826 *
1827 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1828 * array. A completely 0 filled entry terminates the table.
1829 *
1830 * See __register_sysctl_paths for more details.
1831 */
1832struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
1833 struct ctl_table *table)
1834{
1835 return __register_sysctl_paths(&sysctl_table_root, current->nsproxy,
1836 path, table);
1837}
1838
1839/**
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001840 * register_sysctl_table - register a sysctl table hierarchy
1841 * @table: the top-level table structure
1842 *
1843 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1844 * array. A completely 0 filled entry terminates the table.
1845 *
1846 * See register_sysctl_paths for more details.
1847 */
1848struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
1849{
1850 static const struct ctl_path null_path[] = { {} };
1851
1852 return register_sysctl_paths(null_path, table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853}
1854
1855/**
1856 * unregister_sysctl_table - unregister a sysctl table hierarchy
1857 * @header: the header returned from register_sysctl_table
1858 *
1859 * Unregisters the sysctl table and all children. proc entries may not
1860 * actually be removed until they are no longer used by anyone.
1861 */
1862void unregister_sysctl_table(struct ctl_table_header * header)
1863{
Al Viro330d57f2005-11-04 10:18:40 +00001864 might_sleep();
Pavel Emelyanovf1dad162007-12-04 23:45:24 -08001865
1866 if (header == NULL)
1867 return;
1868
Al Viro330d57f2005-11-04 10:18:40 +00001869 spin_lock(&sysctl_lock);
1870 start_unregistering(header);
Al Viroae7edec2008-07-15 06:33:31 -04001871 if (!--header->parent->count) {
1872 WARN_ON(1);
1873 kfree(header->parent);
1874 }
Al Virof7e6ced2008-07-15 01:44:23 -04001875 if (!--header->count)
1876 kfree(header);
Al Viro330d57f2005-11-04 10:18:40 +00001877 spin_unlock(&sysctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878}
1879
Al Viro9043476f2008-07-15 08:54:06 -04001880int sysctl_is_seen(struct ctl_table_header *p)
1881{
1882 struct ctl_table_set *set = p->set;
1883 int res;
1884 spin_lock(&sysctl_lock);
1885 if (p->unregistering)
1886 res = 0;
1887 else if (!set->is_seen)
1888 res = 1;
1889 else
1890 res = set->is_seen(set);
1891 spin_unlock(&sysctl_lock);
1892 return res;
1893}
1894
Al Viro73455092008-07-14 21:22:20 -04001895void setup_sysctl_set(struct ctl_table_set *p,
1896 struct ctl_table_set *parent,
1897 int (*is_seen)(struct ctl_table_set *))
1898{
1899 INIT_LIST_HEAD(&p->list);
1900 p->parent = parent ? parent : &sysctl_table_root.default_set;
1901 p->is_seen = is_seen;
1902}
1903
Eric W. Biedermanb89a8172006-09-27 01:51:04 -07001904#else /* !CONFIG_SYSCTL */
Eric W. Biedermand8217f02007-10-18 03:05:22 -07001905struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
Eric W. Biedermanb89a8172006-09-27 01:51:04 -07001906{
1907 return NULL;
1908}
1909
Eric W. Biederman29e796f2007-11-30 23:50:18 +11001910struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
1911 struct ctl_table *table)
1912{
1913 return NULL;
1914}
1915
Eric W. Biedermanb89a8172006-09-27 01:51:04 -07001916void unregister_sysctl_table(struct ctl_table_header * table)
1917{
1918}
1919
Al Viro73455092008-07-14 21:22:20 -04001920void setup_sysctl_set(struct ctl_table_set *p,
1921 struct ctl_table_set *parent,
1922 int (*is_seen)(struct ctl_table_set *))
1923{
1924}
1925
Al Virof7e6ced2008-07-15 01:44:23 -04001926void sysctl_head_put(struct ctl_table_header *head)
1927{
1928}
1929
Eric W. Biedermanb89a8172006-09-27 01:51:04 -07001930#endif /* CONFIG_SYSCTL */
1931
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932/*
1933 * /proc/sys support
1934 */
1935
Eric W. Biedermanb89a8172006-09-27 01:51:04 -07001936#ifdef CONFIG_PROC_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
Adrian Bunkb1ba4dd2006-10-02 02:18:05 -07001938static int _proc_do_string(void* data, int maxlen, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001939 void __user *buffer,
Adrian Bunkb1ba4dd2006-10-02 02:18:05 -07001940 size_t *lenp, loff_t *ppos)
Sam Vilainf5dd3d62006-10-02 02:18:04 -07001941{
1942 size_t len;
1943 char __user *p;
1944 char c;
Oleg Nesterov8d060872007-02-10 01:46:38 -08001945
1946 if (!data || !maxlen || !*lenp) {
Sam Vilainf5dd3d62006-10-02 02:18:04 -07001947 *lenp = 0;
1948 return 0;
1949 }
Oleg Nesterov8d060872007-02-10 01:46:38 -08001950
Sam Vilainf5dd3d62006-10-02 02:18:04 -07001951 if (write) {
1952 len = 0;
1953 p = buffer;
1954 while (len < *lenp) {
1955 if (get_user(c, p++))
1956 return -EFAULT;
1957 if (c == 0 || c == '\n')
1958 break;
1959 len++;
1960 }
1961 if (len >= maxlen)
1962 len = maxlen-1;
1963 if(copy_from_user(data, buffer, len))
1964 return -EFAULT;
1965 ((char *) data)[len] = 0;
1966 *ppos += *lenp;
1967 } else {
1968 len = strlen(data);
1969 if (len > maxlen)
1970 len = maxlen;
Oleg Nesterov8d060872007-02-10 01:46:38 -08001971
1972 if (*ppos > len) {
1973 *lenp = 0;
1974 return 0;
1975 }
1976
1977 data += *ppos;
1978 len -= *ppos;
1979
Sam Vilainf5dd3d62006-10-02 02:18:04 -07001980 if (len > *lenp)
1981 len = *lenp;
1982 if (len)
1983 if(copy_to_user(buffer, data, len))
1984 return -EFAULT;
1985 if (len < *lenp) {
1986 if(put_user('\n', ((char __user *) buffer) + len))
1987 return -EFAULT;
1988 len++;
1989 }
1990 *lenp = len;
1991 *ppos += len;
1992 }
1993 return 0;
1994}
1995
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996/**
1997 * proc_dostring - read a string sysctl
1998 * @table: the sysctl table
1999 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 * @buffer: the user buffer
2001 * @lenp: the size of the user buffer
2002 * @ppos: file position
2003 *
2004 * Reads/writes a string from/to the user buffer. If the kernel
2005 * buffer provided is not large enough to hold the string, the
2006 * string is truncated. The copied string is %NULL-terminated.
2007 * If the string is being read by the user process, it is copied
2008 * and a newline '\n' is added. It is truncated if the buffer is
2009 * not large enough.
2010 *
2011 * Returns 0 on success.
2012 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002013int proc_dostring(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 void __user *buffer, size_t *lenp, loff_t *ppos)
2015{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002016 return _proc_do_string(table->data, table->maxlen, write,
Sam Vilainf5dd3d62006-10-02 02:18:04 -07002017 buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018}
2019
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020
2021static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
2022 int *valp,
2023 int write, void *data)
2024{
2025 if (write) {
2026 *valp = *negp ? -*lvalp : *lvalp;
2027 } else {
2028 int val = *valp;
2029 if (val < 0) {
2030 *negp = -1;
2031 *lvalp = (unsigned long)-val;
2032 } else {
2033 *negp = 0;
2034 *lvalp = (unsigned long)val;
2035 }
2036 }
2037 return 0;
2038}
2039
Eric W. Biedermand8217f02007-10-18 03:05:22 -07002040static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002041 int write, void __user *buffer,
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002042 size_t *lenp, loff_t *ppos,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 int (*conv)(int *negp, unsigned long *lvalp, int *valp,
2044 int write, void *data),
2045 void *data)
2046{
2047#define TMPBUFLEN 21
Sukanto Ghosh7338f292009-06-17 16:27:50 -07002048 int *i, vleft, first = 1, neg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 unsigned long lval;
2050 size_t left, len;
2051
2052 char buf[TMPBUFLEN], *p;
2053 char __user *s = buffer;
2054
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002055 if (!tbl_data || !table->maxlen || !*lenp ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 (*ppos && !write)) {
2057 *lenp = 0;
2058 return 0;
2059 }
2060
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002061 i = (int *) tbl_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 vleft = table->maxlen / sizeof(*i);
2063 left = *lenp;
2064
2065 if (!conv)
2066 conv = do_proc_dointvec_conv;
2067
2068 for (; left && vleft--; i++, first=0) {
2069 if (write) {
2070 while (left) {
2071 char c;
2072 if (get_user(c, s))
2073 return -EFAULT;
2074 if (!isspace(c))
2075 break;
2076 left--;
2077 s++;
2078 }
2079 if (!left)
2080 break;
2081 neg = 0;
2082 len = left;
2083 if (len > sizeof(buf) - 1)
2084 len = sizeof(buf) - 1;
2085 if (copy_from_user(buf, s, len))
2086 return -EFAULT;
2087 buf[len] = 0;
2088 p = buf;
2089 if (*p == '-' && left > 1) {
2090 neg = 1;
BP, Praveenbd9b0ba2006-12-06 20:39:09 -08002091 p++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 }
2093 if (*p < '0' || *p > '9')
2094 break;
2095
2096 lval = simple_strtoul(p, &p, 0);
2097
2098 len = p-buf;
2099 if ((len < left) && *p && !isspace(*p))
2100 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 s += len;
2102 left -= len;
2103
2104 if (conv(&neg, &lval, i, 1, data))
2105 break;
2106 } else {
2107 p = buf;
2108 if (!first)
2109 *p++ = '\t';
2110
2111 if (conv(&neg, &lval, i, 0, data))
2112 break;
2113
2114 sprintf(p, "%s%lu", neg ? "-" : "", lval);
2115 len = strlen(buf);
2116 if (len > left)
2117 len = left;
2118 if(copy_to_user(s, buf, len))
2119 return -EFAULT;
2120 left -= len;
2121 s += len;
2122 }
2123 }
2124
2125 if (!write && !first && left) {
2126 if(put_user('\n', s))
2127 return -EFAULT;
2128 left--, s++;
2129 }
2130 if (write) {
2131 while (left) {
2132 char c;
2133 if (get_user(c, s++))
2134 return -EFAULT;
2135 if (!isspace(c))
2136 break;
2137 left--;
2138 }
2139 }
2140 if (write && first)
2141 return -EINVAL;
2142 *lenp -= left;
2143 *ppos += *lenp;
2144 return 0;
2145#undef TMPBUFLEN
2146}
2147
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002148static int do_proc_dointvec(struct ctl_table *table, int write,
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002149 void __user *buffer, size_t *lenp, loff_t *ppos,
2150 int (*conv)(int *negp, unsigned long *lvalp, int *valp,
2151 int write, void *data),
2152 void *data)
2153{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002154 return __do_proc_dointvec(table->data, table, write,
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002155 buffer, lenp, ppos, conv, data);
2156}
2157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158/**
2159 * proc_dointvec - read a vector of integers
2160 * @table: the sysctl table
2161 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 * @buffer: the user buffer
2163 * @lenp: the size of the user buffer
2164 * @ppos: file position
2165 *
2166 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2167 * values from/to the user buffer, treated as an ASCII string.
2168 *
2169 * Returns 0 on success.
2170 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002171int proc_dointvec(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 void __user *buffer, size_t *lenp, loff_t *ppos)
2173{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002174 return do_proc_dointvec(table,write,buffer,lenp,ppos,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 NULL,NULL);
2176}
2177
Theodore Ts'o34f5a392007-02-10 01:45:24 -08002178/*
Andi Kleen25ddbb12008-10-15 22:01:41 -07002179 * Taint values can only be increased
2180 * This means we can safely use a temporary.
Theodore Ts'o34f5a392007-02-10 01:45:24 -08002181 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002182static int proc_taint(struct ctl_table *table, int write,
Theodore Ts'o34f5a392007-02-10 01:45:24 -08002183 void __user *buffer, size_t *lenp, loff_t *ppos)
2184{
Andi Kleen25ddbb12008-10-15 22:01:41 -07002185 struct ctl_table t;
2186 unsigned long tmptaint = get_taint();
2187 int err;
Theodore Ts'o34f5a392007-02-10 01:45:24 -08002188
Bastian Blank91fcd412007-04-23 14:41:14 -07002189 if (write && !capable(CAP_SYS_ADMIN))
Theodore Ts'o34f5a392007-02-10 01:45:24 -08002190 return -EPERM;
2191
Andi Kleen25ddbb12008-10-15 22:01:41 -07002192 t = *table;
2193 t.data = &tmptaint;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002194 err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
Andi Kleen25ddbb12008-10-15 22:01:41 -07002195 if (err < 0)
2196 return err;
2197
2198 if (write) {
2199 /*
2200 * Poor man's atomic or. Not worth adding a primitive
2201 * to everyone's atomic.h for this
2202 */
2203 int i;
2204 for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2205 if ((tmptaint >> i) & 1)
2206 add_taint(i);
2207 }
2208 }
2209
2210 return err;
Theodore Ts'o34f5a392007-02-10 01:45:24 -08002211}
2212
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213struct do_proc_dointvec_minmax_conv_param {
2214 int *min;
2215 int *max;
2216};
2217
2218static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp,
2219 int *valp,
2220 int write, void *data)
2221{
2222 struct do_proc_dointvec_minmax_conv_param *param = data;
2223 if (write) {
2224 int val = *negp ? -*lvalp : *lvalp;
2225 if ((param->min && *param->min > val) ||
2226 (param->max && *param->max < val))
2227 return -EINVAL;
2228 *valp = val;
2229 } else {
2230 int val = *valp;
2231 if (val < 0) {
2232 *negp = -1;
2233 *lvalp = (unsigned long)-val;
2234 } else {
2235 *negp = 0;
2236 *lvalp = (unsigned long)val;
2237 }
2238 }
2239 return 0;
2240}
2241
2242/**
2243 * proc_dointvec_minmax - read a vector of integers with min/max values
2244 * @table: the sysctl table
2245 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 * @buffer: the user buffer
2247 * @lenp: the size of the user buffer
2248 * @ppos: file position
2249 *
2250 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2251 * values from/to the user buffer, treated as an ASCII string.
2252 *
2253 * This routine will ensure the values are within the range specified by
2254 * table->extra1 (min) and table->extra2 (max).
2255 *
2256 * Returns 0 on success.
2257 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002258int proc_dointvec_minmax(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 void __user *buffer, size_t *lenp, loff_t *ppos)
2260{
2261 struct do_proc_dointvec_minmax_conv_param param = {
2262 .min = (int *) table->extra1,
2263 .max = (int *) table->extra2,
2264 };
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002265 return do_proc_dointvec(table, write, buffer, lenp, ppos,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 do_proc_dointvec_minmax_conv, &param);
2267}
2268
Eric W. Biedermand8217f02007-10-18 03:05:22 -07002269static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 void __user *buffer,
2271 size_t *lenp, loff_t *ppos,
2272 unsigned long convmul,
2273 unsigned long convdiv)
2274{
2275#define TMPBUFLEN 21
2276 unsigned long *i, *min, *max, val;
2277 int vleft, first=1, neg;
2278 size_t len, left;
2279 char buf[TMPBUFLEN], *p;
2280 char __user *s = buffer;
2281
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002282 if (!data || !table->maxlen || !*lenp ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 (*ppos && !write)) {
2284 *lenp = 0;
2285 return 0;
2286 }
2287
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002288 i = (unsigned long *) data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 min = (unsigned long *) table->extra1;
2290 max = (unsigned long *) table->extra2;
2291 vleft = table->maxlen / sizeof(unsigned long);
2292 left = *lenp;
2293
2294 for (; left && vleft--; i++, min++, max++, first=0) {
2295 if (write) {
2296 while (left) {
2297 char c;
2298 if (get_user(c, s))
2299 return -EFAULT;
2300 if (!isspace(c))
2301 break;
2302 left--;
2303 s++;
2304 }
2305 if (!left)
2306 break;
2307 neg = 0;
2308 len = left;
2309 if (len > TMPBUFLEN-1)
2310 len = TMPBUFLEN-1;
2311 if (copy_from_user(buf, s, len))
2312 return -EFAULT;
2313 buf[len] = 0;
2314 p = buf;
2315 if (*p == '-' && left > 1) {
2316 neg = 1;
BP, Praveenbd9b0ba2006-12-06 20:39:09 -08002317 p++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 }
2319 if (*p < '0' || *p > '9')
2320 break;
2321 val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
2322 len = p-buf;
2323 if ((len < left) && *p && !isspace(*p))
2324 break;
2325 if (neg)
2326 val = -val;
2327 s += len;
2328 left -= len;
2329
2330 if(neg)
2331 continue;
2332 if ((min && val < *min) || (max && val > *max))
2333 continue;
2334 *i = val;
2335 } else {
2336 p = buf;
2337 if (!first)
2338 *p++ = '\t';
2339 sprintf(p, "%lu", convdiv * (*i) / convmul);
2340 len = strlen(buf);
2341 if (len > left)
2342 len = left;
2343 if(copy_to_user(s, buf, len))
2344 return -EFAULT;
2345 left -= len;
2346 s += len;
2347 }
2348 }
2349
2350 if (!write && !first && left) {
2351 if(put_user('\n', s))
2352 return -EFAULT;
2353 left--, s++;
2354 }
2355 if (write) {
2356 while (left) {
2357 char c;
2358 if (get_user(c, s++))
2359 return -EFAULT;
2360 if (!isspace(c))
2361 break;
2362 left--;
2363 }
2364 }
2365 if (write && first)
2366 return -EINVAL;
2367 *lenp -= left;
2368 *ppos += *lenp;
2369 return 0;
2370#undef TMPBUFLEN
2371}
2372
Eric W. Biedermand8217f02007-10-18 03:05:22 -07002373static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002374 void __user *buffer,
2375 size_t *lenp, loff_t *ppos,
2376 unsigned long convmul,
2377 unsigned long convdiv)
2378{
2379 return __do_proc_doulongvec_minmax(table->data, table, write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002380 buffer, lenp, ppos, convmul, convdiv);
Kirill Korotaevfcfbd542006-10-02 02:18:23 -07002381}
2382
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383/**
2384 * proc_doulongvec_minmax - read a vector of long integers with min/max values
2385 * @table: the sysctl table
2386 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 * @buffer: the user buffer
2388 * @lenp: the size of the user buffer
2389 * @ppos: file position
2390 *
2391 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2392 * values from/to the user buffer, treated as an ASCII string.
2393 *
2394 * This routine will ensure the values are within the range specified by
2395 * table->extra1 (min) and table->extra2 (max).
2396 *
2397 * Returns 0 on success.
2398 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002399int proc_doulongvec_minmax(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 void __user *buffer, size_t *lenp, loff_t *ppos)
2401{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002402 return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403}
2404
2405/**
2406 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2407 * @table: the sysctl table
2408 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 * @buffer: the user buffer
2410 * @lenp: the size of the user buffer
2411 * @ppos: file position
2412 *
2413 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2414 * values from/to the user buffer, treated as an ASCII string. The values
2415 * are treated as milliseconds, and converted to jiffies when they are stored.
2416 *
2417 * This routine will ensure the values are within the range specified by
2418 * table->extra1 (min) and table->extra2 (max).
2419 *
2420 * Returns 0 on success.
2421 */
Eric W. Biedermand8217f02007-10-18 03:05:22 -07002422int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 void __user *buffer,
2424 size_t *lenp, loff_t *ppos)
2425{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002426 return do_proc_doulongvec_minmax(table, write, buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 lenp, ppos, HZ, 1000l);
2428}
2429
2430
2431static int do_proc_dointvec_jiffies_conv(int *negp, unsigned long *lvalp,
2432 int *valp,
2433 int write, void *data)
2434{
2435 if (write) {
Bart Samwelcba9f332006-03-24 03:15:50 -08002436 if (*lvalp > LONG_MAX / HZ)
2437 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2439 } else {
2440 int val = *valp;
2441 unsigned long lval;
2442 if (val < 0) {
2443 *negp = -1;
2444 lval = (unsigned long)-val;
2445 } else {
2446 *negp = 0;
2447 lval = (unsigned long)val;
2448 }
2449 *lvalp = lval / HZ;
2450 }
2451 return 0;
2452}
2453
2454static int do_proc_dointvec_userhz_jiffies_conv(int *negp, unsigned long *lvalp,
2455 int *valp,
2456 int write, void *data)
2457{
2458 if (write) {
Bart Samwelcba9f332006-03-24 03:15:50 -08002459 if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2460 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
2462 } else {
2463 int val = *valp;
2464 unsigned long lval;
2465 if (val < 0) {
2466 *negp = -1;
2467 lval = (unsigned long)-val;
2468 } else {
2469 *negp = 0;
2470 lval = (unsigned long)val;
2471 }
2472 *lvalp = jiffies_to_clock_t(lval);
2473 }
2474 return 0;
2475}
2476
2477static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
2478 int *valp,
2479 int write, void *data)
2480{
2481 if (write) {
2482 *valp = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2483 } else {
2484 int val = *valp;
2485 unsigned long lval;
2486 if (val < 0) {
2487 *negp = -1;
2488 lval = (unsigned long)-val;
2489 } else {
2490 *negp = 0;
2491 lval = (unsigned long)val;
2492 }
2493 *lvalp = jiffies_to_msecs(lval);
2494 }
2495 return 0;
2496}
2497
2498/**
2499 * proc_dointvec_jiffies - read a vector of integers as seconds
2500 * @table: the sysctl table
2501 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502 * @buffer: the user buffer
2503 * @lenp: the size of the user buffer
2504 * @ppos: file position
2505 *
2506 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2507 * values from/to the user buffer, treated as an ASCII string.
2508 * The values read are assumed to be in seconds, and are converted into
2509 * jiffies.
2510 *
2511 * Returns 0 on success.
2512 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002513int proc_dointvec_jiffies(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514 void __user *buffer, size_t *lenp, loff_t *ppos)
2515{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002516 return do_proc_dointvec(table,write,buffer,lenp,ppos,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 do_proc_dointvec_jiffies_conv,NULL);
2518}
2519
2520/**
2521 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2522 * @table: the sysctl table
2523 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 * @buffer: the user buffer
2525 * @lenp: the size of the user buffer
Randy Dunlap1e5d5332005-11-07 01:01:06 -08002526 * @ppos: pointer to the file position
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 *
2528 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2529 * values from/to the user buffer, treated as an ASCII string.
2530 * The values read are assumed to be in 1/USER_HZ seconds, and
2531 * are converted into jiffies.
2532 *
2533 * Returns 0 on success.
2534 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002535int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 void __user *buffer, size_t *lenp, loff_t *ppos)
2537{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002538 return do_proc_dointvec(table,write,buffer,lenp,ppos,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 do_proc_dointvec_userhz_jiffies_conv,NULL);
2540}
2541
2542/**
2543 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2544 * @table: the sysctl table
2545 * @write: %TRUE if this is a write to the sysctl file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 * @buffer: the user buffer
2547 * @lenp: the size of the user buffer
Martin Waitz67be2dd2005-05-01 08:59:26 -07002548 * @ppos: file position
2549 * @ppos: the current position in the file
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550 *
2551 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2552 * values from/to the user buffer, treated as an ASCII string.
2553 * The values read are assumed to be in 1/1000 seconds, and
2554 * are converted into jiffies.
2555 *
2556 * Returns 0 on success.
2557 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002558int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 void __user *buffer, size_t *lenp, loff_t *ppos)
2560{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002561 return do_proc_dointvec(table, write, buffer, lenp, ppos,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 do_proc_dointvec_ms_jiffies_conv, NULL);
2563}
2564
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002565static int proc_do_cad_pid(struct ctl_table *table, int write,
Cedric Le Goater9ec52092006-10-02 02:19:00 -07002566 void __user *buffer, size_t *lenp, loff_t *ppos)
2567{
2568 struct pid *new_pid;
2569 pid_t tmp;
2570 int r;
2571
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08002572 tmp = pid_vnr(cad_pid);
Cedric Le Goater9ec52092006-10-02 02:19:00 -07002573
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002574 r = __do_proc_dointvec(&tmp, table, write, buffer,
Cedric Le Goater9ec52092006-10-02 02:19:00 -07002575 lenp, ppos, NULL, NULL);
2576 if (r || !write)
2577 return r;
2578
2579 new_pid = find_get_pid(tmp);
2580 if (!new_pid)
2581 return -ESRCH;
2582
2583 put_pid(xchg(&cad_pid, new_pid));
2584 return 0;
2585}
2586
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587#else /* CONFIG_PROC_FS */
2588
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002589int proc_dostring(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 void __user *buffer, size_t *lenp, loff_t *ppos)
2591{
2592 return -ENOSYS;
2593}
2594
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002595int proc_dointvec(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 void __user *buffer, size_t *lenp, loff_t *ppos)
2597{
2598 return -ENOSYS;
2599}
2600
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002601int proc_dointvec_minmax(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602 void __user *buffer, size_t *lenp, loff_t *ppos)
2603{
2604 return -ENOSYS;
2605}
2606
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002607int proc_dointvec_jiffies(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 void __user *buffer, size_t *lenp, loff_t *ppos)
2609{
2610 return -ENOSYS;
2611}
2612
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002613int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 void __user *buffer, size_t *lenp, loff_t *ppos)
2615{
2616 return -ENOSYS;
2617}
2618
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002619int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 void __user *buffer, size_t *lenp, loff_t *ppos)
2621{
2622 return -ENOSYS;
2623}
2624
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002625int proc_doulongvec_minmax(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 void __user *buffer, size_t *lenp, loff_t *ppos)
2627{
2628 return -ENOSYS;
2629}
2630
Eric W. Biedermand8217f02007-10-18 03:05:22 -07002631int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 void __user *buffer,
2633 size_t *lenp, loff_t *ppos)
2634{
2635 return -ENOSYS;
2636}
2637
2638
2639#endif /* CONFIG_PROC_FS */
2640
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641/*
2642 * No sense putting this after each symbol definition, twice,
2643 * exception granted :-)
2644 */
2645EXPORT_SYMBOL(proc_dointvec);
2646EXPORT_SYMBOL(proc_dointvec_jiffies);
2647EXPORT_SYMBOL(proc_dointvec_minmax);
2648EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2649EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2650EXPORT_SYMBOL(proc_dostring);
2651EXPORT_SYMBOL(proc_doulongvec_minmax);
2652EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2653EXPORT_SYMBOL(register_sysctl_table);
Eric W. Biederman29e796f2007-11-30 23:50:18 +11002654EXPORT_SYMBOL(register_sysctl_paths);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655EXPORT_SYMBOL(unregister_sysctl_table);