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
current_is_kswapd(void)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
zone_reclaim(struct zone * z,gfp_t mask,unsigned int order)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
has_swap_token(struct mm_struct * mm)258 static inline int has_swap_token(struct mm_struct *mm)
259 {
260 return (mm == swap_token_mm);
261 }
262
put_swap_token(struct mm_struct * mm)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
disable_swap_token(void)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
show_swap_cache_info(void)288 static inline void show_swap_cache_info(void)
289 {
290 }
291
free_swap_and_cache(swp_entry_t swp)292 static inline void free_swap_and_cache(swp_entry_t swp)
293 {
294 }
295
swap_duplicate(swp_entry_t swp)296 static inline int swap_duplicate(swp_entry_t swp)
297 {
298 return 0;
299 }
300
swap_free(swp_entry_t swp)301 static inline void swap_free(swp_entry_t swp)
302 {
303 }
304
read_swap_cache_async(swp_entry_t swp,struct vm_area_struct * vma,unsigned long addr)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
lookup_swap_cache(swp_entry_t swp)311 static inline struct page *lookup_swap_cache(swp_entry_t swp)
312 {
313 return NULL;
314 }
315
valid_swaphandles(swp_entry_t entry,unsigned long * offset)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
move_to_swap_cache(struct page * page,swp_entry_t entry)323 static inline int move_to_swap_cache(struct page *page, swp_entry_t entry)
324 {
325 return 1;
326 }
327
move_from_swap_cache(struct page * page,unsigned long index,struct address_space * mapping)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
__delete_from_swap_cache(struct page * page)334 static inline void __delete_from_swap_cache(struct page *page)
335 {
336 }
337
delete_from_swap_cache(struct page * page)338 static inline void delete_from_swap_cache(struct page *page)
339 {
340 }
341
342 #define swap_token_default_timeout 0
343
remove_exclusive_swap_page(struct page * p)344 static inline int remove_exclusive_swap_page(struct page *p)
345 {
346 return 0;
347 }
348
get_swap_page(void)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