LXR linux-old/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 */
  25union 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 */
  64struct 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
  81extern 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
  86extern unsigned int nr_free_pages(void);
  87extern unsigned int nr_free_buffer_pages(void);
  88extern int nr_active_pages;
  89extern int nr_inactive_pages;
  90extern atomic_t nr_async_pages;
  91extern atomic_t page_cache_size;
  92extern atomic_t buffermem_pages;
  93extern spinlock_t pagecache_lock;
  94extern void __remove_inode_page(struct page *);
  95
  96/* Incomplete types for prototype declarations: */
  97struct task_struct;
  98struct vm_area_struct;
  99struct sysinfo;
 100
 101struct zone_t;
 102
 103/* linux/mm/swap.c */
 104extern void FASTCALL(lru_cache_add(struct page *));
 105extern void FASTCALL(__lru_cache_del(struct page *));
 106extern void FASTCALL(lru_cache_del(struct page *));
 107
 108extern void FASTCALL(activate_page(struct page *));
 109
 110extern void swap_setup(void);
 111
 112/* linux/mm/vmscan.c */
 113extern wait_queue_head_t kswapd_wait;
 114extern int FASTCALL(try_to_free_pages(zone_t *, unsigned int, unsigned int));
 115
 116/* linux/mm/page_io.c */
 117extern void rw_swap_page(int, struct page *);
 118extern void rw_swap_page_nolock(int, swp_entry_t, char *);
 119
 120/* linux/mm/page_alloc.c */
 121
 122/* linux/mm/swap_state.c */
 123#define SWAP_CACHE_INFO
 124#ifdef SWAP_CACHE_INFO
 125extern void show_swap_cache_info(void);
 126#endif
 127extern int add_to_swap_cache(struct page *, swp_entry_t);
 128extern void __delete_from_swap_cache(struct page *page);
 129extern void delete_from_swap_cache(struct page *page);
 130extern void free_page_and_swap_cache(struct page *page);
 131extern struct page * lookup_swap_cache(swp_entry_t);
 132extern struct page * read_swap_cache_async(swp_entry_t);
 133
 134/* linux/mm/oom_kill.c */
 135extern void out_of_memory(void);
 136
 137/* linux/mm/swapfile.c */
 138extern int total_swap_pages;
 139extern unsigned int nr_swapfiles;
 140extern struct swap_info_struct swap_info[];
 141extern int is_swap_partition(kdev_t);
 142extern void si_swapinfo(struct sysinfo *);
 143extern swp_entry_t get_swap_page(void);
 144extern void get_swaphandle_info(swp_entry_t, unsigned long *, kdev_t *, 
 145                                        struct inode **);
 146extern int swap_duplicate(swp_entry_t);
 147extern int swap_count(struct page *);
 148extern int valid_swaphandles(swp_entry_t, unsigned long *);
 149extern void swap_free(swp_entry_t);
 150extern void free_swap_and_cache(swp_entry_t);
 151struct swap_list_t {
 152        int head;       /* head of priority-ordered swapfile list */
 153        int next;       /* swapfile to be used next */
 154};
 155extern struct swap_list_t swap_list;
 156asmlinkage long sys_swapoff(const char *);
 157asmlinkage long sys_swapon(const char *, int);
 158
 159extern spinlock_t pagemap_lru_lock;
 160
 161extern void FASTCALL(mark_page_accessed(struct page *));
 162
 163/*
 164 * List add/del helper macros. These must be called
 165 * with the pagemap_lru_lock held!
 166 */
 167#define DEBUG_LRU_PAGE(page)                    \
 168do {                                            \
 169        if (!PageLRU(page))                     \
 170                BUG();                          \
 171        if (PageActive(page))                   \
 172                BUG();                          \
 173} while (0)
 174
 175#define add_page_to_active_list(page)           \
 176do {                                            \
 177        DEBUG_LRU_PAGE(page);                   \
 178        SetPageActive(page);                    \
 179        list_add(&(page)->lru, &active_list);   \
 180        nr_active_pages++;                      \
 181} while (0)
 182
 183#define add_page_to_inactive_list(page)         \
 184do {                                            \
 185        DEBUG_LRU_PAGE(page);                   \
 186        list_add(&(page)->lru, &inactive_list); \
 187        nr_inactive_pages++;                    \
 188} while (0)
 189
 190#define del_page_from_active_list(page)         \
 191do {                                            \
 192        list_del(&(page)->lru);                 \
 193        ClearPageActive(page);                  \
 194        nr_active_pages--;                      \
 195} while (0)
 196
 197#define del_page_from_inactive_list(page)       \
 198do {                                            \
 199        list_del(&(page)->lru);                 \
 200        nr_inactive_pages--;                    \
 201} while (0)
 202
 203extern spinlock_t swaplock;
 204
 205#define swap_list_lock()        spin_lock(&swaplock)
 206#define swap_list_unlock()      spin_unlock(&swaplock)
 207#define swap_device_lock(p)     spin_lock(&p->sdev_lock)
 208#define swap_device_unlock(p)   spin_unlock(&p->sdev_lock)
 209
 210extern void shmem_unuse(swp_entry_t entry, struct page *page);
 211
 212#endif /* __KERNEL__*/
 213
 214#endif /* _LINUX_SWAP_H */
 215