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 17static 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 */ 52union 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 */ 73typedef 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 */ 81struct reclaim_state { 82 unsigned long reclaimed_slab; 83}; 84 85#ifdef __KERNEL__ 86 87struct address_space; 88struct sysinfo; 89struct writeback_control; 90struct 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 */ 100struct 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 114enum { 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 */ 130struct 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 149struct 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 */ 158extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order); 159 160/* linux/mm/memory.c */ 161extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *); 162 163/* linux/mm/page_alloc.c */ 164extern unsigned long totalram_pages; 165extern unsigned long totalhigh_pages; 166extern unsigned long totalreserve_pages; 167extern long nr_swap_pages; 168extern unsigned int nr_free_pages(void); 169extern unsigned int nr_free_pages_pgdat(pg_data_t *pgdat); 170extern unsigned int nr_free_buffer_pages(void); 171extern unsigned int nr_free_pagecache_pages(void); 172 173/* linux/mm/swap.c */ 174extern void FASTCALL(lru_cache_add(struct page *)); 175extern void FASTCALL(lru_cache_add_active(struct page *)); 176extern void FASTCALL(activate_page(struct page *)); 177extern void FASTCALL(mark_page_accessed(struct page *)); 178extern void lru_add_drain(void); 179extern int lru_add_drain_all(void); 180extern int rotate_reclaimable_page(struct page *page); 181extern void swap_setup(void); 182 183/* linux/mm/vmscan.c */ 184extern unsigned long try_to_free_pages(struct zone **, gfp_t); 185extern unsigned long shrink_all_memory(unsigned long nr_pages); 186extern int vm_swappiness; 187extern int remove_mapping(struct address_space *mapping, struct page *page); 188extern long vm_total_pages; 189 190#ifdef CONFIG_NUMA 191extern int zone_reclaim_mode; 192extern int sysctl_min_unmapped_ratio; 193extern int zone_reclaim(struct zone *, gfp_t, unsigned int); 194#else 195#define zone_reclaim_mode 0 196static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order) 197{ 198 return 0; 199} 200#endif 201 202extern int kswapd_run(int nid); 203 204#ifdef CONFIG_MMU 205/* linux/mm/shmem.c */ 206extern int shmem_unuse(swp_entry_t entry, struct page *page); 207#endif /* CONFIG_MMU */ 208 209extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *); 210 211#ifdef CONFIG_SWAP 212/* linux/mm/page_io.c */ 213extern int swap_readpage(struct file *, struct page *); 214extern int swap_writepage(struct page *page, struct writeback_control *wbc); 215extern int rw_swap_page_sync(int, swp_entry_t, struct page *); 216 217/* linux/mm/swap_state.c */ 218extern struct address_space swapper_space; 219#define total_swapcache_pages swapper_space.nrpages 220extern void show_swap_cache_info(void); 221extern int add_to_swap(struct page *, gfp_t); 222extern void __delete_from_swap_cache(struct page *); 223extern void delete_from_swap_cache(struct page *); 224extern int move_to_swap_cache(struct page *, swp_entry_t); 225extern int move_from_swap_cache(struct page *, unsigned long, 226 struct address_space *); 227extern void free_page_and_swap_cache(struct page *); 228extern void free_pages_and_swap_cache(struct page **, int); 229extern struct page * lookup_swap_cache(swp_entry_t); 230extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma, 231 unsigned long addr); 232/* linux/mm/swapfile.c */ 233extern long total_swap_pages; 234extern unsigned int nr_swapfiles; 235extern void si_swapinfo(struct sysinfo *); 236extern swp_entry_t get_swap_page(void); 237extern swp_entry_t get_swap_page_of_type(int); 238extern int swap_duplicate(swp_entry_t); 239extern int valid_swaphandles(swp_entry_t, unsigned long *); 240extern void swap_free(swp_entry_t); 241extern void free_swap_and_cache(swp_entry_t); 242extern int swap_type_of(dev_t); 243extern unsigned int count_swap_pages(int, int); 244extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t); 245extern struct swap_info_struct *get_swap_info_struct(unsigned); 246extern int can_share_swap_page(struct page *); 247extern int remove_exclusive_swap_page(struct page *); 248struct backing_dev_info; 249 250extern spinlock_t swap_lock; 251 252/* linux/mm/thrash.c */ 253extern struct mm_struct * swap_token_mm; 254extern unsigned long swap_token_default_timeout; 255extern void grab_swap_token(void); 256extern void __put_swap_token(struct mm_struct *); 257 258static inline int has_swap_token(struct mm_struct *mm) 259{ 260 return (mm == swap_token_mm); 261} 262 263static inline void put_swap_token(struct mm_struct *mm) 264{ 265 if (has_swap_token(mm)) 266 __put_swap_token(mm); 267} 268 269static 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 288static inline void show_swap_cache_info(void) 289{ 290} 291 292static inline void free_swap_and_cache(swp_entry_t swp) 293{ 294} 295 296static inline int swap_duplicate(swp_entry_t swp) 297{ 298 return 0; 299} 300 301static inline void swap_free(swp_entry_t swp) 302{ 303} 304 305static 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 311static inline struct page *lookup_swap_cache(swp_entry_t swp) 312{ 313 return NULL; 314} 315 316static 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 323static inline int move_to_swap_cache(struct page *page, swp_entry_t entry) 324{ 325 return 1; 326} 327 328static inline int move_from_swap_cache(struct page *page, unsigned long index, 329 struct address_space *mapping) 330{ 331 return 1; 332} 333 334static inline void __delete_from_swap_cache(struct page *page) 335{ 336} 337 338static inline void delete_from_swap_cache(struct page *page) 339{ 340} 341 342#define swap_token_default_timeout 0 343 344static inline int remove_exclusive_swap_page(struct page *p) 345{ 346 return 0; 347} 348 349static 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