~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/power/hibernate.c

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * kernel/power/hibernate.c - Hibernation (a.k.a suspend-to-disk) support.
  3  *
  4  * Copyright (c) 2003 Patrick Mochel
  5  * Copyright (c) 2003 Open Source Development Lab
  6  * Copyright (c) 2004 Pavel Machek <pavel@ucw.cz>
  7  * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
  8  * Copyright (C) 2012 Bojan Smojver <bojan@rexursive.com>
  9  *
 10  * This file is released under the GPLv2.
 11  */
 12 
 13 #include <linux/export.h>
 14 #include <linux/suspend.h>
 15 #include <linux/syscalls.h>
 16 #include <linux/reboot.h>
 17 #include <linux/string.h>
 18 #include <linux/device.h>
 19 #include <linux/async.h>
 20 #include <linux/delay.h>
 21 #include <linux/fs.h>
 22 #include <linux/mount.h>
 23 #include <linux/pm.h>
 24 #include <linux/console.h>
 25 #include <linux/cpu.h>
 26 #include <linux/freezer.h>
 27 #include <linux/gfp.h>
 28 #include <linux/syscore_ops.h>
 29 #include <linux/ctype.h>
 30 #include <linux/genhd.h>
 31 #include <linux/ktime.h>
 32 #include <trace/events/power.h>
 33 
 34 #include "power.h"
 35 
 36 
 37 static int nocompress;
 38 static int noresume;
 39 static int nohibernate;
 40 static int resume_wait;
 41 static unsigned int resume_delay;
 42 static char resume_file[256] = CONFIG_PM_STD_PARTITION;
 43 dev_t swsusp_resume_device;
 44 sector_t swsusp_resume_block;
 45 __visible int in_suspend __nosavedata;
 46 
 47 enum {
 48         HIBERNATION_INVALID,
 49         HIBERNATION_PLATFORM,
 50         HIBERNATION_SHUTDOWN,
 51         HIBERNATION_REBOOT,
 52 #ifdef CONFIG_SUSPEND
 53         HIBERNATION_SUSPEND,
 54 #endif
 55         /* keep last */
 56         __HIBERNATION_AFTER_LAST
 57 };
 58 #define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
 59 #define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
 60 
 61 static int hibernation_mode = HIBERNATION_SHUTDOWN;
 62 
 63 bool freezer_test_done;
 64 
 65 static const struct platform_hibernation_ops *hibernation_ops;
 66 
 67 bool hibernation_available(void)
 68 {
 69         return (nohibernate == 0);
 70 }
 71 
 72 /**
 73  * hibernation_set_ops - Set the global hibernate operations.
 74  * @ops: Hibernation operations to use in subsequent hibernation transitions.
 75  */
 76 void hibernation_set_ops(const struct platform_hibernation_ops *ops)
 77 {
 78         if (ops && !(ops->begin && ops->end &&  ops->pre_snapshot
 79             && ops->prepare && ops->finish && ops->enter && ops->pre_restore
 80             && ops->restore_cleanup && ops->leave)) {
 81                 WARN_ON(1);
 82                 return;
 83         }
 84         lock_system_sleep();
 85         hibernation_ops = ops;
 86         if (ops)
 87                 hibernation_mode = HIBERNATION_PLATFORM;
 88         else if (hibernation_mode == HIBERNATION_PLATFORM)
 89                 hibernation_mode = HIBERNATION_SHUTDOWN;
 90 
 91         unlock_system_sleep();
 92 }
 93 EXPORT_SYMBOL_GPL(hibernation_set_ops);
 94 
 95 static bool entering_platform_hibernation;
 96 
 97 bool system_entering_hibernation(void)
 98 {
 99         return entering_platform_hibernation;
100 }
101 EXPORT_SYMBOL(system_entering_hibernation);
102 
103 #ifdef CONFIG_PM_DEBUG
104 static void hibernation_debug_sleep(void)
105 {
106         printk(KERN_INFO "hibernation debug: Waiting for 5 seconds.\n");
107         mdelay(5000);
108 }
109 
110 static int hibernation_test(int level)
111 {
112         if (pm_test_level == level) {
113                 hibernation_debug_sleep();
114                 return 1;
115         }
116         return 0;
117 }
118 #else /* !CONFIG_PM_DEBUG */
119 static int hibernation_test(int level) { return 0; }
120 #endif /* !CONFIG_PM_DEBUG */
121 
122 /**
123  * platform_begin - Call platform to start hibernation.
124  * @platform_mode: Whether or not to use the platform driver.
125  */
126 static int platform_begin(int platform_mode)
127 {
128         return (platform_mode && hibernation_ops) ?
129                 hibernation_ops->begin() : 0;
130 }
131 
132 /**
133  * platform_end - Call platform to finish transition to the working state.
134  * @platform_mode: Whether or not to use the platform driver.
135  */
136 static void platform_end(int platform_mode)
137 {
138         if (platform_mode && hibernation_ops)
139                 hibernation_ops->end();
140 }
141 
142 /**
143  * platform_pre_snapshot - Call platform to prepare the machine for hibernation.
144  * @platform_mode: Whether or not to use the platform driver.
145  *
146  * Use the platform driver to prepare the system for creating a hibernate image,
147  * if so configured, and return an error code if that fails.
148  */
149 
150 static int platform_pre_snapshot(int platform_mode)
151 {
152         return (platform_mode && hibernation_ops) ?
153                 hibernation_ops->pre_snapshot() : 0;
154 }
155 
156 /**
157  * platform_leave - Call platform to prepare a transition to the working state.
158  * @platform_mode: Whether or not to use the platform driver.
159  *
160  * Use the platform driver prepare to prepare the machine for switching to the
161  * normal mode of operation.
162  *
163  * This routine is called on one CPU with interrupts disabled.
164  */
165 static void platform_leave(int platform_mode)
166 {
167         if (platform_mode && hibernation_ops)
168                 hibernation_ops->leave();
169 }
170 
171 /**
172  * platform_finish - Call platform to switch the system to the working state.
173  * @platform_mode: Whether or not to use the platform driver.
174  *
175  * Use the platform driver to switch the machine to the normal mode of
176  * operation.
177  *
178  * This routine must be called after platform_prepare().
179  */
180 static void platform_finish(int platform_mode)
181 {
182         if (platform_mode && hibernation_ops)
183                 hibernation_ops->finish();
184 }
185 
186 /**
187  * platform_pre_restore - Prepare for hibernate image restoration.
188  * @platform_mode: Whether or not to use the platform driver.
189  *
190  * Use the platform driver to prepare the system for resume from a hibernation
191  * image.
192  *
193  * If the restore fails after this function has been called,
194  * platform_restore_cleanup() must be called.
195  */
196 static int platform_pre_restore(int platform_mode)
197 {
198         return (platform_mode && hibernation_ops) ?
199                 hibernation_ops->pre_restore() : 0;
200 }
201 
202 /**
203  * platform_restore_cleanup - Switch to the working state after failing restore.
204  * @platform_mode: Whether or not to use the platform driver.
205  *
206  * Use the platform driver to switch the system to the normal mode of operation
207  * after a failing restore.
208  *
209  * If platform_pre_restore() has been called before the failing restore, this
210  * function must be called too, regardless of the result of
211  * platform_pre_restore().
212  */
213 static void platform_restore_cleanup(int platform_mode)
214 {
215         if (platform_mode && hibernation_ops)
216                 hibernation_ops->restore_cleanup();
217 }
218 
219 /**
220  * platform_recover - Recover from a failure to suspend devices.
221  * @platform_mode: Whether or not to use the platform driver.
222  */
223 static void platform_recover(int platform_mode)
224 {
225         if (platform_mode && hibernation_ops && hibernation_ops->recover)
226                 hibernation_ops->recover();
227 }
228 
229 /**
230  * swsusp_show_speed - Print time elapsed between two events during hibernation.
231  * @start: Starting event.
232  * @stop: Final event.
233  * @nr_pages: Number of memory pages processed between @start and @stop.
234  * @msg: Additional diagnostic message to print.
235  */
236 void swsusp_show_speed(ktime_t start, ktime_t stop,
237                       unsigned nr_pages, char *msg)
238 {
239         ktime_t diff;
240         u64 elapsed_centisecs64;
241         unsigned int centisecs;
242         unsigned int k;
243         unsigned int kps;
244 
245         diff = ktime_sub(stop, start);
246         elapsed_centisecs64 = ktime_divns(diff, 10*NSEC_PER_MSEC);
247         centisecs = elapsed_centisecs64;
248         if (centisecs == 0)
249                 centisecs = 1;  /* avoid div-by-zero */
250         k = nr_pages * (PAGE_SIZE / 1024);
251         kps = (k * 100) / centisecs;
252         printk(KERN_INFO "PM: %s %u kbytes in %u.%02u seconds (%u.%02u MB/s)\n",
253                         msg, k,
254                         centisecs / 100, centisecs % 100,
255                         kps / 1000, (kps % 1000) / 10);
256 }
257 
258 /**
259  * create_image - Create a hibernation image.
260  * @platform_mode: Whether or not to use the platform driver.
261  *
262  * Execute device drivers' "late" and "noirq" freeze callbacks, create a
263  * hibernation image and run the drivers' "noirq" and "early" thaw callbacks.
264  *
265  * Control reappears in this routine after the subsequent restore.
266  */
267 static int create_image(int platform_mode)
268 {
269         int error;
270 
271         error = dpm_suspend_end(PMSG_FREEZE);
272         if (error) {
273                 printk(KERN_ERR "PM: Some devices failed to power down, "
274                         "aborting hibernation\n");
275                 return error;
276         }
277 
278         error = platform_pre_snapshot(platform_mode);
279         if (error || hibernation_test(TEST_PLATFORM))
280                 goto Platform_finish;
281 
282         error = disable_nonboot_cpus();
283         if (error || hibernation_test(TEST_CPUS))
284                 goto Enable_cpus;
285 
286         local_irq_disable();
287 
288         error = syscore_suspend();
289         if (error) {
290                 printk(KERN_ERR "PM: Some system devices failed to power down, "
291                         "aborting hibernation\n");
292                 goto Enable_irqs;
293         }
294 
295         if (hibernation_test(TEST_CORE) || pm_wakeup_pending())
296                 goto Power_up;
297 
298         in_suspend = 1;
299         save_processor_state();
300         trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true);
301         error = swsusp_arch_suspend();
302         trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false);
303         if (error)
304                 printk(KERN_ERR "PM: Error %d creating hibernation image\n",
305                         error);
306         /* Restore control flow magically appears here */
307         restore_processor_state();
308         if (!in_suspend)
309                 events_check_enabled = false;
310 
311         platform_leave(platform_mode);
312 
313  Power_up:
314         syscore_resume();
315 
316  Enable_irqs:
317         local_irq_enable();
318 
319  Enable_cpus:
320         enable_nonboot_cpus();
321 
322  Platform_finish:
323         platform_finish(platform_mode);
324 
325         dpm_resume_start(in_suspend ?
326                 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
327 
328         return error;
329 }
330 
331 /**
332  * hibernation_snapshot - Quiesce devices and create a hibernation image.
333  * @platform_mode: If set, use platform driver to prepare for the transition.
334  *
335  * This routine must be called with pm_mutex held.
336  */
337 int hibernation_snapshot(int platform_mode)
338 {
339         pm_message_t msg;
340         int error;
341 
342         error = platform_begin(platform_mode);
343         if (error)
344                 goto Close;
345 
346         /* Preallocate image memory before shutting down devices. */
347         error = hibernate_preallocate_memory();
348         if (error)
349                 goto Close;
350 
351         error = freeze_kernel_threads();
352         if (error)
353                 goto Cleanup;
354 
355         if (hibernation_test(TEST_FREEZER)) {
356 
357                 /*
358                  * Indicate to the caller that we are returning due to a
359                  * successful freezer test.
360                  */
361                 freezer_test_done = true;
362                 goto Thaw;
363         }
364 
365         error = dpm_prepare(PMSG_FREEZE);
366         if (error) {
367                 dpm_complete(PMSG_RECOVER);
368                 goto Thaw;
369         }
370 
371         suspend_console();
372         pm_restrict_gfp_mask();
373 
374         error = dpm_suspend(PMSG_FREEZE);
375 
376         if (error || hibernation_test(TEST_DEVICES))
377                 platform_recover(platform_mode);
378         else
379                 error = create_image(platform_mode);
380 
381         /*
382          * In the case that we call create_image() above, the control
383          * returns here (1) after the image has been created or the
384          * image creation has failed and (2) after a successful restore.
385          */
386 
387         /* We may need to release the preallocated image pages here. */
388         if (error || !in_suspend)
389                 swsusp_free();
390 
391         msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
392         dpm_resume(msg);
393 
394         if (error || !in_suspend)
395                 pm_restore_gfp_mask();
396 
397         resume_console();
398         dpm_complete(msg);
399 
400  Close:
401         platform_end(platform_mode);
402         return error;
403 
404  Thaw:
405         thaw_kernel_threads();
406  Cleanup:
407         swsusp_free();
408         goto Close;
409 }
410 
411 /**
412  * resume_target_kernel - Restore system state from a hibernation image.
413  * @platform_mode: Whether or not to use the platform driver.
414  *
415  * Execute device drivers' "noirq" and "late" freeze callbacks, restore the
416  * contents of highmem that have not been restored yet from the image and run
417  * the low-level code that will restore the remaining contents of memory and
418  * switch to the just restored target kernel.
419  */
420 static int resume_target_kernel(bool platform_mode)
421 {
422         int error;
423 
424         error = dpm_suspend_end(PMSG_QUIESCE);
425         if (error) {
426                 printk(KERN_ERR "PM: Some devices failed to power down, "
427                         "aborting resume\n");
428                 return error;
429         }
430 
431         error = platform_pre_restore(platform_mode);
432         if (error)
433                 goto Cleanup;
434 
435         error = disable_nonboot_cpus();
436         if (error)
437                 goto Enable_cpus;
438 
439         local_irq_disable();
440 
441         error = syscore_suspend();
442         if (error)
443                 goto Enable_irqs;
444 
445         save_processor_state();
446         error = restore_highmem();
447         if (!error) {
448                 error = swsusp_arch_resume();
449                 /*
450                  * The code below is only ever reached in case of a failure.
451                  * Otherwise, execution continues at the place where
452                  * swsusp_arch_suspend() was called.
453                  */
454                 BUG_ON(!error);
455                 /*
456                  * This call to restore_highmem() reverts the changes made by
457                  * the previous one.
458                  */
459                 restore_highmem();
460         }
461         /*
462          * The only reason why swsusp_arch_resume() can fail is memory being
463          * very tight, so we have to free it as soon as we can to avoid
464          * subsequent failures.
465          */
466         swsusp_free();
467         restore_processor_state();
468         touch_softlockup_watchdog();
469 
470         syscore_resume();
471 
472  Enable_irqs:
473         local_irq_enable();
474 
475  Enable_cpus:
476         enable_nonboot_cpus();
477 
478  Cleanup:
479         platform_restore_cleanup(platform_mode);
480 
481         dpm_resume_start(PMSG_RECOVER);
482 
483         return error;
484 }
485 
486 /**
487  * hibernation_restore - Quiesce devices and restore from a hibernation image.
488  * @platform_mode: If set, use platform driver to prepare for the transition.
489  *
490  * This routine must be called with pm_mutex held.  If it is successful, control
491  * reappears in the restored target kernel in hibernation_snapshot().
492  */
493 int hibernation_restore(int platform_mode)
494 {
495         int error;
496 
497         pm_prepare_console();
498         suspend_console();
499         pm_restrict_gfp_mask();
500         error = dpm_suspend_start(PMSG_QUIESCE);
501         if (!error) {
502                 error = resume_target_kernel(platform_mode);
503                 /*
504                  * The above should either succeed and jump to the new kernel,
505                  * or return with an error. Otherwise things are just
506                  * undefined, so let's be paranoid.
507                  */
508                 BUG_ON(!error);
509         }
510         dpm_resume_end(PMSG_RECOVER);
511         pm_restore_gfp_mask();
512         resume_console();
513         pm_restore_console();
514         return error;
515 }
516 
517 /**
518  * hibernation_platform_enter - Power off the system using the platform driver.
519  */
520 int hibernation_platform_enter(void)
521 {
522         int error;
523 
524         if (!hibernation_ops)
525                 return -ENOSYS;
526 
527         /*
528          * We have cancelled the power transition by running
529          * hibernation_ops->finish() before saving the image, so we should let
530          * the firmware know that we're going to enter the sleep state after all
531          */
532         error = hibernation_ops->begin();
533         if (error)
534                 goto Close;
535 
536         entering_platform_hibernation = true;
537         suspend_console();
538         error = dpm_suspend_start(PMSG_HIBERNATE);
539         if (error) {
540                 if (hibernation_ops->recover)
541                         hibernation_ops->recover();
542                 goto Resume_devices;
543         }
544 
545         error = dpm_suspend_end(PMSG_HIBERNATE);
546         if (error)
547                 goto Resume_devices;
548 
549         error = hibernation_ops->prepare();
550         if (error)
551                 goto Platform_finish;
552 
553         error = disable_nonboot_cpus();
554         if (error)
555                 goto Platform_finish;
556 
557         local_irq_disable();
558         syscore_suspend();
559         if (pm_wakeup_pending()) {
560                 error = -EAGAIN;
561                 goto Power_up;
562         }
563 
564         hibernation_ops->enter();
565         /* We should never get here */
566         while (1);
567 
568  Power_up:
569         syscore_resume();
570         local_irq_enable();
571         enable_nonboot_cpus();
572 
573  Platform_finish:
574         hibernation_ops->finish();
575 
576         dpm_resume_start(PMSG_RESTORE);
577 
578  Resume_devices:
579         entering_platform_hibernation = false;
580         dpm_resume_end(PMSG_RESTORE);
581         resume_console();
582 
583  Close:
584         hibernation_ops->end();
585 
586         return error;
587 }
588 
589 /**
590  * power_down - Shut the machine down for hibernation.
591  *
592  * Use the platform driver, if configured, to put the system into the sleep
593  * state corresponding to hibernation, or try to power it off or reboot,
594  * depending on the value of hibernation_mode.
595  */
596 static void power_down(void)
597 {
598 #ifdef CONFIG_SUSPEND
599         int error;
600 #endif
601 
602         switch (hibernation_mode) {
603         case HIBERNATION_REBOOT:
604                 kernel_restart(NULL);
605                 break;
606         case HIBERNATION_PLATFORM:
607                 hibernation_platform_enter();
608         case HIBERNATION_SHUTDOWN:
609                 if (pm_power_off)
610                         kernel_power_off();
611                 break;
612 #ifdef CONFIG_SUSPEND
613         case HIBERNATION_SUSPEND:
614                 error = suspend_devices_and_enter(PM_SUSPEND_MEM);
615                 if (error) {
616                         if (hibernation_ops)
617                                 hibernation_mode = HIBERNATION_PLATFORM;
618                         else
619                                 hibernation_mode = HIBERNATION_SHUTDOWN;
620                         power_down();
621                 }
622                 /*
623                  * Restore swap signature.
624                  */
625                 error = swsusp_unmark();
626                 if (error)
627                         printk(KERN_ERR "PM: Swap will be unusable! "
628                                         "Try swapon -a.\n");
629                 return;
630 #endif
631         }
632         kernel_halt();
633         /*
634          * Valid image is on the disk, if we continue we risk serious data
635          * corruption after resume.
636          */
637         printk(KERN_CRIT "PM: Please power down manually\n");
638         while (1)
639                 cpu_relax();
640 }
641 
642 /**
643  * hibernate - Carry out system hibernation, including saving the image.
644  */
645 int hibernate(void)
646 {
647         int error;
648 
649         if (!hibernation_available()) {
650                 pr_debug("PM: Hibernation not available.\n");
651                 return -EPERM;
652         }
653 
654         lock_system_sleep();
655         /* The snapshot device should not be opened while we're running */
656         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
657                 error = -EBUSY;
658                 goto Unlock;
659         }
660 
661         pm_prepare_console();
662         error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
663         if (error)
664                 goto Exit;
665 
666         printk(KERN_INFO "PM: Syncing filesystems ... ");
667         sys_sync();
668         printk("done.\n");
669 
670         error = freeze_processes();
671         if (error)
672                 goto Exit;
673 
674         lock_device_hotplug();
675         /* Allocate memory management structures */
676         error = create_basic_memory_bitmaps();
677         if (error)
678                 goto Thaw;
679 
680         error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
681         if (error || freezer_test_done)
682                 goto Free_bitmaps;
683 
684         if (in_suspend) {
685                 unsigned int flags = 0;
686 
687                 if (hibernation_mode == HIBERNATION_PLATFORM)
688                         flags |= SF_PLATFORM_MODE;
689                 if (nocompress)
690                         flags |= SF_NOCOMPRESS_MODE;
691                 else
692                         flags |= SF_CRC32_MODE;
693 
694                 pr_debug("PM: writing image.\n");
695                 error = swsusp_write(flags);
696                 swsusp_free();
697                 if (!error)
698                         power_down();
699                 in_suspend = 0;
700                 pm_restore_gfp_mask();
701         } else {
702                 pr_debug("PM: Image restored successfully.\n");
703         }
704 
705  Free_bitmaps:
706         free_basic_memory_bitmaps();
707  Thaw:
708         unlock_device_hotplug();
709         thaw_processes();
710 
711         /* Don't bother checking whether freezer_test_done is true */
712         freezer_test_done = false;
713  Exit:
714         pm_notifier_call_chain(PM_POST_HIBERNATION);
715         pm_restore_console();
716         atomic_inc(&snapshot_device_available);
717  Unlock:
718         unlock_system_sleep();
719         return error;
720 }
721 
722 
723 /**
724  * software_resume - Resume from a saved hibernation image.
725  *
726  * This routine is called as a late initcall, when all devices have been
727  * discovered and initialized already.
728  *
729  * The image reading code is called to see if there is a hibernation image
730  * available for reading.  If that is the case, devices are quiesced and the
731  * contents of memory is restored from the saved image.
732  *
733  * If this is successful, control reappears in the restored target kernel in
734  * hibernation_snaphot() which returns to hibernate().  Otherwise, the routine
735  * attempts to recover gracefully and make the kernel return to the normal mode
736  * of operation.
737  */
738 static int software_resume(void)
739 {
740         int error;
741         unsigned int flags;
742 
743         /*
744          * If the user said "noresume".. bail out early.
745          */
746         if (noresume || !hibernation_available())
747                 return 0;
748 
749         /*
750          * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
751          * is configured into the kernel. Since the regular hibernate
752          * trigger path is via sysfs which takes a buffer mutex before
753          * calling hibernate functions (which take pm_mutex) this can
754          * cause lockdep to complain about a possible ABBA deadlock
755          * which cannot happen since we're in the boot code here and
756          * sysfs can't be invoked yet. Therefore, we use a subclass
757          * here to avoid lockdep complaining.
758          */
759         mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
760 
761         if (swsusp_resume_device)
762                 goto Check_image;
763 
764         if (!strlen(resume_file)) {
765                 error = -ENOENT;
766                 goto Unlock;
767         }
768 
769         pr_debug("PM: Checking hibernation image partition %s\n", resume_file);
770 
771         if (resume_delay) {
772                 printk(KERN_INFO "Waiting %dsec before reading resume device...\n",
773                         resume_delay);
774                 ssleep(resume_delay);
775         }
776 
777         /* Check if the device is there */
778         swsusp_resume_device = name_to_dev_t(resume_file);
779 
780         /*
781          * name_to_dev_t is ineffective to verify parition if resume_file is in
782          * integer format. (e.g. major:minor)
783          */
784         if (isdigit(resume_file[0]) && resume_wait) {
785                 int partno;
786                 while (!get_gendisk(swsusp_resume_device, &partno))
787                         msleep(10);
788         }
789 
790         if (!swsusp_resume_device) {
791                 /*
792                  * Some device discovery might still be in progress; we need
793                  * to wait for this to finish.
794                  */
795                 wait_for_device_probe();
796 
797                 if (resume_wait) {
798                         while ((swsusp_resume_device = name_to_dev_t(resume_file)) == 0)
799                                 msleep(10);
800                         async_synchronize_full();
801                 }
802 
803                 swsusp_resume_device = name_to_dev_t(resume_file);
804                 if (!swsusp_resume_device) {
805                         error = -ENODEV;
806                         goto Unlock;
807                 }
808         }
809 
810  Check_image:
811         pr_debug("PM: Hibernation image partition %d:%d present\n",
812                 MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
813 
814         pr_debug("PM: Looking for hibernation image.\n");
815         error = swsusp_check();
816         if (error)
817                 goto Unlock;
818 
819         /* The snapshot device should not be opened while we're running */
820         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
821                 error = -EBUSY;
822                 swsusp_close(FMODE_READ);
823                 goto Unlock;
824         }
825 
826         pm_prepare_console();
827         error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
828         if (error)
829                 goto Close_Finish;
830 
831         pr_debug("PM: Preparing processes for restore.\n");
832         error = freeze_processes();
833         if (error)
834                 goto Close_Finish;
835 
836         pr_debug("PM: Loading hibernation image.\n");
837 
838         lock_device_hotplug();
839         error = create_basic_memory_bitmaps();
840         if (error)
841                 goto Thaw;
842 
843         error = swsusp_read(&flags);
844         swsusp_close(FMODE_READ);
845         if (!error)
846                 hibernation_restore(flags & SF_PLATFORM_MODE);
847 
848         printk(KERN_ERR "PM: Failed to load hibernation image, recovering.\n");
849         swsusp_free();
850         free_basic_memory_bitmaps();
851  Thaw:
852         unlock_device_hotplug();
853         thaw_processes();
854  Finish:
855         pm_notifier_call_chain(PM_POST_RESTORE);
856         pm_restore_console();
857         atomic_inc(&snapshot_device_available);
858         /* For success case, the suspend path will release the lock */
859  Unlock:
860         mutex_unlock(&pm_mutex);
861         pr_debug("PM: Hibernation image not present or could not be loaded.\n");
862         return error;
863  Close_Finish:
864         swsusp_close(FMODE_READ);
865         goto Finish;
866 }
867 
868 late_initcall_sync(software_resume);
869 
870 
871 static const char * const hibernation_modes[] = {
872         [HIBERNATION_PLATFORM]  = "platform",
873         [HIBERNATION_SHUTDOWN]  = "shutdown",
874         [HIBERNATION_REBOOT]    = "reboot",
875 #ifdef CONFIG_SUSPEND
876         [HIBERNATION_SUSPEND]   = "suspend",
877 #endif
878 };
879 
880 /*
881  * /sys/power/disk - Control hibernation mode.
882  *
883  * Hibernation can be handled in several ways.  There are a few different ways
884  * to put the system into the sleep state: using the platform driver (e.g. ACPI
885  * or other hibernation_ops), powering it off or rebooting it (for testing
886  * mostly).
887  *
888  * The sysfs file /sys/power/disk provides an interface for selecting the
889  * hibernation mode to use.  Reading from this file causes the available modes
890  * to be printed.  There are 3 modes that can be supported:
891  *
892  *      'platform'
893  *      'shutdown'
894  *      'reboot'
895  *
896  * If a platform hibernation driver is in use, 'platform' will be supported
897  * and will be used by default.  Otherwise, 'shutdown' will be used by default.
898  * The selected option (i.e. the one corresponding to the current value of
899  * hibernation_mode) is enclosed by a square bracket.
900  *
901  * To select a given hibernation mode it is necessary to write the mode's
902  * string representation (as returned by reading from /sys/power/disk) back
903  * into /sys/power/disk.
904  */
905 
906 static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
907                          char *buf)
908 {
909         int i;
910         char *start = buf;
911 
912         if (!hibernation_available())
913                 return sprintf(buf, "[disabled]\n");
914 
915         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
916                 if (!hibernation_modes[i])
917                         continue;
918                 switch (i) {
919                 case HIBERNATION_SHUTDOWN:
920                 case HIBERNATION_REBOOT:
921 #ifdef CONFIG_SUSPEND
922                 case HIBERNATION_SUSPEND:
923 #endif
924                         break;
925                 case HIBERNATION_PLATFORM:
926                         if (hibernation_ops)
927                                 break;
928                         /* not a valid mode, continue with loop */
929                         continue;
930                 }
931                 if (i == hibernation_mode)
932                         buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
933                 else
934                         buf += sprintf(buf, "%s ", hibernation_modes[i]);
935         }
936         buf += sprintf(buf, "\n");
937         return buf-start;
938 }
939 
940 static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
941                           const char *buf, size_t n)
942 {
943         int error = 0;
944         int i;
945         int len;
946         char *p;
947         int mode = HIBERNATION_INVALID;
948 
949         if (!hibernation_available())
950                 return -EPERM;
951 
952         p = memchr(buf, '\n', n);
953         len = p ? p - buf : n;
954 
955         lock_system_sleep();
956         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
957                 if (len == strlen(hibernation_modes[i])
958                     && !strncmp(buf, hibernation_modes[i], len)) {
959                         mode = i;
960                         break;
961                 }
962         }
963         if (mode != HIBERNATION_INVALID) {
964                 switch (mode) {
965                 case HIBERNATION_SHUTDOWN:
966                 case HIBERNATION_REBOOT:
967 #ifdef CONFIG_SUSPEND
968                 case HIBERNATION_SUSPEND:
969 #endif
970                         hibernation_mode = mode;
971                         break;
972                 case HIBERNATION_PLATFORM:
973                         if (hibernation_ops)
974                                 hibernation_mode = mode;
975                         else
976                                 error = -EINVAL;
977                 }
978         } else
979                 error = -EINVAL;
980 
981         if (!error)
982                 pr_debug("PM: Hibernation mode set to '%s'\n",
983                          hibernation_modes[mode]);
984         unlock_system_sleep();
985         return error ? error : n;
986 }
987 
988 power_attr(disk);
989 
990 static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
991                            char *buf)
992 {
993         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
994                        MINOR(swsusp_resume_device));
995 }
996 
997 static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
998                             const char *buf, size_t n)
999 {
1000         dev_t res;
1001         int len = n;
1002         char *name;
1003 
1004         if (len && buf[len-1] == '\n')
1005                 len--;
1006         name = kstrndup(buf, len, GFP_KERNEL);
1007         if (!name)
1008                 return -ENOMEM;
1009 
1010         res = name_to_dev_t(name);
1011         kfree(name);
1012         if (!res)
1013                 return -EINVAL;
1014 
1015         lock_system_sleep();
1016         swsusp_resume_device = res;
1017         unlock_system_sleep();
1018         printk(KERN_INFO "PM: Starting manual resume from disk\n");
1019         noresume = 0;
1020         software_resume();
1021         return n;
1022 }
1023 
1024 power_attr(resume);
1025 
1026 static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
1027                                char *buf)
1028 {
1029         return sprintf(buf, "%lu\n", image_size);
1030 }
1031 
1032 static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
1033                                 const char *buf, size_t n)
1034 {
1035         unsigned long size;
1036 
1037         if (sscanf(buf, "%lu", &size) == 1) {
1038                 image_size = size;
1039                 return n;
1040         }
1041 
1042         return -EINVAL;
1043 }
1044 
1045 power_attr(image_size);
1046 
1047 static ssize_t reserved_size_show(struct kobject *kobj,
1048                                   struct kobj_attribute *attr, char *buf)
1049 {
1050         return sprintf(buf, "%lu\n", reserved_size);
1051 }
1052 
1053 static ssize_t reserved_size_store(struct kobject *kobj,
1054                                    struct kobj_attribute *attr,
1055                                    const char *buf, size_t n)
1056 {
1057         unsigned long size;
1058 
1059         if (sscanf(buf, "%lu", &size) == 1) {
1060                 reserved_size = size;
1061                 return n;
1062         }
1063 
1064         return -EINVAL;
1065 }
1066 
1067 power_attr(reserved_size);
1068 
1069 static struct attribute * g[] = {
1070         &disk_attr.attr,
1071         &resume_attr.attr,
1072         &image_size_attr.attr,
1073         &reserved_size_attr.attr,
1074         NULL,
1075 };
1076 
1077 
1078 static struct attribute_group attr_group = {
1079         .attrs = g,
1080 };
1081 
1082 
1083 static int __init pm_disk_init(void)
1084 {
1085         return sysfs_create_group(power_kobj, &attr_group);
1086 }
1087 
1088 core_initcall(pm_disk_init);
1089 
1090 
1091 static int __init resume_setup(char *str)
1092 {
1093         if (noresume)
1094                 return 1;
1095 
1096         strncpy( resume_file, str, 255 );
1097         return 1;
1098 }
1099 
1100 static int __init resume_offset_setup(char *str)
1101 {
1102         unsigned long long offset;
1103 
1104         if (noresume)
1105                 return 1;
1106 
1107         if (sscanf(str, "%llu", &offset) == 1)
1108                 swsusp_resume_block = offset;
1109 
1110         return 1;
1111 }
1112 
1113 static int __init hibernate_setup(char *str)
1114 {
1115         if (!strncmp(str, "noresume", 8))
1116                 noresume = 1;
1117         else if (!strncmp(str, "nocompress", 10))
1118                 nocompress = 1;
1119         else if (!strncmp(str, "no", 2)) {
1120                 noresume = 1;
1121                 nohibernate = 1;
1122         }
1123         return 1;
1124 }
1125 
1126 static int __init noresume_setup(char *str)
1127 {
1128         noresume = 1;
1129         return 1;
1130 }
1131 
1132 static int __init resumewait_setup(char *str)
1133 {
1134         resume_wait = 1;
1135         return 1;
1136 }
1137 
1138 static int __init resumedelay_setup(char *str)
1139 {
1140         int rc = kstrtouint(str, 0, &resume_delay);
1141 
1142         if (rc)
1143                 return rc;
1144         return 1;
1145 }
1146 
1147 static int __init nohibernate_setup(char *str)
1148 {
1149         noresume = 1;
1150         nohibernate = 1;
1151         return 1;
1152 }
1153 
1154 static int __init kaslr_nohibernate_setup(char *str)
1155 {
1156         return nohibernate_setup(str);
1157 }
1158 
1159 __setup("noresume", noresume_setup);
1160 __setup("resume_offset=", resume_offset_setup);
1161 __setup("resume=", resume_setup);
1162 __setup("hibernate=", hibernate_setup);
1163 __setup("resumewait", resumewait_setup);
1164 __setup("resumedelay=", resumedelay_setup);
1165 __setup("nohibernate", nohibernate_setup);
1166 __setup("kaslr", kaslr_nohibernate_setup);
1167 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp