[SCSI] megaraid_sas: fix EH locking
[linux-2.6/kvm.git] / fs / afs / file.c
blob4975c9c193dd37505cbdcfad000fdcd24793676d
1 /* file.c: AFS filesystem file handling
3 * Copyright (C) 2002 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/sched.h>
16 #include <linux/slab.h>
17 #include <linux/fs.h>
18 #include <linux/pagemap.h>
19 #include <linux/buffer_head.h>
20 #include "volume.h"
21 #include "vnode.h"
22 #include <rxrpc/call.h>
23 #include "internal.h"
25 #if 0
26 static int afs_file_open(struct inode *inode, struct file *file);
27 static int afs_file_release(struct inode *inode, struct file *file);
28 #endif
30 static int afs_file_readpage(struct file *file, struct page *page);
31 static int afs_file_invalidatepage(struct page *page, unsigned long offset);
32 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags);
34 static ssize_t afs_file_write(struct file *file, const char __user *buf,
35 size_t size, loff_t *off);
37 struct inode_operations afs_file_inode_operations = {
38 .getattr = afs_inode_getattr,
41 struct file_operations afs_file_file_operations = {
42 .read = generic_file_read,
43 .write = afs_file_write,
44 .mmap = generic_file_mmap,
45 #if 0
46 .open = afs_file_open,
47 .release = afs_file_release,
48 .fsync = afs_file_fsync,
49 #endif
52 struct address_space_operations afs_fs_aops = {
53 .readpage = afs_file_readpage,
54 .sync_page = block_sync_page,
55 .set_page_dirty = __set_page_dirty_nobuffers,
56 .releasepage = afs_file_releasepage,
57 .invalidatepage = afs_file_invalidatepage,
60 /*****************************************************************************/
62 * AFS file write
64 static ssize_t afs_file_write(struct file *file, const char __user *buf,
65 size_t size, loff_t *off)
67 struct afs_vnode *vnode;
69 vnode = AFS_FS_I(file->f_dentry->d_inode);
70 if (vnode->flags & AFS_VNODE_DELETED)
71 return -ESTALE;
73 return -EIO;
74 } /* end afs_file_write() */
76 /*****************************************************************************/
78 * deal with notification that a page was read from the cache
80 #ifdef AFS_CACHING_SUPPORT
81 static void afs_file_readpage_read_complete(void *cookie_data,
82 struct page *page,
83 void *data,
84 int error)
86 _enter("%p,%p,%p,%d", cookie_data, page, data, error);
88 if (error)
89 SetPageError(page);
90 else
91 SetPageUptodate(page);
92 unlock_page(page);
94 } /* end afs_file_readpage_read_complete() */
95 #endif
97 /*****************************************************************************/
99 * deal with notification that a page was written to the cache
101 #ifdef AFS_CACHING_SUPPORT
102 static void afs_file_readpage_write_complete(void *cookie_data,
103 struct page *page,
104 void *data,
105 int error)
107 _enter("%p,%p,%p,%d", cookie_data, page, data, error);
109 unlock_page(page);
111 } /* end afs_file_readpage_write_complete() */
112 #endif
114 /*****************************************************************************/
116 * AFS read page from file (or symlink)
118 static int afs_file_readpage(struct file *file, struct page *page)
120 struct afs_rxfs_fetch_descriptor desc;
121 #ifdef AFS_CACHING_SUPPORT
122 struct cachefs_page *pageio;
123 #endif
124 struct afs_vnode *vnode;
125 struct inode *inode;
126 int ret;
128 inode = page->mapping->host;
130 _enter("{%lu},{%lu}", inode->i_ino, page->index);
132 vnode = AFS_FS_I(inode);
134 BUG_ON(!PageLocked(page));
136 ret = -ESTALE;
137 if (vnode->flags & AFS_VNODE_DELETED)
138 goto error;
140 #ifdef AFS_CACHING_SUPPORT
141 ret = cachefs_page_get_private(page, &pageio, GFP_NOIO);
142 if (ret < 0)
143 goto error;
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
155 switch (ret) {
156 /* read BIO submitted and wb-journal entry found */
157 case 1:
158 BUG(); // TODO - handle wb-journal match
160 /* read BIO submitted (page in cache) */
161 case 0:
162 break;
164 /* no page available in cache */
165 case -ENOBUFS:
166 case -ENODATA:
167 default:
168 desc.fid = vnode->fid;
169 desc.offset = page->index << PAGE_CACHE_SHIFT;
170 desc.size = min((size_t) (inode->i_size - desc.offset),
171 (size_t) PAGE_SIZE);
172 desc.buffer = kmap(page);
174 clear_page(desc.buffer);
176 /* read the contents of the file from the server into the
177 * page */
178 ret = afs_vnode_fetch_data(vnode, &desc);
179 kunmap(page);
180 if (ret < 0) {
181 if (ret==-ENOENT) {
182 _debug("got NOENT from server"
183 " - marking file deleted and stale");
184 vnode->flags |= AFS_VNODE_DELETED;
185 ret = -ESTALE;
188 #ifdef AFS_CACHING_SUPPORT
189 cachefs_uncache_page(vnode->cache, page);
190 #endif
191 goto error;
194 SetPageUptodate(page);
196 #ifdef AFS_CACHING_SUPPORT
197 if (cachefs_write_page(vnode->cache,
198 page,
199 afs_file_readpage_write_complete,
200 NULL,
201 GFP_KERNEL) != 0
203 cachefs_uncache_page(vnode->cache, page);
204 unlock_page(page);
206 #else
207 unlock_page(page);
208 #endif
211 _leave(" = 0");
212 return 0;
214 error:
215 SetPageError(page);
216 unlock_page(page);
218 _leave(" = %d", ret);
219 return ret;
221 } /* end afs_file_readpage() */
223 /*****************************************************************************/
225 * get a page cookie for the specified page
227 #ifdef AFS_CACHING_SUPPORT
228 int afs_cache_get_page_cookie(struct page *page,
229 struct cachefs_page **_page_cookie)
231 int ret;
233 _enter("");
234 ret = cachefs_page_get_private(page,_page_cookie, GFP_NOIO);
236 _leave(" = %d", ret);
237 return ret;
238 } /* end afs_cache_get_page_cookie() */
239 #endif
241 /*****************************************************************************/
243 * invalidate part or all of a page
245 static int afs_file_invalidatepage(struct page *page, unsigned long offset)
247 int ret = 1;
249 _enter("{%lu},%lu", page->index, offset);
251 BUG_ON(!PageLocked(page));
253 if (PagePrivate(page)) {
254 #ifdef AFS_CACHING_SUPPORT
255 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
256 cachefs_uncache_page(vnode->cache,page);
257 #endif
259 /* We release buffers only if the entire page is being
260 * invalidated.
261 * The get_block cached value has been unconditionally
262 * invalidated, so real IO is not possible anymore.
264 if (offset == 0) {
265 BUG_ON(!PageLocked(page));
267 ret = 0;
268 if (!PageWriteback(page))
269 ret = page->mapping->a_ops->releasepage(page,
274 _leave(" = %d", ret);
275 return ret;
276 } /* end afs_file_invalidatepage() */
278 /*****************************************************************************/
280 * release a page and cleanup its private data
282 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags)
284 struct cachefs_page *pageio;
286 _enter("{%lu},%x", page->index, gfp_flags);
288 if (PagePrivate(page)) {
289 #ifdef AFS_CACHING_SUPPORT
290 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
291 cachefs_uncache_page(vnode->cache, page);
292 #endif
294 pageio = (struct cachefs_page *) page_private(page);
295 set_page_private(page, 0);
296 ClearPagePrivate(page);
298 if (pageio)
299 kfree(pageio);
302 _leave(" = 0");
303 return 0;
304 } /* end afs_file_releasepage() */