LCOV - code coverage report
Current view: top level - kernel/power - hibernate.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 25 539 4.6 %
Date: 2022-04-01 13:59:58 Functions: 3 34 8.8 %
Branches: 17 303 5.6 %

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

Generated by: LCOV version 1.14