Commit | Line | Data |
---|---|---|
147b31cf EVH |
1 | /* |
2 | * linux/fs/9p/vfs_addr.c | |
3 | * | |
4 | * This file contians vfs address (mmap) ops for 9P2000. | |
5 | * | |
6 | * Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com> | |
7 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
42e8c509 EVH |
10 | * it under the terms of the GNU General Public License version 2 |
11 | * as published by the Free Software Foundation. | |
147b31cf EVH |
12 | * |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to: | |
20 | * Free Software Foundation | |
21 | * 51 Franklin Street, Fifth Floor | |
22 | * Boston, MA 02111-1301 USA | |
23 | * | |
24 | */ | |
25 | ||
26 | #include <linux/module.h> | |
27 | #include <linux/errno.h> | |
28 | #include <linux/fs.h> | |
29 | #include <linux/file.h> | |
30 | #include <linux/stat.h> | |
31 | #include <linux/string.h> | |
147b31cf | 32 | #include <linux/inet.h> |
147b31cf EVH |
33 | #include <linux/pagemap.h> |
34 | #include <linux/idr.h> | |
e8edc6e0 | 35 | #include <linux/sched.h> |
e2e40f2c | 36 | #include <linux/uio.h> |
bd238fb4 LI |
37 | #include <net/9p/9p.h> |
38 | #include <net/9p/client.h> | |
147b31cf | 39 | |
147b31cf | 40 | #include "v9fs.h" |
147b31cf | 41 | #include "v9fs_vfs.h" |
60e78d2c | 42 | #include "cache.h" |
7263cebe | 43 | #include "fid.h" |
147b31cf EVH |
44 | |
45 | /** | |
7263cebe | 46 | * v9fs_fid_readpage - read an entire page in from 9P |
147b31cf | 47 | * |
7263cebe | 48 | * @fid: fid being read |
147b31cf EVH |
49 | * @page: structure to page |
50 | * | |
51 | */ | |
7263cebe | 52 | static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page) |
147b31cf | 53 | { |
bd238fb4 LI |
54 | int retval; |
55 | loff_t offset; | |
56 | char *buffer; | |
60e78d2c | 57 | struct inode *inode; |
e03abc0c | 58 | |
60e78d2c | 59 | inode = page->mapping->host; |
5d385153 | 60 | p9_debug(P9_DEBUG_VFS, "\n"); |
60e78d2c AK |
61 | |
62 | BUG_ON(!PageLocked(page)); | |
63 | ||
64 | retval = v9fs_readpage_from_fscache(inode, page); | |
65 | if (retval == 0) | |
66 | return retval; | |
67 | ||
147b31cf | 68 | buffer = kmap(page); |
bd238fb4 | 69 | offset = page_offset(page); |
147b31cf | 70 | |
7263cebe | 71 | retval = v9fs_fid_readn(fid, buffer, NULL, PAGE_CACHE_SIZE, offset); |
60e78d2c AK |
72 | if (retval < 0) { |
73 | v9fs_uncache_page(inode, page); | |
bd238fb4 | 74 | goto done; |
60e78d2c | 75 | } |
147b31cf | 76 | |
bd238fb4 | 77 | memset(buffer + retval, 0, PAGE_CACHE_SIZE - retval); |
147b31cf EVH |
78 | flush_dcache_page(page); |
79 | SetPageUptodate(page); | |
60e78d2c AK |
80 | |
81 | v9fs_readpage_to_fscache(inode, page); | |
147b31cf EVH |
82 | retval = 0; |
83 | ||
bd238fb4 | 84 | done: |
147b31cf EVH |
85 | kunmap(page); |
86 | unlock_page(page); | |
87 | return retval; | |
88 | } | |
89 | ||
7263cebe AK |
90 | /** |
91 | * v9fs_vfs_readpage - read an entire page in from 9P | |
92 | * | |
93 | * @filp: file being read | |
94 | * @page: structure to page | |
95 | * | |
96 | */ | |
97 | ||
98 | static int v9fs_vfs_readpage(struct file *filp, struct page *page) | |
99 | { | |
100 | return v9fs_fid_readpage(filp->private_data, page); | |
101 | } | |
102 | ||
60e78d2c AK |
103 | /** |
104 | * v9fs_vfs_readpages - read a set of pages from 9P | |
105 | * | |
106 | * @filp: file being read | |
107 | * @mapping: the address space | |
108 | * @pages: list of pages to read | |
109 | * @nr_pages: count of pages to read | |
110 | * | |
111 | */ | |
112 | ||
113 | static int v9fs_vfs_readpages(struct file *filp, struct address_space *mapping, | |
114 | struct list_head *pages, unsigned nr_pages) | |
115 | { | |
116 | int ret = 0; | |
117 | struct inode *inode; | |
118 | ||
119 | inode = mapping->host; | |
5d385153 | 120 | p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, filp); |
60e78d2c AK |
121 | |
122 | ret = v9fs_readpages_from_fscache(inode, mapping, pages, &nr_pages); | |
123 | if (ret == 0) | |
124 | return ret; | |
125 | ||
126 | ret = read_cache_pages(mapping, pages, (void *)v9fs_vfs_readpage, filp); | |
5d385153 | 127 | p9_debug(P9_DEBUG_VFS, " = %d\n", ret); |
60e78d2c AK |
128 | return ret; |
129 | } | |
130 | ||
131 | /** | |
132 | * v9fs_release_page - release the private state associated with a page | |
133 | * | |
134 | * Returns 1 if the page can be released, false otherwise. | |
135 | */ | |
136 | ||
137 | static int v9fs_release_page(struct page *page, gfp_t gfp) | |
138 | { | |
139 | if (PagePrivate(page)) | |
140 | return 0; | |
60e78d2c AK |
141 | return v9fs_fscache_release_page(page, gfp); |
142 | } | |
143 | ||
144 | /** | |
145 | * v9fs_invalidate_page - Invalidate a page completely or partially | |
146 | * | |
147 | * @page: structure to page | |
148 | * @offset: offset in the page | |
149 | */ | |
150 | ||
d47992f8 LC |
151 | static void v9fs_invalidate_page(struct page *page, unsigned int offset, |
152 | unsigned int length) | |
60e78d2c | 153 | { |
7263cebe AK |
154 | /* |
155 | * If called with zero offset, we should release | |
156 | * the private state assocated with the page | |
157 | */ | |
d47992f8 | 158 | if (offset == 0 && length == PAGE_CACHE_SIZE) |
60e78d2c AK |
159 | v9fs_fscache_invalidate_page(page); |
160 | } | |
161 | ||
7263cebe AK |
162 | static int v9fs_vfs_writepage_locked(struct page *page) |
163 | { | |
7263cebe | 164 | struct inode *inode = page->mapping->host; |
371098c6 AV |
165 | struct v9fs_inode *v9inode = V9FS_I(inode); |
166 | loff_t size = i_size_read(inode); | |
167 | struct iov_iter from; | |
168 | struct bio_vec bvec; | |
169 | int err, len; | |
7263cebe | 170 | |
7263cebe AK |
171 | if (page->index == size >> PAGE_CACHE_SHIFT) |
172 | len = size & ~PAGE_CACHE_MASK; | |
173 | else | |
174 | len = PAGE_CACHE_SIZE; | |
175 | ||
371098c6 AV |
176 | bvec.bv_page = page; |
177 | bvec.bv_offset = 0; | |
178 | bvec.bv_len = len; | |
179 | iov_iter_bvec(&from, ITER_BVEC | WRITE, &bvec, 1, len); | |
7263cebe | 180 | |
6b39f6d2 AK |
181 | /* We should have writeback_fid always set */ |
182 | BUG_ON(!v9inode->writeback_fid); | |
7263cebe | 183 | |
371098c6 AV |
184 | set_page_writeback(page); |
185 | ||
186 | p9_client_write(v9inode->writeback_fid, page_offset(page), &from, &err); | |
7263cebe | 187 | |
7263cebe | 188 | end_page_writeback(page); |
371098c6 | 189 | return err; |
7263cebe AK |
190 | } |
191 | ||
192 | static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc) | |
193 | { | |
194 | int retval; | |
195 | ||
fb89b45c DM |
196 | p9_debug(P9_DEBUG_VFS, "page %p\n", page); |
197 | ||
7263cebe AK |
198 | retval = v9fs_vfs_writepage_locked(page); |
199 | if (retval < 0) { | |
200 | if (retval == -EAGAIN) { | |
201 | redirty_page_for_writepage(wbc, page); | |
202 | retval = 0; | |
203 | } else { | |
204 | SetPageError(page); | |
205 | mapping_set_error(page->mapping, retval); | |
206 | } | |
207 | } else | |
208 | retval = 0; | |
209 | ||
210 | unlock_page(page); | |
211 | return retval; | |
212 | } | |
213 | ||
60e78d2c AK |
214 | /** |
215 | * v9fs_launder_page - Writeback a dirty page | |
60e78d2c AK |
216 | * Returns 0 on success. |
217 | */ | |
218 | ||
219 | static int v9fs_launder_page(struct page *page) | |
220 | { | |
7263cebe | 221 | int retval; |
2efda799 | 222 | struct inode *inode = page->mapping->host; |
7263cebe | 223 | |
2efda799 | 224 | v9fs_fscache_wait_on_page_write(inode, page); |
7263cebe AK |
225 | if (clear_page_dirty_for_io(page)) { |
226 | retval = v9fs_vfs_writepage_locked(page); | |
227 | if (retval) | |
228 | return retval; | |
229 | } | |
60e78d2c AK |
230 | return 0; |
231 | } | |
232 | ||
3e24ad2f | 233 | /** |
234 | * v9fs_direct_IO - 9P address space operation for direct I/O | |
235 | * @rw: direction (read or write) | |
236 | * @iocb: target I/O control block | |
237 | * @iov: array of vectors that define I/O buffer | |
238 | * @pos: offset in file to begin the operation | |
239 | * @nr_segs: size of iovec array | |
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 | */ | |
e959b549 | 252 | static ssize_t |
d8d3d94b | 253 | v9fs_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, loff_t pos) |
3e24ad2f | 254 | { |
7263cebe AK |
255 | /* |
256 | * FIXME | |
257 | * Now that we do caching with cache mode enabled, We need | |
258 | * to support direct IO | |
259 | */ | |
4b8e9923 AV |
260 | p9_debug(P9_DEBUG_VFS, "v9fs_direct_IO: v9fs_direct_IO (%pD) off/no(%lld/%lu) EINVAL\n", |
261 | iocb->ki_filp, | |
d8d3d94b | 262 | (long long)pos, iter->nr_segs); |
3e24ad2f | 263 | |
264 | return -EINVAL; | |
265 | } | |
7263cebe AK |
266 | |
267 | static int v9fs_write_begin(struct file *filp, struct address_space *mapping, | |
268 | loff_t pos, unsigned len, unsigned flags, | |
269 | struct page **pagep, void **fsdata) | |
270 | { | |
271 | int retval = 0; | |
272 | struct page *page; | |
6b39f6d2 | 273 | struct v9fs_inode *v9inode; |
7263cebe AK |
274 | pgoff_t index = pos >> PAGE_CACHE_SHIFT; |
275 | struct inode *inode = mapping->host; | |
276 | ||
fb89b45c DM |
277 | |
278 | p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping); | |
279 | ||
6b39f6d2 | 280 | v9inode = V9FS_I(inode); |
7263cebe AK |
281 | start: |
282 | page = grab_cache_page_write_begin(mapping, index, flags); | |
283 | if (!page) { | |
284 | retval = -ENOMEM; | |
285 | goto out; | |
286 | } | |
6b39f6d2 | 287 | BUG_ON(!v9inode->writeback_fid); |
7263cebe AK |
288 | if (PageUptodate(page)) |
289 | goto out; | |
290 | ||
291 | if (len == PAGE_CACHE_SIZE) | |
292 | goto out; | |
293 | ||
6b39f6d2 | 294 | retval = v9fs_fid_readpage(v9inode->writeback_fid, page); |
7263cebe AK |
295 | page_cache_release(page); |
296 | if (!retval) | |
297 | goto start; | |
298 | out: | |
299 | *pagep = page; | |
300 | return retval; | |
301 | } | |
302 | ||
303 | static int v9fs_write_end(struct file *filp, struct address_space *mapping, | |
304 | loff_t pos, unsigned len, unsigned copied, | |
305 | struct page *page, void *fsdata) | |
306 | { | |
307 | loff_t last_pos = pos + copied; | |
308 | struct inode *inode = page->mapping->host; | |
309 | ||
fb89b45c DM |
310 | p9_debug(P9_DEBUG_VFS, "filp %p, mapping %p\n", filp, mapping); |
311 | ||
7263cebe AK |
312 | if (unlikely(copied < len)) { |
313 | /* | |
314 | * zero out the rest of the area | |
315 | */ | |
316 | unsigned from = pos & (PAGE_CACHE_SIZE - 1); | |
317 | ||
318 | zero_user(page, from + copied, len - copied); | |
319 | flush_dcache_page(page); | |
320 | } | |
321 | ||
322 | if (!PageUptodate(page)) | |
323 | SetPageUptodate(page); | |
324 | /* | |
325 | * No need to use i_size_read() here, the i_size | |
326 | * cannot change under us because we hold the i_mutex. | |
327 | */ | |
328 | if (last_pos > inode->i_size) { | |
329 | inode_add_bytes(inode, last_pos - inode->i_size); | |
330 | i_size_write(inode, last_pos); | |
331 | } | |
332 | set_page_dirty(page); | |
333 | unlock_page(page); | |
334 | page_cache_release(page); | |
335 | ||
336 | return copied; | |
337 | } | |
338 | ||
339 | ||
f5e54d6e | 340 | const struct address_space_operations v9fs_addr_operations = { |
7263cebe AK |
341 | .readpage = v9fs_vfs_readpage, |
342 | .readpages = v9fs_vfs_readpages, | |
343 | .set_page_dirty = __set_page_dirty_nobuffers, | |
344 | .writepage = v9fs_vfs_writepage, | |
345 | .write_begin = v9fs_write_begin, | |
346 | .write_end = v9fs_write_end, | |
347 | .releasepage = v9fs_release_page, | |
348 | .invalidatepage = v9fs_invalidate_page, | |
349 | .launder_page = v9fs_launder_page, | |
350 | .direct_IO = v9fs_direct_IO, | |
147b31cf | 351 | }; |