2 * linux/mm/filemap_xip.c
4 * Copyright (C) 2005 IBM Corporation
5 * Author: Carsten Otte <cotte@de.ibm.com>
7 * derived from linux/mm/filemap.c - Copyright (C) Linus Torvalds
12 #include <linux/pagemap.h>
13 #include <linux/module.h>
14 #include <linux/uio.h>
15 #include <linux/rmap.h>
16 #include <linux/vs_base.h>
17 #include <linux/vs_memory.h>
18 #include <asm/tlbflush.h>
22 * This is a file read routine for execute in place files, and uses
23 * the mapping->a_ops->get_xip_page() function for the actual low-level
26 * Note the struct file* is not used at all. It may be NULL.
29 do_xip_mapping_read(struct address_space *mapping,
30 struct file_ra_state *_ra,
33 read_descriptor_t *desc,
36 struct inode *inode = mapping->host;
37 unsigned long index, end_index, offset;
40 BUG_ON(!mapping->a_ops->get_xip_page);
42 index = *ppos >> PAGE_CACHE_SHIFT;
43 offset = *ppos & ~PAGE_CACHE_MASK;
45 isize = i_size_read(inode);
49 end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
52 unsigned long nr, ret;
54 /* nr is the maximum number of bytes to copy from this page */
56 if (index >= end_index) {
57 if (index > end_index)
59 nr = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
66 page = mapping->a_ops->get_xip_page(mapping,
67 index*(PAGE_SIZE/512), 0);
70 if (unlikely(IS_ERR(page))) {
71 if (PTR_ERR(page) == -ENODATA) {
75 desc->error = PTR_ERR(page);
80 /* If users can be writing to this page using arbitrary
81 * virtual addresses, take care about potential aliasing
82 * before reading the page on the kernel side.
84 if (mapping_writably_mapped(mapping))
85 flush_dcache_page(page);
88 * Ok, we have the page, so now we can copy it to user space...
90 * The actor routine returns how many bytes were actually used..
91 * NOTE! This may not be the same as how much of a user buffer
92 * we filled up (we may be padding etc), so we can only update
93 * "pos" here (the actor routine has to update the user buffer
94 * pointers and the remaining count).
96 ret = actor(desc, page, offset, nr);
98 index += offset >> PAGE_CACHE_SHIFT;
99 offset &= ~PAGE_CACHE_MASK;
101 if (ret == nr && desc->count)
106 /* Did not get the page. Report it */
112 *ppos = ((loff_t) index << PAGE_CACHE_SHIFT) + offset;
118 xip_file_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
120 read_descriptor_t desc;
122 if (!access_ok(VERIFY_WRITE, buf, len))
130 do_xip_mapping_read(filp->f_mapping, &filp->f_ra, filp,
131 ppos, &desc, file_read_actor);
138 EXPORT_SYMBOL_GPL(xip_file_read);
141 xip_file_sendfile(struct file *in_file, loff_t *ppos,
142 size_t count, read_actor_t actor, void *target)
144 read_descriptor_t desc;
151 desc.arg.data = target;
154 do_xip_mapping_read(in_file->f_mapping, &in_file->f_ra, in_file,
160 EXPORT_SYMBOL_GPL(xip_file_sendfile);
163 * __xip_unmap is invoked from xip_unmap and
166 * This function walks all vmas of the address_space and unmaps the
167 * ZERO_PAGE when found at pgoff. Should it go in rmap.c?
170 __xip_unmap (struct address_space * mapping,
173 struct vm_area_struct *vma;
174 struct mm_struct *mm;
175 struct prio_tree_iter iter;
176 unsigned long address;
182 spin_lock(&mapping->i_mmap_lock);
183 vma_prio_tree_foreach(vma, &iter, &mapping->i_mmap, pgoff, pgoff) {
185 address = vma->vm_start +
186 ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
187 BUG_ON(address < vma->vm_start || address >= vma->vm_end);
188 page = ZERO_PAGE(address);
189 pte = page_check_address(page, mm, address, &ptl);
191 /* Nuke the page table entry. */
192 flush_cache_page(vma, address, pte_pfn(*pte));
193 pteval = ptep_clear_flush(vma, address, pte);
194 page_remove_rmap(page, vma);
195 dec_mm_counter(mm, file_rss);
196 BUG_ON(pte_dirty(pteval));
197 pte_unmap_unlock(pte, ptl);
198 page_cache_release(page);
201 spin_unlock(&mapping->i_mmap_lock);
205 * xip_nopage() is invoked via the vma operations vector for a
206 * mapped memory region to read in file data during a page fault.
208 * This function is derived from filemap_nopage, but used for execute in place
211 xip_file_nopage(struct vm_area_struct * area,
212 unsigned long address,
215 struct file *file = area->vm_file;
216 struct address_space *mapping = file->f_mapping;
217 struct inode *inode = mapping->host;
219 unsigned long size, pgoff, endoff;
221 pgoff = ((address - area->vm_start) >> PAGE_CACHE_SHIFT)
223 endoff = ((area->vm_end - area->vm_start) >> PAGE_CACHE_SHIFT)
226 size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
231 page = mapping->a_ops->get_xip_page(mapping, pgoff*(PAGE_SIZE/512), 0);
235 if (PTR_ERR(page) != -ENODATA)
239 if ((area->vm_flags & (VM_WRITE | VM_MAYWRITE)) &&
240 (area->vm_flags & (VM_SHARED| VM_MAYSHARE)) &&
241 (!(mapping->host->i_sb->s_flags & MS_RDONLY))) {
242 /* maybe shared writable, allocate new block */
243 page = mapping->a_ops->get_xip_page (mapping,
244 pgoff*(PAGE_SIZE/512), 1);
247 /* unmap page at pgoff from all other vmas */
248 __xip_unmap(mapping, pgoff);
250 /* not shared and writable, use ZERO_PAGE() */
251 page = ZERO_PAGE(address);
255 page_cache_get(page);
259 static struct vm_operations_struct xip_file_vm_ops = {
260 .nopage = xip_file_nopage,
263 int xip_file_mmap(struct file * file, struct vm_area_struct * vma)
265 BUG_ON(!file->f_mapping->a_ops->get_xip_page);
268 vma->vm_ops = &xip_file_vm_ops;
271 EXPORT_SYMBOL_GPL(xip_file_mmap);
274 __xip_file_write(struct file *filp, const char __user *buf,
275 size_t count, loff_t pos, loff_t *ppos)
277 struct address_space * mapping = filp->f_mapping;
278 const struct address_space_operations *a_ops = mapping->a_ops;
279 struct inode *inode = mapping->host;
285 BUG_ON(!mapping->a_ops->get_xip_page);
289 unsigned long offset;
292 offset = (pos & (PAGE_CACHE_SIZE -1)); /* Within page */
293 index = pos >> PAGE_CACHE_SHIFT;
294 bytes = PAGE_CACHE_SIZE - offset;
299 * Bring in the user page that we will copy from _first_.
300 * Otherwise there's a nasty deadlock on copying from the
301 * same page as we're writing to, without it being marked
304 fault_in_pages_readable(buf, bytes);
306 page = a_ops->get_xip_page(mapping,
307 index*(PAGE_SIZE/512), 0);
308 if (IS_ERR(page) && (PTR_ERR(page) == -ENODATA)) {
309 /* we allocate a new page unmap it */
310 page = a_ops->get_xip_page(mapping,
311 index*(PAGE_SIZE/512), 1);
313 /* unmap page at pgoff from all other vmas */
314 __xip_unmap(mapping, index);
318 status = PTR_ERR(page);
322 copied = filemap_copy_from_user(page, offset, buf, bytes);
323 flush_dcache_page(page);
324 if (likely(copied > 0)) {
334 if (unlikely(copied != bytes))
342 * No need to use i_size_read() here, the i_size
343 * cannot change under us because we hold i_mutex.
345 if (pos > inode->i_size) {
346 i_size_write(inode, pos);
347 mark_inode_dirty(inode);
350 return written ? written : status;
354 xip_file_write(struct file *filp, const char __user *buf, size_t len,
357 struct address_space *mapping = filp->f_mapping;
358 struct inode *inode = mapping->host;
363 mutex_lock(&inode->i_mutex);
365 if (!access_ok(VERIFY_READ, buf, len)) {
373 vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
375 /* We can write back this queue in page reclaim */
376 current->backing_dev_info = mapping->backing_dev_info;
378 ret = generic_write_checks(filp, &pos, &count, S_ISBLK(inode->i_mode));
384 ret = remove_suid(filp->f_dentry);
388 file_update_time(filp);
390 ret = __xip_file_write (filp, buf, count, pos, ppos);
393 current->backing_dev_info = NULL;
395 mutex_unlock(&inode->i_mutex);
398 EXPORT_SYMBOL_GPL(xip_file_write);
401 * truncate a page used for execute in place
402 * functionality is analog to block_truncate_page but does use get_xip_page
403 * to get the page instead of page cache
406 xip_truncate_page(struct address_space *mapping, loff_t from)
408 pgoff_t index = from >> PAGE_CACHE_SHIFT;
409 unsigned offset = from & (PAGE_CACHE_SIZE-1);
415 BUG_ON(!mapping->a_ops->get_xip_page);
417 blocksize = 1 << mapping->host->i_blkbits;
418 length = offset & (blocksize - 1);
420 /* Block boundary? Nothing to do */
424 length = blocksize - length;
426 page = mapping->a_ops->get_xip_page(mapping,
427 index*(PAGE_SIZE/512), 0);
430 if (unlikely(IS_ERR(page))) {
431 if (PTR_ERR(page) == -ENODATA)
432 /* Hole? No need to truncate */
435 return PTR_ERR(page);
437 kaddr = kmap_atomic(page, KM_USER0);
438 memset(kaddr + offset, 0, length);
439 kunmap_atomic(kaddr, KM_USER0);
441 flush_dcache_page(page);
444 EXPORT_SYMBOL_GPL(xip_truncate_page);