kernel/power/user.c

   1 /*
   2  * linux/kernel/power/user.c
   3  *
   4  * This file provides the user space interface for software suspend/resume.
   5  *
   6  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
   7  *
   8  * This file is released under the GPLv2.
   9  *
  10  */
  11
  12 #include <linux/suspend.h>
  13 #include <linux/syscalls.h>
  14 #include <linux/reboot.h>
  15 #include <linux/string.h>
  16 #include <linux/device.h>
  17 #include <linux/miscdevice.h>
  18 #include <linux/mm.h>
  19 #include <linux/swap.h>
  20 #include <linux/swapops.h>
  21 #include <linux/pm.h>
  22 #include <linux/fs.h>
  23 #include <linux/console.h>
  24 #include <linux/cpu.h>
  25
  26 #include <asm/uaccess.h>
  27
  28 #include "power.h"
  29
  30 #define SNAPSHOT_MINOR  231
  31
  32 static struct snapshot_data {
  33         struct snapshot_handle handle;
  34         int swap;
  35         struct bitmap_page *bitmap;
  36         int mode;
  37         char frozen;
  38         char ready;
  39 } snapshot_state;
  40
  41 static atomic_t device_available = ATOMIC_INIT(1);
  42
  43 static int snapshot_open(struct inode *inode, struct file *filp)
  44 {
  45         struct snapshot_data *data;
  46
  47         if (!atomic_add_unless(&device_available, -1, 0))
  48                 return -EBUSY;
  49
  50         if ((filp->f_flags & O_ACCMODE) == O_RDWR)
  51                 return -ENOSYS;
  52
  53         nonseekable_open(inode, filp);
  54         data = &snapshot_state;
  55         filp->private_data = data;
  56         memset(&data->handle, 0, sizeof(struct snapshot_handle));
  57         if ((filp->f_flags & O_ACCMODE) == O_RDONLY) {
  58                 data->swap = swsusp_resume_device ? swap_type_of(swsusp_resume_device) : -1;
  59                 data->mode = O_RDONLY;
  60         } else {
  61                 data->swap = -1;
  62                 data->mode = O_WRONLY;
  63         }
  64         data->bitmap = NULL;
  65         data->frozen = 0;
  66         data->ready = 0;
  67
  68         return 0;
  69 }
  70
  71 static int snapshot_release(struct inode *inode, struct file *filp)
  72 {
  73         struct snapshot_data *data;
  74
  75         swsusp_free();
  76         data = filp->private_data;
  77         free_all_swap_pages(data->swap, data->bitmap);
  78         free_bitmap(data->bitmap);
  79         if (data->frozen) {
  80                 down(&pm_sem);
  81                 thaw_processes();
  82                 enable_nonboot_cpus();
  83                 up(&pm_sem);
  84         }
  85         atomic_inc(&device_available);
  86         return 0;
  87 }
  88
  89 static ssize_t snapshot_read(struct file *filp, char __user *buf,
  90                              size_t count, loff_t *offp)
  91 {
  92         struct snapshot_data *data;
  93         ssize_t res;
  94
  95         data = filp->private_data;
  96         res = snapshot_read_next(&data->handle, count);
  97         if (res > 0) {
  98                 if (copy_to_user(buf, data_of(data->handle), res))
  99                         res = -EFAULT;
 100                 else
 101                         *offp = data->handle.offset;
 102         }
 103         return res;
 104 }
 105
 106 static ssize_t snapshot_write(struct file *filp, const char __user *buf,
 107                               size_t count, loff_t *offp)
 108 {
 109         struct snapshot_data *data;
 110         ssize_t res;
 111
 112         data = filp->private_data;
 113         res = snapshot_write_next(&data->handle, count);
 114         if (res > 0) {
 115                 if (copy_from_user(data_of(data->handle), buf, res))
 116                         res = -EFAULT;
 117                 else
 118                         *offp = data->handle.offset;
 119         }
 120         return res;
 121 }
 122
 123 static int snapshot_ioctl(struct inode *inode, struct file *filp,
 124                           unsigned int cmd, unsigned long arg)
 125 {
 126         int error = 0;
 127         struct snapshot_data *data;
 128         loff_t offset, avail;
 129
 130         if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
 131                 return -ENOTTY;
 132         if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)
 133                 return -ENOTTY;
 134         if (!capable(CAP_SYS_ADMIN))
 135                 return -EPERM;
 136
 137         data = filp->private_data;
 138
 139         switch (cmd) {
 140
 141         case SNAPSHOT_FREEZE:
 142                 if (data->frozen)
 143                         break;
 144                 down(&pm_sem);
 145                 error = disable_nonboot_cpus();
 146                 if (!error) {
 147                         error = freeze_processes();
 148                         if (error) {
 149                                 thaw_processes();
 150                                 enable_nonboot_cpus();
 151                                 error = -EBUSY;
 152                         }
 153                 }
 154                 up(&pm_sem);
 155                 if (!error)
 156                         data->frozen = 1;
 157                 break;
 158
 159         case SNAPSHOT_UNFREEZE:
 160                 if (!data->frozen)
 161                         break;
 162                 down(&pm_sem);
 163                 thaw_processes();
 164                 enable_nonboot_cpus();
 165                 up(&pm_sem);
 166                 data->frozen = 0;
 167                 break;
 168
 169         case SNAPSHOT_ATOMIC_SNAPSHOT:
 170                 if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
 171                         error = -EPERM;
 172                         break;
 173                 }
 174                 down(&pm_sem);
 175                 /* Free memory before shutting down devices. */
 176                 error = swsusp_shrink_memory();
 177                 if (!error) {
 178                         suspend_console();
 179                         error = device_suspend(PMSG_FREEZE);
 180                         if (!error) {
 181                                 in_suspend = 1;
 182                                 error = swsusp_suspend();
 183                                 device_resume();
 184                         }
 185                         resume_console();
 186                 }
 187                 up(&pm_sem);
 188                 if (!error)
 189                         error = put_user(in_suspend, (unsigned int __user *)arg);
 190                 if (!error)
 191                         data->ready = 1;
 192                 break;
 193
 194         case SNAPSHOT_ATOMIC_RESTORE:
 195                 if (data->mode != O_WRONLY || !data->frozen ||
 196                     !snapshot_image_loaded(&data->handle)) {
 197                         error = -EPERM;
 198                         break;
 199                 }
 200                 snapshot_free_unused_memory(&data->handle);
 201                 down(&pm_sem);
 202                 pm_prepare_console();
 203                 suspend_console();
 204                 error = device_suspend(PMSG_PRETHAW);
 205                 if (!error) {
 206                         error = swsusp_resume();
 207                         device_resume();
 208                 }
 209                 resume_console();
 210                 pm_restore_console();
 211                 up(&pm_sem);
 212                 break;
 213
 214         case SNAPSHOT_FREE:
 215                 swsusp_free();
 216                 memset(&data->handle, 0, sizeof(struct snapshot_handle));
 217                 data->ready = 0;
 218                 break;
 219
 220         case SNAPSHOT_SET_IMAGE_SIZE:
 221                 image_size = arg;
 222                 break;
 223
 224         case SNAPSHOT_AVAIL_SWAP:
 225                 avail = count_swap_pages(data->swap, 1);
 226                 avail <<= PAGE_SHIFT;
 227                 error = put_user(avail, (loff_t __user *)arg);
 228                 break;
 229
 230         case SNAPSHOT_GET_SWAP_PAGE:
 231                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
 232                         error = -ENODEV;
 233                         break;
 234                 }
 235                 if (!data->bitmap) {
 236                         data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));
 237                         if (!data->bitmap) {
 238                                 error = -ENOMEM;
 239                                 break;
 240                         }
 241                 }
 242                 offset = alloc_swap_page(data->swap, data->bitmap);
 243                 if (offset) {
 244                         offset <<= PAGE_SHIFT;
 245                         error = put_user(offset, (loff_t __user *)arg);
 246                 } else {
 247                         error = -ENOSPC;
 248                 }
 249                 break;
 250
 251         case SNAPSHOT_FREE_SWAP_PAGES:
 252                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
 253                         error = -ENODEV;
 254                         break;
 255                 }
 256                 free_all_swap_pages(data->swap, data->bitmap);
 257                 free_bitmap(data->bitmap);
 258                 data->bitmap = NULL;
 259                 break;
 260
 261         case SNAPSHOT_SET_SWAP_FILE:
 262                 if (!data->bitmap) {
 263                         /*
 264                          * User space encodes device types as two-byte values,
 265                          * so we need to recode them
 266                          */
 267                         if (old_decode_dev(arg)) {
 268                                 data->swap = swap_type_of(old_decode_dev(arg));
 269                                 if (data->swap < 0)
 270                                         error = -ENODEV;
 271                         } else {
 272                                 data->swap = -1;
 273                                 error = -EINVAL;
 274                         }
 275                 } else {
 276                         error = -EPERM;
 277                 }
 278                 break;
 279
 280         case SNAPSHOT_S2RAM:
 281                 if (!data->frozen) {
 282                         error = -EPERM;
 283                         break;
 284                 }
 285
 286                 if (down_trylock(&pm_sem)) {
 287                         error = -EBUSY;
 288                         break;
 289                 }
 290
 291                 if (pm_ops->prepare) {
 292                         error = pm_ops->prepare(PM_SUSPEND_MEM);
 293                         if (error)
 294                                 goto OutS3;
 295                 }
 296
 297                 /* Put devices to sleep */
 298                 suspend_console();
 299                 error = device_suspend(PMSG_SUSPEND);
 300                 if (error) {
 301                         printk(KERN_ERR "Failed to suspend some devices.\n");
 302                 } else {
 303                         /* Enter S3, system is already frozen */
 304                         suspend_enter(PM_SUSPEND_MEM);
 305
 306                         /* Wake up devices */
 307                         device_resume();
 308                 }
 309                 resume_console();
 310                 if (pm_ops->finish)
 311                         pm_ops->finish(PM_SUSPEND_MEM);
 312
 313 OutS3:
 314                 up(&pm_sem);
 315                 break;
 316
 317         case SNAPSHOT_PMOPS:
 318                 switch (arg) {
 319
 320                 case PMOPS_PREPARE:
 321                         if (pm_ops->prepare) {
 322                                 error = pm_ops->prepare(PM_SUSPEND_DISK);
 323                         }
 324                         break;
 325
 326                 case PMOPS_ENTER:
 327                         kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
 328                         error = pm_ops->enter(PM_SUSPEND_DISK);
 329                         break;
 330
 331                 case PMOPS_FINISH:
 332                         if (pm_ops && pm_ops->finish) {
 333                                 pm_ops->finish(PM_SUSPEND_DISK);
 334                         }
 335                         break;
 336
 337                 default:
 338                         printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
 339                         error = -EINVAL;
 340
 341                 }
 342                 break;
 343
 344         default:
 345                 error = -ENOTTY;
 346
 347         }
 348
 349         return error;
 350 }
 351
 352 static struct file_operations snapshot_fops = {
 353         .open = snapshot_open,
 354         .release = snapshot_release,
 355         .read = snapshot_read,
 356         .write = snapshot_write,
 357         .llseek = no_llseek,
 358         .ioctl = snapshot_ioctl,
 359 };
 360
 361 static struct miscdevice snapshot_device = {
 362         .minor = SNAPSHOT_MINOR,
 363         .name = "snapshot",
 364         .fops = &snapshot_fops,
 365 };
 366
 367 static int __init snapshot_device_init(void)
 368 {
 369         return misc_register(&snapshot_device);
 370 };
 371
 372 device_initcall(snapshot_device_init);