7 files changed, 108 insertions, 25 deletions

diff --git a/kernel/power/block_io.c b/kernel/power/block_io.c
index 97024fd40cd5..83bbc7c02df9 100644
--- a/kernel/power/block_io.c
+++ b/kernel/power/block_io.c
@@ -28,7 +28,7 @@
 static int submit(int rw, struct block_device *bdev, sector_t sector,
                 struct page *page, struct bio **bio_chain)
 {
-        const int bio_rw = rw | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
+        const int bio_rw = rw | REQ_SYNC | REQ_UNPLUG;
         struct bio *bio;
 
         bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index aa9e916da4d5..c77963938bca 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -3,7 +3,7 @@
  *
  * Copyright (c) 2003 Patrick Mochel
  * Copyright (c) 2003 Open Source Development Lab
- * Copyright (c) 2004 Pavel Machek <pavel@suse.cz>
+ * Copyright (c) 2004 Pavel Machek <pavel@ucw.cz>
  * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
  *
  * This file is released under the GPLv2.
@@ -277,7 +277,7 @@ static int create_image(int platform_mode)
                 goto Enable_irqs;
         }
 
-        if (hibernation_test(TEST_CORE))
+        if (hibernation_test(TEST_CORE) || !pm_check_wakeup_events())
                 goto Power_up;
 
         in_suspend = 1;
@@ -288,8 +288,10 @@ static int create_image(int platform_mode)
                         error);
         /* Restore control flow magically appears here */
         restore_processor_state();
-        if (!in_suspend)
+        if (!in_suspend) {
+                events_check_enabled = false;
                 platform_leave(platform_mode);
+        }
 
  Power_up:
         sysdev_resume();
@@ -328,7 +330,7 @@ int hibernation_snapshot(int platform_mode)
 
         error = platform_begin(platform_mode);
         if (error)
-                return error;
+                goto Close;
 
         /* Preallocate image memory before shutting down devices. */
         error = hibernate_preallocate_memory();
@@ -336,6 +338,7 @@ int hibernation_snapshot(int platform_mode)
                 goto Close;
 
         suspend_console();
+        hibernation_freeze_swap();
         saved_mask = clear_gfp_allowed_mask(GFP_IOFS);
         error = dpm_suspend_start(PMSG_FREEZE);
         if (error)
@@ -511,18 +514,24 @@ int hibernation_platform_enter(void)
 
         local_irq_disable();
         sysdev_suspend(PMSG_HIBERNATE);
+        if (!pm_check_wakeup_events()) {
+                error = -EAGAIN;
+                goto Power_up;
+        }
+
         hibernation_ops->enter();
         /* We should never get here */
         while (1);
 
-        /*
-         * We don't need to reenable the nonboot CPUs or resume consoles, since
-         * the system is going to be halted anyway.
-         */
+ Power_up:
+        sysdev_resume();
+        local_irq_enable();
+        enable_nonboot_cpus();
+
  Platform_finish:
         hibernation_ops->finish();
 
-        dpm_suspend_noirq(PMSG_RESTORE);
+        dpm_resume_noirq(PMSG_RESTORE);
 
  Resume_devices:
         entering_platform_hibernation = false;
diff --git a/kernel/power/main.c b/kernel/power/main.c
index b58800b21fc0..62b0bc6e4983 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -204,6 +204,60 @@ static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 
 power_attr(state);
 
+#ifdef CONFIG_PM_SLEEP
+/*
+ * The 'wakeup_count' attribute, along with the functions defined in
+ * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
+ * handled in a non-racy way.
+ *
+ * If a wakeup event occurs when the system is in a sleep state, it simply is
+ * woken up.  In turn, if an event that would wake the system up from a sleep
+ * state occurs when it is undergoing a transition to that sleep state, the
+ * transition should be aborted.  Moreover, if such an event occurs when the
+ * system is in the working state, an attempt to start a transition to the
+ * given sleep state should fail during certain period after the detection of
+ * the event.  Using the 'state' attribute alone is not sufficient to satisfy
+ * these requirements, because a wakeup event may occur exactly when 'state'
+ * is being written to and may be delivered to user space right before it is
+ * frozen, so the event will remain only partially processed until the system is
+ * woken up by another event.  In particular, it won't cause the transition to
+ * a sleep state to be aborted.
+ *
+ * This difficulty may be overcome if user space uses 'wakeup_count' before
+ * writing to 'state'.  It first should read from 'wakeup_count' and store
+ * the read value.  Then, after carrying out its own preparations for the system
+ * transition to a sleep state, it should write the stored value to
+ * 'wakeup_count'.  If that fails, at least one wakeup event has occured since
+ * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
+ * is allowed to write to 'state', but the transition will be aborted if there
+ * are any wakeup events detected after 'wakeup_count' was written to.
+ */
+
+static ssize_t wakeup_count_show(struct kobject *kobj,
+                                struct kobj_attribute *attr,
+                                char *buf)
+{
+        unsigned long val;
+
+        return pm_get_wakeup_count(&val) ? sprintf(buf, "%lu\n", val) : -EINTR;
+}
+
+static ssize_t wakeup_count_store(struct kobject *kobj,
+                                struct kobj_attribute *attr,
+                                const char *buf, size_t n)
+{
+        unsigned long val;
+
+        if (sscanf(buf, "%lu", &val) == 1) {
+                if (pm_save_wakeup_count(val))
+                        return n;
+        }
+        return -EINVAL;
+}
+
+power_attr(wakeup_count);
+#endif /* CONFIG_PM_SLEEP */
+
 #ifdef CONFIG_PM_TRACE
 int pm_trace_enabled;
 
@@ -236,6 +290,7 @@ static struct attribute * g[] = {
 #endif
 #ifdef CONFIG_PM_SLEEP
         &pm_async_attr.attr,
+        &wakeup_count_attr.attr,
 #ifdef CONFIG_PM_DEBUG
         &pm_test_attr.attr,
 #endif
diff --git a/kernel/power/process.c b/kernel/power/process.c
index 71ae29052ab6..028a99598f49 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -15,6 +15,7 @@
 #include <linux/syscalls.h>
 #include <linux/freezer.h>
 #include <linux/delay.h>
+#include <linux/workqueue.h>
 
 /* 
  * Timeout for stopping processes
@@ -35,6 +36,7 @@ static int try_to_freeze_tasks(bool sig_only)
         struct task_struct *g, *p;
         unsigned long end_time;
         unsigned int todo;
+        bool wq_busy = false;
         struct timeval start, end;
         u64 elapsed_csecs64;
         unsigned int elapsed_csecs;
@@ -42,6 +44,10 @@ static int try_to_freeze_tasks(bool sig_only)
         do_gettimeofday(&start);
 
         end_time = jiffies + TIMEOUT;
+
+        if (!sig_only)
+                freeze_workqueues_begin();
+
         while (true) {
                 todo = 0;
                 read_lock(&tasklist_lock);
@@ -63,6 +69,12 @@ static int try_to_freeze_tasks(bool sig_only)
                                 todo++;
                 } while_each_thread(g, p);
                 read_unlock(&tasklist_lock);
+
+                if (!sig_only) {
+                        wq_busy = freeze_workqueues_busy();
+                        todo += wq_busy;
+                }
+
                 if (!todo || time_after(jiffies, end_time))
                         break;
 
@@ -86,8 +98,12 @@ static int try_to_freeze_tasks(bool sig_only)
                  */
                 printk("\n");
                 printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
-                                "(%d tasks refusing to freeze):\n",
-                                elapsed_csecs / 100, elapsed_csecs % 100, todo);
+                       "(%d tasks refusing to freeze, wq_busy=%d):\n",
+                       elapsed_csecs / 100, elapsed_csecs % 100,
+                       todo - wq_busy, wq_busy);
+
+                thaw_workqueues();
+
                 read_lock(&tasklist_lock);
                 do_each_thread(g, p) {
                         task_lock(p);
@@ -157,6 +173,7 @@ void thaw_processes(void)
         oom_killer_enable();
 
         printk("Restarting tasks ... ");
+        thaw_workqueues();
         thaw_tasks(true);
         thaw_tasks(false);
         schedule();
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index 25ce010e9f8b..5e7edfb05e66 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -3,7 +3,7 @@
  *
  * This file provides system snapshot/restore functionality for swsusp.
  *
- * Copyright (C) 1998-2005 Pavel Machek <pavel@suse.cz>
+ * Copyright (C) 1998-2005 Pavel Machek <pavel@ucw.cz>
  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
  *
  * This file is released under the GPLv2.
@@ -1086,6 +1086,7 @@ void swsusp_free(void)
         buffer = NULL;
         alloc_normal = 0;
         alloc_highmem = 0;
+        hibernation_thaw_swap();
 }
 
 /* Helper functions used for the shrinking of memory. */
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index f37cb7dd4402..7335952ee473 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -136,19 +136,19 @@ static int suspend_enter(suspend_state_t state)
         if (suspend_ops->prepare) {
                 error = suspend_ops->prepare();
                 if (error)
-                        return error;
+                        goto Platform_finish;
         }
 
         error = dpm_suspend_noirq(PMSG_SUSPEND);
         if (error) {
                 printk(KERN_ERR "PM: Some devices failed to power down\n");
-                goto Platfrom_finish;
+                goto Platform_finish;
         }
 
         if (suspend_ops->prepare_late) {
                 error = suspend_ops->prepare_late();
                 if (error)
-                        goto Power_up_devices;
+                        goto Platform_wake;
         }
 
         if (suspend_test(TEST_PLATFORM))
@@ -163,8 +163,10 @@ static int suspend_enter(suspend_state_t state)
 
         error = sysdev_suspend(PMSG_SUSPEND);
         if (!error) {
-                if (!suspend_test(TEST_CORE))
+                if (!suspend_test(TEST_CORE) && pm_check_wakeup_events()) {
                         error = suspend_ops->enter(state);
+                        events_check_enabled = false;
+                }
                 sysdev_resume();
         }
 
@@ -178,10 +180,9 @@ static int suspend_enter(suspend_state_t state)
         if (suspend_ops->wake)
                 suspend_ops->wake();
 
- Power_up_devices:
         dpm_resume_noirq(PMSG_RESUME);
 
- Platfrom_finish:
+ Platform_finish:
         if (suspend_ops->finish)
                 suspend_ops->finish();
 
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index b0bb21778391..5d0059eed3e4 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -4,7 +4,7 @@
  * This file provides functions for reading the suspend image from
  * and writing it to a swap partition.
  *
- * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
+ * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@ucw.cz>
  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
  *
  * This file is released under the GPLv2.
@@ -32,7 +32,7 @@
 /*
  *      The swap map is a data structure used for keeping track of each page
  *      written to a swap partition.  It consists of many swap_map_page
- *      structures that contain each an array of MAP_PAGE_SIZE swap entries.
+ *      structures that contain each an array of MAP_PAGE_ENTRIES swap entries.
  *      These structures are stored on the swap and linked together with the
  *      help of the .next_swap member.
  *
@@ -136,10 +136,10 @@ sector_t alloc_swapdev_block(int swap)
 {
         unsigned long offset;
 
-        offset = swp_offset(get_swap_page_of_type(swap));
+        offset = swp_offset(get_swap_for_hibernation(swap));
         if (offset) {
                 if (swsusp_extents_insert(offset))
-                        swap_free(swp_entry(swap, offset));
+                        swap_free_for_hibernation(swp_entry(swap, offset));
                 else
                         return swapdev_block(swap, offset);
         }
@@ -148,7 +148,7 @@ sector_t alloc_swapdev_block(int swap)
 
 /**
  *      free_all_swap_pages - free swap pages allocated for saving image data.
- *      It also frees the extents used to register which swap entres had been
+ *      It also frees the extents used to register which swap entries had been
  *      allocated.
  */
 
@@ -163,7 +163,7 @@ void free_all_swap_pages(int swap)
                 ext = container_of(node, struct swsusp_extent, node);
                 rb_erase(node, &swsusp_extents);
                 for (offset = ext->start; offset <= ext->end; offset++)
-                        swap_free(swp_entry(swap, offset));
+                        swap_free_for_hibernation(swp_entry(swap, offset));
 
                 kfree(ext);
         }