vfs_addr.c 3.96 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * This file contians vfs address (mmap) ops for 9P2000.
 *
 *  Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/pagemap.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
16
#include <linux/sched.h>
17
#include <linux/swap.h>
18
#include <linux/uio.h>
19
#include <linux/netfs.h>
20 21
#include <net/9p/9p.h>
#include <net/9p/client.h>
22
#include <trace/events/netfs.h>
23 24 25

#include "v9fs.h"
#include "v9fs_vfs.h"
26
#include "cache.h"
27
#include "fid.h"
28

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
static void v9fs_upload_to_server(struct netfs_io_subrequest *subreq)
{
	struct p9_fid *fid = subreq->rreq->netfs_priv;
	int err;

	trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
	p9_client_write(fid, subreq->start, &subreq->io_iter, &err);
	netfs_write_subrequest_terminated(subreq, err < 0 ? err : subreq->len,
					  false);
}

static void v9fs_upload_to_server_worker(struct work_struct *work)
{
	struct netfs_io_subrequest *subreq =
		container_of(work, struct netfs_io_subrequest, work);

	v9fs_upload_to_server(subreq);
}

/*
 * Set up write requests for a writeback slice.  We need to add a write request
 * for each write we want to make.
 */
static void v9fs_create_write_requests(struct netfs_io_request *wreq, loff_t start, size_t len)
{
	struct netfs_io_subrequest *subreq;

	subreq = netfs_create_write_request(wreq, NETFS_UPLOAD_TO_SERVER,
					    start, len, v9fs_upload_to_server_worker);
	if (subreq)
		netfs_queue_write_request(subreq);
}

62
/**
63
 * v9fs_issue_read - Issue a read from 9P
64
 * @subreq: The read to make
65
 */
66
static void v9fs_issue_read(struct netfs_io_subrequest *subreq)
67
{
68
	struct netfs_io_request *rreq = subreq->rreq;
69 70
	struct p9_fid *fid = rreq->netfs_priv;
	int total, err;
71

72 73
	total = p9_client_read(fid, subreq->start + subreq->transferred,
			       &subreq->io_iter, &err);
74 75 76 77 78

	/* if we just extended the file size, any portion not in
	 * cache won't be on server and is zeroes */
	__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);

79 80
	netfs_subreq_terminated(subreq, err ?: total, false);
}
81

82
/**
83
 * v9fs_init_request - Initialise a request
84 85 86
 * @rreq: The read request
 * @file: The file being read from
 */
87
static int v9fs_init_request(struct netfs_io_request *rreq, struct file *file)
88
{
89 90 91 92 93 94 95 96 97 98
	struct p9_fid *fid;
	bool writing = (rreq->origin == NETFS_READ_FOR_WRITE ||
			rreq->origin == NETFS_WRITEBACK ||
			rreq->origin == NETFS_WRITETHROUGH ||
			rreq->origin == NETFS_LAUNDER_WRITE ||
			rreq->origin == NETFS_UNBUFFERED_WRITE ||
			rreq->origin == NETFS_DIO_WRITE);

	if (file) {
		fid = file->private_data;
99 100
		if (!fid)
			goto no_fid;
101 102 103
		p9_fid_get(fid);
	} else {
		fid = v9fs_fid_find_inode(rreq->inode, writing, INVALID_UID, true);
104 105
		if (!fid)
			goto no_fid;
106
	}
107 108 109 110

	/* we might need to read from a fid that was opened write-only
	 * for read-modify-write of page cache, use the writeback fid
	 * for that */
111
	WARN_ON(rreq->origin == NETFS_READ_FOR_WRITE && !(fid->mode & P9_ORDWR));
112
	rreq->netfs_priv = fid;
113
	return 0;
114 115 116 117 118

no_fid:
	WARN_ONCE(1, "folio expected an open fid inode->i_ino=%lx\n",
		  rreq->inode->i_ino);
	return -EINVAL;
119
}
120

121
/**
122 123
 * v9fs_free_request - Cleanup request initialized by v9fs_init_rreq
 * @rreq: The I/O request to clean up
124
 */
125
static void v9fs_free_request(struct netfs_io_request *rreq)
126
{
127
	struct p9_fid *fid = rreq->netfs_priv;
128

129
	p9_fid_put(fid);
130
}
131

132
const struct netfs_request_ops v9fs_req_ops = {
133
	.init_request		= v9fs_init_request,
134
	.free_request		= v9fs_free_request,
135
	.issue_read		= v9fs_issue_read,
136
	.create_write_requests	= v9fs_create_write_requests,
137 138
};

139
const struct address_space_operations v9fs_addr_operations = {
140 141 142 143 144 145 146 147
	.read_folio		= netfs_read_folio,
	.readahead		= netfs_readahead,
	.dirty_folio		= netfs_dirty_folio,
	.release_folio		= netfs_release_folio,
	.invalidate_folio	= netfs_invalidate_folio,
	.launder_folio		= netfs_launder_folio,
	.direct_IO		= noop_direct_IO,
	.writepages		= netfs_writepages,
148
};