include/linux/swap.h

   1 #ifndef _LINUX_SWAP_H
   2 #define _LINUX_SWAP_H
   3
   4 #include <linux/spinlock.h>
   5 #include <asm/page.h>
   6
   7 #define SWAP_FLAG_PREFER        0x8000  /* set if swap priority specified */
   8 #define SWAP_FLAG_PRIO_MASK     0x7fff
   9 #define SWAP_FLAG_PRIO_SHIFT    0
  10
  11 #define MAX_SWAPFILES 32
  12
  13 /*
  14  * Magic header for a swap area. The first part of the union is
  15  * what the swap magic looks like for the old (limited to 128MB)
  16  * swap area format, the second part of the union adds - in the
  17  * old reserved area - some extra information. Note that the first
  18  * kilobyte is reserved for boot loader or disk label stuff...
  19  *
  20  * Having the magic at the end of the PAGE_SIZE makes detecting swap
  21  * areas somewhat tricky on machines that support multiple page sizes.
  22  * For 2.5 we'll probably want to move the magic to just beyond the
  23  * bootbits...
  24  */
  25 union swap_header {
  26         struct
  27         {
  28                 char reserved[PAGE_SIZE - 10];
  29                 char magic[10];                 /* SWAP-SPACE or SWAPSPACE2 */
  30         } magic;
  31         struct
  32         {
  33                 char         bootbits[1024];    /* Space for disklabel etc. */
  34                 unsigned int version;
  35                 unsigned int last_page;
  36                 unsigned int nr_badpages;
  37                 unsigned int padding[125];
  38                 unsigned int badpages[1];
  39         } info;
  40 };
  41
  42 #ifdef __KERNEL__
  43
  44 /*
  45  * Max bad pages in the new format..
  46  */
  47 #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
  48 #define MAX_SWAP_BADPAGES \
  49         ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
  50
  51 #include <asm/atomic.h>
  52
  53 #define SWP_USED        1
  54 #define SWP_WRITEOK     3
  55
  56 #define SWAP_CLUSTER_MAX 32
  57
  58 #define SWAP_MAP_MAX    0x7fff
  59 #define SWAP_MAP_BAD    0x8000
  60
  61 /*
  62  * The in-memory structure used to track swap areas.
  63  */
  64 struct swap_info_struct {
  65         unsigned int flags;
  66         kdev_t swap_device;
  67         spinlock_t sdev_lock;
  68         struct dentry * swap_file;
  69         struct vfsmount *swap_vfsmnt;
  70         unsigned short * swap_map;
  71         unsigned int lowest_bit;
  72         unsigned int highest_bit;
  73         unsigned int cluster_next;
  74         unsigned int cluster_nr;
  75         int prio;                       /* swap priority */
  76         int pages;
  77         unsigned long max;
  78         int next;                       /* next entry on swap list */
  79 };
  80
  81 extern int nr_swap_pages;
  82
  83 /* Swap 50% full? Release swapcache more aggressively.. */
  84 #define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
  85
  86 extern unsigned int nr_free_pages(void);
  87 extern unsigned int nr_free_buffer_pages(void);
  88 extern int nr_active_pages;
  89 extern int nr_inactive_pages;
  90 extern atomic_t page_cache_size;
  91 extern atomic_t buffermem_pages;
  92
  93 extern spinlock_cacheline_t pagecache_lock_cacheline;
  94 #define pagecache_lock (pagecache_lock_cacheline.lock)
  95
  96 extern void __remove_inode_page(struct page *);
  97
  98 /* Incomplete types for prototype declarations: */
  99 struct task_struct;
 100 struct vm_area_struct;
 101 struct sysinfo;
 102
 103 struct zone_t;
 104
 105 /* linux/mm/swap.c */
 106 extern void FASTCALL(lru_cache_add(struct page *));
 107 extern void FASTCALL(__lru_cache_del(struct page *));
 108 extern void FASTCALL(lru_cache_del(struct page *));
 109
 110 extern void FASTCALL(activate_page(struct page *));
 111
 112 extern void swap_setup(void);
 113
 114 /* linux/mm/vmscan.c */
 115 extern wait_queue_head_t kswapd_wait;
 116 extern int FASTCALL(try_to_free_pages_zone(zone_t *, unsigned int));
 117 extern int FASTCALL(try_to_free_pages(unsigned int));
 118
 119 /* linux/mm/page_io.c */
 120 extern void rw_swap_page(int, struct page *);
 121 extern void rw_swap_page_nolock(int, swp_entry_t, char *);
 122
 123 /* linux/mm/page_alloc.c */
 124
 125 /* linux/mm/swap_state.c */
 126 #define SWAP_CACHE_INFO
 127 #ifdef SWAP_CACHE_INFO
 128 extern void show_swap_cache_info(void);
 129 #endif
 130 extern int add_to_swap_cache(struct page *, swp_entry_t);
 131 extern void __delete_from_swap_cache(struct page *page);
 132 extern void delete_from_swap_cache(struct page *page);
 133 extern void free_page_and_swap_cache(struct page *page);
 134 extern struct page * lookup_swap_cache(swp_entry_t);
 135 extern struct page * read_swap_cache_async(swp_entry_t);
 136
 137 /* linux/mm/oom_kill.c */
 138 extern void out_of_memory(void);
 139
 140 /* linux/mm/swapfile.c */
 141 extern int total_swap_pages;
 142 extern unsigned int nr_swapfiles;
 143 extern struct swap_info_struct swap_info[];
 144 extern int is_swap_partition(kdev_t);
 145 extern void si_swapinfo(struct sysinfo *);
 146 extern swp_entry_t get_swap_page(void);
 147 extern void get_swaphandle_info(swp_entry_t, unsigned long *, kdev_t *,
 148                                         struct inode **);
 149 extern int swap_duplicate(swp_entry_t);
 150 extern int valid_swaphandles(swp_entry_t, unsigned long *);
 151 extern void swap_free(swp_entry_t);
 152 extern void free_swap_and_cache(swp_entry_t);
 153 struct swap_list_t {
 154         int head;       /* head of priority-ordered swapfile list */
 155         int next;       /* swapfile to be used next */
 156 };
 157 extern struct swap_list_t swap_list;
 158 asmlinkage long sys_swapoff(const char *);
 159 asmlinkage long sys_swapon(const char *, int);
 160
 161 extern spinlock_cacheline_t pagemap_lru_lock_cacheline;
 162 #define pagemap_lru_lock pagemap_lru_lock_cacheline.lock
 163
 164 extern void FASTCALL(mark_page_accessed(struct page *));
 165
 166 /*
 167  * List add/del helper macros. These must be called
 168  * with the pagemap_lru_lock held!
 169  */
 170 #define DEBUG_LRU_PAGE(page)                    \
 171 do {                                            \
 172         if (!PageLRU(page))                     \
 173                 BUG();                          \
 174         if (PageActive(page))                   \
 175                 BUG();                          \
 176 } while (0)
 177
 178 #define add_page_to_active_list(page)           \
 179 do {                                            \
 180         DEBUG_LRU_PAGE(page);                   \
 181         SetPageActive(page);                    \
 182         list_add(&(page)->lru, &active_list);   \
 183         nr_active_pages++;                      \
 184 } while (0)
 185
 186 #define add_page_to_inactive_list(page)         \
 187 do {                                            \
 188         DEBUG_LRU_PAGE(page);                   \
 189         list_add(&(page)->lru, &inactive_list); \
 190         nr_inactive_pages++;                    \
 191 } while (0)
 192
 193 #define del_page_from_active_list(page)         \
 194 do {                                            \
 195         list_del(&(page)->lru);                 \
 196         ClearPageActive(page);                  \
 197         nr_active_pages--;                      \
 198 } while (0)
 199
 200 #define del_page_from_inactive_list(page)       \
 201 do {                                            \
 202         list_del(&(page)->lru);                 \
 203         nr_inactive_pages--;                    \
 204 } while (0)
 205
 206 extern spinlock_t swaplock;
 207
 208 #define swap_list_lock()        spin_lock(&swaplock)
 209 #define swap_list_unlock()      spin_unlock(&swaplock)
 210 #define swap_device_lock(p)     spin_lock(&p->sdev_lock)
 211 #define swap_device_unlock(p)   spin_unlock(&p->sdev_lock)
 212
 213 extern void shmem_unuse(swp_entry_t entry, struct page *page);
 214
 215 #endif /* __KERNEL__*/
 216
 217 #endif /* _LINUX_SWAP_H */