Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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/memcontrol.h>
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>
14#include <asm/page.h>
15
16struct notifier_block;
17
18struct bio;
19
20#define SWAP_FLAG_PREFER 0x8000 /* set if swap priority specified */
21#define SWAP_FLAG_PRIO_MASK 0x7fff
22#define SWAP_FLAG_PRIO_SHIFT 0
23#define SWAP_FLAG_DISCARD 0x10000 /* enable discard for swap */
24#define SWAP_FLAG_DISCARD_ONCE 0x20000 /* discard swap area at swapon-time */
25#define SWAP_FLAG_DISCARD_PAGES 0x40000 /* discard page-clusters after use */
26
27#define SWAP_FLAGS_VALID (SWAP_FLAG_PRIO_MASK | SWAP_FLAG_PREFER | \
28 SWAP_FLAG_DISCARD | SWAP_FLAG_DISCARD_ONCE | \
29 SWAP_FLAG_DISCARD_PAGES)
30#define SWAP_BATCH 64
31
32static inline int current_is_kswapd(void)
33{
34 return current->flags & PF_KSWAPD;
35}
36
37/*
38 * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
39 * be swapped to. The swap type and the offset into that swap type are
40 * encoded into pte's and into pgoff_t's in the swapcache. Using five bits
41 * for the type means that the maximum number of swapcache pages is 27 bits
42 * on 32-bit-pgoff_t architectures. And that assumes that the architecture packs
43 * the type/offset into the pte as 5/27 as well.
44 */
45#define MAX_SWAPFILES_SHIFT 5
46
47/*
48 * Use some of the swap files numbers for other purposes. This
49 * is a convenient way to hook into the VM to trigger special
50 * actions on faults.
51 */
52
53/*
54 * Unaddressable device memory support. See include/linux/hmm.h and
55 * Documentation/vm/hmm.txt. Short description is we need struct pages for
56 * device memory that is unaddressable (inaccessible) by CPU, so that we can
57 * migrate part of a process memory to device memory.
58 *
59 * When a page is migrated from CPU to device, we set the CPU page table entry
60 * to a special SWP_DEVICE_* entry.
61 */
62#ifdef CONFIG_DEVICE_PRIVATE
63#define SWP_DEVICE_NUM 2
64#define SWP_DEVICE_WRITE (MAX_SWAPFILES+SWP_HWPOISON_NUM+SWP_MIGRATION_NUM)
65#define SWP_DEVICE_READ (MAX_SWAPFILES+SWP_HWPOISON_NUM+SWP_MIGRATION_NUM+1)
66#else
67#define SWP_DEVICE_NUM 0
68#endif
69
70/*
71 * NUMA node memory migration support
72 */
73#ifdef CONFIG_MIGRATION
74#define SWP_MIGRATION_NUM 2
75#define SWP_MIGRATION_READ (MAX_SWAPFILES + SWP_HWPOISON_NUM)
76#define SWP_MIGRATION_WRITE (MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
77#else
78#define SWP_MIGRATION_NUM 0
79#endif
80
81/*
82 * Handling of hardware poisoned pages with memory corruption.
83 */
84#ifdef CONFIG_MEMORY_FAILURE
85#define SWP_HWPOISON_NUM 1
86#define SWP_HWPOISON MAX_SWAPFILES
87#else
88#define SWP_HWPOISON_NUM 0
89#endif
90
91#define MAX_SWAPFILES \
92 ((1 << MAX_SWAPFILES_SHIFT) - SWP_DEVICE_NUM - \
93 SWP_MIGRATION_NUM - SWP_HWPOISON_NUM)
94
95/*
96 * Magic header for a swap area. The first part of the union is
97 * what the swap magic looks like for the old (limited to 128MB)
98 * swap area format, the second part of the union adds - in the
99 * old reserved area - some extra information. Note that the first
100 * kilobyte is reserved for boot loader or disk label stuff...
101 *
102 * Having the magic at the end of the PAGE_SIZE makes detecting swap
103 * areas somewhat tricky on machines that support multiple page sizes.
104 * For 2.5 we'll probably want to move the magic to just beyond the
105 * bootbits...
106 */
107union swap_header {
108 struct {
109 char reserved[PAGE_SIZE - 10];
110 char magic[10]; /* SWAP-SPACE or SWAPSPACE2 */
111 } magic;
112 struct {
113 char bootbits[1024]; /* Space for disklabel etc. */
114 __u32 version;
115 __u32 last_page;
116 __u32 nr_badpages;
117 unsigned char sws_uuid[16];
118 unsigned char sws_volume[16];
119 __u32 padding[117];
120 __u32 badpages[1];
121 } info;
122};
123
124/*
125 * current->reclaim_state points to one of these when a task is running
126 * memory reclaim
127 */
128struct reclaim_state {
129 unsigned long reclaimed_slab;
130};
131
132#ifdef __KERNEL__
133
134struct address_space;
135struct sysinfo;
136struct writeback_control;
137struct zone;
138
139/*
140 * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
141 * disk blocks. A list of swap extents maps the entire swapfile. (Where the
142 * term `swapfile' refers to either a blockdevice or an IS_REG file. Apart
143 * from setup, they're handled identically.
144 *
145 * We always assume that blocks are of size PAGE_SIZE.
146 */
147struct swap_extent {
148 struct list_head list;
149 pgoff_t start_page;
150 pgoff_t nr_pages;
151 sector_t start_block;
152};
153
154/*
155 * Max bad pages in the new format..
156 */
157#define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
158#define MAX_SWAP_BADPAGES \
159 ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
160
161enum {
162 SWP_USED = (1 << 0), /* is slot in swap_info[] used? */
163 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 SWP_AREA_DISCARD = (1 << 8), /* single-time swap area discards */
171 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 */
175};
176
177#define SWAP_CLUSTER_MAX 32UL
178#define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
179
180#define SWAP_MAP_MAX 0x3e /* Max duplication count, in first swap_map */
181#define SWAP_MAP_BAD 0x3f /* Note pageblock is bad, in first swap_map */
182#define SWAP_HAS_CACHE 0x40 /* Flag page is cached, in first swap_map */
183#define SWAP_CONT_MAX 0x7f /* Max count, in each swap_map continuation */
184#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 * We use this to track usage of a cluster. A cluster is a block of swap disk
189 * space with SWAPFILE_CLUSTER pages long and naturally aligns in disk. All
190 * free clusters are organized into a list. We fetch an entry from the list to
191 * get a free cluster.
192 *
193 * The data field stores next cluster if the cluster is free or cluster usage
194 * counter otherwise. The flags field determines if a cluster is free. This is
195 * protected by swap_info_struct.lock.
196 */
197struct swap_cluster_info {
198 spinlock_t lock; /*
199 * Protect swap_cluster_info fields
200 * and swap_info_struct->swap_map
201 * elements correspond to the swap
202 * cluster
203 */
204 unsigned int data:24;
205 unsigned int flags:8;
206};
207#define CLUSTER_FLAG_FREE 1 /* This cluster is free */
208#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 * We assign a cluster to each CPU, so each CPU can allocate swap entry from
213 * its own cluster and swapout sequentially. The purpose is to optimize swapout
214 * throughput.
215 */
216struct percpu_cluster {
217 struct swap_cluster_info index; /* Current cluster index */
218 unsigned int next; /* Likely next allocation offset */
219};
220
221struct swap_cluster_list {
222 struct swap_cluster_info head;
223 struct swap_cluster_info tail;
224};
225
226/*
227 * The in-memory structure used to track swap areas.
228 */
229struct swap_info_struct {
230 unsigned long flags; /* SWP_USED etc: see above */
231 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 unsigned int max; /* extent of the swap_map */
236 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 unsigned int lowest_bit; /* index of first free in swap_map */
240 unsigned int highest_bit; /* index of last free in swap_map */
241 unsigned int pages; /* total of usable pages of swap */
242 unsigned int inuse_pages; /* number of those currently in use */
243 unsigned int cluster_next; /* likely index for next allocation */
244 unsigned int cluster_nr; /* countdown to next cluster search */
245 struct percpu_cluster __percpu *percpu_cluster; /* per cpu's swap location */
246 struct swap_extent *curr_swap_extent;
247 struct swap_extent first_swap_extent;
248 struct block_device *bdev; /* swap device or bdev of swap file */
249 struct file *swap_file; /* seldom referenced */
250 unsigned int old_block_size; /* seldom referenced */
251#ifdef CONFIG_FRONTSWAP
252 unsigned long *frontswap_map; /* frontswap in-use, one bit per page */
253 atomic_t frontswap_pages; /* frontswap pages in-use counter */
254#endif
255 spinlock_t lock; /*
256 * protect map scan related fields like
257 * swap_map, lowest_bit, highest_bit,
258 * inuse_pages, cluster_next,
259 * cluster_nr, lowest_alloc,
260 * highest_alloc, free/discard cluster
261 * list. other fields are only changed
262 * at swapon/swapoff, so are protected
263 * by swap_lock. changing flags need
264 * hold this lock and swap_lock. If
265 * both locks need hold, hold swap_lock
266 * first.
267 */
268 struct work_struct discard_work; /* discard worker */
269 struct swap_cluster_list discard_clusters; /* discard clusters list */
270};
271
272#ifdef CONFIG_64BIT
273#define SWAP_RA_ORDER_CEILING 5
274#else
275/* Avoid stack overflow, because we need to save part of page table */
276#define SWAP_RA_ORDER_CEILING 3
277#define SWAP_RA_PTE_CACHE_SIZE (1 << SWAP_RA_ORDER_CEILING)
278#endif
279
280struct vma_swap_readahead {
281 unsigned short win;
282 unsigned short offset;
283 unsigned short nr_pte;
284#ifdef CONFIG_64BIT
285 pte_t *ptes;
286#else
287 pte_t ptes[SWAP_RA_PTE_CACHE_SIZE];
288#endif
289};
290
291/* linux/mm/workingset.c */
292void *workingset_eviction(struct address_space *mapping, struct page *page);
293bool workingset_refault(void *shadow);
294void workingset_activation(struct page *page);
295void workingset_update_node(struct radix_tree_node *node, void *private);
296
297/* linux/mm/page_alloc.c */
298extern unsigned long totalram_pages;
299extern unsigned long totalreserve_pages;
300extern unsigned long nr_free_buffer_pages(void);
301extern unsigned long nr_free_pagecache_pages(void);
302
303/* Definition of global_zone_page_state not available yet */
304#define nr_free_pages() global_zone_page_state(NR_FREE_PAGES)
305
306
307/* linux/mm/swap.c */
308extern void lru_cache_add(struct page *);
309extern void lru_cache_add_anon(struct page *page);
310extern void lru_cache_add_file(struct page *page);
311extern void lru_add_page_tail(struct page *page, struct page *page_tail,
312 struct lruvec *lruvec, struct list_head *head);
313extern void activate_page(struct page *);
314extern void mark_page_accessed(struct page *);
315extern void lru_add_drain(void);
316extern void lru_add_drain_cpu(int cpu);
317extern void lru_add_drain_all(void);
318extern void lru_add_drain_all_cpuslocked(void);
319extern void rotate_reclaimable_page(struct page *page);
320extern void deactivate_file_page(struct page *page);
321extern void mark_page_lazyfree(struct page *page);
322extern void swap_setup(void);
323
324extern void add_page_to_unevictable_list(struct page *page);
325
326extern void lru_cache_add_active_or_unevictable(struct page *page,
327 struct vm_area_struct *vma);
328
329/* linux/mm/vmscan.c */
330extern unsigned long zone_reclaimable_pages(struct zone *zone);
331extern unsigned long pgdat_reclaimable_pages(struct pglist_data *pgdat);
332extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
333 gfp_t gfp_mask, nodemask_t *mask);
334extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
335extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
336 unsigned long nr_pages,
337 gfp_t gfp_mask,
338 bool may_swap);
339extern 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);
343extern unsigned long shrink_all_memory(unsigned long nr_pages);
344extern int vm_swappiness;
345extern int remove_mapping(struct address_space *mapping, struct page *page);
346extern unsigned long vm_total_pages;
347
348#ifdef CONFIG_NUMA
349extern int node_reclaim_mode;
350extern int sysctl_min_unmapped_ratio;
351extern int sysctl_min_slab_ratio;
352extern int node_reclaim(struct pglist_data *, gfp_t, unsigned int);
353#else
354#define node_reclaim_mode 0
355static inline int node_reclaim(struct pglist_data *pgdat, gfp_t mask,
356 unsigned int order)
357{
358 return 0;
359}
360#endif
361
362extern int page_evictable(struct page *page);
363extern void check_move_unevictable_pages(struct page **, int nr_pages);
364
365extern int kswapd_run(int nid);
366extern void kswapd_stop(int nid);
367
368#ifdef CONFIG_SWAP
369
370#include <linux/blk_types.h> /* for bio_end_io_t */
371
372/* linux/mm/page_io.c */
373extern int swap_readpage(struct page *page, bool do_poll);
374extern int swap_writepage(struct page *page, struct writeback_control *wbc);
375extern void end_swap_bio_write(struct bio *bio);
376extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
377 bio_end_io_t end_write_func);
378extern int swap_set_page_dirty(struct page *page);
379
380int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
381 unsigned long nr_pages, sector_t start_block);
382int generic_swapfile_activate(struct swap_info_struct *, struct file *,
383 sector_t *);
384
385/* linux/mm/swap_state.c */
386/* One swap address space for each 64M swap space */
387#define SWAP_ADDRESS_SPACE_SHIFT 14
388#define SWAP_ADDRESS_SPACE_PAGES (1 << SWAP_ADDRESS_SPACE_SHIFT)
389extern struct address_space *swapper_spaces[];
390extern bool swap_vma_readahead;
391#define swap_address_space(entry) \
392 (&swapper_spaces[swp_type(entry)][swp_offset(entry) \
393 >> SWAP_ADDRESS_SPACE_SHIFT])
394extern unsigned long total_swapcache_pages(void);
395extern void show_swap_cache_info(void);
396extern int add_to_swap(struct page *page);
397extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
398extern int __add_to_swap_cache(struct page *page, swp_entry_t entry);
399extern void __delete_from_swap_cache(struct page *);
400extern void delete_from_swap_cache(struct page *);
401extern void free_page_and_swap_cache(struct page *);
402extern void free_pages_and_swap_cache(struct page **, int);
403extern struct page *lookup_swap_cache(swp_entry_t entry,
404 struct vm_area_struct *vma,
405 unsigned long addr);
406extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
407 struct vm_area_struct *vma, unsigned long addr,
408 bool do_poll);
409extern struct page *__read_swap_cache_async(swp_entry_t, gfp_t,
410 struct vm_area_struct *vma, unsigned long addr,
411 bool *new_page_allocated);
412extern struct page *swapin_readahead(swp_entry_t, gfp_t,
413 struct vm_area_struct *vma, unsigned long addr);
414
415extern struct page *swap_readahead_detect(struct vm_fault *vmf,
416 struct vma_swap_readahead *swap_ra);
417extern struct page *do_swap_page_readahead(swp_entry_t fentry, gfp_t gfp_mask,
418 struct vm_fault *vmf,
419 struct vma_swap_readahead *swap_ra);
420
421/* linux/mm/swapfile.c */
422extern atomic_long_t nr_swap_pages;
423extern long total_swap_pages;
424extern atomic_t nr_rotate_swap;
425extern bool has_usable_swap(void);
426
427static inline bool swap_use_vma_readahead(void)
428{
429 return READ_ONCE(swap_vma_readahead) && !atomic_read(&nr_rotate_swap);
430}
431
432/* Swap 50% full? Release swapcache more aggressively.. */
433static inline bool vm_swap_full(void)
434{
435 return atomic_long_read(&nr_swap_pages) * 2 < total_swap_pages;
436}
437
438static inline long get_nr_swap_pages(void)
439{
440 return atomic_long_read(&nr_swap_pages);
441}
442
443extern void si_swapinfo(struct sysinfo *);
444extern swp_entry_t get_swap_page(struct page *page);
445extern void put_swap_page(struct page *page, swp_entry_t entry);
446extern swp_entry_t get_swap_page_of_type(int);
447extern int get_swap_pages(int n, bool cluster, swp_entry_t swp_entries[]);
448extern int add_swap_count_continuation(swp_entry_t, gfp_t);
449extern void swap_shmem_alloc(swp_entry_t);
450extern int swap_duplicate(swp_entry_t);
451extern int swapcache_prepare(swp_entry_t);
452extern void swap_free(swp_entry_t);
453extern void swapcache_free_entries(swp_entry_t *entries, int n);
454extern int free_swap_and_cache(swp_entry_t);
455extern int swap_type_of(dev_t, sector_t, struct block_device **);
456extern unsigned int count_swap_pages(int, int);
457extern sector_t map_swap_page(struct page *, struct block_device **);
458extern sector_t swapdev_block(int, pgoff_t);
459extern int page_swapcount(struct page *);
460extern int __swp_swapcount(swp_entry_t entry);
461extern int swp_swapcount(swp_entry_t entry);
462extern struct swap_info_struct *page_swap_info(struct page *);
463extern bool reuse_swap_page(struct page *, int *);
464extern int try_to_free_swap(struct page *);
465struct backing_dev_info;
466extern int init_swap_address_space(unsigned int type, unsigned long nr_pages);
467extern void exit_swap_address_space(unsigned int type);
468
469#else /* CONFIG_SWAP */
470
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
476
477#define si_swapinfo(val) \
478 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... */
481#define free_page_and_swap_cache(page) \
482 put_page(page)
483#define free_pages_and_swap_cache(pages, nr) \
484 release_pages((pages), (nr), false);
485
486static inline void show_swap_cache_info(void)
487{
488}
489
490#define free_swap_and_cache(e) ({(is_migration_entry(e) || is_device_private_entry(e));})
491#define swapcache_prepare(e) ({(is_migration_entry(e) || is_device_private_entry(e));})
492
493static inline int add_swap_count_continuation(swp_entry_t swp, gfp_t gfp_mask)
494{
495 return 0;
496}
497
498static inline void swap_shmem_alloc(swp_entry_t swp)
499{
500}
501
502static inline int swap_duplicate(swp_entry_t swp)
503{
504 return 0;
505}
506
507static inline void swap_free(swp_entry_t swp)
508{
509}
510
511static inline void put_swap_page(struct page *page, swp_entry_t swp)
512{
513}
514
515static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
516 struct vm_area_struct *vma, unsigned long addr)
517{
518 return NULL;
519}
520
521static inline bool swap_use_vma_readahead(void)
522{
523 return false;
524}
525
526static inline struct page *swap_readahead_detect(
527 struct vm_fault *vmf, struct vma_swap_readahead *swap_ra)
528{
529 return NULL;
530}
531
532static inline struct page *do_swap_page_readahead(
533 swp_entry_t fentry, gfp_t gfp_mask,
534 struct vm_fault *vmf, struct vma_swap_readahead *swap_ra)
535{
536 return NULL;
537}
538
539static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
540{
541 return 0;
542}
543
544static inline struct page *lookup_swap_cache(swp_entry_t swp,
545 struct vm_area_struct *vma,
546 unsigned long addr)
547{
548 return NULL;
549}
550
551static inline int add_to_swap(struct page *page)
552{
553 return 0;
554}
555
556static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
557 gfp_t gfp_mask)
558{
559 return -1;
560}
561
562static inline void __delete_from_swap_cache(struct page *page)
563{
564}
565
566static inline void delete_from_swap_cache(struct page *page)
567{
568}
569
570static inline int page_swapcount(struct page *page)
571{
572 return 0;
573}
574
575static inline int __swp_swapcount(swp_entry_t entry)
576{
577 return 0;
578}
579
580static inline int swp_swapcount(swp_entry_t entry)
581{
582 return 0;
583}
584
585#define reuse_swap_page(page, total_map_swapcount) \
586 (page_trans_huge_mapcount(page, total_map_swapcount) == 1)
587
588static inline int try_to_free_swap(struct page *page)
589{
590 return 0;
591}
592
593static inline swp_entry_t get_swap_page(struct page *page)
594{
595 swp_entry_t entry;
596 entry.val = 0;
597 return entry;
598}
599
600#endif /* CONFIG_SWAP */
601
602#ifdef CONFIG_THP_SWAP
603extern int split_swap_cluster(swp_entry_t entry);
604#else
605static inline int split_swap_cluster(swp_entry_t entry)
606{
607 return 0;
608}
609#endif
610
611#ifdef CONFIG_MEMCG
612static inline int mem_cgroup_swappiness(struct mem_cgroup *memcg)
613{
614 /* Cgroup2 doesn't have per-cgroup swappiness */
615 if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
616 return vm_swappiness;
617
618 /* root ? */
619 if (mem_cgroup_disabled() || !memcg->css.parent)
620 return vm_swappiness;
621
622 return memcg->swappiness;
623}
624
625#else
626static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
627{
628 return vm_swappiness;
629}
630#endif
631
632#ifdef CONFIG_MEMCG_SWAP
633extern void mem_cgroup_swapout(struct page *page, swp_entry_t entry);
634extern int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry);
635extern void mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages);
636extern long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg);
637extern bool mem_cgroup_swap_full(struct page *page);
638#else
639static inline void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
640{
641}
642
643static inline int mem_cgroup_try_charge_swap(struct page *page,
644 swp_entry_t entry)
645{
646 return 0;
647}
648
649static inline void mem_cgroup_uncharge_swap(swp_entry_t entry,
650 unsigned int nr_pages)
651{
652}
653
654static inline long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg)
655{
656 return get_nr_swap_pages();
657}
658
659static inline bool mem_cgroup_swap_full(struct page *page)
660{
661 return vm_swap_full();
662}
663#endif
664
665#endif /* __KERNEL__*/
666#endif /* _LINUX_SWAP_H */