1 files changed, 31 insertions, 43 deletions

diff --git a/kernel/kexec.c b/kernel/kexec.c
index c8a4370e2a34..aef265325cd3 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -12,7 +12,7 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/kexec.h>
-#include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/highmem.h>
 #include <linux/syscalls.h>
@@ -77,7 +77,7 @@ int kexec_should_crash(struct task_struct *p)
  *
  * The code for the transition from the current kernel to the
  * the new kernel is placed in the control_code_buffer, whose size
- * is given by KEXEC_CONTROL_CODE_SIZE.  In the best case only a single
+ * is given by KEXEC_CONTROL_PAGE_SIZE.  In the best case only a single
  * page of memory is necessary, but some architectures require more.
  * Because this memory must be identity mapped in the transition from
  * virtual to physical addresses it must live in the range
@@ -242,7 +242,7 @@ static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
          */
         result = -ENOMEM;
         image->control_code_page = kimage_alloc_control_pages(image,
-                                           get_order(KEXEC_CONTROL_CODE_SIZE));
+                                           get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
                 printk(KERN_ERR "Could not allocate control_code_buffer\n");
                 goto out;
@@ -317,7 +317,7 @@ static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
          */
         result = -ENOMEM;
         image->control_code_page = kimage_alloc_control_pages(image,
-                                           get_order(KEXEC_CONTROL_CODE_SIZE));
+                                           get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
                 printk(KERN_ERR "Could not allocate control_code_buffer\n");
                 goto out;
@@ -753,8 +753,14 @@ static struct page *kimage_alloc_page(struct kimage *image,
                         *old = addr | (*old & ~PAGE_MASK);
 
                         /* The old page I have found cannot be a
-                         * destination page, so return it.
+                         * destination page, so return it if it's
+                         * gfp_flags honor the ones passed in.
                          */
+                        if (!(gfp_mask & __GFP_HIGHMEM) &&
+                            PageHighMem(old_page)) {
+                                kimage_free_pages(old_page);
+                                continue;
+                        }
                         addr = old_addr;
                         page = old_page;
                         break;
@@ -924,19 +930,14 @@ static int kimage_load_segment(struct kimage *image,
  */
 struct kimage *kexec_image;
 struct kimage *kexec_crash_image;
-/*
- * A home grown binary mutex.
- * Nothing can wait so this mutex is safe to use
- * in interrupt context :)
- */
-static int kexec_lock;
+
+static DEFINE_MUTEX(kexec_mutex);
 
 asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
                                 struct kexec_segment __user *segments,
                                 unsigned long flags)
 {
         struct kimage **dest_image, *image;
-        int locked;
         int result;
 
         /* We only trust the superuser with rebooting the system. */
@@ -972,8 +973,7 @@ asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
          *
          * KISS: always take the mutex.
          */
-        locked = xchg(&kexec_lock, 1);
-        if (locked)
+        if (!mutex_trylock(&kexec_mutex))
                 return -EBUSY;
 
         dest_image = &kexec_image;
@@ -1015,8 +1015,7 @@ asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
         image = xchg(dest_image, image);
 
 out:
-        locked = xchg(&kexec_lock, 0); /* Release the mutex */
-        BUG_ON(!locked);
+        mutex_unlock(&kexec_mutex);
         kimage_free(image);
 
         return result;
@@ -1063,10 +1062,7 @@ asmlinkage long compat_sys_kexec_load(unsigned long entry,
 
 void crash_kexec(struct pt_regs *regs)
 {
-        int locked;
-
-
-        /* Take the kexec_lock here to prevent sys_kexec_load
+        /* Take the kexec_mutex here to prevent sys_kexec_load
          * running on one cpu from replacing the crash kernel
          * we are using after a panic on a different cpu.
          *
@@ -1074,8 +1070,7 @@ void crash_kexec(struct pt_regs *regs)
          * of memory the xchg(&kexec_crash_image) would be
          * sufficient.  But since I reuse the memory...
          */
-        locked = xchg(&kexec_lock, 1);
-        if (!locked) {
+        if (mutex_trylock(&kexec_mutex)) {
                 if (kexec_crash_image) {
                         struct pt_regs fixed_regs;
                         crash_setup_regs(&fixed_regs, regs);
@@ -1083,8 +1078,7 @@ void crash_kexec(struct pt_regs *regs)
                         machine_crash_shutdown(&fixed_regs);
                         machine_kexec(kexec_crash_image);
                 }
-                locked = xchg(&kexec_lock, 0);
-                BUG_ON(!locked);
+                mutex_unlock(&kexec_mutex);
         }
 }
 
@@ -1426,25 +1420,23 @@ static int __init crash_save_vmcoreinfo_init(void)
 
 module_init(crash_save_vmcoreinfo_init)
 
-/**
- *      kernel_kexec - reboot the system
- *
- *      Move into place and start executing a preloaded standalone
- *      executable.  If nothing was preloaded return an error.
+/*
+ * Move into place and start executing a preloaded standalone
+ * executable.  If nothing was preloaded return an error.
  */
 int kernel_kexec(void)
 {
         int error = 0;
 
-        if (xchg(&kexec_lock, 1))
+        if (!mutex_trylock(&kexec_mutex))
                 return -EBUSY;
         if (!kexec_image) {
                 error = -EINVAL;
                 goto Unlock;
         }
 
-        if (kexec_image->preserve_context) {
 #ifdef CONFIG_KEXEC_JUMP
+        if (kexec_image->preserve_context) {
                 mutex_lock(&pm_mutex);
                 pm_prepare_console();
                 error = freeze_processes();
@@ -1459,6 +1451,7 @@ int kernel_kexec(void)
                 error = disable_nonboot_cpus();
                 if (error)
                         goto Resume_devices;
+                device_pm_lock();
                 local_irq_disable();
                 /* At this point, device_suspend() has been called,
                  * but *not* device_power_down(). We *must*
@@ -1470,26 +1463,22 @@ int kernel_kexec(void)
                 error = device_power_down(PMSG_FREEZE);
                 if (error)
                         goto Enable_irqs;
-                save_processor_state();
+        } else
 #endif
-        } else {
-                blocking_notifier_call_chain(&reboot_notifier_list,
-                                             SYS_RESTART, NULL);
-                system_state = SYSTEM_RESTART;
-                device_shutdown();
-                sysdev_shutdown();
+        {
+                kernel_restart_prepare(NULL);
                 printk(KERN_EMERG "Starting new kernel\n");
                 machine_shutdown();
         }
 
         machine_kexec(kexec_image);
 
-        if (kexec_image->preserve_context) {
 #ifdef CONFIG_KEXEC_JUMP
-                restore_processor_state();
+        if (kexec_image->preserve_context) {
                 device_power_up(PMSG_RESTORE);
  Enable_irqs:
                 local_irq_enable();
+                device_pm_unlock();
                 enable_nonboot_cpus();
  Resume_devices:
                 device_resume(PMSG_RESTORE);
@@ -1499,11 +1488,10 @@ int kernel_kexec(void)
  Restore_console:
                 pm_restore_console();
                 mutex_unlock(&pm_mutex);
-#endif
         }
+#endif
 
  Unlock:
-        xchg(&kexec_lock, 0);
-
+        mutex_unlock(&kexec_mutex);
         return error;
 }