Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #include <linux/suspend.h>
       3                 :            : #include <linux/suspend_ioctls.h>
       4                 :            : #include <linux/utsname.h>
       5                 :            : #include <linux/freezer.h>
       6                 :            : #include <linux/compiler.h>
       7                 :            : 
       8                 :            : struct swsusp_info {
       9                 :            :         struct new_utsname      uts;
      10                 :            :         u32                     version_code;
      11                 :            :         unsigned long           num_physpages;
      12                 :            :         int                     cpus;
      13                 :            :         unsigned long           image_pages;
      14                 :            :         unsigned long           pages;
      15                 :            :         unsigned long           size;
      16                 :            : } __aligned(PAGE_SIZE);
      17                 :            : 
      18                 :            : #ifdef CONFIG_HIBERNATION
      19                 :            : /* kernel/power/snapshot.c */
      20                 :            : extern void __init hibernate_reserved_size_init(void);
      21                 :            : extern void __init hibernate_image_size_init(void);
      22                 :            : 
      23                 :            : #ifdef CONFIG_ARCH_HIBERNATION_HEADER
      24                 :            : /* Maximum size of architecture specific data in a hibernation header */
      25                 :            : #define MAX_ARCH_HEADER_SIZE    (sizeof(struct new_utsname) + 4)
      26                 :            : 
      27                 :            : extern int arch_hibernation_header_save(void *addr, unsigned int max_size);
      28                 :            : extern int arch_hibernation_header_restore(void *addr);
      29                 :            : 
      30                 :          0 : static inline int init_header_complete(struct swsusp_info *info)
      31                 :            : {
      32                 :          0 :         return arch_hibernation_header_save(info, MAX_ARCH_HEADER_SIZE);
      33                 :            : }
      34                 :            : 
      35                 :          0 : static inline char *check_image_kernel(struct swsusp_info *info)
      36                 :            : {
      37                 :          0 :         return arch_hibernation_header_restore(info) ?
      38         [ #  # ]:          0 :                         "architecture specific data" : NULL;
      39                 :            : }
      40                 :            : #endif /* CONFIG_ARCH_HIBERNATION_HEADER */
      41                 :            : 
      42                 :            : extern int hibernate_resume_nonboot_cpu_disable(void);
      43                 :            : 
      44                 :            : /*
      45                 :            :  * Keep some memory free so that I/O operations can succeed without paging
      46                 :            :  * [Might this be more than 4 MB?]
      47                 :            :  */
      48                 :            : #define PAGES_FOR_IO    ((4096 * 1024) >> PAGE_SHIFT)
      49                 :            : 
      50                 :            : /*
      51                 :            :  * Keep 1 MB of memory free so that device drivers can allocate some pages in
      52                 :            :  * their .suspend() routines without breaking the suspend to disk.
      53                 :            :  */
      54                 :            : #define SPARE_PAGES     ((1024 * 1024) >> PAGE_SHIFT)
      55                 :            : 
      56                 :            : asmlinkage int swsusp_save(void);
      57                 :            : 
      58                 :            : /* kernel/power/hibernate.c */
      59                 :            : extern bool freezer_test_done;
      60                 :            : 
      61                 :            : extern int hibernation_snapshot(int platform_mode);
      62                 :            : extern int hibernation_restore(int platform_mode);
      63                 :            : extern int hibernation_platform_enter(void);
      64                 :            : 
      65                 :            : #ifdef CONFIG_STRICT_KERNEL_RWX
      66                 :            : /* kernel/power/snapshot.c */
      67                 :            : extern void enable_restore_image_protection(void);
      68                 :            : #else
      69                 :            : static inline void enable_restore_image_protection(void) {}
      70                 :            : #endif /* CONFIG_STRICT_KERNEL_RWX */
      71                 :            : 
      72                 :            : #else /* !CONFIG_HIBERNATION */
      73                 :            : 
      74                 :            : static inline void hibernate_reserved_size_init(void) {}
      75                 :            : static inline void hibernate_image_size_init(void) {}
      76                 :            : #endif /* !CONFIG_HIBERNATION */
      77                 :            : 
      78                 :            : #define power_attr(_name) \
      79                 :            : static struct kobj_attribute _name##_attr = {   \
      80                 :            :         .attr   = {                             \
      81                 :            :                 .name = __stringify(_name),     \
      82                 :            :                 .mode = 0644,                   \
      83                 :            :         },                                      \
      84                 :            :         .show   = _name##_show,                 \
      85                 :            :         .store  = _name##_store,                \
      86                 :            : }
      87                 :            : 
      88                 :            : #define power_attr_ro(_name) \
      89                 :            : static struct kobj_attribute _name##_attr = {   \
      90                 :            :         .attr   = {                             \
      91                 :            :                 .name = __stringify(_name),     \
      92                 :            :                 .mode = S_IRUGO,                \
      93                 :            :         },                                      \
      94                 :            :         .show   = _name##_show,                 \
      95                 :            : }
      96                 :            : 
      97                 :            : /* Preferred image size in bytes (default 500 MB) */
      98                 :            : extern unsigned long image_size;
      99                 :            : /* Size of memory reserved for drivers (default SPARE_PAGES x PAGE_SIZE) */
     100                 :            : extern unsigned long reserved_size;
     101                 :            : extern int in_suspend;
     102                 :            : extern dev_t swsusp_resume_device;
     103                 :            : extern sector_t swsusp_resume_block;
     104                 :            : 
     105                 :            : extern int create_basic_memory_bitmaps(void);
     106                 :            : extern void free_basic_memory_bitmaps(void);
     107                 :            : extern int hibernate_preallocate_memory(void);
     108                 :            : 
     109                 :            : extern void clear_free_pages(void);
     110                 :            : 
     111                 :            : /**
     112                 :            :  *      Auxiliary structure used for reading the snapshot image data and
     113                 :            :  *      metadata from and writing them to the list of page backup entries
     114                 :            :  *      (PBEs) which is the main data structure of swsusp.
     115                 :            :  *
     116                 :            :  *      Using struct snapshot_handle we can transfer the image, including its
     117                 :            :  *      metadata, as a continuous sequence of bytes with the help of
     118                 :            :  *      snapshot_read_next() and snapshot_write_next().
     119                 :            :  *
     120                 :            :  *      The code that writes the image to a storage or transfers it to
     121                 :            :  *      the user land is required to use snapshot_read_next() for this
     122                 :            :  *      purpose and it should not make any assumptions regarding the internal
     123                 :            :  *      structure of the image.  Similarly, the code that reads the image from
     124                 :            :  *      a storage or transfers it from the user land is required to use
     125                 :            :  *      snapshot_write_next().
     126                 :            :  *
     127                 :            :  *      This may allow us to change the internal structure of the image
     128                 :            :  *      in the future with considerably less effort.
     129                 :            :  */
     130                 :            : 
     131                 :            : struct snapshot_handle {
     132                 :            :         unsigned int    cur;    /* number of the block of PAGE_SIZE bytes the
     133                 :            :                                  * next operation will refer to (ie. current)
     134                 :            :                                  */
     135                 :            :         void            *buffer;        /* address of the block to read from
     136                 :            :                                          * or write to
     137                 :            :                                          */
     138                 :            :         int             sync_read;      /* Set to one to notify the caller of
     139                 :            :                                          * snapshot_write_next() that it may
     140                 :            :                                          * need to call wait_on_bio_chain()
     141                 :            :                                          */
     142                 :            : };
     143                 :            : 
     144                 :            : /* This macro returns the address from/to which the caller of
     145                 :            :  * snapshot_read_next()/snapshot_write_next() is allowed to
     146                 :            :  * read/write data after the function returns
     147                 :            :  */
     148                 :            : #define data_of(handle) ((handle).buffer)
     149                 :            : 
     150                 :            : extern unsigned int snapshot_additional_pages(struct zone *zone);
     151                 :            : extern unsigned long snapshot_get_image_size(void);
     152                 :            : extern int snapshot_read_next(struct snapshot_handle *handle);
     153                 :            : extern int snapshot_write_next(struct snapshot_handle *handle);
     154                 :            : extern void snapshot_write_finalize(struct snapshot_handle *handle);
     155                 :            : extern int snapshot_image_loaded(struct snapshot_handle *handle);
     156                 :            : 
     157                 :            : /* If unset, the snapshot device cannot be open. */
     158                 :            : extern atomic_t snapshot_device_available;
     159                 :            : 
     160                 :            : extern sector_t alloc_swapdev_block(int swap);
     161                 :            : extern void free_all_swap_pages(int swap);
     162                 :            : extern int swsusp_swap_in_use(void);
     163                 :            : 
     164                 :            : /*
     165                 :            :  * Flags that can be passed from the hibernatig hernel to the "boot" kernel in
     166                 :            :  * the image header.
     167                 :            :  */
     168                 :            : #define SF_PLATFORM_MODE        1
     169                 :            : #define SF_NOCOMPRESS_MODE      2
     170                 :            : #define SF_CRC32_MODE           4
     171                 :            : 
     172                 :            : /* kernel/power/hibernate.c */
     173                 :            : extern int swsusp_check(void);
     174                 :            : extern void swsusp_free(void);
     175                 :            : extern int swsusp_read(unsigned int *flags_p);
     176                 :            : extern int swsusp_write(unsigned int flags);
     177                 :            : extern void swsusp_close(fmode_t);
     178                 :            : #ifdef CONFIG_SUSPEND
     179                 :            : extern int swsusp_unmark(void);
     180                 :            : #endif
     181                 :            : 
     182                 :            : struct __kernel_old_timeval;
     183                 :            : /* kernel/power/swsusp.c */
     184                 :            : extern void swsusp_show_speed(ktime_t, ktime_t, unsigned int, char *);
     185                 :            : 
     186                 :            : #ifdef CONFIG_SUSPEND
     187                 :            : /* kernel/power/suspend.c */
     188                 :            : extern const char * const pm_labels[];
     189                 :            : extern const char *pm_states[];
     190                 :            : extern const char *mem_sleep_states[];
     191                 :            : 
     192                 :            : extern int suspend_devices_and_enter(suspend_state_t state);
     193                 :            : #else /* !CONFIG_SUSPEND */
     194                 :            : #define mem_sleep_current       PM_SUSPEND_ON
     195                 :            : 
     196                 :            : static inline int suspend_devices_and_enter(suspend_state_t state)
     197                 :            : {
     198                 :            :         return -ENOSYS;
     199                 :            : }
     200                 :            : #endif /* !CONFIG_SUSPEND */
     201                 :            : 
     202                 :            : #ifdef CONFIG_PM_TEST_SUSPEND
     203                 :            : /* kernel/power/suspend_test.c */
     204                 :            : extern void suspend_test_start(void);
     205                 :            : extern void suspend_test_finish(const char *label);
     206                 :            : #else /* !CONFIG_PM_TEST_SUSPEND */
     207                 :          0 : static inline void suspend_test_start(void) {}
     208                 :          0 : static inline void suspend_test_finish(const char *label) {}
     209                 :            : #endif /* !CONFIG_PM_TEST_SUSPEND */
     210                 :            : 
     211                 :            : #ifdef CONFIG_PM_SLEEP
     212                 :            : /* kernel/power/main.c */
     213                 :            : extern int __pm_notifier_call_chain(unsigned long val, int nr_to_call,
     214                 :            :                                     int *nr_calls);
     215                 :            : extern int pm_notifier_call_chain(unsigned long val);
     216                 :            : #endif
     217                 :            : 
     218                 :            : #ifdef CONFIG_HIGHMEM
     219                 :            : int restore_highmem(void);
     220                 :            : #else
     221         [ #  # ]:          0 : static inline unsigned int count_highmem_pages(void) { return 0; }
     222                 :          0 : static inline int restore_highmem(void) { return 0; }
     223                 :            : #endif
     224                 :            : 
     225                 :            : /*
     226                 :            :  * Suspend test levels
     227                 :            :  */
     228                 :            : enum {
     229                 :            :         /* keep first */
     230                 :            :         TEST_NONE,
     231                 :            :         TEST_CORE,
     232                 :            :         TEST_CPUS,
     233                 :            :         TEST_PLATFORM,
     234                 :            :         TEST_DEVICES,
     235                 :            :         TEST_FREEZER,
     236                 :            :         /* keep last */
     237                 :            :         __TEST_AFTER_LAST
     238                 :            : };
     239                 :            : 
     240                 :            : #define TEST_FIRST      TEST_NONE
     241                 :            : #define TEST_MAX        (__TEST_AFTER_LAST - 1)
     242                 :            : 
     243                 :            : #ifdef CONFIG_PM_SLEEP_DEBUG
     244                 :            : extern int pm_test_level;
     245                 :            : #else
     246                 :            : #define pm_test_level   (TEST_NONE)
     247                 :            : #endif
     248                 :            : 
     249                 :            : #ifdef CONFIG_SUSPEND_FREEZER
     250                 :          0 : static inline int suspend_freeze_processes(void)
     251                 :            : {
     252                 :          0 :         int error;
     253                 :            : 
     254                 :          0 :         error = freeze_processes();
     255                 :            :         /*
     256                 :            :          * freeze_processes() automatically thaws every task if freezing
     257                 :            :          * fails. So we need not do anything extra upon error.
     258                 :            :          */
     259         [ #  # ]:          0 :         if (error)
     260                 :            :                 return error;
     261                 :            : 
     262                 :          0 :         error = freeze_kernel_threads();
     263                 :            :         /*
     264                 :            :          * freeze_kernel_threads() thaws only kernel threads upon freezing
     265                 :            :          * failure. So we have to thaw the userspace tasks ourselves.
     266                 :            :          */
     267         [ #  # ]:          0 :         if (error)
     268                 :          0 :                 thaw_processes();
     269                 :            : 
     270                 :            :         return error;
     271                 :            : }
     272                 :            : 
     273                 :          0 : static inline void suspend_thaw_processes(void)
     274                 :            : {
     275                 :          0 :         thaw_processes();
     276                 :            : }
     277                 :            : #else
     278                 :            : static inline int suspend_freeze_processes(void)
     279                 :            : {
     280                 :            :         return 0;
     281                 :            : }
     282                 :            : 
     283                 :            : static inline void suspend_thaw_processes(void)
     284                 :            : {
     285                 :            : }
     286                 :            : #endif
     287                 :            : 
     288                 :            : #ifdef CONFIG_PM_AUTOSLEEP
     289                 :            : 
     290                 :            : /* kernel/power/autosleep.c */
     291                 :            : extern int pm_autosleep_init(void);
     292                 :            : extern int pm_autosleep_lock(void);
     293                 :            : extern void pm_autosleep_unlock(void);
     294                 :            : extern suspend_state_t pm_autosleep_state(void);
     295                 :            : extern int pm_autosleep_set_state(suspend_state_t state);
     296                 :            : 
     297                 :            : #else /* !CONFIG_PM_AUTOSLEEP */
     298                 :            : 
     299                 :         11 : static inline int pm_autosleep_init(void) { return 0; }
     300   [ #  #  #  #  :          0 : static inline int pm_autosleep_lock(void) { return 0; }
                   #  # ]
     301         [ #  # ]:          0 : static inline void pm_autosleep_unlock(void) {}
     302   [ #  #  #  #  :          0 : static inline suspend_state_t pm_autosleep_state(void) { return PM_SUSPEND_ON; }
                   #  # ]
     303                 :            : 
     304                 :            : #endif /* !CONFIG_PM_AUTOSLEEP */
     305                 :            : 
     306                 :            : #ifdef CONFIG_PM_WAKELOCKS
     307                 :            : 
     308                 :            : /* kernel/power/wakelock.c */
     309                 :            : extern ssize_t pm_show_wakelocks(char *buf, bool show_active);
     310                 :            : extern int pm_wake_lock(const char *buf);
     311                 :            : extern int pm_wake_unlock(const char *buf);
     312                 :            : 
     313                 :            : #endif /* !CONFIG_PM_WAKELOCKS */