Merge commit 'v3.3-rc6' into next

8 files changed, 227 insertions, 236 deletions

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index 196c01268ebd..6d6d28870335 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -43,8 +43,6 @@ int in_suspend __nosavedata;
 enum {
         HIBERNATION_INVALID,
         HIBERNATION_PLATFORM,
-        HIBERNATION_TEST,
-        HIBERNATION_TESTPROC,
         HIBERNATION_SHUTDOWN,
         HIBERNATION_REBOOT,
         /* keep last */
@@ -55,7 +53,7 @@ enum {
 
 static int hibernation_mode = HIBERNATION_SHUTDOWN;
 
-static bool freezer_test_done;
+bool freezer_test_done;
 
 static const struct platform_hibernation_ops *hibernation_ops;
 
@@ -71,14 +69,14 @@ void hibernation_set_ops(const struct platform_hibernation_ops *ops)
                 WARN_ON(1);
                 return;
         }
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
         hibernation_ops = ops;
         if (ops)
                 hibernation_mode = HIBERNATION_PLATFORM;
         else if (hibernation_mode == HIBERNATION_PLATFORM)
                 hibernation_mode = HIBERNATION_SHUTDOWN;
 
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 }
 
 static bool entering_platform_hibernation;
@@ -96,15 +94,6 @@ static void hibernation_debug_sleep(void)
         mdelay(5000);
 }
 
-static int hibernation_testmode(int mode)
-{
-        if (hibernation_mode == mode) {
-                hibernation_debug_sleep();
-                return 1;
-        }
-        return 0;
-}
-
 static int hibernation_test(int level)
 {
         if (pm_test_level == level) {
@@ -114,7 +103,6 @@ static int hibernation_test(int level)
         return 0;
 }
 #else /* !CONFIG_PM_DEBUG */
-static int hibernation_testmode(int mode) { return 0; }
 static int hibernation_test(int level) { return 0; }
 #endif /* !CONFIG_PM_DEBUG */
 
@@ -278,8 +266,7 @@ static int create_image(int platform_mode)
                 goto Platform_finish;
 
         error = disable_nonboot_cpus();
-        if (error || hibernation_test(TEST_CPUS)
-            || hibernation_testmode(HIBERNATION_TEST))
+        if (error || hibernation_test(TEST_CPUS))
                 goto Enable_cpus;
 
         local_irq_disable();
@@ -333,7 +320,7 @@ static int create_image(int platform_mode)
  */
 int hibernation_snapshot(int platform_mode)
 {
-        pm_message_t msg = PMSG_RECOVER;
+        pm_message_t msg;
         int error;
 
         error = platform_begin(platform_mode);
@@ -347,39 +334,40 @@ int hibernation_snapshot(int platform_mode)
 
         error = freeze_kernel_threads();
         if (error)
-                goto Close;
+                goto Cleanup;
 
-        if (hibernation_test(TEST_FREEZER) ||
-                hibernation_testmode(HIBERNATION_TESTPROC)) {
+        if (hibernation_test(TEST_FREEZER)) {
 
                 /*
                  * Indicate to the caller that we are returning due to a
                  * successful freezer test.
                  */
                 freezer_test_done = true;
-                goto Close;
+                goto Cleanup;
         }
 
         error = dpm_prepare(PMSG_FREEZE);
-        if (error)
-                goto Complete_devices;
+        if (error) {
+                dpm_complete(PMSG_RECOVER);
+                goto Cleanup;
+        }
 
         suspend_console();
         pm_restrict_gfp_mask();
+
         error = dpm_suspend(PMSG_FREEZE);
-        if (error)
-                goto Recover_platform;
 
-        if (hibernation_test(TEST_DEVICES))
-                goto Recover_platform;
+        if (error || hibernation_test(TEST_DEVICES))
+                platform_recover(platform_mode);
+        else
+                error = create_image(platform_mode);
 
-        error = create_image(platform_mode);
         /*
-         * Control returns here (1) after the image has been created or the
+         * In the case that we call create_image() above, the control
+         * returns here (1) after the image has been created or the
          * image creation has failed and (2) after a successful restore.
          */
 
- Resume_devices:
         /* We may need to release the preallocated image pages here. */
         if (error || !in_suspend)
                 swsusp_free();
@@ -391,17 +379,15 @@ int hibernation_snapshot(int platform_mode)
                 pm_restore_gfp_mask();
 
         resume_console();
-
- Complete_devices:
         dpm_complete(msg);
 
  Close:
         platform_end(platform_mode);
         return error;
 
- Recover_platform:
-        platform_recover(platform_mode);
-        goto Resume_devices;
+ Cleanup:
+        swsusp_free();
+        goto Close;
 }
 
 /**
@@ -586,9 +572,6 @@ int hibernation_platform_enter(void)
 static void power_down(void)
 {
         switch (hibernation_mode) {
-        case HIBERNATION_TEST:
-        case HIBERNATION_TESTPROC:
-                break;
         case HIBERNATION_REBOOT:
                 kernel_restart(NULL);
                 break;
@@ -607,17 +590,6 @@ static void power_down(void)
         while(1);
 }
 
-static int prepare_processes(void)
-{
-        int error = 0;
-
-        if (freeze_processes()) {
-                error = -EBUSY;
-                thaw_processes();
-        }
-        return error;
-}
-
 /**
  * hibernate - Carry out system hibernation, including saving the image.
  */
@@ -625,7 +597,7 @@ int hibernate(void)
 {
         int error;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
         /* The snapshot device should not be opened while we're running */
         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
                 error = -EBUSY;
@@ -650,7 +622,7 @@ int hibernate(void)
         sys_sync();
         printk("done.\n");
 
-        error = prepare_processes();
+        error = freeze_processes();
         if (error)
                 goto Finish;
 
@@ -693,7 +665,7 @@ int hibernate(void)
         pm_restore_console();
         atomic_inc(&snapshot_device_available);
  Unlock:
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
         return error;
 }
 
@@ -807,11 +779,13 @@ static int software_resume(void)
                 goto close_finish;
 
         error = create_basic_memory_bitmaps();
-        if (error)
+        if (error) {
+                usermodehelper_enable();
                 goto close_finish;
+        }
 
         pr_debug("PM: Preparing processes for restore.\n");
-        error = prepare_processes();
+        error = freeze_processes();
         if (error) {
                 swsusp_close(FMODE_READ);
                 goto Done;
@@ -851,8 +825,6 @@ static const char * const hibernation_modes[] = {
         [HIBERNATION_PLATFORM]  = "platform",
         [HIBERNATION_SHUTDOWN]  = "shutdown",
         [HIBERNATION_REBOOT]    = "reboot",
-        [HIBERNATION_TEST]      = "test",
-        [HIBERNATION_TESTPROC]  = "testproc",
 };
 
 /*
@@ -861,17 +833,15 @@ static const char * const hibernation_modes[] = {
  * Hibernation can be handled in several ways.  There are a few different ways
  * to put the system into the sleep state: using the platform driver (e.g. ACPI
  * or other hibernation_ops), powering it off or rebooting it (for testing
- * mostly), or using one of the two available test modes.
+ * mostly).
  *
  * The sysfs file /sys/power/disk provides an interface for selecting the
  * hibernation mode to use.  Reading from this file causes the available modes
- * to be printed.  There are 5 modes that can be supported:
+ * to be printed.  There are 3 modes that can be supported:
  *
  *      'platform'
  *      'shutdown'
  *      'reboot'
- *      'test'
- *      'testproc'
  *
  * If a platform hibernation driver is in use, 'platform' will be supported
  * and will be used by default.  Otherwise, 'shutdown' will be used by default.
@@ -895,8 +865,6 @@ static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
                 switch (i) {
                 case HIBERNATION_SHUTDOWN:
                 case HIBERNATION_REBOOT:
-                case HIBERNATION_TEST:
-                case HIBERNATION_TESTPROC:
                         break;
                 case HIBERNATION_PLATFORM:
                         if (hibernation_ops)
@@ -925,7 +893,7 @@ static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
         p = memchr(buf, '\n', n);
         len = p ? p - buf : n;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
                 if (len == strlen(hibernation_modes[i])
                     && !strncmp(buf, hibernation_modes[i], len)) {
@@ -937,8 +905,6 @@ static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
                 switch (mode) {
                 case HIBERNATION_SHUTDOWN:
                 case HIBERNATION_REBOOT:
-                case HIBERNATION_TEST:
-                case HIBERNATION_TESTPROC:
                         hibernation_mode = mode;
                         break;
                 case HIBERNATION_PLATFORM:
@@ -953,7 +919,7 @@ static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
         if (!error)
                 pr_debug("PM: Hibernation mode set to '%s'\n",
                          hibernation_modes[mode]);
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
         return error ? error : n;
 }
 
@@ -980,9 +946,9 @@ static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
         if (maj != MAJOR(res) || min != MINOR(res))
                 goto out;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
         swsusp_resume_device = res;
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
         printk(KERN_INFO "PM: Starting manual resume from disk\n");
         noresume = 0;
         software_resume();
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 36e0f0903c32..9824b41e5a18 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -3,7 +3,7 @@
  *
  * Copyright (c) 2003 Patrick Mochel
  * Copyright (c) 2003 Open Source Development Lab
- * 
+ *
  * This file is released under the GPLv2
  *
  */
@@ -116,7 +116,7 @@ static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
         p = memchr(buf, '\n', n);
         len = p ? p - buf : n;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
 
         level = TEST_FIRST;
         for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
@@ -126,7 +126,7 @@ static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
                         break;
                 }
 
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 
         return error ? error : n;
 }
@@ -240,7 +240,7 @@ struct kobject *power_kobj;
  *      'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
  *      'disk' (Suspend-to-Disk).
  *
- *      store() accepts one of those strings, translates it into the 
+ *      store() accepts one of those strings, translates it into the
  *      proper enumerated value, and initiates a suspend transition.
  */
 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
@@ -282,7 +282,7 @@ static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
         /* First, check if we are requested to hibernate */
         if (len == 4 && !strncmp(buf, "disk", len)) {
                 error = hibernate();
-  goto Exit;
+                goto Exit;
         }
 
 #ifdef CONFIG_SUSPEND
diff --git a/kernel/power/power.h b/kernel/power/power.h
index 23a2db1ec442..21724eee5206 100644
--- a/kernel/power/power.h
+++ b/kernel/power/power.h
@@ -50,6 +50,8 @@ static inline char *check_image_kernel(struct swsusp_info *info)
 #define SPARE_PAGES     ((1024 * 1024) >> PAGE_SHIFT)
 
 /* kernel/power/hibernate.c */
+extern bool freezer_test_done;
+
 extern int hibernation_snapshot(int platform_mode);
 extern int hibernation_restore(int platform_mode);
 extern int hibernation_platform_enter(void);
@@ -229,8 +231,28 @@ extern int pm_test_level;
 #ifdef CONFIG_SUSPEND_FREEZER
 static inline int suspend_freeze_processes(void)
 {
-        int error = freeze_processes();
-        return error ? : freeze_kernel_threads();
+        int error;
+
+        error = freeze_processes();
+
+        /*
+         * freeze_processes() automatically thaws every task if freezing
+         * fails. So we need not do anything extra upon error.
+         */
+        if (error)
+                goto Finish;
+
+        error = freeze_kernel_threads();
+
+        /*
+         * freeze_kernel_threads() thaws only kernel threads upon freezing
+         * failure. So we have to thaw the userspace tasks ourselves.
+         */
+        if (error)
+                thaw_processes();
+
+ Finish:
+        return error;
 }
 
 static inline void suspend_thaw_processes(void)
diff --git a/kernel/power/process.c b/kernel/power/process.c
index addbbe5531bc..7e426459e60a 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -22,16 +22,7 @@
  */
 #define TIMEOUT (20 * HZ)
 
-static inline int freezable(struct task_struct * p)
-{
-        if ((p == current) ||
-            (p->flags & PF_NOFREEZE) ||
-            (p->exit_state != 0))
-                return 0;
-        return 1;
-}
-
-static int try_to_freeze_tasks(bool sig_only)
+static int try_to_freeze_tasks(bool user_only)
 {
         struct task_struct *g, *p;
         unsigned long end_time;
@@ -46,17 +37,14 @@ static int try_to_freeze_tasks(bool sig_only)
 
         end_time = jiffies + TIMEOUT;
 
-        if (!sig_only)
+        if (!user_only)
                 freeze_workqueues_begin();
 
         while (true) {
                 todo = 0;
                 read_lock(&tasklist_lock);
                 do_each_thread(g, p) {
-                        if (frozen(p) || !freezable(p))
-                                continue;
-
-                        if (!freeze_task(p, sig_only))
+                        if (p == current || !freeze_task(p))
                                 continue;
 
                         /*
@@ -77,7 +65,7 @@ static int try_to_freeze_tasks(bool sig_only)
                 } while_each_thread(g, p);
                 read_unlock(&tasklist_lock);
 
-                if (!sig_only) {
+                if (!user_only) {
                         wq_busy = freeze_workqueues_busy();
                         todo += wq_busy;
                 }
@@ -103,11 +91,6 @@ static int try_to_freeze_tasks(bool sig_only)
         elapsed_csecs = elapsed_csecs64;
 
         if (todo) {
-                /* This does not unfreeze processes that are already frozen
-                 * (we have slightly ugly calling convention in that respect,
-                 * and caller must call thaw_processes() if something fails),
-                 * but it cleans up leftover PF_FREEZE requests.
-                 */
                 printk("\n");
                 printk(KERN_ERR "Freezing of tasks %s after %d.%02d seconds "
                        "(%d tasks refusing to freeze, wq_busy=%d):\n",
@@ -115,15 +98,11 @@ static int try_to_freeze_tasks(bool sig_only)
                        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);
-                        if (!wakeup && freezing(p) && !freezer_should_skip(p))
+                        if (!wakeup && !freezer_should_skip(p) &&
+                            p != current && freezing(p) && !frozen(p))
                                 sched_show_task(p);
-                        cancel_freezing(p);
-                        task_unlock(p);
                 } while_each_thread(g, p);
                 read_unlock(&tasklist_lock);
         } else {
@@ -136,12 +115,18 @@ static int try_to_freeze_tasks(bool sig_only)
 
 /**
  * freeze_processes - Signal user space processes to enter the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and system is fully thawed.
  */
 int freeze_processes(void)
 {
         int error;
 
+        if (!pm_freezing)
+                atomic_inc(&system_freezing_cnt);
+
         printk("Freezing user space processes ... ");
+        pm_freezing = true;
         error = try_to_freeze_tasks(true);
         if (!error) {
                 printk("done.");
@@ -150,17 +135,25 @@ int freeze_processes(void)
         printk("\n");
         BUG_ON(in_atomic());
 
+        if (error)
+                thaw_processes();
         return error;
 }
 
 /**
  * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and only the kernel threads are
+ * thawed, so as to give a chance to the caller to do additional cleanups
+ * (if any) before thawing the userspace tasks. So, it is the responsibility
+ * of the caller to thaw the userspace tasks, when the time is right.
  */
 int freeze_kernel_threads(void)
 {
         int error;
 
         printk("Freezing remaining freezable tasks ... ");
+        pm_nosig_freezing = true;
         error = try_to_freeze_tasks(false);
         if (!error)
                 printk("done.");
@@ -168,38 +161,52 @@ int freeze_kernel_threads(void)
         printk("\n");
         BUG_ON(in_atomic());
 
+        if (error)
+                thaw_kernel_threads();
         return error;
 }
 
-static void thaw_tasks(bool nosig_only)
+void thaw_processes(void)
 {
         struct task_struct *g, *p;
 
-        read_lock(&tasklist_lock);
-        do_each_thread(g, p) {
-                if (!freezable(p))
-                        continue;
+        if (pm_freezing)
+                atomic_dec(&system_freezing_cnt);
+        pm_freezing = false;
+        pm_nosig_freezing = false;
 
-                if (nosig_only && should_send_signal(p))
-                        continue;
+        oom_killer_enable();
+
+        printk("Restarting tasks ... ");
 
-                if (cgroup_freezing_or_frozen(p))
-                        continue;
+        thaw_workqueues();
 
-                thaw_process(p);
+        read_lock(&tasklist_lock);
+        do_each_thread(g, p) {
+                __thaw_task(p);
         } while_each_thread(g, p);
         read_unlock(&tasklist_lock);
+
+        schedule();
+        printk("done.\n");
 }
 
-void thaw_processes(void)
+void thaw_kernel_threads(void)
 {
-        oom_killer_enable();
+        struct task_struct *g, *p;
+
+        pm_nosig_freezing = false;
+        printk("Restarting kernel threads ... ");
 
-        printk("Restarting tasks ... ");
         thaw_workqueues();
-        thaw_tasks(true);
-        thaw_tasks(false);
+
+        read_lock(&tasklist_lock);
+        do_each_thread(g, p) {
+                if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
+                        __thaw_task(p);
+        } while_each_thread(g, p);
+        read_unlock(&tasklist_lock);
+
         schedule();
         printk("done.\n");
 }
-
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index cbe2c1441392..6a768e537001 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -812,7 +812,8 @@ unsigned int snapshot_additional_pages(struct zone *zone)
         unsigned int res;
 
         res = DIV_ROUND_UP(zone->spanned_pages, BM_BITS_PER_BLOCK);
-        res += DIV_ROUND_UP(res * sizeof(struct bm_block), PAGE_SIZE);
+        res += DIV_ROUND_UP(res * sizeof(struct bm_block),
+                            LINKED_PAGE_DATA_SIZE);
         return 2 * res;
 }
 
@@ -858,6 +859,9 @@ static struct page *saveable_highmem_page(struct zone *zone, unsigned long pfn)
             PageReserved(page))
                 return NULL;
 
+        if (page_is_guard(page))
+                return NULL;
+
         return page;
 }
 
@@ -920,6 +924,9 @@ static struct page *saveable_page(struct zone *zone, unsigned long pfn)
             && (!kernel_page_present(page) || pfn_is_nosave(pfn)))
                 return NULL;
 
+        if (page_is_guard(page))
+                return NULL;
+
         return page;
 }
 
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 4953dc054c53..4fd51beed879 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -42,9 +42,9 @@ static const struct platform_suspend_ops *suspend_ops;
  */
 void suspend_set_ops(const struct platform_suspend_ops *ops)
 {
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
         suspend_ops = ops;
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 }
 EXPORT_SYMBOL_GPL(suspend_set_ops);
 
@@ -106,13 +106,11 @@ static int suspend_prepare(void)
                 goto Finish;
 
         error = suspend_freeze_processes();
-        if (error) {
-                suspend_stats.failed_freeze++;
-                dpm_save_failed_step(SUSPEND_FREEZE);
-        } else
+        if (!error)
                 return 0;
 
-        suspend_thaw_processes();
+        suspend_stats.failed_freeze++;
+        dpm_save_failed_step(SUSPEND_FREEZE);
         usermodehelper_enable();
  Finish:
         pm_notifier_call_chain(PM_POST_SUSPEND);
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 11a594c4ba25..8742fd013a94 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -18,7 +18,6 @@
 #include <linux/bitops.h>
 #include <linux/genhd.h>
 #include <linux/device.h>
-#include <linux/buffer_head.h>
 #include <linux/bio.h>
 #include <linux/blkdev.h>
 #include <linux/swap.h>
@@ -774,8 +773,7 @@ static int enough_swap(unsigned int nr_pages, unsigned int flags)
 
         pr_debug("PM: Free swap pages: %u\n", free_swap);
 
-        required = PAGES_FOR_IO + ((flags & SF_NOCOMPRESS_MODE) ?
-                nr_pages : (nr_pages * LZO_CMP_PAGES) / LZO_UNC_PAGES + 1);
+        required = PAGES_FOR_IO + nr_pages;
         return free_swap > required;
 }
 
@@ -803,10 +801,12 @@ int swsusp_write(unsigned int flags)
                 printk(KERN_ERR "PM: Cannot get swap writer\n");
                 return error;
         }
-        if (!enough_swap(pages, flags)) {
-                printk(KERN_ERR "PM: Not enough free swap\n");
-                error = -ENOSPC;
-                goto out_finish;
+        if (flags & SF_NOCOMPRESS_MODE) {
+                if (!enough_swap(pages, flags)) {
+                        printk(KERN_ERR "PM: Not enough free swap\n");
+                        error = -ENOSPC;
+                        goto out_finish;
+                }
         }
         memset(&snapshot, 0, sizeof(struct snapshot_handle));
         error = snapshot_read_next(&snapshot);
diff --git a/kernel/power/user.c b/kernel/power/user.c
index 6d8f535c2b88..3e100075b13c 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -21,6 +21,7 @@
 #include <linux/swapops.h>
 #include <linux/pm.h>
 #include <linux/fs.h>
+#include <linux/compat.h>
 #include <linux/console.h>
 #include <linux/cpu.h>
 #include <linux/freezer.h>
@@ -30,28 +31,6 @@
 
 #include "power.h"
 
-/*
- * NOTE: The SNAPSHOT_SET_SWAP_FILE and SNAPSHOT_PMOPS ioctls are obsolete and
- * will be removed in the future.  They are only preserved here for
- * compatibility with existing userland utilities.
- */
-#define SNAPSHOT_SET_SWAP_FILE  _IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int)
-#define SNAPSHOT_PMOPS          _IOW(SNAPSHOT_IOC_MAGIC, 12, unsigned int)
-
-#define PMOPS_PREPARE   1
-#define PMOPS_ENTER     2
-#define PMOPS_FINISH    3
-
-/*
- * NOTE: The following ioctl definitions are wrong and have been replaced with
- * correct ones.  They are only preserved here for compatibility with existing
- * userland utilities and will be removed in the future.
- */
-#define SNAPSHOT_ATOMIC_SNAPSHOT        _IOW(SNAPSHOT_IOC_MAGIC, 3, void *)
-#define SNAPSHOT_SET_IMAGE_SIZE         _IOW(SNAPSHOT_IOC_MAGIC, 6, unsigned long)
-#define SNAPSHOT_AVAIL_SWAP             _IOR(SNAPSHOT_IOC_MAGIC, 7, void *)
-#define SNAPSHOT_GET_SWAP_PAGE          _IOR(SNAPSHOT_IOC_MAGIC, 8, void *)
-
 
 #define SNAPSHOT_MINOR  231
 
@@ -71,7 +50,7 @@ static int snapshot_open(struct inode *inode, struct file *filp)
         struct snapshot_data *data;
         int error;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
 
         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
                 error = -EBUSY;
@@ -123,7 +102,7 @@ static int snapshot_open(struct inode *inode, struct file *filp)
         data->platform_support = 0;
 
  Unlock:
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 
         return error;
 }
@@ -132,7 +111,7 @@ static int snapshot_release(struct inode *inode, struct file *filp)
 {
         struct snapshot_data *data;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
 
         swsusp_free();
         free_basic_memory_bitmaps();
@@ -146,7 +125,7 @@ static int snapshot_release(struct inode *inode, struct file *filp)
                         PM_POST_HIBERNATION : PM_POST_RESTORE);
         atomic_inc(&snapshot_device_available);
 
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 
         return 0;
 }
@@ -158,7 +137,7 @@ static ssize_t snapshot_read(struct file *filp, char __user *buf,
         ssize_t res;
         loff_t pg_offp = *offp & ~PAGE_MASK;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
 
         data = filp->private_data;
         if (!data->ready) {
@@ -179,7 +158,7 @@ static ssize_t snapshot_read(struct file *filp, char __user *buf,
                 *offp += res;
 
  Unlock:
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 
         return res;
 }
@@ -191,7 +170,7 @@ static ssize_t snapshot_write(struct file *filp, const char __user *buf,
         ssize_t res;
         loff_t pg_offp = *offp & ~PAGE_MASK;
 
-        mutex_lock(&pm_mutex);
+        lock_system_sleep();
 
         data = filp->private_data;
 
@@ -208,20 +187,11 @@ static ssize_t snapshot_write(struct file *filp, const char __user *buf,
         if (res > 0)
                 *offp += res;
 unlock:
-        mutex_unlock(&pm_mutex);
+        unlock_system_sleep();
 
         return res;
 }
 
-static void snapshot_deprecated_ioctl(unsigned int cmd)
-{
-        if (printk_ratelimit())
-                printk(KERN_NOTICE "%pf: ioctl '%.8x' is deprecated and will "
-                                "be removed soon, update your suspend-to-disk "
-                                "utilities\n",
-                                __builtin_return_address(0), cmd);
-}
-
 static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                                                         unsigned long arg)
 {
@@ -257,11 +227,9 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                         break;
 
                 error = freeze_processes();
-                if (error) {
-                        thaw_processes();
+                if (error)
                         usermodehelper_enable();
-                }
-                if (!error)
+                else
                         data->frozen = 1;
                 break;
 
@@ -274,8 +242,6 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 data->frozen = 0;
                 break;
 
-        case SNAPSHOT_ATOMIC_SNAPSHOT:
-                snapshot_deprecated_ioctl(cmd);
         case SNAPSHOT_CREATE_IMAGE:
                 if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
                         error = -EPERM;
@@ -283,10 +249,17 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 }
                 pm_restore_gfp_mask();
                 error = hibernation_snapshot(data->platform_support);
-                if (!error)
+                if (error) {
+                        thaw_kernel_threads();
+                } else {
                         error = put_user(in_suspend, (int __user *)arg);
-                if (!error)
-                        data->ready = 1;
+                        if (!error && !freezer_test_done)
+                                data->ready = 1;
+                        if (freezer_test_done) {
+                                freezer_test_done = false;
+                                thaw_kernel_threads();
+                        }
+                }
                 break;
 
         case SNAPSHOT_ATOMIC_RESTORE:
@@ -303,10 +276,17 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 swsusp_free();
                 memset(&data->handle, 0, sizeof(struct snapshot_handle));
                 data->ready = 0;
+                /*
+                 * It is necessary to thaw kernel threads here, because
+                 * SNAPSHOT_CREATE_IMAGE may be invoked directly after
+                 * SNAPSHOT_FREE.  In that case, if kernel threads were not
+                 * thawed, the preallocation of memory carried out by
+                 * hibernation_snapshot() might run into problems (i.e. it
+                 * might fail or even deadlock).
+                 */
+                thaw_kernel_threads();
                 break;
 
-        case SNAPSHOT_SET_IMAGE_SIZE:
-                snapshot_deprecated_ioctl(cmd);
         case SNAPSHOT_PREF_IMAGE_SIZE:
                 image_size = arg;
                 break;
@@ -321,16 +301,12 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 error = put_user(size, (loff_t __user *)arg);
                 break;
 
-        case SNAPSHOT_AVAIL_SWAP:
-                snapshot_deprecated_ioctl(cmd);
         case SNAPSHOT_AVAIL_SWAP_SIZE:
                 size = count_swap_pages(data->swap, 1);
                 size <<= PAGE_SHIFT;
                 error = put_user(size, (loff_t __user *)arg);
                 break;
 
-        case SNAPSHOT_GET_SWAP_PAGE:
-                snapshot_deprecated_ioctl(cmd);
         case SNAPSHOT_ALLOC_SWAP_PAGE:
                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
                         error = -ENODEV;
@@ -353,27 +329,6 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 free_all_swap_pages(data->swap);
                 break;
 
-        case SNAPSHOT_SET_SWAP_FILE: /* This ioctl is deprecated */
-                snapshot_deprecated_ioctl(cmd);
-                if (!swsusp_swap_in_use()) {
-                        /*
-                         * User space encodes device types as two-byte values,
-                         * so we need to recode them
-                         */
-                        if (old_decode_dev(arg)) {
-                                data->swap = swap_type_of(old_decode_dev(arg),
-                                                        0, NULL);
-                                if (data->swap < 0)
-                                        error = -ENODEV;
-                        } else {
-                                data->swap = -1;
-                                error = -EINVAL;
-                        }
-                } else {
-                        error = -EPERM;
-                }
-                break;
-
         case SNAPSHOT_S2RAM:
                 if (!data->frozen) {
                         error = -EPERM;
@@ -396,33 +351,6 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                         error = hibernation_platform_enter();
                 break;
 
-        case SNAPSHOT_PMOPS: /* This ioctl is deprecated */
-                snapshot_deprecated_ioctl(cmd);
-                error = -EINVAL;
-
-                switch (arg) {
-
-                case PMOPS_PREPARE:
-                        data->platform_support = 1;
-                        error = 0;
-                        break;
-
-                case PMOPS_ENTER:
-                        if (data->platform_support)
-                                error = hibernation_platform_enter();
-                        break;
-
-                case PMOPS_FINISH:
-                        if (data->platform_support)
-                                error = 0;
-                        break;
-
-                default:
-                        printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
-
-                }
-                break;
-
         case SNAPSHOT_SET_SWAP_AREA:
                 if (swsusp_swap_in_use()) {
                         error = -EPERM;
@@ -464,6 +392,66 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
         return error;
 }
 
+#ifdef CONFIG_COMPAT
+
+struct compat_resume_swap_area {
+        compat_loff_t offset;
+        u32 dev;
+} __packed;
+
+static long
+snapshot_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        BUILD_BUG_ON(sizeof(loff_t) != sizeof(compat_loff_t));
+
+        switch (cmd) {
+        case SNAPSHOT_GET_IMAGE_SIZE:
+        case SNAPSHOT_AVAIL_SWAP_SIZE:
+        case SNAPSHOT_ALLOC_SWAP_PAGE: {
+                compat_loff_t __user *uoffset = compat_ptr(arg);
+                loff_t offset;
+                mm_segment_t old_fs;
+                int err;
+
+                old_fs = get_fs();
+                set_fs(KERNEL_DS);
+                err = snapshot_ioctl(file, cmd, (unsigned long) &offset);
+                set_fs(old_fs);
+                if (!err && put_user(offset, uoffset))
+                        err = -EFAULT;
+                return err;
+        }
+
+        case SNAPSHOT_CREATE_IMAGE:
+                return snapshot_ioctl(file, cmd,
+                                      (unsigned long) compat_ptr(arg));
+
+        case SNAPSHOT_SET_SWAP_AREA: {
+                struct compat_resume_swap_area __user *u_swap_area =
+                        compat_ptr(arg);
+                struct resume_swap_area swap_area;
+                mm_segment_t old_fs;
+                int err;
+
+                err = get_user(swap_area.offset, &u_swap_area->offset);
+                err |= get_user(swap_area.dev, &u_swap_area->dev);
+                if (err)
+                        return -EFAULT;
+                old_fs = get_fs();
+                set_fs(KERNEL_DS);
+                err = snapshot_ioctl(file, SNAPSHOT_SET_SWAP_AREA,
+                                     (unsigned long) &swap_area);
+                set_fs(old_fs);
+                return err;
+        }
+
+        default:
+                return snapshot_ioctl(file, cmd, arg);
+        }
+}
+
+#endif /* CONFIG_COMPAT */
+
 static const struct file_operations snapshot_fops = {
         .open = snapshot_open,
         .release = snapshot_release,
@@ -471,6 +459,9 @@ static const struct file_operations snapshot_fops = {
         .write = snapshot_write,
         .llseek = no_llseek,
         .unlocked_ioctl = snapshot_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = snapshot_compat_ioctl,
+#endif
 };
 
 static struct miscdevice snapshot_device = {