pagemap.h 7.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13
#ifndef _LINUX_PAGEMAP_H
#define _LINUX_PAGEMAP_H

/*
 * Copyright 1995 Linus Torvalds
 */
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/highmem.h>
#include <linux/compiler.h>
#include <asm/uaccess.h>
#include <linux/gfp.h>
14
#include <linux/bitops.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20 21 22

/*
 * Bits in mapping->flags.  The lower __GFP_BITS_SHIFT bits are the page
 * allocation mode flags.
 */
#define	AS_EIO		(__GFP_BITS_SHIFT + 0)	/* IO error on async write */
#define AS_ENOSPC	(__GFP_BITS_SHIFT + 1)	/* ENOSPC on async write */

23 24 25 26 27 28 29 30 31 32
static inline void mapping_set_error(struct address_space *mapping, int error)
{
	if (error) {
		if (error == -ENOSPC)
			set_bit(AS_ENOSPC, &mapping->flags);
		else
			set_bit(AS_EIO, &mapping->flags);
	}
}

33
static inline gfp_t mapping_gfp_mask(struct address_space * mapping)
Linus Torvalds's avatar
Linus Torvalds committed
34
{
Al Viro's avatar
Al Viro committed
35
	return (__force gfp_t)mapping->flags & __GFP_BITS_MASK;
Linus Torvalds's avatar
Linus Torvalds committed
36 37 38 39 40 41
}

/*
 * This is non-atomic.  Only to be used before the mapping is activated.
 * Probably needs a barrier...
 */
Al Viro's avatar
Al Viro committed
42
static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
Linus Torvalds's avatar
Linus Torvalds committed
43
{
Al Viro's avatar
Al Viro committed
44 45
	m->flags = (m->flags & ~(__force unsigned long)__GFP_BITS_MASK) |
				(__force unsigned long)mask;
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
}

/*
 * The page cache can done in larger chunks than
 * one page, because it allows for more efficient
 * throughput (it can then be mapped into user
 * space in smaller chunks for same flexibility).
 *
 * Or rather, it _will_ be done in larger chunks.
 */
#define PAGE_CACHE_SHIFT	PAGE_SHIFT
#define PAGE_CACHE_SIZE		PAGE_SIZE
#define PAGE_CACHE_MASK		PAGE_MASK
#define PAGE_CACHE_ALIGN(addr)	(((addr)+PAGE_CACHE_SIZE-1)&PAGE_CACHE_MASK)

#define page_cache_get(page)		get_page(page)
#define page_cache_release(page)	put_page(page)
void release_pages(struct page **pages, int nr, int cold);

65
#ifdef CONFIG_NUMA
66
extern struct page *__page_cache_alloc(gfp_t gfp);
67
#else
68 69 70 71 72 73
static inline struct page *__page_cache_alloc(gfp_t gfp)
{
	return alloc_pages(gfp, 0);
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
74 75
static inline struct page *page_cache_alloc(struct address_space *x)
{
76
	return __page_cache_alloc(mapping_gfp_mask(x));
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80
}

static inline struct page *page_cache_alloc_cold(struct address_space *x)
{
81
	return __page_cache_alloc(mapping_gfp_mask(x)|__GFP_COLD);
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84 85 86
}

typedef int filler_t(void *, struct page *);

extern struct page * find_get_page(struct address_space *mapping,
87
				pgoff_t index);
Linus Torvalds's avatar
Linus Torvalds committed
88
extern struct page * find_lock_page(struct address_space *mapping,
89
				pgoff_t index);
Linus Torvalds's avatar
Linus Torvalds committed
90
extern struct page * find_or_create_page(struct address_space *mapping,
91
				pgoff_t index, gfp_t gfp_mask);
Linus Torvalds's avatar
Linus Torvalds committed
92 93
unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
			unsigned int nr_pages, struct page **pages);
94 95
unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t start,
			       unsigned int nr_pages, struct page **pages);
Linus Torvalds's avatar
Linus Torvalds committed
96 97 98
unsigned find_get_pages_tag(struct address_space *mapping, pgoff_t *index,
			int tag, unsigned int nr_pages, struct page **pages);

99 100
struct page *__grab_cache_page(struct address_space *mapping, pgoff_t index);

Linus Torvalds's avatar
Linus Torvalds committed
101 102 103
/*
 * Returns locked page at given index in given cache, creating it if needed.
 */
104 105
static inline struct page *grab_cache_page(struct address_space *mapping,
								pgoff_t index)
Linus Torvalds's avatar
Linus Torvalds committed
106 107 108 109 110
{
	return find_or_create_page(mapping, index, mapping_gfp_mask(mapping));
}

extern struct page * grab_cache_page_nowait(struct address_space *mapping,
111
				pgoff_t index);
112
extern struct page * read_cache_page_async(struct address_space *mapping,
113
				pgoff_t index, filler_t *filler,
114
				void *data);
Linus Torvalds's avatar
Linus Torvalds committed
115
extern struct page * read_cache_page(struct address_space *mapping,
116
				pgoff_t index, filler_t *filler,
Linus Torvalds's avatar
Linus Torvalds committed
117 118 119 120
				void *data);
extern int read_cache_pages(struct address_space *mapping,
		struct list_head *pages, filler_t *filler, void *data);

121 122
static inline struct page *read_mapping_page_async(
						struct address_space *mapping,
123
						     pgoff_t index, void *data)
124 125 126 127 128
{
	filler_t *filler = (filler_t *)mapping->a_ops->readpage;
	return read_cache_page_async(mapping, index, filler, data);
}

129
static inline struct page *read_mapping_page(struct address_space *mapping,
130
					     pgoff_t index, void *data)
131 132 133 134 135
{
	filler_t *filler = (filler_t *)mapping->a_ops->readpage;
	return read_cache_page(mapping, index, filler, data);
}

Linus Torvalds's avatar
Linus Torvalds committed
136
int add_to_page_cache(struct page *page, struct address_space *mapping,
137
				pgoff_t index, gfp_t gfp_mask);
Linus Torvalds's avatar
Linus Torvalds committed
138
int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
139
				pgoff_t index, gfp_t gfp_mask);
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
extern void remove_from_page_cache(struct page *page);
extern void __remove_from_page_cache(struct page *page);

/*
 * Return byte-offset into filesystem object for page.
 */
static inline loff_t page_offset(struct page *page)
{
	return ((loff_t)page->index) << PAGE_CACHE_SHIFT;
}

static inline pgoff_t linear_page_index(struct vm_area_struct *vma,
					unsigned long address)
{
	pgoff_t pgoff = (address - vma->vm_start) >> PAGE_SHIFT;
	pgoff += vma->vm_pgoff;
	return pgoff >> (PAGE_CACHE_SHIFT - PAGE_SHIFT);
}

extern void FASTCALL(__lock_page(struct page *page));
160
extern void FASTCALL(__lock_page_nosync(struct page *page));
Linus Torvalds's avatar
Linus Torvalds committed
161 162
extern void FASTCALL(unlock_page(struct page *page));

163 164 165
/*
 * lock_page may only be called if we have the page's inode pinned.
 */
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169 170 171
static inline void lock_page(struct page *page)
{
	might_sleep();
	if (TestSetPageLocked(page))
		__lock_page(page);
}
172 173 174 175 176 177 178 179 180 181 182

/*
 * lock_page_nosync should only be used if we can't pin the page's inode.
 * Doesn't play quite so well with block device plugging.
 */
static inline void lock_page_nosync(struct page *page)
{
	might_sleep();
	if (TestSetPageLocked(page))
		__lock_page_nosync(page);
}
Linus Torvalds's avatar
Linus Torvalds committed
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
	
/*
 * This is exported only for wait_on_page_locked/wait_on_page_writeback.
 * Never use this directly!
 */
extern void FASTCALL(wait_on_page_bit(struct page *page, int bit_nr));

/* 
 * Wait for a page to be unlocked.
 *
 * This must be called with the caller "holding" the page,
 * ie with increased "page->count" so that the page won't
 * go away during the wait..
 */
static inline void wait_on_page_locked(struct page *page)
{
	if (PageLocked(page))
		wait_on_page_bit(page, PG_locked);
}

/* 
 * Wait for a page to complete writeback
 */
static inline void wait_on_page_writeback(struct page *page)
{
	if (PageWriteback(page))
		wait_on_page_bit(page, PG_writeback);
}

extern void end_page_writeback(struct page *page);

/*
 * Fault a userspace page into pagetables.  Return non-zero on a fault.
 *
 * This assumes that two userspace pages are always sufficient.  That's
 * not true if PAGE_CACHE_SIZE > PAGE_SIZE.
 */
static inline int fault_in_pages_writeable(char __user *uaddr, int size)
{
	int ret;

224 225 226
	if (unlikely(size == 0))
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	/*
	 * Writing zeroes into userspace here is OK, because we know that if
	 * the zero gets there, we'll be overwriting it.
	 */
	ret = __put_user(0, uaddr);
	if (ret == 0) {
		char __user *end = uaddr + size - 1;

		/*
		 * If the page was already mapped, this will get a cache miss
		 * for sure, so try to avoid doing it.
		 */
		if (((unsigned long)uaddr & PAGE_MASK) !=
				((unsigned long)end & PAGE_MASK))
		 	ret = __put_user(0, end);
	}
	return ret;
}

246
static inline int fault_in_pages_readable(const char __user *uaddr, int size)
Linus Torvalds's avatar
Linus Torvalds committed
247 248 249 250
{
	volatile char c;
	int ret;

251 252 253
	if (unlikely(size == 0))
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258 259
	ret = __get_user(c, uaddr);
	if (ret == 0) {
		const char __user *end = uaddr + size - 1;

		if (((unsigned long)uaddr & PAGE_MASK) !=
				((unsigned long)end & PAGE_MASK))
260
		 	ret = __get_user(c, end);
Linus Torvalds's avatar
Linus Torvalds committed
261
	}
262
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
263 264 265
}

#endif /* _LINUX_PAGEMAP_H */