]>
Commit | Line | Data |
---|---|---|
08e0e7c8 | 1 | /* AFS filesystem file handling |
1da177e4 | 2 | * |
08e0e7c8 | 3 | * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. |
1da177e4 LT |
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> | |
1da177e4 LT |
15 | #include <linux/slab.h> |
16 | #include <linux/fs.h> | |
17 | #include <linux/pagemap.h> | |
31143d5d | 18 | #include <linux/writeback.h> |
1da177e4 LT |
19 | #include "internal.h" |
20 | ||
416351f2 DH |
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); | |
31143d5d | 24 | static int afs_launder_page(struct page *page); |
1da177e4 | 25 | |
00d3b7a4 DH |
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, | |
31143d5d | 31 | .write = do_sync_write, |
00d3b7a4 | 32 | .aio_read = generic_file_aio_read, |
31143d5d | 33 | .aio_write = afs_file_write, |
00d3b7a4 | 34 | .mmap = generic_file_readonly_mmap, |
5ffc4ef4 | 35 | .splice_read = generic_file_splice_read, |
31143d5d | 36 | .fsync = afs_fsync, |
00d3b7a4 DH |
37 | }; |
38 | ||
754661f1 | 39 | const struct inode_operations afs_file_inode_operations = { |
416351f2 | 40 | .getattr = afs_getattr, |
31143d5d | 41 | .setattr = afs_setattr, |
00d3b7a4 | 42 | .permission = afs_permission, |
1da177e4 LT |
43 | }; |
44 | ||
f5e54d6e | 45 | const struct address_space_operations afs_fs_aops = { |
416351f2 | 46 | .readpage = afs_readpage, |
31143d5d DH |
47 | .set_page_dirty = afs_set_page_dirty, |
48 | .launder_page = afs_launder_page, | |
416351f2 DH |
49 | .releasepage = afs_releasepage, |
50 | .invalidatepage = afs_invalidatepage, | |
31143d5d DH |
51 | .prepare_write = afs_prepare_write, |
52 | .commit_write = afs_commit_write, | |
53 | .writepage = afs_writepage, | |
54 | .writepages = afs_writepages, | |
1da177e4 LT |
55 | }; |
56 | ||
00d3b7a4 DH |
57 | /* |
58 | * open an AFS file or directory and attach a key to it | |
59 | */ | |
60 | int afs_open(struct inode *inode, struct file *file) | |
61 | { | |
62 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
63 | struct key *key; | |
260a9803 | 64 | int ret; |
00d3b7a4 | 65 | |
416351f2 | 66 | _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode); |
00d3b7a4 DH |
67 | |
68 | key = afs_request_key(vnode->volume->cell); | |
69 | if (IS_ERR(key)) { | |
70 | _leave(" = %ld [key]", PTR_ERR(key)); | |
71 | return PTR_ERR(key); | |
72 | } | |
73 | ||
260a9803 DH |
74 | ret = afs_validate(vnode, key); |
75 | if (ret < 0) { | |
76 | _leave(" = %d [val]", ret); | |
77 | return ret; | |
78 | } | |
79 | ||
00d3b7a4 DH |
80 | file->private_data = key; |
81 | _leave(" = 0"); | |
82 | return 0; | |
83 | } | |
84 | ||
85 | /* | |
86 | * release an AFS file or directory and discard its key | |
87 | */ | |
88 | int afs_release(struct inode *inode, struct file *file) | |
89 | { | |
90 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
91 | ||
416351f2 | 92 | _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode); |
00d3b7a4 DH |
93 | |
94 | key_put(file->private_data); | |
95 | _leave(" = 0"); | |
96 | return 0; | |
97 | } | |
98 | ||
1da177e4 LT |
99 | /* |
100 | * deal with notification that a page was read from the cache | |
101 | */ | |
102 | #ifdef AFS_CACHING_SUPPORT | |
416351f2 DH |
103 | static void afs_readpage_read_complete(void *cookie_data, |
104 | struct page *page, | |
105 | void *data, | |
106 | int error) | |
1da177e4 LT |
107 | { |
108 | _enter("%p,%p,%p,%d", cookie_data, page, data, error); | |
109 | ||
110 | if (error) | |
111 | SetPageError(page); | |
112 | else | |
113 | SetPageUptodate(page); | |
114 | unlock_page(page); | |
115 | ||
ec26815a | 116 | } |
1da177e4 LT |
117 | #endif |
118 | ||
1da177e4 LT |
119 | /* |
120 | * deal with notification that a page was written to the cache | |
121 | */ | |
122 | #ifdef AFS_CACHING_SUPPORT | |
416351f2 DH |
123 | static void afs_readpage_write_complete(void *cookie_data, |
124 | struct page *page, | |
125 | void *data, | |
126 | int error) | |
1da177e4 LT |
127 | { |
128 | _enter("%p,%p,%p,%d", cookie_data, page, data, error); | |
129 | ||
130 | unlock_page(page); | |
ec26815a | 131 | } |
1da177e4 LT |
132 | #endif |
133 | ||
1da177e4 | 134 | /* |
416351f2 | 135 | * AFS read page from file, directory or symlink |
1da177e4 | 136 | */ |
416351f2 | 137 | static int afs_readpage(struct file *file, struct page *page) |
1da177e4 | 138 | { |
1da177e4 LT |
139 | struct afs_vnode *vnode; |
140 | struct inode *inode; | |
00d3b7a4 | 141 | struct key *key; |
08e0e7c8 DH |
142 | size_t len; |
143 | off_t offset; | |
1da177e4 LT |
144 | int ret; |
145 | ||
146 | inode = page->mapping->host; | |
147 | ||
00d3b7a4 DH |
148 | ASSERT(file != NULL); |
149 | key = file->private_data; | |
150 | ASSERT(key != NULL); | |
151 | ||
152 | _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index); | |
1da177e4 LT |
153 | |
154 | vnode = AFS_FS_I(inode); | |
155 | ||
cd7619d6 | 156 | BUG_ON(!PageLocked(page)); |
1da177e4 LT |
157 | |
158 | ret = -ESTALE; | |
08e0e7c8 | 159 | if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) |
1da177e4 LT |
160 | goto error; |
161 | ||
162 | #ifdef AFS_CACHING_SUPPORT | |
1da177e4 LT |
163 | /* is it cached? */ |
164 | ret = cachefs_read_or_alloc_page(vnode->cache, | |
165 | page, | |
166 | afs_file_readpage_read_complete, | |
167 | NULL, | |
168 | GFP_KERNEL); | |
169 | #else | |
170 | ret = -ENOBUFS; | |
171 | #endif | |
172 | ||
173 | switch (ret) { | |
174 | /* read BIO submitted and wb-journal entry found */ | |
175 | case 1: | |
176 | BUG(); // TODO - handle wb-journal match | |
177 | ||
178 | /* read BIO submitted (page in cache) */ | |
179 | case 0: | |
180 | break; | |
181 | ||
182 | /* no page available in cache */ | |
183 | case -ENOBUFS: | |
184 | case -ENODATA: | |
185 | default: | |
08e0e7c8 DH |
186 | offset = page->index << PAGE_CACHE_SHIFT; |
187 | len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE); | |
1da177e4 LT |
188 | |
189 | /* read the contents of the file from the server into the | |
190 | * page */ | |
00d3b7a4 | 191 | ret = afs_vnode_fetch_data(vnode, key, offset, len, page); |
1da177e4 | 192 | if (ret < 0) { |
08e0e7c8 | 193 | if (ret == -ENOENT) { |
1da177e4 LT |
194 | _debug("got NOENT from server" |
195 | " - marking file deleted and stale"); | |
08e0e7c8 | 196 | set_bit(AFS_VNODE_DELETED, &vnode->flags); |
1da177e4 LT |
197 | ret = -ESTALE; |
198 | } | |
1da177e4 LT |
199 | #ifdef AFS_CACHING_SUPPORT |
200 | cachefs_uncache_page(vnode->cache, page); | |
201 | #endif | |
202 | goto error; | |
203 | } | |
204 | ||
205 | SetPageUptodate(page); | |
206 | ||
207 | #ifdef AFS_CACHING_SUPPORT | |
208 | if (cachefs_write_page(vnode->cache, | |
209 | page, | |
210 | afs_file_readpage_write_complete, | |
211 | NULL, | |
212 | GFP_KERNEL) != 0 | |
213 | ) { | |
214 | cachefs_uncache_page(vnode->cache, page); | |
215 | unlock_page(page); | |
216 | } | |
217 | #else | |
218 | unlock_page(page); | |
219 | #endif | |
220 | } | |
221 | ||
222 | _leave(" = 0"); | |
223 | return 0; | |
224 | ||
08e0e7c8 | 225 | error: |
1da177e4 LT |
226 | SetPageError(page); |
227 | unlock_page(page); | |
1da177e4 LT |
228 | _leave(" = %d", ret); |
229 | return ret; | |
ec26815a | 230 | } |
1da177e4 | 231 | |
1da177e4 LT |
232 | /* |
233 | * invalidate part or all of a page | |
234 | */ | |
416351f2 | 235 | static void afs_invalidatepage(struct page *page, unsigned long offset) |
1da177e4 LT |
236 | { |
237 | int ret = 1; | |
238 | ||
0f300ca9 | 239 | _enter("{%lu},%lu", page->index, offset); |
1da177e4 LT |
240 | |
241 | BUG_ON(!PageLocked(page)); | |
242 | ||
243 | if (PagePrivate(page)) { | |
1da177e4 LT |
244 | /* We release buffers only if the entire page is being |
245 | * invalidated. | |
246 | * The get_block cached value has been unconditionally | |
247 | * invalidated, so real IO is not possible anymore. | |
248 | */ | |
249 | if (offset == 0) { | |
250 | BUG_ON(!PageLocked(page)); | |
251 | ||
252 | ret = 0; | |
253 | if (!PageWriteback(page)) | |
254 | ret = page->mapping->a_ops->releasepage(page, | |
255 | 0); | |
2ff28e22 | 256 | /* possibly should BUG_ON(!ret); - neilb */ |
1da177e4 LT |
257 | } |
258 | } | |
259 | ||
260 | _leave(" = %d", ret); | |
ec26815a | 261 | } |
1da177e4 | 262 | |
31143d5d DH |
263 | /* |
264 | * write back a dirty page | |
265 | */ | |
266 | static int afs_launder_page(struct page *page) | |
267 | { | |
268 | _enter("{%lu}", page->index); | |
269 | ||
270 | return 0; | |
271 | } | |
272 | ||
1da177e4 LT |
273 | /* |
274 | * release a page and cleanup its private data | |
275 | */ | |
416351f2 | 276 | static int afs_releasepage(struct page *page, gfp_t gfp_flags) |
1da177e4 | 277 | { |
416351f2 | 278 | struct afs_vnode *vnode = AFS_FS_I(page->mapping->host); |
31143d5d | 279 | struct afs_writeback *wb; |
1da177e4 | 280 | |
416351f2 DH |
281 | _enter("{{%x:%u}[%lu],%lx},%x", |
282 | vnode->fid.vid, vnode->fid.vnode, page->index, page->flags, | |
283 | gfp_flags); | |
1da177e4 LT |
284 | |
285 | if (PagePrivate(page)) { | |
31143d5d DH |
286 | wb = (struct afs_writeback *) page_private(page); |
287 | ASSERT(wb != NULL); | |
4c21e2f2 | 288 | set_page_private(page, 0); |
1da177e4 | 289 | ClearPagePrivate(page); |
31143d5d | 290 | afs_put_writeback(wb); |
1da177e4 LT |
291 | } |
292 | ||
293 | _leave(" = 0"); | |
294 | return 0; | |
ec26815a | 295 | } |