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