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