[deliverable/linux.git] / include / linux / rmap.h

#ifndef _LINUX_RMAP_H
#define _LINUX_RMAP_H
/*
 * Declarations for Reverse Mapping functions in mm/rmap.c
 */

#include <linux/list.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <linux/memcontrol.h>

/*
 * The anon_vma heads a list of private "related" vmas, to scan if
 * an anonymous page pointing to this anon_vma needs to be unmapped:
 * the vmas on the list will be related by forking, or by splitting.
 *
 * Since vmas come and go as they are split and merged (particularly
 * in mprotect), the mapping field of an anonymous page cannot point
 * directly to a vma: instead it points to an anon_vma, on whose list
 * the related vmas can be easily linked or unlinked.
 *
 * After unlinking the last vma on the list, we must garbage collect
 * the anon_vma object itself: we're guaranteed no page can be
 * pointing to this anon_vma once its vma list is empty.
 */
struct anon_vma {
	spinlock_t lock;	/* Serialize access to vma list */
	/*
	 * NOTE: the LSB of the head.next is set by
	 * mm_take_all_locks() _after_ taking the above lock. So the
	 * head must only be read/written after taking the above lock
	 * to be sure to see a valid next pointer. The LSB bit itself
	 * is serialized by a system wide lock only visible to
	 * mm_take_all_locks() (mm_all_locks_mutex).
	 */
	struct list_head head;	/* List of private "related" vmas */
};

#ifdef CONFIG_MMU

static inline void anon_vma_lock(struct vm_area_struct *vma)
{
	struct anon_vma *anon_vma = vma->anon_vma;
	if (anon_vma)
		spin_lock(&anon_vma->lock);
}

static inline void anon_vma_unlock(struct vm_area_struct *vma)
{
	struct anon_vma *anon_vma = vma->anon_vma;
	if (anon_vma)
		spin_unlock(&anon_vma->lock);
}

/*
 * anon_vma helper functions.
 */
void anon_vma_init(void);	/* create anon_vma_cachep */
int  anon_vma_prepare(struct vm_area_struct *);
void __anon_vma_merge(struct vm_area_struct *, struct vm_area_struct *);
void anon_vma_unlink(struct vm_area_struct *);
void anon_vma_link(struct vm_area_struct *);
void __anon_vma_link(struct vm_area_struct *);

/*
 * rmap interfaces called when adding or removing pte of page
 */
void page_add_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
void page_add_new_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
void page_add_file_rmap(struct page *);
void page_remove_rmap(struct page *);

static inline void page_dup_rmap(struct page *page)
{
	atomic_inc(&page->_mapcount);
}

/*
 * Called from mm/vmscan.c to handle paging out
 */
int page_referenced(struct page *, int is_locked,
			struct mem_cgroup *cnt, unsigned long *vm_flags);
enum ttu_flags {
	TTU_UNMAP = 0,			/* unmap mode */
	TTU_MIGRATION = 1,		/* migration mode */
	TTU_MUNLOCK = 2,		/* munlock mode */
	TTU_ACTION_MASK = 0xff,

	TTU_IGNORE_MLOCK = (1 << 8),	/* ignore mlock */
	TTU_IGNORE_ACCESS = (1 << 9),	/* don't age */
	TTU_IGNORE_HWPOISON = (1 << 10),/* corrupted page is recoverable */
};
#define TTU_ACTION(x) ((x) & TTU_ACTION_MASK)

int try_to_unmap(struct page *, enum ttu_flags flags);

/*
 * Called from mm/filemap_xip.c to unmap empty zero page
 */
pte_t *page_check_address(struct page *, struct mm_struct *,
				unsigned long, spinlock_t **, int);

/*
 * Used by swapoff to help locate where page is expected in vma.
 */
unsigned long page_address_in_vma(struct page *, struct vm_area_struct *);

/*
 * Cleans the PTEs of shared mappings.
 * (and since clean PTEs should also be readonly, write protects them too)
 *
 * returns the number of cleaned PTEs.
 */
int page_mkclean(struct page *);

/*
 * called in munlock()/munmap() path to check for other vmas holding
 * the page mlocked.
 */
int try_to_munlock(struct page *);

/*
 * Called by memory-failure.c to kill processes.
 */
struct anon_vma *page_lock_anon_vma(struct page *page);
void page_unlock_anon_vma(struct anon_vma *anon_vma);
int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma);

#else	/* !CONFIG_MMU */

#define anon_vma_init()		do {} while (0)
#define anon_vma_prepare(vma)	(0)
#define anon_vma_link(vma)	do {} while (0)

static inline int page_referenced(struct page *page, int is_locked,
				  struct mem_cgroup *cnt,
				  unsigned long *vm_flags)
{
	*vm_flags = 0;
	return TestClearPageReferenced(page);
}

#define try_to_unmap(page, refs) SWAP_FAIL

static inline int page_mkclean(struct page *page)
{
	return 0;
}


#endif	/* CONFIG_MMU */

/*
 * Return values of try_to_unmap
 */
#define SWAP_SUCCESS	0
#define SWAP_AGAIN	1
#define SWAP_FAIL	2
#define SWAP_MLOCK	3

#endif	/* _LINUX_RMAP_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _LINUX_RMAP_H
	2	#define _LINUX_RMAP_H
	3	/*
	4	* Declarations for Reverse Mapping functions in mm/rmap.c
	5	*/
	6
1da177e4 LT	7	#include <linux/list.h>
	8	#include <linux/slab.h>
	9	#include <linux/mm.h>
	10	#include <linux/spinlock.h>
bed7161a	11	#include <linux/memcontrol.h>
1da177e4 LT	12
	13	/*
	14	* The anon_vma heads a list of private "related" vmas, to scan if
	15	* an anonymous page pointing to this anon_vma needs to be unmapped:
	16	* the vmas on the list will be related by forking, or by splitting.
	17	*
	18	* Since vmas come and go as they are split and merged (particularly
	19	* in mprotect), the mapping field of an anonymous page cannot point
	20	* directly to a vma: instead it points to an anon_vma, on whose list
	21	* the related vmas can be easily linked or unlinked.
	22	*
	23	* After unlinking the last vma on the list, we must garbage collect
	24	* the anon_vma object itself: we're guaranteed no page can be
	25	* pointing to this anon_vma once its vma list is empty.
	26	*/
	27	struct anon_vma {
	28	spinlock_t lock; /* Serialize access to vma list */
7906d00c AA	29	/*
	30	* NOTE: the LSB of the head.next is set by
	31	* mm_take_all_locks() _after_ taking the above lock. So the
	32	* head must only be read/written after taking the above lock
	33	* to be sure to see a valid next pointer. The LSB bit itself
	34	* is serialized by a system wide lock only visible to
	35	* mm_take_all_locks() (mm_all_locks_mutex).
	36	*/
1da177e4 LT	37	struct list_head head; /* List of private "related" vmas */
	38	};
	39
	40	#ifdef CONFIG_MMU
	41
1da177e4 LT	42	static inline void anon_vma_lock(struct vm_area_struct *vma)
	43	{
	44	struct anon_vma *anon_vma = vma->anon_vma;
	45	if (anon_vma)
	46	spin_lock(&anon_vma->lock);
	47	}
	48
	49	static inline void anon_vma_unlock(struct vm_area_struct *vma)
	50	{
	51	struct anon_vma *anon_vma = vma->anon_vma;
	52	if (anon_vma)
	53	spin_unlock(&anon_vma->lock);
	54	}
	55
	56	/*
	57	* anon_vma helper functions.
	58	*/
	59	void anon_vma_init(void); /* create anon_vma_cachep */
	60	int anon_vma_prepare(struct vm_area_struct *);
	61	void __anon_vma_merge(struct vm_area_struct , struct vm_area_struct );
	62	void anon_vma_unlink(struct vm_area_struct *);
	63	void anon_vma_link(struct vm_area_struct *);
	64	void __anon_vma_link(struct vm_area_struct *);
	65
	66	/*
	67	* rmap interfaces called when adding or removing pte of page
	68	*/
	69	void page_add_anon_rmap(struct page , struct vm_area_struct , unsigned long);
9617d95e	70	void page_add_new_anon_rmap(struct page , struct vm_area_struct , unsigned long);
1da177e4	71	void page_add_file_rmap(struct page *);
edc315fd	72	void page_remove_rmap(struct page *);
1da177e4	73
21333b2b	74	static inline void page_dup_rmap(struct page *page)
1da177e4 LT	75	{
	76	atomic_inc(&page->_mapcount);
	77	}
	78
	79	/*
	80	* Called from mm/vmscan.c to handle paging out
	81	*/
6fe6b7e3 WF	82	int page_referenced(struct page *, int is_locked,
6fe6b7e3 WF	83	struct mem_cgroup cnt, unsigned long vm_flags);
14fa31b8 AK	84	enum ttu_flags {
	85	TTU_UNMAP = 0, /* unmap mode */
	86	TTU_MIGRATION = 1, /* migration mode */
	87	TTU_MUNLOCK = 2, /* munlock mode */
	88	TTU_ACTION_MASK = 0xff,
	89
	90	TTU_IGNORE_MLOCK = (1 << 8), /* ignore mlock */
	91	TTU_IGNORE_ACCESS = (1 << 9), /* don't age */
888b9f7c	92	TTU_IGNORE_HWPOISON = (1 << 10),/* corrupted page is recoverable */
14fa31b8 AK	93	};
	94	#define TTU_ACTION(x) ((x) & TTU_ACTION_MASK)
	95
	96	int try_to_unmap(struct page *, enum ttu_flags flags);
1da177e4	97
ceffc078 CO	98	/*
	99	* Called from mm/filemap_xip.c to unmap empty zero page
	100	*/
c0718806	101	pte_t page_check_address(struct page , struct mm_struct *,
479db0bf	102	unsigned long, spinlock_t **, int);
ceffc078	103
1da177e4 LT	104	/*
	105	* Used by swapoff to help locate where page is expected in vma.
	106	*/
	107	unsigned long page_address_in_vma(struct page , struct vm_area_struct );
	108
d08b3851 PZ	109	/*
	110	* Cleans the PTEs of shared mappings.
	111	* (and since clean PTEs should also be readonly, write protects them too)
	112	*
	113	* returns the number of cleaned PTEs.
	114	*/
	115	int page_mkclean(struct page *);
	116
b291f000 NP	117	/*
	118	* called in munlock()/munmap() path to check for other vmas holding
	119	* the page mlocked.
	120	*/
	121	int try_to_munlock(struct page *);
b291f000	122
10be22df AK	123	/*
	124	* Called by memory-failure.c to kill processes.
	125	*/
	126	struct anon_vma page_lock_anon_vma(struct page page);
	127	void page_unlock_anon_vma(struct anon_vma *anon_vma);
6a46079c	128	int page_mapped_in_vma(struct page page, struct vm_area_struct vma);
10be22df	129
1da177e4 LT	130	#else /* !CONFIG_MMU */
	131
	132	#define anon_vma_init() do {} while (0)
	133	#define anon_vma_prepare(vma) (0)
	134	#define anon_vma_link(vma) do {} while (0)
	135
01ff53f4 MF	136	static inline int page_referenced(struct page *page, int is_locked,
	137	struct mem_cgroup *cnt,
	138	unsigned long *vm_flags)
	139	{
	140	*vm_flags = 0;
	141	return TestClearPageReferenced(page);
	142	}
	143
a48d07af	144	#define try_to_unmap(page, refs) SWAP_FAIL
1da177e4	145
d08b3851 PZ	146	static inline int page_mkclean(struct page *page)
	147	{
	148	return 0;
	149	}
	150
	151
1da177e4 LT	152	#endif /* CONFIG_MMU */
	153
	154	/*
	155	* Return values of try_to_unmap
	156	*/
	157	#define SWAP_SUCCESS 0
	158	#define SWAP_AGAIN 1
	159	#define SWAP_FAIL 2
b291f000	160	#define SWAP_MLOCK 3
1da177e4 LT	161
1da177e4 LT	162	#endif /* _LINUX_RMAP_H */