Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

12 files changed, 239 insertions, 215 deletions

diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 91e09d3b2eb2..5c36ea9d55d2 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -27,6 +27,15 @@ config PM_DEBUG
         code. This is helpful when debugging and reporting PM bugs, like
         suspend support.
 
+config PM_ADVANCED_DEBUG
+        bool "Extra PM attributes in sysfs for low-level debugging/testing"
+        depends on PM_DEBUG
+        default n
+        ---help---
+        Add extra sysfs attributes allowing one to access some Power Management
+        fields of device objects from user space.  If you are not a kernel
+        developer interested in debugging/testing Power Management, say "no".
+
 config PM_VERBOSE
         bool "Verbose Power Management debugging"
         depends on PM_DEBUG
@@ -85,6 +94,11 @@ config PM_SLEEP
         depends on SUSPEND || HIBERNATION || XEN_SAVE_RESTORE
         default y
 
+config PM_SLEEP_ADVANCED_DEBUG
+        bool
+        depends on PM_ADVANCED_DEBUG
+        default n
+
 config SUSPEND
         bool "Suspend to RAM and standby"
         depends on PM && ARCH_SUSPEND_POSSIBLE
@@ -222,3 +236,8 @@ config PM_RUNTIME
           and the bus type drivers of the buses the devices are on are
           responsible for the actual handling of the autosuspend requests and
           wake-up events.
+
+config PM_OPS
+        bool
+        depends on PM_SLEEP || PM_RUNTIME
+        default y
diff --git a/kernel/power/Makefile b/kernel/power/Makefile
index c3b81c30e5d5..43191815f874 100644
--- a/kernel/power/Makefile
+++ b/kernel/power/Makefile
@@ -8,7 +8,7 @@ obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)           += process.o
 obj-$(CONFIG_SUSPEND)           += suspend.o
 obj-$(CONFIG_PM_TEST_SUSPEND)   += suspend_test.o
-obj-$(CONFIG_HIBERNATION)       += swsusp.o hibernate.o snapshot.o swap.o user.o
+obj-$(CONFIG_HIBERNATION)       += hibernate.o snapshot.o swap.o user.o
 obj-$(CONFIG_HIBERNATION_NVS)   += hibernate_nvs.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)       += poweroff.o
diff --git a/kernel/power/console.c b/kernel/power/console.c
index 5187136fe1de..218e5af90156 100644
--- a/kernel/power/console.c
+++ b/kernel/power/console.c
@@ -6,7 +6,7 @@
 
 #include <linux/vt_kern.h>
 #include <linux/kbd_kern.h>
-#include <linux/console.h>
+#include <linux/vt.h>
 #include <linux/module.h>
 #include "power.h"
 
@@ -21,8 +21,7 @@ int pm_prepare_console(void)
         if (orig_fgconsole < 0)
                 return 1;
 
-        orig_kmsg = kmsg_redirect;
-        kmsg_redirect = SUSPEND_CONSOLE;
+        orig_kmsg = vt_kmsg_redirect(SUSPEND_CONSOLE);
         return 0;
 }
 
@@ -30,7 +29,7 @@ void pm_restore_console(void)
 {
         if (orig_fgconsole >= 0) {
                 vt_move_to_console(orig_fgconsole, 0);
-                kmsg_redirect = orig_kmsg;
+                vt_kmsg_redirect(orig_kmsg);
         }
 }
 #endif
diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index 04a9e90d248f..aa9e916da4d5 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -22,6 +22,7 @@
 #include <linux/console.h>
 #include <linux/cpu.h>
 #include <linux/freezer.h>
+#include <linux/gfp.h>
 #include <scsi/scsi_scan.h>
 #include <asm/suspend.h>
 
@@ -32,6 +33,7 @@ static int noresume = 0;
 static char resume_file[256] = CONFIG_PM_STD_PARTITION;
 dev_t swsusp_resume_device;
 sector_t swsusp_resume_block;
+int in_suspend __nosavedata = 0;
 
 enum {
         HIBERNATION_INVALID,
@@ -202,6 +204,35 @@ static void platform_recover(int platform_mode)
 }
 
 /**
+ *      swsusp_show_speed - print the time elapsed between two events.
+ *      @start: Starting event.
+ *      @stop: Final event.
+ *      @nr_pages -     number of pages processed between @start and @stop
+ *      @msg -          introductory message to print
+ */
+
+void swsusp_show_speed(struct timeval *start, struct timeval *stop,
+                        unsigned nr_pages, char *msg)
+{
+        s64 elapsed_centisecs64;
+        int centisecs;
+        int k;
+        int kps;
+
+        elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
+        do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
+        centisecs = elapsed_centisecs64;
+        if (centisecs == 0)
+                centisecs = 1;  /* avoid div-by-zero */
+        k = nr_pages * (PAGE_SIZE / 1024);
+        kps = (k * 100) / centisecs;
+        printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
+                        msg, k,
+                        centisecs / 100, centisecs % 100,
+                        kps / 1000, (kps % 1000) / 10);
+}
+
+/**
  *      create_image - freeze devices that need to be frozen with interrupts
  *      off, create the hibernation image and thaw those devices.  Control
  *      reappears in this routine after a restore.
@@ -293,6 +324,7 @@ static int create_image(int platform_mode)
 int hibernation_snapshot(int platform_mode)
 {
         int error;
+        gfp_t saved_mask;
 
         error = platform_begin(platform_mode);
         if (error)
@@ -304,6 +336,7 @@ int hibernation_snapshot(int platform_mode)
                 goto Close;
 
         suspend_console();
+        saved_mask = clear_gfp_allowed_mask(GFP_IOFS);
         error = dpm_suspend_start(PMSG_FREEZE);
         if (error)
                 goto Recover_platform;
@@ -321,6 +354,7 @@ int hibernation_snapshot(int platform_mode)
 
         dpm_resume_end(in_suspend ?
                 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
+        set_gfp_allowed_mask(saved_mask);
         resume_console();
  Close:
         platform_end(platform_mode);
@@ -415,14 +449,17 @@ static int resume_target_kernel(bool platform_mode)
 int hibernation_restore(int platform_mode)
 {
         int error;
+        gfp_t saved_mask;
 
         pm_prepare_console();
         suspend_console();
+        saved_mask = clear_gfp_allowed_mask(GFP_IOFS);
         error = dpm_suspend_start(PMSG_QUIESCE);
         if (!error) {
                 error = resume_target_kernel(platform_mode);
                 dpm_resume_end(PMSG_RECOVER);
         }
+        set_gfp_allowed_mask(saved_mask);
         resume_console();
         pm_restore_console();
         return error;
@@ -436,6 +473,7 @@ int hibernation_restore(int platform_mode)
 int hibernation_platform_enter(void)
 {
         int error;
+        gfp_t saved_mask;
 
         if (!hibernation_ops)
                 return -ENOSYS;
@@ -451,6 +489,7 @@ int hibernation_platform_enter(void)
 
         entering_platform_hibernation = true;
         suspend_console();
+        saved_mask = clear_gfp_allowed_mask(GFP_IOFS);
         error = dpm_suspend_start(PMSG_HIBERNATE);
         if (error) {
                 if (hibernation_ops->recover)
@@ -488,6 +527,7 @@ int hibernation_platform_enter(void)
  Resume_devices:
         entering_platform_hibernation = false;
         dpm_resume_end(PMSG_RESTORE);
+        set_gfp_allowed_mask(saved_mask);
         resume_console();
 
  Close:
diff --git a/kernel/power/hibernate_nvs.c b/kernel/power/hibernate_nvs.c
index 39ac698ef836..fdcad9ed5a7b 100644
--- a/kernel/power/hibernate_nvs.c
+++ b/kernel/power/hibernate_nvs.c
@@ -10,6 +10,7 @@
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/suspend.h>
 
 /*
diff --git a/kernel/power/main.c b/kernel/power/main.c
index 347d2cc88cd0..b58800b21fc0 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -44,6 +44,32 @@ int pm_notifier_call_chain(unsigned long val)
                         == NOTIFY_BAD) ? -EINVAL : 0;
 }
 
+/* If set, devices may be suspended and resumed asynchronously. */
+int pm_async_enabled = 1;
+
+static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
+                             char *buf)
+{
+        return sprintf(buf, "%d\n", pm_async_enabled);
+}
+
+static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
+                              const char *buf, size_t n)
+{
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        if (val > 1)
+                return -EINVAL;
+
+        pm_async_enabled = val;
+        return n;
+}
+
+power_attr(pm_async);
+
 #ifdef CONFIG_PM_DEBUG
 int pm_test_level = TEST_NONE;
 
@@ -208,9 +234,12 @@ static struct attribute * g[] = {
 #ifdef CONFIG_PM_TRACE
         &pm_trace_attr.attr,
 #endif
-#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PM_DEBUG)
+#ifdef CONFIG_PM_SLEEP
+        &pm_async_attr.attr,
+#ifdef CONFIG_PM_DEBUG
         &pm_test_attr.attr,
 #endif
+#endif
         NULL,
 };
 
@@ -220,6 +249,7 @@ static struct attribute_group attr_group = {
 
 #ifdef CONFIG_PM_RUNTIME
 struct workqueue_struct *pm_wq;
+EXPORT_SYMBOL_GPL(pm_wq);
 
 static int __init pm_start_workqueue(void)
 {
diff --git a/kernel/power/process.c b/kernel/power/process.c
index cc2e55373b68..71ae29052ab6 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -14,6 +14,7 @@
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/freezer.h>
+#include <linux/delay.h>
 
 /* 
  * Timeout for stopping processes
@@ -41,7 +42,7 @@ static int try_to_freeze_tasks(bool sig_only)
         do_gettimeofday(&start);
 
         end_time = jiffies + TIMEOUT;
-        do {
+        while (true) {
                 todo = 0;
                 read_lock(&tasklist_lock);
                 do_each_thread(g, p) {
@@ -62,10 +63,15 @@ static int try_to_freeze_tasks(bool sig_only)
                                 todo++;
                 } while_each_thread(g, p);
                 read_unlock(&tasklist_lock);
-                yield();                        /* Yield is okay here */
-                if (time_after(jiffies, end_time))
+                if (!todo || time_after(jiffies, end_time))
                         break;
-        } while (todo);
+
+                /*
+                 * We need to retry, but first give the freezing tasks some
+                 * time to enter the regrigerator.
+                 */
+                msleep(10);
+        }
 
         do_gettimeofday(&end);
         elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
@@ -82,12 +88,11 @@ static int try_to_freeze_tasks(bool sig_only)
                 printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
                                 "(%d tasks refusing to freeze):\n",
                                 elapsed_csecs / 100, elapsed_csecs % 100, todo);
-                show_state();
                 read_lock(&tasklist_lock);
                 do_each_thread(g, p) {
                         task_lock(p);
                         if (freezing(p) && !freezer_should_skip(p))
-                                printk(KERN_ERR " %s\n", p->comm);
+                                sched_show_task(p);
                         cancel_freezing(p);
                         task_unlock(p);
                 } while_each_thread(g, p);
@@ -139,7 +144,7 @@ static void thaw_tasks(bool nosig_only)
                 if (nosig_only && should_send_signal(p))
                         continue;
 
-                if (cgroup_frozen(p))
+                if (cgroup_freezing_or_frozen(p))
                         continue;
 
                 thaw_process(p);
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index 36cb168e4330..be861c26dda7 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -26,6 +26,7 @@
 #include <linux/console.h>
 #include <linux/highmem.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
@@ -1181,7 +1182,7 @@ static void free_unnecessary_pages(void)
 
         memory_bm_position_reset(&copy_bm);
 
-        while (to_free_normal > 0 && to_free_highmem > 0) {
+        while (to_free_normal > 0 || to_free_highmem > 0) {
                 unsigned long pfn = memory_bm_next_pfn(&copy_bm);
                 struct page *page = pfn_to_page(pfn);
 
@@ -1500,7 +1501,7 @@ asmlinkage int swsusp_save(void)
 {
         unsigned int nr_pages, nr_highmem;
 
-        printk(KERN_INFO "PM: Creating hibernation image: \n");
+        printk(KERN_INFO "PM: Creating hibernation image:\n");
 
         drain_local_pages(NULL);
         nr_pages = count_data_pages();
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 6f10dfc2d3e9..56e7dbb8b996 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -15,6 +15,7 @@
 #include <linux/console.h>
 #include <linux/cpu.h>
 #include <linux/syscalls.h>
+#include <linux/gfp.h>
 
 #include "power.h"
 
@@ -189,6 +190,7 @@ static int suspend_enter(suspend_state_t state)
 int suspend_devices_and_enter(suspend_state_t state)
 {
         int error;
+        gfp_t saved_mask;
 
         if (!suspend_ops)
                 return -ENOSYS;
@@ -199,6 +201,7 @@ int suspend_devices_and_enter(suspend_state_t state)
                         goto Close;
         }
         suspend_console();
+        saved_mask = clear_gfp_allowed_mask(GFP_IOFS);
         suspend_test_start();
         error = dpm_suspend_start(PMSG_SUSPEND);
         if (error) {
@@ -215,6 +218,7 @@ int suspend_devices_and_enter(suspend_state_t state)
         suspend_test_start();
         dpm_resume_end(PMSG_RESUME);
         suspend_test_finish("resume devices");
+        set_gfp_allowed_mask(saved_mask);
         resume_console();
  Close:
         if (suspend_ops->end)
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 890f6b11b1d3..66824d71983a 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -23,6 +23,7 @@
 #include <linux/swap.h>
 #include <linux/swapops.h>
 #include <linux/pm.h>
+#include <linux/slab.h>
 
 #include "power.h"
 
@@ -38,6 +39,107 @@ struct swsusp_header {
 
 static struct swsusp_header *swsusp_header;
 
+/**
+ *      The following functions are used for tracing the allocated
+ *      swap pages, so that they can be freed in case of an error.
+ */
+
+struct swsusp_extent {
+        struct rb_node node;
+        unsigned long start;
+        unsigned long end;
+};
+
+static struct rb_root swsusp_extents = RB_ROOT;
+
+static int swsusp_extents_insert(unsigned long swap_offset)
+{
+        struct rb_node **new = &(swsusp_extents.rb_node);
+        struct rb_node *parent = NULL;
+        struct swsusp_extent *ext;
+
+        /* Figure out where to put the new node */
+        while (*new) {
+                ext = container_of(*new, struct swsusp_extent, node);
+                parent = *new;
+                if (swap_offset < ext->start) {
+                        /* Try to merge */
+                        if (swap_offset == ext->start - 1) {
+                                ext->start--;
+                                return 0;
+                        }
+                        new = &((*new)->rb_left);
+                } else if (swap_offset > ext->end) {
+                        /* Try to merge */
+                        if (swap_offset == ext->end + 1) {
+                                ext->end++;
+                                return 0;
+                        }
+                        new = &((*new)->rb_right);
+                } else {
+                        /* It already is in the tree */
+                        return -EINVAL;
+                }
+        }
+        /* Add the new node and rebalance the tree. */
+        ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
+        if (!ext)
+                return -ENOMEM;
+
+        ext->start = swap_offset;
+        ext->end = swap_offset;
+        rb_link_node(&ext->node, parent, new);
+        rb_insert_color(&ext->node, &swsusp_extents);
+        return 0;
+}
+
+/**
+ *      alloc_swapdev_block - allocate a swap page and register that it has
+ *      been allocated, so that it can be freed in case of an error.
+ */
+
+sector_t alloc_swapdev_block(int swap)
+{
+        unsigned long offset;
+
+        offset = swp_offset(get_swap_page_of_type(swap));
+        if (offset) {
+                if (swsusp_extents_insert(offset))
+                        swap_free(swp_entry(swap, offset));
+                else
+                        return swapdev_block(swap, offset);
+        }
+        return 0;
+}
+
+/**
+ *      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
+ *      allocated.
+ */
+
+void free_all_swap_pages(int swap)
+{
+        struct rb_node *node;
+
+        while ((node = swsusp_extents.rb_node)) {
+                struct swsusp_extent *ext;
+                unsigned long offset;
+
+                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));
+
+                kfree(ext);
+        }
+}
+
+int swsusp_swap_in_use(void)
+{
+        return (swsusp_extents.rb_node != NULL);
+}
+
 /*
  * General things
  */
@@ -336,7 +438,7 @@ static int save_image(struct swap_map_handle *handle,
                 if (ret)
                         break;
                 if (!(nr_pages % m))
-                        printk("\b\b\b\b%3d%%", nr_pages / m);
+                        printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
                 nr_pages++;
         }
         err2 = wait_on_bio_chain(&bio);
@@ -344,9 +446,9 @@ static int save_image(struct swap_map_handle *handle,
         if (!ret)
                 ret = err2;
         if (!ret)
-                printk("\b\b\b\bdone\n");
+                printk(KERN_CONT "\b\b\b\bdone\n");
         else
-                printk("\n");
+                printk(KERN_CONT "\n");
         swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
         return ret;
 }
@@ -556,10 +658,6 @@ int swsusp_read(unsigned int *flags_p)
         struct swsusp_info *header;
 
         *flags_p = swsusp_header->flags;
-        if (IS_ERR(resume_bdev)) {
-                pr_debug("PM: Image device not initialised\n");
-                return PTR_ERR(resume_bdev);
-        }
 
         memset(&snapshot, 0, sizeof(struct snapshot_handle));
         error = snapshot_write_next(&snapshot, PAGE_SIZE);
diff --git a/kernel/power/swsusp.c b/kernel/power/swsusp.c
deleted file mode 100644
index 6a07f4dbf2f8..000000000000
--- a/kernel/power/swsusp.c
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * linux/kernel/power/swsusp.c
- *
- * This file provides code to write suspend image to swap and read it back.
- *
- * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
- * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
- *
- * This file is released under the GPLv2.
- *
- * I'd like to thank the following people for their work:
- *
- * Pavel Machek <pavel@ucw.cz>:
- * Modifications, defectiveness pointing, being with me at the very beginning,
- * suspend to swap space, stop all tasks. Port to 2.4.18-ac and 2.5.17.
- *
- * Steve Doddi <dirk@loth.demon.co.uk>:
- * Support the possibility of hardware state restoring.
- *
- * Raph <grey.havens@earthling.net>:
- * Support for preserving states of network devices and virtual console
- * (including X and svgatextmode)
- *
- * Kurt Garloff <garloff@suse.de>:
- * Straightened the critical function in order to prevent compilers from
- * playing tricks with local variables.
- *
- * Andreas Mohr <a.mohr@mailto.de>
- *
- * Alex Badea <vampire@go.ro>:
- * Fixed runaway init
- *
- * Rafael J. Wysocki <rjw@sisk.pl>
- * Reworked the freeing of memory and the handling of swap
- *
- * More state savers are welcome. Especially for the scsi layer...
- *
- * For TODOs,FIXMEs also look in Documentation/power/swsusp.txt
- */
-
-#include <linux/mm.h>
-#include <linux/suspend.h>
-#include <linux/spinlock.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/swap.h>
-#include <linux/pm.h>
-#include <linux/swapops.h>
-#include <linux/bootmem.h>
-#include <linux/syscalls.h>
-#include <linux/highmem.h>
-#include <linux/time.h>
-#include <linux/rbtree.h>
-#include <linux/io.h>
-
-#include "power.h"
-
-int in_suspend __nosavedata = 0;
-
-/**
- *      The following functions are used for tracing the allocated
- *      swap pages, so that they can be freed in case of an error.
- */
-
-struct swsusp_extent {
-        struct rb_node node;
-        unsigned long start;
-        unsigned long end;
-};
-
-static struct rb_root swsusp_extents = RB_ROOT;
-
-static int swsusp_extents_insert(unsigned long swap_offset)
-{
-        struct rb_node **new = &(swsusp_extents.rb_node);
-        struct rb_node *parent = NULL;
-        struct swsusp_extent *ext;
-
-        /* Figure out where to put the new node */
-        while (*new) {
-                ext = container_of(*new, struct swsusp_extent, node);
-                parent = *new;
-                if (swap_offset < ext->start) {
-                        /* Try to merge */
-                        if (swap_offset == ext->start - 1) {
-                                ext->start--;
-                                return 0;
-                        }
-                        new = &((*new)->rb_left);
-                } else if (swap_offset > ext->end) {
-                        /* Try to merge */
-                        if (swap_offset == ext->end + 1) {
-                                ext->end++;
-                                return 0;
-                        }
-                        new = &((*new)->rb_right);
-                } else {
-                        /* It already is in the tree */
-                        return -EINVAL;
-                }
-        }
-        /* Add the new node and rebalance the tree. */
-        ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
-        if (!ext)
-                return -ENOMEM;
-
-        ext->start = swap_offset;
-        ext->end = swap_offset;
-        rb_link_node(&ext->node, parent, new);
-        rb_insert_color(&ext->node, &swsusp_extents);
-        return 0;
-}
-
-/**
- *      alloc_swapdev_block - allocate a swap page and register that it has
- *      been allocated, so that it can be freed in case of an error.
- */
-
-sector_t alloc_swapdev_block(int swap)
-{
-        unsigned long offset;
-
-        offset = swp_offset(get_swap_page_of_type(swap));
-        if (offset) {
-                if (swsusp_extents_insert(offset))
-                        swap_free(swp_entry(swap, offset));
-                else
-                        return swapdev_block(swap, offset);
-        }
-        return 0;
-}
-
-/**
- *      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
- *      allocated.
- */
-
-void free_all_swap_pages(int swap)
-{
-        struct rb_node *node;
-
-        while ((node = swsusp_extents.rb_node)) {
-                struct swsusp_extent *ext;
-                unsigned long offset;
-
-                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));
-
-                kfree(ext);
-        }
-}
-
-int swsusp_swap_in_use(void)
-{
-        return (swsusp_extents.rb_node != NULL);
-}
-
-/**
- *      swsusp_show_speed - print the time elapsed between two events represented by
- *      @start and @stop
- *
- *      @nr_pages -     number of pages processed between @start and @stop
- *      @msg -          introductory message to print
- */
-
-void swsusp_show_speed(struct timeval *start, struct timeval *stop,
-                        unsigned nr_pages, char *msg)
-{
-        s64 elapsed_centisecs64;
-        int centisecs;
-        int k;
-        int kps;
-
-        elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
-        do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
-        centisecs = elapsed_centisecs64;
-        if (centisecs == 0)
-                centisecs = 1;  /* avoid div-by-zero */
-        k = nr_pages * (PAGE_SIZE / 1024);
-        kps = (k * 100) / centisecs;
-        printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
-                        msg, k,
-                        centisecs / 100, centisecs % 100,
-                        kps / 1000, (kps % 1000) / 10);
-}
diff --git a/kernel/power/user.c b/kernel/power/user.c
index bf0014d6a5f0..a8c96212bc1b 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -195,6 +195,15 @@ static ssize_t snapshot_write(struct file *filp, const char __user *buf,
         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)
 {
@@ -246,8 +255,9 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 data->frozen = 0;
                 break;
 
-        case SNAPSHOT_CREATE_IMAGE:
         case SNAPSHOT_ATOMIC_SNAPSHOT:
+                snapshot_deprecated_ioctl(cmd);
+        case SNAPSHOT_CREATE_IMAGE:
                 if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
                         error = -EPERM;
                         break;
@@ -275,8 +285,9 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 data->ready = 0;
                 break;
 
-        case SNAPSHOT_PREF_IMAGE_SIZE:
         case SNAPSHOT_SET_IMAGE_SIZE:
+                snapshot_deprecated_ioctl(cmd);
+        case SNAPSHOT_PREF_IMAGE_SIZE:
                 image_size = arg;
                 break;
 
@@ -290,15 +301,17 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 error = put_user(size, (loff_t __user *)arg);
                 break;
 
-        case SNAPSHOT_AVAIL_SWAP_SIZE:
         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_ALLOC_SWAP_PAGE:
         case SNAPSHOT_GET_SWAP_PAGE:
+                snapshot_deprecated_ioctl(cmd);
+        case SNAPSHOT_ALLOC_SWAP_PAGE:
                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
                         error = -ENODEV;
                         break;
@@ -321,6 +334,7 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 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,
@@ -362,6 +376,7 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                 break;
 
         case SNAPSHOT_PMOPS: /* This ioctl is deprecated */
+                snapshot_deprecated_ioctl(cmd);
                 error = -EINVAL;
 
                 switch (arg) {
@@ -405,7 +420,7 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                          * User space encodes device types as two-byte values,
                          * so we need to recode them
                          */
-                        swdev = old_decode_dev(swap_area.dev);
+                        swdev = new_decode_dev(swap_area.dev);
                         if (swdev) {
                                 offset = swap_area.offset;
                                 data->swap = swap_type_of(swdev, offset, NULL);