Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355/* SPDX-License-Identifier: GPL-2.0 */#include <linux/suspend.h>#include <linux/suspend_ioctls.h>#include <linux/utsname.h>#include <linux/freezer.h>#include <linux/compiler.h>#include <linux/cpu.h>#include <linux/cpuidle.h>#include <linux/crypto.h>
struct swsusp_info { struct new_utsname uts; u32 version_code; unsigned long num_physpages; int cpus; unsigned long image_pages; unsigned long pages; unsigned long size;} __aligned(PAGE_SIZE);
#if defined(CONFIG_SUSPEND) || defined(CONFIG_HIBERNATION)extern int pm_sleep_fs_sync(void);extern bool filesystem_freeze_enabled;#endif
#ifdef CONFIG_HIBERNATION/* kernel/power/snapshot.c */extern void __init hibernate_reserved_size_init(void);extern void __init hibernate_image_size_init(void);
#ifdef CONFIG_ARCH_HIBERNATION_HEADER/* Maximum size of architecture specific data in a hibernation header */#define MAX_ARCH_HEADER_SIZE (sizeof(struct new_utsname) + 4)
static inline int init_header_complete(struct swsusp_info *info){ return arch_hibernation_header_save(info, MAX_ARCH_HEADER_SIZE);}
static inline const char *check_image_kernel(struct swsusp_info *info){ return arch_hibernation_header_restore(info) ? "architecture specific data" : NULL;}#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
/* * Keep some memory free so that I/O operations can succeed without paging * [Might this be more than 4 MB?] */#define PAGES_FOR_IO ((4096 * 1024) >> PAGE_SHIFT)
/* * Keep 1 MB of memory free so that device drivers can allocate some pages in * their .suspend() routines without breaking the suspend to disk. */#define SPARE_PAGES ((1024 * 1024) >> PAGE_SHIFT)
asmlinkage int swsusp_save(void);
/* kernel/power/hibernate.c */extern bool freezer_test_done;extern char hib_comp_algo[CRYPTO_MAX_ALG_NAME];
/* kernel/power/swap.c */extern unsigned int swsusp_header_flags;
extern int hibernation_snapshot(int platform_mode);extern int hibernation_restore(int platform_mode);extern int hibernation_platform_enter(void);
#ifdef CONFIG_STRICT_KERNEL_RWX/* kernel/power/snapshot.c */extern void enable_restore_image_protection(void);#elsestatic inline void enable_restore_image_protection(void) {}#endif /* CONFIG_STRICT_KERNEL_RWX */
extern bool hibernation_in_progress(void);
#else /* !CONFIG_HIBERNATION */
static inline void hibernate_reserved_size_init(void) {}static inline void hibernate_image_size_init(void) {}
static inline bool hibernation_in_progress(void) { return false; }#endif /* !CONFIG_HIBERNATION */
#define power_attr(_name) \static struct kobj_attribute _name##_attr = { \ .attr = { \ .name = __stringify(_name), \ .mode = 0644, \ }, \ .show = _name##_show, \ .store = _name##_store, \}
#define power_attr_ro(_name) \static struct kobj_attribute _name##_attr = { \ .attr = { \ .name = __stringify(_name), \ .mode = S_IRUGO, \ }, \ .show = _name##_show, \}
/* Preferred image size in bytes (default 500 MB) */extern unsigned long image_size;/* Size of memory reserved for drivers (default SPARE_PAGES x PAGE_SIZE) */extern unsigned long reserved_size;extern int in_suspend;extern dev_t swsusp_resume_device;extern sector_t swsusp_resume_block;
extern int create_basic_memory_bitmaps(void);extern void free_basic_memory_bitmaps(void);extern int hibernate_preallocate_memory(void);
extern void clear_or_poison_free_pages(void);
/* * Auxiliary structure used for reading the snapshot image data and * metadata from and writing them to the list of page backup entries * (PBEs) which is the main data structure of swsusp. * * Using struct snapshot_handle we can transfer the image, including its * metadata, as a continuous sequence of bytes with the help of * snapshot_read_next() and snapshot_write_next(). * * The code that writes the image to a storage or transfers it to * the user land is required to use snapshot_read_next() for this * purpose and it should not make any assumptions regarding the internal * structure of the image. Similarly, the code that reads the image from * a storage or transfers it from the user land is required to use * snapshot_write_next(). * * This may allow us to change the internal structure of the image * in the future with considerably less effort. */
struct snapshot_handle { unsigned int cur; /* number of the block of PAGE_SIZE bytes the * next operation will refer to (ie. current) */ void *buffer; /* address of the block to read from * or write to */ int sync_read; /* Set to one to notify the caller of * snapshot_write_next() that it may * need to call wait_on_bio_chain() */};
/* This macro returns the address from/to which the caller of * snapshot_read_next()/snapshot_write_next() is allowed to * read/write data after the function returns */#define data_of(handle) ((handle).buffer)
extern unsigned int snapshot_additional_pages(struct zone *zone);extern unsigned long snapshot_get_image_size(void);extern int snapshot_read_next(struct snapshot_handle *handle);extern int snapshot_write_next(struct snapshot_handle *handle);int snapshot_write_finalize(struct snapshot_handle *handle);extern int snapshot_image_loaded(struct snapshot_handle *handle);
extern bool hibernate_acquire(void);extern void hibernate_release(void);
extern sector_t alloc_swapdev_block(int swap);extern void free_all_swap_pages(int swap);extern int swsusp_swap_in_use(void);
/* * Flags that can be passed from the hibernatig hernel to the "boot" kernel in * the image header. */#define SF_COMPRESSION_ALG_LZO 0 /* dummy, details given below */#define SF_PLATFORM_MODE 1#define SF_NOCOMPRESS_MODE 2#define SF_CRC32_MODE 4#define SF_HW_SIG 8
/* * Bit to indicate the compression algorithm to be used(for LZ4). The same * could be checked while saving/loading image to/from disk to use the * corresponding algorithms. * * By default, LZO compression is enabled if SF_CRC32_MODE is set. Use * SF_COMPRESSION_ALG_LZ4 to override this behaviour and use LZ4. * * SF_CRC32_MODE, SF_COMPRESSION_ALG_LZO(dummy) -> Compression, LZO * SF_CRC32_MODE, SF_COMPRESSION_ALG_LZ4 -> Compression, LZ4 */#define SF_COMPRESSION_ALG_LZ4 16
/* kernel/power/hibernate.c */int swsusp_check(bool exclusive);extern void swsusp_free(void);extern int swsusp_read(unsigned int *flags_p);extern int swsusp_write(unsigned int flags);void swsusp_close(void);#ifdef CONFIG_SUSPENDextern int swsusp_unmark(void);#elsestatic inline int swsusp_unmark(void) { return 0; }#endif
struct __kernel_old_timeval;/* kernel/power/swsusp.c */extern void swsusp_show_speed(ktime_t, ktime_t, unsigned int, char *);
#ifdef CONFIG_SUSPEND/* kernel/power/suspend.c */extern const char * const pm_labels[];extern const char *pm_states[];extern const char *mem_sleep_states[];
extern int suspend_devices_and_enter(suspend_state_t state);#else /* !CONFIG_SUSPEND */#define mem_sleep_current PM_SUSPEND_ON
static inline int suspend_devices_and_enter(suspend_state_t state){ return -ENOSYS;}#endif /* !CONFIG_SUSPEND */
#ifdef CONFIG_PM_TEST_SUSPEND/* kernel/power/suspend_test.c */extern void suspend_test_start(void);extern void suspend_test_finish(const char *label);#else /* !CONFIG_PM_TEST_SUSPEND */static inline void suspend_test_start(void) {}static inline void suspend_test_finish(const char *label) {}#endif /* !CONFIG_PM_TEST_SUSPEND */
#ifdef CONFIG_PM_SLEEP/* kernel/power/main.c */extern int pm_notifier_call_chain_robust(unsigned long val_up, unsigned long val_down);extern int pm_notifier_call_chain(unsigned long val);#endif
#ifdef CONFIG_HIGHMEMint restore_highmem(void);#elsestatic inline unsigned int count_highmem_pages(void) { return 0; }static inline int restore_highmem(void) { return 0; }#endif
/* * Suspend test levels */enum { /* keep first */ TEST_NONE, TEST_CORE, TEST_CPUS, TEST_PLATFORM, TEST_DEVICES, TEST_FREEZER, /* keep last */ __TEST_AFTER_LAST};
#define TEST_FIRST TEST_NONE#define TEST_MAX (__TEST_AFTER_LAST - 1)
#ifdef CONFIG_PM_SLEEP_DEBUGextern int pm_test_level;#else#define pm_test_level (TEST_NONE)#endif
#ifdef CONFIG_SUSPEND_FREEZERstatic inline int suspend_freeze_processes(void){ int error;
error = freeze_processes(); /* * freeze_processes() automatically thaws every task if freezing * fails. So we need not do anything extra upon error. */ if (error) return error;
error = freeze_kernel_threads(); /* * freeze_kernel_threads() thaws only kernel threads upon freezing * failure. So we have to thaw the userspace tasks ourselves. */ if (error) thaw_processes();
return error;}
static inline void suspend_thaw_processes(void){ thaw_processes();}#elsestatic inline int suspend_freeze_processes(void){ return 0;}
static inline void suspend_thaw_processes(void){}#endif
#ifdef CONFIG_PM_AUTOSLEEP
/* kernel/power/autosleep.c */extern int pm_autosleep_init(void);extern int pm_autosleep_lock(void);extern void pm_autosleep_unlock(void);extern suspend_state_t pm_autosleep_state(void);extern int pm_autosleep_set_state(suspend_state_t state);
#else /* !CONFIG_PM_AUTOSLEEP */
static inline int pm_autosleep_init(void) { return 0; }static inline int pm_autosleep_lock(void) { return 0; }static inline void pm_autosleep_unlock(void) {}static inline suspend_state_t pm_autosleep_state(void) { return PM_SUSPEND_ON; }
#endif /* !CONFIG_PM_AUTOSLEEP */
#ifdef CONFIG_PM_WAKELOCKS
/* kernel/power/wakelock.c */extern ssize_t pm_show_wakelocks(char *buf, bool show_active);extern int pm_wake_lock(const char *buf);extern int pm_wake_unlock(const char *buf);
#endif /* !CONFIG_PM_WAKELOCKS */
static inline int pm_sleep_disable_secondary_cpus(void){ cpuidle_pause(); return suspend_disable_secondary_cpus();}
static inline void pm_sleep_enable_secondary_cpus(void){ suspend_enable_secondary_cpus(); cpuidle_resume();}
void dpm_save_errno(int err);