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