1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This file contians vfs address (mmap) ops for 9P2000.
4 *
5 * Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
6 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
7 */
8
9#include <linux/module.h>
10#include <linux/errno.h>
11#include <linux/fs.h>
12#include <linux/file.h>
13#include <linux/stat.h>
14#include <linux/string.h>
15#include <linux/pagemap.h>
16#include <linux/sched.h>
17#include <linux/swap.h>
18#include <linux/uio.h>
19#include <linux/netfs.h>
20#include <net/9p/9p.h>
21#include <net/9p/client.h>
22
23#include "v9fs.h"
24#include "v9fs_vfs.h"
25#include "cache.h"
26#include "fid.h"
27
28/**
29 * v9fs_issue_read - Issue a read from 9P
30 * @subreq: The read to make
31 */
32static void v9fs_issue_read(struct netfs_io_subrequest *subreq)
33{
34 struct netfs_io_request *rreq = subreq->rreq;
35 struct p9_fid *fid = rreq->netfs_priv;
36 struct iov_iter to;
37 loff_t pos = subreq->start + subreq->transferred;
38 size_t len = subreq->len - subreq->transferred;
39 int total, err;
40
41 iov_iter_xarray(i: &to, ITER_DEST, xarray: &rreq->mapping->i_pages, start: pos, count: len);
42
43 total = p9_client_read(fid, offset: pos, to: &to, err: &err);
44
45 /* if we just extended the file size, any portion not in
46 * cache won't be on server and is zeroes */
47 __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
48
49 netfs_subreq_terminated(subreq, err ?: total, false);
50}
51
52/**
53 * v9fs_init_request - Initialise a read request
54 * @rreq: The read request
55 * @file: The file being read from
56 */
57static int v9fs_init_request(struct netfs_io_request *rreq, struct file *file)
58{
59 struct p9_fid *fid = file->private_data;
60
61 BUG_ON(!fid);
62
63 /* we might need to read from a fid that was opened write-only
64 * for read-modify-write of page cache, use the writeback fid
65 * for that */
66 WARN_ON(rreq->origin == NETFS_READ_FOR_WRITE &&
67 !(fid->mode & P9_ORDWR));
68
69 p9_fid_get(fid);
70 rreq->netfs_priv = fid;
71 return 0;
72}
73
74/**
75 * v9fs_free_request - Cleanup request initialized by v9fs_init_rreq
76 * @rreq: The I/O request to clean up
77 */
78static void v9fs_free_request(struct netfs_io_request *rreq)
79{
80 struct p9_fid *fid = rreq->netfs_priv;
81
82 p9_fid_put(fid);
83}
84
85/**
86 * v9fs_begin_cache_operation - Begin a cache operation for a read
87 * @rreq: The read request
88 */
89static int v9fs_begin_cache_operation(struct netfs_io_request *rreq)
90{
91#ifdef CONFIG_9P_FSCACHE
92 struct fscache_cookie *cookie = v9fs_inode_cookie(v9inode: V9FS_I(inode: rreq->inode));
93
94 return fscache_begin_read_operation(cres: &rreq->cache_resources, cookie);
95#else
96 return -ENOBUFS;
97#endif
98}
99
100const struct netfs_request_ops v9fs_req_ops = {
101 .init_request = v9fs_init_request,
102 .free_request = v9fs_free_request,
103 .begin_cache_operation = v9fs_begin_cache_operation,
104 .issue_read = v9fs_issue_read,
105};
106
107/**
108 * v9fs_release_folio - release the private state associated with a folio
109 * @folio: The folio to be released
110 * @gfp: The caller's allocation restrictions
111 *
112 * Returns true if the page can be released, false otherwise.
113 */
114
115static bool v9fs_release_folio(struct folio *folio, gfp_t gfp)
116{
117 if (folio_test_private(folio))
118 return false;
119#ifdef CONFIG_9P_FSCACHE
120 if (folio_test_fscache(folio)) {
121 if (current_is_kswapd() || !(gfp & __GFP_FS))
122 return false;
123 folio_wait_fscache(folio);
124 }
125 fscache_note_page_release(cookie: v9fs_inode_cookie(v9inode: V9FS_I(inode: folio_inode(folio))));
126#endif
127 return true;
128}
129
130static void v9fs_invalidate_folio(struct folio *folio, size_t offset,
131 size_t length)
132{
133 folio_wait_fscache(folio);
134}
135
136#ifdef CONFIG_9P_FSCACHE
137static void v9fs_write_to_cache_done(void *priv, ssize_t transferred_or_error,
138 bool was_async)
139{
140 struct v9fs_inode *v9inode = priv;
141 __le32 version;
142
143 if (IS_ERR_VALUE(transferred_or_error) &&
144 transferred_or_error != -ENOBUFS) {
145 version = cpu_to_le32(v9inode->qid.version);
146 fscache_invalidate(cookie: v9fs_inode_cookie(v9inode), aux_data: &version,
147 size: i_size_read(inode: &v9inode->netfs.inode), flags: 0);
148 }
149}
150#endif
151
152static int v9fs_vfs_write_folio_locked(struct folio *folio)
153{
154 struct inode *inode = folio_inode(folio);
155 loff_t start = folio_pos(folio);
156 loff_t i_size = i_size_read(inode);
157 struct iov_iter from;
158 size_t len = folio_size(folio);
159 struct p9_fid *writeback_fid;
160 int err;
161 struct v9fs_inode __maybe_unused *v9inode = V9FS_I(inode);
162 struct fscache_cookie __maybe_unused *cookie = v9fs_inode_cookie(v9inode);
163
164 if (start >= i_size)
165 return 0; /* Simultaneous truncation occurred */
166
167 len = min_t(loff_t, i_size - start, len);
168
169 iov_iter_xarray(i: &from, ITER_SOURCE, xarray: &folio_mapping(folio)->i_pages, start, count: len);
170
171 writeback_fid = v9fs_fid_find_inode(inode, want_writeable: true, INVALID_UID, any: true);
172 if (!writeback_fid) {
173 WARN_ONCE(1, "folio expected an open fid inode->i_private=%p\n",
174 inode->i_private);
175 return -EINVAL;
176 }
177
178 folio_wait_fscache(folio);
179 folio_start_writeback(folio);
180
181 p9_client_write(fid: writeback_fid, offset: start, from: &from, err: &err);
182
183#ifdef CONFIG_9P_FSCACHE
184 if (err == 0 &&
185 fscache_cookie_enabled(cookie) &&
186 test_bit(FSCACHE_COOKIE_IS_CACHING, &cookie->flags)) {
187 folio_start_fscache(folio);
188 fscache_write_to_cache(cookie: v9fs_inode_cookie(v9inode),
189 mapping: folio_mapping(folio), start, len, i_size,
190 term_func: v9fs_write_to_cache_done, term_func_priv: v9inode,
191 caching: true);
192 }
193#endif
194
195 folio_end_writeback(folio);
196 p9_fid_put(fid: writeback_fid);
197
198 return err;
199}
200
201static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc)
202{
203 struct folio *folio = page_folio(page);
204 int retval;
205
206 p9_debug(P9_DEBUG_VFS, "folio %p\n", folio);
207
208 retval = v9fs_vfs_write_folio_locked(folio);
209 if (retval < 0) {
210 if (retval == -EAGAIN) {
211 folio_redirty_for_writepage(wbc, folio);
212 retval = 0;
213 } else {
214 mapping_set_error(mapping: folio_mapping(folio), error: retval);
215 }
216 } else
217 retval = 0;
218
219 folio_unlock(folio);
220 return retval;
221}
222
223static int v9fs_launder_folio(struct folio *folio)
224{
225 int retval;
226
227 if (folio_clear_dirty_for_io(folio)) {
228 retval = v9fs_vfs_write_folio_locked(folio);
229 if (retval)
230 return retval;
231 }
232 folio_wait_fscache(folio);
233 return 0;
234}
235
236/**
237 * v9fs_direct_IO - 9P address space operation for direct I/O
238 * @iocb: target I/O control block
239 * @iter: The data/buffer to use
240 *
241 * The presence of v9fs_direct_IO() in the address space ops vector
242 * allowes open() O_DIRECT flags which would have failed otherwise.
243 *
244 * In the non-cached mode, we shunt off direct read and write requests before
245 * the VFS gets them, so this method should never be called.
246 *
247 * Direct IO is not 'yet' supported in the cached mode. Hence when
248 * this routine is called through generic_file_aio_read(), the read/write fails
249 * with an error.
250 *
251 */
252static ssize_t
253v9fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
254{
255 struct file *file = iocb->ki_filp;
256 loff_t pos = iocb->ki_pos;
257 ssize_t n;
258 int err = 0;
259
260 if (iov_iter_rw(i: iter) == WRITE) {
261 n = p9_client_write(fid: file->private_data, offset: pos, from: iter, err: &err);
262 if (n) {
263 struct inode *inode = file_inode(f: file);
264 loff_t i_size = i_size_read(inode);
265
266 if (pos + n > i_size)
267 inode_add_bytes(inode, bytes: pos + n - i_size);
268 }
269 } else {
270 n = p9_client_read(fid: file->private_data, offset: pos, to: iter, err: &err);
271 }
272 return n ? n : err;
273}
274
275static int v9fs_write_begin(struct file *filp, struct address_space *mapping,
276 loff_t pos, unsigned int len,
277 struct page **subpagep, void **fsdata)
278{
279 int retval;
280 struct folio *folio;
281 struct v9fs_inode *v9inode = V9FS_I(inode: mapping->host);
282
283 p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping);
284
285 /* Prefetch area to be written into the cache if we're caching this
286 * file. We need to do this before we get a lock on the page in case
287 * there's more than one writer competing for the same cache block.
288 */
289 retval = netfs_write_begin(&v9inode->netfs, filp, mapping, pos, len, &folio, fsdata);
290 if (retval < 0)
291 return retval;
292
293 *subpagep = &folio->page;
294 return retval;
295}
296
297static int v9fs_write_end(struct file *filp, struct address_space *mapping,
298 loff_t pos, unsigned int len, unsigned int copied,
299 struct page *subpage, void *fsdata)
300{
301 loff_t last_pos = pos + copied;
302 struct folio *folio = page_folio(subpage);
303 struct inode *inode = mapping->host;
304
305 p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping);
306
307 if (!folio_test_uptodate(folio)) {
308 if (unlikely(copied < len)) {
309 copied = 0;
310 goto out;
311 }
312
313 folio_mark_uptodate(folio);
314 }
315
316 /*
317 * No need to use i_size_read() here, the i_size
318 * cannot change under us because we hold the i_mutex.
319 */
320 if (last_pos > inode->i_size) {
321 inode_add_bytes(inode, bytes: last_pos - inode->i_size);
322 i_size_write(inode, i_size: last_pos);
323#ifdef CONFIG_9P_FSCACHE
324 fscache_update_cookie(cookie: v9fs_inode_cookie(v9inode: V9FS_I(inode)), NULL,
325 object_size: &last_pos);
326#endif
327 }
328 folio_mark_dirty(folio);
329out:
330 folio_unlock(folio);
331 folio_put(folio);
332
333 return copied;
334}
335
336#ifdef CONFIG_9P_FSCACHE
337/*
338 * Mark a page as having been made dirty and thus needing writeback. We also
339 * need to pin the cache object to write back to.
340 */
341static bool v9fs_dirty_folio(struct address_space *mapping, struct folio *folio)
342{
343 struct v9fs_inode *v9inode = V9FS_I(inode: mapping->host);
344
345 return fscache_dirty_folio(mapping, folio, cookie: v9fs_inode_cookie(v9inode));
346}
347#else
348#define v9fs_dirty_folio filemap_dirty_folio
349#endif
350
351const struct address_space_operations v9fs_addr_operations = {
352 .read_folio = netfs_read_folio,
353 .readahead = netfs_readahead,
354 .dirty_folio = v9fs_dirty_folio,
355 .writepage = v9fs_vfs_writepage,
356 .write_begin = v9fs_write_begin,
357 .write_end = v9fs_write_end,
358 .release_folio = v9fs_release_folio,
359 .invalidate_folio = v9fs_invalidate_folio,
360 .launder_folio = v9fs_launder_folio,
361 .direct_IO = v9fs_direct_IO,
362};
363

source code of linux/fs/9p/vfs_addr.c