linux/fs/nfs/read.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * linux/fs/nfs/read.c
 *
 * Block I/O for NFS
 *
 * Partial copy of Linus' read cache modifications to fs/nfs/file.c
 * modified for async RPC by [email protected]
 */

#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/task_io_accounting_ops.h>
#include <linux/pagemap.h>
#include <linux/sunrpc/clnt.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
#include <linux/module.h>

#include "nfs4_fs.h"
#include "internal.h"
#include "iostat.h"
#include "fscache.h"
#include "pnfs.h"
#include "nfstrace.h"
#include "delegation.h"

#define NFSDBG_FACILITY …

const struct nfs_pgio_completion_ops nfs_async_read_completion_ops;
static const struct nfs_rw_ops nfs_rw_read_ops;

static struct kmem_cache *nfs_rdata_cachep;

static struct nfs_pgio_header *nfs_readhdr_alloc(void)
{ … }

static void nfs_readhdr_free(struct nfs_pgio_header *rhdr)
{ … }

static int nfs_return_empty_folio(struct folio *folio)
{ … }

void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
			      struct inode *inode, bool force_mds,
			      const struct nfs_pgio_completion_ops *compl_ops)
{ … }
EXPORT_SYMBOL_GPL(…);

void nfs_pageio_complete_read(struct nfs_pageio_descriptor *pgio)
{ … }


void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio)
{ … }
EXPORT_SYMBOL_GPL(…);

bool nfs_read_alloc_scratch(struct nfs_pgio_header *hdr, size_t size)
{ … }
EXPORT_SYMBOL_GPL(…);

static void nfs_readpage_release(struct nfs_page *req, int error)
{ … }

static void nfs_page_group_set_uptodate(struct nfs_page *req)
{ … }

static void nfs_read_completion(struct nfs_pgio_header *hdr)
{ … }

static void nfs_initiate_read(struct nfs_pgio_header *hdr,
			      struct rpc_message *msg,
			      const struct nfs_rpc_ops *rpc_ops,
			      struct rpc_task_setup *task_setup_data, int how)
{ … }

static void
nfs_async_read_error(struct list_head *head, int error)
{ … }

const struct nfs_pgio_completion_ops nfs_async_read_completion_ops = …;

/*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
 */
static int nfs_readpage_done(struct rpc_task *task,
			     struct nfs_pgio_header *hdr,
			     struct inode *inode)
{ … }

static void nfs_readpage_retry(struct rpc_task *task,
			       struct nfs_pgio_header *hdr)
{ … }

static void nfs_readpage_result(struct rpc_task *task,
				struct nfs_pgio_header *hdr)
{ … }

int nfs_read_add_folio(struct nfs_pageio_descriptor *pgio,
		       struct nfs_open_context *ctx,
		       struct folio *folio)
{ … }

/*
 * Actually read a folio over the wire.
 */
static int nfs_do_read_folio(struct file *file, struct folio *folio)
{ … }

/*
 * Synchronously read a folio.
 *
 * This is not heavily used as most users to try an asynchronous
 * large read through ->readahead first.
 */
int nfs_read_folio(struct file *file, struct folio *folio)
{ … }

void nfs_readahead(struct readahead_control *ractl)
{ … }

int __init nfs_init_readpagecache(void)
{ … }

void nfs_destroy_readpagecache(void)
{ … }

static const struct nfs_rw_ops nfs_rw_read_ops = …;