1 #ifndef _LINUX_SWAP_H 2 #define _LINUX_SWAP_H 3 4 #include <linux/config.h> 5 #include <linux/spinlock.h> 6 #include <linux/linkage.h> 7 #include <linux/mmzone.h> 8 #include <linux/list.h> 9 #include <linux/sched.h> 10 11 #include <asm/atomic.h> 12 #include <asm/page.h> 13 14 #define SWAP_FLAG_PREFER 0x8000 /* set if swap priority specified */ 15 #define SWAP_FLAG_PRIO_MASK 0x7fff 16 #define SWAP_FLAG_PRIO_SHIFT 0 17 18 static inline int current_is_kswapd(void) 19 { 20 return current->flags & PF_KSWAPD; 21 } 22 23 /* 24 * MAX_SWAPFILES defines the maximum number of swaptypes: things which can 25 * be swapped to. The swap type and the offset into that swap type are 26 * encoded into pte's and into pgoff_t's in the swapcache. Using five bits 27 * for the type means that the maximum number of swapcache pages is 27 bits 28 * on 32-bit-pgoff_t architectures. And that assumes that the architecture packs 29 * the type/offset into the pte as 5/27 as well. 30 */ 31 #define MAX_SWAPFILES_SHIFT 5 32 #define MAX_SWAPFILES (1 << MAX_SWAPFILES_SHIFT) 33 34 /* 35 * Magic header for a swap area. The first part of the union is 36 * what the swap magic looks like for the old (limited to 128MB) 37 * swap area format, the second part of the union adds - in the 38 * old reserved area - some extra information. Note that the first 39 * kilobyte is reserved for boot loader or disk label stuff... 40 * 41 * Having the magic at the end of the PAGE_SIZE makes detecting swap 42 * areas somewhat tricky on machines that support multiple page sizes. 43 * For 2.5 we'll probably want to move the magic to just beyond the 44 * bootbits... 45 */ 46 union swap_header { 47 struct { 48 char reserved[PAGE_SIZE - 10]; 49 char magic[10]; /* SWAP-SPACE or SWAPSPACE2 */ 50 } magic; 51 struct { 52 char bootbits[1024]; /* Space for disklabel etc. */ 53 unsigned int version; 54 unsigned int last_page; 55 unsigned int nr_badpages; 56 unsigned int padding[125]; 57 unsigned int badpages[1]; 58 } info; 59 }; 60 61 /* A swap entry has to fit into a "unsigned long", as 62 * the entry is hidden in the "index" field of the 63 * swapper address space. 64 */ 65 typedef struct { 66 unsigned long val; 67 } swp_entry_t; 68 69 /* 70 * current->reclaim_state points to one of these when a task is running 71 * memory reclaim 72 */ 73 struct reclaim_state { 74 unsigned long reclaimed_slab; 75 }; 76 77 #ifdef __KERNEL__ 78 79 struct address_space; 80 struct sysinfo; 81 struct writeback_control; 82 struct zone; 83 84 /* 85 * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of 86 * disk blocks. A list of swap extents maps the entire swapfile. (Where the 87 * term `swapfile' refers to either a blockdevice or an IS_REG file. Apart 88 * from setup, they're handled identically. 89 * 90 * We always assume that blocks are of size PAGE_SIZE. 91 */ 92 struct swap_extent { 93 struct list_head list; 94 pgoff_t start_page; 95 pgoff_t nr_pages; 96 sector_t start_block; 97 }; 98 99 /* 100 * Max bad pages in the new format.. 101 */ 102 #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x) 103 #define MAX_SWAP_BADPAGES \ 104 ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int)) 105 106 enum { 107 SWP_USED = (1 << 0), /* is slot in swap_info[] used? */ 108 SWP_WRITEOK = (1 << 1), /* ok to write to this swap? */ 109 SWP_ACTIVE = (SWP_USED | SWP_WRITEOK), 110 /* add others here before... */ 111 SWP_SCANNING = (1 << 8), /* refcount in scan_swap_map */ 112 }; 113 114 #define SWAP_CLUSTER_MAX 32 115 116 #define SWAP_MAP_MAX 0x7fff 117 #define SWAP_MAP_BAD 0x8000 118 119 /* 120 * The in-memory structure used to track swap areas. 121 */ 122 struct swap_info_struct { 123 unsigned int flags; 124 int prio; /* swap priority */ 125 struct file *swap_file; 126 struct block_device *bdev; 127 struct list_head extent_list; 128 struct swap_extent *curr_swap_extent; 129 unsigned old_block_size; 130 unsigned short * swap_map; 131 unsigned int lowest_bit; 132 unsigned int highest_bit; 133 unsigned int cluster_next; 134 unsigned int cluster_nr; 135 unsigned int pages; 136 unsigned int max; 137 unsigned int inuse_pages; 138 int next; /* next entry on swap list */ 139 }; 140 141 struct swap_list_t { 142 int head; /* head of priority-ordered swapfile list */ 143 int next; /* swapfile to be used next */ 144 }; 145 146 /* Swap 50% full? Release swapcache more aggressively.. */ 147 #define vm_swap_full() (nr_swap_pages*2 < total_swap_pages) 148 149 /* linux/mm/oom_kill.c */ 150 extern void out_of_memory(gfp_t gfp_mask, int order); 151 152 /* linux/mm/memory.c */ 153 extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *); 154 155 /* linux/mm/page_alloc.c */ 156 extern unsigned long totalram_pages; 157 extern unsigned long totalhigh_pages; 158 extern long nr_swap_pages; 159 extern unsigned int nr_free_pages(void); 160 extern unsigned int nr_free_pages_pgdat(pg_data_t *pgdat); 161 extern unsigned int nr_free_buffer_pages(void); 162 extern unsigned int nr_free_pagecache_pages(void); 163 164 /* linux/mm/swap.c */ 165 extern void FASTCALL(lru_cache_add(struct page *)); 166 extern void FASTCALL(lru_cache_add_active(struct page *)); 167 extern void FASTCALL(activate_page(struct page *)); 168 extern void FASTCALL(mark_page_accessed(struct page *)); 169 extern void lru_add_drain(void); 170 extern int lru_add_drain_all(void); 171 extern int rotate_reclaimable_page(struct page *page); 172 extern void swap_setup(void); 173 174 /* linux/mm/vmscan.c */ 175 extern int try_to_free_pages(struct zone **, gfp_t); 176 extern int shrink_all_memory(int); 177 extern int vm_swappiness; 178 179 #ifdef CONFIG_NUMA 180 extern int zone_reclaim_mode; 181 extern int zone_reclaim_interval; 182 extern int zone_reclaim(struct zone *, gfp_t, unsigned int); 183 #else 184 #define zone_reclaim_mode 0 185 static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order) 186 { 187 return 0; 188 } 189 #endif 190 191 #ifdef CONFIG_MIGRATION 192 extern int isolate_lru_page(struct page *p); 193 extern int putback_lru_pages(struct list_head *l); 194 extern int migrate_page(struct page *, struct page *); 195 extern void migrate_page_copy(struct page *, struct page *); 196 extern int migrate_page_remove_references(struct page *, struct page *, int); 197 extern int migrate_pages(struct list_head *l, struct list_head *t, 198 struct list_head *moved, struct list_head *failed); 199 extern int fail_migrate_page(struct page *, struct page *); 200 #else 201 static inline int isolate_lru_page(struct page *p) { return -ENOSYS; } 202 static inline int putback_lru_pages(struct list_head *l) { return 0; } 203 static inline int migrate_pages(struct list_head *l, struct list_head *t, 204 struct list_head *moved, struct list_head *failed) { return -ENOSYS; } 205 /* Possible settings for the migrate_page() method in address_operations */ 206 #define migrate_page NULL 207 #define fail_migrate_page NULL 208 #endif 209 210 #ifdef CONFIG_MMU 211 /* linux/mm/shmem.c */ 212 extern int shmem_unuse(swp_entry_t entry, struct page *page); 213 #endif /* CONFIG_MMU */ 214 215 extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *); 216 217 #ifdef CONFIG_SWAP 218 /* linux/mm/page_io.c */ 219 extern int swap_readpage(struct file *, struct page *); 220 extern int swap_writepage(struct page *page, struct writeback_control *wbc); 221 extern int rw_swap_page_sync(int, swp_entry_t, struct page *); 222 223 /* linux/mm/swap_state.c */ 224 extern struct address_space swapper_space; 225 #define total_swapcache_pages swapper_space.nrpages 226 extern void show_swap_cache_info(void); 227 extern int add_to_swap(struct page *, gfp_t); 228 extern void __delete_from_swap_cache(struct page *); 229 extern void delete_from_swap_cache(struct page *); 230 extern int move_to_swap_cache(struct page *, swp_entry_t); 231 extern int move_from_swap_cache(struct page *, unsigned long, 232 struct address_space *); 233 extern void free_page_and_swap_cache(struct page *); 234 extern void free_pages_and_swap_cache(struct page **, int); 235 extern struct page * lookup_swap_cache(swp_entry_t); 236 extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma, 237 unsigned long addr); 238 /* linux/mm/swapfile.c */ 239 extern long total_swap_pages; 240 extern unsigned int nr_swapfiles; 241 extern struct swap_info_struct swap_info[]; 242 extern void si_swapinfo(struct sysinfo *); 243 extern swp_entry_t get_swap_page(void); 244 extern swp_entry_t get_swap_page_of_type(int type); 245 extern int swap_duplicate(swp_entry_t); 246 extern int valid_swaphandles(swp_entry_t, unsigned long *); 247 extern void swap_free(swp_entry_t); 248 extern void free_swap_and_cache(swp_entry_t); 249 extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t); 250 extern struct swap_info_struct *get_swap_info_struct(unsigned); 251 extern int can_share_swap_page(struct page *); 252 extern int remove_exclusive_swap_page(struct page *); 253 struct backing_dev_info; 254 255 extern spinlock_t swap_lock; 256 extern int remove_vma_swap(struct vm_area_struct *vma, struct page *page); 257 258 /* linux/mm/thrash.c */ 259 extern struct mm_struct * swap_token_mm; 260 extern unsigned long swap_token_default_timeout; 261 extern void grab_swap_token(void); 262 extern void __put_swap_token(struct mm_struct *); 263 264 static inline int has_swap_token(struct mm_struct *mm) 265 { 266 return (mm == swap_token_mm); 267 } 268 269 static inline void put_swap_token(struct mm_struct *mm) 270 { 271 if (has_swap_token(mm)) 272 __put_swap_token(mm); 273 } 274 275 static inline void disable_swap_token(void) 276 { 277 put_swap_token(swap_token_mm); 278 } 279 280 #else /* CONFIG_SWAP */ 281 282 #define total_swap_pages 0 283 #define total_swapcache_pages 0UL 284 285 #define si_swapinfo(val) \ 286 do { (val)->freeswap = (val)->totalswap = 0; } while (0) 287 /* only sparc can not include linux/pagemap.h in this file 288 * so leave page_cache_release and release_pages undeclared... */ 289 #define free_page_and_swap_cache(page) \ 290 page_cache_release(page) 291 #define free_pages_and_swap_cache(pages, nr) \ 292 release_pages((pages), (nr), 0); 293 294 #define show_swap_cache_info() /*NOTHING*/ 295 #define free_swap_and_cache(swp) /*NOTHING*/ 296 #define swap_duplicate(swp) /*NOTHING*/ 297 #define swap_free(swp) /*NOTHING*/ 298 #define read_swap_cache_async(swp,vma,addr) NULL 299 #define lookup_swap_cache(swp) NULL 300 #define valid_swaphandles(swp, off) 0 301 #define can_share_swap_page(p) 0 302 #define move_to_swap_cache(p, swp) 1 303 #define move_from_swap_cache(p, i, m) 1 304 #define __delete_from_swap_cache(p) /*NOTHING*/ 305 #define delete_from_swap_cache(p) /*NOTHING*/ 306 #define swap_token_default_timeout 0 307 308 static inline int remove_exclusive_swap_page(struct page *p) 309 { 310 return 0; 311 } 312 313 static inline swp_entry_t get_swap_page(void) 314 { 315 swp_entry_t entry; 316 entry.val = 0; 317 return entry; 318 } 319 320 /* linux/mm/thrash.c */ 321 #define put_swap_token(x) do { } while(0) 322 #define grab_swap_token() do { } while(0) 323 #define has_swap_token(x) 0 324 #define disable_swap_token() do { } while(0) 325 326 #endif /* CONFIG_SWAP */ 327 #endif /* __KERNEL__*/ 328 #endif /* _LINUX_SWAP_H */ 329