blob: a3901769a96c4231b3b6c0cf88b9d3e6746f7468 [file] [log] [blame]
David Howells08e0e7c2007-04-26 15:55:03 -07001/* AFS filesystem file handling
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
David Howells08e0e7c2007-04-26 15:55:03 -07003 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/slab.h>
16#include <linux/fs.h>
17#include <linux/pagemap.h>
David Howells31143d52007-05-09 02:33:46 -070018#include <linux/writeback.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "internal.h"
20
David Howells416351f2007-05-09 02:33:45 -070021static int afs_readpage(struct file *file, struct page *page);
22static void afs_invalidatepage(struct page *page, unsigned long offset);
23static int afs_releasepage(struct page *page, gfp_t gfp_flags);
David Howells31143d52007-05-09 02:33:46 -070024static int afs_launder_page(struct page *page);
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
David Howells00d3b7a2007-04-26 15:57:07 -070026const struct file_operations afs_file_operations = {
27 .open = afs_open,
28 .release = afs_release,
29 .llseek = generic_file_llseek,
30 .read = do_sync_read,
David Howells31143d52007-05-09 02:33:46 -070031 .write = do_sync_write,
David Howells00d3b7a2007-04-26 15:57:07 -070032 .aio_read = generic_file_aio_read,
David Howells31143d52007-05-09 02:33:46 -070033 .aio_write = afs_file_write,
David Howells00d3b7a2007-04-26 15:57:07 -070034 .mmap = generic_file_readonly_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +020035 .splice_read = generic_file_splice_read,
David Howells31143d52007-05-09 02:33:46 -070036 .fsync = afs_fsync,
David Howellse8d6c552007-07-15 23:40:12 -070037 .lock = afs_lock,
38 .flock = afs_flock,
David Howells00d3b7a2007-04-26 15:57:07 -070039};
40
Arjan van de Ven754661f2007-02-12 00:55:38 -080041const struct inode_operations afs_file_inode_operations = {
David Howells416351f2007-05-09 02:33:45 -070042 .getattr = afs_getattr,
David Howells31143d52007-05-09 02:33:46 -070043 .setattr = afs_setattr,
David Howells00d3b7a2007-04-26 15:57:07 -070044 .permission = afs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -070045};
46
Christoph Hellwigf5e54d62006-06-28 04:26:44 -070047const struct address_space_operations afs_fs_aops = {
David Howells416351f2007-05-09 02:33:45 -070048 .readpage = afs_readpage,
David Howells31143d52007-05-09 02:33:46 -070049 .set_page_dirty = afs_set_page_dirty,
50 .launder_page = afs_launder_page,
David Howells416351f2007-05-09 02:33:45 -070051 .releasepage = afs_releasepage,
52 .invalidatepage = afs_invalidatepage,
Nick Piggin15b46502008-10-15 22:04:32 -070053 .write_begin = afs_write_begin,
54 .write_end = afs_write_end,
David Howells31143d52007-05-09 02:33:46 -070055 .writepage = afs_writepage,
56 .writepages = afs_writepages,
Linus Torvalds1da177e2005-04-16 15:20:36 -070057};
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059/*
David Howells00d3b7a2007-04-26 15:57:07 -070060 * open an AFS file or directory and attach a key to it
61 */
62int afs_open(struct inode *inode, struct file *file)
63{
64 struct afs_vnode *vnode = AFS_FS_I(inode);
65 struct key *key;
David Howells260a9802007-04-26 15:59:35 -070066 int ret;
David Howells00d3b7a2007-04-26 15:57:07 -070067
David Howells416351f2007-05-09 02:33:45 -070068 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
David Howells00d3b7a2007-04-26 15:57:07 -070069
70 key = afs_request_key(vnode->volume->cell);
71 if (IS_ERR(key)) {
72 _leave(" = %ld [key]", PTR_ERR(key));
73 return PTR_ERR(key);
74 }
75
David Howells260a9802007-04-26 15:59:35 -070076 ret = afs_validate(vnode, key);
77 if (ret < 0) {
78 _leave(" = %d [val]", ret);
79 return ret;
80 }
81
David Howells00d3b7a2007-04-26 15:57:07 -070082 file->private_data = key;
83 _leave(" = 0");
84 return 0;
85}
86
87/*
88 * release an AFS file or directory and discard its key
89 */
90int afs_release(struct inode *inode, struct file *file)
91{
92 struct afs_vnode *vnode = AFS_FS_I(inode);
93
David Howells416351f2007-05-09 02:33:45 -070094 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
David Howells00d3b7a2007-04-26 15:57:07 -070095
96 key_put(file->private_data);
97 _leave(" = 0");
98 return 0;
99}
100
101/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 * deal with notification that a page was read from the cache
103 */
104#ifdef AFS_CACHING_SUPPORT
David Howells416351f2007-05-09 02:33:45 -0700105static void afs_readpage_read_complete(void *cookie_data,
106 struct page *page,
107 void *data,
108 int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 _enter("%p,%p,%p,%d", cookie_data, page, data, error);
111
112 if (error)
113 SetPageError(page);
114 else
115 SetPageUptodate(page);
116 unlock_page(page);
117
David Howellsec268152007-04-26 15:49:28 -0700118}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#endif
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121/*
122 * deal with notification that a page was written to the cache
123 */
124#ifdef AFS_CACHING_SUPPORT
David Howells416351f2007-05-09 02:33:45 -0700125static void afs_readpage_write_complete(void *cookie_data,
126 struct page *page,
127 void *data,
128 int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
130 _enter("%p,%p,%p,%d", cookie_data, page, data, error);
131
132 unlock_page(page);
David Howellsec268152007-04-26 15:49:28 -0700133}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134#endif
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/*
David Howells416351f2007-05-09 02:33:45 -0700137 * AFS read page from file, directory or symlink
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 */
David Howells416351f2007-05-09 02:33:45 -0700139static int afs_readpage(struct file *file, struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 struct afs_vnode *vnode;
142 struct inode *inode;
David Howells00d3b7a2007-04-26 15:57:07 -0700143 struct key *key;
David Howells08e0e7c2007-04-26 15:55:03 -0700144 size_t len;
145 off_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 int ret;
147
148 inode = page->mapping->host;
149
David Howells00d3b7a2007-04-26 15:57:07 -0700150 ASSERT(file != NULL);
151 key = file->private_data;
152 ASSERT(key != NULL);
153
154 _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
156 vnode = AFS_FS_I(inode);
157
Matt Mackallcd7619d2005-05-01 08:59:01 -0700158 BUG_ON(!PageLocked(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160 ret = -ESTALE;
David Howells08e0e7c2007-04-26 15:55:03 -0700161 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 goto error;
163
164#ifdef AFS_CACHING_SUPPORT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 /* is it cached? */
166 ret = cachefs_read_or_alloc_page(vnode->cache,
167 page,
168 afs_file_readpage_read_complete,
169 NULL,
170 GFP_KERNEL);
171#else
172 ret = -ENOBUFS;
173#endif
174
175 switch (ret) {
176 /* read BIO submitted and wb-journal entry found */
177 case 1:
178 BUG(); // TODO - handle wb-journal match
179
180 /* read BIO submitted (page in cache) */
181 case 0:
182 break;
183
184 /* no page available in cache */
185 case -ENOBUFS:
186 case -ENODATA:
187 default:
David Howells08e0e7c2007-04-26 15:55:03 -0700188 offset = page->index << PAGE_CACHE_SHIFT;
189 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 /* read the contents of the file from the server into the
192 * page */
David Howells00d3b7a2007-04-26 15:57:07 -0700193 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 if (ret < 0) {
David Howells08e0e7c2007-04-26 15:55:03 -0700195 if (ret == -ENOENT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 _debug("got NOENT from server"
197 " - marking file deleted and stale");
David Howells08e0e7c2007-04-26 15:55:03 -0700198 set_bit(AFS_VNODE_DELETED, &vnode->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 ret = -ESTALE;
200 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201#ifdef AFS_CACHING_SUPPORT
202 cachefs_uncache_page(vnode->cache, page);
203#endif
204 goto error;
205 }
206
207 SetPageUptodate(page);
208
209#ifdef AFS_CACHING_SUPPORT
210 if (cachefs_write_page(vnode->cache,
211 page,
212 afs_file_readpage_write_complete,
213 NULL,
214 GFP_KERNEL) != 0
215 ) {
216 cachefs_uncache_page(vnode->cache, page);
217 unlock_page(page);
218 }
219#else
220 unlock_page(page);
221#endif
222 }
223
224 _leave(" = 0");
225 return 0;
226
David Howells08e0e7c2007-04-26 15:55:03 -0700227error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 SetPageError(page);
229 unlock_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 _leave(" = %d", ret);
231 return ret;
David Howellsec268152007-04-26 15:49:28 -0700232}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 * invalidate part or all of a page
236 */
David Howells416351f2007-05-09 02:33:45 -0700237static void afs_invalidatepage(struct page *page, unsigned long offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
239 int ret = 1;
240
David Howells0f300ca2007-05-10 22:22:20 -0700241 _enter("{%lu},%lu", page->index, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243 BUG_ON(!PageLocked(page));
244
245 if (PagePrivate(page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* We release buffers only if the entire page is being
247 * invalidated.
248 * The get_block cached value has been unconditionally
249 * invalidated, so real IO is not possible anymore.
250 */
251 if (offset == 0) {
252 BUG_ON(!PageLocked(page));
253
254 ret = 0;
255 if (!PageWriteback(page))
256 ret = page->mapping->a_ops->releasepage(page,
257 0);
NeilBrown2ff28e22006-03-26 01:37:18 -0800258 /* possibly should BUG_ON(!ret); - neilb */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 }
260 }
261
262 _leave(" = %d", ret);
David Howellsec268152007-04-26 15:49:28 -0700263}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/*
David Howells31143d52007-05-09 02:33:46 -0700266 * write back a dirty page
267 */
268static int afs_launder_page(struct page *page)
269{
270 _enter("{%lu}", page->index);
271
272 return 0;
273}
274
275/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 * release a page and cleanup its private data
277 */
David Howells416351f2007-05-09 02:33:45 -0700278static int afs_releasepage(struct page *page, gfp_t gfp_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
David Howells416351f2007-05-09 02:33:45 -0700280 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
David Howells31143d52007-05-09 02:33:46 -0700281 struct afs_writeback *wb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
David Howells416351f2007-05-09 02:33:45 -0700283 _enter("{{%x:%u}[%lu],%lx},%x",
284 vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
285 gfp_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 if (PagePrivate(page)) {
David Howells31143d52007-05-09 02:33:46 -0700288 wb = (struct afs_writeback *) page_private(page);
289 ASSERT(wb != NULL);
Hugh Dickins4c21e2f2005-10-29 18:16:40 -0700290 set_page_private(page, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 ClearPagePrivate(page);
David Howells31143d52007-05-09 02:33:46 -0700292 afs_put_writeback(wb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 }
294
295 _leave(" = 0");
296 return 0;
David Howellsec268152007-04-26 15:49:28 -0700297}