1 /* AFS filesystem file handling
3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
17 #include <linux/pagemap.h>
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);
24 const struct file_operations afs_file_operations = {
26 .release = afs_release,
27 .llseek = generic_file_llseek,
29 .aio_read = generic_file_aio_read,
30 .mmap = generic_file_readonly_mmap,
31 .sendfile = generic_file_sendfile,
34 const struct inode_operations afs_file_inode_operations = {
35 .getattr = afs_inode_getattr,
36 .permission = afs_permission,
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,
47 * open an AFS file or directory and attach a key to it
49 int afs_open(struct inode *inode, struct file *file)
51 struct afs_vnode *vnode = AFS_FS_I(inode);
54 _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
56 key = afs_request_key(vnode->volume->cell);
58 _leave(" = %ld [key]", PTR_ERR(key));
62 file->private_data = key;
68 * release an AFS file or directory and discard its key
70 int afs_release(struct inode *inode, struct file *file)
72 struct afs_vnode *vnode = AFS_FS_I(inode);
74 _enter("{%x:%x},", vnode->fid.vid, vnode->fid.vnode);
76 key_put(file->private_data);
82 * deal with notification that a page was read from the cache
84 #ifdef AFS_CACHING_SUPPORT
85 static void afs_file_readpage_read_complete(void *cookie_data,
90 _enter("%p,%p,%p,%d", cookie_data, page, data, error);
95 SetPageUptodate(page);
102 * deal with notification that a page was written to the cache
104 #ifdef AFS_CACHING_SUPPORT
105 static void afs_file_readpage_write_complete(void *cookie_data,
110 _enter("%p,%p,%p,%d", cookie_data, page, data, error);
117 * AFS read page from file (or symlink)
119 static int afs_file_readpage(struct file *file, struct page *page)
121 struct afs_vnode *vnode;
128 inode = page->mapping->host;
130 ASSERT(file != NULL);
131 key = file->private_data;
134 _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
136 vnode = AFS_FS_I(inode);
138 BUG_ON(!PageLocked(page));
141 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
144 #ifdef AFS_CACHING_SUPPORT
146 ret = cachefs_read_or_alloc_page(vnode->cache,
148 afs_file_readpage_read_complete,
156 /* read BIO submitted and wb-journal entry found */
158 BUG(); // TODO - handle wb-journal match
160 /* read BIO submitted (page in cache) */
164 /* no page available in cache */
168 offset = page->index << PAGE_CACHE_SHIFT;
169 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
171 /* read the contents of the file from the server into the
173 ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
175 if (ret == -ENOENT) {
176 _debug("got NOENT from server"
177 " - marking file deleted and stale");
178 set_bit(AFS_VNODE_DELETED, &vnode->flags);
181 #ifdef AFS_CACHING_SUPPORT
182 cachefs_uncache_page(vnode->cache, page);
187 SetPageUptodate(page);
189 #ifdef AFS_CACHING_SUPPORT
190 if (cachefs_write_page(vnode->cache,
192 afs_file_readpage_write_complete,
196 cachefs_uncache_page(vnode->cache, page);
210 _leave(" = %d", ret);
215 * get a page cookie for the specified page
217 #ifdef AFS_CACHING_SUPPORT
218 int afs_cache_get_page_cookie(struct page *page,
219 struct cachefs_page **_page_cookie)
224 ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
226 _leave(" = %d", ret);
232 * invalidate part or all of a page
234 static void afs_file_invalidatepage(struct page *page, unsigned long offset)
238 _enter("{%lu},%lu", page->index, offset);
240 BUG_ON(!PageLocked(page));
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);
248 /* We release buffers only if the entire page is being
250 * The get_block cached value has been unconditionally
251 * invalidated, so real IO is not possible anymore.
254 BUG_ON(!PageLocked(page));
257 if (!PageWriteback(page))
258 ret = page->mapping->a_ops->releasepage(page,
260 /* possibly should BUG_ON(!ret); - neilb */
264 _leave(" = %d", ret);
268 * release a page and cleanup its private data
270 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
272 struct cachefs_page *pageio;
274 _enter("{%lu},%x", page->index, gfp_flags);
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);
282 pageio = (struct cachefs_page *) page_private(page);
283 set_page_private(page, 0);
284 ClearPagePrivate(page);