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 <asm/tlbflush.h>
20 * This is a file read routine for execute in place files, and uses
21 * the mapping->a_ops->get_xip_page() function for the actual low-level
24 * Note the struct file* is not used at all. It may be NULL.
27 do_xip_mapping_read(struct address_space
*mapping
,
28 struct file_ra_state
*_ra
,
31 read_descriptor_t
*desc
,
34 struct inode
*inode
= mapping
->host
;
35 unsigned long index
, end_index
, offset
;
38 BUG_ON(!mapping
->a_ops
->get_xip_page
);
40 index
= *ppos
>> PAGE_CACHE_SHIFT
;
41 offset
= *ppos
& ~PAGE_CACHE_MASK
;
43 isize
= i_size_read(inode
);
47 end_index
= (isize
- 1) >> PAGE_CACHE_SHIFT
;
50 unsigned long nr
, ret
;
52 /* nr is the maximum number of bytes to copy from this page */
54 if (index
>= end_index
) {
55 if (index
> end_index
)
57 nr
= ((isize
- 1) & ~PAGE_CACHE_MASK
) + 1;
64 page
= mapping
->a_ops
->get_xip_page(mapping
,
65 index
*(PAGE_SIZE
/512), 0);
68 if (unlikely(IS_ERR(page
))) {
69 if (PTR_ERR(page
) == -ENODATA
) {
73 desc
->error
= PTR_ERR(page
);
78 /* If users can be writing to this page using arbitrary
79 * virtual addresses, take care about potential aliasing
80 * before reading the page on the kernel side.
82 if (mapping_writably_mapped(mapping
))
83 flush_dcache_page(page
);
86 * Ok, we have the page, so now we can copy it to user space...
88 * The actor routine returns how many bytes were actually used..
89 * NOTE! This may not be the same as how much of a user buffer
90 * we filled up (we may be padding etc), so we can only update
91 * "pos" here (the actor routine has to update the user buffer
92 * pointers and the remaining count).
94 ret
= actor(desc
, page
, offset
, nr
);
96 index
+= offset
>> PAGE_CACHE_SHIFT
;
97 offset
&= ~PAGE_CACHE_MASK
;
99 if (ret
== nr
&& desc
->count
)
104 /* Did not get the page. Report it */
110 *ppos
= ((loff_t
) index
<< PAGE_CACHE_SHIFT
) + offset
;
116 xip_file_read(struct file
*filp
, char __user
*buf
, size_t len
, loff_t
*ppos
)
118 read_descriptor_t desc
;
120 if (!access_ok(VERIFY_WRITE
, buf
, len
))
128 do_xip_mapping_read(filp
->f_mapping
, &filp
->f_ra
, filp
,
129 ppos
, &desc
, file_read_actor
);
136 EXPORT_SYMBOL_GPL(xip_file_read
);
139 xip_file_sendfile(struct file
*in_file
, loff_t
*ppos
,
140 size_t count
, read_actor_t actor
, void *target
)
142 read_descriptor_t desc
;
149 desc
.arg
.data
= target
;
152 do_xip_mapping_read(in_file
->f_mapping
, &in_file
->f_ra
, in_file
,
158 EXPORT_SYMBOL_GPL(xip_file_sendfile
);
161 * __xip_unmap is invoked from xip_unmap and
164 * This function walks all vmas of the address_space and unmaps the
165 * ZERO_PAGE when found at pgoff. Should it go in rmap.c?
168 __xip_unmap (struct address_space
* mapping
,
171 struct vm_area_struct
*vma
;
172 struct mm_struct
*mm
;
173 struct prio_tree_iter iter
;
174 unsigned long address
;
177 struct page
*page
= ZERO_PAGE(address
);
179 spin_lock(&mapping
->i_mmap_lock
);
180 vma_prio_tree_foreach(vma
, &iter
, &mapping
->i_mmap
, pgoff
, pgoff
) {
182 address
= vma
->vm_start
+
183 ((pgoff
- vma
->vm_pgoff
) << PAGE_SHIFT
);
184 BUG_ON(address
< vma
->vm_start
|| address
>= vma
->vm_end
);
186 * We need the page_table_lock to protect us from page faults,
187 * munmap, fork, etc...
189 pte
= page_check_address(page
, mm
, address
);
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
);
195 dec_mm_counter(mm
, file_rss
);
196 BUG_ON(pte_dirty(pteval
));
198 spin_unlock(&mm
->page_table_lock
);
199 page_cache_release(page
);
202 spin_unlock(&mapping
->i_mmap_lock
);
206 * xip_nopage() is invoked via the vma operations vector for a
207 * mapped memory region to read in file data during a page fault.
209 * This function is derived from filemap_nopage, but used for execute in place
212 xip_file_nopage(struct vm_area_struct
* area
,
213 unsigned long address
,
216 struct file
*file
= area
->vm_file
;
217 struct address_space
*mapping
= file
->f_mapping
;
218 struct inode
*inode
= mapping
->host
;
220 unsigned long size
, pgoff
, endoff
;
222 pgoff
= ((address
- area
->vm_start
) >> PAGE_CACHE_SHIFT
)
224 endoff
= ((area
->vm_end
- area
->vm_start
) >> PAGE_CACHE_SHIFT
)
227 size
= (i_size_read(inode
) + PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
232 page
= mapping
->a_ops
->get_xip_page(mapping
, pgoff
*(PAGE_SIZE
/512), 0);
236 if (PTR_ERR(page
) != -ENODATA
)
240 if ((area
->vm_flags
& (VM_WRITE
| VM_MAYWRITE
)) &&
241 (area
->vm_flags
& (VM_SHARED
| VM_MAYSHARE
)) &&
242 (!(mapping
->host
->i_sb
->s_flags
& MS_RDONLY
))) {
243 /* maybe shared writable, allocate new block */
244 page
= mapping
->a_ops
->get_xip_page (mapping
,
245 pgoff
*(PAGE_SIZE
/512), 1);
248 /* unmap page at pgoff from all other vmas */
249 __xip_unmap(mapping
, pgoff
);
251 /* not shared and writable, use ZERO_PAGE() */
252 page
= ZERO_PAGE(address
);
256 page_cache_get(page
);
260 static struct vm_operations_struct xip_file_vm_ops
= {
261 .nopage
= xip_file_nopage
,
264 int xip_file_mmap(struct file
* file
, struct vm_area_struct
* vma
)
266 BUG_ON(!file
->f_mapping
->a_ops
->get_xip_page
);
269 vma
->vm_ops
= &xip_file_vm_ops
;
272 EXPORT_SYMBOL_GPL(xip_file_mmap
);
275 __xip_file_write(struct file
*filp
, const char __user
*buf
,
276 size_t count
, loff_t pos
, loff_t
*ppos
)
278 struct address_space
* mapping
= filp
->f_mapping
;
279 struct address_space_operations
*a_ops
= mapping
->a_ops
;
280 struct inode
*inode
= mapping
->host
;
286 BUG_ON(!mapping
->a_ops
->get_xip_page
);
290 unsigned long offset
;
293 offset
= (pos
& (PAGE_CACHE_SIZE
-1)); /* Within page */
294 index
= pos
>> PAGE_CACHE_SHIFT
;
295 bytes
= PAGE_CACHE_SIZE
- offset
;
300 * Bring in the user page that we will copy from _first_.
301 * Otherwise there's a nasty deadlock on copying from the
302 * same page as we're writing to, without it being marked
305 fault_in_pages_readable(buf
, bytes
);
307 page
= a_ops
->get_xip_page(mapping
,
308 index
*(PAGE_SIZE
/512), 0);
309 if (IS_ERR(page
) && (PTR_ERR(page
) == -ENODATA
)) {
310 /* we allocate a new page unmap it */
311 page
= a_ops
->get_xip_page(mapping
,
312 index
*(PAGE_SIZE
/512), 1);
314 /* unmap page at pgoff from all other vmas */
315 __xip_unmap(mapping
, index
);
319 status
= PTR_ERR(page
);
323 copied
= filemap_copy_from_user(page
, offset
, buf
, bytes
);
324 flush_dcache_page(page
);
325 if (likely(copied
> 0)) {
335 if (unlikely(copied
!= bytes
))
343 * No need to use i_size_read() here, the i_size
344 * cannot change under us because we hold i_sem.
346 if (pos
> inode
->i_size
) {
347 i_size_write(inode
, pos
);
348 mark_inode_dirty(inode
);
351 return written
? written
: status
;
355 xip_file_write(struct file
*filp
, const char __user
*buf
, size_t len
,
358 struct address_space
*mapping
= filp
->f_mapping
;
359 struct inode
*inode
= mapping
->host
;
366 if (!access_ok(VERIFY_READ
, buf
, len
)) {
374 vfs_check_frozen(inode
->i_sb
, SB_FREEZE_WRITE
);
376 /* We can write back this queue in page reclaim */
377 current
->backing_dev_info
= mapping
->backing_dev_info
;
379 ret
= generic_write_checks(filp
, &pos
, &count
, S_ISBLK(inode
->i_mode
));
385 ret
= remove_suid(filp
->f_dentry
);
389 inode_update_time(inode
, 1);
391 ret
= __xip_file_write (filp
, buf
, count
, pos
, ppos
);
394 current
->backing_dev_info
= NULL
;
399 EXPORT_SYMBOL_GPL(xip_file_write
);
402 * truncate a page used for execute in place
403 * functionality is analog to block_truncate_page but does use get_xip_page
404 * to get the page instead of page cache
407 xip_truncate_page(struct address_space
*mapping
, loff_t from
)
409 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
410 unsigned offset
= from
& (PAGE_CACHE_SIZE
-1);
416 BUG_ON(!mapping
->a_ops
->get_xip_page
);
418 blocksize
= 1 << mapping
->host
->i_blkbits
;
419 length
= offset
& (blocksize
- 1);
421 /* Block boundary? Nothing to do */
425 length
= blocksize
- length
;
427 page
= mapping
->a_ops
->get_xip_page(mapping
,
428 index
*(PAGE_SIZE
/512), 0);
431 if (unlikely(IS_ERR(page
))) {
432 if (PTR_ERR(page
) == -ENODATA
)
433 /* Hole? No need to truncate */
436 return PTR_ERR(page
);
438 kaddr
= kmap_atomic(page
, KM_USER0
);
439 memset(kaddr
+ offset
, 0, length
);
440 kunmap_atomic(kaddr
, KM_USER0
);
442 flush_dcache_page(page
);
445 EXPORT_SYMBOL_GPL(xip_truncate_page
);