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