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 rotate_reclaimable_page(struct page *page); 171 extern void swap_setup(void); 172 173 /* linux/mm/vmscan.c */ 174 extern int try_to_free_pages(struct zone **, gfp_t); 175 extern int shrink_all_memory(int); 176 extern int vm_swappiness; 177 178 #ifdef CONFIG_MIGRATION 179 extern int isolate_lru_page(struct page *p); 180 extern int putback_lru_pages(struct list_head *l); 181 extern int migrate_pages(struct list_head *l, struct list_head *t, 182 struct list_head *moved, struct list_head *failed); 183 #endif 184 185 #ifdef CONFIG_MMU 186 /* linux/mm/shmem.c */ 187 extern int shmem_unuse(swp_entry_t entry, struct page *page); 188 #endif /* CONFIG_MMU */ 189 190 extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *); 191 192 #ifdef CONFIG_SWAP 193 /* linux/mm/page_io.c */ 194 extern int swap_readpage(struct file *, struct page *); 195 extern int swap_writepage(struct page *page, struct writeback_control *wbc); 196 extern int rw_swap_page_sync(int, swp_entry_t, struct page *); 197 198 /* linux/mm/swap_state.c */ 199 extern struct address_space swapper_space; 200 #define total_swapcache_pages swapper_space.nrpages 201 extern void show_swap_cache_info(void); 202 extern int add_to_swap(struct page *, gfp_t); 203 extern void __delete_from_swap_cache(struct page *); 204 extern void delete_from_swap_cache(struct page *); 205 extern int move_to_swap_cache(struct page *, swp_entry_t); 206 extern int move_from_swap_cache(struct page *, unsigned long, 207 struct address_space *); 208 extern void free_page_and_swap_cache(struct page *); 209 extern void free_pages_and_swap_cache(struct page **, int); 210 extern struct page * lookup_swap_cache(swp_entry_t); 211 extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma, 212 unsigned long addr); 213 /* linux/mm/swapfile.c */ 214 extern long total_swap_pages; 215 extern unsigned int nr_swapfiles; 216 extern struct swap_info_struct swap_info[]; 217 extern void si_swapinfo(struct sysinfo *); 218 extern swp_entry_t get_swap_page(void); 219 extern swp_entry_t get_swap_page_of_type(int type); 220 extern int swap_duplicate(swp_entry_t); 221 extern int valid_swaphandles(swp_entry_t, unsigned long *); 222 extern void swap_free(swp_entry_t); 223 extern void free_swap_and_cache(swp_entry_t); 224 extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t); 225 extern struct swap_info_struct *get_swap_info_struct(unsigned); 226 extern int can_share_swap_page(struct page *); 227 extern int remove_exclusive_swap_page(struct page *); 228 struct backing_dev_info; 229 230 extern spinlock_t swap_lock; 231 232 /* linux/mm/thrash.c */ 233 extern struct mm_struct * swap_token_mm; 234 extern unsigned long swap_token_default_timeout; 235 extern void grab_swap_token(void); 236 extern void __put_swap_token(struct mm_struct *); 237 238 static inline int has_swap_token(struct mm_struct *mm) 239 { 240 return (mm == swap_token_mm); 241 } 242 243 static inline void put_swap_token(struct mm_struct *mm) 244 { 245 if (has_swap_token(mm)) 246 __put_swap_token(mm); 247 } 248 249 static inline void disable_swap_token(void) 250 { 251 put_swap_token(swap_token_mm); 252 } 253 254 #else /* CONFIG_SWAP */ 255 256 #define total_swap_pages 0 257 #define total_swapcache_pages 0UL 258 259 #define si_swapinfo(val) \ 260 do { (val)->freeswap = (val)->totalswap = 0; } while (0) 261 /* only sparc can not include linux/pagemap.h in this file 262 * so leave page_cache_release and release_pages undeclared... */ 263 #define free_page_and_swap_cache(page) \ 264 page_cache_release(page) 265 #define free_pages_and_swap_cache(pages, nr) \ 266 release_pages((pages), (nr), 0); 267 268 #define show_swap_cache_info() /*NOTHING*/ 269 #define free_swap_and_cache(swp) /*NOTHING*/ 270 #define swap_duplicate(swp) /*NOTHING*/ 271 #define swap_free(swp) /*NOTHING*/ 272 #define read_swap_cache_async(swp,vma,addr) NULL 273 #define lookup_swap_cache(swp) NULL 274 #define valid_swaphandles(swp, off) 0 275 #define can_share_swap_page(p) 0 276 #define move_to_swap_cache(p, swp) 1 277 #define move_from_swap_cache(p, i, m) 1 278 #define __delete_from_swap_cache(p) /*NOTHING*/ 279 #define delete_from_swap_cache(p) /*NOTHING*/ 280 #define swap_token_default_timeout 0 281 282 static inline int remove_exclusive_swap_page(struct page *p) 283 { 284 return 0; 285 } 286 287 static inline swp_entry_t get_swap_page(void) 288 { 289 swp_entry_t entry; 290 entry.val = 0; 291 return entry; 292 } 293 294 /* linux/mm/thrash.c */ 295 #define put_swap_token(x) do { } while(0) 296 #define grab_swap_token() do { } while(0) 297 #define has_swap_token(x) 0 298 #define disable_swap_token() do { } while(0) 299 300 #endif /* CONFIG_SWAP */ 301 #endif /* __KERNEL__*/ 302 #endif /* _LINUX_SWAP_H */ 303