3 files changed, 78 insertions, 83 deletions

diff --git a/kernel/sched.c b/kernel/sched.c
index 18cceeecce35..9c30858b6463 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -26,6 +26,8 @@
  *              Thomas Gleixner, Mike Kravetz
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/nmi.h>
@@ -5340,8 +5342,8 @@ static noinline void __schedule_bug(struct task_struct *prev)
 {
         struct pt_regs *regs = get_irq_regs();
 
-        printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
-                prev->comm, prev->pid, preempt_count());
+        pr_err("BUG: scheduling while atomic: %s/%d/0x%08x\n",
+               prev->comm, prev->pid, preempt_count());
 
         debug_show_held_locks(prev);
         print_modules();
@@ -5911,14 +5913,15 @@ EXPORT_SYMBOL(wait_for_completion_killable);
  */
 bool try_wait_for_completion(struct completion *x)
 {
+        unsigned long flags;
         int ret = 1;
 
-        spin_lock_irq(&x->wait.lock);
+        spin_lock_irqsave(&x->wait.lock, flags);
         if (!x->done)
                 ret = 0;
         else
                 x->done--;
-        spin_unlock_irq(&x->wait.lock);
+        spin_unlock_irqrestore(&x->wait.lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(try_wait_for_completion);
@@ -5933,12 +5936,13 @@ EXPORT_SYMBOL(try_wait_for_completion);
  */
 bool completion_done(struct completion *x)
 {
+        unsigned long flags;
         int ret = 1;
 
-        spin_lock_irq(&x->wait.lock);
+        spin_lock_irqsave(&x->wait.lock, flags);
         if (!x->done)
                 ret = 0;
-        spin_unlock_irq(&x->wait.lock);
+        spin_unlock_irqrestore(&x->wait.lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(completion_done);
@@ -6457,7 +6461,7 @@ SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
                 return -EINVAL;
 
         retval = -ESRCH;
-        read_lock(&tasklist_lock);
+        rcu_read_lock();
         p = find_process_by_pid(pid);
         if (p) {
                 retval = security_task_getscheduler(p);
@@ -6465,7 +6469,7 @@ SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
                         retval = p->policy
                                 | (p->sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0);
         }
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
         return retval;
 }
 
@@ -6483,7 +6487,7 @@ SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
         if (!param || pid < 0)
                 return -EINVAL;
 
-        read_lock(&tasklist_lock);
+        rcu_read_lock();
         p = find_process_by_pid(pid);
         retval = -ESRCH;
         if (!p)
@@ -6494,7 +6498,7 @@ SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
                 goto out_unlock;
 
         lp.sched_priority = p->rt_priority;
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
 
         /*
          * This one might sleep, we cannot do it with a spinlock held ...
@@ -6504,7 +6508,7 @@ SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
         return retval;
 
 out_unlock:
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
         return retval;
 }
 
@@ -6515,22 +6519,18 @@ long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
         int retval;
 
         get_online_cpus();
-        read_lock(&tasklist_lock);
+        rcu_read_lock();
 
         p = find_process_by_pid(pid);
         if (!p) {
-                read_unlock(&tasklist_lock);
+                rcu_read_unlock();
                 put_online_cpus();
                 return -ESRCH;
         }
 
-        /*
-         * It is not safe to call set_cpus_allowed with the
-         * tasklist_lock held. We will bump the task_struct's
-         * usage count and then drop tasklist_lock.
-         */
+        /* Prevent p going away */
         get_task_struct(p);
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
 
         if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
                 retval = -ENOMEM;
@@ -6616,7 +6616,7 @@ long sched_getaffinity(pid_t pid, struct cpumask *mask)
         int retval;
 
         get_online_cpus();
-        read_lock(&tasklist_lock);
+        rcu_read_lock();
 
         retval = -ESRCH;
         p = find_process_by_pid(pid);
@@ -6632,7 +6632,7 @@ long sched_getaffinity(pid_t pid, struct cpumask *mask)
         task_rq_unlock(rq, &flags);
 
 out_unlock:
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
         put_online_cpus();
 
         return retval;
@@ -6876,7 +6876,7 @@ SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
                 return -EINVAL;
 
         retval = -ESRCH;
-        read_lock(&tasklist_lock);
+        rcu_read_lock();
         p = find_process_by_pid(pid);
         if (!p)
                 goto out_unlock;
@@ -6889,13 +6889,13 @@ SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
         time_slice = p->sched_class->get_rr_interval(rq, p);
         task_rq_unlock(rq, &flags);
 
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
         jiffies_to_timespec(time_slice, &t);
         retval = copy_to_user(interval, &t, sizeof(t)) ? -EFAULT : 0;
         return retval;
 
 out_unlock:
-        read_unlock(&tasklist_lock);
+        rcu_read_unlock();
         return retval;
 }
 
@@ -6907,23 +6907,23 @@ void sched_show_task(struct task_struct *p)
         unsigned state;
 
         state = p->state ? __ffs(p->state) + 1 : 0;
-        printk(KERN_INFO "%-13.13s %c", p->comm,
+        pr_info("%-13.13s %c", p->comm,
                 state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
 #if BITS_PER_LONG == 32
         if (state == TASK_RUNNING)
-                printk(KERN_CONT " running  ");
+                pr_cont(" running  ");
         else
-                printk(KERN_CONT " %08lx ", thread_saved_pc(p));
+                pr_cont(" %08lx ", thread_saved_pc(p));
 #else
         if (state == TASK_RUNNING)
-                printk(KERN_CONT "  running task    ");
+                pr_cont("  running task    ");
         else
-                printk(KERN_CONT " %016lx ", thread_saved_pc(p));
+                pr_cont(" %016lx ", thread_saved_pc(p));
 #endif
 #ifdef CONFIG_DEBUG_STACK_USAGE
         free = stack_not_used(p);
 #endif
-        printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free,
+        pr_cont("%5lu %5d %6d 0x%08lx\n", free,
                 task_pid_nr(p), task_pid_nr(p->real_parent),
                 (unsigned long)task_thread_info(p)->flags);
 
@@ -6935,11 +6935,9 @@ void show_state_filter(unsigned long state_filter)
         struct task_struct *g, *p;
 
 #if BITS_PER_LONG == 32
-        printk(KERN_INFO
-                "  task                PC stack   pid father\n");
+        pr_info("  task                PC stack   pid father\n");
 #else
-        printk(KERN_INFO
-                "  task                        PC stack   pid father\n");
+        pr_info("  task                        PC stack   pid father\n");
 #endif
         read_lock(&tasklist_lock);
         do_each_thread(g, p) {
@@ -7297,9 +7295,8 @@ again:
                  * leave kernel.
                  */
                 if (p->mm && printk_ratelimit()) {
-                        printk(KERN_INFO "process %d (%s) no "
-                               "longer affine to cpu%d\n",
-                               task_pid_nr(p), p->comm, dead_cpu);
+                        pr_info("process %d (%s) no longer affine to cpu%d\n",
+                                task_pid_nr(p), p->comm, dead_cpu);
                 }
         }
 
@@ -7806,48 +7803,44 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
         printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
 
         if (!(sd->flags & SD_LOAD_BALANCE)) {
-                printk("does not load-balance\n");
+                pr_cont("does not load-balance\n");
                 if (sd->parent)
-                        printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
-                                        " has parent");
+                        pr_err("ERROR: !SD_LOAD_BALANCE domain has parent\n");
                 return -1;
         }
 
-        printk(KERN_CONT "span %s level %s\n", str, sd->name);
+        pr_cont("span %s level %s\n", str, sd->name);
 
         if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
-                printk(KERN_ERR "ERROR: domain->span does not contain "
-                                "CPU%d\n", cpu);
+                pr_err("ERROR: domain->span does not contain CPU%d\n", cpu);
         }
         if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
-                printk(KERN_ERR "ERROR: domain->groups does not contain"
-                                " CPU%d\n", cpu);
+                pr_err("ERROR: domain->groups does not contain CPU%d\n", cpu);
         }
 
         printk(KERN_DEBUG "%*s groups:", level + 1, "");
         do {
                 if (!group) {
-                        printk("\n");
-                        printk(KERN_ERR "ERROR: group is NULL\n");
+                        pr_cont("\n");
+                        pr_err("ERROR: group is NULL\n");
                         break;
                 }
 
                 if (!group->cpu_power) {
-                        printk(KERN_CONT "\n");
-                        printk(KERN_ERR "ERROR: domain->cpu_power not "
-                                        "set\n");
+                        pr_cont("\n");
+                        pr_err("ERROR: domain->cpu_power not set\n");
                         break;
                 }
 
                 if (!cpumask_weight(sched_group_cpus(group))) {
-                        printk(KERN_CONT "\n");
-                        printk(KERN_ERR "ERROR: empty group\n");
+                        pr_cont("\n");
+                        pr_err("ERROR: empty group\n");
                         break;
                 }
 
                 if (cpumask_intersects(groupmask, sched_group_cpus(group))) {
-                        printk(KERN_CONT "\n");
-                        printk(KERN_ERR "ERROR: repeated CPUs\n");
+                        pr_cont("\n");
+                        pr_err("ERROR: repeated CPUs\n");
                         break;
                 }
 
@@ -7855,23 +7848,21 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
 
                 cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
 
-                printk(KERN_CONT " %s", str);
+                pr_cont(" %s", str);
                 if (group->cpu_power != SCHED_LOAD_SCALE) {
-                        printk(KERN_CONT " (cpu_power = %d)",
-                                group->cpu_power);
+                        pr_cont(" (cpu_power = %d)", group->cpu_power);
                 }
 
                 group = group->next;
         } while (group != sd->groups);
-        printk(KERN_CONT "\n");
+        pr_cont("\n");
 
         if (!cpumask_equal(sched_domain_span(sd), groupmask))
-                printk(KERN_ERR "ERROR: groups don't span domain->span\n");
+                pr_err("ERROR: groups don't span domain->span\n");
 
         if (sd->parent &&
             !cpumask_subset(groupmask, sched_domain_span(sd->parent)))
-                printk(KERN_ERR "ERROR: parent span is not a superset "
-                        "of domain->span\n");
+                pr_err("ERROR: parent span is not a superset of domain->span\n");
         return 0;
 }
 
@@ -8427,8 +8418,7 @@ static int build_numa_sched_groups(struct s_data *d,
         sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
                           GFP_KERNEL, num);
         if (!sg) {
-                printk(KERN_WARNING "Can not alloc domain group for node %d\n",
-                       num);
+                pr_warning("Can not alloc domain group for node %d\n", num);
                 return -ENOMEM;
         }
         d->sched_group_nodes[num] = sg;
@@ -8457,8 +8447,8 @@ static int build_numa_sched_groups(struct s_data *d,
                 sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
                                   GFP_KERNEL, num);
                 if (!sg) {
-                        printk(KERN_WARNING
-                               "Can not alloc domain group for node %d\n", j);
+                        pr_warning("Can not alloc domain group for node %d\n",
+                                   j);
                         return -ENOMEM;
                 }
                 sg->cpu_power = 0;
@@ -8686,7 +8676,7 @@ static enum s_alloc __visit_domain_allocation_hell(struct s_data *d,
         d->sched_group_nodes = kcalloc(nr_node_ids,
                                       sizeof(struct sched_group *), GFP_KERNEL);
         if (!d->sched_group_nodes) {
-                printk(KERN_WARNING "Can not alloc sched group node list\n");
+                pr_warning("Can not alloc sched group node list\n");
                 return sa_notcovered;
         }
         sched_group_nodes_bycpu[cpumask_first(cpu_map)] = d->sched_group_nodes;
@@ -8703,7 +8693,7 @@ static enum s_alloc __visit_domain_allocation_hell(struct s_data *d,
                 return sa_send_covered;
         d->rd = alloc_rootdomain();
         if (!d->rd) {
-                printk(KERN_WARNING "Cannot alloc root domain\n");
+                pr_warning("Cannot alloc root domain\n");
                 return sa_tmpmask;
         }
         return sa_rootdomain;
@@ -9685,13 +9675,11 @@ void __might_sleep(char *file, int line, int preempt_offset)
                 return;
         prev_jiffy = jiffies;
 
-        printk(KERN_ERR
-                "BUG: sleeping function called from invalid context at %s:%d\n",
-                        file, line);
-        printk(KERN_ERR
-                "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
-                        in_atomic(), irqs_disabled(),
-                        current->pid, current->comm);
+        pr_err("BUG: sleeping function called from invalid context at %s:%d\n",
+               file, line);
+        pr_err("in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
+               in_atomic(), irqs_disabled(),
+               current->pid, current->comm);
 
         debug_show_held_locks(current);
         if (irqs_disabled())
diff --git a/kernel/sched_clock.c b/kernel/sched_clock.c
index 479ce5682d7c..5b496132c28a 100644
--- a/kernel/sched_clock.c
+++ b/kernel/sched_clock.c
@@ -236,6 +236,18 @@ void sched_clock_idle_wakeup_event(u64 delta_ns)
 }
 EXPORT_SYMBOL_GPL(sched_clock_idle_wakeup_event);
 
+unsigned long long cpu_clock(int cpu)
+{
+        unsigned long long clock;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        clock = sched_clock_cpu(cpu);
+        local_irq_restore(flags);
+
+        return clock;
+}
+
 #else /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
 
 void sched_clock_init(void)
@@ -251,17 +263,12 @@ u64 sched_clock_cpu(int cpu)
         return sched_clock();
 }
 
-#endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
 
 unsigned long long cpu_clock(int cpu)
 {
-        unsigned long long clock;
-        unsigned long flags;
+        return sched_clock_cpu(cpu);
+}
 
-        local_irq_save(flags);
-        clock = sched_clock_cpu(cpu);
-        local_irq_restore(flags);
+#endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
 
-        return clock;
-}
 EXPORT_SYMBOL_GPL(cpu_clock);
diff --git a/kernel/sched_idletask.c b/kernel/sched_idletask.c
index 5f93b570d383..21b969a28725 100644
--- a/kernel/sched_idletask.c
+++ b/kernel/sched_idletask.c
@@ -35,7 +35,7 @@ static void
 dequeue_task_idle(struct rq *rq, struct task_struct *p, int sleep)
 {
         raw_spin_unlock_irq(&rq->lock);
-        printk(KERN_ERR "bad: scheduling from the idle thread!\n");
+        pr_err("bad: scheduling from the idle thread!\n");
         dump_stack();
         raw_spin_lock_irq(&rq->lock);
 }