Linux Kernel: page to be flushed.

flush_icache_page - Flush a page from the dcache and invalidate the icache : The VMA the page is part of.

Write a page back from the dcache and invalidate the icache so that we can run code from it that we've just written into it

struct efx_rx_buffer - An Efx RX data buffer : DMA base address of the buffer : The associated socket buffer. Valid iff !( & EFX_RX_BUF_PAGE). Will be NULL if the buffer slot is currently free.

Will be NULL if the buffer slot is currently free. : Buffer length, in bytes. : Flags for buffer and packet state.

: The fsdata (unused)

gfs2_writepage_common - Common bits of writepage

: The writeback control

Returns: 1 if writepage is ok, otherwise an error code or zero if no error.

gfs2_writeback_writepage - Write page for writeback mappings

: The writeback control

gfs2_ordered_writepage - Write page for ordered data files

: The writeback control

__gfs2_jdata_writepage - The core of jdata writepage

: The writeback control

This is shared between writepage and writepages and implements the core of the writepage operation. If a transaction is required then PageChecked will have been set and the transaction will have already been started before this is called.

This is the core of gfs2's readpage. Its used by the internal file reading code as in that case we already hold the glock. Also its called by gfs2_readpage() once the required lock has been granted.

This deals with the locking required. We have to unlock and relock the page in order to get the locking in the right order.

gfs2_stuffed_write_end - Write end for stuffed files : The inode : The buffer_head containing the on-disk inode : The file position : The length of the write : How much was actually copied by the VFS

This copies the data from the page into the inode block after the inode data structure itself.

Returns: errno

: The fsdata (unused in GFS2)

The main write_end function for GFS2. We have a separate one for stuffed files as they are slightly different, otherwise we just put our locking around the VFS provided functions.

Returns: errno

gfs2_set_page_dirty - Page dirtying function

Returns: 1 if it dirtyed the page, or 0 otherwise

gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page : the inode : the dinode buffer : the block number that was allocated

Returns: errno

gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big : The GFS2 inode to unstuff

This routine unstuffs a dinode and returns it to a "normal" state such that the height can be grown in the traditional way.

Returns: errno

gfs2_allocate_page_backing - Use bmap to allocate blocks

We try to allocate all the blocks required for the page in one go. This might fail for various reasons, so we keep trying until all the blocks to back this page are allocated. If some of the blocks are already allocated, thats ok too.

gfs2_page_mkwrite - Make a shared, mmap()ed, page writable : The virtual memory area

When the page becomes writable, we need to ensure that we have blocks allocated on disk to back that page.

gfs2_log_write_page - write one block stored in a page, into the log : The superblock

This writes the first block-sized part of the page into the log. Note that the page must have been allocated from the gfs2_page_pool mempool and that after this has been called, ownership has been transferred and the page may be freed at any time.

struct ttm_bo_kmap_obj

: The current kernel virtual address.

: Type of bo_kmap.

Object describing a kernel mapping. Since a TTM bo may be located in various memory types with various caching policies, the mapping can either be an ioremap, a vmap, a kmap or part of a premapped region.

fscache_end_io - End a retrieval operation on a page : The FS-Cache operation covering the retrieval

: The error code (0 if successful)

Note the end of an operation to retrieve a page, as covered by a particular operation record.

fscache_read_or_alloc_page - Read a page from the cache or allocate a block in which to store it : The cookie representing the cache object

: The callback to invoke when and if the page is filled : An arbitrary piece of data to pass on to end_io_func() : The conditions under which memory allocation should be made

Read a page from the cache, or if that's not possible make a potential one-block reservation in the cache into which the page may be stored once fetched from the server.

If the page is not backed by the cache object, or if it there's some reason it can't be, -ENOBUFS will be returned and nothing more will be done for that page.

Else, if that page is backed by the cache, a read will be initiated directly to the netfs's page and 0 will be returned by this function. The end_io_func() callback will be invoked when the operation terminates on a completion or failure. Note that the callback may be invoked before the return.

Else, if the page is unbacked, -ENODATA is returned and a block may have been allocated in the cache.