blob: a2b48041b91084865a71c74b3f13342bf02fc6be [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_MM_H
2#define _LINUX_MM_H
3
Linus Torvalds1da177e2005-04-16 15:20:36 -07004#include <linux/errno.h>
5
6#ifdef __KERNEL__
7
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/gfp.h>
9#include <linux/list.h>
10#include <linux/mmzone.h>
11#include <linux/rbtree.h>
12#include <linux/prio_tree.h>
Ingo Molnar9a11b49a2006-07-03 00:24:33 -070013#include <linux/debug_locks.h>
Heiko Carstens5b99cd02006-09-27 01:50:01 -070014#include <linux/mm_types.h>
Yinghai Lu08677212010-02-10 01:20:20 -080015#include <linux/range.h>
Chris Metcalfc6f6b592010-05-24 14:32:53 -070016#include <linux/pfn.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18struct mempolicy;
19struct anon_vma;
Alexey Dobriyan4e950f62007-07-30 02:36:13 +040020struct file_ra_state;
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040021struct user_struct;
Alexey Dobriyan4e950f62007-07-30 02:36:13 +040022struct writeback_control;
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24#ifndef CONFIG_DISCONTIGMEM /* Don't use mapnrs, do it properly */
25extern unsigned long max_mapnr;
26#endif
27
28extern unsigned long num_physpages;
Jan Beulich44813742009-09-21 17:03:05 -070029extern unsigned long totalram_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030extern void * high_memory;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031extern int page_cluster;
32
33#ifdef CONFIG_SYSCTL
34extern int sysctl_legacy_va_layout;
35#else
36#define sysctl_legacy_va_layout 0
37#endif
38
39#include <asm/page.h>
40#include <asm/pgtable.h>
41#include <asm/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n))
44
Andrea Righi27ac7922008-07-23 21:28:13 -070045/* to align the pointer to the (next) page boundary */
46#define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE)
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/*
49 * Linux kernel virtual memory manager primitives.
50 * The idea being to have a "virtual" mm in the same way
51 * we have a virtual fs - giving a cleaner interface to the
52 * mm details, and allowing different kinds of memory mappings
53 * (from shared memory to executable loading to arbitrary
54 * mmap() functions).
55 */
56
Christoph Lameterc43692e2006-12-06 20:32:48 -080057extern struct kmem_cache *vm_area_cachep;
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#ifndef CONFIG_MMU
David Howells8feae132009-01-08 12:04:47 +000060extern struct rb_root nommu_region_tree;
61extern struct rw_semaphore nommu_region_sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63extern unsigned int kobjsize(const void *objp);
64#endif
65
66/*
Hugh Dickins605d9282008-08-16 11:07:21 +010067 * vm_flags in vm_area_struct, see mm_types.h.
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 */
69#define VM_READ 0x00000001 /* currently active flags */
70#define VM_WRITE 0x00000002
71#define VM_EXEC 0x00000004
72#define VM_SHARED 0x00000008
73
Paolo 'Blaisorblade' Giarrusso7e2cff42005-09-21 09:55:39 -070074/* mprotect() hardcodes VM_MAYREAD >> 4 == VM_READ, and so for r/w/x bits. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#define VM_MAYREAD 0x00000010 /* limits for mprotect() etc */
76#define VM_MAYWRITE 0x00000020
77#define VM_MAYEXEC 0x00000040
78#define VM_MAYSHARE 0x00000080
79
80#define VM_GROWSDOWN 0x00000100 /* general info on the segment */
81#define VM_GROWSUP 0x00000200
Linus Torvalds6aab3412005-11-28 14:34:23 -080082#define VM_PFNMAP 0x00000400 /* Page-ranges managed without "struct page", just pure PFN */
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#define VM_DENYWRITE 0x00000800 /* ETXTBSY on write attempts.. */
84
85#define VM_EXECUTABLE 0x00001000
86#define VM_LOCKED 0x00002000
87#define VM_IO 0x00004000 /* Memory mapped I/O or similar */
88
89 /* Used by sys_madvise() */
90#define VM_SEQ_READ 0x00008000 /* App will access data sequentially */
91#define VM_RAND_READ 0x00010000 /* App will not benefit from clustered reads */
92
93#define VM_DONTCOPY 0x00020000 /* Do not copy this vma on fork */
94#define VM_DONTEXPAND 0x00040000 /* Cannot expand with mremap() */
Hugh Dickins0b14c172005-11-21 21:32:15 -080095#define VM_RESERVED 0x00080000 /* Count as reserved_vm like IO */
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#define VM_ACCOUNT 0x00100000 /* Is a VM accounted object */
Andy Whitcroftcdfd4322008-07-23 21:27:28 -070097#define VM_NORESERVE 0x00200000 /* should the VM suppress accounting */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */
99#define VM_NONLINEAR 0x00800000 /* Is non-linear (remap_file_pages) */
100#define VM_MAPPED_COPY 0x01000000 /* T if mapped copy of data (nommu mmap) */
Pallipadi, Venkatesh895791d2009-03-13 16:35:44 -0700101#define VM_INSERTPAGE 0x02000000 /* The vma has had "vm_insert_page()" done on it */
Roland McGrathe5b97dd2007-01-26 00:56:48 -0800102#define VM_ALWAYSDUMP 0x04000000 /* Always include in core dumps */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Nick Piggind0217ac2007-07-19 01:47:03 -0700104#define VM_CAN_NONLINEAR 0x08000000 /* Has ->fault & does nonlinear pages */
Jared Hulbertb379d792008-04-28 02:12:58 -0700105#define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */
Dave Kleikampaba46c52008-07-08 00:28:52 +1000106#define VM_SAO 0x20000000 /* Strong Access Ordering (powerpc) */
Pallipadi, Venkatesh895791d2009-03-13 16:35:44 -0700107#define VM_PFN_AT_MMAP 0x40000000 /* PFNMAP vma that is fully mapped at mmap time */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700108#define VM_MERGEABLE 0x80000000 /* KSM may merge identical pages */
Nick Piggind00806b2007-07-19 01:46:57 -0700109
Mel Gormana8bef8ff2010-05-24 14:32:24 -0700110/* Bits set in the VMA until the stack is in its final location */
111#define VM_STACK_INCOMPLETE_SETUP (VM_RAND_READ | VM_SEQ_READ)
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */
114#define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
115#endif
116
117#ifdef CONFIG_STACK_GROWSUP
118#define VM_STACK_FLAGS (VM_GROWSUP | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
119#else
120#define VM_STACK_FLAGS (VM_GROWSDOWN | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
121#endif
122
123#define VM_READHINTMASK (VM_SEQ_READ | VM_RAND_READ)
124#define VM_ClearReadHint(v) (v)->vm_flags &= ~VM_READHINTMASK
125#define VM_NormalReadHint(v) (!((v)->vm_flags & VM_READHINTMASK))
126#define VM_SequentialReadHint(v) ((v)->vm_flags & VM_SEQ_READ)
127#define VM_RandomReadHint(v) ((v)->vm_flags & VM_RAND_READ)
128
129/*
Nick Pigginb291f002008-10-18 20:26:44 -0700130 * special vmas that are non-mergable, non-mlock()able
131 */
132#define VM_SPECIAL (VM_IO | VM_DONTEXPAND | VM_RESERVED | VM_PFNMAP)
133
134/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 * mapping from the currently active vm_flags protection bits (the
136 * low four bits) to a page protection mask..
137 */
138extern pgprot_t protection_map[16];
139
Nick Piggind0217ac2007-07-19 01:47:03 -0700140#define FAULT_FLAG_WRITE 0x01 /* Fault was a write access */
141#define FAULT_FLAG_NONLINEAR 0x02 /* Fault was via a nonlinear mapping */
Nick Pigginc2ec1752009-03-31 15:23:21 -0700142#define FAULT_FLAG_MKWRITE 0x04 /* Fault was mkwrite of existing pte */
Nick Piggind0217ac2007-07-19 01:47:03 -0700143
venkatesh.pallipadi@intel.com6bd9cd52008-12-19 13:47:26 -0800144/*
145 * This interface is used by x86 PAT code to identify a pfn mapping that is
146 * linear over entire vma. This is to optimize PAT code that deals with
147 * marking the physical region with a particular prot. This is not for generic
148 * mm use. Note also that this check will not work if the pfn mapping is
149 * linear for a vma starting at physical address 0. In which case PAT code
150 * falls back to slow path of reserving physical range page by page.
151 */
venkatesh.pallipadi@intel.com3c8bb732008-12-18 11:41:27 -0800152static inline int is_linear_pfn_mapping(struct vm_area_struct *vma)
153{
Pallipadi, Venkatesh895791d2009-03-13 16:35:44 -0700154 return (vma->vm_flags & VM_PFN_AT_MMAP);
venkatesh.pallipadi@intel.com3c8bb732008-12-18 11:41:27 -0800155}
156
157static inline int is_pfn_mapping(struct vm_area_struct *vma)
158{
159 return (vma->vm_flags & VM_PFNMAP);
160}
Nick Piggind0217ac2007-07-19 01:47:03 -0700161
Nick Piggin54cb8822007-07-19 01:46:59 -0700162/*
Nick Piggind0217ac2007-07-19 01:47:03 -0700163 * vm_fault is filled by the the pagefault handler and passed to the vma's
Nick Piggin83c54072007-07-19 01:47:05 -0700164 * ->fault function. The vma's ->fault is responsible for returning a bitmask
165 * of VM_FAULT_xxx flags that give details about how the fault was handled.
Nick Piggin54cb8822007-07-19 01:46:59 -0700166 *
Nick Piggind0217ac2007-07-19 01:47:03 -0700167 * pgoff should be used in favour of virtual_address, if possible. If pgoff
168 * is used, one may set VM_CAN_NONLINEAR in the vma->vm_flags to get nonlinear
169 * mapping support.
Nick Piggin54cb8822007-07-19 01:46:59 -0700170 */
Nick Piggind0217ac2007-07-19 01:47:03 -0700171struct vm_fault {
172 unsigned int flags; /* FAULT_FLAG_xxx flags */
173 pgoff_t pgoff; /* Logical page offset based on vma */
174 void __user *virtual_address; /* Faulting virtual address */
175
176 struct page *page; /* ->fault handlers should return a
Nick Piggin83c54072007-07-19 01:47:05 -0700177 * page here, unless VM_FAULT_NOPAGE
Nick Piggind0217ac2007-07-19 01:47:03 -0700178 * is set (which is also implied by
Nick Piggin83c54072007-07-19 01:47:05 -0700179 * VM_FAULT_ERROR).
Nick Piggind0217ac2007-07-19 01:47:03 -0700180 */
Nick Piggin54cb8822007-07-19 01:46:59 -0700181};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183/*
184 * These are the virtual MM functions - opening of an area, closing and
185 * unmapping it (needed to keep files on disk up-to-date etc), pointer
186 * to the functions called when a no-page or a wp-page exception occurs.
187 */
188struct vm_operations_struct {
189 void (*open)(struct vm_area_struct * area);
190 void (*close)(struct vm_area_struct * area);
Nick Piggind0217ac2007-07-19 01:47:03 -0700191 int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);
David Howells9637a5e2006-06-23 02:03:43 -0700192
193 /* notification that a previously read-only page is about to become
194 * writable, if an error is returned it will cause a SIGBUS */
Nick Pigginc2ec1752009-03-31 15:23:21 -0700195 int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);
Rik van Riel28b2ee22008-07-23 21:27:05 -0700196
197 /* called by access_process_vm when get_user_pages() fails, typically
198 * for use by special VMAs that can switch between memory and hardware
199 */
200 int (*access)(struct vm_area_struct *vma, unsigned long addr,
201 void *buf, int len, int write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202#ifdef CONFIG_NUMA
Lee Schermerhorna6020ed2008-04-28 02:13:14 -0700203 /*
204 * set_policy() op must add a reference to any non-NULL @new mempolicy
205 * to hold the policy upon return. Caller should pass NULL @new to
206 * remove a policy and fall back to surrounding context--i.e. do not
207 * install a MPOL_DEFAULT policy, nor the task or system default
208 * mempolicy.
209 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
Lee Schermerhorna6020ed2008-04-28 02:13:14 -0700211
212 /*
213 * get_policy() op must add reference [mpol_get()] to any policy at
214 * (vma,addr) marked as MPOL_SHARED. The shared policy infrastructure
215 * in mm/mempolicy.c will do this automatically.
216 * get_policy() must NOT add a ref if the policy at (vma,addr) is not
217 * marked as MPOL_SHARED. vma policies are protected by the mmap_sem.
218 * If no [shared/vma] mempolicy exists at the addr, get_policy() op
219 * must return NULL--i.e., do not "fallback" to task or system default
220 * policy.
221 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
223 unsigned long addr);
Christoph Lameter7b2259b2006-06-25 05:46:48 -0700224 int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
225 const nodemask_t *to, unsigned long flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226#endif
227};
228
229struct mmu_gather;
230struct inode;
231
Andrew Morton349aef02006-01-08 01:04:36 -0800232#define page_private(page) ((page)->private)
233#define set_page_private(page, v) ((page)->private = (v))
Hugh Dickins4c21e2f2005-10-29 18:16:40 -0700234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235/*
236 * FIXME: take this include out, include page-flags.h in
237 * files which need it (119 of them)
238 */
239#include <linux/page-flags.h>
240
241/*
242 * Methods to modify the page usage count.
243 *
244 * What counts for a page usage:
245 * - cache mapping (page->mapping)
246 * - private data (page->private)
247 * - page mapped in a task's page tables, each mapping
248 * is counted separately
249 *
250 * Also, many kernel routines increase the page count before a critical
251 * routine so they can be sure the page doesn't go away from under them.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 */
253
254/*
Nick Pigginda6052f2006-09-25 23:31:35 -0700255 * Drop a ref, return true if the refcount fell to zero (the page has no users)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 */
Nick Piggin7c8ee9a2006-03-22 00:08:03 -0800257static inline int put_page_testzero(struct page *page)
258{
Nick Piggin725d7042006-09-25 23:30:55 -0700259 VM_BUG_ON(atomic_read(&page->_count) == 0);
Nick Piggin8dc04ef2006-03-22 00:08:03 -0800260 return atomic_dec_and_test(&page->_count);
Nick Piggin7c8ee9a2006-03-22 00:08:03 -0800261}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263/*
Nick Piggin7c8ee9a2006-03-22 00:08:03 -0800264 * Try to grab a ref unless the page has a refcount of zero, return false if
265 * that is the case.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 */
Nick Piggin7c8ee9a2006-03-22 00:08:03 -0800267static inline int get_page_unless_zero(struct page *page)
268{
Nick Piggin8dc04ef2006-03-22 00:08:03 -0800269 return atomic_inc_not_zero(&page->_count);
Nick Piggin7c8ee9a2006-03-22 00:08:03 -0800270}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Wu Fengguang53df8fd2010-01-27 11:06:39 +0800272extern int page_is_ram(unsigned long pfn);
273
Christoph Lameter48667e72008-02-04 22:28:31 -0800274/* Support for virtually mapped pages */
Christoph Lameterb3bdda02008-02-04 22:28:32 -0800275struct page *vmalloc_to_page(const void *addr);
276unsigned long vmalloc_to_pfn(const void *addr);
Christoph Lameter48667e72008-02-04 22:28:31 -0800277
Paul Mundt0738c4b2008-03-12 16:51:31 +0900278/*
279 * Determine if an address is within the vmalloc range
280 *
281 * On nommu, vmalloc/vfree wrap through kmalloc/kfree directly, so there
282 * is no special casing required.
283 */
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800284static inline int is_vmalloc_addr(const void *x)
285{
Paul Mundt0738c4b2008-03-12 16:51:31 +0900286#ifdef CONFIG_MMU
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800287 unsigned long addr = (unsigned long)x;
288
289 return addr >= VMALLOC_START && addr < VMALLOC_END;
Paul Mundt0738c4b2008-03-12 16:51:31 +0900290#else
291 return 0;
David Howells8ca3ed82008-02-23 15:23:37 -0800292#endif
Paul Mundt0738c4b2008-03-12 16:51:31 +0900293}
KAMEZAWA Hiroyuki81ac3ad2009-09-22 16:45:49 -0700294#ifdef CONFIG_MMU
295extern int is_vmalloc_or_module_addr(const void *x);
296#else
David Howells934831d2009-09-24 12:33:32 +0100297static inline int is_vmalloc_or_module_addr(const void *x)
KAMEZAWA Hiroyuki81ac3ad2009-09-22 16:45:49 -0700298{
299 return 0;
300}
301#endif
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800302
Christoph Lameterd85f3382007-05-06 14:49:39 -0700303static inline struct page *compound_head(struct page *page)
304{
Christoph Lameter6d777952007-05-06 14:49:40 -0700305 if (unlikely(PageTail(page)))
Christoph Lameterd85f3382007-05-06 14:49:39 -0700306 return page->first_page;
307 return page;
308}
309
Hugh Dickins4c21e2f2005-10-29 18:16:40 -0700310static inline int page_count(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Christoph Lameterd85f3382007-05-06 14:49:39 -0700312 return atomic_read(&compound_head(page)->_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
315static inline void get_page(struct page *page)
316{
Christoph Lameterd85f3382007-05-06 14:49:39 -0700317 page = compound_head(page);
Nick Piggin725d7042006-09-25 23:30:55 -0700318 VM_BUG_ON(atomic_read(&page->_count) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 atomic_inc(&page->_count);
320}
321
Christoph Lameterb49af682007-05-06 14:49:41 -0700322static inline struct page *virt_to_head_page(const void *x)
323{
324 struct page *page = virt_to_page(x);
325 return compound_head(page);
326}
327
Nick Piggin7835e982006-03-22 00:08:40 -0800328/*
329 * Setup the page count before being freed into the page allocator for
330 * the first time (boot or memory hotplug)
331 */
332static inline void init_page_count(struct page *page)
333{
334 atomic_set(&page->_count, 1);
335}
336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337void put_page(struct page *page);
Alexander Zarochentsev1d7ea732006-08-13 23:24:27 -0700338void put_pages_list(struct list_head *pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Nick Piggin8dfcc9b2006-03-22 00:08:05 -0800340void split_page(struct page *page, unsigned int order);
Mel Gorman748446b2010-05-24 14:32:27 -0700341int split_free_page(struct page *page);
Nick Piggin8dfcc9b2006-03-22 00:08:05 -0800342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343/*
Andy Whitcroft33f2ef82006-12-06 20:33:32 -0800344 * Compound pages have a destructor function. Provide a
345 * prototype for that function and accessor functions.
346 * These are _only_ valid on the head of a PG_compound page.
347 */
348typedef void compound_page_dtor(struct page *);
349
350static inline void set_compound_page_dtor(struct page *page,
351 compound_page_dtor *dtor)
352{
353 page[1].lru.next = (void *)dtor;
354}
355
356static inline compound_page_dtor *get_compound_page_dtor(struct page *page)
357{
358 return (compound_page_dtor *)page[1].lru.next;
359}
360
Christoph Lameterd85f3382007-05-06 14:49:39 -0700361static inline int compound_order(struct page *page)
362{
Christoph Lameter6d777952007-05-06 14:49:40 -0700363 if (!PageHead(page))
Christoph Lameterd85f3382007-05-06 14:49:39 -0700364 return 0;
365 return (unsigned long)page[1].lru.prev;
366}
367
368static inline void set_compound_order(struct page *page, unsigned long order)
369{
370 page[1].lru.prev = (void *)order;
371}
372
Andy Whitcroft33f2ef82006-12-06 20:33:32 -0800373/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 * Multiple processes may "see" the same page. E.g. for untouched
375 * mappings of /dev/null, all processes see the same page full of
376 * zeroes, and text pages of executables and shared libraries have
377 * only one copy in memory, at most, normally.
378 *
379 * For the non-reserved pages, page_count(page) denotes a reference count.
Paolo 'Blaisorblade' Giarrusso7e871b62005-09-21 09:55:38 -0700380 * page_count() == 0 means the page is free. page->lru is then used for
381 * freelist management in the buddy allocator.
Nick Pigginda6052f2006-09-25 23:31:35 -0700382 * page_count() > 0 means the page has been allocated.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700384 * Pages are allocated by the slab allocator in order to provide memory
385 * to kmalloc and kmem_cache_alloc. In this case, the management of the
386 * page, and the fields in 'struct page' are the responsibility of mm/slab.c
387 * unless a particular usage is carefully commented. (the responsibility of
388 * freeing the kmalloc memory is the caller's, of course).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700390 * A page may be used by anyone else who does a __get_free_page().
391 * In this case, page_count still tracks the references, and should only
392 * be used through the normal accessor functions. The top bits of page->flags
393 * and page->virtual store page management information, but all other fields
394 * are unused and could be used privately, carefully. The management of this
395 * page is the responsibility of the one who allocated it, and those who have
396 * subsequently been given references to it.
397 *
398 * The other pages (we may call them "pagecache pages") are completely
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 * managed by the Linux memory manager: I/O, buffers, swapping etc.
400 * The following discussion applies only to them.
401 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700402 * A pagecache page contains an opaque `private' member, which belongs to the
403 * page's address_space. Usually, this is the address of a circular list of
404 * the page's disk buffers. PG_private must be set to tell the VM to call
405 * into the filesystem to release these pages.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700407 * A page may belong to an inode's memory mapping. In this case, page->mapping
408 * is the pointer to the inode, and page->index is the file offset of the page,
409 * in units of PAGE_CACHE_SIZE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700411 * If pagecache pages are not associated with an inode, they are said to be
412 * anonymous pages. These may become associated with the swapcache, and in that
413 * case PG_swapcache is set, and page->private is an offset into the swapcache.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700415 * In either case (swapcache or inode backed), the pagecache itself holds one
416 * reference to the page. Setting PG_private should also increment the
417 * refcount. The each user mapping also has a reference to the page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700419 * The pagecache pages are stored in a per-mapping radix tree, which is
420 * rooted at mapping->page_tree, and indexed by offset.
421 * Where 2.4 and early 2.6 kernels kept dirty/clean pages in per-address_space
422 * lists, we instead now tag pages as dirty/writeback in the radix tree.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 *
Nick Pigginda6052f2006-09-25 23:31:35 -0700424 * All pagecache pages may be subject to I/O:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 * - inode pages may need to be read from disk,
426 * - inode pages which have been modified and are MAP_SHARED may need
Nick Pigginda6052f2006-09-25 23:31:35 -0700427 * to be written back to the inode on disk,
428 * - anonymous pages (including MAP_PRIVATE file mappings) which have been
429 * modified may need to be swapped out to swap space and (later) to be read
430 * back into memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 */
432
433/*
434 * The zone field is never updated after free_area_init_core()
435 * sets it, so none of the operations on it need to be atomic.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 */
Dave Hansen348f8b62005-06-23 00:07:40 -0700437
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700438
439/*
440 * page->flags layout:
441 *
442 * There are three possibilities for how page->flags get
443 * laid out. The first is for the normal case, without
444 * sparsemem. The second is for sparsemem when there is
445 * plenty of space for node and section. The last is when
446 * we have run out of space and have to fall back to an
447 * alternate (slower) way of determining the node.
448 *
Christoph Lameter308c05e2008-04-28 02:12:43 -0700449 * No sparsemem or sparsemem vmemmap: | NODE | ZONE | ... | FLAGS |
450 * classic sparse with space for node:| SECTION | NODE | ZONE | ... | FLAGS |
451 * classic sparse no space for node: | SECTION | ZONE | ... | FLAGS |
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700452 */
Christoph Lameter308c05e2008-04-28 02:12:43 -0700453#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700454#define SECTIONS_WIDTH SECTIONS_SHIFT
455#else
456#define SECTIONS_WIDTH 0
457#endif
458
459#define ZONES_WIDTH ZONES_SHIFT
460
Christoph Lameter9223b412008-04-28 02:12:48 -0700461#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700462#define NODES_WIDTH NODES_SHIFT
463#else
Christoph Lameter308c05e2008-04-28 02:12:43 -0700464#ifdef CONFIG_SPARSEMEM_VMEMMAP
465#error "Vmemmap: No space for nodes field in page flags"
466#endif
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700467#define NODES_WIDTH 0
468#endif
469
470/* Page flags: | [SECTION] | [NODE] | ZONE | ... | FLAGS | */
Andi Kleen07808b72005-11-05 17:25:53 +0100471#define SECTIONS_PGOFF ((sizeof(unsigned long)*8) - SECTIONS_WIDTH)
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700472#define NODES_PGOFF (SECTIONS_PGOFF - NODES_WIDTH)
473#define ZONES_PGOFF (NODES_PGOFF - ZONES_WIDTH)
474
475/*
476 * We are going to use the flags for the page to node mapping if its in
477 * there. This includes the case where there is no node, so it is implicit.
478 */
Christoph Lameter89689ae2006-12-06 20:31:45 -0800479#if !(NODES_WIDTH > 0 || NODES_SHIFT == 0)
480#define NODE_NOT_IN_PAGE_FLAGS
481#endif
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700482
483#ifndef PFN_SECTION_SHIFT
484#define PFN_SECTION_SHIFT 0
485#endif
Dave Hansen348f8b62005-06-23 00:07:40 -0700486
487/*
488 * Define the bit shifts to access each section. For non-existant
489 * sections we define the shift as 0; that plus a 0 mask ensures
490 * the compiler will optimise away reference to them.
491 */
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700492#define SECTIONS_PGSHIFT (SECTIONS_PGOFF * (SECTIONS_WIDTH != 0))
493#define NODES_PGSHIFT (NODES_PGOFF * (NODES_WIDTH != 0))
494#define ZONES_PGSHIFT (ZONES_PGOFF * (ZONES_WIDTH != 0))
Dave Hansen348f8b62005-06-23 00:07:40 -0700495
Christoph Lameter89689ae2006-12-06 20:31:45 -0800496/* NODE:ZONE or SECTION:ZONE is used to ID a zone for the buddy allcator */
497#ifdef NODE_NOT_IN_PAGEFLAGS
498#define ZONEID_SHIFT (SECTIONS_SHIFT + ZONES_SHIFT)
Andy Whitcroftbd8029b2007-02-10 01:43:14 -0800499#define ZONEID_PGOFF ((SECTIONS_PGOFF < ZONES_PGOFF)? \
500 SECTIONS_PGOFF : ZONES_PGOFF)
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700501#else
Christoph Lameter89689ae2006-12-06 20:31:45 -0800502#define ZONEID_SHIFT (NODES_SHIFT + ZONES_SHIFT)
Andy Whitcroftbd8029b2007-02-10 01:43:14 -0800503#define ZONEID_PGOFF ((NODES_PGOFF < ZONES_PGOFF)? \
504 NODES_PGOFF : ZONES_PGOFF)
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700505#endif
Christoph Lameter89689ae2006-12-06 20:31:45 -0800506
Andy Whitcroftbd8029b2007-02-10 01:43:14 -0800507#define ZONEID_PGSHIFT (ZONEID_PGOFF * (ZONEID_SHIFT != 0))
Dave Hansen348f8b62005-06-23 00:07:40 -0700508
Christoph Lameter9223b412008-04-28 02:12:48 -0700509#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS
510#error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS
Dave Hansen348f8b62005-06-23 00:07:40 -0700511#endif
512
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700513#define ZONES_MASK ((1UL << ZONES_WIDTH) - 1)
514#define NODES_MASK ((1UL << NODES_WIDTH) - 1)
515#define SECTIONS_MASK ((1UL << SECTIONS_WIDTH) - 1)
Christoph Lameter89689ae2006-12-06 20:31:45 -0800516#define ZONEID_MASK ((1UL << ZONEID_SHIFT) - 1)
Dave Hansen348f8b62005-06-23 00:07:40 -0700517
Christoph Lameter2f1b6242006-09-25 23:31:13 -0700518static inline enum zone_type page_zonenum(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
Dave Hansen348f8b62005-06-23 00:07:40 -0700520 return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Christoph Lameter89689ae2006-12-06 20:31:45 -0800523/*
524 * The identification function is only used by the buddy allocator for
525 * determining if two pages could be buddies. We are not really
526 * identifying a zone since we could be using a the section number
527 * id if we have not node id available in page flags.
528 * We guarantee only that it will return the same value for two
529 * combinable pages in a zone.
530 */
Andy Whitcroftcb2b95e2006-06-23 02:03:01 -0700531static inline int page_zone_id(struct page *page)
532{
Christoph Lameter89689ae2006-12-06 20:31:45 -0800533 return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534}
535
Andy Whitcroft25ba77c2006-12-06 20:33:03 -0800536static inline int zone_to_nid(struct zone *zone)
Christoph Lameter89fa3022006-09-25 23:31:55 -0700537{
Christoph Lameterd5f541e2006-09-27 01:50:08 -0700538#ifdef CONFIG_NUMA
539 return zone->node;
540#else
541 return 0;
542#endif
Christoph Lameter89fa3022006-09-25 23:31:55 -0700543}
544
Christoph Lameter89689ae2006-12-06 20:31:45 -0800545#ifdef NODE_NOT_IN_PAGE_FLAGS
Andy Whitcroft25ba77c2006-12-06 20:33:03 -0800546extern int page_to_nid(struct page *page);
Christoph Lameter89689ae2006-12-06 20:31:45 -0800547#else
Andy Whitcroft25ba77c2006-12-06 20:33:03 -0800548static inline int page_to_nid(struct page *page)
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700549{
Christoph Lameter89689ae2006-12-06 20:31:45 -0800550 return (page->flags >> NODES_PGSHIFT) & NODES_MASK;
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700551}
Christoph Lameter89689ae2006-12-06 20:31:45 -0800552#endif
553
554static inline struct zone *page_zone(struct page *page)
555{
556 return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)];
557}
558
Christoph Lameter308c05e2008-04-28 02:12:43 -0700559#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700560static inline unsigned long page_to_section(struct page *page)
561{
562 return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
563}
Christoph Lameter308c05e2008-04-28 02:12:43 -0700564#endif
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700565
Christoph Lameter2f1b6242006-09-25 23:31:13 -0700566static inline void set_page_zone(struct page *page, enum zone_type zone)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
Dave Hansen348f8b62005-06-23 00:07:40 -0700568 page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);
569 page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;
570}
Christoph Lameter2f1b6242006-09-25 23:31:13 -0700571
Dave Hansen348f8b62005-06-23 00:07:40 -0700572static inline void set_page_node(struct page *page, unsigned long node)
573{
574 page->flags &= ~(NODES_MASK << NODES_PGSHIFT);
575 page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
576}
Christoph Lameter89689ae2006-12-06 20:31:45 -0800577
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700578static inline void set_page_section(struct page *page, unsigned long section)
579{
580 page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
581 page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
582}
Dave Hansen348f8b62005-06-23 00:07:40 -0700583
Christoph Lameter2f1b6242006-09-25 23:31:13 -0700584static inline void set_page_links(struct page *page, enum zone_type zone,
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700585 unsigned long node, unsigned long pfn)
Dave Hansen348f8b62005-06-23 00:07:40 -0700586{
587 set_page_zone(page, zone);
588 set_page_node(page, node);
Andy Whitcroftd41dee32005-06-23 00:07:54 -0700589 set_page_section(page, pfn_to_section_nr(pfn));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590}
591
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700592/*
593 * Some inline functions in vmstat.h depend on page_zone()
594 */
595#include <linux/vmstat.h>
596
Ingo Molnar652050a2006-01-14 13:21:30 -0800597static __always_inline void *lowmem_page_address(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Chris Metcalfc6f6b592010-05-24 14:32:53 -0700599 return __va(PFN_PHYS(page_to_pfn(page)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
602#if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL)
603#define HASHED_PAGE_VIRTUAL
604#endif
605
606#if defined(WANT_PAGE_VIRTUAL)
607#define page_address(page) ((page)->virtual)
608#define set_page_address(page, address) \
609 do { \
610 (page)->virtual = (address); \
611 } while(0)
612#define page_address_init() do { } while(0)
613#endif
614
615#if defined(HASHED_PAGE_VIRTUAL)
616void *page_address(struct page *page);
617void set_page_address(struct page *page, void *virtual);
618void page_address_init(void);
619#endif
620
621#if !defined(HASHED_PAGE_VIRTUAL) && !defined(WANT_PAGE_VIRTUAL)
622#define page_address(page) lowmem_page_address(page)
623#define set_page_address(page, address) do { } while(0)
624#define page_address_init() do { } while(0)
625#endif
626
627/*
628 * On an anonymous page mapped into a user virtual memory area,
629 * page->mapping points to its anon_vma, not to a struct address_space;
Hugh Dickins3ca7b3c2009-12-14 17:58:57 -0800630 * with the PAGE_MAPPING_ANON bit set to distinguish it. See rmap.h.
631 *
632 * On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
633 * the PAGE_MAPPING_KSM bit may be set along with the PAGE_MAPPING_ANON bit;
634 * and then page->mapping points, not to an anon_vma, but to a private
635 * structure which KSM associates with that merged page. See ksm.h.
636 *
637 * PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is currently never used.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 *
639 * Please note that, confusingly, "page_mapping" refers to the inode
640 * address_space which maps the page from disk; whereas "page_mapped"
641 * refers to user virtual address space into which the page is mapped.
642 */
643#define PAGE_MAPPING_ANON 1
Hugh Dickins3ca7b3c2009-12-14 17:58:57 -0800644#define PAGE_MAPPING_KSM 2
645#define PAGE_MAPPING_FLAGS (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647extern struct address_space swapper_space;
648static inline struct address_space *page_mapping(struct page *page)
649{
650 struct address_space *mapping = page->mapping;
651
Christoph Lameterb5fab142007-07-17 04:03:33 -0700652 VM_BUG_ON(PageSlab(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (unlikely(PageSwapCache(page)))
654 mapping = &swapper_space;
Huang Shijief096e592009-12-14 17:59:51 -0800655 else if (unlikely((unsigned long)mapping & PAGE_MAPPING_ANON))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 mapping = NULL;
657 return mapping;
658}
659
Hugh Dickins3ca7b3c2009-12-14 17:58:57 -0800660/* Neutral page->mapping pointer to address_space or anon_vma or other */
661static inline void *page_rmapping(struct page *page)
662{
663 return (void *)((unsigned long)page->mapping & ~PAGE_MAPPING_FLAGS);
664}
665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666static inline int PageAnon(struct page *page)
667{
668 return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
669}
670
671/*
672 * Return the pagecache index of the passed page. Regular pagecache pages
673 * use ->index whereas swapcache pages use ->private
674 */
675static inline pgoff_t page_index(struct page *page)
676{
677 if (unlikely(PageSwapCache(page)))
Hugh Dickins4c21e2f2005-10-29 18:16:40 -0700678 return page_private(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 return page->index;
680}
681
682/*
683 * The atomic page->_mapcount, like _count, starts from -1:
684 * so that transitions both from it and to it can be tracked,
685 * using atomic_inc_and_test and atomic_add_negative(-1).
686 */
687static inline void reset_page_mapcount(struct page *page)
688{
689 atomic_set(&(page)->_mapcount, -1);
690}
691
692static inline int page_mapcount(struct page *page)
693{
694 return atomic_read(&(page)->_mapcount) + 1;
695}
696
697/*
698 * Return true if this page is mapped into pagetables.
699 */
700static inline int page_mapped(struct page *page)
701{
702 return atomic_read(&(page)->_mapcount) >= 0;
703}
704
705/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 * Different kinds of faults, as returned by handle_mm_fault().
707 * Used to decide whether a process gets delivered SIGBUS or
708 * just gets major/minor fault counters bumped up.
709 */
Nick Piggind0217ac2007-07-19 01:47:03 -0700710
Nick Piggin83c54072007-07-19 01:47:05 -0700711#define VM_FAULT_MINOR 0 /* For backwards compat. Remove me quickly. */
Nick Piggind0217ac2007-07-19 01:47:03 -0700712
Nick Piggin83c54072007-07-19 01:47:05 -0700713#define VM_FAULT_OOM 0x0001
714#define VM_FAULT_SIGBUS 0x0002
715#define VM_FAULT_MAJOR 0x0004
716#define VM_FAULT_WRITE 0x0008 /* Special case for get_user_pages */
Andi Kleend1737fd2009-09-16 11:50:06 +0200717#define VM_FAULT_HWPOISON 0x0010 /* Hit poisoned page */
Nick Pigginf33ea7f2005-08-03 20:24:01 +1000718
Nick Piggin83c54072007-07-19 01:47:05 -0700719#define VM_FAULT_NOPAGE 0x0100 /* ->fault installed the pte, not return page */
720#define VM_FAULT_LOCKED 0x0200 /* ->fault locked the returned page */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Andi Kleend1737fd2009-09-16 11:50:06 +0200722#define VM_FAULT_ERROR (VM_FAULT_OOM | VM_FAULT_SIGBUS | VM_FAULT_HWPOISON)
Nick Piggind0217ac2007-07-19 01:47:03 -0700723
Nick Piggin1c0fe6e2009-01-06 14:38:59 -0800724/*
725 * Can be called by the pagefault handler when it gets a VM_FAULT_OOM.
726 */
727extern void pagefault_out_of_memory(void);
728
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729#define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)
730
731extern void show_free_areas(void);
732
Hugh Dickins3f96b792009-09-21 17:03:37 -0700733int shmem_lock(struct file *file, int lock, struct user_struct *user);
Sergei Trofimovich168f5ac2009-06-16 15:33:02 -0700734struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735int shmem_zero_setup(struct vm_area_struct *);
736
David Howellsb0e15192006-01-06 00:11:42 -0800737#ifndef CONFIG_MMU
738extern unsigned long shmem_get_unmapped_area(struct file *file,
739 unsigned long addr,
740 unsigned long len,
741 unsigned long pgoff,
742 unsigned long flags);
743#endif
744
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +0400745extern int can_do_mlock(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746extern int user_shm_lock(size_t, struct user_struct *);
747extern void user_shm_unlock(size_t, struct user_struct *);
748
749/*
750 * Parameter block passed down to zap_pte_range in exceptional cases.
751 */
752struct zap_details {
753 struct vm_area_struct *nonlinear_vma; /* Check page->index if set */
754 struct address_space *check_mapping; /* Check page->mapping if set */
755 pgoff_t first_index; /* Lowest page->index to unmap */
756 pgoff_t last_index; /* Highest page->index to unmap */
757 spinlock_t *i_mmap_lock; /* For unmap_mapping_range: */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 unsigned long truncate_count; /* Compare vm_truncate_count */
759};
760
Nick Piggin7e675132008-04-28 02:13:00 -0700761struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
762 pte_t pte);
763
Jack Steinerc627f9c2008-07-29 22:33:53 -0700764int zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
765 unsigned long size);
Hugh Dickinsee39b372005-04-19 13:29:15 -0700766unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 unsigned long size, struct zap_details *);
Hugh Dickins508034a2005-10-29 18:16:30 -0700768unsigned long unmap_vmas(struct mmu_gather **tlb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 struct vm_area_struct *start_vma, unsigned long start_addr,
770 unsigned long end_addr, unsigned long *nr_accounted,
771 struct zap_details *);
Matt Mackalle6473092008-02-04 22:29:01 -0800772
773/**
774 * mm_walk - callbacks for walk_page_range
775 * @pgd_entry: if set, called for each non-empty PGD (top-level) entry
776 * @pud_entry: if set, called for each non-empty PUD (2nd-level) entry
777 * @pmd_entry: if set, called for each non-empty PMD (3rd-level) entry
778 * @pte_entry: if set, called for each non-empty PTE (4th-level) entry
779 * @pte_hole: if set, called for each hole at all levels
Naoya Horiguchi5dc37642009-12-14 18:00:01 -0800780 * @hugetlb_entry: if set, called for each hugetlb entry
Matt Mackalle6473092008-02-04 22:29:01 -0800781 *
782 * (see walk_page_range for more details)
783 */
784struct mm_walk {
Dave Hansen21650092008-06-12 15:21:47 -0700785 int (*pgd_entry)(pgd_t *, unsigned long, unsigned long, struct mm_walk *);
786 int (*pud_entry)(pud_t *, unsigned long, unsigned long, struct mm_walk *);
787 int (*pmd_entry)(pmd_t *, unsigned long, unsigned long, struct mm_walk *);
788 int (*pte_entry)(pte_t *, unsigned long, unsigned long, struct mm_walk *);
789 int (*pte_hole)(unsigned long, unsigned long, struct mm_walk *);
Naoya Horiguchi116354d2010-04-06 14:35:04 -0700790 int (*hugetlb_entry)(pte_t *, unsigned long,
791 unsigned long, unsigned long, struct mm_walk *);
Dave Hansen21650092008-06-12 15:21:47 -0700792 struct mm_struct *mm;
793 void *private;
Matt Mackalle6473092008-02-04 22:29:01 -0800794};
795
Dave Hansen21650092008-06-12 15:21:47 -0700796int walk_page_range(unsigned long addr, unsigned long end,
797 struct mm_walk *walk);
Jan Beulich42b77722008-07-23 21:27:10 -0700798void free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
Hugh Dickins3bf5ee92005-04-19 13:29:16 -0700799 unsigned long end, unsigned long floor, unsigned long ceiling);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
801 struct vm_area_struct *vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802void unmap_mapping_range(struct address_space *mapping,
803 loff_t const holebegin, loff_t const holelen, int even_cows);
Johannes Weiner3b6748e2009-06-16 15:32:35 -0700804int follow_pfn(struct vm_area_struct *vma, unsigned long address,
805 unsigned long *pfn);
venkatesh.pallipadi@intel.comd87fe662008-12-19 13:47:27 -0800806int follow_phys(struct vm_area_struct *vma, unsigned long address,
807 unsigned int flags, unsigned long *prot, resource_size_t *phys);
Rik van Riel28b2ee22008-07-23 21:27:05 -0700808int generic_access_phys(struct vm_area_struct *vma, unsigned long addr,
809 void *buf, int len, int write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
811static inline void unmap_shared_mapping_range(struct address_space *mapping,
812 loff_t const holebegin, loff_t const holelen)
813{
814 unmap_mapping_range(mapping, holebegin, holelen, 0);
815}
816
npiggin@suse.de25d9e2d2009-08-21 02:35:05 +1000817extern void truncate_pagecache(struct inode *inode, loff_t old, loff_t new);
818extern int vmtruncate(struct inode *inode, loff_t offset);
819extern int vmtruncate_range(struct inode *inode, loff_t offset, loff_t end);
Nick Pigginf33ea7f2005-08-03 20:24:01 +1000820
Nick Piggin750b4982009-09-16 11:50:12 +0200821int truncate_inode_page(struct address_space *mapping, struct page *page);
Andi Kleen25718732009-09-16 11:50:13 +0200822int generic_error_remove_page(struct address_space *mapping, struct page *page);
Nick Piggin750b4982009-09-16 11:50:12 +0200823
Wu Fengguang83f78662009-09-16 11:50:13 +0200824int invalidate_inode_page(struct page *page);
825
David Howells7ee1dd32006-01-06 00:11:44 -0800826#ifdef CONFIG_MMU
Nick Piggin83c54072007-07-19 01:47:05 -0700827extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
Linus Torvaldsd06063c2009-04-10 09:01:23 -0700828 unsigned long address, unsigned int flags);
David Howells7ee1dd32006-01-06 00:11:44 -0800829#else
830static inline int handle_mm_fault(struct mm_struct *mm,
831 struct vm_area_struct *vma, unsigned long address,
Linus Torvaldsd06063c2009-04-10 09:01:23 -0700832 unsigned int flags)
David Howells7ee1dd32006-01-06 00:11:44 -0800833{
834 /* should never happen if there's no MMU */
835 BUG();
836 return VM_FAULT_SIGBUS;
837}
838#endif
Nick Pigginf33ea7f2005-08-03 20:24:01 +1000839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840extern int make_pages_present(unsigned long addr, unsigned long end);
841extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Nick Piggind2bf6be2009-06-16 15:31:39 -0700843int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
Peter Zijlstra9d737772009-06-25 11:58:55 +0200844 unsigned long start, int nr_pages, int write, int force,
Nick Piggind2bf6be2009-06-16 15:31:39 -0700845 struct page **pages, struct vm_area_struct **vmas);
846int get_user_pages_fast(unsigned long start, int nr_pages, int write,
847 struct page **pages);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -0700848struct page *get_dump_page(unsigned long addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
David Howellscf9a2ae2006-08-29 19:05:54 +0100850extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
851extern void do_invalidatepage(struct page *page, unsigned long offset);
852
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853int __set_page_dirty_nobuffers(struct page *page);
Ken Chen76719322007-02-10 01:43:15 -0800854int __set_page_dirty_no_writeback(struct page *page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855int redirty_page_for_writepage(struct writeback_control *wbc,
856 struct page *page);
Edward Shishkine3a7cca2009-03-31 15:19:39 -0700857void account_page_dirtied(struct page *page, struct address_space *mapping);
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800858int set_page_dirty(struct page *page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859int set_page_dirty_lock(struct page *page);
860int clear_page_dirty_for_io(struct page *page);
861
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700862extern unsigned long move_page_tables(struct vm_area_struct *vma,
863 unsigned long old_addr, struct vm_area_struct *new_vma,
864 unsigned long new_addr, unsigned long len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865extern unsigned long do_mremap(unsigned long addr,
866 unsigned long old_len, unsigned long new_len,
867 unsigned long flags, unsigned long new_addr);
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700868extern int mprotect_fixup(struct vm_area_struct *vma,
869 struct vm_area_struct **pprev, unsigned long start,
870 unsigned long end, unsigned long newflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Nick Piggin21cc1992008-07-25 19:45:22 -0700872/*
Peter Zijlstra465a4542009-06-15 12:31:37 +0200873 * doesn't attempt to fault and will return short.
874 */
875int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
876 struct page **pages);
KAMEZAWA Hiroyukid559db02010-03-05 13:41:39 -0800877/*
878 * per-process(per-mm_struct) statistics.
879 */
KAMEZAWA Hiroyuki34e55232010-03-05 13:41:40 -0800880#if defined(SPLIT_RSS_COUNTING)
KAMEZAWA Hiroyukid559db02010-03-05 13:41:39 -0800881/*
882 * The mm counters are not protected by its page_table_lock,
883 * so must be incremented atomically.
884 */
885static inline void set_mm_counter(struct mm_struct *mm, int member, long value)
886{
887 atomic_long_set(&mm->rss_stat.count[member], value);
888}
889
KAMEZAWA Hiroyuki34e55232010-03-05 13:41:40 -0800890unsigned long get_mm_counter(struct mm_struct *mm, int member);
KAMEZAWA Hiroyukid559db02010-03-05 13:41:39 -0800891
892static inline void add_mm_counter(struct mm_struct *mm, int member, long value)
893{
894 atomic_long_add(value, &mm->rss_stat.count[member]);
895}
896
897static inline void inc_mm_counter(struct mm_struct *mm, int member)
898{
899 atomic_long_inc(&mm->rss_stat.count[member]);
900}
901
902static inline void dec_mm_counter(struct mm_struct *mm, int member)
903{
904 atomic_long_dec(&mm->rss_stat.count[member]);
905}
906
907#else /* !USE_SPLIT_PTLOCKS */
908/*
909 * The mm counters are protected by its page_table_lock,
910 * so can be incremented directly.
911 */
912static inline void set_mm_counter(struct mm_struct *mm, int member, long value)
913{
914 mm->rss_stat.count[member] = value;
915}
916
917static inline unsigned long get_mm_counter(struct mm_struct *mm, int member)
918{
919 return mm->rss_stat.count[member];
920}
921
922static inline void add_mm_counter(struct mm_struct *mm, int member, long value)
923{
924 mm->rss_stat.count[member] += value;
925}
926
927static inline void inc_mm_counter(struct mm_struct *mm, int member)
928{
929 mm->rss_stat.count[member]++;
930}
931
932static inline void dec_mm_counter(struct mm_struct *mm, int member)
933{
934 mm->rss_stat.count[member]--;
935}
936
937#endif /* !USE_SPLIT_PTLOCKS */
938
939static inline unsigned long get_mm_rss(struct mm_struct *mm)
940{
941 return get_mm_counter(mm, MM_FILEPAGES) +
942 get_mm_counter(mm, MM_ANONPAGES);
943}
944
945static inline unsigned long get_mm_hiwater_rss(struct mm_struct *mm)
946{
947 return max(mm->hiwater_rss, get_mm_rss(mm));
948}
949
950static inline unsigned long get_mm_hiwater_vm(struct mm_struct *mm)
951{
952 return max(mm->hiwater_vm, mm->total_vm);
953}
954
955static inline void update_hiwater_rss(struct mm_struct *mm)
956{
957 unsigned long _rss = get_mm_rss(mm);
958
959 if ((mm)->hiwater_rss < _rss)
960 (mm)->hiwater_rss = _rss;
961}
962
963static inline void update_hiwater_vm(struct mm_struct *mm)
964{
965 if (mm->hiwater_vm < mm->total_vm)
966 mm->hiwater_vm = mm->total_vm;
967}
968
969static inline void setmax_mm_hiwater_rss(unsigned long *maxrss,
970 struct mm_struct *mm)
971{
972 unsigned long hiwater_rss = get_mm_hiwater_rss(mm);
973
974 if (*maxrss < hiwater_rss)
975 *maxrss = hiwater_rss;
976}
977
KAMEZAWA Hiroyuki53bddb42010-03-10 15:20:38 -0800978#if defined(SPLIT_RSS_COUNTING)
KAMEZAWA Hiroyuki34e55232010-03-05 13:41:40 -0800979void sync_mm_rss(struct task_struct *task, struct mm_struct *mm);
KAMEZAWA Hiroyuki53bddb42010-03-10 15:20:38 -0800980#else
981static inline void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
982{
983}
984#endif
Peter Zijlstra465a4542009-06-15 12:31:37 +0200985
986/*
Rusty Russell8e1f9362007-07-17 04:03:17 -0700987 * A callback you can register to apply pressure to ageable caches.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 *
Rusty Russell8e1f9362007-07-17 04:03:17 -0700989 * 'shrink' is passed a count 'nr_to_scan' and a 'gfpmask'. It should
990 * look through the least-recently-used 'nr_to_scan' entries and
991 * attempt to free them up. It should return the number of objects
992 * which remain in the cache. If it returns -1, it means it cannot do
993 * any scanning at this time (eg. there is a risk of deadlock).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 *
Rusty Russell8e1f9362007-07-17 04:03:17 -0700995 * The 'gfpmask' refers to the allocation we are currently trying to
996 * fulfil.
997 *
998 * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is
999 * querying the cache size, so a fastpath for that case is appropriate.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 */
Rusty Russell8e1f9362007-07-17 04:03:17 -07001001struct shrinker {
Dave Chinner7f8275d2010-07-19 14:56:17 +10001002 int (*shrink)(struct shrinker *, int nr_to_scan, gfp_t gfp_mask);
Rusty Russell8e1f9362007-07-17 04:03:17 -07001003 int seeks; /* seeks to recreate an obj */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
Rusty Russell8e1f9362007-07-17 04:03:17 -07001005 /* These are for internal use */
1006 struct list_head list;
1007 long nr; /* objs pending delete */
1008};
1009#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
1010extern void register_shrinker(struct shrinker *);
1011extern void unregister_shrinker(struct shrinker *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
Alexey Dobriyan4e950f62007-07-30 02:36:13 +04001013int vma_wants_writenotify(struct vm_area_struct *vma);
Peter Zijlstrad08b3852006-09-25 23:30:57 -07001014
Harvey Harrisonb3c97522008-02-13 15:03:15 -08001015extern pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl);
Linus Torvaldsc9cfcdd2005-11-29 14:03:14 -08001016
Nick Piggin5f22df02007-05-06 14:49:02 -07001017#ifdef __PAGETABLE_PUD_FOLDED
1018static inline int __pud_alloc(struct mm_struct *mm, pgd_t *pgd,
1019 unsigned long address)
1020{
1021 return 0;
1022}
1023#else
Hugh Dickins1bb36302005-10-29 18:16:22 -07001024int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
Nick Piggin5f22df02007-05-06 14:49:02 -07001025#endif
1026
1027#ifdef __PAGETABLE_PMD_FOLDED
1028static inline int __pmd_alloc(struct mm_struct *mm, pud_t *pud,
1029 unsigned long address)
1030{
1031 return 0;
1032}
1033#else
Hugh Dickins1bb36302005-10-29 18:16:22 -07001034int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address);
Nick Piggin5f22df02007-05-06 14:49:02 -07001035#endif
1036
Hugh Dickins1bb36302005-10-29 18:16:22 -07001037int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
1038int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);
1039
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040/*
1041 * The following ifdef needed to get the 4level-fixup.h header to work.
1042 * Remove it when 4level-fixup.h has been removed.
1043 */
Hugh Dickins1bb36302005-10-29 18:16:22 -07001044#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045static inline pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
1046{
Hugh Dickins1bb36302005-10-29 18:16:22 -07001047 return (unlikely(pgd_none(*pgd)) && __pud_alloc(mm, pgd, address))?
1048 NULL: pud_offset(pgd, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
1051static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
1052{
Hugh Dickins1bb36302005-10-29 18:16:22 -07001053 return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?
1054 NULL: pmd_offset(pud, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055}
Hugh Dickins1bb36302005-10-29 18:16:22 -07001056#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */
1057
Jeremy Fitzhardingef7d0b922008-09-09 15:43:22 -07001058#if USE_SPLIT_PTLOCKS
Hugh Dickins4c21e2f2005-10-29 18:16:40 -07001059/*
1060 * We tuck a spinlock to guard each pagetable page into its struct page,
1061 * at page->private, with BUILD_BUG_ON to make sure that this will not
1062 * overflow into the next struct page (as it might with DEBUG_SPINLOCK).
1063 * When freeing, reset page->mapping so free_pages_check won't complain.
1064 */
Andrew Morton349aef02006-01-08 01:04:36 -08001065#define __pte_lockptr(page) &((page)->ptl)
Hugh Dickins4c21e2f2005-10-29 18:16:40 -07001066#define pte_lock_init(_page) do { \
1067 spin_lock_init(__pte_lockptr(_page)); \
1068} while (0)
1069#define pte_lock_deinit(page) ((page)->mapping = NULL)
1070#define pte_lockptr(mm, pmd) ({(void)(mm); __pte_lockptr(pmd_page(*(pmd)));})
Jeremy Fitzhardingef7d0b922008-09-09 15:43:22 -07001071#else /* !USE_SPLIT_PTLOCKS */
Hugh Dickins4c21e2f2005-10-29 18:16:40 -07001072/*
1073 * We use mm->page_table_lock to guard all pagetable pages of the mm.
1074 */
1075#define pte_lock_init(page) do {} while (0)
1076#define pte_lock_deinit(page) do {} while (0)
1077#define pte_lockptr(mm, pmd) ({(void)(pmd); &(mm)->page_table_lock;})
Jeremy Fitzhardingef7d0b922008-09-09 15:43:22 -07001078#endif /* USE_SPLIT_PTLOCKS */
Hugh Dickins4c21e2f2005-10-29 18:16:40 -07001079
Martin Schwidefsky2f569af2008-02-08 04:22:04 -08001080static inline void pgtable_page_ctor(struct page *page)
1081{
1082 pte_lock_init(page);
1083 inc_zone_page_state(page, NR_PAGETABLE);
1084}
1085
1086static inline void pgtable_page_dtor(struct page *page)
1087{
1088 pte_lock_deinit(page);
1089 dec_zone_page_state(page, NR_PAGETABLE);
1090}
1091
Hugh Dickinsc74df322005-10-29 18:16:23 -07001092#define pte_offset_map_lock(mm, pmd, address, ptlp) \
1093({ \
Hugh Dickins4c21e2f2005-10-29 18:16:40 -07001094 spinlock_t *__ptl = pte_lockptr(mm, pmd); \
Hugh Dickinsc74df322005-10-29 18:16:23 -07001095 pte_t *__pte = pte_offset_map(pmd, address); \
1096 *(ptlp) = __ptl; \
1097 spin_lock(__ptl); \
1098 __pte; \
1099})
1100
1101#define pte_unmap_unlock(pte, ptl) do { \
1102 spin_unlock(ptl); \
1103 pte_unmap(pte); \
1104} while (0)
1105
Hugh Dickins1bb36302005-10-29 18:16:22 -07001106#define pte_alloc_map(mm, pmd, address) \
1107 ((unlikely(!pmd_present(*(pmd))) && __pte_alloc(mm, pmd, address))? \
1108 NULL: pte_offset_map(pmd, address))
1109
Hugh Dickinsc74df322005-10-29 18:16:23 -07001110#define pte_alloc_map_lock(mm, pmd, address, ptlp) \
1111 ((unlikely(!pmd_present(*(pmd))) && __pte_alloc(mm, pmd, address))? \
1112 NULL: pte_offset_map_lock(mm, pmd, address, ptlp))
1113
Hugh Dickins1bb36302005-10-29 18:16:22 -07001114#define pte_alloc_kernel(pmd, address) \
1115 ((unlikely(!pmd_present(*(pmd))) && __pte_alloc_kernel(pmd, address))? \
1116 NULL: pte_offset_kernel(pmd, address))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
1118extern void free_area_init(unsigned long * zones_size);
Johannes Weiner9109fb72008-07-23 21:27:20 -07001119extern void free_area_init_node(int nid, unsigned long * zones_size,
1120 unsigned long zone_start_pfn, unsigned long *zholes_size);
Mel Gormanc7132162006-09-27 01:49:43 -07001121#ifdef CONFIG_ARCH_POPULATES_NODE_MAP
1122/*
1123 * With CONFIG_ARCH_POPULATES_NODE_MAP set, an architecture may initialise its
1124 * zones, allocate the backing mem_map and account for memory holes in a more
1125 * architecture independent manner. This is a substitute for creating the
1126 * zone_sizes[] and zholes_size[] arrays and passing them to
1127 * free_area_init_node()
1128 *
1129 * An architecture is expected to register range of page frames backed by
1130 * physical memory with add_active_range() before calling
1131 * free_area_init_nodes() passing in the PFN each zone ends at. At a basic
1132 * usage, an architecture is expected to do something like
1133 *
1134 * unsigned long max_zone_pfns[MAX_NR_ZONES] = {max_dma, max_normal_pfn,
1135 * max_highmem_pfn};
1136 * for_each_valid_physical_page_range()
1137 * add_active_range(node_id, start_pfn, end_pfn)
1138 * free_area_init_nodes(max_zone_pfns);
1139 *
1140 * If the architecture guarantees that there are no holes in the ranges
1141 * registered with add_active_range(), free_bootmem_active_regions()
1142 * will call free_bootmem_node() for each registered physical page range.
1143 * Similarly sparse_memory_present_with_active_regions() calls
1144 * memory_present() for each range when SPARSEMEM is enabled.
1145 *
1146 * See mm/page_alloc.c for more information on each function exposed by
1147 * CONFIG_ARCH_POPULATES_NODE_MAP
1148 */
1149extern void free_area_init_nodes(unsigned long *max_zone_pfn);
1150extern void add_active_range(unsigned int nid, unsigned long start_pfn,
1151 unsigned long end_pfn);
Yinghai Lucc1050b2008-06-13 19:08:52 -07001152extern void remove_active_range(unsigned int nid, unsigned long start_pfn,
1153 unsigned long end_pfn);
Mel Gormanc7132162006-09-27 01:49:43 -07001154extern void remove_all_active_ranges(void);
Yinghai Lu32996252009-12-15 17:59:02 -08001155void sort_node_map(void);
1156unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn,
1157 unsigned long end_pfn);
Mel Gormanc7132162006-09-27 01:49:43 -07001158extern unsigned long absent_pages_in_range(unsigned long start_pfn,
1159 unsigned long end_pfn);
1160extern void get_pfn_range_for_nid(unsigned int nid,
1161 unsigned long *start_pfn, unsigned long *end_pfn);
1162extern unsigned long find_min_pfn_with_active_regions(void);
Mel Gormanc7132162006-09-27 01:49:43 -07001163extern void free_bootmem_with_active_regions(int nid,
1164 unsigned long max_low_pfn);
Yinghai Lu08677212010-02-10 01:20:20 -08001165int add_from_early_node_map(struct range *range, int az,
1166 int nr_range, int nid);
1167void *__alloc_memory_core_early(int nodeid, u64 size, u64 align,
1168 u64 goal, u64 limit);
Yinghai Lud52d53b2008-06-16 20:10:55 -07001169typedef int (*work_fn_t)(unsigned long, unsigned long, void *);
Yinghai Lub5bc6c02008-06-14 18:32:52 -07001170extern void work_with_active_regions(int nid, work_fn_t work_fn, void *data);
Mel Gormanc7132162006-09-27 01:49:43 -07001171extern void sparse_memory_present_with_active_regions(int nid);
Mel Gormanc7132162006-09-27 01:49:43 -07001172#endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
KAMEZAWA Hiroyukif2dbcfa2009-02-18 14:48:32 -08001173
1174#if !defined(CONFIG_ARCH_POPULATES_NODE_MAP) && \
1175 !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID)
1176static inline int __early_pfn_to_nid(unsigned long pfn)
1177{
1178 return 0;
1179}
1180#else
1181/* please see mm/page_alloc.c */
1182extern int __meminit early_pfn_to_nid(unsigned long pfn);
1183#ifdef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
1184/* there is a per-arch backend function. */
1185extern int __meminit __early_pfn_to_nid(unsigned long pfn);
1186#endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
1187#endif
1188
Mel Gorman0e0b8642006-09-27 01:49:56 -07001189extern void set_dma_reserve(unsigned long new_dma_reserve);
Dave Hansena2f3aa02007-01-10 23:15:30 -08001190extern void memmap_init_zone(unsigned long, int, unsigned long,
1191 unsigned long, enum memmap_context);
Minchan Kimbc75d332009-06-16 15:32:48 -07001192extern void setup_per_zone_wmarks(void);
Minchan Kim96cb4df2009-06-16 15:32:49 -07001193extern void calculate_zone_inactive_ratio(struct zone *zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194extern void mem_init(void);
David Howells8feae132009-01-08 12:04:47 +00001195extern void __init mmap_init(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196extern void show_mem(void);
1197extern void si_meminfo(struct sysinfo * val);
1198extern void si_meminfo_node(struct sysinfo *val, int nid);
Mike Travis3461b0a2008-05-12 21:21:13 +02001199extern int after_bootmem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200
Christoph Lametere7c8d5c2005-06-21 17:14:47 -07001201extern void setup_per_cpu_pageset(void);
Christoph Lametere7c8d5c2005-06-21 17:14:47 -07001202
Shaohua Li112067f2009-09-21 17:01:16 -07001203extern void zone_pcp_update(struct zone *zone);
1204
David Howells8feae132009-01-08 12:04:47 +00001205/* nommu.c */
David Howells33e5d7692009-04-02 16:56:32 -07001206extern atomic_long_t mmap_pages_allocated;
David Howells7e660872010-01-15 17:01:39 -08001207extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t);
David Howells8feae132009-01-08 12:04:47 +00001208
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209/* prio_tree.c */
1210void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
1211void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
1212void vma_prio_tree_remove(struct vm_area_struct *, struct prio_tree_root *);
1213struct vm_area_struct *vma_prio_tree_next(struct vm_area_struct *vma,
1214 struct prio_tree_iter *iter);
1215
1216#define vma_prio_tree_foreach(vma, iter, root, begin, end) \
1217 for (prio_tree_iter_init(iter, root, begin, end), vma = NULL; \
1218 (vma = vma_prio_tree_next(vma, iter)); )
1219
1220static inline void vma_nonlinear_insert(struct vm_area_struct *vma,
1221 struct list_head *list)
1222{
1223 vma->shared.vm_set.parent = NULL;
1224 list_add_tail(&vma->shared.vm_set.list, list);
1225}
1226
1227/* mmap.c */
Alan Cox34b4e4a2007-08-22 14:01:28 -07001228extern int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin);
Rik van Riel5beb4932010-03-05 13:42:07 -08001229extern int vma_adjust(struct vm_area_struct *vma, unsigned long start,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert);
1231extern struct vm_area_struct *vma_merge(struct mm_struct *,
1232 struct vm_area_struct *prev, unsigned long addr, unsigned long end,
1233 unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t,
1234 struct mempolicy *);
1235extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
1236extern int split_vma(struct mm_struct *,
1237 struct vm_area_struct *, unsigned long addr, int new_below);
1238extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
1239extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
1240 struct rb_node **, struct rb_node *);
Hugh Dickinsa8fb5612005-10-29 18:15:57 -07001241extern void unlink_file_vma(struct vm_area_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
1243 unsigned long addr, unsigned long len, pgoff_t pgoff);
1244extern void exit_mmap(struct mm_struct *);
Matt Helsley925d1c42008-04-29 01:01:36 -07001245
Andrea Arcangeli7906d002008-07-28 15:46:26 -07001246extern int mm_take_all_locks(struct mm_struct *mm);
1247extern void mm_drop_all_locks(struct mm_struct *mm);
1248
Matt Helsley925d1c42008-04-29 01:01:36 -07001249#ifdef CONFIG_PROC_FS
1250/* From fs/proc/base.c. callers must _not_ hold the mm's exe_file_lock */
1251extern void added_exe_file_vma(struct mm_struct *mm);
1252extern void removed_exe_file_vma(struct mm_struct *mm);
1253#else
1254static inline void added_exe_file_vma(struct mm_struct *mm)
1255{}
1256
1257static inline void removed_exe_file_vma(struct mm_struct *mm)
1258{}
1259#endif /* CONFIG_PROC_FS */
1260
akpm@osdl.org119f6572005-05-01 08:58:35 -07001261extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
Roland McGrathfa5dc222007-02-08 14:20:41 -08001262extern int install_special_mapping(struct mm_struct *mm,
1263 unsigned long addr, unsigned long len,
1264 unsigned long flags, struct page **pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
1266extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1267
1268extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
1269 unsigned long len, unsigned long prot,
1270 unsigned long flag, unsigned long pgoff);
Miklos Szeredi0165ab42007-07-15 23:38:26 -07001271extern unsigned long mmap_region(struct file *file, unsigned long addr,
1272 unsigned long len, unsigned long flags,
Mel Gorman5a6fe122009-02-10 14:02:27 +00001273 unsigned int vm_flags, unsigned long pgoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275static inline unsigned long do_mmap(struct file *file, unsigned long addr,
1276 unsigned long len, unsigned long prot,
1277 unsigned long flag, unsigned long offset)
1278{
1279 unsigned long ret = -EINVAL;
1280 if ((offset + PAGE_ALIGN(len)) < offset)
1281 goto out;
1282 if (!(offset & ~PAGE_MASK))
1283 ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
1284out:
1285 return ret;
1286}
1287
1288extern int do_munmap(struct mm_struct *, unsigned long, size_t);
1289
1290extern unsigned long do_brk(unsigned long, unsigned long);
1291
1292/* filemap.c */
1293extern unsigned long page_unuse(struct page *);
1294extern void truncate_inode_pages(struct address_space *, loff_t);
Hans Reiserd7339072006-01-06 00:10:36 -08001295extern void truncate_inode_pages_range(struct address_space *,
1296 loff_t lstart, loff_t lend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
1298/* generic vm_area_ops exported for stackable file systems */
Nick Piggind0217ac2007-07-19 01:47:03 -07001299extern int filemap_fault(struct vm_area_struct *, struct vm_fault *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
1301/* mm/page-writeback.c */
1302int write_one_page(struct page *page, int wait);
Nick Piggin1cf6e7d2009-02-18 14:48:18 -08001303void task_dirty_inc(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
1305/* readahead.c */
1306#define VM_MAX_READAHEAD 128 /* kbytes */
1307#define VM_MIN_READAHEAD 16 /* kbytes (includes current page) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
Andrew Morton7361f4d2005-11-07 00:59:28 -08001310 pgoff_t offset, unsigned long nr_to_read);
Rusty Russellcf914a72007-07-19 01:48:08 -07001311
1312void page_cache_sync_readahead(struct address_space *mapping,
1313 struct file_ra_state *ra,
1314 struct file *filp,
1315 pgoff_t offset,
1316 unsigned long size);
1317
1318void page_cache_async_readahead(struct address_space *mapping,
1319 struct file_ra_state *ra,
1320 struct file *filp,
1321 struct page *pg,
1322 pgoff_t offset,
1323 unsigned long size);
1324
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325unsigned long max_sane_readahead(unsigned long nr);
Wu Fengguangd30a1102009-06-16 15:31:30 -07001326unsigned long ra_submit(struct file_ra_state *ra,
1327 struct address_space *mapping,
1328 struct file *filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329
1330/* Do stack extension */
Hugh Dickins46dea3d2005-10-29 18:16:20 -07001331extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
Matthew Wilcox9ab88512005-11-18 16:16:42 -05001332#ifdef CONFIG_IA64
Hugh Dickins46dea3d2005-10-29 18:16:20 -07001333extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
Matthew Wilcox9ab88512005-11-18 16:16:42 -05001334#endif
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001335extern int expand_stack_downwards(struct vm_area_struct *vma,
1336 unsigned long address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
1338/* Look up the first VMA which satisfies addr < vm_end, NULL if none. */
1339extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
1340extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
1341 struct vm_area_struct **pprev);
1342
1343/* Look up the first VMA which intersects the interval start_addr..end_addr-1,
1344 NULL if none. Assume start_addr < end_addr. */
1345static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
1346{
1347 struct vm_area_struct * vma = find_vma(mm,start_addr);
1348
1349 if (vma && end_addr <= vma->vm_start)
1350 vma = NULL;
1351 return vma;
1352}
1353
1354static inline unsigned long vma_pages(struct vm_area_struct *vma)
1355{
1356 return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
1357}
1358
Hugh Dickins804af2c2006-07-26 21:39:49 +01001359pgprot_t vm_get_page_prot(unsigned long vm_flags);
Hugh Dickinsdeceb6c2005-10-29 18:16:33 -07001360struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
Hugh Dickinsdeceb6c2005-10-29 18:16:33 -07001361int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
1362 unsigned long pfn, unsigned long size, pgprot_t);
Linus Torvaldsa145dd42005-11-30 09:35:19 -08001363int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
Nick Piggine0dc0d82007-02-12 00:51:36 -08001364int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
1365 unsigned long pfn);
Nick Piggin423bad62008-04-28 02:13:01 -07001366int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
1367 unsigned long pfn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
Linus Torvalds6aab3412005-11-28 14:34:23 -08001369struct page *follow_page(struct vm_area_struct *, unsigned long address,
Hugh Dickinsdeceb6c2005-10-29 18:16:33 -07001370 unsigned int foll_flags);
1371#define FOLL_WRITE 0x01 /* check pte is writable */
1372#define FOLL_TOUCH 0x02 /* mark page accessed */
1373#define FOLL_GET 0x04 /* do get_page on page */
Hugh Dickins8e4b9a62009-09-21 17:03:26 -07001374#define FOLL_DUMP 0x08 /* give error on hole if it would be zero */
Hugh Dickins58fa8792009-09-21 17:03:31 -07001375#define FOLL_FORCE 0x10 /* get_user_pages read/write w/o permission */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
Martin Schwidefsky2f569af2008-02-08 04:22:04 -08001377typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr,
Jeremy Fitzhardingeaee16b32007-05-06 14:48:54 -07001378 void *data);
1379extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
1380 unsigned long size, pte_fn_t fn, void *data);
1381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382#ifdef CONFIG_PROC_FS
Hugh Dickinsab50b8e2005-10-29 18:15:56 -07001383void vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384#else
Hugh Dickinsab50b8e2005-10-29 18:15:56 -07001385static inline void vm_stat_account(struct mm_struct *mm,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 unsigned long flags, struct file *file, long pages)
1387{
1388}
1389#endif /* CONFIG_PROC_FS */
1390
Ingo Molnar12d6f212008-01-30 13:33:58 +01001391#ifdef CONFIG_DEBUG_PAGEALLOC
1392extern int debug_pagealloc_enabled;
1393
1394extern void kernel_map_pages(struct page *page, int numpages, int enable);
1395
1396static inline void enable_debug_pagealloc(void)
1397{
1398 debug_pagealloc_enabled = 1;
1399}
Rafael J. Wysocki8a235ef2008-02-20 01:47:44 +01001400#ifdef CONFIG_HIBERNATION
1401extern bool kernel_page_present(struct page *page);
1402#endif /* CONFIG_HIBERNATION */
Ingo Molnar12d6f212008-01-30 13:33:58 +01001403#else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404static inline void
Nick Piggin9858db52006-10-11 01:21:30 -07001405kernel_map_pages(struct page *page, int numpages, int enable) {}
Ingo Molnar12d6f212008-01-30 13:33:58 +01001406static inline void enable_debug_pagealloc(void)
1407{
1408}
Rafael J. Wysocki8a235ef2008-02-20 01:47:44 +01001409#ifdef CONFIG_HIBERNATION
1410static inline bool kernel_page_present(struct page *page) { return true; }
1411#endif /* CONFIG_HIBERNATION */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412#endif
1413
1414extern struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
1415#ifdef __HAVE_ARCH_GATE_AREA
1416int in_gate_area_no_task(unsigned long addr);
1417int in_gate_area(struct task_struct *task, unsigned long addr);
1418#else
1419int in_gate_area_no_task(unsigned long addr);
1420#define in_gate_area(task, addr) ({(void)task; in_gate_area_no_task(addr);})
1421#endif /* __HAVE_ARCH_GATE_AREA */
1422
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001423int drop_caches_sysctl_handler(struct ctl_table *, int,
Andrew Morton9d0243b2006-01-08 01:00:39 -08001424 void __user *, size_t *, loff_t *);
Andrew Morton69e05942006-03-22 00:08:19 -08001425unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
Andrew Morton9d0243b2006-01-08 01:00:39 -08001426 unsigned long lru_pages);
Andrew Morton9d0243b2006-01-08 01:00:39 -08001427
Luke Yang7a9166e2006-02-20 18:28:07 -08001428#ifndef CONFIG_MMU
1429#define randomize_va_space 0
1430#else
Andi Kleena62eaf12006-02-16 23:41:58 +01001431extern int randomize_va_space;
Luke Yang7a9166e2006-02-20 18:28:07 -08001432#endif
Andi Kleena62eaf12006-02-16 23:41:58 +01001433
Sam Ravnborg045e72a2007-07-26 10:41:13 -07001434const char * arch_vma_name(struct vm_area_struct *vma);
Andi Kleen03252912008-01-30 13:33:18 +01001435void print_vma_addr(char *prefix, unsigned long rip);
Ingo Molnare6e54942006-06-27 02:53:50 -07001436
Yinghai Lu9bdac912010-02-10 01:20:22 -08001437void sparse_mem_maps_populate_node(struct page **map_map,
1438 unsigned long pnum_begin,
1439 unsigned long pnum_end,
1440 unsigned long map_count,
1441 int nodeid);
1442
Yasunori Goto98f3cfc2007-10-16 01:26:14 -07001443struct page *sparse_mem_map_populate(unsigned long pnum, int nid);
Andy Whitcroft29c71112007-10-16 01:24:14 -07001444pgd_t *vmemmap_pgd_populate(unsigned long addr, int node);
1445pud_t *vmemmap_pud_populate(pgd_t *pgd, unsigned long addr, int node);
1446pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node);
1447pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node);
Christoph Lameter8f6aac42007-10-16 01:24:13 -07001448void *vmemmap_alloc_block(unsigned long size, int node);
Yinghai Lu9bdac912010-02-10 01:20:22 -08001449void *vmemmap_alloc_block_buf(unsigned long size, int node);
Christoph Lameter8f6aac42007-10-16 01:24:13 -07001450void vmemmap_verify(pte_t *, int, unsigned long, unsigned long);
Andy Whitcroft29c71112007-10-16 01:24:14 -07001451int vmemmap_populate_basepages(struct page *start_page,
1452 unsigned long pages, int node);
1453int vmemmap_populate(struct page *start_page, unsigned long pages, int node);
Yinghai Luc2b91e22008-04-12 01:19:24 -07001454void vmemmap_populate_print_last(void);
Christoph Lameter8f6aac42007-10-16 01:24:13 -07001455
Andi Kleen6a460792009-09-16 11:50:15 +02001456
Andi Kleen82ba0112009-12-16 12:19:57 +01001457enum mf_flags {
1458 MF_COUNT_INCREASED = 1 << 0,
1459};
Andi Kleen6a460792009-09-16 11:50:15 +02001460extern void memory_failure(unsigned long pfn, int trapno);
Andi Kleen82ba0112009-12-16 12:19:57 +01001461extern int __memory_failure(unsigned long pfn, int trapno, int flags);
Wu Fengguang847ce402009-12-16 12:19:58 +01001462extern int unpoison_memory(unsigned long pfn);
Andi Kleen6a460792009-09-16 11:50:15 +02001463extern int sysctl_memory_failure_early_kill;
1464extern int sysctl_memory_failure_recovery;
Andi Kleenfacb6012009-12-16 12:20:00 +01001465extern void shake_page(struct page *p, int access);
Andi Kleen6a460792009-09-16 11:50:15 +02001466extern atomic_long_t mce_bad_pages;
Andi Kleenfacb6012009-12-16 12:20:00 +01001467extern int soft_offline_page(struct page *page, int flags);
Andi Kleen6a460792009-09-16 11:50:15 +02001468
Wu Fengguang718a3822010-03-10 15:20:43 -08001469extern void dump_page(struct page *page);
1470
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471#endif /* __KERNEL__ */
1472#endif /* _LINUX_MM_H */