mm.h 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050
  1. #ifndef _LINUX_MM_H
  2. #define _LINUX_MM_H
  3. #include <linux/sched.h>
  4. #include <linux/errno.h>
  5. #ifdef __KERNEL__
  6. #include <linux/config.h>
  7. #include <linux/gfp.h>
  8. #include <linux/list.h>
  9. #include <linux/mmzone.h>
  10. #include <linux/rbtree.h>
  11. #include <linux/prio_tree.h>
  12. #include <linux/fs.h>
  13. struct mempolicy;
  14. struct anon_vma;
  15. #ifndef CONFIG_DISCONTIGMEM /* Don't use mapnrs, do it properly */
  16. extern unsigned long max_mapnr;
  17. #endif
  18. extern unsigned long num_physpages;
  19. extern void * high_memory;
  20. extern unsigned long vmalloc_earlyreserve;
  21. extern int page_cluster;
  22. #ifdef CONFIG_SYSCTL
  23. extern int sysctl_legacy_va_layout;
  24. #else
  25. #define sysctl_legacy_va_layout 0
  26. #endif
  27. #include <asm/page.h>
  28. #include <asm/pgtable.h>
  29. #include <asm/processor.h>
  30. #include <asm/atomic.h>
  31. #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n))
  32. /*
  33. * Linux kernel virtual memory manager primitives.
  34. * The idea being to have a "virtual" mm in the same way
  35. * we have a virtual fs - giving a cleaner interface to the
  36. * mm details, and allowing different kinds of memory mappings
  37. * (from shared memory to executable loading to arbitrary
  38. * mmap() functions).
  39. */
  40. /*
  41. * This struct defines a memory VMM memory area. There is one of these
  42. * per VM-area/task. A VM area is any part of the process virtual memory
  43. * space that has a special rule for the page-fault handlers (ie a shared
  44. * library, the executable area etc).
  45. */
  46. struct vm_area_struct {
  47. struct mm_struct * vm_mm; /* The address space we belong to. */
  48. unsigned long vm_start; /* Our start address within vm_mm. */
  49. unsigned long vm_end; /* The first byte after our end address
  50. within vm_mm. */
  51. /* linked list of VM areas per task, sorted by address */
  52. struct vm_area_struct *vm_next;
  53. pgprot_t vm_page_prot; /* Access permissions of this VMA. */
  54. unsigned long vm_flags; /* Flags, listed below. */
  55. struct rb_node vm_rb;
  56. /*
  57. * For areas with an address space and backing store,
  58. * linkage into the address_space->i_mmap prio tree, or
  59. * linkage to the list of like vmas hanging off its node, or
  60. * linkage of vma in the address_space->i_mmap_nonlinear list.
  61. */
  62. union {
  63. struct {
  64. struct list_head list;
  65. void *parent; /* aligns with prio_tree_node parent */
  66. struct vm_area_struct *head;
  67. } vm_set;
  68. struct raw_prio_tree_node prio_tree_node;
  69. } shared;
  70. /*
  71. * A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
  72. * list, after a COW of one of the file pages. A MAP_SHARED vma
  73. * can only be in the i_mmap tree. An anonymous MAP_PRIVATE, stack
  74. * or brk vma (with NULL file) can only be in an anon_vma list.
  75. */
  76. struct list_head anon_vma_node; /* Serialized by anon_vma->lock */
  77. struct anon_vma *anon_vma; /* Serialized by page_table_lock */
  78. /* Function pointers to deal with this struct. */
  79. struct vm_operations_struct * vm_ops;
  80. /* Information about our backing store: */
  81. unsigned long vm_pgoff; /* Offset (within vm_file) in PAGE_SIZE
  82. units, *not* PAGE_CACHE_SIZE */
  83. struct file * vm_file; /* File we map to (can be NULL). */
  84. void * vm_private_data; /* was vm_pte (shared mem) */
  85. unsigned long vm_truncate_count;/* truncate_count or restart_addr */
  86. #ifndef CONFIG_MMU
  87. atomic_t vm_usage; /* refcount (VMAs shared if !MMU) */
  88. #endif
  89. #ifdef CONFIG_NUMA
  90. struct mempolicy *vm_policy; /* NUMA policy for the VMA */
  91. #endif
  92. };
  93. /*
  94. * This struct defines the per-mm list of VMAs for uClinux. If CONFIG_MMU is
  95. * disabled, then there's a single shared list of VMAs maintained by the
  96. * system, and mm's subscribe to these individually
  97. */
  98. struct vm_list_struct {
  99. struct vm_list_struct *next;
  100. struct vm_area_struct *vma;
  101. };
  102. #ifndef CONFIG_MMU
  103. extern struct rb_root nommu_vma_tree;
  104. extern struct rw_semaphore nommu_vma_sem;
  105. extern unsigned int kobjsize(const void *objp);
  106. #endif
  107. /*
  108. * vm_flags..
  109. */
  110. #define VM_READ 0x00000001 /* currently active flags */
  111. #define VM_WRITE 0x00000002
  112. #define VM_EXEC 0x00000004
  113. #define VM_SHARED 0x00000008
  114. /* mprotect() hardcodes VM_MAYREAD >> 4 == VM_READ, and so for r/w/x bits. */
  115. #define VM_MAYREAD 0x00000010 /* limits for mprotect() etc */
  116. #define VM_MAYWRITE 0x00000020
  117. #define VM_MAYEXEC 0x00000040
  118. #define VM_MAYSHARE 0x00000080
  119. #define VM_GROWSDOWN 0x00000100 /* general info on the segment */
  120. #define VM_GROWSUP 0x00000200
  121. #define VM_SHM 0x00000000 /* Means nothing: delete it later */
  122. #define VM_PFNMAP 0x00000400 /* Page-ranges managed without "struct page", just pure PFN */
  123. #define VM_DENYWRITE 0x00000800 /* ETXTBSY on write attempts.. */
  124. #define VM_EXECUTABLE 0x00001000
  125. #define VM_LOCKED 0x00002000
  126. #define VM_IO 0x00004000 /* Memory mapped I/O or similar */
  127. /* Used by sys_madvise() */
  128. #define VM_SEQ_READ 0x00008000 /* App will access data sequentially */
  129. #define VM_RAND_READ 0x00010000 /* App will not benefit from clustered reads */
  130. #define VM_DONTCOPY 0x00020000 /* Do not copy this vma on fork */
  131. #define VM_DONTEXPAND 0x00040000 /* Cannot expand with mremap() */
  132. #define VM_RESERVED 0x00080000 /* Count as reserved_vm like IO */
  133. #define VM_ACCOUNT 0x00100000 /* Is a VM accounted object */
  134. #define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */
  135. #define VM_NONLINEAR 0x00800000 /* Is non-linear (remap_file_pages) */
  136. #define VM_MAPPED_COPY 0x01000000 /* T if mapped copy of data (nommu mmap) */
  137. #define VM_INSERTPAGE 0x02000000 /* The vma has had "vm_insert_page()" done on it */
  138. #ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */
  139. #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
  140. #endif
  141. #ifdef CONFIG_STACK_GROWSUP
  142. #define VM_STACK_FLAGS (VM_GROWSUP | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
  143. #else
  144. #define VM_STACK_FLAGS (VM_GROWSDOWN | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
  145. #endif
  146. #define VM_READHINTMASK (VM_SEQ_READ | VM_RAND_READ)
  147. #define VM_ClearReadHint(v) (v)->vm_flags &= ~VM_READHINTMASK
  148. #define VM_NormalReadHint(v) (!((v)->vm_flags & VM_READHINTMASK))
  149. #define VM_SequentialReadHint(v) ((v)->vm_flags & VM_SEQ_READ)
  150. #define VM_RandomReadHint(v) ((v)->vm_flags & VM_RAND_READ)
  151. /*
  152. * mapping from the currently active vm_flags protection bits (the
  153. * low four bits) to a page protection mask..
  154. */
  155. extern pgprot_t protection_map[16];
  156. /*
  157. * These are the virtual MM functions - opening of an area, closing and
  158. * unmapping it (needed to keep files on disk up-to-date etc), pointer
  159. * to the functions called when a no-page or a wp-page exception occurs.
  160. */
  161. struct vm_operations_struct {
  162. void (*open)(struct vm_area_struct * area);
  163. void (*close)(struct vm_area_struct * area);
  164. struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int *type);
  165. int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);
  166. #ifdef CONFIG_NUMA
  167. int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
  168. struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
  169. unsigned long addr);
  170. #endif
  171. };
  172. struct mmu_gather;
  173. struct inode;
  174. /*
  175. * Each physical page in the system has a struct page associated with
  176. * it to keep track of whatever it is we are using the page for at the
  177. * moment. Note that we have no way to track which tasks are using
  178. * a page.
  179. */
  180. struct page {
  181. unsigned long flags; /* Atomic flags, some possibly
  182. * updated asynchronously */
  183. atomic_t _count; /* Usage count, see below. */
  184. atomic_t _mapcount; /* Count of ptes mapped in mms,
  185. * to show when page is mapped
  186. * & limit reverse map searches.
  187. */
  188. union {
  189. struct {
  190. unsigned long private; /* Mapping-private opaque data:
  191. * usually used for buffer_heads
  192. * if PagePrivate set; used for
  193. * swp_entry_t if PageSwapCache.
  194. * When page is free, this
  195. * indicates order in the buddy
  196. * system.
  197. */
  198. struct address_space *mapping; /* If low bit clear, points to
  199. * inode address_space, or NULL.
  200. * If page mapped as anonymous
  201. * memory, low bit is set, and
  202. * it points to anon_vma object:
  203. * see PAGE_MAPPING_ANON below.
  204. */
  205. };
  206. #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
  207. spinlock_t ptl;
  208. #endif
  209. };
  210. pgoff_t index; /* Our offset within mapping. */
  211. struct list_head lru; /* Pageout list, eg. active_list
  212. * protected by zone->lru_lock !
  213. */
  214. /*
  215. * On machines where all RAM is mapped into kernel address space,
  216. * we can simply calculate the virtual address. On machines with
  217. * highmem some memory is mapped into kernel virtual memory
  218. * dynamically, so we need a place to store that address.
  219. * Note that this field could be 16 bits on x86 ... ;)
  220. *
  221. * Architectures with slow multiplication can define
  222. * WANT_PAGE_VIRTUAL in asm/page.h
  223. */
  224. #if defined(WANT_PAGE_VIRTUAL)
  225. void *virtual; /* Kernel virtual address (NULL if
  226. not kmapped, ie. highmem) */
  227. #endif /* WANT_PAGE_VIRTUAL */
  228. };
  229. #define page_private(page) ((page)->private)
  230. #define set_page_private(page, v) ((page)->private = (v))
  231. /*
  232. * FIXME: take this include out, include page-flags.h in
  233. * files which need it (119 of them)
  234. */
  235. #include <linux/page-flags.h>
  236. /*
  237. * Methods to modify the page usage count.
  238. *
  239. * What counts for a page usage:
  240. * - cache mapping (page->mapping)
  241. * - private data (page->private)
  242. * - page mapped in a task's page tables, each mapping
  243. * is counted separately
  244. *
  245. * Also, many kernel routines increase the page count before a critical
  246. * routine so they can be sure the page doesn't go away from under them.
  247. *
  248. * Since 2.6.6 (approx), a free page has ->_count = -1. This is so that we
  249. * can use atomic_add_negative(-1, page->_count) to detect when the page
  250. * becomes free and so that we can also use atomic_inc_and_test to atomically
  251. * detect when we just tried to grab a ref on a page which some other CPU has
  252. * already deemed to be freeable.
  253. *
  254. * NO code should make assumptions about this internal detail! Use the provided
  255. * macros which retain the old rules: page_count(page) == 0 is a free page.
  256. */
  257. /*
  258. * Drop a ref, return true if the logical refcount fell to zero (the page has
  259. * no users)
  260. */
  261. #define put_page_testzero(p) \
  262. ({ \
  263. BUG_ON(page_count(p) == 0); \
  264. atomic_add_negative(-1, &(p)->_count); \
  265. })
  266. /*
  267. * Grab a ref, return true if the page previously had a logical refcount of
  268. * zero. ie: returns true if we just grabbed an already-deemed-to-be-free page
  269. */
  270. #define get_page_testone(p) atomic_inc_and_test(&(p)->_count)
  271. #define set_page_count(p,v) atomic_set(&(p)->_count, (v) - 1)
  272. #define __put_page(p) atomic_dec(&(p)->_count)
  273. extern void FASTCALL(__page_cache_release(struct page *));
  274. static inline int page_count(struct page *page)
  275. {
  276. if (PageCompound(page))
  277. page = (struct page *)page_private(page);
  278. return atomic_read(&page->_count) + 1;
  279. }
  280. static inline void get_page(struct page *page)
  281. {
  282. if (unlikely(PageCompound(page)))
  283. page = (struct page *)page_private(page);
  284. atomic_inc(&page->_count);
  285. }
  286. void put_page(struct page *page);
  287. /*
  288. * Multiple processes may "see" the same page. E.g. for untouched
  289. * mappings of /dev/null, all processes see the same page full of
  290. * zeroes, and text pages of executables and shared libraries have
  291. * only one copy in memory, at most, normally.
  292. *
  293. * For the non-reserved pages, page_count(page) denotes a reference count.
  294. * page_count() == 0 means the page is free. page->lru is then used for
  295. * freelist management in the buddy allocator.
  296. * page_count() == 1 means the page is used for exactly one purpose
  297. * (e.g. a private data page of one process).
  298. *
  299. * A page may be used for kmalloc() or anyone else who does a
  300. * __get_free_page(). In this case the page_count() is at least 1, and
  301. * all other fields are unused but should be 0 or NULL. The
  302. * management of this page is the responsibility of the one who uses
  303. * it.
  304. *
  305. * The other pages (we may call them "process pages") are completely
  306. * managed by the Linux memory manager: I/O, buffers, swapping etc.
  307. * The following discussion applies only to them.
  308. *
  309. * A page may belong to an inode's memory mapping. In this case,
  310. * page->mapping is the pointer to the inode, and page->index is the
  311. * file offset of the page, in units of PAGE_CACHE_SIZE.
  312. *
  313. * A page contains an opaque `private' member, which belongs to the
  314. * page's address_space. Usually, this is the address of a circular
  315. * list of the page's disk buffers.
  316. *
  317. * For pages belonging to inodes, the page_count() is the number of
  318. * attaches, plus 1 if `private' contains something, plus one for
  319. * the page cache itself.
  320. *
  321. * Instead of keeping dirty/clean pages in per address-space lists, we instead
  322. * now tag pages as dirty/under writeback in the radix tree.
  323. *
  324. * There is also a per-mapping radix tree mapping index to the page
  325. * in memory if present. The tree is rooted at mapping->root.
  326. *
  327. * All process pages can do I/O:
  328. * - inode pages may need to be read from disk,
  329. * - inode pages which have been modified and are MAP_SHARED may need
  330. * to be written to disk,
  331. * - private pages which have been modified may need to be swapped out
  332. * to swap space and (later) to be read back into memory.
  333. */
  334. /*
  335. * The zone field is never updated after free_area_init_core()
  336. * sets it, so none of the operations on it need to be atomic.
  337. */
  338. /*
  339. * page->flags layout:
  340. *
  341. * There are three possibilities for how page->flags get
  342. * laid out. The first is for the normal case, without
  343. * sparsemem. The second is for sparsemem when there is
  344. * plenty of space for node and section. The last is when
  345. * we have run out of space and have to fall back to an
  346. * alternate (slower) way of determining the node.
  347. *
  348. * No sparsemem: | NODE | ZONE | ... | FLAGS |
  349. * with space for node: | SECTION | NODE | ZONE | ... | FLAGS |
  350. * no space for node: | SECTION | ZONE | ... | FLAGS |
  351. */
  352. #ifdef CONFIG_SPARSEMEM
  353. #define SECTIONS_WIDTH SECTIONS_SHIFT
  354. #else
  355. #define SECTIONS_WIDTH 0
  356. #endif
  357. #define ZONES_WIDTH ZONES_SHIFT
  358. #if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= FLAGS_RESERVED
  359. #define NODES_WIDTH NODES_SHIFT
  360. #else
  361. #define NODES_WIDTH 0
  362. #endif
  363. /* Page flags: | [SECTION] | [NODE] | ZONE | ... | FLAGS | */
  364. #define SECTIONS_PGOFF ((sizeof(unsigned long)*8) - SECTIONS_WIDTH)
  365. #define NODES_PGOFF (SECTIONS_PGOFF - NODES_WIDTH)
  366. #define ZONES_PGOFF (NODES_PGOFF - ZONES_WIDTH)
  367. /*
  368. * We are going to use the flags for the page to node mapping if its in
  369. * there. This includes the case where there is no node, so it is implicit.
  370. */
  371. #define FLAGS_HAS_NODE (NODES_WIDTH > 0 || NODES_SHIFT == 0)
  372. #ifndef PFN_SECTION_SHIFT
  373. #define PFN_SECTION_SHIFT 0
  374. #endif
  375. /*
  376. * Define the bit shifts to access each section. For non-existant
  377. * sections we define the shift as 0; that plus a 0 mask ensures
  378. * the compiler will optimise away reference to them.
  379. */
  380. #define SECTIONS_PGSHIFT (SECTIONS_PGOFF * (SECTIONS_WIDTH != 0))
  381. #define NODES_PGSHIFT (NODES_PGOFF * (NODES_WIDTH != 0))
  382. #define ZONES_PGSHIFT (ZONES_PGOFF * (ZONES_WIDTH != 0))
  383. /* NODE:ZONE or SECTION:ZONE is used to lookup the zone from a page. */
  384. #if FLAGS_HAS_NODE
  385. #define ZONETABLE_SHIFT (NODES_SHIFT + ZONES_SHIFT)
  386. #else
  387. #define ZONETABLE_SHIFT (SECTIONS_SHIFT + ZONES_SHIFT)
  388. #endif
  389. #define ZONETABLE_PGSHIFT ZONES_PGSHIFT
  390. #if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > FLAGS_RESERVED
  391. #error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > FLAGS_RESERVED
  392. #endif
  393. #define ZONES_MASK ((1UL << ZONES_WIDTH) - 1)
  394. #define NODES_MASK ((1UL << NODES_WIDTH) - 1)
  395. #define SECTIONS_MASK ((1UL << SECTIONS_WIDTH) - 1)
  396. #define ZONETABLE_MASK ((1UL << ZONETABLE_SHIFT) - 1)
  397. static inline unsigned long page_zonenum(struct page *page)
  398. {
  399. return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
  400. }
  401. struct zone;
  402. extern struct zone *zone_table[];
  403. static inline struct zone *page_zone(struct page *page)
  404. {
  405. return zone_table[(page->flags >> ZONETABLE_PGSHIFT) &
  406. ZONETABLE_MASK];
  407. }
  408. static inline unsigned long page_to_nid(struct page *page)
  409. {
  410. if (FLAGS_HAS_NODE)
  411. return (page->flags >> NODES_PGSHIFT) & NODES_MASK;
  412. else
  413. return page_zone(page)->zone_pgdat->node_id;
  414. }
  415. static inline unsigned long page_to_section(struct page *page)
  416. {
  417. return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
  418. }
  419. static inline void set_page_zone(struct page *page, unsigned long zone)
  420. {
  421. page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);
  422. page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;
  423. }
  424. static inline void set_page_node(struct page *page, unsigned long node)
  425. {
  426. page->flags &= ~(NODES_MASK << NODES_PGSHIFT);
  427. page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
  428. }
  429. static inline void set_page_section(struct page *page, unsigned long section)
  430. {
  431. page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
  432. page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
  433. }
  434. static inline void set_page_links(struct page *page, unsigned long zone,
  435. unsigned long node, unsigned long pfn)
  436. {
  437. set_page_zone(page, zone);
  438. set_page_node(page, node);
  439. set_page_section(page, pfn_to_section_nr(pfn));
  440. }
  441. #ifndef CONFIG_DISCONTIGMEM
  442. /* The array of struct pages - for discontigmem use pgdat->lmem_map */
  443. extern struct page *mem_map;
  444. #endif
  445. static inline void *lowmem_page_address(struct page *page)
  446. {
  447. return __va(page_to_pfn(page) << PAGE_SHIFT);
  448. }
  449. #if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL)
  450. #define HASHED_PAGE_VIRTUAL
  451. #endif
  452. #if defined(WANT_PAGE_VIRTUAL)
  453. #define page_address(page) ((page)->virtual)
  454. #define set_page_address(page, address) \
  455. do { \
  456. (page)->virtual = (address); \
  457. } while(0)
  458. #define page_address_init() do { } while(0)
  459. #endif
  460. #if defined(HASHED_PAGE_VIRTUAL)
  461. void *page_address(struct page *page);
  462. void set_page_address(struct page *page, void *virtual);
  463. void page_address_init(void);
  464. #endif
  465. #if !defined(HASHED_PAGE_VIRTUAL) && !defined(WANT_PAGE_VIRTUAL)
  466. #define page_address(page) lowmem_page_address(page)
  467. #define set_page_address(page, address) do { } while(0)
  468. #define page_address_init() do { } while(0)
  469. #endif
  470. /*
  471. * On an anonymous page mapped into a user virtual memory area,
  472. * page->mapping points to its anon_vma, not to a struct address_space;
  473. * with the PAGE_MAPPING_ANON bit set to distinguish it.
  474. *
  475. * Please note that, confusingly, "page_mapping" refers to the inode
  476. * address_space which maps the page from disk; whereas "page_mapped"
  477. * refers to user virtual address space into which the page is mapped.
  478. */
  479. #define PAGE_MAPPING_ANON 1
  480. extern struct address_space swapper_space;
  481. static inline struct address_space *page_mapping(struct page *page)
  482. {
  483. struct address_space *mapping = page->mapping;
  484. if (unlikely(PageSwapCache(page)))
  485. mapping = &swapper_space;
  486. else if (unlikely((unsigned long)mapping & PAGE_MAPPING_ANON))
  487. mapping = NULL;
  488. return mapping;
  489. }
  490. static inline int PageAnon(struct page *page)
  491. {
  492. return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
  493. }
  494. /*
  495. * Return the pagecache index of the passed page. Regular pagecache pages
  496. * use ->index whereas swapcache pages use ->private
  497. */
  498. static inline pgoff_t page_index(struct page *page)
  499. {
  500. if (unlikely(PageSwapCache(page)))
  501. return page_private(page);
  502. return page->index;
  503. }
  504. /*
  505. * The atomic page->_mapcount, like _count, starts from -1:
  506. * so that transitions both from it and to it can be tracked,
  507. * using atomic_inc_and_test and atomic_add_negative(-1).
  508. */
  509. static inline void reset_page_mapcount(struct page *page)
  510. {
  511. atomic_set(&(page)->_mapcount, -1);
  512. }
  513. static inline int page_mapcount(struct page *page)
  514. {
  515. return atomic_read(&(page)->_mapcount) + 1;
  516. }
  517. /*
  518. * Return true if this page is mapped into pagetables.
  519. */
  520. static inline int page_mapped(struct page *page)
  521. {
  522. return atomic_read(&(page)->_mapcount) >= 0;
  523. }
  524. /*
  525. * Error return values for the *_nopage functions
  526. */
  527. #define NOPAGE_SIGBUS (NULL)
  528. #define NOPAGE_OOM ((struct page *) (-1))
  529. /*
  530. * Different kinds of faults, as returned by handle_mm_fault().
  531. * Used to decide whether a process gets delivered SIGBUS or
  532. * just gets major/minor fault counters bumped up.
  533. */
  534. #define VM_FAULT_OOM 0x00
  535. #define VM_FAULT_SIGBUS 0x01
  536. #define VM_FAULT_MINOR 0x02
  537. #define VM_FAULT_MAJOR 0x03
  538. /*
  539. * Special case for get_user_pages.
  540. * Must be in a distinct bit from the above VM_FAULT_ flags.
  541. */
  542. #define VM_FAULT_WRITE 0x10
  543. #define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)
  544. extern void show_free_areas(void);
  545. #ifdef CONFIG_SHMEM
  546. struct page *shmem_nopage(struct vm_area_struct *vma,
  547. unsigned long address, int *type);
  548. int shmem_set_policy(struct vm_area_struct *vma, struct mempolicy *new);
  549. struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
  550. unsigned long addr);
  551. int shmem_lock(struct file *file, int lock, struct user_struct *user);
  552. #else
  553. #define shmem_nopage filemap_nopage
  554. static inline int shmem_lock(struct file *file, int lock,
  555. struct user_struct *user)
  556. {
  557. return 0;
  558. }
  559. static inline int shmem_set_policy(struct vm_area_struct *vma,
  560. struct mempolicy *new)
  561. {
  562. return 0;
  563. }
  564. static inline struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
  565. unsigned long addr)
  566. {
  567. return NULL;
  568. }
  569. #endif
  570. struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
  571. extern int shmem_mmap(struct file *file, struct vm_area_struct *vma);
  572. int shmem_zero_setup(struct vm_area_struct *);
  573. #ifndef CONFIG_MMU
  574. extern unsigned long shmem_get_unmapped_area(struct file *file,
  575. unsigned long addr,
  576. unsigned long len,
  577. unsigned long pgoff,
  578. unsigned long flags);
  579. #endif
  580. static inline int can_do_mlock(void)
  581. {
  582. if (capable(CAP_IPC_LOCK))
  583. return 1;
  584. if (current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur != 0)
  585. return 1;
  586. return 0;
  587. }
  588. extern int user_shm_lock(size_t, struct user_struct *);
  589. extern void user_shm_unlock(size_t, struct user_struct *);
  590. /*
  591. * Parameter block passed down to zap_pte_range in exceptional cases.
  592. */
  593. struct zap_details {
  594. struct vm_area_struct *nonlinear_vma; /* Check page->index if set */
  595. struct address_space *check_mapping; /* Check page->mapping if set */
  596. pgoff_t first_index; /* Lowest page->index to unmap */
  597. pgoff_t last_index; /* Highest page->index to unmap */
  598. spinlock_t *i_mmap_lock; /* For unmap_mapping_range: */
  599. unsigned long truncate_count; /* Compare vm_truncate_count */
  600. };
  601. struct page *vm_normal_page(struct vm_area_struct *, unsigned long, pte_t);
  602. unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
  603. unsigned long size, struct zap_details *);
  604. unsigned long unmap_vmas(struct mmu_gather **tlb,
  605. struct vm_area_struct *start_vma, unsigned long start_addr,
  606. unsigned long end_addr, unsigned long *nr_accounted,
  607. struct zap_details *);
  608. void free_pgd_range(struct mmu_gather **tlb, unsigned long addr,
  609. unsigned long end, unsigned long floor, unsigned long ceiling);
  610. void free_pgtables(struct mmu_gather **tlb, struct vm_area_struct *start_vma,
  611. unsigned long floor, unsigned long ceiling);
  612. int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
  613. struct vm_area_struct *vma);
  614. int zeromap_page_range(struct vm_area_struct *vma, unsigned long from,
  615. unsigned long size, pgprot_t prot);
  616. void unmap_mapping_range(struct address_space *mapping,
  617. loff_t const holebegin, loff_t const holelen, int even_cows);
  618. static inline void unmap_shared_mapping_range(struct address_space *mapping,
  619. loff_t const holebegin, loff_t const holelen)
  620. {
  621. unmap_mapping_range(mapping, holebegin, holelen, 0);
  622. }
  623. extern int vmtruncate(struct inode * inode, loff_t offset);
  624. extern int vmtruncate_range(struct inode * inode, loff_t offset, loff_t end);
  625. extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
  626. extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
  627. #ifdef CONFIG_MMU
  628. extern int __handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma,
  629. unsigned long address, int write_access);
  630. static inline int handle_mm_fault(struct mm_struct *mm,
  631. struct vm_area_struct *vma, unsigned long address,
  632. int write_access)
  633. {
  634. return __handle_mm_fault(mm, vma, address, write_access) &
  635. (~VM_FAULT_WRITE);
  636. }
  637. #else
  638. static inline int handle_mm_fault(struct mm_struct *mm,
  639. struct vm_area_struct *vma, unsigned long address,
  640. int write_access)
  641. {
  642. /* should never happen if there's no MMU */
  643. BUG();
  644. return VM_FAULT_SIGBUS;
  645. }
  646. #endif
  647. extern int make_pages_present(unsigned long addr, unsigned long end);
  648. extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
  649. void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
  650. int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
  651. int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
  652. void print_bad_pte(struct vm_area_struct *, pte_t, unsigned long);
  653. int __set_page_dirty_buffers(struct page *page);
  654. int __set_page_dirty_nobuffers(struct page *page);
  655. int redirty_page_for_writepage(struct writeback_control *wbc,
  656. struct page *page);
  657. int FASTCALL(set_page_dirty(struct page *page));
  658. int set_page_dirty_lock(struct page *page);
  659. int clear_page_dirty_for_io(struct page *page);
  660. extern unsigned long do_mremap(unsigned long addr,
  661. unsigned long old_len, unsigned long new_len,
  662. unsigned long flags, unsigned long new_addr);
  663. /*
  664. * Prototype to add a shrinker callback for ageable caches.
  665. *
  666. * These functions are passed a count `nr_to_scan' and a gfpmask. They should
  667. * scan `nr_to_scan' objects, attempting to free them.
  668. *
  669. * The callback must return the number of objects which remain in the cache.
  670. *
  671. * The callback will be passed nr_to_scan == 0 when the VM is querying the
  672. * cache size, so a fastpath for that case is appropriate.
  673. */
  674. typedef int (*shrinker_t)(int nr_to_scan, gfp_t gfp_mask);
  675. /*
  676. * Add an aging callback. The int is the number of 'seeks' it takes
  677. * to recreate one of the objects that these functions age.
  678. */
  679. #define DEFAULT_SEEKS 2
  680. struct shrinker;
  681. extern struct shrinker *set_shrinker(int, shrinker_t);
  682. extern void remove_shrinker(struct shrinker *shrinker);
  683. extern pte_t *FASTCALL(get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl));
  684. int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
  685. int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address);
  686. int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
  687. int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);
  688. /*
  689. * The following ifdef needed to get the 4level-fixup.h header to work.
  690. * Remove it when 4level-fixup.h has been removed.
  691. */
  692. #if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
  693. static inline pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
  694. {
  695. return (unlikely(pgd_none(*pgd)) && __pud_alloc(mm, pgd, address))?
  696. NULL: pud_offset(pgd, address);
  697. }
  698. static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
  699. {
  700. return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?
  701. NULL: pmd_offset(pud, address);
  702. }
  703. #endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */
  704. #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
  705. /*
  706. * We tuck a spinlock to guard each pagetable page into its struct page,
  707. * at page->private, with BUILD_BUG_ON to make sure that this will not
  708. * overflow into the next struct page (as it might with DEBUG_SPINLOCK).
  709. * When freeing, reset page->mapping so free_pages_check won't complain.
  710. */
  711. #define __pte_lockptr(page) &((page)->ptl)
  712. #define pte_lock_init(_page) do { \
  713. spin_lock_init(__pte_lockptr(_page)); \
  714. } while (0)
  715. #define pte_lock_deinit(page) ((page)->mapping = NULL)
  716. #define pte_lockptr(mm, pmd) ({(void)(mm); __pte_lockptr(pmd_page(*(pmd)));})
  717. #else
  718. /*
  719. * We use mm->page_table_lock to guard all pagetable pages of the mm.
  720. */
  721. #define pte_lock_init(page) do {} while (0)
  722. #define pte_lock_deinit(page) do {} while (0)
  723. #define pte_lockptr(mm, pmd) ({(void)(pmd); &(mm)->page_table_lock;})
  724. #endif /* NR_CPUS < CONFIG_SPLIT_PTLOCK_CPUS */
  725. #define pte_offset_map_lock(mm, pmd, address, ptlp) \
  726. ({ \
  727. spinlock_t *__ptl = pte_lockptr(mm, pmd); \
  728. pte_t *__pte = pte_offset_map(pmd, address); \
  729. *(ptlp) = __ptl; \
  730. spin_lock(__ptl); \
  731. __pte; \
  732. })
  733. #define pte_unmap_unlock(pte, ptl) do { \
  734. spin_unlock(ptl); \
  735. pte_unmap(pte); \
  736. } while (0)
  737. #define pte_alloc_map(mm, pmd, address) \
  738. ((unlikely(!pmd_present(*(pmd))) && __pte_alloc(mm, pmd, address))? \
  739. NULL: pte_offset_map(pmd, address))
  740. #define pte_alloc_map_lock(mm, pmd, address, ptlp) \
  741. ((unlikely(!pmd_present(*(pmd))) && __pte_alloc(mm, pmd, address))? \
  742. NULL: pte_offset_map_lock(mm, pmd, address, ptlp))
  743. #define pte_alloc_kernel(pmd, address) \
  744. ((unlikely(!pmd_present(*(pmd))) && __pte_alloc_kernel(pmd, address))? \
  745. NULL: pte_offset_kernel(pmd, address))
  746. extern void free_area_init(unsigned long * zones_size);
  747. extern void free_area_init_node(int nid, pg_data_t *pgdat,
  748. unsigned long * zones_size, unsigned long zone_start_pfn,
  749. unsigned long *zholes_size);
  750. extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long);
  751. extern void setup_per_zone_pages_min(void);
  752. extern void mem_init(void);
  753. extern void show_mem(void);
  754. extern void si_meminfo(struct sysinfo * val);
  755. extern void si_meminfo_node(struct sysinfo *val, int nid);
  756. #ifdef CONFIG_NUMA
  757. extern void setup_per_cpu_pageset(void);
  758. #else
  759. static inline void setup_per_cpu_pageset(void) {}
  760. #endif
  761. /* prio_tree.c */
  762. void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
  763. void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
  764. void vma_prio_tree_remove(struct vm_area_struct *, struct prio_tree_root *);
  765. struct vm_area_struct *vma_prio_tree_next(struct vm_area_struct *vma,
  766. struct prio_tree_iter *iter);
  767. #define vma_prio_tree_foreach(vma, iter, root, begin, end) \
  768. for (prio_tree_iter_init(iter, root, begin, end), vma = NULL; \
  769. (vma = vma_prio_tree_next(vma, iter)); )
  770. static inline void vma_nonlinear_insert(struct vm_area_struct *vma,
  771. struct list_head *list)
  772. {
  773. vma->shared.vm_set.parent = NULL;
  774. list_add_tail(&vma->shared.vm_set.list, list);
  775. }
  776. /* mmap.c */
  777. extern int __vm_enough_memory(long pages, int cap_sys_admin);
  778. extern void vma_adjust(struct vm_area_struct *vma, unsigned long start,
  779. unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert);
  780. extern struct vm_area_struct *vma_merge(struct mm_struct *,
  781. struct vm_area_struct *prev, unsigned long addr, unsigned long end,
  782. unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t,
  783. struct mempolicy *);
  784. extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
  785. extern int split_vma(struct mm_struct *,
  786. struct vm_area_struct *, unsigned long addr, int new_below);
  787. extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
  788. extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
  789. struct rb_node **, struct rb_node *);
  790. extern void unlink_file_vma(struct vm_area_struct *);
  791. extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
  792. unsigned long addr, unsigned long len, pgoff_t pgoff);
  793. extern void exit_mmap(struct mm_struct *);
  794. extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
  795. extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  796. extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
  797. unsigned long len, unsigned long prot,
  798. unsigned long flag, unsigned long pgoff);
  799. static inline unsigned long do_mmap(struct file *file, unsigned long addr,
  800. unsigned long len, unsigned long prot,
  801. unsigned long flag, unsigned long offset)
  802. {
  803. unsigned long ret = -EINVAL;
  804. if ((offset + PAGE_ALIGN(len)) < offset)
  805. goto out;
  806. if (!(offset & ~PAGE_MASK))
  807. ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
  808. out:
  809. return ret;
  810. }
  811. extern int do_munmap(struct mm_struct *, unsigned long, size_t);
  812. extern unsigned long do_brk(unsigned long, unsigned long);
  813. /* filemap.c */
  814. extern unsigned long page_unuse(struct page *);
  815. extern void truncate_inode_pages(struct address_space *, loff_t);
  816. extern void truncate_inode_pages_range(struct address_space *,
  817. loff_t lstart, loff_t lend);
  818. /* generic vm_area_ops exported for stackable file systems */
  819. extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int *);
  820. extern int filemap_populate(struct vm_area_struct *, unsigned long,
  821. unsigned long, pgprot_t, unsigned long, int);
  822. /* mm/page-writeback.c */
  823. int write_one_page(struct page *page, int wait);
  824. /* readahead.c */
  825. #define VM_MAX_READAHEAD 128 /* kbytes */
  826. #define VM_MIN_READAHEAD 16 /* kbytes (includes current page) */
  827. #define VM_MAX_CACHE_HIT 256 /* max pages in a row in cache before
  828. * turning readahead off */
  829. int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
  830. pgoff_t offset, unsigned long nr_to_read);
  831. int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
  832. pgoff_t offset, unsigned long nr_to_read);
  833. unsigned long page_cache_readahead(struct address_space *mapping,
  834. struct file_ra_state *ra,
  835. struct file *filp,
  836. pgoff_t offset,
  837. unsigned long size);
  838. void handle_ra_miss(struct address_space *mapping,
  839. struct file_ra_state *ra, pgoff_t offset);
  840. unsigned long max_sane_readahead(unsigned long nr);
  841. /* Do stack extension */
  842. extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
  843. #ifdef CONFIG_IA64
  844. extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
  845. #endif
  846. /* Look up the first VMA which satisfies addr < vm_end, NULL if none. */
  847. extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
  848. extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
  849. struct vm_area_struct **pprev);
  850. /* Look up the first VMA which intersects the interval start_addr..end_addr-1,
  851. NULL if none. Assume start_addr < end_addr. */
  852. static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
  853. {
  854. struct vm_area_struct * vma = find_vma(mm,start_addr);
  855. if (vma && end_addr <= vma->vm_start)
  856. vma = NULL;
  857. return vma;
  858. }
  859. static inline unsigned long vma_pages(struct vm_area_struct *vma)
  860. {
  861. return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
  862. }
  863. struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
  864. struct page *vmalloc_to_page(void *addr);
  865. unsigned long vmalloc_to_pfn(void *addr);
  866. int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
  867. unsigned long pfn, unsigned long size, pgprot_t);
  868. int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
  869. struct page *follow_page(struct vm_area_struct *, unsigned long address,
  870. unsigned int foll_flags);
  871. #define FOLL_WRITE 0x01 /* check pte is writable */
  872. #define FOLL_TOUCH 0x02 /* mark page accessed */
  873. #define FOLL_GET 0x04 /* do get_page on page */
  874. #define FOLL_ANON 0x08 /* give ZERO_PAGE if no pgtable */
  875. #ifdef CONFIG_PROC_FS
  876. void vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
  877. #else
  878. static inline void vm_stat_account(struct mm_struct *mm,
  879. unsigned long flags, struct file *file, long pages)
  880. {
  881. }
  882. #endif /* CONFIG_PROC_FS */
  883. #ifndef CONFIG_DEBUG_PAGEALLOC
  884. static inline void
  885. kernel_map_pages(struct page *page, int numpages, int enable)
  886. {
  887. }
  888. #endif
  889. extern struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
  890. #ifdef __HAVE_ARCH_GATE_AREA
  891. int in_gate_area_no_task(unsigned long addr);
  892. int in_gate_area(struct task_struct *task, unsigned long addr);
  893. #else
  894. int in_gate_area_no_task(unsigned long addr);
  895. #define in_gate_area(task, addr) ({(void)task; in_gate_area_no_task(addr);})
  896. #endif /* __HAVE_ARCH_GATE_AREA */
  897. /* /proc/<pid>/oom_adj set to -17 protects from the oom-killer */
  898. #define OOM_DISABLE -17
  899. int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *,
  900. void __user *, size_t *, loff_t *);
  901. int shrink_slab(unsigned long scanned, gfp_t gfp_mask,
  902. unsigned long lru_pages);
  903. void drop_pagecache(void);
  904. void drop_slab(void);
  905. #endif /* __KERNEL__ */
  906. #endif /* _LINUX_MM_H */