Back to home page

LXR

 
 

    


0001 /*
0002  * sysctl.c: General linux system control interface
0003  *
0004  * Begun 24 March 1995, Stephen Tweedie
0005  * Added /proc support, Dec 1995
0006  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
0007  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
0008  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
0009  * Dynamic registration fixes, Stephen Tweedie.
0010  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
0011  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
0012  *  Horn.
0013  * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
0014  * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
0015  * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
0016  *  Wendling.
0017  * The list_for_each() macro wasn't appropriate for the sysctl loop.
0018  *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
0019  */
0020 
0021 #include <linux/module.h>
0022 #include <linux/aio.h>
0023 #include <linux/mm.h>
0024 #include <linux/swap.h>
0025 #include <linux/slab.h>
0026 #include <linux/sysctl.h>
0027 #include <linux/bitmap.h>
0028 #include <linux/signal.h>
0029 #include <linux/printk.h>
0030 #include <linux/proc_fs.h>
0031 #include <linux/security.h>
0032 #include <linux/ctype.h>
0033 #include <linux/kmemcheck.h>
0034 #include <linux/kmemleak.h>
0035 #include <linux/fs.h>
0036 #include <linux/init.h>
0037 #include <linux/kernel.h>
0038 #include <linux/kobject.h>
0039 #include <linux/net.h>
0040 #include <linux/sysrq.h>
0041 #include <linux/highuid.h>
0042 #include <linux/writeback.h>
0043 #include <linux/ratelimit.h>
0044 #include <linux/compaction.h>
0045 #include <linux/hugetlb.h>
0046 #include <linux/initrd.h>
0047 #include <linux/key.h>
0048 #include <linux/times.h>
0049 #include <linux/limits.h>
0050 #include <linux/dcache.h>
0051 #include <linux/dnotify.h>
0052 #include <linux/syscalls.h>
0053 #include <linux/vmstat.h>
0054 #include <linux/nfs_fs.h>
0055 #include <linux/acpi.h>
0056 #include <linux/reboot.h>
0057 #include <linux/ftrace.h>
0058 #include <linux/perf_event.h>
0059 #include <linux/kprobes.h>
0060 #include <linux/pipe_fs_i.h>
0061 #include <linux/oom.h>
0062 #include <linux/kmod.h>
0063 #include <linux/capability.h>
0064 #include <linux/binfmts.h>
0065 #include <linux/sched/sysctl.h>
0066 #include <linux/kexec.h>
0067 #include <linux/bpf.h>
0068 #include <linux/mount.h>
0069 
0070 #include <linux/uaccess.h>
0071 #include <asm/processor.h>
0072 
0073 #ifdef CONFIG_X86
0074 #include <asm/nmi.h>
0075 #include <asm/stacktrace.h>
0076 #include <asm/io.h>
0077 #endif
0078 #ifdef CONFIG_SPARC
0079 #include <asm/setup.h>
0080 #endif
0081 #ifdef CONFIG_BSD_PROCESS_ACCT
0082 #include <linux/acct.h>
0083 #endif
0084 #ifdef CONFIG_RT_MUTEXES
0085 #include <linux/rtmutex.h>
0086 #endif
0087 #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
0088 #include <linux/lockdep.h>
0089 #endif
0090 #ifdef CONFIG_CHR_DEV_SG
0091 #include <scsi/sg.h>
0092 #endif
0093 
0094 #ifdef CONFIG_LOCKUP_DETECTOR
0095 #include <linux/nmi.h>
0096 #endif
0097 
0098 #if defined(CONFIG_SYSCTL)
0099 
0100 /* External variables not in a header file. */
0101 extern int suid_dumpable;
0102 #ifdef CONFIG_COREDUMP
0103 extern int core_uses_pid;
0104 extern char core_pattern[];
0105 extern unsigned int core_pipe_limit;
0106 #endif
0107 extern int pid_max;
0108 extern int pid_max_min, pid_max_max;
0109 extern int percpu_pagelist_fraction;
0110 extern int latencytop_enabled;
0111 extern unsigned int sysctl_nr_open_min, sysctl_nr_open_max;
0112 #ifndef CONFIG_MMU
0113 extern int sysctl_nr_trim_pages;
0114 #endif
0115 
0116 /* Constants used for minimum and  maximum */
0117 #ifdef CONFIG_LOCKUP_DETECTOR
0118 static int sixty = 60;
0119 #endif
0120 
0121 static int __maybe_unused neg_one = -1;
0122 
0123 static int zero;
0124 static int __maybe_unused one = 1;
0125 static int __maybe_unused two = 2;
0126 static int __maybe_unused four = 4;
0127 static unsigned long one_ul = 1;
0128 static int one_hundred = 100;
0129 static int one_thousand = 1000;
0130 #ifdef CONFIG_PRINTK
0131 static int ten_thousand = 10000;
0132 #endif
0133 #ifdef CONFIG_PERF_EVENTS
0134 static int six_hundred_forty_kb = 640 * 1024;
0135 #endif
0136 
0137 /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
0138 static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
0139 
0140 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
0141 static int maxolduid = 65535;
0142 static int minolduid;
0143 
0144 static int ngroups_max = NGROUPS_MAX;
0145 static const int cap_last_cap = CAP_LAST_CAP;
0146 
0147 /*this is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs */
0148 #ifdef CONFIG_DETECT_HUNG_TASK
0149 static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
0150 #endif
0151 
0152 #ifdef CONFIG_INOTIFY_USER
0153 #include <linux/inotify.h>
0154 #endif
0155 #ifdef CONFIG_SPARC
0156 #endif
0157 
0158 #ifdef __hppa__
0159 extern int pwrsw_enabled;
0160 #endif
0161 
0162 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
0163 extern int unaligned_enabled;
0164 #endif
0165 
0166 #ifdef CONFIG_IA64
0167 extern int unaligned_dump_stack;
0168 #endif
0169 
0170 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
0171 extern int no_unaligned_warning;
0172 #endif
0173 
0174 #ifdef CONFIG_PROC_SYSCTL
0175 
0176 #define SYSCTL_WRITES_LEGACY    -1
0177 #define SYSCTL_WRITES_WARN   0
0178 #define SYSCTL_WRITES_STRICT     1
0179 
0180 static int sysctl_writes_strict = SYSCTL_WRITES_STRICT;
0181 
0182 static int proc_do_cad_pid(struct ctl_table *table, int write,
0183           void __user *buffer, size_t *lenp, loff_t *ppos);
0184 static int proc_taint(struct ctl_table *table, int write,
0185                    void __user *buffer, size_t *lenp, loff_t *ppos);
0186 #endif
0187 
0188 #ifdef CONFIG_PRINTK
0189 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
0190                 void __user *buffer, size_t *lenp, loff_t *ppos);
0191 #endif
0192 
0193 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
0194         void __user *buffer, size_t *lenp, loff_t *ppos);
0195 #ifdef CONFIG_COREDUMP
0196 static int proc_dostring_coredump(struct ctl_table *table, int write,
0197         void __user *buffer, size_t *lenp, loff_t *ppos);
0198 #endif
0199 
0200 #ifdef CONFIG_MAGIC_SYSRQ
0201 /* Note: sysrq code uses it's own private copy */
0202 static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
0203 
0204 static int sysrq_sysctl_handler(struct ctl_table *table, int write,
0205                 void __user *buffer, size_t *lenp,
0206                 loff_t *ppos)
0207 {
0208     int error;
0209 
0210     error = proc_dointvec(table, write, buffer, lenp, ppos);
0211     if (error)
0212         return error;
0213 
0214     if (write)
0215         sysrq_toggle_support(__sysrq_enabled);
0216 
0217     return 0;
0218 }
0219 
0220 #endif
0221 
0222 static struct ctl_table kern_table[];
0223 static struct ctl_table vm_table[];
0224 static struct ctl_table fs_table[];
0225 static struct ctl_table debug_table[];
0226 static struct ctl_table dev_table[];
0227 extern struct ctl_table random_table[];
0228 #ifdef CONFIG_EPOLL
0229 extern struct ctl_table epoll_table[];
0230 #endif
0231 
0232 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
0233 int sysctl_legacy_va_layout;
0234 #endif
0235 
0236 /* The default sysctl tables: */
0237 
0238 static struct ctl_table sysctl_base_table[] = {
0239     {
0240         .procname   = "kernel",
0241         .mode       = 0555,
0242         .child      = kern_table,
0243     },
0244     {
0245         .procname   = "vm",
0246         .mode       = 0555,
0247         .child      = vm_table,
0248     },
0249     {
0250         .procname   = "fs",
0251         .mode       = 0555,
0252         .child      = fs_table,
0253     },
0254     {
0255         .procname   = "debug",
0256         .mode       = 0555,
0257         .child      = debug_table,
0258     },
0259     {
0260         .procname   = "dev",
0261         .mode       = 0555,
0262         .child      = dev_table,
0263     },
0264     { }
0265 };
0266 
0267 #ifdef CONFIG_SCHED_DEBUG
0268 static int min_sched_granularity_ns = 100000;       /* 100 usecs */
0269 static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */
0270 static int min_wakeup_granularity_ns;           /* 0 usecs */
0271 static int max_wakeup_granularity_ns = NSEC_PER_SEC;    /* 1 second */
0272 #ifdef CONFIG_SMP
0273 static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
0274 static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
0275 #endif /* CONFIG_SMP */
0276 #endif /* CONFIG_SCHED_DEBUG */
0277 
0278 #ifdef CONFIG_COMPACTION
0279 static int min_extfrag_threshold;
0280 static int max_extfrag_threshold = 1000;
0281 #endif
0282 
0283 static struct ctl_table kern_table[] = {
0284     {
0285         .procname   = "sched_child_runs_first",
0286         .data       = &sysctl_sched_child_runs_first,
0287         .maxlen     = sizeof(unsigned int),
0288         .mode       = 0644,
0289         .proc_handler   = proc_dointvec,
0290     },
0291 #ifdef CONFIG_SCHED_DEBUG
0292     {
0293         .procname   = "sched_min_granularity_ns",
0294         .data       = &sysctl_sched_min_granularity,
0295         .maxlen     = sizeof(unsigned int),
0296         .mode       = 0644,
0297         .proc_handler   = sched_proc_update_handler,
0298         .extra1     = &min_sched_granularity_ns,
0299         .extra2     = &max_sched_granularity_ns,
0300     },
0301     {
0302         .procname   = "sched_latency_ns",
0303         .data       = &sysctl_sched_latency,
0304         .maxlen     = sizeof(unsigned int),
0305         .mode       = 0644,
0306         .proc_handler   = sched_proc_update_handler,
0307         .extra1     = &min_sched_granularity_ns,
0308         .extra2     = &max_sched_granularity_ns,
0309     },
0310     {
0311         .procname   = "sched_wakeup_granularity_ns",
0312         .data       = &sysctl_sched_wakeup_granularity,
0313         .maxlen     = sizeof(unsigned int),
0314         .mode       = 0644,
0315         .proc_handler   = sched_proc_update_handler,
0316         .extra1     = &min_wakeup_granularity_ns,
0317         .extra2     = &max_wakeup_granularity_ns,
0318     },
0319 #ifdef CONFIG_SMP
0320     {
0321         .procname   = "sched_tunable_scaling",
0322         .data       = &sysctl_sched_tunable_scaling,
0323         .maxlen     = sizeof(enum sched_tunable_scaling),
0324         .mode       = 0644,
0325         .proc_handler   = sched_proc_update_handler,
0326         .extra1     = &min_sched_tunable_scaling,
0327         .extra2     = &max_sched_tunable_scaling,
0328     },
0329     {
0330         .procname   = "sched_migration_cost_ns",
0331         .data       = &sysctl_sched_migration_cost,
0332         .maxlen     = sizeof(unsigned int),
0333         .mode       = 0644,
0334         .proc_handler   = proc_dointvec,
0335     },
0336     {
0337         .procname   = "sched_nr_migrate",
0338         .data       = &sysctl_sched_nr_migrate,
0339         .maxlen     = sizeof(unsigned int),
0340         .mode       = 0644,
0341         .proc_handler   = proc_dointvec,
0342     },
0343     {
0344         .procname   = "sched_time_avg_ms",
0345         .data       = &sysctl_sched_time_avg,
0346         .maxlen     = sizeof(unsigned int),
0347         .mode       = 0644,
0348         .proc_handler   = proc_dointvec,
0349     },
0350 #ifdef CONFIG_SCHEDSTATS
0351     {
0352         .procname   = "sched_schedstats",
0353         .data       = NULL,
0354         .maxlen     = sizeof(unsigned int),
0355         .mode       = 0644,
0356         .proc_handler   = sysctl_schedstats,
0357         .extra1     = &zero,
0358         .extra2     = &one,
0359     },
0360 #endif /* CONFIG_SCHEDSTATS */
0361 #endif /* CONFIG_SMP */
0362 #ifdef CONFIG_NUMA_BALANCING
0363     {
0364         .procname   = "numa_balancing_scan_delay_ms",
0365         .data       = &sysctl_numa_balancing_scan_delay,
0366         .maxlen     = sizeof(unsigned int),
0367         .mode       = 0644,
0368         .proc_handler   = proc_dointvec,
0369     },
0370     {
0371         .procname   = "numa_balancing_scan_period_min_ms",
0372         .data       = &sysctl_numa_balancing_scan_period_min,
0373         .maxlen     = sizeof(unsigned int),
0374         .mode       = 0644,
0375         .proc_handler   = proc_dointvec,
0376     },
0377     {
0378         .procname   = "numa_balancing_scan_period_max_ms",
0379         .data       = &sysctl_numa_balancing_scan_period_max,
0380         .maxlen     = sizeof(unsigned int),
0381         .mode       = 0644,
0382         .proc_handler   = proc_dointvec,
0383     },
0384     {
0385         .procname   = "numa_balancing_scan_size_mb",
0386         .data       = &sysctl_numa_balancing_scan_size,
0387         .maxlen     = sizeof(unsigned int),
0388         .mode       = 0644,
0389         .proc_handler   = proc_dointvec_minmax,
0390         .extra1     = &one,
0391     },
0392     {
0393         .procname   = "numa_balancing",
0394         .data       = NULL, /* filled in by handler */
0395         .maxlen     = sizeof(unsigned int),
0396         .mode       = 0644,
0397         .proc_handler   = sysctl_numa_balancing,
0398         .extra1     = &zero,
0399         .extra2     = &one,
0400     },
0401 #endif /* CONFIG_NUMA_BALANCING */
0402 #endif /* CONFIG_SCHED_DEBUG */
0403     {
0404         .procname   = "sched_rt_period_us",
0405         .data       = &sysctl_sched_rt_period,
0406         .maxlen     = sizeof(unsigned int),
0407         .mode       = 0644,
0408         .proc_handler   = sched_rt_handler,
0409     },
0410     {
0411         .procname   = "sched_rt_runtime_us",
0412         .data       = &sysctl_sched_rt_runtime,
0413         .maxlen     = sizeof(int),
0414         .mode       = 0644,
0415         .proc_handler   = sched_rt_handler,
0416     },
0417     {
0418         .procname   = "sched_rr_timeslice_ms",
0419         .data       = &sched_rr_timeslice,
0420         .maxlen     = sizeof(int),
0421         .mode       = 0644,
0422         .proc_handler   = sched_rr_handler,
0423     },
0424 #ifdef CONFIG_SCHED_AUTOGROUP
0425     {
0426         .procname   = "sched_autogroup_enabled",
0427         .data       = &sysctl_sched_autogroup_enabled,
0428         .maxlen     = sizeof(unsigned int),
0429         .mode       = 0644,
0430         .proc_handler   = proc_dointvec_minmax,
0431         .extra1     = &zero,
0432         .extra2     = &one,
0433     },
0434 #endif
0435 #ifdef CONFIG_CFS_BANDWIDTH
0436     {
0437         .procname   = "sched_cfs_bandwidth_slice_us",
0438         .data       = &sysctl_sched_cfs_bandwidth_slice,
0439         .maxlen     = sizeof(unsigned int),
0440         .mode       = 0644,
0441         .proc_handler   = proc_dointvec_minmax,
0442         .extra1     = &one,
0443     },
0444 #endif
0445 #ifdef CONFIG_PROVE_LOCKING
0446     {
0447         .procname   = "prove_locking",
0448         .data       = &prove_locking,
0449         .maxlen     = sizeof(int),
0450         .mode       = 0644,
0451         .proc_handler   = proc_dointvec,
0452     },
0453 #endif
0454 #ifdef CONFIG_LOCK_STAT
0455     {
0456         .procname   = "lock_stat",
0457         .data       = &lock_stat,
0458         .maxlen     = sizeof(int),
0459         .mode       = 0644,
0460         .proc_handler   = proc_dointvec,
0461     },
0462 #endif
0463     {
0464         .procname   = "panic",
0465         .data       = &panic_timeout,
0466         .maxlen     = sizeof(int),
0467         .mode       = 0644,
0468         .proc_handler   = proc_dointvec,
0469     },
0470 #ifdef CONFIG_COREDUMP
0471     {
0472         .procname   = "core_uses_pid",
0473         .data       = &core_uses_pid,
0474         .maxlen     = sizeof(int),
0475         .mode       = 0644,
0476         .proc_handler   = proc_dointvec,
0477     },
0478     {
0479         .procname   = "core_pattern",
0480         .data       = core_pattern,
0481         .maxlen     = CORENAME_MAX_SIZE,
0482         .mode       = 0644,
0483         .proc_handler   = proc_dostring_coredump,
0484     },
0485     {
0486         .procname   = "core_pipe_limit",
0487         .data       = &core_pipe_limit,
0488         .maxlen     = sizeof(unsigned int),
0489         .mode       = 0644,
0490         .proc_handler   = proc_dointvec,
0491     },
0492 #endif
0493 #ifdef CONFIG_PROC_SYSCTL
0494     {
0495         .procname   = "tainted",
0496         .maxlen     = sizeof(long),
0497         .mode       = 0644,
0498         .proc_handler   = proc_taint,
0499     },
0500     {
0501         .procname   = "sysctl_writes_strict",
0502         .data       = &sysctl_writes_strict,
0503         .maxlen     = sizeof(int),
0504         .mode       = 0644,
0505         .proc_handler   = proc_dointvec_minmax,
0506         .extra1     = &neg_one,
0507         .extra2     = &one,
0508     },
0509 #endif
0510 #ifdef CONFIG_LATENCYTOP
0511     {
0512         .procname   = "latencytop",
0513         .data       = &latencytop_enabled,
0514         .maxlen     = sizeof(int),
0515         .mode       = 0644,
0516         .proc_handler   = sysctl_latencytop,
0517     },
0518 #endif
0519 #ifdef CONFIG_BLK_DEV_INITRD
0520     {
0521         .procname   = "real-root-dev",
0522         .data       = &real_root_dev,
0523         .maxlen     = sizeof(int),
0524         .mode       = 0644,
0525         .proc_handler   = proc_dointvec,
0526     },
0527 #endif
0528     {
0529         .procname   = "print-fatal-signals",
0530         .data       = &print_fatal_signals,
0531         .maxlen     = sizeof(int),
0532         .mode       = 0644,
0533         .proc_handler   = proc_dointvec,
0534     },
0535 #ifdef CONFIG_SPARC
0536     {
0537         .procname   = "reboot-cmd",
0538         .data       = reboot_command,
0539         .maxlen     = 256,
0540         .mode       = 0644,
0541         .proc_handler   = proc_dostring,
0542     },
0543     {
0544         .procname   = "stop-a",
0545         .data       = &stop_a_enabled,
0546         .maxlen     = sizeof (int),
0547         .mode       = 0644,
0548         .proc_handler   = proc_dointvec,
0549     },
0550     {
0551         .procname   = "scons-poweroff",
0552         .data       = &scons_pwroff,
0553         .maxlen     = sizeof (int),
0554         .mode       = 0644,
0555         .proc_handler   = proc_dointvec,
0556     },
0557 #endif
0558 #ifdef CONFIG_SPARC64
0559     {
0560         .procname   = "tsb-ratio",
0561         .data       = &sysctl_tsb_ratio,
0562         .maxlen     = sizeof (int),
0563         .mode       = 0644,
0564         .proc_handler   = proc_dointvec,
0565     },
0566 #endif
0567 #ifdef __hppa__
0568     {
0569         .procname   = "soft-power",
0570         .data       = &pwrsw_enabled,
0571         .maxlen     = sizeof (int),
0572         .mode       = 0644,
0573         .proc_handler   = proc_dointvec,
0574     },
0575 #endif
0576 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
0577     {
0578         .procname   = "unaligned-trap",
0579         .data       = &unaligned_enabled,
0580         .maxlen     = sizeof (int),
0581         .mode       = 0644,
0582         .proc_handler   = proc_dointvec,
0583     },
0584 #endif
0585     {
0586         .procname   = "ctrl-alt-del",
0587         .data       = &C_A_D,
0588         .maxlen     = sizeof(int),
0589         .mode       = 0644,
0590         .proc_handler   = proc_dointvec,
0591     },
0592 #ifdef CONFIG_FUNCTION_TRACER
0593     {
0594         .procname   = "ftrace_enabled",
0595         .data       = &ftrace_enabled,
0596         .maxlen     = sizeof(int),
0597         .mode       = 0644,
0598         .proc_handler   = ftrace_enable_sysctl,
0599     },
0600 #endif
0601 #ifdef CONFIG_STACK_TRACER
0602     {
0603         .procname   = "stack_tracer_enabled",
0604         .data       = &stack_tracer_enabled,
0605         .maxlen     = sizeof(int),
0606         .mode       = 0644,
0607         .proc_handler   = stack_trace_sysctl,
0608     },
0609 #endif
0610 #ifdef CONFIG_TRACING
0611     {
0612         .procname   = "ftrace_dump_on_oops",
0613         .data       = &ftrace_dump_on_oops,
0614         .maxlen     = sizeof(int),
0615         .mode       = 0644,
0616         .proc_handler   = proc_dointvec,
0617     },
0618     {
0619         .procname   = "traceoff_on_warning",
0620         .data       = &__disable_trace_on_warning,
0621         .maxlen     = sizeof(__disable_trace_on_warning),
0622         .mode       = 0644,
0623         .proc_handler   = proc_dointvec,
0624     },
0625     {
0626         .procname   = "tracepoint_printk",
0627         .data       = &tracepoint_printk,
0628         .maxlen     = sizeof(tracepoint_printk),
0629         .mode       = 0644,
0630         .proc_handler   = tracepoint_printk_sysctl,
0631     },
0632 #endif
0633 #ifdef CONFIG_KEXEC_CORE
0634     {
0635         .procname   = "kexec_load_disabled",
0636         .data       = &kexec_load_disabled,
0637         .maxlen     = sizeof(int),
0638         .mode       = 0644,
0639         /* only handle a transition from default "0" to "1" */
0640         .proc_handler   = proc_dointvec_minmax,
0641         .extra1     = &one,
0642         .extra2     = &one,
0643     },
0644 #endif
0645 #ifdef CONFIG_MODULES
0646     {
0647         .procname   = "modprobe",
0648         .data       = &modprobe_path,
0649         .maxlen     = KMOD_PATH_LEN,
0650         .mode       = 0644,
0651         .proc_handler   = proc_dostring,
0652     },
0653     {
0654         .procname   = "modules_disabled",
0655         .data       = &modules_disabled,
0656         .maxlen     = sizeof(int),
0657         .mode       = 0644,
0658         /* only handle a transition from default "0" to "1" */
0659         .proc_handler   = proc_dointvec_minmax,
0660         .extra1     = &one,
0661         .extra2     = &one,
0662     },
0663 #endif
0664 #ifdef CONFIG_UEVENT_HELPER
0665     {
0666         .procname   = "hotplug",
0667         .data       = &uevent_helper,
0668         .maxlen     = UEVENT_HELPER_PATH_LEN,
0669         .mode       = 0644,
0670         .proc_handler   = proc_dostring,
0671     },
0672 #endif
0673 #ifdef CONFIG_CHR_DEV_SG
0674     {
0675         .procname   = "sg-big-buff",
0676         .data       = &sg_big_buff,
0677         .maxlen     = sizeof (int),
0678         .mode       = 0444,
0679         .proc_handler   = proc_dointvec,
0680     },
0681 #endif
0682 #ifdef CONFIG_BSD_PROCESS_ACCT
0683     {
0684         .procname   = "acct",
0685         .data       = &acct_parm,
0686         .maxlen     = 3*sizeof(int),
0687         .mode       = 0644,
0688         .proc_handler   = proc_dointvec,
0689     },
0690 #endif
0691 #ifdef CONFIG_MAGIC_SYSRQ
0692     {
0693         .procname   = "sysrq",
0694         .data       = &__sysrq_enabled,
0695         .maxlen     = sizeof (int),
0696         .mode       = 0644,
0697         .proc_handler   = sysrq_sysctl_handler,
0698     },
0699 #endif
0700 #ifdef CONFIG_PROC_SYSCTL
0701     {
0702         .procname   = "cad_pid",
0703         .data       = NULL,
0704         .maxlen     = sizeof (int),
0705         .mode       = 0600,
0706         .proc_handler   = proc_do_cad_pid,
0707     },
0708 #endif
0709     {
0710         .procname   = "threads-max",
0711         .data       = NULL,
0712         .maxlen     = sizeof(int),
0713         .mode       = 0644,
0714         .proc_handler   = sysctl_max_threads,
0715     },
0716     {
0717         .procname   = "random",
0718         .mode       = 0555,
0719         .child      = random_table,
0720     },
0721     {
0722         .procname   = "usermodehelper",
0723         .mode       = 0555,
0724         .child      = usermodehelper_table,
0725     },
0726     {
0727         .procname   = "overflowuid",
0728         .data       = &overflowuid,
0729         .maxlen     = sizeof(int),
0730         .mode       = 0644,
0731         .proc_handler   = proc_dointvec_minmax,
0732         .extra1     = &minolduid,
0733         .extra2     = &maxolduid,
0734     },
0735     {
0736         .procname   = "overflowgid",
0737         .data       = &overflowgid,
0738         .maxlen     = sizeof(int),
0739         .mode       = 0644,
0740         .proc_handler   = proc_dointvec_minmax,
0741         .extra1     = &minolduid,
0742         .extra2     = &maxolduid,
0743     },
0744 #ifdef CONFIG_S390
0745 #ifdef CONFIG_MATHEMU
0746     {
0747         .procname   = "ieee_emulation_warnings",
0748         .data       = &sysctl_ieee_emulation_warnings,
0749         .maxlen     = sizeof(int),
0750         .mode       = 0644,
0751         .proc_handler   = proc_dointvec,
0752     },
0753 #endif
0754     {
0755         .procname   = "userprocess_debug",
0756         .data       = &show_unhandled_signals,
0757         .maxlen     = sizeof(int),
0758         .mode       = 0644,
0759         .proc_handler   = proc_dointvec,
0760     },
0761 #endif
0762     {
0763         .procname   = "pid_max",
0764         .data       = &pid_max,
0765         .maxlen     = sizeof (int),
0766         .mode       = 0644,
0767         .proc_handler   = proc_dointvec_minmax,
0768         .extra1     = &pid_max_min,
0769         .extra2     = &pid_max_max,
0770     },
0771     {
0772         .procname   = "panic_on_oops",
0773         .data       = &panic_on_oops,
0774         .maxlen     = sizeof(int),
0775         .mode       = 0644,
0776         .proc_handler   = proc_dointvec,
0777     },
0778 #if defined CONFIG_PRINTK
0779     {
0780         .procname   = "printk",
0781         .data       = &console_loglevel,
0782         .maxlen     = 4*sizeof(int),
0783         .mode       = 0644,
0784         .proc_handler   = proc_dointvec,
0785     },
0786     {
0787         .procname   = "printk_ratelimit",
0788         .data       = &printk_ratelimit_state.interval,
0789         .maxlen     = sizeof(int),
0790         .mode       = 0644,
0791         .proc_handler   = proc_dointvec_jiffies,
0792     },
0793     {
0794         .procname   = "printk_ratelimit_burst",
0795         .data       = &printk_ratelimit_state.burst,
0796         .maxlen     = sizeof(int),
0797         .mode       = 0644,
0798         .proc_handler   = proc_dointvec,
0799     },
0800     {
0801         .procname   = "printk_delay",
0802         .data       = &printk_delay_msec,
0803         .maxlen     = sizeof(int),
0804         .mode       = 0644,
0805         .proc_handler   = proc_dointvec_minmax,
0806         .extra1     = &zero,
0807         .extra2     = &ten_thousand,
0808     },
0809     {
0810         .procname   = "printk_devkmsg",
0811         .data       = devkmsg_log_str,
0812         .maxlen     = DEVKMSG_STR_MAX_SIZE,
0813         .mode       = 0644,
0814         .proc_handler   = devkmsg_sysctl_set_loglvl,
0815     },
0816     {
0817         .procname   = "dmesg_restrict",
0818         .data       = &dmesg_restrict,
0819         .maxlen     = sizeof(int),
0820         .mode       = 0644,
0821         .proc_handler   = proc_dointvec_minmax_sysadmin,
0822         .extra1     = &zero,
0823         .extra2     = &one,
0824     },
0825     {
0826         .procname   = "kptr_restrict",
0827         .data       = &kptr_restrict,
0828         .maxlen     = sizeof(int),
0829         .mode       = 0644,
0830         .proc_handler   = proc_dointvec_minmax_sysadmin,
0831         .extra1     = &zero,
0832         .extra2     = &two,
0833     },
0834 #endif
0835     {
0836         .procname   = "ngroups_max",
0837         .data       = &ngroups_max,
0838         .maxlen     = sizeof (int),
0839         .mode       = 0444,
0840         .proc_handler   = proc_dointvec,
0841     },
0842     {
0843         .procname   = "cap_last_cap",
0844         .data       = (void *)&cap_last_cap,
0845         .maxlen     = sizeof(int),
0846         .mode       = 0444,
0847         .proc_handler   = proc_dointvec,
0848     },
0849 #if defined(CONFIG_LOCKUP_DETECTOR)
0850     {
0851         .procname       = "watchdog",
0852         .data           = &watchdog_user_enabled,
0853         .maxlen         = sizeof (int),
0854         .mode           = 0644,
0855         .proc_handler   = proc_watchdog,
0856         .extra1     = &zero,
0857         .extra2     = &one,
0858     },
0859     {
0860         .procname   = "watchdog_thresh",
0861         .data       = &watchdog_thresh,
0862         .maxlen     = sizeof(int),
0863         .mode       = 0644,
0864         .proc_handler   = proc_watchdog_thresh,
0865         .extra1     = &zero,
0866         .extra2     = &sixty,
0867     },
0868     {
0869         .procname       = "nmi_watchdog",
0870         .data           = &nmi_watchdog_enabled,
0871         .maxlen         = sizeof (int),
0872         .mode           = 0644,
0873         .proc_handler   = proc_nmi_watchdog,
0874         .extra1     = &zero,
0875 #if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
0876         .extra2     = &one,
0877 #else
0878         .extra2     = &zero,
0879 #endif
0880     },
0881     {
0882         .procname       = "soft_watchdog",
0883         .data           = &soft_watchdog_enabled,
0884         .maxlen         = sizeof (int),
0885         .mode           = 0644,
0886         .proc_handler   = proc_soft_watchdog,
0887         .extra1     = &zero,
0888         .extra2     = &one,
0889     },
0890     {
0891         .procname   = "watchdog_cpumask",
0892         .data       = &watchdog_cpumask_bits,
0893         .maxlen     = NR_CPUS,
0894         .mode       = 0644,
0895         .proc_handler   = proc_watchdog_cpumask,
0896     },
0897     {
0898         .procname   = "softlockup_panic",
0899         .data       = &softlockup_panic,
0900         .maxlen     = sizeof(int),
0901         .mode       = 0644,
0902         .proc_handler   = proc_dointvec_minmax,
0903         .extra1     = &zero,
0904         .extra2     = &one,
0905     },
0906 #ifdef CONFIG_HARDLOCKUP_DETECTOR
0907     {
0908         .procname   = "hardlockup_panic",
0909         .data       = &hardlockup_panic,
0910         .maxlen     = sizeof(int),
0911         .mode       = 0644,
0912         .proc_handler   = proc_dointvec_minmax,
0913         .extra1     = &zero,
0914         .extra2     = &one,
0915     },
0916 #endif
0917 #ifdef CONFIG_SMP
0918     {
0919         .procname   = "softlockup_all_cpu_backtrace",
0920         .data       = &sysctl_softlockup_all_cpu_backtrace,
0921         .maxlen     = sizeof(int),
0922         .mode       = 0644,
0923         .proc_handler   = proc_dointvec_minmax,
0924         .extra1     = &zero,
0925         .extra2     = &one,
0926     },
0927     {
0928         .procname   = "hardlockup_all_cpu_backtrace",
0929         .data       = &sysctl_hardlockup_all_cpu_backtrace,
0930         .maxlen     = sizeof(int),
0931         .mode       = 0644,
0932         .proc_handler   = proc_dointvec_minmax,
0933         .extra1     = &zero,
0934         .extra2     = &one,
0935     },
0936 #endif /* CONFIG_SMP */
0937 #endif
0938 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
0939     {
0940         .procname       = "unknown_nmi_panic",
0941         .data           = &unknown_nmi_panic,
0942         .maxlen         = sizeof (int),
0943         .mode           = 0644,
0944         .proc_handler   = proc_dointvec,
0945     },
0946 #endif
0947 #if defined(CONFIG_X86)
0948     {
0949         .procname   = "panic_on_unrecovered_nmi",
0950         .data       = &panic_on_unrecovered_nmi,
0951         .maxlen     = sizeof(int),
0952         .mode       = 0644,
0953         .proc_handler   = proc_dointvec,
0954     },
0955     {
0956         .procname   = "panic_on_io_nmi",
0957         .data       = &panic_on_io_nmi,
0958         .maxlen     = sizeof(int),
0959         .mode       = 0644,
0960         .proc_handler   = proc_dointvec,
0961     },
0962 #ifdef CONFIG_DEBUG_STACKOVERFLOW
0963     {
0964         .procname   = "panic_on_stackoverflow",
0965         .data       = &sysctl_panic_on_stackoverflow,
0966         .maxlen     = sizeof(int),
0967         .mode       = 0644,
0968         .proc_handler   = proc_dointvec,
0969     },
0970 #endif
0971     {
0972         .procname   = "bootloader_type",
0973         .data       = &bootloader_type,
0974         .maxlen     = sizeof (int),
0975         .mode       = 0444,
0976         .proc_handler   = proc_dointvec,
0977     },
0978     {
0979         .procname   = "bootloader_version",
0980         .data       = &bootloader_version,
0981         .maxlen     = sizeof (int),
0982         .mode       = 0444,
0983         .proc_handler   = proc_dointvec,
0984     },
0985     {
0986         .procname   = "io_delay_type",
0987         .data       = &io_delay_type,
0988         .maxlen     = sizeof(int),
0989         .mode       = 0644,
0990         .proc_handler   = proc_dointvec,
0991     },
0992 #endif
0993 #if defined(CONFIG_MMU)
0994     {
0995         .procname   = "randomize_va_space",
0996         .data       = &randomize_va_space,
0997         .maxlen     = sizeof(int),
0998         .mode       = 0644,
0999         .proc_handler   = proc_dointvec,
1000     },
1001 #endif
1002 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
1003     {
1004         .procname   = "spin_retry",
1005         .data       = &spin_retry,
1006         .maxlen     = sizeof (int),
1007         .mode       = 0644,
1008         .proc_handler   = proc_dointvec,
1009     },
1010 #endif
1011 #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1012     {
1013         .procname   = "acpi_video_flags",
1014         .data       = &acpi_realmode_flags,
1015         .maxlen     = sizeof (unsigned long),
1016         .mode       = 0644,
1017         .proc_handler   = proc_doulongvec_minmax,
1018     },
1019 #endif
1020 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1021     {
1022         .procname   = "ignore-unaligned-usertrap",
1023         .data       = &no_unaligned_warning,
1024         .maxlen     = sizeof (int),
1025         .mode       = 0644,
1026         .proc_handler   = proc_dointvec,
1027     },
1028 #endif
1029 #ifdef CONFIG_IA64
1030     {
1031         .procname   = "unaligned-dump-stack",
1032         .data       = &unaligned_dump_stack,
1033         .maxlen     = sizeof (int),
1034         .mode       = 0644,
1035         .proc_handler   = proc_dointvec,
1036     },
1037 #endif
1038 #ifdef CONFIG_DETECT_HUNG_TASK
1039     {
1040         .procname   = "hung_task_panic",
1041         .data       = &sysctl_hung_task_panic,
1042         .maxlen     = sizeof(int),
1043         .mode       = 0644,
1044         .proc_handler   = proc_dointvec_minmax,
1045         .extra1     = &zero,
1046         .extra2     = &one,
1047     },
1048     {
1049         .procname   = "hung_task_check_count",
1050         .data       = &sysctl_hung_task_check_count,
1051         .maxlen     = sizeof(int),
1052         .mode       = 0644,
1053         .proc_handler   = proc_dointvec_minmax,
1054         .extra1     = &zero,
1055     },
1056     {
1057         .procname   = "hung_task_timeout_secs",
1058         .data       = &sysctl_hung_task_timeout_secs,
1059         .maxlen     = sizeof(unsigned long),
1060         .mode       = 0644,
1061         .proc_handler   = proc_dohung_task_timeout_secs,
1062         .extra2     = &hung_task_timeout_max,
1063     },
1064     {
1065         .procname   = "hung_task_warnings",
1066         .data       = &sysctl_hung_task_warnings,
1067         .maxlen     = sizeof(int),
1068         .mode       = 0644,
1069         .proc_handler   = proc_dointvec_minmax,
1070         .extra1     = &neg_one,
1071     },
1072 #endif
1073 #ifdef CONFIG_RT_MUTEXES
1074     {
1075         .procname   = "max_lock_depth",
1076         .data       = &max_lock_depth,
1077         .maxlen     = sizeof(int),
1078         .mode       = 0644,
1079         .proc_handler   = proc_dointvec,
1080     },
1081 #endif
1082     {
1083         .procname   = "poweroff_cmd",
1084         .data       = &poweroff_cmd,
1085         .maxlen     = POWEROFF_CMD_PATH_LEN,
1086         .mode       = 0644,
1087         .proc_handler   = proc_dostring,
1088     },
1089 #ifdef CONFIG_KEYS
1090     {
1091         .procname   = "keys",
1092         .mode       = 0555,
1093         .child      = key_sysctls,
1094     },
1095 #endif
1096 #ifdef CONFIG_PERF_EVENTS
1097     /*
1098      * User-space scripts rely on the existence of this file
1099      * as a feature check for perf_events being enabled.
1100      *
1101      * So it's an ABI, do not remove!
1102      */
1103     {
1104         .procname   = "perf_event_paranoid",
1105         .data       = &sysctl_perf_event_paranoid,
1106         .maxlen     = sizeof(sysctl_perf_event_paranoid),
1107         .mode       = 0644,
1108         .proc_handler   = proc_dointvec,
1109     },
1110     {
1111         .procname   = "perf_event_mlock_kb",
1112         .data       = &sysctl_perf_event_mlock,
1113         .maxlen     = sizeof(sysctl_perf_event_mlock),
1114         .mode       = 0644,
1115         .proc_handler   = proc_dointvec,
1116     },
1117     {
1118         .procname   = "perf_event_max_sample_rate",
1119         .data       = &sysctl_perf_event_sample_rate,
1120         .maxlen     = sizeof(sysctl_perf_event_sample_rate),
1121         .mode       = 0644,
1122         .proc_handler   = perf_proc_update_handler,
1123         .extra1     = &one,
1124     },
1125     {
1126         .procname   = "perf_cpu_time_max_percent",
1127         .data       = &sysctl_perf_cpu_time_max_percent,
1128         .maxlen     = sizeof(sysctl_perf_cpu_time_max_percent),
1129         .mode       = 0644,
1130         .proc_handler   = perf_cpu_time_max_percent_handler,
1131         .extra1     = &zero,
1132         .extra2     = &one_hundred,
1133     },
1134     {
1135         .procname   = "perf_event_max_stack",
1136         .data       = &sysctl_perf_event_max_stack,
1137         .maxlen     = sizeof(sysctl_perf_event_max_stack),
1138         .mode       = 0644,
1139         .proc_handler   = perf_event_max_stack_handler,
1140         .extra1     = &zero,
1141         .extra2     = &six_hundred_forty_kb,
1142     },
1143     {
1144         .procname   = "perf_event_max_contexts_per_stack",
1145         .data       = &sysctl_perf_event_max_contexts_per_stack,
1146         .maxlen     = sizeof(sysctl_perf_event_max_contexts_per_stack),
1147         .mode       = 0644,
1148         .proc_handler   = perf_event_max_stack_handler,
1149         .extra1     = &zero,
1150         .extra2     = &one_thousand,
1151     },
1152 #endif
1153 #ifdef CONFIG_KMEMCHECK
1154     {
1155         .procname   = "kmemcheck",
1156         .data       = &kmemcheck_enabled,
1157         .maxlen     = sizeof(int),
1158         .mode       = 0644,
1159         .proc_handler   = proc_dointvec,
1160     },
1161 #endif
1162     {
1163         .procname   = "panic_on_warn",
1164         .data       = &panic_on_warn,
1165         .maxlen     = sizeof(int),
1166         .mode       = 0644,
1167         .proc_handler   = proc_dointvec_minmax,
1168         .extra1     = &zero,
1169         .extra2     = &one,
1170     },
1171 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
1172     {
1173         .procname   = "timer_migration",
1174         .data       = &sysctl_timer_migration,
1175         .maxlen     = sizeof(unsigned int),
1176         .mode       = 0644,
1177         .proc_handler   = timer_migration_handler,
1178     },
1179 #endif
1180 #ifdef CONFIG_BPF_SYSCALL
1181     {
1182         .procname   = "unprivileged_bpf_disabled",
1183         .data       = &sysctl_unprivileged_bpf_disabled,
1184         .maxlen     = sizeof(sysctl_unprivileged_bpf_disabled),
1185         .mode       = 0644,
1186         /* only handle a transition from default "0" to "1" */
1187         .proc_handler   = proc_dointvec_minmax,
1188         .extra1     = &one,
1189         .extra2     = &one,
1190     },
1191 #endif
1192 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
1193     {
1194         .procname   = "panic_on_rcu_stall",
1195         .data       = &sysctl_panic_on_rcu_stall,
1196         .maxlen     = sizeof(sysctl_panic_on_rcu_stall),
1197         .mode       = 0644,
1198         .proc_handler   = proc_dointvec_minmax,
1199         .extra1     = &zero,
1200         .extra2     = &one,
1201     },
1202 #endif
1203     { }
1204 };
1205 
1206 static struct ctl_table vm_table[] = {
1207     {
1208         .procname   = "overcommit_memory",
1209         .data       = &sysctl_overcommit_memory,
1210         .maxlen     = sizeof(sysctl_overcommit_memory),
1211         .mode       = 0644,
1212         .proc_handler   = proc_dointvec_minmax,
1213         .extra1     = &zero,
1214         .extra2     = &two,
1215     },
1216     {
1217         .procname   = "panic_on_oom",
1218         .data       = &sysctl_panic_on_oom,
1219         .maxlen     = sizeof(sysctl_panic_on_oom),
1220         .mode       = 0644,
1221         .proc_handler   = proc_dointvec_minmax,
1222         .extra1     = &zero,
1223         .extra2     = &two,
1224     },
1225     {
1226         .procname   = "oom_kill_allocating_task",
1227         .data       = &sysctl_oom_kill_allocating_task,
1228         .maxlen     = sizeof(sysctl_oom_kill_allocating_task),
1229         .mode       = 0644,
1230         .proc_handler   = proc_dointvec,
1231     },
1232     {
1233         .procname   = "oom_dump_tasks",
1234         .data       = &sysctl_oom_dump_tasks,
1235         .maxlen     = sizeof(sysctl_oom_dump_tasks),
1236         .mode       = 0644,
1237         .proc_handler   = proc_dointvec,
1238     },
1239     {
1240         .procname   = "overcommit_ratio",
1241         .data       = &sysctl_overcommit_ratio,
1242         .maxlen     = sizeof(sysctl_overcommit_ratio),
1243         .mode       = 0644,
1244         .proc_handler   = overcommit_ratio_handler,
1245     },
1246     {
1247         .procname   = "overcommit_kbytes",
1248         .data       = &sysctl_overcommit_kbytes,
1249         .maxlen     = sizeof(sysctl_overcommit_kbytes),
1250         .mode       = 0644,
1251         .proc_handler   = overcommit_kbytes_handler,
1252     },
1253     {
1254         .procname   = "page-cluster", 
1255         .data       = &page_cluster,
1256         .maxlen     = sizeof(int),
1257         .mode       = 0644,
1258         .proc_handler   = proc_dointvec_minmax,
1259         .extra1     = &zero,
1260     },
1261     {
1262         .procname   = "dirty_background_ratio",
1263         .data       = &dirty_background_ratio,
1264         .maxlen     = sizeof(dirty_background_ratio),
1265         .mode       = 0644,
1266         .proc_handler   = dirty_background_ratio_handler,
1267         .extra1     = &zero,
1268         .extra2     = &one_hundred,
1269     },
1270     {
1271         .procname   = "dirty_background_bytes",
1272         .data       = &dirty_background_bytes,
1273         .maxlen     = sizeof(dirty_background_bytes),
1274         .mode       = 0644,
1275         .proc_handler   = dirty_background_bytes_handler,
1276         .extra1     = &one_ul,
1277     },
1278     {
1279         .procname   = "dirty_ratio",
1280         .data       = &vm_dirty_ratio,
1281         .maxlen     = sizeof(vm_dirty_ratio),
1282         .mode       = 0644,
1283         .proc_handler   = dirty_ratio_handler,
1284         .extra1     = &zero,
1285         .extra2     = &one_hundred,
1286     },
1287     {
1288         .procname   = "dirty_bytes",
1289         .data       = &vm_dirty_bytes,
1290         .maxlen     = sizeof(vm_dirty_bytes),
1291         .mode       = 0644,
1292         .proc_handler   = dirty_bytes_handler,
1293         .extra1     = &dirty_bytes_min,
1294     },
1295     {
1296         .procname   = "dirty_writeback_centisecs",
1297         .data       = &dirty_writeback_interval,
1298         .maxlen     = sizeof(dirty_writeback_interval),
1299         .mode       = 0644,
1300         .proc_handler   = dirty_writeback_centisecs_handler,
1301     },
1302     {
1303         .procname   = "dirty_expire_centisecs",
1304         .data       = &dirty_expire_interval,
1305         .maxlen     = sizeof(dirty_expire_interval),
1306         .mode       = 0644,
1307         .proc_handler   = proc_dointvec_minmax,
1308         .extra1     = &zero,
1309     },
1310     {
1311         .procname   = "dirtytime_expire_seconds",
1312         .data       = &dirtytime_expire_interval,
1313         .maxlen     = sizeof(dirty_expire_interval),
1314         .mode       = 0644,
1315         .proc_handler   = dirtytime_interval_handler,
1316         .extra1     = &zero,
1317     },
1318     {
1319         .procname       = "nr_pdflush_threads",
1320         .mode           = 0444 /* read-only */,
1321         .proc_handler   = pdflush_proc_obsolete,
1322     },
1323     {
1324         .procname   = "swappiness",
1325         .data       = &vm_swappiness,
1326         .maxlen     = sizeof(vm_swappiness),
1327         .mode       = 0644,
1328         .proc_handler   = proc_dointvec_minmax,
1329         .extra1     = &zero,
1330         .extra2     = &one_hundred,
1331     },
1332 #ifdef CONFIG_HUGETLB_PAGE
1333     {
1334         .procname   = "nr_hugepages",
1335         .data       = NULL,
1336         .maxlen     = sizeof(unsigned long),
1337         .mode       = 0644,
1338         .proc_handler   = hugetlb_sysctl_handler,
1339     },
1340 #ifdef CONFIG_NUMA
1341     {
1342         .procname       = "nr_hugepages_mempolicy",
1343         .data           = NULL,
1344         .maxlen         = sizeof(unsigned long),
1345         .mode           = 0644,
1346         .proc_handler   = &hugetlb_mempolicy_sysctl_handler,
1347     },
1348 #endif
1349      {
1350         .procname   = "hugetlb_shm_group",
1351         .data       = &sysctl_hugetlb_shm_group,
1352         .maxlen     = sizeof(gid_t),
1353         .mode       = 0644,
1354         .proc_handler   = proc_dointvec,
1355      },
1356      {
1357         .procname   = "hugepages_treat_as_movable",
1358         .data       = &hugepages_treat_as_movable,
1359         .maxlen     = sizeof(int),
1360         .mode       = 0644,
1361         .proc_handler   = proc_dointvec,
1362     },
1363     {
1364         .procname   = "nr_overcommit_hugepages",
1365         .data       = NULL,
1366         .maxlen     = sizeof(unsigned long),
1367         .mode       = 0644,
1368         .proc_handler   = hugetlb_overcommit_handler,
1369     },
1370 #endif
1371     {
1372         .procname   = "lowmem_reserve_ratio",
1373         .data       = &sysctl_lowmem_reserve_ratio,
1374         .maxlen     = sizeof(sysctl_lowmem_reserve_ratio),
1375         .mode       = 0644,
1376         .proc_handler   = lowmem_reserve_ratio_sysctl_handler,
1377     },
1378     {
1379         .procname   = "drop_caches",
1380         .data       = &sysctl_drop_caches,
1381         .maxlen     = sizeof(int),
1382         .mode       = 0644,
1383         .proc_handler   = drop_caches_sysctl_handler,
1384         .extra1     = &one,
1385         .extra2     = &four,
1386     },
1387 #ifdef CONFIG_COMPACTION
1388     {
1389         .procname   = "compact_memory",
1390         .data       = &sysctl_compact_memory,
1391         .maxlen     = sizeof(int),
1392         .mode       = 0200,
1393         .proc_handler   = sysctl_compaction_handler,
1394     },
1395     {
1396         .procname   = "extfrag_threshold",
1397         .data       = &sysctl_extfrag_threshold,
1398         .maxlen     = sizeof(int),
1399         .mode       = 0644,
1400         .proc_handler   = sysctl_extfrag_handler,
1401         .extra1     = &min_extfrag_threshold,
1402         .extra2     = &max_extfrag_threshold,
1403     },
1404     {
1405         .procname   = "compact_unevictable_allowed",
1406         .data       = &sysctl_compact_unevictable_allowed,
1407         .maxlen     = sizeof(int),
1408         .mode       = 0644,
1409         .proc_handler   = proc_dointvec,
1410         .extra1     = &zero,
1411         .extra2     = &one,
1412     },
1413 
1414 #endif /* CONFIG_COMPACTION */
1415     {
1416         .procname   = "min_free_kbytes",
1417         .data       = &min_free_kbytes,
1418         .maxlen     = sizeof(min_free_kbytes),
1419         .mode       = 0644,
1420         .proc_handler   = min_free_kbytes_sysctl_handler,
1421         .extra1     = &zero,
1422     },
1423     {
1424         .procname   = "watermark_scale_factor",
1425         .data       = &watermark_scale_factor,
1426         .maxlen     = sizeof(watermark_scale_factor),
1427         .mode       = 0644,
1428         .proc_handler   = watermark_scale_factor_sysctl_handler,
1429         .extra1     = &one,
1430         .extra2     = &one_thousand,
1431     },
1432     {
1433         .procname   = "percpu_pagelist_fraction",
1434         .data       = &percpu_pagelist_fraction,
1435         .maxlen     = sizeof(percpu_pagelist_fraction),
1436         .mode       = 0644,
1437         .proc_handler   = percpu_pagelist_fraction_sysctl_handler,
1438         .extra1     = &zero,
1439     },
1440 #ifdef CONFIG_MMU
1441     {
1442         .procname   = "max_map_count",
1443         .data       = &sysctl_max_map_count,
1444         .maxlen     = sizeof(sysctl_max_map_count),
1445         .mode       = 0644,
1446         .proc_handler   = proc_dointvec_minmax,
1447         .extra1     = &zero,
1448     },
1449 #else
1450     {
1451         .procname   = "nr_trim_pages",
1452         .data       = &sysctl_nr_trim_pages,
1453         .maxlen     = sizeof(sysctl_nr_trim_pages),
1454         .mode       = 0644,
1455         .proc_handler   = proc_dointvec_minmax,
1456         .extra1     = &zero,
1457     },
1458 #endif
1459     {
1460         .procname   = "laptop_mode",
1461         .data       = &laptop_mode,
1462         .maxlen     = sizeof(laptop_mode),
1463         .mode       = 0644,
1464         .proc_handler   = proc_dointvec_jiffies,
1465     },
1466     {
1467         .procname   = "block_dump",
1468         .data       = &block_dump,
1469         .maxlen     = sizeof(block_dump),
1470         .mode       = 0644,
1471         .proc_handler   = proc_dointvec,
1472         .extra1     = &zero,
1473     },
1474     {
1475         .procname   = "vfs_cache_pressure",
1476         .data       = &sysctl_vfs_cache_pressure,
1477         .maxlen     = sizeof(sysctl_vfs_cache_pressure),
1478         .mode       = 0644,
1479         .proc_handler   = proc_dointvec,
1480         .extra1     = &zero,
1481     },
1482 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1483     {
1484         .procname   = "legacy_va_layout",
1485         .data       = &sysctl_legacy_va_layout,
1486         .maxlen     = sizeof(sysctl_legacy_va_layout),
1487         .mode       = 0644,
1488         .proc_handler   = proc_dointvec,
1489         .extra1     = &zero,
1490     },
1491 #endif
1492 #ifdef CONFIG_NUMA
1493     {
1494         .procname   = "zone_reclaim_mode",
1495         .data       = &node_reclaim_mode,
1496         .maxlen     = sizeof(node_reclaim_mode),
1497         .mode       = 0644,
1498         .proc_handler   = proc_dointvec,
1499         .extra1     = &zero,
1500     },
1501     {
1502         .procname   = "min_unmapped_ratio",
1503         .data       = &sysctl_min_unmapped_ratio,
1504         .maxlen     = sizeof(sysctl_min_unmapped_ratio),
1505         .mode       = 0644,
1506         .proc_handler   = sysctl_min_unmapped_ratio_sysctl_handler,
1507         .extra1     = &zero,
1508         .extra2     = &one_hundred,
1509     },
1510     {
1511         .procname   = "min_slab_ratio",
1512         .data       = &sysctl_min_slab_ratio,
1513         .maxlen     = sizeof(sysctl_min_slab_ratio),
1514         .mode       = 0644,
1515         .proc_handler   = sysctl_min_slab_ratio_sysctl_handler,
1516         .extra1     = &zero,
1517         .extra2     = &one_hundred,
1518     },
1519 #endif
1520 #ifdef CONFIG_SMP
1521     {
1522         .procname   = "stat_interval",
1523         .data       = &sysctl_stat_interval,
1524         .maxlen     = sizeof(sysctl_stat_interval),
1525         .mode       = 0644,
1526         .proc_handler   = proc_dointvec_jiffies,
1527     },
1528     {
1529         .procname   = "stat_refresh",
1530         .data       = NULL,
1531         .maxlen     = 0,
1532         .mode       = 0600,
1533         .proc_handler   = vmstat_refresh,
1534     },
1535 #endif
1536 #ifdef CONFIG_MMU
1537     {
1538         .procname   = "mmap_min_addr",
1539         .data       = &dac_mmap_min_addr,
1540         .maxlen     = sizeof(unsigned long),
1541         .mode       = 0644,
1542         .proc_handler   = mmap_min_addr_handler,
1543     },
1544 #endif
1545 #ifdef CONFIG_NUMA
1546     {
1547         .procname   = "numa_zonelist_order",
1548         .data       = &numa_zonelist_order,
1549         .maxlen     = NUMA_ZONELIST_ORDER_LEN,
1550         .mode       = 0644,
1551         .proc_handler   = numa_zonelist_order_handler,
1552     },
1553 #endif
1554 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
1555    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1556     {
1557         .procname   = "vdso_enabled",
1558 #ifdef CONFIG_X86_32
1559         .data       = &vdso32_enabled,
1560         .maxlen     = sizeof(vdso32_enabled),
1561 #else
1562         .data       = &vdso_enabled,
1563         .maxlen     = sizeof(vdso_enabled),
1564 #endif
1565         .mode       = 0644,
1566         .proc_handler   = proc_dointvec,
1567         .extra1     = &zero,
1568     },
1569 #endif
1570 #ifdef CONFIG_HIGHMEM
1571     {
1572         .procname   = "highmem_is_dirtyable",
1573         .data       = &vm_highmem_is_dirtyable,
1574         .maxlen     = sizeof(vm_highmem_is_dirtyable),
1575         .mode       = 0644,
1576         .proc_handler   = proc_dointvec_minmax,
1577         .extra1     = &zero,
1578         .extra2     = &one,
1579     },
1580 #endif
1581 #ifdef CONFIG_MEMORY_FAILURE
1582     {
1583         .procname   = "memory_failure_early_kill",
1584         .data       = &sysctl_memory_failure_early_kill,
1585         .maxlen     = sizeof(sysctl_memory_failure_early_kill),
1586         .mode       = 0644,
1587         .proc_handler   = proc_dointvec_minmax,
1588         .extra1     = &zero,
1589         .extra2     = &one,
1590     },
1591     {
1592         .procname   = "memory_failure_recovery",
1593         .data       = &sysctl_memory_failure_recovery,
1594         .maxlen     = sizeof(sysctl_memory_failure_recovery),
1595         .mode       = 0644,
1596         .proc_handler   = proc_dointvec_minmax,
1597         .extra1     = &zero,
1598         .extra2     = &one,
1599     },
1600 #endif
1601     {
1602         .procname   = "user_reserve_kbytes",
1603         .data       = &sysctl_user_reserve_kbytes,
1604         .maxlen     = sizeof(sysctl_user_reserve_kbytes),
1605         .mode       = 0644,
1606         .proc_handler   = proc_doulongvec_minmax,
1607     },
1608     {
1609         .procname   = "admin_reserve_kbytes",
1610         .data       = &sysctl_admin_reserve_kbytes,
1611         .maxlen     = sizeof(sysctl_admin_reserve_kbytes),
1612         .mode       = 0644,
1613         .proc_handler   = proc_doulongvec_minmax,
1614     },
1615 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
1616     {
1617         .procname   = "mmap_rnd_bits",
1618         .data       = &mmap_rnd_bits,
1619         .maxlen     = sizeof(mmap_rnd_bits),
1620         .mode       = 0600,
1621         .proc_handler   = proc_dointvec_minmax,
1622         .extra1     = (void *)&mmap_rnd_bits_min,
1623         .extra2     = (void *)&mmap_rnd_bits_max,
1624     },
1625 #endif
1626 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
1627     {
1628         .procname   = "mmap_rnd_compat_bits",
1629         .data       = &mmap_rnd_compat_bits,
1630         .maxlen     = sizeof(mmap_rnd_compat_bits),
1631         .mode       = 0600,
1632         .proc_handler   = proc_dointvec_minmax,
1633         .extra1     = (void *)&mmap_rnd_compat_bits_min,
1634         .extra2     = (void *)&mmap_rnd_compat_bits_max,
1635     },
1636 #endif
1637     { }
1638 };
1639 
1640 static struct ctl_table fs_table[] = {
1641     {
1642         .procname   = "inode-nr",
1643         .data       = &inodes_stat,
1644         .maxlen     = 2*sizeof(long),
1645         .mode       = 0444,
1646         .proc_handler   = proc_nr_inodes,
1647     },
1648     {
1649         .procname   = "inode-state",
1650         .data       = &inodes_stat,
1651         .maxlen     = 7*sizeof(long),
1652         .mode       = 0444,
1653         .proc_handler   = proc_nr_inodes,
1654     },
1655     {
1656         .procname   = "file-nr",
1657         .data       = &files_stat,
1658         .maxlen     = sizeof(files_stat),
1659         .mode       = 0444,
1660         .proc_handler   = proc_nr_files,
1661     },
1662     {
1663         .procname   = "file-max",
1664         .data       = &files_stat.max_files,
1665         .maxlen     = sizeof(files_stat.max_files),
1666         .mode       = 0644,
1667         .proc_handler   = proc_doulongvec_minmax,
1668     },
1669     {
1670         .procname   = "nr_open",
1671         .data       = &sysctl_nr_open,
1672         .maxlen     = sizeof(unsigned int),
1673         .mode       = 0644,
1674         .proc_handler   = proc_dointvec_minmax,
1675         .extra1     = &sysctl_nr_open_min,
1676         .extra2     = &sysctl_nr_open_max,
1677     },
1678     {
1679         .procname   = "dentry-state",
1680         .data       = &dentry_stat,
1681         .maxlen     = 6*sizeof(long),
1682         .mode       = 0444,
1683         .proc_handler   = proc_nr_dentry,
1684     },
1685     {
1686         .procname   = "overflowuid",
1687         .data       = &fs_overflowuid,
1688         .maxlen     = sizeof(int),
1689         .mode       = 0644,
1690         .proc_handler   = proc_dointvec_minmax,
1691         .extra1     = &minolduid,
1692         .extra2     = &maxolduid,
1693     },
1694     {
1695         .procname   = "overflowgid",
1696         .data       = &fs_overflowgid,
1697         .maxlen     = sizeof(int),
1698         .mode       = 0644,
1699         .proc_handler   = proc_dointvec_minmax,
1700         .extra1     = &minolduid,
1701         .extra2     = &maxolduid,
1702     },
1703 #ifdef CONFIG_FILE_LOCKING
1704     {
1705         .procname   = "leases-enable",
1706         .data       = &leases_enable,
1707         .maxlen     = sizeof(int),
1708         .mode       = 0644,
1709         .proc_handler   = proc_dointvec,
1710     },
1711 #endif
1712 #ifdef CONFIG_DNOTIFY
1713     {
1714         .procname   = "dir-notify-enable",
1715         .data       = &dir_notify_enable,
1716         .maxlen     = sizeof(int),
1717         .mode       = 0644,
1718         .proc_handler   = proc_dointvec,
1719     },
1720 #endif
1721 #ifdef CONFIG_MMU
1722 #ifdef CONFIG_FILE_LOCKING
1723     {
1724         .procname   = "lease-break-time",
1725         .data       = &lease_break_time,
1726         .maxlen     = sizeof(int),
1727         .mode       = 0644,
1728         .proc_handler   = proc_dointvec,
1729     },
1730 #endif
1731 #ifdef CONFIG_AIO
1732     {
1733         .procname   = "aio-nr",
1734         .data       = &aio_nr,
1735         .maxlen     = sizeof(aio_nr),
1736         .mode       = 0444,
1737         .proc_handler   = proc_doulongvec_minmax,
1738     },
1739     {
1740         .procname   = "aio-max-nr",
1741         .data       = &aio_max_nr,
1742         .maxlen     = sizeof(aio_max_nr),
1743         .mode       = 0644,
1744         .proc_handler   = proc_doulongvec_minmax,
1745     },
1746 #endif /* CONFIG_AIO */
1747 #ifdef CONFIG_INOTIFY_USER
1748     {
1749         .procname   = "inotify",
1750         .mode       = 0555,
1751         .child      = inotify_table,
1752     },
1753 #endif  
1754 #ifdef CONFIG_EPOLL
1755     {
1756         .procname   = "epoll",
1757         .mode       = 0555,
1758         .child      = epoll_table,
1759     },
1760 #endif
1761 #endif
1762     {
1763         .procname   = "protected_symlinks",
1764         .data       = &sysctl_protected_symlinks,
1765         .maxlen     = sizeof(int),
1766         .mode       = 0600,
1767         .proc_handler   = proc_dointvec_minmax,
1768         .extra1     = &zero,
1769         .extra2     = &one,
1770     },
1771     {
1772         .procname   = "protected_hardlinks",
1773         .data       = &sysctl_protected_hardlinks,
1774         .maxlen     = sizeof(int),
1775         .mode       = 0600,
1776         .proc_handler   = proc_dointvec_minmax,
1777         .extra1     = &zero,
1778         .extra2     = &one,
1779     },
1780     {
1781         .procname   = "suid_dumpable",
1782         .data       = &suid_dumpable,
1783         .maxlen     = sizeof(int),
1784         .mode       = 0644,
1785         .proc_handler   = proc_dointvec_minmax_coredump,
1786         .extra1     = &zero,
1787         .extra2     = &two,
1788     },
1789 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1790     {
1791         .procname   = "binfmt_misc",
1792         .mode       = 0555,
1793         .child      = sysctl_mount_point,
1794     },
1795 #endif
1796     {
1797         .procname   = "pipe-max-size",
1798         .data       = &pipe_max_size,
1799         .maxlen     = sizeof(int),
1800         .mode       = 0644,
1801         .proc_handler   = &pipe_proc_fn,
1802         .extra1     = &pipe_min_size,
1803     },
1804     {
1805         .procname   = "pipe-user-pages-hard",
1806         .data       = &pipe_user_pages_hard,
1807         .maxlen     = sizeof(pipe_user_pages_hard),
1808         .mode       = 0644,
1809         .proc_handler   = proc_doulongvec_minmax,
1810     },
1811     {
1812         .procname   = "pipe-user-pages-soft",
1813         .data       = &pipe_user_pages_soft,
1814         .maxlen     = sizeof(pipe_user_pages_soft),
1815         .mode       = 0644,
1816         .proc_handler   = proc_doulongvec_minmax,
1817     },
1818     {
1819         .procname   = "mount-max",
1820         .data       = &sysctl_mount_max,
1821         .maxlen     = sizeof(unsigned int),
1822         .mode       = 0644,
1823         .proc_handler   = proc_dointvec_minmax,
1824         .extra1     = &one,
1825     },
1826     { }
1827 };
1828 
1829 static struct ctl_table debug_table[] = {
1830 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
1831     {
1832         .procname   = "exception-trace",
1833         .data       = &show_unhandled_signals,
1834         .maxlen     = sizeof(int),
1835         .mode       = 0644,
1836         .proc_handler   = proc_dointvec
1837     },
1838 #endif
1839 #if defined(CONFIG_OPTPROBES)
1840     {
1841         .procname   = "kprobes-optimization",
1842         .data       = &sysctl_kprobes_optimization,
1843         .maxlen     = sizeof(int),
1844         .mode       = 0644,
1845         .proc_handler   = proc_kprobes_optimization_handler,
1846         .extra1     = &zero,
1847         .extra2     = &one,
1848     },
1849 #endif
1850     { }
1851 };
1852 
1853 static struct ctl_table dev_table[] = {
1854     { }
1855 };
1856 
1857 int __init sysctl_init(void)
1858 {
1859     struct ctl_table_header *hdr;
1860 
1861     hdr = register_sysctl_table(sysctl_base_table);
1862     kmemleak_not_leak(hdr);
1863     return 0;
1864 }
1865 
1866 #endif /* CONFIG_SYSCTL */
1867 
1868 /*
1869  * /proc/sys support
1870  */
1871 
1872 #ifdef CONFIG_PROC_SYSCTL
1873 
1874 static int _proc_do_string(char *data, int maxlen, int write,
1875                char __user *buffer,
1876                size_t *lenp, loff_t *ppos)
1877 {
1878     size_t len;
1879     char __user *p;
1880     char c;
1881 
1882     if (!data || !maxlen || !*lenp) {
1883         *lenp = 0;
1884         return 0;
1885     }
1886 
1887     if (write) {
1888         if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
1889             /* Only continue writes not past the end of buffer. */
1890             len = strlen(data);
1891             if (len > maxlen - 1)
1892                 len = maxlen - 1;
1893 
1894             if (*ppos > len)
1895                 return 0;
1896             len = *ppos;
1897         } else {
1898             /* Start writing from beginning of buffer. */
1899             len = 0;
1900         }
1901 
1902         *ppos += *lenp;
1903         p = buffer;
1904         while ((p - buffer) < *lenp && len < maxlen - 1) {
1905             if (get_user(c, p++))
1906                 return -EFAULT;
1907             if (c == 0 || c == '\n')
1908                 break;
1909             data[len++] = c;
1910         }
1911         data[len] = 0;
1912     } else {
1913         len = strlen(data);
1914         if (len > maxlen)
1915             len = maxlen;
1916 
1917         if (*ppos > len) {
1918             *lenp = 0;
1919             return 0;
1920         }
1921 
1922         data += *ppos;
1923         len  -= *ppos;
1924 
1925         if (len > *lenp)
1926             len = *lenp;
1927         if (len)
1928             if (copy_to_user(buffer, data, len))
1929                 return -EFAULT;
1930         if (len < *lenp) {
1931             if (put_user('\n', buffer + len))
1932                 return -EFAULT;
1933             len++;
1934         }
1935         *lenp = len;
1936         *ppos += len;
1937     }
1938     return 0;
1939 }
1940 
1941 static void warn_sysctl_write(struct ctl_table *table)
1942 {
1943     pr_warn_once("%s wrote to %s when file position was not 0!\n"
1944         "This will not be supported in the future. To silence this\n"
1945         "warning, set kernel.sysctl_writes_strict = -1\n",
1946         current->comm, table->procname);
1947 }
1948 
1949 /**
1950  * proc_dostring - read a string sysctl
1951  * @table: the sysctl table
1952  * @write: %TRUE if this is a write to the sysctl file
1953  * @buffer: the user buffer
1954  * @lenp: the size of the user buffer
1955  * @ppos: file position
1956  *
1957  * Reads/writes a string from/to the user buffer. If the kernel
1958  * buffer provided is not large enough to hold the string, the
1959  * string is truncated. The copied string is %NULL-terminated.
1960  * If the string is being read by the user process, it is copied
1961  * and a newline '\n' is added. It is truncated if the buffer is
1962  * not large enough.
1963  *
1964  * Returns 0 on success.
1965  */
1966 int proc_dostring(struct ctl_table *table, int write,
1967           void __user *buffer, size_t *lenp, loff_t *ppos)
1968 {
1969     if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
1970         warn_sysctl_write(table);
1971 
1972     return _proc_do_string((char *)(table->data), table->maxlen, write,
1973                    (char __user *)buffer, lenp, ppos);
1974 }
1975 
1976 static size_t proc_skip_spaces(char **buf)
1977 {
1978     size_t ret;
1979     char *tmp = skip_spaces(*buf);
1980     ret = tmp - *buf;
1981     *buf = tmp;
1982     return ret;
1983 }
1984 
1985 static void proc_skip_char(char **buf, size_t *size, const char v)
1986 {
1987     while (*size) {
1988         if (**buf != v)
1989             break;
1990         (*size)--;
1991         (*buf)++;
1992     }
1993 }
1994 
1995 #define TMPBUFLEN 22
1996 /**
1997  * proc_get_long - reads an ASCII formatted integer from a user buffer
1998  *
1999  * @buf: a kernel buffer
2000  * @size: size of the kernel buffer
2001  * @val: this is where the number will be stored
2002  * @neg: set to %TRUE if number is negative
2003  * @perm_tr: a vector which contains the allowed trailers
2004  * @perm_tr_len: size of the perm_tr vector
2005  * @tr: pointer to store the trailer character
2006  *
2007  * In case of success %0 is returned and @buf and @size are updated with
2008  * the amount of bytes read. If @tr is non-NULL and a trailing
2009  * character exists (size is non-zero after returning from this
2010  * function), @tr is updated with the trailing character.
2011  */
2012 static int proc_get_long(char **buf, size_t *size,
2013               unsigned long *val, bool *neg,
2014               const char *perm_tr, unsigned perm_tr_len, char *tr)
2015 {
2016     int len;
2017     char *p, tmp[TMPBUFLEN];
2018 
2019     if (!*size)
2020         return -EINVAL;
2021 
2022     len = *size;
2023     if (len > TMPBUFLEN - 1)
2024         len = TMPBUFLEN - 1;
2025 
2026     memcpy(tmp, *buf, len);
2027 
2028     tmp[len] = 0;
2029     p = tmp;
2030     if (*p == '-' && *size > 1) {
2031         *neg = true;
2032         p++;
2033     } else
2034         *neg = false;
2035     if (!isdigit(*p))
2036         return -EINVAL;
2037 
2038     *val = simple_strtoul(p, &p, 0);
2039 
2040     len = p - tmp;
2041 
2042     /* We don't know if the next char is whitespace thus we may accept
2043      * invalid integers (e.g. 1234...a) or two integers instead of one
2044      * (e.g. 123...1). So lets not allow such large numbers. */
2045     if (len == TMPBUFLEN - 1)
2046         return -EINVAL;
2047 
2048     if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
2049         return -EINVAL;
2050 
2051     if (tr && (len < *size))
2052         *tr = *p;
2053 
2054     *buf += len;
2055     *size -= len;
2056 
2057     return 0;
2058 }
2059 
2060 /**
2061  * proc_put_long - converts an integer to a decimal ASCII formatted string
2062  *
2063  * @buf: the user buffer
2064  * @size: the size of the user buffer
2065  * @val: the integer to be converted
2066  * @neg: sign of the number, %TRUE for negative
2067  *
2068  * In case of success %0 is returned and @buf and @size are updated with
2069  * the amount of bytes written.
2070  */
2071 static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
2072               bool neg)
2073 {
2074     int len;
2075     char tmp[TMPBUFLEN], *p = tmp;
2076 
2077     sprintf(p, "%s%lu", neg ? "-" : "", val);
2078     len = strlen(tmp);
2079     if (len > *size)
2080         len = *size;
2081     if (copy_to_user(*buf, tmp, len))
2082         return -EFAULT;
2083     *size -= len;
2084     *buf += len;
2085     return 0;
2086 }
2087 #undef TMPBUFLEN
2088 
2089 static int proc_put_char(void __user **buf, size_t *size, char c)
2090 {
2091     if (*size) {
2092         char __user **buffer = (char __user **)buf;
2093         if (put_user(c, *buffer))
2094             return -EFAULT;
2095         (*size)--, (*buffer)++;
2096         *buf = *buffer;
2097     }
2098     return 0;
2099 }
2100 
2101 static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
2102                  int *valp,
2103                  int write, void *data)
2104 {
2105     if (write) {
2106         if (*negp) {
2107             if (*lvalp > (unsigned long) INT_MAX + 1)
2108                 return -EINVAL;
2109             *valp = -*lvalp;
2110         } else {
2111             if (*lvalp > (unsigned long) INT_MAX)
2112                 return -EINVAL;
2113             *valp = *lvalp;
2114         }
2115     } else {
2116         int val = *valp;
2117         if (val < 0) {
2118             *negp = true;
2119             *lvalp = -(unsigned long)val;
2120         } else {
2121             *negp = false;
2122             *lvalp = (unsigned long)val;
2123         }
2124     }
2125     return 0;
2126 }
2127 
2128 static int do_proc_douintvec_conv(bool *negp, unsigned long *lvalp,
2129                  int *valp,
2130                  int write, void *data)
2131 {
2132     if (write) {
2133         if (*negp)
2134             return -EINVAL;
2135         *valp = *lvalp;
2136     } else {
2137         unsigned int val = *valp;
2138         *lvalp = (unsigned long)val;
2139     }
2140     return 0;
2141 }
2142 
2143 static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
2144 
2145 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
2146           int write, void __user *buffer,
2147           size_t *lenp, loff_t *ppos,
2148           int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2149                   int write, void *data),
2150           void *data)
2151 {
2152     int *i, vleft, first = 1, err = 0;
2153     size_t left;
2154     char *kbuf = NULL, *p;
2155     
2156     if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
2157         *lenp = 0;
2158         return 0;
2159     }
2160     
2161     i = (int *) tbl_data;
2162     vleft = table->maxlen / sizeof(*i);
2163     left = *lenp;
2164 
2165     if (!conv)
2166         conv = do_proc_dointvec_conv;
2167 
2168     if (write) {
2169         if (*ppos) {
2170             switch (sysctl_writes_strict) {
2171             case SYSCTL_WRITES_STRICT:
2172                 goto out;
2173             case SYSCTL_WRITES_WARN:
2174                 warn_sysctl_write(table);
2175                 break;
2176             default:
2177                 break;
2178             }
2179         }
2180 
2181         if (left > PAGE_SIZE - 1)
2182             left = PAGE_SIZE - 1;
2183         p = kbuf = memdup_user_nul(buffer, left);
2184         if (IS_ERR(kbuf))
2185             return PTR_ERR(kbuf);
2186     }
2187 
2188     for (; left && vleft--; i++, first=0) {
2189         unsigned long lval;
2190         bool neg;
2191 
2192         if (write) {
2193             left -= proc_skip_spaces(&p);
2194 
2195             if (!left)
2196                 break;
2197             err = proc_get_long(&p, &left, &lval, &neg,
2198                          proc_wspace_sep,
2199                          sizeof(proc_wspace_sep), NULL);
2200             if (err)
2201                 break;
2202             if (conv(&neg, &lval, i, 1, data)) {
2203                 err = -EINVAL;
2204                 break;
2205             }
2206         } else {
2207             if (conv(&neg, &lval, i, 0, data)) {
2208                 err = -EINVAL;
2209                 break;
2210             }
2211             if (!first)
2212                 err = proc_put_char(&buffer, &left, '\t');
2213             if (err)
2214                 break;
2215             err = proc_put_long(&buffer, &left, lval, neg);
2216             if (err)
2217                 break;
2218         }
2219     }
2220 
2221     if (!write && !first && left && !err)
2222         err = proc_put_char(&buffer, &left, '\n');
2223     if (write && !err && left)
2224         left -= proc_skip_spaces(&p);
2225     if (write) {
2226         kfree(kbuf);
2227         if (first)
2228             return err ? : -EINVAL;
2229     }
2230     *lenp -= left;
2231 out:
2232     *ppos += *lenp;
2233     return err;
2234 }
2235 
2236 static int do_proc_dointvec(struct ctl_table *table, int write,
2237           void __user *buffer, size_t *lenp, loff_t *ppos,
2238           int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2239                   int write, void *data),
2240           void *data)
2241 {
2242     return __do_proc_dointvec(table->data, table, write,
2243             buffer, lenp, ppos, conv, data);
2244 }
2245 
2246 /**
2247  * proc_dointvec - read a vector of integers
2248  * @table: the sysctl table
2249  * @write: %TRUE if this is a write to the sysctl file
2250  * @buffer: the user buffer
2251  * @lenp: the size of the user buffer
2252  * @ppos: file position
2253  *
2254  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2255  * values from/to the user buffer, treated as an ASCII string. 
2256  *
2257  * Returns 0 on success.
2258  */
2259 int proc_dointvec(struct ctl_table *table, int write,
2260              void __user *buffer, size_t *lenp, loff_t *ppos)
2261 {
2262     return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
2263 }
2264 
2265 /**
2266  * proc_douintvec - read a vector of unsigned integers
2267  * @table: the sysctl table
2268  * @write: %TRUE if this is a write to the sysctl file
2269  * @buffer: the user buffer
2270  * @lenp: the size of the user buffer
2271  * @ppos: file position
2272  *
2273  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
2274  * values from/to the user buffer, treated as an ASCII string.
2275  *
2276  * Returns 0 on success.
2277  */
2278 int proc_douintvec(struct ctl_table *table, int write,
2279              void __user *buffer, size_t *lenp, loff_t *ppos)
2280 {
2281     return do_proc_dointvec(table, write, buffer, lenp, ppos,
2282                 do_proc_douintvec_conv, NULL);
2283 }
2284 
2285 /*
2286  * Taint values can only be increased
2287  * This means we can safely use a temporary.
2288  */
2289 static int proc_taint(struct ctl_table *table, int write,
2290                    void __user *buffer, size_t *lenp, loff_t *ppos)
2291 {
2292     struct ctl_table t;
2293     unsigned long tmptaint = get_taint();
2294     int err;
2295 
2296     if (write && !capable(CAP_SYS_ADMIN))
2297         return -EPERM;
2298 
2299     t = *table;
2300     t.data = &tmptaint;
2301     err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
2302     if (err < 0)
2303         return err;
2304 
2305     if (write) {
2306         /*
2307          * Poor man's atomic or. Not worth adding a primitive
2308          * to everyone's atomic.h for this
2309          */
2310         int i;
2311         for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2312             if ((tmptaint >> i) & 1)
2313                 add_taint(i, LOCKDEP_STILL_OK);
2314         }
2315     }
2316 
2317     return err;
2318 }
2319 
2320 #ifdef CONFIG_PRINTK
2321 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
2322                 void __user *buffer, size_t *lenp, loff_t *ppos)
2323 {
2324     if (write && !capable(CAP_SYS_ADMIN))
2325         return -EPERM;
2326 
2327     return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2328 }
2329 #endif
2330 
2331 struct do_proc_dointvec_minmax_conv_param {
2332     int *min;
2333     int *max;
2334 };
2335 
2336 static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
2337                     int *valp,
2338                     int write, void *data)
2339 {
2340     struct do_proc_dointvec_minmax_conv_param *param = data;
2341     if (write) {
2342         int val = *negp ? -*lvalp : *lvalp;
2343         if ((param->min && *param->min > val) ||
2344             (param->max && *param->max < val))
2345             return -EINVAL;
2346         *valp = val;
2347     } else {
2348         int val = *valp;
2349         if (val < 0) {
2350             *negp = true;
2351             *lvalp = -(unsigned long)val;
2352         } else {
2353             *negp = false;
2354             *lvalp = (unsigned long)val;
2355         }
2356     }
2357     return 0;
2358 }
2359 
2360 /**
2361  * proc_dointvec_minmax - read a vector of integers with min/max values
2362  * @table: the sysctl table
2363  * @write: %TRUE if this is a write to the sysctl file
2364  * @buffer: the user buffer
2365  * @lenp: the size of the user buffer
2366  * @ppos: file position
2367  *
2368  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2369  * values from/to the user buffer, treated as an ASCII string.
2370  *
2371  * This routine will ensure the values are within the range specified by
2372  * table->extra1 (min) and table->extra2 (max).
2373  *
2374  * Returns 0 on success.
2375  */
2376 int proc_dointvec_minmax(struct ctl_table *table, int write,
2377           void __user *buffer, size_t *lenp, loff_t *ppos)
2378 {
2379     struct do_proc_dointvec_minmax_conv_param param = {
2380         .min = (int *) table->extra1,
2381         .max = (int *) table->extra2,
2382     };
2383     return do_proc_dointvec(table, write, buffer, lenp, ppos,
2384                 do_proc_dointvec_minmax_conv, &param);
2385 }
2386 
2387 static void validate_coredump_safety(void)
2388 {
2389 #ifdef CONFIG_COREDUMP
2390     if (suid_dumpable == SUID_DUMP_ROOT &&
2391         core_pattern[0] != '/' && core_pattern[0] != '|') {
2392         printk(KERN_WARNING
2393 "Unsafe core_pattern used with fs.suid_dumpable=2.\n"
2394 "Pipe handler or fully qualified core dump path required.\n"
2395 "Set kernel.core_pattern before fs.suid_dumpable.\n"
2396         );
2397     }
2398 #endif
2399 }
2400 
2401 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
2402         void __user *buffer, size_t *lenp, loff_t *ppos)
2403 {
2404     int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2405     if (!error)
2406         validate_coredump_safety();
2407     return error;
2408 }
2409 
2410 #ifdef CONFIG_COREDUMP
2411 static int proc_dostring_coredump(struct ctl_table *table, int write,
2412           void __user *buffer, size_t *lenp, loff_t *ppos)
2413 {
2414     int error = proc_dostring(table, write, buffer, lenp, ppos);
2415     if (!error)
2416         validate_coredump_safety();
2417     return error;
2418 }
2419 #endif
2420 
2421 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
2422                      void __user *buffer,
2423                      size_t *lenp, loff_t *ppos,
2424                      unsigned long convmul,
2425                      unsigned long convdiv)
2426 {
2427     unsigned long *i, *min, *max;
2428     int vleft, first = 1, err = 0;
2429     size_t left;
2430     char *kbuf = NULL, *p;
2431 
2432     if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
2433         *lenp = 0;
2434         return 0;
2435     }
2436 
2437     i = (unsigned long *) data;
2438     min = (unsigned long *) table->extra1;
2439     max = (unsigned long *) table->extra2;
2440     vleft = table->maxlen / sizeof(unsigned long);
2441     left = *lenp;
2442 
2443     if (write) {
2444         if (*ppos) {
2445             switch (sysctl_writes_strict) {
2446             case SYSCTL_WRITES_STRICT:
2447                 goto out;
2448             case SYSCTL_WRITES_WARN:
2449                 warn_sysctl_write(table);
2450                 break;
2451             default:
2452                 break;
2453             }
2454         }
2455 
2456         if (left > PAGE_SIZE - 1)
2457             left = PAGE_SIZE - 1;
2458         p = kbuf = memdup_user_nul(buffer, left);
2459         if (IS_ERR(kbuf))
2460             return PTR_ERR(kbuf);
2461     }
2462 
2463     for (; left && vleft--; i++, first = 0) {
2464         unsigned long val;
2465 
2466         if (write) {
2467             bool neg;
2468 
2469             left -= proc_skip_spaces(&p);
2470 
2471             err = proc_get_long(&p, &left, &val, &neg,
2472                          proc_wspace_sep,
2473                          sizeof(proc_wspace_sep), NULL);
2474             if (err)
2475                 break;
2476             if (neg)
2477                 continue;
2478             val = convmul * val / convdiv;
2479             if ((min && val < *min) || (max && val > *max))
2480                 continue;
2481             *i = val;
2482         } else {
2483             val = convdiv * (*i) / convmul;
2484             if (!first) {
2485                 err = proc_put_char(&buffer, &left, '\t');
2486                 if (err)
2487                     break;
2488             }
2489             err = proc_put_long(&buffer, &left, val, false);
2490             if (err)
2491                 break;
2492         }
2493     }
2494 
2495     if (!write && !first && left && !err)
2496         err = proc_put_char(&buffer, &left, '\n');
2497     if (write && !err)
2498         left -= proc_skip_spaces(&p);
2499     if (write) {
2500         kfree(kbuf);
2501         if (first)
2502             return err ? : -EINVAL;
2503     }
2504     *lenp -= left;
2505 out:
2506     *ppos += *lenp;
2507     return err;
2508 }
2509 
2510 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2511                      void __user *buffer,
2512                      size_t *lenp, loff_t *ppos,
2513                      unsigned long convmul,
2514                      unsigned long convdiv)
2515 {
2516     return __do_proc_doulongvec_minmax(table->data, table, write,
2517             buffer, lenp, ppos, convmul, convdiv);
2518 }
2519 
2520 /**
2521  * proc_doulongvec_minmax - read a vector of long integers with min/max values
2522  * @table: the sysctl table
2523  * @write: %TRUE if this is a write to the sysctl file
2524  * @buffer: the user buffer
2525  * @lenp: the size of the user buffer
2526  * @ppos: file position
2527  *
2528  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2529  * values from/to the user buffer, treated as an ASCII string.
2530  *
2531  * This routine will ensure the values are within the range specified by
2532  * table->extra1 (min) and table->extra2 (max).
2533  *
2534  * Returns 0 on success.
2535  */
2536 int proc_doulongvec_minmax(struct ctl_table *table, int write,
2537                void __user *buffer, size_t *lenp, loff_t *ppos)
2538 {
2539     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
2540 }
2541 
2542 /**
2543  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2544  * @table: the sysctl table
2545  * @write: %TRUE if this is a write to the sysctl file
2546  * @buffer: the user buffer
2547  * @lenp: the size of the user buffer
2548  * @ppos: file position
2549  *
2550  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2551  * values from/to the user buffer, treated as an ASCII string. The values
2552  * are treated as milliseconds, and converted to jiffies when they are stored.
2553  *
2554  * This routine will ensure the values are within the range specified by
2555  * table->extra1 (min) and table->extra2 (max).
2556  *
2557  * Returns 0 on success.
2558  */
2559 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2560                       void __user *buffer,
2561                       size_t *lenp, loff_t *ppos)
2562 {
2563     return do_proc_doulongvec_minmax(table, write, buffer,
2564                      lenp, ppos, HZ, 1000l);
2565 }
2566 
2567 
2568 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
2569                      int *valp,
2570                      int write, void *data)
2571 {
2572     if (write) {
2573         if (*lvalp > LONG_MAX / HZ)
2574             return 1;
2575         *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2576     } else {
2577         int val = *valp;
2578         unsigned long lval;
2579         if (val < 0) {
2580             *negp = true;
2581             lval = -(unsigned long)val;
2582         } else {
2583             *negp = false;
2584             lval = (unsigned long)val;
2585         }
2586         *lvalp = lval / HZ;
2587     }
2588     return 0;
2589 }
2590 
2591 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
2592                         int *valp,
2593                         int write, void *data)
2594 {
2595     if (write) {
2596         if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2597             return 1;
2598         *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
2599     } else {
2600         int val = *valp;
2601         unsigned long lval;
2602         if (val < 0) {
2603             *negp = true;
2604             lval = -(unsigned long)val;
2605         } else {
2606             *negp = false;
2607             lval = (unsigned long)val;
2608         }
2609         *lvalp = jiffies_to_clock_t(lval);
2610     }
2611     return 0;
2612 }
2613 
2614 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
2615                         int *valp,
2616                         int write, void *data)
2617 {
2618     if (write) {
2619         unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2620 
2621         if (jif > INT_MAX)
2622             return 1;
2623         *valp = (int)jif;
2624     } else {
2625         int val = *valp;
2626         unsigned long lval;
2627         if (val < 0) {
2628             *negp = true;
2629             lval = -(unsigned long)val;
2630         } else {
2631             *negp = false;
2632             lval = (unsigned long)val;
2633         }
2634         *lvalp = jiffies_to_msecs(lval);
2635     }
2636     return 0;
2637 }
2638 
2639 /**
2640  * proc_dointvec_jiffies - read a vector of integers as seconds
2641  * @table: the sysctl table
2642  * @write: %TRUE if this is a write to the sysctl file
2643  * @buffer: the user buffer
2644  * @lenp: the size of the user buffer
2645  * @ppos: file position
2646  *
2647  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2648  * values from/to the user buffer, treated as an ASCII string. 
2649  * The values read are assumed to be in seconds, and are converted into
2650  * jiffies.
2651  *
2652  * Returns 0 on success.
2653  */
2654 int proc_dointvec_jiffies(struct ctl_table *table, int write,
2655               void __user *buffer, size_t *lenp, loff_t *ppos)
2656 {
2657     return do_proc_dointvec(table,write,buffer,lenp,ppos,
2658                     do_proc_dointvec_jiffies_conv,NULL);
2659 }
2660 
2661 /**
2662  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2663  * @table: the sysctl table
2664  * @write: %TRUE if this is a write to the sysctl file
2665  * @buffer: the user buffer
2666  * @lenp: the size of the user buffer
2667  * @ppos: pointer to the file position
2668  *
2669  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2670  * values from/to the user buffer, treated as an ASCII string. 
2671  * The values read are assumed to be in 1/USER_HZ seconds, and 
2672  * are converted into jiffies.
2673  *
2674  * Returns 0 on success.
2675  */
2676 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
2677                  void __user *buffer, size_t *lenp, loff_t *ppos)
2678 {
2679     return do_proc_dointvec(table,write,buffer,lenp,ppos,
2680                     do_proc_dointvec_userhz_jiffies_conv,NULL);
2681 }
2682 
2683 /**
2684  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2685  * @table: the sysctl table
2686  * @write: %TRUE if this is a write to the sysctl file
2687  * @buffer: the user buffer
2688  * @lenp: the size of the user buffer
2689  * @ppos: file position
2690  * @ppos: the current position in the file
2691  *
2692  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2693  * values from/to the user buffer, treated as an ASCII string. 
2694  * The values read are assumed to be in 1/1000 seconds, and 
2695  * are converted into jiffies.
2696  *
2697  * Returns 0 on success.
2698  */
2699 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
2700                  void __user *buffer, size_t *lenp, loff_t *ppos)
2701 {
2702     return do_proc_dointvec(table, write, buffer, lenp, ppos,
2703                 do_proc_dointvec_ms_jiffies_conv, NULL);
2704 }
2705 
2706 static int proc_do_cad_pid(struct ctl_table *table, int write,
2707                void __user *buffer, size_t *lenp, loff_t *ppos)
2708 {
2709     struct pid *new_pid;
2710     pid_t tmp;
2711     int r;
2712 
2713     tmp = pid_vnr(cad_pid);
2714 
2715     r = __do_proc_dointvec(&tmp, table, write, buffer,
2716                    lenp, ppos, NULL, NULL);
2717     if (r || !write)
2718         return r;
2719 
2720     new_pid = find_get_pid(tmp);
2721     if (!new_pid)
2722         return -ESRCH;
2723 
2724     put_pid(xchg(&cad_pid, new_pid));
2725     return 0;
2726 }
2727 
2728 /**
2729  * proc_do_large_bitmap - read/write from/to a large bitmap
2730  * @table: the sysctl table
2731  * @write: %TRUE if this is a write to the sysctl file
2732  * @buffer: the user buffer
2733  * @lenp: the size of the user buffer
2734  * @ppos: file position
2735  *
2736  * The bitmap is stored at table->data and the bitmap length (in bits)
2737  * in table->maxlen.
2738  *
2739  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
2740  * large bitmaps may be represented in a compact manner. Writing into
2741  * the file will clear the bitmap then update it with the given input.
2742  *
2743  * Returns 0 on success.
2744  */
2745 int proc_do_large_bitmap(struct ctl_table *table, int write,
2746              void __user *buffer, size_t *lenp, loff_t *ppos)
2747 {
2748     int err = 0;
2749     bool first = 1;
2750     size_t left = *lenp;
2751     unsigned long bitmap_len = table->maxlen;
2752     unsigned long *bitmap = *(unsigned long **) table->data;
2753     unsigned long *tmp_bitmap = NULL;
2754     char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
2755 
2756     if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
2757         *lenp = 0;
2758         return 0;
2759     }
2760 
2761     if (write) {
2762         char *kbuf, *p;
2763 
2764         if (left > PAGE_SIZE - 1)
2765             left = PAGE_SIZE - 1;
2766 
2767         p = kbuf = memdup_user_nul(buffer, left);
2768         if (IS_ERR(kbuf))
2769             return PTR_ERR(kbuf);
2770 
2771         tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
2772                      GFP_KERNEL);
2773         if (!tmp_bitmap) {
2774             kfree(kbuf);
2775             return -ENOMEM;
2776         }
2777         proc_skip_char(&p, &left, '\n');
2778         while (!err && left) {
2779             unsigned long val_a, val_b;
2780             bool neg;
2781 
2782             err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
2783                          sizeof(tr_a), &c);
2784             if (err)
2785                 break;
2786             if (val_a >= bitmap_len || neg) {
2787                 err = -EINVAL;
2788                 break;
2789             }
2790 
2791             val_b = val_a;
2792             if (left) {
2793                 p++;
2794                 left--;
2795             }
2796 
2797             if (c == '-') {
2798                 err = proc_get_long(&p, &left, &val_b,
2799                              &neg, tr_b, sizeof(tr_b),
2800                              &c);
2801                 if (err)
2802                     break;
2803                 if (val_b >= bitmap_len || neg ||
2804                     val_a > val_b) {
2805                     err = -EINVAL;
2806                     break;
2807                 }
2808                 if (left) {
2809                     p++;
2810                     left--;
2811                 }
2812             }
2813 
2814             bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
2815             first = 0;
2816             proc_skip_char(&p, &left, '\n');
2817         }
2818         kfree(kbuf);
2819     } else {
2820         unsigned long bit_a, bit_b = 0;
2821 
2822         while (left) {
2823             bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
2824             if (bit_a >= bitmap_len)
2825                 break;
2826             bit_b = find_next_zero_bit(bitmap, bitmap_len,
2827                            bit_a + 1) - 1;
2828 
2829             if (!first) {
2830                 err = proc_put_char(&buffer, &left, ',');
2831                 if (err)
2832                     break;
2833             }
2834             err = proc_put_long(&buffer, &left, bit_a, false);
2835             if (err)
2836                 break;
2837             if (bit_a != bit_b) {
2838                 err = proc_put_char(&buffer, &left, '-');
2839                 if (err)
2840                     break;
2841                 err = proc_put_long(&buffer, &left, bit_b, false);
2842                 if (err)
2843                     break;
2844             }
2845 
2846             first = 0; bit_b++;
2847         }
2848         if (!err)
2849             err = proc_put_char(&buffer, &left, '\n');
2850     }
2851 
2852     if (!err) {
2853         if (write) {
2854             if (*ppos)
2855                 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
2856             else
2857                 bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
2858         }
2859         kfree(tmp_bitmap);
2860         *lenp -= left;
2861         *ppos += *lenp;
2862         return 0;
2863     } else {
2864         kfree(tmp_bitmap);
2865         return err;
2866     }
2867 }
2868 
2869 #else /* CONFIG_PROC_SYSCTL */
2870 
2871 int proc_dostring(struct ctl_table *table, int write,
2872           void __user *buffer, size_t *lenp, loff_t *ppos)
2873 {
2874     return -ENOSYS;
2875 }
2876 
2877 int proc_dointvec(struct ctl_table *table, int write,
2878           void __user *buffer, size_t *lenp, loff_t *ppos)
2879 {
2880     return -ENOSYS;
2881 }
2882 
2883 int proc_douintvec(struct ctl_table *table, int write,
2884           void __user *buffer, size_t *lenp, loff_t *ppos)
2885 {
2886     return -ENOSYS;
2887 }
2888 
2889 int proc_dointvec_minmax(struct ctl_table *table, int write,
2890             void __user *buffer, size_t *lenp, loff_t *ppos)
2891 {
2892     return -ENOSYS;
2893 }
2894 
2895 int proc_dointvec_jiffies(struct ctl_table *table, int write,
2896             void __user *buffer, size_t *lenp, loff_t *ppos)
2897 {
2898     return -ENOSYS;
2899 }
2900 
2901 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
2902             void __user *buffer, size_t *lenp, loff_t *ppos)
2903 {
2904     return -ENOSYS;
2905 }
2906 
2907 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
2908                  void __user *buffer, size_t *lenp, loff_t *ppos)
2909 {
2910     return -ENOSYS;
2911 }
2912 
2913 int proc_doulongvec_minmax(struct ctl_table *table, int write,
2914             void __user *buffer, size_t *lenp, loff_t *ppos)
2915 {
2916     return -ENOSYS;
2917 }
2918 
2919 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2920                       void __user *buffer,
2921                       size_t *lenp, loff_t *ppos)
2922 {
2923     return -ENOSYS;
2924 }
2925 
2926 
2927 #endif /* CONFIG_PROC_SYSCTL */
2928 
2929 /*
2930  * No sense putting this after each symbol definition, twice,
2931  * exception granted :-)
2932  */
2933 EXPORT_SYMBOL(proc_dointvec);
2934 EXPORT_SYMBOL(proc_douintvec);
2935 EXPORT_SYMBOL(proc_dointvec_jiffies);
2936 EXPORT_SYMBOL(proc_dointvec_minmax);
2937 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2938 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2939 EXPORT_SYMBOL(proc_dostring);
2940 EXPORT_SYMBOL(proc_doulongvec_minmax);
2941 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);