Merge branch 'akpm' (patches from Andrew Morton) into next

Merge more updates from Andrew Morton:

 - Most of the rest of MM.

   This includes "mark remap_file_pages syscall as deprecated" but the
   actual "replace remap_file_pages syscall with emulation" is held
   back.  I guess we'll need to work out when to pull the trigger on
   that one.

 - various minor cleanups to obscure filesystems

 - the drivers/rtc queue

 - hfsplus updates

 - ufs, hpfs, fatfs, affs, reiserfs

 - Documentation/

 - signals

 - procfs

 - cpu hotplug

 - lib/idr.c

 - rapidio

 - sysctl

 - ipc updates

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (171 commits)
  ufs: sb mutex merge + mutex_destroy
  powerpc: update comments for generic idle conversion
  cris: update comments for generic idle conversion
  idle: remove cpu_idle() forward declarations
  nbd: zero from and len fields in NBD_CMD_DISCONNECT.
  mm: convert some level-less printks to pr_*
  MAINTAINERS: adi-buildroot-devel is moderated
  MAINTAINERS: add linux-api for review of API/ABI changes
  mm/kmemleak-test.c: use pr_fmt for logging
  fs/dlm/debug_fs.c: replace seq_printf by seq_puts
  fs/dlm/lockspace.c: convert simple_str to kstr
  fs/dlm/config.c: convert simple_str to kstr
  mm: mark remap_file_pages() syscall as deprecated
  mm: memcontrol: remove unnecessary memcg argument from soft limit functions
  mm: memcontrol: clean up memcg zoneinfo lookup
  mm/memblock.c: call kmemleak directly from memblock_(alloc|free)
  mm/mempool.c: update the kmemleak stack trace for mempool allocations
  lib/radix-tree.c: update the kmemleak stack trace for radix tree allocations
  mm: introduce kmemleak_update_trace()
  mm/kmemleak.c: use %u to print ->checksum
  ...

14 files changed, 234 insertions, 186 deletions

diff --git a/kernel/acct.c b/kernel/acct.c
index 8d6e145138bb..808a86ff229d 100644
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -55,7 +55,7 @@
 #include <linux/times.h>
 #include <linux/syscalls.h>
 #include <linux/mount.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/div64.h>
 #include <linux/blkdev.h> /* sector_div */
 #include <linux/pid_namespace.h>
@@ -134,7 +134,7 @@ static int check_free_space(struct bsd_acct_struct *acct, struct file *file)
         spin_lock(&acct_lock);
         if (file != acct->file) {
                 if (act)
-                        res = act>0;
+                        res = act > 0;
                 goto out;
         }
 
@@ -262,7 +262,7 @@ SYSCALL_DEFINE1(acct, const char __user *, name)
         if (name) {
                 struct filename *tmp = getname(name);
                 if (IS_ERR(tmp))
-                        return (PTR_ERR(tmp));
+                        return PTR_ERR(tmp);
                 error = acct_on(tmp);
                 putname(tmp);
         } else {
diff --git a/kernel/audit.c b/kernel/audit.c
index 47845c57eb19..f30106459a32 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -44,7 +44,7 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/init.h>
-#include <asm/types.h>
+#include <linux/types.h>
 #include <linux/atomic.h>
 #include <linux/mm.h>
 #include <linux/export.h>
diff --git a/kernel/exit.c b/kernel/exit.c
index 750c2e594617..e5c4668f1799 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -313,45 +313,6 @@ kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
         }
 }
 
-/*
- * Let kernel threads use this to say that they allow a certain signal.
- * Must not be used if kthread was cloned with CLONE_SIGHAND.
- */
-int allow_signal(int sig)
-{
-        if (!valid_signal(sig) || sig < 1)
-                return -EINVAL;
-
-        spin_lock_irq(&current->sighand->siglock);
-        /* This is only needed for daemonize()'ed kthreads */
-        sigdelset(&current->blocked, sig);
-        /*
-         * Kernel threads handle their own signals. Let the signal code
-         * know it'll be handled, so that they don't get converted to
-         * SIGKILL or just silently dropped.
-         */
-        current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        return 0;
-}
-
-EXPORT_SYMBOL(allow_signal);
-
-int disallow_signal(int sig)
-{
-        if (!valid_signal(sig) || sig < 1)
-                return -EINVAL;
-
-        spin_lock_irq(&current->sighand->siglock);
-        current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        return 0;
-}
-
-EXPORT_SYMBOL(disallow_signal);
-
 #ifdef CONFIG_MEMCG
 /*
  * A task is exiting.   If it owned this mm, find a new owner for the mm.
diff --git a/kernel/fork.c b/kernel/fork.c
index 0d53eb0dfb6f..d2799d1fc952 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1606,10 +1606,12 @@ long do_fork(unsigned long clone_flags,
          */
         if (!IS_ERR(p)) {
                 struct completion vfork;
+                struct pid *pid;
 
                 trace_sched_process_fork(current, p);
 
-                nr = task_pid_vnr(p);
+                pid = get_task_pid(p, PIDTYPE_PID);
+                nr = pid_vnr(pid);
 
                 if (clone_flags & CLONE_PARENT_SETTID)
                         put_user(nr, parent_tidptr);
@@ -1624,12 +1626,14 @@ long do_fork(unsigned long clone_flags,
 
                 /* forking complete and child started to run, tell ptracer */
                 if (unlikely(trace))
-                        ptrace_event(trace, nr);
+                        ptrace_event_pid(trace, pid);
 
                 if (clone_flags & CLONE_VFORK) {
                         if (!wait_for_vfork_done(p, &vfork))
-                                ptrace_event(PTRACE_EVENT_VFORK_DONE, nr);
+                                ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
                 }
+
+                put_pid(pid);
         } else {
                 nr = PTR_ERR(p);
         }
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 28c57069ef68..6748688813d0 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -125,8 +125,8 @@ static struct page *kimage_alloc_page(struct kimage *image,
                                        unsigned long dest);
 
 static int do_kimage_alloc(struct kimage **rimage, unsigned long entry,
-                            unsigned long nr_segments,
-                            struct kexec_segment __user *segments)
+                           unsigned long nr_segments,
+                           struct kexec_segment __user *segments)
 {
         size_t segment_bytes;
         struct kimage *image;
@@ -257,13 +257,13 @@ static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
         image->control_code_page = kimage_alloc_control_pages(image,
                                            get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
-                printk(KERN_ERR "Could not allocate control_code_buffer\n");
+                pr_err("Could not allocate control_code_buffer\n");
                 goto out_free;
         }
 
         image->swap_page = kimage_alloc_control_pages(image, 0);
         if (!image->swap_page) {
-                printk(KERN_ERR "Could not allocate swap buffer\n");
+                pr_err("Could not allocate swap buffer\n");
                 goto out_free;
         }
 
@@ -332,7 +332,7 @@ static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
         image->control_code_page = kimage_alloc_control_pages(image,
                                            get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
-                printk(KERN_ERR "Could not allocate control_code_buffer\n");
+                pr_err("Could not allocate control_code_buffer\n");
                 goto out_free;
         }
 
@@ -621,8 +621,8 @@ static void kimage_terminate(struct kimage *image)
 
 #define for_each_kimage_entry(image, ptr, entry) \
         for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
-                ptr = (entry & IND_INDIRECTION)? \
-                        phys_to_virt((entry & PAGE_MASK)): ptr +1)
+                ptr = (entry & IND_INDIRECTION) ? \
+                        phys_to_virt((entry & PAGE_MASK)) : ptr + 1)
 
 static void kimage_free_entry(kimage_entry_t entry)
 {
@@ -650,8 +650,7 @@ static void kimage_free(struct kimage *image)
                          * done with it.
                          */
                         ind = entry;
-                }
-                else if (entry & IND_SOURCE)
+                } else if (entry & IND_SOURCE)
                         kimage_free_entry(entry);
         }
         /* Free the final indirection page */
@@ -774,8 +773,7 @@ static struct page *kimage_alloc_page(struct kimage *image,
                         addr = old_addr;
                         page = old_page;
                         break;
-                }
-                else {
+                } else {
                         /* Place the page on the destination list I
                          * will use it later.
                          */
@@ -1059,7 +1057,7 @@ COMPAT_SYSCALL_DEFINE4(kexec_load, compat_ulong_t, entry,
                 return -EINVAL;
 
         ksegments = compat_alloc_user_space(nr_segments * sizeof(out));
-        for (i=0; i < nr_segments; i++) {
+        for (i = 0; i < nr_segments; i++) {
                 result = copy_from_user(&in, &segments[i], sizeof(in));
                 if (result)
                         return -EFAULT;
@@ -1214,14 +1212,14 @@ void crash_save_cpu(struct pt_regs *regs, int cpu)
          * squirrelled away.  ELF notes happen to provide
          * all of that, so there is no need to invent something new.
          */
-        buf = (u32*)per_cpu_ptr(crash_notes, cpu);
+        buf = (u32 *)per_cpu_ptr(crash_notes, cpu);
         if (!buf)
                 return;
         memset(&prstatus, 0, sizeof(prstatus));
         prstatus.pr_pid = current->pid;
         elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
         buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS,
-                              &prstatus, sizeof(prstatus));
+                              &prstatus, sizeof(prstatus));
         final_note(buf);
 }
 
@@ -1230,8 +1228,7 @@ static int __init crash_notes_memory_init(void)
         /* Allocate memory for saving cpu registers. */
         crash_notes = alloc_percpu(note_buf_t);
         if (!crash_notes) {
-                printk("Kexec: Memory allocation for saving cpu register"
-                " states failed\n");
+                pr_warn("Kexec: Memory allocation for saving cpu register states failed\n");
                 return -ENOMEM;
         }
         return 0;
@@ -1253,10 +1250,10 @@ subsys_initcall(crash_notes_memory_init);
  *
  * The function returns 0 on success and -EINVAL on failure.
  */
-static int __init parse_crashkernel_mem(char                    *cmdline,
-                                        unsigned long long      system_ram,
-                                        unsigned long long      *crash_size,
-                                        unsigned long long      *crash_base)
+static int __init parse_crashkernel_mem(char *cmdline,
+                                        unsigned long long system_ram,
+                                        unsigned long long *crash_size,
+                                        unsigned long long *crash_base)
 {
         char *cur = cmdline, *tmp;
 
@@ -1267,12 +1264,12 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
                 /* get the start of the range */
                 start = memparse(cur, &tmp);
                 if (cur == tmp) {
-                        pr_warning("crashkernel: Memory value expected\n");
+                        pr_warn("crashkernel: Memory value expected\n");
                         return -EINVAL;
                 }
                 cur = tmp;
                 if (*cur != '-') {
-                        pr_warning("crashkernel: '-' expected\n");
+                        pr_warn("crashkernel: '-' expected\n");
                         return -EINVAL;
                 }
                 cur++;
@@ -1281,31 +1278,30 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
                 if (*cur != ':') {
                         end = memparse(cur, &tmp);
                         if (cur == tmp) {
-                                pr_warning("crashkernel: Memory "
-                                                "value expected\n");
+                                pr_warn("crashkernel: Memory value expected\n");
                                 return -EINVAL;
                         }
                         cur = tmp;
                         if (end <= start) {
-                                pr_warning("crashkernel: end <= start\n");
+                                pr_warn("crashkernel: end <= start\n");
                                 return -EINVAL;
                         }
                 }
 
                 if (*cur != ':') {
-                        pr_warning("crashkernel: ':' expected\n");
+                        pr_warn("crashkernel: ':' expected\n");
                         return -EINVAL;
                 }
                 cur++;
 
                 size = memparse(cur, &tmp);
                 if (cur == tmp) {
-                        pr_warning("Memory value expected\n");
+                        pr_warn("Memory value expected\n");
                         return -EINVAL;
                 }
                 cur = tmp;
                 if (size >= system_ram) {
-                        pr_warning("crashkernel: invalid size\n");
+                        pr_warn("crashkernel: invalid size\n");
                         return -EINVAL;
                 }
 
@@ -1323,8 +1319,7 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
                         cur++;
                         *crash_base = memparse(cur, &tmp);
                         if (cur == tmp) {
-                                pr_warning("Memory value expected "
-                                                "after '@'\n");
+                                pr_warn("Memory value expected after '@'\n");
                                 return -EINVAL;
                         }
                 }
@@ -1336,26 +1331,26 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
 /*
  * That function parses "simple" (old) crashkernel command lines like
  *
- *      crashkernel=size[@offset]
+ *      crashkernel=size[@offset]
  *
  * It returns 0 on success and -EINVAL on failure.
  */
-static int __init parse_crashkernel_simple(char                 *cmdline,
-                                           unsigned long long   *crash_size,
-                                           unsigned long long   *crash_base)
+static int __init parse_crashkernel_simple(char *cmdline,
+                                           unsigned long long *crash_size,
+                                           unsigned long long *crash_base)
 {
         char *cur = cmdline;
 
         *crash_size = memparse(cmdline, &cur);
         if (cmdline == cur) {
-                pr_warning("crashkernel: memory value expected\n");
+                pr_warn("crashkernel: memory value expected\n");
                 return -EINVAL;
         }
 
         if (*cur == '@')
                 *crash_base = memparse(cur+1, &cur);
         else if (*cur != ' ' && *cur != '\0') {
-                pr_warning("crashkernel: unrecognized char\n");
+                pr_warn("crashkernel: unrecognized char\n");
                 return -EINVAL;
         }
 
@@ -1691,7 +1686,7 @@ int kernel_kexec(void)
                  * CPU hotplug again; so re-enable it here.
                  */
                 cpu_hotplug_enable();
-                printk(KERN_EMERG "Starting new kernel\n");
+                pr_emerg("Starting new kernel\n");
                 machine_shutdown();
         }
 
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 0ac67a5861c5..8637e041a247 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -285,10 +285,7 @@ static int wait_for_helper(void *data)
         pid_t pid;
 
         /* If SIGCLD is ignored sys_wait4 won't populate the status. */
-        spin_lock_irq(&current->sighand->siglock);
-        current->sighand->action[SIGCHLD-1].sa.sa_handler = SIG_DFL;
-        spin_unlock_irq(&current->sighand->siglock);
-
+        kernel_sigaction(SIGCHLD, SIG_DFL);
         pid = kernel_thread(____call_usermodehelper, sub_info, SIGCHLD);
         if (pid < 0) {
                 sub_info->retval = pid;
diff --git a/kernel/panic.c b/kernel/panic.c
index d02fa9fef46a..62e16cef9cc2 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -32,6 +32,7 @@ static unsigned long tainted_mask;
 static int pause_on_oops;
 static int pause_on_oops_flag;
 static DEFINE_SPINLOCK(pause_on_oops_lock);
+static bool crash_kexec_post_notifiers;
 
 int panic_timeout = CONFIG_PANIC_TIMEOUT;
 EXPORT_SYMBOL_GPL(panic_timeout);
@@ -112,9 +113,11 @@ void panic(const char *fmt, ...)
         /*
          * If we have crashed and we have a crash kernel loaded let it handle
          * everything else.
-         * Do we want to call this before we try to display a message?
+         * If we want to run this after calling panic_notifiers, pass
+         * the "crash_kexec_post_notifiers" option to the kernel.
          */
-        crash_kexec(NULL);
+        if (!crash_kexec_post_notifiers)
+                crash_kexec(NULL);
 
         /*
          * Note smp_send_stop is the usual smp shutdown function, which
@@ -131,6 +134,15 @@ void panic(const char *fmt, ...)
 
         kmsg_dump(KMSG_DUMP_PANIC);
 
+        /*
+         * If you doubt kdump always works fine in any situation,
+         * "crash_kexec_post_notifiers" offers you a chance to run
+         * panic_notifiers and dumping kmsg before kdump.
+         * Note: since some panic_notifiers can make crashed kernel
+         * more unstable, it can increase risks of the kdump failure too.
+         */
+        crash_kexec(NULL);
+
         bust_spinlocks(0);
 
         if (!panic_blink)
@@ -472,6 +484,13 @@ EXPORT_SYMBOL(__stack_chk_fail);
 core_param(panic, panic_timeout, int, 0644);
 core_param(pause_on_oops, pause_on_oops, int, 0644);
 
+static int __init setup_crash_kexec_post_notifiers(char *s)
+{
+        crash_kexec_post_notifiers = true;
+        return 0;
+}
+early_param("crash_kexec_post_notifiers", setup_crash_kexec_post_notifiers);
+
 static int __init oops_setup(char *s)
 {
         if (!s)
diff --git a/kernel/profile.c b/kernel/profile.c
index cb980f0c731b..54bf5ba26420 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -52,9 +52,9 @@ static DEFINE_MUTEX(profile_flip_mutex);
 
 int profile_setup(char *str)
 {
-        static char schedstr[] = "schedule";
-        static char sleepstr[] = "sleep";
-        static char kvmstr[] = "kvm";
+        static const char schedstr[] = "schedule";
+        static const char sleepstr[] = "sleep";
+        static const char kvmstr[] = "kvm";
         int par;
 
         if (!strncmp(str, sleepstr, strlen(sleepstr))) {
@@ -64,12 +64,10 @@ int profile_setup(char *str)
                         str += strlen(sleepstr) + 1;
                 if (get_option(&str, &par))
                         prof_shift = par;
-                printk(KERN_INFO
-                        "kernel sleep profiling enabled (shift: %ld)\n",
+                pr_info("kernel sleep profiling enabled (shift: %ld)\n",
                         prof_shift);
 #else
-                printk(KERN_WARNING
-                        "kernel sleep profiling requires CONFIG_SCHEDSTATS\n");
+                pr_warn("kernel sleep profiling requires CONFIG_SCHEDSTATS\n");
 #endif /* CONFIG_SCHEDSTATS */
         } else if (!strncmp(str, schedstr, strlen(schedstr))) {
                 prof_on = SCHED_PROFILING;
@@ -77,8 +75,7 @@ int profile_setup(char *str)
                         str += strlen(schedstr) + 1;
                 if (get_option(&str, &par))
                         prof_shift = par;
-                printk(KERN_INFO
-                        "kernel schedule profiling enabled (shift: %ld)\n",
+                pr_info("kernel schedule profiling enabled (shift: %ld)\n",
                         prof_shift);
         } else if (!strncmp(str, kvmstr, strlen(kvmstr))) {
                 prof_on = KVM_PROFILING;
@@ -86,13 +83,12 @@ int profile_setup(char *str)
                         str += strlen(kvmstr) + 1;
                 if (get_option(&str, &par))
                         prof_shift = par;
-                printk(KERN_INFO
-                        "kernel KVM profiling enabled (shift: %ld)\n",
+                pr_info("kernel KVM profiling enabled (shift: %ld)\n",
                         prof_shift);
         } else if (get_option(&str, &par)) {
                 prof_shift = par;
                 prof_on = CPU_PROFILING;
-                printk(KERN_INFO "kernel profiling enabled (shift: %ld)\n",
+                pr_info("kernel profiling enabled (shift: %ld)\n",
                         prof_shift);
         }
         return 1;
diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index b35c21503a36..f6d76bebe69f 100644
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -39,7 +39,7 @@
  *         is only needed for handling filters shared across tasks.
  * @prev: points to a previously installed, or inherited, filter
  * @len: the number of instructions in the program
- * @insns: the BPF program instructions to evaluate
+ * @insnsi: the BPF program instructions to evaluate
  *
  * seccomp_filter objects are organized in a tree linked via the @prev
  * pointer.  For any task, it appears to be a singly-linked list starting
@@ -220,7 +220,7 @@ static long seccomp_attach_filter(struct sock_fprog *fprog)
                 return -ENOMEM;
 
         /*
-         * Installing a seccomp filter requires that the task have
+         * Installing a seccomp filter requires that the task has
          * CAP_SYS_ADMIN in its namespace or be running with no_new_privs.
          * This avoids scenarios where unprivileged tasks can affect the
          * behavior of privileged children.
diff --git a/kernel/signal.c b/kernel/signal.c
index 6e600aaa2af4..a4077e90f19f 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -277,6 +277,7 @@ void task_clear_jobctl_trapping(struct task_struct *task)
 {
         if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
                 task->jobctl &= ~JOBCTL_TRAPPING;
+                smp_mb();       /* advised by wake_up_bit() */
                 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
         }
 }
@@ -705,11 +706,8 @@ void signal_wake_up_state(struct task_struct *t, unsigned int state)
  * Returns 1 if any signals were found.
  *
  * All callers must be holding the siglock.
- *
- * This version takes a sigset mask and looks at all signals,
- * not just those in the first mask word.
  */
-static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
+static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
 {
         struct sigqueue *q, *n;
         sigset_t m;
@@ -727,29 +725,6 @@ static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
         }
         return 1;
 }
-/*
- * Remove signals in mask from the pending set and queue.
- * Returns 1 if any signals were found.
- *
- * All callers must be holding the siglock.
- */
-static int rm_from_queue(unsigned long mask, struct sigpending *s)
-{
-        struct sigqueue *q, *n;
-
-        if (!sigtestsetmask(&s->signal, mask))
-                return 0;
-
-        sigdelsetmask(&s->signal, mask);
-        list_for_each_entry_safe(q, n, &s->list, list) {
-                if (q->info.si_signo < SIGRTMIN &&
-                    (mask & sigmask(q->info.si_signo))) {
-                        list_del_init(&q->list);
-                        __sigqueue_free(q);
-                }
-        }
-        return 1;
-}
 
 static inline int is_si_special(const struct siginfo *info)
 {
@@ -861,6 +836,7 @@ static bool prepare_signal(int sig, struct task_struct *p, bool force)
 {
         struct signal_struct *signal = p->signal;
         struct task_struct *t;
+        sigset_t flush;
 
         if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
                 if (signal->flags & SIGNAL_GROUP_COREDUMP)
@@ -872,26 +848,25 @@ static bool prepare_signal(int sig, struct task_struct *p, bool force)
                 /*
                  * This is a stop signal.  Remove SIGCONT from all queues.
                  */
-                rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
-                t = p;
-                do {
-                        rm_from_queue(sigmask(SIGCONT), &t->pending);
-                } while_each_thread(p, t);
+                siginitset(&flush, sigmask(SIGCONT));
+                flush_sigqueue_mask(&flush, &signal->shared_pending);
+                for_each_thread(p, t)
+                        flush_sigqueue_mask(&flush, &t->pending);
         } else if (sig == SIGCONT) {
                 unsigned int why;
                 /*
                  * Remove all stop signals from all queues, wake all threads.
                  */
-                rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
-                t = p;
-                do {
+                siginitset(&flush, SIG_KERNEL_STOP_MASK);
+                flush_sigqueue_mask(&flush, &signal->shared_pending);
+                for_each_thread(p, t) {
+                        flush_sigqueue_mask(&flush, &t->pending);
                         task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
-                        rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
                         if (likely(!(t->ptrace & PT_SEIZED)))
                                 wake_up_state(t, __TASK_STOPPED);
                         else
                                 ptrace_trap_notify(t);
-                } while_each_thread(p, t);
+                }
 
                 /*
                  * Notify the parent with CLD_CONTINUED if we were stopped.
@@ -2854,7 +2829,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
 
                 spin_lock_irq(&tsk->sighand->siglock);
                 __set_task_blocked(tsk, &tsk->real_blocked);
-                siginitset(&tsk->real_blocked, 0);
+                sigemptyset(&tsk->real_blocked);
                 sig = dequeue_signal(tsk, &mask, info);
         }
         spin_unlock_irq(&tsk->sighand->siglock);
@@ -3091,18 +3066,39 @@ COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
 }
 #endif
 
+/*
+ * For kthreads only, must not be used if cloned with CLONE_SIGHAND
+ */
+void kernel_sigaction(int sig, __sighandler_t action)
+{
+        spin_lock_irq(&current->sighand->siglock);
+        current->sighand->action[sig - 1].sa.sa_handler = action;
+        if (action == SIG_IGN) {
+                sigset_t mask;
+
+                sigemptyset(&mask);
+                sigaddset(&mask, sig);
+
+                flush_sigqueue_mask(&mask, &current->signal->shared_pending);
+                flush_sigqueue_mask(&mask, &current->pending);
+                recalc_sigpending();
+        }
+        spin_unlock_irq(&current->sighand->siglock);
+}
+EXPORT_SYMBOL(kernel_sigaction);
+
 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
 {
-        struct task_struct *t = current;
+        struct task_struct *p = current, *t;
         struct k_sigaction *k;
         sigset_t mask;
 
         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
                 return -EINVAL;
 
-        k = &t->sighand->action[sig-1];
+        k = &p->sighand->action[sig-1];
 
-        spin_lock_irq(&current->sighand->siglock);
+        spin_lock_irq(&p->sighand->siglock);
         if (oact)
                 *oact = *k;
 
@@ -3121,21 +3117,20 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
                  *   (for example, SIGCHLD), shall cause the pending signal to
                  *   be discarded, whether or not it is blocked"
                  */
-                if (sig_handler_ignored(sig_handler(t, sig), sig)) {
+                if (sig_handler_ignored(sig_handler(p, sig), sig)) {
                         sigemptyset(&mask);
                         sigaddset(&mask, sig);
-                        rm_from_queue_full(&mask, &t->signal->shared_pending);
-                        do {
-                                rm_from_queue_full(&mask, &t->pending);
-                        } while_each_thread(current, t);
+                        flush_sigqueue_mask(&mask, &p->signal->shared_pending);
+                        for_each_thread(p, t)
+                                flush_sigqueue_mask(&mask, &t->pending);
                 }
         }
 
-        spin_unlock_irq(&current->sighand->siglock);
+        spin_unlock_irq(&p->sighand->siglock);
         return 0;
 }
 
-static int 
+static int
 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
 {
         stack_t oss;
diff --git a/kernel/smp.c b/kernel/smp.c
index 06d574e42c72..306f8180b0d5 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -185,14 +185,26 @@ void generic_smp_call_function_single_interrupt(void)
 {
         struct llist_node *entry;
         struct call_single_data *csd, *csd_next;
+        static bool warned;
+
+        entry = llist_del_all(&__get_cpu_var(call_single_queue));
+        entry = llist_reverse_order(entry);
 
         /*
          * Shouldn't receive this interrupt on a cpu that is not yet online.
          */
-        WARN_ON_ONCE(!cpu_online(smp_processor_id()));
+        if (unlikely(!cpu_online(smp_processor_id()) && !warned)) {
+                warned = true;
+                WARN(1, "IPI on offline CPU %d\n", smp_processor_id());
 
-        entry = llist_del_all(&__get_cpu_var(call_single_queue));
-        entry = llist_reverse_order(entry);
+                /*
+                 * We don't have to use the _safe() variant here
+                 * because we are not invoking the IPI handlers yet.
+                 */
+                llist_for_each_entry(csd, entry, llist)
+                        pr_warn("IPI callback %pS sent to offline CPU\n",
+                                csd->func);
+        }
 
         llist_for_each_entry_safe(csd, csd_next, entry, llist) {
                 csd->func(csd->info);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 40ce2d983b12..db19e3e2aa4b 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -173,6 +173,13 @@ extern int no_unaligned_warning;
 #endif
 
 #ifdef CONFIG_PROC_SYSCTL
+
+#define SYSCTL_WRITES_LEGACY    -1
+#define SYSCTL_WRITES_WARN       0
+#define SYSCTL_WRITES_STRICT     1
+
+static int sysctl_writes_strict = SYSCTL_WRITES_WARN;
+
 static int proc_do_cad_pid(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos);
 static int proc_taint(struct ctl_table *table, int write,
@@ -195,7 +202,7 @@ static int proc_dostring_coredump(struct ctl_table *table, int write,
 /* Note: sysrq code uses it's own private copy */
 static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
 
-static int sysrq_sysctl_handler(ctl_table *table, int write,
+static int sysrq_sysctl_handler(struct ctl_table *table, int write,
                                 void __user *buffer, size_t *lenp,
                                 loff_t *ppos)
 {
@@ -495,6 +502,15 @@ static struct ctl_table kern_table[] = {
                 .mode           = 0644,
                 .proc_handler   = proc_taint,
         },
+        {
+                .procname       = "sysctl_writes_strict",
+                .data           = &sysctl_writes_strict,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec_minmax,
+                .extra1         = &neg_one,
+                .extra2         = &one,
+        },
 #endif
 #ifdef CONFIG_LATENCYTOP
         {
@@ -1703,8 +1719,8 @@ int __init sysctl_init(void)
 
 #ifdef CONFIG_PROC_SYSCTL
 
-static int _proc_do_string(void* data, int maxlen, int write,
-                           void __user *buffer,
+static int _proc_do_string(char *data, int maxlen, int write,
+                           char __user *buffer,
                            size_t *lenp, loff_t *ppos)
 {
         size_t len;
@@ -1717,21 +1733,30 @@ static int _proc_do_string(void* data, int maxlen, int write,
         }
 
         if (write) {
-                len = 0;
+                if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
+                        /* Only continue writes not past the end of buffer. */
+                        len = strlen(data);
+                        if (len > maxlen - 1)
+                                len = maxlen - 1;
+
+                        if (*ppos > len)
+                                return 0;
+                        len = *ppos;
+                } else {
+                        /* Start writing from beginning of buffer. */
+                        len = 0;
+                }
+
+                *ppos += *lenp;
                 p = buffer;
-                while (len < *lenp) {
+                while ((p - buffer) < *lenp && len < maxlen - 1) {
                         if (get_user(c, p++))
                                 return -EFAULT;
                         if (c == 0 || c == '\n')
                                 break;
-                        len++;
+                        data[len++] = c;
                 }
-                if (len >= maxlen)
-                        len = maxlen-1;
-                if(copy_from_user(data, buffer, len))
-                        return -EFAULT;
-                ((char *) data)[len] = 0;
-                *ppos += *lenp;
+                data[len] = 0;
         } else {
                 len = strlen(data);
                 if (len > maxlen)
@@ -1748,10 +1773,10 @@ static int _proc_do_string(void* data, int maxlen, int write,
                 if (len > *lenp)
                         len = *lenp;
                 if (len)
-                        if(copy_to_user(buffer, data, len))
+                        if (copy_to_user(buffer, data, len))
                                 return -EFAULT;
                 if (len < *lenp) {
-                        if(put_user('\n', ((char __user *) buffer) + len))
+                        if (put_user('\n', buffer + len))
                                 return -EFAULT;
                         len++;
                 }
@@ -1761,6 +1786,14 @@ static int _proc_do_string(void* data, int maxlen, int write,
         return 0;
 }
 
+static void warn_sysctl_write(struct ctl_table *table)
+{
+        pr_warn_once("%s wrote to %s when file position was not 0!\n"
+                "This will not be supported in the future. To silence this\n"
+                "warning, set kernel.sysctl_writes_strict = -1\n",
+                current->comm, table->procname);
+}
+
 /**
  * proc_dostring - read a string sysctl
  * @table: the sysctl table
@@ -1781,8 +1814,11 @@ static int _proc_do_string(void* data, int maxlen, int write,
 int proc_dostring(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        return _proc_do_string(table->data, table->maxlen, write,
-                               buffer, lenp, ppos);
+        if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
+                warn_sysctl_write(table);
+
+        return _proc_do_string((char *)(table->data), table->maxlen, write,
+                               (char __user *)buffer, lenp, ppos);
 }
 
 static size_t proc_skip_spaces(char **buf)
@@ -1956,6 +1992,18 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
                 conv = do_proc_dointvec_conv;
 
         if (write) {
+                if (*ppos) {
+                        switch (sysctl_writes_strict) {
+                        case SYSCTL_WRITES_STRICT:
+                                goto out;
+                        case SYSCTL_WRITES_WARN:
+                                warn_sysctl_write(table);
+                                break;
+                        default:
+                                break;
+                        }
+                }
+
                 if (left > PAGE_SIZE - 1)
                         left = PAGE_SIZE - 1;
                 page = __get_free_page(GFP_TEMPORARY);
@@ -2013,6 +2061,7 @@ free:
                         return err ? : -EINVAL;
         }
         *lenp -= left;
+out:
         *ppos += *lenp;
         return err;
 }
@@ -2205,6 +2254,18 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
         left = *lenp;
 
         if (write) {
+                if (*ppos) {
+                        switch (sysctl_writes_strict) {
+                        case SYSCTL_WRITES_STRICT:
+                                goto out;
+                        case SYSCTL_WRITES_WARN:
+                                warn_sysctl_write(table);
+                                break;
+                        default:
+                                break;
+                        }
+                }
+
                 if (left > PAGE_SIZE - 1)
                         left = PAGE_SIZE - 1;
                 page = __get_free_page(GFP_TEMPORARY);
@@ -2260,6 +2321,7 @@ free:
                         return err ? : -EINVAL;
         }
         *lenp -= left;
+out:
         *ppos += *lenp;
         return err;
 }
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index bf71b4b2d632..fcc02560fd6b 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -286,7 +286,7 @@ EXPORT_SYMBOL(from_kuid_munged);
 /**
  *      make_kgid - Map a user-namespace gid pair into a kgid.
  *      @ns:  User namespace that the gid is in
- *      @uid: group identifier
+ *      @gid: group identifier
  *
  *      Maps a user-namespace gid pair into a kernel internal kgid,
  *      and returns that kgid.
@@ -482,7 +482,8 @@ static int projid_m_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static void *m_start(struct seq_file *seq, loff_t *ppos, struct uid_gid_map *map)
+static void *m_start(struct seq_file *seq, loff_t *ppos,
+                     struct uid_gid_map *map)
 {
         struct uid_gid_extent *extent = NULL;
         loff_t pos = *ppos;
@@ -546,7 +547,8 @@ struct seq_operations proc_projid_seq_operations = {
         .show = projid_m_show,
 };
 
-static bool mappings_overlap(struct uid_gid_map *new_map, struct uid_gid_extent *extent)
+static bool mappings_overlap(struct uid_gid_map *new_map,
+                             struct uid_gid_extent *extent)
 {
         u32 upper_first, lower_first, upper_last, lower_last;
         unsigned idx;
@@ -653,7 +655,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,
         ret = -EINVAL;
         pos = kbuf;
         new_map.nr_extents = 0;
-        for (;pos; pos = next_line) {
+        for (; pos; pos = next_line) {
                 extent = &new_map.extent[new_map.nr_extents];
 
                 /* Find the end of line and ensure I don't look past it */
@@ -687,13 +689,16 @@ static ssize_t map_write(struct file *file, const char __user *buf,
 
                 /* Verify we have been given valid starting values */
                 if ((extent->first == (u32) -1) ||
-                    (extent->lower_first == (u32) -1 ))
+                    (extent->lower_first == (u32) -1))
                         goto out;
 
-                /* Verify count is not zero and does not cause the extent to wrap */
+                /* Verify count is not zero and does not cause the
+                 * extent to wrap
+                 */
                 if ((extent->first + extent->count) <= extent->first)
                         goto out;
-                if ((extent->lower_first + extent->count) <= extent->lower_first)
+                if ((extent->lower_first + extent->count) <=
+                     extent->lower_first)
                         goto out;
 
                 /* Do the ranges in extent overlap any previous extents? */
@@ -751,7 +756,8 @@ out:
         return ret;
 }
 
-ssize_t proc_uid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+ssize_t proc_uid_map_write(struct file *file, const char __user *buf,
+                           size_t size, loff_t *ppos)
 {
         struct seq_file *seq = file->private_data;
         struct user_namespace *ns = seq->private;
@@ -767,7 +773,8 @@ ssize_t proc_uid_map_write(struct file *file, const char __user *buf, size_t siz
                          &ns->uid_map, &ns->parent->uid_map);
 }
 
-ssize_t proc_gid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+ssize_t proc_gid_map_write(struct file *file, const char __user *buf,
+                           size_t size, loff_t *ppos)
 {
         struct seq_file *seq = file->private_data;
         struct user_namespace *ns = seq->private;
@@ -783,7 +790,8 @@ ssize_t proc_gid_map_write(struct file *file, const char __user *buf, size_t siz
                          &ns->gid_map, &ns->parent->gid_map);
 }
 
-ssize_t proc_projid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+ssize_t proc_projid_map_write(struct file *file, const char __user *buf,
+                              size_t size, loff_t *ppos)
 {
         struct seq_file *seq = file->private_data;
         struct user_namespace *ns = seq->private;
@@ -800,7 +808,7 @@ ssize_t proc_projid_map_write(struct file *file, const char __user *buf, size_t
                          &ns->projid_map, &ns->parent->projid_map);
 }
 
-static bool new_idmap_permitted(const struct file *file, 
+static bool new_idmap_permitted(const struct file *file,
                                 struct user_namespace *ns, int cap_setid,
                                 struct uid_gid_map *new_map)
 {
@@ -811,8 +819,7 @@ static bool new_idmap_permitted(const struct file *file,
                         kuid_t uid = make_kuid(ns->parent, id);
                         if (uid_eq(uid, file->f_cred->fsuid))
                                 return true;
-                }
-                else if (cap_setid == CAP_SETGID) {
+                } else if (cap_setid == CAP_SETGID) {
                         kgid_t gid = make_kgid(ns->parent, id);
                         if (gid_eq(gid, file->f_cred->fsgid))
                                 return true;
diff --git a/kernel/utsname_sysctl.c b/kernel/utsname_sysctl.c
index 6fbe811c7ad1..c8eac43267e9 100644
--- a/kernel/utsname_sysctl.c
+++ b/kernel/utsname_sysctl.c
@@ -17,7 +17,7 @@
 
 #ifdef CONFIG_PROC_SYSCTL
 
-static void *get_uts(ctl_table *table, int write)
+static void *get_uts(struct ctl_table *table, int write)
 {
         char *which = table->data;
         struct uts_namespace *uts_ns;
@@ -32,7 +32,7 @@ static void *get_uts(ctl_table *table, int write)
         return which;
 }
 
-static void put_uts(ctl_table *table, int write, void *which)
+static void put_uts(struct ctl_table *table, int write, void *which)
 {
         if (!write)
                 up_read(&uts_sem);
@@ -44,7 +44,7 @@ static void put_uts(ctl_table *table, int write, void *which)
  *      Special case of dostring for the UTS structure. This has locks
  *      to observe. Should this be in kernel/sys.c ????
  */
-static int proc_do_uts_string(ctl_table *table, int write,
+static int proc_do_uts_string(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table uts_table;