PM: Separate suspend to RAM functionality from core
[linux-2.6.git] / kernel / power / swap.c
1 /*
2  * linux/kernel/power/swap.c
3  *
4  * This file provides functions for reading the suspend image from
5  * and writing it to a swap partition.
6  *
7  * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
8  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
9  *
10  * This file is released under the GPLv2.
11  *
12  */
13
14 #include <linux/module.h>
15 #include <linux/file.h>
16 #include <linux/utsname.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
28 #include "power.h"
29
30 #define SWSUSP_SIG      "S1SUSPEND"
31
32 struct swsusp_header {
33         char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
34         sector_t image;
35         unsigned int flags;     /* Flags to pass to the "boot" kernel */
36         char    orig_sig[10];
37         char    sig[10];
38 } __attribute__((packed));
39
40 static struct swsusp_header *swsusp_header;
41
42 /*
43  * General things
44  */
45
46 static unsigned short root_swap = 0xffff;
47 static struct block_device *resume_bdev;
48
49 /**
50  *      submit - submit BIO request.
51  *      @rw:    READ or WRITE.
52  *      @off    physical offset of page.
53  *      @page:  page we're reading or writing.
54  *      @bio_chain: list of pending biod (for async reading)
55  *
56  *      Straight from the textbook - allocate and initialize the bio.
57  *      If we're reading, make sure the page is marked as dirty.
58  *      Then submit it and, if @bio_chain == NULL, wait.
59  */
60 static int submit(int rw, pgoff_t page_off, struct page *page,
61                         struct bio **bio_chain)
62 {
63         const int bio_rw = rw | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
64         struct bio *bio;
65
66         bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
67         bio->bi_sector = page_off * (PAGE_SIZE >> 9);
68         bio->bi_bdev = resume_bdev;
69         bio->bi_end_io = end_swap_bio_read;
70
71         if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
72                 printk(KERN_ERR "PM: Adding page to bio failed at %ld\n",
73                         page_off);
74                 bio_put(bio);
75                 return -EFAULT;
76         }
77
78         lock_page(page);
79         bio_get(bio);
80
81         if (bio_chain == NULL) {
82                 submit_bio(bio_rw, bio);
83                 wait_on_page_locked(page);
84                 if (rw == READ)
85                         bio_set_pages_dirty(bio);
86                 bio_put(bio);
87         } else {
88                 if (rw == READ)
89                         get_page(page); /* These pages are freed later */
90                 bio->bi_private = *bio_chain;
91                 *bio_chain = bio;
92                 submit_bio(bio_rw, bio);
93         }
94         return 0;
95 }
96
97 static int bio_read_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
98 {
99         return submit(READ, page_off, virt_to_page(addr), bio_chain);
100 }
101
102 static int bio_write_page(pgoff_t page_off, void *addr, struct bio **bio_chain)
103 {
104         return submit(WRITE, page_off, virt_to_page(addr), bio_chain);
105 }
106
107 static int wait_on_bio_chain(struct bio **bio_chain)
108 {
109         struct bio *bio;
110         struct bio *next_bio;
111         int ret = 0;
112
113         if (bio_chain == NULL)
114                 return 0;
115
116         bio = *bio_chain;
117         if (bio == NULL)
118                 return 0;
119         while (bio) {
120                 struct page *page;
121
122                 next_bio = bio->bi_private;
123                 page = bio->bi_io_vec[0].bv_page;
124                 wait_on_page_locked(page);
125                 if (!PageUptodate(page) || PageError(page))
126                         ret = -EIO;
127                 put_page(page);
128                 bio_put(bio);
129                 bio = next_bio;
130         }
131         *bio_chain = NULL;
132         return ret;
133 }
134
135 /*
136  * Saving part
137  */
138
139 static int mark_swapfiles(sector_t start, unsigned int flags)
140 {
141         int error;
142
143         bio_read_page(swsusp_resume_block, swsusp_header, NULL);
144         if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
145             !memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
146                 memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
147                 memcpy(swsusp_header->sig,SWSUSP_SIG, 10);
148                 swsusp_header->image = start;
149                 swsusp_header->flags = flags;
150                 error = bio_write_page(swsusp_resume_block,
151                                         swsusp_header, NULL);
152         } else {
153                 printk(KERN_ERR "PM: Swap header not found!\n");
154                 error = -ENODEV;
155         }
156         return error;
157 }
158
159 /**
160  *      swsusp_swap_check - check if the resume device is a swap device
161  *      and get its index (if so)
162  */
163
164 static int swsusp_swap_check(void) /* This is called before saving image */
165 {
166         int res;
167
168         res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
169                         &resume_bdev);
170         if (res < 0)
171                 return res;
172
173         root_swap = res;
174         res = blkdev_get(resume_bdev, FMODE_WRITE);
175         if (res)
176                 return res;
177
178         res = set_blocksize(resume_bdev, PAGE_SIZE);
179         if (res < 0)
180                 blkdev_put(resume_bdev, FMODE_WRITE);
181
182         return res;
183 }
184
185 /**
186  *      write_page - Write one page to given swap location.
187  *      @buf:           Address we're writing.
188  *      @offset:        Offset of the swap page we're writing to.
189  *      @bio_chain:     Link the next write BIO here
190  */
191
192 static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
193 {
194         void *src;
195
196         if (!offset)
197                 return -ENOSPC;
198
199         if (bio_chain) {
200                 src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
201                 if (src) {
202                         memcpy(src, buf, PAGE_SIZE);
203                 } else {
204                         WARN_ON_ONCE(1);
205                         bio_chain = NULL;       /* Go synchronous */
206                         src = buf;
207                 }
208         } else {
209                 src = buf;
210         }
211         return bio_write_page(offset, src, bio_chain);
212 }
213
214 /*
215  *      The swap map is a data structure used for keeping track of each page
216  *      written to a swap partition.  It consists of many swap_map_page
217  *      structures that contain each an array of MAP_PAGE_SIZE swap entries.
218  *      These structures are stored on the swap and linked together with the
219  *      help of the .next_swap member.
220  *
221  *      The swap map is created during suspend.  The swap map pages are
222  *      allocated and populated one at a time, so we only need one memory
223  *      page to set up the entire structure.
224  *
225  *      During resume we also only need to use one swap_map_page structure
226  *      at a time.
227  */
228
229 #define MAP_PAGE_ENTRIES        (PAGE_SIZE / sizeof(sector_t) - 1)
230
231 struct swap_map_page {
232         sector_t entries[MAP_PAGE_ENTRIES];
233         sector_t next_swap;
234 };
235
236 /**
237  *      The swap_map_handle structure is used for handling swap in
238  *      a file-alike way
239  */
240
241 struct swap_map_handle {
242         struct swap_map_page *cur;
243         sector_t cur_swap;
244         unsigned int k;
245 };
246
247 static void release_swap_writer(struct swap_map_handle *handle)
248 {
249         if (handle->cur)
250                 free_page((unsigned long)handle->cur);
251         handle->cur = NULL;
252 }
253
254 static int get_swap_writer(struct swap_map_handle *handle)
255 {
256         handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
257         if (!handle->cur)
258                 return -ENOMEM;
259         handle->cur_swap = alloc_swapdev_block(root_swap);
260         if (!handle->cur_swap) {
261                 release_swap_writer(handle);
262                 return -ENOSPC;
263         }
264         handle->k = 0;
265         return 0;
266 }
267
268 static int swap_write_page(struct swap_map_handle *handle, void *buf,
269                                 struct bio **bio_chain)
270 {
271         int error = 0;
272         sector_t offset;
273
274         if (!handle->cur)
275                 return -EINVAL;
276         offset = alloc_swapdev_block(root_swap);
277         error = write_page(buf, offset, bio_chain);
278         if (error)
279                 return error;
280         handle->cur->entries[handle->k++] = offset;
281         if (handle->k >= MAP_PAGE_ENTRIES) {
282                 error = wait_on_bio_chain(bio_chain);
283                 if (error)
284                         goto out;
285                 offset = alloc_swapdev_block(root_swap);
286                 if (!offset)
287                         return -ENOSPC;
288                 handle->cur->next_swap = offset;
289                 error = write_page(handle->cur, handle->cur_swap, NULL);
290                 if (error)
291                         goto out;
292                 memset(handle->cur, 0, PAGE_SIZE);
293                 handle->cur_swap = offset;
294                 handle->k = 0;
295         }
296  out:
297         return error;
298 }
299
300 static int flush_swap_writer(struct swap_map_handle *handle)
301 {
302         if (handle->cur && handle->cur_swap)
303                 return write_page(handle->cur, handle->cur_swap, NULL);
304         else
305                 return -EINVAL;
306 }
307
308 /**
309  *      save_image - save the suspend image data
310  */
311
312 static int save_image(struct swap_map_handle *handle,
313                       struct snapshot_handle *snapshot,
314                       unsigned int nr_to_write)
315 {
316         unsigned int m;
317         int ret;
318         int error = 0;
319         int nr_pages;
320         int err2;
321         struct bio *bio;
322         struct timeval start;
323         struct timeval stop;
324
325         printk(KERN_INFO "PM: Saving image data pages (%u pages) ...     ",
326                 nr_to_write);
327         m = nr_to_write / 100;
328         if (!m)
329                 m = 1;
330         nr_pages = 0;
331         bio = NULL;
332         do_gettimeofday(&start);
333         do {
334                 ret = snapshot_read_next(snapshot, PAGE_SIZE);
335                 if (ret > 0) {
336                         error = swap_write_page(handle, data_of(*snapshot),
337                                                 &bio);
338                         if (error)
339                                 break;
340                         if (!(nr_pages % m))
341                                 printk("\b\b\b\b%3d%%", nr_pages / m);
342                         nr_pages++;
343                 }
344         } while (ret > 0);
345         err2 = wait_on_bio_chain(&bio);
346         do_gettimeofday(&stop);
347         if (!error)
348                 error = err2;
349         if (!error)
350                 printk("\b\b\b\bdone\n");
351         swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
352         return error;
353 }
354
355 /**
356  *      enough_swap - Make sure we have enough swap to save the image.
357  *
358  *      Returns TRUE or FALSE after checking the total amount of swap
359  *      space avaiable from the resume partition.
360  */
361
362 static int enough_swap(unsigned int nr_pages)
363 {
364         unsigned int free_swap = count_swap_pages(root_swap, 1);
365
366         pr_debug("PM: Free swap pages: %u\n", free_swap);
367         return free_swap > nr_pages + PAGES_FOR_IO;
368 }
369
370 /**
371  *      swsusp_write - Write entire image and metadata.
372  *      @flags: flags to pass to the "boot" kernel in the image header
373  *
374  *      It is important _NOT_ to umount filesystems at this point. We want
375  *      them synced (in case something goes wrong) but we DO not want to mark
376  *      filesystem clean: it is not. (And it does not matter, if we resume
377  *      correctly, we'll mark system clean, anyway.)
378  */
379
380 int swsusp_write(unsigned int flags)
381 {
382         struct swap_map_handle handle;
383         struct snapshot_handle snapshot;
384         struct swsusp_info *header;
385         int error;
386
387         error = swsusp_swap_check();
388         if (error) {
389                 printk(KERN_ERR "PM: Cannot find swap device, try "
390                                 "swapon -a.\n");
391                 return error;
392         }
393         memset(&snapshot, 0, sizeof(struct snapshot_handle));
394         error = snapshot_read_next(&snapshot, PAGE_SIZE);
395         if (error < PAGE_SIZE) {
396                 if (error >= 0)
397                         error = -EFAULT;
398
399                 goto out;
400         }
401         header = (struct swsusp_info *)data_of(snapshot);
402         if (!enough_swap(header->pages)) {
403                 printk(KERN_ERR "PM: Not enough free swap\n");
404                 error = -ENOSPC;
405                 goto out;
406         }
407         error = get_swap_writer(&handle);
408         if (!error) {
409                 sector_t start = handle.cur_swap;
410
411                 error = swap_write_page(&handle, header, NULL);
412                 if (!error)
413                         error = save_image(&handle, &snapshot,
414                                         header->pages - 1);
415
416                 if (!error) {
417                         flush_swap_writer(&handle);
418                         printk(KERN_INFO "PM: S");
419                         error = mark_swapfiles(start, flags);
420                         printk("|\n");
421                 }
422         }
423         if (error)
424                 free_all_swap_pages(root_swap);
425
426         release_swap_writer(&handle);
427  out:
428         swsusp_close(FMODE_WRITE);
429         return error;
430 }
431
432 /**
433  *      The following functions allow us to read data using a swap map
434  *      in a file-alike way
435  */
436
437 static void release_swap_reader(struct swap_map_handle *handle)
438 {
439         if (handle->cur)
440                 free_page((unsigned long)handle->cur);
441         handle->cur = NULL;
442 }
443
444 static int get_swap_reader(struct swap_map_handle *handle, sector_t start)
445 {
446         int error;
447
448         if (!start)
449                 return -EINVAL;
450
451         handle->cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
452         if (!handle->cur)
453                 return -ENOMEM;
454
455         error = bio_read_page(start, handle->cur, NULL);
456         if (error) {
457                 release_swap_reader(handle);
458                 return error;
459         }
460         handle->k = 0;
461         return 0;
462 }
463
464 static int swap_read_page(struct swap_map_handle *handle, void *buf,
465                                 struct bio **bio_chain)
466 {
467         sector_t offset;
468         int error;
469
470         if (!handle->cur)
471                 return -EINVAL;
472         offset = handle->cur->entries[handle->k];
473         if (!offset)
474                 return -EFAULT;
475         error = bio_read_page(offset, buf, bio_chain);
476         if (error)
477                 return error;
478         if (++handle->k >= MAP_PAGE_ENTRIES) {
479                 error = wait_on_bio_chain(bio_chain);
480                 handle->k = 0;
481                 offset = handle->cur->next_swap;
482                 if (!offset)
483                         release_swap_reader(handle);
484                 else if (!error)
485                         error = bio_read_page(offset, handle->cur, NULL);
486         }
487         return error;
488 }
489
490 /**
491  *      load_image - load the image using the swap map handle
492  *      @handle and the snapshot handle @snapshot
493  *      (assume there are @nr_pages pages to load)
494  */
495
496 static int load_image(struct swap_map_handle *handle,
497                       struct snapshot_handle *snapshot,
498                       unsigned int nr_to_read)
499 {
500         unsigned int m;
501         int error = 0;
502         struct timeval start;
503         struct timeval stop;
504         struct bio *bio;
505         int err2;
506         unsigned nr_pages;
507
508         printk(KERN_INFO "PM: Loading image data pages (%u pages) ...     ",
509                 nr_to_read);
510         m = nr_to_read / 100;
511         if (!m)
512                 m = 1;
513         nr_pages = 0;
514         bio = NULL;
515         do_gettimeofday(&start);
516         for ( ; ; ) {
517                 error = snapshot_write_next(snapshot, PAGE_SIZE);
518                 if (error <= 0)
519                         break;
520                 error = swap_read_page(handle, data_of(*snapshot), &bio);
521                 if (error)
522                         break;
523                 if (snapshot->sync_read)
524                         error = wait_on_bio_chain(&bio);
525                 if (error)
526                         break;
527                 if (!(nr_pages % m))
528                         printk("\b\b\b\b%3d%%", nr_pages / m);
529                 nr_pages++;
530         }
531         err2 = wait_on_bio_chain(&bio);
532         do_gettimeofday(&stop);
533         if (!error)
534                 error = err2;
535         if (!error) {
536                 printk("\b\b\b\bdone\n");
537                 snapshot_write_finalize(snapshot);
538                 if (!snapshot_image_loaded(snapshot))
539                         error = -ENODATA;
540         }
541         swsusp_show_speed(&start, &stop, nr_to_read, "Read");
542         return error;
543 }
544
545 /**
546  *      swsusp_read - read the hibernation image.
547  *      @flags_p: flags passed by the "frozen" kernel in the image header should
548  *                be written into this memeory location
549  */
550
551 int 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         blkdev_put(resume_bdev, FMODE_READ);
577
578         if (!error)
579                 pr_debug("PM: Image successfully loaded\n");
580         else
581                 pr_debug("PM: Error %d resuming\n", error);
582         return error;
583 }
584
585 /**
586  *      swsusp_check - Check for swsusp signature in the resume device
587  */
588
589 int swsusp_check(void)
590 {
591         int error;
592
593         resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
594         if (!IS_ERR(resume_bdev)) {
595                 set_blocksize(resume_bdev, PAGE_SIZE);
596                 memset(swsusp_header, 0, PAGE_SIZE);
597                 error = bio_read_page(swsusp_resume_block,
598                                         swsusp_header, NULL);
599                 if (error)
600                         return error;
601
602                 if (!memcmp(SWSUSP_SIG, swsusp_header->sig, 10)) {
603                         memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
604                         /* Reset swap signature now */
605                         error = bio_write_page(swsusp_resume_block,
606                                                 swsusp_header, NULL);
607                 } else {
608                         return -EINVAL;
609                 }
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  *      swsusp_close - close swap device.
626  */
627
628 void 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
638 static 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
646 core_initcall(swsusp_header_init);