1 #include <linux/suspend.h> 2 #include <linux/utsname.h> 3 4 struct swsusp_info { 5 struct new_utsname uts; 6 u32 version_code; 7 unsigned long num_physpages; 8 int cpus; 9 unsigned long image_pages; 10 unsigned long pages; 11 unsigned long size; 12 } __attribute__((aligned(PAGE_SIZE))); 13 14 15 16 #ifdef CONFIG_SOFTWARE_SUSPEND 17 extern int pm_suspend_disk(void); 18 19 #else 20 static inline int pm_suspend_disk(void) 21 { 22 return -EPERM; 23 } 24 #endif 25 extern struct semaphore pm_sem; 26 #define power_attr(_name) \ 27 static struct subsys_attribute _name##_attr = { \ 28 .attr = { \ 29 .name = __stringify(_name), \ 30 .mode = 0644, \ 31 }, \ 32 .show = _name##_show, \ 33 .store = _name##_store, \ 34 } 35 36 extern struct subsystem power_subsys; 37 38 /* References to section boundaries */ 39 extern const void __nosave_begin, __nosave_end; 40 41 /* Preferred image size in bytes (default 500 MB) */ 42 extern unsigned long image_size; 43 extern int in_suspend; 44 extern dev_t swsusp_resume_device; 45 46 extern asmlinkage int swsusp_arch_suspend(void); 47 extern asmlinkage int swsusp_arch_resume(void); 48 49 extern unsigned int count_data_pages(void); 50 51 /** 52 * Auxiliary structure used for reading the snapshot image data and 53 * metadata from and writing them to the list of page backup entries 54 * (PBEs) which is the main data structure of swsusp. 55 * 56 * Using struct snapshot_handle we can transfer the image, including its 57 * metadata, as a continuous sequence of bytes with the help of 58 * snapshot_read_next() and snapshot_write_next(). 59 * 60 * The code that writes the image to a storage or transfers it to 61 * the user land is required to use snapshot_read_next() for this 62 * purpose and it should not make any assumptions regarding the internal 63 * structure of the image. Similarly, the code that reads the image from 64 * a storage or transfers it from the user land is required to use 65 * snapshot_write_next(). 66 * 67 * This may allow us to change the internal structure of the image 68 * in the future with considerably less effort. 69 */ 70 71 struct snapshot_handle { 72 loff_t offset; /* number of the last byte ready for reading 73 * or writing in the sequence 74 */ 75 unsigned int cur; /* number of the block of PAGE_SIZE bytes the 76 * next operation will refer to (ie. current) 77 */ 78 unsigned int cur_offset; /* offset with respect to the current 79 * block (for the next operation) 80 */ 81 unsigned int prev; /* number of the block of PAGE_SIZE bytes that 82 * was the current one previously 83 */ 84 void *buffer; /* address of the block to read from 85 * or write to 86 */ 87 unsigned int buf_offset; /* location to read from or write to, 88 * given as a displacement from 'buffer' 89 */ 90 int sync_read; /* Set to one to notify the caller of 91 * snapshot_write_next() that it may 92 * need to call wait_on_bio_chain() 93 */ 94 }; 95 96 /* This macro returns the address from/to which the caller of 97 * snapshot_read_next()/snapshot_write_next() is allowed to 98 * read/write data after the function returns 99 */ 100 #define data_of(handle) ((handle).buffer + (handle).buf_offset) 101 102 extern unsigned int snapshot_additional_pages(struct zone *zone); 103 extern int snapshot_read_next(struct snapshot_handle *handle, size_t count); 104 extern int snapshot_write_next(struct snapshot_handle *handle, size_t count); 105 extern int snapshot_image_loaded(struct snapshot_handle *handle); 106 extern void snapshot_free_unused_memory(struct snapshot_handle *handle); 107 108 #define SNAPSHOT_IOC_MAGIC '3' 109 #define SNAPSHOT_FREEZE _IO(SNAPSHOT_IOC_MAGIC, 1) 110 #define SNAPSHOT_UNFREEZE _IO(SNAPSHOT_IOC_MAGIC, 2) 111 #define SNAPSHOT_ATOMIC_SNAPSHOT _IOW(SNAPSHOT_IOC_MAGIC, 3, void *) 112 #define SNAPSHOT_ATOMIC_RESTORE _IO(SNAPSHOT_IOC_MAGIC, 4) 113 #define SNAPSHOT_FREE _IO(SNAPSHOT_IOC_MAGIC, 5) 114 #define SNAPSHOT_SET_IMAGE_SIZE _IOW(SNAPSHOT_IOC_MAGIC, 6, unsigned long) 115 #define SNAPSHOT_AVAIL_SWAP _IOR(SNAPSHOT_IOC_MAGIC, 7, void *) 116 #define SNAPSHOT_GET_SWAP_PAGE _IOR(SNAPSHOT_IOC_MAGIC, 8, void *) 117 #define SNAPSHOT_FREE_SWAP_PAGES _IO(SNAPSHOT_IOC_MAGIC, 9) 118 #define SNAPSHOT_SET_SWAP_FILE _IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int) 119 #define SNAPSHOT_S2RAM _IO(SNAPSHOT_IOC_MAGIC, 11) 120 #define SNAPSHOT_PMOPS _IOW(SNAPSHOT_IOC_MAGIC, 12, unsigned int) 121 #define SNAPSHOT_IOC_MAXNR 12 122 123 #define PMOPS_PREPARE 1 124 #define PMOPS_ENTER 2 125 #define PMOPS_FINISH 3 126 127 /** 128 * The bitmap is used for tracing allocated swap pages 129 * 130 * The entire bitmap consists of a number of bitmap_page 131 * structures linked with the help of the .next member. 132 * Thus each page can be allocated individually, so we only 133 * need to make 0-order memory allocations to create 134 * the bitmap. 135 */ 136 137 #define BITMAP_PAGE_SIZE (PAGE_SIZE - sizeof(void *)) 138 #define BITMAP_PAGE_CHUNKS (BITMAP_PAGE_SIZE / sizeof(long)) 139 #define BITS_PER_CHUNK (sizeof(long) * 8) 140 #define BITMAP_PAGE_BITS (BITMAP_PAGE_CHUNKS * BITS_PER_CHUNK) 141 142 struct bitmap_page { 143 unsigned long chunks[BITMAP_PAGE_CHUNKS]; 144 struct bitmap_page *next; 145 }; 146 147 extern void free_bitmap(struct bitmap_page *bitmap); 148 extern struct bitmap_page *alloc_bitmap(unsigned int nr_bits); 149 extern unsigned long alloc_swap_page(int swap, struct bitmap_page *bitmap); 150 extern void free_all_swap_pages(int swap, struct bitmap_page *bitmap); 151 152 extern int swsusp_check(void); 153 extern int swsusp_shrink_memory(void); 154 extern void swsusp_free(void); 155 extern int swsusp_suspend(void); 156 extern int swsusp_resume(void); 157 extern int swsusp_read(void); 158 extern int swsusp_write(void); 159 extern void swsusp_close(void); 160 extern int suspend_enter(suspend_state_t state); 161