OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [swap.h] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
#ifndef _LINUX_SWAP_H
2
#define _LINUX_SWAP_H
3
 
4
#include <linux/spinlock.h>
5
#include <linux/linkage.h>
6
#include <linux/mmzone.h>
7
#include <linux/list.h>
8
#include <linux/sched.h>
9
 
10
#include <asm/atomic.h>
11
#include <asm/page.h>
12
 
13
struct notifier_block;
14
 
15
struct bio;
16
 
17
#define SWAP_FLAG_PREFER        0x8000  /* set if swap priority specified */
18
#define SWAP_FLAG_PRIO_MASK     0x7fff
19
#define SWAP_FLAG_PRIO_SHIFT    0
20
 
21
static inline int current_is_kswapd(void)
22
{
23
        return current->flags & PF_KSWAPD;
24
}
25
 
26
/*
27
 * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
28
 * be swapped to.  The swap type and the offset into that swap type are
29
 * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
30
 * for the type means that the maximum number of swapcache pages is 27 bits
31
 * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
32
 * the type/offset into the pte as 5/27 as well.
33
 */
34
#define MAX_SWAPFILES_SHIFT     5
35
#ifndef CONFIG_MIGRATION
36
#define MAX_SWAPFILES           (1 << MAX_SWAPFILES_SHIFT)
37
#else
38
/* Use last two entries for page migration swap entries */
39
#define MAX_SWAPFILES           ((1 << MAX_SWAPFILES_SHIFT)-2)
40
#define SWP_MIGRATION_READ      MAX_SWAPFILES
41
#define SWP_MIGRATION_WRITE     (MAX_SWAPFILES + 1)
42
#endif
43
 
44
/*
45
 * Magic header for a swap area. The first part of the union is
46
 * what the swap magic looks like for the old (limited to 128MB)
47
 * swap area format, the second part of the union adds - in the
48
 * old reserved area - some extra information. Note that the first
49
 * kilobyte is reserved for boot loader or disk label stuff...
50
 *
51
 * Having the magic at the end of the PAGE_SIZE makes detecting swap
52
 * areas somewhat tricky on machines that support multiple page sizes.
53
 * For 2.5 we'll probably want to move the magic to just beyond the
54
 * bootbits...
55
 */
56
union swap_header {
57
        struct {
58
                char reserved[PAGE_SIZE - 10];
59
                char magic[10];                 /* SWAP-SPACE or SWAPSPACE2 */
60
        } magic;
61
        struct {
62
                char            bootbits[1024]; /* Space for disklabel etc. */
63
                __u32           version;
64
                __u32           last_page;
65
                __u32           nr_badpages;
66
                unsigned char   sws_uuid[16];
67
                unsigned char   sws_volume[16];
68
                __u32           padding[117];
69
                __u32           badpages[1];
70
        } info;
71
};
72
 
73
 /* A swap entry has to fit into a "unsigned long", as
74
  * the entry is hidden in the "index" field of the
75
  * swapper address space.
76
  */
77
typedef struct {
78
        unsigned long val;
79
} swp_entry_t;
80
 
81
/*
82
 * current->reclaim_state points to one of these when a task is running
83
 * memory reclaim
84
 */
85
struct reclaim_state {
86
        unsigned long reclaimed_slab;
87
};
88
 
89
#ifdef __KERNEL__
90
 
91
struct address_space;
92
struct sysinfo;
93
struct writeback_control;
94
struct zone;
95
 
96
/*
97
 * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
98
 * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
99
 * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
100
 * from setup, they're handled identically.
101
 *
102
 * We always assume that blocks are of size PAGE_SIZE.
103
 */
104
struct swap_extent {
105
        struct list_head list;
106
        pgoff_t start_page;
107
        pgoff_t nr_pages;
108
        sector_t start_block;
109
};
110
 
111
/*
112
 * Max bad pages in the new format..
113
 */
114
#define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
115
#define MAX_SWAP_BADPAGES \
116
        ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
117
 
118
enum {
119
        SWP_USED        = (1 << 0),      /* is slot in swap_info[] used? */
120
        SWP_WRITEOK     = (1 << 1),     /* ok to write to this swap?    */
121
        SWP_ACTIVE      = (SWP_USED | SWP_WRITEOK),
122
                                        /* add others here before... */
123
        SWP_SCANNING    = (1 << 8),     /* refcount in scan_swap_map */
124
};
125
 
126
#define SWAP_CLUSTER_MAX 32
127
 
128
#define SWAP_MAP_MAX    0x7fff
129
#define SWAP_MAP_BAD    0x8000
130
 
131
/*
132
 * The in-memory structure used to track swap areas.
133
 */
134
struct swap_info_struct {
135
        unsigned int flags;
136
        int prio;                       /* swap priority */
137
        struct file *swap_file;
138
        struct block_device *bdev;
139
        struct list_head extent_list;
140
        struct swap_extent *curr_swap_extent;
141
        unsigned old_block_size;
142
        unsigned short * swap_map;
143
        unsigned int lowest_bit;
144
        unsigned int highest_bit;
145
        unsigned int cluster_next;
146
        unsigned int cluster_nr;
147
        unsigned int pages;
148
        unsigned int max;
149
        unsigned int inuse_pages;
150
        int next;                       /* next entry on swap list */
151
};
152
 
153
struct swap_list_t {
154
        int head;       /* head of priority-ordered swapfile list */
155
        int next;       /* swapfile to be used next */
156
};
157
 
158
/* Swap 50% full? Release swapcache more aggressively.. */
159
#define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
160
 
161
/* linux/mm/memory.c */
162
extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
163
 
164
/* linux/mm/page_alloc.c */
165
extern unsigned long totalram_pages;
166
extern unsigned long totalreserve_pages;
167
extern long nr_swap_pages;
168
extern unsigned int nr_free_buffer_pages(void);
169
extern unsigned int nr_free_pagecache_pages(void);
170
 
171
/* Definition of global_page_state not available yet */
172
#define nr_free_pages() global_page_state(NR_FREE_PAGES)
173
 
174
 
175
/* linux/mm/swap.c */
176
extern void FASTCALL(lru_cache_add(struct page *));
177
extern void FASTCALL(lru_cache_add_active(struct page *));
178
extern void FASTCALL(activate_page(struct page *));
179
extern void FASTCALL(mark_page_accessed(struct page *));
180
extern void lru_add_drain(void);
181
extern int lru_add_drain_all(void);
182
extern int rotate_reclaimable_page(struct page *page);
183
extern void swap_setup(void);
184
 
185
/* linux/mm/vmscan.c */
186
extern unsigned long try_to_free_pages(struct zone **zones, int order,
187
                                        gfp_t gfp_mask);
188
extern unsigned long shrink_all_memory(unsigned long nr_pages);
189
extern int vm_swappiness;
190
extern int remove_mapping(struct address_space *mapping, struct page *page);
191
extern long vm_total_pages;
192
 
193
#ifdef CONFIG_NUMA
194
extern int zone_reclaim_mode;
195
extern int sysctl_min_unmapped_ratio;
196
extern int sysctl_min_slab_ratio;
197
extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
198
#else
199
#define zone_reclaim_mode 0
200
static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
201
{
202
        return 0;
203
}
204
#endif
205
 
206
extern int kswapd_run(int nid);
207
 
208
#ifdef CONFIG_MMU
209
/* linux/mm/shmem.c */
210
extern int shmem_unuse(swp_entry_t entry, struct page *page);
211
#endif /* CONFIG_MMU */
212
 
213
extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
214
 
215
#ifdef CONFIG_SWAP
216
/* linux/mm/page_io.c */
217
extern int swap_readpage(struct file *, struct page *);
218
extern int swap_writepage(struct page *page, struct writeback_control *wbc);
219
extern void end_swap_bio_read(struct bio *bio, int err);
220
 
221
/* linux/mm/swap_state.c */
222
extern struct address_space swapper_space;
223
#define total_swapcache_pages  swapper_space.nrpages
224
extern void show_swap_cache_info(void);
225
extern int add_to_swap(struct page *, gfp_t);
226
extern void __delete_from_swap_cache(struct page *);
227
extern void delete_from_swap_cache(struct page *);
228
extern int move_to_swap_cache(struct page *, swp_entry_t);
229
extern int move_from_swap_cache(struct page *, unsigned long,
230
                struct address_space *);
231
extern void free_page_and_swap_cache(struct page *);
232
extern void free_pages_and_swap_cache(struct page **, int);
233
extern struct page * lookup_swap_cache(swp_entry_t);
234
extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma,
235
                                           unsigned long addr);
236
/* linux/mm/swapfile.c */
237
extern long total_swap_pages;
238
extern unsigned int nr_swapfiles;
239
extern void si_swapinfo(struct sysinfo *);
240
extern swp_entry_t get_swap_page(void);
241
extern swp_entry_t get_swap_page_of_type(int);
242
extern int swap_duplicate(swp_entry_t);
243
extern int valid_swaphandles(swp_entry_t, unsigned long *);
244
extern void swap_free(swp_entry_t);
245
extern void free_swap_and_cache(swp_entry_t);
246
extern int swap_type_of(dev_t, sector_t, struct block_device **);
247
extern unsigned int count_swap_pages(int, int);
248
extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
249
extern sector_t swapdev_block(int, pgoff_t);
250
extern struct swap_info_struct *get_swap_info_struct(unsigned);
251
extern int can_share_swap_page(struct page *);
252
extern int remove_exclusive_swap_page(struct page *);
253
struct backing_dev_info;
254
 
255
extern spinlock_t swap_lock;
256
 
257
/* linux/mm/thrash.c */
258
extern struct mm_struct * swap_token_mm;
259
extern void grab_swap_token(void);
260
extern void __put_swap_token(struct mm_struct *);
261
 
262
static inline int has_swap_token(struct mm_struct *mm)
263
{
264
        return (mm == swap_token_mm);
265
}
266
 
267
static inline void put_swap_token(struct mm_struct *mm)
268
{
269
        if (has_swap_token(mm))
270
                __put_swap_token(mm);
271
}
272
 
273
static inline void disable_swap_token(void)
274
{
275
        put_swap_token(swap_token_mm);
276
}
277
 
278
#else /* CONFIG_SWAP */
279
 
280
#define total_swap_pages                        0
281
#define total_swapcache_pages                   0UL
282
 
283
#define si_swapinfo(val) \
284
        do { (val)->freeswap = (val)->totalswap = 0; } while (0)
285
/* only sparc can not include linux/pagemap.h in this file
286
 * so leave page_cache_release and release_pages undeclared... */
287
#define free_page_and_swap_cache(page) \
288
        page_cache_release(page)
289
#define free_pages_and_swap_cache(pages, nr) \
290
        release_pages((pages), (nr), 0);
291
 
292
static inline void show_swap_cache_info(void)
293
{
294
}
295
 
296
static inline void free_swap_and_cache(swp_entry_t swp)
297
{
298
}
299
 
300
static inline int swap_duplicate(swp_entry_t swp)
301
{
302
        return 0;
303
}
304
 
305
static inline void swap_free(swp_entry_t swp)
306
{
307
}
308
 
309
static inline struct page *read_swap_cache_async(swp_entry_t swp,
310
                        struct vm_area_struct *vma, unsigned long addr)
311
{
312
        return NULL;
313
}
314
 
315
static inline struct page *lookup_swap_cache(swp_entry_t swp)
316
{
317
        return NULL;
318
}
319
 
320
static inline int valid_swaphandles(swp_entry_t entry, unsigned long *offset)
321
{
322
        return 0;
323
}
324
 
325
#define can_share_swap_page(p)                  (page_mapcount(p) == 1)
326
 
327
static inline int move_to_swap_cache(struct page *page, swp_entry_t entry)
328
{
329
        return 1;
330
}
331
 
332
static inline int move_from_swap_cache(struct page *page, unsigned long index,
333
                                        struct address_space *mapping)
334
{
335
        return 1;
336
}
337
 
338
static inline void __delete_from_swap_cache(struct page *page)
339
{
340
}
341
 
342
static inline void delete_from_swap_cache(struct page *page)
343
{
344
}
345
 
346
#define swap_token_default_timeout              0
347
 
348
static inline int remove_exclusive_swap_page(struct page *p)
349
{
350
        return 0;
351
}
352
 
353
static inline swp_entry_t get_swap_page(void)
354
{
355
        swp_entry_t entry;
356
        entry.val = 0;
357
        return entry;
358
}
359
 
360
/* linux/mm/thrash.c */
361
#define put_swap_token(x) do { } while(0)
362
#define grab_swap_token()  do { } while(0)
363
#define has_swap_token(x) 0
364
#define disable_swap_token() do { } while(0)
365
 
366
#endif /* CONFIG_SWAP */
367
#endif /* __KERNEL__*/
368
#endif /* _LINUX_SWAP_H */

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.