39 files changed, 2395 insertions, 564 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 2a999836ca18..d63fbb18798a 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -9,7 +9,7 @@ obj-y     = sched.o fork.o exec_domain.o panic.o printk.o profile.o \
             rcupdate.o extable.o params.o posix-timers.o \
             kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \
             hrtimer.o rwsem.o latency.o nsproxy.o srcu.o die_notifier.o \
-            utsname.o
+            utsname.o sysctl_check.o
 
 obj-$(CONFIG_STACKTRACE) += stacktrace.o
 obj-y += time/
diff --git a/kernel/acct.c b/kernel/acct.c
index 24f0f8b2ba72..fce53d8df8a7 100644
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -329,16 +329,16 @@ static comp_t encode_comp_t(unsigned long value)
         }
 
         /*
-         * If we need to round up, do it (and handle overflow correctly).
-         */
+         * If we need to round up, do it (and handle overflow correctly).
+         */
         if (rnd && (++value > MAXFRACT)) {
                 value >>= EXPSIZE;
                 exp++;
         }
 
         /*
-         * Clean it up and polish it off.
-         */
+         * Clean it up and polish it off.
+         */
         exp <<= MANTSIZE;               /* Shift the exponent into place */
         exp += value;                   /* and add on the mantissa. */
         return exp;
@@ -361,30 +361,30 @@ static comp_t encode_comp_t(unsigned long value)
 
 static comp2_t encode_comp2_t(u64 value)
 {
-        int exp, rnd;
-
-        exp = (value > (MAXFRACT2>>1));
-        rnd = 0;
-        while (value > MAXFRACT2) {
-                rnd = value & 1;
-                value >>= 1;
-                exp++;
-        }
-
-        /*
-         * If we need to round up, do it (and handle overflow correctly).
-         */
-        if (rnd && (++value > MAXFRACT2)) {
-                value >>= 1;
-                exp++;
-        }
-
-        if (exp > MAXEXP2) {
-                /* Overflow. Return largest representable number instead. */
-                return (1ul << (MANTSIZE2+EXPSIZE2-1)) - 1;
-        } else {
-                return (value & (MAXFRACT2>>1)) | (exp << (MANTSIZE2-1));
-        }
+        int exp, rnd;
+
+        exp = (value > (MAXFRACT2>>1));
+        rnd = 0;
+        while (value > MAXFRACT2) {
+                rnd = value & 1;
+                value >>= 1;
+                exp++;
+        }
+
+        /*
+         * If we need to round up, do it (and handle overflow correctly).
+         */
+        if (rnd && (++value > MAXFRACT2)) {
+                value >>= 1;
+                exp++;
+        }
+
+        if (exp > MAXEXP2) {
+                /* Overflow. Return largest representable number instead. */
+                return (1ul << (MANTSIZE2+EXPSIZE2-1)) - 1;
+        } else {
+                return (value & (MAXFRACT2>>1)) | (exp << (MANTSIZE2-1));
+        }
 }
 #endif
 
@@ -501,14 +501,14 @@ static void do_acct_process(struct file *file)
         ac.ac_swaps = encode_comp_t(0);
 
         /*
-         * Kernel segment override to datasegment and write it
-         * to the accounting file.
-         */
+         * Kernel segment override to datasegment and write it
+         * to the accounting file.
+         */
         fs = get_fs();
         set_fs(KERNEL_DS);
         /*
-         * Accounting records are not subject to resource limits.
-         */
+         * Accounting records are not subject to resource limits.
+         */
         flim = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
         current->signal->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
         file->f_op->write(file, (char *)&ac,
diff --git a/kernel/audit.c b/kernel/audit.c
index 2924251a6547..6977ea57a7e2 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -664,11 +664,11 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                                 if (sid) {
                                         if (selinux_sid_to_string(
                                                         sid, &ctx, &len)) {
-                                                audit_log_format(ab, 
+                                                audit_log_format(ab,
                                                         " ssid=%u", sid);
                                                 /* Maybe call audit_panic? */
                                         } else
-                                                audit_log_format(ab, 
+                                                audit_log_format(ab,
                                                         " subj=%s", ctx);
                                         kfree(ctx);
                                 }
@@ -769,7 +769,7 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                 sig_data->pid = audit_sig_pid;
                 memcpy(sig_data->ctx, ctx, len);
                 kfree(ctx);
-                audit_send_reply(NETLINK_CB(skb).pid, seq, AUDIT_SIGNAL_INFO, 
+                audit_send_reply(NETLINK_CB(skb).pid, seq, AUDIT_SIGNAL_INFO,
                                 0, 0, sig_data, sizeof(*sig_data) + len);
                 kfree(sig_data);
                 break;
@@ -1005,7 +1005,7 @@ unsigned int audit_serial(void)
         return ret;
 }
 
-static inline void audit_get_stamp(struct audit_context *ctx, 
+static inline void audit_get_stamp(struct audit_context *ctx,
                                    struct timespec *t, unsigned int *serial)
 {
         if (ctx)
@@ -1056,7 +1056,7 @@ struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask,
         if (gfp_mask & __GFP_WAIT)
                 reserve = 0;
         else
-                reserve = 5; /* Allow atomic callers to go up to five 
+                reserve = 5; /* Allow atomic callers to go up to five
                                 entries over the normal backlog limit */
 
         while (audit_backlog_limit
@@ -1319,7 +1319,7 @@ void audit_log_d_path(struct audit_buffer *ab, const char *prefix,
         if (IS_ERR(p)) { /* Should never happen since we send PATH_MAX */
                 /* FIXME: can we save some information here? */
                 audit_log_format(ab, "<too long>");
-        } else 
+        } else
                 audit_log_untrustedstring(ab, p);
         kfree(path);
 }
@@ -1365,7 +1365,7 @@ void audit_log_end(struct audit_buffer *ab)
  * audit_log_vformat, and audit_log_end.  It may be called
  * in any context.
  */
-void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type, 
+void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type,
                const char *fmt, ...)
 {
         struct audit_buffer *ab;
diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 359645cff5b2..df66a21fb360 100644
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -1498,7 +1498,7 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
                  * auditctl to read from it... which isn't ever going to
                  * happen if we're actually running in the context of auditctl
                  * trying to _send_ the stuff */
-                 
+
                 dest = kmalloc(sizeof(struct audit_netlink_list), GFP_KERNEL);
                 if (!dest)
                         return -ENOMEM;
@@ -1678,7 +1678,7 @@ int audit_filter_type(int type)
 {
         struct audit_entry *e;
         int result = 0;
-        
+
         rcu_read_lock();
         if (list_empty(&audit_filter_list[AUDIT_FILTER_TYPE]))
                 goto unlock_and_return;
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index 938e60a61882..e19b5a33aede 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -320,7 +320,7 @@ static int audit_filter_rules(struct task_struct *tsk,
                         result = audit_comparator(tsk->personality, f->op, f->val);
                         break;
                 case AUDIT_ARCH:
-                        if (ctx)
+                        if (ctx)
                                 result = audit_comparator(ctx->arch, f->op, f->val);
                         break;
 
@@ -898,7 +898,7 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
         if (context->personality != PER_LINUX)
                 audit_log_format(ab, " per=%lx", context->personality);
         if (context->return_valid)
-                audit_log_format(ab, " success=%s exit=%ld", 
+                audit_log_format(ab, " success=%s exit=%ld",
                                  (context->return_valid==AUDITSC_SUCCESS)?"yes":"no",
                                  context->return_code);
 
@@ -1135,8 +1135,8 @@ void audit_free(struct task_struct *tsk)
                 return;
 
         /* Check for system calls that do not go through the exit
-         * function (e.g., exit_group), then free context block. 
-         * We use GFP_ATOMIC here because we might be doing this 
+         * function (e.g., exit_group), then free context block.
+         * We use GFP_ATOMIC here because we might be doing this
          * in the context of the idle thread */
         /* that can happen only if we are called from do_exit() */
         if (context->in_syscall && context->auditable)
@@ -1316,7 +1316,7 @@ void __audit_getname(const char *name)
                 context->pwdmnt = mntget(current->fs->pwdmnt);
                 read_unlock(&current->fs->lock);
         }
-                
+
 }
 
 /* audit_putname - intercept a putname request
diff --git a/kernel/capability.c b/kernel/capability.c
index 4e350a36ed6a..cbc5fd60c0f3 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -3,9 +3,9 @@
  *
  * Copyright (C) 1997  Andrew Main <zefram@fysh.org>
  *
- * Integrated into 2.1.97+,  Andrew G. Morgan <morgan@transmeta.com>
+ * Integrated into 2.1.97+,  Andrew G. Morgan <morgan@kernel.org>
  * 30 May 2002: Cleanup, Robert M. Love <rml@tech9.net>
- */ 
+ */
 
 #include <linux/capability.h>
 #include <linux/mm.h>
@@ -14,9 +14,6 @@
 #include <linux/syscalls.h>
 #include <asm/uaccess.h>
 
-unsigned securebits = SECUREBITS_DEFAULT; /* systemwide security settings */
-kernel_cap_t cap_bset = CAP_INIT_EFF_SET;
-
 /*
  * This lock protects task->cap_* for all tasks including current.
  * Locking rule: acquire this prior to tasklist_lock.
@@ -40,49 +37,49 @@ static DEFINE_SPINLOCK(task_capability_lock);
  */
 asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
 {
-     int ret = 0;
-     pid_t pid;
-     __u32 version;
-     struct task_struct *target;
-     struct __user_cap_data_struct data;
-
-     if (get_user(version, &header->version))
-             return -EFAULT;
-
-     if (version != _LINUX_CAPABILITY_VERSION) {
-             if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
-                     return -EFAULT; 
-             return -EINVAL;
-     }
+        int ret = 0;
+        pid_t pid;
+        __u32 version;
+        struct task_struct *target;
+        struct __user_cap_data_struct data;
+
+        if (get_user(version, &header->version))
+                return -EFAULT;
+
+        if (version != _LINUX_CAPABILITY_VERSION) {
+                if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
+                        return -EFAULT;
+                return -EINVAL;
+        }
 
-     if (get_user(pid, &header->pid))
-             return -EFAULT;
+        if (get_user(pid, &header->pid))
+                return -EFAULT;
 
-     if (pid < 0) 
-             return -EINVAL;
+        if (pid < 0)
+                return -EINVAL;
 
-     spin_lock(&task_capability_lock);
-     read_lock(&tasklist_lock); 
+        spin_lock(&task_capability_lock);
+        read_lock(&tasklist_lock);
 
-     if (pid && pid != current->pid) {
-             target = find_task_by_pid(pid);
-             if (!target) {
-                  ret = -ESRCH;
-                  goto out;
-             }
-     } else
-             target = current;
+        if (pid && pid != current->pid) {
+                target = find_task_by_pid(pid);
+                if (!target) {
+                        ret = -ESRCH;
+                        goto out;
+                }
+        } else
+                target = current;
 
-     ret = security_capget(target, &data.effective, &data.inheritable, &data.permitted);
+        ret = security_capget(target, &data.effective, &data.inheritable, &data.permitted);
 
 out:
-     read_unlock(&tasklist_lock); 
-     spin_unlock(&task_capability_lock);
+        read_unlock(&tasklist_lock);
+        spin_unlock(&task_capability_lock);
 
-     if (!ret && copy_to_user(dataptr, &data, sizeof data))
-          return -EFAULT; 
+        if (!ret && copy_to_user(dataptr, &data, sizeof data))
+                return -EFAULT;
 
-     return ret;
+        return ret;
 }
 
 /*
@@ -115,7 +112,7 @@ static inline int cap_set_pg(int pgrp_nr, kernel_cap_t *effective,
         } while_each_pid_task(pgrp, PIDTYPE_PGID, g);
 
         if (!found)
-             ret = 0;
+                ret = 0;
         return ret;
 }
 
@@ -169,68 +166,68 @@ static inline int cap_set_all(kernel_cap_t *effective,
  */
 asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
 {
-     kernel_cap_t inheritable, permitted, effective;
-     __u32 version;
-     struct task_struct *target;
-     int ret;
-     pid_t pid;
-
-     if (get_user(version, &header->version))
-             return -EFAULT; 
-
-     if (version != _LINUX_CAPABILITY_VERSION) {
-             if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
-                     return -EFAULT; 
-             return -EINVAL;
-     }
-
-     if (get_user(pid, &header->pid))
-             return -EFAULT; 
-
-     if (pid && pid != current->pid && !capable(CAP_SETPCAP))
-             return -EPERM;
-
-     if (copy_from_user(&effective, &data->effective, sizeof(effective)) ||
-         copy_from_user(&inheritable, &data->inheritable, sizeof(inheritable)) ||
-         copy_from_user(&permitted, &data->permitted, sizeof(permitted)))
-             return -EFAULT; 
-
-     spin_lock(&task_capability_lock);
-     read_lock(&tasklist_lock);
-
-     if (pid > 0 && pid != current->pid) {
-          target = find_task_by_pid(pid);
-          if (!target) {
-               ret = -ESRCH;
-               goto out;
-          }
-     } else
-               target = current;
-
-     ret = 0;
-
-     /* having verified that the proposed changes are legal,
-           we now put them into effect. */
-     if (pid < 0) {
-             if (pid == -1)  /* all procs other than current and init */
-                     ret = cap_set_all(&effective, &inheritable, &permitted);
-
-             else            /* all procs in process group */
-                     ret = cap_set_pg(-pid, &effective, &inheritable,
-                                                        &permitted);
-     } else {
-             ret = security_capset_check(target, &effective, &inheritable,
-                                                        &permitted);
-             if (!ret)
-                     security_capset_set(target, &effective, &inheritable,
-                                                        &permitted);
-     }
+        kernel_cap_t inheritable, permitted, effective;
+        __u32 version;
+        struct task_struct *target;
+        int ret;
+        pid_t pid;
+
+        if (get_user(version, &header->version))
+                return -EFAULT;
+
+        if (version != _LINUX_CAPABILITY_VERSION) {
+                if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
+                        return -EFAULT;
+                return -EINVAL;
+        }
+
+        if (get_user(pid, &header->pid))
+                return -EFAULT;
+
+        if (pid && pid != current->pid && !capable(CAP_SETPCAP))
+                return -EPERM;
+
+        if (copy_from_user(&effective, &data->effective, sizeof(effective)) ||
+            copy_from_user(&inheritable, &data->inheritable, sizeof(inheritable)) ||
+            copy_from_user(&permitted, &data->permitted, sizeof(permitted)))
+                return -EFAULT;
+
+        spin_lock(&task_capability_lock);
+        read_lock(&tasklist_lock);
+
+        if (pid > 0 && pid != current->pid) {
+                target = find_task_by_pid(pid);
+                if (!target) {
+                        ret = -ESRCH;
+                        goto out;
+                }
+        } else
+                target = current;
+
+        ret = 0;
+
+        /* having verified that the proposed changes are legal,
+           we now put them into effect. */
+        if (pid < 0) {
+                if (pid == -1)  /* all procs other than current and init */
+                        ret = cap_set_all(&effective, &inheritable, &permitted);
+
+                else            /* all procs in process group */
+                        ret = cap_set_pg(-pid, &effective, &inheritable,
+                                         &permitted);
+        } else {
+                ret = security_capset_check(target, &effective, &inheritable,
+                                            &permitted);
+                if (!ret)
+                        security_capset_set(target, &effective, &inheritable,
+                                            &permitted);
+        }
 
 out:
-     read_unlock(&tasklist_lock);
-     spin_unlock(&task_capability_lock);
+        read_unlock(&tasklist_lock);
+        spin_unlock(&task_capability_lock);
 
-     return ret;
+        return ret;
 }
 
 int __capable(struct task_struct *t, int cap)
diff --git a/kernel/compat.c b/kernel/compat.c
index 252a446fb0d0..42a1ed4b61b1 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -212,8 +212,8 @@ asmlinkage long compat_sys_setrlimit(unsigned int resource,
         int ret;
         mm_segment_t old_fs = get_fs ();
 
-        if (resource >= RLIM_NLIMITS) 
-                return -EINVAL; 
+        if (resource >= RLIM_NLIMITS)
+                return -EINVAL;
 
         if (!access_ok(VERIFY_READ, rlim, sizeof(*rlim)) ||
             __get_user(r.rlim_cur, &rlim->rlim_cur) ||
@@ -442,21 +442,21 @@ asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid, unsigned int len,
 
 int get_compat_itimerspec(struct itimerspec *dst,
                           const struct compat_itimerspec __user *src)
-{ 
+{
         if (get_compat_timespec(&dst->it_interval, &src->it_interval) ||
             get_compat_timespec(&dst->it_value, &src->it_value))
                 return -EFAULT;
         return 0;
-} 
+}
 
 int put_compat_itimerspec(struct compat_itimerspec __user *dst,
                           const struct itimerspec *src)
-{ 
+{
         if (put_compat_timespec(&src->it_interval, &dst->it_interval) ||
             put_compat_timespec(&src->it_value, &dst->it_value))
                 return -EFAULT;
         return 0;
-} 
+}
 
 long compat_sys_timer_create(clockid_t which_clock,
                         struct compat_sigevent __user *timer_event_spec,
@@ -477,9 +477,9 @@ long compat_sys_timer_create(clockid_t which_clock,
 }
 
 long compat_sys_timer_settime(timer_t timer_id, int flags,
-                          struct compat_itimerspec __user *new, 
+                          struct compat_itimerspec __user *new,
                           struct compat_itimerspec __user *old)
-{ 
+{
         long err;
         mm_segment_t oldfs;
         struct itimerspec newts, oldts;
@@ -487,58 +487,58 @@ long compat_sys_timer_settime(timer_t timer_id, int flags,
         if (!new)
                 return -EINVAL;
         if (get_compat_itimerspec(&newts, new))
-                return -EFAULT; 
+                return -EFAULT;
         oldfs = get_fs();
         set_fs(KERNEL_DS);
         err = sys_timer_settime(timer_id, flags,
                                 (struct itimerspec __user *) &newts,
                                 (struct itimerspec __user *) &oldts);
-        set_fs(oldfs); 
+        set_fs(oldfs);
         if (!err && old && put_compat_itimerspec(old, &oldts))
                 return -EFAULT;
         return err;
-} 
+}
 
 long compat_sys_timer_gettime(timer_t timer_id,
                 struct compat_itimerspec __user *setting)
-{ 
+{
         long err;
         mm_segment_t oldfs;
-        struct itimerspec ts; 
+        struct itimerspec ts;
 
         oldfs = get_fs();
         set_fs(KERNEL_DS);
         err = sys_timer_gettime(timer_id,
-                                (struct itimerspec __user *) &ts); 
-        set_fs(oldfs); 
+                                (struct itimerspec __user *) &ts);
+        set_fs(oldfs);
         if (!err && put_compat_itimerspec(setting, &ts))
                 return -EFAULT;
         return err;
-} 
+}
 
 long compat_sys_clock_settime(clockid_t which_clock,
                 struct compat_timespec __user *tp)
 {
         long err;
         mm_segment_t oldfs;
-        struct timespec ts; 
+        struct timespec ts;
 
         if (get_compat_timespec(&ts, tp))
-                return -EFAULT; 
+                return -EFAULT;
         oldfs = get_fs();
-        set_fs(KERNEL_DS);      
+        set_fs(KERNEL_DS);
         err = sys_clock_settime(which_clock,
                                 (struct timespec __user *) &ts);
         set_fs(oldfs);
         return err;
-} 
+}
 
 long compat_sys_clock_gettime(clockid_t which_clock,
                 struct compat_timespec __user *tp)
 {
         long err;
         mm_segment_t oldfs;
-        struct timespec ts; 
+        struct timespec ts;
 
         oldfs = get_fs();
         set_fs(KERNEL_DS);
@@ -546,16 +546,16 @@ long compat_sys_clock_gettime(clockid_t which_clock,
                                 (struct timespec __user *) &ts);
         set_fs(oldfs);
         if (!err && put_compat_timespec(&ts, tp))
-                return -EFAULT; 
+                return -EFAULT;
         return err;
-} 
+}
 
 long compat_sys_clock_getres(clockid_t which_clock,
                 struct compat_timespec __user *tp)
 {
         long err;
         mm_segment_t oldfs;
-        struct timespec ts; 
+        struct timespec ts;
 
         oldfs = get_fs();
         set_fs(KERNEL_DS);
@@ -563,9 +563,9 @@ long compat_sys_clock_getres(clockid_t which_clock,
                                (struct timespec __user *) &ts);
         set_fs(oldfs);
         if (!err && tp && put_compat_timespec(&ts, tp))
-                return -EFAULT; 
+                return -EFAULT;
         return err;
-} 
+}
 
 static long compat_clock_nanosleep_restart(struct restart_block *restart)
 {
@@ -597,10 +597,10 @@ long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
 {
         long err;
         mm_segment_t oldfs;
-        struct timespec in, out; 
+        struct timespec in, out;
         struct restart_block *restart;
 
-        if (get_compat_timespec(&in, rqtp)) 
+        if (get_compat_timespec(&in, rqtp))
                 return -EFAULT;
 
         oldfs = get_fs();
@@ -619,8 +619,8 @@ long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
                 restart->fn = compat_clock_nanosleep_restart;
                 restart->arg1 = (unsigned long) rmtp;
         }
-        return err;     
-} 
+        return err;
+}
 
 /*
  * We currently only need the following fields from the sigevent
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 38033db8d8ec..a21f71af9d81 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -150,6 +150,7 @@ static int _cpu_down(unsigned int cpu, int tasks_frozen)
         err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
                                         hcpu, -1, &nr_calls);
         if (err == NOTIFY_BAD) {
+                nr_calls--;
                 __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
                                           hcpu, nr_calls, NULL);
                 printk("%s: attempt to take down CPU %u failed\n",
@@ -233,6 +234,7 @@ static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
         ret = __raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE | mod, hcpu,
                                                         -1, &nr_calls);
         if (ret == NOTIFY_BAD) {
+                nr_calls--;
                 printk("%s: attempt to bring up CPU %u failed\n",
                                 __FUNCTION__, cpu);
                 ret = -EINVAL;
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 2eb2e50db0d6..64950fa5d321 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -2431,12 +2431,12 @@ int __cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask)
         node = zone_to_nid(z);
         if (node_isset(node, current->mems_allowed))
                 return 1;
-        /*
-         * Allow tasks that have access to memory reserves because they have
-         * been OOM killed to get memory anywhere.
-         */
-        if (unlikely(test_thread_flag(TIF_MEMDIE)))
-                return 1;
+        /*
+         * Allow tasks that have access to memory reserves because they have
+         * been OOM killed to get memory anywhere.
+         */
+        if (unlikely(test_thread_flag(TIF_MEMDIE)))
+                return 1;
         return 0;
 }
 
diff --git a/kernel/delayacct.c b/kernel/delayacct.c
index 09e9574eeb26..10e43fd8b721 100644
--- a/kernel/delayacct.c
+++ b/kernel/delayacct.c
@@ -115,6 +115,12 @@ int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
         tmp += timespec_to_ns(&ts);
         d->cpu_run_real_total = (tmp < (s64)d->cpu_run_real_total) ? 0 : tmp;
 
+        tmp = (s64)d->cpu_scaled_run_real_total;
+        cputime_to_timespec(tsk->utimescaled + tsk->stimescaled, &ts);
+        tmp += timespec_to_ns(&ts);
+        d->cpu_scaled_run_real_total =
+                (tmp < (s64)d->cpu_scaled_run_real_total) ? 0 : tmp;
+
         /*
          * No locking available for sched_info (and too expensive to add one)
          * Mitigate by taking snapshot of values
diff --git a/kernel/dma.c b/kernel/dma.c
index 937b13ca33ba..6a82bb716dac 100644
--- a/kernel/dma.c
+++ b/kernel/dma.c
@@ -20,7 +20,7 @@
 #include <asm/dma.h>
 #include <asm/system.h>
 
- 
+
 
 /* A note on resource allocation:
  *
@@ -95,7 +95,7 @@ void free_dma(unsigned int dmanr)
         if (xchg(&dma_chan_busy[dmanr].lock, 0) == 0) {
                 printk(KERN_WARNING "Trying to free free DMA%d\n", dmanr);
                 return;
-        }       
+        }
 
 } /* free_dma */
 
@@ -121,8 +121,8 @@ static int proc_dma_show(struct seq_file *m, void *v)
 
         for (i = 0 ; i < MAX_DMA_CHANNELS ; i++) {
                 if (dma_chan_busy[i].lock) {
-                    seq_printf(m, "%2d: %s\n", i,
-                               dma_chan_busy[i].device_id);
+                        seq_printf(m, "%2d: %s\n", i,
+                                   dma_chan_busy[i].device_id);
                 }
         }
         return 0;
diff --git a/kernel/exec_domain.c b/kernel/exec_domain.c
index 3c2eaea66b1e..a9e6bad9f706 100644
--- a/kernel/exec_domain.c
+++ b/kernel/exec_domain.c
@@ -57,7 +57,7 @@ lookup_exec_domain(u_long personality)
 {
         struct exec_domain *    ep;
         u_long                  pers = personality(personality);
-                
+
         read_lock(&exec_domains_lock);
         for (ep = exec_domains; ep; ep = ep->next) {
                 if (pers >= ep->pers_low && pers <= ep->pers_high)
diff --git a/kernel/fork.c b/kernel/fork.c
index 490495a39c7e..2ce28f165e31 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -268,7 +268,7 @@ static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
                         get_file(file);
                         if (tmp->vm_flags & VM_DENYWRITE)
                                 atomic_dec(&inode->i_writecount);
-      
+
                         /* insert tmp into the share list, just after mpnt */
                         spin_lock(&file->f_mapping->i_mmap_lock);
                         tmp->vm_truncate_count = mpnt->vm_truncate_count;
@@ -331,7 +331,7 @@ static inline void mm_free_pgd(struct mm_struct * mm)
 #define mm_free_pgd(mm)
 #endif /* CONFIG_MMU */
 
- __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
+__cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
 
 #define allocate_mm()   (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
 #define free_mm(mm)     (kmem_cache_free(mm_cachep, (mm)))
@@ -738,8 +738,8 @@ static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
         /* compute the remainder to be cleared */
         size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
 
-        /* This is long word aligned thus could use a optimized version */ 
-        memset(new_fds, 0, size); 
+        /* This is long word aligned thus could use a optimized version */
+        memset(new_fds, 0, size);
 
         if (new_fdt->max_fds > open_files) {
                 int left = (new_fdt->max_fds-open_files)/8;
@@ -942,6 +942,7 @@ static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
         if (!(clone_flags & CLONE_PTRACE))
                 p->ptrace = 0;
         p->flags = new_flags;
+        clear_freeze_flag(p);
 }
 
 asmlinkage long sys_set_tid_address(int __user *tidptr)
@@ -1058,6 +1059,8 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         p->utime = cputime_zero;
         p->stime = cputime_zero;
         p->gtime = cputime_zero;
+        p->utimescaled = cputime_zero;
+        p->stimescaled = cputime_zero;
 
 #ifdef CONFIG_TASK_XACCT
         p->rchar = 0;           /* I/O counter: bytes read */
@@ -1068,12 +1071,12 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         task_io_accounting_init(p);
         acct_clear_integrals(p);
 
-        p->it_virt_expires = cputime_zero;
+        p->it_virt_expires = cputime_zero;
         p->it_prof_expires = cputime_zero;
-        p->it_sched_expires = 0;
-        INIT_LIST_HEAD(&p->cpu_timers[0]);
-        INIT_LIST_HEAD(&p->cpu_timers[1]);
-        INIT_LIST_HEAD(&p->cpu_timers[2]);
+        p->it_sched_expires = 0;
+        INIT_LIST_HEAD(&p->cpu_timers[0]);
+        INIT_LIST_HEAD(&p->cpu_timers[1]);
+        INIT_LIST_HEAD(&p->cpu_timers[2]);
 
         p->lock_depth = -1;             /* -1 = no lock */
         do_posix_clock_monotonic_gettime(&p->start_time);
@@ -1083,7 +1086,6 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         p->security = NULL;
 #endif
         p->io_context = NULL;
-        p->io_wait = NULL;
         p->audit_context = NULL;
         cpuset_fork(p);
 #ifdef CONFIG_NUMA
@@ -1239,7 +1241,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
          * A fatal signal pending means that current will exit, so the new
          * thread can't slip out of an OOM kill (or normal SIGKILL).
          */
-        recalc_sigpending();
+        recalc_sigpending();
         if (signal_pending(current)) {
                 spin_unlock(&current->sighand->siglock);
                 write_unlock_irq(&tasklist_lock);
diff --git a/kernel/futex.c b/kernel/futex.c
index d725676d84f3..e45a65e41686 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -293,7 +293,7 @@ EXPORT_SYMBOL_GPL(get_futex_key_refs);
  */
 void drop_futex_key_refs(union futex_key *key)
 {
-        if (key->both.ptr == 0)
+        if (!key->both.ptr)
                 return;
         switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
                 case FUT_OFF_INODE:
@@ -1046,7 +1046,7 @@ static int unqueue_me(struct futex_q *q)
  retry:
         lock_ptr = q->lock_ptr;
         barrier();
-        if (lock_ptr != 0) {
+        if (lock_ptr != NULL) {
                 spin_lock(lock_ptr);
                 /*
                  * q->lock_ptr can change between reading it and
diff --git a/kernel/itimer.c b/kernel/itimer.c
index 3205e8e114fa..2fab344dbf56 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -130,7 +130,7 @@ asmlinkage long sys_getitimer(int which, struct itimerval __user *value)
 enum hrtimer_restart it_real_fn(struct hrtimer *timer)
 {
         struct signal_struct *sig =
-            container_of(timer, struct signal_struct, real_timer);
+                container_of(timer, struct signal_struct, real_timer);
 
         send_group_sig_info(SIGALRM, SEND_SIG_PRIV, sig->tsk);
 
@@ -291,6 +291,6 @@ asmlinkage long sys_setitimer(int which,
                 return error;
 
         if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer)))
-                return -EFAULT; 
+                return -EFAULT;
         return 0;
 }
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 7885269b0da2..e9f1b4ea504d 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -785,7 +785,7 @@ static int kimage_load_normal_segment(struct kimage *image,
                 size_t uchunk, mchunk;
 
                 page = kimage_alloc_page(image, GFP_HIGHUSER, maddr);
-                if (page == 0) {
+                if (!page) {
                         result  = -ENOMEM;
                         goto out;
                 }
@@ -844,7 +844,7 @@ static int kimage_load_crash_segment(struct kimage *image,
                 size_t uchunk, mchunk;
 
                 page = pfn_to_page(maddr >> PAGE_SHIFT);
-                if (page == 0) {
+                if (!page) {
                         result  = -ENOMEM;
                         goto out;
                 }
diff --git a/kernel/module.c b/kernel/module.c
index a389b423c279..7734595bd329 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -105,7 +105,7 @@ void __module_put_and_exit(struct module *mod, long code)
         do_exit(code);
 }
 EXPORT_SYMBOL(__module_put_and_exit);
-        
+
 /* Find a module section: 0 means not found. */
 static unsigned int find_sec(Elf_Ehdr *hdr,
                              Elf_Shdr *sechdrs,
@@ -179,7 +179,7 @@ static unsigned long __find_symbol(const char *name,
         struct module *mod;
         const struct kernel_symbol *ks;
 
-        /* Core kernel first. */ 
+        /* Core kernel first. */
         *owner = NULL;
         ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
         if (ks) {
@@ -231,7 +231,7 @@ static unsigned long __find_symbol(const char *name,
                 return ks->value;
         }
 
-        /* Now try modules. */ 
+        /* Now try modules. */
         list_for_each_entry(mod, &modules, list) {
                 *owner = mod;
                 ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
@@ -285,7 +285,7 @@ static unsigned long __find_symbol(const char *name,
                 }
         }
         DEBUGP("Failed to find symbol %s\n", name);
-        return 0;
+        return 0;
 }
 
 /* Search for module by name: must hold module_mutex. */
@@ -441,7 +441,7 @@ static int percpu_modinit(void)
         }
 
         return 0;
-}       
+}
 __initcall(percpu_modinit);
 #else /* ... !CONFIG_SMP */
 static inline void *percpu_modalloc(unsigned long size, unsigned long align,
@@ -483,8 +483,8 @@ static int modinfo_##field##_exists(struct module *mod)               \
 }                                                                     \
 static void free_modinfo_##field(struct module *mod)                  \
 {                                                                     \
-        kfree(mod->field);                                            \
-        mod->field = NULL;                                            \
+        kfree(mod->field);                                            \
+        mod->field = NULL;                                            \
 }                                                                     \
 static struct module_attribute modinfo_##field = {                    \
         .attr = { .name = __stringify(field), .mode = 0444 },         \
@@ -990,7 +990,7 @@ static void add_sect_attrs(struct module *mod, unsigned int nsect,
         struct module_sect_attrs *sect_attrs;
         struct module_sect_attr *sattr;
         struct attribute **gattr;
-        
+
         /* Count loaded sections and allocate structures */
         for (i = 0; i < nsect; i++)
                 if (sechdrs[i].sh_flags & SHF_ALLOC)
@@ -1348,14 +1348,14 @@ static int verify_export_symbols(struct module *mod)
         const unsigned long *crc;
 
         for (i = 0; i < mod->num_syms; i++)
-                if (__find_symbol(mod->syms[i].name, &owner, &crc, 1)) {
+                if (__find_symbol(mod->syms[i].name, &owner, &crc, 1)) {
                         name = mod->syms[i].name;
                         ret = -ENOEXEC;
                         goto dup;
                 }
 
         for (i = 0; i < mod->num_gpl_syms; i++)
-                if (__find_symbol(mod->gpl_syms[i].name, &owner, &crc, 1)) {
+                if (__find_symbol(mod->gpl_syms[i].name, &owner, &crc, 1)) {
                         name = mod->gpl_syms[i].name;
                         ret = -ENOEXEC;
                         goto dup;
@@ -1929,7 +1929,7 @@ static struct module *load_module(void __user *umod,
                 mod->unused_crcs = (void *)sechdrs[unusedgplcrcindex].sh_addr;
 
 #ifdef CONFIG_MODVERSIONS
-        if ((mod->num_syms && !crcindex) || 
+        if ((mod->num_syms && !crcindex) ||
             (mod->num_gpl_syms && !gplcrcindex) ||
             (mod->num_gpl_future_syms && !gplfuturecrcindex) ||
             (mod->num_unused_syms && !unusedcrcindex) ||
@@ -2016,7 +2016,7 @@ static struct module *load_module(void __user *umod,
         if (err < 0)
                 goto arch_cleanup;
 
-        err = mod_sysfs_setup(mod, 
+        err = mod_sysfs_setup(mod,
                               (struct kernel_param *)
                               sechdrs[setupindex].sh_addr,
                               sechdrs[setupindex].sh_size
@@ -2028,8 +2028,8 @@ static struct module *load_module(void __user *umod,
 
         /* Size of section 0 is 0, so this works well if no unwind info. */
         mod->unwind_info = unwind_add_table(mod,
-                                            (void *)sechdrs[unwindex].sh_addr,
-                                            sechdrs[unwindex].sh_size);
+                                            (void *)sechdrs[unwindex].sh_addr,
+                                            sechdrs[unwindex].sh_size);
 
         /* Get rid of temporary copy */
         vfree(hdr);
@@ -2146,7 +2146,7 @@ static inline int within(unsigned long addr, void *start, unsigned long size)
  */
 static inline int is_arm_mapping_symbol(const char *str)
 {
-        return str[0] == '$' && strchr("atd", str[1]) 
+        return str[0] == '$' && strchr("atd", str[1])
                && (str[2] == '\0' || str[2] == '.');
 }
 
@@ -2161,11 +2161,11 @@ static const char *get_ksymbol(struct module *mod,
         /* At worse, next value is at end of module */
         if (within(addr, mod->module_init, mod->init_size))
                 nextval = (unsigned long)mod->module_init+mod->init_text_size;
-        else 
+        else
                 nextval = (unsigned long)mod->module_core+mod->core_text_size;
 
         /* Scan for closest preceeding symbol, and next symbol. (ELF
-           starts real symbols at 1). */
+           starts real symbols at 1). */
         for (i = 1; i < mod->num_symtab; i++) {
                 if (mod->symtab[i].st_shndx == SHN_UNDEF)
                         continue;
@@ -2407,7 +2407,7 @@ const struct exception_table_entry *search_module_extables(unsigned long addr)
         list_for_each_entry(mod, &modules, list) {
                 if (mod->num_exentries == 0)
                         continue;
-                                
+
                 e = search_extable(mod->extable,
                                    mod->extable + mod->num_exentries - 1,
                                    addr);
@@ -2417,7 +2417,7 @@ const struct exception_table_entry *search_module_extables(unsigned long addr)
         preempt_enable();
 
         /* Now, if we found one, we are running inside it now, hence
-           we cannot unload the module, hence no refcnt needed. */
+           we cannot unload the module, hence no refcnt needed. */
         return e;
 }
 
diff --git a/kernel/panic.c b/kernel/panic.c
index f64f4c1ac11f..3886bd8230fe 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -56,14 +56,14 @@ EXPORT_SYMBOL(panic_blink);
  *
  *      This function never returns.
  */
- 
+
 NORET_TYPE void panic(const char * fmt, ...)
 {
         long i;
         static char buf[1024];
         va_list args;
 #if defined(CONFIG_S390)
-        unsigned long caller = (unsigned long) __builtin_return_address(0);
+        unsigned long caller = (unsigned long) __builtin_return_address(0);
 #endif
 
         /*
@@ -128,7 +128,7 @@ NORET_TYPE void panic(const char * fmt, ...)
         }
 #endif
 #if defined(CONFIG_S390)
-        disabled_wait(caller);
+        disabled_wait(caller);
 #endif
         local_irq_enable();
         for (i = 0;;) {
@@ -154,7 +154,7 @@ EXPORT_SYMBOL(panic);
  *
  *      The string is overwritten by the next call to print_taint().
  */
- 
+
 const char *print_tainted(void)
 {
         static char buf[20];
@@ -164,7 +164,7 @@ const char *print_tainted(void)
                         tainted & TAINT_FORCED_MODULE ? 'F' : ' ',
                         tainted & TAINT_UNSAFE_SMP ? 'S' : ' ',
                         tainted & TAINT_FORCED_RMMOD ? 'R' : ' ',
-                        tainted & TAINT_MACHINE_CHECK ? 'M' : ' ',
+                        tainted & TAINT_MACHINE_CHECK ? 'M' : ' ',
                         tainted & TAINT_BAD_PAGE ? 'B' : ' ',
                         tainted & TAINT_USER ? 'U' : ' ',
                         tainted & TAINT_DIE ? 'D' : ' ');
diff --git a/kernel/params.c b/kernel/params.c
index 1d6aca288cdc..16f269e9ddc9 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -592,11 +592,17 @@ static void __init param_sysfs_builtin(void)
 
         for (i=0; i < __stop___param - __start___param; i++) {
                 char *dot;
+                size_t kplen;
 
                 kp = &__start___param[i];
+                kplen = strlen(kp->name);
 
                 /* We do not handle args without periods. */
-                dot = memchr(kp->name, '.', MAX_KBUILD_MODNAME);
+                if (kplen > MAX_KBUILD_MODNAME) {
+                        DEBUGP("kernel parameter name is too long: %s\n", kp->name);
+                        continue;
+                }
+                dot = memchr(kp->name, '.', kplen);
                 if (!dot) {
                         DEBUGP("couldn't find period in %s\n", kp->name);
                         continue;
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 14b0e10dc95c..8e186c678149 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -44,17 +44,6 @@ config PM_VERBOSE
         ---help---
         This option enables verbose messages from the Power Management code.
 
-config DISABLE_CONSOLE_SUSPEND
-        bool "Keep console(s) enabled during suspend/resume (DANGEROUS)"
-        depends on PM_DEBUG && PM_SLEEP
-        default n
-        ---help---
-        This option turns off the console suspend mechanism that prevents
-        debug messages from reaching the console during the suspend/resume
-        operations.  This may be helpful when debugging device drivers'
-        suspend/resume routines, but may itself lead to problems, for example
-        if netconsole is used.
-
 config PM_TRACE
         bool "Suspend/resume event tracing"
         depends on PM_DEBUG && X86 && PM_SLEEP && EXPERIMENTAL
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index eb72255b5c86..8b15f777010a 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -45,17 +45,18 @@ enum {
 
 static int hibernation_mode = HIBERNATION_SHUTDOWN;
 
-static struct hibernation_ops *hibernation_ops;
+static struct platform_hibernation_ops *hibernation_ops;
 
 /**
  * hibernation_set_ops - set the global hibernate operations
  * @ops: the hibernation operations to use in subsequent hibernation transitions
  */
 
-void hibernation_set_ops(struct hibernation_ops *ops)
+void hibernation_set_ops(struct platform_hibernation_ops *ops)
 {
-        if (ops && !(ops->prepare && ops->enter && ops->finish
-            && ops->pre_restore && ops->restore_cleanup)) {
+        if (ops && !(ops->start && ops->pre_snapshot && ops->finish
+            && ops->prepare && ops->enter && ops->pre_restore
+            && ops->restore_cleanup)) {
                 WARN_ON(1);
                 return;
         }
@@ -69,16 +70,37 @@ void hibernation_set_ops(struct hibernation_ops *ops)
         mutex_unlock(&pm_mutex);
 }
 
+/**
+ *      platform_start - tell the platform driver that we're starting
+ *      hibernation
+ */
+
+static int platform_start(int platform_mode)
+{
+        return (platform_mode && hibernation_ops) ?
+                hibernation_ops->start() : 0;
+}
 
 /**
- *      platform_prepare - prepare the machine for hibernation using the
+ *      platform_pre_snapshot - prepare the machine for hibernation using the
  *      platform driver if so configured and return an error code if it fails
  */
 
-static int platform_prepare(int platform_mode)
+static int platform_pre_snapshot(int platform_mode)
 {
         return (platform_mode && hibernation_ops) ?
-                hibernation_ops->prepare() : 0;
+                hibernation_ops->pre_snapshot() : 0;
+}
+
+/**
+ *      platform_leave - prepare the machine for switching to the normal mode
+ *      of operation using the platform driver (called with interrupts disabled)
+ */
+
+static void platform_leave(int platform_mode)
+{
+        if (platform_mode && hibernation_ops)
+                hibernation_ops->leave();
 }
 
 /**
@@ -118,6 +140,51 @@ static void platform_restore_cleanup(int platform_mode)
 }
 
 /**
+ *      create_image - freeze devices that need to be frozen with interrupts
+ *      off, create the hibernation image and thaw those devices.  Control
+ *      reappears in this routine after a restore.
+ */
+
+int create_image(int platform_mode)
+{
+        int error;
+
+        error = arch_prepare_suspend();
+        if (error)
+                return error;
+
+        local_irq_disable();
+        /* At this point, device_suspend() has been called, but *not*
+         * device_power_down(). We *must* call device_power_down() now.
+         * Otherwise, drivers for some devices (e.g. interrupt controllers)
+         * become desynchronized with the actual state of the hardware
+         * at resume time, and evil weirdness ensues.
+         */
+        error = device_power_down(PMSG_FREEZE);
+        if (error) {
+                printk(KERN_ERR "Some devices failed to power down, "
+                        KERN_ERR "aborting suspend\n");
+                goto Enable_irqs;
+        }
+
+        save_processor_state();
+        error = swsusp_arch_suspend();
+        if (error)
+                printk(KERN_ERR "Error %d while creating the image\n", error);
+        /* Restore control flow magically appears here */
+        restore_processor_state();
+        if (!in_suspend)
+                platform_leave(platform_mode);
+        /* NOTE:  device_power_up() is just a resume() for devices
+         * that suspended with irqs off ... no overall powerup.
+         */
+        device_power_up();
+ Enable_irqs:
+        local_irq_enable();
+        return error;
+}
+
+/**
  *      hibernation_snapshot - quiesce devices and create the hibernation
  *      snapshot image.
  *      @platform_mode - if set, use the platform driver, if available, to
@@ -135,12 +202,16 @@ int hibernation_snapshot(int platform_mode)
         if (error)
                 return error;
 
+        error = platform_start(platform_mode);
+        if (error)
+                return error;
+
         suspend_console();
         error = device_suspend(PMSG_FREEZE);
         if (error)
                 goto Resume_console;
 
-        error = platform_prepare(platform_mode);
+        error = platform_pre_snapshot(platform_mode);
         if (error)
                 goto Resume_devices;
 
@@ -148,7 +219,7 @@ int hibernation_snapshot(int platform_mode)
         if (!error) {
                 if (hibernation_mode != HIBERNATION_TEST) {
                         in_suspend = 1;
-                        error = swsusp_suspend();
+                        error = create_image(platform_mode);
                         /* Control returns here after successful restore */
                 } else {
                         printk("swsusp debug: Waiting for 5 seconds.\n");
@@ -207,21 +278,50 @@ int hibernation_platform_enter(void)
 {
         int error;
 
-        if (hibernation_ops) {
-                kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
-                /*
-                 * We have cancelled the power transition by running
-                 * hibernation_ops->finish() before saving the image, so we
-                 * should let the firmware know that we're going to enter the
-                 * sleep state after all
-                 */
-                error = hibernation_ops->prepare();
-                sysdev_shutdown();
-                if (!error)
-                        error = hibernation_ops->enter();
-        } else {
-                error = -ENOSYS;
+        if (!hibernation_ops)
+                return -ENOSYS;
+
+        /*
+         * We have cancelled the power transition by running
+         * hibernation_ops->finish() before saving the image, so we should let
+         * the firmware know that we're going to enter the sleep state after all
+         */
+        error = hibernation_ops->start();
+        if (error)
+                return error;
+
+        suspend_console();
+        error = device_suspend(PMSG_SUSPEND);
+        if (error)
+                goto Resume_console;
+
+        error = hibernation_ops->prepare();
+        if (error)
+                goto Resume_devices;
+
+        error = disable_nonboot_cpus();
+        if (error)
+                goto Finish;
+
+        local_irq_disable();
+        error = device_power_down(PMSG_SUSPEND);
+        if (!error) {
+                hibernation_ops->enter();
+                /* We should never get here */
+                while (1);
         }
+        local_irq_enable();
+
+        /*
+         * We don't need to reenable the nonboot CPUs or resume consoles, since
+         * the system is going to be halted anyway.
+         */
+ Finish:
+        hibernation_ops->finish();
+ Resume_devices:
+        device_resume();
+ Resume_console:
+        resume_console();
         return error;
 }
 
@@ -238,14 +338,14 @@ static void power_down(void)
         case HIBERNATION_TEST:
         case HIBERNATION_TESTPROC:
                 break;
-        case HIBERNATION_SHUTDOWN:
-                kernel_power_off();
-                break;
         case HIBERNATION_REBOOT:
                 kernel_restart(NULL);
                 break;
         case HIBERNATION_PLATFORM:
                 hibernation_platform_enter();
+        case HIBERNATION_SHUTDOWN:
+                kernel_power_off();
+                break;
         }
         kernel_halt();
         /*
@@ -298,6 +398,10 @@ int hibernate(void)
         if (error)
                 goto Exit;
 
+        printk("Syncing filesystems ... ");
+        sys_sync();
+        printk("done.\n");
+
         error = prepare_processes();
         if (error)
                 goto Finish;
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 350b485b3b60..3cdf95b1dc92 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -20,6 +20,7 @@
 #include <linux/resume-trace.h>
 #include <linux/freezer.h>
 #include <linux/vmstat.h>
+#include <linux/syscalls.h>
 
 #include "power.h"
 
@@ -32,39 +33,32 @@ DEFINE_MUTEX(pm_mutex);
 /* This is just an arbitrary number */
 #define FREE_PAGE_NUMBER (100)
 
-struct pm_ops *pm_ops;
+static struct platform_suspend_ops *suspend_ops;
 
 /**
- *      pm_set_ops - Set the global power method table. 
+ *      suspend_set_ops - Set the global suspend method table.
  *      @ops:   Pointer to ops structure.
  */
 
-void pm_set_ops(struct pm_ops * ops)
+void suspend_set_ops(struct platform_suspend_ops *ops)
 {
         mutex_lock(&pm_mutex);
-        pm_ops = ops;
+        suspend_ops = ops;
         mutex_unlock(&pm_mutex);
 }
 
 /**
- * pm_valid_only_mem - generic memory-only valid callback
+ * suspend_valid_only_mem - generic memory-only valid callback
  *
- * pm_ops drivers that implement mem suspend only and only need
+ * Platform drivers that implement mem suspend only and only need
  * to check for that in their .valid callback can use this instead
  * of rolling their own .valid callback.
  */
-int pm_valid_only_mem(suspend_state_t state)
+int suspend_valid_only_mem(suspend_state_t state)
 {
         return state == PM_SUSPEND_MEM;
 }
 
-
-static inline void pm_finish(suspend_state_t state)
-{
-        if (pm_ops->finish)
-                pm_ops->finish(state);
-}
-
 /**
  *      suspend_prepare - Do prep work before entering low-power state.
  *
@@ -76,7 +70,7 @@ static int suspend_prepare(void)
         int error;
         unsigned int free_pages;
 
-        if (!pm_ops || !pm_ops->enter)
+        if (!suspend_ops || !suspend_ops->enter)
                 return -EPERM;
 
         error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
@@ -128,7 +122,7 @@ void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
  *
  *      This function should be called after devices have been suspended.
  */
-int suspend_enter(suspend_state_t state)
+static int suspend_enter(suspend_state_t state)
 {
         int error = 0;
 
@@ -139,7 +133,7 @@ int suspend_enter(suspend_state_t state)
                 printk(KERN_ERR "Some devices failed to power down\n");
                 goto Done;
         }
-        error = pm_ops->enter(state);
+        error = suspend_ops->enter(state);
         device_power_up();
  Done:
         arch_suspend_enable_irqs();
@@ -156,11 +150,11 @@ int suspend_devices_and_enter(suspend_state_t state)
 {
         int error;
 
-        if (!pm_ops)
+        if (!suspend_ops)
                 return -ENOSYS;
 
-        if (pm_ops->set_target) {
-                error = pm_ops->set_target(state);
+        if (suspend_ops->set_target) {
+                error = suspend_ops->set_target(state);
                 if (error)
                         return error;
         }
@@ -170,8 +164,8 @@ int suspend_devices_and_enter(suspend_state_t state)
                 printk(KERN_ERR "Some devices failed to suspend\n");
                 goto Resume_console;
         }
-        if (pm_ops->prepare) {
-                error = pm_ops->prepare(state);
+        if (suspend_ops->prepare) {
+                error = suspend_ops->prepare();
                 if (error)
                         goto Resume_devices;
         }
@@ -180,7 +174,8 @@ int suspend_devices_and_enter(suspend_state_t state)
                 suspend_enter(state);
 
         enable_nonboot_cpus();
-        pm_finish(state);
+        if (suspend_ops->finish)
+                suspend_ops->finish();
  Resume_devices:
         device_resume();
  Resume_console:
@@ -214,7 +209,7 @@ static inline int valid_state(suspend_state_t state)
         /* All states need lowlevel support and need to be valid
          * to the lowlevel implementation, no valid callback
          * implies that none are valid. */
-        if (!pm_ops || !pm_ops->valid || !pm_ops->valid(state))
+        if (!suspend_ops || !suspend_ops->valid || !suspend_ops->valid(state))
                 return 0;
         return 1;
 }
@@ -236,9 +231,14 @@ static int enter_state(suspend_state_t state)
 
         if (!valid_state(state))
                 return -ENODEV;
+
         if (!mutex_trylock(&pm_mutex))
                 return -EBUSY;
 
+        printk("Syncing filesystems ... ");
+        sys_sync();
+        printk("done.\n");
+
         pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
         if ((error = suspend_prepare()))
                 goto Unlock;
diff --git a/kernel/power/power.h b/kernel/power/power.h
index 95fbf2dd3fe3..195dc4611764 100644
--- a/kernel/power/power.h
+++ b/kernel/power/power.h
@@ -11,14 +11,32 @@ struct swsusp_info {
         unsigned long           size;
 } __attribute__((aligned(PAGE_SIZE)));
 
+#ifdef CONFIG_HIBERNATION
+#ifdef CONFIG_ARCH_HIBERNATION_HEADER
+/* Maximum size of architecture specific data in a hibernation header */
+#define MAX_ARCH_HEADER_SIZE    (sizeof(struct new_utsname) + 4)
 
+extern int arch_hibernation_header_save(void *addr, unsigned int max_size);
+extern int arch_hibernation_header_restore(void *addr);
+
+static inline int init_header_complete(struct swsusp_info *info)
+{
+        return arch_hibernation_header_save(info, MAX_ARCH_HEADER_SIZE);
+}
+
+static inline char *check_image_kernel(struct swsusp_info *info)
+{
+        return arch_hibernation_header_restore(info) ?
+                        "architecture specific data" : NULL;
+}
+#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
 
-#ifdef CONFIG_HIBERNATION
 /*
  * Keep some memory free so that I/O operations can succeed without paging
  * [Might this be more than 4 MB?]
  */
 #define PAGES_FOR_IO    ((4096 * 1024) >> PAGE_SHIFT)
+
 /*
  * Keep 1 MB of memory free so that device drivers can allocate some pages in
  * their .suspend() routines without breaking the suspend to disk.
@@ -165,7 +183,6 @@ extern int swsusp_swap_in_use(void);
 extern int swsusp_check(void);
 extern int swsusp_shrink_memory(void);
 extern void swsusp_free(void);
-extern int swsusp_suspend(void);
 extern int swsusp_resume(void);
 extern int swsusp_read(unsigned int *flags_p);
 extern int swsusp_write(unsigned int flags);
diff --git a/kernel/power/process.c b/kernel/power/process.c
index 3434940a3df1..6533923e711b 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -75,21 +75,79 @@ void refrigerator(void)
         __set_current_state(save);
 }
 
-static void freeze_task(struct task_struct *p)
+static void fake_signal_wake_up(struct task_struct *p, int resume)
 {
         unsigned long flags;
 
-        if (!freezing(p)) {
+        spin_lock_irqsave(&p->sighand->siglock, flags);
+        signal_wake_up(p, resume);
+        spin_unlock_irqrestore(&p->sighand->siglock, flags);
+}
+
+static void send_fake_signal(struct task_struct *p)
+{
+        if (p->state == TASK_STOPPED)
+                force_sig_specific(SIGSTOP, p);
+        fake_signal_wake_up(p, p->state == TASK_STOPPED);
+}
+
+static int has_mm(struct task_struct *p)
+{
+        return (p->mm && !(p->flags & PF_BORROWED_MM));
+}
+
+/**
+ *      freeze_task - send a freeze request to given task
+ *      @p: task to send the request to
+ *      @with_mm_only: if set, the request will only be sent if the task has its
+ *              own mm
+ *      Return value: 0, if @with_mm_only is set and the task has no mm of its
+ *              own or the task is frozen, 1, otherwise
+ *
+ *      The freeze request is sent by seting the tasks's TIF_FREEZE flag and
+ *      either sending a fake signal to it or waking it up, depending on whether
+ *      or not it has its own mm (ie. it is a user land task).  If @with_mm_only
+ *      is set and the task has no mm of its own (ie. it is a kernel thread),
+ *      its TIF_FREEZE flag should not be set.
+ *
+ *      The task_lock() is necessary to prevent races with exit_mm() or
+ *      use_mm()/unuse_mm() from occuring.
+ */
+static int freeze_task(struct task_struct *p, int with_mm_only)
+{
+        int ret = 1;
+
+        task_lock(p);
+        if (freezing(p)) {
+                if (has_mm(p)) {
+                        if (!signal_pending(p))
+                                fake_signal_wake_up(p, 0);
+                } else {
+                        if (with_mm_only)
+                                ret = 0;
+                        else
+                                wake_up_state(p, TASK_INTERRUPTIBLE);
+                }
+        } else {
                 rmb();
-                if (!frozen(p)) {
-                        set_freeze_flag(p);
-                        if (p->state == TASK_STOPPED)
-                                force_sig_specific(SIGSTOP, p);
-                        spin_lock_irqsave(&p->sighand->siglock, flags);
-                        signal_wake_up(p, p->state == TASK_STOPPED);
-                        spin_unlock_irqrestore(&p->sighand->siglock, flags);
+                if (frozen(p)) {
+                        ret = 0;
+                } else {
+                        if (has_mm(p)) {
+                                set_freeze_flag(p);
+                                send_fake_signal(p);
+                        } else {
+                                if (with_mm_only) {
+                                        ret = 0;
+                                } else {
+                                        set_freeze_flag(p);
+                                        wake_up_state(p, TASK_INTERRUPTIBLE);
+                                }
+                        }
                 }
         }
+        task_unlock(p);
+        return ret;
 }
 
 static void cancel_freezing(struct task_struct *p)
@@ -110,6 +168,11 @@ static int try_to_freeze_tasks(int freeze_user_space)
         struct task_struct *g, *p;
         unsigned long end_time;
         unsigned int todo;
+        struct timeval start, end;
+        s64 elapsed_csecs64;
+        unsigned int elapsed_csecs;
+
+        do_gettimeofday(&start);
 
         end_time = jiffies + TIMEOUT;
         do {
@@ -119,31 +182,14 @@ static int try_to_freeze_tasks(int freeze_user_space)
                         if (frozen(p) || !freezeable(p))
                                 continue;
 
-                        if (freeze_user_space) {
-                                if (p->state == TASK_TRACED &&
-                                    frozen(p->parent)) {
-                                        cancel_freezing(p);
-                                        continue;
-                                }
-                                /*
-                                 * Kernel threads should not have TIF_FREEZE set
-                                 * at this point, so we must ensure that either
-                                 * p->mm is not NULL *and* PF_BORROWED_MM is
-                                 * unset, or TIF_FRREZE is left unset.
-                                 * The task_lock() is necessary to prevent races
-                                 * with exit_mm() or use_mm()/unuse_mm() from
-                                 * occuring.
-                                 */
-                                task_lock(p);
-                                if (!p->mm || (p->flags & PF_BORROWED_MM)) {
-                                        task_unlock(p);
-                                        continue;
-                                }
-                                freeze_task(p);
-                                task_unlock(p);
-                        } else {
-                                freeze_task(p);
+                        if (p->state == TASK_TRACED && frozen(p->parent)) {
+                                cancel_freezing(p);
+                                continue;
                         }
+
+                        if (!freeze_task(p, freeze_user_space))
+                                continue;
+
                         if (!freezer_should_skip(p))
                                 todo++;
                 } while_each_thread(g, p);
@@ -153,6 +199,11 @@ static int try_to_freeze_tasks(int freeze_user_space)
                         break;
         } while (todo);
 
+        do_gettimeofday(&end);
+        elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
+        do_div(elapsed_csecs64, NSEC_PER_SEC / 100);
+        elapsed_csecs = elapsed_csecs64;
+
         if (todo) {
                 /* This does not unfreeze processes that are already frozen
                  * (we have slightly ugly calling convention in that respect,
@@ -160,10 +211,9 @@ static int try_to_freeze_tasks(int freeze_user_space)
                  * but it cleans up leftover PF_FREEZE requests.
                  */
                 printk("\n");
-                printk(KERN_ERR "Freezing of %s timed out after %d seconds "
+                printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
                                 "(%d tasks refusing to freeze):\n",
-                                freeze_user_space ? "user space " : "tasks ",
-                                TIMEOUT / HZ, todo);
+                                elapsed_csecs / 100, elapsed_csecs % 100, todo);
                 show_state();
                 read_lock(&tasklist_lock);
                 do_each_thread(g, p) {
@@ -174,6 +224,9 @@ static int try_to_freeze_tasks(int freeze_user_space)
                         task_unlock(p);
                 } while_each_thread(g, p);
                 read_unlock(&tasklist_lock);
+        } else {
+                printk("(elapsed %d.%02d seconds) ", elapsed_csecs / 100,
+                        elapsed_csecs % 100);
         }
 
         return todo ? -EBUSY : 0;
@@ -186,19 +239,21 @@ int freeze_processes(void)
 {
         int error;
 
-        printk("Stopping tasks ... ");
+        printk("Freezing user space processes ... ");
         error = try_to_freeze_tasks(FREEZER_USER_SPACE);
         if (error)
-                return error;
+                goto Exit;
+        printk("done.\n");
 
-        sys_sync();
+        printk("Freezing remaining freezable tasks ... ");
         error = try_to_freeze_tasks(FREEZER_KERNEL_THREADS);
         if (error)
-                return error;
-
-        printk("done.\n");
+                goto Exit;
+        printk("done.");
+ Exit:
         BUG_ON(in_atomic());
-        return 0;
+        printk("\n");
+        return error;
 }
 
 static void thaw_tasks(int thaw_user_space)
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index a686590d88c1..ccc95ac07bed 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -1239,17 +1239,39 @@ asmlinkage int swsusp_save(void)
         return 0;
 }
 
-static void init_header(struct swsusp_info *info)
+#ifndef CONFIG_ARCH_HIBERNATION_HEADER
+static int init_header_complete(struct swsusp_info *info)
 {
-        memset(info, 0, sizeof(struct swsusp_info));
+        memcpy(&info->uts, init_utsname(), sizeof(struct new_utsname));
         info->version_code = LINUX_VERSION_CODE;
+        return 0;
+}
+
+static char *check_image_kernel(struct swsusp_info *info)
+{
+        if (info->version_code != LINUX_VERSION_CODE)
+                return "kernel version";
+        if (strcmp(info->uts.sysname,init_utsname()->sysname))
+                return "system type";
+        if (strcmp(info->uts.release,init_utsname()->release))
+                return "kernel release";
+        if (strcmp(info->uts.version,init_utsname()->version))
+                return "version";
+        if (strcmp(info->uts.machine,init_utsname()->machine))
+                return "machine";
+        return NULL;
+}
+#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
+
+static int init_header(struct swsusp_info *info)
+{
+        memset(info, 0, sizeof(struct swsusp_info));
         info->num_physpages = num_physpages;
-        memcpy(&info->uts, init_utsname(), sizeof(struct new_utsname));
-        info->cpus = num_online_cpus();
         info->image_pages = nr_copy_pages;
         info->pages = nr_copy_pages + nr_meta_pages + 1;
         info->size = info->pages;
         info->size <<= PAGE_SHIFT;
+        return init_header_complete(info);
 }
 
 /**
@@ -1303,7 +1325,11 @@ int snapshot_read_next(struct snapshot_handle *handle, size_t count)
                         return -ENOMEM;
         }
         if (!handle->offset) {
-                init_header((struct swsusp_info *)buffer);
+                int error;
+
+                error = init_header((struct swsusp_info *)buffer);
+                if (error)
+                        return error;
                 handle->buffer = buffer;
                 memory_bm_position_reset(&orig_bm);
                 memory_bm_position_reset(&copy_bm);
@@ -1394,22 +1420,13 @@ duplicate_memory_bitmap(struct memory_bitmap *dst, struct memory_bitmap *src)
         }
 }
 
-static inline int check_header(struct swsusp_info *info)
+static int check_header(struct swsusp_info *info)
 {
-        char *reason = NULL;
+        char *reason;
 
-        if (info->version_code != LINUX_VERSION_CODE)
-                reason = "kernel version";
-        if (info->num_physpages != num_physpages)
+        reason = check_image_kernel(info);
+        if (!reason && info->num_physpages != num_physpages)
                 reason = "memory size";
-        if (strcmp(info->uts.sysname,init_utsname()->sysname))
-                reason = "system type";
-        if (strcmp(info->uts.release,init_utsname()->release))
-                reason = "kernel release";
-        if (strcmp(info->uts.version,init_utsname()->version))
-                reason = "version";
-        if (strcmp(info->uts.machine,init_utsname()->machine))
-                reason = "machine";
         if (reason) {
                 printk(KERN_ERR "swsusp: Resume mismatch: %s\n", reason);
                 return -EPERM;
diff --git a/kernel/power/swsusp.c b/kernel/power/swsusp.c
index 5da304c8f1f6..e1722d3155f1 100644
--- a/kernel/power/swsusp.c
+++ b/kernel/power/swsusp.c
@@ -270,39 +270,6 @@ int swsusp_shrink_memory(void)
         return 0;
 }
 
-int swsusp_suspend(void)
-{
-        int error;
-
-        if ((error = arch_prepare_suspend()))
-                return error;
-
-        local_irq_disable();
-        /* At this point, device_suspend() has been called, but *not*
-         * device_power_down(). We *must* device_power_down() now.
-         * Otherwise, drivers for some devices (e.g. interrupt controllers)
-         * become desynchronized with the actual state of the hardware
-         * at resume time, and evil weirdness ensues.
-         */
-        if ((error = device_power_down(PMSG_FREEZE))) {
-                printk(KERN_ERR "Some devices failed to power down, aborting suspend\n");
-                goto Enable_irqs;
-        }
-
-        save_processor_state();
-        if ((error = swsusp_arch_suspend()))
-                printk(KERN_ERR "Error %d suspending\n", error);
-        /* Restore control flow magically appears here */
-        restore_processor_state();
-        /* NOTE:  device_power_up() is just a resume() for devices
-         * that suspended with irqs off ... no overall powerup.
-         */
-        device_power_up();
- Enable_irqs:
-        local_irq_enable();
-        return error;
-}
-
 int swsusp_resume(void)
 {
         int error;
diff --git a/kernel/power/user.c b/kernel/power/user.c
index bd0723a7df3f..5bd321bcbb75 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -153,6 +153,10 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 mutex_lock(&pm_mutex);
                 error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
                 if (!error) {
+                        printk("Syncing filesystems ... ");
+                        sys_sync();
+                        printk("done.\n");
+
                         error = freeze_processes();
                         if (error)
                                 thaw_processes();
diff --git a/kernel/printk.c b/kernel/printk.c
index 52493474f0ab..a30fe33de395 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -862,7 +862,16 @@ int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, cha
         return -1;
 }
 
-#ifndef CONFIG_DISABLE_CONSOLE_SUSPEND
+int console_suspend_enabled = 1;
+EXPORT_SYMBOL(console_suspend_enabled);
+
+static int __init console_suspend_disable(char *str)
+{
+        console_suspend_enabled = 0;
+        return 1;
+}
+__setup("no_console_suspend", console_suspend_disable);
+
 /**
  * suspend_console - suspend the console subsystem
  *
@@ -870,6 +879,8 @@ int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, cha
  */
 void suspend_console(void)
 {
+        if (!console_suspend_enabled)
+                return;
         printk("Suspending console(s)\n");
         acquire_console_sem();
         console_suspended = 1;
@@ -877,10 +888,11 @@ void suspend_console(void)
 
 void resume_console(void)
 {
+        if (!console_suspend_enabled)
+                return;
         console_suspended = 0;
         release_console_sem();
 }
-#endif /* CONFIG_DISABLE_CONSOLE_SUSPEND */
 
 /**
  * acquire_console_sem - lock the console system for exclusive use.
diff --git a/kernel/relay.c b/kernel/relay.c
index ad855017bc59..61134eb7a0c8 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -370,7 +370,7 @@ void relay_reset(struct rchan *chan)
         if (!chan)
                 return;
 
-        if (chan->is_global && chan->buf[0]) {
+        if (chan->is_global && chan->buf[0]) {
                 __relay_reset(chan->buf[0], 0);
                 return;
         }
@@ -850,13 +850,13 @@ static int relay_file_read_avail(struct rchan_buf *buf, size_t read_pos)
                 buf->subbufs_consumed = consumed;
                 buf->bytes_consumed = 0;
         }
-        
+
         produced = (produced % n_subbufs) * subbuf_size + buf->offset;
         consumed = (consumed % n_subbufs) * subbuf_size + buf->bytes_consumed;
 
         if (consumed > produced)
                 produced += n_subbufs * subbuf_size;
-        
+
         if (consumed == produced)
                 return 0;
 
diff --git a/kernel/sched.c b/kernel/sched.c
index 92721d1534b8..ed90be46fb31 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -266,7 +266,8 @@ struct rt_rq {
  * acquire operations must be ordered by ascending &runqueue.
  */
 struct rq {
-        spinlock_t lock;        /* runqueue lock */
+        /* runqueue lock: */
+        spinlock_t lock;
 
         /*
          * nr_running and cpu_load should be in the same cacheline because
@@ -279,13 +280,15 @@ struct rq {
 #ifdef CONFIG_NO_HZ
         unsigned char in_nohz_recently;
 #endif
-        struct load_weight load;        /* capture load from *all* tasks on this cpu */
+        /* capture load from *all* tasks on this cpu: */
+        struct load_weight load;
         unsigned long nr_load_updates;
         u64 nr_switches;
 
         struct cfs_rq cfs;
 #ifdef CONFIG_FAIR_GROUP_SCHED
-        struct list_head leaf_cfs_rq_list; /* list of leaf cfs_rq on this cpu */
+        /* list of leaf cfs_rq on this cpu: */
+        struct list_head leaf_cfs_rq_list;
 #endif
         struct rt_rq  rt;
 
@@ -317,7 +320,8 @@ struct rq {
         /* For active balancing */
         int active_balance;
         int push_cpu;
-        int cpu;                /* cpu of this runqueue */
+        /* cpu of this runqueue: */
+        int cpu;
 
         struct task_struct *migration_thread;
         struct list_head migration_queue;
@@ -328,22 +332,22 @@ struct rq {
         struct sched_info rq_sched_info;
 
         /* sys_sched_yield() stats */
-        unsigned long yld_exp_empty;
-        unsigned long yld_act_empty;
-        unsigned long yld_both_empty;
-        unsigned long yld_count;
+        unsigned int yld_exp_empty;
+        unsigned int yld_act_empty;
+        unsigned int yld_both_empty;
+        unsigned int yld_count;
 
         /* schedule() stats */
-        unsigned long sched_switch;
-        unsigned long sched_count;
-        unsigned long sched_goidle;
+        unsigned int sched_switch;
+        unsigned int sched_count;
+        unsigned int sched_goidle;
 
         /* try_to_wake_up() stats */
-        unsigned long ttwu_count;
-        unsigned long ttwu_local;
+        unsigned int ttwu_count;
+        unsigned int ttwu_local;
 
         /* BKL stats */
-        unsigned long bkl_count;
+        unsigned int bkl_count;
 #endif
         struct lock_class_key rq_lock_key;
 };
@@ -449,12 +453,12 @@ enum {
 };
 
 const_debug unsigned int sysctl_sched_features =
-                SCHED_FEAT_NEW_FAIR_SLEEPERS    *1 |
-                SCHED_FEAT_START_DEBIT          *1 |
-                SCHED_FEAT_TREE_AVG             *0 |
-                SCHED_FEAT_APPROX_AVG           *0 |
-                SCHED_FEAT_WAKEUP_PREEMPT       *1 |
-                SCHED_FEAT_PREEMPT_RESTRICT     *1;
+                SCHED_FEAT_NEW_FAIR_SLEEPERS    * 1 |
+                SCHED_FEAT_START_DEBIT          * 1 |
+                SCHED_FEAT_TREE_AVG             * 0 |
+                SCHED_FEAT_APPROX_AVG           * 0 |
+                SCHED_FEAT_WAKEUP_PREEMPT       * 1 |
+                SCHED_FEAT_PREEMPT_RESTRICT     * 1;
 
 #define sched_feat(x) (sysctl_sched_features & SCHED_FEAT_##x)
 
@@ -3334,6 +3338,16 @@ void account_guest_time(struct task_struct *p, cputime_t cputime)
 }
 
 /*
+ * Account scaled user cpu time to a process.
+ * @p: the process that the cpu time gets accounted to
+ * @cputime: the cpu time spent in user space since the last update
+ */
+void account_user_time_scaled(struct task_struct *p, cputime_t cputime)
+{
+        p->utimescaled = cputime_add(p->utimescaled, cputime);
+}
+
+/*
  * Account system cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @hardirq_offset: the offset to subtract from hardirq_count()
@@ -3371,6 +3385,17 @@ void account_system_time(struct task_struct *p, int hardirq_offset,
 }
 
 /*
+ * Account scaled system cpu time to a process.
+ * @p: the process that the cpu time gets accounted to
+ * @hardirq_offset: the offset to subtract from hardirq_count()
+ * @cputime: the cpu time spent in kernel space since the last update
+ */
+void account_system_time_scaled(struct task_struct *p, cputime_t cputime)
+{
+        p->stimescaled = cputime_add(p->stimescaled, cputime);
+}
+
+/*
  * Account for involuntary wait time.
  * @p: the process from which the cpu time has been stolen
  * @steal: the cpu time spent in involuntary wait
@@ -3859,7 +3884,10 @@ EXPORT_SYMBOL(wait_for_completion_timeout);
 
 int __sched wait_for_completion_interruptible(struct completion *x)
 {
-        return wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
+        long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
+        if (t == -ERESTARTSYS)
+                return t;
+        return 0;
 }
 EXPORT_SYMBOL(wait_for_completion_interruptible);
 
@@ -4794,18 +4822,18 @@ static void show_task(struct task_struct *p)
         unsigned state;
 
         state = p->state ? __ffs(p->state) + 1 : 0;
-        printk("%-13.13s %c", p->comm,
+        printk(KERN_INFO "%-13.13s %c", p->comm,
                 state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
 #if BITS_PER_LONG == 32
         if (state == TASK_RUNNING)
-                printk(" running  ");
+                printk(KERN_CONT " running  ");
         else
-                printk(" %08lx ", thread_saved_pc(p));
+                printk(KERN_CONT " %08lx ", thread_saved_pc(p));
 #else
         if (state == TASK_RUNNING)
-                printk("  running task    ");
+                printk(KERN_CONT "  running task    ");
         else
-                printk(" %016lx ", thread_saved_pc(p));
+                printk(KERN_CONT " %016lx ", thread_saved_pc(p));
 #endif
 #ifdef CONFIG_DEBUG_STACK_USAGE
         {
@@ -4815,7 +4843,7 @@ static void show_task(struct task_struct *p)
                 free = (unsigned long)n - (unsigned long)end_of_stack(p);
         }
 #endif
-        printk("%5lu %5d %6d\n", free, p->pid, p->parent->pid);
+        printk(KERN_CONT "%5lu %5d %6d\n", free, p->pid, p->parent->pid);
 
         if (state != TASK_RUNNING)
                 show_stack(p, NULL);
@@ -5364,7 +5392,7 @@ sd_alloc_ctl_domain_table(struct sched_domain *sd)
         return table;
 }
 
-static ctl_table *sd_alloc_ctl_cpu_table(int cpu)
+static ctl_table * sd_alloc_ctl_cpu_table(int cpu)
 {
         struct ctl_table *entry, *table;
         struct sched_domain *sd;
@@ -5598,20 +5626,20 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
                         }
 
                         if (!group->__cpu_power) {
-                                printk("\n");
+                                printk(KERN_CONT "\n");
                                 printk(KERN_ERR "ERROR: domain->cpu_power not "
                                                 "set\n");
                                 break;
                         }
 
                         if (!cpus_weight(group->cpumask)) {
-                                printk("\n");
+                                printk(KERN_CONT "\n");
                                 printk(KERN_ERR "ERROR: empty group\n");
                                 break;
                         }
 
                         if (cpus_intersects(groupmask, group->cpumask)) {
-                                printk("\n");
+                                printk(KERN_CONT "\n");
                                 printk(KERN_ERR "ERROR: repeated CPUs\n");
                                 break;
                         }
@@ -5619,11 +5647,11 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
                         cpus_or(groupmask, groupmask, group->cpumask);
 
                         cpumask_scnprintf(str, NR_CPUS, group->cpumask);
-                        printk(" %s", str);
+                        printk(KERN_CONT " %s", str);
 
                         group = group->next;
                 } while (group != sd->groups);
-                printk("\n");
+                printk(KERN_CONT "\n");
 
                 if (!cpus_equal(sd->span, groupmask))
                         printk(KERN_ERR "ERROR: groups don't span "
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index a5e517ec07c3..e6fb392e5164 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -137,7 +137,7 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
         SEQ_printf(m, "  .%-30s: %ld\n", "nr_running", cfs_rq->nr_running);
         SEQ_printf(m, "  .%-30s: %ld\n", "load", cfs_rq->load.weight);
 #ifdef CONFIG_SCHEDSTATS
-        SEQ_printf(m, "  .%-30s: %ld\n", "bkl_count",
+        SEQ_printf(m, "  .%-30s: %d\n", "bkl_count",
                         rq->bkl_count);
 #endif
         SEQ_printf(m, "  .%-30s: %ld\n", "nr_spread_over",
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index 1c084842c3e7..ef1a7df80ea2 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -21,7 +21,7 @@ static int show_schedstat(struct seq_file *seq, void *v)
 
                 /* runqueue-specific stats */
                 seq_printf(seq,
-                    "cpu%d %lu %lu %lu %lu %lu %lu %lu %lu %lu %llu %llu %lu",
+                    "cpu%d %u %u %u %u %u %u %u %u %u %llu %llu %lu",
                     cpu, rq->yld_both_empty,
                     rq->yld_act_empty, rq->yld_exp_empty, rq->yld_count,
                     rq->sched_switch, rq->sched_count, rq->sched_goidle,
@@ -42,8 +42,7 @@ static int show_schedstat(struct seq_file *seq, void *v)
                         seq_printf(seq, "domain%d %s", dcount++, mask_str);
                         for (itype = CPU_IDLE; itype < CPU_MAX_IDLE_TYPES;
                                         itype++) {
-                                seq_printf(seq, " %lu %lu %lu %lu %lu %lu %lu "
-                                                "%lu",
+                                seq_printf(seq, " %u %u %u %u %u %u %u %u",
                                     sd->lb_count[itype],
                                     sd->lb_balanced[itype],
                                     sd->lb_failed[itype],
@@ -53,8 +52,7 @@ static int show_schedstat(struct seq_file *seq, void *v)
                                     sd->lb_nobusyq[itype],
                                     sd->lb_nobusyg[itype]);
                         }
-                        seq_printf(seq, " %lu %lu %lu %lu %lu %lu %lu %lu %lu"
-                            " %lu %lu %lu\n",
+                        seq_printf(seq, " %u %u %u %u %u %u %u %u %u %u %u %u\n",
                             sd->alb_count, sd->alb_failed, sd->alb_pushed,
                             sd->sbe_count, sd->sbe_balanced, sd->sbe_pushed,
                             sd->sbf_count, sd->sbf_balanced, sd->sbf_pushed,
diff --git a/kernel/signal.c b/kernel/signal.c
index 2124ffadcfde..e4f059cd9867 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -99,7 +99,6 @@ static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
 static int recalc_sigpending_tsk(struct task_struct *t)
 {
         if (t->signal->group_stop_count > 0 ||
-            (freezing(t)) ||
             PENDING(&t->pending, &t->blocked) ||
             PENDING(&t->signal->shared_pending, &t->blocked)) {
                 set_tsk_thread_flag(t, TIF_SIGPENDING);
diff --git a/kernel/sys.c b/kernel/sys.c
index 8ae2e636eb1b..bc8879c822a5 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -105,7 +105,6 @@ EXPORT_SYMBOL(cad_pid);
  */
 
 void (*pm_power_off_prepare)(void);
-EXPORT_SYMBOL(pm_power_off_prepare);
 
 /*
  *      Notifier list for kernel code which wants to be called
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index dde3d53e8adc..067554bda8b7 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -24,7 +24,7 @@
 #include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
-#include <linux/capability.h>
+#include <linux/security.h>
 #include <linux/ctype.h>
 #include <linux/utsname.h>
 #include <linux/smp_lock.h>
@@ -55,6 +55,8 @@
 #include <asm/stacktrace.h>
 #endif
 
+static int deprecated_sysctl_warning(struct __sysctl_args *args);
+
 #if defined(CONFIG_SYSCTL)
 
 /* External variables not in a header file. */
@@ -142,32 +144,29 @@ extern int max_lock_depth;
 
 #ifdef CONFIG_SYSCTL_SYSCALL
 static int parse_table(int __user *, int, void __user *, size_t __user *,
-                void __user *, size_t, ctl_table *);
+                void __user *, size_t, struct ctl_table *);
 #endif
 
 
 #ifdef CONFIG_PROC_SYSCTL
-static int proc_do_cad_pid(ctl_table *table, int write, struct file *filp,
+static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos);
-static int proc_dointvec_taint(ctl_table *table, int write, struct file *filp,
+static int proc_dointvec_taint(struct ctl_table *table, int write, struct file *filp,
                                void __user *buffer, size_t *lenp, loff_t *ppos);
 #endif
 
-static ctl_table root_table[];
+static struct ctl_table root_table[];
 static struct ctl_table_header root_table_header =
         { root_table, LIST_HEAD_INIT(root_table_header.ctl_entry) };
 
-static ctl_table kern_table[];
-static ctl_table vm_table[];
-static ctl_table fs_table[];
-static ctl_table debug_table[];
-static ctl_table dev_table[];
-extern ctl_table random_table[];
-#ifdef CONFIG_UNIX98_PTYS
-extern ctl_table pty_table[];
-#endif
+static struct ctl_table kern_table[];
+static struct ctl_table vm_table[];
+static struct ctl_table fs_table[];
+static struct ctl_table debug_table[];
+static struct ctl_table dev_table[];
+extern struct ctl_table random_table[];
 #ifdef CONFIG_INOTIFY_USER
-extern ctl_table inotify_table[];
+extern struct ctl_table inotify_table[];
 #endif
 
 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
@@ -179,7 +178,7 @@ extern int lock_stat;
 
 /* The default sysctl tables: */
 
-static ctl_table root_table[] = {
+static struct ctl_table root_table[] = {
         {
                 .ctl_name       = CTL_KERN,
                 .procname       = "kernel",
@@ -232,7 +231,7 @@ static unsigned long min_wakeup_granularity_ns;			/* 0 usecs */
 static unsigned long max_wakeup_granularity_ns = 1000000000;    /* 1 second */
 #endif
 
-static ctl_table kern_table[] = {
+static struct ctl_table kern_table[] = {
 #ifdef CONFIG_SCHED_DEBUG
         {
                 .ctl_name       = CTL_UNNUMBERED,
@@ -365,7 +364,6 @@ static ctl_table kern_table[] = {
         },
 #ifdef CONFIG_PROC_SYSCTL
         {
-                .ctl_name       = KERN_TAINTED,
                 .procname       = "tainted",
                 .data           = &tainted,
                 .maxlen         = sizeof(int),
@@ -373,14 +371,15 @@ static ctl_table kern_table[] = {
                 .proc_handler   = &proc_dointvec_taint,
         },
 #endif
+#ifdef CONFIG_SECURITY_CAPABILITIES
         {
-                .ctl_name       = KERN_CAP_BSET,
                 .procname       = "cap-bound",
                 .data           = &cap_bset,
                 .maxlen         = sizeof(kernel_cap_t),
                 .mode           = 0600,
                 .proc_handler   = &proc_dointvec_bset,
         },
+#endif /* def CONFIG_SECURITY_CAPABILITIES */
 #ifdef CONFIG_BLK_DEV_INITRD
         {
                 .ctl_name       = KERN_REALROOTDEV,
@@ -514,7 +513,6 @@ static ctl_table kern_table[] = {
 #endif
 #ifdef CONFIG_PROC_SYSCTL
         {
-                .ctl_name       = KERN_CADPID,
                 .procname       = "cad_pid",
                 .data           = NULL,
                 .maxlen         = sizeof (int),
@@ -536,14 +534,6 @@ static ctl_table kern_table[] = {
                 .mode           = 0555,
                 .child          = random_table,
         },
-#ifdef CONFIG_UNIX98_PTYS
-        {
-                .ctl_name       = KERN_PTY,
-                .procname       = "pty",
-                .mode           = 0555,
-                .child          = pty_table,
-        },
-#endif
         {
                 .ctl_name       = KERN_OVERFLOWUID,
                 .procname       = "overflowuid",
@@ -650,7 +640,6 @@ static ctl_table kern_table[] = {
                 .proc_handler   = &proc_dointvec,
         },
         {
-                .ctl_name       = KERN_NMI_WATCHDOG,
                 .procname       = "nmi_watchdog",
                 .data           = &nmi_watchdog_enabled,
                 .maxlen         = sizeof (int),
@@ -706,7 +695,6 @@ static ctl_table kern_table[] = {
 #endif
 #if     defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
         {
-                .ctl_name       = KERN_ACPI_VIDEO_FLAGS,
                 .procname       = "acpi_video_flags",
                 .data           = &acpi_realmode_flags,
                 .maxlen         = sizeof (unsigned long),
@@ -783,7 +771,7 @@ static ctl_table kern_table[] = {
         { .ctl_name = 0 }
 };
 
-static ctl_table vm_table[] = {
+static struct ctl_table vm_table[] = {
         {
                 .ctl_name       = VM_OVERCOMMIT_MEMORY,
                 .procname       = "overcommit_memory",
@@ -847,7 +835,6 @@ static ctl_table vm_table[] = {
                 .extra2         = &one_hundred,
         },
         {
-                .ctl_name       = VM_DIRTY_WB_CS,
                 .procname       = "dirty_writeback_centisecs",
                 .data           = &dirty_writeback_interval,
                 .maxlen         = sizeof(dirty_writeback_interval),
@@ -855,7 +842,6 @@ static ctl_table vm_table[] = {
                 .proc_handler   = &dirty_writeback_centisecs_handler,
         },
         {
-                .ctl_name       = VM_DIRTY_EXPIRE_CS,
                 .procname       = "dirty_expire_centisecs",
                 .data           = &dirty_expire_interval,
                 .maxlen         = sizeof(dirty_expire_interval),
@@ -883,7 +869,6 @@ static ctl_table vm_table[] = {
         },
 #ifdef CONFIG_HUGETLB_PAGE
          {
-                .ctl_name       = VM_HUGETLB_PAGES,
                 .procname       = "nr_hugepages",
                 .data           = &max_huge_pages,
                 .maxlen         = sizeof(unsigned long),
@@ -1093,12 +1078,12 @@ static ctl_table vm_table[] = {
 };
 
 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
-static ctl_table binfmt_misc_table[] = {
+static struct ctl_table binfmt_misc_table[] = {
         { .ctl_name = 0 }
 };
 #endif
 
-static ctl_table fs_table[] = {
+static struct ctl_table fs_table[] = {
         {
                 .ctl_name       = FS_NRINODE,
                 .procname       = "inode-nr",
@@ -1116,7 +1101,6 @@ static ctl_table fs_table[] = {
                 .proc_handler   = &proc_dointvec,
         },
         {
-                .ctl_name       = FS_NRFILE,
                 .procname       = "file-nr",
                 .data           = &files_stat,
                 .maxlen         = 3*sizeof(int),
@@ -1192,7 +1176,6 @@ static ctl_table fs_table[] = {
                 .extra2         = &two,
         },
         {
-                .ctl_name       = FS_AIO_NR,
                 .procname       = "aio-nr",
                 .data           = &aio_nr,
                 .maxlen         = sizeof(aio_nr),
@@ -1200,7 +1183,6 @@ static ctl_table fs_table[] = {
                 .proc_handler   = &proc_doulongvec_minmax,
         },
         {
-                .ctl_name       = FS_AIO_MAX_NR,
                 .procname       = "aio-max-nr",
                 .data           = &aio_max_nr,
                 .maxlen         = sizeof(aio_max_nr),
@@ -1239,7 +1221,7 @@ static ctl_table fs_table[] = {
         { .ctl_name = 0 }
 };
 
-static ctl_table debug_table[] = {
+static struct ctl_table debug_table[] = {
 #if defined(CONFIG_X86) || defined(CONFIG_PPC)
         {
                 .ctl_name       = CTL_UNNUMBERED,
@@ -1253,7 +1235,7 @@ static ctl_table debug_table[] = {
         { .ctl_name = 0 }
 };
 
-static ctl_table dev_table[] = {
+static struct ctl_table dev_table[] = {
         { .ctl_name = 0 }
 };
 
@@ -1369,10 +1351,15 @@ asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
         if (copy_from_user(&tmp, args, sizeof(tmp)))
                 return -EFAULT;
 
+        error = deprecated_sysctl_warning(&tmp);
+        if (error)
+                goto out;
+
         lock_kernel();
         error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
                           tmp.newval, tmp.newlen);
         unlock_kernel();
+out:
         return error;
 }
 #endif /* CONFIG_SYSCTL_SYSCALL */
@@ -1393,7 +1380,7 @@ static int test_perm(int mode, int op)
         return -EACCES;
 }
 
-int sysctl_perm(ctl_table *table, int op)
+int sysctl_perm(struct ctl_table *table, int op)
 {
         int error;
         error = security_sysctl(table, op);
@@ -1406,7 +1393,7 @@ int sysctl_perm(ctl_table *table, int op)
 static int parse_table(int __user *name, int nlen,
                        void __user *oldval, size_t __user *oldlenp,
                        void __user *newval, size_t newlen,
-                       ctl_table *table)
+                       struct ctl_table *table)
 {
         int n;
 repeat:
@@ -1437,13 +1424,12 @@ repeat:
 }
 
 /* Perform the actual read/write of a sysctl table entry. */
-int do_sysctl_strategy (ctl_table *table, 
+int do_sysctl_strategy (struct ctl_table *table,
                         int __user *name, int nlen,
                         void __user *oldval, size_t __user *oldlenp,
                         void __user *newval, size_t newlen)
 {
         int op = 0, rc;
-        size_t len;
 
         if (oldval)
                 op |= 004;
@@ -1464,25 +1450,10 @@ int do_sysctl_strategy (ctl_table *table,
         /* If there is no strategy routine, or if the strategy returns
          * zero, proceed with automatic r/w */
         if (table->data && table->maxlen) {
-                if (oldval && oldlenp) {
-                        if (get_user(len, oldlenp))
-                                return -EFAULT;
-                        if (len) {
-                                if (len > table->maxlen)
-                                        len = table->maxlen;
-                                if(copy_to_user(oldval, table->data, len))
-                                        return -EFAULT;
-                                if(put_user(len, oldlenp))
-                                        return -EFAULT;
-                        }
-                }
-                if (newval && newlen) {
-                        len = newlen;
-                        if (len > table->maxlen)
-                                len = table->maxlen;
-                        if(copy_from_user(table->data, newval, len))
-                                return -EFAULT;
-                }
+                rc = sysctl_data(table, name, nlen, oldval, oldlenp,
+                                 newval, newlen);
+                if (rc < 0)
+                        return rc;
         }
         return 0;
 }
@@ -1499,7 +1470,9 @@ static void sysctl_set_parent(struct ctl_table *parent, struct ctl_table *table)
 
 static __init int sysctl_init(void)
 {
+        int err;
         sysctl_set_parent(NULL, root_table);
+        err = sysctl_check_table(root_table);
         return 0;
 }
 
@@ -1512,7 +1485,7 @@ core_initcall(sysctl_init);
  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
  * array. An entry with a ctl_name of 0 terminates the table. 
  *
- * The members of the &ctl_table structure are used as follows:
+ * The members of the &struct ctl_table structure are used as follows:
  *
  * ctl_name - This is the numeric sysctl value used by sysctl(2). The number
  *            must be unique within that level of sysctl
@@ -1573,7 +1546,7 @@ core_initcall(sysctl_init);
  * This routine returns %NULL on a failure to register, and a pointer
  * to the table header on success.
  */
-struct ctl_table_header *register_sysctl_table(ctl_table * table)
+struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
 {
         struct ctl_table_header *tmp;
         tmp = kmalloc(sizeof(struct ctl_table_header), GFP_KERNEL);
@@ -1584,6 +1557,10 @@ struct ctl_table_header *register_sysctl_table(ctl_table * table)
         tmp->used = 0;
         tmp->unregistering = NULL;
         sysctl_set_parent(NULL, table);
+        if (sysctl_check_table(tmp->ctl_table)) {
+                kfree(tmp);
+                return NULL;
+        }
         spin_lock(&sysctl_lock);
         list_add_tail(&tmp->ctl_entry, &root_table_header.ctl_entry);
         spin_unlock(&sysctl_lock);
@@ -1607,7 +1584,7 @@ void unregister_sysctl_table(struct ctl_table_header * header)
 }
 
 #else /* !CONFIG_SYSCTL */
-struct ctl_table_header *register_sysctl_table(ctl_table * table)
+struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
 {
         return NULL;
 }
@@ -1700,7 +1677,7 @@ static int _proc_do_string(void* data, int maxlen, int write,
  *
  * Returns 0 on success.
  */
-int proc_dostring(ctl_table *table, int write, struct file *filp,
+int proc_dostring(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return _proc_do_string(table->data, table->maxlen, write, filp,
@@ -1727,7 +1704,7 @@ static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
         return 0;
 }
 
-static int __do_proc_dointvec(void *tbl_data, ctl_table *table,
+static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
                   int write, struct file *filp, void __user *buffer,
                   size_t *lenp, loff_t *ppos,
                   int (*conv)(int *negp, unsigned long *lvalp, int *valp,
@@ -1837,7 +1814,7 @@ static int __do_proc_dointvec(void *tbl_data, ctl_table *table,
 #undef TMPBUFLEN
 }
 
-static int do_proc_dointvec(ctl_table *table, int write, struct file *filp,
+static int do_proc_dointvec(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos,
                   int (*conv)(int *negp, unsigned long *lvalp, int *valp,
                               int write, void *data),
@@ -1861,7 +1838,7 @@ static int do_proc_dointvec(ctl_table *table, int write, struct file *filp,
  *
  * Returns 0 on success.
  */
-int proc_dointvec(ctl_table *table, int write, struct file *filp,
+int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
                      void __user *buffer, size_t *lenp, loff_t *ppos)
 {
     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
@@ -1897,11 +1874,12 @@ static int do_proc_dointvec_bset_conv(int *negp, unsigned long *lvalp,
         return 0;
 }
 
+#ifdef CONFIG_SECURITY_CAPABILITIES
 /*
  *      init may raise the set.
  */
- 
-int proc_dointvec_bset(ctl_table *table, int write, struct file *filp,
+
+int proc_dointvec_bset(struct ctl_table *table, int write, struct file *filp,
                         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         int op;
@@ -1914,11 +1892,12 @@ int proc_dointvec_bset(ctl_table *table, int write, struct file *filp,
         return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
                                 do_proc_dointvec_bset_conv,&op);
 }
+#endif /* def CONFIG_SECURITY_CAPABILITIES */
 
 /*
  *      Taint values can only be increased
  */
-static int proc_dointvec_taint(ctl_table *table, int write, struct file *filp,
+static int proc_dointvec_taint(struct ctl_table *table, int write, struct file *filp,
                                void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         int op;
@@ -1977,7 +1956,7 @@ static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp,
  *
  * Returns 0 on success.
  */
-int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct do_proc_dointvec_minmax_conv_param param = {
@@ -1988,7 +1967,7 @@ int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
                                 do_proc_dointvec_minmax_conv, &param);
 }
 
-static int __do_proc_doulongvec_minmax(void *data, ctl_table *table, int write,
+static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
                                      struct file *filp,
                                      void __user *buffer,
                                      size_t *lenp, loff_t *ppos,
@@ -2093,7 +2072,7 @@ static int __do_proc_doulongvec_minmax(void *data, ctl_table *table, int write,
 #undef TMPBUFLEN
 }
 
-static int do_proc_doulongvec_minmax(ctl_table *table, int write,
+static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
                                      struct file *filp,
                                      void __user *buffer,
                                      size_t *lenp, loff_t *ppos,
@@ -2121,7 +2100,7 @@ static int do_proc_doulongvec_minmax(ctl_table *table, int write,
  *
  * Returns 0 on success.
  */
-int proc_doulongvec_minmax(ctl_table *table, int write, struct file *filp,
+int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp,
                            void __user *buffer, size_t *lenp, loff_t *ppos)
 {
     return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l);
@@ -2145,7 +2124,7 @@ int proc_doulongvec_minmax(ctl_table *table, int write, struct file *filp,
  *
  * Returns 0 on success.
  */
-int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int write,
+int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
                                       struct file *filp,
                                       void __user *buffer,
                                       size_t *lenp, loff_t *ppos)
@@ -2238,7 +2217,7 @@ static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
  *
  * Returns 0 on success.
  */
-int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp,
                           void __user *buffer, size_t *lenp, loff_t *ppos)
 {
     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
@@ -2261,7 +2240,7 @@ int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
  *
  * Returns 0 on success.
  */
-int proc_dointvec_userhz_jiffies(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp,
                                  void __user *buffer, size_t *lenp, loff_t *ppos)
 {
     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
@@ -2285,14 +2264,14 @@ int proc_dointvec_userhz_jiffies(ctl_table *table, int write, struct file *filp,
  *
  * Returns 0 on success.
  */
-int proc_dointvec_ms_jiffies(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp,
                              void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
                                 do_proc_dointvec_ms_jiffies_conv, NULL);
 }
 
-static int proc_do_cad_pid(ctl_table *table, int write, struct file *filp,
+static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
                            void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct pid *new_pid;
@@ -2316,55 +2295,55 @@ static int proc_do_cad_pid(ctl_table *table, int write, struct file *filp,
 
 #else /* CONFIG_PROC_FS */
 
-int proc_dostring(ctl_table *table, int write, struct file *filp,
+int proc_dostring(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_dointvec(ctl_table *table, int write, struct file *filp,
+int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_dointvec_bset(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_bset(struct ctl_table *table, int write, struct file *filp,
                         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_dointvec_userhz_jiffies(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_dointvec_ms_jiffies(ctl_table *table, int write, struct file *filp,
+int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp,
                              void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_doulongvec_minmax(ctl_table *table, int write, struct file *filp,
+int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
 }
 
-int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int write,
+int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
                                       struct file *filp,
                                       void __user *buffer,
                                       size_t *lenp, loff_t *ppos)
@@ -2381,8 +2360,42 @@ int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int write,
  * General sysctl support routines 
  */
 
+/* The generic sysctl data routine (used if no strategy routine supplied) */
+int sysctl_data(struct ctl_table *table, int __user *name, int nlen,
+                void __user *oldval, size_t __user *oldlenp,
+                void __user *newval, size_t newlen)
+{
+        size_t len;
+
+        /* Get out of I don't have a variable */
+        if (!table->data || !table->maxlen)
+                return -ENOTDIR;
+
+        if (oldval && oldlenp) {
+                if (get_user(len, oldlenp))
+                        return -EFAULT;
+                if (len) {
+                        if (len > table->maxlen)
+                                len = table->maxlen;
+                        if (copy_to_user(oldval, table->data, len))
+                                return -EFAULT;
+                        if (put_user(len, oldlenp))
+                                return -EFAULT;
+                }
+        }
+
+        if (newval && newlen) {
+                if (newlen > table->maxlen)
+                        newlen = table->maxlen;
+
+                if (copy_from_user(table->data, newval, newlen))
+                        return -EFAULT;
+        }
+        return 1;
+}
+
 /* The generic string strategy routine: */
-int sysctl_string(ctl_table *table, int __user *name, int nlen,
+int sysctl_string(struct ctl_table *table, int __user *name, int nlen,
                   void __user *oldval, size_t __user *oldlenp,
                   void __user *newval, size_t newlen)
 {
@@ -2428,7 +2441,7 @@ int sysctl_string(ctl_table *table, int __user *name, int nlen,
  * are between the minimum and maximum values given in the arrays
  * table->extra1 and table->extra2, respectively.
  */
-int sysctl_intvec(ctl_table *table, int __user *name, int nlen,
+int sysctl_intvec(struct ctl_table *table, int __user *name, int nlen,
                 void __user *oldval, size_t __user *oldlenp,
                 void __user *newval, size_t newlen)
 {
@@ -2464,7 +2477,7 @@ int sysctl_intvec(ctl_table *table, int __user *name, int nlen,
 }
 
 /* Strategy function to convert jiffies to seconds */ 
-int sysctl_jiffies(ctl_table *table, int __user *name, int nlen,
+int sysctl_jiffies(struct ctl_table *table, int __user *name, int nlen,
                 void __user *oldval, size_t __user *oldlenp,
                 void __user *newval, size_t newlen)
 {
@@ -2498,7 +2511,7 @@ int sysctl_jiffies(ctl_table *table, int __user *name, int nlen,
 }
 
 /* Strategy function to convert jiffies to seconds */ 
-int sysctl_ms_jiffies(ctl_table *table, int __user *name, int nlen,
+int sysctl_ms_jiffies(struct ctl_table *table, int __user *name, int nlen,
                 void __user *oldval, size_t __user *oldlenp,
                 void __user *newval, size_t newlen)
 {
@@ -2538,59 +2551,50 @@ int sysctl_ms_jiffies(ctl_table *table, int __user *name, int nlen,
 
 asmlinkage long sys_sysctl(struct __sysctl_args __user *args)
 {
-        static int msg_count;
         struct __sysctl_args tmp;
-        int name[CTL_MAXNAME];
-        int i;
+        int error;
 
-        /* Read in the sysctl name for better debug message logging */
         if (copy_from_user(&tmp, args, sizeof(tmp)))
                 return -EFAULT;
-        if (tmp.nlen <= 0 || tmp.nlen >= CTL_MAXNAME)
-                return -ENOTDIR;
-        for (i = 0; i < tmp.nlen; i++)
-                if (get_user(name[i], tmp.name + i))
-                        return -EFAULT;
 
-        /* Ignore accesses to kernel.version */
-        if ((tmp.nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
-                goto out;
+        error = deprecated_sysctl_warning(&tmp);
 
-        if (msg_count < 5) {
-                msg_count++;
-                printk(KERN_INFO
-                        "warning: process `%s' used the removed sysctl "
-                        "system call with ", current->comm);
-                for (i = 0; i < tmp.nlen; i++)
-                        printk("%d.", name[i]);
-                printk("\n");
-        }
-out:
+        /* If no error reading the parameters then just -ENOSYS ... */
+        if (!error)
+                error = -ENOSYS;
+
+        return error;
+}
+
+int sysctl_data(struct ctl_table *table, int __user *name, int nlen,
+                  void __user *oldval, size_t __user *oldlenp,
+                  void __user *newval, size_t newlen)
+{
         return -ENOSYS;
 }
 
-int sysctl_string(ctl_table *table, int __user *name, int nlen,
+int sysctl_string(struct ctl_table *table, int __user *name, int nlen,
                   void __user *oldval, size_t __user *oldlenp,
                   void __user *newval, size_t newlen)
 {
         return -ENOSYS;
 }
 
-int sysctl_intvec(ctl_table *table, int __user *name, int nlen,
+int sysctl_intvec(struct ctl_table *table, int __user *name, int nlen,
                 void __user *oldval, size_t __user *oldlenp,
                 void __user *newval, size_t newlen)
 {
         return -ENOSYS;
 }
 
-int sysctl_jiffies(ctl_table *table, int __user *name, int nlen,
+int sysctl_jiffies(struct ctl_table *table, int __user *name, int nlen,
                 void __user *oldval, size_t __user *oldlenp,
                 void __user *newval, size_t newlen)
 {
         return -ENOSYS;
 }
 
-int sysctl_ms_jiffies(ctl_table *table, int __user *name, int nlen,
+int sysctl_ms_jiffies(struct ctl_table *table, int __user *name, int nlen,
                 void __user *oldval, size_t __user *oldlenp,
                 void __user *newval, size_t newlen)
 {
@@ -2599,6 +2603,33 @@ int sysctl_ms_jiffies(ctl_table *table, int __user *name, int nlen,
 
 #endif /* CONFIG_SYSCTL_SYSCALL */
 
+static int deprecated_sysctl_warning(struct __sysctl_args *args)
+{
+        static int msg_count;
+        int name[CTL_MAXNAME];
+        int i;
+
+        /* Read in the sysctl name for better debug message logging */
+        for (i = 0; i < args->nlen; i++)
+                if (get_user(name[i], args->name + i))
+                        return -EFAULT;
+
+        /* Ignore accesses to kernel.version */
+        if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
+                return 0;
+
+        if (msg_count < 5) {
+                msg_count++;
+                printk(KERN_INFO
+                        "warning: process `%s' used the deprecated sysctl "
+                        "system call with ", current->comm);
+                for (i = 0; i < args->nlen; i++)
+                        printk("%d.", name[i]);
+                printk("\n");
+        }
+        return 0;
+}
+
 /*
  * No sense putting this after each symbol definition, twice,
  * exception granted :-)
@@ -2616,4 +2647,5 @@ EXPORT_SYMBOL(sysctl_intvec);
 EXPORT_SYMBOL(sysctl_jiffies);
 EXPORT_SYMBOL(sysctl_ms_jiffies);
 EXPORT_SYMBOL(sysctl_string);
+EXPORT_SYMBOL(sysctl_data);
 EXPORT_SYMBOL(unregister_sysctl_table);
diff --git a/kernel/sysctl_check.c b/kernel/sysctl_check.c
new file mode 100644
index 000000000000..3c9ef5a7d575
--- /dev/null
+++ b/kernel/sysctl_check.c
@@ -0,0 +1,1588 @@
+#include <linux/stat.h>
+#include <linux/sysctl.h>
+#include "../arch/s390/appldata/appldata.h"
+#include "../fs/xfs/linux-2.6/xfs_sysctl.h"
+#include <linux/sunrpc/debug.h>
+#include <linux/string.h>
+#include <net/ip_vs.h>
+
+struct trans_ctl_table {
+        int                     ctl_name;
+        const char              *procname;
+        struct trans_ctl_table  *child;
+};
+
+static struct trans_ctl_table trans_random_table[] = {
+        { RANDOM_POOLSIZE,      "poolsize" },
+        { RANDOM_ENTROPY_COUNT, "entropy_avail" },
+        { RANDOM_READ_THRESH,   "read_wakeup_threshold" },
+        { RANDOM_WRITE_THRESH,  "write_wakeup_threshold" },
+        { RANDOM_BOOT_ID,       "boot_id" },
+        { RANDOM_UUID,          "uuid" },
+        {}
+};
+
+static struct trans_ctl_table trans_pty_table[] = {
+        { PTY_MAX,              "max" },
+        { PTY_NR,               "nr" },
+        {}
+};
+
+static struct trans_ctl_table trans_kern_table[] = {
+        { KERN_OSTYPE,                  "ostype" },
+        { KERN_OSRELEASE,               "osrelease" },
+        /* KERN_OSREV not used */
+        { KERN_VERSION,                 "version" },
+        /* KERN_SECUREMASK not used */
+        /* KERN_PROF not used */
+        { KERN_NODENAME,                "hostname" },
+        { KERN_DOMAINNAME,              "domainname" },
+
+#ifdef CONFIG_SECURITY_CAPABILITIES
+        { KERN_CAP_BSET,                "cap-bound" },
+#endif /* def CONFIG_SECURITY_CAPABILITIES */
+
+        { KERN_PANIC,                   "panic" },
+        { KERN_REALROOTDEV,             "real-root-dev" },
+
+        { KERN_SPARC_REBOOT,            "reboot-cmd" },
+        { KERN_CTLALTDEL,               "ctrl-alt-del" },
+        { KERN_PRINTK,                  "printk" },
+
+        /* KERN_NAMETRANS not used */
+        /* KERN_PPC_HTABRECLAIM not used */
+        /* KERN_PPC_ZEROPAGED not used */
+        { KERN_PPC_POWERSAVE_NAP,       "powersave-nap" },
+
+        { KERN_MODPROBE,                "modprobe" },
+        { KERN_SG_BIG_BUFF,             "sg-big-buff" },
+        { KERN_ACCT,                    "acct" },
+        { KERN_PPC_L2CR,                "l2cr" },
+
+        /* KERN_RTSIGNR not used */
+        /* KERN_RTSIGMAX not used */
+
+        { KERN_SHMMAX,                  "shmmax" },
+        { KERN_MSGMAX,                  "msgmax" },
+        { KERN_MSGMNB,                  "msgmnb" },
+        /* KERN_MSGPOOL not used*/
+        { KERN_SYSRQ,                   "sysrq" },
+        { KERN_MAX_THREADS,             "threads-max" },
+        { KERN_RANDOM,                  "random",       trans_random_table },
+        { KERN_SHMALL,                  "shmall" },
+        { KERN_MSGMNI,                  "msgmni" },
+        { KERN_SEM,                     "sem" },
+        { KERN_SPARC_STOP_A,            "stop-a" },
+        { KERN_SHMMNI,                  "shmmni" },
+
+        { KERN_OVERFLOWUID,             "overflowuid" },
+        { KERN_OVERFLOWGID,             "overflowgid" },
+
+        { KERN_HOTPLUG,                 "hotplug", },
+        { KERN_IEEE_EMULATION_WARNINGS, "ieee_emulation_warnings" },
+
+        { KERN_S390_USER_DEBUG_LOGGING, "userprocess_debug" },
+        { KERN_CORE_USES_PID,           "core_uses_pid" },
+        { KERN_TAINTED,                 "tainted" },
+        { KERN_CADPID,                  "cad_pid" },
+        { KERN_PIDMAX,                  "pid_max" },
+        { KERN_CORE_PATTERN,            "core_pattern" },
+        { KERN_PANIC_ON_OOPS,           "panic_on_oops" },
+        { KERN_HPPA_PWRSW,              "soft-power" },
+        { KERN_HPPA_UNALIGNED,          "unaligned-trap" },
+
+        { KERN_PRINTK_RATELIMIT,        "printk_ratelimit" },
+        { KERN_PRINTK_RATELIMIT_BURST,  "printk_ratelimit_burst" },
+
+        { KERN_PTY,                     "pty",          trans_pty_table },
+        { KERN_NGROUPS_MAX,             "ngroups_max" },
+        { KERN_SPARC_SCONS_PWROFF,      "scons_poweroff" },
+        { KERN_HZ_TIMER,                "hz_timer" },
+        { KERN_UNKNOWN_NMI_PANIC,       "unknown_nmi_panic" },
+        { KERN_BOOTLOADER_TYPE,         "bootloader_type" },
+        { KERN_RANDOMIZE,               "randomize_va_space" },
+
+        { KERN_SPIN_RETRY,              "spin_retry" },
+        { KERN_ACPI_VIDEO_FLAGS,        "acpi_video_flags" },
+        { KERN_IA64_UNALIGNED,          "ignore-unaligned-usertrap" },
+        { KERN_COMPAT_LOG,              "compat-log" },
+        { KERN_MAX_LOCK_DEPTH,          "max_lock_depth" },
+        { KERN_NMI_WATCHDOG,            "nmi_watchdog" },
+        { KERN_PANIC_ON_NMI,            "panic_on_unrecovered_nmi" },
+        {}
+};
+
+static struct trans_ctl_table trans_vm_table[] = {
+        { VM_OVERCOMMIT_MEMORY,         "overcommit_memory" },
+        { VM_PAGE_CLUSTER,              "page-cluster" },
+        { VM_DIRTY_BACKGROUND,          "dirty_background_ratio" },
+        { VM_DIRTY_RATIO,               "dirty_ratio" },
+        { VM_DIRTY_WB_CS,               "dirty_writeback_centisecs" },
+        { VM_DIRTY_EXPIRE_CS,           "dirty_expire_centisecs" },
+        { VM_NR_PDFLUSH_THREADS,        "nr_pdflush_threads" },
+        { VM_OVERCOMMIT_RATIO,          "overcommit_ratio" },
+        /* VM_PAGEBUF unused */
+        { VM_HUGETLB_PAGES,             "nr_hugepages" },
+        { VM_SWAPPINESS,                "swappiness" },
+        { VM_LOWMEM_RESERVE_RATIO,      "lowmem_reserve_ratio" },
+        { VM_MIN_FREE_KBYTES,           "min_free_kbytes" },
+        { VM_MAX_MAP_COUNT,             "max_map_count" },
+        { VM_LAPTOP_MODE,               "laptop_mode" },
+        { VM_BLOCK_DUMP,                "block_dump" },
+        { VM_HUGETLB_GROUP,             "hugetlb_shm_group" },
+        { VM_VFS_CACHE_PRESSURE,        "vfs_cache_pressure" },
+        { VM_LEGACY_VA_LAYOUT,          "legacy_va_layout" },
+        /* VM_SWAP_TOKEN_TIMEOUT unused */
+        { VM_DROP_PAGECACHE,            "drop_caches" },
+        { VM_PERCPU_PAGELIST_FRACTION,  "percpu_pagelist_fraction" },
+        { VM_ZONE_RECLAIM_MODE,         "zone_reclaim_mode" },
+        { VM_MIN_UNMAPPED,              "min_unmapped_ratio" },
+        { VM_PANIC_ON_OOM,              "panic_on_oom" },
+        { VM_VDSO_ENABLED,              "vdso_enabled" },
+        { VM_MIN_SLAB,                  "min_slab_ratio" },
+        { VM_CMM_PAGES,                 "cmm_pages" },
+        { VM_CMM_TIMED_PAGES,           "cmm_timed_pages" },
+        { VM_CMM_TIMEOUT,               "cmm_timeout" },
+
+        {}
+};
+
+static struct trans_ctl_table trans_net_core_table[] = {
+        { NET_CORE_WMEM_MAX,            "wmem_max" },
+        { NET_CORE_RMEM_MAX,            "rmem_max" },
+        { NET_CORE_WMEM_DEFAULT,        "wmem_default" },
+        { NET_CORE_RMEM_DEFAULT,        "rmem_default" },
+        /* NET_CORE_DESTROY_DELAY unused */
+        { NET_CORE_MAX_BACKLOG,         "netdev_max_backlog" },
+        /* NET_CORE_FASTROUTE unused */
+        { NET_CORE_MSG_COST,            "message_cost" },
+        { NET_CORE_MSG_BURST,           "message_burst" },
+        { NET_CORE_OPTMEM_MAX,          "optmem_max" },
+        /* NET_CORE_HOT_LIST_LENGTH unused */
+        /* NET_CORE_DIVERT_VERSION unused */
+        /* NET_CORE_NO_CONG_THRESH unused */
+        /* NET_CORE_NO_CONG unused */
+        /* NET_CORE_LO_CONG unused */
+        /* NET_CORE_MOD_CONG unused */
+        { NET_CORE_DEV_WEIGHT,          "dev_weight" },
+        { NET_CORE_SOMAXCONN,           "somaxconn" },
+        { NET_CORE_BUDGET,              "netdev_budget" },
+        { NET_CORE_AEVENT_ETIME,        "xfrm_aevent_etime" },
+        { NET_CORE_AEVENT_RSEQTH,       "xfrm_aevent_rseqth" },
+        { NET_CORE_WARNINGS,            "warnings" },
+        {},
+};
+
+static struct trans_ctl_table trans_net_unix_table[] = {
+        /* NET_UNIX_DESTROY_DELAY unused */
+        /* NET_UNIX_DELETE_DELAY unused */
+        { NET_UNIX_MAX_DGRAM_QLEN,      "max_dgram_qlen" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv4_route_table[] = {
+        { NET_IPV4_ROUTE_FLUSH,                 "flush" },
+        { NET_IPV4_ROUTE_MIN_DELAY,             "min_delay" },
+        { NET_IPV4_ROUTE_MAX_DELAY,             "max_delay" },
+        { NET_IPV4_ROUTE_GC_THRESH,             "gc_thresh" },
+        { NET_IPV4_ROUTE_MAX_SIZE,              "max_size" },
+        { NET_IPV4_ROUTE_GC_MIN_INTERVAL,       "gc_min_interval" },
+        { NET_IPV4_ROUTE_GC_TIMEOUT,            "gc_timeout" },
+        { NET_IPV4_ROUTE_GC_INTERVAL,           "gc_interval" },
+        { NET_IPV4_ROUTE_REDIRECT_LOAD,         "redirect_load" },
+        { NET_IPV4_ROUTE_REDIRECT_NUMBER,       "redirect_number" },
+        { NET_IPV4_ROUTE_REDIRECT_SILENCE,      "redirect_silence" },
+        { NET_IPV4_ROUTE_ERROR_COST,            "error_cost" },
+        { NET_IPV4_ROUTE_ERROR_BURST,           "error_burst" },
+        { NET_IPV4_ROUTE_GC_ELASTICITY,         "gc_elasticity" },
+        { NET_IPV4_ROUTE_MTU_EXPIRES,           "mtu_expires" },
+        { NET_IPV4_ROUTE_MIN_PMTU,              "min_pmtu" },
+        { NET_IPV4_ROUTE_MIN_ADVMSS,            "min_adv_mss" },
+        { NET_IPV4_ROUTE_SECRET_INTERVAL,       "secret_interval" },
+        { NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS,    "gc_min_interval_ms" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv4_conf_vars_table[] = {
+        { NET_IPV4_CONF_FORWARDING,             "forwarding" },
+        { NET_IPV4_CONF_MC_FORWARDING,          "mc_forwarding" },
+
+        { NET_IPV4_CONF_PROXY_ARP,              "proxy_arp" },
+        { NET_IPV4_CONF_ACCEPT_REDIRECTS,       "accept_redirects" },
+        { NET_IPV4_CONF_SECURE_REDIRECTS,       "secure_redirects" },
+        { NET_IPV4_CONF_SEND_REDIRECTS,         "send_redirects" },
+        { NET_IPV4_CONF_SHARED_MEDIA,           "shared_media" },
+        { NET_IPV4_CONF_RP_FILTER,              "rp_filter" },
+        { NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,    "accept_source_route" },
+        { NET_IPV4_CONF_BOOTP_RELAY,            "bootp_relay" },
+        { NET_IPV4_CONF_LOG_MARTIANS,           "log_martians" },
+        { NET_IPV4_CONF_TAG,                    "tag" },
+        { NET_IPV4_CONF_ARPFILTER,              "arp_filter" },
+        { NET_IPV4_CONF_MEDIUM_ID,              "medium_id" },
+        { NET_IPV4_CONF_NOXFRM,                 "disable_xfrm" },
+        { NET_IPV4_CONF_NOPOLICY,               "disable_policy" },
+        { NET_IPV4_CONF_FORCE_IGMP_VERSION,     "force_igmp_version" },
+
+        { NET_IPV4_CONF_ARP_ANNOUNCE,           "arp_announce" },
+        { NET_IPV4_CONF_ARP_IGNORE,             "arp_ignore" },
+        { NET_IPV4_CONF_PROMOTE_SECONDARIES,    "promote_secondaries" },
+        { NET_IPV4_CONF_ARP_ACCEPT,             "arp_accept" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv4_conf_table[] = {
+        { NET_PROTO_CONF_ALL,           "all",          trans_net_ipv4_conf_vars_table },
+        { NET_PROTO_CONF_DEFAULT,       "default",      trans_net_ipv4_conf_vars_table },
+        { 0, NULL, trans_net_ipv4_conf_vars_table },
+        {}
+};
+
+
+static struct trans_ctl_table trans_net_ipv4_vs_table[] = {
+        { NET_IPV4_VS_AMEMTHRESH,       "amemthresh" },
+        { NET_IPV4_VS_DEBUG_LEVEL,      "debug_level" },
+        { NET_IPV4_VS_AMDROPRATE,       "am_droprate" },
+        { NET_IPV4_VS_DROP_ENTRY,       "drop_entry" },
+        { NET_IPV4_VS_DROP_PACKET,      "drop_packet" },
+        { NET_IPV4_VS_SECURE_TCP,       "secure_tcp" },
+        { NET_IPV4_VS_TO_ES,            "timeout_established" },
+        { NET_IPV4_VS_TO_SS,            "timeout_synsent" },
+        { NET_IPV4_VS_TO_SR,            "timeout_synrecv" },
+        { NET_IPV4_VS_TO_FW,            "timeout_finwait" },
+        { NET_IPV4_VS_TO_TW,            "timeout_timewait" },
+        { NET_IPV4_VS_TO_CL,            "timeout_close" },
+        { NET_IPV4_VS_TO_CW,            "timeout_closewait" },
+        { NET_IPV4_VS_TO_LA,            "timeout_lastack" },
+        { NET_IPV4_VS_TO_LI,            "timeout_listen" },
+        { NET_IPV4_VS_TO_SA,            "timeout_synack" },
+        { NET_IPV4_VS_TO_UDP,           "timeout_udp" },
+        { NET_IPV4_VS_TO_ICMP,          "timeout_icmp" },
+        { NET_IPV4_VS_CACHE_BYPASS,     "cache_bypass" },
+        { NET_IPV4_VS_EXPIRE_NODEST_CONN,       "expire_nodest_conn" },
+        { NET_IPV4_VS_EXPIRE_QUIESCENT_TEMPLATE,        "expire_quiescent_template" },
+        { NET_IPV4_VS_SYNC_THRESHOLD,           "sync_threshold" },
+        { NET_IPV4_VS_NAT_ICMP_SEND,    "nat_icmp_send" },
+        { NET_IPV4_VS_LBLC_EXPIRE,              "lblc_expiration" },
+        { NET_IPV4_VS_LBLCR_EXPIRE,             "lblcr_expiration" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_neigh_vars_table[] = {
+        { NET_NEIGH_MCAST_SOLICIT,      "mcast_solicit" },
+        { NET_NEIGH_UCAST_SOLICIT,      "ucast_solicit" },
+        { NET_NEIGH_APP_SOLICIT,        "app_solicit" },
+        { NET_NEIGH_RETRANS_TIME,       "retrans_time" },
+        { NET_NEIGH_REACHABLE_TIME,     "base_reachable_time" },
+        { NET_NEIGH_DELAY_PROBE_TIME,   "delay_first_probe_time" },
+        { NET_NEIGH_GC_STALE_TIME,      "gc_stale_time" },
+        { NET_NEIGH_UNRES_QLEN,         "unres_qlen" },
+        { NET_NEIGH_PROXY_QLEN,         "proxy_qlen" },
+        { NET_NEIGH_ANYCAST_DELAY,      "anycast_delay" },
+        { NET_NEIGH_PROXY_DELAY,        "proxy_delay" },
+        { NET_NEIGH_LOCKTIME,           "locktime" },
+        { NET_NEIGH_GC_INTERVAL,        "gc_interval" },
+        { NET_NEIGH_GC_THRESH1,         "gc_thresh1" },
+        { NET_NEIGH_GC_THRESH2,         "gc_thresh2" },
+        { NET_NEIGH_GC_THRESH3,         "gc_thresh3" },
+        { NET_NEIGH_RETRANS_TIME_MS,    "retrans_time_ms" },
+        { NET_NEIGH_REACHABLE_TIME_MS,  "base_reachable_time_ms" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_neigh_table[] = {
+        { NET_PROTO_CONF_DEFAULT, "default", trans_net_neigh_vars_table },
+        { 0, NULL, trans_net_neigh_vars_table },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv4_netfilter_table[] = {
+        { NET_IPV4_NF_CONNTRACK_MAX,                            "ip_conntrack_max" },
+
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT,           "ip_conntrack_tcp_timeout_syn_sent" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV,           "ip_conntrack_tcp_timeout_syn_recv" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED,        "ip_conntrack_tcp_timeout_established" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT,           "ip_conntrack_tcp_timeout_fin_wait" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT,         "ip_conntrack_tcp_timeout_close_wait" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK,           "ip_conntrack_tcp_timeout_last_ack" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT,          "ip_conntrack_tcp_timeout_time_wait" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE,              "ip_conntrack_tcp_timeout_close" },
+
+        { NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT,                    "ip_conntrack_udp_timeout" },
+        { NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT_STREAM,             "ip_conntrack_udp_timeout_stream" },
+        { NET_IPV4_NF_CONNTRACK_ICMP_TIMEOUT,                   "ip_conntrack_icmp_timeout" },
+        { NET_IPV4_NF_CONNTRACK_GENERIC_TIMEOUT,                "ip_conntrack_generic_timeout" },
+
+        { NET_IPV4_NF_CONNTRACK_BUCKETS,                        "ip_conntrack_buckets" },
+        { NET_IPV4_NF_CONNTRACK_LOG_INVALID,                    "ip_conntrack_log_invalid" },
+        { NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS,        "ip_conntrack_tcp_timeout_max_retrans" },
+        { NET_IPV4_NF_CONNTRACK_TCP_LOOSE,                      "ip_conntrack_tcp_loose" },
+        { NET_IPV4_NF_CONNTRACK_TCP_BE_LIBERAL,                 "ip_conntrack_tcp_be_liberal" },
+        { NET_IPV4_NF_CONNTRACK_TCP_MAX_RETRANS,                "ip_conntrack_tcp_max_retrans" },
+
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED,            "ip_conntrack_sctp_timeout_closed" },
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT,       "ip_conntrack_sctp_timeout_cookie_wait" },
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED,     "ip_conntrack_sctp_timeout_cookie_echoed" },
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED,       "ip_conntrack_sctp_timeout_established" },
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT,     "ip_conntrack_sctp_timeout_shutdown_sent" },
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD,     "ip_conntrack_sctp_timeout_shutdown_recd" },
+        { NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT, "ip_conntrack_sctp_timeout_shutdown_ack_sent" },
+
+        { NET_IPV4_NF_CONNTRACK_COUNT,          "ip_conntrack_count" },
+        { NET_IPV4_NF_CONNTRACK_CHECKSUM,       "ip_conntrack_checksum" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv4_table[] = {
+        { NET_IPV4_FORWARD,                     "ip_forward" },
+        { NET_IPV4_DYNADDR,                     "ip_dynaddr" },
+
+        { NET_IPV4_CONF,                "conf",         trans_net_ipv4_conf_table },
+        { NET_IPV4_NEIGH,               "neigh",        trans_net_neigh_table },
+        { NET_IPV4_ROUTE,               "route",        trans_net_ipv4_route_table },
+        /* NET_IPV4_FIB_HASH unused */
+        { NET_IPV4_NETFILTER,           "netfilter",    trans_net_ipv4_netfilter_table },
+        { NET_IPV4_VS,                  "vs",           trans_net_ipv4_vs_table },
+
+        { NET_IPV4_TCP_TIMESTAMPS,              "tcp_timestamps" },
+        { NET_IPV4_TCP_WINDOW_SCALING,          "tcp_window_scaling" },
+        { NET_IPV4_TCP_SACK,                    "tcp_sack" },
+        { NET_IPV4_TCP_RETRANS_COLLAPSE,        "tcp_retrans_collapse" },
+        { NET_IPV4_DEFAULT_TTL,                 "ip_default_ttl" },
+        /* NET_IPV4_AUTOCONFIG unused */
+        { NET_IPV4_NO_PMTU_DISC,                "ip_no_pmtu_disc" },
+        { NET_IPV4_TCP_SYN_RETRIES,             "tcp_syn_retries" },
+        { NET_IPV4_IPFRAG_HIGH_THRESH,          "ipfrag_high_thresh" },
+        { NET_IPV4_IPFRAG_LOW_THRESH,           "ipfrag_low_thresh" },
+        { NET_IPV4_IPFRAG_TIME,                 "ipfrag_time" },
+        /* NET_IPV4_TCP_MAX_KA_PROBES unused */
+        { NET_IPV4_TCP_KEEPALIVE_TIME,          "tcp_keepalive_time" },
+        { NET_IPV4_TCP_KEEPALIVE_PROBES,        "tcp_keepalive_probes" },
+        { NET_IPV4_TCP_RETRIES1,                "tcp_retries1" },
+        { NET_IPV4_TCP_RETRIES2,                "tcp_retries2" },
+        { NET_IPV4_TCP_FIN_TIMEOUT,             "tcp_fin_timeout" },
+        /* NET_IPV4_IP_MASQ_DEBUG unused */
+        { NET_TCP_SYNCOOKIES,                   "tcp_syncookies" },
+        { NET_TCP_STDURG,                       "tcp_stdurg" },
+        { NET_TCP_RFC1337,                      "tcp_rfc1337" },
+        /* NET_TCP_SYN_TAILDROP unused */
+        { NET_TCP_MAX_SYN_BACKLOG,              "tcp_max_syn_backlog" },
+        { NET_IPV4_LOCAL_PORT_RANGE,            "ip_local_port_range" },
+        { NET_IPV4_ICMP_ECHO_IGNORE_ALL,        "icmp_echo_ignore_all" },
+        { NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "icmp_echo_ignore_broadcasts" },
+        /* NET_IPV4_ICMP_SOURCEQUENCH_RATE unused */
+        /* NET_IPV4_ICMP_DESTUNREACH_RATE unused */
+        /* NET_IPV4_ICMP_TIMEEXCEED_RATE unused */
+        /* NET_IPV4_ICMP_PARAMPROB_RATE unused */
+        /* NET_IPV4_ICMP_ECHOREPLY_RATE unused */
+        { NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES,   "icmp_ignore_bogus_error_responses" },
+        { NET_IPV4_IGMP_MAX_MEMBERSHIPS,        "igmp_max_memberships" },
+        { NET_TCP_TW_RECYCLE,                   "tcp_tw_recycle" },
+        /* NET_IPV4_ALWAYS_DEFRAG unused */
+        { NET_IPV4_TCP_KEEPALIVE_INTVL,         "tcp_keepalive_intvl" },
+        { NET_IPV4_INET_PEER_THRESHOLD,         "inet_peer_threshold" },
+        { NET_IPV4_INET_PEER_MINTTL,            "inet_peer_minttl" },
+        { NET_IPV4_INET_PEER_MAXTTL,            "inet_peer_maxttl" },
+        { NET_IPV4_INET_PEER_GC_MINTIME,        "inet_peer_gc_mintime" },
+        { NET_IPV4_INET_PEER_GC_MAXTIME,        "inet_peer_gc_maxtime" },
+        { NET_TCP_ORPHAN_RETRIES,               "tcp_orphan_retries" },
+        { NET_TCP_ABORT_ON_OVERFLOW,            "tcp_abort_on_overflow" },
+        { NET_TCP_SYNACK_RETRIES,               "tcp_synack_retries" },
+        { NET_TCP_MAX_ORPHANS,                  "tcp_max_orphans" },
+        { NET_TCP_MAX_TW_BUCKETS,               "tcp_max_tw_buckets" },
+        { NET_TCP_FACK,                         "tcp_fack" },
+        { NET_TCP_REORDERING,                   "tcp_reordering" },
+        { NET_TCP_ECN,                          "tcp_ecn" },
+        { NET_TCP_DSACK,                        "tcp_dsack" },
+        { NET_TCP_MEM,                          "tcp_mem" },
+        { NET_TCP_WMEM,                         "tcp_wmem" },
+        { NET_TCP_RMEM,                         "tcp_rmem" },
+        { NET_TCP_APP_WIN,                      "tcp_app_win" },
+        { NET_TCP_ADV_WIN_SCALE,                "tcp_adv_win_scale" },
+        { NET_IPV4_NONLOCAL_BIND,               "ip_nonlocal_bind" },
+        { NET_IPV4_ICMP_RATELIMIT,              "icmp_ratelimit" },
+        { NET_IPV4_ICMP_RATEMASK,               "icmp_ratemask" },
+        { NET_TCP_TW_REUSE,                     "tcp_tw_reuse" },
+        { NET_TCP_FRTO,                         "tcp_frto" },
+        { NET_TCP_LOW_LATENCY,                  "tcp_low_latency" },
+        { NET_IPV4_IPFRAG_SECRET_INTERVAL,      "ipfrag_secret_interval" },
+        { NET_IPV4_IGMP_MAX_MSF,                "igmp_max_msf" },
+        { NET_TCP_NO_METRICS_SAVE,              "tcp_no_metrics_save" },
+        /* NET_TCP_DEFAULT_WIN_SCALE unused */
+        { NET_TCP_MODERATE_RCVBUF,              "tcp_moderate_rcvbuf" },
+        { NET_TCP_TSO_WIN_DIVISOR,              "tcp_tso_win_divisor" },
+        /* NET_TCP_BIC_BETA unused */
+        { NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR,      "icmp_errors_use_inbound_ifaddr" },
+        { NET_TCP_CONG_CONTROL,                 "tcp_congestion_control" },
+        { NET_TCP_ABC,                          "tcp_abc" },
+        { NET_IPV4_IPFRAG_MAX_DIST,             "ipfrag_max_dist" },
+        { NET_TCP_MTU_PROBING,                  "tcp_mtu_probing" },
+        { NET_TCP_BASE_MSS,                     "tcp_base_mss" },
+        { NET_IPV4_TCP_WORKAROUND_SIGNED_WINDOWS,       "tcp_workaround_signed_windows" },
+        { NET_TCP_DMA_COPYBREAK,                "tcp_dma_copybreak" },
+        { NET_TCP_SLOW_START_AFTER_IDLE,        "tcp_slow_start_after_idle" },
+        { NET_CIPSOV4_CACHE_ENABLE,             "cipso_cache_enable" },
+        { NET_CIPSOV4_CACHE_BUCKET_SIZE,        "cipso_cache_bucket_size" },
+        { NET_CIPSOV4_RBM_OPTFMT,               "cipso_rbm_optfmt" },
+        { NET_CIPSOV4_RBM_STRICTVALID,          "cipso_rbm_strictvalid" },
+        { NET_TCP_AVAIL_CONG_CONTROL,           "tcp_available_congestion_control" },
+        { NET_TCP_ALLOWED_CONG_CONTROL,         "tcp_allowed_congestion_control" },
+        { NET_TCP_MAX_SSTHRESH,                 "tcp_max_ssthresh" },
+        { NET_TCP_FRTO_RESPONSE,                "tcp_frto_response" },
+        { 2088 /* NET_IPQ_QMAX */,              "ip_queue_maxlen" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipx_table[] = {
+        { NET_IPX_PPROP_BROADCASTING,   "ipx_pprop_broadcasting" },
+        /* NET_IPX_FORWARDING unused */
+        {}
+};
+
+static struct trans_ctl_table trans_net_atalk_table[] = {
+        { NET_ATALK_AARP_EXPIRY_TIME,           "aarp-expiry-time" },
+        { NET_ATALK_AARP_TICK_TIME,             "aarp-tick-time" },
+        { NET_ATALK_AARP_RETRANSMIT_LIMIT,      "aarp-retransmit-limit" },
+        { NET_ATALK_AARP_RESOLVE_TIME,          "aarp-resolve-time" },
+        {},
+};
+
+static struct trans_ctl_table trans_net_netrom_table[] = {
+        { NET_NETROM_DEFAULT_PATH_QUALITY,              "default_path_quality" },
+        { NET_NETROM_OBSOLESCENCE_COUNT_INITIALISER,    "obsolescence_count_initialiser" },
+        { NET_NETROM_NETWORK_TTL_INITIALISER,           "network_ttl_initialiser" },
+        { NET_NETROM_TRANSPORT_TIMEOUT,                 "transport_timeout" },
+        { NET_NETROM_TRANSPORT_MAXIMUM_TRIES,           "transport_maximum_tries" },
+        { NET_NETROM_TRANSPORT_ACKNOWLEDGE_DELAY,       "transport_acknowledge_delay" },
+        { NET_NETROM_TRANSPORT_BUSY_DELAY,              "transport_busy_delay" },
+        { NET_NETROM_TRANSPORT_REQUESTED_WINDOW_SIZE,   "transport_requested_window_size" },
+        { NET_NETROM_TRANSPORT_NO_ACTIVITY_TIMEOUT,     "transport_no_activity_timeout" },
+        { NET_NETROM_ROUTING_CONTROL,                   "routing_control" },
+        { NET_NETROM_LINK_FAILS_COUNT,                  "link_fails_count" },
+        { NET_NETROM_RESET,                             "reset" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ax25_table[] = {
+        { NET_AX25_IP_DEFAULT_MODE,     "ip_default_mode" },
+        { NET_AX25_DEFAULT_MODE,        "ax25_default_mode" },
+        { NET_AX25_BACKOFF_TYPE,        "backoff_type" },
+        { NET_AX25_CONNECT_MODE,        "connect_mode" },
+        { NET_AX25_STANDARD_WINDOW,     "standard_window_size" },
+        { NET_AX25_EXTENDED_WINDOW,     "extended_window_size" },
+        { NET_AX25_T1_TIMEOUT,          "t1_timeout" },
+        { NET_AX25_T2_TIMEOUT,          "t2_timeout" },
+        { NET_AX25_T3_TIMEOUT,          "t3_timeout" },
+        { NET_AX25_IDLE_TIMEOUT,        "idle_timeout" },
+        { NET_AX25_N2,                  "maximum_retry_count" },
+        { NET_AX25_PACLEN,              "maximum_packet_length" },
+        { NET_AX25_PROTOCOL,            "protocol" },
+        { NET_AX25_DAMA_SLAVE_TIMEOUT,  "dama_slave_timeout" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_bridge_table[] = {
+        { NET_BRIDGE_NF_CALL_ARPTABLES,         "bridge-nf-call-arptables" },
+        { NET_BRIDGE_NF_CALL_IPTABLES,          "bridge-nf-call-iptables" },
+        { NET_BRIDGE_NF_CALL_IP6TABLES,         "bridge-nf-call-ip6tables" },
+        { NET_BRIDGE_NF_FILTER_VLAN_TAGGED,     "bridge-nf-filter-vlan-tagged" },
+        { NET_BRIDGE_NF_FILTER_PPPOE_TAGGED,    "bridge-nf-filter-pppoe-tagged" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_rose_table[] = {
+        { NET_ROSE_RESTART_REQUEST_TIMEOUT,     "restart_request_timeout" },
+        { NET_ROSE_CALL_REQUEST_TIMEOUT,        "call_request_timeout" },
+        { NET_ROSE_RESET_REQUEST_TIMEOUT,       "reset_request_timeout" },
+        { NET_ROSE_CLEAR_REQUEST_TIMEOUT,       "clear_request_timeout" },
+        { NET_ROSE_ACK_HOLD_BACK_TIMEOUT,       "acknowledge_hold_back_timeout" },
+        { NET_ROSE_ROUTING_CONTROL,             "routing_control" },
+        { NET_ROSE_LINK_FAIL_TIMEOUT,           "link_fail_timeout" },
+        { NET_ROSE_MAX_VCS,                     "maximum_virtual_circuits" },
+        { NET_ROSE_WINDOW_SIZE,                 "window_size" },
+        { NET_ROSE_NO_ACTIVITY_TIMEOUT,         "no_activity_timeout" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv6_conf_var_table[] = {
+        { NET_IPV6_FORWARDING,                  "forwarding" },
+        { NET_IPV6_HOP_LIMIT,                   "hop_limit" },
+        { NET_IPV6_MTU,                         "mtu" },
+        { NET_IPV6_ACCEPT_RA,                   "accept_ra" },
+        { NET_IPV6_ACCEPT_REDIRECTS,            "accept_redirects" },
+        { NET_IPV6_AUTOCONF,                    "autoconf" },
+        { NET_IPV6_DAD_TRANSMITS,               "dad_transmits" },
+        { NET_IPV6_RTR_SOLICITS,                "router_solicitations" },
+        { NET_IPV6_RTR_SOLICIT_INTERVAL,        "router_solicitation_interval" },
+        { NET_IPV6_RTR_SOLICIT_DELAY,           "router_solicitation_delay" },
+        { NET_IPV6_USE_TEMPADDR,                "use_tempaddr" },
+        { NET_IPV6_TEMP_VALID_LFT,              "temp_valid_lft" },
+        { NET_IPV6_TEMP_PREFERED_LFT,           "temp_prefered_lft" },
+        { NET_IPV6_REGEN_MAX_RETRY,             "regen_max_retry" },
+        { NET_IPV6_MAX_DESYNC_FACTOR,           "max_desync_factor" },
+        { NET_IPV6_MAX_ADDRESSES,               "max_addresses" },
+        { NET_IPV6_FORCE_MLD_VERSION,           "force_mld_version" },
+        { NET_IPV6_ACCEPT_RA_DEFRTR,            "accept_ra_defrtr" },
+        { NET_IPV6_ACCEPT_RA_PINFO,             "accept_ra_pinfo" },
+        { NET_IPV6_ACCEPT_RA_RTR_PREF,          "accept_ra_rtr_pref" },
+        { NET_IPV6_RTR_PROBE_INTERVAL,          "router_probe_interval" },
+        { NET_IPV6_ACCEPT_RA_RT_INFO_MAX_PLEN,  "accept_ra_rt_info_max_plen" },
+        { NET_IPV6_PROXY_NDP,                   "proxy_ndp" },
+        { NET_IPV6_ACCEPT_SOURCE_ROUTE,         "accept_source_route" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv6_conf_table[] = {
+        { NET_PROTO_CONF_ALL,           "all",  trans_net_ipv6_conf_var_table },
+        { NET_PROTO_CONF_DEFAULT,       "default", trans_net_ipv6_conf_var_table },
+        { 0, NULL, trans_net_ipv6_conf_var_table },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv6_route_table[] = {
+        { NET_IPV6_ROUTE_FLUSH,                 "flush" },
+        { NET_IPV6_ROUTE_GC_THRESH,             "gc_thresh" },
+        { NET_IPV6_ROUTE_MAX_SIZE,              "max_size" },
+        { NET_IPV6_ROUTE_GC_MIN_INTERVAL,       "gc_min_interval" },
+        { NET_IPV6_ROUTE_GC_TIMEOUT,            "gc_timeout" },
+        { NET_IPV6_ROUTE_GC_INTERVAL,           "gc_interval" },
+        { NET_IPV6_ROUTE_GC_ELASTICITY,         "gc_elasticity" },
+        { NET_IPV6_ROUTE_MTU_EXPIRES,           "mtu_expires" },
+        { NET_IPV6_ROUTE_MIN_ADVMSS,            "min_adv_mss" },
+        { NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,    "gc_min_interval_ms" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv6_icmp_table[] = {
+        { NET_IPV6_ICMP_RATELIMIT,      "ratelimit" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_ipv6_table[] = {
+        { NET_IPV6_CONF,                "conf",         trans_net_ipv6_conf_table },
+        { NET_IPV6_NEIGH,               "neigh",        trans_net_neigh_table },
+        { NET_IPV6_ROUTE,               "route",        trans_net_ipv6_route_table },
+        { NET_IPV6_ICMP,                "icmp",         trans_net_ipv6_icmp_table },
+        { NET_IPV6_BINDV6ONLY,          "bindv6only" },
+        { NET_IPV6_IP6FRAG_HIGH_THRESH, "ip6frag_high_thresh" },
+        { NET_IPV6_IP6FRAG_LOW_THRESH,  "ip6frag_low_thresh" },
+        { NET_IPV6_IP6FRAG_TIME,        "ip6frag_time" },
+        { NET_IPV6_IP6FRAG_SECRET_INTERVAL,     "ip6frag_secret_interval" },
+        { NET_IPV6_MLD_MAX_MSF,         "mld_max_msf" },
+        { 2088 /* IPQ_QMAX */,          "ip6_queue_maxlen" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_x25_table[] = {
+        { NET_X25_RESTART_REQUEST_TIMEOUT,      "restart_request_timeout" },
+        { NET_X25_CALL_REQUEST_TIMEOUT,         "call_request_timeout" },
+        { NET_X25_RESET_REQUEST_TIMEOUT,        "reset_request_timeout" },
+        { NET_X25_CLEAR_REQUEST_TIMEOUT,        "clear_request_timeout" },
+        { NET_X25_ACK_HOLD_BACK_TIMEOUT,        "acknowledgement_hold_back_timeout" },
+        { NET_X25_FORWARD,                      "x25_forward" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_tr_table[] = {
+        { NET_TR_RIF_TIMEOUT,   "rif_timeout" },
+        {}
+};
+
+
+static struct trans_ctl_table trans_net_decnet_conf_vars[] = {
+        { NET_DECNET_CONF_DEV_FORWARDING,       "forwarding" },
+        { NET_DECNET_CONF_DEV_PRIORITY,         "priority" },
+        { NET_DECNET_CONF_DEV_T2,               "t2" },
+        { NET_DECNET_CONF_DEV_T3,               "t3" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_decnet_conf[] = {
+        { 0, NULL, trans_net_decnet_conf_vars },
+        {}
+};
+
+static struct trans_ctl_table trans_net_decnet_table[] = {
+        { NET_DECNET_CONF,              "conf", trans_net_decnet_conf },
+        { NET_DECNET_NODE_ADDRESS,      "node_address" },
+        { NET_DECNET_NODE_NAME,         "node_name" },
+        { NET_DECNET_DEFAULT_DEVICE,    "default_device" },
+        { NET_DECNET_TIME_WAIT,         "time_wait" },
+        { NET_DECNET_DN_COUNT,          "dn_count" },
+        { NET_DECNET_DI_COUNT,          "di_count" },
+        { NET_DECNET_DR_COUNT,          "dr_count" },
+        { NET_DECNET_DST_GC_INTERVAL,   "dst_gc_interval" },
+        { NET_DECNET_NO_FC_MAX_CWND,    "no_fc_max_cwnd" },
+        { NET_DECNET_MEM,               "decnet_mem" },
+        { NET_DECNET_RMEM,              "decnet_rmem" },
+        { NET_DECNET_WMEM,              "decnet_wmem" },
+        { NET_DECNET_DEBUG_LEVEL,       "debug" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_sctp_table[] = {
+        { NET_SCTP_RTO_INITIAL,         "rto_initial" },
+        { NET_SCTP_RTO_MIN,             "rto_min" },
+        { NET_SCTP_RTO_MAX,             "rto_max" },
+        { NET_SCTP_RTO_ALPHA,           "rto_alpha_exp_divisor" },
+        { NET_SCTP_RTO_BETA,            "rto_beta_exp_divisor" },
+        { NET_SCTP_VALID_COOKIE_LIFE,   "valid_cookie_life" },
+        { NET_SCTP_ASSOCIATION_MAX_RETRANS,     "association_max_retrans" },
+        { NET_SCTP_PATH_MAX_RETRANS,    "path_max_retrans" },
+        { NET_SCTP_MAX_INIT_RETRANSMITS,        "max_init_retransmits" },
+        { NET_SCTP_HB_INTERVAL,         "hb_interval" },
+        { NET_SCTP_PRESERVE_ENABLE,     "cookie_preserve_enable" },
+        { NET_SCTP_MAX_BURST,           "max_burst" },
+        { NET_SCTP_ADDIP_ENABLE,        "addip_enable" },
+        { NET_SCTP_PRSCTP_ENABLE,       "prsctp_enable" },
+        { NET_SCTP_SNDBUF_POLICY,       "sndbuf_policy" },
+        { NET_SCTP_SACK_TIMEOUT,        "sack_timeout" },
+        { NET_SCTP_RCVBUF_POLICY,       "rcvbuf_policy" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_llc_llc2_timeout_table[] = {
+        { NET_LLC2_ACK_TIMEOUT,         "ack" },
+        { NET_LLC2_P_TIMEOUT,           "p" },
+        { NET_LLC2_REJ_TIMEOUT,         "rej" },
+        { NET_LLC2_BUSY_TIMEOUT,        "busy" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_llc_station_table[] = {
+        { NET_LLC_STATION_ACK_TIMEOUT,  "ack_timeout" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_llc_llc2_table[] = {
+        { NET_LLC2,             "timeout",      trans_net_llc_llc2_timeout_table },
+        {}
+};
+
+static struct trans_ctl_table trans_net_llc_table[] = {
+        { NET_LLC2,             "llc2",         trans_net_llc_llc2_table },
+        { NET_LLC_STATION,      "station",      trans_net_llc_station_table },
+        {}
+};
+
+static struct trans_ctl_table trans_net_netfilter_table[] = {
+        { NET_NF_CONNTRACK_MAX,                         "nf_conntrack_max" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT,        "nf_conntrack_tcp_timeout_syn_sent" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV,        "nf_conntrack_tcp_timeout_syn_recv" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED,     "nf_conntrack_tcp_timeout_established" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT,        "nf_conntrack_tcp_timeout_fin_wait" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT,      "nf_conntrack_tcp_timeout_close_wait" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK,        "nf_conntrack_tcp_timeout_last_ack" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT,       "nf_conntrack_tcp_timeout_time_wait" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE,           "nf_conntrack_tcp_timeout_close" },
+        { NET_NF_CONNTRACK_UDP_TIMEOUT,                 "nf_conntrack_udp_timeout" },
+        { NET_NF_CONNTRACK_UDP_TIMEOUT_STREAM,          "nf_conntrack_udp_timeout_stream" },
+        { NET_NF_CONNTRACK_ICMP_TIMEOUT,        "nf_conntrack_icmp_timeout" },
+        { NET_NF_CONNTRACK_GENERIC_TIMEOUT,             "nf_conntrack_generic_timeout" },
+        { NET_NF_CONNTRACK_BUCKETS,                     "nf_conntrack_buckets" },
+        { NET_NF_CONNTRACK_LOG_INVALID,                 "nf_conntrack_log_invalid" },
+        { NET_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS,     "nf_conntrack_tcp_timeout_max_retrans" },
+        { NET_NF_CONNTRACK_TCP_LOOSE,                   "nf_conntrack_tcp_loose" },
+        { NET_NF_CONNTRACK_TCP_BE_LIBERAL,              "nf_conntrack_tcp_be_liberal" },
+        { NET_NF_CONNTRACK_TCP_MAX_RETRANS,             "nf_conntrack_tcp_max_retrans" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED,         "nf_conntrack_sctp_timeout_closed" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT,    "nf_conntrack_sctp_timeout_cookie_wait" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED,  "nf_conntrack_sctp_timeout_cookie_echoed" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED,    "nf_conntrack_sctp_timeout_established" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT,  "nf_conntrack_sctp_timeout_shutdown_sent" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD,  "nf_conntrack_sctp_timeout_shutdown_recd" },
+        { NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT,      "nf_conntrack_sctp_timeout_shutdown_ack_sent" },
+        { NET_NF_CONNTRACK_COUNT,                       "nf_conntrack_count" },
+        { NET_NF_CONNTRACK_ICMPV6_TIMEOUT,      "nf_conntrack_icmpv6_timeout" },
+        { NET_NF_CONNTRACK_FRAG6_TIMEOUT,               "nf_conntrack_frag6_timeout" },
+        { NET_NF_CONNTRACK_FRAG6_LOW_THRESH,            "nf_conntrack_frag6_low_thresh" },
+        { NET_NF_CONNTRACK_FRAG6_HIGH_THRESH,           "nf_conntrack_frag6_high_thresh" },
+        { NET_NF_CONNTRACK_CHECKSUM,                    "nf_conntrack_checksum" },
+
+        {}
+};
+
+static struct trans_ctl_table trans_net_dccp_table[] = {
+        { NET_DCCP_DEFAULT,     "default" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_irda_table[] = {
+        { NET_IRDA_DISCOVERY,           "discovery" },
+        { NET_IRDA_DEVNAME,             "devname" },
+        { NET_IRDA_DEBUG,               "debug" },
+        { NET_IRDA_FAST_POLL,           "fast_poll_increase" },
+        { NET_IRDA_DISCOVERY_SLOTS,     "discovery_slots" },
+        { NET_IRDA_DISCOVERY_TIMEOUT,   "discovery_timeout" },
+        { NET_IRDA_SLOT_TIMEOUT,        "slot_timeout" },
+        { NET_IRDA_MAX_BAUD_RATE,       "max_baud_rate" },
+        { NET_IRDA_MIN_TX_TURN_TIME,    "min_tx_turn_time" },
+        { NET_IRDA_MAX_TX_DATA_SIZE,    "max_tx_data_size" },
+        { NET_IRDA_MAX_TX_WINDOW,       "max_tx_window" },
+        { NET_IRDA_MAX_NOREPLY_TIME,    "max_noreply_time" },
+        { NET_IRDA_WARN_NOREPLY_TIME,   "warn_noreply_time" },
+        { NET_IRDA_LAP_KEEPALIVE_TIME,  "lap_keepalive_time" },
+        {}
+};
+
+static struct trans_ctl_table trans_net_table[] = {
+        { NET_CORE,             "core",         trans_net_core_table },
+        /* NET_ETHER not used */
+        /* NET_802 not used */
+        { NET_UNIX,             "unix",         trans_net_unix_table },
+        { NET_IPV4,             "ipv4",         trans_net_ipv4_table },
+        { NET_IPX,              "ipx",          trans_net_ipx_table },
+        { NET_ATALK,            "atalk",        trans_net_atalk_table },
+        { NET_NETROM,           "netrom",       trans_net_netrom_table },
+        { NET_AX25,             "ax25",         trans_net_ax25_table },
+        { NET_BRIDGE,           "bridge",       trans_net_bridge_table },
+        { NET_ROSE,             "rose",         trans_net_rose_table },
+        { NET_IPV6,             "ipv6",         trans_net_ipv6_table },
+        { NET_X25,              "x25",          trans_net_x25_table },
+        { NET_TR,               "tr",           trans_net_tr_table },
+        { NET_DECNET,           "decnet",       trans_net_decnet_table },
+        /*  NET_ECONET not used */
+        { NET_SCTP,             "sctp",         trans_net_sctp_table },
+        { NET_LLC,              "llc",          trans_net_llc_table },
+        { NET_NETFILTER,        "netfilter",    trans_net_netfilter_table },
+        { NET_DCCP,             "dccp",         trans_net_dccp_table },
+        { NET_IRDA,             "irda",         trans_net_irda_table },
+        { 2089,                 "nf_conntrack_max" },
+        {}
+};
+
+static struct trans_ctl_table trans_fs_quota_table[] = {
+        { FS_DQ_LOOKUPS,        "lookups" },
+        { FS_DQ_DROPS,          "drops" },
+        { FS_DQ_READS,          "reads" },
+        { FS_DQ_WRITES,         "writes" },
+        { FS_DQ_CACHE_HITS,     "cache_hits" },
+        { FS_DQ_ALLOCATED,      "allocated_dquots" },
+        { FS_DQ_FREE,           "free_dquots" },
+        { FS_DQ_SYNCS,          "syncs" },
+        { FS_DQ_WARNINGS,       "warnings" },
+        {}
+};
+
+static struct trans_ctl_table trans_fs_xfs_table[] = {
+        { XFS_RESTRICT_CHOWN,   "restrict_chown" },
+        { XFS_SGID_INHERIT,     "irix_sgid_inherit" },
+        { XFS_SYMLINK_MODE,     "irix_symlink_mode" },
+        { XFS_PANIC_MASK,       "panic_mask" },
+
+        { XFS_ERRLEVEL,         "error_level" },
+        { XFS_SYNCD_TIMER,      "xfssyncd_centisecs" },
+        { XFS_INHERIT_SYNC,     "inherit_sync" },
+        { XFS_INHERIT_NODUMP,   "inherit_nodump" },
+        { XFS_INHERIT_NOATIME,  "inherit_noatime" },
+        { XFS_BUF_TIMER,        "xfsbufd_centisecs" },
+        { XFS_BUF_AGE,          "age_buffer_centisecs" },
+        { XFS_INHERIT_NOSYM,    "inherit_nosymlinks" },
+        { XFS_ROTORSTEP,        "rotorstep" },
+        { XFS_INHERIT_NODFRG,   "inherit_nodefrag" },
+        { XFS_FILESTREAM_TIMER, "filestream_centisecs" },
+        { XFS_STATS_CLEAR,      "stats_clear" },
+        {}
+};
+
+static struct trans_ctl_table trans_fs_ocfs2_nm_table[] = {
+        { 1, "hb_ctl_path" },
+        {}
+};
+
+static struct trans_ctl_table trans_fs_ocfs2_table[] = {
+        { 1,    "nm",   trans_fs_ocfs2_nm_table },
+        {}
+};
+
+static struct trans_ctl_table trans_inotify_table[] = {
+        { INOTIFY_MAX_USER_INSTANCES,   "max_user_instances" },
+        { INOTIFY_MAX_USER_WATCHES,     "max_user_watches" },
+        { INOTIFY_MAX_QUEUED_EVENTS,    "max_queued_events" },
+        {}
+};
+
+static struct trans_ctl_table trans_fs_table[] = {
+        { FS_NRINODE,           "inode-nr" },
+        { FS_STATINODE,         "inode-state" },
+        /* FS_MAXINODE unused */
+        /* FS_NRDQUOT unused */
+        /* FS_MAXDQUOT unused */
+        { FS_NRFILE,            "file-nr" },
+        { FS_MAXFILE,           "file-max" },
+        { FS_DENTRY,            "dentry-state" },
+        /* FS_NRSUPER unused */
+        /* FS_MAXUPSER unused */
+        { FS_OVERFLOWUID,       "overflowuid" },
+        { FS_OVERFLOWGID,       "overflowgid" },
+        { FS_LEASES,            "leases-enable" },
+        { FS_DIR_NOTIFY,        "dir-notify-enable" },
+        { FS_LEASE_TIME,        "lease-break-time" },
+        { FS_DQSTATS,           "quota",                trans_fs_quota_table },
+        { FS_XFS,               "xfs",                  trans_fs_xfs_table },
+        { FS_AIO_NR,            "aio-nr" },
+        { FS_AIO_MAX_NR,        "aio-max-nr" },
+        { FS_INOTIFY,           "inotify",              trans_inotify_table },
+        { FS_OCFS2,             "ocfs2",                trans_fs_ocfs2_table },
+        { KERN_SETUID_DUMPABLE, "suid_dumpable" },
+        {}
+};
+
+static struct trans_ctl_table trans_debug_table[] = {
+        {}
+};
+
+static struct trans_ctl_table trans_cdrom_table[] = {
+        { DEV_CDROM_INFO,               "info" },
+        { DEV_CDROM_AUTOCLOSE,          "autoclose" },
+        { DEV_CDROM_AUTOEJECT,          "autoeject" },
+        { DEV_CDROM_DEBUG,              "debug" },
+        { DEV_CDROM_LOCK,               "lock" },
+        { DEV_CDROM_CHECK_MEDIA,        "check_media" },
+        {}
+};
+
+static struct trans_ctl_table trans_ipmi_table[] = {
+        { DEV_IPMI_POWEROFF_POWERCYCLE, "poweroff_powercycle" },
+        {}
+};
+
+static struct trans_ctl_table trans_mac_hid_files[] = {
+        /* DEV_MAC_HID_KEYBOARD_SENDS_LINUX_KEYCODES unused */
+        /* DEV_MAC_HID_KEYBOARD_LOCK_KEYCODES unused */
+        { DEV_MAC_HID_MOUSE_BUTTON_EMULATION,   "mouse_button_emulation" },
+        { DEV_MAC_HID_MOUSE_BUTTON2_KEYCODE,    "mouse_button2_keycode" },
+        { DEV_MAC_HID_MOUSE_BUTTON3_KEYCODE,    "mouse_button3_keycode" },
+        /* DEV_MAC_HID_ADB_MOUSE_SENDS_KEYCODES unused */
+        {}
+};
+
+static struct trans_ctl_table trans_raid_table[] = {
+        { DEV_RAID_SPEED_LIMIT_MIN,     "speed_limit_min" },
+        { DEV_RAID_SPEED_LIMIT_MAX,     "speed_limit_max" },
+        {}
+};
+
+static struct trans_ctl_table trans_scsi_table[] = {
+        { DEV_SCSI_LOGGING_LEVEL, "logging_level" },
+        {}
+};
+
+static struct trans_ctl_table trans_parport_default_table[] = {
+        { DEV_PARPORT_DEFAULT_TIMESLICE,        "timeslice" },
+        { DEV_PARPORT_DEFAULT_SPINTIME,         "spintime" },
+        {}
+};
+
+static struct trans_ctl_table trans_parport_device_table[] = {
+        { DEV_PARPORT_DEVICE_TIMESLICE,         "timeslice" },
+        {}
+};
+
+static struct trans_ctl_table trans_parport_devices_table[] = {
+        { DEV_PARPORT_DEVICES_ACTIVE,           "active" },
+        { 0, NULL, trans_parport_device_table },
+        {}
+};
+
+static struct trans_ctl_table trans_parport_parport_table[] = {
+        { DEV_PARPORT_SPINTIME,         "spintime" },
+        { DEV_PARPORT_BASE_ADDR,        "base-addr" },
+        { DEV_PARPORT_IRQ,              "irq" },
+        { DEV_PARPORT_DMA,              "dma" },
+        { DEV_PARPORT_MODES,            "modes" },
+        { DEV_PARPORT_DEVICES,          "devices",      trans_parport_devices_table },
+        { DEV_PARPORT_AUTOPROBE,        "autoprobe" },
+        { DEV_PARPORT_AUTOPROBE + 1,    "autoprobe0" },
+        { DEV_PARPORT_AUTOPROBE + 2,    "autoprobe1" },
+        { DEV_PARPORT_AUTOPROBE + 3,    "autoprobe2" },
+        { DEV_PARPORT_AUTOPROBE + 4,    "autoprobe3" },
+        {}
+};
+static struct trans_ctl_table trans_parport_table[] = {
+        { DEV_PARPORT_DEFAULT,  "default",      trans_parport_default_table },
+        { 0, NULL, trans_parport_parport_table },
+        {}
+};
+
+static struct trans_ctl_table trans_dev_table[] = {
+        { DEV_CDROM,    "cdrom",        trans_cdrom_table },
+        /* DEV_HWMON unused */
+        { DEV_PARPORT,  "parport",      trans_parport_table },
+        { DEV_RAID,     "raid",         trans_raid_table },
+        { DEV_MAC_HID,  "mac_hid",      trans_mac_hid_files },
+        { DEV_SCSI,     "scsi",         trans_scsi_table },
+        { DEV_IPMI,     "ipmi",         trans_ipmi_table },
+        {}
+};
+
+static struct trans_ctl_table trans_bus_isa_table[] = {
+        { BUS_ISA_MEM_BASE,     "membase" },
+        { BUS_ISA_PORT_BASE,    "portbase" },
+        { BUS_ISA_PORT_SHIFT,   "portshift" },
+        {}
+};
+
+static struct trans_ctl_table trans_bus_table[] = {
+        { CTL_BUS_ISA,  "isa",  trans_bus_isa_table },
+        {}
+};
+
+static struct trans_ctl_table trans_arlan_conf_table0[] = {
+        { 1,    "spreadingCode" },
+        { 2,    "channelNumber" },
+        { 3,    "scramblingDisable" },
+        { 4,    "txAttenuation" },
+        { 5,    "systemId" },
+        { 6,    "maxDatagramSize" },
+        { 7,    "maxFrameSize" },
+        { 8,    "maxRetries" },
+        { 9,    "receiveMode" },
+        { 10,   "priority" },
+        { 11,   "rootOrRepeater" },
+        { 12,   "SID" },
+        { 13,   "registrationMode" },
+        { 14,   "registrationFill" },
+        { 15,   "localTalkAddress" },
+        { 16,   "codeFormat" },
+        { 17,   "numChannels" },
+        { 18,   "channel1" },
+        { 19,   "channel2" },
+        { 20,   "channel3" },
+        { 21,   "channel4" },
+        { 22,   "txClear" },
+        { 23,   "txRetries" },
+        { 24,   "txRouting" },
+        { 25,   "txScrambled" },
+        { 26,   "rxParameter" },
+        { 27,   "txTimeoutMs" },
+        { 28,   "waitCardTimeout" },
+        { 29,   "channelSet" },
+        { 30,   "name" },
+        { 31,   "waitTime" },
+        { 32,   "lParameter" },
+        { 33,   "_15" },
+        { 34,   "headerSize" },
+        { 36,   "tx_delay_ms" },
+        { 37,   "retries" },
+        { 38,   "ReTransmitPacketMaxSize" },
+        { 39,   "waitReTransmitPacketMaxSize" },
+        { 40,   "fastReTransCount" },
+        { 41,   "driverRetransmissions" },
+        { 42,   "txAckTimeoutMs" },
+        { 43,   "registrationInterrupts" },
+        { 44,   "hardwareType" },
+        { 45,   "radioType" },
+        { 46,   "writeEEPROM" },
+        { 47,   "writeRadioType" },
+        { 48,   "entry_exit_debug" },
+        { 49,   "debug" },
+        { 50,   "in_speed" },
+        { 51,   "out_speed" },
+        { 52,   "in_speed10" },
+        { 53,   "out_speed10" },
+        { 54,   "in_speed_max" },
+        { 55,   "out_speed_max" },
+        { 56,   "measure_rate" },
+        { 57,   "pre_Command_Wait" },
+        { 58,   "rx_tweak1" },
+        { 59,   "rx_tweak2" },
+        { 60,   "tx_queue_len" },
+
+        { 150,  "arlan0-txRing" },
+        { 151,  "arlan0-rxRing" },
+        { 152,  "arlan0-18" },
+        { 153,  "arlan0-ring" },
+        { 154,  "arlan0-shm-cpy" },
+        { 155,  "config0" },
+        { 156,  "reset0" },
+        {}
+};
+
+static struct trans_ctl_table trans_arlan_conf_table1[] = {
+        { 1,    "spreadingCode" },
+        { 2,    "channelNumber" },
+        { 3,    "scramblingDisable" },
+        { 4,    "txAttenuation" },
+        { 5,    "systemId" },
+        { 6,    "maxDatagramSize" },
+        { 7,    "maxFrameSize" },
+        { 8,    "maxRetries" },
+        { 9,    "receiveMode" },
+        { 10,   "priority" },
+        { 11,   "rootOrRepeater" },
+        { 12,   "SID" },
+        { 13,   "registrationMode" },
+        { 14,   "registrationFill" },
+        { 15,   "localTalkAddress" },
+        { 16,   "codeFormat" },
+        { 17,   "numChannels" },
+        { 18,   "channel1" },
+        { 19,   "channel2" },
+        { 20,   "channel3" },
+        { 21,   "channel4" },
+        { 22,   "txClear" },
+        { 23,   "txRetries" },
+        { 24,   "txRouting" },
+        { 25,   "txScrambled" },
+        { 26,   "rxParameter" },
+        { 27,   "txTimeoutMs" },
+        { 28,   "waitCardTimeout" },
+        { 29,   "channelSet" },
+        { 30,   "name" },
+        { 31,   "waitTime" },
+        { 32,   "lParameter" },
+        { 33,   "_15" },
+        { 34,   "headerSize" },
+        { 36,   "tx_delay_ms" },
+        { 37,   "retries" },
+        { 38,   "ReTransmitPacketMaxSize" },
+        { 39,   "waitReTransmitPacketMaxSize" },
+        { 40,   "fastReTransCount" },
+        { 41,   "driverRetransmissions" },
+        { 42,   "txAckTimeoutMs" },
+        { 43,   "registrationInterrupts" },
+        { 44,   "hardwareType" },
+        { 45,   "radioType" },
+        { 46,   "writeEEPROM" },
+        { 47,   "writeRadioType" },
+        { 48,   "entry_exit_debug" },
+        { 49,   "debug" },
+        { 50,   "in_speed" },
+        { 51,   "out_speed" },
+        { 52,   "in_speed10" },
+        { 53,   "out_speed10" },
+        { 54,   "in_speed_max" },
+        { 55,   "out_speed_max" },
+        { 56,   "measure_rate" },
+        { 57,   "pre_Command_Wait" },
+        { 58,   "rx_tweak1" },
+        { 59,   "rx_tweak2" },
+        { 60,   "tx_queue_len" },
+
+        { 150,  "arlan1-txRing" },
+        { 151,  "arlan1-rxRing" },
+        { 152,  "arlan1-18" },
+        { 153,  "arlan1-ring" },
+        { 154,  "arlan1-shm-cpy" },
+        { 155,  "config1" },
+        { 156,  "reset1" },
+        {}
+};
+
+static struct trans_ctl_table trans_arlan_conf_table2[] = {
+        { 1,    "spreadingCode" },
+        { 2,    "channelNumber" },
+        { 3,    "scramblingDisable" },
+        { 4,    "txAttenuation" },
+        { 5,    "systemId" },
+        { 6,    "maxDatagramSize" },
+        { 7,    "maxFrameSize" },
+        { 8,    "maxRetries" },
+        { 9,    "receiveMode" },
+        { 10,   "priority" },
+        { 11,   "rootOrRepeater" },
+        { 12,   "SID" },
+        { 13,   "registrationMode" },
+        { 14,   "registrationFill" },
+        { 15,   "localTalkAddress" },
+        { 16,   "codeFormat" },
+        { 17,   "numChannels" },
+        { 18,   "channel1" },
+        { 19,   "channel2" },
+        { 20,   "channel3" },
+        { 21,   "channel4" },
+        { 22,   "txClear" },
+        { 23,   "txRetries" },
+        { 24,   "txRouting" },
+        { 25,   "txScrambled" },
+        { 26,   "rxParameter" },
+        { 27,   "txTimeoutMs" },
+        { 28,   "waitCardTimeout" },
+        { 29,   "channelSet" },
+        { 30,   "name" },
+        { 31,   "waitTime" },
+        { 32,   "lParameter" },
+        { 33,   "_15" },
+        { 34,   "headerSize" },
+        { 36,   "tx_delay_ms" },
+        { 37,   "retries" },
+        { 38,   "ReTransmitPacketMaxSize" },
+        { 39,   "waitReTransmitPacketMaxSize" },
+        { 40,   "fastReTransCount" },
+        { 41,   "driverRetransmissions" },
+        { 42,   "txAckTimeoutMs" },
+        { 43,   "registrationInterrupts" },
+        { 44,   "hardwareType" },
+        { 45,   "radioType" },
+        { 46,   "writeEEPROM" },
+        { 47,   "writeRadioType" },
+        { 48,   "entry_exit_debug" },
+        { 49,   "debug" },
+        { 50,   "in_speed" },
+        { 51,   "out_speed" },
+        { 52,   "in_speed10" },
+        { 53,   "out_speed10" },
+        { 54,   "in_speed_max" },
+        { 55,   "out_speed_max" },
+        { 56,   "measure_rate" },
+        { 57,   "pre_Command_Wait" },
+        { 58,   "rx_tweak1" },
+        { 59,   "rx_tweak2" },
+        { 60,   "tx_queue_len" },
+
+        { 150,  "arlan2-txRing" },
+        { 151,  "arlan2-rxRing" },
+        { 152,  "arlan2-18" },
+        { 153,  "arlan2-ring" },
+        { 154,  "arlan2-shm-cpy" },
+        { 155,  "config2" },
+        { 156,  "reset2" },
+        {}
+};
+
+static struct trans_ctl_table trans_arlan_conf_table3[] = {
+        { 1,    "spreadingCode" },
+        { 2,    "channelNumber" },
+        { 3,    "scramblingDisable" },
+        { 4,    "txAttenuation" },
+        { 5,    "systemId" },
+        { 6,    "maxDatagramSize" },
+        { 7,    "maxFrameSize" },
+        { 8,    "maxRetries" },
+        { 9,    "receiveMode" },
+        { 10,   "priority" },
+        { 11,   "rootOrRepeater" },
+        { 12,   "SID" },
+        { 13,   "registrationMode" },
+        { 14,   "registrationFill" },
+        { 15,   "localTalkAddress" },
+        { 16,   "codeFormat" },
+        { 17,   "numChannels" },
+        { 18,   "channel1" },
+        { 19,   "channel2" },
+        { 20,   "channel3" },
+        { 21,   "channel4" },
+        { 22,   "txClear" },
+        { 23,   "txRetries" },
+        { 24,   "txRouting" },
+        { 25,   "txScrambled" },
+        { 26,   "rxParameter" },
+        { 27,   "txTimeoutMs" },
+        { 28,   "waitCardTimeout" },
+        { 29,   "channelSet" },
+        { 30,   "name" },
+        { 31,   "waitTime" },
+        { 32,   "lParameter" },
+        { 33,   "_15" },
+        { 34,   "headerSize" },
+        { 36,   "tx_delay_ms" },
+        { 37,   "retries" },
+        { 38,   "ReTransmitPacketMaxSize" },
+        { 39,   "waitReTransmitPacketMaxSize" },
+        { 40,   "fastReTransCount" },
+        { 41,   "driverRetransmissions" },
+        { 42,   "txAckTimeoutMs" },
+        { 43,   "registrationInterrupts" },
+        { 44,   "hardwareType" },
+        { 45,   "radioType" },
+        { 46,   "writeEEPROM" },
+        { 47,   "writeRadioType" },
+        { 48,   "entry_exit_debug" },
+        { 49,   "debug" },
+        { 50,   "in_speed" },
+        { 51,   "out_speed" },
+        { 52,   "in_speed10" },
+        { 53,   "out_speed10" },
+        { 54,   "in_speed_max" },
+        { 55,   "out_speed_max" },
+        { 56,   "measure_rate" },
+        { 57,   "pre_Command_Wait" },
+        { 58,   "rx_tweak1" },
+        { 59,   "rx_tweak2" },
+        { 60,   "tx_queue_len" },
+
+        { 150,  "arlan3-txRing" },
+        { 151,  "arlan3-rxRing" },
+        { 152,  "arlan3-18" },
+        { 153,  "arlan3-ring" },
+        { 154,  "arlan3-shm-cpy" },
+        { 155,  "config3" },
+        { 156,  "reset3" },
+        {}
+};
+
+static struct trans_ctl_table trans_arlan_table[] = {
+        { 1,            "arlan0",       trans_arlan_conf_table0 },
+        { 2,            "arlan1",       trans_arlan_conf_table1 },
+        { 3,            "arlan2",       trans_arlan_conf_table2 },
+        { 4,            "arlan3",       trans_arlan_conf_table3 },
+        {}
+};
+
+static struct trans_ctl_table trans_appldata_table[] = {
+        { CTL_APPLDATA_TIMER,           "timer" },
+        { CTL_APPLDATA_INTERVAL,        "interval" },
+        { CTL_APPLDATA_OS,              "os" },
+        { CTL_APPLDATA_NET_SUM,         "net_sum" },
+        { CTL_APPLDATA_MEM,             "mem" },
+        {}
+
+};
+
+static struct trans_ctl_table trans_s390dbf_table[] = {
+        { 5678 /* CTL_S390DBF_STOPPABLE */,     "debug_stoppable" },
+        { 5679 /* CTL_S390DBF_ACTIVE */,        "debug_active" },
+        {}
+};
+
+static struct trans_ctl_table trans_sunrpc_table[] = {
+        { CTL_RPCDEBUG,         "rpc_debug" },
+        { CTL_NFSDEBUG,         "nfs_debug" },
+        { CTL_NFSDDEBUG,        "nfsd_debug" },
+        { CTL_NLMDEBUG,         "nlm_debug" },
+        { CTL_SLOTTABLE_UDP,    "udp_slot_table_entries" },
+        { CTL_SLOTTABLE_TCP,    "tcp_slot_table_entries" },
+        { CTL_MIN_RESVPORT,     "min_resvport" },
+        { CTL_MAX_RESVPORT,     "max_resvport" },
+        {}
+};
+
+static struct trans_ctl_table trans_pm_table[] = {
+        { 1 /* CTL_PM_SUSPEND */,       "suspend" },
+        { 2 /* CTL_PM_CMODE */,         "cmode" },
+        { 3 /* CTL_PM_P0 */,            "p0" },
+        { 4 /* CTL_PM_CM */,            "cm" },
+        {}
+};
+
+static struct trans_ctl_table trans_frv_table[] = {
+        { 1,    "cache-mode" },
+        { 2,    "pin-cxnr" },
+        {}
+};
+
+static struct trans_ctl_table trans_root_table[] = {
+        { CTL_KERN,     "kernel",       trans_kern_table },
+        { CTL_VM,       "vm",           trans_vm_table },
+        { CTL_NET,      "net",          trans_net_table },
+        /* CTL_PROC not used */
+        { CTL_FS,       "fs",           trans_fs_table },
+        { CTL_DEBUG,    "debug",        trans_debug_table },
+        { CTL_DEV,      "dev",          trans_dev_table },
+        { CTL_BUS,      "bus",          trans_bus_table },
+        { CTL_ABI,      "abi" },
+        /* CTL_CPU not used */
+        { CTL_ARLAN,    "arlan",        trans_arlan_table },
+        { CTL_APPLDATA, "appldata",     trans_appldata_table },
+        { CTL_S390DBF,  "s390dbf",      trans_s390dbf_table },
+        { CTL_SUNRPC,   "sunrpc",       trans_sunrpc_table },
+        { CTL_PM,       "pm",           trans_pm_table },
+        { CTL_FRV,      "frv",          trans_frv_table },
+        {}
+};
+
+
+
+
+static int sysctl_depth(struct ctl_table *table)
+{
+        struct ctl_table *tmp;
+        int depth;
+
+        depth = 0;
+        for (tmp = table; tmp->parent; tmp = tmp->parent)
+                depth++;
+
+        return depth;
+}
+
+static struct ctl_table *sysctl_parent(struct ctl_table *table, int n)
+{
+        int i;
+
+        for (i = 0; table && i < n; i++)
+                table = table->parent;
+
+        return table;
+}
+
+static struct trans_ctl_table *sysctl_binary_lookup(struct ctl_table *table)
+{
+        struct ctl_table *test;
+        struct trans_ctl_table *ref;
+        int depth, cur_depth;
+
+        depth = sysctl_depth(table);
+
+        cur_depth = depth;
+        ref = trans_root_table;
+repeat:
+        test = sysctl_parent(table, cur_depth);
+        for (; ref->ctl_name || ref->procname || ref->child; ref++) {
+                int match = 0;
+
+                if (cur_depth && !ref->child)
+                        continue;
+
+                if (test->procname && ref->procname &&
+                        (strcmp(test->procname, ref->procname) == 0))
+                        match++;
+
+                if (test->ctl_name && ref->ctl_name &&
+                        (test->ctl_name == ref->ctl_name))
+                        match++;
+
+                if (!ref->ctl_name && !ref->procname)
+                        match++;
+
+                if (match) {
+                        if (cur_depth != 0) {
+                                cur_depth--;
+                                ref = ref->child;
+                                goto repeat;
+                        }
+                        goto out;
+                }
+        }
+        ref = NULL;
+out:
+        return ref;
+}
+
+static void sysctl_print_path(struct ctl_table *table)
+{
+        struct ctl_table *tmp;
+        int depth, i;
+        depth = sysctl_depth(table);
+        if (table->procname) {
+                for (i = depth; i >= 0; i--) {
+                        tmp = sysctl_parent(table, i);
+                        printk("/%s", tmp->procname?tmp->procname:"");
+                }
+        }
+        printk(" ");
+        if (table->ctl_name) {
+                for (i = depth; i >= 0; i--) {
+                        tmp = sysctl_parent(table, i);
+                        printk(".%d", tmp->ctl_name);
+                }
+        }
+}
+
+static void sysctl_repair_table(struct ctl_table *table)
+{
+        /* Don't complain about the classic default
+         * sysctl strategy routine.  Maybe later we
+         * can get the tables fixed and complain about
+         * this.
+         */
+        if (table->ctl_name && table->procname &&
+                (table->proc_handler == proc_dointvec) &&
+                (!table->strategy)) {
+                table->strategy = sysctl_data;
+        }
+}
+
+static struct ctl_table *sysctl_check_lookup(struct ctl_table *table)
+{
+        struct ctl_table_header *head;
+        struct ctl_table *ref, *test;
+        int depth, cur_depth;
+
+        depth = sysctl_depth(table);
+
+        for (head = sysctl_head_next(NULL); head;
+             head = sysctl_head_next(head)) {
+                cur_depth = depth;
+                ref = head->ctl_table;
+repeat:
+                test = sysctl_parent(table, cur_depth);
+                for (; ref->ctl_name || ref->procname; ref++) {
+                        int match = 0;
+                        if (cur_depth && !ref->child)
+                                continue;
+
+                        if (test->procname && ref->procname &&
+                            (strcmp(test->procname, ref->procname) == 0))
+                                        match++;
+
+                        if (test->ctl_name && ref->ctl_name &&
+                            (test->ctl_name == ref->ctl_name))
+                                match++;
+
+                        if (match) {
+                                if (cur_depth != 0) {
+                                        cur_depth--;
+                                        ref = ref->child;
+                                        goto repeat;
+                                }
+                                goto out;
+                        }
+                }
+        }
+        ref = NULL;
+out:
+        sysctl_head_finish(head);
+        return ref;
+}
+
+static void set_fail(const char **fail, struct ctl_table *table, const char *str)
+{
+        if (*fail) {
+                printk(KERN_ERR "sysctl table check failed: ");
+                sysctl_print_path(table);
+                printk(" %s\n", *fail);
+        }
+        *fail = str;
+}
+
+static int sysctl_check_dir(struct ctl_table *table)
+{
+        struct ctl_table *ref;
+        int error;
+
+        error = 0;
+        ref = sysctl_check_lookup(table);
+        if (ref) {
+                int match = 0;
+                if ((!table->procname && !ref->procname) ||
+                    (table->procname && ref->procname &&
+                     (strcmp(table->procname, ref->procname) == 0)))
+                        match++;
+
+                if ((!table->ctl_name && !ref->ctl_name) ||
+                    (table->ctl_name && ref->ctl_name &&
+                     (table->ctl_name == ref->ctl_name)))
+                        match++;
+
+                if (match != 2) {
+                        printk(KERN_ERR "%s: failed: ", __func__);
+                        sysctl_print_path(table);
+                        printk(" ref: ");
+                        sysctl_print_path(ref);
+                        printk("\n");
+                        error = -EINVAL;
+                }
+        }
+        return error;
+}
+
+static void sysctl_check_leaf(struct ctl_table *table, const char **fail)
+{
+        struct ctl_table *ref;
+
+        ref = sysctl_check_lookup(table);
+        if (ref && (ref != table))
+                set_fail(fail, table, "Sysctl already exists");
+}
+
+static void sysctl_check_bin_path(struct ctl_table *table, const char **fail)
+{
+        struct trans_ctl_table *ref;
+
+        ref = sysctl_binary_lookup(table);
+        if (table->ctl_name && !ref)
+                set_fail(fail, table, "Unknown sysctl binary path");
+        if (ref) {
+                if (ref->procname &&
+                    (!table->procname ||
+                     (strcmp(table->procname, ref->procname) != 0)))
+                        set_fail(fail, table, "procname does not match binary path procname");
+
+                if (ref->ctl_name && table->ctl_name &&
+                    (table->ctl_name != ref->ctl_name))
+                        set_fail(fail, table, "ctl_name does not match binary path ctl_name");
+        }
+}
+
+int sysctl_check_table(struct ctl_table *table)
+{
+        int error = 0;
+        for (; table->ctl_name || table->procname; table++) {
+                const char *fail = NULL;
+
+                sysctl_repair_table(table);
+                if (table->parent) {
+                        if (table->procname && !table->parent->procname)
+                                set_fail(&fail, table, "Parent without procname");
+                        if (table->ctl_name && !table->parent->ctl_name)
+                                set_fail(&fail, table, "Parent without ctl_name");
+                }
+                if (!table->procname)
+                        set_fail(&fail, table, "No procname");
+                if (table->child) {
+                        if (table->data)
+                                set_fail(&fail, table, "Directory with data?");
+                        if (table->maxlen)
+                                set_fail(&fail, table, "Directory with maxlen?");
+                        if ((table->mode & (S_IRUGO|S_IXUGO)) != table->mode)
+                                set_fail(&fail, table, "Writable sysctl directory");
+                        if (table->proc_handler)
+                                set_fail(&fail, table, "Directory with proc_handler");
+                        if (table->strategy)
+                                set_fail(&fail, table, "Directory with strategy");
+                        if (table->extra1)
+                                set_fail(&fail, table, "Directory with extra1");
+                        if (table->extra2)
+                                set_fail(&fail, table, "Directory with extra2");
+                        if (sysctl_check_dir(table))
+                                set_fail(&fail, table, "Inconsistent directory names");
+                } else {
+                        if ((table->strategy == sysctl_data) ||
+                            (table->strategy == sysctl_string) ||
+                            (table->strategy == sysctl_intvec) ||
+                            (table->strategy == sysctl_jiffies) ||
+                            (table->strategy == sysctl_ms_jiffies) ||
+                            (table->proc_handler == proc_dostring) ||
+                            (table->proc_handler == proc_dointvec) ||
+#ifdef CONFIG_SECURITY_CAPABILITIES
+                            (table->proc_handler == proc_dointvec_bset) ||
+#endif /* def CONFIG_SECURITY_CAPABILITIES */
+                            (table->proc_handler == proc_dointvec_minmax) ||
+                            (table->proc_handler == proc_dointvec_jiffies) ||
+                            (table->proc_handler == proc_dointvec_userhz_jiffies) ||
+                            (table->proc_handler == proc_dointvec_ms_jiffies) ||
+                            (table->proc_handler == proc_doulongvec_minmax) ||
+                            (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) {
+                                if (!table->data)
+                                        set_fail(&fail, table, "No data");
+                                if (!table->maxlen)
+                                        set_fail(&fail, table, "No maxlen");
+                        }
+                        if ((table->proc_handler == proc_doulongvec_minmax) ||
+                            (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) {
+                                if (table->maxlen > sizeof (unsigned long)) {
+                                        if (!table->extra1)
+                                                set_fail(&fail, table, "No min");
+                                        if (!table->extra2)
+                                                set_fail(&fail, table, "No max");
+                                }
+                        }
+#ifdef CONFIG_SYSCTL_SYSCALL
+                        if (table->ctl_name && !table->strategy)
+                                set_fail(&fail, table, "Missing strategy");
+#endif
+#if 0
+                        if (!table->ctl_name && table->strategy)
+                                set_fail(&fail, table, "Strategy without ctl_name");
+#endif
+#ifdef CONFIG_PROC_FS
+                        if (table->procname && !table->proc_handler)
+                                set_fail(&fail, table, "No proc_handler");
+#endif
+#if 0
+                        if (!table->procname && table->proc_handler)
+                                set_fail(&fail, table, "proc_handler without procname");
+#endif
+                        sysctl_check_leaf(table, &fail);
+                }
+                sysctl_check_bin_path(table, &fail);
+                if (fail) {
+                        set_fail(&fail, table, NULL);
+                        error = -EINVAL;
+                }
+                if (table->child)
+                        error |= sysctl_check_table(table->child);
+        }
+        return error;
+}
diff --git a/kernel/time.c b/kernel/time.c
index 2d5b6a682138..09d3c45c4da7 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -9,9 +9,9 @@
  */
 /*
  * Modification history kernel/time.c
- * 
+ *
  * 1993-09-02    Philip Gladstone
- *      Created file with time related functions from sched.c and adjtimex() 
+ *      Created file with time related functions from sched.c and adjtimex()
  * 1993-10-08    Torsten Duwe
  *      adjtime interface update and CMOS clock write code
  * 1995-08-13    Torsten Duwe
@@ -30,6 +30,7 @@
 #include <linux/module.h>
 #include <linux/timex.h>
 #include <linux/capability.h>
+#include <linux/clocksource.h>
 #include <linux/errno.h>
 #include <linux/syscalls.h>
 #include <linux/security.h>
@@ -38,7 +39,7 @@
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 
-/* 
+/*
  * The timezone where the local system is located.  Used as a default by some
  * programs who obtain this value by using gettimeofday.
  */
@@ -71,7 +72,7 @@ asmlinkage long sys_time(time_t __user * tloc)
  * why not move it into the appropriate arch directory (for those
  * architectures that need it).
  */
- 
+
 asmlinkage long sys_stime(time_t __user *tptr)
 {
         struct timespec tv;
@@ -110,10 +111,10 @@ asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __us
 /*
  * Adjust the time obtained from the CMOS to be UTC time instead of
  * local time.
- * 
+ *
  * This is ugly, but preferable to the alternatives.  Otherwise we
  * would either need to write a program to do it in /etc/rc (and risk
- * confusion if the program gets run more than once; it would also be 
+ * confusion if the program gets run more than once; it would also be
  * hard to make the program warp the clock precisely n hours)  or
  * compile in the timezone information into the kernel.  Bad, bad....
  *
@@ -158,6 +159,7 @@ int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
         if (tz) {
                 /* SMP safe, global irq locking makes it work. */
                 sys_tz = *tz;
+                update_vsyscall_tz();
                 if (firsttime) {
                         firsttime = 0;
                         if (!tv)
diff --git a/kernel/timer.c b/kernel/timer.c
index 6ce1952eea7d..8521d10fbb27 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -817,7 +817,7 @@ unsigned long next_timer_interrupt(void)
 #endif
 
 /*
- * Called from the timer interrupt handler to charge one tick to the current 
+ * Called from the timer interrupt handler to charge one tick to the current
  * process.  user_tick is 1 if the tick is user time, 0 for system.
  */
 void update_process_times(int user_tick)
@@ -826,10 +826,13 @@ void update_process_times(int user_tick)
         int cpu = smp_processor_id();
 
         /* Note: this timer irq context must be accounted for as well. */
-        if (user_tick)
+        if (user_tick) {
                 account_user_time(p, jiffies_to_cputime(1));
-        else
+                account_user_time_scaled(p, jiffies_to_cputime(1));
+        } else {
                 account_system_time(p, HARDIRQ_OFFSET, jiffies_to_cputime(1));
+                account_system_time_scaled(p, jiffies_to_cputime(1));
+        }
         run_local_timers();
         if (rcu_pending(cpu))
                 rcu_check_callbacks(cpu, user_tick);
diff --git a/kernel/tsacct.c b/kernel/tsacct.c
index c122131a122f..4ab1b584961b 100644
--- a/kernel/tsacct.c
+++ b/kernel/tsacct.c
@@ -62,6 +62,10 @@ void bacct_add_tsk(struct taskstats *stats, struct task_struct *tsk)
         rcu_read_unlock();
         stats->ac_utime  = cputime_to_msecs(tsk->utime) * USEC_PER_MSEC;
         stats->ac_stime  = cputime_to_msecs(tsk->stime) * USEC_PER_MSEC;
+        stats->ac_utimescaled =
+                cputime_to_msecs(tsk->utimescaled) * USEC_PER_MSEC;
+        stats->ac_stimescaled =
+                cputime_to_msecs(tsk->stimescaled) * USEC_PER_MSEC;
         stats->ac_minflt = tsk->min_flt;
         stats->ac_majflt = tsk->maj_flt;