xref: /openbmc/linux/fs/afs/file.c (revision 78c99ba1) 
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/slab.h>
16 #include <linux/fs.h>
17 #include <linux/pagemap.h>
18 #include <linux/writeback.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 long offset);
23 static int afs_releasepage(struct page *page, gfp_t gfp_flags);
24 static int afs_launder_page(struct page *page);
25 
26 static int afs_readpages(struct file *filp, struct address_space *mapping,
27 			 struct list_head *pages, unsigned nr_pages);
28 
29 const struct file_operations afs_file_operations = {
30 	.open		= afs_open,
31 	.release	= afs_release,
32 	.llseek		= generic_file_llseek,
33 	.read		= do_sync_read,
34 	.write		= do_sync_write,
35 	.aio_read	= generic_file_aio_read,
36 	.aio_write	= 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  */
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  */
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  */
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  * AFS read page from file, directory or symlink
125  */
126 static int afs_readpage(struct file *file, struct page *page)
127 {
128 	struct afs_vnode *vnode;
129 	struct inode *inode;
130 	struct key *key;
131 	size_t len;
132 	off_t offset;
133 	int ret;
134 
135 	inode = page->mapping->host;
136 
137 	ASSERT(file != NULL);
138 	key = file->private_data;
139 	ASSERT(key != NULL);
140 
141 	_enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
142 
143 	vnode = AFS_FS_I(inode);
144 
145 	BUG_ON(!PageLocked(page));
146 
147 	ret = -ESTALE;
148 	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
149 		goto error;
150 
151 	/* is it cached? */
152 #ifdef CONFIG_AFS_FSCACHE
153 	ret = fscache_read_or_alloc_page(vnode->cache,
154 					 page,
155 					 afs_file_readpage_read_complete,
156 					 NULL,
157 					 GFP_KERNEL);
158 #else
159 	ret = -ENOBUFS;
160 #endif
161 	switch (ret) {
162 		/* read BIO submitted (page in cache) */
163 	case 0:
164 		break;
165 
166 		/* page not yet cached */
167 	case -ENODATA:
168 		_debug("cache said ENODATA");
169 		goto go_on;
170 
171 		/* page will not be cached */
172 	case -ENOBUFS:
173 		_debug("cache said ENOBUFS");
174 	default:
175 	go_on:
176 		offset = page->index << PAGE_CACHE_SHIFT;
177 		len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
178 
179 		/* read the contents of the file from the server into the
180 		 * page */
181 		ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
182 		if (ret < 0) {
183 			if (ret == -ENOENT) {
184 				_debug("got NOENT from server"
185 				       " - marking file deleted and stale");
186 				set_bit(AFS_VNODE_DELETED, &vnode->flags);
187 				ret = -ESTALE;
188 			}
189 
190 #ifdef CONFIG_AFS_FSCACHE
191 			fscache_uncache_page(vnode->cache, page);
192 #endif
193 			BUG_ON(PageFsCache(page));
194 			goto error;
195 		}
196 
197 		SetPageUptodate(page);
198 
199 		/* send the page to the cache */
200 #ifdef CONFIG_AFS_FSCACHE
201 		if (PageFsCache(page) &&
202 		    fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
203 			fscache_uncache_page(vnode->cache, page);
204 			BUG_ON(PageFsCache(page));
205 		}
206 #endif
207 		unlock_page(page);
208 	}
209 
210 	_leave(" = 0");
211 	return 0;
212 
213 error:
214 	SetPageError(page);
215 	unlock_page(page);
216 	_leave(" = %d", ret);
217 	return ret;
218 }
219 
220 /*
221  * read a set of pages
222  */
223 static int afs_readpages(struct file *file, struct address_space *mapping,
224 			 struct list_head *pages, unsigned nr_pages)
225 {
226 	struct afs_vnode *vnode;
227 	int ret = 0;
228 
229 	_enter(",{%lu},,%d", mapping->host->i_ino, nr_pages);
230 
231 	vnode = AFS_FS_I(mapping->host);
232 	if (vnode->flags & AFS_VNODE_DELETED) {
233 		_leave(" = -ESTALE");
234 		return -ESTALE;
235 	}
236 
237 	/* attempt to read as many of the pages as possible */
238 #ifdef CONFIG_AFS_FSCACHE
239 	ret = fscache_read_or_alloc_pages(vnode->cache,
240 					  mapping,
241 					  pages,
242 					  &nr_pages,
243 					  afs_file_readpage_read_complete,
244 					  NULL,
245 					  mapping_gfp_mask(mapping));
246 #else
247 	ret = -ENOBUFS;
248 #endif
249 
250 	switch (ret) {
251 		/* all pages are being read from the cache */
252 	case 0:
253 		BUG_ON(!list_empty(pages));
254 		BUG_ON(nr_pages != 0);
255 		_leave(" = 0 [reading all]");
256 		return 0;
257 
258 		/* there were pages that couldn't be read from the cache */
259 	case -ENODATA:
260 	case -ENOBUFS:
261 		break;
262 
263 		/* other error */
264 	default:
265 		_leave(" = %d", ret);
266 		return ret;
267 	}
268 
269 	/* load the missing pages from the network */
270 	ret = read_cache_pages(mapping, pages, (void *) afs_readpage, file);
271 
272 	_leave(" = %d [netting]", ret);
273 	return ret;
274 }
275 
276 /*
277  * write back a dirty page
278  */
279 static int afs_launder_page(struct page *page)
280 {
281 	_enter("{%lu}", page->index);
282 
283 	return 0;
284 }
285 
286 /*
287  * invalidate part or all of a page
288  * - release a page and clean up its private data if offset is 0 (indicating
289  *   the entire page)
290  */
291 static void afs_invalidatepage(struct page *page, unsigned long offset)
292 {
293 	struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
294 
295 	_enter("{%lu},%lu", page->index, offset);
296 
297 	BUG_ON(!PageLocked(page));
298 
299 	/* we clean up only if the entire page is being invalidated */
300 	if (offset == 0) {
301 #ifdef CONFIG_AFS_FSCACHE
302 		if (PageFsCache(page)) {
303 			struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
304 			fscache_wait_on_page_write(vnode->cache, page);
305 			fscache_uncache_page(vnode->cache, page);
306 			ClearPageFsCache(page);
307 		}
308 #endif
309 
310 		if (PagePrivate(page)) {
311 			if (wb && !PageWriteback(page)) {
312 				set_page_private(page, 0);
313 				afs_put_writeback(wb);
314 			}
315 
316 			if (!page_private(page))
317 				ClearPagePrivate(page);
318 		}
319 	}
320 
321 	_leave("");
322 }
323 
324 /*
325  * release a page and clean up its private state if it's not busy
326  * - return true if the page can now be released, false if not
327  */
328 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
329 {
330 	struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
331 	struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
332 
333 	_enter("{{%x:%u}[%lu],%lx},%x",
334 	       vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
335 	       gfp_flags);
336 
337 	/* deny if page is being written to the cache and the caller hasn't
338 	 * elected to wait */
339 #ifdef CONFIG_AFS_FSCACHE
340 	if (PageFsCache(page)) {
341 		if (fscache_check_page_write(vnode->cache, page)) {
342 			if (!(gfp_flags & __GFP_WAIT)) {
343 				_leave(" = F [cache busy]");
344 				return 0;
345 			}
346 			fscache_wait_on_page_write(vnode->cache, page);
347 		}
348 
349 		fscache_uncache_page(vnode->cache, page);
350 		ClearPageFsCache(page);
351 	}
352 #endif
353 
354 	if (PagePrivate(page)) {
355 		if (wb) {
356 			set_page_private(page, 0);
357 			afs_put_writeback(wb);
358 		}
359 		ClearPagePrivate(page);
360 	}
361 
362 	/* indicate that the page can be released */
363 	_leave(" = T");
364 	return 1;
365 }
366