swap.h 17.2 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>
10
#include <linux/node.h>
11
#include <linux/fs.h>
Arun Sharma's avatar
Arun Sharma committed
12
#include <linux/atomic.h>
13
#include <linux/page-flags.h>
Linus Torvalds's avatar
Linus Torvalds committed
14 15
#include <asm/page.h>

16 17
struct notifier_block;

Andrew Morton's avatar
Andrew Morton committed
18 19
struct bio;

Linus Torvalds's avatar
Linus Torvalds committed
20 21 22
#define SWAP_FLAG_PREFER	0x8000	/* set if swap priority specified */
#define SWAP_FLAG_PRIO_MASK	0x7fff
#define SWAP_FLAG_PRIO_SHIFT	0
23 24 25
#define SWAP_FLAG_DISCARD	0x10000 /* enable discard for swap */
#define SWAP_FLAG_DISCARD_ONCE	0x20000 /* discard swap area at swapon-time */
#define SWAP_FLAG_DISCARD_PAGES 0x40000 /* discard page-clusters after use */
Linus Torvalds's avatar
Linus Torvalds committed
26

27
#define SWAP_FLAGS_VALID	(SWAP_FLAG_PRIO_MASK | SWAP_FLAG_PREFER | \
28 29
				 SWAP_FLAG_DISCARD | SWAP_FLAG_DISCARD_ONCE | \
				 SWAP_FLAG_DISCARD_PAGES)
30

Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36 37 38 39 40 41 42 43 44
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
45 46 47 48 49 50 51 52 53 54 55 56 57 58

/*
 * Use some of the swap files numbers for other purposes. This
 * is a convenient way to hook into the VM to trigger special
 * actions on faults.
 */

/*
 * NUMA node memory migration support
 */
#ifdef CONFIG_MIGRATION
#define SWP_MIGRATION_NUM 2
#define SWP_MIGRATION_READ	(MAX_SWAPFILES + SWP_HWPOISON_NUM)
#define SWP_MIGRATION_WRITE	(MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
59
#else
60
#define SWP_MIGRATION_NUM 0
61
#endif
Linus Torvalds's avatar
Linus Torvalds committed
62

63 64 65 66 67 68 69 70 71 72 73 74 75
/*
 * Handling of hardware poisoned pages with memory corruption.
 */
#ifdef CONFIG_MEMORY_FAILURE
#define SWP_HWPOISON_NUM 1
#define SWP_HWPOISON		MAX_SWAPFILES
#else
#define SWP_HWPOISON_NUM 0
#endif

#define MAX_SWAPFILES \
	((1 << MAX_SWAPFILES_SHIFT) - SWP_MIGRATION_NUM - SWP_HWPOISON_NUM)

Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
/*
 * 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 {
94 95 96 97 98 99 100 101
		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
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
	} 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?	*/
153
	SWP_DISCARDABLE = (1 << 2),	/* blkdev support discard */
154
	SWP_DISCARDING	= (1 << 3),	/* now discarding a free cluster */
155
	SWP_SOLIDSTATE	= (1 << 4),	/* blkdev seeks are cheap */
156
	SWP_CONTINUED	= (1 << 5),	/* swap_map has count continuation */
157
	SWP_BLKDEV	= (1 << 6),	/* its a block device */
158
	SWP_FILE	= (1 << 7),	/* set after swap_activate success */
159 160
	SWP_AREA_DISCARD = (1 << 8),	/* single-time swap area discards */
	SWP_PAGE_DISCARD = (1 << 9),	/* freed swap page-cluster discards */
161
					/* add others here before... */
162
	SWP_SCANNING	= (1 << 10),	/* refcount in scan_swap_map */
Linus Torvalds's avatar
Linus Torvalds committed
163 164
};

165
#define SWAP_CLUSTER_MAX 32UL
166
#define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
Linus Torvalds's avatar
Linus Torvalds committed
167

168 169 170 171 172 173 174 175 176
/*
 * Ratio between the present memory in the zone and the "gap" that
 * we're allowing kswapd to shrink in addition to the per-zone high
 * wmark, even for zones that already have the high wmark satisfied,
 * in order to provide better per-zone lru behavior. We are ok to
 * spend not more than 1% of the memory for this zone balancing "gap".
 */
#define KSWAPD_ZONE_BALANCE_GAP_RATIO 100

177 178 179 180 181
#define SWAP_MAP_MAX	0x3e	/* Max duplication count, in first swap_map */
#define SWAP_MAP_BAD	0x3f	/* Note pageblock is bad, in first swap_map */
#define SWAP_HAS_CACHE	0x40	/* Flag page is cached, in first swap_map */
#define SWAP_CONT_MAX	0x7f	/* Max count, in each swap_map continuation */
#define COUNT_CONTINUED	0x80	/* See swap_map continuation for full count */
Hugh Dickins's avatar
Hugh Dickins committed
182
#define SWAP_MAP_SHMEM	0xbf	/* Owned by shmem/tmpfs, in first swap_map */
183

184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
/*
 * We use this to track usage of a cluster. A cluster is a block of swap disk
 * space with SWAPFILE_CLUSTER pages long and naturally aligns in disk. All
 * free clusters are organized into a list. We fetch an entry from the list to
 * get a free cluster.
 *
 * The data field stores next cluster if the cluster is free or cluster usage
 * counter otherwise. The flags field determines if a cluster is free. This is
 * protected by swap_info_struct.lock.
 */
struct swap_cluster_info {
	unsigned int data:24;
	unsigned int flags:8;
};
#define CLUSTER_FLAG_FREE 1 /* This cluster is free */
#define CLUSTER_FLAG_NEXT_NULL 2 /* This cluster has no next cluster */

201 202 203 204 205 206 207 208 209 210
/*
 * We assign a cluster to each CPU, so each CPU can allocate swap entry from
 * its own cluster and swapout sequentially. The purpose is to optimize swapout
 * throughput.
 */
struct percpu_cluster {
	struct swap_cluster_info index; /* Current cluster index */
	unsigned int next; /* Likely next allocation offset */
};

Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214
/*
 * The in-memory structure used to track swap areas.
 */
struct swap_info_struct {
215 216 217 218
	unsigned long	flags;		/* SWP_USED etc: see above */
	signed short	prio;		/* swap priority of this type */
	signed char	type;		/* strange name for an index */
	signed char	next;		/* next type on the swap list */
Hugh Dickins's avatar
Hugh Dickins committed
219 220
	unsigned int	max;		/* extent of the swap_map */
	unsigned char *swap_map;	/* vmalloc'ed array of usage counts */
221 222 223
	struct swap_cluster_info *cluster_info; /* cluster info. Only for SSD */
	struct swap_cluster_info free_cluster_head; /* free cluster list head */
	struct swap_cluster_info free_cluster_tail; /* free cluster list tail */
Hugh Dickins's avatar
Hugh Dickins committed
224 225 226 227 228 229
	unsigned int lowest_bit;	/* index of first free in swap_map */
	unsigned int highest_bit;	/* index of last free in swap_map */
	unsigned int pages;		/* total of usable pages of swap */
	unsigned int inuse_pages;	/* number of those currently in use */
	unsigned int cluster_next;	/* likely index for next allocation */
	unsigned int cluster_nr;	/* countdown to next cluster search */
230
	struct percpu_cluster __percpu *percpu_cluster; /* per cpu's swap location */
Hugh Dickins's avatar
Hugh Dickins committed
231 232 233 234 235
	struct swap_extent *curr_swap_extent;
	struct swap_extent first_swap_extent;
	struct block_device *bdev;	/* swap device or bdev of swap file */
	struct file *swap_file;		/* seldom referenced */
	unsigned int old_block_size;	/* seldom referenced */
236 237 238 239
#ifdef CONFIG_FRONTSWAP
	unsigned long *frontswap_map;	/* frontswap in-use, one bit per page */
	atomic_t frontswap_pages;	/* frontswap pages in-use counter */
#endif
240 241 242 243
	spinlock_t lock;		/*
					 * protect map scan related fields like
					 * swap_map, lowest_bit, highest_bit,
					 * inuse_pages, cluster_next,
Shaohua Li's avatar
Shaohua Li committed
244 245 246 247 248 249 250 251
					 * cluster_nr, lowest_alloc,
					 * highest_alloc, free/discard cluster
					 * list. other fields are only changed
					 * at swapon/swapoff, so are protected
					 * by swap_lock. changing flags need
					 * hold this lock and swap_lock. If
					 * both locks need hold, hold swap_lock
					 * first.
252
					 */
Shaohua Li's avatar
Shaohua Li committed
253 254 255
	struct work_struct discard_work; /* discard worker */
	struct swap_cluster_info discard_cluster_head; /* list head of discard clusters */
	struct swap_cluster_info discard_cluster_tail; /* list tail of discard clusters */
Linus Torvalds's avatar
Linus Torvalds committed
256 257 258 259 260 261 262 263 264
};

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

/* linux/mm/page_alloc.c */
extern unsigned long totalram_pages;
265
extern unsigned long totalreserve_pages;
266
extern unsigned long dirty_balance_reserve;
267 268
extern unsigned long nr_free_buffer_pages(void);
extern unsigned long nr_free_pagecache_pages(void);
Linus Torvalds's avatar
Linus Torvalds committed
269

Christoph Lameter's avatar
Christoph Lameter committed
270 271 272 273
/* 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
274
/* linux/mm/swap.c */
275 276
extern void __lru_cache_add(struct page *);
extern void lru_cache_add(struct page *);
277
extern void lru_add_page_tail(struct page *page, struct page *page_tail,
278
			 struct lruvec *lruvec, struct list_head *head);
279 280
extern void activate_page(struct page *);
extern void mark_page_accessed(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
281
extern void lru_add_drain(void);
282
extern void lru_add_drain_cpu(int cpu);
283
extern int lru_add_drain_all(void);
284
extern void rotate_reclaimable_page(struct page *page);
Minchan Kim's avatar
Minchan Kim committed
285
extern void deactivate_page(struct page *page);
Linus Torvalds's avatar
Linus Torvalds committed
286 287
extern void swap_setup(void);

288 289
extern void add_page_to_unevictable_list(struct page *page);

290 291 292 293
/**
 * lru_cache_add: add a page to the page lists
 * @page: the page to add
 */
294
static inline void lru_cache_add_anon(struct page *page)
295
{
296 297
	ClearPageActive(page);
	__lru_cache_add(page);
298 299
}

300 301
static inline void lru_cache_add_file(struct page *page)
{
302 303
	ClearPageActive(page);
	__lru_cache_add(page);
304 305
}

Linus Torvalds's avatar
Linus Torvalds committed
306
/* linux/mm/vmscan.c */
307
extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
308
					gfp_t gfp_mask, nodemask_t *mask);
309
extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
310 311 312 313 314 315
extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
						  gfp_t gfp_mask, bool noswap);
extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
						gfp_t gfp_mask, bool noswap,
						struct zone *zone,
						unsigned long *nr_scanned);
316
extern unsigned long shrink_all_memory(unsigned long nr_pages);
Linus Torvalds's avatar
Linus Torvalds committed
317
extern int vm_swappiness;
318
extern int remove_mapping(struct address_space *mapping, struct page *page);
319
extern unsigned long vm_total_pages;
320

321 322
#ifdef CONFIG_NUMA
extern int zone_reclaim_mode;
323
extern int sysctl_min_unmapped_ratio;
324
extern int sysctl_min_slab_ratio;
325 326 327 328 329 330 331 332 333
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

334
extern int page_evictable(struct page *page);
335
extern void check_move_unevictable_pages(struct page **, int nr_pages);
336 337

extern unsigned long scan_unevictable_pages;
338
extern int scan_unevictable_handler(struct ctl_table *, int,
339
					void __user *, size_t *, loff_t *);
340
#ifdef CONFIG_NUMA
341 342
extern int scan_unevictable_register_node(struct node *node);
extern void scan_unevictable_unregister_node(struct node *node);
343 344 345 346 347 348 349 350 351
#else
static inline int scan_unevictable_register_node(struct node *node)
{
	return 0;
}
static inline void scan_unevictable_unregister_node(struct node *node)
{
}
#endif
352

353
extern int kswapd_run(int nid);
354
extern void kswapd_stop(int nid);
Andrew Morton's avatar
Andrew Morton committed
355
#ifdef CONFIG_MEMCG
356 357 358 359 360 361 362
extern int mem_cgroup_swappiness(struct mem_cgroup *mem);
#else
static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
{
	return vm_swappiness;
}
#endif
Andrew Morton's avatar
Andrew Morton committed
363
#ifdef CONFIG_MEMCG_SWAP
364 365 366 367 368 369
extern void mem_cgroup_uncharge_swap(swp_entry_t ent);
#else
static inline void mem_cgroup_uncharge_swap(swp_entry_t ent)
{
}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
370 371
#ifdef CONFIG_SWAP
/* linux/mm/page_io.c */
372
extern int swap_readpage(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
373
extern int swap_writepage(struct page *page, struct writeback_control *wbc);
374 375 376
extern void end_swap_bio_write(struct bio *bio, int err);
extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
	void (*end_write_func)(struct bio *, int));
377
extern int swap_set_page_dirty(struct page *page);
378
extern void end_swap_bio_read(struct bio *bio, int err);
Linus Torvalds's avatar
Linus Torvalds committed
379

380 381 382 383 384
int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
		unsigned long nr_pages, sector_t start_block);
int generic_swapfile_activate(struct swap_info_struct *, struct file *,
		sector_t *);

Linus Torvalds's avatar
Linus Torvalds committed
385
/* linux/mm/swap_state.c */
386 387 388
extern struct address_space swapper_spaces[];
#define swap_address_space(entry) (&swapper_spaces[swp_type(entry)])
extern unsigned long total_swapcache_pages(void);
Linus Torvalds's avatar
Linus Torvalds committed
389
extern void show_swap_cache_info(void);
390
extern int add_to_swap(struct page *, struct list_head *list);
391
extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
392
extern int __add_to_swap_cache(struct page *page, swp_entry_t entry);
Linus Torvalds's avatar
Linus Torvalds committed
393 394 395 396
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);
397
extern struct page *lookup_swap_cache(swp_entry_t);
398
extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
399
			struct vm_area_struct *vma, unsigned long addr);
400
extern struct page *swapin_readahead(swp_entry_t, gfp_t,
401 402
			struct vm_area_struct *vma, unsigned long addr);

Linus Torvalds's avatar
Linus Torvalds committed
403
/* linux/mm/swapfile.c */
404
extern atomic_long_t nr_swap_pages;
Linus Torvalds's avatar
Linus Torvalds committed
405
extern long total_swap_pages;
406 407 408 409 410 411 412 413 414 415 416 417

/* Swap 50% full? Release swapcache more aggressively.. */
static inline bool vm_swap_full(void)
{
	return atomic_long_read(&nr_swap_pages) * 2 < total_swap_pages;
}

static inline long get_nr_swap_pages(void)
{
	return atomic_long_read(&nr_swap_pages);
}

Linus Torvalds's avatar
Linus Torvalds committed
418 419
extern void si_swapinfo(struct sysinfo *);
extern swp_entry_t get_swap_page(void);
420
extern swp_entry_t get_swap_page_of_type(int);
421
extern int add_swap_count_continuation(swp_entry_t, gfp_t);
Hugh Dickins's avatar
Hugh Dickins committed
422
extern void swap_shmem_alloc(swp_entry_t);
423 424
extern int swap_duplicate(swp_entry_t);
extern int swapcache_prepare(swp_entry_t);
Linus Torvalds's avatar
Linus Torvalds committed
425
extern void swap_free(swp_entry_t);
426
extern void swapcache_free(swp_entry_t, struct page *page);
427
extern int free_swap_and_cache(swp_entry_t);
428
extern int swap_type_of(dev_t, sector_t, struct block_device **);
429
extern unsigned int count_swap_pages(int, int);
430
extern sector_t map_swap_page(struct page *, struct block_device **);
431
extern sector_t swapdev_block(int, pgoff_t);
432
extern int page_swapcount(struct page *);
433
extern struct swap_info_struct *page_swap_info(struct page *);
434
extern int reuse_swap_page(struct page *);
435
extern int try_to_free_swap(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
436 437
struct backing_dev_info;

Andrew Morton's avatar
Andrew Morton committed
438
#ifdef CONFIG_MEMCG
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
439 440
extern void
mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout);
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
441
#else
442
static inline void
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
443
mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
444 445 446
{
}
#endif
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
447

Linus Torvalds's avatar
Linus Torvalds committed
448 449
#else /* CONFIG_SWAP */

450
#define get_nr_swap_pages()			0L
451
#define total_swap_pages			0L
452
#define total_swapcache_pages()			0UL
453
#define vm_swap_full()				0
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456

#define si_swapinfo(val) \
	do { (val)->freeswap = (val)->totalswap = 0; } while (0)
457 458
/* 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
459 460 461 462 463
#define free_page_and_swap_cache(page) \
	page_cache_release(page)
#define free_pages_and_swap_cache(pages, nr) \
	release_pages((pages), (nr), 0);

464 465 466 467
static inline void show_swap_cache_info(void)
{
}

468
#define free_swap_and_cache(swp)	is_migration_entry(swp)
469
#define swapcache_prepare(swp)		is_migration_entry(swp)
470

471
static inline int add_swap_count_continuation(swp_entry_t swp, gfp_t gfp_mask)
472
{
473 474 475
	return 0;
}

Hugh Dickins's avatar
Hugh Dickins committed
476 477 478 479
static inline void swap_shmem_alloc(swp_entry_t swp)
{
}

480 481 482
static inline int swap_duplicate(swp_entry_t swp)
{
	return 0;
483 484
}

485 486 487 488
static inline void swap_free(swp_entry_t swp)
{
}

489 490 491 492
static inline void swapcache_free(swp_entry_t swp, struct page *page)
{
}

493
static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
494 495 496 497 498
			struct vm_area_struct *vma, unsigned long addr)
{
	return NULL;
}

499 500 501 502 503
static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
{
	return 0;
}

504 505 506 507 508
static inline struct page *lookup_swap_cache(swp_entry_t swp)
{
	return NULL;
}

509
static inline int add_to_swap(struct page *page, struct list_head *list)
Hugh Dickins's avatar
Hugh Dickins committed
510 511 512 513
{
	return 0;
}

514 515
static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
							gfp_t gfp_mask)
516
{
517
	return -1;
518 519 520 521 522 523 524 525 526 527
}

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

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

528 529 530 531 532
static inline int page_swapcount(struct page *page)
{
	return 0;
}

533
#define reuse_swap_page(page)	(page_mapcount(page) == 1)
Linus Torvalds's avatar
Linus Torvalds committed
534

535
static inline int try_to_free_swap(struct page *page)
536 537 538 539
{
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
540 541 542 543 544 545 546
static inline swp_entry_t get_swap_page(void)
{
	swp_entry_t entry;
	entry.val = 0;
	return entry;
}

547 548 549 550 551
static inline void
mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
{
}

Linus Torvalds's avatar
Linus Torvalds committed
552 553 554
#endif /* CONFIG_SWAP */
#endif /* __KERNEL__*/
#endif /* _LINUX_SWAP_H */