1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/module.h>
16#include <linux/file.h>
17#include <linux/delay.h>
18#include <linux/bitops.h>
19#include <linux/genhd.h>
20#include <linux/device.h>
21#include <linux/buffer_head.h>
22#include <linux/bio.h>
23#include <linux/blkdev.h>
24#include <linux/swap.h>
25#include <linux/swapops.h>
26#include <linux/pm.h>
27#include <linux/slab.h>
28#include <linux/lzo.h>
29#include <linux/vmalloc.h>
30
31#include "power.h"
32
33#define HIBERNATE_SIG "S1SUSPEND"
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50#define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
51
52struct swap_map_page {
53 sector_t entries[MAP_PAGE_ENTRIES];
54 sector_t next_swap;
55};
56
57
58
59
60
61
62struct swap_map_handle {
63 struct swap_map_page *cur;
64 sector_t cur_swap;
65 sector_t first_sector;
66 unsigned int k;
67};
68
69struct swsusp_header {
70 char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
71 sector_t image;
72 unsigned int flags;
73 char orig_sig[10];
74 char sig[10];
75} __attribute__((packed));
76
77static struct swsusp_header *swsusp_header;
78
79
80
81
82
83
84struct swsusp_extent {
85 struct rb_node node;
86 unsigned long start;
87 unsigned long end;
88};
89
90static struct rb_root swsusp_extents = RB_ROOT;
91
92static int swsusp_extents_insert(unsigned long swap_offset)
93{
94 struct rb_node **new = &(swsusp_extents.rb_node);
95 struct rb_node *parent = NULL;
96 struct swsusp_extent *ext;
97
98
99 while (*new) {
100 ext = container_of(*new, struct swsusp_extent, node);
101 parent = *new;
102 if (swap_offset < ext->start) {
103
104 if (swap_offset == ext->start - 1) {
105 ext->start--;
106 return 0;
107 }
108 new = &((*new)->rb_left);
109 } else if (swap_offset > ext->end) {
110
111 if (swap_offset == ext->end + 1) {
112 ext->end++;
113 return 0;
114 }
115 new = &((*new)->rb_right);
116 } else {
117
118 return -EINVAL;
119 }
120 }
121
122 ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
123 if (!ext)
124 return -ENOMEM;
125
126 ext->start = swap_offset;
127 ext->end = swap_offset;
128 rb_link_node(&ext->node, parent, new);
129 rb_insert_color(&ext->node, &swsusp_extents);
130 return 0;
131}
132
133
134
135
136
137
138sector_t alloc_swapdev_block(int swap)
139{
140 unsigned long offset;
141
142 offset = swp_offset(get_swap_page_of_type(swap));
143 if (offset) {
144 if (swsusp_extents_insert(offset))
145 swap_free(swp_entry(swap, offset));
146 else
147 return swapdev_block(swap, offset);
148 }
149 return 0;
150}
151
152
153
154
155
156
157
158void free_all_swap_pages(int swap)
159{
160 struct rb_node *node;
161
162 while ((node = swsusp_extents.rb_node)) {
163 struct swsusp_extent *ext;
164 unsigned long offset;
165
166 ext = container_of(node, struct swsusp_extent, node);
167 rb_erase(node, &swsusp_extents);
168 for (offset = ext->start; offset <= ext->end; offset++)
169 swap_free(swp_entry(swap, offset));
170
171 kfree(ext);
172 }
173}
174
175int swsusp_swap_in_use(void)
176{
177 return (swsusp_extents.rb_node != NULL);
178}
179
180
181
182
183
184static unsigned short root_swap = 0xffff;
185struct block_device *hib_resume_bdev;
186
187
188
189
190
191static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
192{
193 int error;
194
195 hib_bio_read_page(swsusp_resume_block, swsusp_header, NULL);
196 if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
197 !memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
198 memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
199 memcpy(swsusp_header->sig, HIBERNATE_SIG, 10);
200 swsusp_header->image = handle->first_sector;
201 swsusp_header->flags = flags;
202 error = hib_bio_write_page(swsusp_resume_block,
203 swsusp_header, NULL);
204 } else {
205 printk(KERN_ERR "PM: Swap header not found!\n");
206 error = -ENODEV;
207 }
208 return error;
209}
210
211
212
213
214
215
216
217static int swsusp_swap_check(void)
218{
219 int res;
220
221 res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
222 &hib_resume_bdev);
223 if (res < 0)
224 return res;
225
226 root_swap = res;
227 res = blkdev_get(hib_resume_bdev, FMODE_WRITE, NULL);
228 if (res)
229 return res;
230
231 res = set_blocksize(hib_resume_bdev, PAGE_SIZE);
232 if (res < 0)
233 blkdev_put(hib_resume_bdev, FMODE_WRITE);
234
235 return res;
236}
237
238
239
240
241
242
243
244
245static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
246{
247 void *src;
248
249 if (!offset)
250 return -ENOSPC;
251
252 if (bio_chain) {
253 src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
254 if (src) {
255 copy_page(src, buf);
256 } else {
257 WARN_ON_ONCE(1);
258 bio_chain = NULL;
259 src = buf;
260 }
261 } else {
262 src = buf;
263 }
264 return hib_bio_write_page(offset, src, bio_chain);
265}
266
267static void release_swap_writer(struct swap_map_handle *handle)
268{
269 if (handle->cur)
270 free_page((unsigned long)handle->cur);
271 handle->cur = NULL;
272}
273
274static int get_swap_writer(struct swap_map_handle *handle)
275{
276 int ret;
277
278 ret = swsusp_swap_check();
279 if (ret) {
280 if (ret != -ENOSPC)
281 printk(KERN_ERR "PM: Cannot find swap device, try "
282 "swapon -a.\n");
283 return ret;
284 }
285 handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
286 if (!handle->cur) {
287 ret = -ENOMEM;
288 goto err_close;
289 }
290 handle->cur_swap = alloc_swapdev_block(root_swap);
291 if (!handle->cur_swap) {
292 ret = -ENOSPC;
293 goto err_rel;
294 }
295 handle->k = 0;
296 handle->first_sector = handle->cur_swap;
297 return 0;
298err_rel:
299 release_swap_writer(handle);
300err_close:
301 swsusp_close(FMODE_WRITE);
302 return ret;
303}
304
305static int swap_write_page(struct swap_map_handle *handle, void *buf,
306 struct bio **bio_chain)
307{
308 int error = 0;
309 sector_t offset;
310
311 if (!handle->cur)
312 return -EINVAL;
313 offset = alloc_swapdev_block(root_swap);
314 error = write_page(buf, offset, bio_chain);
315 if (error)
316 return error;
317 handle->cur->entries[handle->k++] = offset;
318 if (handle->k >= MAP_PAGE_ENTRIES) {
319 error = hib_wait_on_bio_chain(bio_chain);
320 if (error)
321 goto out;
322 offset = alloc_swapdev_block(root_swap);
323 if (!offset)
324 return -ENOSPC;
325 handle->cur->next_swap = offset;
326 error = write_page(handle->cur, handle->cur_swap, NULL);
327 if (error)
328 goto out;
329 clear_page(handle->cur);
330 handle->cur_swap = offset;
331 handle->k = 0;
332 }
333 out:
334 return error;
335}
336
337static int flush_swap_writer(struct swap_map_handle *handle)
338{
339 if (handle->cur && handle->cur_swap)
340 return write_page(handle->cur, handle->cur_swap, NULL);
341 else
342 return -EINVAL;
343}
344
345static int swap_writer_finish(struct swap_map_handle *handle,
346 unsigned int flags, int error)
347{
348 if (!error) {
349 flush_swap_writer(handle);
350 printk(KERN_INFO "PM: S");
351 error = mark_swapfiles(handle, flags);
352 printk("|\n");
353 }
354
355 if (error)
356 free_all_swap_pages(root_swap);
357 release_swap_writer(handle);
358 swsusp_close(FMODE_WRITE);
359
360 return error;
361}
362
363
364#define LZO_HEADER sizeof(size_t)
365
366
367#define LZO_UNC_PAGES 32
368#define LZO_UNC_SIZE (LZO_UNC_PAGES * PAGE_SIZE)
369
370
371#define LZO_CMP_PAGES DIV_ROUND_UP(lzo1x_worst_compress(LZO_UNC_SIZE) + \
372 LZO_HEADER, PAGE_SIZE)
373#define LZO_CMP_SIZE (LZO_CMP_PAGES * PAGE_SIZE)
374
375
376
377
378
379static int save_image(struct swap_map_handle *handle,
380 struct snapshot_handle *snapshot,
381 unsigned int nr_to_write)
382{
383 unsigned int m;
384 int ret;
385 int nr_pages;
386 int err2;
387 struct bio *bio;
388 struct timeval start;
389 struct timeval stop;
390
391 printk(KERN_INFO "PM: Saving image data pages (%u pages) ... ",
392 nr_to_write);
393 m = nr_to_write / 100;
394 if (!m)
395 m = 1;
396 nr_pages = 0;
397 bio = NULL;
398 do_gettimeofday(&start);
399 while (1) {
400 ret = snapshot_read_next(snapshot);
401 if (ret <= 0)
402 break;
403 ret = swap_write_page(handle, data_of(*snapshot), &bio);
404 if (ret)
405 break;
406 if (!(nr_pages % m))
407 printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
408 nr_pages++;
409 }
410 err2 = hib_wait_on_bio_chain(&bio);
411 do_gettimeofday(&stop);
412 if (!ret)
413 ret = err2;
414 if (!ret)
415 printk(KERN_CONT "\b\b\b\bdone\n");
416 else
417 printk(KERN_CONT "\n");
418 swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
419 return ret;
420}
421
422
423
424
425
426
427
428
429static int save_image_lzo(struct swap_map_handle *handle,
430 struct snapshot_handle *snapshot,
431 unsigned int nr_to_write)
432{
433 unsigned int m;
434 int ret = 0;
435 int nr_pages;
436 int err2;
437 struct bio *bio;
438 struct timeval start;
439 struct timeval stop;
440 size_t off, unc_len, cmp_len;
441 unsigned char *unc, *cmp, *wrk, *page;
442
443 page = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
444 if (!page) {
445 printk(KERN_ERR "PM: Failed to allocate LZO page\n");
446 return -ENOMEM;
447 }
448
449 wrk = vmalloc(LZO1X_1_MEM_COMPRESS);
450 if (!wrk) {
451 printk(KERN_ERR "PM: Failed to allocate LZO workspace\n");
452 free_page((unsigned long)page);
453 return -ENOMEM;
454 }
455
456 unc = vmalloc(LZO_UNC_SIZE);
457 if (!unc) {
458 printk(KERN_ERR "PM: Failed to allocate LZO uncompressed\n");
459 vfree(wrk);
460 free_page((unsigned long)page);
461 return -ENOMEM;
462 }
463
464 cmp = vmalloc(LZO_CMP_SIZE);
465 if (!cmp) {
466 printk(KERN_ERR "PM: Failed to allocate LZO compressed\n");
467 vfree(unc);
468 vfree(wrk);
469 free_page((unsigned long)page);
470 return -ENOMEM;
471 }
472
473 printk(KERN_INFO
474 "PM: Compressing and saving image data (%u pages) ... ",
475 nr_to_write);
476 m = nr_to_write / 100;
477 if (!m)
478 m = 1;
479 nr_pages = 0;
480 bio = NULL;
481 do_gettimeofday(&start);
482 for (;;) {
483 for (off = 0; off < LZO_UNC_SIZE; off += PAGE_SIZE) {
484 ret = snapshot_read_next(snapshot);
485 if (ret < 0)
486 goto out_finish;
487
488 if (!ret)
489 break;
490
491 memcpy(unc + off, data_of(*snapshot), PAGE_SIZE);
492
493 if (!(nr_pages % m))
494 printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
495 nr_pages++;
496 }
497
498 if (!off)
499 break;
500
501 unc_len = off;
502 ret = lzo1x_1_compress(unc, unc_len,
503 cmp + LZO_HEADER, &cmp_len, wrk);
504 if (ret < 0) {
505 printk(KERN_ERR "PM: LZO compression failed\n");
506 break;
507 }
508
509 if (unlikely(!cmp_len ||
510 cmp_len > lzo1x_worst_compress(unc_len))) {
511 printk(KERN_ERR "PM: Invalid LZO compressed length\n");
512 ret = -1;
513 break;
514 }
515
516 *(size_t *)cmp = cmp_len;
517
518
519
520
521
522
523
524
525 for (off = 0; off < LZO_HEADER + cmp_len; off += PAGE_SIZE) {
526 memcpy(page, cmp + off, PAGE_SIZE);
527
528 ret = swap_write_page(handle, page, &bio);
529 if (ret)
530 goto out_finish;
531 }
532 }
533
534out_finish:
535 err2 = hib_wait_on_bio_chain(&bio);
536 do_gettimeofday(&stop);
537 if (!ret)
538 ret = err2;
539 if (!ret)
540 printk(KERN_CONT "\b\b\b\bdone\n");
541 else
542 printk(KERN_CONT "\n");
543 swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
544
545 vfree(cmp);
546 vfree(unc);
547 vfree(wrk);
548 free_page((unsigned long)page);
549
550 return ret;
551}
552
553
554
555
556
557
558
559
560static int enough_swap(unsigned int nr_pages, unsigned int flags)
561{
562 unsigned int free_swap = count_swap_pages(root_swap, 1);
563 unsigned int required;
564
565 pr_debug("PM: Free swap pages: %u\n", free_swap);
566
567 required = PAGES_FOR_IO + ((flags & SF_NOCOMPRESS_MODE) ?
568 nr_pages : (nr_pages * LZO_CMP_PAGES) / LZO_UNC_PAGES + 1);
569 return free_swap > required;
570}
571
572
573
574
575
576
577
578
579
580
581
582int swsusp_write(unsigned int flags)
583{
584 struct swap_map_handle handle;
585 struct snapshot_handle snapshot;
586 struct swsusp_info *header;
587 unsigned long pages;
588 int error;
589
590 pages = snapshot_get_image_size();
591 error = get_swap_writer(&handle);
592 if (error) {
593 printk(KERN_ERR "PM: Cannot get swap writer\n");
594 return error;
595 }
596 if (!enough_swap(pages, flags)) {
597 printk(KERN_ERR "PM: Not enough free swap\n");
598 error = -ENOSPC;
599 goto out_finish;
600 }
601 memset(&snapshot, 0, sizeof(struct snapshot_handle));
602 error = snapshot_read_next(&snapshot);
603 if (error < PAGE_SIZE) {
604 if (error >= 0)
605 error = -EFAULT;
606
607 goto out_finish;
608 }
609 header = (struct swsusp_info *)data_of(snapshot);
610 error = swap_write_page(&handle, header, NULL);
611 if (!error) {
612 error = (flags & SF_NOCOMPRESS_MODE) ?
613 save_image(&handle, &snapshot, pages - 1) :
614 save_image_lzo(&handle, &snapshot, pages - 1);
615 }
616out_finish:
617 error = swap_writer_finish(&handle, flags, error);
618 return error;
619}
620
621
622
623
624
625
626static void release_swap_reader(struct swap_map_handle *handle)
627{
628 if (handle->cur)
629 free_page((unsigned long)handle->cur);
630 handle->cur = NULL;
631}
632
633static int get_swap_reader(struct swap_map_handle *handle,
634 unsigned int *flags_p)
635{
636 int error;
637
638 *flags_p = swsusp_header->flags;
639
640 if (!swsusp_header->image)
641 return -EINVAL;
642
643 handle->cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
644 if (!handle->cur)
645 return -ENOMEM;
646
647 error = hib_bio_read_page(swsusp_header->image, handle->cur, NULL);
648 if (error) {
649 release_swap_reader(handle);
650 return error;
651 }
652 handle->k = 0;
653 return 0;
654}
655
656static int swap_read_page(struct swap_map_handle *handle, void *buf,
657 struct bio **bio_chain)
658{
659 sector_t offset;
660 int error;
661
662 if (!handle->cur)
663 return -EINVAL;
664 offset = handle->cur->entries[handle->k];
665 if (!offset)
666 return -EFAULT;
667 error = hib_bio_read_page(offset, buf, bio_chain);
668 if (error)
669 return error;
670 if (++handle->k >= MAP_PAGE_ENTRIES) {
671 error = hib_wait_on_bio_chain(bio_chain);
672 handle->k = 0;
673 offset = handle->cur->next_swap;
674 if (!offset)
675 release_swap_reader(handle);
676 else if (!error)
677 error = hib_bio_read_page(offset, handle->cur, NULL);
678 }
679 return error;
680}
681
682static int swap_reader_finish(struct swap_map_handle *handle)
683{
684 release_swap_reader(handle);
685
686 return 0;
687}
688
689
690
691
692
693
694
695static int load_image(struct swap_map_handle *handle,
696 struct snapshot_handle *snapshot,
697 unsigned int nr_to_read)
698{
699 unsigned int m;
700 int error = 0;
701 struct timeval start;
702 struct timeval stop;
703 struct bio *bio;
704 int err2;
705 unsigned nr_pages;
706
707 printk(KERN_INFO "PM: Loading image data pages (%u pages) ... ",
708 nr_to_read);
709 m = nr_to_read / 100;
710 if (!m)
711 m = 1;
712 nr_pages = 0;
713 bio = NULL;
714 do_gettimeofday(&start);
715 for ( ; ; ) {
716 error = snapshot_write_next(snapshot);
717 if (error <= 0)
718 break;
719 error = swap_read_page(handle, data_of(*snapshot), &bio);
720 if (error)
721 break;
722 if (snapshot->sync_read)
723 error = hib_wait_on_bio_chain(&bio);
724 if (error)
725 break;
726 if (!(nr_pages % m))
727 printk("\b\b\b\b%3d%%", nr_pages / m);
728 nr_pages++;
729 }
730 err2 = hib_wait_on_bio_chain(&bio);
731 do_gettimeofday(&stop);
732 if (!error)
733 error = err2;
734 if (!error) {
735 printk("\b\b\b\bdone\n");
736 snapshot_write_finalize(snapshot);
737 if (!snapshot_image_loaded(snapshot))
738 error = -ENODATA;
739 } else
740 printk("\n");
741 swsusp_show_speed(&start, &stop, nr_to_read, "Read");
742 return error;
743}
744
745
746
747
748
749
750
751static int load_image_lzo(struct swap_map_handle *handle,
752 struct snapshot_handle *snapshot,
753 unsigned int nr_to_read)
754{
755 unsigned int m;
756 int error = 0;
757 struct bio *bio;
758 struct timeval start;
759 struct timeval stop;
760 unsigned nr_pages;
761 size_t i, off, unc_len, cmp_len;
762 unsigned char *unc, *cmp, *page[LZO_CMP_PAGES];
763
764 for (i = 0; i < LZO_CMP_PAGES; i++) {
765 page[i] = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
766 if (!page[i]) {
767 printk(KERN_ERR "PM: Failed to allocate LZO page\n");
768
769 while (i)
770 free_page((unsigned long)page[--i]);
771
772 return -ENOMEM;
773 }
774 }
775
776 unc = vmalloc(LZO_UNC_SIZE);
777 if (!unc) {
778 printk(KERN_ERR "PM: Failed to allocate LZO uncompressed\n");
779
780 for (i = 0; i < LZO_CMP_PAGES; i++)
781 free_page((unsigned long)page[i]);
782
783 return -ENOMEM;
784 }
785
786 cmp = vmalloc(LZO_CMP_SIZE);
787 if (!cmp) {
788 printk(KERN_ERR "PM: Failed to allocate LZO compressed\n");
789
790 vfree(unc);
791 for (i = 0; i < LZO_CMP_PAGES; i++)
792 free_page((unsigned long)page[i]);
793
794 return -ENOMEM;
795 }
796
797 printk(KERN_INFO
798 "PM: Loading and decompressing image data (%u pages) ... ",
799 nr_to_read);
800 m = nr_to_read / 100;
801 if (!m)
802 m = 1;
803 nr_pages = 0;
804 bio = NULL;
805 do_gettimeofday(&start);
806
807 error = snapshot_write_next(snapshot);
808 if (error <= 0)
809 goto out_finish;
810
811 for (;;) {
812 error = swap_read_page(handle, page[0], NULL);
813 if (error)
814 break;
815
816 cmp_len = *(size_t *)page[0];
817 if (unlikely(!cmp_len ||
818 cmp_len > lzo1x_worst_compress(LZO_UNC_SIZE))) {
819 printk(KERN_ERR "PM: Invalid LZO compressed length\n");
820 error = -1;
821 break;
822 }
823
824 for (off = PAGE_SIZE, i = 1;
825 off < LZO_HEADER + cmp_len; off += PAGE_SIZE, i++) {
826 error = swap_read_page(handle, page[i], &bio);
827 if (error)
828 goto out_finish;
829 }
830
831 error = hib_wait_on_bio_chain(&bio);
832 if (error)
833 goto out_finish;
834
835 for (off = 0, i = 0;
836 off < LZO_HEADER + cmp_len; off += PAGE_SIZE, i++) {
837 memcpy(cmp + off, page[i], PAGE_SIZE);
838 }
839
840 unc_len = LZO_UNC_SIZE;
841 error = lzo1x_decompress_safe(cmp + LZO_HEADER, cmp_len,
842 unc, &unc_len);
843 if (error < 0) {
844 printk(KERN_ERR "PM: LZO decompression failed\n");
845 break;
846 }
847
848 if (unlikely(!unc_len ||
849 unc_len > LZO_UNC_SIZE ||
850 unc_len & (PAGE_SIZE - 1))) {
851 printk(KERN_ERR "PM: Invalid LZO uncompressed length\n");
852 error = -1;
853 break;
854 }
855
856 for (off = 0; off < unc_len; off += PAGE_SIZE) {
857 memcpy(data_of(*snapshot), unc + off, PAGE_SIZE);
858
859 if (!(nr_pages % m))
860 printk("\b\b\b\b%3d%%", nr_pages / m);
861 nr_pages++;
862
863 error = snapshot_write_next(snapshot);
864 if (error <= 0)
865 goto out_finish;
866 }
867 }
868
869out_finish:
870 do_gettimeofday(&stop);
871 if (!error) {
872 printk("\b\b\b\bdone\n");
873 snapshot_write_finalize(snapshot);
874 if (!snapshot_image_loaded(snapshot))
875 error = -ENODATA;
876 } else
877 printk("\n");
878 swsusp_show_speed(&start, &stop, nr_to_read, "Read");
879
880 vfree(cmp);
881 vfree(unc);
882 for (i = 0; i < LZO_CMP_PAGES; i++)
883 free_page((unsigned long)page[i]);
884
885 return error;
886}
887
888
889
890
891
892
893
894int swsusp_read(unsigned int *flags_p)
895{
896 int error;
897 struct swap_map_handle handle;
898 struct snapshot_handle snapshot;
899 struct swsusp_info *header;
900
901 memset(&snapshot, 0, sizeof(struct snapshot_handle));
902 error = snapshot_write_next(&snapshot);
903 if (error < PAGE_SIZE)
904 return error < 0 ? error : -EFAULT;
905 header = (struct swsusp_info *)data_of(snapshot);
906 error = get_swap_reader(&handle, flags_p);
907 if (error)
908 goto end;
909 if (!error)
910 error = swap_read_page(&handle, header, NULL);
911 if (!error) {
912 error = (*flags_p & SF_NOCOMPRESS_MODE) ?
913 load_image(&handle, &snapshot, header->pages - 1) :
914 load_image_lzo(&handle, &snapshot, header->pages - 1);
915 }
916 swap_reader_finish(&handle);
917end:
918 if (!error)
919 pr_debug("PM: Image successfully loaded\n");
920 else
921 pr_debug("PM: Error %d resuming\n", error);
922 return error;
923}
924
925
926
927
928
929int swsusp_check(void)
930{
931 int error;
932
933 hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device,
934 FMODE_READ, NULL);
935 if (!IS_ERR(hib_resume_bdev)) {
936 set_blocksize(hib_resume_bdev, PAGE_SIZE);
937 clear_page(swsusp_header);
938 error = hib_bio_read_page(swsusp_resume_block,
939 swsusp_header, NULL);
940 if (error)
941 goto put;
942
943 if (!memcmp(HIBERNATE_SIG, swsusp_header->sig, 10)) {
944 memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
945
946 error = hib_bio_write_page(swsusp_resume_block,
947 swsusp_header, NULL);
948 } else {
949 error = -EINVAL;
950 }
951
952put:
953 if (error)
954 blkdev_put(hib_resume_bdev, FMODE_READ);
955 else
956 pr_debug("PM: Image signature found, resuming\n");
957 } else {
958 error = PTR_ERR(hib_resume_bdev);
959 }
960
961 if (error)
962 pr_debug("PM: Image not found (code %d)\n", error);
963
964 return error;
965}
966
967
968
969
970
971void swsusp_close(fmode_t mode)
972{
973 if (IS_ERR(hib_resume_bdev)) {
974 pr_debug("PM: Image device not initialised\n");
975 return;
976 }
977
978 blkdev_put(hib_resume_bdev, mode);
979}
980
981static int swsusp_header_init(void)
982{
983 swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
984 if (!swsusp_header)
985 panic("Could not allocate memory for swsusp_header\n");
986 return 0;
987}
988
989core_initcall(swsusp_header_init);
990