[AFS]: Add security support.
[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 "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
54         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
55
56         key = afs_request_key(vnode->volume->cell);
57         if (IS_ERR(key)) {
58                 _leave(" = %ld [key]", PTR_ERR(key));
59                 return PTR_ERR(key);
60         }
61
62         file->private_data = key;
63         _leave(" = 0");
64         return 0;
65 }
66
67 /*
68  * release an AFS file or directory and discard its key
69  */
70 int afs_release(struct inode *inode, struct file *file)
71 {
72         struct afs_vnode *vnode = AFS_FS_I(inode);
73
74         _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
75
76         key_put(file->private_data);
77         _leave(" = 0");
78         return 0;
79 }
80
81 /*
82  * deal with notification that a page was read from the cache
83  */
84 #ifdef AFS_CACHING_SUPPORT
85 static void afs_file_readpage_read_complete(void *cookie_data,
86                                             struct page *page,
87                                             void *data,
88                                             int error)
89 {
90         _enter("%p,%p,%p,%d", cookie_data, page, data, error);
91
92         if (error)
93                 SetPageError(page);
94         else
95                 SetPageUptodate(page);
96         unlock_page(page);
97
98 }
99 #endif
100
101 /*
102  * deal with notification that a page was written to the cache
103  */
104 #ifdef AFS_CACHING_SUPPORT
105 static void afs_file_readpage_write_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         unlock_page(page);
113 }
114 #endif
115
116 /*
117  * AFS read page from file (or symlink)
118  */
119 static int afs_file_readpage(struct file *file, struct page *page)
120 {
121         struct afs_vnode *vnode;
122         struct inode *inode;
123         struct key *key;
124         size_t len;
125         off_t offset;
126         int ret;
127
128         inode = page->mapping->host;
129
130         ASSERT(file != NULL);
131         key = file->private_data;
132         ASSERT(key != NULL);
133
134         _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
135
136         vnode = AFS_FS_I(inode);
137
138         BUG_ON(!PageLocked(page));
139
140         ret = -ESTALE;
141         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
142                 goto error;
143
144 #ifdef AFS_CACHING_SUPPORT
145         /* is it cached? */
146         ret = cachefs_read_or_alloc_page(vnode->cache,
147                                          page,
148                                          afs_file_readpage_read_complete,
149                                          NULL,
150                                          GFP_KERNEL);
151 #else
152         ret = -ENOBUFS;
153 #endif
154
155         switch (ret) {
156                 /* read BIO submitted and wb-journal entry found */
157         case 1:
158                 BUG(); // TODO - handle wb-journal match
159
160                 /* read BIO submitted (page in cache) */
161         case 0:
162                 break;
163
164                 /* no page available in cache */
165         case -ENOBUFS:
166         case -ENODATA:
167         default:
168                 offset = page->index << PAGE_CACHE_SHIFT;
169                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
170
171                 /* read the contents of the file from the server into the
172                  * page */
173                 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
174                 if (ret < 0) {
175                         if (ret == -ENOENT) {
176                                 _debug("got NOENT from server"
177                                        " - marking file deleted and stale");
178                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
179                                 ret = -ESTALE;
180                         }
181 #ifdef AFS_CACHING_SUPPORT
182                         cachefs_uncache_page(vnode->cache, page);
183 #endif
184                         goto error;
185                 }
186
187                 SetPageUptodate(page);
188
189 #ifdef AFS_CACHING_SUPPORT
190                 if (cachefs_write_page(vnode->cache,
191                                        page,
192                                        afs_file_readpage_write_complete,
193                                        NULL,
194                                        GFP_KERNEL) != 0
195                     ) {
196                         cachefs_uncache_page(vnode->cache, page);
197                         unlock_page(page);
198                 }
199 #else
200                 unlock_page(page);
201 #endif
202         }
203
204         _leave(" = 0");
205         return 0;
206
207 error:
208         SetPageError(page);
209         unlock_page(page);
210         _leave(" = %d", ret);
211         return ret;
212 }
213
214 /*
215  * get a page cookie for the specified page
216  */
217 #ifdef AFS_CACHING_SUPPORT
218 int afs_cache_get_page_cookie(struct page *page,
219                               struct cachefs_page **_page_cookie)
220 {
221         int ret;
222
223         _enter("");
224         ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
225
226         _leave(" = %d", ret);
227         return ret;
228 }
229 #endif
230
231 /*
232  * invalidate part or all of a page
233  */
234 static void afs_file_invalidatepage(struct page *page, unsigned long offset)
235 {
236         int ret = 1;
237
238         _enter("{%lu},%lu", page->index, offset);
239
240         BUG_ON(!PageLocked(page));
241
242         if (PagePrivate(page)) {
243 #ifdef AFS_CACHING_SUPPORT
244                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
245                 cachefs_uncache_page(vnode->cache,page);
246 #endif
247
248                 /* We release buffers only if the entire page is being
249                  * invalidated.
250                  * The get_block cached value has been unconditionally
251                  * invalidated, so real IO is not possible anymore.
252                  */
253                 if (offset == 0) {
254                         BUG_ON(!PageLocked(page));
255
256                         ret = 0;
257                         if (!PageWriteback(page))
258                                 ret = page->mapping->a_ops->releasepage(page,
259                                                                         0);
260                         /* possibly should BUG_ON(!ret); - neilb */
261                 }
262         }
263
264         _leave(" = %d", ret);
265 }
266
267 /*
268  * release a page and cleanup its private data
269  */
270 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
271 {
272         struct cachefs_page *pageio;
273
274         _enter("{%lu},%x", page->index, gfp_flags);
275
276         if (PagePrivate(page)) {
277 #ifdef AFS_CACHING_SUPPORT
278                 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
279                 cachefs_uncache_page(vnode->cache, page);
280 #endif
281
282                 pageio = (struct cachefs_page *) page_private(page);
283                 set_page_private(page, 0);
284                 ClearPagePrivate(page);
285
286                 kfree(pageio);
287         }
288
289         _leave(" = 0");
290         return 0;
291 }