#ifndef _LINUX_SWAP_H #define _LINUX_SWAP_H #include #include #define SWAP_FLAG_PREFER 0x8000 /* set if swap priority specified */ #define SWAP_FLAG_PRIO_MASK 0x7fff #define SWAP_FLAG_PRIO_SHIFT 0 #define MAX_SWAPFILES 8 union swap_header { struct { char reserved[PAGE_SIZE - 10]; char magic[10]; } magic; struct { char bootbits[1024]; /* Space for disklabel etc. */ unsigned int version; unsigned int last_page; unsigned int nr_badpages; unsigned int padding[125]; unsigned int badpages[1]; } info; }; #ifdef __KERNEL__ /* * Max bad pages in the new format.. */ #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x) #define MAX_SWAP_BADPAGES \ ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int)) #include #define SWP_USED 1 #define SWP_WRITEOK 3 #define SWAP_CLUSTER_MAX 32 #define SWAP_MAP_MAX 0x7fff #define SWAP_MAP_BAD 0x8000 struct swap_info_struct { unsigned int flags; kdev_t swap_device; spinlock_t sdev_lock; struct dentry * swap_file; struct vfsmount *swap_vfsmnt; unsigned short * swap_map; unsigned int lowest_bit; unsigned int highest_bit; unsigned int cluster_next; unsigned int cluster_nr; int prio; /* swap priority */ int pages; unsigned long max; int next; /* next entry on swap list */ }; extern int nr_swap_pages; FASTCALL(unsigned int nr_free_pages(void)); FASTCALL(unsigned int nr_inactive_clean_pages(void)); FASTCALL(unsigned int nr_free_buffer_pages(void)); extern int nr_active_pages; extern int nr_inactive_dirty_pages; extern atomic_t nr_async_pages; extern struct address_space swapper_space; extern atomic_t page_cache_size; extern atomic_t buffermem_pages; extern spinlock_t pagecache_lock; extern void __remove_inode_page(struct page *); /* Incomplete types for prototype declarations: */ struct task_struct; struct vm_area_struct; struct sysinfo; struct zone_t; /* linux/ipc/shm.c */ extern int shm_swap(int, int); /* linux/mm/swap.c */ extern int memory_pressure; extern void age_page_up(struct page *); extern void age_page_up_nolock(struct page *); extern void age_page_down(struct page *); extern void age_page_down_nolock(struct page *); extern void age_page_down_ageonly(struct page *); extern void deactivate_page(struct page *); extern void deactivate_page_nolock(struct page *); extern void activate_page(struct page *); extern void activate_page_nolock(struct page *); extern void lru_cache_add(struct page *); extern void __lru_cache_del(struct page *); extern void lru_cache_del(struct page *); extern void recalculate_vm_stats(void); extern void swap_setup(void); /* linux/mm/vmscan.c */ extern struct page * reclaim_page(zone_t *); extern wait_queue_head_t kswapd_wait; extern wait_queue_head_t kreclaimd_wait; extern int page_launder(int, int); extern int free_shortage(void); extern int inactive_shortage(void); extern void wakeup_kswapd(int); extern int try_to_free_pages(unsigned int gfp_mask); /* linux/mm/page_io.c */ extern void rw_swap_page(int, struct page *, int); extern void rw_swap_page_nolock(int, swp_entry_t, char *, int); /* linux/mm/page_alloc.c */ /* linux/mm/swap_state.c */ extern void show_swap_cache_info(void); extern void add_to_swap_cache(struct page *, swp_entry_t); extern int swap_check_entry(unsigned long); extern struct page * lookup_swap_cache(swp_entry_t); extern struct page * read_swap_cache_async(swp_entry_t, int); #define read_swap_cache(entry) read_swap_cache_async(entry, 1); /* linux/mm/oom_kill.c */ extern int out_of_memory(void); extern void oom_kill(void); /* * Make these inline later once they are working properly. */ extern void __delete_from_swap_cache(struct page *page); extern void delete_from_swap_cache(struct page *page); extern void delete_from_swap_cache_nolock(struct page *page); extern void free_page_and_swap_cache(struct page *page); /* linux/mm/swapfile.c */ extern unsigned int nr_swapfiles; extern struct swap_info_struct swap_info[]; extern int is_swap_partition(kdev_t); extern void si_swapinfo(struct sysinfo *); extern swp_entry_t __get_swap_page(unsigned short); extern void get_swaphandle_info(swp_entry_t, unsigned long *, kdev_t *, struct inode **); extern int swap_duplicate(swp_entry_t); extern int swap_count(struct page *); extern int valid_swaphandles(swp_entry_t, unsigned long *); #define get_swap_page() __get_swap_page(1) extern void __swap_free(swp_entry_t, unsigned short); #define swap_free(entry) __swap_free((entry), 1) struct swap_list_t { int head; /* head of priority-ordered swapfile list */ int next; /* swapfile to be used next */ }; extern struct swap_list_t swap_list; asmlinkage long sys_swapoff(const char *); asmlinkage long sys_swapon(const char *, int); #define SWAP_CACHE_INFO #ifdef SWAP_CACHE_INFO extern unsigned long swap_cache_add_total; extern unsigned long swap_cache_del_total; extern unsigned long swap_cache_find_total; extern unsigned long swap_cache_find_success; #endif /* * Work out if there are any other processes sharing this page, ignoring * any page reference coming from the swap cache, or from outstanding * swap IO on this page. (The page cache _does_ count as another valid * reference to the page, however.) */ static inline int is_page_shared(struct page *page) { unsigned int count; if (PageReserved(page)) return 1; count = page_count(page); if (PageSwapCache(page)) count += swap_count(page) - 2 - !!page->buffers; return count > 1; } extern spinlock_t pagemap_lru_lock; /* * Page aging defines. * Since we do exponential decay of the page age, we * can chose a fairly large maximum. */ #define PAGE_AGE_START 2 #define PAGE_AGE_ADV 3 #define PAGE_AGE_MAX 64 /* * List add/del helper macros. These must be called * with the pagemap_lru_lock held! */ #define DEBUG_ADD_PAGE \ if (PageActive(page) || PageInactiveDirty(page) || \ PageInactiveClean(page)) BUG(); #define ZERO_PAGE_BUG \ if (page_count(page) == 0) BUG(); #define add_page_to_active_list(page) { \ DEBUG_ADD_PAGE \ ZERO_PAGE_BUG \ SetPageActive(page); \ list_add(&(page)->lru, &active_list); \ nr_active_pages++; \ } #define add_page_to_inactive_dirty_list(page) { \ DEBUG_ADD_PAGE \ ZERO_PAGE_BUG \ SetPageInactiveDirty(page); \ list_add(&(page)->lru, &inactive_dirty_list); \ nr_inactive_dirty_pages++; \ page->zone->inactive_dirty_pages++; \ } #define add_page_to_inactive_clean_list(page) { \ DEBUG_ADD_PAGE \ ZERO_PAGE_BUG \ SetPageInactiveClean(page); \ list_add(&(page)->lru, &page->zone->inactive_clean_list); \ page->zone->inactive_clean_pages++; \ } #define del_page_from_active_list(page) { \ list_del(&(page)->lru); \ ClearPageActive(page); \ nr_active_pages--; \ DEBUG_ADD_PAGE \ ZERO_PAGE_BUG \ } #define del_page_from_inactive_dirty_list(page) { \ list_del(&(page)->lru); \ ClearPageInactiveDirty(page); \ nr_inactive_dirty_pages--; \ page->zone->inactive_dirty_pages--; \ DEBUG_ADD_PAGE \ ZERO_PAGE_BUG \ } #define del_page_from_inactive_clean_list(page) { \ list_del(&(page)->lru); \ ClearPageInactiveClean(page); \ page->zone->inactive_clean_pages--; \ DEBUG_ADD_PAGE \ ZERO_PAGE_BUG \ } /* * In mm/swap.c::recalculate_vm_stats(), we substract * inactive_target from memory_pressure every second. * This means that memory_pressure is smoothed over * 64 (1 << INACTIVE_SHIFT) seconds. */ #define INACTIVE_SHIFT 6 #define inactive_min(a,b) ((a) < (b) ? (a) : (b)) #define inactive_target inactive_min((memory_pressure >> INACTIVE_SHIFT), \ (num_physpages / 4)) /* * Ugly ugly ugly HACK to make sure the inactive lists * don't fill up with unfreeable ramdisk pages. We really * want to fix the ramdisk driver to mark its pages as * unfreeable instead of using dirty buffer magic, but the * next code-change time is when 2.5 is forked... */ #ifndef _LINUX_KDEV_T_H #include #endif #ifndef _LINUX_MAJOR_H #include #endif #define page_ramdisk(page) \ (page->buffers && (MAJOR(page->buffers->b_dev) == RAMDISK_MAJOR)) extern spinlock_t swaplock; #define swap_list_lock() spin_lock(&swaplock) #define swap_list_unlock() spin_unlock(&swaplock) #define swap_device_lock(p) spin_lock(&p->sdev_lock) #define swap_device_unlock(p) spin_unlock(&p->sdev_lock) #endif /* __KERNEL__*/ #endif /* _LINUX_SWAP_H */