|
| void | __delete_from_page_cache (struct page *page) |
| |
| void | delete_from_page_cache (struct page *page) |
| |
| | EXPORT_SYMBOL (delete_from_page_cache) |
| |
| int | __filemap_fdatawrite_range (struct address_space *mapping, loff_t start, loff_t end, int sync_mode) |
| |
| int | filemap_fdatawrite (struct address_space *mapping) |
| |
| | EXPORT_SYMBOL (filemap_fdatawrite) |
| |
| int | filemap_fdatawrite_range (struct address_space *mapping, loff_t start, loff_t end) |
| |
| | EXPORT_SYMBOL (filemap_fdatawrite_range) |
| |
| int | filemap_flush (struct address_space *mapping) |
| |
| | EXPORT_SYMBOL (filemap_flush) |
| |
| int | filemap_fdatawait_range (struct address_space *mapping, loff_t start_byte, loff_t end_byte) |
| |
| | EXPORT_SYMBOL (filemap_fdatawait_range) |
| |
| int | filemap_fdatawait (struct address_space *mapping) |
| |
| | EXPORT_SYMBOL (filemap_fdatawait) |
| |
| int | filemap_write_and_wait (struct address_space *mapping) |
| |
| | EXPORT_SYMBOL (filemap_write_and_wait) |
| |
| int | filemap_write_and_wait_range (struct address_space *mapping, loff_t lstart, loff_t lend) |
| |
| | EXPORT_SYMBOL (filemap_write_and_wait_range) |
| |
| int | replace_page_cache_page (struct page *old, struct page *new, gfp_t gfp_mask) |
| |
| | EXPORT_SYMBOL_GPL (replace_page_cache_page) |
| |
| int | add_to_page_cache_locked (struct page *page, struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask) |
| |
| | EXPORT_SYMBOL (add_to_page_cache_locked) |
| |
| int | add_to_page_cache_lru (struct page *page, struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask) |
| |
| | EXPORT_SYMBOL_GPL (add_to_page_cache_lru) |
| |
| void | wait_on_page_bit (struct page *page, int bit_nr) |
| |
| | EXPORT_SYMBOL (wait_on_page_bit) |
| |
| int | wait_on_page_bit_killable (struct page *page, int bit_nr) |
| |
| void | add_page_wait_queue (struct page *page, wait_queue_t *waiter) |
| |
| | EXPORT_SYMBOL_GPL (add_page_wait_queue) |
| |
| void | unlock_page (struct page *page) |
| |
| | EXPORT_SYMBOL (unlock_page) |
| |
| void | end_page_writeback (struct page *page) |
| |
| | EXPORT_SYMBOL (end_page_writeback) |
| |
| void | __lock_page (struct page *page) |
| |
| | EXPORT_SYMBOL (__lock_page) |
| |
| int | __lock_page_killable (struct page *page) |
| |
| | EXPORT_SYMBOL_GPL (__lock_page_killable) |
| |
| int | __lock_page_or_retry (struct page *page, struct mm_struct *mm, unsigned int flags) |
| |
| struct page * | find_get_page (struct address_space *mapping, pgoff_t offset) |
| |
| | EXPORT_SYMBOL (find_get_page) |
| |
| struct page * | find_lock_page (struct address_space *mapping, pgoff_t offset) |
| |
| | EXPORT_SYMBOL (find_lock_page) |
| |
| struct page * | find_or_create_page (struct address_space *mapping, pgoff_t index, gfp_t gfp_mask) |
| |
| | EXPORT_SYMBOL (find_or_create_page) |
| |
| unsigned | find_get_pages (struct address_space *mapping, pgoff_t start, unsigned int nr_pages, struct page **pages) |
| |
| unsigned | find_get_pages_contig (struct address_space *mapping, pgoff_t index, unsigned int nr_pages, struct page **pages) |
| |
| | EXPORT_SYMBOL (find_get_pages_contig) |
| |
| unsigned | find_get_pages_tag (struct address_space *mapping, pgoff_t *index, int tag, unsigned int nr_pages, struct page **pages) |
| |
| | EXPORT_SYMBOL (find_get_pages_tag) |
| |
| struct page * | grab_cache_page_nowait (struct address_space *mapping, pgoff_t index) |
| |
| | EXPORT_SYMBOL (grab_cache_page_nowait) |
| |
| int | file_read_actor (read_descriptor_t *desc, struct page *page, unsigned long offset, unsigned long size) |
| |
| int | generic_segment_checks (const struct iovec *iov, unsigned long *nr_segs, size_t *count, int access_flags) |
| |
| | EXPORT_SYMBOL (generic_segment_checks) |
| |
| ssize_t | generic_file_aio_read (struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) |
| |
| | EXPORT_SYMBOL (generic_file_aio_read) |
| |
| int | generic_file_mmap (struct file *file, struct vm_area_struct *vma) |
| |
| int | generic_file_readonly_mmap (struct file *file, struct vm_area_struct *vma) |
| |
| | EXPORT_SYMBOL (generic_file_mmap) |
| |
| | EXPORT_SYMBOL (generic_file_readonly_mmap) |
| |
| struct page * | read_cache_page_async (struct address_space *mapping, pgoff_t index, int(*filler)(void *, struct page *), void *data) |
| |
| | EXPORT_SYMBOL (read_cache_page_async) |
| |
| struct page * | read_cache_page_gfp (struct address_space *mapping, pgoff_t index, gfp_t gfp) |
| |
| | EXPORT_SYMBOL (read_cache_page_gfp) |
| |
| struct page * | read_cache_page (struct address_space *mapping, pgoff_t index, int(*filler)(void *, struct page *), void *data) |
| |
| | EXPORT_SYMBOL (read_cache_page) |
| |
| size_t | iov_iter_copy_from_user_atomic (struct page *page, struct iov_iter *i, unsigned long offset, size_t bytes) |
| |
| | EXPORT_SYMBOL (iov_iter_copy_from_user_atomic) |
| |
| size_t | iov_iter_copy_from_user (struct page *page, struct iov_iter *i, unsigned long offset, size_t bytes) |
| |
| | EXPORT_SYMBOL (iov_iter_copy_from_user) |
| |
| void | iov_iter_advance (struct iov_iter *i, size_t bytes) |
| |
| | EXPORT_SYMBOL (iov_iter_advance) |
| |
| int | iov_iter_fault_in_readable (struct iov_iter *i, size_t bytes) |
| |
| | EXPORT_SYMBOL (iov_iter_fault_in_readable) |
| |
| size_t | iov_iter_single_seg_count (struct iov_iter *i) |
| |
| | EXPORT_SYMBOL (iov_iter_single_seg_count) |
| |
| int | generic_write_checks (struct file *file, loff_t *pos, size_t *count, int isblk) |
| |
| | EXPORT_SYMBOL (generic_write_checks) |
| |
| int | pagecache_write_begin (struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned flags, struct page **pagep, void **fsdata) |
| |
| | EXPORT_SYMBOL (pagecache_write_begin) |
| |
| int | pagecache_write_end (struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata) |
| |
| | EXPORT_SYMBOL (pagecache_write_end) |
| |
| ssize_t | generic_file_direct_write (struct kiocb *iocb, const struct iovec *iov, unsigned long *nr_segs, loff_t pos, loff_t *ppos, size_t count, size_t ocount) |
| |
| | EXPORT_SYMBOL (generic_file_direct_write) |
| |
| struct page * | grab_cache_page_write_begin (struct address_space *mapping, pgoff_t index, unsigned flags) |
| |
| | EXPORT_SYMBOL (grab_cache_page_write_begin) |
| |
| ssize_t | generic_file_buffered_write (struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos, loff_t *ppos, size_t count, ssize_t written) |
| |
| | EXPORT_SYMBOL (generic_file_buffered_write) |
| |
| ssize_t | __generic_file_aio_write (struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t *ppos) |
| |
| | EXPORT_SYMBOL (__generic_file_aio_write) |
| |
| ssize_t | generic_file_aio_write (struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) |
| |
| | EXPORT_SYMBOL (generic_file_aio_write) |
| |
| int | try_to_release_page (struct page *page, gfp_t gfp_mask) |
| |
| | EXPORT_SYMBOL (try_to_release_page) |
| |
__filemap_fdatawrite_range - start writeback on mapping dirty pages in range : address space structure to write : offset in bytes where the range starts : offset in bytes where the range ends (inclusive) : enable synchronous operation
Start writeback against all of a mapping's dirty pages that lie within the byte offsets <start, end> inclusive.
If sync_mode is WB_SYNC_ALL then this is a "data integrity" operation, as opposed to a regular memory cleansing writeback. The difference between these two operations is that if a dirty page/buffer is encountered, it must be waited upon, and not just skipped over.
Definition at line 202 of file filemap.c.
__generic_file_aio_write - write data to a file : IO state structure (file, offset, etc.) : vector with data to write : number of segments in the vector : position where to write
This function does all the work needed for actually writing data to a file. It does all basic checks, removes SUID from the file, updates modification times and calls proper subroutines depending on whether we do direct IO or a standard buffered write.
It expects i_mutex to be grabbed unless we work on a block device or similar object which does not need locking at all.
This function does not take care of syncing data in case of O_SYNC write. A caller has to handle it. This is mainly due to the fact that we want to avoid syncing under i_mutex.
Definition at line 2413 of file filemap.c.
filemap_write_and_wait_range - write out & wait on a file range : the address_space for the pages : offset in bytes where the range starts : offset in bytes where the range ends (inclusive)
Write out and wait upon file offsets lstart->lend, inclusive.
Note that `lend' is inclusive (describes the last byte to be written) so that this function can be used to write to the very end-of-file (end = -1).
Definition at line 356 of file filemap.c.
find_get_pages - gang pagecache lookup : The address_space to search : The starting page index : The maximum number of pages : Where the resulting pages are placed
find_get_pages() will search for and return a group of up to pages in the mapping. The pages are placed at . find_get_pages() takes a reference against the returned pages.
The search returns a group of mapping-contiguous pages with ascending indexes. There may be holes in the indices due to not-present pages.
find_get_pages() returns the number of pages which were found.
Definition at line 812 of file filemap.c.
find_or_create_page - locate or add a pagecache page : the page's address_space : the page's index into the mapping : page allocation mode
Locates a page in the pagecache. If the page is not present, a new page is allocated using and is added to the pagecache and to the VM's LRU list. The returned page is locked and has its reference count incremented.
find_or_create_page() may sleep, even if specifies an atomic allocation!
find_or_create_page() returns the desired page's address, or zero on memory exhaustion.
Definition at line 766 of file filemap.c.
grab_cache_page_nowait - returns locked page at given index in given cache : target address_space : the page index
Same as grab_cache_page(), but do not wait if the page is unavailable. This is intended for speculative data generators, where the data can be regenerated if the page couldn't be grabbed. This routine should be safe to call while holding the lock for another page.
Clear __GFP_FS when allocating the page to avoid recursion into the fs and deadlock against the caller's locked page.
Definition at line 1028 of file filemap.c.
read_cache_page - read into page cache, fill it if needed : the page's address_space : the page index : function to perform the read : first arg to filler(data, page) function, often left as NULL
Read into the page cache. If a page already exists, and PageUptodate() is not set, try to fill the page then wait for it to become unlocked.
If the page does not get brought uptodate, return -EIO.
Definition at line 1916 of file filemap.c.
read_cache_page_async - read into page cache, fill it if needed : the page's address_space : the page index : function to perform the read : first arg to filler(data, page) function, often left as NULL
Same as read_cache_page, but don't wait for page to become unlocked after submitting it to the filler.
Read into the page cache. If a page already exists, and PageUptodate() is not set, try to fill the page but don't wait for it to become unlocked.
If the page does not get brought uptodate, return -EIO.
Definition at line 1862 of file filemap.c.
read_cache_page_gfp - read into page cache, using specified page allocation flags. : the page's address_space : the page index : the page allocator flags to use if allocating
This is the same as "read_mapping_page(mapping, index, NULL)", but with any new page allocations done using the specified allocation flags.
If the page does not get brought uptodate, return -EIO.
Definition at line 1894 of file filemap.c.
replace_page_cache_page - replace a pagecache page with a new one : page to be replaced : page to replace with : allocation mode
This function replaces a page in the pagecache with a new one. On success it acquires the pagecache reference for the new page and drops it for the old page. Both the old and new pages must be locked. This function does not add the new page to the LRU, the caller must do that.
The remove + add is atomic. The only way this function can fail is memory allocation failure.
Definition at line 391 of file filemap.c.
1.8.2