Add suspend_console() and resume_console() to the suspend-to-disk code paths
so that the users of netconsole can use swsusp with it.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
 #include <linux/fs.h>
 #include <linux/mount.h>
 #include <linux/pm.h>
+#include <linux/console.h>
 #include <linux/cpu.h>
 
 #include "power.h"
        if (error)
                return error;
 
+       suspend_console();
        error = device_suspend(PMSG_FREEZE);
        if (error) {
+               resume_console();
                printk("Some devices failed to suspend\n");
                unprepare_processes();
                return error;
 
        if (in_suspend) {
                device_resume();
+               resume_console();
                pr_debug("PM: writing image.\n");
                error = swsusp_write();
                if (!error)
        swsusp_free();
  Done:
        device_resume();
+       resume_console();
        unprepare_processes();
        return error;
 }
 
        pr_debug("PM: Preparing devices for restore.\n");
 
+       suspend_console();
        if ((error = device_suspend(PMSG_PRETHAW))) {
+               resume_console();
                printk("Some devices failed to suspend\n");
                swsusp_free();
                goto Thaw;
        swsusp_resume();
        pr_debug("PM: Restore failed, recovering.n");
        device_resume();
+       resume_console();
  Thaw:
        unprepare_processes();
  Done:
 
 #include <linux/swapops.h>
 #include <linux/pm.h>
 #include <linux/fs.h>
+#include <linux/console.h>
 #include <linux/cpu.h>
 
 #include <asm/uaccess.h>
                /* Free memory before shutting down devices. */
                error = swsusp_shrink_memory();
                if (!error) {
+                       suspend_console();
                        error = device_suspend(PMSG_FREEZE);
                        if (!error) {
                                in_suspend = 1;
                                error = swsusp_suspend();
                                device_resume();
                        }
+                       resume_console();
                }
                up(&pm_sem);
                if (!error)
                snapshot_free_unused_memory(&data->handle);
                down(&pm_sem);
                pm_prepare_console();
+               suspend_console();
                error = device_suspend(PMSG_PRETHAW);
                if (!error) {
                        error = swsusp_resume();
                        device_resume();
                }
+               resume_console();
                pm_restore_console();
                up(&pm_sem);
                break;
                }
 
                /* Put devices to sleep */
+               suspend_console();
                error = device_suspend(PMSG_SUSPEND);
                if (error) {
                        printk(KERN_ERR "Failed to suspend some devices.\n");
                        /* Wake up devices */
                        device_resume();
                }
-
+               resume_console();
                if (pm_ops->finish)
                        pm_ops->finish(PM_SUSPEND_MEM);