LXR linux/kernel/power/power.h

   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
   8struct 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 */
  20extern void __init hibernate_reserved_size_init(void);
  21extern 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
  27extern int arch_hibernation_header_save(void *addr, unsigned int max_size);
  28extern int arch_hibernation_header_restore(void *addr);
  29
  30static inline int init_header_complete(struct swsusp_info *info)
  31{
  32        return arch_hibernation_header_save(info, MAX_ARCH_HEADER_SIZE);
  33}
  34
  35static inline char *check_image_kernel(struct swsusp_info *info)
  36{
  37        return arch_hibernation_header_restore(info) ?
  38                        "architecture specific data" : NULL;
  39}
  40#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
  41
  42extern 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
  56asmlinkage int swsusp_save(void);
  57
  58/* kernel/power/hibernate.c */
  59extern bool freezer_test_done;
  60
  61extern int hibernation_snapshot(int platform_mode);
  62extern int hibernation_restore(int platform_mode);
  63extern int hibernation_platform_enter(void);
  64
  65#ifdef CONFIG_STRICT_KERNEL_RWX
  66/* kernel/power/snapshot.c */
  67extern void enable_restore_image_protection(void);
  68#else
  69static inline void enable_restore_image_protection(void) {}
  70#endif /* CONFIG_STRICT_KERNEL_RWX */
  71
  72#else /* !CONFIG_HIBERNATION */
  73
  74static inline void hibernate_reserved_size_init(void) {}
  75static inline void hibernate_image_size_init(void) {}
  76#endif /* !CONFIG_HIBERNATION */
  77
  78#define power_attr(_name) \
  79static 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) \
  89static 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) */
  98extern unsigned long image_size;
  99/* Size of memory reserved for drivers (default SPARE_PAGES x PAGE_SIZE) */
 100extern unsigned long reserved_size;
 101extern int in_suspend;
 102extern dev_t swsusp_resume_device;
 103extern sector_t swsusp_resume_block;
 104
 105extern int create_basic_memory_bitmaps(void);
 106extern void free_basic_memory_bitmaps(void);
 107extern int hibernate_preallocate_memory(void);
 108
 109extern 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
 131struct 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
 150extern unsigned int snapshot_additional_pages(struct zone *zone);
 151extern unsigned long snapshot_get_image_size(void);
 152extern int snapshot_read_next(struct snapshot_handle *handle);
 153extern int snapshot_write_next(struct snapshot_handle *handle);
 154extern void snapshot_write_finalize(struct snapshot_handle *handle);
 155extern int snapshot_image_loaded(struct snapshot_handle *handle);
 156
 157/* If unset, the snapshot device cannot be open. */
 158extern atomic_t snapshot_device_available;
 159
 160extern sector_t alloc_swapdev_block(int swap);
 161extern void free_all_swap_pages(int swap);
 162extern 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 */
 173extern int swsusp_check(void);
 174extern void swsusp_free(void);
 175extern int swsusp_read(unsigned int *flags_p);
 176extern int swsusp_write(unsigned int flags);
 177extern void swsusp_close(fmode_t);
 178#ifdef CONFIG_SUSPEND
 179extern int swsusp_unmark(void);
 180#endif
 181
 182struct timeval;
 183/* kernel/power/swsusp.c */
 184extern void swsusp_show_speed(ktime_t, ktime_t, unsigned int, char *);
 185
 186#ifdef CONFIG_SUSPEND
 187/* kernel/power/suspend.c */
 188extern const char * const pm_labels[];
 189extern const char *pm_states[];
 190extern const char *mem_sleep_states[];
 191
 192extern int suspend_devices_and_enter(suspend_state_t state);
 193#else /* !CONFIG_SUSPEND */
 194#define mem_sleep_current       PM_SUSPEND_ON
 195
 196static 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 */
 204extern void suspend_test_start(void);
 205extern void suspend_test_finish(const char *label);
 206#else /* !CONFIG_PM_TEST_SUSPEND */
 207static inline void suspend_test_start(void) {}
 208static 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 */
 213extern int __pm_notifier_call_chain(unsigned long val, int nr_to_call,
 214                                    int *nr_calls);
 215extern int pm_notifier_call_chain(unsigned long val);
 216#endif
 217
 218#ifdef CONFIG_HIGHMEM
 219int restore_highmem(void);
 220#else
 221static inline unsigned int count_highmem_pages(void) { return 0; }
 222static inline int restore_highmem(void) { return 0; }
 223#endif
 224
 225/*
 226 * Suspend test levels
 227 */
 228enum {
 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
 244extern int pm_test_level;
 245#else
 246#define pm_test_level   (TEST_NONE)
 247#endif
 248
 249#ifdef CONFIG_SUSPEND_FREEZER
 250static inline int suspend_freeze_processes(void)
 251{
 252        int error;
 253
 254        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        if (error)
 260                return error;
 261
 262        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        if (error)
 268                thaw_processes();
 269
 270        return error;
 271}
 272
 273static inline void suspend_thaw_processes(void)
 274{
 275        thaw_processes();
 276}
 277#else
 278static inline int suspend_freeze_processes(void)
 279{
 280        return 0;
 281}
 282
 283static inline void suspend_thaw_processes(void)
 284{
 285}
 286#endif
 287
 288#ifdef CONFIG_PM_AUTOSLEEP
 289
 290/* kernel/power/autosleep.c */
 291extern int pm_autosleep_init(void);
 292extern int pm_autosleep_lock(void);
 293extern void pm_autosleep_unlock(void);
 294extern suspend_state_t pm_autosleep_state(void);
 295extern int pm_autosleep_set_state(suspend_state_t state);
 296
 297#else /* !CONFIG_PM_AUTOSLEEP */
 298
 299static inline int pm_autosleep_init(void) { return 0; }
 300static inline int pm_autosleep_lock(void) { return 0; }
 301static inline void pm_autosleep_unlock(void) {}
 302static 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 */
 309extern ssize_t pm_show_wakelocks(char *buf, bool show_active);
 310extern int pm_wake_lock(const char *buf);
 311extern int pm_wake_unlock(const char *buf);
 312
 313#endif /* !CONFIG_PM_WAKELOCKS */
 314