bf7867200b95b488fd960c95f7200af5837286bb
[linux-3.10.git] / include / linux / mm_types.h
1 #ifndef _LINUX_MM_TYPES_H
2 #define _LINUX_MM_TYPES_H
3
4 #include <linux/auxvec.h>
5 #include <linux/types.h>
6 #include <linux/threads.h>
7 #include <linux/list.h>
8 #include <linux/spinlock.h>
9 #include <linux/prio_tree.h>
10 #include <linux/rbtree.h>
11 #include <linux/rwsem.h>
12 #include <linux/completion.h>
13 #include <linux/cpumask.h>
14 #include <linux/page-debug-flags.h>
15 #include <linux/uprobes.h>
16 #include <asm/page.h>
17 #include <asm/mmu.h>
18
19 #ifndef AT_VECTOR_SIZE_ARCH
20 #define AT_VECTOR_SIZE_ARCH 0
21 #endif
22 #define AT_VECTOR_SIZE (2*(AT_VECTOR_SIZE_ARCH + AT_VECTOR_SIZE_BASE + 1))
23
24 struct address_space;
25
26 #define USE_SPLIT_PTLOCKS       (NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS)
27
28 /*
29  * Each physical page in the system has a struct page associated with
30  * it to keep track of whatever it is we are using the page for at the
31  * moment. Note that we have no way to track which tasks are using
32  * a page, though if it is a pagecache page, rmap structures can tell us
33  * who is mapping it.
34  *
35  * The objects in struct page are organized in double word blocks in
36  * order to allows us to use atomic double word operations on portions
37  * of struct page. That is currently only used by slub but the arrangement
38  * allows the use of atomic double word operations on the flags/mapping
39  * and lru list pointers also.
40  */
41 struct page {
42         /* First double word block */
43         unsigned long flags;            /* Atomic flags, some possibly
44                                          * updated asynchronously */
45         struct address_space *mapping;  /* If low bit clear, points to
46                                          * inode address_space, or NULL.
47                                          * If page mapped as anonymous
48                                          * memory, low bit is set, and
49                                          * it points to anon_vma object:
50                                          * see PAGE_MAPPING_ANON below.
51                                          */
52         /* Second double word */
53         struct {
54                 union {
55                         pgoff_t index;          /* Our offset within mapping. */
56                         void *freelist;         /* slub/slob first free object */
57                         bool pfmemalloc;        /* If set by the page allocator,
58                                                  * ALLOC_NO_WATERMARKS was set
59                                                  * and the low watermark was not
60                                                  * met implying that the system
61                                                  * is under some pressure. The
62                                                  * caller should try ensure
63                                                  * this page is only used to
64                                                  * free other pages.
65                                                  */
66                 };
67
68                 union {
69 #if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
70         defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
71                         /* Used for cmpxchg_double in slub */
72                         unsigned long counters;
73 #else
74                         /*
75                          * Keep _count separate from slub cmpxchg_double data.
76                          * As the rest of the double word is protected by
77                          * slab_lock but _count is not.
78                          */
79                         unsigned counters;
80 #endif
81
82                         struct {
83
84                                 union {
85                                         /*
86                                          * Count of ptes mapped in
87                                          * mms, to show when page is
88                                          * mapped & limit reverse map
89                                          * searches.
90                                          *
91                                          * Used also for tail pages
92                                          * refcounting instead of
93                                          * _count. Tail pages cannot
94                                          * be mapped and keeping the
95                                          * tail page _count zero at
96                                          * all times guarantees
97                                          * get_page_unless_zero() will
98                                          * never succeed on tail
99                                          * pages.
100                                          */
101                                         atomic_t _mapcount;
102
103                                         struct { /* SLUB */
104                                                 unsigned inuse:16;
105                                                 unsigned objects:15;
106                                                 unsigned frozen:1;
107                                         };
108                                         int units;      /* SLOB */
109                                 };
110                                 atomic_t _count;                /* Usage count, see below. */
111                         };
112                 };
113         };
114
115         /* Third double word block */
116         union {
117                 struct list_head lru;   /* Pageout list, eg. active_list
118                                          * protected by zone->lru_lock !
119                                          */
120                 struct {                /* slub per cpu partial pages */
121                         struct page *next;      /* Next partial slab */
122 #ifdef CONFIG_64BIT
123                         int pages;      /* Nr of partial slabs left */
124                         int pobjects;   /* Approximate # of objects */
125 #else
126                         short int pages;
127                         short int pobjects;
128 #endif
129                 };
130
131                 struct list_head list;  /* slobs list of pages */
132                 struct {                /* slab fields */
133                         struct kmem_cache *slab_cache;
134                         struct slab *slab_page;
135                 };
136         };
137
138         /* Remainder is not double word aligned */
139         union {
140                 unsigned long private;          /* Mapping-private opaque data:
141                                                  * usually used for buffer_heads
142                                                  * if PagePrivate set; used for
143                                                  * swp_entry_t if PageSwapCache;
144                                                  * indicates order in the buddy
145                                                  * system if PG_buddy is set.
146                                                  */
147 #if USE_SPLIT_PTLOCKS
148                 spinlock_t ptl;
149 #endif
150                 struct kmem_cache *slab;        /* SLUB: Pointer to slab */
151                 struct page *first_page;        /* Compound tail pages */
152         };
153
154         /*
155          * On machines where all RAM is mapped into kernel address space,
156          * we can simply calculate the virtual address. On machines with
157          * highmem some memory is mapped into kernel virtual memory
158          * dynamically, so we need a place to store that address.
159          * Note that this field could be 16 bits on x86 ... ;)
160          *
161          * Architectures with slow multiplication can define
162          * WANT_PAGE_VIRTUAL in asm/page.h
163          */
164 #if defined(WANT_PAGE_VIRTUAL)
165         void *virtual;                  /* Kernel virtual address (NULL if
166                                            not kmapped, ie. highmem) */
167 #endif /* WANT_PAGE_VIRTUAL */
168 #ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
169         unsigned long debug_flags;      /* Use atomic bitops on this */
170 #endif
171
172 #ifdef CONFIG_KMEMCHECK
173         /*
174          * kmemcheck wants to track the status of each byte in a page; this
175          * is a pointer to such a status block. NULL if not tracked.
176          */
177         void *shadow;
178 #endif
179 }
180 /*
181  * The struct page can be forced to be double word aligned so that atomic ops
182  * on double words work. The SLUB allocator can make use of such a feature.
183  */
184 #ifdef CONFIG_HAVE_ALIGNED_STRUCT_PAGE
185         __aligned(2 * sizeof(unsigned long))
186 #endif
187 ;
188
189 struct page_frag {
190         struct page *page;
191 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
192         __u32 offset;
193         __u32 size;
194 #else
195         __u16 offset;
196         __u16 size;
197 #endif
198 };
199
200 typedef unsigned long __nocast vm_flags_t;
201
202 /*
203  * A region containing a mapping of a non-memory backed file under NOMMU
204  * conditions.  These are held in a global tree and are pinned by the VMAs that
205  * map parts of them.
206  */
207 struct vm_region {
208         struct rb_node  vm_rb;          /* link in global region tree */
209         vm_flags_t      vm_flags;       /* VMA vm_flags */
210         unsigned long   vm_start;       /* start address of region */
211         unsigned long   vm_end;         /* region initialised to here */
212         unsigned long   vm_top;         /* region allocated to here */
213         unsigned long   vm_pgoff;       /* the offset in vm_file corresponding to vm_start */
214         struct file     *vm_file;       /* the backing file or NULL */
215
216         int             vm_usage;       /* region usage count (access under nommu_region_sem) */
217         bool            vm_icache_flushed : 1; /* true if the icache has been flushed for
218                                                 * this region */
219 };
220
221 /*
222  * This struct defines a memory VMM memory area. There is one of these
223  * per VM-area/task.  A VM area is any part of the process virtual memory
224  * space that has a special rule for the page-fault handlers (ie a shared
225  * library, the executable area etc).
226  */
227 struct vm_area_struct {
228         struct mm_struct * vm_mm;       /* The address space we belong to. */
229         unsigned long vm_start;         /* Our start address within vm_mm. */
230         unsigned long vm_end;           /* The first byte after our end address
231                                            within vm_mm. */
232
233         /* linked list of VM areas per task, sorted by address */
234         struct vm_area_struct *vm_next, *vm_prev;
235
236         pgprot_t vm_page_prot;          /* Access permissions of this VMA. */
237         unsigned long vm_flags;         /* Flags, see mm.h. */
238
239         struct rb_node vm_rb;
240
241         /*
242          * For areas with an address space and backing store,
243          * linkage into the address_space->i_mmap prio tree, or
244          * linkage to the list of like vmas hanging off its node, or
245          * linkage of vma in the address_space->i_mmap_nonlinear list.
246          */
247         union {
248                 struct {
249                         struct list_head list;
250                         void *parent;   /* aligns with prio_tree_node parent */
251                         struct vm_area_struct *head;
252                 } vm_set;
253
254                 struct raw_prio_tree_node prio_tree_node;
255         } shared;
256
257         /*
258          * A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
259          * list, after a COW of one of the file pages.  A MAP_SHARED vma
260          * can only be in the i_mmap tree.  An anonymous MAP_PRIVATE, stack
261          * or brk vma (with NULL file) can only be in an anon_vma list.
262          */
263         struct list_head anon_vma_chain; /* Serialized by mmap_sem &
264                                           * page_table_lock */
265         struct anon_vma *anon_vma;      /* Serialized by page_table_lock */
266
267         /* Function pointers to deal with this struct. */
268         const struct vm_operations_struct *vm_ops;
269
270         /* Information about our backing store: */
271         unsigned long vm_pgoff;         /* Offset (within vm_file) in PAGE_SIZE
272                                            units, *not* PAGE_CACHE_SIZE */
273         struct file * vm_file;          /* File we map to (can be NULL). */
274         void * vm_private_data;         /* was vm_pte (shared mem) */
275
276 #ifndef CONFIG_MMU
277         struct vm_region *vm_region;    /* NOMMU mapping region */
278 #endif
279 #ifdef CONFIG_NUMA
280         struct mempolicy *vm_policy;    /* NUMA policy for the VMA */
281 #endif
282 };
283
284 struct core_thread {
285         struct task_struct *task;
286         struct core_thread *next;
287 };
288
289 struct core_state {
290         atomic_t nr_threads;
291         struct core_thread dumper;
292         struct completion startup;
293 };
294
295 enum {
296         MM_FILEPAGES,
297         MM_ANONPAGES,
298         MM_SWAPENTS,
299         NR_MM_COUNTERS
300 };
301
302 #if USE_SPLIT_PTLOCKS && defined(CONFIG_MMU)
303 #define SPLIT_RSS_COUNTING
304 /* per-thread cached information, */
305 struct task_rss_stat {
306         int events;     /* for synchronization threshold */
307         int count[NR_MM_COUNTERS];
308 };
309 #endif /* USE_SPLIT_PTLOCKS */
310
311 struct mm_rss_stat {
312         atomic_long_t count[NR_MM_COUNTERS];
313 };
314
315 struct mm_struct {
316         struct vm_area_struct * mmap;           /* list of VMAs */
317         struct rb_root mm_rb;
318         struct vm_area_struct * mmap_cache;     /* last find_vma result */
319 #ifdef CONFIG_MMU
320         unsigned long (*get_unmapped_area) (struct file *filp,
321                                 unsigned long addr, unsigned long len,
322                                 unsigned long pgoff, unsigned long flags);
323         void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
324 #endif
325         unsigned long mmap_base;                /* base of mmap area */
326         unsigned long task_size;                /* size of task vm space */
327         unsigned long cached_hole_size;         /* if non-zero, the largest hole below free_area_cache */
328         unsigned long free_area_cache;          /* first hole of size cached_hole_size or larger */
329         pgd_t * pgd;
330         atomic_t mm_users;                      /* How many users with user space? */
331         atomic_t mm_count;                      /* How many references to "struct mm_struct" (users count as 1) */
332         int map_count;                          /* number of VMAs */
333
334         spinlock_t page_table_lock;             /* Protects page tables and some counters */
335         struct rw_semaphore mmap_sem;
336
337         struct list_head mmlist;                /* List of maybe swapped mm's.  These are globally strung
338                                                  * together off init_mm.mmlist, and are protected
339                                                  * by mmlist_lock
340                                                  */
341
342
343         unsigned long hiwater_rss;      /* High-watermark of RSS usage */
344         unsigned long hiwater_vm;       /* High-water virtual memory usage */
345
346         unsigned long total_vm;         /* Total pages mapped */
347         unsigned long locked_vm;        /* Pages that have PG_mlocked set */
348         unsigned long pinned_vm;        /* Refcount permanently increased */
349         unsigned long shared_vm;        /* Shared pages (files) */
350         unsigned long exec_vm;          /* VM_EXEC & ~VM_WRITE */
351         unsigned long stack_vm;         /* VM_GROWSUP/DOWN */
352         unsigned long reserved_vm;      /* VM_RESERVED|VM_IO pages */
353         unsigned long def_flags;
354         unsigned long nr_ptes;          /* Page table pages */
355         unsigned long start_code, end_code, start_data, end_data;
356         unsigned long start_brk, brk, start_stack;
357         unsigned long arg_start, arg_end, env_start, env_end;
358
359         unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */
360
361         /*
362          * Special counters, in some configurations protected by the
363          * page_table_lock, in other configurations by being atomic.
364          */
365         struct mm_rss_stat rss_stat;
366
367         struct linux_binfmt *binfmt;
368
369         cpumask_var_t cpu_vm_mask_var;
370
371         /* Architecture-specific MM context */
372         mm_context_t context;
373
374         unsigned long flags; /* Must use atomic bitops to access the bits */
375
376         struct core_state *core_state; /* coredumping support */
377 #ifdef CONFIG_AIO
378         spinlock_t              ioctx_lock;
379         struct hlist_head       ioctx_list;
380 #endif
381 #ifdef CONFIG_MM_OWNER
382         /*
383          * "owner" points to a task that is regarded as the canonical
384          * user/owner of this mm. All of the following must be true in
385          * order for it to be changed:
386          *
387          * current == mm->owner
388          * current->mm != mm
389          * new_owner->mm == mm
390          * new_owner->alloc_lock is held
391          */
392         struct task_struct __rcu *owner;
393 #endif
394
395         /* store ref to file /proc/<pid>/exe symlink points to */
396         struct file *exe_file;
397         unsigned long num_exe_file_vmas;
398 #ifdef CONFIG_MMU_NOTIFIER
399         struct mmu_notifier_mm *mmu_notifier_mm;
400 #endif
401 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
402         pgtable_t pmd_huge_pte; /* protected by page_table_lock */
403 #endif
404 #ifdef CONFIG_CPUMASK_OFFSTACK
405         struct cpumask cpumask_allocation;
406 #endif
407         struct uprobes_state uprobes_state;
408 };
409
410 static inline void mm_init_cpumask(struct mm_struct *mm)
411 {
412 #ifdef CONFIG_CPUMASK_OFFSTACK
413         mm->cpu_vm_mask_var = &mm->cpumask_allocation;
414 #endif
415 }
416
417 /* Future-safe accessor for struct mm_struct's cpu_vm_mask. */
418 static inline cpumask_t *mm_cpumask(struct mm_struct *mm)
419 {
420         return mm->cpu_vm_mask_var;
421 }
422
423 #endif /* _LINUX_MM_TYPES_H */