Fix races around the access to ->s_options
[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 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 }