swap.h 10.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
#ifndef _LINUX_SWAP_H
#define _LINUX_SWAP_H

#include <linux/spinlock.h>
#include <linux/linkage.h>
#include <linux/mmzone.h>
#include <linux/list.h>
8
#include <linux/memcontrol.h>
Linus Torvalds's avatar
Linus Torvalds committed
9
#include <linux/sched.h>
Andrew Morton's avatar
Andrew Morton committed
10

Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
#include <asm/atomic.h>
#include <asm/page.h>

14
15
struct notifier_block;

Andrew Morton's avatar
Andrew Morton committed
16
17
struct bio;

Linus Torvalds's avatar
Linus Torvalds committed
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#define SWAP_FLAG_PREFER	0x8000	/* set if swap priority specified */
#define SWAP_FLAG_PRIO_MASK	0x7fff
#define SWAP_FLAG_PRIO_SHIFT	0

static inline int current_is_kswapd(void)
{
	return current->flags & PF_KSWAPD;
}

/*
 * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
 * be swapped to.  The swap type and the offset into that swap type are
 * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
 * for the type means that the maximum number of swapcache pages is 27 bits
 * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
 * the type/offset into the pte as 5/27 as well.
 */
#define MAX_SWAPFILES_SHIFT	5
36
#ifndef CONFIG_MIGRATION
Linus Torvalds's avatar
Linus Torvalds committed
37
#define MAX_SWAPFILES		(1 << MAX_SWAPFILES_SHIFT)
38
39
40
41
42
43
#else
/* Use last two entries for page migration swap entries */
#define MAX_SWAPFILES		((1 << MAX_SWAPFILES_SHIFT)-2)
#define SWP_MIGRATION_READ	MAX_SWAPFILES
#define SWP_MIGRATION_WRITE	(MAX_SWAPFILES + 1)
#endif
Linus Torvalds's avatar
Linus Torvalds committed
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/*
 * Magic header for a swap area. The first part of the union is
 * what the swap magic looks like for the old (limited to 128MB)
 * swap area format, the second part of the union adds - in the
 * old reserved area - some extra information. Note that the first
 * kilobyte is reserved for boot loader or disk label stuff...
 *
 * Having the magic at the end of the PAGE_SIZE makes detecting swap
 * areas somewhat tricky on machines that support multiple page sizes.
 * For 2.5 we'll probably want to move the magic to just beyond the
 * bootbits...
 */
union swap_header {
	struct {
		char reserved[PAGE_SIZE - 10];
		char magic[10];			/* SWAP-SPACE or SWAPSPACE2 */
	} magic;
	struct {
63
64
65
66
67
68
69
70
		char		bootbits[1024];	/* Space for disklabel etc. */
		__u32		version;
		__u32		last_page;
		__u32		nr_badpages;
		unsigned char	sws_uuid[16];
		unsigned char	sws_volume[16];
		__u32		padding[117];
		__u32		badpages[1];
Linus Torvalds's avatar
Linus Torvalds committed
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
	} info;
};

 /* A swap entry has to fit into a "unsigned long", as
  * the entry is hidden in the "index" field of the
  * swapper address space.
  */
typedef struct {
	unsigned long val;
} swp_entry_t;

/*
 * current->reclaim_state points to one of these when a task is running
 * memory reclaim
 */
struct reclaim_state {
	unsigned long reclaimed_slab;
};

#ifdef __KERNEL__

struct address_space;
struct sysinfo;
struct writeback_control;
struct zone;

/*
 * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
 * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
 * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
 * from setup, they're handled identically.
 *
 * We always assume that blocks are of size PAGE_SIZE.
 */
struct swap_extent {
	struct list_head list;
	pgoff_t start_page;
	pgoff_t nr_pages;
	sector_t start_block;
};

/*
 * Max bad pages in the new format..
 */
#define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
#define MAX_SWAP_BADPAGES \
	((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))

enum {
	SWP_USED	= (1 << 0),	/* is slot in swap_info[] used? */
	SWP_WRITEOK	= (1 << 1),	/* ok to write to this swap?	*/
	SWP_ACTIVE	= (SWP_USED | SWP_WRITEOK),
123
124
					/* add others here before... */
	SWP_SCANNING	= (1 << 8),	/* refcount in scan_swap_map */
Linus Torvalds's avatar
Linus Torvalds committed
125
126
127
128
129
130
131
132
133
134
135
136
};

#define SWAP_CLUSTER_MAX 32

#define SWAP_MAP_MAX	0x7fff
#define SWAP_MAP_BAD	0x8000

/*
 * The in-memory structure used to track swap areas.
 */
struct swap_info_struct {
	unsigned int flags;
137
	int prio;			/* swap priority */
Linus Torvalds's avatar
Linus Torvalds committed
138
139
140
141
142
143
144
145
146
147
	struct file *swap_file;
	struct block_device *bdev;
	struct list_head extent_list;
	struct swap_extent *curr_swap_extent;
	unsigned old_block_size;
	unsigned short * swap_map;
	unsigned int lowest_bit;
	unsigned int highest_bit;
	unsigned int cluster_next;
	unsigned int cluster_nr;
148
149
150
	unsigned int pages;
	unsigned int max;
	unsigned int inuse_pages;
Linus Torvalds's avatar
Linus Torvalds committed
151
152
153
154
155
156
157
158
159
160
161
162
163
	int next;			/* next entry on swap list */
};

struct swap_list_t {
	int head;	/* head of priority-ordered swapfile list */
	int next;	/* swapfile to be used next */
};

/* Swap 50% full? Release swapcache more aggressively.. */
#define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)

/* linux/mm/page_alloc.c */
extern unsigned long totalram_pages;
164
extern unsigned long totalreserve_pages;
Linus Torvalds's avatar
Linus Torvalds committed
165
166
167
168
extern long nr_swap_pages;
extern unsigned int nr_free_buffer_pages(void);
extern unsigned int nr_free_pagecache_pages(void);

Christoph Lameter's avatar
Christoph Lameter committed
169
170
171
172
/* Definition of global_page_state not available yet */
#define nr_free_pages() global_page_state(NR_FREE_PAGES)


Linus Torvalds's avatar
Linus Torvalds committed
173
/* linux/mm/swap.c */
174
175
extern void __lru_cache_add(struct page *, enum lru_list lru);
extern void lru_cache_add_lru(struct page *, enum lru_list lru);
176
177
extern void activate_page(struct page *);
extern void mark_page_accessed(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
178
extern void lru_add_drain(void);
179
extern int lru_add_drain_all(void);
180
extern void rotate_reclaimable_page(struct page *page);
Linus Torvalds's avatar
Linus Torvalds committed
181
182
extern void swap_setup(void);

183
184
185
186
/**
 * lru_cache_add: add a page to the page lists
 * @page: the page to add
 */
187
static inline void lru_cache_add_anon(struct page *page)
188
{
189
	__lru_cache_add(page, LRU_INACTIVE_ANON);
190
191
}

192
static inline void lru_cache_add_active_anon(struct page *page)
193
{
194
195
196
197
198
199
200
201
202
203
204
	__lru_cache_add(page, LRU_ACTIVE_ANON);
}

static inline void lru_cache_add_file(struct page *page)
{
	__lru_cache_add(page, LRU_INACTIVE_FILE);
}

static inline void lru_cache_add_active_file(struct page *page)
{
	__lru_cache_add(page, LRU_ACTIVE_FILE);
205
206
}

Linus Torvalds's avatar
Linus Torvalds committed
207
/* linux/mm/vmscan.c */
208
extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
Andy Whitcroft's avatar
Andy Whitcroft committed
209
					gfp_t gfp_mask);
210
211
extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
							gfp_t gfp_mask);
212
extern int __isolate_lru_page(struct page *page, int mode, int file);
213
extern unsigned long shrink_all_memory(unsigned long nr_pages);
Linus Torvalds's avatar
Linus Torvalds committed
214
extern int vm_swappiness;
215
extern int remove_mapping(struct address_space *mapping, struct page *page);
216
extern long vm_total_pages;
217

218
219
#ifdef CONFIG_NUMA
extern int zone_reclaim_mode;
220
extern int sysctl_min_unmapped_ratio;
221
extern int sysctl_min_slab_ratio;
222
223
224
225
226
227
228
229
230
extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
#else
#define zone_reclaim_mode 0
static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
{
	return 0;
}
#endif

231
232
extern int kswapd_run(int nid);

Linus Torvalds's avatar
Linus Torvalds committed
233
234
235
236
237
238
239
240
241
242
243
#ifdef CONFIG_MMU
/* linux/mm/shmem.c */
extern int shmem_unuse(swp_entry_t entry, struct page *page);
#endif /* CONFIG_MMU */

extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);

#ifdef CONFIG_SWAP
/* linux/mm/page_io.c */
extern int swap_readpage(struct file *, struct page *);
extern int swap_writepage(struct page *page, struct writeback_control *wbc);
244
extern void end_swap_bio_read(struct bio *bio, int err);
Linus Torvalds's avatar
Linus Torvalds committed
245
246
247
248
249

/* linux/mm/swap_state.c */
extern struct address_space swapper_space;
#define total_swapcache_pages  swapper_space.nrpages
extern void show_swap_cache_info(void);
250
extern int add_to_swap(struct page *, gfp_t);
251
extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
Linus Torvalds's avatar
Linus Torvalds committed
252
253
254
255
extern void __delete_from_swap_cache(struct page *);
extern void delete_from_swap_cache(struct page *);
extern void free_page_and_swap_cache(struct page *);
extern void free_pages_and_swap_cache(struct page **, int);
256
extern struct page *lookup_swap_cache(swp_entry_t);
257
extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
258
			struct vm_area_struct *vma, unsigned long addr);
259
extern struct page *swapin_readahead(swp_entry_t, gfp_t,
260
261
			struct vm_area_struct *vma, unsigned long addr);

Linus Torvalds's avatar
Linus Torvalds committed
262
263
264
265
/* linux/mm/swapfile.c */
extern long total_swap_pages;
extern void si_swapinfo(struct sysinfo *);
extern swp_entry_t get_swap_page(void);
266
extern swp_entry_t get_swap_page_of_type(int);
Linus Torvalds's avatar
Linus Torvalds committed
267
268
269
270
extern int swap_duplicate(swp_entry_t);
extern int valid_swaphandles(swp_entry_t, unsigned long *);
extern void swap_free(swp_entry_t);
extern void free_swap_and_cache(swp_entry_t);
271
extern int swap_type_of(dev_t, sector_t, struct block_device **);
272
extern unsigned int count_swap_pages(int, int);
Linus Torvalds's avatar
Linus Torvalds committed
273
extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
274
extern sector_t swapdev_block(int, pgoff_t);
Linus Torvalds's avatar
Linus Torvalds committed
275
276
277
extern struct swap_info_struct *get_swap_info_struct(unsigned);
extern int can_share_swap_page(struct page *);
extern int remove_exclusive_swap_page(struct page *);
278
extern int remove_exclusive_swap_page_ref(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
struct backing_dev_info;

/* linux/mm/thrash.c */
extern struct mm_struct * swap_token_mm;
extern void grab_swap_token(void);
extern void __put_swap_token(struct mm_struct *);

static inline int has_swap_token(struct mm_struct *mm)
{
	return (mm == swap_token_mm);
}

static inline void put_swap_token(struct mm_struct *mm)
{
	if (has_swap_token(mm))
		__put_swap_token(mm);
}

297
298
299
300
301
static inline void disable_swap_token(void)
{
	put_swap_token(swap_token_mm);
}

Linus Torvalds's avatar
Linus Torvalds committed
302
303
304
305
306
307
308
#else /* CONFIG_SWAP */

#define total_swap_pages			0
#define total_swapcache_pages			0UL

#define si_swapinfo(val) \
	do { (val)->freeswap = (val)->totalswap = 0; } while (0)
309
310
/* only sparc can not include linux/pagemap.h in this file
 * so leave page_cache_release and release_pages undeclared... */
Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
314
315
#define free_page_and_swap_cache(page) \
	page_cache_release(page)
#define free_pages_and_swap_cache(pages, nr) \
	release_pages((pages), (nr), 0);

316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
static inline void show_swap_cache_info(void)
{
}

static inline void free_swap_and_cache(swp_entry_t swp)
{
}

static inline int swap_duplicate(swp_entry_t swp)
{
	return 0;
}

static inline void swap_free(swp_entry_t swp)
{
}

333
static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
334
335
336
337
338
339
340
341
342
343
			struct vm_area_struct *vma, unsigned long addr)
{
	return NULL;
}

static inline struct page *lookup_swap_cache(swp_entry_t swp)
{
	return NULL;
}

344
#define can_share_swap_page(p)			(page_mapcount(p) == 1)
345

346
347
static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
							gfp_t gfp_mask)
348
{
349
	return -1;
350
351
352
353
354
355
356
357
358
359
}

static inline void __delete_from_swap_cache(struct page *page)
{
}

static inline void delete_from_swap_cache(struct page *page)
{
}

Linus Torvalds's avatar
Linus Torvalds committed
360
361
362
363
364
365
366
#define swap_token_default_timeout		0

static inline int remove_exclusive_swap_page(struct page *p)
{
	return 0;
}

367
368
369
370
371
static inline int remove_exclusive_swap_page_ref(struct page *page)
{
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
372
373
374
375
376
377
378
379
380
381
382
static inline swp_entry_t get_swap_page(void)
{
	swp_entry_t entry;
	entry.val = 0;
	return entry;
}

/* linux/mm/thrash.c */
#define put_swap_token(x) do { } while(0)
#define grab_swap_token()  do { } while(0)
#define has_swap_token(x) 0
383
#define disable_swap_token() do { } while(0)
Linus Torvalds's avatar
Linus Torvalds committed
384
385
386
387

#endif /* CONFIG_SWAP */
#endif /* __KERNEL__*/
#endif /* _LINUX_SWAP_H */