1 /* AFS filesystem file handling
2 *
3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/fs.h>
16 #include <linux/pagemap.h>
17 #include <linux/writeback.h>
18 #include <linux/gfp.h>
19 #include "internal.h"
20
21 static int afs_readpage(struct file *file, struct page *page);
22 static void afs_invalidatepage(struct page *page, unsigned int offset,
23 unsigned int length);
24 static int afs_releasepage(struct page *page, gfp_t gfp_flags);
25 static int afs_launder_page(struct page *page);
26
27 static int afs_readpages(struct file *filp, struct address_space *mapping,
28 struct list_head *pages, unsigned nr_pages);
29
30 const struct file_operations afs_file_operations = {
31 .open = afs_open,
32 .flush = afs_flush,
33 .release = afs_release,
34 .llseek = generic_file_llseek,
35 .read_iter = generic_file_read_iter,
36 .write_iter = afs_file_write,
37 .mmap = generic_file_readonly_mmap,
38 .splice_read = generic_file_splice_read,
39 .fsync = afs_fsync,
40 .lock = afs_lock,
41 .flock = afs_flock,
42 };
43
44 const struct inode_operations afs_file_inode_operations = {
45 .getattr = afs_getattr,
46 .setattr = afs_setattr,
47 .permission = afs_permission,
48 };
49
50 const struct address_space_operations afs_fs_aops = {
51 .readpage = afs_readpage,
52 .readpages = afs_readpages,
53 .set_page_dirty = afs_set_page_dirty,
54 .launder_page = afs_launder_page,
55 .releasepage = afs_releasepage,
56 .invalidatepage = afs_invalidatepage,
57 .write_begin = afs_write_begin,
58 .write_end = afs_write_end,
59 .writepage = afs_writepage,
60 .writepages = afs_writepages,
61 };
62
63 /*
64 * open an AFS file or directory and attach a key to it
65 */
afs_open(struct inode * inode,struct file * file)66 int afs_open(struct inode *inode, struct file *file)
67 {
68 struct afs_vnode *vnode = AFS_FS_I(inode);
69 struct key *key;
70 int ret;
71
72 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
73
74 key = afs_request_key(vnode->volume->cell);
75 if (IS_ERR(key)) {
76 _leave(" = %ld [key]", PTR_ERR(key));
77 return PTR_ERR(key);
78 }
79
80 ret = afs_validate(vnode, key);
81 if (ret < 0) {
82 _leave(" = %d [val]", ret);
83 return ret;
84 }
85
86 file->private_data = key;
87 _leave(" = 0");
88 return 0;
89 }
90
91 /*
92 * release an AFS file or directory and discard its key
93 */
afs_release(struct inode * inode,struct file * file)94 int afs_release(struct inode *inode, struct file *file)
95 {
96 struct afs_vnode *vnode = AFS_FS_I(inode);
97
98 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
99
100 key_put(file->private_data);
101 _leave(" = 0");
102 return 0;
103 }
104
105 #ifdef CONFIG_AFS_FSCACHE
106 /*
107 * deal with notification that a page was read from the cache
108 */
afs_file_readpage_read_complete(struct page * page,void * data,int error)109 static void afs_file_readpage_read_complete(struct page *page,
110 void *data,
111 int error)
112 {
113 _enter("%p,%p,%d", page, data, error);
114
115 /* if the read completes with an error, we just unlock the page and let
116 * the VM reissue the readpage */
117 if (!error)
118 SetPageUptodate(page);
119 unlock_page(page);
120 }
121 #endif
122
123 /*
124 * read page from file, directory or symlink, given a key to use
125 */
__afs_page_filler(struct key * key,struct page * page)126 static int __afs_page_filler(struct key *key, struct page *page)
127 {
128 struct inode *inode = page->mapping->host;
129 struct afs_vnode *vnode = AFS_FS_I(inode);
130 size_t len;
131 off_t offset;
132 int ret;
133
134 _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
135
136 BUG_ON(!PageLocked(page));
137
138 ret = -ESTALE;
139 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
140 goto error;
141
142 /* is it cached? */
143 #ifdef CONFIG_AFS_FSCACHE
144 ret = fscache_read_or_alloc_page(vnode->cache,
145 page,
146 afs_file_readpage_read_complete,
147 NULL,
148 GFP_KERNEL);
149 #else
150 ret = -ENOBUFS;
151 #endif
152 switch (ret) {
153 /* read BIO submitted (page in cache) */
154 case 0:
155 break;
156
157 /* page not yet cached */
158 case -ENODATA:
159 _debug("cache said ENODATA");
160 goto go_on;
161
162 /* page will not be cached */
163 case -ENOBUFS:
164 _debug("cache said ENOBUFS");
165 default:
166 go_on:
167 offset = page->index << PAGE_SHIFT;
168 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
169
170 /* read the contents of the file from the server into the
171 * page */
172 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
173 if (ret < 0) {
174 if (ret == -ENOENT) {
175 _debug("got NOENT from server"
176 " - marking file deleted and stale");
177 set_bit(AFS_VNODE_DELETED, &vnode->flags);
178 ret = -ESTALE;
179 }
180
181 #ifdef CONFIG_AFS_FSCACHE
182 fscache_uncache_page(vnode->cache, page);
183 #endif
184 BUG_ON(PageFsCache(page));
185 goto error;
186 }
187
188 SetPageUptodate(page);
189
190 /* send the page to the cache */
191 #ifdef CONFIG_AFS_FSCACHE
192 if (PageFsCache(page) &&
193 fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
194 fscache_uncache_page(vnode->cache, page);
195 BUG_ON(PageFsCache(page));
196 }
197 #endif
198 unlock_page(page);
199 }
200
201 _leave(" = 0");
202 return 0;
203
204 error:
205 SetPageError(page);
206 unlock_page(page);
207 _leave(" = %d", ret);
208 return ret;
209 }
210
afs_page_filler(struct file * data,struct page * page)211 int afs_page_filler(struct file *data, struct page *page)
212 {
213 struct key *key = (struct key *)data;
214
215 return __afs_page_filler(key, page);
216 }
217
218 /*
219 * read page from file, directory or symlink, given a file to nominate the key
220 * to be used
221 */
afs_readpage(struct file * file,struct page * page)222 static int afs_readpage(struct file *file, struct page *page)
223 {
224 struct key *key;
225 int ret;
226
227 if (file) {
228 key = file->private_data;
229 ASSERT(key != NULL);
230 ret = __afs_page_filler(key, page);
231 } else {
232 struct inode *inode = page->mapping->host;
233 key = afs_request_key(AFS_FS_S(inode->i_sb)->volume->cell);
234 if (IS_ERR(key)) {
235 ret = PTR_ERR(key);
236 } else {
237 ret = __afs_page_filler(key, page);
238 key_put(key);
239 }
240 }
241 return ret;
242 }
243
244 /*
245 * read a set of pages
246 */
afs_readpages(struct file * file,struct address_space * mapping,struct list_head * pages,unsigned nr_pages)247 static int afs_readpages(struct file *file, struct address_space *mapping,
248 struct list_head *pages, unsigned nr_pages)
249 {
250 struct key *key = file->private_data;
251 struct afs_vnode *vnode;
252 int ret = 0;
253
254 _enter("{%d},{%lu},,%d",
255 key_serial(key), mapping->host->i_ino, nr_pages);
256
257 ASSERT(key != NULL);
258
259 vnode = AFS_FS_I(mapping->host);
260 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
261 _leave(" = -ESTALE");
262 return -ESTALE;
263 }
264
265 /* attempt to read as many of the pages as possible */
266 #ifdef CONFIG_AFS_FSCACHE
267 ret = fscache_read_or_alloc_pages(vnode->cache,
268 mapping,
269 pages,
270 &nr_pages,
271 afs_file_readpage_read_complete,
272 NULL,
273 mapping_gfp_mask(mapping));
274 #else
275 ret = -ENOBUFS;
276 #endif
277
278 switch (ret) {
279 /* all pages are being read from the cache */
280 case 0:
281 BUG_ON(!list_empty(pages));
282 BUG_ON(nr_pages != 0);
283 _leave(" = 0 [reading all]");
284 return 0;
285
286 /* there were pages that couldn't be read from the cache */
287 case -ENODATA:
288 case -ENOBUFS:
289 break;
290
291 /* other error */
292 default:
293 _leave(" = %d", ret);
294 return ret;
295 }
296
297 /* load the missing pages from the network */
298 ret = read_cache_pages(mapping, pages, afs_page_filler, key);
299
300 _leave(" = %d [netting]", ret);
301 return ret;
302 }
303
304 /*
305 * write back a dirty page
306 */
afs_launder_page(struct page * page)307 static int afs_launder_page(struct page *page)
308 {
309 _enter("{%lu}", page->index);
310
311 return 0;
312 }
313
314 /*
315 * invalidate part or all of a page
316 * - release a page and clean up its private data if offset is 0 (indicating
317 * the entire page)
318 */
afs_invalidatepage(struct page * page,unsigned int offset,unsigned int length)319 static void afs_invalidatepage(struct page *page, unsigned int offset,
320 unsigned int length)
321 {
322 struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
323
324 _enter("{%lu},%u,%u", page->index, offset, length);
325
326 BUG_ON(!PageLocked(page));
327
328 /* we clean up only if the entire page is being invalidated */
329 if (offset == 0 && length == PAGE_SIZE) {
330 #ifdef CONFIG_AFS_FSCACHE
331 if (PageFsCache(page)) {
332 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
333 fscache_wait_on_page_write(vnode->cache, page);
334 fscache_uncache_page(vnode->cache, page);
335 }
336 #endif
337
338 if (PagePrivate(page)) {
339 if (wb && !PageWriteback(page)) {
340 set_page_private(page, 0);
341 afs_put_writeback(wb);
342 }
343
344 if (!page_private(page))
345 ClearPagePrivate(page);
346 }
347 }
348
349 _leave("");
350 }
351
352 /*
353 * release a page and clean up its private state if it's not busy
354 * - return true if the page can now be released, false if not
355 */
afs_releasepage(struct page * page,gfp_t gfp_flags)356 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
357 {
358 struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
359 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
360
361 _enter("{{%x:%u}[%lu],%lx},%x",
362 vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
363 gfp_flags);
364
365 /* deny if page is being written to the cache and the caller hasn't
366 * elected to wait */
367 #ifdef CONFIG_AFS_FSCACHE
368 if (!fscache_maybe_release_page(vnode->cache, page, gfp_flags)) {
369 _leave(" = F [cache busy]");
370 return 0;
371 }
372 #endif
373
374 if (PagePrivate(page)) {
375 if (wb) {
376 set_page_private(page, 0);
377 afs_put_writeback(wb);
378 }
379 ClearPagePrivate(page);
380 }
381
382 /* indicate that the page can be released */
383 _leave(" = T");
384 return 1;
385 }
386