525f7c56e068d877e95dedea3a15dafc116fdb41
[linux-2.6.git] / 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 <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 const struct file_operations afs_file_operations = {
27         .open           = afs_open,
28         .release        = afs_release,
29         .llseek         = generic_file_llseek,
30         .read           = do_sync_read,
31         .write          = do_sync_write,
32         .aio_read       = generic_file_aio_read,
33         .aio_write      = afs_file_write,
34         .mmap           = generic_file_readonly_mmap,
35         .splice_read    = generic_file_splice_read,
36         .fsync          = afs_fsync,
37         .lock           = afs_lock,
38         .flock          = afs_flock,
39 };
40
41 const struct inode_operations afs_file_inode_operations = {
42         .getattr        = afs_getattr,
43         .setattr        = afs_setattr,
44         .permission     = afs_permission,
45 };
46
47 const struct address_space_operations afs_fs_aops = {
48         .readpage       = afs_readpage,
49         .set_page_dirty = afs_set_page_dirty,
50         .launder_page   = afs_launder_page,
51         .releasepage    = afs_releasepage,
52         .invalidatepage = afs_invalidatepage,
53         .prepare_write  = afs_prepare_write,
54         .commit_write   = afs_commit_write,
55         .writepage      = afs_writepage,
56         .writepages     = afs_writepages,
57 };
58
59 /*
60  * open an AFS file or directory and attach a key to it
61  */
62 int afs_open(struct inode *inode, struct file *file)
63 {
64         struct afs_vnode *vnode = AFS_FS_I(inode);
65         struct key *key;
66         int ret;
67
68         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
69
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
76         ret = afs_validate(vnode, key);
77         if (ret < 0) {
78                 _leave(" = %d [val]", ret);
79                 return ret;
80         }
81
82         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  */
90 int afs_release(struct inode *inode, struct file *file)
91 {
92         struct afs_vnode *vnode = AFS_FS_I(inode);
93
94         _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
95
96         key_put(file->private_data);
97         _leave(" = 0");
98         return 0;
99 }
100
101 /*
102  * deal with notification that a page was read from the cache
103  */
104 #ifdef AFS_CACHING_SUPPORT
105 static void afs_readpage_read_complete(void *cookie_data,
106                                        struct page *page,
107                                        void *data,
108                                        int error)
109 {
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
118 }
119 #endif
120
121 /*
122  * deal with notification that a page was written to the cache
123  */
124 #ifdef AFS_CACHING_SUPPORT
125 static void afs_readpage_write_complete(void *cookie_data,
126                                         struct page *page,
127                                         void *data,
128                                         int error)
129 {
130         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
131
132         unlock_page(page);
133 }
134 #endif
135
136 /*
137  * AFS read page from file, directory or symlink
138  */
139 static int afs_readpage(struct file *file, struct page *page)
140 {
141         struct afs_vnode *vnode;
142         struct inode *inode;
143         struct key *key;
144         size_t len;
145         off_t offset;
146         int ret;
147
148         inode = page->mapping->host;
149
150         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);
155
156         vnode = AFS_FS_I(inode);
157
158         BUG_ON(!PageLocked(page));
159
160         ret = -ESTALE;
161         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
162                 goto error;
163
164 #ifdef AFS_CACHING_SUPPORT
165         /* 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:
188                 offset = page->index << PAGE_CACHE_SHIFT;
189                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
190
191                 /* read the contents of the file from the server into the
192                  * page */
193                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
194                 if (ret < 0) {
195                         if (ret == -ENOENT) {
196                                 _debug("got NOENT from server"
197                                        " - marking file deleted and stale");
198                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
199                                 ret = -ESTALE;
200                         }
201 #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
227 error:
228         SetPageError(page);
229         unlock_page(page);
230         _leave(" = %d", ret);
231         return ret;
232 }
233
234 /*
235  * invalidate part or all of a page
236  */
237 static void afs_invalidatepage(struct page *page, unsigned long offset)
238 {
239         int ret = 1;
240
241         _enter("{%lu},%lu", page->index, offset);
242
243         BUG_ON(!PageLocked(page));
244
245         if (PagePrivate(page)) {
246                 /* 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);
258                         /* possibly should BUG_ON(!ret); - neilb */
259                 }
260         }
261
262         _leave(" = %d", ret);
263 }
264
265 /*
266  * write back a dirty page
267  */
268 static int afs_launder_page(struct page *page)
269 {
270         _enter("{%lu}", page->index);
271
272         return 0;
273 }
274
275 /*
276  * release a page and cleanup its private data
277  */
278 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
279 {
280         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
281         struct afs_writeback *wb;
282
283         _enter("{{%x:%u}[%lu],%lx},%x",
284                vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
285                gfp_flags);
286
287         if (PagePrivate(page)) {
288                 wb = (struct afs_writeback *) page_private(page);
289                 ASSERT(wb != NULL);
290                 set_page_private(page, 0);
291                 ClearPagePrivate(page);
292                 afs_put_writeback(wb);
293         }
294
295         _leave(" = 0");
296         return 0;
297 }