Eric Lee / linux-smarc-t335x-v3.2

Commit baf48f6577e581a9adb8fe849dc80e24b21d171d

Authored by Mandeep Singh Baines 2009-01-13 13:15:17 +0800

Committed by Ingo Molnar 2009-01-14 18:48:07 +0800

Exists in master and in 4 other branches

softlock: fix false panic which can occur if softlockup_thresh is reduced

At run-time, if softlockup_thresh is changed to a much lower value,
touch_timestamp is likely to be much older than the new softlock_thresh.

This will cause a false softlockup to be detected. If softlockup_panic
is enabled, the system will panic.

The fix is to touch all watchdogs before changing softlockup_thresh.

Signed-off-by: Mandeep Singh Baines <msb@google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

Showing 3 changed files with 13 additions and 1 deletions Inline Diff

include/linux/sched.h
kernel/softlockup.c
kernel/sysctl.c

include/linux/sched.h

Diff comments View file @ baf48f6

 #ifndef _LINUX_SCHED_H
 #define _LINUX_SCHED_H
 /*
  * cloning flags:
  */
 #define CSIGNAL		0x000000ff	/* signal mask to be sent at exit */
 #define CLONE_VM	0x00000100	/* set if VM shared between processes */
 #define CLONE_FS	0x00000200	/* set if fs info shared between processes */
 #define CLONE_FILES	0x00000400	/* set if open files shared between processes */
 #define CLONE_SIGHAND	0x00000800	/* set if signal handlers and blocked signals shared */
 #define CLONE_PTRACE	0x00002000	/* set if we want to let tracing continue on the child too */
 #define CLONE_VFORK	0x00004000	/* set if the parent wants the child to wake it up on mm_release */
 #define CLONE_PARENT	0x00008000	/* set if we want to have the same parent as the cloner */
 #define CLONE_THREAD	0x00010000	/* Same thread group? */
 #define CLONE_NEWNS	0x00020000	/* New namespace group? */
 #define CLONE_SYSVSEM	0x00040000	/* share system V SEM_UNDO semantics */
 #define CLONE_SETTLS	0x00080000	/* create a new TLS for the child */
 #define CLONE_PARENT_SETTID	0x00100000	/* set the TID in the parent */
 #define CLONE_CHILD_CLEARTID	0x00200000	/* clear the TID in the child */
 #define CLONE_DETACHED		0x00400000	/* Unused, ignored */
 #define CLONE_UNTRACED		0x00800000	/* set if the tracing process can't force CLONE_PTRACE on this clone */
 #define CLONE_CHILD_SETTID	0x01000000	/* set the TID in the child */
 #define CLONE_STOPPED		0x02000000	/* Start in stopped state */
 #define CLONE_NEWUTS		0x04000000	/* New utsname group? */
 #define CLONE_NEWIPC		0x08000000	/* New ipcs */
 #define CLONE_NEWUSER		0x10000000	/* New user namespace */
 #define CLONE_NEWPID		0x20000000	/* New pid namespace */
 #define CLONE_NEWNET		0x40000000	/* New network namespace */
 #define CLONE_IO		0x80000000	/* Clone io context */
 /*
  * Scheduling policies
  */
 #define SCHED_NORMAL		0
 #define SCHED_FIFO		1
 #define SCHED_RR		2
 #define SCHED_BATCH		3
 /* SCHED_ISO: reserved but not implemented yet */
 #define SCHED_IDLE		5
 #ifdef __KERNEL__
 struct sched_param {
 	int sched_priority;
 };
 #include <asm/param.h>	/* for HZ */
 #include <linux/capability.h>
 #include <linux/threads.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/rbtree.h>
 #include <linux/thread_info.h>
 #include <linux/cpumask.h>
 #include <linux/errno.h>
 #include <linux/nodemask.h>
 #include <linux/mm_types.h>
 #include <asm/system.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
 #include <asm/cputime.h>
 #include <linux/smp.h>
 #include <linux/sem.h>
 #include <linux/signal.h>
 #include <linux/fs_struct.h>
 #include <linux/compiler.h>
 #include <linux/completion.h>
 #include <linux/pid.h>
 #include <linux/percpu.h>
 #include <linux/topology.h>
 #include <linux/proportions.h>
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
 #include <linux/rtmutex.h>
 #include <linux/time.h>
 #include <linux/param.h>
 #include <linux/resource.h>
 #include <linux/timer.h>
 #include <linux/hrtimer.h>
 #include <linux/task_io_accounting.h>
 #include <linux/kobject.h>
 #include <linux/latencytop.h>
 #include <linux/cred.h>
 #include <asm/processor.h>
 struct mem_cgroup;
 struct exec_domain;
 struct futex_pi_state;
 struct robust_list_head;
 struct bio;
 struct bts_tracer;
 /*
  * List of flags we want to share for kernel threads,
  * if only because they are not used by them anyway.
  */
 #define CLONE_KERNEL	(CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
 /*
  * These are the constant used to fake the fixed-point load-average
  * counting. Some notes:
  *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
  *    a load-average precision of 10 bits integer + 11 bits fractional
  *  - if you want to count load-averages more often, you need more
  *    precision, or rounding will get you. With 2-second counting freq,
  *    the EXP_n values would be 1981, 2034 and 2043 if still using only
  *    11 bit fractions.
  */
 extern unsigned long avenrun[];		/* Load averages */
 #define FSHIFT		11		/* nr of bits of precision */
 #define FIXED_1		(1<<FSHIFT)	/* 1.0 as fixed-point */
 #define LOAD_FREQ	(5*HZ+1)	/* 5 sec intervals */
 #define EXP_1		1884		/* 1/exp(5sec/1min) as fixed-point */
 #define EXP_5		2014		/* 1/exp(5sec/5min) */
 #define EXP_15		2037		/* 1/exp(5sec/15min) */
 #define CALC_LOAD(load,exp,n) \
 	load *= exp; \
 	load += n*(FIXED_1-exp); \
 	load >>= FSHIFT;
 extern unsigned long total_forks;
 extern int nr_threads;
 DECLARE_PER_CPU(unsigned long, process_counts);
 extern int nr_processes(void);
 extern unsigned long nr_running(void);
 extern unsigned long nr_uninterruptible(void);
 extern unsigned long nr_active(void);
 extern unsigned long nr_iowait(void);
 struct seq_file;
 struct cfs_rq;
 struct task_group;
 #ifdef CONFIG_SCHED_DEBUG
 extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
 extern void proc_sched_set_task(struct task_struct *p);
 extern void
 print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
 #else
 static inline void
 proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 {
 }
 static inline void proc_sched_set_task(struct task_struct *p)
 {
 }
 static inline void
 print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 {
 }
 #endif
 extern unsigned long long time_sync_thresh;
 /*
  * Task state bitmask. NOTE! These bits are also
  * encoded in fs/proc/array.c: get_task_state().
  *
  * We have two separate sets of flags: task->state
  * is about runnability, while task->exit_state are
  * about the task exiting. Confusing, but this way
  * modifying one set can't modify the other one by
  * mistake.
  */
 #define TASK_RUNNING		0
 #define TASK_INTERRUPTIBLE	1
 #define TASK_UNINTERRUPTIBLE	2
 #define __TASK_STOPPED		4
 #define __TASK_TRACED		8
 /* in tsk->exit_state */
 #define EXIT_ZOMBIE		16
 #define EXIT_DEAD		32
 /* in tsk->state again */
 #define TASK_DEAD		64
 #define TASK_WAKEKILL		128
 /* Convenience macros for the sake of set_task_state */
 #define TASK_KILLABLE		(TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
 #define TASK_STOPPED		(TASK_WAKEKILL | __TASK_STOPPED)
 #define TASK_TRACED		(TASK_WAKEKILL | __TASK_TRACED)
 /* Convenience macros for the sake of wake_up */
 #define TASK_NORMAL		(TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
 #define TASK_ALL		(TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
 /* get_task_state() */
 #define TASK_REPORT		(TASK_RUNNING | TASK_INTERRUPTIBLE | \
 				 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
 				 __TASK_TRACED)
 #define task_is_traced(task)	((task->state & __TASK_TRACED) != 0)
 #define task_is_stopped(task)	((task->state & __TASK_STOPPED) != 0)
 #define task_is_stopped_or_traced(task)	\
 			((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
 #define task_contributes_to_load(task)	\
 				((task->state & TASK_UNINTERRUPTIBLE) != 0)
 #define __set_task_state(tsk, state_value)		\
 	do { (tsk)->state = (state_value); } while (0)
 #define set_task_state(tsk, state_value)		\
 	set_mb((tsk)->state, (state_value))
 /*
  * set_current_state() includes a barrier so that the write of current->state
  * is correctly serialised wrt the caller's subsequent test of whether to
  * actually sleep:
  *
  *	set_current_state(TASK_UNINTERRUPTIBLE);
  *	if (do_i_need_to_sleep())
  *		schedule();
  *
  * If the caller does not need such serialisation then use __set_current_state()
  */
 #define __set_current_state(state_value)			\
 	do { current->state = (state_value); } while (0)
 #define set_current_state(state_value)		\
 	set_mb(current->state, (state_value))
 /* Task command name length */
 #define TASK_COMM_LEN 16
 #include <linux/spinlock.h>
 /*
  * This serializes "schedule()" and also protects
  * the run-queue from deletions/modifications (but
  * _adding_ to the beginning of the run-queue has
  * a separate lock).
  */
 extern rwlock_t tasklist_lock;
 extern spinlock_t mmlist_lock;
 struct task_struct;
 extern void sched_init(void);
 extern void sched_init_smp(void);
 extern asmlinkage void schedule_tail(struct task_struct *prev);
 extern void init_idle(struct task_struct *idle, int cpu);
 extern void init_idle_bootup_task(struct task_struct *idle);
 extern int runqueue_is_locked(void);
 extern void task_rq_unlock_wait(struct task_struct *p);
 extern cpumask_var_t nohz_cpu_mask;
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
 extern int select_nohz_load_balancer(int cpu);
 #else
 static inline int select_nohz_load_balancer(int cpu)
 {
 	return 0;
 }
 #endif
 /*
  * Only dump TASK_* tasks. (0 for all tasks)
  */
 extern void show_state_filter(unsigned long state_filter);
 static inline void show_state(void)
 {
 	show_state_filter(0);
 }
 extern void show_regs(struct pt_regs *);
 /*
  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
  * task), SP is the stack pointer of the first frame that should be shown in the back
  * trace (or NULL if the entire call-chain of the task should be shown).
  */
 extern void show_stack(struct task_struct *task, unsigned long *sp);
 void io_schedule(void);
 long io_schedule_timeout(long timeout);
 extern void cpu_init (void);
 extern void trap_init(void);
 extern void update_process_times(int user);
 extern void scheduler_tick(void);
 extern void sched_show_task(struct task_struct *p);
 #ifdef CONFIG_DETECT_SOFTLOCKUP
 extern void softlockup_tick(void);
 extern void touch_softlockup_watchdog(void);
 extern void touch_all_softlockup_watchdogs(void);
+extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
+				    struct file *filp, void __user *buffer,
+				    size_t *lenp, loff_t *ppos);
 extern unsigned int  softlockup_panic;
 extern unsigned long sysctl_hung_task_check_count;
 extern unsigned long sysctl_hung_task_timeout_secs;
 extern unsigned long sysctl_hung_task_warnings;
 extern int softlockup_thresh;
 #else
 static inline void softlockup_tick(void)
 {
 }
 static inline void spawn_softlockup_task(void)
 {
 }
 static inline void touch_softlockup_watchdog(void)
 {
 }
 static inline void touch_all_softlockup_watchdogs(void)
 {
 }
 #endif
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched		__attribute__((__section__(".sched.text")))
 /* Linker adds these: start and end of __sched functions */
 extern char __sched_text_start[], __sched_text_end[];
 /* Is this address in the __sched functions? */
 extern int in_sched_functions(unsigned long addr);
 #define	MAX_SCHEDULE_TIMEOUT	LONG_MAX
 extern signed long schedule_timeout(signed long timeout);
 extern signed long schedule_timeout_interruptible(signed long timeout);
 extern signed long schedule_timeout_killable(signed long timeout);
 extern signed long schedule_timeout_uninterruptible(signed long timeout);
 asmlinkage void schedule(void);
 struct nsproxy;
 struct user_namespace;
 /* Maximum number of active map areas.. This is a random (large) number */
 #define DEFAULT_MAX_MAP_COUNT	65536
 extern int sysctl_max_map_count;
 #include <linux/aio.h>
 extern unsigned long
 arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
 		       unsigned long, unsigned long);
 extern unsigned long
 arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
 			  unsigned long len, unsigned long pgoff,
 			  unsigned long flags);
 extern void arch_unmap_area(struct mm_struct *, unsigned long);
 extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
 #if USE_SPLIT_PTLOCKS
 /*
  * The mm counters are not protected by its page_table_lock,
  * so must be incremented atomically.
  */
 #define set_mm_counter(mm, member, value) atomic_long_set(&(mm)->_##member, value)
 #define get_mm_counter(mm, member) ((unsigned long)atomic_long_read(&(mm)->_##member))
 #define add_mm_counter(mm, member, value) atomic_long_add(value, &(mm)->_##member)
 #define inc_mm_counter(mm, member) atomic_long_inc(&(mm)->_##member)
 #define dec_mm_counter(mm, member) atomic_long_dec(&(mm)->_##member)
 #else  /* !USE_SPLIT_PTLOCKS */
 /*
  * The mm counters are protected by its page_table_lock,
  * so can be incremented directly.
  */
 #define set_mm_counter(mm, member, value) (mm)->_##member = (value)
 #define get_mm_counter(mm, member) ((mm)->_##member)
 #define add_mm_counter(mm, member, value) (mm)->_##member += (value)
 #define inc_mm_counter(mm, member) (mm)->_##member++
 #define dec_mm_counter(mm, member) (mm)->_##member--
 #endif /* !USE_SPLIT_PTLOCKS */
 #define get_mm_rss(mm)					\
 	(get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))
 #define update_hiwater_rss(mm)	do {			\
 	unsigned long _rss = get_mm_rss(mm);		\
 	if ((mm)->hiwater_rss < _rss)			\
 		(mm)->hiwater_rss = _rss;		\
 } while (0)
 #define update_hiwater_vm(mm)	do {			\
 	if ((mm)->hiwater_vm < (mm)->total_vm)		\
 		(mm)->hiwater_vm = (mm)->total_vm;	\
 } while (0)
 #define get_mm_hiwater_rss(mm)	max((mm)->hiwater_rss, get_mm_rss(mm))
 #define get_mm_hiwater_vm(mm)	max((mm)->hiwater_vm, (mm)->total_vm)
 extern void set_dumpable(struct mm_struct *mm, int value);
 extern int get_dumpable(struct mm_struct *mm);
 /* mm flags */
 /* dumpable bits */
 #define MMF_DUMPABLE      0  /* core dump is permitted */
 #define MMF_DUMP_SECURELY 1  /* core file is readable only by root */
 #define MMF_DUMPABLE_BITS 2
 /* coredump filter bits */
 #define MMF_DUMP_ANON_PRIVATE	2
 #define MMF_DUMP_ANON_SHARED	3
 #define MMF_DUMP_MAPPED_PRIVATE	4
 #define MMF_DUMP_MAPPED_SHARED	5
 #define MMF_DUMP_ELF_HEADERS	6
 #define MMF_DUMP_HUGETLB_PRIVATE 7
 #define MMF_DUMP_HUGETLB_SHARED  8
 #define MMF_DUMP_FILTER_SHIFT	MMF_DUMPABLE_BITS
 #define MMF_DUMP_FILTER_BITS	7
 #define MMF_DUMP_FILTER_MASK \
 	(((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
 #define MMF_DUMP_FILTER_DEFAULT \
 	((1 << MMF_DUMP_ANON_PRIVATE) |	(1 << MMF_DUMP_ANON_SHARED) |\
 	 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
 #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
 # define MMF_DUMP_MASK_DEFAULT_ELF	(1 << MMF_DUMP_ELF_HEADERS)
 #else
 # define MMF_DUMP_MASK_DEFAULT_ELF	0
 #endif
 struct sighand_struct {
 	atomic_t		count;
 	struct k_sigaction	action[_NSIG];
 	spinlock_t		siglock;
 	wait_queue_head_t	signalfd_wqh;
 };
 struct pacct_struct {
 	int			ac_flag;
 	long			ac_exitcode;
 	unsigned long		ac_mem;
 	cputime_t		ac_utime, ac_stime;
 	unsigned long		ac_minflt, ac_majflt;
 };
 /**
  * struct task_cputime - collected CPU time counts
  * @utime:		time spent in user mode, in &cputime_t units
  * @stime:		time spent in kernel mode, in &cputime_t units
  * @sum_exec_runtime:	total time spent on the CPU, in nanoseconds
  *
  * This structure groups together three kinds of CPU time that are
  * tracked for threads and thread groups.  Most things considering
  * CPU time want to group these counts together and treat all three
  * of them in parallel.
  */
 struct task_cputime {
 	cputime_t utime;
 	cputime_t stime;
 	unsigned long long sum_exec_runtime;
 };
 /* Alternate field names when used to cache expirations. */
 #define prof_exp	stime
 #define virt_exp	utime
 #define sched_exp	sum_exec_runtime
 /**
  * struct thread_group_cputime - thread group interval timer counts
  * @totals:		thread group interval timers; substructure for
  *			uniprocessor kernel, per-cpu for SMP kernel.
  *
  * This structure contains the version of task_cputime, above, that is
  * used for thread group CPU clock calculations.
  */
 struct thread_group_cputime {
 	struct task_cputime *totals;
 };
 /*
  * NOTE! "signal_struct" does not have it's own
  * locking, because a shared signal_struct always
  * implies a shared sighand_struct, so locking
  * sighand_struct is always a proper superset of
  * the locking of signal_struct.
  */
 struct signal_struct {
 	atomic_t		count;
 	atomic_t		live;
 	wait_queue_head_t	wait_chldexit;	/* for wait4() */
 	/* current thread group signal load-balancing target: */
 	struct task_struct	*curr_target;
 	/* shared signal handling: */
 	struct sigpending	shared_pending;
 	/* thread group exit support */
 	int			group_exit_code;
 	/* overloaded:
 	 * - notify group_exit_task when ->count is equal to notify_count
 	 * - everyone except group_exit_task is stopped during signal delivery
 	 *   of fatal signals, group_exit_task processes the signal.
 	 */
 	int			notify_count;
 	struct task_struct	*group_exit_task;
 	/* thread group stop support, overloads group_exit_code too */
 	int			group_stop_count;
 	unsigned int		flags; /* see SIGNAL_* flags below */
 	/* POSIX.1b Interval Timers */
 	struct list_head posix_timers;
 	/* ITIMER_REAL timer for the process */
 	struct hrtimer real_timer;
 	struct pid *leader_pid;
 	ktime_t it_real_incr;
 	/* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
 	cputime_t it_prof_expires, it_virt_expires;
 	cputime_t it_prof_incr, it_virt_incr;
 	/*
 	 * Thread group totals for process CPU clocks.
 	 * See thread_group_cputime(), et al, for details.
 	 */
 	struct thread_group_cputime cputime;
 	/* Earliest-expiration cache. */
 	struct task_cputime cputime_expires;
 	struct list_head cpu_timers[3];
 	/* job control IDs */
 	/*
 	 * pgrp and session fields are deprecated.
 	 * use the task_session_Xnr and task_pgrp_Xnr routines below
 	 */
 	union {
 		pid_t pgrp __deprecated;
 		pid_t __pgrp;
 	};
 	struct pid *tty_old_pgrp;
 	union {
 		pid_t session __deprecated;
 		pid_t __session;
 	};
 	/* boolean value for session group leader */
 	int leader;
 	struct tty_struct *tty; /* NULL if no tty */
 	/*
 	 * Cumulative resource counters for dead threads in the group,
 	 * and for reaped dead child processes forked by this group.
 	 * Live threads maintain their own counters and add to these
 	 * in __exit_signal, except for the group leader.
 	 */
 	cputime_t cutime, cstime;
 	cputime_t gtime;
 	cputime_t cgtime;
 	unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
 	unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
 	unsigned long inblock, oublock, cinblock, coublock;
 	struct task_io_accounting ioac;
 	/*
 	 * We don't bother to synchronize most readers of this at all,
 	 * because there is no reader checking a limit that actually needs
 	 * to get both rlim_cur and rlim_max atomically, and either one
 	 * alone is a single word that can safely be read normally.
 	 * getrlimit/setrlimit use task_lock(current->group_leader) to
 	 * protect this instead of the siglock, because they really
 	 * have no need to disable irqs.
 	 */
 	struct rlimit rlim[RLIM_NLIMITS];
 #ifdef CONFIG_BSD_PROCESS_ACCT
 	struct pacct_struct pacct;	/* per-process accounting information */
 #endif
 #ifdef CONFIG_TASKSTATS
 	struct taskstats *stats;
 #endif
 #ifdef CONFIG_AUDIT
 	unsigned audit_tty;
 	struct tty_audit_buf *tty_audit_buf;
 #endif
 };
 /* Context switch must be unlocked if interrupts are to be enabled */
 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
 # define __ARCH_WANT_UNLOCKED_CTXSW
 #endif
 /*
  * Bits in flags field of signal_struct.
  */
 #define SIGNAL_STOP_STOPPED	0x00000001 /* job control stop in effect */
 #define SIGNAL_STOP_DEQUEUED	0x00000002 /* stop signal dequeued */
 #define SIGNAL_STOP_CONTINUED	0x00000004 /* SIGCONT since WCONTINUED reap */
 #define SIGNAL_GROUP_EXIT	0x00000008 /* group exit in progress */
 /*
  * Pending notifications to parent.
  */
 #define SIGNAL_CLD_STOPPED	0x00000010
 #define SIGNAL_CLD_CONTINUED	0x00000020
 #define SIGNAL_CLD_MASK		(SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
 #define SIGNAL_UNKILLABLE	0x00000040 /* for init: ignore fatal signals */
 /* If true, all threads except ->group_exit_task have pending SIGKILL */
 static inline int signal_group_exit(const struct signal_struct *sig)
 {
 	return	(sig->flags & SIGNAL_GROUP_EXIT) ||
 		(sig->group_exit_task != NULL);
 }
 /*
  * Some day this will be a full-fledged user tracking system..
  */
 struct user_struct {
 	atomic_t __count;	/* reference count */
 	atomic_t processes;	/* How many processes does this user have? */
 	atomic_t files;		/* How many open files does this user have? */
 	atomic_t sigpending;	/* How many pending signals does this user have? */
 #ifdef CONFIG_INOTIFY_USER
 	atomic_t inotify_watches; /* How many inotify watches does this user have? */
 	atomic_t inotify_devs;	/* How many inotify devs does this user have opened? */
 #endif
 #ifdef CONFIG_EPOLL
 	atomic_t epoll_devs;	/* The number of epoll descriptors currently open */
 	atomic_t epoll_watches;	/* The number of file descriptors currently watched */
 #endif
 #ifdef CONFIG_POSIX_MQUEUE
 	/* protected by mq_lock	*/
 	unsigned long mq_bytes;	/* How many bytes can be allocated to mqueue? */
 #endif
 	unsigned long locked_shm; /* How many pages of mlocked shm ? */
 #ifdef CONFIG_KEYS
 	struct key *uid_keyring;	/* UID specific keyring */
 	struct key *session_keyring;	/* UID's default session keyring */
 #endif
 	/* Hash table maintenance information */
 	struct hlist_node uidhash_node;
 	uid_t uid;
 	struct user_namespace *user_ns;
 #ifdef CONFIG_USER_SCHED
 	struct task_group *tg;
 #ifdef CONFIG_SYSFS
 	struct kobject kobj;
 	struct work_struct work;
 #endif
 #endif
 };
 extern int uids_sysfs_init(void);
 extern struct user_struct *find_user(uid_t);
 extern struct user_struct root_user;
 #define INIT_USER (&root_user)
 struct backing_dev_info;
 struct reclaim_state;
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
 struct sched_info {
 	/* cumulative counters */
 	unsigned long pcount;	      /* # of times run on this cpu */
 	unsigned long long run_delay; /* time spent waiting on a runqueue */
 	/* timestamps */
 	unsigned long long last_arrival,/* when we last ran on a cpu */
 			   last_queued;	/* when we were last queued to run */
 #ifdef CONFIG_SCHEDSTATS
 	/* BKL stats */
 	unsigned int bkl_count;
 #endif
 };
 #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
 #ifdef CONFIG_TASK_DELAY_ACCT
 struct task_delay_info {
 	spinlock_t	lock;
 	unsigned int	flags;	/* Private per-task flags */
 	/* For each stat XXX, add following, aligned appropriately
 	 *
 	 * struct timespec XXX_start, XXX_end;
 	 * u64 XXX_delay;
 	 * u32 XXX_count;
 	 *
 	 * Atomicity of updates to XXX_delay, XXX_count protected by
 	 * single lock above (split into XXX_lock if contention is an issue).
 	 */
 	/*
 	 * XXX_count is incremented on every XXX operation, the delay
 	 * associated with the operation is added to XXX_delay.
 	 * XXX_delay contains the accumulated delay time in nanoseconds.
 	 */
 	struct timespec blkio_start, blkio_end;	/* Shared by blkio, swapin */
 	u64 blkio_delay;	/* wait for sync block io completion */
 	u64 swapin_delay;	/* wait for swapin block io completion */
 	u32 blkio_count;	/* total count of the number of sync block */
 				/* io operations performed */
 	u32 swapin_count;	/* total count of the number of swapin block */
 				/* io operations performed */
 	struct timespec freepages_start, freepages_end;
 	u64 freepages_delay;	/* wait for memory reclaim */
 	u32 freepages_count;	/* total count of memory reclaim */
 };
 #endif	/* CONFIG_TASK_DELAY_ACCT */
 static inline int sched_info_on(void)
 {
 #ifdef CONFIG_SCHEDSTATS
 	return 1;
 #elif defined(CONFIG_TASK_DELAY_ACCT)
 	extern int delayacct_on;
 	return delayacct_on;
 #else
 	return 0;
 #endif
 }
 enum cpu_idle_type {
 	CPU_IDLE,
 	CPU_NOT_IDLE,
 	CPU_NEWLY_IDLE,
 	CPU_MAX_IDLE_TYPES
 };
 /*
  * sched-domains (multiprocessor balancing) declarations:
  */
 /*
  * Increase resolution of nice-level calculations:
  */
 #define SCHED_LOAD_SHIFT	10
 #define SCHED_LOAD_SCALE	(1L << SCHED_LOAD_SHIFT)
 #define SCHED_LOAD_SCALE_FUZZ	SCHED_LOAD_SCALE
 #ifdef CONFIG_SMP
 #define SD_LOAD_BALANCE		1	/* Do load balancing on this domain. */
 #define SD_BALANCE_NEWIDLE	2	/* Balance when about to become idle */
 #define SD_BALANCE_EXEC		4	/* Balance on exec */
 #define SD_BALANCE_FORK		8	/* Balance on fork, clone */
 #define SD_WAKE_IDLE		16	/* Wake to idle CPU on task wakeup */
 #define SD_WAKE_AFFINE		32	/* Wake task to waking CPU */
 #define SD_WAKE_BALANCE		64	/* Perform balancing at task wakeup */
 #define SD_SHARE_CPUPOWER	128	/* Domain members share cpu power */
 #define SD_POWERSAVINGS_BALANCE	256	/* Balance for power savings */
 #define SD_SHARE_PKG_RESOURCES	512	/* Domain members share cpu pkg resources */
 #define SD_SERIALIZE		1024	/* Only a single load balancing instance */
 #define SD_WAKE_IDLE_FAR	2048	/* Gain latency sacrificing cache hit */
 enum powersavings_balance_level {
 	POWERSAVINGS_BALANCE_NONE = 0,  /* No power saving load balance */
 	POWERSAVINGS_BALANCE_BASIC,	/* Fill one thread/core/package
 					 * first for long running threads
 					 */
 	POWERSAVINGS_BALANCE_WAKEUP,	/* Also bias task wakeups to semi-idle
 					 * cpu package for power savings
 					 */
 	MAX_POWERSAVINGS_BALANCE_LEVELS
 };
 extern int sched_mc_power_savings, sched_smt_power_savings;
 static inline int sd_balance_for_mc_power(void)
 {
 	if (sched_smt_power_savings)
 		return SD_POWERSAVINGS_BALANCE;
 	return 0;
 }
 static inline int sd_balance_for_package_power(void)
 {
 	if (sched_mc_power_savings | sched_smt_power_savings)
 		return SD_POWERSAVINGS_BALANCE;
 	return 0;
 }
 /*
  * Optimise SD flags for power savings:
  * SD_BALANCE_NEWIDLE helps agressive task consolidation and power savings.
  * Keep default SD flags if sched_{smt,mc}_power_saving=0
  */
 static inline int sd_power_saving_flags(void)
 {
 	if (sched_mc_power_savings | sched_smt_power_savings)
 		return SD_BALANCE_NEWIDLE;
 	return 0;
 }
 struct sched_group {
 	struct sched_group *next;	/* Must be a circular list */
 	/*
 	 * CPU power of this group, SCHED_LOAD_SCALE being max power for a
 	 * single CPU. This is read only (except for setup, hotplug CPU).
 	 * Note : Never change cpu_power without recompute its reciprocal
 	 */
 	unsigned int __cpu_power;
 	/*
 	 * reciprocal value of cpu_power to avoid expensive divides
 	 * (see include/linux/reciprocal_div.h)
 	 */
 	u32 reciprocal_cpu_power;
 	unsigned long cpumask[];
 };
 static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
 {
 	return to_cpumask(sg->cpumask);
 }
 enum sched_domain_level {
 	SD_LV_NONE = 0,
 	SD_LV_SIBLING,
 	SD_LV_MC,
 	SD_LV_CPU,
 	SD_LV_NODE,
 	SD_LV_ALLNODES,
 	SD_LV_MAX
 };
 struct sched_domain_attr {
 	int relax_domain_level;
 };
 #define SD_ATTR_INIT	(struct sched_domain_attr) {	\
 	.relax_domain_level = -1,			\
 }
 struct sched_domain {
 	/* These fields must be setup */
 	struct sched_domain *parent;	/* top domain must be null terminated */
 	struct sched_domain *child;	/* bottom domain must be null terminated */
 	struct sched_group *groups;	/* the balancing groups of the domain */
 	unsigned long min_interval;	/* Minimum balance interval ms */
 	unsigned long max_interval;	/* Maximum balance interval ms */
 	unsigned int busy_factor;	/* less balancing by factor if busy */
 	unsigned int imbalance_pct;	/* No balance until over watermark */
 	unsigned int cache_nice_tries;	/* Leave cache hot tasks for # tries */
 	unsigned int busy_idx;
 	unsigned int idle_idx;
 	unsigned int newidle_idx;
 	unsigned int wake_idx;
 	unsigned int forkexec_idx;
 	int flags;			/* See SD_* */
 	enum sched_domain_level level;
 	/* Runtime fields. */
 	unsigned long last_balance;	/* init to jiffies. units in jiffies */
 	unsigned int balance_interval;	/* initialise to 1. units in ms. */
 	unsigned int nr_balance_failed; /* initialise to 0 */
 	u64 last_update;
 #ifdef CONFIG_SCHEDSTATS
 	/* load_balance() stats */
 	unsigned int lb_count[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
 	/* Active load balancing */
 	unsigned int alb_count;
 	unsigned int alb_failed;
 	unsigned int alb_pushed;
 	/* SD_BALANCE_EXEC stats */
 	unsigned int sbe_count;
 	unsigned int sbe_balanced;
 	unsigned int sbe_pushed;
 	/* SD_BALANCE_FORK stats */
 	unsigned int sbf_count;
 	unsigned int sbf_balanced;
 	unsigned int sbf_pushed;
 	/* try_to_wake_up() stats */
 	unsigned int ttwu_wake_remote;
 	unsigned int ttwu_move_affine;
 	unsigned int ttwu_move_balance;
 #endif
 #ifdef CONFIG_SCHED_DEBUG
 	char *name;
 #endif
 	/* span of all CPUs in this domain */
 	unsigned long span[];
 };
 static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
 {
 	return to_cpumask(sd->span);
 }
 extern void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
 				    struct sched_domain_attr *dattr_new);
 /* Test a flag in parent sched domain */
 static inline int test_sd_parent(struct sched_domain *sd, int flag)
 {
 	if (sd->parent && (sd->parent->flags & flag))
 		return 1;
 	return 0;
 }
 #else /* CONFIG_SMP */
 struct sched_domain_attr;
 static inline void
 partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
 			struct sched_domain_attr *dattr_new)
 {
 }
 #endif	/* !CONFIG_SMP */
 struct io_context;			/* See blkdev.h */
 #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
 extern void prefetch_stack(struct task_struct *t);
 #else
 static inline void prefetch_stack(struct task_struct *t) { }
 #endif
 struct audit_context;		/* See audit.c */
 struct mempolicy;
 struct pipe_inode_info;
 struct uts_namespace;
 struct rq;
 struct sched_domain;
 struct sched_class {
 	const struct sched_class *next;
 	void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
 	void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
 	void (*yield_task) (struct rq *rq);
 	void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int sync);
 	struct task_struct * (*pick_next_task) (struct rq *rq);
 	void (*put_prev_task) (struct rq *rq, struct task_struct *p);
 #ifdef CONFIG_SMP
 	int  (*select_task_rq)(struct task_struct *p, int sync);
 	unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
 			struct rq *busiest, unsigned long max_load_move,
 			struct sched_domain *sd, enum cpu_idle_type idle,
 			int *all_pinned, int *this_best_prio);
 	int (*move_one_task) (struct rq *this_rq, int this_cpu,
 			      struct rq *busiest, struct sched_domain *sd,
 			      enum cpu_idle_type idle);
 	void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
 	void (*post_schedule) (struct rq *this_rq);
 	void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
 	void (*set_cpus_allowed)(struct task_struct *p,
 				 const struct cpumask *newmask);
 	void (*rq_online)(struct rq *rq);
 	void (*rq_offline)(struct rq *rq);
 #endif
 	void (*set_curr_task) (struct rq *rq);
 	void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
 	void (*task_new) (struct rq *rq, struct task_struct *p);
 	void (*switched_from) (struct rq *this_rq, struct task_struct *task,
 			       int running);
 	void (*switched_to) (struct rq *this_rq, struct task_struct *task,
 			     int running);
 	void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
 			     int oldprio, int running);
 #ifdef CONFIG_FAIR_GROUP_SCHED
 	void (*moved_group) (struct task_struct *p);
 #endif
 };
 struct load_weight {
 	unsigned long weight, inv_weight;
 };
 /*
  * CFS stats for a schedulable entity (task, task-group etc)
  *
  * Current field usage histogram:
  *
  *     4 se->block_start
  *     4 se->run_node
  *     4 se->sleep_start
  *     6 se->load.weight
  */
 struct sched_entity {
 	struct load_weight	load;		/* for load-balancing */
 	struct rb_node		run_node;
 	struct list_head	group_node;
 	unsigned int		on_rq;
 	u64			exec_start;
 	u64			sum_exec_runtime;
 	u64			vruntime;
 	u64			prev_sum_exec_runtime;
 	u64			last_wakeup;
 	u64			avg_overlap;
 #ifdef CONFIG_SCHEDSTATS
 	u64			wait_start;
 	u64			wait_max;
 	u64			wait_count;
 	u64			wait_sum;
 	u64			sleep_start;
 	u64			sleep_max;
 	s64			sum_sleep_runtime;
 	u64			block_start;
 	u64			block_max;
 	u64			exec_max;
 	u64			slice_max;
 	u64			nr_migrations;
 	u64			nr_migrations_cold;
 	u64			nr_failed_migrations_affine;
 	u64			nr_failed_migrations_running;
 	u64			nr_failed_migrations_hot;
 	u64			nr_forced_migrations;
 	u64			nr_forced2_migrations;
 	u64			nr_wakeups;
 	u64			nr_wakeups_sync;
 	u64			nr_wakeups_migrate;
 	u64			nr_wakeups_local;
 	u64			nr_wakeups_remote;
 	u64			nr_wakeups_affine;
 	u64			nr_wakeups_affine_attempts;
 	u64			nr_wakeups_passive;
 	u64			nr_wakeups_idle;
 #endif
 #ifdef CONFIG_FAIR_GROUP_SCHED
 	struct sched_entity	*parent;
 	/* rq on which this entity is (to be) queued: */
 	struct cfs_rq		*cfs_rq;
 	/* rq "owned" by this entity/group: */
 	struct cfs_rq		*my_q;
 #endif
 };
 struct sched_rt_entity {
 	struct list_head run_list;
 	unsigned long timeout;
 	unsigned int time_slice;
 	int nr_cpus_allowed;
 	struct sched_rt_entity *back;
 #ifdef CONFIG_RT_GROUP_SCHED
 	struct sched_rt_entity	*parent;
 	/* rq on which this entity is (to be) queued: */
 	struct rt_rq		*rt_rq;
 	/* rq "owned" by this entity/group: */
 	struct rt_rq		*my_q;
 #endif
 };
 struct task_struct {
 	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
 	void *stack;
 	atomic_t usage;
 	unsigned int flags;	/* per process flags, defined below */
 	unsigned int ptrace;
 	int lock_depth;		/* BKL lock depth */
 #ifdef CONFIG_SMP
 #ifdef __ARCH_WANT_UNLOCKED_CTXSW
 	int oncpu;
 #endif
 #endif
 	int prio, static_prio, normal_prio;
 	unsigned int rt_priority;
 	const struct sched_class *sched_class;
 	struct sched_entity se;
 	struct sched_rt_entity rt;
 #ifdef CONFIG_PREEMPT_NOTIFIERS
 	/* list of struct preempt_notifier: */
 	struct hlist_head preempt_notifiers;
 #endif
 	/*
 	 * fpu_counter contains the number of consecutive context switches
 	 * that the FPU is used. If this is over a threshold, the lazy fpu
 	 * saving becomes unlazy to save the trap. This is an unsigned char
 	 * so that after 256 times the counter wraps and the behavior turns
 	 * lazy again; this to deal with bursty apps that only use FPU for
 	 * a short time
 	 */
 	unsigned char fpu_counter;
 	s8 oomkilladj; /* OOM kill score adjustment (bit shift). */
 #ifdef CONFIG_BLK_DEV_IO_TRACE
 	unsigned int btrace_seq;
 #endif
 	unsigned int policy;
 	cpumask_t cpus_allowed;
 #ifdef CONFIG_PREEMPT_RCU
 	int rcu_read_lock_nesting;
 	int rcu_flipctr_idx;
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
 	struct sched_info sched_info;
 #endif
 	struct list_head tasks;
 	struct mm_struct *mm, *active_mm;
 /* task state */
 	struct linux_binfmt *binfmt;
 	int exit_state;
 	int exit_code, exit_signal;
 	int pdeath_signal;  /*  The signal sent when the parent dies  */
 	/* ??? */
 	unsigned int personality;
 	unsigned did_exec:1;
 	pid_t pid;
 	pid_t tgid;
 #ifdef CONFIG_CC_STACKPROTECTOR
 	/* Canary value for the -fstack-protector gcc feature */
 	unsigned long stack_canary;
 #endif
 	/*
 	 * pointers to (original) parent process, youngest child, younger sibling,
 	 * older sibling, respectively.  (p->father can be replaced with
 	 * p->real_parent->pid)
 	 */
 	struct task_struct *real_parent; /* real parent process */
 	struct task_struct *parent; /* recipient of SIGCHLD, wait4() reports */
 	/*
 	 * children/sibling forms the list of my natural children
 	 */
 	struct list_head children;	/* list of my children */
 	struct list_head sibling;	/* linkage in my parent's children list */
 	struct task_struct *group_leader;	/* threadgroup leader */
 	/*
 	 * ptraced is the list of tasks this task is using ptrace on.
 	 * This includes both natural children and PTRACE_ATTACH targets.
 	 * p->ptrace_entry is p's link on the p->parent->ptraced list.
 	 */
 	struct list_head ptraced;
 	struct list_head ptrace_entry;
 #ifdef CONFIG_X86_PTRACE_BTS
 	/*
 	 * This is the tracer handle for the ptrace BTS extension.
 	 * This field actually belongs to the ptracer task.
 	 */
 	struct bts_tracer *bts;
 	/*
 	 * The buffer to hold the BTS data.
 	 */
 	void *bts_buffer;
 	size_t bts_size;
 #endif /* CONFIG_X86_PTRACE_BTS */
 	/* PID/PID hash table linkage. */
 	struct pid_link pids[PIDTYPE_MAX];
 	struct list_head thread_group;
 	struct completion *vfork_done;		/* for vfork() */
 	int __user *set_child_tid;		/* CLONE_CHILD_SETTID */
 	int __user *clear_child_tid;		/* CLONE_CHILD_CLEARTID */
 	cputime_t utime, stime, utimescaled, stimescaled;
 	cputime_t gtime;
 	cputime_t prev_utime, prev_stime;
 	unsigned long nvcsw, nivcsw; /* context switch counts */
 	struct timespec start_time; 		/* monotonic time */
 	struct timespec real_start_time;	/* boot based time */
 /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
 	unsigned long min_flt, maj_flt;
 	struct task_cputime cputime_expires;
 	struct list_head cpu_timers[3];
 /* process credentials */
 	const struct cred *real_cred;	/* objective and real subjective task
 					 * credentials (COW) */
 	const struct cred *cred;	/* effective (overridable) subjective task
 					 * credentials (COW) */
 	struct mutex cred_exec_mutex;	/* execve vs ptrace cred calculation mutex */
 	char comm[TASK_COMM_LEN]; /* executable name excluding path
 				     - access with [gs]et_task_comm (which lock
 				       it with task_lock())
 				     - initialized normally by flush_old_exec */
 /* file system info */
 	int link_count, total_link_count;
 #ifdef CONFIG_SYSVIPC
 /* ipc stuff */
 	struct sysv_sem sysvsem;
 #endif
 #ifdef CONFIG_DETECT_SOFTLOCKUP
 /* hung task detection */
 	unsigned long last_switch_timestamp;
 	unsigned long last_switch_count;
 #endif
 /* CPU-specific state of this task */
 	struct thread_struct thread;
 /* filesystem information */
 	struct fs_struct *fs;
 /* open file information */
 	struct files_struct *files;
 /* namespaces */
 	struct nsproxy *nsproxy;
 /* signal handlers */
 	struct signal_struct *signal;
 	struct sighand_struct *sighand;
 	sigset_t blocked, real_blocked;
 	sigset_t saved_sigmask;	/* restored if set_restore_sigmask() was used */
 	struct sigpending pending;
 	unsigned long sas_ss_sp;
 	size_t sas_ss_size;
 	int (*notifier)(void *priv);
 	void *notifier_data;
 	sigset_t *notifier_mask;
 	struct audit_context *audit_context;
 #ifdef CONFIG_AUDITSYSCALL
 	uid_t loginuid;
 	unsigned int sessionid;
 #endif
 	seccomp_t seccomp;
 /* Thread group tracking */
    	u32 parent_exec_id;
    	u32 self_exec_id;
 /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
 	spinlock_t alloc_lock;
 	/* Protection of the PI data structures: */
 	spinlock_t pi_lock;
 #ifdef CONFIG_RT_MUTEXES
 	/* PI waiters blocked on a rt_mutex held by this task */
 	struct plist_head pi_waiters;
 	/* Deadlock detection and priority inheritance handling */
 	struct rt_mutex_waiter *pi_blocked_on;
 #endif
 #ifdef CONFIG_DEBUG_MUTEXES
 	/* mutex deadlock detection */
 	struct mutex_waiter *blocked_on;
 #endif
 #ifdef CONFIG_TRACE_IRQFLAGS
 	unsigned int irq_events;
 	int hardirqs_enabled;
 	unsigned long hardirq_enable_ip;
 	unsigned int hardirq_enable_event;
 	unsigned long hardirq_disable_ip;
 	unsigned int hardirq_disable_event;
 	int softirqs_enabled;
 	unsigned long softirq_disable_ip;
 	unsigned int softirq_disable_event;
 	unsigned long softirq_enable_ip;
 	unsigned int softirq_enable_event;
 	int hardirq_context;
 	int softirq_context;
 #endif
 #ifdef CONFIG_LOCKDEP
 # define MAX_LOCK_DEPTH 48UL
 	u64 curr_chain_key;
 	int lockdep_depth;
 	unsigned int lockdep_recursion;
 	struct held_lock held_locks[MAX_LOCK_DEPTH];
 #endif
 /* journalling filesystem info */
 	void *journal_info;
 /* stacked block device info */
 	struct bio *bio_list, **bio_tail;
 /* VM state */
 	struct reclaim_state *reclaim_state;
 	struct backing_dev_info *backing_dev_info;
 	struct io_context *io_context;
 	unsigned long ptrace_message;
 	siginfo_t *last_siginfo; /* For ptrace use.  */
 	struct task_io_accounting ioac;
 #if defined(CONFIG_TASK_XACCT)
 	u64 acct_rss_mem1;	/* accumulated rss usage */
 	u64 acct_vm_mem1;	/* accumulated virtual memory usage */
 	cputime_t acct_timexpd;	/* stime + utime since last update */
 #endif
 #ifdef CONFIG_CPUSETS
 	nodemask_t mems_allowed;
 	int cpuset_mems_generation;
 	int cpuset_mem_spread_rotor;
 #endif
 #ifdef CONFIG_CGROUPS
 	/* Control Group info protected by css_set_lock */
 	struct css_set *cgroups;
 	/* cg_list protected by css_set_lock and tsk->alloc_lock */
 	struct list_head cg_list;
 #endif
 #ifdef CONFIG_FUTEX
 	struct robust_list_head __user *robust_list;
 #ifdef CONFIG_COMPAT
 	struct compat_robust_list_head __user *compat_robust_list;
 #endif
 	struct list_head pi_state_list;
 	struct futex_pi_state *pi_state_cache;
 #endif
 #ifdef CONFIG_NUMA
 	struct mempolicy *mempolicy;
 	short il_next;
 #endif
 	atomic_t fs_excl;	/* holding fs exclusive resources */
 	struct rcu_head rcu;
 	/*
 	 * cache last used pipe for splice
 	 */
 	struct pipe_inode_info *splice_pipe;
 #ifdef	CONFIG_TASK_DELAY_ACCT
 	struct task_delay_info *delays;
 #endif
 #ifdef CONFIG_FAULT_INJECTION
 	int make_it_fail;
 #endif
 	struct prop_local_single dirties;
 #ifdef CONFIG_LATENCYTOP
 	int latency_record_count;
 	struct latency_record latency_record[LT_SAVECOUNT];
 #endif
 	/*
 	 * time slack values; these are used to round up poll() and
 	 * select() etc timeout values. These are in nanoseconds.
 	 */
 	unsigned long timer_slack_ns;
 	unsigned long default_timer_slack_ns;
 	struct list_head	*scm_work_list;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 	/* Index of current stored adress in ret_stack */
 	int curr_ret_stack;
 	/* Stack of return addresses for return function tracing */
 	struct ftrace_ret_stack	*ret_stack;
 	/*
 	 * Number of functions that haven't been traced
 	 * because of depth overrun.
 	 */
 	atomic_t trace_overrun;
 	/* Pause for the tracing */
 	atomic_t tracing_graph_pause;
 #endif
 #ifdef CONFIG_TRACING
 	/* state flags for use by tracers */
 	unsigned long trace;
 #endif
 };
 /*
  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
  * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
  * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
  * values are inverted: lower p->prio value means higher priority.
  *
  * The MAX_USER_RT_PRIO value allows the actual maximum
  * RT priority to be separate from the value exported to
  * user-space.  This allows kernel threads to set their
  * priority to a value higher than any user task. Note:
  * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
  */
 #define MAX_USER_RT_PRIO	100
 #define MAX_RT_PRIO		MAX_USER_RT_PRIO
 #define MAX_PRIO		(MAX_RT_PRIO + 40)
 #define DEFAULT_PRIO		(MAX_RT_PRIO + 20)
 static inline int rt_prio(int prio)
 {
 	if (unlikely(prio < MAX_RT_PRIO))
 		return 1;
 	return 0;
 }
 static inline int rt_task(struct task_struct *p)
 {
 	return rt_prio(p->prio);
 }
 static inline void set_task_session(struct task_struct *tsk, pid_t session)
 {
 	tsk->signal->__session = session;
 }
 static inline void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
 {
 	tsk->signal->__pgrp = pgrp;
 }
 static inline struct pid *task_pid(struct task_struct *task)
 {
 	return task->pids[PIDTYPE_PID].pid;
 }
 static inline struct pid *task_tgid(struct task_struct *task)
 {
 	return task->group_leader->pids[PIDTYPE_PID].pid;
 }
 static inline struct pid *task_pgrp(struct task_struct *task)
 {
 	return task->group_leader->pids[PIDTYPE_PGID].pid;
 }
 static inline struct pid *task_session(struct task_struct *task)
 {
 	return task->group_leader->pids[PIDTYPE_SID].pid;
 }
 struct pid_namespace;
 /*
  * the helpers to get the task's different pids as they are seen
  * from various namespaces
  *
  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
  *                     current.
  * task_xid_nr_ns()  : id seen from the ns specified;
  *
  * set_task_vxid()   : assigns a virtual id to a task;
  *
  * see also pid_nr() etc in include/linux/pid.h
  */
 static inline pid_t task_pid_nr(struct task_struct *tsk)
 {
 	return tsk->pid;
 }
 pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
 static inline pid_t task_pid_vnr(struct task_struct *tsk)
 {
 	return pid_vnr(task_pid(tsk));
 }
 static inline pid_t task_tgid_nr(struct task_struct *tsk)
 {
 	return tsk->tgid;
 }
 pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
 {
 	return pid_vnr(task_tgid(tsk));
 }
 static inline pid_t task_pgrp_nr(struct task_struct *tsk)
 {
 	return tsk->signal->__pgrp;
 }
 pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
 {
 	return pid_vnr(task_pgrp(tsk));
 }
 static inline pid_t task_session_nr(struct task_struct *tsk)
 {
 	return tsk->signal->__session;
 }
 pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
 static inline pid_t task_session_vnr(struct task_struct *tsk)
 {
 	return pid_vnr(task_session(tsk));
 }
 /**
  * pid_alive - check that a task structure is not stale
  * @p: Task structure to be checked.
  *
  * Test if a process is not yet dead (at most zombie state)
  * If pid_alive fails, then pointers within the task structure
  * can be stale and must not be dereferenced.
  */
 static inline int pid_alive(struct task_struct *p)
 {
 	return p->pids[PIDTYPE_PID].pid != NULL;
 }
 /**
  * is_global_init - check if a task structure is init
  * @tsk: Task structure to be checked.
  *
  * Check if a task structure is the first user space task the kernel created.
  */
 static inline int is_global_init(struct task_struct *tsk)
 {
 	return tsk->pid == 1;
 }
 /*
  * is_container_init:
  * check whether in the task is init in its own pid namespace.
  */
 extern int is_container_init(struct task_struct *tsk);
 extern struct pid *cad_pid;
 extern void free_task(struct task_struct *tsk);
 #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
 extern void __put_task_struct(struct task_struct *t);
 static inline void put_task_struct(struct task_struct *t)
 {
 	if (atomic_dec_and_test(&t->usage))
 		__put_task_struct(t);
 }
 extern cputime_t task_utime(struct task_struct *p);
 extern cputime_t task_stime(struct task_struct *p);
 extern cputime_t task_gtime(struct task_struct *p);
 /*
  * Per process flags
  */
 #define PF_ALIGNWARN	0x00000001	/* Print alignment warning msgs */
 					/* Not implemented yet, only for 486*/
 #define PF_STARTING	0x00000002	/* being created */
 #define PF_EXITING	0x00000004	/* getting shut down */
 #define PF_EXITPIDONE	0x00000008	/* pi exit done on shut down */
 #define PF_VCPU		0x00000010	/* I'm a virtual CPU */
 #define PF_FORKNOEXEC	0x00000040	/* forked but didn't exec */
 #define PF_SUPERPRIV	0x00000100	/* used super-user privileges */
 #define PF_DUMPCORE	0x00000200	/* dumped core */
 #define PF_SIGNALED	0x00000400	/* killed by a signal */
 #define PF_MEMALLOC	0x00000800	/* Allocating memory */
 #define PF_FLUSHER	0x00001000	/* responsible for disk writeback */
 #define PF_USED_MATH	0x00002000	/* if unset the fpu must be initialized before use */
 #define PF_NOFREEZE	0x00008000	/* this thread should not be frozen */
 #define PF_FROZEN	0x00010000	/* frozen for system suspend */
 #define PF_FSTRANS	0x00020000	/* inside a filesystem transaction */
 #define PF_KSWAPD	0x00040000	/* I am kswapd */
 #define PF_SWAPOFF	0x00080000	/* I am in swapoff */
 #define PF_LESS_THROTTLE 0x00100000	/* Throttle me less: I clean memory */
 #define PF_KTHREAD	0x00200000	/* I am a kernel thread */
 #define PF_RANDOMIZE	0x00400000	/* randomize virtual address space */
 #define PF_SWAPWRITE	0x00800000	/* Allowed to write to swap */
 #define PF_SPREAD_PAGE	0x01000000	/* Spread page cache over cpuset */
 #define PF_SPREAD_SLAB	0x02000000	/* Spread some slab caches over cpuset */
 #define PF_THREAD_BOUND	0x04000000	/* Thread bound to specific cpu */
 #define PF_MEMPOLICY	0x10000000	/* Non-default NUMA mempolicy */
 #define PF_MUTEX_TESTER	0x20000000	/* Thread belongs to the rt mutex tester */
 #define PF_FREEZER_SKIP	0x40000000	/* Freezer should not count it as freezeable */
 #define PF_FREEZER_NOSIG 0x80000000	/* Freezer won't send signals to it */
 /*
  * Only the _current_ task can read/write to tsk->flags, but other
  * tasks can access tsk->flags in readonly mode for example
  * with tsk_used_math (like during threaded core dumping).
  * There is however an exception to this rule during ptrace
  * or during fork: the ptracer task is allowed to write to the
  * child->flags of its traced child (same goes for fork, the parent
  * can write to the child->flags), because we're guaranteed the
  * child is not running and in turn not changing child->flags
  * at the same time the parent does it.
  */
 #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
 #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
 #define clear_used_math() clear_stopped_child_used_math(current)
 #define set_used_math() set_stopped_child_used_math(current)
 #define conditional_stopped_child_used_math(condition, child) \
 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
 #define conditional_used_math(condition) \
 	conditional_stopped_child_used_math(condition, current)
 #define copy_to_stopped_child_used_math(child) \
 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
 /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
 #define used_math() tsk_used_math(current)
 #ifdef CONFIG_SMP
 extern int set_cpus_allowed_ptr(struct task_struct *p,
 				const struct cpumask *new_mask);
 #else
 static inline int set_cpus_allowed_ptr(struct task_struct *p,
 				       const struct cpumask *new_mask)
 {
 	if (!cpumask_test_cpu(0, new_mask))
 		return -EINVAL;
 	return 0;
 }
 #endif
 static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
 {
 	return set_cpus_allowed_ptr(p, &new_mask);
 }
 extern unsigned long long sched_clock(void);
 extern void sched_clock_init(void);
 extern u64 sched_clock_cpu(int cpu);
 #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
 static inline void sched_clock_tick(void)
 {
 }
 static inline void sched_clock_idle_sleep_event(void)
 {
 }
 static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
 {
 }
 #else
 extern void sched_clock_tick(void);
 extern void sched_clock_idle_sleep_event(void);
 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
 #endif
 /*
  * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
  * clock constructed from sched_clock():
  */
 extern unsigned long long cpu_clock(int cpu);
 extern unsigned long long
 task_sched_runtime(struct task_struct *task);
 extern unsigned long long thread_group_sched_runtime(struct task_struct *task);
 /* sched_exec is called by processes performing an exec */
 #ifdef CONFIG_SMP
 extern void sched_exec(void);
 #else
 #define sched_exec()   {}
 #endif
 extern void sched_clock_idle_sleep_event(void);
 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
 #ifdef CONFIG_HOTPLUG_CPU
 extern void idle_task_exit(void);
 #else
 static inline void idle_task_exit(void) {}
 #endif
 extern void sched_idle_next(void);
 #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
 extern void wake_up_idle_cpu(int cpu);
 #else
 static inline void wake_up_idle_cpu(int cpu) { }
 #endif
 extern unsigned int sysctl_sched_latency;
 extern unsigned int sysctl_sched_min_granularity;
 extern unsigned int sysctl_sched_wakeup_granularity;
 extern unsigned int sysctl_sched_shares_ratelimit;
 extern unsigned int sysctl_sched_shares_thresh;
 #ifdef CONFIG_SCHED_DEBUG
 extern unsigned int sysctl_sched_child_runs_first;
 extern unsigned int sysctl_sched_features;
 extern unsigned int sysctl_sched_migration_cost;
 extern unsigned int sysctl_sched_nr_migrate;
 int sched_nr_latency_handler(struct ctl_table *table, int write,
 		struct file *file, void __user *buffer, size_t *length,
 		loff_t *ppos);
 #endif
 extern unsigned int sysctl_sched_rt_period;
 extern int sysctl_sched_rt_runtime;
 int sched_rt_handler(struct ctl_table *table, int write,
 		struct file *filp, void __user *buffer, size_t *lenp,
 		loff_t *ppos);
 extern unsigned int sysctl_sched_compat_yield;
 #ifdef CONFIG_RT_MUTEXES
 extern int rt_mutex_getprio(struct task_struct *p);
 extern void rt_mutex_setprio(struct task_struct *p, int prio);
 extern void rt_mutex_adjust_pi(struct task_struct *p);
 #else
 static inline int rt_mutex_getprio(struct task_struct *p)
 {
 	return p->normal_prio;
 }
 # define rt_mutex_adjust_pi(p)		do { } while (0)
 #endif
 extern void set_user_nice(struct task_struct *p, long nice);
 extern int task_prio(const struct task_struct *p);
 extern int task_nice(const struct task_struct *p);
 extern int can_nice(const struct task_struct *p, const int nice);
 extern int task_curr(const struct task_struct *p);
 extern int idle_cpu(int cpu);
 extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
 extern int sched_setscheduler_nocheck(struct task_struct *, int,
 				      struct sched_param *);
 extern struct task_struct *idle_task(int cpu);
 extern struct task_struct *curr_task(int cpu);
 extern void set_curr_task(int cpu, struct task_struct *p);
 void yield(void);
 /*
  * The default (Linux) execution domain.
  */
 extern struct exec_domain	default_exec_domain;
 union thread_union {
 	struct thread_info thread_info;
 	unsigned long stack[THREAD_SIZE/sizeof(long)];
 };
 #ifndef __HAVE_ARCH_KSTACK_END
 static inline int kstack_end(void *addr)
 {
 	/* Reliable end of stack detection:
 	 * Some APM bios versions misalign the stack
 	 */
 	return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
 }
 #endif
 extern union thread_union init_thread_union;
 extern struct task_struct init_task;
 extern struct   mm_struct init_mm;
 extern struct pid_namespace init_pid_ns;
 /*
  * find a task by one of its numerical ids
  *
  * find_task_by_pid_type_ns():
  *      it is the most generic call - it finds a task by all id,
  *      type and namespace specified
  * find_task_by_pid_ns():
  *      finds a task by its pid in the specified namespace
  * find_task_by_vpid():
  *      finds a task by its virtual pid
  *
  * see also find_vpid() etc in include/linux/pid.h
  */
 extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
 		struct pid_namespace *ns);
 extern struct task_struct *find_task_by_vpid(pid_t nr);
 extern struct task_struct *find_task_by_pid_ns(pid_t nr,
 		struct pid_namespace *ns);
 extern void __set_special_pids(struct pid *pid);
 /* per-UID process charging. */
 extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
 static inline struct user_struct *get_uid(struct user_struct *u)
 {
 	atomic_inc(&u->__count);
 	return u;
 }
 extern void free_uid(struct user_struct *);
 extern void release_uids(struct user_namespace *ns);
 #include <asm/current.h>
 extern void do_timer(unsigned long ticks);
 extern int wake_up_state(struct task_struct *tsk, unsigned int state);
 extern int wake_up_process(struct task_struct *tsk);
 extern void wake_up_new_task(struct task_struct *tsk,
 				unsigned long clone_flags);
 #ifdef CONFIG_SMP
  extern void kick_process(struct task_struct *tsk);
 #else
  static inline void kick_process(struct task_struct *tsk) { }
 #endif
 extern void sched_fork(struct task_struct *p, int clone_flags);
 extern void sched_dead(struct task_struct *p);
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
 static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 {
 	unsigned long flags;
 	int ret;
 	spin_lock_irqsave(&tsk->sighand->siglock, flags);
 	ret = dequeue_signal(tsk, mask, info);
 	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
 	return ret;
 }
 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
 			      sigset_t *mask);
 extern void unblock_all_signals(void);
 extern void release_task(struct task_struct * p);
 extern int send_sig_info(int, struct siginfo *, struct task_struct *);
 extern int force_sigsegv(int, struct task_struct *);
 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
 extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
 extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
 extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
 extern int kill_pgrp(struct pid *pid, int sig, int priv);
 extern int kill_pid(struct pid *pid, int sig, int priv);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
 extern int do_notify_parent(struct task_struct *, int);
 extern void force_sig(int, struct task_struct *);
 extern void force_sig_specific(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
 extern void zap_other_threads(struct task_struct *p);
 extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
 extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
 extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
 static inline int kill_cad_pid(int sig, int priv)
 {
 	return kill_pid(cad_pid, sig, priv);
 }
 /* These can be the second arg to send_sig_info/send_group_sig_info.  */
 #define SEND_SIG_NOINFO ((struct siginfo *) 0)
 #define SEND_SIG_PRIV	((struct siginfo *) 1)
 #define SEND_SIG_FORCED	((struct siginfo *) 2)
 static inline int is_si_special(const struct siginfo *info)
 {
 	return info <= SEND_SIG_FORCED;
 }
 /* True if we are on the alternate signal stack.  */
 static inline int on_sig_stack(unsigned long sp)
 {
 	return (sp - current->sas_ss_sp < current->sas_ss_size);
 }
 static inline int sas_ss_flags(unsigned long sp)
 {
 	return (current->sas_ss_size == 0 ? SS_DISABLE
 		: on_sig_stack(sp) ? SS_ONSTACK : 0);
 }
 /*
  * Routines for handling mm_structs
  */
 extern struct mm_struct * mm_alloc(void);
 /* mmdrop drops the mm and the page tables */
 extern void __mmdrop(struct mm_struct *);
 static inline void mmdrop(struct mm_struct * mm)
 {
 	if (unlikely(atomic_dec_and_test(&mm->mm_count)))
 		__mmdrop(mm);
 }
 /* mmput gets rid of the mappings and all user-space */
 extern void mmput(struct mm_struct *);
 /* Grab a reference to a task's mm, if it is not already going away */
 extern struct mm_struct *get_task_mm(struct task_struct *task);
 /* Remove the current tasks stale references to the old mm_struct */
 extern void mm_release(struct task_struct *, struct mm_struct *);
 /* Allocate a new mm structure and copy contents from tsk->mm */
 extern struct mm_struct *dup_mm(struct task_struct *tsk);
 extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
 extern void flush_thread(void);
 extern void exit_thread(void);
 extern void exit_files(struct task_struct *);
 extern void __cleanup_signal(struct signal_struct *);
 extern void __cleanup_sighand(struct sighand_struct *);
 extern void exit_itimers(struct signal_struct *);
 extern void flush_itimer_signals(void);
 extern NORET_TYPE void do_group_exit(int);
 extern void daemonize(const char *, ...);
 extern int allow_signal(int);
 extern int disallow_signal(int);
 extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
 extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
 struct task_struct *fork_idle(int);
 extern void set_task_comm(struct task_struct *tsk, char *from);
 extern char *get_task_comm(char *to, struct task_struct *tsk);
 #ifdef CONFIG_SMP
 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
 #else
 static inline unsigned long wait_task_inactive(struct task_struct *p,
 					       long match_state)
 {
 	return 1;
 }
 #endif
 #define next_task(p)	list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
 #define for_each_process(p) \
 	for (p = &init_task ; (p = next_task(p)) != &init_task ; )
 extern bool is_single_threaded(struct task_struct *);
 /*
  * Careful: do_each_thread/while_each_thread is a double loop so
  *          'break' will not work as expected - use goto instead.
  */
 #define do_each_thread(g, t) \
 	for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
 #define while_each_thread(g, t) \
 	while ((t = next_thread(t)) != g)
 /* de_thread depends on thread_group_leader not being a pid based check */
 #define thread_group_leader(p)	(p == p->group_leader)
 /* Do to the insanities of de_thread it is possible for a process
  * to have the pid of the thread group leader without actually being
  * the thread group leader.  For iteration through the pids in proc
  * all we care about is that we have a task with the appropriate
  * pid, we don't actually care if we have the right task.
  */
 static inline int has_group_leader_pid(struct task_struct *p)
 {
 	return p->pid == p->tgid;
 }
 static inline
 int same_thread_group(struct task_struct *p1, struct task_struct *p2)
 {
 	return p1->tgid == p2->tgid;
 }
 static inline struct task_struct *next_thread(const struct task_struct *p)
 {
 	return list_entry(rcu_dereference(p->thread_group.next),
 			  struct task_struct, thread_group);
 }
 static inline int thread_group_empty(struct task_struct *p)
 {
 	return list_empty(&p->thread_group);
 }
 #define delay_group_leader(p) \
 		(thread_group_leader(p) && !thread_group_empty(p))
 /*
  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
  * pins the final release of task.io_context.  Also protects ->cpuset and
  * ->cgroup.subsys[].
  *
  * Nests both inside and outside of read_lock(&tasklist_lock).
  * It must not be nested with write_lock_irq(&tasklist_lock),
  * neither inside nor outside.
  */
 static inline void task_lock(struct task_struct *p)
 {
 	spin_lock(&p->alloc_lock);
 }
 static inline void task_unlock(struct task_struct *p)
 {
 	spin_unlock(&p->alloc_lock);
 }
 extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
 							unsigned long *flags);
 static inline void unlock_task_sighand(struct task_struct *tsk,
 						unsigned long *flags)
 {
 	spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
 }
 #ifndef __HAVE_THREAD_FUNCTIONS
 #define task_thread_info(task)	((struct thread_info *)(task)->stack)
 #define task_stack_page(task)	((task)->stack)
 static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
 {
 	*task_thread_info(p) = *task_thread_info(org);
 	task_thread_info(p)->task = p;
 }
 static inline unsigned long *end_of_stack(struct task_struct *p)
 {
 	return (unsigned long *)(task_thread_info(p) + 1);
 }
 #endif
 static inline int object_is_on_stack(void *obj)
 {
 	void *stack = task_stack_page(current);
 	return (obj >= stack) && (obj < (stack + THREAD_SIZE));
 }
 extern void thread_info_cache_init(void);
 /* set thread flags in other task's structures
  * - see asm/thread_info.h for TIF_xxxx flags available
  */
 static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	set_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	return test_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline void set_tsk_need_resched(struct task_struct *tsk)
 {
 	set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
 }
 static inline void clear_tsk_need_resched(struct task_struct *tsk)
 {
 	clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
 }
 static inline int test_tsk_need_resched(struct task_struct *tsk)
 {
 	return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
 }
 static inline int signal_pending(struct task_struct *p)
 {
 	return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
 }
 extern int __fatal_signal_pending(struct task_struct *p);
 static inline int fatal_signal_pending(struct task_struct *p)
 {
 	return signal_pending(p) && __fatal_signal_pending(p);
 }
 static inline int signal_pending_state(long state, struct task_struct *p)
 {
 	if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
 		return 0;
 	if (!signal_pending(p))
 		return 0;
 	return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
 }
 static inline int need_resched(void)
 {
 	return unlikely(test_thread_flag(TIF_NEED_RESCHED));
 }
 /*
  * cond_resched() and cond_resched_lock(): latency reduction via
  * explicit rescheduling in places that are safe. The return
  * value indicates whether a reschedule was done in fact.
  * cond_resched_lock() will drop the spinlock before scheduling,
  * cond_resched_softirq() will enable bhs before scheduling.
  */
 extern int _cond_resched(void);
 #ifdef CONFIG_PREEMPT_BKL
 static inline int cond_resched(void)
 {
 	return 0;
 }
 #else
 static inline int cond_resched(void)
 {
 	return _cond_resched();
 }
 #endif
 extern int cond_resched_lock(spinlock_t * lock);
 extern int cond_resched_softirq(void);
 static inline int cond_resched_bkl(void)
 {
 	return _cond_resched();
 }
 /*
  * Does a critical section need to be broken due to another
  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
  * but a general need for low latency)
  */
 static inline int spin_needbreak(spinlock_t *lock)
 {
 #ifdef CONFIG_PREEMPT
 	return spin_is_contended(lock);
 #else
 	return 0;
 #endif
 }
 /*
  * Thread group CPU time accounting.
  */
 extern int thread_group_cputime_alloc(struct task_struct *);
 extern void thread_group_cputime(struct task_struct *, struct task_cputime *);
 static inline void thread_group_cputime_init(struct signal_struct *sig)
 {
 	sig->cputime.totals = NULL;
 }
 static inline int thread_group_cputime_clone_thread(struct task_struct *curr)
 {
 	if (curr->signal->cputime.totals)
 		return 0;
 	return thread_group_cputime_alloc(curr);
 }
 static inline void thread_group_cputime_free(struct signal_struct *sig)
 {
 	free_percpu(sig->cputime.totals);
 }
 /*
  * Reevaluate whether the task has signals pending delivery.
  * Wake the task if so.
  * This is required every time the blocked sigset_t changes.
  * callers must hold sighand->siglock.
  */
 extern void recalc_sigpending_and_wake(struct task_struct *t);
 extern void recalc_sigpending(void);
 extern void signal_wake_up(struct task_struct *t, int resume_stopped);
 /*
  * Wrappers for p->thread_info->cpu access. No-op on UP.
  */
 #ifdef CONFIG_SMP
 static inline unsigned int task_cpu(const struct task_struct *p)
 {
 	return task_thread_info(p)->cpu;
 }
 extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
 #else
 static inline unsigned int task_cpu(const struct task_struct *p)
 {
 	return 0;
 }
 static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
 {
 }
 #endif /* CONFIG_SMP */
 extern void arch_pick_mmap_layout(struct mm_struct *mm);
 #ifdef CONFIG_TRACING
 extern void
 __trace_special(void *__tr, void *__data,
 		unsigned long arg1, unsigned long arg2, unsigned long arg3);
 #else
 static inline void
 __trace_special(void *__tr, void *__data,
 		unsigned long arg1, unsigned long arg2, unsigned long arg3)
 {
 }
 #endif
 extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
 extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
 extern void normalize_rt_tasks(void);
 #ifdef CONFIG_GROUP_SCHED
 extern struct task_group init_task_group;
 #ifdef CONFIG_USER_SCHED
 extern struct task_group root_task_group;
 extern void set_tg_uid(struct user_struct *user);
 #endif
 extern struct task_group *sched_create_group(struct task_group *parent);
 extern void sched_destroy_group(struct task_group *tg);
 extern void sched_move_task(struct task_struct *tsk);
 #ifdef CONFIG_FAIR_GROUP_SCHED
 extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
 extern unsigned long sched_group_shares(struct task_group *tg);
 #endif
 #ifdef CONFIG_RT_GROUP_SCHED
 extern int sched_group_set_rt_runtime(struct task_group *tg,
 				      long rt_runtime_us);
 extern long sched_group_rt_runtime(struct task_group *tg);
 extern int sched_group_set_rt_period(struct task_group *tg,
 				      long rt_period_us);
 extern long sched_group_rt_period(struct task_group *tg);
 #endif
 #endif
 #ifdef CONFIG_TASK_XACCT
 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
 {
 	tsk->ioac.rchar += amt;
 }
 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
 {
 	tsk->ioac.wchar += amt;
 }
 static inline void inc_syscr(struct task_struct *tsk)
 {
 	tsk->ioac.syscr++;
 }
 static inline void inc_syscw(struct task_struct *tsk)
 {
 	tsk->ioac.syscw++;
 }
 #else
 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
 {
 }
 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
 {
 }
 static inline void inc_syscr(struct task_struct *tsk)
 {
 }
 static inline void inc_syscw(struct task_struct *tsk)
 {
 }
 #endif
 #ifndef TASK_SIZE_OF
 #define TASK_SIZE_OF(tsk)	TASK_SIZE
 #endif
 #ifdef CONFIG_MM_OWNER
 extern void mm_update_next_owner(struct mm_struct *mm);
 extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
 #else
 static inline void mm_update_next_owner(struct mm_struct *mm)
 {
 }
 static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
 {
 }
 #endif /* CONFIG_MM_OWNER */
 #define TASK_STATE_TO_CHAR_STR "RSDTtZX"
 #endif /* __KERNEL__ */
 #endif

kernel/softlockup.c

Diff comments View file @ baf48f6

 /*
  * Detect Soft Lockups
  *
  * started by Ingo Molnar, Copyright (C) 2005, 2006 Red Hat, Inc.
  *
  * this code detects soft lockups: incidents in where on a CPU
  * the kernel does not reschedule for 10 seconds or more.
  */
 #include <linux/mm.h>
 #include <linux/cpu.h>
 #include <linux/nmi.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/freezer.h>
 #include <linux/kthread.h>
 #include <linux/lockdep.h>
 #include <linux/notifier.h>
 #include <linux/module.h>
+#include <linux/sysctl.h>
 #include <asm/irq_regs.h>
 static DEFINE_SPINLOCK(print_lock);
 static DEFINE_PER_CPU(unsigned long, touch_timestamp);
 static DEFINE_PER_CPU(unsigned long, print_timestamp);
 static DEFINE_PER_CPU(struct task_struct *, watchdog_task);
 static int __read_mostly did_panic;
 int __read_mostly softlockup_thresh = 60;
 /*
  * Should we panic (and reboot, if panic_timeout= is set) when a
  * soft-lockup occurs:
  */
 unsigned int __read_mostly softlockup_panic =
 				CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
 static int __init softlockup_panic_setup(char *str)
 {
 	softlockup_panic = simple_strtoul(str, NULL, 0);
 	return 1;
 }
 __setup("softlockup_panic=", softlockup_panic_setup);
 static int
 softlock_panic(struct notifier_block *this, unsigned long event, void *ptr)
 {
 	did_panic = 1;
 	return NOTIFY_DONE;
 }
 static struct notifier_block panic_block = {
 	.notifier_call = softlock_panic,
 };
 /*
  * Returns seconds, approximately.  We don't need nanosecond
  * resolution, and we don't need to waste time with a big divide when
  * 2^30ns == 1.074s.
  */
 static unsigned long get_timestamp(int this_cpu)
 {
 	return cpu_clock(this_cpu) >> 30LL;  /* 2^30 ~= 10^9 */
 }
 static void __touch_softlockup_watchdog(void)
 {
 	int this_cpu = raw_smp_processor_id();
 	__raw_get_cpu_var(touch_timestamp) = get_timestamp(this_cpu);
 }
 void touch_softlockup_watchdog(void)
 {
 	__raw_get_cpu_var(touch_timestamp) = 0;
 }
 EXPORT_SYMBOL(touch_softlockup_watchdog);
 void touch_all_softlockup_watchdogs(void)
 {
 	int cpu;
 	/* Cause each CPU to re-update its timestamp rather than complain */
 	for_each_online_cpu(cpu)
 		per_cpu(touch_timestamp, cpu) = 0;
 }
 EXPORT_SYMBOL(touch_all_softlockup_watchdogs);
+int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
+			     struct file *filp, void __user *buffer,
+			     size_t *lenp, loff_t *ppos)
+{
+	touch_all_softlockup_watchdogs();
+	return proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos);
+}
 /*
  * This callback runs from the timer interrupt, and checks
  * whether the watchdog thread has hung or not:
  */
 void softlockup_tick(void)
 {
 	int this_cpu = smp_processor_id();
 	unsigned long touch_timestamp = per_cpu(touch_timestamp, this_cpu);
 	unsigned long print_timestamp;
 	struct pt_regs *regs = get_irq_regs();
 	unsigned long now;
 	/* Is detection switched off? */
 	if (!per_cpu(watchdog_task, this_cpu) || softlockup_thresh <= 0) {
 		/* Be sure we don't false trigger if switched back on */
 		if (touch_timestamp)
 			per_cpu(touch_timestamp, this_cpu) = 0;
 		return;
 	}
 	if (touch_timestamp == 0) {
 		__touch_softlockup_watchdog();
 		return;
 	}
 	print_timestamp = per_cpu(print_timestamp, this_cpu);
 	/* report at most once a second */
 	if (print_timestamp == touch_timestamp || did_panic)
 		return;
 	/* do not print during early bootup: */
 	if (unlikely(system_state != SYSTEM_RUNNING)) {
 		__touch_softlockup_watchdog();
 		return;
 	}
 	now = get_timestamp(this_cpu);
 	/*
 	 * Wake up the high-prio watchdog task twice per
 	 * threshold timespan.
 	 */
 	if (now > touch_timestamp + softlockup_thresh/2)
 		wake_up_process(per_cpu(watchdog_task, this_cpu));
 	/* Warn about unreasonable delays: */
 	if (now <= (touch_timestamp + softlockup_thresh))
 		return;
 	per_cpu(print_timestamp, this_cpu) = touch_timestamp;
 	spin_lock(&print_lock);
 	printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %lus! [%s:%d]\n",
 			this_cpu, now - touch_timestamp,
 			current->comm, task_pid_nr(current));
 	print_modules();
 	print_irqtrace_events(current);
 	if (regs)
 		show_regs(regs);
 	else
 		dump_stack();
 	spin_unlock(&print_lock);
 	if (softlockup_panic)
 		panic("softlockup: hung tasks");
 }
 /*
  * Have a reasonable limit on the number of tasks checked:
  */
 unsigned long __read_mostly sysctl_hung_task_check_count = 1024;
 /*
  * Zero means infinite timeout - no checking done:
  */
 unsigned long __read_mostly sysctl_hung_task_timeout_secs = 480;
 unsigned long __read_mostly sysctl_hung_task_warnings = 10;
 /*
  * Only do the hung-tasks check on one CPU:
  */
 static int check_cpu __read_mostly = -1;
 static void check_hung_task(struct task_struct *t, unsigned long now)
 {
 	unsigned long switch_count = t->nvcsw + t->nivcsw;
 	if (t->flags & PF_FROZEN)
 		return;
 	if (switch_count != t->last_switch_count || !t->last_switch_timestamp) {
 		t->last_switch_count = switch_count;
 		t->last_switch_timestamp = now;
 		return;
 	}
 	if ((long)(now - t->last_switch_timestamp) <
 					sysctl_hung_task_timeout_secs)
 		return;
 	if (!sysctl_hung_task_warnings)
 		return;
 	sysctl_hung_task_warnings--;
 	/*
 	 * Ok, the task did not get scheduled for more than 2 minutes,
 	 * complain:
 	 */
 	printk(KERN_ERR "INFO: task %s:%d blocked for more than "
 			"%ld seconds.\n", t->comm, t->pid,
 			sysctl_hung_task_timeout_secs);
 	printk(KERN_ERR "\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\""
 			" disables this message.\n");
 	sched_show_task(t);
 	__debug_show_held_locks(t);
 	t->last_switch_timestamp = now;
 	touch_nmi_watchdog();
 	if (softlockup_panic)
 		panic("softlockup: blocked tasks");
 }
 /*
  * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for
  * a really long time (120 seconds). If that happens, print out
  * a warning.
  */
 static void check_hung_uninterruptible_tasks(int this_cpu)
 {
 	int max_count = sysctl_hung_task_check_count;
 	unsigned long now = get_timestamp(this_cpu);
 	struct task_struct *g, *t;
 	/*
 	 * If the system crashed already then all bets are off,
 	 * do not report extra hung tasks:
 	 */
 	if (test_taint(TAINT_DIE) || did_panic)
 		return;
 	read_lock(&tasklist_lock);
 	do_each_thread(g, t) {
 		if (!--max_count)
 			goto unlock;
 		/* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */
 		if (t->state == TASK_UNINTERRUPTIBLE)
 			check_hung_task(t, now);
 	} while_each_thread(g, t);
  unlock:
 	read_unlock(&tasklist_lock);
 }
 /*
  * The watchdog thread - runs every second and touches the timestamp.
  */
 static int watchdog(void *__bind_cpu)
 {
 	struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
 	int this_cpu = (long)__bind_cpu;
 	sched_setscheduler(current, SCHED_FIFO, &param);
 	/* initialize timestamp */
 	__touch_softlockup_watchdog();
 	set_current_state(TASK_INTERRUPTIBLE);
 	/*
 	 * Run briefly once per second to reset the softlockup timestamp.
 	 * If this gets delayed for more than 60 seconds then the
 	 * debug-printout triggers in softlockup_tick().
 	 */
 	while (!kthread_should_stop()) {
 		__touch_softlockup_watchdog();
 		schedule();
 		if (kthread_should_stop())
 			break;
 		if (this_cpu == check_cpu) {
 			if (sysctl_hung_task_timeout_secs)
 				check_hung_uninterruptible_tasks(this_cpu);
 		}
 		set_current_state(TASK_INTERRUPTIBLE);
 	}
 	__set_current_state(TASK_RUNNING);
 	return 0;
 }
 /*
  * Create/destroy watchdog threads as CPUs come and go:
  */
 static int __cpuinit
 cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
 {
 	int hotcpu = (unsigned long)hcpu;
 	struct task_struct *p;
 	switch (action) {
 	case CPU_UP_PREPARE:
 	case CPU_UP_PREPARE_FROZEN:
 		BUG_ON(per_cpu(watchdog_task, hotcpu));
 		p = kthread_create(watchdog, hcpu, "watchdog/%d", hotcpu);
 		if (IS_ERR(p)) {
 			printk(KERN_ERR "watchdog for %i failed\n", hotcpu);
 			return NOTIFY_BAD;
 		}
 		per_cpu(touch_timestamp, hotcpu) = 0;
 		per_cpu(watchdog_task, hotcpu) = p;
 		kthread_bind(p, hotcpu);
 		break;
 	case CPU_ONLINE:
 	case CPU_ONLINE_FROZEN:
 		check_cpu = cpumask_any(cpu_online_mask);
 		wake_up_process(per_cpu(watchdog_task, hotcpu));
 		break;
 #ifdef CONFIG_HOTPLUG_CPU
 	case CPU_DOWN_PREPARE:
 	case CPU_DOWN_PREPARE_FROZEN:
 		if (hotcpu == check_cpu) {
 			/* Pick any other online cpu. */
 			check_cpu = cpumask_any_but(cpu_online_mask, hotcpu);
 		}
 		break;
 	case CPU_UP_CANCELED:
 	case CPU_UP_CANCELED_FROZEN:
 		if (!per_cpu(watchdog_task, hotcpu))
 			break;
 		/* Unbind so it can run.  Fall thru. */
 		kthread_bind(per_cpu(watchdog_task, hotcpu),
 			     cpumask_any(cpu_online_mask));
 	case CPU_DEAD:
 	case CPU_DEAD_FROZEN:
 		p = per_cpu(watchdog_task, hotcpu);
 		per_cpu(watchdog_task, hotcpu) = NULL;
 		kthread_stop(p);
 		break;
 #endif /* CONFIG_HOTPLUG_CPU */
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block __cpuinitdata cpu_nfb = {
 	.notifier_call = cpu_callback
 };
 static int __initdata nosoftlockup;
 static int __init nosoftlockup_setup(char *str)
 {
 	nosoftlockup = 1;
 	return 1;
 }
 __setup("nosoftlockup", nosoftlockup_setup);
 static int __init spawn_softlockup_task(void)
 {
 	void *cpu = (void *)(long)smp_processor_id();
 	int err;
 	if (nosoftlockup)
 		return 0;
 	err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
 	if (err == NOTIFY_BAD) {
 		BUG();
 		return 1;
 	}
 	cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
 	register_cpu_notifier(&cpu_nfb);
 	atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 	return 0;
 }
 early_initcall(spawn_softlockup_task);

kernel/sysctl.c

Diff comments View file @ baf48f6

1	/*	1	/*
2	* sysctl.c: General linux system control interface	2	* sysctl.c: General linux system control interface
3	*	3	*
4	* Begun 24 March 1995, Stephen Tweedie	4	* Begun 24 March 1995, Stephen Tweedie
5	* Added /proc support, Dec 1995	5	* Added /proc support, Dec 1995
6	* Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.	6	* Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
7	* Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.	7	* Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
8	* Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.	8	* Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
9	* Dynamic registration fixes, Stephen Tweedie.	9	* Dynamic registration fixes, Stephen Tweedie.
10	* Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.	10	* Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
11	* Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris	11	* Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
12	* Horn.	12	* Horn.
13	* Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.	13	* Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
14	* Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.	14	* Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
15	* Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill	15	* Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
16	* Wendling.	16	* Wendling.
17	* The list_for_each() macro wasn't appropriate for the sysctl loop.	17	* The list_for_each() macro wasn't appropriate for the sysctl loop.
18	* Removed it and replaced it with older style, 03/23/00, Bill Wendling	18	* Removed it and replaced it with older style, 03/23/00, Bill Wendling
19	*/	19	*/
20		20
21	#include <linux/module.h>	21	#include <linux/module.h>
22	#include <linux/mm.h>	22	#include <linux/mm.h>
23	#include <linux/swap.h>	23	#include <linux/swap.h>
24	#include <linux/slab.h>	24	#include <linux/slab.h>
25	#include <linux/sysctl.h>	25	#include <linux/sysctl.h>
26	#include <linux/proc_fs.h>	26	#include <linux/proc_fs.h>
27	#include <linux/security.h>	27	#include <linux/security.h>
28	#include <linux/ctype.h>	28	#include <linux/ctype.h>
29	#include <linux/utsname.h>	29	#include <linux/utsname.h>
30	#include <linux/smp_lock.h>	30	#include <linux/smp_lock.h>
31	#include <linux/fs.h>	31	#include <linux/fs.h>
32	#include <linux/init.h>	32	#include <linux/init.h>
33	#include <linux/kernel.h>	33	#include <linux/kernel.h>
34	#include <linux/kobject.h>	34	#include <linux/kobject.h>
35	#include <linux/net.h>	35	#include <linux/net.h>
36	#include <linux/sysrq.h>	36	#include <linux/sysrq.h>
37	#include <linux/highuid.h>	37	#include <linux/highuid.h>
38	#include <linux/writeback.h>	38	#include <linux/writeback.h>
39	#include <linux/hugetlb.h>	39	#include <linux/hugetlb.h>
40	#include <linux/initrd.h>	40	#include <linux/initrd.h>
41	#include <linux/key.h>	41	#include <linux/key.h>
42	#include <linux/times.h>	42	#include <linux/times.h>
43	#include <linux/limits.h>	43	#include <linux/limits.h>
44	#include <linux/dcache.h>	44	#include <linux/dcache.h>
45	#include <linux/syscalls.h>	45	#include <linux/syscalls.h>
46	#include <linux/vmstat.h>	46	#include <linux/vmstat.h>
47	#include <linux/nfs_fs.h>	47	#include <linux/nfs_fs.h>
48	#include <linux/acpi.h>	48	#include <linux/acpi.h>
49	#include <linux/reboot.h>	49	#include <linux/reboot.h>
50	#include <linux/ftrace.h>	50	#include <linux/ftrace.h>
51		51
52	#include <asm/uaccess.h>	52	#include <asm/uaccess.h>
53	#include <asm/processor.h>	53	#include <asm/processor.h>
54		54
55	#ifdef CONFIG_X86	55	#ifdef CONFIG_X86
56	#include <asm/nmi.h>	56	#include <asm/nmi.h>
57	#include <asm/stacktrace.h>	57	#include <asm/stacktrace.h>
58	#include <asm/io.h>	58	#include <asm/io.h>
59	#endif	59	#endif
60		60
61	static int deprecated_sysctl_warning(struct __sysctl_args *args);	61	static int deprecated_sysctl_warning(struct __sysctl_args *args);
62		62
63	#if defined(CONFIG_SYSCTL)	63	#if defined(CONFIG_SYSCTL)
64		64
65	/* External variables not in a header file. */	65	/* External variables not in a header file. */
66	extern int C_A_D;	66	extern int C_A_D;
67	extern int print_fatal_signals;	67	extern int print_fatal_signals;
68	extern int sysctl_overcommit_memory;	68	extern int sysctl_overcommit_memory;
69	extern int sysctl_overcommit_ratio;	69	extern int sysctl_overcommit_ratio;
70	extern int sysctl_panic_on_oom;	70	extern int sysctl_panic_on_oom;
71	extern int sysctl_oom_kill_allocating_task;	71	extern int sysctl_oom_kill_allocating_task;
72	extern int sysctl_oom_dump_tasks;	72	extern int sysctl_oom_dump_tasks;
73	extern int max_threads;	73	extern int max_threads;
74	extern int core_uses_pid;	74	extern int core_uses_pid;
75	extern int suid_dumpable;	75	extern int suid_dumpable;
76	extern char core_pattern[];	76	extern char core_pattern[];
77	extern int pid_max;	77	extern int pid_max;
78	extern int min_free_kbytes;	78	extern int min_free_kbytes;
79	extern int pid_max_min, pid_max_max;	79	extern int pid_max_min, pid_max_max;
80	extern int sysctl_drop_caches;	80	extern int sysctl_drop_caches;
81	extern int percpu_pagelist_fraction;	81	extern int percpu_pagelist_fraction;
82	extern int compat_log;	82	extern int compat_log;
83	extern int latencytop_enabled;	83	extern int latencytop_enabled;
84	extern int sysctl_nr_open_min, sysctl_nr_open_max;	84	extern int sysctl_nr_open_min, sysctl_nr_open_max;
85	#ifndef CONFIG_MMU	85	#ifndef CONFIG_MMU
86	extern int sysctl_nr_trim_pages;	86	extern int sysctl_nr_trim_pages;
87	#endif	87	#endif
88	#ifdef CONFIG_RCU_TORTURE_TEST	88	#ifdef CONFIG_RCU_TORTURE_TEST
89	extern int rcutorture_runnable;	89	extern int rcutorture_runnable;
90	#endif /* #ifdef CONFIG_RCU_TORTURE_TEST */	90	#endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
91		91
92	/* Constants used for minimum and maximum */	92	/* Constants used for minimum and maximum */
93	#ifdef CONFIG_DETECT_SOFTLOCKUP	93	#ifdef CONFIG_DETECT_SOFTLOCKUP
94	static int sixty = 60;	94	static int sixty = 60;
95	static int neg_one = -1;	95	static int neg_one = -1;
96	#endif	96	#endif
97		97
98	#if defined(CONFIG_MMU) && defined(CONFIG_FILE_LOCKING)	98	#if defined(CONFIG_MMU) && defined(CONFIG_FILE_LOCKING)
99	static int two = 2;	99	static int two = 2;
100	#endif	100	#endif
101		101
102	static int zero;	102	static int zero;
103	static int one = 1;	103	static int one = 1;
104	static int one_hundred = 100;	104	static int one_hundred = 100;
105		105
106	/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */	106	/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
107	static int maxolduid = 65535;	107	static int maxolduid = 65535;
108	static int minolduid;	108	static int minolduid;
109	static int min_percpu_pagelist_fract = 8;	109	static int min_percpu_pagelist_fract = 8;
110		110
111	static int ngroups_max = NGROUPS_MAX;	111	static int ngroups_max = NGROUPS_MAX;
112		112
113	#ifdef CONFIG_MODULES	113	#ifdef CONFIG_MODULES
114	extern char modprobe_path[];	114	extern char modprobe_path[];
115	#endif	115	#endif
116	#ifdef CONFIG_CHR_DEV_SG	116	#ifdef CONFIG_CHR_DEV_SG
117	extern int sg_big_buff;	117	extern int sg_big_buff;
118	#endif	118	#endif
119		119
120	#ifdef CONFIG_SPARC	120	#ifdef CONFIG_SPARC
121	#include <asm/system.h>	121	#include <asm/system.h>
122	#endif	122	#endif
123		123
124	#ifdef CONFIG_SPARC64	124	#ifdef CONFIG_SPARC64
125	extern int sysctl_tsb_ratio;	125	extern int sysctl_tsb_ratio;
126	#endif	126	#endif
127		127
128	#ifdef __hppa__	128	#ifdef __hppa__
129	extern int pwrsw_enabled;	129	extern int pwrsw_enabled;
130	extern int unaligned_enabled;	130	extern int unaligned_enabled;
131	#endif	131	#endif
132		132
133	#ifdef CONFIG_S390	133	#ifdef CONFIG_S390
134	#ifdef CONFIG_MATHEMU	134	#ifdef CONFIG_MATHEMU
135	extern int sysctl_ieee_emulation_warnings;	135	extern int sysctl_ieee_emulation_warnings;
136	#endif	136	#endif
137	extern int sysctl_userprocess_debug;	137	extern int sysctl_userprocess_debug;
138	extern int spin_retry;	138	extern int spin_retry;
139	#endif	139	#endif
140		140
141	#ifdef CONFIG_BSD_PROCESS_ACCT	141	#ifdef CONFIG_BSD_PROCESS_ACCT
142	extern int acct_parm[];	142	extern int acct_parm[];
143	#endif	143	#endif
144		144
145	#ifdef CONFIG_IA64	145	#ifdef CONFIG_IA64
146	extern int no_unaligned_warning;	146	extern int no_unaligned_warning;
147	#endif	147	#endif
148		148
149	#ifdef CONFIG_RT_MUTEXES	149	#ifdef CONFIG_RT_MUTEXES
150	extern int max_lock_depth;	150	extern int max_lock_depth;
151	#endif	151	#endif
152		152
153	#ifdef CONFIG_PROC_SYSCTL	153	#ifdef CONFIG_PROC_SYSCTL
154	static int proc_do_cad_pid(struct ctl_table table, int write, struct file filp,	154	static int proc_do_cad_pid(struct ctl_table table, int write, struct file filp,
155	void __user buffer, size_t lenp, loff_t *ppos);	155	void __user buffer, size_t lenp, loff_t *ppos);
156	static int proc_taint(struct ctl_table table, int write, struct file filp,	156	static int proc_taint(struct ctl_table table, int write, struct file filp,
157	void __user buffer, size_t lenp, loff_t *ppos);	157	void __user buffer, size_t lenp, loff_t *ppos);
158	#endif	158	#endif
159		159
160	static struct ctl_table root_table[];	160	static struct ctl_table root_table[];
161	static struct ctl_table_root sysctl_table_root;	161	static struct ctl_table_root sysctl_table_root;
162	static struct ctl_table_header root_table_header = {	162	static struct ctl_table_header root_table_header = {
163	.count = 1,	163	.count = 1,
164	.ctl_table = root_table,	164	.ctl_table = root_table,
165	.ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),	165	.ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),
166	.root = &sysctl_table_root,	166	.root = &sysctl_table_root,
167	.set = &sysctl_table_root.default_set,	167	.set = &sysctl_table_root.default_set,
168	};	168	};
169	static struct ctl_table_root sysctl_table_root = {	169	static struct ctl_table_root sysctl_table_root = {
170	.root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),	170	.root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),
171	.default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),	171	.default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),
172	};	172	};
173		173
174	static struct ctl_table kern_table[];	174	static struct ctl_table kern_table[];
175	static struct ctl_table vm_table[];	175	static struct ctl_table vm_table[];
176	static struct ctl_table fs_table[];	176	static struct ctl_table fs_table[];
177	static struct ctl_table debug_table[];	177	static struct ctl_table debug_table[];
178	static struct ctl_table dev_table[];	178	static struct ctl_table dev_table[];
179	extern struct ctl_table random_table[];	179	extern struct ctl_table random_table[];
180	#ifdef CONFIG_INOTIFY_USER	180	#ifdef CONFIG_INOTIFY_USER
181	extern struct ctl_table inotify_table[];	181	extern struct ctl_table inotify_table[];
182	#endif	182	#endif
183	#ifdef CONFIG_EPOLL	183	#ifdef CONFIG_EPOLL
184	extern struct ctl_table epoll_table[];	184	extern struct ctl_table epoll_table[];
185	#endif	185	#endif
186		186
187	#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT	187	#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
188	int sysctl_legacy_va_layout;	188	int sysctl_legacy_va_layout;
189	#endif	189	#endif
190		190
191	extern int prove_locking;	191	extern int prove_locking;
192	extern int lock_stat;	192	extern int lock_stat;
193		193
194	/* The default sysctl tables: */	194	/* The default sysctl tables: */
195		195
196	static struct ctl_table root_table[] = {	196	static struct ctl_table root_table[] = {
197	{	197	{
198	.ctl_name = CTL_KERN,	198	.ctl_name = CTL_KERN,
199	.procname = "kernel",	199	.procname = "kernel",
200	.mode = 0555,	200	.mode = 0555,
201	.child = kern_table,	201	.child = kern_table,
202	},	202	},
203	{	203	{
204	.ctl_name = CTL_VM,	204	.ctl_name = CTL_VM,
205	.procname = "vm",	205	.procname = "vm",
206	.mode = 0555,	206	.mode = 0555,
207	.child = vm_table,	207	.child = vm_table,
208	},	208	},
209	{	209	{
210	.ctl_name = CTL_FS,	210	.ctl_name = CTL_FS,
211	.procname = "fs",	211	.procname = "fs",
212	.mode = 0555,	212	.mode = 0555,
213	.child = fs_table,	213	.child = fs_table,
214	},	214	},
215	{	215	{
216	.ctl_name = CTL_DEBUG,	216	.ctl_name = CTL_DEBUG,
217	.procname = "debug",	217	.procname = "debug",
218	.mode = 0555,	218	.mode = 0555,
219	.child = debug_table,	219	.child = debug_table,
220	},	220	},
221	{	221	{
222	.ctl_name = CTL_DEV,	222	.ctl_name = CTL_DEV,
223	.procname = "dev",	223	.procname = "dev",
224	.mode = 0555,	224	.mode = 0555,
225	.child = dev_table,	225	.child = dev_table,
226	},	226	},
227	/*	227	/*
228	* NOTE: do not add new entries to this table unless you have read	228	* NOTE: do not add new entries to this table unless you have read
229	* Documentation/sysctl/ctl_unnumbered.txt	229	* Documentation/sysctl/ctl_unnumbered.txt
230	*/	230	*/
231	{ .ctl_name = 0 }	231	{ .ctl_name = 0 }
232	};	232	};
233		233
234	#ifdef CONFIG_SCHED_DEBUG	234	#ifdef CONFIG_SCHED_DEBUG
235	static int min_sched_granularity_ns = 100000; /* 100 usecs */	235	static int min_sched_granularity_ns = 100000; /* 100 usecs */
236	static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */	236	static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */
237	static int min_wakeup_granularity_ns; /* 0 usecs */	237	static int min_wakeup_granularity_ns; /* 0 usecs */
238	static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */	238	static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */
239	#endif	239	#endif
240		240
241	static struct ctl_table kern_table[] = {	241	static struct ctl_table kern_table[] = {
242	#ifdef CONFIG_SCHED_DEBUG	242	#ifdef CONFIG_SCHED_DEBUG
243	{	243	{
244	.ctl_name = CTL_UNNUMBERED,	244	.ctl_name = CTL_UNNUMBERED,
245	.procname = "sched_min_granularity_ns",	245	.procname = "sched_min_granularity_ns",
246	.data = &sysctl_sched_min_granularity,	246	.data = &sysctl_sched_min_granularity,
247	.maxlen = sizeof(unsigned int),	247	.maxlen = sizeof(unsigned int),
248	.mode = 0644,	248	.mode = 0644,
249	.proc_handler = &sched_nr_latency_handler,	249	.proc_handler = &sched_nr_latency_handler,
250	.strategy = &sysctl_intvec,	250	.strategy = &sysctl_intvec,
251	.extra1 = &min_sched_granularity_ns,	251	.extra1 = &min_sched_granularity_ns,
252	.extra2 = &max_sched_granularity_ns,	252	.extra2 = &max_sched_granularity_ns,
253	},	253	},
254	{	254	{
255	.ctl_name = CTL_UNNUMBERED,	255	.ctl_name = CTL_UNNUMBERED,
256	.procname = "sched_latency_ns",	256	.procname = "sched_latency_ns",
257	.data = &sysctl_sched_latency,	257	.data = &sysctl_sched_latency,
258	.maxlen = sizeof(unsigned int),	258	.maxlen = sizeof(unsigned int),
259	.mode = 0644,	259	.mode = 0644,
260	.proc_handler = &sched_nr_latency_handler,	260	.proc_handler = &sched_nr_latency_handler,
261	.strategy = &sysctl_intvec,	261	.strategy = &sysctl_intvec,
262	.extra1 = &min_sched_granularity_ns,	262	.extra1 = &min_sched_granularity_ns,
263	.extra2 = &max_sched_granularity_ns,	263	.extra2 = &max_sched_granularity_ns,
264	},	264	},
265	{	265	{
266	.ctl_name = CTL_UNNUMBERED,	266	.ctl_name = CTL_UNNUMBERED,
267	.procname = "sched_wakeup_granularity_ns",	267	.procname = "sched_wakeup_granularity_ns",
268	.data = &sysctl_sched_wakeup_granularity,	268	.data = &sysctl_sched_wakeup_granularity,
269	.maxlen = sizeof(unsigned int),	269	.maxlen = sizeof(unsigned int),
270	.mode = 0644,	270	.mode = 0644,
271	.proc_handler = &proc_dointvec_minmax,	271	.proc_handler = &proc_dointvec_minmax,
272	.strategy = &sysctl_intvec,	272	.strategy = &sysctl_intvec,
273	.extra1 = &min_wakeup_granularity_ns,	273	.extra1 = &min_wakeup_granularity_ns,
274	.extra2 = &max_wakeup_granularity_ns,	274	.extra2 = &max_wakeup_granularity_ns,
275	},	275	},
276	{	276	{
277	.ctl_name = CTL_UNNUMBERED,	277	.ctl_name = CTL_UNNUMBERED,
278	.procname = "sched_shares_ratelimit",	278	.procname = "sched_shares_ratelimit",
279	.data = &sysctl_sched_shares_ratelimit,	279	.data = &sysctl_sched_shares_ratelimit,
280	.maxlen = sizeof(unsigned int),	280	.maxlen = sizeof(unsigned int),
281	.mode = 0644,	281	.mode = 0644,
282	.proc_handler = &proc_dointvec,	282	.proc_handler = &proc_dointvec,
283	},	283	},
284	{	284	{
285	.ctl_name = CTL_UNNUMBERED,	285	.ctl_name = CTL_UNNUMBERED,
286	.procname = "sched_shares_thresh",	286	.procname = "sched_shares_thresh",
287	.data = &sysctl_sched_shares_thresh,	287	.data = &sysctl_sched_shares_thresh,
288	.maxlen = sizeof(unsigned int),	288	.maxlen = sizeof(unsigned int),
289	.mode = 0644,	289	.mode = 0644,
290	.proc_handler = &proc_dointvec_minmax,	290	.proc_handler = &proc_dointvec_minmax,
291	.strategy = &sysctl_intvec,	291	.strategy = &sysctl_intvec,
292	.extra1 = &zero,	292	.extra1 = &zero,
293	},	293	},
294	{	294	{
295	.ctl_name = CTL_UNNUMBERED,	295	.ctl_name = CTL_UNNUMBERED,
296	.procname = "sched_child_runs_first",	296	.procname = "sched_child_runs_first",
297	.data = &sysctl_sched_child_runs_first,	297	.data = &sysctl_sched_child_runs_first,
298	.maxlen = sizeof(unsigned int),	298	.maxlen = sizeof(unsigned int),
299	.mode = 0644,	299	.mode = 0644,
300	.proc_handler = &proc_dointvec,	300	.proc_handler = &proc_dointvec,
301	},	301	},
302	{	302	{
303	.ctl_name = CTL_UNNUMBERED,	303	.ctl_name = CTL_UNNUMBERED,
304	.procname = "sched_features",	304	.procname = "sched_features",
305	.data = &sysctl_sched_features,	305	.data = &sysctl_sched_features,
306	.maxlen = sizeof(unsigned int),	306	.maxlen = sizeof(unsigned int),
307	.mode = 0644,	307	.mode = 0644,
308	.proc_handler = &proc_dointvec,	308	.proc_handler = &proc_dointvec,
309	},	309	},
310	{	310	{
311	.ctl_name = CTL_UNNUMBERED,	311	.ctl_name = CTL_UNNUMBERED,
312	.procname = "sched_migration_cost",	312	.procname = "sched_migration_cost",
313	.data = &sysctl_sched_migration_cost,	313	.data = &sysctl_sched_migration_cost,
314	.maxlen = sizeof(unsigned int),	314	.maxlen = sizeof(unsigned int),
315	.mode = 0644,	315	.mode = 0644,
316	.proc_handler = &proc_dointvec,	316	.proc_handler = &proc_dointvec,
317	},	317	},
318	{	318	{
319	.ctl_name = CTL_UNNUMBERED,	319	.ctl_name = CTL_UNNUMBERED,
320	.procname = "sched_nr_migrate",	320	.procname = "sched_nr_migrate",
321	.data = &sysctl_sched_nr_migrate,	321	.data = &sysctl_sched_nr_migrate,
322	.maxlen = sizeof(unsigned int),	322	.maxlen = sizeof(unsigned int),
323	.mode = 0644,	323	.mode = 0644,
324	.proc_handler = &proc_dointvec,	324	.proc_handler = &proc_dointvec,
325	},	325	},
326	#endif	326	#endif
327	{	327	{
328	.ctl_name = CTL_UNNUMBERED,	328	.ctl_name = CTL_UNNUMBERED,
329	.procname = "sched_rt_period_us",	329	.procname = "sched_rt_period_us",
330	.data = &sysctl_sched_rt_period,	330	.data = &sysctl_sched_rt_period,
331	.maxlen = sizeof(unsigned int),	331	.maxlen = sizeof(unsigned int),
332	.mode = 0644,	332	.mode = 0644,
333	.proc_handler = &sched_rt_handler,	333	.proc_handler = &sched_rt_handler,
334	},	334	},
335	{	335	{
336	.ctl_name = CTL_UNNUMBERED,	336	.ctl_name = CTL_UNNUMBERED,
337	.procname = "sched_rt_runtime_us",	337	.procname = "sched_rt_runtime_us",
338	.data = &sysctl_sched_rt_runtime,	338	.data = &sysctl_sched_rt_runtime,
339	.maxlen = sizeof(int),	339	.maxlen = sizeof(int),
340	.mode = 0644,	340	.mode = 0644,
341	.proc_handler = &sched_rt_handler,	341	.proc_handler = &sched_rt_handler,
342	},	342	},
343	{	343	{
344	.ctl_name = CTL_UNNUMBERED,	344	.ctl_name = CTL_UNNUMBERED,
345	.procname = "sched_compat_yield",	345	.procname = "sched_compat_yield",
346	.data = &sysctl_sched_compat_yield,	346	.data = &sysctl_sched_compat_yield,
347	.maxlen = sizeof(unsigned int),	347	.maxlen = sizeof(unsigned int),
348	.mode = 0644,	348	.mode = 0644,
349	.proc_handler = &proc_dointvec,	349	.proc_handler = &proc_dointvec,
350	},	350	},
351	#ifdef CONFIG_PROVE_LOCKING	351	#ifdef CONFIG_PROVE_LOCKING
352	{	352	{
353	.ctl_name = CTL_UNNUMBERED,	353	.ctl_name = CTL_UNNUMBERED,
354	.procname = "prove_locking",	354	.procname = "prove_locking",
355	.data = &prove_locking,	355	.data = &prove_locking,
356	.maxlen = sizeof(int),	356	.maxlen = sizeof(int),
357	.mode = 0644,	357	.mode = 0644,
358	.proc_handler = &proc_dointvec,	358	.proc_handler = &proc_dointvec,
359	},	359	},
360	#endif	360	#endif
361	#ifdef CONFIG_LOCK_STAT	361	#ifdef CONFIG_LOCK_STAT
362	{	362	{
363	.ctl_name = CTL_UNNUMBERED,	363	.ctl_name = CTL_UNNUMBERED,
364	.procname = "lock_stat",	364	.procname = "lock_stat",
365	.data = &lock_stat,	365	.data = &lock_stat,
366	.maxlen = sizeof(int),	366	.maxlen = sizeof(int),
367	.mode = 0644,	367	.mode = 0644,
368	.proc_handler = &proc_dointvec,	368	.proc_handler = &proc_dointvec,
369	},	369	},
370	#endif	370	#endif
371	{	371	{
372	.ctl_name = KERN_PANIC,	372	.ctl_name = KERN_PANIC,
373	.procname = "panic",	373	.procname = "panic",
374	.data = &panic_timeout,	374	.data = &panic_timeout,
375	.maxlen = sizeof(int),	375	.maxlen = sizeof(int),
376	.mode = 0644,	376	.mode = 0644,
377	.proc_handler = &proc_dointvec,	377	.proc_handler = &proc_dointvec,
378	},	378	},
379	{	379	{
380	.ctl_name = KERN_CORE_USES_PID,	380	.ctl_name = KERN_CORE_USES_PID,
381	.procname = "core_uses_pid",	381	.procname = "core_uses_pid",
382	.data = &core_uses_pid,	382	.data = &core_uses_pid,
383	.maxlen = sizeof(int),	383	.maxlen = sizeof(int),
384	.mode = 0644,	384	.mode = 0644,
385	.proc_handler = &proc_dointvec,	385	.proc_handler = &proc_dointvec,
386	},	386	},
387	{	387	{
388	.ctl_name = KERN_CORE_PATTERN,	388	.ctl_name = KERN_CORE_PATTERN,
389	.procname = "core_pattern",	389	.procname = "core_pattern",
390	.data = core_pattern,	390	.data = core_pattern,
391	.maxlen = CORENAME_MAX_SIZE,	391	.maxlen = CORENAME_MAX_SIZE,
392	.mode = 0644,	392	.mode = 0644,
393	.proc_handler = &proc_dostring,	393	.proc_handler = &proc_dostring,
394	.strategy = &sysctl_string,	394	.strategy = &sysctl_string,
395	},	395	},
396	#ifdef CONFIG_PROC_SYSCTL	396	#ifdef CONFIG_PROC_SYSCTL
397	{	397	{
398	.procname = "tainted",	398	.procname = "tainted",
399	.maxlen = sizeof(long),	399	.maxlen = sizeof(long),
400	.mode = 0644,	400	.mode = 0644,
401	.proc_handler = &proc_taint,	401	.proc_handler = &proc_taint,
402	},	402	},
403	#endif	403	#endif
404	#ifdef CONFIG_LATENCYTOP	404	#ifdef CONFIG_LATENCYTOP
405	{	405	{
406	.procname = "latencytop",	406	.procname = "latencytop",
407	.data = &latencytop_enabled,	407	.data = &latencytop_enabled,
408	.maxlen = sizeof(int),	408	.maxlen = sizeof(int),
409	.mode = 0644,	409	.mode = 0644,
410	.proc_handler = &proc_dointvec,	410	.proc_handler = &proc_dointvec,
411	},	411	},
412	#endif	412	#endif
413	#ifdef CONFIG_BLK_DEV_INITRD	413	#ifdef CONFIG_BLK_DEV_INITRD
414	{	414	{
415	.ctl_name = KERN_REALROOTDEV,	415	.ctl_name = KERN_REALROOTDEV,
416	.procname = "real-root-dev",	416	.procname = "real-root-dev",
417	.data = &real_root_dev,	417	.data = &real_root_dev,
418	.maxlen = sizeof(int),	418	.maxlen = sizeof(int),
419	.mode = 0644,	419	.mode = 0644,
420	.proc_handler = &proc_dointvec,	420	.proc_handler = &proc_dointvec,
421	},	421	},
422	#endif	422	#endif
423	{	423	{
424	.ctl_name = CTL_UNNUMBERED,	424	.ctl_name = CTL_UNNUMBERED,
425	.procname = "print-fatal-signals",	425	.procname = "print-fatal-signals",
426	.data = &print_fatal_signals,	426	.data = &print_fatal_signals,
427	.maxlen = sizeof(int),	427	.maxlen = sizeof(int),
428	.mode = 0644,	428	.mode = 0644,
429	.proc_handler = &proc_dointvec,	429	.proc_handler = &proc_dointvec,
430	},	430	},
431	#ifdef CONFIG_SPARC	431	#ifdef CONFIG_SPARC
432	{	432	{
433	.ctl_name = KERN_SPARC_REBOOT,	433	.ctl_name = KERN_SPARC_REBOOT,
434	.procname = "reboot-cmd",	434	.procname = "reboot-cmd",
435	.data = reboot_command,	435	.data = reboot_command,
436	.maxlen = 256,	436	.maxlen = 256,
437	.mode = 0644,	437	.mode = 0644,
438	.proc_handler = &proc_dostring,	438	.proc_handler = &proc_dostring,
439	.strategy = &sysctl_string,	439	.strategy = &sysctl_string,
440	},	440	},
441	{	441	{
442	.ctl_name = KERN_SPARC_STOP_A,	442	.ctl_name = KERN_SPARC_STOP_A,
443	.procname = "stop-a",	443	.procname = "stop-a",
444	.data = &stop_a_enabled,	444	.data = &stop_a_enabled,
445	.maxlen = sizeof (int),	445	.maxlen = sizeof (int),
446	.mode = 0644,	446	.mode = 0644,
447	.proc_handler = &proc_dointvec,	447	.proc_handler = &proc_dointvec,
448	},	448	},
449	{	449	{
450	.ctl_name = KERN_SPARC_SCONS_PWROFF,	450	.ctl_name = KERN_SPARC_SCONS_PWROFF,
451	.procname = "scons-poweroff",	451	.procname = "scons-poweroff",
452	.data = &scons_pwroff,	452	.data = &scons_pwroff,
453	.maxlen = sizeof (int),	453	.maxlen = sizeof (int),
454	.mode = 0644,	454	.mode = 0644,
455	.proc_handler = &proc_dointvec,	455	.proc_handler = &proc_dointvec,
456	},	456	},
457	#endif	457	#endif
458	#ifdef CONFIG_SPARC64	458	#ifdef CONFIG_SPARC64
459	{	459	{
460	.ctl_name = CTL_UNNUMBERED,	460	.ctl_name = CTL_UNNUMBERED,
461	.procname = "tsb-ratio",	461	.procname = "tsb-ratio",
462	.data = &sysctl_tsb_ratio,	462	.data = &sysctl_tsb_ratio,
463	.maxlen = sizeof (int),	463	.maxlen = sizeof (int),
464	.mode = 0644,	464	.mode = 0644,
465	.proc_handler = &proc_dointvec,	465	.proc_handler = &proc_dointvec,
466	},	466	},
467	#endif	467	#endif
468	#ifdef __hppa__	468	#ifdef __hppa__
469	{	469	{
470	.ctl_name = KERN_HPPA_PWRSW,	470	.ctl_name = KERN_HPPA_PWRSW,
471	.procname = "soft-power",	471	.procname = "soft-power",
472	.data = &pwrsw_enabled,	472	.data = &pwrsw_enabled,
473	.maxlen = sizeof (int),	473	.maxlen = sizeof (int),
474	.mode = 0644,	474	.mode = 0644,
475	.proc_handler = &proc_dointvec,	475	.proc_handler = &proc_dointvec,
476	},	476	},
477	{	477	{
478	.ctl_name = KERN_HPPA_UNALIGNED,	478	.ctl_name = KERN_HPPA_UNALIGNED,
479	.procname = "unaligned-trap",	479	.procname = "unaligned-trap",
480	.data = &unaligned_enabled,	480	.data = &unaligned_enabled,
481	.maxlen = sizeof (int),	481	.maxlen = sizeof (int),
482	.mode = 0644,	482	.mode = 0644,
483	.proc_handler = &proc_dointvec,	483	.proc_handler = &proc_dointvec,
484	},	484	},
485	#endif	485	#endif
486	{	486	{
487	.ctl_name = KERN_CTLALTDEL,	487	.ctl_name = KERN_CTLALTDEL,
488	.procname = "ctrl-alt-del",	488	.procname = "ctrl-alt-del",
489	.data = &C_A_D,	489	.data = &C_A_D,
490	.maxlen = sizeof(int),	490	.maxlen = sizeof(int),
491	.mode = 0644,	491	.mode = 0644,
492	.proc_handler = &proc_dointvec,	492	.proc_handler = &proc_dointvec,
493	},	493	},
494	#ifdef CONFIG_FUNCTION_TRACER	494	#ifdef CONFIG_FUNCTION_TRACER
495	{	495	{
496	.ctl_name = CTL_UNNUMBERED,	496	.ctl_name = CTL_UNNUMBERED,
497	.procname = "ftrace_enabled",	497	.procname = "ftrace_enabled",
498	.data = &ftrace_enabled,	498	.data = &ftrace_enabled,
499	.maxlen = sizeof(int),	499	.maxlen = sizeof(int),
500	.mode = 0644,	500	.mode = 0644,
501	.proc_handler = &ftrace_enable_sysctl,	501	.proc_handler = &ftrace_enable_sysctl,
502	},	502	},
503	#endif	503	#endif
504	#ifdef CONFIG_STACK_TRACER	504	#ifdef CONFIG_STACK_TRACER
505	{	505	{
506	.ctl_name = CTL_UNNUMBERED,	506	.ctl_name = CTL_UNNUMBERED,
507	.procname = "stack_tracer_enabled",	507	.procname = "stack_tracer_enabled",
508	.data = &stack_tracer_enabled,	508	.data = &stack_tracer_enabled,
509	.maxlen = sizeof(int),	509	.maxlen = sizeof(int),
510	.mode = 0644,	510	.mode = 0644,
511	.proc_handler = &stack_trace_sysctl,	511	.proc_handler = &stack_trace_sysctl,
512	},	512	},
513	#endif	513	#endif
514	#ifdef CONFIG_TRACING	514	#ifdef CONFIG_TRACING
515	{	515	{
516	.ctl_name = CTL_UNNUMBERED,	516	.ctl_name = CTL_UNNUMBERED,
517	.procname = "ftrace_dump_on_oops",	517	.procname = "ftrace_dump_on_oops",
518	.data = &ftrace_dump_on_oops,	518	.data = &ftrace_dump_on_oops,
519	.maxlen = sizeof(int),	519	.maxlen = sizeof(int),
520	.mode = 0644,	520	.mode = 0644,
521	.proc_handler = &proc_dointvec,	521	.proc_handler = &proc_dointvec,
522	},	522	},
523	#endif	523	#endif
524	#ifdef CONFIG_MODULES	524	#ifdef CONFIG_MODULES
525	{	525	{
526	.ctl_name = KERN_MODPROBE,	526	.ctl_name = KERN_MODPROBE,
527	.procname = "modprobe",	527	.procname = "modprobe",
528	.data = &modprobe_path,	528	.data = &modprobe_path,
529	.maxlen = KMOD_PATH_LEN,	529	.maxlen = KMOD_PATH_LEN,
530	.mode = 0644,	530	.mode = 0644,
531	.proc_handler = &proc_dostring,	531	.proc_handler = &proc_dostring,
532	.strategy = &sysctl_string,	532	.strategy = &sysctl_string,
533	},	533	},
534	#endif	534	#endif
535	#if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)	535	#if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
536	{	536	{
537	.ctl_name = KERN_HOTPLUG,	537	.ctl_name = KERN_HOTPLUG,
538	.procname = "hotplug",	538	.procname = "hotplug",
539	.data = &uevent_helper,	539	.data = &uevent_helper,
540	.maxlen = UEVENT_HELPER_PATH_LEN,	540	.maxlen = UEVENT_HELPER_PATH_LEN,
541	.mode = 0644,	541	.mode = 0644,
542	.proc_handler = &proc_dostring,	542	.proc_handler = &proc_dostring,
543	.strategy = &sysctl_string,	543	.strategy = &sysctl_string,
544	},	544	},
545	#endif	545	#endif
546	#ifdef CONFIG_CHR_DEV_SG	546	#ifdef CONFIG_CHR_DEV_SG
547	{	547	{
548	.ctl_name = KERN_SG_BIG_BUFF,	548	.ctl_name = KERN_SG_BIG_BUFF,
549	.procname = "sg-big-buff",	549	.procname = "sg-big-buff",
550	.data = &sg_big_buff,	550	.data = &sg_big_buff,
551	.maxlen = sizeof (int),	551	.maxlen = sizeof (int),
552	.mode = 0444,	552	.mode = 0444,
553	.proc_handler = &proc_dointvec,	553	.proc_handler = &proc_dointvec,
554	},	554	},
555	#endif	555	#endif
556	#ifdef CONFIG_BSD_PROCESS_ACCT	556	#ifdef CONFIG_BSD_PROCESS_ACCT
557	{	557	{
558	.ctl_name = KERN_ACCT,	558	.ctl_name = KERN_ACCT,
559	.procname = "acct",	559	.procname = "acct",
560	.data = &acct_parm,	560	.data = &acct_parm,
561	.maxlen = 3*sizeof(int),	561	.maxlen = 3*sizeof(int),
562	.mode = 0644,	562	.mode = 0644,
563	.proc_handler = &proc_dointvec,	563	.proc_handler = &proc_dointvec,
564	},	564	},
565	#endif	565	#endif
566	#ifdef CONFIG_MAGIC_SYSRQ	566	#ifdef CONFIG_MAGIC_SYSRQ
567	{	567	{
568	.ctl_name = KERN_SYSRQ,	568	.ctl_name = KERN_SYSRQ,
569	.procname = "sysrq",	569	.procname = "sysrq",
570	.data = &__sysrq_enabled,	570	.data = &__sysrq_enabled,
571	.maxlen = sizeof (int),	571	.maxlen = sizeof (int),
572	.mode = 0644,	572	.mode = 0644,
573	.proc_handler = &proc_dointvec,	573	.proc_handler = &proc_dointvec,
574	},	574	},
575	#endif	575	#endif
576	#ifdef CONFIG_PROC_SYSCTL	576	#ifdef CONFIG_PROC_SYSCTL
577	{	577	{
578	.procname = "cad_pid",	578	.procname = "cad_pid",
579	.data = NULL,	579	.data = NULL,
580	.maxlen = sizeof (int),	580	.maxlen = sizeof (int),
581	.mode = 0600,	581	.mode = 0600,
582	.proc_handler = &proc_do_cad_pid,	582	.proc_handler = &proc_do_cad_pid,
583	},	583	},
584	#endif	584	#endif
585	{	585	{
586	.ctl_name = KERN_MAX_THREADS,	586	.ctl_name = KERN_MAX_THREADS,
587	.procname = "threads-max",	587	.procname = "threads-max",
588	.data = &max_threads,	588	.data = &max_threads,
589	.maxlen = sizeof(int),	589	.maxlen = sizeof(int),
590	.mode = 0644,	590	.mode = 0644,
591	.proc_handler = &proc_dointvec,	591	.proc_handler = &proc_dointvec,
592	},	592	},
593	{	593	{
594	.ctl_name = KERN_RANDOM,	594	.ctl_name = KERN_RANDOM,
595	.procname = "random",	595	.procname = "random",
596	.mode = 0555,	596	.mode = 0555,
597	.child = random_table,	597	.child = random_table,
598	},	598	},
599	{	599	{
600	.ctl_name = KERN_OVERFLOWUID,	600	.ctl_name = KERN_OVERFLOWUID,
601	.procname = "overflowuid",	601	.procname = "overflowuid",
602	.data = &overflowuid,	602	.data = &overflowuid,
603	.maxlen = sizeof(int),	603	.maxlen = sizeof(int),
604	.mode = 0644,	604	.mode = 0644,
605	.proc_handler = &proc_dointvec_minmax,	605	.proc_handler = &proc_dointvec_minmax,
606	.strategy = &sysctl_intvec,	606	.strategy = &sysctl_intvec,
607	.extra1 = &minolduid,	607	.extra1 = &minolduid,
608	.extra2 = &maxolduid,	608	.extra2 = &maxolduid,
609	},	609	},
610	{	610	{
611	.ctl_name = KERN_OVERFLOWGID,	611	.ctl_name = KERN_OVERFLOWGID,
612	.procname = "overflowgid",	612	.procname = "overflowgid",
613	.data = &overflowgid,	613	.data = &overflowgid,
614	.maxlen = sizeof(int),	614	.maxlen = sizeof(int),
615	.mode = 0644,	615	.mode = 0644,
616	.proc_handler = &proc_dointvec_minmax,	616	.proc_handler = &proc_dointvec_minmax,
617	.strategy = &sysctl_intvec,	617	.strategy = &sysctl_intvec,
618	.extra1 = &minolduid,	618	.extra1 = &minolduid,
619	.extra2 = &maxolduid,	619	.extra2 = &maxolduid,
620	},	620	},
621	#ifdef CONFIG_S390	621	#ifdef CONFIG_S390
622	#ifdef CONFIG_MATHEMU	622	#ifdef CONFIG_MATHEMU
623	{	623	{
624	.ctl_name = KERN_IEEE_EMULATION_WARNINGS,	624	.ctl_name = KERN_IEEE_EMULATION_WARNINGS,
625	.procname = "ieee_emulation_warnings",	625	.procname = "ieee_emulation_warnings",
626	.data = &sysctl_ieee_emulation_warnings,	626	.data = &sysctl_ieee_emulation_warnings,
627	.maxlen = sizeof(int),	627	.maxlen = sizeof(int),
628	.mode = 0644,	628	.mode = 0644,
629	.proc_handler = &proc_dointvec,	629	.proc_handler = &proc_dointvec,
630	},	630	},
631	#endif	631	#endif
632	{	632	{
633	.ctl_name = KERN_S390_USER_DEBUG_LOGGING,	633	.ctl_name = KERN_S390_USER_DEBUG_LOGGING,
634	.procname = "userprocess_debug",	634	.procname = "userprocess_debug",
635	.data = &sysctl_userprocess_debug,	635	.data = &sysctl_userprocess_debug,
636	.maxlen = sizeof(int),	636	.maxlen = sizeof(int),
637	.mode = 0644,	637	.mode = 0644,
638	.proc_handler = &proc_dointvec,	638	.proc_handler = &proc_dointvec,
639	},	639	},
640	#endif	640	#endif
641	{	641	{
642	.ctl_name = KERN_PIDMAX,	642	.ctl_name = KERN_PIDMAX,
643	.procname = "pid_max",	643	.procname = "pid_max",
644	.data = &pid_max,	644	.data = &pid_max,
645	.maxlen = sizeof (int),	645	.maxlen = sizeof (int),
646	.mode = 0644,	646	.mode = 0644,
647	.proc_handler = &proc_dointvec_minmax,	647	.proc_handler = &proc_dointvec_minmax,
648	.strategy = sysctl_intvec,	648	.strategy = sysctl_intvec,
649	.extra1 = &pid_max_min,	649	.extra1 = &pid_max_min,
650	.extra2 = &pid_max_max,	650	.extra2 = &pid_max_max,
651	},	651	},
652	{	652	{
653	.ctl_name = KERN_PANIC_ON_OOPS,	653	.ctl_name = KERN_PANIC_ON_OOPS,
654	.procname = "panic_on_oops",	654	.procname = "panic_on_oops",
655	.data = &panic_on_oops,	655	.data = &panic_on_oops,
656	.maxlen = sizeof(int),	656	.maxlen = sizeof(int),
657	.mode = 0644,	657	.mode = 0644,
658	.proc_handler = &proc_dointvec,	658	.proc_handler = &proc_dointvec,
659	},	659	},
660	#if defined CONFIG_PRINTK	660	#if defined CONFIG_PRINTK
661	{	661	{
662	.ctl_name = KERN_PRINTK,	662	.ctl_name = KERN_PRINTK,
663	.procname = "printk",	663	.procname = "printk",
664	.data = &console_loglevel,	664	.data = &console_loglevel,
665	.maxlen = 4*sizeof(int),	665	.maxlen = 4*sizeof(int),
666	.mode = 0644,	666	.mode = 0644,
667	.proc_handler = &proc_dointvec,	667	.proc_handler = &proc_dointvec,
668	},	668	},
669	{	669	{
670	.ctl_name = KERN_PRINTK_RATELIMIT,	670	.ctl_name = KERN_PRINTK_RATELIMIT,
671	.procname = "printk_ratelimit",	671	.procname = "printk_ratelimit",
672	.data = &printk_ratelimit_state.interval,	672	.data = &printk_ratelimit_state.interval,
673	.maxlen = sizeof(int),	673	.maxlen = sizeof(int),
674	.mode = 0644,	674	.mode = 0644,
675	.proc_handler = &proc_dointvec_jiffies,	675	.proc_handler = &proc_dointvec_jiffies,
676	.strategy = &sysctl_jiffies,	676	.strategy = &sysctl_jiffies,
677	},	677	},
678	{	678	{
679	.ctl_name = KERN_PRINTK_RATELIMIT_BURST,	679	.ctl_name = KERN_PRINTK_RATELIMIT_BURST,
680	.procname = "printk_ratelimit_burst",	680	.procname = "printk_ratelimit_burst",
681	.data = &printk_ratelimit_state.burst,	681	.data = &printk_ratelimit_state.burst,
682	.maxlen = sizeof(int),	682	.maxlen = sizeof(int),
683	.mode = 0644,	683	.mode = 0644,
684	.proc_handler = &proc_dointvec,	684	.proc_handler = &proc_dointvec,
685	},	685	},
686	#endif	686	#endif
687	{	687	{
688	.ctl_name = KERN_NGROUPS_MAX,	688	.ctl_name = KERN_NGROUPS_MAX,
689	.procname = "ngroups_max",	689	.procname = "ngroups_max",
690	.data = &ngroups_max,	690	.data = &ngroups_max,
691	.maxlen = sizeof (int),	691	.maxlen = sizeof (int),
692	.mode = 0444,	692	.mode = 0444,
693	.proc_handler = &proc_dointvec,	693	.proc_handler = &proc_dointvec,
694	},	694	},
695	#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)	695	#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
696	{	696	{
697	.ctl_name = KERN_UNKNOWN_NMI_PANIC,	697	.ctl_name = KERN_UNKNOWN_NMI_PANIC,
698	.procname = "unknown_nmi_panic",	698	.procname = "unknown_nmi_panic",
699	.data = &unknown_nmi_panic,	699	.data = &unknown_nmi_panic,
700	.maxlen = sizeof (int),	700	.maxlen = sizeof (int),
701	.mode = 0644,	701	.mode = 0644,
702	.proc_handler = &proc_dointvec,	702	.proc_handler = &proc_dointvec,
703	},	703	},
704	{	704	{
705	.procname = "nmi_watchdog",	705	.procname = "nmi_watchdog",
706	.data = &nmi_watchdog_enabled,	706	.data = &nmi_watchdog_enabled,
707	.maxlen = sizeof (int),	707	.maxlen = sizeof (int),
708	.mode = 0644,	708	.mode = 0644,
709	.proc_handler = &proc_nmi_enabled,	709	.proc_handler = &proc_nmi_enabled,
710	},	710	},
711	#endif	711	#endif
712	#if defined(CONFIG_X86)	712	#if defined(CONFIG_X86)
713	{	713	{
714	.ctl_name = KERN_PANIC_ON_NMI,	714	.ctl_name = KERN_PANIC_ON_NMI,
715	.procname = "panic_on_unrecovered_nmi",	715	.procname = "panic_on_unrecovered_nmi",
716	.data = &panic_on_unrecovered_nmi,	716	.data = &panic_on_unrecovered_nmi,
717	.maxlen = sizeof(int),	717	.maxlen = sizeof(int),
718	.mode = 0644,	718	.mode = 0644,
719	.proc_handler = &proc_dointvec,	719	.proc_handler = &proc_dointvec,
720	},	720	},
721	{	721	{
722	.ctl_name = KERN_BOOTLOADER_TYPE,	722	.ctl_name = KERN_BOOTLOADER_TYPE,
723	.procname = "bootloader_type",	723	.procname = "bootloader_type",
724	.data = &bootloader_type,	724	.data = &bootloader_type,
725	.maxlen = sizeof (int),	725	.maxlen = sizeof (int),
726	.mode = 0444,	726	.mode = 0444,
727	.proc_handler = &proc_dointvec,	727	.proc_handler = &proc_dointvec,
728	},	728	},
729	{	729	{
730	.ctl_name = CTL_UNNUMBERED,	730	.ctl_name = CTL_UNNUMBERED,
731	.procname = "kstack_depth_to_print",	731	.procname = "kstack_depth_to_print",
732	.data = &kstack_depth_to_print,	732	.data = &kstack_depth_to_print,
733	.maxlen = sizeof(int),	733	.maxlen = sizeof(int),
734	.mode = 0644,	734	.mode = 0644,
735	.proc_handler = &proc_dointvec,	735	.proc_handler = &proc_dointvec,
736	},	736	},
737	{	737	{
738	.ctl_name = CTL_UNNUMBERED,	738	.ctl_name = CTL_UNNUMBERED,
739	.procname = "io_delay_type",	739	.procname = "io_delay_type",
740	.data = &io_delay_type,	740	.data = &io_delay_type,
741	.maxlen = sizeof(int),	741	.maxlen = sizeof(int),
742	.mode = 0644,	742	.mode = 0644,
743	.proc_handler = &proc_dointvec,	743	.proc_handler = &proc_dointvec,
744	},	744	},
745	#endif	745	#endif
746	#if defined(CONFIG_MMU)	746	#if defined(CONFIG_MMU)
747	{	747	{
748	.ctl_name = KERN_RANDOMIZE,	748	.ctl_name = KERN_RANDOMIZE,
749	.procname = "randomize_va_space",	749	.procname = "randomize_va_space",
750	.data = &randomize_va_space,	750	.data = &randomize_va_space,
751	.maxlen = sizeof(int),	751	.maxlen = sizeof(int),
752	.mode = 0644,	752	.mode = 0644,
753	.proc_handler = &proc_dointvec,	753	.proc_handler = &proc_dointvec,
754	},	754	},
755	#endif	755	#endif
756	#if defined(CONFIG_S390) && defined(CONFIG_SMP)	756	#if defined(CONFIG_S390) && defined(CONFIG_SMP)
757	{	757	{
758	.ctl_name = KERN_SPIN_RETRY,	758	.ctl_name = KERN_SPIN_RETRY,
759	.procname = "spin_retry",	759	.procname = "spin_retry",
760	.data = &spin_retry,	760	.data = &spin_retry,
761	.maxlen = sizeof (int),	761	.maxlen = sizeof (int),
762	.mode = 0644,	762	.mode = 0644,
763	.proc_handler = &proc_dointvec,	763	.proc_handler = &proc_dointvec,
764	},	764	},
765	#endif	765	#endif
766	#if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)	766	#if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
767	{	767	{
768	.procname = "acpi_video_flags",	768	.procname = "acpi_video_flags",
769	.data = &acpi_realmode_flags,	769	.data = &acpi_realmode_flags,
770	.maxlen = sizeof (unsigned long),	770	.maxlen = sizeof (unsigned long),
771	.mode = 0644,	771	.mode = 0644,
772	.proc_handler = &proc_doulongvec_minmax,	772	.proc_handler = &proc_doulongvec_minmax,
773	},	773	},
774	#endif	774	#endif
775	#ifdef CONFIG_IA64	775	#ifdef CONFIG_IA64
776	{	776	{
777	.ctl_name = KERN_IA64_UNALIGNED,	777	.ctl_name = KERN_IA64_UNALIGNED,
778	.procname = "ignore-unaligned-usertrap",	778	.procname = "ignore-unaligned-usertrap",
779	.data = &no_unaligned_warning,	779	.data = &no_unaligned_warning,
780	.maxlen = sizeof (int),	780	.maxlen = sizeof (int),
781	.mode = 0644,	781	.mode = 0644,
782	.proc_handler = &proc_dointvec,	782	.proc_handler = &proc_dointvec,
783	},	783	},
784	#endif	784	#endif
785	#ifdef CONFIG_DETECT_SOFTLOCKUP	785	#ifdef CONFIG_DETECT_SOFTLOCKUP
786	{	786	{
787	.ctl_name = CTL_UNNUMBERED,	787	.ctl_name = CTL_UNNUMBERED,
788	.procname = "softlockup_panic",	788	.procname = "softlockup_panic",
789	.data = &softlockup_panic,	789	.data = &softlockup_panic,
790	.maxlen = sizeof(int),	790	.maxlen = sizeof(int),
791	.mode = 0644,	791	.mode = 0644,
792	.proc_handler = &proc_dointvec_minmax,	792	.proc_handler = &proc_dointvec_minmax,
793	.strategy = &sysctl_intvec,	793	.strategy = &sysctl_intvec,
794	.extra1 = &zero,	794	.extra1 = &zero,
795	.extra2 = &one,	795	.extra2 = &one,
796	},	796	},
797	{	797	{
798	.ctl_name = CTL_UNNUMBERED,	798	.ctl_name = CTL_UNNUMBERED,
799	.procname = "softlockup_thresh",	799	.procname = "softlockup_thresh",
800	.data = &softlockup_thresh,	800	.data = &softlockup_thresh,
801	.maxlen = sizeof(int),	801	.maxlen = sizeof(int),
802	.mode = 0644,	802	.mode = 0644,
803	.proc_handler = &proc_dointvec_minmax,	803	.proc_handler = &proc_dosoftlockup_thresh,
804	.strategy = &sysctl_intvec,	804	.strategy = &sysctl_intvec,
805	.extra1 = &neg_one,	805	.extra1 = &neg_one,
806	.extra2 = &sixty,	806	.extra2 = &sixty,
807	},	807	},
808	{	808	{
809	.ctl_name = CTL_UNNUMBERED,	809	.ctl_name = CTL_UNNUMBERED,
810	.procname = "hung_task_check_count",	810	.procname = "hung_task_check_count",
811	.data = &sysctl_hung_task_check_count,	811	.data = &sysctl_hung_task_check_count,
812	.maxlen = sizeof(unsigned long),	812	.maxlen = sizeof(unsigned long),
813	.mode = 0644,	813	.mode = 0644,
814	.proc_handler = &proc_doulongvec_minmax,	814	.proc_handler = &proc_doulongvec_minmax,
815	.strategy = &sysctl_intvec,	815	.strategy = &sysctl_intvec,
816	},	816	},
817	{	817	{
818	.ctl_name = CTL_UNNUMBERED,	818	.ctl_name = CTL_UNNUMBERED,
819	.procname = "hung_task_timeout_secs",	819	.procname = "hung_task_timeout_secs",
820	.data = &sysctl_hung_task_timeout_secs,	820	.data = &sysctl_hung_task_timeout_secs,
821	.maxlen = sizeof(unsigned long),	821	.maxlen = sizeof(unsigned long),
822	.mode = 0644,	822	.mode = 0644,
823	.proc_handler = &proc_doulongvec_minmax,	823	.proc_handler = &proc_doulongvec_minmax,
824	.strategy = &sysctl_intvec,	824	.strategy = &sysctl_intvec,
825	},	825	},
826	{	826	{
827	.ctl_name = CTL_UNNUMBERED,	827	.ctl_name = CTL_UNNUMBERED,
828	.procname = "hung_task_warnings",	828	.procname = "hung_task_warnings",
829	.data = &sysctl_hung_task_warnings,	829	.data = &sysctl_hung_task_warnings,
830	.maxlen = sizeof(unsigned long),	830	.maxlen = sizeof(unsigned long),
831	.mode = 0644,	831	.mode = 0644,
832	.proc_handler = &proc_doulongvec_minmax,	832	.proc_handler = &proc_doulongvec_minmax,
833	.strategy = &sysctl_intvec,	833	.strategy = &sysctl_intvec,
834	},	834	},
835	#endif	835	#endif
836	#ifdef CONFIG_COMPAT	836	#ifdef CONFIG_COMPAT
837	{	837	{
838	.ctl_name = KERN_COMPAT_LOG,	838	.ctl_name = KERN_COMPAT_LOG,
839	.procname = "compat-log",	839	.procname = "compat-log",
840	.data = &compat_log,	840	.data = &compat_log,
841	.maxlen = sizeof (int),	841	.maxlen = sizeof (int),
842	.mode = 0644,	842	.mode = 0644,
843	.proc_handler = &proc_dointvec,	843	.proc_handler = &proc_dointvec,
844	},	844	},
845	#endif	845	#endif
846	#ifdef CONFIG_RT_MUTEXES	846	#ifdef CONFIG_RT_MUTEXES
847	{	847	{
848	.ctl_name = KERN_MAX_LOCK_DEPTH,	848	.ctl_name = KERN_MAX_LOCK_DEPTH,
849	.procname = "max_lock_depth",	849	.procname = "max_lock_depth",
850	.data = &max_lock_depth,	850	.data = &max_lock_depth,
851	.maxlen = sizeof(int),	851	.maxlen = sizeof(int),
852	.mode = 0644,	852	.mode = 0644,
853	.proc_handler = &proc_dointvec,	853	.proc_handler = &proc_dointvec,
854	},	854	},
855	#endif	855	#endif
856	{	856	{
857	.ctl_name = CTL_UNNUMBERED,	857	.ctl_name = CTL_UNNUMBERED,
858	.procname = "poweroff_cmd",	858	.procname = "poweroff_cmd",
859	.data = &poweroff_cmd,	859	.data = &poweroff_cmd,
860	.maxlen = POWEROFF_CMD_PATH_LEN,	860	.maxlen = POWEROFF_CMD_PATH_LEN,
861	.mode = 0644,	861	.mode = 0644,
862	.proc_handler = &proc_dostring,	862	.proc_handler = &proc_dostring,
863	.strategy = &sysctl_string,	863	.strategy = &sysctl_string,
864	},	864	},
865	#ifdef CONFIG_KEYS	865	#ifdef CONFIG_KEYS
866	{	866	{
867	.ctl_name = CTL_UNNUMBERED,	867	.ctl_name = CTL_UNNUMBERED,
868	.procname = "keys",	868	.procname = "keys",
869	.mode = 0555,	869	.mode = 0555,
870	.child = key_sysctls,	870	.child = key_sysctls,
871	},	871	},
872	#endif	872	#endif
873	#ifdef CONFIG_RCU_TORTURE_TEST	873	#ifdef CONFIG_RCU_TORTURE_TEST
874	{	874	{
875	.ctl_name = CTL_UNNUMBERED,	875	.ctl_name = CTL_UNNUMBERED,
876	.procname = "rcutorture_runnable",	876	.procname = "rcutorture_runnable",
877	.data = &rcutorture_runnable,	877	.data = &rcutorture_runnable,
878	.maxlen = sizeof(int),	878	.maxlen = sizeof(int),
879	.mode = 0644,	879	.mode = 0644,
880	.proc_handler = &proc_dointvec,	880	.proc_handler = &proc_dointvec,
881	},	881	},
882	#endif	882	#endif
883	#ifdef CONFIG_UNEVICTABLE_LRU	883	#ifdef CONFIG_UNEVICTABLE_LRU
884	{	884	{
885	.ctl_name = CTL_UNNUMBERED,	885	.ctl_name = CTL_UNNUMBERED,
886	.procname = "scan_unevictable_pages",	886	.procname = "scan_unevictable_pages",
887	.data = &scan_unevictable_pages,	887	.data = &scan_unevictable_pages,
888	.maxlen = sizeof(scan_unevictable_pages),	888	.maxlen = sizeof(scan_unevictable_pages),
889	.mode = 0644,	889	.mode = 0644,
890	.proc_handler = &scan_unevictable_handler,	890	.proc_handler = &scan_unevictable_handler,
891	},	891	},
892	#endif	892	#endif
893	/*	893	/*
894	* NOTE: do not add new entries to this table unless you have read	894	* NOTE: do not add new entries to this table unless you have read
895	* Documentation/sysctl/ctl_unnumbered.txt	895	* Documentation/sysctl/ctl_unnumbered.txt
896	*/	896	*/
897	{ .ctl_name = 0 }	897	{ .ctl_name = 0 }
898	};	898	};
899		899
900	static struct ctl_table vm_table[] = {	900	static struct ctl_table vm_table[] = {
901	{	901	{
902	.ctl_name = VM_OVERCOMMIT_MEMORY,	902	.ctl_name = VM_OVERCOMMIT_MEMORY,
903	.procname = "overcommit_memory",	903	.procname = "overcommit_memory",
904	.data = &sysctl_overcommit_memory,	904	.data = &sysctl_overcommit_memory,
905	.maxlen = sizeof(sysctl_overcommit_memory),	905	.maxlen = sizeof(sysctl_overcommit_memory),
906	.mode = 0644,	906	.mode = 0644,
907	.proc_handler = &proc_dointvec,	907	.proc_handler = &proc_dointvec,
908	},	908	},
909	{	909	{
910	.ctl_name = VM_PANIC_ON_OOM,	910	.ctl_name = VM_PANIC_ON_OOM,
911	.procname = "panic_on_oom",	911	.procname = "panic_on_oom",
912	.data = &sysctl_panic_on_oom,	912	.data = &sysctl_panic_on_oom,
913	.maxlen = sizeof(sysctl_panic_on_oom),	913	.maxlen = sizeof(sysctl_panic_on_oom),
914	.mode = 0644,	914	.mode = 0644,
915	.proc_handler = &proc_dointvec,	915	.proc_handler = &proc_dointvec,
916	},	916	},
917	{	917	{
918	.ctl_name = CTL_UNNUMBERED,	918	.ctl_name = CTL_UNNUMBERED,
919	.procname = "oom_kill_allocating_task",	919	.procname = "oom_kill_allocating_task",
920	.data = &sysctl_oom_kill_allocating_task,	920	.data = &sysctl_oom_kill_allocating_task,
921	.maxlen = sizeof(sysctl_oom_kill_allocating_task),	921	.maxlen = sizeof(sysctl_oom_kill_allocating_task),
922	.mode = 0644,	922	.mode = 0644,
923	.proc_handler = &proc_dointvec,	923	.proc_handler = &proc_dointvec,
924	},	924	},
925	{	925	{
926	.ctl_name = CTL_UNNUMBERED,	926	.ctl_name = CTL_UNNUMBERED,
927	.procname = "oom_dump_tasks",	927	.procname = "oom_dump_tasks",
928	.data = &sysctl_oom_dump_tasks,	928	.data = &sysctl_oom_dump_tasks,
929	.maxlen = sizeof(sysctl_oom_dump_tasks),	929	.maxlen = sizeof(sysctl_oom_dump_tasks),
930	.mode = 0644,	930	.mode = 0644,
931	.proc_handler = &proc_dointvec,	931	.proc_handler = &proc_dointvec,
932	},	932	},
933	{	933	{
934	.ctl_name = VM_OVERCOMMIT_RATIO,	934	.ctl_name = VM_OVERCOMMIT_RATIO,
935	.procname = "overcommit_ratio",	935	.procname = "overcommit_ratio",
936	.data = &sysctl_overcommit_ratio,	936	.data = &sysctl_overcommit_ratio,
937	.maxlen = sizeof(sysctl_overcommit_ratio),	937	.maxlen = sizeof(sysctl_overcommit_ratio),
938	.mode = 0644,	938	.mode = 0644,
939	.proc_handler = &proc_dointvec,	939	.proc_handler = &proc_dointvec,
940	},	940	},
941	{	941	{
942	.ctl_name = VM_PAGE_CLUSTER,	942	.ctl_name = VM_PAGE_CLUSTER,
943	.procname = "page-cluster",	943	.procname = "page-cluster",
944	.data = &page_cluster,	944	.data = &page_cluster,
945	.maxlen = sizeof(int),	945	.maxlen = sizeof(int),
946	.mode = 0644,	946	.mode = 0644,
947	.proc_handler = &proc_dointvec,	947	.proc_handler = &proc_dointvec,
948	},	948	},
949	{	949	{
950	.ctl_name = VM_DIRTY_BACKGROUND,	950	.ctl_name = VM_DIRTY_BACKGROUND,
951	.procname = "dirty_background_ratio",	951	.procname = "dirty_background_ratio",
952	.data = &dirty_background_ratio,	952	.data = &dirty_background_ratio,
953	.maxlen = sizeof(dirty_background_ratio),	953	.maxlen = sizeof(dirty_background_ratio),
954	.mode = 0644,	954	.mode = 0644,
955	.proc_handler = &dirty_background_ratio_handler,	955	.proc_handler = &dirty_background_ratio_handler,
956	.strategy = &sysctl_intvec,	956	.strategy = &sysctl_intvec,
957	.extra1 = &zero,	957	.extra1 = &zero,
958	.extra2 = &one_hundred,	958	.extra2 = &one_hundred,
959	},	959	},
960	{	960	{
961	.ctl_name = CTL_UNNUMBERED,	961	.ctl_name = CTL_UNNUMBERED,
962	.procname = "dirty_background_bytes",	962	.procname = "dirty_background_bytes",
963	.data = &dirty_background_bytes,	963	.data = &dirty_background_bytes,
964	.maxlen = sizeof(dirty_background_bytes),	964	.maxlen = sizeof(dirty_background_bytes),
965	.mode = 0644,	965	.mode = 0644,
966	.proc_handler = &dirty_background_bytes_handler,	966	.proc_handler = &dirty_background_bytes_handler,
967	.strategy = &sysctl_intvec,	967	.strategy = &sysctl_intvec,
968	.extra1 = &one,	968	.extra1 = &one,
969	},	969	},
970	{	970	{
971	.ctl_name = VM_DIRTY_RATIO,	971	.ctl_name = VM_DIRTY_RATIO,
972	.procname = "dirty_ratio",	972	.procname = "dirty_ratio",
973	.data = &vm_dirty_ratio,	973	.data = &vm_dirty_ratio,
974	.maxlen = sizeof(vm_dirty_ratio),	974	.maxlen = sizeof(vm_dirty_ratio),
975	.mode = 0644,	975	.mode = 0644,
976	.proc_handler = &dirty_ratio_handler,	976	.proc_handler = &dirty_ratio_handler,
977	.strategy = &sysctl_intvec,	977	.strategy = &sysctl_intvec,
978	.extra1 = &zero,	978	.extra1 = &zero,
979	.extra2 = &one_hundred,	979	.extra2 = &one_hundred,
980	},	980	},
981	{	981	{
982	.ctl_name = CTL_UNNUMBERED,	982	.ctl_name = CTL_UNNUMBERED,
983	.procname = "dirty_bytes",	983	.procname = "dirty_bytes",
984	.data = &vm_dirty_bytes,	984	.data = &vm_dirty_bytes,
985	.maxlen = sizeof(vm_dirty_bytes),	985	.maxlen = sizeof(vm_dirty_bytes),
986	.mode = 0644,	986	.mode = 0644,
987	.proc_handler = &dirty_bytes_handler,	987	.proc_handler = &dirty_bytes_handler,
988	.strategy = &sysctl_intvec,	988	.strategy = &sysctl_intvec,
989	.extra1 = &one,	989	.extra1 = &one,
990	},	990	},
991	{	991	{
992	.procname = "dirty_writeback_centisecs",	992	.procname = "dirty_writeback_centisecs",
993	.data = &dirty_writeback_interval,	993	.data = &dirty_writeback_interval,
994	.maxlen = sizeof(dirty_writeback_interval),	994	.maxlen = sizeof(dirty_writeback_interval),
995	.mode = 0644,	995	.mode = 0644,
996	.proc_handler = &dirty_writeback_centisecs_handler,	996	.proc_handler = &dirty_writeback_centisecs_handler,
997	},	997	},
998	{	998	{
999	.procname = "dirty_expire_centisecs",	999	.procname = "dirty_expire_centisecs",
1000	.data = &dirty_expire_interval,	1000	.data = &dirty_expire_interval,
1001	.maxlen = sizeof(dirty_expire_interval),	1001	.maxlen = sizeof(dirty_expire_interval),
1002	.mode = 0644,	1002	.mode = 0644,
1003	.proc_handler = &proc_dointvec_userhz_jiffies,	1003	.proc_handler = &proc_dointvec_userhz_jiffies,
1004	},	1004	},
1005	{	1005	{
1006	.ctl_name = VM_NR_PDFLUSH_THREADS,	1006	.ctl_name = VM_NR_PDFLUSH_THREADS,
1007	.procname = "nr_pdflush_threads",	1007	.procname = "nr_pdflush_threads",
1008	.data = &nr_pdflush_threads,	1008	.data = &nr_pdflush_threads,
1009	.maxlen = sizeof nr_pdflush_threads,	1009	.maxlen = sizeof nr_pdflush_threads,
1010	.mode = 0444 /* read-only*/,	1010	.mode = 0444 /* read-only*/,
1011	.proc_handler = &proc_dointvec,	1011	.proc_handler = &proc_dointvec,
1012	},	1012	},
1013	{	1013	{
1014	.ctl_name = VM_SWAPPINESS,	1014	.ctl_name = VM_SWAPPINESS,
1015	.procname = "swappiness",	1015	.procname = "swappiness",
1016	.data = &vm_swappiness,	1016	.data = &vm_swappiness,
1017	.maxlen = sizeof(vm_swappiness),	1017	.maxlen = sizeof(vm_swappiness),
1018	.mode = 0644,	1018	.mode = 0644,
1019	.proc_handler = &proc_dointvec_minmax,	1019	.proc_handler = &proc_dointvec_minmax,
1020	.strategy = &sysctl_intvec,	1020	.strategy = &sysctl_intvec,
1021	.extra1 = &zero,	1021	.extra1 = &zero,
1022	.extra2 = &one_hundred,	1022	.extra2 = &one_hundred,
1023	},	1023	},
1024	#ifdef CONFIG_HUGETLB_PAGE	1024	#ifdef CONFIG_HUGETLB_PAGE
1025	{	1025	{
1026	.procname = "nr_hugepages",	1026	.procname = "nr_hugepages",
1027	.data = NULL,	1027	.data = NULL,
1028	.maxlen = sizeof(unsigned long),	1028	.maxlen = sizeof(unsigned long),
1029	.mode = 0644,	1029	.mode = 0644,
1030	.proc_handler = &hugetlb_sysctl_handler,	1030	.proc_handler = &hugetlb_sysctl_handler,
1031	.extra1 = (void *)&hugetlb_zero,	1031	.extra1 = (void *)&hugetlb_zero,
1032	.extra2 = (void *)&hugetlb_infinity,	1032	.extra2 = (void *)&hugetlb_infinity,
1033	},	1033	},
1034	{	1034	{
1035	.ctl_name = VM_HUGETLB_GROUP,	1035	.ctl_name = VM_HUGETLB_GROUP,
1036	.procname = "hugetlb_shm_group",	1036	.procname = "hugetlb_shm_group",
1037	.data = &sysctl_hugetlb_shm_group,	1037	.data = &sysctl_hugetlb_shm_group,
1038	.maxlen = sizeof(gid_t),	1038	.maxlen = sizeof(gid_t),
1039	.mode = 0644,	1039	.mode = 0644,
1040	.proc_handler = &proc_dointvec,	1040	.proc_handler = &proc_dointvec,
1041	},	1041	},
1042	{	1042	{
1043	.ctl_name = CTL_UNNUMBERED,	1043	.ctl_name = CTL_UNNUMBERED,
1044	.procname = "hugepages_treat_as_movable",	1044	.procname = "hugepages_treat_as_movable",
1045	.data = &hugepages_treat_as_movable,	1045	.data = &hugepages_treat_as_movable,
1046	.maxlen = sizeof(int),	1046	.maxlen = sizeof(int),
1047	.mode = 0644,	1047	.mode = 0644,
1048	.proc_handler = &hugetlb_treat_movable_handler,	1048	.proc_handler = &hugetlb_treat_movable_handler,
1049	},	1049	},
1050	{	1050	{
1051	.ctl_name = CTL_UNNUMBERED,	1051	.ctl_name = CTL_UNNUMBERED,
1052	.procname = "nr_overcommit_hugepages",	1052	.procname = "nr_overcommit_hugepages",
1053	.data = NULL,	1053	.data = NULL,
1054	.maxlen = sizeof(unsigned long),	1054	.maxlen = sizeof(unsigned long),
1055	.mode = 0644,	1055	.mode = 0644,
1056	.proc_handler = &hugetlb_overcommit_handler,	1056	.proc_handler = &hugetlb_overcommit_handler,
1057	.extra1 = (void *)&hugetlb_zero,	1057	.extra1 = (void *)&hugetlb_zero,
1058	.extra2 = (void *)&hugetlb_infinity,	1058	.extra2 = (void *)&hugetlb_infinity,
1059	},	1059	},
1060	#endif	1060	#endif
1061	{	1061	{
1062	.ctl_name = VM_LOWMEM_RESERVE_RATIO,	1062	.ctl_name = VM_LOWMEM_RESERVE_RATIO,
1063	.procname = "lowmem_reserve_ratio",	1063	.procname = "lowmem_reserve_ratio",
1064	.data = &sysctl_lowmem_reserve_ratio,	1064	.data = &sysctl_lowmem_reserve_ratio,
1065	.maxlen = sizeof(sysctl_lowmem_reserve_ratio),	1065	.maxlen = sizeof(sysctl_lowmem_reserve_ratio),
1066	.mode = 0644,	1066	.mode = 0644,
1067	.proc_handler = &lowmem_reserve_ratio_sysctl_handler,	1067	.proc_handler = &lowmem_reserve_ratio_sysctl_handler,
1068	.strategy = &sysctl_intvec,	1068	.strategy = &sysctl_intvec,
1069	},	1069	},
1070	{	1070	{
1071	.ctl_name = VM_DROP_PAGECACHE,	1071	.ctl_name = VM_DROP_PAGECACHE,
1072	.procname = "drop_caches",	1072	.procname = "drop_caches",
1073	.data = &sysctl_drop_caches,	1073	.data = &sysctl_drop_caches,
1074	.maxlen = sizeof(int),	1074	.maxlen = sizeof(int),
1075	.mode = 0644,	1075	.mode = 0644,
1076	.proc_handler = drop_caches_sysctl_handler,	1076	.proc_handler = drop_caches_sysctl_handler,
1077	.strategy = &sysctl_intvec,	1077	.strategy = &sysctl_intvec,
1078	},	1078	},
1079	{	1079	{
1080	.ctl_name = VM_MIN_FREE_KBYTES,	1080	.ctl_name = VM_MIN_FREE_KBYTES,
1081	.procname = "min_free_kbytes",	1081	.procname = "min_free_kbytes",
1082	.data = &min_free_kbytes,	1082	.data = &min_free_kbytes,
1083	.maxlen = sizeof(min_free_kbytes),	1083	.maxlen = sizeof(min_free_kbytes),
1084	.mode = 0644,	1084	.mode = 0644,
1085	.proc_handler = &min_free_kbytes_sysctl_handler,	1085	.proc_handler = &min_free_kbytes_sysctl_handler,
1086	.strategy = &sysctl_intvec,	1086	.strategy = &sysctl_intvec,
1087	.extra1 = &zero,	1087	.extra1 = &zero,
1088	},	1088	},
1089	{	1089	{
1090	.ctl_name = VM_PERCPU_PAGELIST_FRACTION,	1090	.ctl_name = VM_PERCPU_PAGELIST_FRACTION,
1091	.procname = "percpu_pagelist_fraction",	1091	.procname = "percpu_pagelist_fraction",
1092	.data = &percpu_pagelist_fraction,	1092	.data = &percpu_pagelist_fraction,
1093	.maxlen = sizeof(percpu_pagelist_fraction),	1093	.maxlen = sizeof(percpu_pagelist_fraction),
1094	.mode = 0644,	1094	.mode = 0644,
1095	.proc_handler = &percpu_pagelist_fraction_sysctl_handler,	1095	.proc_handler = &percpu_pagelist_fraction_sysctl_handler,
1096	.strategy = &sysctl_intvec,	1096	.strategy = &sysctl_intvec,
1097	.extra1 = &min_percpu_pagelist_fract,	1097	.extra1 = &min_percpu_pagelist_fract,
1098	},	1098	},
1099	#ifdef CONFIG_MMU	1099	#ifdef CONFIG_MMU
1100	{	1100	{
1101	.ctl_name = VM_MAX_MAP_COUNT,	1101	.ctl_name = VM_MAX_MAP_COUNT,
1102	.procname = "max_map_count",	1102	.procname = "max_map_count",
1103	.data = &sysctl_max_map_count,	1103	.data = &sysctl_max_map_count,
1104	.maxlen = sizeof(sysctl_max_map_count),	1104	.maxlen = sizeof(sysctl_max_map_count),
1105	.mode = 0644,	1105	.mode = 0644,
1106	.proc_handler = &proc_dointvec	1106	.proc_handler = &proc_dointvec
1107	},	1107	},
1108	#else	1108	#else
1109	{	1109	{
1110	.ctl_name = CTL_UNNUMBERED,	1110	.ctl_name = CTL_UNNUMBERED,
1111	.procname = "nr_trim_pages",	1111	.procname = "nr_trim_pages",
1112	.data = &sysctl_nr_trim_pages,	1112	.data = &sysctl_nr_trim_pages,
1113	.maxlen = sizeof(sysctl_nr_trim_pages),	1113	.maxlen = sizeof(sysctl_nr_trim_pages),
1114	.mode = 0644,	1114	.mode = 0644,
1115	.proc_handler = &proc_dointvec_minmax,	1115	.proc_handler = &proc_dointvec_minmax,
1116	.strategy = &sysctl_intvec,	1116	.strategy = &sysctl_intvec,
1117	.extra1 = &zero,	1117	.extra1 = &zero,
1118	},	1118	},
1119	#endif	1119	#endif
1120	{	1120	{
1121	.ctl_name = VM_LAPTOP_MODE,	1121	.ctl_name = VM_LAPTOP_MODE,
1122	.procname = "laptop_mode",	1122	.procname = "laptop_mode",
1123	.data = &laptop_mode,	1123	.data = &laptop_mode,
1124	.maxlen = sizeof(laptop_mode),	1124	.maxlen = sizeof(laptop_mode),
1125	.mode = 0644,	1125	.mode = 0644,
1126	.proc_handler = &proc_dointvec_jiffies,	1126	.proc_handler = &proc_dointvec_jiffies,
1127	.strategy = &sysctl_jiffies,	1127	.strategy = &sysctl_jiffies,
1128	},	1128	},
1129	{	1129	{
1130	.ctl_name = VM_BLOCK_DUMP,	1130	.ctl_name = VM_BLOCK_DUMP,
1131	.procname = "block_dump",	1131	.procname = "block_dump",
1132	.data = &block_dump,	1132	.data = &block_dump,
1133	.maxlen = sizeof(block_dump),	1133	.maxlen = sizeof(block_dump),
1134	.mode = 0644,	1134	.mode = 0644,
1135	.proc_handler = &proc_dointvec,	1135	.proc_handler = &proc_dointvec,
1136	.strategy = &sysctl_intvec,	1136	.strategy = &sysctl_intvec,
1137	.extra1 = &zero,	1137	.extra1 = &zero,
1138	},	1138	},
1139	{	1139	{
1140	.ctl_name = VM_VFS_CACHE_PRESSURE,	1140	.ctl_name = VM_VFS_CACHE_PRESSURE,
1141	.procname = "vfs_cache_pressure",	1141	.procname = "vfs_cache_pressure",
1142	.data = &sysctl_vfs_cache_pressure,	1142	.data = &sysctl_vfs_cache_pressure,
1143	.maxlen = sizeof(sysctl_vfs_cache_pressure),	1143	.maxlen = sizeof(sysctl_vfs_cache_pressure),
1144	.mode = 0644,	1144	.mode = 0644,
1145	.proc_handler = &proc_dointvec,	1145	.proc_handler = &proc_dointvec,
1146	.strategy = &sysctl_intvec,	1146	.strategy = &sysctl_intvec,
1147	.extra1 = &zero,	1147	.extra1 = &zero,
1148	},	1148	},
1149	#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT	1149	#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1150	{	1150	{
1151	.ctl_name = VM_LEGACY_VA_LAYOUT,	1151	.ctl_name = VM_LEGACY_VA_LAYOUT,
1152	.procname = "legacy_va_layout",	1152	.procname = "legacy_va_layout",
1153	.data = &sysctl_legacy_va_layout,	1153	.data = &sysctl_legacy_va_layout,
1154	.maxlen = sizeof(sysctl_legacy_va_layout),	1154	.maxlen = sizeof(sysctl_legacy_va_layout),
1155	.mode = 0644,	1155	.mode = 0644,
1156	.proc_handler = &proc_dointvec,	1156	.proc_handler = &proc_dointvec,
1157	.strategy = &sysctl_intvec,	1157	.strategy = &sysctl_intvec,
1158	.extra1 = &zero,	1158	.extra1 = &zero,
1159	},	1159	},
1160	#endif	1160	#endif
1161	#ifdef CONFIG_NUMA	1161	#ifdef CONFIG_NUMA
1162	{	1162	{
1163	.ctl_name = VM_ZONE_RECLAIM_MODE,	1163	.ctl_name = VM_ZONE_RECLAIM_MODE,
1164	.procname = "zone_reclaim_mode",	1164	.procname = "zone_reclaim_mode",
1165	.data = &zone_reclaim_mode,	1165	.data = &zone_reclaim_mode,
1166	.maxlen = sizeof(zone_reclaim_mode),	1166	.maxlen = sizeof(zone_reclaim_mode),
1167	.mode = 0644,	1167	.mode = 0644,
1168	.proc_handler = &proc_dointvec,	1168	.proc_handler = &proc_dointvec,
1169	.strategy = &sysctl_intvec,	1169	.strategy = &sysctl_intvec,
1170	.extra1 = &zero,	1170	.extra1 = &zero,
1171	},	1171	},
1172	{	1172	{
1173	.ctl_name = VM_MIN_UNMAPPED,	1173	.ctl_name = VM_MIN_UNMAPPED,
1174	.procname = "min_unmapped_ratio",	1174	.procname = "min_unmapped_ratio",
1175	.data = &sysctl_min_unmapped_ratio,	1175	.data = &sysctl_min_unmapped_ratio,
1176	.maxlen = sizeof(sysctl_min_unmapped_ratio),	1176	.maxlen = sizeof(sysctl_min_unmapped_ratio),
1177	.mode = 0644,	1177	.mode = 0644,
1178	.proc_handler = &sysctl_min_unmapped_ratio_sysctl_handler,	1178	.proc_handler = &sysctl_min_unmapped_ratio_sysctl_handler,
1179	.strategy = &sysctl_intvec,	1179	.strategy = &sysctl_intvec,
1180	.extra1 = &zero,	1180	.extra1 = &zero,
1181	.extra2 = &one_hundred,	1181	.extra2 = &one_hundred,
1182	},	1182	},
1183	{	1183	{
1184	.ctl_name = VM_MIN_SLAB,	1184	.ctl_name = VM_MIN_SLAB,
1185	.procname = "min_slab_ratio",	1185	.procname = "min_slab_ratio",
1186	.data = &sysctl_min_slab_ratio,	1186	.data = &sysctl_min_slab_ratio,
1187	.maxlen = sizeof(sysctl_min_slab_ratio),	1187	.maxlen = sizeof(sysctl_min_slab_ratio),
1188	.mode = 0644,	1188	.mode = 0644,
1189	.proc_handler = &sysctl_min_slab_ratio_sysctl_handler,	1189	.proc_handler = &sysctl_min_slab_ratio_sysctl_handler,
1190	.strategy = &sysctl_intvec,	1190	.strategy = &sysctl_intvec,
1191	.extra1 = &zero,	1191	.extra1 = &zero,
1192	.extra2 = &one_hundred,	1192	.extra2 = &one_hundred,
1193	},	1193	},
1194	#endif	1194	#endif
1195	#ifdef CONFIG_SMP	1195	#ifdef CONFIG_SMP
1196	{	1196	{
1197	.ctl_name = CTL_UNNUMBERED,	1197	.ctl_name = CTL_UNNUMBERED,
1198	.procname = "stat_interval",	1198	.procname = "stat_interval",
1199	.data = &sysctl_stat_interval,	1199	.data = &sysctl_stat_interval,
1200	.maxlen = sizeof(sysctl_stat_interval),	1200	.maxlen = sizeof(sysctl_stat_interval),
1201	.mode = 0644,	1201	.mode = 0644,
1202	.proc_handler = &proc_dointvec_jiffies,	1202	.proc_handler = &proc_dointvec_jiffies,
1203	.strategy = &sysctl_jiffies,	1203	.strategy = &sysctl_jiffies,
1204	},	1204	},
1205	#endif	1205	#endif
1206	#ifdef CONFIG_SECURITY	1206	#ifdef CONFIG_SECURITY
1207	{	1207	{
1208	.ctl_name = CTL_UNNUMBERED,	1208	.ctl_name = CTL_UNNUMBERED,
1209	.procname = "mmap_min_addr",	1209	.procname = "mmap_min_addr",
1210	.data = &mmap_min_addr,	1210	.data = &mmap_min_addr,
1211	.maxlen = sizeof(unsigned long),	1211	.maxlen = sizeof(unsigned long),
1212	.mode = 0644,	1212	.mode = 0644,
1213	.proc_handler = &proc_doulongvec_minmax,	1213	.proc_handler = &proc_doulongvec_minmax,
1214	},	1214	},
1215	#endif	1215	#endif
1216	#ifdef CONFIG_NUMA	1216	#ifdef CONFIG_NUMA
1217	{	1217	{
1218	.ctl_name = CTL_UNNUMBERED,	1218	.ctl_name = CTL_UNNUMBERED,
1219	.procname = "numa_zonelist_order",	1219	.procname = "numa_zonelist_order",
1220	.data = &numa_zonelist_order,	1220	.data = &numa_zonelist_order,
1221	.maxlen = NUMA_ZONELIST_ORDER_LEN,	1221	.maxlen = NUMA_ZONELIST_ORDER_LEN,
1222	.mode = 0644,	1222	.mode = 0644,
1223	.proc_handler = &numa_zonelist_order_handler,	1223	.proc_handler = &numa_zonelist_order_handler,
1224	.strategy = &sysctl_string,	1224	.strategy = &sysctl_string,
1225	},	1225	},
1226	#endif	1226	#endif
1227	#if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))\|\| \	1227	#if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))\|\| \
1228	(defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))	1228	(defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1229	{	1229	{
1230	.ctl_name = VM_VDSO_ENABLED,	1230	.ctl_name = VM_VDSO_ENABLED,
1231	.procname = "vdso_enabled",	1231	.procname = "vdso_enabled",
1232	.data = &vdso_enabled,	1232	.data = &vdso_enabled,
1233	.maxlen = sizeof(vdso_enabled),	1233	.maxlen = sizeof(vdso_enabled),
1234	.mode = 0644,	1234	.mode = 0644,
1235	.proc_handler = &proc_dointvec,	1235	.proc_handler = &proc_dointvec,
1236	.strategy = &sysctl_intvec,	1236	.strategy = &sysctl_intvec,
1237	.extra1 = &zero,	1237	.extra1 = &zero,
1238	},	1238	},
1239	#endif	1239	#endif
1240	#ifdef CONFIG_HIGHMEM	1240	#ifdef CONFIG_HIGHMEM
1241	{	1241	{
1242	.ctl_name = CTL_UNNUMBERED,	1242	.ctl_name = CTL_UNNUMBERED,
1243	.procname = "highmem_is_dirtyable",	1243	.procname = "highmem_is_dirtyable",
1244	.data = &vm_highmem_is_dirtyable,	1244	.data = &vm_highmem_is_dirtyable,
1245	.maxlen = sizeof(vm_highmem_is_dirtyable),	1245	.maxlen = sizeof(vm_highmem_is_dirtyable),
1246	.mode = 0644,	1246	.mode = 0644,
1247	.proc_handler = &proc_dointvec_minmax,	1247	.proc_handler = &proc_dointvec_minmax,
1248	.strategy = &sysctl_intvec,	1248	.strategy = &sysctl_intvec,
1249	.extra1 = &zero,	1249	.extra1 = &zero,
1250	.extra2 = &one,	1250	.extra2 = &one,
1251	},	1251	},
1252	#endif	1252	#endif
1253	/*	1253	/*
1254	* NOTE: do not add new entries to this table unless you have read	1254	* NOTE: do not add new entries to this table unless you have read
1255	* Documentation/sysctl/ctl_unnumbered.txt	1255	* Documentation/sysctl/ctl_unnumbered.txt
1256	*/	1256	*/
1257	{ .ctl_name = 0 }	1257	{ .ctl_name = 0 }
1258	};	1258	};
1259		1259
1260	#if defined(CONFIG_BINFMT_MISC) \|\| defined(CONFIG_BINFMT_MISC_MODULE)	1260	#if defined(CONFIG_BINFMT_MISC) \|\| defined(CONFIG_BINFMT_MISC_MODULE)
1261	static struct ctl_table binfmt_misc_table[] = {	1261	static struct ctl_table binfmt_misc_table[] = {
1262	{ .ctl_name = 0 }	1262	{ .ctl_name = 0 }
1263	};	1263	};
1264	#endif	1264	#endif
1265		1265
1266	static struct ctl_table fs_table[] = {	1266	static struct ctl_table fs_table[] = {
1267	{	1267	{
1268	.ctl_name = FS_NRINODE,	1268	.ctl_name = FS_NRINODE,
1269	.procname = "inode-nr",	1269	.procname = "inode-nr",
1270	.data = &inodes_stat,	1270	.data = &inodes_stat,
1271	.maxlen = 2*sizeof(int),	1271	.maxlen = 2*sizeof(int),
1272	.mode = 0444,	1272	.mode = 0444,
1273	.proc_handler = &proc_dointvec,	1273	.proc_handler = &proc_dointvec,
1274	},	1274	},
1275	{	1275	{
1276	.ctl_name = FS_STATINODE,	1276	.ctl_name = FS_STATINODE,
1277	.procname = "inode-state",	1277	.procname = "inode-state",
1278	.data = &inodes_stat,	1278	.data = &inodes_stat,
1279	.maxlen = 7*sizeof(int),	1279	.maxlen = 7*sizeof(int),
1280	.mode = 0444,	1280	.mode = 0444,
1281	.proc_handler = &proc_dointvec,	1281	.proc_handler = &proc_dointvec,
1282	},	1282	},
1283	{	1283	{
1284	.procname = "file-nr",	1284	.procname = "file-nr",
1285	.data = &files_stat,	1285	.data = &files_stat,
1286	.maxlen = 3*sizeof(int),	1286	.maxlen = 3*sizeof(int),
1287	.mode = 0444,	1287	.mode = 0444,
1288	.proc_handler = &proc_nr_files,	1288	.proc_handler = &proc_nr_files,
1289	},	1289	},
1290	{	1290	{
1291	.ctl_name = FS_MAXFILE,	1291	.ctl_name = FS_MAXFILE,
1292	.procname = "file-max",	1292	.procname = "file-max",
1293	.data = &files_stat.max_files,	1293	.data = &files_stat.max_files,
1294	.maxlen = sizeof(int),	1294	.maxlen = sizeof(int),
1295	.mode = 0644,	1295	.mode = 0644,
1296	.proc_handler = &proc_dointvec,	1296	.proc_handler = &proc_dointvec,
1297	},	1297	},
1298	{	1298	{
1299	.ctl_name = CTL_UNNUMBERED,	1299	.ctl_name = CTL_UNNUMBERED,
1300	.procname = "nr_open",	1300	.procname = "nr_open",
1301	.data = &sysctl_nr_open,	1301	.data = &sysctl_nr_open,
1302	.maxlen = sizeof(int),	1302	.maxlen = sizeof(int),
1303	.mode = 0644,	1303	.mode = 0644,
1304	.proc_handler = &proc_dointvec_minmax,	1304	.proc_handler = &proc_dointvec_minmax,
1305	.extra1 = &sysctl_nr_open_min,	1305	.extra1 = &sysctl_nr_open_min,
1306	.extra2 = &sysctl_nr_open_max,	1306	.extra2 = &sysctl_nr_open_max,
1307	},	1307	},
1308	{	1308	{
1309	.ctl_name = FS_DENTRY,	1309	.ctl_name = FS_DENTRY,
1310	.procname = "dentry-state",	1310	.procname = "dentry-state",
1311	.data = &dentry_stat,	1311	.data = &dentry_stat,
1312	.maxlen = 6*sizeof(int),	1312	.maxlen = 6*sizeof(int),
1313	.mode = 0444,	1313	.mode = 0444,
1314	.proc_handler = &proc_dointvec,	1314	.proc_handler = &proc_dointvec,
1315	},	1315	},
1316	{	1316	{
1317	.ctl_name = FS_OVERFLOWUID,	1317	.ctl_name = FS_OVERFLOWUID,
1318	.procname = "overflowuid",	1318	.procname = "overflowuid",
1319	.data = &fs_overflowuid,	1319	.data = &fs_overflowuid,
1320	.maxlen = sizeof(int),	1320	.maxlen = sizeof(int),
1321	.mode = 0644,	1321	.mode = 0644,
1322	.proc_handler = &proc_dointvec_minmax,	1322	.proc_handler = &proc_dointvec_minmax,
1323	.strategy = &sysctl_intvec,	1323	.strategy = &sysctl_intvec,
1324	.extra1 = &minolduid,	1324	.extra1 = &minolduid,
1325	.extra2 = &maxolduid,	1325	.extra2 = &maxolduid,
1326	},	1326	},
1327	{	1327	{
1328	.ctl_name = FS_OVERFLOWGID,	1328	.ctl_name = FS_OVERFLOWGID,
1329	.procname = "overflowgid",	1329	.procname = "overflowgid",
1330	.data = &fs_overflowgid,	1330	.data = &fs_overflowgid,
1331	.maxlen = sizeof(int),	1331	.maxlen = sizeof(int),
1332	.mode = 0644,	1332	.mode = 0644,
1333	.proc_handler = &proc_dointvec_minmax,	1333	.proc_handler = &proc_dointvec_minmax,
1334	.strategy = &sysctl_intvec,	1334	.strategy = &sysctl_intvec,
1335	.extra1 = &minolduid,	1335	.extra1 = &minolduid,
1336	.extra2 = &maxolduid,	1336	.extra2 = &maxolduid,
1337	},	1337	},
1338	#ifdef CONFIG_FILE_LOCKING	1338	#ifdef CONFIG_FILE_LOCKING
1339	{	1339	{
1340	.ctl_name = FS_LEASES,	1340	.ctl_name = FS_LEASES,
1341	.procname = "leases-enable",	1341	.procname = "leases-enable",
1342	.data = &leases_enable,	1342	.data = &leases_enable,
1343	.maxlen = sizeof(int),	1343	.maxlen = sizeof(int),
1344	.mode = 0644,	1344	.mode = 0644,
1345	.proc_handler = &proc_dointvec,	1345	.proc_handler = &proc_dointvec,
1346	},	1346	},
1347	#endif	1347	#endif
1348	#ifdef CONFIG_DNOTIFY	1348	#ifdef CONFIG_DNOTIFY
1349	{	1349	{
1350	.ctl_name = FS_DIR_NOTIFY,	1350	.ctl_name = FS_DIR_NOTIFY,
1351	.procname = "dir-notify-enable",	1351	.procname = "dir-notify-enable",
1352	.data = &dir_notify_enable,	1352	.data = &dir_notify_enable,
1353	.maxlen = sizeof(int),	1353	.maxlen = sizeof(int),
1354	.mode = 0644,	1354	.mode = 0644,
1355	.proc_handler = &proc_dointvec,	1355	.proc_handler = &proc_dointvec,
1356	},	1356	},
1357	#endif	1357	#endif
1358	#ifdef CONFIG_MMU	1358	#ifdef CONFIG_MMU
1359	#ifdef CONFIG_FILE_LOCKING	1359	#ifdef CONFIG_FILE_LOCKING
1360	{	1360	{
1361	.ctl_name = FS_LEASE_TIME,	1361	.ctl_name = FS_LEASE_TIME,
1362	.procname = "lease-break-time",	1362	.procname = "lease-break-time",
1363	.data = &lease_break_time,	1363	.data = &lease_break_time,
1364	.maxlen = sizeof(int),	1364	.maxlen = sizeof(int),
1365	.mode = 0644,	1365	.mode = 0644,
1366	.proc_handler = &proc_dointvec_minmax,	1366	.proc_handler = &proc_dointvec_minmax,
1367	.strategy = &sysctl_intvec,	1367	.strategy = &sysctl_intvec,
1368	.extra1 = &zero,	1368	.extra1 = &zero,
1369	.extra2 = &two,	1369	.extra2 = &two,
1370	},	1370	},
1371	#endif	1371	#endif
1372	#ifdef CONFIG_AIO	1372	#ifdef CONFIG_AIO
1373	{	1373	{
1374	.procname = "aio-nr",	1374	.procname = "aio-nr",
1375	.data = &aio_nr,	1375	.data = &aio_nr,
1376	.maxlen = sizeof(aio_nr),	1376	.maxlen = sizeof(aio_nr),
1377	.mode = 0444,	1377	.mode = 0444,
1378	.proc_handler = &proc_doulongvec_minmax,	1378	.proc_handler = &proc_doulongvec_minmax,
1379	},	1379	},
1380	{	1380	{
1381	.procname = "aio-max-nr",	1381	.procname = "aio-max-nr",
1382	.data = &aio_max_nr,	1382	.data = &aio_max_nr,
1383	.maxlen = sizeof(aio_max_nr),	1383	.maxlen = sizeof(aio_max_nr),
1384	.mode = 0644,	1384	.mode = 0644,
1385	.proc_handler = &proc_doulongvec_minmax,	1385	.proc_handler = &proc_doulongvec_minmax,
1386	},	1386	},
1387	#endif /* CONFIG_AIO */	1387	#endif /* CONFIG_AIO */
1388	#ifdef CONFIG_INOTIFY_USER	1388	#ifdef CONFIG_INOTIFY_USER
1389	{	1389	{
1390	.ctl_name = FS_INOTIFY,	1390	.ctl_name = FS_INOTIFY,
1391	.procname = "inotify",	1391	.procname = "inotify",
1392	.mode = 0555,	1392	.mode = 0555,
1393	.child = inotify_table,	1393	.child = inotify_table,
1394	},	1394	},
1395	#endif	1395	#endif
1396	#ifdef CONFIG_EPOLL	1396	#ifdef CONFIG_EPOLL
1397	{	1397	{
1398	.procname = "epoll",	1398	.procname = "epoll",
1399	.mode = 0555,	1399	.mode = 0555,
1400	.child = epoll_table,	1400	.child = epoll_table,
1401	},	1401	},
1402	#endif	1402	#endif
1403	#endif	1403	#endif
1404	{	1404	{
1405	.ctl_name = KERN_SETUID_DUMPABLE,	1405	.ctl_name = KERN_SETUID_DUMPABLE,
1406	.procname = "suid_dumpable",	1406	.procname = "suid_dumpable",
1407	.data = &suid_dumpable,	1407	.data = &suid_dumpable,
1408	.maxlen = sizeof(int),	1408	.maxlen = sizeof(int),
1409	.mode = 0644,	1409	.mode = 0644,
1410	.proc_handler = &proc_dointvec,	1410	.proc_handler = &proc_dointvec,
1411	},	1411	},
1412	#if defined(CONFIG_BINFMT_MISC) \|\| defined(CONFIG_BINFMT_MISC_MODULE)	1412	#if defined(CONFIG_BINFMT_MISC) \|\| defined(CONFIG_BINFMT_MISC_MODULE)
1413	{	1413	{
1414	.ctl_name = CTL_UNNUMBERED,	1414	.ctl_name = CTL_UNNUMBERED,
1415	.procname = "binfmt_misc",	1415	.procname = "binfmt_misc",
1416	.mode = 0555,	1416	.mode = 0555,
1417	.child = binfmt_misc_table,	1417	.child = binfmt_misc_table,
1418	},	1418	},
1419	#endif	1419	#endif
1420	/*	1420	/*
1421	* NOTE: do not add new entries to this table unless you have read	1421	* NOTE: do not add new entries to this table unless you have read
1422	* Documentation/sysctl/ctl_unnumbered.txt	1422	* Documentation/sysctl/ctl_unnumbered.txt
1423	*/	1423	*/
1424	{ .ctl_name = 0 }	1424	{ .ctl_name = 0 }
1425	};	1425	};
1426		1426
1427	static struct ctl_table debug_table[] = {	1427	static struct ctl_table debug_table[] = {
1428	#if defined(CONFIG_X86) \|\| defined(CONFIG_PPC)	1428	#if defined(CONFIG_X86) \|\| defined(CONFIG_PPC)
1429	{	1429	{
1430	.ctl_name = CTL_UNNUMBERED,	1430	.ctl_name = CTL_UNNUMBERED,
1431	.procname = "exception-trace",	1431	.procname = "exception-trace",
1432	.data = &show_unhandled_signals,	1432	.data = &show_unhandled_signals,
1433	.maxlen = sizeof(int),	1433	.maxlen = sizeof(int),
1434	.mode = 0644,	1434	.mode = 0644,
1435	.proc_handler = proc_dointvec	1435	.proc_handler = proc_dointvec
1436	},	1436	},
1437	#endif	1437	#endif
1438	{ .ctl_name = 0 }	1438	{ .ctl_name = 0 }
1439	};	1439	};
1440		1440
1441	static struct ctl_table dev_table[] = {	1441	static struct ctl_table dev_table[] = {
1442	{ .ctl_name = 0 }	1442	{ .ctl_name = 0 }
1443	};	1443	};
1444		1444
1445	static DEFINE_SPINLOCK(sysctl_lock);	1445	static DEFINE_SPINLOCK(sysctl_lock);
1446		1446
1447	/* called under sysctl_lock */	1447	/* called under sysctl_lock */
1448	static int use_table(struct ctl_table_header *p)	1448	static int use_table(struct ctl_table_header *p)
1449	{	1449	{
1450	if (unlikely(p->unregistering))	1450	if (unlikely(p->unregistering))
1451	return 0;	1451	return 0;
1452	p->used++;	1452	p->used++;
1453	return 1;	1453	return 1;
1454	}	1454	}
1455		1455
1456	/* called under sysctl_lock */	1456	/* called under sysctl_lock */
1457	static void unuse_table(struct ctl_table_header *p)	1457	static void unuse_table(struct ctl_table_header *p)
1458	{	1458	{
1459	if (!--p->used)	1459	if (!--p->used)
1460	if (unlikely(p->unregistering))	1460	if (unlikely(p->unregistering))
1461	complete(p->unregistering);	1461	complete(p->unregistering);
1462	}	1462	}
1463		1463
1464	/* called under sysctl_lock, will reacquire if has to wait */	1464	/* called under sysctl_lock, will reacquire if has to wait */
1465	static void start_unregistering(struct ctl_table_header *p)	1465	static void start_unregistering(struct ctl_table_header *p)
1466	{	1466	{
1467	/*	1467	/*
1468	* if p->used is 0, nobody will ever touch that entry again;	1468	* if p->used is 0, nobody will ever touch that entry again;
1469	* we'll eliminate all paths to it before dropping sysctl_lock	1469	* we'll eliminate all paths to it before dropping sysctl_lock
1470	*/	1470	*/
1471	if (unlikely(p->used)) {	1471	if (unlikely(p->used)) {
1472	struct completion wait;	1472	struct completion wait;
1473	init_completion(&wait);	1473	init_completion(&wait);
1474	p->unregistering = &wait;	1474	p->unregistering = &wait;
1475	spin_unlock(&sysctl_lock);	1475	spin_unlock(&sysctl_lock);
1476	wait_for_completion(&wait);	1476	wait_for_completion(&wait);
1477	spin_lock(&sysctl_lock);	1477	spin_lock(&sysctl_lock);
1478	} else {	1478	} else {
1479	/* anything non-NULL; we'll never dereference it */	1479	/* anything non-NULL; we'll never dereference it */
1480	p->unregistering = ERR_PTR(-EINVAL);	1480	p->unregistering = ERR_PTR(-EINVAL);
1481	}	1481	}
1482	/*	1482	/*
1483	* do not remove from the list until nobody holds it; walking the	1483	* do not remove from the list until nobody holds it; walking the
1484	* list in do_sysctl() relies on that.	1484	* list in do_sysctl() relies on that.
1485	*/	1485	*/
1486	list_del_init(&p->ctl_entry);	1486	list_del_init(&p->ctl_entry);
1487	}	1487	}
1488		1488
1489	void sysctl_head_get(struct ctl_table_header *head)	1489	void sysctl_head_get(struct ctl_table_header *head)
1490	{	1490	{
1491	spin_lock(&sysctl_lock);	1491	spin_lock(&sysctl_lock);
1492	head->count++;	1492	head->count++;
1493	spin_unlock(&sysctl_lock);	1493	spin_unlock(&sysctl_lock);
1494	}	1494	}
1495		1495
1496	void sysctl_head_put(struct ctl_table_header *head)	1496	void sysctl_head_put(struct ctl_table_header *head)
1497	{	1497	{
1498	spin_lock(&sysctl_lock);	1498	spin_lock(&sysctl_lock);
1499	if (!--head->count)	1499	if (!--head->count)
1500	kfree(head);	1500	kfree(head);
1501	spin_unlock(&sysctl_lock);	1501	spin_unlock(&sysctl_lock);
1502	}	1502	}
1503		1503
1504	struct ctl_table_header sysctl_head_grab(struct ctl_table_header head)	1504	struct ctl_table_header sysctl_head_grab(struct ctl_table_header head)
1505	{	1505	{
1506	if (!head)	1506	if (!head)
1507	BUG();	1507	BUG();
1508	spin_lock(&sysctl_lock);	1508	spin_lock(&sysctl_lock);
1509	if (!use_table(head))	1509	if (!use_table(head))
1510	head = ERR_PTR(-ENOENT);	1510	head = ERR_PTR(-ENOENT);
1511	spin_unlock(&sysctl_lock);	1511	spin_unlock(&sysctl_lock);
1512	return head;	1512	return head;
1513	}	1513	}
1514		1514
1515	void sysctl_head_finish(struct ctl_table_header *head)	1515	void sysctl_head_finish(struct ctl_table_header *head)
1516	{	1516	{
1517	if (!head)	1517	if (!head)
1518	return;	1518	return;
1519	spin_lock(&sysctl_lock);	1519	spin_lock(&sysctl_lock);
1520	unuse_table(head);	1520	unuse_table(head);
1521	spin_unlock(&sysctl_lock);	1521	spin_unlock(&sysctl_lock);
1522	}	1522	}
1523		1523
1524	static struct ctl_table_set *	1524	static struct ctl_table_set *
1525	lookup_header_set(struct ctl_table_root root, struct nsproxy namespaces)	1525	lookup_header_set(struct ctl_table_root root, struct nsproxy namespaces)
1526	{	1526	{
1527	struct ctl_table_set *set = &root->default_set;	1527	struct ctl_table_set *set = &root->default_set;
1528	if (root->lookup)	1528	if (root->lookup)
1529	set = root->lookup(root, namespaces);	1529	set = root->lookup(root, namespaces);
1530	return set;	1530	return set;
1531	}	1531	}
1532		1532
1533	static struct list_head *	1533	static struct list_head *
1534	lookup_header_list(struct ctl_table_root root, struct nsproxy namespaces)	1534	lookup_header_list(struct ctl_table_root root, struct nsproxy namespaces)
1535	{	1535	{
1536	struct ctl_table_set *set = lookup_header_set(root, namespaces);	1536	struct ctl_table_set *set = lookup_header_set(root, namespaces);
1537	return &set->list;	1537	return &set->list;
1538	}	1538	}
1539		1539
1540	struct ctl_table_header __sysctl_head_next(struct nsproxy namespaces,	1540	struct ctl_table_header __sysctl_head_next(struct nsproxy namespaces,
1541	struct ctl_table_header *prev)	1541	struct ctl_table_header *prev)
1542	{	1542	{
1543	struct ctl_table_root *root;	1543	struct ctl_table_root *root;
1544	struct list_head *header_list;	1544	struct list_head *header_list;
1545	struct ctl_table_header *head;	1545	struct ctl_table_header *head;
1546	struct list_head *tmp;	1546	struct list_head *tmp;
1547		1547
1548	spin_lock(&sysctl_lock);	1548	spin_lock(&sysctl_lock);
1549	if (prev) {	1549	if (prev) {
1550	head = prev;	1550	head = prev;
1551	tmp = &prev->ctl_entry;	1551	tmp = &prev->ctl_entry;
1552	unuse_table(prev);	1552	unuse_table(prev);
1553	goto next;	1553	goto next;
1554	}	1554	}
1555	tmp = &root_table_header.ctl_entry;	1555	tmp = &root_table_header.ctl_entry;
1556	for (;;) {	1556	for (;;) {
1557	head = list_entry(tmp, struct ctl_table_header, ctl_entry);	1557	head = list_entry(tmp, struct ctl_table_header, ctl_entry);
1558		1558
1559	if (!use_table(head))	1559	if (!use_table(head))
1560	goto next;	1560	goto next;
1561	spin_unlock(&sysctl_lock);	1561	spin_unlock(&sysctl_lock);
1562	return head;	1562	return head;
1563	next:	1563	next:
1564	root = head->root;	1564	root = head->root;
1565	tmp = tmp->next;	1565	tmp = tmp->next;
1566	header_list = lookup_header_list(root, namespaces);	1566	header_list = lookup_header_list(root, namespaces);
1567	if (tmp != header_list)	1567	if (tmp != header_list)
1568	continue;	1568	continue;
1569		1569
1570	do {	1570	do {
1571	root = list_entry(root->root_list.next,	1571	root = list_entry(root->root_list.next,
1572	struct ctl_table_root, root_list);	1572	struct ctl_table_root, root_list);
1573	if (root == &sysctl_table_root)	1573	if (root == &sysctl_table_root)
1574	goto out;	1574	goto out;
1575	header_list = lookup_header_list(root, namespaces);	1575	header_list = lookup_header_list(root, namespaces);
1576	} while (list_empty(header_list));	1576	} while (list_empty(header_list));
1577	tmp = header_list->next;	1577	tmp = header_list->next;
1578	}	1578	}
1579	out:	1579	out:
1580	spin_unlock(&sysctl_lock);	1580	spin_unlock(&sysctl_lock);
1581	return NULL;	1581	return NULL;
1582	}	1582	}
1583		1583
1584	struct ctl_table_header sysctl_head_next(struct ctl_table_header prev)	1584	struct ctl_table_header sysctl_head_next(struct ctl_table_header prev)
1585	{	1585	{
1586	return __sysctl_head_next(current->nsproxy, prev);	1586	return __sysctl_head_next(current->nsproxy, prev);
1587	}	1587	}
1588		1588
1589	void register_sysctl_root(struct ctl_table_root *root)	1589	void register_sysctl_root(struct ctl_table_root *root)
1590	{	1590	{
1591	spin_lock(&sysctl_lock);	1591	spin_lock(&sysctl_lock);
1592	list_add_tail(&root->root_list, &sysctl_table_root.root_list);	1592	list_add_tail(&root->root_list, &sysctl_table_root.root_list);
1593	spin_unlock(&sysctl_lock);	1593	spin_unlock(&sysctl_lock);
1594	}	1594	}
1595		1595
1596	#ifdef CONFIG_SYSCTL_SYSCALL	1596	#ifdef CONFIG_SYSCTL_SYSCALL
1597	/* Perform the actual read/write of a sysctl table entry. */	1597	/* Perform the actual read/write of a sysctl table entry. */
1598	static int do_sysctl_strategy(struct ctl_table_root *root,	1598	static int do_sysctl_strategy(struct ctl_table_root *root,
1599	struct ctl_table *table,	1599	struct ctl_table *table,
1600	void __user oldval, size_t __user oldlenp,	1600	void __user oldval, size_t __user oldlenp,
1601	void __user *newval, size_t newlen)	1601	void __user *newval, size_t newlen)
1602	{	1602	{
1603	int op = 0, rc;	1603	int op = 0, rc;
1604		1604
1605	if (oldval)	1605	if (oldval)
1606	op \|= MAY_READ;	1606	op \|= MAY_READ;
1607	if (newval)	1607	if (newval)
1608	op \|= MAY_WRITE;	1608	op \|= MAY_WRITE;
1609	if (sysctl_perm(root, table, op))	1609	if (sysctl_perm(root, table, op))
1610	return -EPERM;	1610	return -EPERM;
1611		1611
1612	if (table->strategy) {	1612	if (table->strategy) {
1613	rc = table->strategy(table, oldval, oldlenp, newval, newlen);	1613	rc = table->strategy(table, oldval, oldlenp, newval, newlen);
1614	if (rc < 0)	1614	if (rc < 0)
1615	return rc;	1615	return rc;
1616	if (rc > 0)	1616	if (rc > 0)
1617	return 0;	1617	return 0;
1618	}	1618	}
1619		1619
1620	/* If there is no strategy routine, or if the strategy returns	1620	/* If there is no strategy routine, or if the strategy returns
1621	* zero, proceed with automatic r/w */	1621	* zero, proceed with automatic r/w */
1622	if (table->data && table->maxlen) {	1622	if (table->data && table->maxlen) {
1623	rc = sysctl_data(table, oldval, oldlenp, newval, newlen);	1623	rc = sysctl_data(table, oldval, oldlenp, newval, newlen);
1624	if (rc < 0)	1624	if (rc < 0)
1625	return rc;	1625	return rc;
1626	}	1626	}
1627	return 0;	1627	return 0;
1628	}	1628	}
1629		1629
1630	static int parse_table(int __user *name, int nlen,	1630	static int parse_table(int __user *name, int nlen,
1631	void __user oldval, size_t __user oldlenp,	1631	void __user oldval, size_t __user oldlenp,
1632	void __user *newval, size_t newlen,	1632	void __user *newval, size_t newlen,
1633	struct ctl_table_root *root,	1633	struct ctl_table_root *root,
1634	struct ctl_table *table)	1634	struct ctl_table *table)
1635	{	1635	{
1636	int n;	1636	int n;
1637	repeat:	1637	repeat:
1638	if (!nlen)	1638	if (!nlen)
1639	return -ENOTDIR;	1639	return -ENOTDIR;
1640	if (get_user(n, name))	1640	if (get_user(n, name))
1641	return -EFAULT;	1641	return -EFAULT;
1642	for ( ; table->ctl_name \|\| table->procname; table++) {	1642	for ( ; table->ctl_name \|\| table->procname; table++) {
1643	if (!table->ctl_name)	1643	if (!table->ctl_name)
1644	continue;	1644	continue;
1645	if (n == table->ctl_name) {	1645	if (n == table->ctl_name) {
1646	int error;	1646	int error;
1647	if (table->child) {	1647	if (table->child) {
1648	if (sysctl_perm(root, table, MAY_EXEC))	1648	if (sysctl_perm(root, table, MAY_EXEC))
1649	return -EPERM;	1649	return -EPERM;
1650	name++;	1650	name++;
1651	nlen--;	1651	nlen--;
1652	table = table->child;	1652	table = table->child;
1653	goto repeat;	1653	goto repeat;
1654	}	1654	}
1655	error = do_sysctl_strategy(root, table,	1655	error = do_sysctl_strategy(root, table,
1656	oldval, oldlenp,	1656	oldval, oldlenp,
1657	newval, newlen);	1657	newval, newlen);
1658	return error;	1658	return error;
1659	}	1659	}
1660	}	1660	}
1661	return -ENOTDIR;	1661	return -ENOTDIR;
1662	}	1662	}
1663		1663
1664	int do_sysctl(int __user name, int nlen, void __user oldval, size_t __user *oldlenp,	1664	int do_sysctl(int __user name, int nlen, void __user oldval, size_t __user *oldlenp,
1665	void __user *newval, size_t newlen)	1665	void __user *newval, size_t newlen)
1666	{	1666	{
1667	struct ctl_table_header *head;	1667	struct ctl_table_header *head;
1668	int error = -ENOTDIR;	1668	int error = -ENOTDIR;
1669		1669
1670	if (nlen <= 0 \|\| nlen >= CTL_MAXNAME)	1670	if (nlen <= 0 \|\| nlen >= CTL_MAXNAME)
1671	return -ENOTDIR;	1671	return -ENOTDIR;
1672	if (oldval) {	1672	if (oldval) {
1673	int old_len;	1673	int old_len;
1674	if (!oldlenp \|\| get_user(old_len, oldlenp))	1674	if (!oldlenp \|\| get_user(old_len, oldlenp))
1675	return -EFAULT;	1675	return -EFAULT;
1676	}	1676	}
1677		1677
1678	for (head = sysctl_head_next(NULL); head;	1678	for (head = sysctl_head_next(NULL); head;
1679	head = sysctl_head_next(head)) {	1679	head = sysctl_head_next(head)) {
1680	error = parse_table(name, nlen, oldval, oldlenp,	1680	error = parse_table(name, nlen, oldval, oldlenp,
1681	newval, newlen,	1681	newval, newlen,
1682	head->root, head->ctl_table);	1682	head->root, head->ctl_table);
1683	if (error != -ENOTDIR) {	1683	if (error != -ENOTDIR) {
1684	sysctl_head_finish(head);	1684	sysctl_head_finish(head);
1685	break;	1685	break;
1686	}	1686	}
1687	}	1687	}
1688	return error;	1688	return error;
1689	}	1689	}
1690		1690
1691	asmlinkage long sys_sysctl(struct __sysctl_args __user *args)	1691	asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
1692	{	1692	{
1693	struct __sysctl_args tmp;	1693	struct __sysctl_args tmp;
1694	int error;	1694	int error;
1695		1695
1696	if (copy_from_user(&tmp, args, sizeof(tmp)))	1696	if (copy_from_user(&tmp, args, sizeof(tmp)))
1697	return -EFAULT;	1697	return -EFAULT;
1698		1698
1699	error = deprecated_sysctl_warning(&tmp);	1699	error = deprecated_sysctl_warning(&tmp);
1700	if (error)	1700	if (error)
1701	goto out;	1701	goto out;
1702		1702
1703	lock_kernel();	1703	lock_kernel();
1704	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,	1704	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
1705	tmp.newval, tmp.newlen);	1705	tmp.newval, tmp.newlen);
1706	unlock_kernel();	1706	unlock_kernel();
1707	out:	1707	out:
1708	return error;	1708	return error;
1709	}	1709	}
1710	#endif /* CONFIG_SYSCTL_SYSCALL */	1710	#endif /* CONFIG_SYSCTL_SYSCALL */
1711		1711
1712	/*	1712	/*
1713	* sysctl_perm does NOT grant the superuser all rights automatically, because	1713	* sysctl_perm does NOT grant the superuser all rights automatically, because
1714	* some sysctl variables are readonly even to root.	1714	* some sysctl variables are readonly even to root.
1715	*/	1715	*/
1716		1716
1717	static int test_perm(int mode, int op)	1717	static int test_perm(int mode, int op)
1718	{	1718	{
1719	if (!current_euid())	1719	if (!current_euid())
1720	mode >>= 6;	1720	mode >>= 6;
1721	else if (in_egroup_p(0))	1721	else if (in_egroup_p(0))
1722	mode >>= 3;	1722	mode >>= 3;
1723	if ((op & ~mode & (MAY_READ\|MAY_WRITE\|MAY_EXEC)) == 0)	1723	if ((op & ~mode & (MAY_READ\|MAY_WRITE\|MAY_EXEC)) == 0)
1724	return 0;	1724	return 0;
1725	return -EACCES;	1725	return -EACCES;
1726	}	1726	}
1727		1727
1728	int sysctl_perm(struct ctl_table_root root, struct ctl_table table, int op)	1728	int sysctl_perm(struct ctl_table_root root, struct ctl_table table, int op)
1729	{	1729	{
1730	int error;	1730	int error;
1731	int mode;	1731	int mode;
1732		1732
1733	error = security_sysctl(table, op & (MAY_READ \| MAY_WRITE \| MAY_EXEC));	1733	error = security_sysctl(table, op & (MAY_READ \| MAY_WRITE \| MAY_EXEC));
1734	if (error)	1734	if (error)
1735	return error;	1735	return error;
1736		1736
1737	if (root->permissions)	1737	if (root->permissions)
1738	mode = root->permissions(root, current->nsproxy, table);	1738	mode = root->permissions(root, current->nsproxy, table);
1739	else	1739	else
1740	mode = table->mode;	1740	mode = table->mode;
1741		1741
1742	return test_perm(mode, op);	1742	return test_perm(mode, op);
1743	}	1743	}
1744		1744
1745	static void sysctl_set_parent(struct ctl_table parent, struct ctl_table table)	1745	static void sysctl_set_parent(struct ctl_table parent, struct ctl_table table)
1746	{	1746	{
1747	for (; table->ctl_name \|\| table->procname; table++) {	1747	for (; table->ctl_name \|\| table->procname; table++) {
1748	table->parent = parent;	1748	table->parent = parent;
1749	if (table->child)	1749	if (table->child)
1750	sysctl_set_parent(table, table->child);	1750	sysctl_set_parent(table, table->child);
1751	}	1751	}
1752	}	1752	}
1753		1753
1754	static __init int sysctl_init(void)	1754	static __init int sysctl_init(void)
1755	{	1755	{
1756	sysctl_set_parent(NULL, root_table);	1756	sysctl_set_parent(NULL, root_table);
1757	#ifdef CONFIG_SYSCTL_SYSCALL_CHECK	1757	#ifdef CONFIG_SYSCTL_SYSCALL_CHECK
1758	{	1758	{
1759	int err;	1759	int err;
1760	err = sysctl_check_table(current->nsproxy, root_table);	1760	err = sysctl_check_table(current->nsproxy, root_table);
1761	}	1761	}
1762	#endif	1762	#endif
1763	return 0;	1763	return 0;
1764	}	1764	}
1765		1765
1766	core_initcall(sysctl_init);	1766	core_initcall(sysctl_init);
1767		1767
1768	static struct ctl_table is_branch_in(struct ctl_table branch,	1768	static struct ctl_table is_branch_in(struct ctl_table branch,
1769	struct ctl_table *table)	1769	struct ctl_table *table)
1770	{	1770	{
1771	struct ctl_table *p;	1771	struct ctl_table *p;
1772	const char *s = branch->procname;	1772	const char *s = branch->procname;
1773		1773
1774	/* branch should have named subdirectory as its first element */	1774	/* branch should have named subdirectory as its first element */
1775	if (!s \|\| !branch->child)	1775	if (!s \|\| !branch->child)
1776	return NULL;	1776	return NULL;
1777		1777
1778	/* ... and nothing else */	1778	/* ... and nothing else */
1779	if (branch[1].procname \|\| branch[1].ctl_name)	1779	if (branch[1].procname \|\| branch[1].ctl_name)
1780	return NULL;	1780	return NULL;
1781		1781
1782	/* table should contain subdirectory with the same name */	1782	/* table should contain subdirectory with the same name */
1783	for (p = table; p->procname \|\| p->ctl_name; p++) {	1783	for (p = table; p->procname \|\| p->ctl_name; p++) {
1784	if (!p->child)	1784	if (!p->child)
1785	continue;	1785	continue;
1786	if (p->procname && strcmp(p->procname, s) == 0)	1786	if (p->procname && strcmp(p->procname, s) == 0)
1787	return p;	1787	return p;
1788	}	1788	}
1789	return NULL;	1789	return NULL;
1790	}	1790	}
1791		1791
1792	/* see if attaching q to p would be an improvement */	1792	/* see if attaching q to p would be an improvement */
1793	static void try_attach(struct ctl_table_header p, struct ctl_table_header q)	1793	static void try_attach(struct ctl_table_header p, struct ctl_table_header q)
1794	{	1794	{
1795	struct ctl_table to = p->ctl_table, by = q->ctl_table;	1795	struct ctl_table to = p->ctl_table, by = q->ctl_table;
1796	struct ctl_table *next;	1796	struct ctl_table *next;
1797	int is_better = 0;	1797	int is_better = 0;
1798	int not_in_parent = !p->attached_by;	1798	int not_in_parent = !p->attached_by;
1799		1799
1800	while ((next = is_branch_in(by, to)) != NULL) {	1800	while ((next = is_branch_in(by, to)) != NULL) {
1801	if (by == q->attached_by)	1801	if (by == q->attached_by)
1802	is_better = 1;	1802	is_better = 1;
1803	if (to == p->attached_by)	1803	if (to == p->attached_by)
1804	not_in_parent = 1;	1804	not_in_parent = 1;
1805	by = by->child;	1805	by = by->child;
1806	to = next->child;	1806	to = next->child;
1807	}	1807	}
1808		1808
1809	if (is_better && not_in_parent) {	1809	if (is_better && not_in_parent) {
1810	q->attached_by = by;	1810	q->attached_by = by;
1811	q->attached_to = to;	1811	q->attached_to = to;
1812	q->parent = p;	1812	q->parent = p;
1813	}	1813	}
1814	}	1814	}
1815		1815
1816	/**	1816	/**
1817	* __register_sysctl_paths - register a sysctl hierarchy	1817	* __register_sysctl_paths - register a sysctl hierarchy
1818	* @root: List of sysctl headers to register on	1818	* @root: List of sysctl headers to register on
1819	* @namespaces: Data to compute which lists of sysctl entries are visible	1819	* @namespaces: Data to compute which lists of sysctl entries are visible
1820	* @path: The path to the directory the sysctl table is in.	1820	* @path: The path to the directory the sysctl table is in.
1821	* @table: the top-level table structure	1821	* @table: the top-level table structure
1822	*	1822	*
1823	* Register a sysctl table hierarchy. @table should be a filled in ctl_table	1823	* Register a sysctl table hierarchy. @table should be a filled in ctl_table
1824	* array. A completely 0 filled entry terminates the table.	1824	* array. A completely 0 filled entry terminates the table.
1825	*	1825	*
1826	* The members of the &struct ctl_table structure are used as follows:	1826	* The members of the &struct ctl_table structure are used as follows:
1827	*	1827	*
1828	* ctl_name - This is the numeric sysctl value used by sysctl(2). The number	1828	* ctl_name - This is the numeric sysctl value used by sysctl(2). The number
1829	* must be unique within that level of sysctl	1829	* must be unique within that level of sysctl
1830	*	1830	*
1831	* procname - the name of the sysctl file under /proc/sys. Set to %NULL to not	1831	* procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
1832	* enter a sysctl file	1832	* enter a sysctl file
1833	*	1833	*
1834	* data - a pointer to data for use by proc_handler	1834	* data - a pointer to data for use by proc_handler
1835	*	1835	*
1836	* maxlen - the maximum size in bytes of the data	1836	* maxlen - the maximum size in bytes of the data
1837	*	1837	*
1838	* mode - the file permissions for the /proc/sys file, and for sysctl(2)	1838	* mode - the file permissions for the /proc/sys file, and for sysctl(2)
1839	*	1839	*
1840	* child - a pointer to the child sysctl table if this entry is a directory, or	1840	* child - a pointer to the child sysctl table if this entry is a directory, or
1841	* %NULL.	1841	* %NULL.
1842	*	1842	*
1843	* proc_handler - the text handler routine (described below)	1843	* proc_handler - the text handler routine (described below)
1844	*	1844	*
1845	* strategy - the strategy routine (described below)	1845	* strategy - the strategy routine (described below)
1846	*	1846	*
1847	* de - for internal use by the sysctl routines	1847	* de - for internal use by the sysctl routines
1848	*	1848	*
1849	* extra1, extra2 - extra pointers usable by the proc handler routines	1849	* extra1, extra2 - extra pointers usable by the proc handler routines
1850	*	1850	*
1851	* Leaf nodes in the sysctl tree will be represented by a single file	1851	* Leaf nodes in the sysctl tree will be represented by a single file
1852	* under /proc; non-leaf nodes will be represented by directories.	1852	* under /proc; non-leaf nodes will be represented by directories.
1853	*	1853	*
1854	* sysctl(2) can automatically manage read and write requests through	1854	* sysctl(2) can automatically manage read and write requests through
1855	* the sysctl table. The data and maxlen fields of the ctl_table	1855	* the sysctl table. The data and maxlen fields of the ctl_table
1856	* struct enable minimal validation of the values being written to be	1856	* struct enable minimal validation of the values being written to be
1857	* performed, and the mode field allows minimal authentication.	1857	* performed, and the mode field allows minimal authentication.
1858	*	1858	*
1859	* More sophisticated management can be enabled by the provision of a	1859	* More sophisticated management can be enabled by the provision of a
1860	* strategy routine with the table entry. This will be called before	1860	* strategy routine with the table entry. This will be called before
1861	* any automatic read or write of the data is performed.	1861	* any automatic read or write of the data is performed.
1862	*	1862	*
1863	* The strategy routine may return	1863	* The strategy routine may return
1864	*	1864	*
1865	* < 0 - Error occurred (error is passed to user process)	1865	* < 0 - Error occurred (error is passed to user process)
1866	*	1866	*
1867	* 0 - OK - proceed with automatic read or write.	1867	* 0 - OK - proceed with automatic read or write.
1868	*	1868	*
1869	* > 0 - OK - read or write has been done by the strategy routine, so	1869	* > 0 - OK - read or write has been done by the strategy routine, so
1870	* return immediately.	1870	* return immediately.
1871	*	1871	*
1872	* There must be a proc_handler routine for any terminal nodes	1872	* There must be a proc_handler routine for any terminal nodes
1873	* mirrored under /proc/sys (non-terminals are handled by a built-in	1873	* mirrored under /proc/sys (non-terminals are handled by a built-in
1874	* directory handler). Several default handlers are available to	1874	* directory handler). Several default handlers are available to
1875	* cover common cases -	1875	* cover common cases -
1876	*	1876	*
1877	* proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),	1877	* proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
1878	* proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),	1878	* proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
1879	* proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()	1879	* proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
1880	*	1880	*
1881	* It is the handler's job to read the input buffer from user memory	1881	* It is the handler's job to read the input buffer from user memory
1882	* and process it. The handler should return 0 on success.	1882	* and process it. The handler should return 0 on success.
1883	*	1883	*
1884	* This routine returns %NULL on a failure to register, and a pointer	1884	* This routine returns %NULL on a failure to register, and a pointer
1885	* to the table header on success.	1885	* to the table header on success.
1886	*/	1886	*/
1887	struct ctl_table_header *__register_sysctl_paths(	1887	struct ctl_table_header *__register_sysctl_paths(
1888	struct ctl_table_root *root,	1888	struct ctl_table_root *root,
1889	struct nsproxy *namespaces,	1889	struct nsproxy *namespaces,
1890	const struct ctl_path path, struct ctl_table table)	1890	const struct ctl_path path, struct ctl_table table)
1891	{	1891	{
1892	struct ctl_table_header *header;	1892	struct ctl_table_header *header;
1893	struct ctl_table new, *prevp;	1893	struct ctl_table new, *prevp;
1894	unsigned int n, npath;	1894	unsigned int n, npath;
1895	struct ctl_table_set *set;	1895	struct ctl_table_set *set;
1896		1896
1897	/* Count the path components */	1897	/* Count the path components */
1898	for (npath = 0; path[npath].ctl_name \|\| path[npath].procname; ++npath)	1898	for (npath = 0; path[npath].ctl_name \|\| path[npath].procname; ++npath)
1899	;	1899	;
1900		1900
1901	/*	1901	/*
1902	* For each path component, allocate a 2-element ctl_table array.	1902	* For each path component, allocate a 2-element ctl_table array.
1903	* The first array element will be filled with the sysctl entry	1903	* The first array element will be filled with the sysctl entry
1904	* for this, the second will be the sentinel (ctl_name == 0).	1904	* for this, the second will be the sentinel (ctl_name == 0).
1905	*	1905	*
1906	* We allocate everything in one go so that we don't have to	1906	* We allocate everything in one go so that we don't have to
1907	* worry about freeing additional memory in unregister_sysctl_table.	1907	* worry about freeing additional memory in unregister_sysctl_table.
1908	*/	1908	*/
1909	header = kzalloc(sizeof(struct ctl_table_header) +	1909	header = kzalloc(sizeof(struct ctl_table_header) +
1910	(2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);	1910	(2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);
1911	if (!header)	1911	if (!header)
1912	return NULL;	1912	return NULL;
1913		1913
1914	new = (struct ctl_table *) (header + 1);	1914	new = (struct ctl_table *) (header + 1);
1915		1915
1916	/* Now connect the dots */	1916	/* Now connect the dots */
1917	prevp = &header->ctl_table;	1917	prevp = &header->ctl_table;
1918	for (n = 0; n < npath; ++n, ++path) {	1918	for (n = 0; n < npath; ++n, ++path) {
1919	/* Copy the procname */	1919	/* Copy the procname */
1920	new->procname = path->procname;	1920	new->procname = path->procname;
1921	new->ctl_name = path->ctl_name;	1921	new->ctl_name = path->ctl_name;
1922	new->mode = 0555;	1922	new->mode = 0555;
1923		1923
1924	*prevp = new;	1924	*prevp = new;
1925	prevp = &new->child;	1925	prevp = &new->child;
1926		1926
1927	new += 2;	1927	new += 2;
1928	}	1928	}
1929	*prevp = table;	1929	*prevp = table;
1930	header->ctl_table_arg = table;	1930	header->ctl_table_arg = table;
1931		1931
1932	INIT_LIST_HEAD(&header->ctl_entry);	1932	INIT_LIST_HEAD(&header->ctl_entry);
1933	header->used = 0;	1933	header->used = 0;
1934	header->unregistering = NULL;	1934	header->unregistering = NULL;
1935	header->root = root;	1935	header->root = root;
1936	sysctl_set_parent(NULL, header->ctl_table);	1936	sysctl_set_parent(NULL, header->ctl_table);
1937	header->count = 1;	1937	header->count = 1;
1938	#ifdef CONFIG_SYSCTL_SYSCALL_CHECK	1938	#ifdef CONFIG_SYSCTL_SYSCALL_CHECK
1939	if (sysctl_check_table(namespaces, header->ctl_table)) {	1939	if (sysctl_check_table(namespaces, header->ctl_table)) {
1940	kfree(header);	1940	kfree(header);
1941	return NULL;	1941	return NULL;
1942	}	1942	}
1943	#endif	1943	#endif
1944	spin_lock(&sysctl_lock);	1944	spin_lock(&sysctl_lock);
1945	header->set = lookup_header_set(root, namespaces);	1945	header->set = lookup_header_set(root, namespaces);
1946	header->attached_by = header->ctl_table;	1946	header->attached_by = header->ctl_table;
1947	header->attached_to = root_table;	1947	header->attached_to = root_table;
1948	header->parent = &root_table_header;	1948	header->parent = &root_table_header;
1949	for (set = header->set; set; set = set->parent) {	1949	for (set = header->set; set; set = set->parent) {
1950	struct ctl_table_header *p;	1950	struct ctl_table_header *p;
1951	list_for_each_entry(p, &set->list, ctl_entry) {	1951	list_for_each_entry(p, &set->list, ctl_entry) {
1952	if (p->unregistering)	1952	if (p->unregistering)
1953	continue;	1953	continue;
1954	try_attach(p, header);	1954	try_attach(p, header);
1955	}	1955	}
1956	}	1956	}
1957	header->parent->count++;	1957	header->parent->count++;
1958	list_add_tail(&header->ctl_entry, &header->set->list);	1958	list_add_tail(&header->ctl_entry, &header->set->list);
1959	spin_unlock(&sysctl_lock);	1959	spin_unlock(&sysctl_lock);
1960		1960
1961	return header;	1961	return header;
1962	}	1962	}
1963		1963
1964	/**	1964	/**
1965	* register_sysctl_table_path - register a sysctl table hierarchy	1965	* register_sysctl_table_path - register a sysctl table hierarchy
1966	* @path: The path to the directory the sysctl table is in.	1966	* @path: The path to the directory the sysctl table is in.
1967	* @table: the top-level table structure	1967	* @table: the top-level table structure
1968	*	1968	*
1969	* Register a sysctl table hierarchy. @table should be a filled in ctl_table	1969	* Register a sysctl table hierarchy. @table should be a filled in ctl_table
1970	* array. A completely 0 filled entry terminates the table.	1970	* array. A completely 0 filled entry terminates the table.
1971	*	1971	*
1972	* See __register_sysctl_paths for more details.	1972	* See __register_sysctl_paths for more details.
1973	*/	1973	*/
1974	struct ctl_table_header register_sysctl_paths(const struct ctl_path path,	1974	struct ctl_table_header register_sysctl_paths(const struct ctl_path path,
1975	struct ctl_table *table)	1975	struct ctl_table *table)
1976	{	1976	{
1977	return __register_sysctl_paths(&sysctl_table_root, current->nsproxy,	1977	return __register_sysctl_paths(&sysctl_table_root, current->nsproxy,
1978	path, table);	1978	path, table);
1979	}	1979	}
1980		1980
1981	/**	1981	/**
1982	* register_sysctl_table - register a sysctl table hierarchy	1982	* register_sysctl_table - register a sysctl table hierarchy
1983	* @table: the top-level table structure	1983	* @table: the top-level table structure
1984	*	1984	*
1985	* Register a sysctl table hierarchy. @table should be a filled in ctl_table	1985	* Register a sysctl table hierarchy. @table should be a filled in ctl_table
1986	* array. A completely 0 filled entry terminates the table.	1986	* array. A completely 0 filled entry terminates the table.
1987	*	1987	*
1988	* See register_sysctl_paths for more details.	1988	* See register_sysctl_paths for more details.
1989	*/	1989	*/
1990	struct ctl_table_header register_sysctl_table(struct ctl_table table)	1990	struct ctl_table_header register_sysctl_table(struct ctl_table table)
1991	{	1991	{
1992	static const struct ctl_path null_path[] = { {} };	1992	static const struct ctl_path null_path[] = { {} };
1993		1993
1994	return register_sysctl_paths(null_path, table);	1994	return register_sysctl_paths(null_path, table);
1995	}	1995	}
1996		1996
1997	/**	1997	/**
1998	* unregister_sysctl_table - unregister a sysctl table hierarchy	1998	* unregister_sysctl_table - unregister a sysctl table hierarchy
1999	* @header: the header returned from register_sysctl_table	1999	* @header: the header returned from register_sysctl_table
2000	*	2000	*
2001	* Unregisters the sysctl table and all children. proc entries may not	2001	* Unregisters the sysctl table and all children. proc entries may not
2002	* actually be removed until they are no longer used by anyone.	2002	* actually be removed until they are no longer used by anyone.
2003	*/	2003	*/
2004	void unregister_sysctl_table(struct ctl_table_header * header)	2004	void unregister_sysctl_table(struct ctl_table_header * header)
2005	{	2005	{
2006	might_sleep();	2006	might_sleep();
2007		2007
2008	if (header == NULL)	2008	if (header == NULL)
2009	return;	2009	return;
2010		2010
2011	spin_lock(&sysctl_lock);	2011	spin_lock(&sysctl_lock);
2012	start_unregistering(header);	2012	start_unregistering(header);
2013	if (!--header->parent->count) {	2013	if (!--header->parent->count) {
2014	WARN_ON(1);	2014	WARN_ON(1);
2015	kfree(header->parent);	2015	kfree(header->parent);
2016	}	2016	}
2017	if (!--header->count)	2017	if (!--header->count)
2018	kfree(header);	2018	kfree(header);
2019	spin_unlock(&sysctl_lock);	2019	spin_unlock(&sysctl_lock);
2020	}	2020	}
2021		2021
2022	int sysctl_is_seen(struct ctl_table_header *p)	2022	int sysctl_is_seen(struct ctl_table_header *p)
2023	{	2023	{
2024	struct ctl_table_set *set = p->set;	2024	struct ctl_table_set *set = p->set;
2025	int res;	2025	int res;
2026	spin_lock(&sysctl_lock);	2026	spin_lock(&sysctl_lock);
2027	if (p->unregistering)	2027	if (p->unregistering)
2028	res = 0;	2028	res = 0;
2029	else if (!set->is_seen)	2029	else if (!set->is_seen)
2030	res = 1;	2030	res = 1;
2031	else	2031	else
2032	res = set->is_seen(set);	2032	res = set->is_seen(set);
2033	spin_unlock(&sysctl_lock);	2033	spin_unlock(&sysctl_lock);
2034	return res;	2034	return res;
2035	}	2035	}
2036		2036
2037	void setup_sysctl_set(struct ctl_table_set *p,	2037	void setup_sysctl_set(struct ctl_table_set *p,
2038	struct ctl_table_set *parent,	2038	struct ctl_table_set *parent,
2039	int (is_seen)(struct ctl_table_set ))	2039	int (is_seen)(struct ctl_table_set ))
2040	{	2040	{
2041	INIT_LIST_HEAD(&p->list);	2041	INIT_LIST_HEAD(&p->list);
2042	p->parent = parent ? parent : &sysctl_table_root.default_set;	2042	p->parent = parent ? parent : &sysctl_table_root.default_set;
2043	p->is_seen = is_seen;	2043	p->is_seen = is_seen;
2044	}	2044	}
2045		2045
2046	#else /* !CONFIG_SYSCTL */	2046	#else /* !CONFIG_SYSCTL */
2047	struct ctl_table_header register_sysctl_table(struct ctl_table table)	2047	struct ctl_table_header register_sysctl_table(struct ctl_table table)
2048	{	2048	{
2049	return NULL;	2049	return NULL;
2050	}	2050	}
2051		2051
2052	struct ctl_table_header register_sysctl_paths(const struct ctl_path path,	2052	struct ctl_table_header register_sysctl_paths(const struct ctl_path path,
2053	struct ctl_table *table)	2053	struct ctl_table *table)
2054	{	2054	{
2055	return NULL;	2055	return NULL;
2056	}	2056	}
2057		2057
2058	void unregister_sysctl_table(struct ctl_table_header * table)	2058	void unregister_sysctl_table(struct ctl_table_header * table)
2059	{	2059	{
2060	}	2060	}
2061		2061
2062	void setup_sysctl_set(struct ctl_table_set *p,	2062	void setup_sysctl_set(struct ctl_table_set *p,
2063	struct ctl_table_set *parent,	2063	struct ctl_table_set *parent,
2064	int (is_seen)(struct ctl_table_set ))	2064	int (is_seen)(struct ctl_table_set ))
2065	{	2065	{
2066	}	2066	}
2067		2067
2068	void sysctl_head_put(struct ctl_table_header *head)	2068	void sysctl_head_put(struct ctl_table_header *head)
2069	{	2069	{
2070	}	2070	}
2071		2071
2072	#endif /* CONFIG_SYSCTL */	2072	#endif /* CONFIG_SYSCTL */
2073		2073
2074	/*	2074	/*
2075	* /proc/sys support	2075	* /proc/sys support
2076	*/	2076	*/
2077		2077
2078	#ifdef CONFIG_PROC_SYSCTL	2078	#ifdef CONFIG_PROC_SYSCTL
2079		2079
2080	static int _proc_do_string(void* data, int maxlen, int write,	2080	static int _proc_do_string(void* data, int maxlen, int write,
2081	struct file filp, void __user buffer,	2081	struct file filp, void __user buffer,
2082	size_t lenp, loff_t ppos)	2082	size_t lenp, loff_t ppos)
2083	{	2083	{
2084	size_t len;	2084	size_t len;
2085	char __user *p;	2085	char __user *p;
2086	char c;	2086	char c;
2087		2087
2088	if (!data \|\| !maxlen \|\| !*lenp) {	2088	if (!data \|\| !maxlen \|\| !*lenp) {
2089	*lenp = 0;	2089	*lenp = 0;
2090	return 0;	2090	return 0;
2091	}	2091	}
2092		2092
2093	if (write) {	2093	if (write) {
2094	len = 0;	2094	len = 0;
2095	p = buffer;	2095	p = buffer;
2096	while (len < *lenp) {	2096	while (len < *lenp) {
2097	if (get_user(c, p++))	2097	if (get_user(c, p++))
2098	return -EFAULT;	2098	return -EFAULT;
2099	if (c == 0 \|\| c == '\n')	2099	if (c == 0 \|\| c == '\n')
2100	break;	2100	break;
2101	len++;	2101	len++;
2102	}	2102	}
2103	if (len >= maxlen)	2103	if (len >= maxlen)
2104	len = maxlen-1;	2104	len = maxlen-1;
2105	if(copy_from_user(data, buffer, len))	2105	if(copy_from_user(data, buffer, len))
2106	return -EFAULT;	2106	return -EFAULT;
2107	((char *) data)[len] = 0;	2107	((char *) data)[len] = 0;
2108	ppos += lenp;	2108	ppos += lenp;
2109	} else {	2109	} else {
2110	len = strlen(data);	2110	len = strlen(data);
2111	if (len > maxlen)	2111	if (len > maxlen)
2112	len = maxlen;	2112	len = maxlen;
2113		2113
2114	if (*ppos > len) {	2114	if (*ppos > len) {
2115	*lenp = 0;	2115	*lenp = 0;
2116	return 0;	2116	return 0;
2117	}	2117	}
2118		2118
2119	data += *ppos;	2119	data += *ppos;
2120	len -= *ppos;	2120	len -= *ppos;
2121		2121
2122	if (len > *lenp)	2122	if (len > *lenp)
2123	len = *lenp;	2123	len = *lenp;
2124	if (len)	2124	if (len)
2125	if(copy_to_user(buffer, data, len))	2125	if(copy_to_user(buffer, data, len))
2126	return -EFAULT;	2126	return -EFAULT;
2127	if (len < *lenp) {	2127	if (len < *lenp) {
2128	if(put_user('\n', ((char __user *) buffer) + len))	2128	if(put_user('\n', ((char __user *) buffer) + len))
2129	return -EFAULT;	2129	return -EFAULT;
2130	len++;	2130	len++;
2131	}	2131	}
2132	*lenp = len;	2132	*lenp = len;
2133	*ppos += len;	2133	*ppos += len;
2134	}	2134	}
2135	return 0;	2135	return 0;
2136	}	2136	}
2137		2137
2138	/**	2138	/**
2139	* proc_dostring - read a string sysctl	2139	* proc_dostring - read a string sysctl
2140	* @table: the sysctl table	2140	* @table: the sysctl table
2141	* @write: %TRUE if this is a write to the sysctl file	2141	* @write: %TRUE if this is a write to the sysctl file
2142	* @filp: the file structure	2142	* @filp: the file structure
2143	* @buffer: the user buffer	2143	* @buffer: the user buffer
2144	* @lenp: the size of the user buffer	2144	* @lenp: the size of the user buffer
2145	* @ppos: file position	2145	* @ppos: file position
2146	*	2146	*
2147	* Reads/writes a string from/to the user buffer. If the kernel	2147	* Reads/writes a string from/to the user buffer. If the kernel
2148	* buffer provided is not large enough to hold the string, the	2148	* buffer provided is not large enough to hold the string, the
2149	* string is truncated. The copied string is %NULL-terminated.	2149	* string is truncated. The copied string is %NULL-terminated.
2150	* If the string is being read by the user process, it is copied	2150	* If the string is being read by the user process, it is copied
2151	* and a newline '\n' is added. It is truncated if the buffer is	2151	* and a newline '\n' is added. It is truncated if the buffer is
2152	* not large enough.	2152	* not large enough.
2153	*	2153	*
2154	* Returns 0 on success.	2154	* Returns 0 on success.
2155	*/	2155	*/
2156	int proc_dostring(struct ctl_table table, int write, struct file filp,	2156	int proc_dostring(struct ctl_table table, int write, struct file filp,
2157	void __user buffer, size_t lenp, loff_t *ppos)	2157	void __user buffer, size_t lenp, loff_t *ppos)
2158	{	2158	{
2159	return _proc_do_string(table->data, table->maxlen, write, filp,	2159	return _proc_do_string(table->data, table->maxlen, write, filp,
2160	buffer, lenp, ppos);	2160	buffer, lenp, ppos);
2161	}	2161	}
2162		2162
2163		2163
2164	static int do_proc_dointvec_conv(int negp, unsigned long lvalp,	2164	static int do_proc_dointvec_conv(int negp, unsigned long lvalp,
2165	int *valp,	2165	int *valp,
2166	int write, void *data)	2166	int write, void *data)
2167	{	2167	{
2168	if (write) {	2168	if (write) {
2169	valp = negp ? -lvalp : lvalp;	2169	valp = negp ? -lvalp : lvalp;
2170	} else {	2170	} else {
2171	int val = *valp;	2171	int val = *valp;
2172	if (val < 0) {	2172	if (val < 0) {
2173	*negp = -1;	2173	*negp = -1;
2174	*lvalp = (unsigned long)-val;	2174	*lvalp = (unsigned long)-val;
2175	} else {	2175	} else {
2176	*negp = 0;	2176	*negp = 0;
2177	*lvalp = (unsigned long)val;	2177	*lvalp = (unsigned long)val;
2178	}	2178	}
2179	}	2179	}
2180	return 0;	2180	return 0;
2181	}	2181	}
2182		2182
2183	static int __do_proc_dointvec(void tbl_data, struct ctl_table table,	2183	static int __do_proc_dointvec(void tbl_data, struct ctl_table table,
2184	int write, struct file filp, void __user buffer,	2184	int write, struct file filp, void __user buffer,
2185	size_t lenp, loff_t ppos,	2185	size_t lenp, loff_t ppos,
2186	int (conv)(int negp, unsigned long lvalp, int valp,	2186	int (conv)(int negp, unsigned long lvalp, int valp,
2187	int write, void *data),	2187	int write, void *data),
2188	void *data)	2188	void *data)
2189	{	2189	{
2190	#define TMPBUFLEN 21	2190	#define TMPBUFLEN 21
2191	int *i, vleft, first=1, neg, val;	2191	int *i, vleft, first=1, neg, val;
2192	unsigned long lval;	2192	unsigned long lval;
2193	size_t left, len;	2193	size_t left, len;
2194		2194
2195	char buf[TMPBUFLEN], *p;	2195	char buf[TMPBUFLEN], *p;
2196	char __user *s = buffer;	2196	char __user *s = buffer;
2197		2197
2198	if (!tbl_data \|\| !table->maxlen \|\| !*lenp \|\|	2198	if (!tbl_data \|\| !table->maxlen \|\| !*lenp \|\|
2199	(*ppos && !write)) {	2199	(*ppos && !write)) {
2200	*lenp = 0;	2200	*lenp = 0;
2201	return 0;	2201	return 0;
2202	}	2202	}
2203		2203
2204	i = (int *) tbl_data;	2204	i = (int *) tbl_data;
2205	vleft = table->maxlen / sizeof(*i);	2205	vleft = table->maxlen / sizeof(*i);
2206	left = *lenp;	2206	left = *lenp;
2207		2207
2208	if (!conv)	2208	if (!conv)
2209	conv = do_proc_dointvec_conv;	2209	conv = do_proc_dointvec_conv;
2210		2210
2211	for (; left && vleft--; i++, first=0) {	2211	for (; left && vleft--; i++, first=0) {
2212	if (write) {	2212	if (write) {
2213	while (left) {	2213	while (left) {
2214	char c;	2214	char c;
2215	if (get_user(c, s))	2215	if (get_user(c, s))
2216	return -EFAULT;	2216	return -EFAULT;
2217	if (!isspace(c))	2217	if (!isspace(c))
2218	break;	2218	break;
2219	left--;	2219	left--;
2220	s++;	2220	s++;
2221	}	2221	}
2222	if (!left)	2222	if (!left)
2223	break;	2223	break;
2224	neg = 0;	2224	neg = 0;
2225	len = left;	2225	len = left;
2226	if (len > sizeof(buf) - 1)	2226	if (len > sizeof(buf) - 1)
2227	len = sizeof(buf) - 1;	2227	len = sizeof(buf) - 1;
2228	if (copy_from_user(buf, s, len))	2228	if (copy_from_user(buf, s, len))
2229	return -EFAULT;	2229	return -EFAULT;
2230	buf[len] = 0;	2230	buf[len] = 0;
2231	p = buf;	2231	p = buf;
2232	if (*p == '-' && left > 1) {	2232	if (*p == '-' && left > 1) {
2233	neg = 1;	2233	neg = 1;
2234	p++;	2234	p++;
2235	}	2235	}
2236	if (p < '0' \|\| p > '9')	2236	if (p < '0' \|\| p > '9')
2237	break;	2237	break;
2238		2238
2239	lval = simple_strtoul(p, &p, 0);	2239	lval = simple_strtoul(p, &p, 0);
2240		2240
2241	len = p-buf;	2241	len = p-buf;
2242	if ((len < left) && p && !isspace(p))	2242	if ((len < left) && p && !isspace(p))
2243	break;	2243	break;
2244	if (neg)	2244	if (neg)
2245	val = -val;	2245	val = -val;
2246	s += len;	2246	s += len;
2247	left -= len;	2247	left -= len;
2248		2248
2249	if (conv(&neg, &lval, i, 1, data))	2249	if (conv(&neg, &lval, i, 1, data))
2250	break;	2250	break;
2251	} else {	2251	} else {
2252	p = buf;	2252	p = buf;
2253	if (!first)	2253	if (!first)
2254	*p++ = '\t';	2254	*p++ = '\t';
2255		2255
2256	if (conv(&neg, &lval, i, 0, data))	2256	if (conv(&neg, &lval, i, 0, data))
2257	break;	2257	break;
2258		2258
2259	sprintf(p, "%s%lu", neg ? "-" : "", lval);	2259	sprintf(p, "%s%lu", neg ? "-" : "", lval);
2260	len = strlen(buf);	2260	len = strlen(buf);
2261	if (len > left)	2261	if (len > left)
2262	len = left;	2262	len = left;
2263	if(copy_to_user(s, buf, len))	2263	if(copy_to_user(s, buf, len))
2264	return -EFAULT;	2264	return -EFAULT;
2265	left -= len;	2265	left -= len;
2266	s += len;	2266	s += len;
2267	}	2267	}
2268	}	2268	}
2269		2269
2270	if (!write && !first && left) {	2270	if (!write && !first && left) {
2271	if(put_user('\n', s))	2271	if(put_user('\n', s))
2272	return -EFAULT;	2272	return -EFAULT;
2273	left--, s++;	2273	left--, s++;
2274	}	2274	}
2275	if (write) {	2275	if (write) {
2276	while (left) {	2276	while (left) {
2277	char c;	2277	char c;
2278	if (get_user(c, s++))	2278	if (get_user(c, s++))
2279	return -EFAULT;	2279	return -EFAULT;
2280	if (!isspace(c))	2280	if (!isspace(c))
2281	break;	2281	break;
2282	left--;	2282	left--;
2283	}	2283	}
2284	}	2284	}
2285	if (write && first)	2285	if (write && first)
2286	return -EINVAL;	2286	return -EINVAL;
2287	*lenp -= left;	2287	*lenp -= left;
2288	ppos += lenp;	2288	ppos += lenp;
2289	return 0;	2289	return 0;
2290	#undef TMPBUFLEN	2290	#undef TMPBUFLEN
2291	}	2291	}
2292		2292
2293	static int do_proc_dointvec(struct ctl_table table, int write, struct file filp,	2293	static int do_proc_dointvec(struct ctl_table table, int write, struct file filp,
2294	void __user buffer, size_t lenp, loff_t *ppos,	2294	void __user buffer, size_t lenp, loff_t *ppos,
2295	int (conv)(int negp, unsigned long lvalp, int valp,	2295	int (conv)(int negp, unsigned long lvalp, int valp,
2296	int write, void *data),	2296	int write, void *data),
2297	void *data)	2297	void *data)
2298	{	2298	{
2299	return __do_proc_dointvec(table->data, table, write, filp,	2299	return __do_proc_dointvec(table->data, table, write, filp,
2300	buffer, lenp, ppos, conv, data);	2300	buffer, lenp, ppos, conv, data);
2301	}	2301	}
2302		2302
2303	/**	2303	/**
2304	* proc_dointvec - read a vector of integers	2304	* proc_dointvec - read a vector of integers
2305	* @table: the sysctl table	2305	* @table: the sysctl table
2306	* @write: %TRUE if this is a write to the sysctl file	2306	* @write: %TRUE if this is a write to the sysctl file
2307	* @filp: the file structure	2307	* @filp: the file structure
2308	* @buffer: the user buffer	2308	* @buffer: the user buffer
2309	* @lenp: the size of the user buffer	2309	* @lenp: the size of the user buffer
2310	* @ppos: file position	2310	* @ppos: file position
2311	*	2311	*
2312	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer	2312	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2313	* values from/to the user buffer, treated as an ASCII string.	2313	* values from/to the user buffer, treated as an ASCII string.
2314	*	2314	*
2315	* Returns 0 on success.	2315	* Returns 0 on success.
2316	*/	2316	*/
2317	int proc_dointvec(struct ctl_table table, int write, struct file filp,	2317	int proc_dointvec(struct ctl_table table, int write, struct file filp,
2318	void __user buffer, size_t lenp, loff_t *ppos)	2318	void __user buffer, size_t lenp, loff_t *ppos)
2319	{	2319	{
2320	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,	2320	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
2321	NULL,NULL);	2321	NULL,NULL);
2322	}	2322	}
2323		2323
2324	/*	2324	/*
2325	* Taint values can only be increased	2325	* Taint values can only be increased
2326	* This means we can safely use a temporary.	2326	* This means we can safely use a temporary.
2327	*/	2327	*/
2328	static int proc_taint(struct ctl_table table, int write, struct file filp,	2328	static int proc_taint(struct ctl_table table, int write, struct file filp,
2329	void __user buffer, size_t lenp, loff_t *ppos)	2329	void __user buffer, size_t lenp, loff_t *ppos)
2330	{	2330	{
2331	struct ctl_table t;	2331	struct ctl_table t;
2332	unsigned long tmptaint = get_taint();	2332	unsigned long tmptaint = get_taint();
2333	int err;	2333	int err;
2334		2334
2335	if (write && !capable(CAP_SYS_ADMIN))	2335	if (write && !capable(CAP_SYS_ADMIN))
2336	return -EPERM;	2336	return -EPERM;
2337		2337
2338	t = *table;	2338	t = *table;
2339	t.data = &tmptaint;	2339	t.data = &tmptaint;
2340	err = proc_doulongvec_minmax(&t, write, filp, buffer, lenp, ppos);	2340	err = proc_doulongvec_minmax(&t, write, filp, buffer, lenp, ppos);
2341	if (err < 0)	2341	if (err < 0)
2342	return err;	2342	return err;
2343		2343
2344	if (write) {	2344	if (write) {
2345	/*	2345	/*
2346	* Poor man's atomic or. Not worth adding a primitive	2346	* Poor man's atomic or. Not worth adding a primitive
2347	* to everyone's atomic.h for this	2347	* to everyone's atomic.h for this
2348	*/	2348	*/
2349	int i;	2349	int i;
2350	for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {	2350	for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2351	if ((tmptaint >> i) & 1)	2351	if ((tmptaint >> i) & 1)
2352	add_taint(i);	2352	add_taint(i);
2353	}	2353	}
2354	}	2354	}
2355		2355
2356	return err;	2356	return err;
2357	}	2357	}
2358		2358
2359	struct do_proc_dointvec_minmax_conv_param {	2359	struct do_proc_dointvec_minmax_conv_param {
2360	int *min;	2360	int *min;
2361	int *max;	2361	int *max;
2362	};	2362	};
2363		2363
2364	static int do_proc_dointvec_minmax_conv(int negp, unsigned long lvalp,	2364	static int do_proc_dointvec_minmax_conv(int negp, unsigned long lvalp,
2365	int *valp,	2365	int *valp,
2366	int write, void *data)	2366	int write, void *data)
2367	{	2367	{
2368	struct do_proc_dointvec_minmax_conv_param *param = data;	2368	struct do_proc_dointvec_minmax_conv_param *param = data;
2369	if (write) {	2369	if (write) {
2370	int val = negp ? -lvalp : *lvalp;	2370	int val = negp ? -lvalp : *lvalp;
2371	if ((param->min && *param->min > val) \|\|	2371	if ((param->min && *param->min > val) \|\|
2372	(param->max && *param->max < val))	2372	(param->max && *param->max < val))
2373	return -EINVAL;	2373	return -EINVAL;
2374	*valp = val;	2374	*valp = val;
2375	} else {	2375	} else {
2376	int val = *valp;	2376	int val = *valp;
2377	if (val < 0) {	2377	if (val < 0) {
2378	*negp = -1;	2378	*negp = -1;
2379	*lvalp = (unsigned long)-val;	2379	*lvalp = (unsigned long)-val;
2380	} else {	2380	} else {
2381	*negp = 0;	2381	*negp = 0;
2382	*lvalp = (unsigned long)val;	2382	*lvalp = (unsigned long)val;
2383	}	2383	}
2384	}	2384	}
2385	return 0;	2385	return 0;
2386	}	2386	}
2387		2387
2388	/**	2388	/**
2389	* proc_dointvec_minmax - read a vector of integers with min/max values	2389	* proc_dointvec_minmax - read a vector of integers with min/max values
2390	* @table: the sysctl table	2390	* @table: the sysctl table
2391	* @write: %TRUE if this is a write to the sysctl file	2391	* @write: %TRUE if this is a write to the sysctl file
2392	* @filp: the file structure	2392	* @filp: the file structure
2393	* @buffer: the user buffer	2393	* @buffer: the user buffer
2394	* @lenp: the size of the user buffer	2394	* @lenp: the size of the user buffer
2395	* @ppos: file position	2395	* @ppos: file position
2396	*	2396	*
2397	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer	2397	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2398	* values from/to the user buffer, treated as an ASCII string.	2398	* values from/to the user buffer, treated as an ASCII string.
2399	*	2399	*
2400	* This routine will ensure the values are within the range specified by	2400	* This routine will ensure the values are within the range specified by
2401	* table->extra1 (min) and table->extra2 (max).	2401	* table->extra1 (min) and table->extra2 (max).
2402	*	2402	*
2403	* Returns 0 on success.	2403	* Returns 0 on success.
2404	*/	2404	*/
2405	int proc_dointvec_minmax(struct ctl_table table, int write, struct file filp,	2405	int proc_dointvec_minmax(struct ctl_table table, int write, struct file filp,
2406	void __user buffer, size_t lenp, loff_t *ppos)	2406	void __user buffer, size_t lenp, loff_t *ppos)
2407	{	2407	{
2408	struct do_proc_dointvec_minmax_conv_param param = {	2408	struct do_proc_dointvec_minmax_conv_param param = {
2409	.min = (int *) table->extra1,	2409	.min = (int *) table->extra1,
2410	.max = (int *) table->extra2,	2410	.max = (int *) table->extra2,
2411	};	2411	};
2412	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,	2412	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
2413	do_proc_dointvec_minmax_conv, &param);	2413	do_proc_dointvec_minmax_conv, &param);
2414	}	2414	}
2415		2415
2416	static int __do_proc_doulongvec_minmax(void data, struct ctl_table table, int write,	2416	static int __do_proc_doulongvec_minmax(void data, struct ctl_table table, int write,
2417	struct file *filp,	2417	struct file *filp,
2418	void __user *buffer,	2418	void __user *buffer,
2419	size_t lenp, loff_t ppos,	2419	size_t lenp, loff_t ppos,
2420	unsigned long convmul,	2420	unsigned long convmul,
2421	unsigned long convdiv)	2421	unsigned long convdiv)
2422	{	2422	{
2423	#define TMPBUFLEN 21	2423	#define TMPBUFLEN 21
2424	unsigned long i, min, *max, val;	2424	unsigned long i, min, *max, val;
2425	int vleft, first=1, neg;	2425	int vleft, first=1, neg;
2426	size_t len, left;	2426	size_t len, left;
2427	char buf[TMPBUFLEN], *p;	2427	char buf[TMPBUFLEN], *p;
2428	char __user *s = buffer;	2428	char __user *s = buffer;
2429		2429
2430	if (!data \|\| !table->maxlen \|\| !*lenp \|\|	2430	if (!data \|\| !table->maxlen \|\| !*lenp \|\|
2431	(*ppos && !write)) {	2431	(*ppos && !write)) {
2432	*lenp = 0;	2432	*lenp = 0;
2433	return 0;	2433	return 0;
2434	}	2434	}
2435		2435
2436	i = (unsigned long *) data;	2436	i = (unsigned long *) data;
2437	min = (unsigned long *) table->extra1;	2437	min = (unsigned long *) table->extra1;
2438	max = (unsigned long *) table->extra2;	2438	max = (unsigned long *) table->extra2;
2439	vleft = table->maxlen / sizeof(unsigned long);	2439	vleft = table->maxlen / sizeof(unsigned long);
2440	left = *lenp;	2440	left = *lenp;
2441		2441
2442	for (; left && vleft--; i++, min++, max++, first=0) {	2442	for (; left && vleft--; i++, min++, max++, first=0) {
2443	if (write) {	2443	if (write) {
2444	while (left) {	2444	while (left) {
2445	char c;	2445	char c;
2446	if (get_user(c, s))	2446	if (get_user(c, s))
2447	return -EFAULT;	2447	return -EFAULT;
2448	if (!isspace(c))	2448	if (!isspace(c))
2449	break;	2449	break;
2450	left--;	2450	left--;
2451	s++;	2451	s++;
2452	}	2452	}
2453	if (!left)	2453	if (!left)
2454	break;	2454	break;
2455	neg = 0;	2455	neg = 0;
2456	len = left;	2456	len = left;
2457	if (len > TMPBUFLEN-1)	2457	if (len > TMPBUFLEN-1)
2458	len = TMPBUFLEN-1;	2458	len = TMPBUFLEN-1;
2459	if (copy_from_user(buf, s, len))	2459	if (copy_from_user(buf, s, len))
2460	return -EFAULT;	2460	return -EFAULT;
2461	buf[len] = 0;	2461	buf[len] = 0;
2462	p = buf;	2462	p = buf;
2463	if (*p == '-' && left > 1) {	2463	if (*p == '-' && left > 1) {
2464	neg = 1;	2464	neg = 1;
2465	p++;	2465	p++;
2466	}	2466	}
2467	if (p < '0' \|\| p > '9')	2467	if (p < '0' \|\| p > '9')
2468	break;	2468	break;
2469	val = simple_strtoul(p, &p, 0) * convmul / convdiv ;	2469	val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
2470	len = p-buf;	2470	len = p-buf;
2471	if ((len < left) && p && !isspace(p))	2471	if ((len < left) && p && !isspace(p))
2472	break;	2472	break;
2473	if (neg)	2473	if (neg)
2474	val = -val;	2474	val = -val;
2475	s += len;	2475	s += len;
2476	left -= len;	2476	left -= len;
2477		2477
2478	if(neg)	2478	if(neg)
2479	continue;	2479	continue;
2480	if ((min && val < min) \|\| (max && val > max))	2480	if ((min && val < min) \|\| (max && val > max))
2481	continue;	2481	continue;
2482	*i = val;	2482	*i = val;
2483	} else {	2483	} else {
2484	p = buf;	2484	p = buf;
2485	if (!first)	2485	if (!first)
2486	*p++ = '\t';	2486	*p++ = '\t';
2487	sprintf(p, "%lu", convdiv * (*i) / convmul);	2487	sprintf(p, "%lu", convdiv * (*i) / convmul);
2488	len = strlen(buf);	2488	len = strlen(buf);
2489	if (len > left)	2489	if (len > left)
2490	len = left;	2490	len = left;
2491	if(copy_to_user(s, buf, len))	2491	if(copy_to_user(s, buf, len))
2492	return -EFAULT;	2492	return -EFAULT;
2493	left -= len;	2493	left -= len;
2494	s += len;	2494	s += len;
2495	}	2495	}
2496	}	2496	}
2497		2497
2498	if (!write && !first && left) {	2498	if (!write && !first && left) {
2499	if(put_user('\n', s))	2499	if(put_user('\n', s))
2500	return -EFAULT;	2500	return -EFAULT;
2501	left--, s++;	2501	left--, s++;
2502	}	2502	}
2503	if (write) {	2503	if (write) {
2504	while (left) {	2504	while (left) {
2505	char c;	2505	char c;
2506	if (get_user(c, s++))	2506	if (get_user(c, s++))
2507	return -EFAULT;	2507	return -EFAULT;
2508	if (!isspace(c))	2508	if (!isspace(c))
2509	break;	2509	break;
2510	left--;	2510	left--;
2511	}	2511	}
2512	}	2512	}
2513	if (write && first)	2513	if (write && first)
2514	return -EINVAL;	2514	return -EINVAL;
2515	*lenp -= left;	2515	*lenp -= left;
2516	ppos += lenp;	2516	ppos += lenp;
2517	return 0;	2517	return 0;
2518	#undef TMPBUFLEN	2518	#undef TMPBUFLEN
2519	}	2519	}
2520		2520
2521	static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,	2521	static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2522	struct file *filp,	2522	struct file *filp,
2523	void __user *buffer,	2523	void __user *buffer,
2524	size_t lenp, loff_t ppos,	2524	size_t lenp, loff_t ppos,
2525	unsigned long convmul,	2525	unsigned long convmul,
2526	unsigned long convdiv)	2526	unsigned long convdiv)
2527	{	2527	{
2528	return __do_proc_doulongvec_minmax(table->data, table, write,	2528	return __do_proc_doulongvec_minmax(table->data, table, write,
2529	filp, buffer, lenp, ppos, convmul, convdiv);	2529	filp, buffer, lenp, ppos, convmul, convdiv);
2530	}	2530	}
2531		2531
2532	/**	2532	/**
2533	* proc_doulongvec_minmax - read a vector of long integers with min/max values	2533	* proc_doulongvec_minmax - read a vector of long integers with min/max values
2534	* @table: the sysctl table	2534	* @table: the sysctl table
2535	* @write: %TRUE if this is a write to the sysctl file	2535	* @write: %TRUE if this is a write to the sysctl file
2536	* @filp: the file structure	2536	* @filp: the file structure
2537	* @buffer: the user buffer	2537	* @buffer: the user buffer
2538	* @lenp: the size of the user buffer	2538	* @lenp: the size of the user buffer
2539	* @ppos: file position	2539	* @ppos: file position
2540	*	2540	*
2541	* Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long	2541	* Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2542	* values from/to the user buffer, treated as an ASCII string.	2542	* values from/to the user buffer, treated as an ASCII string.
2543	*	2543	*
2544	* This routine will ensure the values are within the range specified by	2544	* This routine will ensure the values are within the range specified by
2545	* table->extra1 (min) and table->extra2 (max).	2545	* table->extra1 (min) and table->extra2 (max).
2546	*	2546	*
2547	* Returns 0 on success.	2547	* Returns 0 on success.
2548	*/	2548	*/
2549	int proc_doulongvec_minmax(struct ctl_table table, int write, struct file filp,	2549	int proc_doulongvec_minmax(struct ctl_table table, int write, struct file filp,
2550	void __user buffer, size_t lenp, loff_t *ppos)	2550	void __user buffer, size_t lenp, loff_t *ppos)
2551	{	2551	{
2552	return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l);	2552	return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l);
2553	}	2553	}
2554		2554
2555	/**	2555	/**
2556	* proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values	2556	* proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2557	* @table: the sysctl table	2557	* @table: the sysctl table
2558	* @write: %TRUE if this is a write to the sysctl file	2558	* @write: %TRUE if this is a write to the sysctl file
2559	* @filp: the file structure	2559	* @filp: the file structure
2560	* @buffer: the user buffer	2560	* @buffer: the user buffer
2561	* @lenp: the size of the user buffer	2561	* @lenp: the size of the user buffer
2562	* @ppos: file position	2562	* @ppos: file position
2563	*	2563	*
2564	* Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long	2564	* Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2565	* values from/to the user buffer, treated as an ASCII string. The values	2565	* values from/to the user buffer, treated as an ASCII string. The values
2566	* are treated as milliseconds, and converted to jiffies when they are stored.	2566	* are treated as milliseconds, and converted to jiffies when they are stored.
2567	*	2567	*
2568	* This routine will ensure the values are within the range specified by	2568	* This routine will ensure the values are within the range specified by
2569	* table->extra1 (min) and table->extra2 (max).	2569	* table->extra1 (min) and table->extra2 (max).
2570	*	2570	*
2571	* Returns 0 on success.	2571	* Returns 0 on success.
2572	*/	2572	*/
2573	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,	2573	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2574	struct file *filp,	2574	struct file *filp,
2575	void __user *buffer,	2575	void __user *buffer,
2576	size_t lenp, loff_t ppos)	2576	size_t lenp, loff_t ppos)
2577	{	2577	{
2578	return do_proc_doulongvec_minmax(table, write, filp, buffer,	2578	return do_proc_doulongvec_minmax(table, write, filp, buffer,
2579	lenp, ppos, HZ, 1000l);	2579	lenp, ppos, HZ, 1000l);
2580	}	2580	}
2581		2581
2582		2582
2583	static int do_proc_dointvec_jiffies_conv(int negp, unsigned long lvalp,	2583	static int do_proc_dointvec_jiffies_conv(int negp, unsigned long lvalp,
2584	int *valp,	2584	int *valp,
2585	int write, void *data)	2585	int write, void *data)
2586	{	2586	{
2587	if (write) {	2587	if (write) {
2588	if (*lvalp > LONG_MAX / HZ)	2588	if (*lvalp > LONG_MAX / HZ)
2589	return 1;	2589	return 1;
2590	valp = negp ? -(lvalpHZ) : (lvalpHZ);	2590	valp = negp ? -(lvalpHZ) : (lvalpHZ);
2591	} else {	2591	} else {
2592	int val = *valp;	2592	int val = *valp;
2593	unsigned long lval;	2593	unsigned long lval;
2594	if (val < 0) {	2594	if (val < 0) {
2595	*negp = -1;	2595	*negp = -1;
2596	lval = (unsigned long)-val;	2596	lval = (unsigned long)-val;
2597	} else {	2597	} else {
2598	*negp = 0;	2598	*negp = 0;
2599	lval = (unsigned long)val;	2599	lval = (unsigned long)val;
2600	}	2600	}
2601	*lvalp = lval / HZ;	2601	*lvalp = lval / HZ;
2602	}	2602	}
2603	return 0;	2603	return 0;
2604	}	2604	}
2605		2605
2606	static int do_proc_dointvec_userhz_jiffies_conv(int negp, unsigned long lvalp,	2606	static int do_proc_dointvec_userhz_jiffies_conv(int negp, unsigned long lvalp,
2607	int *valp,	2607	int *valp,
2608	int write, void *data)	2608	int write, void *data)
2609	{	2609	{
2610	if (write) {	2610	if (write) {
2611	if (USER_HZ < HZ && lvalp > (LONG_MAX / HZ) USER_HZ)	2611	if (USER_HZ < HZ && lvalp > (LONG_MAX / HZ) USER_HZ)
2612	return 1;	2612	return 1;
2613	valp = clock_t_to_jiffies(negp ? -lvalp : lvalp);	2613	valp = clock_t_to_jiffies(negp ? -lvalp : lvalp);
2614	} else {	2614	} else {
2615	int val = *valp;	2615	int val = *valp;
2616	unsigned long lval;	2616	unsigned long lval;
2617	if (val < 0) {	2617	if (val < 0) {
2618	*negp = -1;	2618	*negp = -1;
2619	lval = (unsigned long)-val;	2619	lval = (unsigned long)-val;
2620	} else {	2620	} else {
2621	*negp = 0;	2621	*negp = 0;
2622	lval = (unsigned long)val;	2622	lval = (unsigned long)val;
2623	}	2623	}
2624	*lvalp = jiffies_to_clock_t(lval);	2624	*lvalp = jiffies_to_clock_t(lval);
2625	}	2625	}
2626	return 0;	2626	return 0;
2627	}	2627	}
2628		2628
2629	static int do_proc_dointvec_ms_jiffies_conv(int negp, unsigned long lvalp,	2629	static int do_proc_dointvec_ms_jiffies_conv(int negp, unsigned long lvalp,
2630	int *valp,	2630	int *valp,
2631	int write, void *data)	2631	int write, void *data)
2632	{	2632	{
2633	if (write) {	2633	if (write) {
2634	valp = msecs_to_jiffies(negp ? -lvalp : lvalp);	2634	valp = msecs_to_jiffies(negp ? -lvalp : lvalp);
2635	} else {	2635	} else {
2636	int val = *valp;	2636	int val = *valp;
2637	unsigned long lval;	2637	unsigned long lval;
2638	if (val < 0) {	2638	if (val < 0) {
2639	*negp = -1;	2639	*negp = -1;
2640	lval = (unsigned long)-val;	2640	lval = (unsigned long)-val;
2641	} else {	2641	} else {
2642	*negp = 0;	2642	*negp = 0;
2643	lval = (unsigned long)val;	2643	lval = (unsigned long)val;
2644	}	2644	}
2645	*lvalp = jiffies_to_msecs(lval);	2645	*lvalp = jiffies_to_msecs(lval);
2646	}	2646	}
2647	return 0;	2647	return 0;
2648	}	2648	}
2649		2649
2650	/**	2650	/**
2651	* proc_dointvec_jiffies - read a vector of integers as seconds	2651	* proc_dointvec_jiffies - read a vector of integers as seconds
2652	* @table: the sysctl table	2652	* @table: the sysctl table
2653	* @write: %TRUE if this is a write to the sysctl file	2653	* @write: %TRUE if this is a write to the sysctl file
2654	* @filp: the file structure	2654	* @filp: the file structure
2655	* @buffer: the user buffer	2655	* @buffer: the user buffer
2656	* @lenp: the size of the user buffer	2656	* @lenp: the size of the user buffer
2657	* @ppos: file position	2657	* @ppos: file position
2658	*	2658	*
2659	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer	2659	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2660	* values from/to the user buffer, treated as an ASCII string.	2660	* values from/to the user buffer, treated as an ASCII string.
2661	* The values read are assumed to be in seconds, and are converted into	2661	* The values read are assumed to be in seconds, and are converted into
2662	* jiffies.	2662	* jiffies.
2663	*	2663	*
2664	* Returns 0 on success.	2664	* Returns 0 on success.
2665	*/	2665	*/
2666	int proc_dointvec_jiffies(struct ctl_table table, int write, struct file filp,	2666	int proc_dointvec_jiffies(struct ctl_table table, int write, struct file filp,
2667	void __user buffer, size_t lenp, loff_t *ppos)	2667	void __user buffer, size_t lenp, loff_t *ppos)
2668	{	2668	{
2669	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,	2669	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
2670	do_proc_dointvec_jiffies_conv,NULL);	2670	do_proc_dointvec_jiffies_conv,NULL);
2671	}	2671	}
2672		2672
2673	/**	2673	/**
2674	* proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds	2674	* proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2675	* @table: the sysctl table	2675	* @table: the sysctl table
2676	* @write: %TRUE if this is a write to the sysctl file	2676	* @write: %TRUE if this is a write to the sysctl file
2677	* @filp: the file structure	2677	* @filp: the file structure
2678	* @buffer: the user buffer	2678	* @buffer: the user buffer
2679	* @lenp: the size of the user buffer	2679	* @lenp: the size of the user buffer
2680	* @ppos: pointer to the file position	2680	* @ppos: pointer to the file position
2681	*	2681	*
2682	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer	2682	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2683	* values from/to the user buffer, treated as an ASCII string.	2683	* values from/to the user buffer, treated as an ASCII string.
2684	* The values read are assumed to be in 1/USER_HZ seconds, and	2684	* The values read are assumed to be in 1/USER_HZ seconds, and
2685	* are converted into jiffies.	2685	* are converted into jiffies.
2686	*	2686	*
2687	* Returns 0 on success.	2687	* Returns 0 on success.
2688	*/	2688	*/
2689	int proc_dointvec_userhz_jiffies(struct ctl_table table, int write, struct file filp,	2689	int proc_dointvec_userhz_jiffies(struct ctl_table table, int write, struct file filp,
2690	void __user buffer, size_t lenp, loff_t *ppos)	2690	void __user buffer, size_t lenp, loff_t *ppos)
2691	{	2691	{
2692	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,	2692	return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
2693	do_proc_dointvec_userhz_jiffies_conv,NULL);	2693	do_proc_dointvec_userhz_jiffies_conv,NULL);
2694	}	2694	}
2695		2695
2696	/**	2696	/**
2697	* proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds	2697	* proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2698	* @table: the sysctl table	2698	* @table: the sysctl table
2699	* @write: %TRUE if this is a write to the sysctl file	2699	* @write: %TRUE if this is a write to the sysctl file
2700	* @filp: the file structure	2700	* @filp: the file structure
2701	* @buffer: the user buffer	2701	* @buffer: the user buffer
2702	* @lenp: the size of the user buffer	2702	* @lenp: the size of the user buffer
2703	* @ppos: file position	2703	* @ppos: file position
2704	* @ppos: the current position in the file	2704	* @ppos: the current position in the file
2705	*	2705	*
2706	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer	2706	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2707	* values from/to the user buffer, treated as an ASCII string.	2707	* values from/to the user buffer, treated as an ASCII string.
2708	* The values read are assumed to be in 1/1000 seconds, and	2708	* The values read are assumed to be in 1/1000 seconds, and
2709	* are converted into jiffies.	2709	* are converted into jiffies.
2710	*	2710	*
2711	* Returns 0 on success.	2711	* Returns 0 on success.
2712	*/	2712	*/
2713	int proc_dointvec_ms_jiffies(struct ctl_table table, int write, struct file filp,	2713	int proc_dointvec_ms_jiffies(struct ctl_table table, int write, struct file filp,
2714	void __user buffer, size_t lenp, loff_t *ppos)	2714	void __user buffer, size_t lenp, loff_t *ppos)
2715	{	2715	{
2716	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,	2716	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
2717	do_proc_dointvec_ms_jiffies_conv, NULL);	2717	do_proc_dointvec_ms_jiffies_conv, NULL);
2718	}	2718	}
2719		2719
2720	static int proc_do_cad_pid(struct ctl_table table, int write, struct file filp,	2720	static int proc_do_cad_pid(struct ctl_table table, int write, struct file filp,
2721	void __user buffer, size_t lenp, loff_t *ppos)	2721	void __user buffer, size_t lenp, loff_t *ppos)
2722	{	2722	{
2723	struct pid *new_pid;	2723	struct pid *new_pid;
2724	pid_t tmp;	2724	pid_t tmp;
2725	int r;	2725	int r;
2726		2726
2727	tmp = pid_vnr(cad_pid);	2727	tmp = pid_vnr(cad_pid);
2728		2728
2729	r = __do_proc_dointvec(&tmp, table, write, filp, buffer,	2729	r = __do_proc_dointvec(&tmp, table, write, filp, buffer,
2730	lenp, ppos, NULL, NULL);	2730	lenp, ppos, NULL, NULL);
2731	if (r \|\| !write)	2731	if (r \|\| !write)
2732	return r;	2732	return r;
2733		2733
2734	new_pid = find_get_pid(tmp);	2734	new_pid = find_get_pid(tmp);
2735	if (!new_pid)	2735	if (!new_pid)
2736	return -ESRCH;	2736	return -ESRCH;
2737		2737
2738	put_pid(xchg(&cad_pid, new_pid));	2738	put_pid(xchg(&cad_pid, new_pid));
2739	return 0;	2739	return 0;
2740	}	2740	}
2741		2741
2742	#else /* CONFIG_PROC_FS */	2742	#else /* CONFIG_PROC_FS */
2743		2743
2744	int proc_dostring(struct ctl_table table, int write, struct file filp,	2744	int proc_dostring(struct ctl_table table, int write, struct file filp,
2745	void __user buffer, size_t lenp, loff_t *ppos)	2745	void __user buffer, size_t lenp, loff_t *ppos)
2746	{	2746	{
2747	return -ENOSYS;	2747	return -ENOSYS;
2748	}	2748	}
2749		2749
2750	int proc_dointvec(struct ctl_table table, int write, struct file filp,	2750	int proc_dointvec(struct ctl_table table, int write, struct file filp,
2751	void __user buffer, size_t lenp, loff_t *ppos)	2751	void __user buffer, size_t lenp, loff_t *ppos)
2752	{	2752	{
2753	return -ENOSYS;	2753	return -ENOSYS;
2754	}	2754	}
2755		2755
2756	int proc_dointvec_minmax(struct ctl_table table, int write, struct file filp,	2756	int proc_dointvec_minmax(struct ctl_table table, int write, struct file filp,
2757	void __user buffer, size_t lenp, loff_t *ppos)	2757	void __user buffer, size_t lenp, loff_t *ppos)
2758	{	2758	{
2759	return -ENOSYS;	2759	return -ENOSYS;
2760	}	2760	}
2761		2761
2762	int proc_dointvec_jiffies(struct ctl_table table, int write, struct file filp,	2762	int proc_dointvec_jiffies(struct ctl_table table, int write, struct file filp,
2763	void __user buffer, size_t lenp, loff_t *ppos)	2763	void __user buffer, size_t lenp, loff_t *ppos)
2764	{	2764	{
2765	return -ENOSYS;	2765	return -ENOSYS;
2766	}	2766	}
2767		2767
2768	int proc_dointvec_userhz_jiffies(struct ctl_table table, int write, struct file filp,	2768	int proc_dointvec_userhz_jiffies(struct ctl_table table, int write, struct file filp,
2769	void __user buffer, size_t lenp, loff_t *ppos)	2769	void __user buffer, size_t lenp, loff_t *ppos)
2770	{	2770	{
2771	return -ENOSYS;	2771	return -ENOSYS;
2772	}	2772	}
2773		2773
2774	int proc_dointvec_ms_jiffies(struct ctl_table table, int write, struct file filp,	2774	int proc_dointvec_ms_jiffies(struct ctl_table table, int write, struct file filp,
2775	void __user buffer, size_t lenp, loff_t *ppos)	2775	void __user buffer, size_t lenp, loff_t *ppos)
2776	{	2776	{
2777	return -ENOSYS;	2777	return -ENOSYS;
2778	}	2778	}
2779		2779
2780	int proc_doulongvec_minmax(struct ctl_table table, int write, struct file filp,	2780	int proc_doulongvec_minmax(struct ctl_table table, int write, struct file filp,
2781	void __user buffer, size_t lenp, loff_t *ppos)	2781	void __user buffer, size_t lenp, loff_t *ppos)
2782	{	2782	{
2783	return -ENOSYS;	2783	return -ENOSYS;
2784	}	2784	}
2785		2785
2786	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,	2786	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2787	struct file *filp,	2787	struct file *filp,
2788	void __user *buffer,	2788	void __user *buffer,
2789	size_t lenp, loff_t ppos)	2789	size_t lenp, loff_t ppos)
2790	{	2790	{
2791	return -ENOSYS;	2791	return -ENOSYS;
2792	}	2792	}
2793		2793
2794		2794
2795	#endif /* CONFIG_PROC_FS */	2795	#endif /* CONFIG_PROC_FS */
2796		2796
2797		2797
2798	#ifdef CONFIG_SYSCTL_SYSCALL	2798	#ifdef CONFIG_SYSCTL_SYSCALL
2799	/*	2799	/*
2800	* General sysctl support routines	2800	* General sysctl support routines
2801	*/	2801	*/
2802		2802
2803	/* The generic sysctl data routine (used if no strategy routine supplied) */	2803	/* The generic sysctl data routine (used if no strategy routine supplied) */
2804	int sysctl_data(struct ctl_table *table,	2804	int sysctl_data(struct ctl_table *table,
2805	void __user oldval, size_t __user oldlenp,	2805	void __user oldval, size_t __user oldlenp,
2806	void __user *newval, size_t newlen)	2806	void __user *newval, size_t newlen)
2807	{	2807	{
2808	size_t len;	2808	size_t len;
2809		2809
2810	/* Get out of I don't have a variable */	2810	/* Get out of I don't have a variable */
2811	if (!table->data \|\| !table->maxlen)	2811	if (!table->data \|\| !table->maxlen)
2812	return -ENOTDIR;	2812	return -ENOTDIR;
2813		2813
2814	if (oldval && oldlenp) {	2814	if (oldval && oldlenp) {
2815	if (get_user(len, oldlenp))	2815	if (get_user(len, oldlenp))
2816	return -EFAULT;	2816	return -EFAULT;
2817	if (len) {	2817	if (len) {
2818	if (len > table->maxlen)	2818	if (len > table->maxlen)
2819	len = table->maxlen;	2819	len = table->maxlen;
2820	if (copy_to_user(oldval, table->data, len))	2820	if (copy_to_user(oldval, table->data, len))
2821	return -EFAULT;	2821	return -EFAULT;
2822	if (put_user(len, oldlenp))	2822	if (put_user(len, oldlenp))
2823	return -EFAULT;	2823	return -EFAULT;
2824	}	2824	}
2825	}	2825	}
2826		2826
2827	if (newval && newlen) {	2827	if (newval && newlen) {
2828	if (newlen > table->maxlen)	2828	if (newlen > table->maxlen)
2829	newlen = table->maxlen;	2829	newlen = table->maxlen;
2830		2830
2831	if (copy_from_user(table->data, newval, newlen))	2831	if (copy_from_user(table->data, newval, newlen))
2832	return -EFAULT;	2832	return -EFAULT;
2833	}	2833	}
2834	return 1;	2834	return 1;
2835	}	2835	}
2836		2836
2837	/* The generic string strategy routine: */	2837	/* The generic string strategy routine: */
2838	int sysctl_string(struct ctl_table *table,	2838	int sysctl_string(struct ctl_table *table,
2839	void __user oldval, size_t __user oldlenp,	2839	void __user oldval, size_t __user oldlenp,
2840	void __user *newval, size_t newlen)	2840	void __user *newval, size_t newlen)
2841	{	2841	{
2842	if (!table->data \|\| !table->maxlen)	2842	if (!table->data \|\| !table->maxlen)
2843	return -ENOTDIR;	2843	return -ENOTDIR;
2844		2844
2845	if (oldval && oldlenp) {	2845	if (oldval && oldlenp) {
2846	size_t bufsize;	2846	size_t bufsize;
2847	if (get_user(bufsize, oldlenp))	2847	if (get_user(bufsize, oldlenp))
2848	return -EFAULT;	2848	return -EFAULT;
2849	if (bufsize) {	2849	if (bufsize) {
2850	size_t len = strlen(table->data), copied;	2850	size_t len = strlen(table->data), copied;
2851		2851
2852	/* This shouldn't trigger for a well-formed sysctl */	2852	/* This shouldn't trigger for a well-formed sysctl */
2853	if (len > table->maxlen)	2853	if (len > table->maxlen)
2854	len = table->maxlen;	2854	len = table->maxlen;
2855		2855
2856	/* Copy up to a max of bufsize-1 bytes of the string */	2856	/* Copy up to a max of bufsize-1 bytes of the string */
2857	copied = (len >= bufsize) ? bufsize - 1 : len;	2857	copied = (len >= bufsize) ? bufsize - 1 : len;
2858		2858
2859	if (copy_to_user(oldval, table->data, copied) \|\|	2859	if (copy_to_user(oldval, table->data, copied) \|\|
2860	put_user(0, (char __user *)(oldval + copied)))	2860	put_user(0, (char __user *)(oldval + copied)))
2861	return -EFAULT;	2861	return -EFAULT;
2862	if (put_user(len, oldlenp))	2862	if (put_user(len, oldlenp))
2863	return -EFAULT;	2863	return -EFAULT;
2864	}	2864	}
2865	}	2865	}
2866	if (newval && newlen) {	2866	if (newval && newlen) {
2867	size_t len = newlen;	2867	size_t len = newlen;
2868	if (len > table->maxlen)	2868	if (len > table->maxlen)
2869	len = table->maxlen;	2869	len = table->maxlen;
2870	if(copy_from_user(table->data, newval, len))	2870	if(copy_from_user(table->data, newval, len))
2871	return -EFAULT;	2871	return -EFAULT;
2872	if (len == table->maxlen)	2872	if (len == table->maxlen)
2873	len--;	2873	len--;
2874	((char *) table->data)[len] = 0;	2874	((char *) table->data)[len] = 0;
2875	}	2875	}
2876	return 1;	2876	return 1;
2877	}	2877	}
2878		2878
2879	/*	2879	/*
2880	* This function makes sure that all of the integers in the vector	2880	* This function makes sure that all of the integers in the vector
2881	* are between the minimum and maximum values given in the arrays	2881	* are between the minimum and maximum values given in the arrays
2882	* table->extra1 and table->extra2, respectively.	2882	* table->extra1 and table->extra2, respectively.
2883	*/	2883	*/
2884	int sysctl_intvec(struct ctl_table *table,	2884	int sysctl_intvec(struct ctl_table *table,
2885	void __user oldval, size_t __user oldlenp,	2885	void __user oldval, size_t __user oldlenp,
2886	void __user *newval, size_t newlen)	2886	void __user *newval, size_t newlen)
2887	{	2887	{
2888		2888
2889	if (newval && newlen) {	2889	if (newval && newlen) {
2890	int __user vec = (int __user ) newval;	2890	int __user vec = (int __user ) newval;
2891	int min = (int ) table->extra1;	2891	int min = (int ) table->extra1;
2892	int max = (int ) table->extra2;	2892	int max = (int ) table->extra2;
2893	size_t length;	2893	size_t length;
2894	int i;	2894	int i;
2895		2895
2896	if (newlen % sizeof(int) != 0)	2896	if (newlen % sizeof(int) != 0)
2897	return -EINVAL;	2897	return -EINVAL;
2898		2898
2899	if (!table->extra1 && !table->extra2)	2899	if (!table->extra1 && !table->extra2)
2900	return 0;	2900	return 0;
2901		2901
2902	if (newlen > table->maxlen)	2902	if (newlen > table->maxlen)
2903	newlen = table->maxlen;	2903	newlen = table->maxlen;
2904	length = newlen / sizeof(int);	2904	length = newlen / sizeof(int);
2905		2905
2906	for (i = 0; i < length; i++) {	2906	for (i = 0; i < length; i++) {
2907	int value;	2907	int value;
2908	if (get_user(value, vec + i))	2908	if (get_user(value, vec + i))
2909	return -EFAULT;	2909	return -EFAULT;
2910	if (min && value < min[i])	2910	if (min && value < min[i])
2911	return -EINVAL;	2911	return -EINVAL;
2912	if (max && value > max[i])	2912	if (max && value > max[i])
2913	return -EINVAL;	2913	return -EINVAL;
2914	}	2914	}
2915	}	2915	}
2916	return 0;	2916	return 0;
2917	}	2917	}
2918		2918
2919	/* Strategy function to convert jiffies to seconds */	2919	/* Strategy function to convert jiffies to seconds */
2920	int sysctl_jiffies(struct ctl_table *table,	2920	int sysctl_jiffies(struct ctl_table *table,
2921	void __user oldval, size_t __user oldlenp,	2921	void __user oldval, size_t __user oldlenp,
2922	void __user *newval, size_t newlen)	2922	void __user *newval, size_t newlen)
2923	{	2923	{
2924	if (oldval && oldlenp) {	2924	if (oldval && oldlenp) {
2925	size_t olen;	2925	size_t olen;
2926		2926
2927	if (get_user(olen, oldlenp))	2927	if (get_user(olen, oldlenp))
2928	return -EFAULT;	2928	return -EFAULT;
2929	if (olen) {	2929	if (olen) {
2930	int val;	2930	int val;
2931		2931
2932	if (olen < sizeof(int))	2932	if (olen < sizeof(int))
2933	return -EINVAL;	2933	return -EINVAL;
2934		2934
2935	val = (int )(table->data) / HZ;	2935	val = (int )(table->data) / HZ;
2936	if (put_user(val, (int __user *)oldval))	2936	if (put_user(val, (int __user *)oldval))
2937	return -EFAULT;	2937	return -EFAULT;
2938	if (put_user(sizeof(int), oldlenp))	2938	if (put_user(sizeof(int), oldlenp))
2939	return -EFAULT;	2939	return -EFAULT;
2940	}	2940	}
2941	}	2941	}
2942	if (newval && newlen) {	2942	if (newval && newlen) {
2943	int new;	2943	int new;
2944	if (newlen != sizeof(int))	2944	if (newlen != sizeof(int))
2945	return -EINVAL;	2945	return -EINVAL;
2946	if (get_user(new, (int __user *)newval))	2946	if (get_user(new, (int __user *)newval))
2947	return -EFAULT;	2947	return -EFAULT;
2948	(int )(table->data) = new*HZ;	2948	(int )(table->data) = new*HZ;
2949	}	2949	}
2950	return 1;	2950	return 1;
2951	}	2951	}
2952		2952
2953	/* Strategy function to convert jiffies to seconds */	2953	/* Strategy function to convert jiffies to seconds */
2954	int sysctl_ms_jiffies(struct ctl_table *table,	2954	int sysctl_ms_jiffies(struct ctl_table *table,
2955	void __user oldval, size_t __user oldlenp,	2955	void __user oldval, size_t __user oldlenp,
2956	void __user *newval, size_t newlen)	2956	void __user *newval, size_t newlen)
2957	{	2957	{
2958	if (oldval && oldlenp) {	2958	if (oldval && oldlenp) {
2959	size_t olen;	2959	size_t olen;
2960		2960
2961	if (get_user(olen, oldlenp))	2961	if (get_user(olen, oldlenp))
2962	return -EFAULT;	2962	return -EFAULT;
2963	if (olen) {	2963	if (olen) {
2964	int val;	2964	int val;
2965		2965
2966	if (olen < sizeof(int))	2966	if (olen < sizeof(int))
2967	return -EINVAL;	2967	return -EINVAL;
2968		2968
2969	val = jiffies_to_msecs((int )(table->data));	2969	val = jiffies_to_msecs((int )(table->data));
2970	if (put_user(val, (int __user *)oldval))	2970	if (put_user(val, (int __user *)oldval))
2971	return -EFAULT;	2971	return -EFAULT;
2972	if (put_user(sizeof(int), oldlenp))	2972	if (put_user(sizeof(int), oldlenp))
2973	return -EFAULT;	2973	return -EFAULT;
2974	}	2974	}
2975	}	2975	}
2976	if (newval && newlen) {	2976	if (newval && newlen) {
2977	int new;	2977	int new;
2978	if (newlen != sizeof(int))	2978	if (newlen != sizeof(int))
2979	return -EINVAL;	2979	return -EINVAL;
2980	if (get_user(new, (int __user *)newval))	2980	if (get_user(new, (int __user *)newval))
2981	return -EFAULT;	2981	return -EFAULT;
2982	(int )(table->data) = msecs_to_jiffies(new);	2982	(int )(table->data) = msecs_to_jiffies(new);
2983	}	2983	}
2984	return 1;	2984	return 1;
2985	}	2985	}
2986		2986
2987		2987
2988		2988
2989	#else /* CONFIG_SYSCTL_SYSCALL */	2989	#else /* CONFIG_SYSCTL_SYSCALL */
2990		2990
2991		2991
2992	asmlinkage long sys_sysctl(struct __sysctl_args __user *args)	2992	asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
2993	{	2993	{
2994	struct __sysctl_args tmp;	2994	struct __sysctl_args tmp;
2995	int error;	2995	int error;
2996		2996
2997	if (copy_from_user(&tmp, args, sizeof(tmp)))	2997	if (copy_from_user(&tmp, args, sizeof(tmp)))
2998	return -EFAULT;	2998	return -EFAULT;
2999		2999
3000	error = deprecated_sysctl_warning(&tmp);	3000	error = deprecated_sysctl_warning(&tmp);
3001		3001
3002	/* If no error reading the parameters then just -ENOSYS ... */	3002	/* If no error reading the parameters then just -ENOSYS ... */
3003	if (!error)	3003	if (!error)
3004	error = -ENOSYS;	3004	error = -ENOSYS;
3005		3005
3006	return error;	3006	return error;
3007	}	3007	}
3008		3008
3009	int sysctl_data(struct ctl_table *table,	3009	int sysctl_data(struct ctl_table *table,
3010	void __user oldval, size_t __user oldlenp,	3010	void __user oldval, size_t __user oldlenp,
3011	void __user *newval, size_t newlen)	3011	void __user *newval, size_t newlen)
3012	{	3012	{
3013	return -ENOSYS;	3013	return -ENOSYS;
3014	}	3014	}
3015		3015
3016	int sysctl_string(struct ctl_table *table,	3016	int sysctl_string(struct ctl_table *table,
3017	void __user oldval, size_t __user oldlenp,	3017	void __user oldval, size_t __user oldlenp,
3018	void __user *newval, size_t newlen)	3018	void __user *newval, size_t newlen)
3019	{	3019	{
3020	return -ENOSYS;	3020	return -ENOSYS;
3021	}	3021	}
3022		3022
3023	int sysctl_intvec(struct ctl_table *table,	3023	int sysctl_intvec(struct ctl_table *table,
3024	void __user oldval, size_t __user oldlenp,	3024	void __user oldval, size_t __user oldlenp,
3025	void __user *newval, size_t newlen)	3025	void __user *newval, size_t newlen)
3026	{	3026	{
3027	return -ENOSYS;	3027	return -ENOSYS;
3028	}	3028	}
3029		3029
3030	int sysctl_jiffies(struct ctl_table *table,	3030	int sysctl_jiffies(struct ctl_table *table,
3031	void __user oldval, size_t __user oldlenp,	3031	void __user oldval, size_t __user oldlenp,
3032	void __user *newval, size_t newlen)	3032	void __user *newval, size_t newlen)
3033	{	3033	{
3034	return -ENOSYS;	3034	return -ENOSYS;
3035	}	3035	}
3036		3036
3037	int sysctl_ms_jiffies(struct ctl_table *table,	3037	int sysctl_ms_jiffies(struct ctl_table *table,
3038	void __user oldval, size_t __user oldlenp,	3038	void __user oldval, size_t __user oldlenp,
3039	void __user *newval, size_t newlen)	3039	void __user *newval, size_t newlen)
3040	{	3040	{
3041	return -ENOSYS;	3041	return -ENOSYS;
3042	}	3042	}
3043		3043
3044	#endif /* CONFIG_SYSCTL_SYSCALL */	3044	#endif /* CONFIG_SYSCTL_SYSCALL */
3045		3045
3046	static int deprecated_sysctl_warning(struct __sysctl_args *args)	3046	static int deprecated_sysctl_warning(struct __sysctl_args *args)
3047	{	3047	{
3048	static int msg_count;	3048	static int msg_count;
3049	int name[CTL_MAXNAME];	3049	int name[CTL_MAXNAME];
3050	int i;	3050	int i;
3051		3051
3052	/* Check args->nlen. */	3052	/* Check args->nlen. */
3053	if (args->nlen < 0 \|\| args->nlen > CTL_MAXNAME)	3053	if (args->nlen < 0 \|\| args->nlen > CTL_MAXNAME)
3054	return -ENOTDIR;	3054	return -ENOTDIR;
3055		3055
3056	/* Read in the sysctl name for better debug message logging */	3056	/* Read in the sysctl name for better debug message logging */
3057	for (i = 0; i < args->nlen; i++)	3057	for (i = 0; i < args->nlen; i++)
3058	if (get_user(name[i], args->name + i))	3058	if (get_user(name[i], args->name + i))
3059	return -EFAULT;	3059	return -EFAULT;
3060		3060
3061	/* Ignore accesses to kernel.version */	3061	/* Ignore accesses to kernel.version */
3062	if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))	3062	if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
3063	return 0;	3063	return 0;
3064		3064
3065	if (msg_count < 5) {	3065	if (msg_count < 5) {
3066	msg_count++;	3066	msg_count++;
3067	printk(KERN_INFO	3067	printk(KERN_INFO
3068	"warning: process `%s' used the deprecated sysctl "	3068	"warning: process `%s' used the deprecated sysctl "
3069	"system call with ", current->comm);	3069	"system call with ", current->comm);
3070	for (i = 0; i < args->nlen; i++)	3070	for (i = 0; i < args->nlen; i++)
3071	printk("%d.", name[i]);	3071	printk("%d.", name[i]);
3072	printk("\n");	3072	printk("\n");
3073	}	3073	}
3074	return 0;	3074	return 0;
3075	}	3075	}
3076		3076
3077	/*	3077	/*
3078	* No sense putting this after each symbol definition, twice,	3078	* No sense putting this after each symbol definition, twice,
3079	* exception granted :-)	3079	* exception granted :-)
3080	*/	3080	*/
3081	EXPORT_SYMBOL(proc_dointvec);	3081	EXPORT_SYMBOL(proc_dointvec);
3082	EXPORT_SYMBOL(proc_dointvec_jiffies);	3082	EXPORT_SYMBOL(proc_dointvec_jiffies);
3083	EXPORT_SYMBOL(proc_dointvec_minmax);	3083	EXPORT_SYMBOL(proc_dointvec_minmax);
3084	EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);	3084	EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
3085	EXPORT_SYMBOL(proc_dointvec_ms_jiffies);	3085	EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
3086	EXPORT_SYMBOL(proc_dostring);	3086	EXPORT_SYMBOL(proc_dostring);
3087	EXPORT_SYMBOL(proc_doulongvec_minmax);	3087	EXPORT_SYMBOL(proc_doulongvec_minmax);
3088	EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);	3088	EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
3089	EXPORT_SYMBOL(register_sysctl_table);	3089	EXPORT_SYMBOL(register_sysctl_table);
3090	EXPORT_SYMBOL(register_sysctl_paths);	3090	EXPORT_SYMBOL(register_sysctl_paths);
3091	EXPORT_SYMBOL(sysctl_intvec);	3091	EXPORT_SYMBOL(sysctl_intvec);
3092	EXPORT_SYMBOL(sysctl_jiffies);	3092	EXPORT_SYMBOL(sysctl_jiffies);
3093	EXPORT_SYMBOL(sysctl_ms_jiffies);	3093	EXPORT_SYMBOL(sysctl_ms_jiffies);
3094	EXPORT_SYMBOL(sysctl_string);	3094	EXPORT_SYMBOL(sysctl_string);
3095	EXPORT_SYMBOL(sysctl_data);	3095	EXPORT_SYMBOL(sysctl_data);
3096	EXPORT_SYMBOL(unregister_sysctl_table);	3096	EXPORT_SYMBOL(unregister_sysctl_table);
3097		3097