4 files changed, 42 insertions, 56 deletions

diff --git a/kernel/nsproxy.c b/kernel/nsproxy.c
index 8e7811086b82..ef42d0ab3115 100644
--- a/kernel/nsproxy.c
+++ b/kernel/nsproxy.c
@@ -204,20 +204,13 @@ void switch_task_namespaces(struct task_struct *p, struct nsproxy *new)
 
         might_sleep();
 
+        task_lock(p);
         ns = p->nsproxy;
+        p->nsproxy = new;
+        task_unlock(p);
 
-        rcu_assign_pointer(p->nsproxy, new);
-
-        if (ns && atomic_dec_and_test(&ns->count)) {
-                /*
-                 * wait for others to get what they want from this nsproxy.
-                 *
-                 * cannot release this nsproxy via the call_rcu() since
-                 * put_mnt_ns() will want to sleep
-                 */
-                synchronize_rcu();
+        if (ns && atomic_dec_and_test(&ns->count))
                 free_nsproxy(ns);
-        }
 }
 
 void exit_task_namespaces(struct task_struct *p)
diff --git a/kernel/signal.c b/kernel/signal.c
index 40b76e351e64..8f0876f9f6dd 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2170,8 +2170,7 @@ static int ptrace_signal(int signr, siginfo_t *info)
         return signr;
 }
 
-int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
-                          struct pt_regs *regs, void *cookie)
+int get_signal(struct ksignal *ksig)
 {
         struct sighand_struct *sighand = current->sighand;
         struct signal_struct *signal = current->signal;
@@ -2241,13 +2240,13 @@ relock:
                         goto relock;
                 }
 
-                signr = dequeue_signal(current, &current->blocked, info);
+                signr = dequeue_signal(current, &current->blocked, &ksig->info);
 
                 if (!signr)
                         break; /* will return 0 */
 
                 if (unlikely(current->ptrace) && signr != SIGKILL) {
-                        signr = ptrace_signal(signr, info);
+                        signr = ptrace_signal(signr, &ksig->info);
                         if (!signr)
                                 continue;
                 }
@@ -2255,13 +2254,13 @@ relock:
                 ka = &sighand->action[signr-1];
 
                 /* Trace actually delivered signals. */
-                trace_signal_deliver(signr, info, ka);
+                trace_signal_deliver(signr, &ksig->info, ka);
 
                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
                         continue;
                 if (ka->sa.sa_handler != SIG_DFL) {
                         /* Run the handler.  */
-                        *return_ka = *ka;
+                        ksig->ka = *ka;
 
                         if (ka->sa.sa_flags & SA_ONESHOT)
                                 ka->sa.sa_handler = SIG_DFL;
@@ -2311,7 +2310,7 @@ relock:
                                 spin_lock_irq(&sighand->siglock);
                         }
 
-                        if (likely(do_signal_stop(info->si_signo))) {
+                        if (likely(do_signal_stop(ksig->info.si_signo))) {
                                 /* It released the siglock.  */
                                 goto relock;
                         }
@@ -2332,7 +2331,7 @@ relock:
 
                 if (sig_kernel_coredump(signr)) {
                         if (print_fatal_signals)
-                                print_fatal_signal(info->si_signo);
+                                print_fatal_signal(ksig->info.si_signo);
                         proc_coredump_connector(current);
                         /*
                          * If it was able to dump core, this kills all
@@ -2342,34 +2341,32 @@ relock:
                          * first and our do_group_exit call below will use
                          * that value and ignore the one we pass it.
                          */
-                        do_coredump(info);
+                        do_coredump(&ksig->info);
                 }
 
                 /*
                  * Death signals, no core dump.
                  */
-                do_group_exit(info->si_signo);
+                do_group_exit(ksig->info.si_signo);
                 /* NOTREACHED */
         }
         spin_unlock_irq(&sighand->siglock);
-        return signr;
+
+        ksig->sig = signr;
+        return ksig->sig > 0;
 }
 
 /**
  * signal_delivered - 
- * @sig:                number of signal being delivered
- * @info:               siginfo_t of signal being delivered
- * @ka:                 sigaction setting that chose the handler
- * @regs:               user register state
+ * @ksig:               kernel signal struct
  * @stepping:           nonzero if debugger single-step or block-step in use
  *
  * This function should be called when a signal has successfully been
- * delivered. It updates the blocked signals accordingly (@ka->sa.sa_mask
+ * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
  * is always blocked, and the signal itself is blocked unless %SA_NODEFER
- * is set in @ka->sa.sa_flags.  Tracing is notified.
+ * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
  */
-void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka,
-                        struct pt_regs *regs, int stepping)
+static void signal_delivered(struct ksignal *ksig, int stepping)
 {
         sigset_t blocked;
 
@@ -2379,11 +2376,11 @@ void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka,
            simply clear the restore sigmask flag.  */
         clear_restore_sigmask();
 
-        sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
-        if (!(ka->sa.sa_flags & SA_NODEFER))
-                sigaddset(&blocked, sig);
+        sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
+        if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
+                sigaddset(&blocked, ksig->sig);
         set_current_blocked(&blocked);
-        tracehook_signal_handler(sig, info, ka, regs, stepping);
+        tracehook_signal_handler(stepping);
 }
 
 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
@@ -2391,8 +2388,7 @@ void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
         if (failed)
                 force_sigsegv(ksig->sig, current);
         else
-                signal_delivered(ksig->sig, &ksig->info, &ksig->ka,
-                        signal_pt_regs(), stepping);
+                signal_delivered(ksig, stepping);
 }
 
 /*
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 925f629658d6..afb04b9b818a 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -1968,7 +1968,7 @@ rb_add_time_stamp(struct ring_buffer_event *event, u64 delta)
 
 /**
  * rb_update_event - update event type and data
- * @event: the even to update
+ * @event: the event to update
  * @type: the type of event
  * @length: the size of the event field in the ring buffer
  *
@@ -3341,21 +3341,16 @@ static void rb_iter_reset(struct ring_buffer_iter *iter)
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
 
         /* Iterator usage is expected to have record disabled */
-        if (list_empty(&cpu_buffer->reader_page->list)) {
-                iter->head_page = rb_set_head_page(cpu_buffer);
-                if (unlikely(!iter->head_page))
-                        return;
-                iter->head = iter->head_page->read;
-        } else {
-                iter->head_page = cpu_buffer->reader_page;
-                iter->head = cpu_buffer->reader_page->read;
-        }
+        iter->head_page = cpu_buffer->reader_page;
+        iter->head = cpu_buffer->reader_page->read;
+
+        iter->cache_reader_page = iter->head_page;
+        iter->cache_read = iter->head;
+
         if (iter->head)
                 iter->read_stamp = cpu_buffer->read_stamp;
         else
                 iter->read_stamp = iter->head_page->page->time_stamp;
-        iter->cache_reader_page = cpu_buffer->reader_page;
-        iter->cache_read = cpu_buffer->read;
 }
 
 /**
@@ -3748,12 +3743,14 @@ rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
                 return NULL;
 
         /*
-         * We repeat when a time extend is encountered.
-         * Since the time extend is always attached to a data event,
-         * we should never loop more than once.
-         * (We never hit the following condition more than twice).
+         * We repeat when a time extend is encountered or we hit
+         * the end of the page. Since the time extend is always attached
+         * to a data event, we should never loop more than three times.
+         * Once for going to next page, once on time extend, and
+         * finally once to get the event.
+         * (We never hit the following condition more than thrice).
          */
-        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 2))
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 3))
                 return NULL;
 
         if (rb_per_cpu_empty(cpu_buffer))
diff --git a/kernel/utsname.c b/kernel/utsname.c
index fd393124e507..883aaaa7de8a 100644
--- a/kernel/utsname.c
+++ b/kernel/utsname.c
@@ -93,13 +93,13 @@ static void *utsns_get(struct task_struct *task)
         struct uts_namespace *ns = NULL;
         struct nsproxy *nsproxy;
 
-        rcu_read_lock();
-        nsproxy = task_nsproxy(task);
+        task_lock(task);
+        nsproxy = task->nsproxy;
         if (nsproxy) {
                 ns = nsproxy->uts_ns;
                 get_uts_ns(ns);
         }
-        rcu_read_unlock();
+        task_unlock(task);
 
         return ns;
 }