v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / 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 8
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 extern unsigned int nr_free_pages(void);
83 extern unsigned int nr_inactive_clean_pages(void);
84 extern unsigned int nr_free_buffer_pages(void);
85 extern int nr_active_pages;
86 extern int nr_inactive_dirty_pages;
87 extern atomic_t nr_async_pages;
88 extern struct address_space swapper_space;
89 extern atomic_t page_cache_size;
90 extern atomic_t buffermem_pages;
91 extern spinlock_t pagecache_lock;
92 extern void __remove_inode_page(struct page *);
93
94 /* Incomplete types for prototype declarations: */
95 struct task_struct;
96 struct vm_area_struct;
97 struct sysinfo;
98
99 struct zone_t;
100
101 /* linux/mm/swap.c */
102 extern int memory_pressure;
103 extern void deactivate_page(struct page *);
104 extern void deactivate_page_nolock(struct page *);
105 extern void activate_page(struct page *);
106 extern void activate_page_nolock(struct page *);
107 extern void lru_cache_add(struct page *);
108 extern void __lru_cache_del(struct page *);
109 extern void lru_cache_del(struct page *);
110 extern void recalculate_vm_stats(void);
111 extern void swap_setup(void);
112
113 /* linux/mm/vmscan.c */
114 extern struct page * reclaim_page(zone_t *);
115 extern wait_queue_head_t kswapd_wait;
116 extern wait_queue_head_t kreclaimd_wait;
117 extern int page_launder(int, int);
118 extern int free_shortage(void);
119 extern int inactive_shortage(void);
120 extern void wakeup_kswapd(void);
121 extern int try_to_free_pages(unsigned int gfp_mask);
122
123 /* linux/mm/page_io.c */
124 extern void rw_swap_page(int, struct page *);
125 extern void rw_swap_page_nolock(int, swp_entry_t, char *);
126
127 /* linux/mm/page_alloc.c */
128
129 /* linux/mm/swap_state.c */
130 extern void show_swap_cache_info(void);
131 extern void add_to_swap_cache(struct page *, swp_entry_t);
132 extern int swap_check_entry(unsigned long);
133 extern struct page * lookup_swap_cache(swp_entry_t);
134 extern struct page * read_swap_cache_async(swp_entry_t);
135
136 /* linux/mm/oom_kill.c */
137 extern int out_of_memory(void);
138 extern void oom_kill(void);
139
140 /*
141  * Make these inline later once they are working properly.
142  */
143 extern void __delete_from_swap_cache(struct page *page);
144 extern void delete_from_swap_cache(struct page *page);
145 extern void delete_from_swap_cache_nolock(struct page *page);
146 extern void free_page_and_swap_cache(struct page *page);
147
148 /* linux/mm/swapfile.c */
149 extern int vm_swap_full(void);
150 extern unsigned int nr_swapfiles;
151 extern struct swap_info_struct swap_info[];
152 extern int is_swap_partition(kdev_t);
153 extern void si_swapinfo(struct sysinfo *);
154 extern swp_entry_t __get_swap_page(unsigned short);
155 extern void get_swaphandle_info(swp_entry_t, unsigned long *, kdev_t *, 
156                                         struct inode **);
157 extern int swap_duplicate(swp_entry_t);
158 extern int swap_count(struct page *);
159 extern int valid_swaphandles(swp_entry_t, unsigned long *);
160 #define get_swap_page() __get_swap_page(1)
161 extern void __swap_free(swp_entry_t, unsigned short);
162 #define swap_free(entry) __swap_free((entry), 1)
163 struct swap_list_t {
164         int head;       /* head of priority-ordered swapfile list */
165         int next;       /* swapfile to be used next */
166 };
167 extern struct swap_list_t swap_list;
168 asmlinkage long sys_swapoff(const char *);
169 asmlinkage long sys_swapon(const char *, int);
170
171 #define SWAP_CACHE_INFO
172
173 #ifdef SWAP_CACHE_INFO
174 extern unsigned long swap_cache_add_total;
175 extern unsigned long swap_cache_del_total;
176 extern unsigned long swap_cache_find_total;
177 extern unsigned long swap_cache_find_success;
178 #endif
179
180 extern spinlock_t pagemap_lru_lock;
181
182 extern void FASTCALL(mark_page_accessed(struct page *));
183
184 /*
185  * Page aging defines.
186  * Since we do exponential decay of the page age, we
187  * can chose a fairly large maximum.
188  */
189 #define PAGE_AGE_START 2
190 #define PAGE_AGE_ADV 3
191 #define PAGE_AGE_MAX 64
192
193 /*
194  * List add/del helper macros. These must be called
195  * with the pagemap_lru_lock held!
196  */
197 #define DEBUG_ADD_PAGE \
198         if (PageActive(page) || PageInactiveDirty(page) || \
199                                         PageInactiveClean(page)) BUG();
200
201 #define ZERO_PAGE_BUG \
202         if (page_count(page) == 0) BUG();
203
204 #define add_page_to_active_list(page) { \
205         DEBUG_ADD_PAGE \
206         ZERO_PAGE_BUG \
207         page->age = 0; \
208         ClearPageReferenced(page); \
209         SetPageActive(page); \
210         list_add(&(page)->lru, &active_list); \
211         nr_active_pages++; \
212 }
213
214 #define add_page_to_inactive_dirty_list(page) { \
215         DEBUG_ADD_PAGE \
216         ZERO_PAGE_BUG \
217         SetPageInactiveDirty(page); \
218         list_add(&(page)->lru, &inactive_dirty_list); \
219         nr_inactive_dirty_pages++; \
220         page->zone->inactive_dirty_pages++; \
221 }
222
223 #define add_page_to_inactive_clean_list(page) { \
224         DEBUG_ADD_PAGE \
225         ZERO_PAGE_BUG \
226         SetPageInactiveClean(page); \
227         list_add(&(page)->lru, &page->zone->inactive_clean_list); \
228         page->zone->inactive_clean_pages++; \
229 }
230
231 #define del_page_from_active_list(page) { \
232         list_del(&(page)->lru); \
233         ClearPageActive(page); \
234         nr_active_pages--; \
235         DEBUG_ADD_PAGE \
236         ZERO_PAGE_BUG \
237 }
238
239 #define del_page_from_inactive_dirty_list(page) { \
240         list_del(&(page)->lru); \
241         ClearPageInactiveDirty(page); \
242         nr_inactive_dirty_pages--; \
243         page->zone->inactive_dirty_pages--; \
244         DEBUG_ADD_PAGE \
245         ZERO_PAGE_BUG \
246 }
247
248 #define del_page_from_inactive_clean_list(page) { \
249         list_del(&(page)->lru); \
250         ClearPageInactiveClean(page); \
251         page->zone->inactive_clean_pages--; \
252         DEBUG_ADD_PAGE \
253         ZERO_PAGE_BUG \
254 }
255
256 /*
257  * In mm/swap.c::recalculate_vm_stats(), we substract
258  * inactive_target from memory_pressure every second.
259  * This means that memory_pressure is smoothed over
260  * 64 (1 << INACTIVE_SHIFT) seconds.
261  */
262 #define INACTIVE_SHIFT 6
263 #define inactive_target min_t(unsigned long, \
264                             (memory_pressure >> INACTIVE_SHIFT), \
265                             (num_physpages / 4))
266
267 /*
268  * Ugly ugly ugly HACK to make sure the inactive lists
269  * don't fill up with unfreeable ramdisk pages. We really
270  * want to fix the ramdisk driver to mark its pages as
271  * unfreeable instead of using dirty buffer magic, but the
272  * next code-change time is when 2.5 is forked...
273  */
274 #ifndef _LINUX_KDEV_T_H
275 #include <linux/kdev_t.h>
276 #endif
277 #ifndef _LINUX_MAJOR_H
278 #include <linux/major.h>
279 #endif
280
281 #define page_ramdisk(page) \
282         (page->buffers && (MAJOR(page->buffers->b_dev) == RAMDISK_MAJOR))
283
284 extern spinlock_t swaplock;
285
286 #define swap_list_lock()        spin_lock(&swaplock)
287 #define swap_list_unlock()      spin_unlock(&swaplock)
288 #define swap_device_lock(p)     spin_lock(&p->sdev_lock)
289 #define swap_device_unlock(p)   spin_unlock(&p->sdev_lock)
290
291 extern void shmem_unuse(swp_entry_t entry, struct page *page);
292
293 #endif /* __KERNEL__*/
294
295 #endif /* _LINUX_SWAP_H */