Merge commit 'v2.6.28-rc3' into sched/core

11 files changed, 64 insertions, 59 deletions

diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c
index e95056954498..7fa476f01d05 100644
--- a/kernel/cgroup_freezer.c
+++ b/kernel/cgroup_freezer.c
@@ -162,9 +162,13 @@ static int freezer_can_attach(struct cgroup_subsys *ss,
                               struct task_struct *task)
 {
         struct freezer *freezer;
-        int retval;
 
-        /* Anything frozen can't move or be moved to/from */
+        /*
+         * Anything frozen can't move or be moved to/from.
+         *
+         * Since orig_freezer->state == FROZEN means that @task has been
+         * frozen, so it's sufficient to check the latter condition.
+         */
 
         if (is_task_frozen_enough(task))
                 return -EBUSY;
@@ -173,13 +177,7 @@ static int freezer_can_attach(struct cgroup_subsys *ss,
         if (freezer->state == CGROUP_FROZEN)
                 return -EBUSY;
 
-        retval = 0;
-        task_lock(task);
-        freezer = task_freezer(task);
-        if (freezer->state == CGROUP_FROZEN)
-                retval = -EBUSY;
-        task_unlock(task);
-        return retval;
+        return 0;
 }
 
 static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
@@ -190,8 +188,9 @@ static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
         freezer = task_freezer(task);
         task_unlock(task);
 
-        BUG_ON(freezer->state == CGROUP_FROZEN);
         spin_lock_irq(&freezer->lock);
+        BUG_ON(freezer->state == CGROUP_FROZEN);
+
         /* Locking avoids race with FREEZING -> THAWED transitions. */
         if (freezer->state == CGROUP_FREEZING)
                 freeze_task(task, true);
@@ -276,25 +275,18 @@ static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
         return num_cant_freeze_now ? -EBUSY : 0;
 }
 
-static int unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
+static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
 {
         struct cgroup_iter it;
         struct task_struct *task;
 
         cgroup_iter_start(cgroup, &it);
         while ((task = cgroup_iter_next(cgroup, &it))) {
-                int do_wake;
-
-                task_lock(task);
-                do_wake = __thaw_process(task);
-                task_unlock(task);
-                if (do_wake)
-                        wake_up_process(task);
+                thaw_process(task);
         }
         cgroup_iter_end(cgroup, &it);
-        freezer->state = CGROUP_THAWED;
 
-        return 0;
+        freezer->state = CGROUP_THAWED;
 }
 
 static int freezer_change_state(struct cgroup *cgroup,
@@ -304,27 +296,22 @@ static int freezer_change_state(struct cgroup *cgroup,
         int retval = 0;
 
         freezer = cgroup_freezer(cgroup);
+
         spin_lock_irq(&freezer->lock);
+
         update_freezer_state(cgroup, freezer);
         if (goal_state == freezer->state)
                 goto out;
-        switch (freezer->state) {
+
+        switch (goal_state) {
         case CGROUP_THAWED:
-                retval = try_to_freeze_cgroup(cgroup, freezer);
+                unfreeze_cgroup(cgroup, freezer);
                 break;
-        case CGROUP_FREEZING:
-                if (goal_state == CGROUP_FROZEN) {
-                        /* Userspace is retrying after
-                         * "/bin/echo FROZEN > freezer.state" returned -EBUSY */
-                        retval = try_to_freeze_cgroup(cgroup, freezer);
-                        break;
-                }
-                /* state == FREEZING and goal_state == THAWED, so unfreeze */
         case CGROUP_FROZEN:
-                retval = unfreeze_cgroup(cgroup, freezer);
+                retval = try_to_freeze_cgroup(cgroup, freezer);
                 break;
         default:
-                break;
+                BUG();
         }
 out:
         spin_unlock_irq(&freezer->lock);
diff --git a/kernel/freezer.c b/kernel/freezer.c
index ba6248b323ef..2f4936cf7083 100644
--- a/kernel/freezer.c
+++ b/kernel/freezer.c
@@ -121,16 +121,7 @@ void cancel_freezing(struct task_struct *p)
         }
 }
 
-/*
- * Wake up a frozen process
- *
- * task_lock() is needed to prevent the race with refrigerator() which may
- * occur if the freezing of tasks fails.  Namely, without the lock, if the
- * freezing of tasks failed, thaw_tasks() might have run before a task in
- * refrigerator() could call frozen_process(), in which case the task would be
- * frozen and no one would thaw it.
- */
-int __thaw_process(struct task_struct *p)
+static int __thaw_process(struct task_struct *p)
 {
         if (frozen(p)) {
                 p->flags &= ~PF_FROZEN;
@@ -140,6 +131,15 @@ int __thaw_process(struct task_struct *p)
         return 0;
 }
 
+/*
+ * Wake up a frozen process
+ *
+ * task_lock() is needed to prevent the race with refrigerator() which may
+ * occur if the freezing of tasks fails.  Namely, without the lock, if the
+ * freezing of tasks failed, thaw_tasks() might have run before a task in
+ * refrigerator() could call frozen_process(), in which case the task would be
+ * frozen and no one would thaw it.
+ */
 int thaw_process(struct task_struct *p)
 {
         task_lock(p);
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index dcd165f92a88..23bd4daeb96b 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -96,7 +96,7 @@ config SUSPEND
 
 config PM_TEST_SUSPEND
         bool "Test suspend/resume and wakealarm during bootup"
-        depends on SUSPEND && PM_DEBUG && RTC_LIB=y
+        depends on SUSPEND && PM_DEBUG && RTC_CLASS=y
         ---help---
         This option will let you suspend your machine during bootup, and
         make it wake up a few seconds later using an RTC wakeup alarm.
diff --git a/kernel/profile.c b/kernel/profile.c
index a9e422df6bf6..9830a037d8db 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -102,7 +102,7 @@ int profile_setup(char *str)
 __setup("profile=", profile_setup);
 
 
-int profile_init(void)
+int __ref profile_init(void)
 {
         int buffer_bytes;
         if (!prof_on)
diff --git a/kernel/resource.c b/kernel/resource.c
index 7fec0e427234..4337063663ef 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -17,6 +17,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/device.h>
+#include <linux/pfn.h>
 #include <asm/io.h>
 
 
@@ -522,7 +523,7 @@ static void __init __reserve_region_with_split(struct resource *root,
 {
         struct resource *parent = root;
         struct resource *conflict;
-        struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
+        struct resource *res = kzalloc(sizeof(*res), GFP_ATOMIC);
 
         if (!res)
                 return;
@@ -849,7 +850,8 @@ int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
                         continue;
                 if (p->end < addr)
                         continue;
-                if (p->start <= addr && (p->end >= addr + size - 1))
+                if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
+                    PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
                         continue;
                 printk(KERN_WARNING "resource map sanity check conflict: "
                        "0x%llx 0x%llx 0x%llx 0x%llx %s\n",
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index ad958c1ec708..5ae17762ec32 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -319,7 +319,7 @@ static int __init init_sched_debug_procfs(void)
 {
         struct proc_dir_entry *pe;
 
-        pe = proc_create("sched_debug", 0644, NULL, &sched_debug_fops);
+        pe = proc_create("sched_debug", 0444, NULL, &sched_debug_fops);
         if (!pe)
                 return -ENOMEM;
         return 0;
diff --git a/kernel/signal.c b/kernel/signal.c
index 105217da5c82..4530fc654455 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1144,7 +1144,8 @@ static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
                 struct task_struct * p;
 
                 for_each_process(p) {
-                        if (p->pid > 1 && !same_thread_group(p, current)) {
+                        if (task_pid_vnr(p) > 1 &&
+                                        !same_thread_group(p, current)) {
                                 int err = group_send_sig_info(sig, info, p);
                                 ++count;
                                 if (err != -EPERM)
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index e0cea282e0c5..b58f43bec363 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -8,7 +8,6 @@ config NOP_TRACER
 
 config HAVE_FUNCTION_TRACER
         bool
-        select NOP_TRACER
 
 config HAVE_DYNAMIC_FTRACE
         bool
@@ -28,6 +27,7 @@ config TRACING
         select RING_BUFFER
         select STACKTRACE
         select TRACEPOINTS
+        select NOP_TRACER
 
 menu "Tracers"
 
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 7618c528756b..4a39d24568c8 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -1339,6 +1339,14 @@ void __init ftrace_init(void)
 }
 
 #else
+
+static int __init ftrace_nodyn_init(void)
+{
+        ftrace_enabled = 1;
+        return 0;
+}
+device_initcall(ftrace_nodyn_init);
+
 # define ftrace_startup()               do { } while (0)
 # define ftrace_shutdown()              do { } while (0)
 # define ftrace_startup_sysctl()        do { } while (0)
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index a610ca771558..8a499e2adaec 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -656,7 +656,11 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
         entry->preempt_count            = pc & 0xff;
         entry->pid                      = (tsk) ? tsk->pid : 0;
         entry->flags =
+#ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
                 (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
+#else
+                TRACE_FLAG_IRQS_NOSUPPORT |
+#endif
                 ((pc & HARDIRQ_MASK) ? TRACE_FLAG_HARDIRQ : 0) |
                 ((pc & SOFTIRQ_MASK) ? TRACE_FLAG_SOFTIRQ : 0) |
                 (need_resched() ? TRACE_FLAG_NEED_RESCHED : 0);
@@ -1244,7 +1248,8 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
         trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid);
         trace_seq_printf(s, "%3d", cpu);
         trace_seq_printf(s, "%c%c",
-                        (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : '.',
+                        (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+                         (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : '.',
                         ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.'));
 
         hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 6889ca48f1f1..8465ad052707 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -120,18 +120,20 @@ struct trace_boot {
 /*
  * trace_flag_type is an enumeration that holds different
  * states when a trace occurs. These are:
- *  IRQS_OFF    - interrupts were disabled
- *  NEED_RESCED - reschedule is requested
- *  HARDIRQ     - inside an interrupt handler
- *  SOFTIRQ     - inside a softirq handler
- *  CONT        - multiple entries hold the trace item
+ *  IRQS_OFF            - interrupts were disabled
+ *  IRQS_NOSUPPORT      - arch does not support irqs_disabled_flags
+ *  NEED_RESCED         - reschedule is requested
+ *  HARDIRQ             - inside an interrupt handler
+ *  SOFTIRQ             - inside a softirq handler
+ *  CONT                - multiple entries hold the trace item
  */
 enum trace_flag_type {
         TRACE_FLAG_IRQS_OFF             = 0x01,
-        TRACE_FLAG_NEED_RESCHED         = 0x02,
-        TRACE_FLAG_HARDIRQ              = 0x04,
-        TRACE_FLAG_SOFTIRQ              = 0x08,
-        TRACE_FLAG_CONT                 = 0x10,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
+        TRACE_FLAG_HARDIRQ              = 0x08,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+        TRACE_FLAG_CONT                 = 0x20,
 };
 
 #define TRACE_BUF_SIZE          1024