LXR linux-bk/include/linux/swap.h

   1#ifndef _LINUX_SWAP_H
   2#define _LINUX_SWAP_H
   3
   4#include <linux/config.h>
   5#include <linux/spinlock.h>
   6#include <linux/linkage.h>
   7#include <linux/mmzone.h>
   8#include <linux/list.h>
   9#include <linux/sched.h>
  10#include <asm/atomic.h>
  11#include <asm/page.h>
  12
  13#define SWAP_FLAG_PREFER        0x8000  /* set if swap priority specified */
  14#define SWAP_FLAG_PRIO_MASK     0x7fff
  15#define SWAP_FLAG_PRIO_SHIFT    0
  16
  17static inline int current_is_kswapd(void)
  18{
  19        return current->flags & PF_KSWAPD;
  20}
  21
  22/*
  23 * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
  24 * be swapped to.  The swap type and the offset into that swap type are
  25 * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
  26 * for the type means that the maximum number of swapcache pages is 27 bits
  27 * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
  28 * the type/offset into the pte as 5/27 as well.
  29 */
  30#define MAX_SWAPFILES_SHIFT     5
  31#define MAX_SWAPFILES           (1 << MAX_SWAPFILES_SHIFT)
  32
  33/*
  34 * Magic header for a swap area. The first part of the union is
  35 * what the swap magic looks like for the old (limited to 128MB)
  36 * swap area format, the second part of the union adds - in the
  37 * old reserved area - some extra information. Note that the first
  38 * kilobyte is reserved for boot loader or disk label stuff...
  39 *
  40 * Having the magic at the end of the PAGE_SIZE makes detecting swap
  41 * areas somewhat tricky on machines that support multiple page sizes.
  42 * For 2.5 we'll probably want to move the magic to just beyond the
  43 * bootbits...
  44 */
  45union swap_header {
  46        struct {
  47                char reserved[PAGE_SIZE - 10];
  48                char magic[10];                 /* SWAP-SPACE or SWAPSPACE2 */
  49        } magic;
  50        struct {
  51                char         bootbits[1024];    /* Space for disklabel etc. */
  52                unsigned int version;
  53                unsigned int last_page;
  54                unsigned int nr_badpages;
  55                unsigned int padding[125];
  56                unsigned int badpages[1];
  57        } info;
  58};
  59
  60 /* A swap entry has to fit into a "unsigned long", as
  61  * the entry is hidden in the "index" field of the
  62  * swapper address space.
  63  */
  64typedef struct {
  65        unsigned long val;
  66} swp_entry_t;
  67
  68/*
  69 * current->reclaim_state points to one of these when a task is running
  70 * memory reclaim
  71 */
  72struct reclaim_state {
  73        unsigned long reclaimed_slab;
  74};
  75
  76#ifdef __KERNEL__
  77
  78struct address_space;
  79struct sysinfo;
  80struct writeback_control;
  81struct zone;
  82
  83/*
  84 * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
  85 * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
  86 * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
  87 * from setup, they're handled identically.
  88 *
  89 * We always assume that blocks are of size PAGE_SIZE.
  90 */
  91struct swap_extent {
  92        struct list_head list;
  93        pgoff_t start_page;
  94        pgoff_t nr_pages;
  95        sector_t start_block;
  96};
  97
  98/*
  99 * Max bad pages in the new format..
 100 */
 101#define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
 102#define MAX_SWAP_BADPAGES \
 103        ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
 104
 105enum {
 106        SWP_USED        = (1 << 0),     /* is slot in swap_info[] used? */
 107        SWP_WRITEOK     = (1 << 1),     /* ok to write to this swap?    */
 108        SWP_ACTIVE      = (SWP_USED | SWP_WRITEOK),
 109};
 110
 111#define SWAP_CLUSTER_MAX 32
 112
 113#define SWAP_MAP_MAX    0x7fff
 114#define SWAP_MAP_BAD    0x8000
 115
 116/*
 117 * The in-memory structure used to track swap areas.
 118 * extent_list.prev points at the lowest-index extent.  That list is
 119 * sorted.
 120 */
 121struct swap_info_struct {
 122        unsigned int flags;
 123        spinlock_t sdev_lock;
 124        struct file *swap_file;
 125        struct block_device *bdev;
 126        struct list_head extent_list;
 127        int nr_extents;
 128        struct swap_extent *curr_swap_extent;
 129        unsigned old_block_size;
 130        unsigned short * swap_map;
 131        unsigned int lowest_bit;
 132        unsigned int highest_bit;
 133        unsigned int cluster_next;
 134        unsigned int cluster_nr;
 135        int prio;                       /* swap priority */
 136        int pages;
 137        unsigned long max;
 138        unsigned long inuse_pages;
 139        int next;                       /* next entry on swap list */
 140};
 141
 142struct swap_list_t {
 143        int head;       /* head of priority-ordered swapfile list */
 144        int next;       /* swapfile to be used next */
 145};
 146
 147/* Swap 50% full? Release swapcache more aggressively.. */
 148#define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
 149
 150/* linux/mm/oom_kill.c */
 151extern void out_of_memory(int gfp_mask);
 152
 153/* linux/mm/memory.c */
 154extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
 155
 156/* linux/mm/page_alloc.c */
 157extern unsigned long totalram_pages;
 158extern unsigned long totalhigh_pages;
 159extern long nr_swap_pages;
 160extern unsigned int nr_free_pages(void);
 161extern unsigned int nr_free_pages_pgdat(pg_data_t *pgdat);
 162extern unsigned int nr_free_buffer_pages(void);
 163extern unsigned int nr_free_pagecache_pages(void);
 164
 165/* linux/mm/swap.c */
 166extern void FASTCALL(lru_cache_add(struct page *));
 167extern void FASTCALL(lru_cache_add_active(struct page *));
 168extern void FASTCALL(activate_page(struct page *));
 169extern void FASTCALL(mark_page_accessed(struct page *));
 170extern void lru_add_drain(void);
 171extern int rotate_reclaimable_page(struct page *page);
 172extern void swap_setup(void);
 173
 174/* linux/mm/vmscan.c */
 175extern int try_to_free_pages(struct zone **, unsigned int, unsigned int);
 176extern int shrink_all_memory(int);
 177extern int vm_swappiness;
 178
 179#ifdef CONFIG_MMU
 180/* linux/mm/shmem.c */
 181extern int shmem_unuse(swp_entry_t entry, struct page *page);
 182#endif /* CONFIG_MMU */
 183
 184extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
 185
 186#ifdef CONFIG_SWAP
 187/* linux/mm/page_io.c */
 188extern int swap_readpage(struct file *, struct page *);
 189extern int swap_writepage(struct page *page, struct writeback_control *wbc);
 190extern int rw_swap_page_sync(int, swp_entry_t, struct page *);
 191
 192/* linux/mm/swap_state.c */
 193extern struct address_space swapper_space;
 194#define total_swapcache_pages  swapper_space.nrpages
 195extern void show_swap_cache_info(void);
 196extern int add_to_swap(struct page *);
 197extern void __delete_from_swap_cache(struct page *);
 198extern void delete_from_swap_cache(struct page *);
 199extern int move_to_swap_cache(struct page *, swp_entry_t);
 200extern int move_from_swap_cache(struct page *, unsigned long,
 201                struct address_space *);
 202extern void free_page_and_swap_cache(struct page *);
 203extern void free_pages_and_swap_cache(struct page **, int);
 204extern struct page * lookup_swap_cache(swp_entry_t);
 205extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma,
 206                                           unsigned long addr);
 207/* linux/mm/swapfile.c */
 208extern long total_swap_pages;
 209extern unsigned int nr_swapfiles;
 210extern struct swap_info_struct swap_info[];
 211extern void si_swapinfo(struct sysinfo *);
 212extern swp_entry_t get_swap_page(void);
 213extern int swap_duplicate(swp_entry_t);
 214extern int valid_swaphandles(swp_entry_t, unsigned long *);
 215extern void swap_free(swp_entry_t);
 216extern void free_swap_and_cache(swp_entry_t);
 217extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
 218extern struct swap_info_struct *get_swap_info_struct(unsigned);
 219extern int can_share_swap_page(struct page *);
 220extern int remove_exclusive_swap_page(struct page *);
 221struct backing_dev_info;
 222
 223extern struct swap_list_t swap_list;
 224extern spinlock_t swaplock;
 225
 226#define swap_list_lock()        spin_lock(&swaplock)
 227#define swap_list_unlock()      spin_unlock(&swaplock)
 228#define swap_device_lock(p)     spin_lock(&p->sdev_lock)
 229#define swap_device_unlock(p)   spin_unlock(&p->sdev_lock)
 230
 231/* linux/mm/thrash.c */
 232extern struct mm_struct * swap_token_mm;
 233extern unsigned long swap_token_default_timeout;
 234extern void grab_swap_token(void);
 235extern void __put_swap_token(struct mm_struct *);
 236
 237static inline int has_swap_token(struct mm_struct *mm)
 238{
 239        return (mm == swap_token_mm);
 240}
 241
 242static inline void put_swap_token(struct mm_struct *mm)
 243{
 244        if (has_swap_token(mm))
 245                __put_swap_token(mm);
 246}
 247
 248#else /* CONFIG_SWAP */
 249
 250#define total_swap_pages                        0
 251#define total_swapcache_pages                   0UL
 252
 253#define si_swapinfo(val) \
 254        do { (val)->freeswap = (val)->totalswap = 0; } while (0)
 255#define free_page_and_swap_cache(page) \
 256        page_cache_release(page)
 257#define free_pages_and_swap_cache(pages, nr) \
 258        release_pages((pages), (nr), 0);
 259
 260#define show_swap_cache_info()                  /*NOTHING*/
 261#define free_swap_and_cache(swp)                /*NOTHING*/
 262#define swap_duplicate(swp)                     /*NOTHING*/
 263#define swap_free(swp)                          /*NOTHING*/
 264#define read_swap_cache_async(swp,vma,addr)     NULL
 265#define lookup_swap_cache(swp)                  NULL
 266#define valid_swaphandles(swp, off)             0
 267#define can_share_swap_page(p)                  0
 268#define move_to_swap_cache(p, swp)              1
 269#define move_from_swap_cache(p, i, m)           1
 270#define __delete_from_swap_cache(p)             /*NOTHING*/
 271#define delete_from_swap_cache(p)               /*NOTHING*/
 272#define swap_token_default_timeout              0
 273
 274static inline int remove_exclusive_swap_page(struct page *p)
 275{
 276        return 0;
 277}
 278
 279static inline swp_entry_t get_swap_page(void)
 280{
 281        swp_entry_t entry;
 282        entry.val = 0;
 283        return entry;
 284}
 285
 286/* linux/mm/thrash.c */
 287#define put_swap_token(x) do { } while(0)
 288#define grab_swap_token()  do { } while(0)
 289#define has_swap_token(x) 0
 290
 291#endif /* CONFIG_SWAP */
 292#endif /* __KERNEL__*/
 293#endif /* _LINUX_SWAP_H */
 294