Branch data Line data Source code
1 : : #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/memcontrol.h>
9 : : #include <linux/sched.h>
10 : : #include <linux/node.h>
11 : : #include <linux/fs.h>
12 : : #include <linux/atomic.h>
13 : : #include <linux/page-flags.h>
14 : : #include <asm/page.h>
15 : :
16 : : struct notifier_block;
17 : :
18 : : struct bio;
19 : :
20 : : #define SWAP_FLAG_PREFER 0x8000 /* set if swap priority specified */
21 : : #define SWAP_FLAG_PRIO_MASK 0x7fff
22 : : #define SWAP_FLAG_PRIO_SHIFT 0
23 : : #define SWAP_FLAG_DISCARD 0x10000 /* enable discard for swap */
24 : : #define SWAP_FLAG_DISCARD_ONCE 0x20000 /* discard swap area at swapon-time */
25 : : #define SWAP_FLAG_DISCARD_PAGES 0x40000 /* discard page-clusters after use */
26 : :
27 : : #define SWAP_FLAGS_VALID (SWAP_FLAG_PRIO_MASK | SWAP_FLAG_PREFER | \
28 : : SWAP_FLAG_DISCARD | SWAP_FLAG_DISCARD_ONCE | \
29 : : SWAP_FLAG_DISCARD_PAGES)
30 : :
31 : : static inline int current_is_kswapd(void)
32 : : {
33 : 1252249 : return current->flags & PF_KSWAPD;
34 : : }
35 : :
36 : : /*
37 : : * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
38 : : * be swapped to. The swap type and the offset into that swap type are
39 : : * encoded into pte's and into pgoff_t's in the swapcache. Using five bits
40 : : * for the type means that the maximum number of swapcache pages is 27 bits
41 : : * on 32-bit-pgoff_t architectures. And that assumes that the architecture packs
42 : : * the type/offset into the pte as 5/27 as well.
43 : : */
44 : : #define MAX_SWAPFILES_SHIFT 5
45 : :
46 : : /*
47 : : * Use some of the swap files numbers for other purposes. This
48 : : * is a convenient way to hook into the VM to trigger special
49 : : * actions on faults.
50 : : */
51 : :
52 : : /*
53 : : * NUMA node memory migration support
54 : : */
55 : : #ifdef CONFIG_MIGRATION
56 : : #define SWP_MIGRATION_NUM 2
57 : : #define SWP_MIGRATION_READ (MAX_SWAPFILES + SWP_HWPOISON_NUM)
58 : : #define SWP_MIGRATION_WRITE (MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
59 : : #else
60 : : #define SWP_MIGRATION_NUM 0
61 : : #endif
62 : :
63 : : /*
64 : : * Handling of hardware poisoned pages with memory corruption.
65 : : */
66 : : #ifdef CONFIG_MEMORY_FAILURE
67 : : #define SWP_HWPOISON_NUM 1
68 : : #define SWP_HWPOISON MAX_SWAPFILES
69 : : #else
70 : : #define SWP_HWPOISON_NUM 0
71 : : #endif
72 : :
73 : : #define MAX_SWAPFILES \
74 : : ((1 << MAX_SWAPFILES_SHIFT) - SWP_MIGRATION_NUM - SWP_HWPOISON_NUM)
75 : :
76 : : /*
77 : : * Magic header for a swap area. The first part of the union is
78 : : * what the swap magic looks like for the old (limited to 128MB)
79 : : * swap area format, the second part of the union adds - in the
80 : : * old reserved area - some extra information. Note that the first
81 : : * kilobyte is reserved for boot loader or disk label stuff...
82 : : *
83 : : * Having the magic at the end of the PAGE_SIZE makes detecting swap
84 : : * areas somewhat tricky on machines that support multiple page sizes.
85 : : * For 2.5 we'll probably want to move the magic to just beyond the
86 : : * bootbits...
87 : : */
88 : : union swap_header {
89 : : struct {
90 : : char reserved[PAGE_SIZE - 10];
91 : : char magic[10]; /* SWAP-SPACE or SWAPSPACE2 */
92 : : } magic;
93 : : struct {
94 : : char bootbits[1024]; /* Space for disklabel etc. */
95 : : __u32 version;
96 : : __u32 last_page;
97 : : __u32 nr_badpages;
98 : : unsigned char sws_uuid[16];
99 : : unsigned char sws_volume[16];
100 : : __u32 padding[117];
101 : : __u32 badpages[1];
102 : : } info;
103 : : };
104 : :
105 : : /* A swap entry has to fit into a "unsigned long", as
106 : : * the entry is hidden in the "index" field of the
107 : : * swapper address space.
108 : : */
109 : : typedef struct {
110 : : unsigned long val;
111 : : } swp_entry_t;
112 : :
113 : : /*
114 : : * current->reclaim_state points to one of these when a task is running
115 : : * memory reclaim
116 : : */
117 : : struct reclaim_state {
118 : : unsigned long reclaimed_slab;
119 : : };
120 : :
121 : : #ifdef __KERNEL__
122 : :
123 : : struct address_space;
124 : : struct sysinfo;
125 : : struct writeback_control;
126 : : struct zone;
127 : :
128 : : /*
129 : : * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
130 : : * disk blocks. A list of swap extents maps the entire swapfile. (Where the
131 : : * term `swapfile' refers to either a blockdevice or an IS_REG file. Apart
132 : : * from setup, they're handled identically.
133 : : *
134 : : * We always assume that blocks are of size PAGE_SIZE.
135 : : */
136 : : struct swap_extent {
137 : : struct list_head list;
138 : : pgoff_t start_page;
139 : : pgoff_t nr_pages;
140 : : sector_t start_block;
141 : : };
142 : :
143 : : /*
144 : : * Max bad pages in the new format..
145 : : */
146 : : #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
147 : : #define MAX_SWAP_BADPAGES \
148 : : ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
149 : :
150 : : enum {
151 : : SWP_USED = (1 << 0), /* is slot in swap_info[] used? */
152 : : SWP_WRITEOK = (1 << 1), /* ok to write to this swap? */
153 : : SWP_DISCARDABLE = (1 << 2), /* blkdev support discard */
154 : : SWP_DISCARDING = (1 << 3), /* now discarding a free cluster */
155 : : SWP_SOLIDSTATE = (1 << 4), /* blkdev seeks are cheap */
156 : : SWP_CONTINUED = (1 << 5), /* swap_map has count continuation */
157 : : SWP_BLKDEV = (1 << 6), /* its a block device */
158 : : SWP_FILE = (1 << 7), /* set after swap_activate success */
159 : : SWP_AREA_DISCARD = (1 << 8), /* single-time swap area discards */
160 : : SWP_PAGE_DISCARD = (1 << 9), /* freed swap page-cluster discards */
161 : : /* add others here before... */
162 : : SWP_SCANNING = (1 << 10), /* refcount in scan_swap_map */
163 : : };
164 : :
165 : : #define SWAP_CLUSTER_MAX 32UL
166 : : #define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
167 : :
168 : : /*
169 : : * Ratio between the present memory in the zone and the "gap" that
170 : : * we're allowing kswapd to shrink in addition to the per-zone high
171 : : * wmark, even for zones that already have the high wmark satisfied,
172 : : * in order to provide better per-zone lru behavior. We are ok to
173 : : * spend not more than 1% of the memory for this zone balancing "gap".
174 : : */
175 : : #define KSWAPD_ZONE_BALANCE_GAP_RATIO 100
176 : :
177 : : #define SWAP_MAP_MAX 0x3e /* Max duplication count, in first swap_map */
178 : : #define SWAP_MAP_BAD 0x3f /* Note pageblock is bad, in first swap_map */
179 : : #define SWAP_HAS_CACHE 0x40 /* Flag page is cached, in first swap_map */
180 : : #define SWAP_CONT_MAX 0x7f /* Max count, in each swap_map continuation */
181 : : #define COUNT_CONTINUED 0x80 /* See swap_map continuation for full count */
182 : : #define SWAP_MAP_SHMEM 0xbf /* Owned by shmem/tmpfs, in first swap_map */
183 : :
184 : : /*
185 : : * We use this to track usage of a cluster. A cluster is a block of swap disk
186 : : * space with SWAPFILE_CLUSTER pages long and naturally aligns in disk. All
187 : : * free clusters are organized into a list. We fetch an entry from the list to
188 : : * get a free cluster.
189 : : *
190 : : * The data field stores next cluster if the cluster is free or cluster usage
191 : : * counter otherwise. The flags field determines if a cluster is free. This is
192 : : * protected by swap_info_struct.lock.
193 : : */
194 : : struct swap_cluster_info {
195 : : unsigned int data:24;
196 : : unsigned int flags:8;
197 : : };
198 : : #define CLUSTER_FLAG_FREE 1 /* This cluster is free */
199 : : #define CLUSTER_FLAG_NEXT_NULL 2 /* This cluster has no next cluster */
200 : :
201 : : /*
202 : : * We assign a cluster to each CPU, so each CPU can allocate swap entry from
203 : : * its own cluster and swapout sequentially. The purpose is to optimize swapout
204 : : * throughput.
205 : : */
206 : : struct percpu_cluster {
207 : : struct swap_cluster_info index; /* Current cluster index */
208 : : unsigned int next; /* Likely next allocation offset */
209 : : };
210 : :
211 : : /*
212 : : * The in-memory structure used to track swap areas.
213 : : */
214 : : struct swap_info_struct {
215 : : unsigned long flags; /* SWP_USED etc: see above */
216 : : signed short prio; /* swap priority of this type */
217 : : signed char type; /* strange name for an index */
218 : : signed char next; /* next type on the swap list */
219 : : unsigned int max; /* extent of the swap_map */
220 : : unsigned char *swap_map; /* vmalloc'ed array of usage counts */
221 : : struct swap_cluster_info *cluster_info; /* cluster info. Only for SSD */
222 : : struct swap_cluster_info free_cluster_head; /* free cluster list head */
223 : : struct swap_cluster_info free_cluster_tail; /* free cluster list tail */
224 : : unsigned int lowest_bit; /* index of first free in swap_map */
225 : : unsigned int highest_bit; /* index of last free in swap_map */
226 : : unsigned int pages; /* total of usable pages of swap */
227 : : unsigned int inuse_pages; /* number of those currently in use */
228 : : unsigned int cluster_next; /* likely index for next allocation */
229 : : unsigned int cluster_nr; /* countdown to next cluster search */
230 : : struct percpu_cluster __percpu *percpu_cluster; /* per cpu's swap location */
231 : : struct swap_extent *curr_swap_extent;
232 : : struct swap_extent first_swap_extent;
233 : : struct block_device *bdev; /* swap device or bdev of swap file */
234 : : struct file *swap_file; /* seldom referenced */
235 : : unsigned int old_block_size; /* seldom referenced */
236 : : #ifdef CONFIG_FRONTSWAP
237 : : unsigned long *frontswap_map; /* frontswap in-use, one bit per page */
238 : : atomic_t frontswap_pages; /* frontswap pages in-use counter */
239 : : #endif
240 : : spinlock_t lock; /*
241 : : * protect map scan related fields like
242 : : * swap_map, lowest_bit, highest_bit,
243 : : * inuse_pages, cluster_next,
244 : : * cluster_nr, lowest_alloc,
245 : : * highest_alloc, free/discard cluster
246 : : * list. other fields are only changed
247 : : * at swapon/swapoff, so are protected
248 : : * by swap_lock. changing flags need
249 : : * hold this lock and swap_lock. If
250 : : * both locks need hold, hold swap_lock
251 : : * first.
252 : : */
253 : : struct work_struct discard_work; /* discard worker */
254 : : struct swap_cluster_info discard_cluster_head; /* list head of discard clusters */
255 : : struct swap_cluster_info discard_cluster_tail; /* list tail of discard clusters */
256 : : };
257 : :
258 : : struct swap_list_t {
259 : : int head; /* head of priority-ordered swapfile list */
260 : : int next; /* swapfile to be used next */
261 : : };
262 : :
263 : : /* linux/mm/page_alloc.c */
264 : : extern unsigned long totalram_pages;
265 : : extern unsigned long totalreserve_pages;
266 : : extern unsigned long dirty_balance_reserve;
267 : : extern unsigned long nr_free_buffer_pages(void);
268 : : extern unsigned long nr_free_pagecache_pages(void);
269 : :
270 : : /* Definition of global_page_state not available yet */
271 : : #define nr_free_pages() global_page_state(NR_FREE_PAGES)
272 : :
273 : :
274 : : /* linux/mm/swap.c */
275 : : extern void __lru_cache_add(struct page *);
276 : : extern void lru_cache_add(struct page *);
277 : : extern void lru_add_page_tail(struct page *page, struct page *page_tail,
278 : : struct lruvec *lruvec, struct list_head *head);
279 : : extern void activate_page(struct page *);
280 : : extern void mark_page_accessed(struct page *);
281 : : extern void lru_add_drain(void);
282 : : extern void lru_add_drain_cpu(int cpu);
283 : : extern void lru_add_drain_all(void);
284 : : extern void rotate_reclaimable_page(struct page *page);
285 : : extern void deactivate_page(struct page *page);
286 : : extern void swap_setup(void);
287 : :
288 : : extern void add_page_to_unevictable_list(struct page *page);
289 : :
290 : : /**
291 : : * lru_cache_add: add a page to the page lists
292 : : * @page: the page to add
293 : : */
294 : : static inline void lru_cache_add_anon(struct page *page)
295 : : {
296 : : ClearPageActive(page);
297 : 11323 : __lru_cache_add(page);
298 : : }
299 : :
300 : : static inline void lru_cache_add_file(struct page *page)
301 : : {
302 : : ClearPageActive(page);
303 : 2176646 : __lru_cache_add(page);
304 : : }
305 : :
306 : : /* linux/mm/vmscan.c */
307 : : extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
308 : : gfp_t gfp_mask, nodemask_t *mask);
309 : : extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
310 : : extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
311 : : gfp_t gfp_mask, bool noswap);
312 : : extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
313 : : gfp_t gfp_mask, bool noswap,
314 : : struct zone *zone,
315 : : unsigned long *nr_scanned);
316 : : extern unsigned long shrink_all_memory(unsigned long nr_pages);
317 : : extern int vm_swappiness;
318 : : extern int remove_mapping(struct address_space *mapping, struct page *page);
319 : : extern unsigned long vm_total_pages;
320 : :
321 : : #ifdef CONFIG_NUMA
322 : : extern int zone_reclaim_mode;
323 : : extern int sysctl_min_unmapped_ratio;
324 : : extern int sysctl_min_slab_ratio;
325 : : extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
326 : : #else
327 : : #define zone_reclaim_mode 0
328 : : static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
329 : : {
330 : : return 0;
331 : : }
332 : : #endif
333 : :
334 : : extern int page_evictable(struct page *page);
335 : : extern void check_move_unevictable_pages(struct page **, int nr_pages);
336 : :
337 : : extern unsigned long scan_unevictable_pages;
338 : : extern int scan_unevictable_handler(struct ctl_table *, int,
339 : : void __user *, size_t *, loff_t *);
340 : : #ifdef CONFIG_NUMA
341 : : extern int scan_unevictable_register_node(struct node *node);
342 : : extern void scan_unevictable_unregister_node(struct node *node);
343 : : #else
344 : : static inline int scan_unevictable_register_node(struct node *node)
345 : : {
346 : : return 0;
347 : : }
348 : : static inline void scan_unevictable_unregister_node(struct node *node)
349 : : {
350 : : }
351 : : #endif
352 : :
353 : : extern int kswapd_run(int nid);
354 : : extern void kswapd_stop(int nid);
355 : : #ifdef CONFIG_MEMCG
356 : : extern int mem_cgroup_swappiness(struct mem_cgroup *mem);
357 : : #else
358 : : static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
359 : : {
360 : : return vm_swappiness;
361 : : }
362 : : #endif
363 : : #ifdef CONFIG_MEMCG_SWAP
364 : : extern void mem_cgroup_uncharge_swap(swp_entry_t ent);
365 : : #else
366 : : static inline void mem_cgroup_uncharge_swap(swp_entry_t ent)
367 : : {
368 : : }
369 : : #endif
370 : : #ifdef CONFIG_SWAP
371 : : /* linux/mm/page_io.c */
372 : : extern int swap_readpage(struct page *);
373 : : extern int swap_writepage(struct page *page, struct writeback_control *wbc);
374 : : extern void end_swap_bio_write(struct bio *bio, int err);
375 : : extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
376 : : void (*end_write_func)(struct bio *, int));
377 : : extern int swap_set_page_dirty(struct page *page);
378 : : extern void end_swap_bio_read(struct bio *bio, int err);
379 : :
380 : : int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
381 : : unsigned long nr_pages, sector_t start_block);
382 : : int generic_swapfile_activate(struct swap_info_struct *, struct file *,
383 : : sector_t *);
384 : :
385 : : /* linux/mm/swap_state.c */
386 : : extern struct address_space swapper_spaces[];
387 : : #define swap_address_space(entry) (&swapper_spaces[swp_type(entry)])
388 : : extern unsigned long total_swapcache_pages(void);
389 : : extern void show_swap_cache_info(void);
390 : : extern int add_to_swap(struct page *, struct list_head *list);
391 : : extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
392 : : extern int __add_to_swap_cache(struct page *page, swp_entry_t entry);
393 : : extern void __delete_from_swap_cache(struct page *);
394 : : extern void delete_from_swap_cache(struct page *);
395 : : extern void free_page_and_swap_cache(struct page *);
396 : : extern void free_pages_and_swap_cache(struct page **, int);
397 : : extern struct page *lookup_swap_cache(swp_entry_t);
398 : : extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
399 : : struct vm_area_struct *vma, unsigned long addr);
400 : : extern struct page *swapin_readahead(swp_entry_t, gfp_t,
401 : : struct vm_area_struct *vma, unsigned long addr);
402 : :
403 : : /* linux/mm/swapfile.c */
404 : : extern atomic_long_t nr_swap_pages;
405 : : extern long total_swap_pages;
406 : :
407 : : /* Swap 50% full? Release swapcache more aggressively.. */
408 : : static inline bool vm_swap_full(void)
409 : : {
410 : 0 : return atomic_long_read(&nr_swap_pages) * 2 < total_swap_pages;
411 : : }
412 : :
413 : : static inline long get_nr_swap_pages(void)
414 : : {
415 : : return atomic_long_read(&nr_swap_pages);
416 : : }
417 : :
418 : : extern void si_swapinfo(struct sysinfo *);
419 : : extern swp_entry_t get_swap_page(void);
420 : : extern swp_entry_t get_swap_page_of_type(int);
421 : : extern int add_swap_count_continuation(swp_entry_t, gfp_t);
422 : : extern void swap_shmem_alloc(swp_entry_t);
423 : : extern int swap_duplicate(swp_entry_t);
424 : : extern int swapcache_prepare(swp_entry_t);
425 : : extern void swap_free(swp_entry_t);
426 : : extern void swapcache_free(swp_entry_t, struct page *page);
427 : : extern int free_swap_and_cache(swp_entry_t);
428 : : extern int swap_type_of(dev_t, sector_t, struct block_device **);
429 : : extern unsigned int count_swap_pages(int, int);
430 : : extern sector_t map_swap_page(struct page *, struct block_device **);
431 : : extern sector_t swapdev_block(int, pgoff_t);
432 : : extern int page_swapcount(struct page *);
433 : : extern struct swap_info_struct *page_swap_info(struct page *);
434 : : extern int reuse_swap_page(struct page *);
435 : : extern int try_to_free_swap(struct page *);
436 : : struct backing_dev_info;
437 : :
438 : : #ifdef CONFIG_MEMCG
439 : : extern void
440 : : mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout);
441 : : #else
442 : : static inline void
443 : : mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
444 : : {
445 : : }
446 : : #endif
447 : :
448 : : #else /* CONFIG_SWAP */
449 : :
450 : : #define swap_address_space(entry) (NULL)
451 : : #define get_nr_swap_pages() 0L
452 : : #define total_swap_pages 0L
453 : : #define total_swapcache_pages() 0UL
454 : : #define vm_swap_full() 0
455 : :
456 : : #define si_swapinfo(val) \
457 : : do { (val)->freeswap = (val)->totalswap = 0; } while (0)
458 : : /* only sparc can not include linux/pagemap.h in this file
459 : : * so leave page_cache_release and release_pages undeclared... */
460 : : #define free_page_and_swap_cache(page) \
461 : : page_cache_release(page)
462 : : #define free_pages_and_swap_cache(pages, nr) \
463 : : release_pages((pages), (nr), 0);
464 : :
465 : : static inline void show_swap_cache_info(void)
466 : : {
467 : : }
468 : :
469 : : #define free_swap_and_cache(swp) is_migration_entry(swp)
470 : : #define swapcache_prepare(swp) is_migration_entry(swp)
471 : :
472 : : static inline int add_swap_count_continuation(swp_entry_t swp, gfp_t gfp_mask)
473 : : {
474 : : return 0;
475 : : }
476 : :
477 : : static inline void swap_shmem_alloc(swp_entry_t swp)
478 : : {
479 : : }
480 : :
481 : : static inline int swap_duplicate(swp_entry_t swp)
482 : : {
483 : : return 0;
484 : : }
485 : :
486 : : static inline void swap_free(swp_entry_t swp)
487 : : {
488 : : }
489 : :
490 : : static inline void swapcache_free(swp_entry_t swp, struct page *page)
491 : : {
492 : : }
493 : :
494 : : static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
495 : : struct vm_area_struct *vma, unsigned long addr)
496 : : {
497 : : return NULL;
498 : : }
499 : :
500 : : static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
501 : : {
502 : : return 0;
503 : : }
504 : :
505 : : static inline struct page *lookup_swap_cache(swp_entry_t swp)
506 : : {
507 : : return NULL;
508 : : }
509 : :
510 : : static inline int add_to_swap(struct page *page, struct list_head *list)
511 : : {
512 : : return 0;
513 : : }
514 : :
515 : : static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
516 : : gfp_t gfp_mask)
517 : : {
518 : : return -1;
519 : : }
520 : :
521 : : static inline void __delete_from_swap_cache(struct page *page)
522 : : {
523 : : }
524 : :
525 : : static inline void delete_from_swap_cache(struct page *page)
526 : : {
527 : : }
528 : :
529 : : static inline int page_swapcount(struct page *page)
530 : : {
531 : : return 0;
532 : : }
533 : :
534 : : #define reuse_swap_page(page) (page_mapcount(page) == 1)
535 : :
536 : : static inline int try_to_free_swap(struct page *page)
537 : : {
538 : : return 0;
539 : : }
540 : :
541 : : static inline swp_entry_t get_swap_page(void)
542 : : {
543 : : swp_entry_t entry;
544 : : entry.val = 0;
545 : : return entry;
546 : : }
547 : :
548 : : static inline void
549 : : mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
550 : : {
551 : : }
552 : :
553 : : #endif /* CONFIG_SWAP */
554 : : #endif /* __KERNEL__*/
555 : : #endif /* _LINUX_SWAP_H */
|
