[PATCH] swsusp-change-code-ordering-in-userc-sanity

[linux-2.6-omap-h63xx.git] / kernel / power / user.c

diff --git a/kernel/power/user.c b/kernel/power/user.c
index a327b18a5ffd82a0ab385150e8886dbfd77b1415..b70d83d6b16e89c9882f99938e6cb40e173fb2e5 100644 (file)
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -22,6 +22,7 @@
 #include <linux/fs.h>
 #include <linux/console.h>
 #include <linux/cpu.h>
+#include <linux/freezer.h>
 
 #include <asm/uaccess.h>
 
@@ -56,7 +57,7 @@ static int snapshot_open(struct inode *inode, struct file *filp)
        memset(&data->handle, 0, sizeof(struct snapshot_handle));
        if ((filp->f_flags & O_ACCMODE) == O_RDONLY) {
                data->swap = swsusp_resume_device ?
-                               swap_type_of(swsusp_resume_device, 0) : -1;
+                       swap_type_of(swsusp_resume_device, 0, NULL) : -1;
                data->mode = O_RDONLY;
        } else {
                data->swap = -1;
@@ -78,10 +79,10 @@ static int snapshot_release(struct inode *inode, struct file *filp)
        free_all_swap_pages(data->swap, data->bitmap);
        free_bitmap(data->bitmap);
        if (data->frozen) {
-               down(&pm_sem);
+               mutex_lock(&pm_mutex);
                thaw_processes();
                enable_nonboot_cpus();
-               up(&pm_sem);
+               mutex_unlock(&pm_mutex);
        }
        atomic_inc(&device_available);
        return 0;
@@ -121,12 +122,66 @@ static ssize_t snapshot_write(struct file *filp, const char __user *buf,
        return res;
 }
 
+static int snapshot_suspend(void)
+{
+       int error;
+
+       mutex_lock(&pm_mutex);
+       /* Free memory before shutting down devices. */
+       error = swsusp_shrink_memory();
+       if (error)
+               goto Finish;
+
+       suspend_console();
+       error = device_suspend(PMSG_FREEZE);
+       if (error)
+               goto Resume_devices;
+
+       error = disable_nonboot_cpus();
+       if (!error) {
+               in_suspend = 1;
+               error = swsusp_suspend();
+       }
+       enable_nonboot_cpus();
+ Resume_devices:
+       device_resume();
+       resume_console();
+ Finish:
+       mutex_unlock(&pm_mutex);
+       return error;
+}
+
+static int snapshot_restore(void)
+{
+       int error;
+
+       mutex_lock(&pm_mutex);
+       pm_prepare_console();
+       suspend_console();
+       error = device_suspend(PMSG_PRETHAW);
+       if (error)
+               goto Resume_devices;
+
+       error = disable_nonboot_cpus();
+       if (!error)
+               error = swsusp_resume();
+
+       enable_nonboot_cpus();
+ Resume_devices:
+       device_resume();
+       resume_console();
+       pm_restore_console();
+       mutex_unlock(&pm_mutex);
+       return error;
+}
+
 static int snapshot_ioctl(struct inode *inode, struct file *filp,
                           unsigned int cmd, unsigned long arg)
 {
        int error = 0;
        struct snapshot_data *data;
-       loff_t offset, avail;
+       loff_t avail;
+       sector_t offset;
 
        if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
                return -ENOTTY;
@@ -142,17 +197,12 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
        case SNAPSHOT_FREEZE:
                if (data->frozen)
                        break;
-               down(&pm_sem);
-               error = disable_nonboot_cpus();
-               if (!error) {
-                       error = freeze_processes();
-                       if (error) {
-                               thaw_processes();
-                               enable_nonboot_cpus();
-                               error = -EBUSY;
-                       }
+               mutex_lock(&pm_mutex);
+               if (freeze_processes()) {
+                       thaw_processes();
+                       error = -EBUSY;
                }
-               up(&pm_sem);
+               mutex_unlock(&pm_mutex);
                if (!error)
                        data->frozen = 1;
                break;
@@ -160,10 +210,9 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
        case SNAPSHOT_UNFREEZE:
                if (!data->frozen)
                        break;
-               down(&pm_sem);
+               mutex_lock(&pm_mutex);
                thaw_processes();
-               enable_nonboot_cpus();
-               up(&pm_sem);
+               mutex_unlock(&pm_mutex);
                data->frozen = 0;
                break;
 
@@ -172,20 +221,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                        error = -EPERM;
                        break;
                }
-               down(&pm_sem);
-               /* Free memory before shutting down devices. */
-               error = swsusp_shrink_memory();
-               if (!error) {
-                       suspend_console();
-                       error = device_suspend(PMSG_FREEZE);
-                       if (!error) {
-                               in_suspend = 1;
-                               error = swsusp_suspend();
-                               device_resume();
-                       }
-                       resume_console();
-               }
-               up(&pm_sem);
+               error = snapshot_suspend();
                if (!error)
                        error = put_user(in_suspend, (unsigned int __user *)arg);
                if (!error)
@@ -193,23 +229,13 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                break;
 
        case SNAPSHOT_ATOMIC_RESTORE:
+               snapshot_write_finalize(&data->handle);
                if (data->mode != O_WRONLY || !data->frozen ||
                    !snapshot_image_loaded(&data->handle)) {
                        error = -EPERM;
                        break;
                }
-               snapshot_free_unused_memory(&data->handle);
-               down(&pm_sem);
-               pm_prepare_console();
-               suspend_console();
-               error = device_suspend(PMSG_PRETHAW);
-               if (!error) {
-                       error = swsusp_resume();
-                       device_resume();
-               }
-               resume_console();
-               pm_restore_console();
-               up(&pm_sem);
+               error = snapshot_restore();
                break;
 
        case SNAPSHOT_FREE:
@@ -240,10 +266,10 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                                break;
                        }
                }
-               offset = alloc_swap_page(data->swap, data->bitmap);
+               offset = alloc_swapdev_block(data->swap, data->bitmap);
                if (offset) {
                        offset <<= PAGE_SHIFT;
-                       error = put_user(offset, (loff_t __user *)arg);
+                       error = put_user(offset, (sector_t __user *)arg);
                } else {
                        error = -ENOSPC;
                }
@@ -266,7 +292,8 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                         * so we need to recode them
                         */
                        if (old_decode_dev(arg)) {
-                               data->swap = swap_type_of(old_decode_dev(arg), 0);
+                               data->swap = swap_type_of(old_decode_dev(arg),
+                                                       0, NULL);
                                if (data->swap < 0)
                                        error = -ENODEV;
                        } else {
@@ -284,7 +311,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                        break;
                }
 
-               if (down_trylock(&pm_sem)) {
+               if (!mutex_trylock(&pm_mutex)) {
                        error = -EBUSY;
                        break;
                }
@@ -311,8 +338,8 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                if (pm_ops->finish)
                        pm_ops->finish(PM_SUSPEND_MEM);
 
-OutS3:
-               up(&pm_sem);
+ OutS3:
+               mutex_unlock(&pm_mutex);
                break;
 
        case SNAPSHOT_PMOPS:
@@ -342,6 +369,37 @@ OutS3:
                }
                break;
 
+       case SNAPSHOT_SET_SWAP_AREA:
+               if (data->bitmap) {
+                       error = -EPERM;
+               } else {
+                       struct resume_swap_area swap_area;
+                       dev_t swdev;
+
+                       error = copy_from_user(&swap_area, (void __user *)arg,
+                                       sizeof(struct resume_swap_area));
+                       if (error) {
+                               error = -EFAULT;
+                               break;
+                       }
+
+                       /*
+                        * User space encodes device types as two-byte values,
+                        * so we need to recode them
+                        */
+                       swdev = old_decode_dev(swap_area.dev);
+                       if (swdev) {
+                               offset = swap_area.offset;
+                               data->swap = swap_type_of(swdev, offset, NULL);
+                               if (data->swap < 0)
+                                       error = -ENODEV;
+                       } else {
+                               data->swap = -1;
+                               error = -EINVAL;
+                       }
+               }
+               break;
+
        default:
                error = -ENOTTY;
 
@@ -350,7 +408,7 @@ OutS3:
        return error;
 }
 
-static struct file_operations snapshot_fops = {
+static const struct file_operations snapshot_fops = {
        .open = snapshot_open,
        .release = snapshot_release,
        .read = snapshot_read,