1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/fs/9p/vfs_addr.c
5 * This file contians vfs address (mmap) ops for 9P2000.
7 * Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
8 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
11 #include <linux/module.h>
12 #include <linux/errno.h>
14 #include <linux/file.h>
15 #include <linux/stat.h>
16 #include <linux/string.h>
17 #include <linux/inet.h>
18 #include <linux/pagemap.h>
19 #include <linux/idr.h>
20 #include <linux/sched.h>
21 #include <linux/uio.h>
22 #include <linux/bvec.h>
23 #include <net/9p/9p.h>
24 #include <net/9p/client.h>
32 * v9fs_fid_readpage - read an entire page in from 9P
33 * @data: Opaque pointer to the fid being read
34 * @page: structure to page
37 static int v9fs_fid_readpage(void *data
, struct page
*page
)
39 struct p9_fid
*fid
= data
;
40 struct inode
*inode
= page
->mapping
->host
;
41 struct bio_vec bvec
= {.bv_page
= page
, .bv_len
= PAGE_SIZE
};
45 p9_debug(P9_DEBUG_VFS
, "\n");
47 BUG_ON(!PageLocked(page
));
49 retval
= v9fs_readpage_from_fscache(inode
, page
);
53 iov_iter_bvec(&to
, READ
, &bvec
, 1, PAGE_SIZE
);
55 retval
= p9_client_read(fid
, page_offset(page
), &to
, &err
);
57 v9fs_uncache_page(inode
, page
);
62 zero_user(page
, retval
, PAGE_SIZE
- retval
);
63 flush_dcache_page(page
);
64 SetPageUptodate(page
);
66 v9fs_readpage_to_fscache(inode
, page
);
75 * v9fs_vfs_readpage - read an entire page in from 9P
77 * @filp: file being read
78 * @page: structure to page
82 static int v9fs_vfs_readpage(struct file
*filp
, struct page
*page
)
84 return v9fs_fid_readpage(filp
->private_data
, page
);
88 * v9fs_vfs_readpages - read a set of pages from 9P
90 * @filp: file being read
91 * @mapping: the address space
92 * @pages: list of pages to read
93 * @nr_pages: count of pages to read
97 static int v9fs_vfs_readpages(struct file
*filp
, struct address_space
*mapping
,
98 struct list_head
*pages
, unsigned nr_pages
)
103 inode
= mapping
->host
;
104 p9_debug(P9_DEBUG_VFS
, "inode: %p file: %p\n", inode
, filp
);
106 ret
= v9fs_readpages_from_fscache(inode
, mapping
, pages
, &nr_pages
);
110 ret
= read_cache_pages(mapping
, pages
, v9fs_fid_readpage
,
112 p9_debug(P9_DEBUG_VFS
, " = %d\n", ret
);
117 * v9fs_release_page - release the private state associated with a page
118 * @page: The page to be released
119 * @gfp: The caller's allocation restrictions
121 * Returns 1 if the page can be released, false otherwise.
124 static int v9fs_release_page(struct page
*page
, gfp_t gfp
)
126 if (PagePrivate(page
))
128 return v9fs_fscache_release_page(page
, gfp
);
132 * v9fs_invalidate_page - Invalidate a page completely or partially
133 * @page: The page to be invalidated
134 * @offset: offset of the invalidated region
135 * @length: length of the invalidated region
138 static void v9fs_invalidate_page(struct page
*page
, unsigned int offset
,
142 * If called with zero offset, we should release
143 * the private state assocated with the page
145 if (offset
== 0 && length
== PAGE_SIZE
)
146 v9fs_fscache_invalidate_page(page
);
149 static int v9fs_vfs_writepage_locked(struct page
*page
)
151 struct inode
*inode
= page
->mapping
->host
;
152 struct v9fs_inode
*v9inode
= V9FS_I(inode
);
153 loff_t size
= i_size_read(inode
);
154 struct iov_iter from
;
158 if (page
->index
== size
>> PAGE_SHIFT
)
159 len
= size
& ~PAGE_MASK
;
166 iov_iter_bvec(&from
, WRITE
, &bvec
, 1, len
);
168 /* We should have writeback_fid always set */
169 BUG_ON(!v9inode
->writeback_fid
);
171 set_page_writeback(page
);
173 p9_client_write(v9inode
->writeback_fid
, page_offset(page
), &from
, &err
);
175 end_page_writeback(page
);
179 static int v9fs_vfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
183 p9_debug(P9_DEBUG_VFS
, "page %p\n", page
);
185 retval
= v9fs_vfs_writepage_locked(page
);
187 if (retval
== -EAGAIN
) {
188 redirty_page_for_writepage(wbc
, page
);
192 mapping_set_error(page
->mapping
, retval
);
202 * v9fs_launder_page - Writeback a dirty page
203 * @page: The page to be cleaned up
205 * Returns 0 on success.
208 static int v9fs_launder_page(struct page
*page
)
211 struct inode
*inode
= page
->mapping
->host
;
213 v9fs_fscache_wait_on_page_write(inode
, page
);
214 if (clear_page_dirty_for_io(page
)) {
215 retval
= v9fs_vfs_writepage_locked(page
);
223 * v9fs_direct_IO - 9P address space operation for direct I/O
224 * @iocb: target I/O control block
225 * @iter: The data/buffer to use
227 * The presence of v9fs_direct_IO() in the address space ops vector
228 * allowes open() O_DIRECT flags which would have failed otherwise.
230 * In the non-cached mode, we shunt off direct read and write requests before
231 * the VFS gets them, so this method should never be called.
233 * Direct IO is not 'yet' supported in the cached mode. Hence when
234 * this routine is called through generic_file_aio_read(), the read/write fails
239 v9fs_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
241 struct file
*file
= iocb
->ki_filp
;
242 loff_t pos
= iocb
->ki_pos
;
245 if (iov_iter_rw(iter
) == WRITE
) {
246 n
= p9_client_write(file
->private_data
, pos
, iter
, &err
);
248 struct inode
*inode
= file_inode(file
);
249 loff_t i_size
= i_size_read(inode
);
250 if (pos
+ n
> i_size
)
251 inode_add_bytes(inode
, pos
+ n
- i_size
);
254 n
= p9_client_read(file
->private_data
, pos
, iter
, &err
);
259 static int v9fs_write_begin(struct file
*filp
, struct address_space
*mapping
,
260 loff_t pos
, unsigned len
, unsigned flags
,
261 struct page
**pagep
, void **fsdata
)
265 struct v9fs_inode
*v9inode
;
266 pgoff_t index
= pos
>> PAGE_SHIFT
;
267 struct inode
*inode
= mapping
->host
;
270 p9_debug(P9_DEBUG_VFS
, "filp %p, mapping %p\n", filp
, mapping
);
272 v9inode
= V9FS_I(inode
);
274 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
279 BUG_ON(!v9inode
->writeback_fid
);
280 if (PageUptodate(page
))
283 if (len
== PAGE_SIZE
)
286 retval
= v9fs_fid_readpage(v9inode
->writeback_fid
, page
);
295 static int v9fs_write_end(struct file
*filp
, struct address_space
*mapping
,
296 loff_t pos
, unsigned len
, unsigned copied
,
297 struct page
*page
, void *fsdata
)
299 loff_t last_pos
= pos
+ copied
;
300 struct inode
*inode
= page
->mapping
->host
;
302 p9_debug(P9_DEBUG_VFS
, "filp %p, mapping %p\n", filp
, mapping
);
304 if (!PageUptodate(page
)) {
305 if (unlikely(copied
< len
)) {
308 } else if (len
== PAGE_SIZE
) {
309 SetPageUptodate(page
);
313 * No need to use i_size_read() here, the i_size
314 * cannot change under us because we hold the i_mutex.
316 if (last_pos
> inode
->i_size
) {
317 inode_add_bytes(inode
, last_pos
- inode
->i_size
);
318 i_size_write(inode
, last_pos
);
320 set_page_dirty(page
);
329 const struct address_space_operations v9fs_addr_operations
= {
330 .readpage
= v9fs_vfs_readpage
,
331 .readpages
= v9fs_vfs_readpages
,
332 .set_page_dirty
= __set_page_dirty_nobuffers
,
333 .writepage
= v9fs_vfs_writepage
,
334 .write_begin
= v9fs_write_begin
,
335 .write_end
= v9fs_write_end
,
336 .releasepage
= v9fs_release_page
,
337 .invalidatepage
= v9fs_invalidate_page
,
338 .launder_page
= v9fs_launder_page
,
339 .direct_IO
= v9fs_direct_IO
,