Hibernation: Update messages

[linux-2.6-omap-h63xx.git] / kernel / power / swap.c

diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index b8b235cc19d1591077f7cda71175ec2c152ff808..a0abf9a463f95bc9948f3ccd10fecddf75401eb8 100644 (file)
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -28,13 +28,12 @@
 
 #include "power.h"
 
-extern char resume_file[];
-
 #define SWSUSP_SIG     "S1SUSPEND"
 
 struct swsusp_header {
-       char reserved[PAGE_SIZE - 20 - sizeof(sector_t)];
+       char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
        sector_t image;
+       unsigned int flags;     /* Flags to pass to the "boot" kernel */
        char    orig_sig[10];
        char    sig[10];
 } __attribute__((packed));
@@ -72,7 +71,8 @@ static int submit(int rw, pgoff_t page_off, struct page *page,
        bio->bi_end_io = end_swap_bio_read;
 
        if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
-               printk("swsusp: ERROR: adding page to bio at %ld\n", page_off);
+               printk(KERN_ERR "PM: Adding page to bio failed at %ld\n",
+                       page_off);
                bio_put(bio);
                return -EFAULT;
        }
@@ -138,7 +138,7 @@ static int wait_on_bio_chain(struct bio **bio_chain)
  * Saving part
  */
 
-static int mark_swapfiles(sector_t start)
+static int mark_swapfiles(sector_t start, unsigned int flags)
 {
        int error;
 
@@ -148,10 +148,11 @@ static int mark_swapfiles(sector_t start)
                memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
                memcpy(swsusp_header->sig,SWSUSP_SIG, 10);
                swsusp_header->image = start;
+               swsusp_header->flags = flags;
                error = bio_write_page(swsusp_resume_block,
                                        swsusp_header, NULL);
        } else {
-               printk(KERN_ERR "swsusp: Swap header not found!\n");
+               printk(KERN_ERR "PM: Swap header not found!\n");
                error = -ENODEV;
        }
        return error;
@@ -323,7 +324,8 @@ static int save_image(struct swap_map_handle *handle,
        struct timeval start;
        struct timeval stop;
 
-       printk("Saving image data pages (%u pages) ...     ", nr_to_write);
+       printk(KERN_INFO "PM: Saving image data pages (%u pages) ...     ",
+               nr_to_write);
        m = nr_to_write / 100;
        if (!m)
                m = 1;
@@ -363,12 +365,13 @@ static int enough_swap(unsigned int nr_pages)
 {
        unsigned int free_swap = count_swap_pages(root_swap, 1);
 
-       pr_debug("swsusp: free swap pages: %u\n", free_swap);
+       pr_debug("PM: Free swap pages: %u\n", free_swap);
        return free_swap > nr_pages + PAGES_FOR_IO;
 }
 
 /**
  *     swsusp_write - Write entire image and metadata.
+ *     @flags: flags to pass to the "boot" kernel in the image header
  *
  *     It is important _NOT_ to umount filesystems at this point. We want
  *     them synced (in case something goes wrong) but we DO not want to mark
@@ -376,7 +379,7 @@ static int enough_swap(unsigned int nr_pages)
  *     correctly, we'll mark system clean, anyway.)
  */
 
-int swsusp_write(void)
+int swsusp_write(unsigned int flags)
 {
        struct swap_map_handle handle;
        struct snapshot_handle snapshot;
@@ -385,7 +388,7 @@ int swsusp_write(void)
 
        error = swsusp_swap_check();
        if (error) {
-               printk(KERN_ERR "swsusp: Cannot find swap device, try "
+               printk(KERN_ERR "PM: Cannot find swap device, try "
                                "swapon -a.\n");
                return error;
        }
@@ -399,7 +402,7 @@ int swsusp_write(void)
        }
        header = (struct swsusp_info *)data_of(snapshot);
        if (!enough_swap(header->pages)) {
-               printk(KERN_ERR "swsusp: Not enough free swap\n");
+               printk(KERN_ERR "PM: Not enough free swap\n");
                error = -ENOSPC;
                goto out;
        }
@@ -414,8 +417,8 @@ int swsusp_write(void)
 
                if (!error) {
                        flush_swap_writer(&handle);
-                       printk("S");
-                       error = mark_swapfiles(start);
+                       printk(KERN_INFO "PM: S");
+                       error = mark_swapfiles(start, flags);
                        printk("|\n");
                }
        }
@@ -504,7 +507,8 @@ static int load_image(struct swap_map_handle *handle,
        int err2;
        unsigned nr_pages;
 
-       printk("Loading image data pages (%u pages) ...     ", nr_to_read);
+       printk(KERN_INFO "PM: Loading image data pages (%u pages) ...     ",
+               nr_to_read);
        m = nr_to_read / 100;
        if (!m)
                m = 1;
@@ -540,15 +544,22 @@ static int load_image(struct swap_map_handle *handle,
        return error;
 }
 
-int swsusp_read(void)
+/**
+ *     swsusp_read - read the hibernation image.
+ *     @flags_p: flags passed by the "frozen" kernel in the image header should
+ *               be written into this memeory location
+ */
+
+int swsusp_read(unsigned int *flags_p)
 {
        int error;
        struct swap_map_handle handle;
        struct snapshot_handle snapshot;
        struct swsusp_info *header;
 
+       *flags_p = swsusp_header->flags;
        if (IS_ERR(resume_bdev)) {
-               pr_debug("swsusp: block device not initialised\n");
+               pr_debug("PM: Image device not initialised\n");
                return PTR_ERR(resume_bdev);
        }
 
@@ -567,9 +578,9 @@ int swsusp_read(void)
        blkdev_put(resume_bdev);
 
        if (!error)
-               pr_debug("swsusp: Reading resume file was successful\n");
+               pr_debug("PM: Image successfully loaded\n");
        else
-               pr_debug("swsusp: Error %d resuming\n", error);
+               pr_debug("PM: Error %d resuming\n", error);
        return error;
 }
 
@@ -584,7 +595,7 @@ int swsusp_check(void)
        resume_bdev = open_by_devnum(swsusp_resume_device, FMODE_READ);
        if (!IS_ERR(resume_bdev)) {
                set_blocksize(resume_bdev, PAGE_SIZE);
-               memset(swsusp_header, 0, sizeof(PAGE_SIZE));
+               memset(swsusp_header, 0, PAGE_SIZE);
                error = bio_read_page(swsusp_resume_block,
                                        swsusp_header, NULL);
                if (error)
@@ -601,13 +612,13 @@ int swsusp_check(void)
                if (error)
                        blkdev_put(resume_bdev);
                else
-                       pr_debug("swsusp: Signature found, resuming\n");
+                       pr_debug("PM: Signature found, resuming\n");
        } else {
                error = PTR_ERR(resume_bdev);
        }
 
        if (error)
-               pr_debug("swsusp: Error %d check for resume file\n", error);
+               pr_debug("PM: Error %d checking image file\n", error);
 
        return error;
 }
@@ -619,7 +630,7 @@ int swsusp_check(void)
 void swsusp_close(void)
 {
        if (IS_ERR(resume_bdev)) {
-               pr_debug("swsusp: block device not initialised\n");
+               pr_debug("PM: Image device not initialised\n");
                return;
        }