1
2
3
4
5
6
7
8
9
10
11#include <linux/module.h>
12#include <linux/errno.h>
13#include <linux/fs.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>
25
26#include "v9fs.h"
27#include "v9fs_vfs.h"
28#include "cache.h"
29#include "fid.h"
30
31
32
33
34
35
36
37static int v9fs_fid_readpage(void *data, struct page *page)
38{
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};
42 struct iov_iter to;
43 int retval, err;
44
45 p9_debug(P9_DEBUG_VFS, "\n");
46
47 BUG_ON(!PageLocked(page));
48
49 retval = v9fs_readpage_from_fscache(inode, page);
50 if (retval == 0)
51 return retval;
52
53 iov_iter_bvec(&to, READ, &bvec, 1, PAGE_SIZE);
54
55 retval = p9_client_read(fid, page_offset(page), &to, &err);
56 if (err) {
57 v9fs_uncache_page(inode, page);
58 retval = err;
59 goto done;
60 }
61
62 zero_user(page, retval, PAGE_SIZE - retval);
63 flush_dcache_page(page);
64 SetPageUptodate(page);
65
66 v9fs_readpage_to_fscache(inode, page);
67 retval = 0;
68
69done:
70 unlock_page(page);
71 return retval;
72}
73
74
75
76
77
78
79
80
81
82static int v9fs_vfs_readpage(struct file *filp, struct page *page)
83{
84 return v9fs_fid_readpage(filp->private_data, page);
85}
86
87
88
89
90
91
92
93
94
95
96
97static int v9fs_vfs_readpages(struct file *filp, struct address_space *mapping,
98 struct list_head *pages, unsigned nr_pages)
99{
100 int ret = 0;
101 struct inode *inode;
102
103 inode = mapping->host;
104 p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, filp);
105
106 ret = v9fs_readpages_from_fscache(inode, mapping, pages, &nr_pages);
107 if (ret == 0)
108 return ret;
109
110 ret = read_cache_pages(mapping, pages, v9fs_fid_readpage,
111 filp->private_data);
112 p9_debug(P9_DEBUG_VFS, " = %d\n", ret);
113 return ret;
114}
115
116
117
118
119
120
121
122
123
124static int v9fs_release_page(struct page *page, gfp_t gfp)
125{
126 if (PagePrivate(page))
127 return 0;
128 return v9fs_fscache_release_page(page, gfp);
129}
130
131
132
133
134
135
136
137
138static void v9fs_invalidate_page(struct page *page, unsigned int offset,
139 unsigned int length)
140{
141
142
143
144
145 if (offset == 0 && length == PAGE_SIZE)
146 v9fs_fscache_invalidate_page(page);
147}
148
149static int v9fs_vfs_writepage_locked(struct page *page)
150{
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;
155 struct bio_vec bvec;
156 int err, len;
157
158 if (page->index == size >> PAGE_SHIFT)
159 len = size & ~PAGE_MASK;
160 else
161 len = PAGE_SIZE;
162
163 bvec.bv_page = page;
164 bvec.bv_offset = 0;
165 bvec.bv_len = len;
166 iov_iter_bvec(&from, WRITE, &bvec, 1, len);
167
168
169 BUG_ON(!v9inode->writeback_fid);
170
171 set_page_writeback(page);
172
173 p9_client_write(v9inode->writeback_fid, page_offset(page), &from, &err);
174
175 end_page_writeback(page);
176 return err;
177}
178
179static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc)
180{
181 int retval;
182
183 p9_debug(P9_DEBUG_VFS, "page %p\n", page);
184
185 retval = v9fs_vfs_writepage_locked(page);
186 if (retval < 0) {
187 if (retval == -EAGAIN) {
188 redirty_page_for_writepage(wbc, page);
189 retval = 0;
190 } else {
191 SetPageError(page);
192 mapping_set_error(page->mapping, retval);
193 }
194 } else
195 retval = 0;
196
197 unlock_page(page);
198 return retval;
199}
200
201
202
203
204
205
206
207
208static int v9fs_launder_page(struct page *page)
209{
210 int retval;
211 struct inode *inode = page->mapping->host;
212
213 v9fs_fscache_wait_on_page_write(inode, page);
214 if (clear_page_dirty_for_io(page)) {
215 retval = v9fs_vfs_writepage_locked(page);
216 if (retval)
217 return retval;
218 }
219 return 0;
220}
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238static ssize_t
239v9fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
240{
241 struct file *file = iocb->ki_filp;
242 loff_t pos = iocb->ki_pos;
243 ssize_t n;
244 int err = 0;
245 if (iov_iter_rw(iter) == WRITE) {
246 n = p9_client_write(file->private_data, pos, iter, &err);
247 if (n) {
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);
252 }
253 } else {
254 n = p9_client_read(file->private_data, pos, iter, &err);
255 }
256 return n ? n : err;
257}
258
259static 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)
262{
263 int retval = 0;
264 struct page *page;
265 struct v9fs_inode *v9inode;
266 pgoff_t index = pos >> PAGE_SHIFT;
267 struct inode *inode = mapping->host;
268
269
270 p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping);
271
272 v9inode = V9FS_I(inode);
273start:
274 page = grab_cache_page_write_begin(mapping, index, flags);
275 if (!page) {
276 retval = -ENOMEM;
277 goto out;
278 }
279 BUG_ON(!v9inode->writeback_fid);
280 if (PageUptodate(page))
281 goto out;
282
283 if (len == PAGE_SIZE)
284 goto out;
285
286 retval = v9fs_fid_readpage(v9inode->writeback_fid, page);
287 put_page(page);
288 if (!retval)
289 goto start;
290out:
291 *pagep = page;
292 return retval;
293}
294
295static 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)
298{
299 loff_t last_pos = pos + copied;
300 struct inode *inode = page->mapping->host;
301
302 p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping);
303
304 if (!PageUptodate(page)) {
305 if (unlikely(copied < len)) {
306 copied = 0;
307 goto out;
308 } else if (len == PAGE_SIZE) {
309 SetPageUptodate(page);
310 }
311 }
312
313
314
315
316 if (last_pos > inode->i_size) {
317 inode_add_bytes(inode, last_pos - inode->i_size);
318 i_size_write(inode, last_pos);
319 }
320 set_page_dirty(page);
321out:
322 unlock_page(page);
323 put_page(page);
324
325 return copied;
326}
327
328
329const 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,
340};
341