filemap_xip.c 10.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 *	linux/mm/filemap_xip.c
 *
 * Copyright (C) 2005 IBM Corporation
 * Author: Carsten Otte <cotte@de.ibm.com>
 *
 * derived from linux/mm/filemap.c - Copyright (C) Linus Torvalds
 *
 */

#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/module.h>
#include <linux/uio.h>
#include <linux/rmap.h>
A
Alexey Dobriyan 已提交
16
#include <linux/sched.h>
17 18 19
#include <asm/tlbflush.h>
#include "filemap.h"

20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
/*
 * We do use our own empty page to avoid interference with other users
 * of ZERO_PAGE(), such as /dev/zero
 */
static struct page *__xip_sparse_page;

static struct page *xip_sparse_page(void)
{
	if (!__xip_sparse_page) {
		unsigned long zeroes = get_zeroed_page(GFP_HIGHUSER);
		if (zeroes) {
			static DEFINE_SPINLOCK(xip_alloc_lock);
			spin_lock(&xip_alloc_lock);
			if (!__xip_sparse_page)
				__xip_sparse_page = virt_to_page(zeroes);
			else
				free_page(zeroes);
			spin_unlock(&xip_alloc_lock);
		}
	}
	return __xip_sparse_page;
}

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
/*
 * This is a file read routine for execute in place files, and uses
 * the mapping->a_ops->get_xip_page() function for the actual low-level
 * stuff.
 *
 * Note the struct file* is not used at all.  It may be NULL.
 */
static void
do_xip_mapping_read(struct address_space *mapping,
		    struct file_ra_state *_ra,
		    struct file *filp,
		    loff_t *ppos,
		    read_descriptor_t *desc,
		    read_actor_t actor)
{
	struct inode *inode = mapping->host;
	unsigned long index, end_index, offset;
	loff_t isize;

	BUG_ON(!mapping->a_ops->get_xip_page);

	index = *ppos >> PAGE_CACHE_SHIFT;
	offset = *ppos & ~PAGE_CACHE_MASK;

	isize = i_size_read(inode);
	if (!isize)
		goto out;

	end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
	for (;;) {
		struct page *page;
		unsigned long nr, ret;

		/* nr is the maximum number of bytes to copy from this page */
		nr = PAGE_CACHE_SIZE;
		if (index >= end_index) {
			if (index > end_index)
				goto out;
			nr = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
			if (nr <= offset) {
				goto out;
			}
		}
		nr = nr - offset;

		page = mapping->a_ops->get_xip_page(mapping,
			index*(PAGE_SIZE/512), 0);
		if (!page)
			goto no_xip_page;
		if (unlikely(IS_ERR(page))) {
			if (PTR_ERR(page) == -ENODATA) {
				/* sparse */
C
Carsten Otte 已提交
95
				page = ZERO_PAGE(0);
96 97 98 99
			} else {
				desc->error = PTR_ERR(page);
				goto out;
			}
C
Carsten Otte 已提交
100
		}
101 102 103 104 105 106 107 108 109

		/* If users can be writing to this page using arbitrary
		 * virtual addresses, take care about potential aliasing
		 * before reading the page on the kernel side.
		 */
		if (mapping_writably_mapped(mapping))
			flush_dcache_page(page);

		/*
C
Carsten Otte 已提交
110
		 * Ok, we have the page, so now we can copy it to user space...
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
		 *
		 * The actor routine returns how many bytes were actually used..
		 * NOTE! This may not be the same as how much of a user buffer
		 * we filled up (we may be padding etc), so we can only update
		 * "pos" here (the actor routine has to update the user buffer
		 * pointers and the remaining count).
		 */
		ret = actor(desc, page, offset, nr);
		offset += ret;
		index += offset >> PAGE_CACHE_SHIFT;
		offset &= ~PAGE_CACHE_MASK;

		if (ret == nr && desc->count)
			continue;
		goto out;

no_xip_page:
		/* Did not get the page. Report it */
		desc->error = -EIO;
		goto out;
	}

out:
	*ppos = ((loff_t) index << PAGE_CACHE_SHIFT) + offset;
	if (filp)
		file_accessed(filp);
}

ssize_t
140
xip_file_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
141
{
142
	read_descriptor_t desc;
143

144 145
	if (!access_ok(VERIFY_WRITE, buf, len))
		return -EFAULT;
146

147 148 149 150
	desc.written = 0;
	desc.arg.buf = buf;
	desc.count = len;
	desc.error = 0;
151

152 153 154 155 156 157 158
	do_xip_mapping_read(filp->f_mapping, &filp->f_ra, filp,
			    ppos, &desc, file_read_actor);

	if (desc.written)
		return desc.written;
	else
		return desc.error;
159
}
160
EXPORT_SYMBOL_GPL(xip_file_read);
161 162 163 164 165 166

/*
 * __xip_unmap is invoked from xip_unmap and
 * xip_write
 *
 * This function walks all vmas of the address_space and unmaps the
167
 * __xip_sparse_page when found at pgoff.
168 169 170 171 172 173 174 175 176 177 178
 */
static void
__xip_unmap (struct address_space * mapping,
		     unsigned long pgoff)
{
	struct vm_area_struct *vma;
	struct mm_struct *mm;
	struct prio_tree_iter iter;
	unsigned long address;
	pte_t *pte;
	pte_t pteval;
H
Hugh Dickins 已提交
179
	spinlock_t *ptl;
H
Hugh Dickins 已提交
180
	struct page *page;
181

182 183 184 185
	page = __xip_sparse_page;
	if (!page)
		return;

186 187 188 189 190 191
	spin_lock(&mapping->i_mmap_lock);
	vma_prio_tree_foreach(vma, &iter, &mapping->i_mmap, pgoff, pgoff) {
		mm = vma->vm_mm;
		address = vma->vm_start +
			((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
		BUG_ON(address < vma->vm_start || address >= vma->vm_end);
H
Hugh Dickins 已提交
192 193
		pte = page_check_address(page, mm, address, &ptl);
		if (pte) {
194
			/* Nuke the page table entry. */
195
			flush_cache_page(vma, address, pte_pfn(*pte));
196
			pteval = ptep_clear_flush(vma, address, pte);
N
Nick Piggin 已提交
197
			page_remove_rmap(page, vma);
N
Nick Piggin 已提交
198
			dec_mm_counter(mm, file_rss);
199
			BUG_ON(pte_dirty(pteval));
H
Hugh Dickins 已提交
200
			pte_unmap_unlock(pte, ptl);
N
Nick Piggin 已提交
201
			page_cache_release(page);
202 203 204 205 206 207
		}
	}
	spin_unlock(&mapping->i_mmap_lock);
}

/*
208
 * xip_fault() is invoked via the vma operations vector for a
209 210
 * mapped memory region to read in file data during a page fault.
 *
211
 * This function is derived from filemap_fault, but used for execute in place
212
 */
N
Nick Piggin 已提交
213
static int xip_file_fault(struct vm_area_struct *area, struct vm_fault *vmf)
214 215 216 217 218
{
	struct file *file = area->vm_file;
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
	struct page *page;
219
	pgoff_t size;
220

221
	/* XXX: are VM_FAULT_ codes OK? */
222 223

	size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
N
Nick Piggin 已提交
224 225
	if (vmf->pgoff >= size)
		return VM_FAULT_SIGBUS;
226

227
	page = mapping->a_ops->get_xip_page(mapping,
N
Nick Piggin 已提交
228
					vmf->pgoff*(PAGE_SIZE/512), 0);
229
	if (!IS_ERR(page))
N
Nick Piggin 已提交
230
		goto out;
N
Nick Piggin 已提交
231 232
	if (PTR_ERR(page) != -ENODATA)
		return VM_FAULT_OOM;
233 234 235 236 237 238

	/* sparse block */
	if ((area->vm_flags & (VM_WRITE | VM_MAYWRITE)) &&
	    (area->vm_flags & (VM_SHARED| VM_MAYSHARE)) &&
	    (!(mapping->host->i_sb->s_flags & MS_RDONLY))) {
		/* maybe shared writable, allocate new block */
239
		page = mapping->a_ops->get_xip_page(mapping,
N
Nick Piggin 已提交
240 241 242
					vmf->pgoff*(PAGE_SIZE/512), 1);
		if (IS_ERR(page))
			return VM_FAULT_SIGBUS;
243
		/* unmap page at pgoff from all other vmas */
N
Nick Piggin 已提交
244
		__xip_unmap(mapping, vmf->pgoff);
245
	} else {
246 247
		/* not shared and writable, use xip_sparse_page() */
		page = xip_sparse_page();
N
Nick Piggin 已提交
248 249
		if (!page)
			return VM_FAULT_OOM;
250 251
	}

N
Nick Piggin 已提交
252 253
out:
	page_cache_get(page);
N
Nick Piggin 已提交
254
	vmf->page = page;
N
Nick Piggin 已提交
255
	return 0;
256 257 258
}

static struct vm_operations_struct xip_file_vm_ops = {
259
	.fault	= xip_file_fault,
260 261 262 263 264 265 266 267
};

int xip_file_mmap(struct file * file, struct vm_area_struct * vma)
{
	BUG_ON(!file->f_mapping->a_ops->get_xip_page);

	file_accessed(file);
	vma->vm_ops = &xip_file_vm_ops;
268
	vma->vm_flags |= VM_CAN_NONLINEAR;
269 270 271 272 273
	return 0;
}
EXPORT_SYMBOL_GPL(xip_file_mmap);

static ssize_t
274 275
__xip_file_write(struct file *filp, const char __user *buf,
		  size_t count, loff_t pos, loff_t *ppos)
276
{
277
	struct address_space * mapping = filp->f_mapping;
278
	const struct address_space_operations *a_ops = mapping->a_ops;
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	struct inode 	*inode = mapping->host;
	long		status = 0;
	struct page	*page;
	size_t		bytes;
	ssize_t		written = 0;

	BUG_ON(!mapping->a_ops->get_xip_page);

	do {
		unsigned long index;
		unsigned long offset;
		size_t copied;

		offset = (pos & (PAGE_CACHE_SIZE -1)); /* Within page */
		index = pos >> PAGE_CACHE_SHIFT;
		bytes = PAGE_CACHE_SIZE - offset;
		if (bytes > count)
			bytes = count;

		/*
		 * Bring in the user page that we will copy from _first_.
		 * Otherwise there's a nasty deadlock on copying from the
		 * same page as we're writing to, without it being marked
		 * up-to-date.
		 */
		fault_in_pages_readable(buf, bytes);

		page = a_ops->get_xip_page(mapping,
307
					   index*(PAGE_SIZE/512), 0);
308 309 310
		if (IS_ERR(page) && (PTR_ERR(page) == -ENODATA)) {
			/* we allocate a new page unmap it */
			page = a_ops->get_xip_page(mapping,
311
						   index*(PAGE_SIZE/512), 1);
312
			if (!IS_ERR(page))
313 314
				/* unmap page at pgoff from all other vmas */
				__xip_unmap(mapping, index);
315 316 317 318 319 320 321
		}

		if (IS_ERR(page)) {
			status = PTR_ERR(page);
			break;
		}

322
		copied = filemap_copy_from_user(page, offset, buf, bytes);
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
		flush_dcache_page(page);
		if (likely(copied > 0)) {
			status = copied;

			if (status >= 0) {
				written += status;
				count -= status;
				pos += status;
				buf += status;
			}
		}
		if (unlikely(copied != bytes))
			if (status >= 0)
				status = -EFAULT;
		if (status < 0)
			break;
	} while (count);
	*ppos = pos;
	/*
	 * No need to use i_size_read() here, the i_size
343
	 * cannot change under us because we hold i_mutex.
344 345 346 347 348 349 350 351 352
	 */
	if (pos > inode->i_size) {
		i_size_write(inode, pos);
		mark_inode_dirty(inode);
	}

	return written ? written : status;
}

353 354 355
ssize_t
xip_file_write(struct file *filp, const char __user *buf, size_t len,
	       loff_t *ppos)
356
{
357 358 359 360 361
	struct address_space *mapping = filp->f_mapping;
	struct inode *inode = mapping->host;
	size_t count;
	loff_t pos;
	ssize_t ret;
362

363
	mutex_lock(&inode->i_mutex);
364

365 366 367
	if (!access_ok(VERIFY_READ, buf, len)) {
		ret=-EFAULT;
		goto out_up;
368 369 370
	}

	pos = *ppos;
371
	count = len;
372 373 374

	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);

375 376
	/* We can write back this queue in page reclaim */
	current->backing_dev_info = mapping->backing_dev_info;
377

378 379 380
	ret = generic_write_checks(filp, &pos, &count, S_ISBLK(inode->i_mode));
	if (ret)
		goto out_backing;
381
	if (count == 0)
382
		goto out_backing;
383

384
	ret = remove_suid(filp->f_path.dentry);
385 386
	if (ret)
		goto out_backing;
387

388
	file_update_time(filp);
389

390
	ret = __xip_file_write (filp, buf, count, pos, ppos);
391

392 393 394
 out_backing:
	current->backing_dev_info = NULL;
 out_up:
395
	mutex_unlock(&inode->i_mutex);
396 397
	return ret;
}
398
EXPORT_SYMBOL_GPL(xip_file_write);
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427

/*
 * truncate a page used for execute in place
 * functionality is analog to block_truncate_page but does use get_xip_page
 * to get the page instead of page cache
 */
int
xip_truncate_page(struct address_space *mapping, loff_t from)
{
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	unsigned blocksize;
	unsigned length;
	struct page *page;

	BUG_ON(!mapping->a_ops->get_xip_page);

	blocksize = 1 << mapping->host->i_blkbits;
	length = offset & (blocksize - 1);

	/* Block boundary? Nothing to do */
	if (!length)
		return 0;

	length = blocksize - length;

	page = mapping->a_ops->get_xip_page(mapping,
					    index*(PAGE_SIZE/512), 0);
	if (!page)
428
		return -ENOMEM;
429
	if (unlikely(IS_ERR(page))) {
430
		if (PTR_ERR(page) == -ENODATA)
431 432
			/* Hole? No need to truncate */
			return 0;
433 434
		else
			return PTR_ERR(page);
C
Carsten Otte 已提交
435
	}
436
	zero_user_page(page, offset, length, KM_USER0);
437
	return 0;
438 439
}
EXPORT_SYMBOL_GPL(xip_truncate_page);