power.h 8.6 KB

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