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 ?
  59                                 swap_type_of(swsusp_resume_device, 0) : -1;
  60                 data->mode = O_RDONLY;
  61         } else {
  62                 data->swap = -1;
  63                 data->mode = O_WRONLY;
  64         }
  65         data->bitmap = NULL;
  66         data->frozen = 0;
  67         data->ready = 0;
  68
  69         return 0;
  70 }
  71
  72 static int snapshot_release(struct inode *inode, struct file *filp)
  73 {
  74         struct snapshot_data *data;
  75
  76         swsusp_free();
  77         data = filp->private_data;
  78         free_all_swap_pages(data->swap, data->bitmap);
  79         free_bitmap(data->bitmap);
  80         if (data->frozen) {
  81                 down(&pm_sem);
  82                 thaw_processes();
  83                 enable_nonboot_cpus();
  84                 up(&pm_sem);
  85         }
  86         atomic_inc(&device_available);
  87         return 0;
  88 }
  89
  90 static ssize_t snapshot_read(struct file *filp, char __user *buf,
  91                              size_t count, loff_t *offp)
  92 {
  93         struct snapshot_data *data;
  94         ssize_t res;
  95
  96         data = filp->private_data;
  97         res = snapshot_read_next(&data->handle, count);
  98         if (res > 0) {
  99                 if (copy_to_user(buf, data_of(data->handle), res))
 100                         res = -EFAULT;
 101                 else
 102                         *offp = data->handle.offset;
 103         }
 104         return res;
 105 }
 106
 107 static ssize_t snapshot_write(struct file *filp, const char __user *buf,
 108                               size_t count, loff_t *offp)
 109 {
 110         struct snapshot_data *data;
 111         ssize_t res;
 112
 113         data = filp->private_data;
 114         res = snapshot_write_next(&data->handle, count);
 115         if (res > 0) {
 116                 if (copy_from_user(data_of(data->handle), buf, res))
 117                         res = -EFAULT;
 118                 else
 119                         *offp = data->handle.offset;
 120         }
 121         return res;
 122 }
 123
 124 static int snapshot_ioctl(struct inode *inode, struct file *filp,
 125                           unsigned int cmd, unsigned long arg)
 126 {
 127         int error = 0;
 128         struct snapshot_data *data;
 129         loff_t avail;
 130         sector_t offset;
 131
 132         if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
 133                 return -ENOTTY;
 134         if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)
 135                 return -ENOTTY;
 136         if (!capable(CAP_SYS_ADMIN))
 137                 return -EPERM;
 138
 139         data = filp->private_data;
 140
 141         switch (cmd) {
 142
 143         case SNAPSHOT_FREEZE:
 144                 if (data->frozen)
 145                         break;
 146                 down(&pm_sem);
 147                 error = disable_nonboot_cpus();
 148                 if (!error) {
 149                         error = freeze_processes();
 150                         if (error) {
 151                                 thaw_processes();
 152                                 enable_nonboot_cpus();
 153                                 error = -EBUSY;
 154                         }
 155                 }
 156                 up(&pm_sem);
 157                 if (!error)
 158                         data->frozen = 1;
 159                 break;
 160
 161         case SNAPSHOT_UNFREEZE:
 162                 if (!data->frozen)
 163                         break;
 164                 down(&pm_sem);
 165                 thaw_processes();
 166                 enable_nonboot_cpus();
 167                 up(&pm_sem);
 168                 data->frozen = 0;
 169                 break;
 170
 171         case SNAPSHOT_ATOMIC_SNAPSHOT:
 172                 if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
 173                         error = -EPERM;
 174                         break;
 175                 }
 176                 down(&pm_sem);
 177                 /* Free memory before shutting down devices. */
 178                 error = swsusp_shrink_memory();
 179                 if (!error) {
 180                         suspend_console();
 181                         error = device_suspend(PMSG_FREEZE);
 182                         if (!error) {
 183                                 in_suspend = 1;
 184                                 error = swsusp_suspend();
 185                                 device_resume();
 186                         }
 187                         resume_console();
 188                 }
 189                 up(&pm_sem);
 190                 if (!error)
 191                         error = put_user(in_suspend, (unsigned int __user *)arg);
 192                 if (!error)
 193                         data->ready = 1;
 194                 break;
 195
 196         case SNAPSHOT_ATOMIC_RESTORE:
 197                 if (data->mode != O_WRONLY || !data->frozen ||
 198                     !snapshot_image_loaded(&data->handle)) {
 199                         error = -EPERM;
 200                         break;
 201                 }
 202                 snapshot_free_unused_memory(&data->handle);
 203                 down(&pm_sem);
 204                 pm_prepare_console();
 205                 suspend_console();
 206                 error = device_suspend(PMSG_PRETHAW);
 207                 if (!error) {
 208                         error = swsusp_resume();
 209                         device_resume();
 210                 }
 211                 resume_console();
 212                 pm_restore_console();
 213                 up(&pm_sem);
 214                 break;
 215
 216         case SNAPSHOT_FREE:
 217                 swsusp_free();
 218                 memset(&data->handle, 0, sizeof(struct snapshot_handle));
 219                 data->ready = 0;
 220                 break;
 221
 222         case SNAPSHOT_SET_IMAGE_SIZE:
 223                 image_size = arg;
 224                 break;
 225
 226         case SNAPSHOT_AVAIL_SWAP:
 227                 avail = count_swap_pages(data->swap, 1);
 228                 avail <<= PAGE_SHIFT;
 229                 error = put_user(avail, (loff_t __user *)arg);
 230                 break;
 231
 232         case SNAPSHOT_GET_SWAP_PAGE:
 233                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
 234                         error = -ENODEV;
 235                         break;
 236                 }
 237                 if (!data->bitmap) {
 238                         data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));
 239                         if (!data->bitmap) {
 240                                 error = -ENOMEM;
 241                                 break;
 242                         }
 243                 }
 244                 offset = alloc_swapdev_block(data->swap, data->bitmap);
 245                 if (offset) {
 246                         offset <<= PAGE_SHIFT;
 247                         error = put_user(offset, (sector_t __user *)arg);
 248                 } else {
 249                         error = -ENOSPC;
 250                 }
 251                 break;
 252
 253         case SNAPSHOT_FREE_SWAP_PAGES:
 254                 if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
 255                         error = -ENODEV;
 256                         break;
 257                 }
 258                 free_all_swap_pages(data->swap, data->bitmap);
 259                 free_bitmap(data->bitmap);
 260                 data->bitmap = NULL;
 261                 break;
 262
 263         case SNAPSHOT_SET_SWAP_FILE:
 264                 if (!data->bitmap) {
 265                         /*
 266                          * User space encodes device types as two-byte values,
 267                          * so we need to recode them
 268                          */
 269                         if (old_decode_dev(arg)) {
 270                                 data->swap = swap_type_of(old_decode_dev(arg), 0);
 271                                 if (data->swap < 0)
 272                                         error = -ENODEV;
 273                         } else {
 274                                 data->swap = -1;
 275                                 error = -EINVAL;
 276                         }
 277                 } else {
 278                         error = -EPERM;
 279                 }
 280                 break;
 281
 282         case SNAPSHOT_S2RAM:
 283                 if (!data->frozen) {
 284                         error = -EPERM;
 285                         break;
 286                 }
 287
 288                 if (down_trylock(&pm_sem)) {
 289                         error = -EBUSY;
 290                         break;
 291                 }
 292
 293                 if (pm_ops->prepare) {
 294                         error = pm_ops->prepare(PM_SUSPEND_MEM);
 295                         if (error)
 296                                 goto OutS3;
 297                 }
 298
 299                 /* Put devices to sleep */
 300                 suspend_console();
 301                 error = device_suspend(PMSG_SUSPEND);
 302                 if (error) {
 303                         printk(KERN_ERR "Failed to suspend some devices.\n");
 304                 } else {
 305                         /* Enter S3, system is already frozen */
 306                         suspend_enter(PM_SUSPEND_MEM);
 307
 308                         /* Wake up devices */
 309                         device_resume();
 310                 }
 311                 resume_console();
 312                 if (pm_ops->finish)
 313                         pm_ops->finish(PM_SUSPEND_MEM);
 314
 315 OutS3:
 316                 up(&pm_sem);
 317                 break;
 318
 319         case SNAPSHOT_PMOPS:
 320                 switch (arg) {
 321
 322                 case PMOPS_PREPARE:
 323                         if (pm_ops->prepare) {
 324                                 error = pm_ops->prepare(PM_SUSPEND_DISK);
 325                         }
 326                         break;
 327
 328                 case PMOPS_ENTER:
 329                         kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
 330                         error = pm_ops->enter(PM_SUSPEND_DISK);
 331                         break;
 332
 333                 case PMOPS_FINISH:
 334                         if (pm_ops && pm_ops->finish) {
 335                                 pm_ops->finish(PM_SUSPEND_DISK);
 336                         }
 337                         break;
 338
 339                 default:
 340                         printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
 341                         error = -EINVAL;
 342
 343                 }
 344                 break;
 345
 346         case SNAPSHOT_SET_SWAP_AREA:
 347                 if (data->bitmap) {
 348                         error = -EPERM;
 349                 } else {
 350                         struct resume_swap_area swap_area;
 351                         dev_t swdev;
 352
 353                         error = copy_from_user(&swap_area, (void __user *)arg,
 354                                         sizeof(struct resume_swap_area));
 355                         if (error) {
 356                                 error = -EFAULT;
 357                                 break;
 358                         }
 359
 360                         /*
 361                          * User space encodes device types as two-byte values,
 362                          * so we need to recode them
 363                          */
 364                         swdev = old_decode_dev(swap_area.dev);
 365                         if (swdev) {
 366                                 offset = swap_area.offset;
 367                                 data->swap = swap_type_of(swdev, offset);
 368                                 if (data->swap < 0)
 369                                         error = -ENODEV;
 370                         } else {
 371                                 data->swap = -1;
 372                                 error = -EINVAL;
 373                         }
 374                 }
 375                 break;
 376
 377         default:
 378                 error = -ENOTTY;
 379
 380         }
 381
 382         return error;
 383 }
 384
 385 static struct file_operations snapshot_fops = {
 386         .open = snapshot_open,
 387         .release = snapshot_release,
 388         .read = snapshot_read,
 389         .write = snapshot_write,
 390         .llseek = no_llseek,
 391         .ioctl = snapshot_ioctl,
 392 };
 393
 394 static struct miscdevice snapshot_device = {
 395         .minor = SNAPSHOT_MINOR,
 396         .name = "snapshot",
 397         .fops = &snapshot_fops,
 398 };
 399
 400 static int __init snapshot_device_init(void)
 401 {
 402         return misc_register(&snapshot_device);
 403 };
 404
 405 device_initcall(snapshot_device_init);