1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/module.h>
15#include <linux/file.h>
16#include <linux/delay.h>
17#include <linux/bitops.h>
18#include <linux/genhd.h>
19#include <linux/device.h>
20#include <linux/buffer_head.h>
21#include <linux/bio.h>
22#include <linux/blkdev.h>
23#include <linux/swap.h>
24#include <linux/swapops.h>
25#include <linux/pm.h>
26
27#include "power.h"
28
29#define SWSUSP_SIG "S1SUSPEND"
30
31struct swsusp_header {
32 char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
33 sector_t image;
34 unsigned int flags;
35 char orig_sig[10];
36 char sig[10];
37} __attribute__((packed));
38
39static struct swsusp_header *swsusp_header;
40
41
42
43
44
45static unsigned short root_swap = 0xffff;
46static struct block_device *resume_bdev;
47
48
49
50
51
52
53
54
55
56
57
58
59static int submit(int rw, pgoff_t page_off, struct page *page,
60 struct bio **bio_chain)
61{
62 const int bio_rw = rw | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
63 struct bio *bio;
64
65 bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
66 bio->bi_sector = page_off * (PAGE_SIZE >> 9);
67 bio->bi_bdev = resume_bdev;
68 bio->bi_end_io = end_swap_bio_read;
69
70 if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
71 printk(KERN_ERR "PM: Adding page to bio failed at %ld\n",
72 page_off);
73 bio_put(bio);
74 return -EFAULT;
75 }
76
77 lock_page(page);
78 bio_get(bio);
79
80 if (bio_chain == NULL) {
81 submit_bio(bio_rw, bio);
82 wait_on_page_locked(page);
83 if (rw == READ)
84 bio_set_pages_dirty(bio);
85 bio_put(bio);
86 } else {
87 if (rw == READ)
88 get_page(page);
89 bio->bi_private = *bio_chain;
90 *bio_chain = bio;
91 submit_bio(bio_rw, bio);
92 }
93 return 0;
94}
95
96static int bio_read_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
97{
98 return submit(READ, page_off, virt_to_page(addr), bio_chain);
99}
100
101static int bio_write_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
102{
103 return submit(WRITE, page_off, virt_to_page(addr), bio_chain);
104}
105
106static int wait_on_bio_chain(struct bio **bio_chain)
107{
108 struct bio *bio;
109 struct bio *next_bio;
110 int ret = 0;
111
112 if (bio_chain == NULL)
113 return 0;
114
115 bio = *bio_chain;
116 if (bio == NULL)
117 return 0;
118 while (bio) {
119 struct page *page;
120
121 next_bio = bio->bi_private;
122 page = bio->bi_io_vec[0].bv_page;
123 wait_on_page_locked(page);
124 if (!PageUptodate(page) || PageError(page))
125 ret = -EIO;
126 put_page(page);
127 bio_put(bio);
128 bio = next_bio;
129 }
130 *bio_chain = NULL;
131 return ret;
132}
133
134
135
136
137
138static int mark_swapfiles(sector_t start, unsigned int flags)
139{
140 int error;
141
142 bio_read_page(swsusp_resume_block, swsusp_header, NULL);
143 if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
144 !memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
145 memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
146 memcpy(swsusp_header->sig,SWSUSP_SIG, 10);
147 swsusp_header->image = start;
148 swsusp_header->flags = flags;
149 error = bio_write_page(swsusp_resume_block,
150 swsusp_header, NULL);
151 } else {
152 printk(KERN_ERR "PM: Swap header not found!\n");
153 error = -ENODEV;
154 }
155 return error;
156}
157
158
159
160
161
162
163static int swsusp_swap_check(void)
164{
165 int res;
166
167 res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
168 &resume_bdev);
169 if (res < 0)
170 return res;
171
172 root_swap = res;
173 res = blkdev_get(resume_bdev, FMODE_WRITE);
174 if (res)
175 return res;
176
177 res = set_blocksize(resume_bdev, PAGE_SIZE);
178 if (res < 0)
179 blkdev_put(resume_bdev, FMODE_WRITE);
180
181 return res;
182}
183
184
185
186
187
188
189
190
191static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
192{
193 void *src;
194
195 if (!offset)
196 return -ENOSPC;
197
198 if (bio_chain) {
199 src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
200 if (src) {
201 memcpy(src, buf, PAGE_SIZE);
202 } else {
203 WARN_ON_ONCE(1);
204 bio_chain = NULL;
205 src = buf;
206 }
207 } else {
208 src = buf;
209 }
210 return bio_write_page(offset, src, bio_chain);
211}
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228#define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
229
230struct swap_map_page {
231 sector_t entries[MAP_PAGE_ENTRIES];
232 sector_t next_swap;
233};
234
235
236
237
238
239
240struct swap_map_handle {
241 struct swap_map_page *cur;
242 sector_t cur_swap;
243 unsigned int k;
244};
245
246static void release_swap_writer(struct swap_map_handle *handle)
247{
248 if (handle->cur)
249 free_page((unsigned long)handle->cur);
250 handle->cur = NULL;
251}
252
253static int get_swap_writer(struct swap_map_handle *handle)
254{
255 handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
256 if (!handle->cur)
257 return -ENOMEM;
258 handle->cur_swap = alloc_swapdev_block(root_swap);
259 if (!handle->cur_swap) {
260 release_swap_writer(handle);
261 return -ENOSPC;
262 }
263 handle->k = 0;
264 return 0;
265}
266
267static int swap_write_page(struct swap_map_handle *handle, void *buf,
268 struct bio **bio_chain)
269{
270 int error = 0;
271 sector_t offset;
272
273 if (!handle->cur)
274 return -EINVAL;
275 offset = alloc_swapdev_block(root_swap);
276 error = write_page(buf, offset, bio_chain);
277 if (error)
278 return error;
279 handle->cur->entries[handle->k++] = offset;
280 if (handle->k >= MAP_PAGE_ENTRIES) {
281 error = wait_on_bio_chain(bio_chain);
282 if (error)
283 goto out;
284 offset = alloc_swapdev_block(root_swap);
285 if (!offset)
286 return -ENOSPC;
287 handle->cur->next_swap = offset;
288 error = write_page(handle->cur, handle->cur_swap, NULL);
289 if (error)
290 goto out;
291 memset(handle->cur, 0, PAGE_SIZE);
292 handle->cur_swap = offset;
293 handle->k = 0;
294 }
295 out:
296 return error;
297}
298
299static int flush_swap_writer(struct swap_map_handle *handle)
300{
301 if (handle->cur && handle->cur_swap)
302 return write_page(handle->cur, handle->cur_swap, NULL);
303 else
304 return -EINVAL;
305}
306
307
308
309
310
311static int save_image(struct swap_map_handle *handle,
312 struct snapshot_handle *snapshot,
313 unsigned int nr_to_write)
314{
315 unsigned int m;
316 int ret;
317 int nr_pages;
318 int err2;
319 struct bio *bio;
320 struct timeval start;
321 struct timeval stop;
322
323 printk(KERN_INFO "PM: Saving image data pages (%u pages) ... ",
324 nr_to_write);
325 m = nr_to_write / 100;
326 if (!m)
327 m = 1;
328 nr_pages = 0;
329 bio = NULL;
330 do_gettimeofday(&start);
331 while (1) {
332 ret = snapshot_read_next(snapshot, PAGE_SIZE);
333 if (ret <= 0)
334 break;
335 ret = swap_write_page(handle, data_of(*snapshot), &bio);
336 if (ret)
337 break;
338 if (!(nr_pages % m))
339 printk("\b\b\b\b%3d%%", nr_pages / m);
340 nr_pages++;
341 }
342 err2 = wait_on_bio_chain(&bio);
343 do_gettimeofday(&stop);
344 if (!ret)
345 ret = err2;
346 if (!ret)
347 printk("\b\b\b\bdone\n");
348 else
349 printk("\n");
350 swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
351 return ret;
352}
353
354
355
356
357
358
359
360
361static int enough_swap(unsigned int nr_pages)
362{
363 unsigned int free_swap = count_swap_pages(root_swap, 1);
364
365 pr_debug("PM: Free swap pages: %u\n", free_swap);
366 return free_swap > nr_pages + PAGES_FOR_IO;
367}
368
369
370
371
372
373
374
375
376
377
378
379int swsusp_write(unsigned int flags)
380{
381 struct swap_map_handle handle;
382 struct snapshot_handle snapshot;
383 struct swsusp_info *header;
384 int error;
385
386 error = swsusp_swap_check();
387 if (error) {
388 printk(KERN_ERR "PM: Cannot find swap device, try "
389 "swapon -a.\n");
390 return error;
391 }
392 memset(&snapshot, 0, sizeof(struct snapshot_handle));
393 error = snapshot_read_next(&snapshot, PAGE_SIZE);
394 if (error < PAGE_SIZE) {
395 if (error >= 0)
396 error = -EFAULT;
397
398 goto out;
399 }
400 header = (struct swsusp_info *)data_of(snapshot);
401 if (!enough_swap(header->pages)) {
402 printk(KERN_ERR "PM: Not enough free swap\n");
403 error = -ENOSPC;
404 goto out;
405 }
406 error = get_swap_writer(&handle);
407 if (!error) {
408 sector_t start = handle.cur_swap;
409
410 error = swap_write_page(&handle, header, NULL);
411 if (!error)
412 error = save_image(&handle, &snapshot,
413 header->pages - 1);
414
415 if (!error) {
416 flush_swap_writer(&handle);
417 printk(KERN_INFO "PM: S");
418 error = mark_swapfiles(start, flags);
419 printk("|\n");
420 }
421 }
422 if (error)
423 free_all_swap_pages(root_swap);
424
425 release_swap_writer(&handle);
426 out:
427 swsusp_close(FMODE_WRITE);
428 return error;
429}
430
431
432
433
434
435
436static void release_swap_reader(struct swap_map_handle *handle)
437{
438 if (handle->cur)
439 free_page((unsigned long)handle->cur);
440 handle->cur = NULL;
441}
442
443static int get_swap_reader(struct swap_map_handle *handle, sector_t start)
444{
445 int error;
446
447 if (!start)
448 return -EINVAL;
449
450 handle->cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
451 if (!handle->cur)
452 return -ENOMEM;
453
454 error = bio_read_page(start, handle->cur, NULL);
455 if (error) {
456 release_swap_reader(handle);
457 return error;
458 }
459 handle->k = 0;
460 return 0;
461}
462
463static int swap_read_page(struct swap_map_handle *handle, void *buf,
464 struct bio **bio_chain)
465{
466 sector_t offset;
467 int error;
468
469 if (!handle->cur)
470 return -EINVAL;
471 offset = handle->cur->entries[handle->k];
472 if (!offset)
473 return -EFAULT;
474 error = bio_read_page(offset, buf, bio_chain);
475 if (error)
476 return error;
477 if (++handle->k >= MAP_PAGE_ENTRIES) {
478 error = wait_on_bio_chain(bio_chain);
479 handle->k = 0;
480 offset = handle->cur->next_swap;
481 if (!offset)
482 release_swap_reader(handle);
483 else if (!error)
484 error = bio_read_page(offset, handle->cur, NULL);
485 }
486 return error;
487}
488
489
490
491
492
493
494
495static int load_image(struct swap_map_handle *handle,
496 struct snapshot_handle *snapshot,
497 unsigned int nr_to_read)
498{
499 unsigned int m;
500 int error = 0;
501 struct timeval start;
502 struct timeval stop;
503 struct bio *bio;
504 int err2;
505 unsigned nr_pages;
506
507 printk(KERN_INFO "PM: Loading image data pages (%u pages) ... ",
508 nr_to_read);
509 m = nr_to_read / 100;
510 if (!m)
511 m = 1;
512 nr_pages = 0;
513 bio = NULL;
514 do_gettimeofday(&start);
515 for ( ; ; ) {
516 error = snapshot_write_next(snapshot, PAGE_SIZE);
517 if (error <= 0)
518 break;
519 error = swap_read_page(handle, data_of(*snapshot), &bio);
520 if (error)
521 break;
522 if (snapshot->sync_read)
523 error = wait_on_bio_chain(&bio);
524 if (error)
525 break;
526 if (!(nr_pages % m))
527 printk("\b\b\b\b%3d%%", nr_pages / m);
528 nr_pages++;
529 }
530 err2 = wait_on_bio_chain(&bio);
531 do_gettimeofday(&stop);
532 if (!error)
533 error = err2;
534 if (!error) {
535 printk("\b\b\b\bdone\n");
536 snapshot_write_finalize(snapshot);
537 if (!snapshot_image_loaded(snapshot))
538 error = -ENODATA;
539 } else
540 printk("\n");
541 swsusp_show_speed(&start, &stop, nr_to_read, "Read");
542 return error;
543}
544
545
546
547
548
549
550
551int swsusp_read(unsigned int *flags_p)
552{
553 int error;
554 struct swap_map_handle handle;
555 struct snapshot_handle snapshot;
556 struct swsusp_info *header;
557
558 *flags_p = swsusp_header->flags;
559 if (IS_ERR(resume_bdev)) {
560 pr_debug("PM: Image device not initialised\n");
561 return PTR_ERR(resume_bdev);
562 }
563
564 memset(&snapshot, 0, sizeof(struct snapshot_handle));
565 error = snapshot_write_next(&snapshot, PAGE_SIZE);
566 if (error < PAGE_SIZE)
567 return error < 0 ? error : -EFAULT;
568 header = (struct swsusp_info *)data_of(snapshot);
569 error = get_swap_reader(&handle, swsusp_header->image);
570 if (!error)
571 error = swap_read_page(&handle, header, NULL);
572 if (!error)
573 error = load_image(&handle, &snapshot, header->pages - 1);
574 release_swap_reader(&handle);
575
576 if (!error)
577 pr_debug("PM: Image successfully loaded\n");
578 else
579 pr_debug("PM: Error %d resuming\n", error);
580 return error;
581}
582
583
584
585
586
587int swsusp_check(void)
588{
589 int error;
590
591 resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
592 if (!IS_ERR(resume_bdev)) {
593 set_blocksize(resume_bdev, PAGE_SIZE);
594 memset(swsusp_header, 0, PAGE_SIZE);
595 error = bio_read_page(swsusp_resume_block,
596 swsusp_header, NULL);
597 if (error)
598 goto put;
599
600 if (!memcmp(SWSUSP_SIG, swsusp_header->sig, 10)) {
601 memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
602
603 error = bio_write_page(swsusp_resume_block,
604 swsusp_header, NULL);
605 } else {
606 error = -EINVAL;
607 }
608
609put:
610 if (error)
611 blkdev_put(resume_bdev, FMODE_READ);
612 else
613 pr_debug("PM: Signature found, resuming\n");
614 } else {
615 error = PTR_ERR(resume_bdev);
616 }
617
618 if (error)
619 pr_debug("PM: Error %d checking image file\n", error);
620
621 return error;
622}
623
624
625
626
627
628void swsusp_close(fmode_t mode)
629{
630 if (IS_ERR(resume_bdev)) {
631 pr_debug("PM: Image device not initialised\n");
632 return;
633 }
634
635 blkdev_put(resume_bdev, mode);
636}
637
638static int swsusp_header_init(void)
639{
640 swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
641 if (!swsusp_header)
642 panic("Could not allocate memory for swsusp_header\n");
643 return 0;
644}
645
646core_initcall(swsusp_header_init);
647