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