15 files changed, 76 insertions, 62 deletions

diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 026faccca869..d5a7e17474ee 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -1857,7 +1857,7 @@ struct cgroup_subsys cpuset_subsys = {
 
 int __init cpuset_init_early(void)
 {
-        alloc_bootmem_cpumask_var(&top_cpuset.cpus_allowed);
+        alloc_cpumask_var(&top_cpuset.cpus_allowed, GFP_NOWAIT);
 
         top_cpuset.mems_generation = cpuset_mems_generation++;
         return 0;
diff --git a/kernel/cred.c b/kernel/cred.c
index 3a039189d707..1bb4d7e5d616 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -167,7 +167,7 @@ EXPORT_SYMBOL(prepare_creds);
 
 /*
  * Prepare credentials for current to perform an execve()
- * - The caller must hold current->cred_exec_mutex
+ * - The caller must hold current->cred_guard_mutex
  */
 struct cred *prepare_exec_creds(void)
 {
@@ -276,7 +276,7 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)
         struct cred *new;
         int ret;
 
-        mutex_init(&p->cred_exec_mutex);
+        mutex_init(&p->cred_guard_mutex);
 
         if (
 #ifdef CONFIG_KEYS
diff --git a/kernel/exit.c b/kernel/exit.c
index 49cdf6946f34..b6c90b5ef509 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1480,6 +1480,7 @@ static int wait_consider_task(struct task_struct *parent, int ptrace,
                  */
                 if (*notask_error)
                         *notask_error = ret;
+                return 0;
         }
 
         if (likely(!ptrace) && unlikely(p->ptrace)) {
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index a60018402f42..104578541230 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -150,6 +150,7 @@ int __init early_irq_init(void)
 {
         struct irq_desc *desc;
         int legacy_count;
+        int node;
         int i;
 
         init_irq_default_affinity();
@@ -160,20 +161,20 @@ int __init early_irq_init(void)
 
         desc = irq_desc_legacy;
         legacy_count = ARRAY_SIZE(irq_desc_legacy);
+        node = first_online_node;
 
         /* allocate irq_desc_ptrs array based on nr_irqs */
-        irq_desc_ptrs = alloc_bootmem(nr_irqs * sizeof(void *));
+        irq_desc_ptrs = kcalloc(nr_irqs, sizeof(void *), GFP_NOWAIT);
 
         /* allocate based on nr_cpu_ids */
-        /* FIXME: invert kstat_irgs, and it'd be a per_cpu_alloc'd thing */
-        kstat_irqs_legacy = alloc_bootmem(NR_IRQS_LEGACY * nr_cpu_ids *
-                                          sizeof(int));
+        kstat_irqs_legacy = kzalloc_node(NR_IRQS_LEGACY * nr_cpu_ids *
+                                          sizeof(int), GFP_NOWAIT, node);
 
         for (i = 0; i < legacy_count; i++) {
                 desc[i].irq = i;
                 desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
                 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
-                alloc_desc_masks(&desc[i], 0, true);
+                alloc_desc_masks(&desc[i], node, true);
                 init_desc_masks(&desc[i]);
                 irq_desc_ptrs[i] = desc + i;
         }
diff --git a/kernel/module.c b/kernel/module.c
index 2383e60fcf3f..278e9b6762bb 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -73,6 +73,9 @@ DEFINE_MUTEX(module_mutex);
 EXPORT_SYMBOL_GPL(module_mutex);
 static LIST_HEAD(modules);
 
+/* Block module loading/unloading? */
+int modules_disabled = 0;
+
 /* Waiting for a module to finish initializing? */
 static DECLARE_WAIT_QUEUE_HEAD(module_wq);
 
@@ -778,7 +781,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
         char name[MODULE_NAME_LEN];
         int ret, forced = 0;
 
-        if (!capable(CAP_SYS_MODULE))
+        if (!capable(CAP_SYS_MODULE) || modules_disabled)
                 return -EPERM;
 
         if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
@@ -2338,7 +2341,7 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
         int ret = 0;
 
         /* Must have permission */
-        if (!capable(CAP_SYS_MODULE))
+        if (!capable(CAP_SYS_MODULE) || modules_disabled)
                 return -EPERM;
 
         /* Only one module load at a time, please */
diff --git a/kernel/profile.c b/kernel/profile.c
index 7724e0409bae..28cf26ad2d24 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -111,12 +111,6 @@ int __ref profile_init(void)
         /* only text is profiled */
         prof_len = (_etext - _stext) >> prof_shift;
         buffer_bytes = prof_len*sizeof(atomic_t);
-        if (!slab_is_available()) {
-                prof_buffer = alloc_bootmem(buffer_bytes);
-                alloc_bootmem_cpumask_var(&prof_cpu_mask);
-                cpumask_copy(prof_cpu_mask, cpu_possible_mask);
-                return 0;
-        }
 
         if (!alloc_cpumask_var(&prof_cpu_mask, GFP_KERNEL))
                 return -ENOMEM;
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 2442d140bd9a..f6d8b8cb5e34 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -175,10 +175,11 @@ int ptrace_attach(struct task_struct *task)
         if (same_thread_group(task, current))
                 goto out;
 
-        /* Protect exec's credential calculations against our interference;
-         * SUID, SGID and LSM creds get determined differently under ptrace.
+        /* Protect the target's credential calculations against our
+         * interference; SUID, SGID and LSM creds get determined differently
+         * under ptrace.
          */
-        retval = mutex_lock_interruptible(&task->cred_exec_mutex);
+        retval = mutex_lock_interruptible(&task->cred_guard_mutex);
         if (retval  < 0)
                 goto out;
 
@@ -222,7 +223,7 @@ repeat:
 bad:
         write_unlock_irqrestore(&tasklist_lock, flags);
         task_unlock(task);
-        mutex_unlock(&task->cred_exec_mutex);
+        mutex_unlock(&task->cred_guard_mutex);
 out:
         return retval;
 }
diff --git a/kernel/sched.c b/kernel/sched.c
index 5b3f6ec1b0b3..f04aa9664504 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -69,7 +69,6 @@
 #include <linux/pagemap.h>
 #include <linux/hrtimer.h>
 #include <linux/tick.h>
-#include <linux/bootmem.h>
 #include <linux/debugfs.h>
 #include <linux/ctype.h>
 #include <linux/ftrace.h>
@@ -7825,24 +7824,21 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
 
 static int __init_refok init_rootdomain(struct root_domain *rd, bool bootmem)
 {
+        gfp_t gfp = GFP_KERNEL;
+
         memset(rd, 0, sizeof(*rd));
 
-        if (bootmem) {
-                alloc_bootmem_cpumask_var(&def_root_domain.span);
-                alloc_bootmem_cpumask_var(&def_root_domain.online);
-                alloc_bootmem_cpumask_var(&def_root_domain.rto_mask);
-                cpupri_init(&rd->cpupri, true);
-                return 0;
-        }
+        if (bootmem)
+                gfp = GFP_NOWAIT;
 
-        if (!alloc_cpumask_var(&rd->span, GFP_KERNEL))
+        if (!alloc_cpumask_var(&rd->span, gfp))
                 goto out;
-        if (!alloc_cpumask_var(&rd->online, GFP_KERNEL))
+        if (!alloc_cpumask_var(&rd->online, gfp))
                 goto free_span;
-        if (!alloc_cpumask_var(&rd->rto_mask, GFP_KERNEL))
+        if (!alloc_cpumask_var(&rd->rto_mask, gfp))
                 goto free_online;
 
-        if (cpupri_init(&rd->cpupri, false) != 0)
+        if (cpupri_init(&rd->cpupri, bootmem) != 0)
                 goto free_rto_mask;
         return 0;
 
@@ -9166,7 +9162,7 @@ void __init sched_init(void)
          * we use alloc_bootmem().
          */
         if (alloc_size) {
-                ptr = (unsigned long)alloc_bootmem(alloc_size);
+                ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
                 init_task_group.se = (struct sched_entity **)ptr;
@@ -9357,13 +9353,13 @@ void __init sched_init(void)
         current->sched_class = &fair_sched_class;
 
         /* Allocate the nohz_cpu_mask if CONFIG_CPUMASK_OFFSTACK */
-        alloc_bootmem_cpumask_var(&nohz_cpu_mask);
+        alloc_cpumask_var(&nohz_cpu_mask, GFP_NOWAIT);
 #ifdef CONFIG_SMP
 #ifdef CONFIG_NO_HZ
-        alloc_bootmem_cpumask_var(&nohz.cpu_mask);
-        alloc_bootmem_cpumask_var(&nohz.ilb_grp_nohz_mask);
+        alloc_cpumask_var(&nohz.cpu_mask, GFP_NOWAIT);
+        alloc_cpumask_var(&nohz.ilb_grp_nohz_mask, GFP_NOWAIT);
 #endif
-        alloc_bootmem_cpumask_var(&cpu_isolated_map);
+        alloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
 #endif /* SMP */
 
         perf_counter_init();
diff --git a/kernel/sched_cpupri.c b/kernel/sched_cpupri.c
index 344712a5e3ed..7deffc9f0e5f 100644
--- a/kernel/sched_cpupri.c
+++ b/kernel/sched_cpupri.c
@@ -154,8 +154,12 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
  */
 int __init_refok cpupri_init(struct cpupri *cp, bool bootmem)
 {
+        gfp_t gfp = GFP_KERNEL;
         int i;
 
+        if (bootmem)
+                gfp = GFP_NOWAIT;
+
         memset(cp, 0, sizeof(*cp));
 
         for (i = 0; i < CPUPRI_NR_PRIORITIES; i++) {
@@ -163,9 +167,7 @@ int __init_refok cpupri_init(struct cpupri *cp, bool bootmem)
 
                 spin_lock_init(&vec->lock);
                 vec->count = 0;
-                if (bootmem)
-                        alloc_bootmem_cpumask_var(&vec->mask);
-                else if (!zalloc_cpumask_var(&vec->mask, GFP_KERNEL))
+                if (!zalloc_cpumask_var(&vec->mask, gfp))
                         goto cleanup;
         }
 
diff --git a/kernel/signal.c b/kernel/signal.c
index dba6ae99978a..809a228019ad 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -247,14 +247,19 @@ void flush_sigqueue(struct sigpending *queue)
 /*
  * Flush all pending signals for a task.
  */
+void __flush_signals(struct task_struct *t)
+{
+        clear_tsk_thread_flag(t, TIF_SIGPENDING);
+        flush_sigqueue(&t->pending);
+        flush_sigqueue(&t->signal->shared_pending);
+}
+
 void flush_signals(struct task_struct *t)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&t->sighand->siglock, flags);
-        clear_tsk_thread_flag(t, TIF_SIGPENDING);
-        flush_sigqueue(&t->pending);
-        flush_sigqueue(&t->signal->shared_pending);
+        __flush_signals(t);
         spin_unlock_irqrestore(&t->sighand->siglock, flags);
 }
 
diff --git a/kernel/slow-work.c b/kernel/slow-work.c
index b28d19135f43..521ed2004d63 100644
--- a/kernel/slow-work.c
+++ b/kernel/slow-work.c
@@ -372,8 +372,8 @@ static int slow_work_thread(void *_data)
                 vsmax *= atomic_read(&slow_work_thread_count);
                 vsmax /= 100;
 
-                prepare_to_wait(&slow_work_thread_wq, &wait,
-                                TASK_INTERRUPTIBLE);
+                prepare_to_wait_exclusive(&slow_work_thread_wq, &wait,
+                                          TASK_INTERRUPTIBLE);
                 if (!freezing(current) &&
                     !slow_work_threads_should_exit &&
                     !slow_work_available(vsmax) &&
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index a7e4eb0525b1..ce664f98e3fb 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -115,6 +115,7 @@ static int ngroups_max = NGROUPS_MAX;
 
 #ifdef CONFIG_MODULES
 extern char modprobe_path[];
+extern int modules_disabled;
 #endif
 #ifdef CONFIG_CHR_DEV_SG
 extern int sg_big_buff;
@@ -535,6 +536,17 @@ static struct ctl_table kern_table[] = {
                 .proc_handler   = &proc_dostring,
                 .strategy       = &sysctl_string,
         },
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "modules_disabled",
+                .data           = &modules_disabled,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                /* only handle a transition from default "0" to "1" */
+                .proc_handler   = &proc_dointvec_minmax,
+                .extra1         = &one,
+                .extra2         = &one,
+        },
 #endif
 #if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
         {
@@ -1260,7 +1272,6 @@ static struct ctl_table vm_table[] = {
                 .strategy       = &sysctl_jiffies,
         },
 #endif
-#ifdef CONFIG_SECURITY
         {
                 .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "mmap_min_addr",
@@ -1269,7 +1280,6 @@ static struct ctl_table vm_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &proc_doulongvec_minmax,
         },
-#endif
 #ifdef CONFIG_NUMA
         {
                 .ctl_name       = CTL_UNNUMBERED,
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index ecfd7b5187e0..80189f6f1c5a 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -402,9 +402,6 @@ int clocksource_register(struct clocksource *c)
         unsigned long flags;
         int ret;
 
-        /* save mult_orig on registration */
-        c->mult_orig = c->mult;
-
         spin_lock_irqsave(&clocksource_lock, flags);
         ret = clocksource_enqueue(c);
         if (!ret)
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 52a8bf8931f3..e8c77d9c633a 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -77,6 +77,10 @@ static void clocksource_forward_now(void)
         clock->cycle_last = cycle_now;
 
         nsec = cyc2ns(clock, cycle_delta);
+
+        /* If arch requires, add in gettimeoffset() */
+        nsec += arch_gettimeoffset();
+
         timespec_add_ns(&xtime, nsec);
 
         nsec = ((s64)cycle_delta * clock->mult_orig) >> clock->shift;
@@ -111,6 +115,9 @@ void getnstimeofday(struct timespec *ts)
                 /* convert to nanoseconds: */
                 nsecs = cyc2ns(clock, cycle_delta);
 
+                /* If arch requires, add in gettimeoffset() */
+                nsecs += arch_gettimeoffset();
+
         } while (read_seqretry(&xtime_lock, seq));
 
         timespec_add_ns(ts, nsecs);
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 7bd6a9893c24..39af8af6fc30 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -669,12 +669,12 @@ static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
 
         if (blk_pc_request(rq)) {
                 what |= BLK_TC_ACT(BLK_TC_PC);
-                __blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors,
-                                rq->cmd_len, rq->cmd);
+                __blk_add_trace(bt, 0, blk_rq_bytes(rq), rw,
+                                what, rq->errors, rq->cmd_len, rq->cmd);
         } else  {
                 what |= BLK_TC_ACT(BLK_TC_FS);
-                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
-                                rw, what, rq->errors, 0, NULL);
+                __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), rw,
+                                what, rq->errors, 0, NULL);
         }
 }
 
@@ -881,11 +881,11 @@ void blk_add_driver_data(struct request_queue *q,
                 return;
 
         if (blk_pc_request(rq))
-                __blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,
-                                rq->errors, len, data);
+                __blk_add_trace(bt, 0, blk_rq_bytes(rq), 0,
+                                BLK_TA_DRV_DATA, rq->errors, len, data);
         else
-                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
-                                0, BLK_TA_DRV_DATA, rq->errors, len, data);
+                __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), 0,
+                                BLK_TA_DRV_DATA, rq->errors, len, data);
 }
 EXPORT_SYMBOL_GPL(blk_add_driver_data);
 
@@ -1724,10 +1724,7 @@ void blk_fill_rwbs_rq(char *rwbs, struct request *rq)
         if (blk_discard_rq(rq))
                 rw |= (1 << BIO_RW_DISCARD);
 
-        if (blk_pc_request(rq))
-                bytes = rq->data_len;
-        else
-                bytes = rq->hard_nr_sectors << 9;
+        bytes = blk_rq_bytes(rq);
 
         blk_fill_rwbs(rwbs, rw, bytes);
 }