include/linux/swap.h

   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
  16 struct notifier_block;
  17
  18 struct 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 /* discard swap cluster after use */
  24
  25 #define SWAP_FLAGS_VALID        (SWAP_FLAG_PRIO_MASK | SWAP_FLAG_PREFER | \
  26                                  SWAP_FLAG_DISCARD)
  27
  28 static inline int current_is_kswapd(void)
  29 {
  30         return current->flags & PF_KSWAPD;
  31 }
  32
  33 /*
  34  * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
  35  * be swapped to.  The swap type and the offset into that swap type are
  36  * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
  37  * for the type means that the maximum number of swapcache pages is 27 bits
  38  * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
  39  * the type/offset into the pte as 5/27 as well.
  40  */
  41 #define MAX_SWAPFILES_SHIFT     5
  42
  43 /*
  44  * Use some of the swap files numbers for other purposes. This
  45  * is a convenient way to hook into the VM to trigger special
  46  * actions on faults.
  47  */
  48
  49 /*
  50  * NUMA node memory migration support
  51  */
  52 #ifdef CONFIG_MIGRATION
  53 #define SWP_MIGRATION_NUM 2
  54 #define SWP_MIGRATION_READ      (MAX_SWAPFILES + SWP_HWPOISON_NUM)
  55 #define SWP_MIGRATION_WRITE     (MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
  56 #else
  57 #define SWP_MIGRATION_NUM 0
  58 #endif
  59
  60 /*
  61  * Handling of hardware poisoned pages with memory corruption.
  62  */
  63 #ifdef CONFIG_MEMORY_FAILURE
  64 #define SWP_HWPOISON_NUM 1
  65 #define SWP_HWPOISON            MAX_SWAPFILES
  66 #else
  67 #define SWP_HWPOISON_NUM 0
  68 #endif
  69
  70 #define MAX_SWAPFILES \
  71         ((1 << MAX_SWAPFILES_SHIFT) - SWP_MIGRATION_NUM - SWP_HWPOISON_NUM)
  72
  73 /*
  74  * Magic header for a swap area. The first part of the union is
  75  * what the swap magic looks like for the old (limited to 128MB)
  76  * swap area format, the second part of the union adds - in the
  77  * old reserved area - some extra information. Note that the first
  78  * kilobyte is reserved for boot loader or disk label stuff...
  79  *
  80  * Having the magic at the end of the PAGE_SIZE makes detecting swap
  81  * areas somewhat tricky on machines that support multiple page sizes.
  82  * For 2.5 we'll probably want to move the magic to just beyond the
  83  * bootbits...
  84  */
  85 union swap_header {
  86         struct {
  87                 char reserved[PAGE_SIZE - 10];
  88                 char magic[10];                 /* SWAP-SPACE or SWAPSPACE2 */
  89         } magic;
  90         struct {
  91                 char            bootbits[1024]; /* Space for disklabel etc. */
  92                 __u32           version;
  93                 __u32           last_page;
  94                 __u32           nr_badpages;
  95                 unsigned char   sws_uuid[16];
  96                 unsigned char   sws_volume[16];
  97                 __u32           padding[117];
  98                 __u32           badpages[1];
  99         } info;
 100 };
 101
 102  /* A swap entry has to fit into a "unsigned long", as
 103   * the entry is hidden in the "index" field of the
 104   * swapper address space.
 105   */
 106 typedef struct {
 107         unsigned long val;
 108 } swp_entry_t;
 109
 110 /*
 111  * current->reclaim_state points to one of these when a task is running
 112  * memory reclaim
 113  */
 114 struct reclaim_state {
 115         unsigned long reclaimed_slab;
 116 };
 117
 118 #ifdef __KERNEL__
 119
 120 struct address_space;
 121 struct sysinfo;
 122 struct writeback_control;
 123 struct zone;
 124
 125 /*
 126  * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
 127  * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
 128  * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
 129  * from setup, they're handled identically.
 130  *
 131  * We always assume that blocks are of size PAGE_SIZE.
 132  */
 133 struct swap_extent {
 134         struct list_head list;
 135         pgoff_t start_page;
 136         pgoff_t nr_pages;
 137         sector_t start_block;
 138 };
 139
 140 /*
 141  * Max bad pages in the new format..
 142  */
 143 #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
 144 #define MAX_SWAP_BADPAGES \
 145         ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
 146
 147 enum {
 148         SWP_USED        = (1 << 0),     /* is slot in swap_info[] used? */
 149         SWP_WRITEOK     = (1 << 1),     /* ok to write to this swap?    */
 150         SWP_DISCARDABLE = (1 << 2),     /* swapon+blkdev support discard */
 151         SWP_DISCARDING  = (1 << 3),     /* now discarding a free cluster */
 152         SWP_SOLIDSTATE  = (1 << 4),     /* blkdev seeks are cheap */
 153         SWP_CONTINUED   = (1 << 5),     /* swap_map has count continuation */
 154         SWP_BLKDEV      = (1 << 6),     /* its a block device */
 155         SWP_FILE        = (1 << 7),     /* set after swap_activate success */
 156                                         /* add others here before... */
 157         SWP_SCANNING    = (1 << 8),     /* refcount in scan_swap_map */
 158 };
 159
 160 #define SWAP_CLUSTER_MAX 32UL
 161 #define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
 162
 163 /*
 164  * Ratio between the present memory in the zone and the "gap" that
 165  * we're allowing kswapd to shrink in addition to the per-zone high
 166  * wmark, even for zones that already have the high wmark satisfied,
 167  * in order to provide better per-zone lru behavior. We are ok to
 168  * spend not more than 1% of the memory for this zone balancing "gap".
 169  */
 170 #define KSWAPD_ZONE_BALANCE_GAP_RATIO 100
 171
 172 #define SWAP_MAP_MAX    0x3e    /* Max duplication count, in first swap_map */
 173 #define SWAP_MAP_BAD    0x3f    /* Note pageblock is bad, in first swap_map */
 174 #define SWAP_HAS_CACHE  0x40    /* Flag page is cached, in first swap_map */
 175 #define SWAP_CONT_MAX   0x7f    /* Max count, in each swap_map continuation */
 176 #define COUNT_CONTINUED 0x80    /* See swap_map continuation for full count */
 177 #define SWAP_MAP_SHMEM  0xbf    /* Owned by shmem/tmpfs, in first swap_map */
 178
 179 /*
 180  * The in-memory structure used to track swap areas.
 181  */
 182 struct swap_info_struct {
 183         unsigned long   flags;          /* SWP_USED etc: see above */
 184         signed short    prio;           /* swap priority of this type */
 185         signed char     type;           /* strange name for an index */
 186         signed char     next;           /* next type on the swap list */
 187         unsigned int    max;            /* extent of the swap_map */
 188         unsigned char *swap_map;        /* vmalloc'ed array of usage counts */
 189         unsigned int lowest_bit;        /* index of first free in swap_map */
 190         unsigned int highest_bit;       /* index of last free in swap_map */
 191         unsigned int pages;             /* total of usable pages of swap */
 192         unsigned int inuse_pages;       /* number of those currently in use */
 193         unsigned int cluster_next;      /* likely index for next allocation */
 194         unsigned int cluster_nr;        /* countdown to next cluster search */
 195         unsigned int lowest_alloc;      /* while preparing discard cluster */
 196         unsigned int highest_alloc;     /* while preparing discard cluster */
 197         struct swap_extent *curr_swap_extent;
 198         struct swap_extent first_swap_extent;
 199         struct block_device *bdev;      /* swap device or bdev of swap file */
 200         struct file *swap_file;         /* seldom referenced */
 201         unsigned int old_block_size;    /* seldom referenced */
 202 #ifdef CONFIG_FRONTSWAP
 203         unsigned long *frontswap_map;   /* frontswap in-use, one bit per page */
 204         atomic_t frontswap_pages;       /* frontswap pages in-use counter */
 205 #endif
 206         spinlock_t lock;                /*
 207                                          * protect map scan related fields like
 208                                          * swap_map, lowest_bit, highest_bit,
 209                                          * inuse_pages, cluster_next,
 210                                          * cluster_nr, lowest_alloc and
 211                                          * highest_alloc. other fields are only
 212                                          * changed at swapon/swapoff, so are
 213                                          * protected by swap_lock. changing
 214                                          * flags need hold this lock and
 215                                          * swap_lock. If both locks need hold,
 216                                          * hold swap_lock first.
 217                                          */
 218 };
 219
 220 struct swap_list_t {
 221         int head;       /* head of priority-ordered swapfile list */
 222         int next;       /* swapfile to be used next */
 223 };
 224
 225 /* linux/mm/page_alloc.c */
 226 extern unsigned long totalram_pages;
 227 extern unsigned long totalreserve_pages;
 228 extern unsigned long dirty_balance_reserve;
 229 extern unsigned long nr_free_buffer_pages(void);
 230 extern unsigned long nr_free_pagecache_pages(void);
 231
 232 /* Definition of global_page_state not available yet */
 233 #define nr_free_pages() global_page_state(NR_FREE_PAGES)
 234
 235
 236 /* linux/mm/swap.c */
 237 extern void __lru_cache_add(struct page *);
 238 extern void lru_cache_add(struct page *);
 239 extern void lru_add_page_tail(struct page *page, struct page *page_tail,
 240                          struct lruvec *lruvec, struct list_head *head);
 241 extern void activate_page(struct page *);
 242 extern void mark_page_accessed(struct page *);
 243 extern void lru_add_drain(void);
 244 extern void lru_add_drain_cpu(int cpu);
 245 extern int lru_add_drain_all(void);
 246 extern void rotate_reclaimable_page(struct page *page);
 247 extern void deactivate_page(struct page *page);
 248 extern void swap_setup(void);
 249
 250 extern void add_page_to_unevictable_list(struct page *page);
 251
 252 /**
 253  * lru_cache_add: add a page to the page lists
 254  * @page: the page to add
 255  */
 256 static inline void lru_cache_add_anon(struct page *page)
 257 {
 258         ClearPageActive(page);
 259         __lru_cache_add(page);
 260 }
 261
 262 static inline void lru_cache_add_file(struct page *page)
 263 {
 264         ClearPageActive(page);
 265         __lru_cache_add(page);
 266 }
 267
 268 /* linux/mm/vmscan.c */
 269 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
 270                                         gfp_t gfp_mask, nodemask_t *mask);
 271 extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
 272 extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
 273                                                   gfp_t gfp_mask, bool noswap);
 274 extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
 275                                                 gfp_t gfp_mask, bool noswap,
 276                                                 struct zone *zone,
 277                                                 unsigned long *nr_scanned);
 278 extern unsigned long shrink_all_memory(unsigned long nr_pages);
 279 extern int vm_swappiness;
 280 extern int remove_mapping(struct address_space *mapping, struct page *page);
 281 extern unsigned long vm_total_pages;
 282
 283 #ifdef CONFIG_NUMA
 284 extern int zone_reclaim_mode;
 285 extern int sysctl_min_unmapped_ratio;
 286 extern int sysctl_min_slab_ratio;
 287 extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
 288 #else
 289 #define zone_reclaim_mode 0
 290 static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
 291 {
 292         return 0;
 293 }
 294 #endif
 295
 296 extern int page_evictable(struct page *page);
 297 extern void check_move_unevictable_pages(struct page **, int nr_pages);
 298
 299 extern unsigned long scan_unevictable_pages;
 300 extern int scan_unevictable_handler(struct ctl_table *, int,
 301                                         void __user *, size_t *, loff_t *);
 302 #ifdef CONFIG_NUMA
 303 extern int scan_unevictable_register_node(struct node *node);
 304 extern void scan_unevictable_unregister_node(struct node *node);
 305 #else
 306 static inline int scan_unevictable_register_node(struct node *node)
 307 {
 308         return 0;
 309 }
 310 static inline void scan_unevictable_unregister_node(struct node *node)
 311 {
 312 }
 313 #endif
 314
 315 extern int kswapd_run(int nid);
 316 extern void kswapd_stop(int nid);
 317 #ifdef CONFIG_MEMCG
 318 extern int mem_cgroup_swappiness(struct mem_cgroup *mem);
 319 #else
 320 static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
 321 {
 322         return vm_swappiness;
 323 }
 324 #endif
 325 #ifdef CONFIG_MEMCG_SWAP
 326 extern void mem_cgroup_uncharge_swap(swp_entry_t ent);
 327 #else
 328 static inline void mem_cgroup_uncharge_swap(swp_entry_t ent)
 329 {
 330 }
 331 #endif
 332 #ifdef CONFIG_SWAP
 333 /* linux/mm/page_io.c */
 334 extern int swap_readpage(struct page *);
 335 extern int swap_writepage(struct page *page, struct writeback_control *wbc);
 336 extern void end_swap_bio_write(struct bio *bio, int err);
 337 extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
 338         void (*end_write_func)(struct bio *, int));
 339 extern int swap_set_page_dirty(struct page *page);
 340 extern void end_swap_bio_read(struct bio *bio, int err);
 341
 342 int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
 343                 unsigned long nr_pages, sector_t start_block);
 344 int generic_swapfile_activate(struct swap_info_struct *, struct file *,
 345                 sector_t *);
 346
 347 /* linux/mm/swap_state.c */
 348 extern struct address_space swapper_spaces[];
 349 #define swap_address_space(entry) (&swapper_spaces[swp_type(entry)])
 350 extern unsigned long total_swapcache_pages(void);
 351 extern void show_swap_cache_info(void);
 352 extern int add_to_swap(struct page *, struct list_head *list);
 353 extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
 354 extern int __add_to_swap_cache(struct page *page, swp_entry_t entry);
 355 extern void __delete_from_swap_cache(struct page *);
 356 extern void delete_from_swap_cache(struct page *);
 357 extern void free_page_and_swap_cache(struct page *);
 358 extern void free_pages_and_swap_cache(struct page **, int);
 359 extern struct page *lookup_swap_cache(swp_entry_t);
 360 extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
 361                         struct vm_area_struct *vma, unsigned long addr);
 362 extern struct page *swapin_readahead(swp_entry_t, gfp_t,
 363                         struct vm_area_struct *vma, unsigned long addr);
 364
 365 /* linux/mm/swapfile.c */
 366 extern atomic_long_t nr_swap_pages;
 367 extern long total_swap_pages;
 368
 369 /* Swap 50% full? Release swapcache more aggressively.. */
 370 static inline bool vm_swap_full(void)
 371 {
 372         return atomic_long_read(&nr_swap_pages) * 2 < total_swap_pages;
 373 }
 374
 375 static inline long get_nr_swap_pages(void)
 376 {
 377         return atomic_long_read(&nr_swap_pages);
 378 }
 379
 380 extern void si_swapinfo(struct sysinfo *);
 381 extern swp_entry_t get_swap_page(void);
 382 extern swp_entry_t get_swap_page_of_type(int);
 383 extern int add_swap_count_continuation(swp_entry_t, gfp_t);
 384 extern void swap_shmem_alloc(swp_entry_t);
 385 extern int swap_duplicate(swp_entry_t);
 386 extern int swapcache_prepare(swp_entry_t);
 387 extern void swap_free(swp_entry_t);
 388 extern void swapcache_free(swp_entry_t, struct page *page);
 389 extern int free_swap_and_cache(swp_entry_t);
 390 extern int swap_type_of(dev_t, sector_t, struct block_device **);
 391 extern unsigned int count_swap_pages(int, int);
 392 extern sector_t map_swap_page(struct page *, struct block_device **);
 393 extern sector_t swapdev_block(int, pgoff_t);
 394 extern int page_swapcount(struct page *);
 395 extern struct swap_info_struct *page_swap_info(struct page *);
 396 extern int reuse_swap_page(struct page *);
 397 extern int try_to_free_swap(struct page *);
 398 struct backing_dev_info;
 399
 400 #ifdef CONFIG_MEMCG
 401 extern void
 402 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout);
 403 #else
 404 static inline void
 405 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
 406 {
 407 }
 408 #endif
 409
 410 #else /* CONFIG_SWAP */
 411
 412 #define get_nr_swap_pages()                     0L
 413 #define total_swap_pages                        0L
 414 #define total_swapcache_pages()                 0UL
 415 #define vm_swap_full()                          0
 416
 417 #define si_swapinfo(val) \
 418         do { (val)->freeswap = (val)->totalswap = 0; } while (0)
 419 /* only sparc can not include linux/pagemap.h in this file
 420  * so leave page_cache_release and release_pages undeclared... */
 421 #define free_page_and_swap_cache(page) \
 422         page_cache_release(page)
 423 #define free_pages_and_swap_cache(pages, nr) \
 424         release_pages((pages), (nr), 0);
 425
 426 static inline void show_swap_cache_info(void)
 427 {
 428 }
 429
 430 #define free_swap_and_cache(swp)        is_migration_entry(swp)
 431 #define swapcache_prepare(swp)          is_migration_entry(swp)
 432
 433 static inline int add_swap_count_continuation(swp_entry_t swp, gfp_t gfp_mask)
 434 {
 435         return 0;
 436 }
 437
 438 static inline void swap_shmem_alloc(swp_entry_t swp)
 439 {
 440 }
 441
 442 static inline int swap_duplicate(swp_entry_t swp)
 443 {
 444         return 0;
 445 }
 446
 447 static inline void swap_free(swp_entry_t swp)
 448 {
 449 }
 450
 451 static inline void swapcache_free(swp_entry_t swp, struct page *page)
 452 {
 453 }
 454
 455 static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
 456                         struct vm_area_struct *vma, unsigned long addr)
 457 {
 458         return NULL;
 459 }
 460
 461 static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
 462 {
 463         return 0;
 464 }
 465
 466 static inline struct page *lookup_swap_cache(swp_entry_t swp)
 467 {
 468         return NULL;
 469 }
 470
 471 static inline int add_to_swap(struct page *page, struct list_head *list)
 472 {
 473         return 0;
 474 }
 475
 476 static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
 477                                                         gfp_t gfp_mask)
 478 {
 479         return -1;
 480 }
 481
 482 static inline void __delete_from_swap_cache(struct page *page)
 483 {
 484 }
 485
 486 static inline void delete_from_swap_cache(struct page *page)
 487 {
 488 }
 489
 490 static inline int page_swapcount(struct page *page)
 491 {
 492         return 0;
 493 }
 494
 495 #define reuse_swap_page(page)   (page_mapcount(page) == 1)
 496
 497 static inline int try_to_free_swap(struct page *page)
 498 {
 499         return 0;
 500 }
 501
 502 static inline swp_entry_t get_swap_page(void)
 503 {
 504         swp_entry_t entry;
 505         entry.val = 0;
 506         return entry;
 507 }
 508
 509 static inline void
 510 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
 511 {
 512 }
 513
 514 #endif /* CONFIG_SWAP */
 515 #endif /* __KERNEL__*/
 516 #endif /* _LINUX_SWAP_H */