swap.h 20.6 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>
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;

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
#define SWAP_BATCH 64
31

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

/*
 * 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.
 */

53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
/*
 * Unaddressable device memory support. See include/linux/hmm.h and
 * Documentation/vm/hmm.txt. Short description is we need struct pages for
 * device memory that is unaddressable (inaccessible) by CPU, so that we can
 * migrate part of a process memory to device memory.
 *
 * When a page is migrated from CPU to device, we set the CPU page table entry
 * to a special SWP_DEVICE_* entry.
 */
#ifdef CONFIG_DEVICE_PRIVATE
#define SWP_DEVICE_NUM 2
#define SWP_DEVICE_WRITE (MAX_SWAPFILES+SWP_HWPOISON_NUM+SWP_MIGRATION_NUM)
#define SWP_DEVICE_READ (MAX_SWAPFILES+SWP_HWPOISON_NUM+SWP_MIGRATION_NUM+1)
#else
#define SWP_DEVICE_NUM 0
#endif

70 71 72 73 74 75 76
/*
 * 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)
77
#else
78
#define SWP_MIGRATION_NUM 0
79
#endif
Linus Torvalds's avatar
Linus Torvalds committed
80

81 82 83 84 85 86 87 88 89 90 91
/*
 * 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 \
92 93
	((1 << MAX_SWAPFILES_SHIFT) - SWP_DEVICE_NUM - \
	SWP_MIGRATION_NUM - SWP_HWPOISON_NUM)
94

Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
/*
 * 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 {
113 114 115 116 117 118 119 120
		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
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 153 154 155 156 157 158 159 160 161 162 163
	} info;
};

/*
 * 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?	*/
164
	SWP_DISCARDABLE = (1 << 2),	/* blkdev support discard */
165
	SWP_DISCARDING	= (1 << 3),	/* now discarding a free cluster */
166
	SWP_SOLIDSTATE	= (1 << 4),	/* blkdev seeks are cheap */
167
	SWP_CONTINUED	= (1 << 5),	/* swap_map has count continuation */
168
	SWP_BLKDEV	= (1 << 6),	/* its a block device */
169
	SWP_FILE	= (1 << 7),	/* set after swap_activate success */
170 171
	SWP_AREA_DISCARD = (1 << 8),	/* single-time swap area discards */
	SWP_PAGE_DISCARD = (1 << 9),	/* freed swap page-cluster discards */
172
	SWP_STABLE_WRITES = (1 << 10),	/* no overwrite PG_writeback pages */
173
					/* add others here before... */
174
	SWP_SCANNING	= (1 << 11),	/* refcount in scan_swap_map */
Linus Torvalds's avatar
Linus Torvalds committed
175 176
};

177
#define SWAP_CLUSTER_MAX 32UL
178
#define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
Linus Torvalds's avatar
Linus Torvalds committed
179

180 181 182 183 184
#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 */
185
#define SWAP_MAP_SHMEM	0xbf	/* Owned by shmem/tmpfs, in first swap_map */
186

187 188 189 190 191 192 193 194 195 196 197
/*
 * 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 {
Huang, Ying's avatar
Huang, Ying committed
198 199 200 201 202 203
	spinlock_t lock;	/*
				 * Protect swap_cluster_info fields
				 * and swap_info_struct->swap_map
				 * elements correspond to the swap
				 * cluster
				 */
204 205 206 207 208
	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 */
209
#define CLUSTER_FLAG_HUGE 4 /* This cluster is backing a transparent huge page */
210

211 212 213 214 215 216 217 218 219 220
/*
 * 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 */
};

221 222 223 224 225
struct swap_cluster_list {
	struct swap_cluster_info head;
	struct swap_cluster_info tail;
};

Linus Torvalds's avatar
Linus Torvalds committed
226 227 228 229
/*
 * The in-memory structure used to track swap areas.
 */
struct swap_info_struct {
230 231
	unsigned long	flags;		/* SWP_USED etc: see above */
	signed short	prio;		/* swap priority of this type */
232
	struct plist_node list;		/* entry in swap_active_head */
233
	struct plist_node avail_lists[MAX_NUMNODES];/* entry in swap_avail_heads */
234
	signed char	type;		/* strange name for an index */
235 236
	unsigned int	max;		/* extent of the swap_map */
	unsigned char *swap_map;	/* vmalloc'ed array of usage counts */
237
	struct swap_cluster_info *cluster_info; /* cluster info. Only for SSD */
238
	struct swap_cluster_list free_clusters; /* free clusters list */
239 240 241 242 243 244
	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 */
245
	struct percpu_cluster __percpu *percpu_cluster; /* per cpu's swap location */
246 247 248 249 250
	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 */
251 252 253 254
#ifdef CONFIG_FRONTSWAP
	unsigned long *frontswap_map;	/* frontswap in-use, one bit per page */
	atomic_t frontswap_pages;	/* frontswap pages in-use counter */
#endif
255 256 257 258
	spinlock_t lock;		/*
					 * protect map scan related fields like
					 * swap_map, lowest_bit, highest_bit,
					 * inuse_pages, cluster_next,
259 260 261 262 263 264 265 266
					 * 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.
267
					 */
268
	struct work_struct discard_work; /* discard worker */
269
	struct swap_cluster_list discard_clusters; /* discard clusters list */
Linus Torvalds's avatar
Linus Torvalds committed
270 271
};

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
#ifdef CONFIG_64BIT
#define SWAP_RA_ORDER_CEILING	5
#else
/* Avoid stack overflow, because we need to save part of page table */
#define SWAP_RA_ORDER_CEILING	3
#define SWAP_RA_PTE_CACHE_SIZE	(1 << SWAP_RA_ORDER_CEILING)
#endif

struct vma_swap_readahead {
	unsigned short win;
	unsigned short offset;
	unsigned short nr_pte;
#ifdef CONFIG_64BIT
	pte_t *ptes;
#else
	pte_t ptes[SWAP_RA_PTE_CACHE_SIZE];
#endif
};

291 292 293 294
/* linux/mm/workingset.c */
void *workingset_eviction(struct address_space *mapping, struct page *page);
bool workingset_refault(void *shadow);
void workingset_activation(struct page *page);
295
void workingset_update_node(struct radix_tree_node *node, void *private);
296

Linus Torvalds's avatar
Linus Torvalds committed
297 298
/* linux/mm/page_alloc.c */
extern unsigned long totalram_pages;
299
extern unsigned long totalreserve_pages;
300 301
extern unsigned long nr_free_buffer_pages(void);
extern unsigned long nr_free_pagecache_pages(void);
Linus Torvalds's avatar
Linus Torvalds committed
302

303 304
/* Definition of global_zone_page_state not available yet */
#define nr_free_pages() global_zone_page_state(NR_FREE_PAGES)
305 306


Linus Torvalds's avatar
Linus Torvalds committed
307
/* linux/mm/swap.c */
308
extern void lru_cache_add(struct page *);
309 310
extern void lru_cache_add_anon(struct page *page);
extern void lru_cache_add_file(struct page *page);
311
extern void lru_add_page_tail(struct page *page, struct page *page_tail,
312
			 struct lruvec *lruvec, struct list_head *head);
313 314
extern void activate_page(struct page *);
extern void mark_page_accessed(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
315
extern void lru_add_drain(void);
316
extern void lru_add_drain_cpu(int cpu);
317
extern void lru_add_drain_all(void);
318
extern void lru_add_drain_all_cpuslocked(void);
319
extern void rotate_reclaimable_page(struct page *page);
320
extern void deactivate_file_page(struct page *page);
321
extern void mark_page_lazyfree(struct page *page);
Linus Torvalds's avatar
Linus Torvalds committed
322 323
extern void swap_setup(void);

324 325
extern void add_page_to_unevictable_list(struct page *page);

326 327 328
extern void lru_cache_add_active_or_unevictable(struct page *page,
						struct vm_area_struct *vma);

Linus Torvalds's avatar
Linus Torvalds committed
329
/* linux/mm/vmscan.c */
330
extern unsigned long zone_reclaimable_pages(struct zone *zone);
331
extern unsigned long pgdat_reclaimable_pages(struct pglist_data *pgdat);
332
extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
333
					gfp_t gfp_mask, nodemask_t *mask);
334
extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
335 336 337 338
extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
						  unsigned long nr_pages,
						  gfp_t gfp_mask,
						  bool may_swap);
339
extern unsigned long mem_cgroup_shrink_node(struct mem_cgroup *mem,
340
						gfp_t gfp_mask, bool noswap,
341
						pg_data_t *pgdat,
342
						unsigned long *nr_scanned);
343
extern unsigned long shrink_all_memory(unsigned long nr_pages);
Linus Torvalds's avatar
Linus Torvalds committed
344
extern int vm_swappiness;
345
extern int remove_mapping(struct address_space *mapping, struct page *page);
346
extern unsigned long vm_total_pages;
347

348
#ifdef CONFIG_NUMA
349
extern int node_reclaim_mode;
350
extern int sysctl_min_unmapped_ratio;
351
extern int sysctl_min_slab_ratio;
352
extern int node_reclaim(struct pglist_data *, gfp_t, unsigned int);
353
#else
354 355 356
#define node_reclaim_mode 0
static inline int node_reclaim(struct pglist_data *pgdat, gfp_t mask,
				unsigned int order)
357 358 359 360 361
{
	return 0;
}
#endif

362
extern int page_evictable(struct page *page);
363
extern void check_move_unevictable_pages(struct page **, int nr_pages);
364

365
extern int kswapd_run(int nid);
366
extern void kswapd_stop(int nid);
367

Linus Torvalds's avatar
Linus Torvalds committed
368
#ifdef CONFIG_SWAP
369 370 371

#include <linux/blk_types.h> /* for bio_end_io_t */

Linus Torvalds's avatar
Linus Torvalds committed
372
/* linux/mm/page_io.c */
373
extern int swap_readpage(struct page *page, bool do_poll);
Linus Torvalds's avatar
Linus Torvalds committed
374
extern int swap_writepage(struct page *page, struct writeback_control *wbc);
375
extern void end_swap_bio_write(struct bio *bio);
376
extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
377
	bio_end_io_t end_write_func);
378
extern int swap_set_page_dirty(struct page *page);
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 389
/* One swap address space for each 64M swap space */
#define SWAP_ADDRESS_SPACE_SHIFT	14
#define SWAP_ADDRESS_SPACE_PAGES	(1 << SWAP_ADDRESS_SPACE_SHIFT)
extern struct address_space *swapper_spaces[];
390
extern bool swap_vma_readahead;
391 392 393
#define swap_address_space(entry)			    \
	(&swapper_spaces[swp_type(entry)][swp_offset(entry) \
		>> SWAP_ADDRESS_SPACE_SHIFT])
394
extern unsigned long total_swapcache_pages(void);
Linus Torvalds's avatar
Linus Torvalds committed
395
extern void show_swap_cache_info(void);
396
extern int add_to_swap(struct page *page);
397
extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
398
extern int __add_to_swap_cache(struct page *page, swp_entry_t entry);
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401 402
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);
403 404 405
extern struct page *lookup_swap_cache(swp_entry_t entry,
				      struct vm_area_struct *vma,
				      unsigned long addr);
406
extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
407 408
			struct vm_area_struct *vma, unsigned long addr,
			bool do_poll);
409 410 411
extern struct page *__read_swap_cache_async(swp_entry_t, gfp_t,
			struct vm_area_struct *vma, unsigned long addr,
			bool *new_page_allocated);
412
extern struct page *swapin_readahead(swp_entry_t, gfp_t,
413 414
			struct vm_area_struct *vma, unsigned long addr);

415 416 417 418 419 420
extern struct page *swap_readahead_detect(struct vm_fault *vmf,
					  struct vma_swap_readahead *swap_ra);
extern struct page *do_swap_page_readahead(swp_entry_t fentry, gfp_t gfp_mask,
					   struct vm_fault *vmf,
					   struct vma_swap_readahead *swap_ra);

Linus Torvalds's avatar
Linus Torvalds committed
421
/* linux/mm/swapfile.c */
422
extern atomic_long_t nr_swap_pages;
Linus Torvalds's avatar
Linus Torvalds committed
423
extern long total_swap_pages;
424
extern atomic_t nr_rotate_swap;
425
extern bool has_usable_swap(void);
426

427 428 429 430 431
static inline bool swap_use_vma_readahead(void)
{
	return READ_ONCE(swap_vma_readahead) && !atomic_read(&nr_rotate_swap);
}

432 433 434 435 436 437 438 439 440 441 442
/* 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
443
extern void si_swapinfo(struct sysinfo *);
444
extern swp_entry_t get_swap_page(struct page *page);
445
extern void put_swap_page(struct page *page, swp_entry_t entry);
446
extern swp_entry_t get_swap_page_of_type(int);
447
extern int get_swap_pages(int n, bool cluster, swp_entry_t swp_entries[]);
448
extern int add_swap_count_continuation(swp_entry_t, gfp_t);
449
extern void swap_shmem_alloc(swp_entry_t);
450 451
extern int swap_duplicate(swp_entry_t);
extern int swapcache_prepare(swp_entry_t);
Linus Torvalds's avatar
Linus Torvalds committed
452
extern void swap_free(swp_entry_t);
453
extern void swapcache_free_entries(swp_entry_t *entries, int n);
454
extern int free_swap_and_cache(swp_entry_t);
455
extern int swap_type_of(dev_t, sector_t, struct block_device **);
456
extern unsigned int count_swap_pages(int, int);
457
extern sector_t map_swap_page(struct page *, struct block_device **);
458
extern sector_t swapdev_block(int, pgoff_t);
459
extern int page_swapcount(struct page *);
460
extern int __swp_swapcount(swp_entry_t entry);
461
extern int swp_swapcount(swp_entry_t entry);
462
extern struct swap_info_struct *page_swap_info(struct page *);
463
extern bool reuse_swap_page(struct page *, int *);
464
extern int try_to_free_swap(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
465
struct backing_dev_info;
466 467
extern int init_swap_address_space(unsigned int type, unsigned long nr_pages);
extern void exit_swap_address_space(unsigned int type);
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470

#else /* CONFIG_SWAP */

471
#define swap_address_space(entry)		(NULL)
472
#define get_nr_swap_pages()			0L
473
#define total_swap_pages			0L
474
#define total_swapcache_pages()			0UL
475
#define vm_swap_full()				0
Linus Torvalds's avatar
Linus Torvalds committed
476 477 478

#define si_swapinfo(val) \
	do { (val)->freeswap = (val)->totalswap = 0; } while (0)
479
/* only sparc can not include linux/pagemap.h in this file
480
 * so leave put_page and release_pages undeclared... */
Linus Torvalds's avatar
Linus Torvalds committed
481
#define free_page_and_swap_cache(page) \
482
	put_page(page)
Linus Torvalds's avatar
Linus Torvalds committed
483
#define free_pages_and_swap_cache(pages, nr) \
484
	release_pages((pages), (nr), false);
Linus Torvalds's avatar
Linus Torvalds committed
485

486 487 488 489
static inline void show_swap_cache_info(void)
{
}

490 491
#define free_swap_and_cache(e) ({(is_migration_entry(e) || is_device_private_entry(e));})
#define swapcache_prepare(e) ({(is_migration_entry(e) || is_device_private_entry(e));})
492

493
static inline int add_swap_count_continuation(swp_entry_t swp, gfp_t gfp_mask)
494
{
495 496 497
	return 0;
}

498 499 500 501
static inline void swap_shmem_alloc(swp_entry_t swp)
{
}

502 503 504
static inline int swap_duplicate(swp_entry_t swp)
{
	return 0;
505 506
}

507 508 509 510
static inline void swap_free(swp_entry_t swp)
{
}

511
static inline void put_swap_page(struct page *page, swp_entry_t swp)
512 513 514
{
}

515
static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
516 517 518 519 520
			struct vm_area_struct *vma, unsigned long addr)
{
	return NULL;
}

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
static inline bool swap_use_vma_readahead(void)
{
	return false;
}

static inline struct page *swap_readahead_detect(
	struct vm_fault *vmf, struct vma_swap_readahead *swap_ra)
{
	return NULL;
}

static inline struct page *do_swap_page_readahead(
	swp_entry_t fentry, gfp_t gfp_mask,
	struct vm_fault *vmf, struct vma_swap_readahead *swap_ra)
{
	return NULL;
}

539 540 541 542 543
static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
{
	return 0;
}

544 545 546
static inline struct page *lookup_swap_cache(swp_entry_t swp,
					     struct vm_area_struct *vma,
					     unsigned long addr)
547 548 549 550
{
	return NULL;
}

551
static inline int add_to_swap(struct page *page)
Hugh Dickins's avatar
Hugh Dickins committed
552 553 554 555
{
	return 0;
}

556 557
static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
							gfp_t gfp_mask)
558
{
559
	return -1;
560 561 562 563 564 565 566 567 568 569
}

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

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

570 571 572 573 574
static inline int page_swapcount(struct page *page)
{
	return 0;
}

575 576 577 578 579
static inline int __swp_swapcount(swp_entry_t entry)
{
	return 0;
}

580 581 582 583 584
static inline int swp_swapcount(swp_entry_t entry)
{
	return 0;
}

585 586
#define reuse_swap_page(page, total_map_swapcount) \
	(page_trans_huge_mapcount(page, total_map_swapcount) == 1)
Linus Torvalds's avatar
Linus Torvalds committed
587

588
static inline int try_to_free_swap(struct page *page)
589 590 591 592
{
	return 0;
}

593
static inline swp_entry_t get_swap_page(struct page *page)
Linus Torvalds's avatar
Linus Torvalds committed
594 595 596 597 598 599 600
{
	swp_entry_t entry;
	entry.val = 0;
	return entry;
}

#endif /* CONFIG_SWAP */
601

602 603 604 605 606 607 608 609 610
#ifdef CONFIG_THP_SWAP
extern int split_swap_cluster(swp_entry_t entry);
#else
static inline int split_swap_cluster(swp_entry_t entry)
{
	return 0;
}
#endif

611 612 613
#ifdef CONFIG_MEMCG
static inline int mem_cgroup_swappiness(struct mem_cgroup *memcg)
{
614 615 616 617
	/* Cgroup2 doesn't have per-cgroup swappiness */
	if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
		return vm_swappiness;

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
	/* root ? */
	if (mem_cgroup_disabled() || !memcg->css.parent)
		return vm_swappiness;

	return memcg->swappiness;
}

#else
static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
{
	return vm_swappiness;
}
#endif

#ifdef CONFIG_MEMCG_SWAP
extern void mem_cgroup_swapout(struct page *page, swp_entry_t entry);
extern int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry);
635
extern void mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages);
636
extern long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg);
637
extern bool mem_cgroup_swap_full(struct page *page);
638 639 640 641 642 643 644 645 646 647 648
#else
static inline void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
{
}

static inline int mem_cgroup_try_charge_swap(struct page *page,
					     swp_entry_t entry)
{
	return 0;
}

649 650
static inline void mem_cgroup_uncharge_swap(swp_entry_t entry,
					    unsigned int nr_pages)
651 652
{
}
653 654 655 656 657

static inline long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg)
{
	return get_nr_swap_pages();
}
658 659 660 661 662

static inline bool mem_cgroup_swap_full(struct page *page)
{
	return vm_swap_full();
}
663 664
#endif

Linus Torvalds's avatar
Linus Torvalds committed
665 666
#endif /* __KERNEL__*/
#endif /* _LINUX_SWAP_H */