LXR linux-old/include/linux/mm.h

   1#ifndef _LINUX_MM_H
   2#define _LINUX_MM_H
   3
   4#include <linux/sched.h>
   5#include <linux/errno.h>
   6#include <linux/kernel.h>
   7#include <linux/string.h>
   8
   9extern unsigned long high_memory;
  10
  11#include <asm/page.h>
  12
  13#ifdef __KERNEL__
  14
  15#define VERIFY_READ 0
  16#define VERIFY_WRITE 1
  17
  18extern int verify_area(int, const void *, unsigned long);
  19
  20/*
  21 * Linux kernel virtual memory manager primitives.
  22 * The idea being to have a "virtual" mm in the same way
  23 * we have a virtual fs - giving a cleaner interface to the
  24 * mm details, and allowing different kinds of memory mappings
  25 * (from shared memory to executable loading to arbitrary
  26 * mmap() functions).
  27 */
  28
  29/*
  30 * This struct defines a memory VMM memory area. There is one of these
  31 * per VM-area/task.  A VM area is any part of the process virtual memory
  32 * space that has a special rule for the page-fault handlers (ie a shared
  33 * library, the executable area etc).
  34 */
  35struct vm_area_struct {
  36        struct task_struct * vm_task;           /* VM area parameters */
  37        unsigned long vm_start;
  38        unsigned long vm_end;
  39        pgprot_t vm_page_prot;
  40        unsigned short vm_flags;
  41/* AVL tree of VM areas per task, sorted by address */
  42        short vm_avl_height;
  43        struct vm_area_struct * vm_avl_left;
  44        struct vm_area_struct * vm_avl_right;
  45/* linked list of VM areas per task, sorted by address */
  46        struct vm_area_struct * vm_next;
  47/* for areas with inode, the circular list inode->i_mmap */
  48/* for shm areas, the circular list of attaches */
  49/* otherwise unused */
  50        struct vm_area_struct * vm_next_share;
  51        struct vm_area_struct * vm_prev_share;
  52/* more */
  53        struct vm_operations_struct * vm_ops;
  54        unsigned long vm_offset;
  55        struct inode * vm_inode;
  56        unsigned long vm_pte;                   /* shared mem */
  57};
  58
  59/*
  60 * vm_flags..
  61 */
  62#define VM_READ         0x0001  /* currently active flags */
  63#define VM_WRITE        0x0002
  64#define VM_EXEC         0x0004
  65#define VM_SHARED       0x0008
  66
  67#define VM_MAYREAD      0x0010  /* limits for mprotect() etc */
  68#define VM_MAYWRITE     0x0020
  69#define VM_MAYEXEC      0x0040
  70#define VM_MAYSHARE     0x0080
  71
  72#define VM_GROWSDOWN    0x0100  /* general info on the segment */
  73#define VM_GROWSUP      0x0200
  74#define VM_SHM          0x0400
  75#define VM_DENYWRITE    0x0800  /* ETXTBSY on write attempts.. */
  76
  77#define VM_EXECUTABLE   0x1000
  78
  79#define VM_STACK_FLAGS  0x0177
  80
  81/*
  82 * mapping from the currently active vm_flags protection bits (the
  83 * low four bits) to a page protection mask..
  84 */
  85extern pgprot_t protection_map[16];
  86
  87
  88/*
  89 * These are the virtual MM functions - opening of an area, closing and
  90 * unmapping it (needed to keep files on disk up-to-date etc), pointer
  91 * to the functions called when a no-page or a wp-page exception occurs. 
  92 */
  93struct vm_operations_struct {
  94        void (*open)(struct vm_area_struct * area);
  95        void (*close)(struct vm_area_struct * area);
  96        void (*unmap)(struct vm_area_struct *area, unsigned long, size_t);
  97        void (*protect)(struct vm_area_struct *area, unsigned long, size_t, unsigned int newprot);
  98        void (*sync)(struct vm_area_struct *area, unsigned long, size_t, unsigned int flags);
  99        void (*advise)(struct vm_area_struct *area, unsigned long, size_t, unsigned int advise);
 100        unsigned long (*nopage)(struct vm_area_struct * area, unsigned long address,
 101                unsigned long page, int write_access);
 102        unsigned long (*wppage)(struct vm_area_struct * area, unsigned long address,
 103                unsigned long page);
 104        void (*swapout)(struct vm_area_struct *,  unsigned long, pte_t *);
 105        pte_t (*swapin)(struct vm_area_struct *, unsigned long, unsigned long);
 106};
 107
 108extern mem_map_t * mem_map;
 109
 110/* planning stage.. */
 111#define P_DIRTY         0x0001
 112#define P_LOCKED        0x0002
 113#define P_UPTODATE      0x0004
 114#define P_RESERVED      0x8000
 115
 116struct page_info {
 117        unsigned short flags;
 118        unsigned short count;
 119        struct inode * inode;
 120        unsigned long offset;
 121        struct page_info * next_same_inode;
 122        struct page_info * prev_same_inode;
 123        struct page_info * next_hash;
 124        struct page_info * prev_hash;
 125        struct wait_queue *wait;
 126};
 127/* end of planning stage */
 128
 129/*
 130 * Free area management
 131 */
 132
 133extern int nr_swap_pages;
 134extern int nr_free_pages;
 135extern int min_free_pages;
 136
 137#define NR_MEM_LISTS 6
 138
 139struct mem_list {
 140        struct mem_list * next;
 141        struct mem_list * prev;
 142};
 143
 144extern struct mem_list free_area_list[NR_MEM_LISTS];
 145extern unsigned char * free_area_map[NR_MEM_LISTS];
 146
 147/*
 148 * This is timing-critical - most of the time in getting a new page
 149 * goes to clearing the page. If you want a page without the clearing
 150 * overhead, just use __get_free_page() directly..
 151 */
 152#define __get_free_page(priority) __get_free_pages((priority),0)
 153extern unsigned long __get_free_pages(int priority, unsigned long gfporder);
 154extern unsigned long __get_dma_pages(int priority, unsigned long gfporder);
 155extern inline unsigned long get_free_page(int priority)
 156{
 157        unsigned long page;
 158
 159        page = __get_free_page(priority);
 160        if (page)
 161                memset((void *) page, 0, PAGE_SIZE);
 162        return page;
 163}
 164
 165/* memory.c & swap.c*/
 166
 167#define free_page(addr) free_pages((addr),0)
 168extern void free_pages(unsigned long addr, unsigned long order);
 169
 170extern void show_free_areas(void);
 171extern unsigned long put_dirty_page(struct task_struct * tsk,unsigned long page,
 172        unsigned long address);
 173
 174extern void free_page_tables(struct task_struct * tsk);
 175extern void clear_page_tables(struct task_struct * tsk);
 176extern int copy_page_tables(struct task_struct * to);
 177extern int clone_page_tables(struct task_struct * to);
 178extern int unmap_page_range(unsigned long from, unsigned long size);
 179extern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot);
 180extern int zeromap_page_range(unsigned long from, unsigned long size, pgprot_t prot);
 181
 182extern void handle_mm_fault(struct vm_area_struct *vma, unsigned long address, int write_access);
 183extern void do_wp_page(struct vm_area_struct * vma, unsigned long address, int write_access);
 184extern void do_no_page(struct vm_area_struct * vma, unsigned long address, int write_access);
 185
 186extern unsigned long paging_init(unsigned long start_mem, unsigned long end_mem);
 187extern void mem_init(unsigned long start_mem, unsigned long end_mem);
 188extern void show_mem(void);
 189extern void oom(struct task_struct * tsk);
 190extern void si_meminfo(struct sysinfo * val);
 191
 192/* vmalloc.c */
 193
 194extern void * vmalloc(unsigned long size);
 195extern void vfree(void * addr);
 196extern int vread(char *buf, char *addr, int count);
 197
 198/* swap.c */
 199
 200extern void swap_free(unsigned long);
 201extern void swap_duplicate(unsigned long);
 202extern void swap_in(struct vm_area_struct *, pte_t *, unsigned long id, int write_access);
 203
 204extern void si_swapinfo(struct sysinfo * val);
 205extern void rw_swap_page(int rw, unsigned long nr, char * buf);
 206
 207/* mmap.c */
 208extern unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
 209        unsigned long prot, unsigned long flags, unsigned long off);
 210extern struct vm_area_struct * find_vma (struct task_struct *, unsigned long);
 211extern struct vm_area_struct * find_vma_intersection (struct task_struct *, unsigned long, unsigned long);
 212extern void merge_segments(struct task_struct *, unsigned long, unsigned long);
 213extern void insert_vm_struct(struct task_struct *, struct vm_area_struct *);
 214extern void remove_shared_vm_struct(struct vm_area_struct *);
 215extern void build_mmap_avl(struct task_struct *);
 216extern void exit_mmap(struct task_struct *);
 217extern int do_munmap(unsigned long, size_t);
 218extern unsigned long get_unmapped_area(unsigned long);
 219
 220#define read_swap_page(nr,buf) \
 221        rw_swap_page(READ,(nr),(buf))
 222#define write_swap_page(nr,buf) \
 223        rw_swap_page(WRITE,(nr),(buf))
 224
 225#define GFP_BUFFER      0x00
 226#define GFP_ATOMIC      0x01
 227#define GFP_USER        0x02
 228#define GFP_KERNEL      0x03
 229#define GFP_NOBUFFER    0x04
 230#define GFP_NFS         0x05
 231
 232/* Flag - indicates that the buffer will be suitable for DMA.  Ignored on some
 233   platforms, used as appropriate on others */
 234
 235#define GFP_DMA         0x80
 236
 237/*
 238 * vm_ops not present page codes for shared memory.
 239 *
 240 * Will go away eventually..
 241 */
 242#define SHM_SWP_TYPE 0x41
 243extern void shm_no_page (ulong *);
 244
 245/*
 246 * swap cache stuff (in swap.c)
 247 */
 248#define SWAP_CACHE_INFO
 249
 250extern unsigned long * swap_cache;
 251
 252#ifdef SWAP_CACHE_INFO
 253extern unsigned long swap_cache_add_total;
 254extern unsigned long swap_cache_add_success;
 255extern unsigned long swap_cache_del_total;
 256extern unsigned long swap_cache_del_success;
 257extern unsigned long swap_cache_find_total;
 258extern unsigned long swap_cache_find_success;
 259#endif
 260
 261extern inline unsigned long in_swap_cache(unsigned long addr)
 262{
 263        return swap_cache[MAP_NR(addr)]; 
 264}
 265
 266extern inline long find_in_swap_cache (unsigned long addr)
 267{
 268        unsigned long entry;
 269
 270#ifdef SWAP_CACHE_INFO
 271        swap_cache_find_total++;
 272#endif
 273        entry = (unsigned long) xchg_ptr(swap_cache + MAP_NR(addr), NULL);
 274#ifdef SWAP_CACHE_INFO
 275        if (entry)
 276                swap_cache_find_success++;
 277#endif  
 278        return entry;
 279}
 280
 281extern inline int delete_from_swap_cache(unsigned long addr)
 282{
 283        unsigned long entry;
 284        
 285#ifdef SWAP_CACHE_INFO
 286        swap_cache_del_total++;
 287#endif  
 288        entry= (unsigned long) xchg_ptr(swap_cache + MAP_NR(addr), NULL);
 289        if (entry)  {
 290#ifdef SWAP_CACHE_INFO
 291                swap_cache_del_success++;
 292#endif
 293                swap_free(entry);
 294                return 1;
 295        }
 296        return 0;
 297}
 298
 299#endif /* __KERNEL__ */
 300
 301#endif
 302