user.c 9.5 KB

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