Merge git://git.linux-nfs.org/pub/linux/nfs-2.6
[linux-2.6] / fs / afs / file.c
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 "internal.h"
19
20 static int afs_file_readpage(struct file *file, struct page *page);
21 static void afs_file_invalidatepage(struct page *page, unsigned long offset);
22 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags);
23
24 const struct file_operations afs_file_operations = {
25         .open           = afs_open,
26         .release        = afs_release,
27         .llseek         = generic_file_llseek,
28         .read           = do_sync_read,
29         .aio_read       = generic_file_aio_read,
30         .mmap           = generic_file_readonly_mmap,
31         .sendfile       = generic_file_sendfile,
32 };
33
34 const struct inode_operations afs_file_inode_operations = {
35         .getattr        = afs_inode_getattr,
36         .permission     = afs_permission,
37 };
38
39 const struct address_space_operations afs_fs_aops = {
40         .readpage       = afs_file_readpage,
41         .set_page_dirty = __set_page_dirty_nobuffers,
42         .releasepage    = afs_file_releasepage,
43         .invalidatepage = afs_file_invalidatepage,
44 };
45
46 /*
47  * open an AFS file or directory and attach a key to it
48  */
49 int afs_open(struct inode *inode, struct file *file)
50 {
51         struct afs_vnode *vnode = AFS_FS_I(inode);
52         struct key *key;
53         int ret;
54
55         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
56
57         key = afs_request_key(vnode->volume->cell);
58         if (IS_ERR(key)) {
59                 _leave(" = %ld [key]", PTR_ERR(key));
60                 return PTR_ERR(key);
61         }
62
63         ret = afs_validate(vnode, key);
64         if (ret < 0) {
65                 _leave(" = %d [val]", ret);
66                 return ret;
67         }
68
69         file->private_data = key;
70         _leave(" = 0");
71         return 0;
72 }
73
74 /*
75  * release an AFS file or directory and discard its key
76  */
77 int afs_release(struct inode *inode, struct file *file)
78 {
79         struct afs_vnode *vnode = AFS_FS_I(inode);
80
81         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
82
83         key_put(file->private_data);
84         _leave(" = 0");
85         return 0;
86 }
87
88 /*
89  * deal with notification that a page was read from the cache
90  */
91 #ifdef AFS_CACHING_SUPPORT
92 static void afs_file_readpage_read_complete(void *cookie_data,
93                                             struct page *page,
94                                             void *data,
95                                             int error)
96 {
97         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
98
99         if (error)
100                 SetPageError(page);
101         else
102                 SetPageUptodate(page);
103         unlock_page(page);
104
105 }
106 #endif
107
108 /*
109  * deal with notification that a page was written to the cache
110  */
111 #ifdef AFS_CACHING_SUPPORT
112 static void afs_file_readpage_write_complete(void *cookie_data,
113                                              struct page *page,
114                                              void *data,
115                                              int error)
116 {
117         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
118
119         unlock_page(page);
120 }
121 #endif
122
123 /*
124  * AFS read page from file (or symlink)
125  */
126 static int afs_file_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 #ifdef AFS_CACHING_SUPPORT
152         /* is it cached? */
153         ret = cachefs_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
162         switch (ret) {
163                 /* read BIO submitted and wb-journal entry found */
164         case 1:
165                 BUG(); // TODO - handle wb-journal match
166
167                 /* read BIO submitted (page in cache) */
168         case 0:
169                 break;
170
171                 /* no page available in cache */
172         case -ENOBUFS:
173         case -ENODATA:
174         default:
175                 offset = page->index << PAGE_CACHE_SHIFT;
176                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
177
178                 /* read the contents of the file from the server into the
179                  * page */
180                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
181                 if (ret < 0) {
182                         if (ret == -ENOENT) {
183                                 _debug("got NOENT from server"
184                                        " - marking file deleted and stale");
185                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
186                                 ret = -ESTALE;
187                         }
188 #ifdef AFS_CACHING_SUPPORT
189                         cachefs_uncache_page(vnode->cache, page);
190 #endif
191                         goto error;
192                 }
193
194                 SetPageUptodate(page);
195
196 #ifdef AFS_CACHING_SUPPORT
197                 if (cachefs_write_page(vnode->cache,
198                                        page,
199                                        afs_file_readpage_write_complete,
200                                        NULL,
201                                        GFP_KERNEL) != 0
202                     ) {
203                         cachefs_uncache_page(vnode->cache, page);
204                         unlock_page(page);
205                 }
206 #else
207                 unlock_page(page);
208 #endif
209         }
210
211         _leave(" = 0");
212         return 0;
213
214 error:
215         SetPageError(page);
216         unlock_page(page);
217         _leave(" = %d", ret);
218         return ret;
219 }
220
221 /*
222  * get a page cookie for the specified page
223  */
224 #ifdef AFS_CACHING_SUPPORT
225 int afs_cache_get_page_cookie(struct page *page,
226                               struct cachefs_page **_page_cookie)
227 {
228         int ret;
229
230         _enter("");
231         ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
232
233         _leave(" = %d", ret);
234         return ret;
235 }
236 #endif
237
238 /*
239  * invalidate part or all of a page
240  */
241 static void afs_file_invalidatepage(struct page *page, unsigned long offset)
242 {
243         int ret = 1;
244
245         _enter("{%lu},%lu", page->index, offset);
246
247         BUG_ON(!PageLocked(page));
248
249         if (PagePrivate(page)) {
250 #ifdef AFS_CACHING_SUPPORT
251                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
252                 cachefs_uncache_page(vnode->cache,page);
253 #endif
254
255                 /* We release buffers only if the entire page is being
256                  * invalidated.
257                  * The get_block cached value has been unconditionally
258                  * invalidated, so real IO is not possible anymore.
259                  */
260                 if (offset == 0) {
261                         BUG_ON(!PageLocked(page));
262
263                         ret = 0;
264                         if (!PageWriteback(page))
265                                 ret = page->mapping->a_ops->releasepage(page,
266                                                                         0);
267                         /* possibly should BUG_ON(!ret); - neilb */
268                 }
269         }
270
271         _leave(" = %d", ret);
272 }
273
274 /*
275  * release a page and cleanup its private data
276  */
277 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
278 {
279         struct cachefs_page *pageio;
280
281         _enter("{%lu},%x", page->index, gfp_flags);
282
283         if (PagePrivate(page)) {
284 #ifdef AFS_CACHING_SUPPORT
285                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
286                 cachefs_uncache_page(vnode->cache, page);
287 #endif
288
289                 pageio = (struct cachefs_page *) page_private(page);
290                 set_page_private(page, 0);
291                 ClearPagePrivate(page);
292
293                 kfree(pageio);
294         }
295
296         _leave(" = 0");
297         return 0;
298 }