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>
18 #include <linux/writeback.h>
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
);
26 static int afs_readpages(struct file
*filp
, struct address_space
*mapping
,
27 struct list_head
*pages
, unsigned nr_pages
);
29 const struct file_operations afs_file_operations
= {
31 .release
= afs_release
,
32 .llseek
= generic_file_llseek
,
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
,
44 const struct inode_operations afs_file_inode_operations
= {
45 .getattr
= afs_getattr
,
46 .setattr
= afs_setattr
,
47 .permission
= afs_permission
,
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
,
64 * open an AFS file or directory and attach a key to it
66 int afs_open(struct inode
*inode
, struct file
*file
)
68 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
72 _enter("{%x:%u},", vnode
->fid
.vid
, vnode
->fid
.vnode
);
74 key
= afs_request_key(vnode
->volume
->cell
);
76 _leave(" = %ld [key]", PTR_ERR(key
));
80 ret
= afs_validate(vnode
, key
);
82 _leave(" = %d [val]", ret
);
86 file
->private_data
= key
;
92 * release an AFS file or directory and discard its key
94 int afs_release(struct inode
*inode
, struct file
*file
)
96 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
98 _enter("{%x:%u},", vnode
->fid
.vid
, vnode
->fid
.vnode
);
100 key_put(file
->private_data
);
106 * deal with notification that a page was read from the cache
108 static void afs_file_readpage_read_complete(struct page
*page
,
112 _enter("%p,%p,%d", page
, data
, error
);
114 /* if the read completes with an error, we just unlock the page and let
115 * the VM reissue the readpage */
117 SetPageUptodate(page
);
122 * AFS read page from file, directory or symlink
124 static int afs_readpage(struct file
*file
, struct page
*page
)
126 struct afs_vnode
*vnode
;
133 inode
= page
->mapping
->host
;
135 ASSERT(file
!= NULL
);
136 key
= file
->private_data
;
139 _enter("{%x},{%lu},{%lu}", key_serial(key
), inode
->i_ino
, page
->index
);
141 vnode
= AFS_FS_I(inode
);
143 BUG_ON(!PageLocked(page
));
146 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
150 #ifdef CONFIG_AFS_FSCACHE
151 ret
= fscache_read_or_alloc_page(vnode
->cache
,
153 afs_file_readpage_read_complete
,
160 /* read BIO submitted (page in cache) */
164 /* page not yet cached */
166 _debug("cache said ENODATA");
169 /* page will not be cached */
171 _debug("cache said ENOBUFS");
174 offset
= page
->index
<< PAGE_CACHE_SHIFT
;
175 len
= min_t(size_t, i_size_read(inode
) - offset
, PAGE_SIZE
);
177 /* read the contents of the file from the server into the
179 ret
= afs_vnode_fetch_data(vnode
, key
, offset
, len
, page
);
181 if (ret
== -ENOENT
) {
182 _debug("got NOENT from server"
183 " - marking file deleted and stale");
184 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
188 #ifdef CONFIG_AFS_FSCACHE
189 fscache_uncache_page(vnode
->cache
, page
);
191 BUG_ON(PageFsCache(page
));
195 SetPageUptodate(page
);
197 /* send the page to the cache */
198 #ifdef CONFIG_AFS_FSCACHE
199 if (PageFsCache(page
) &&
200 fscache_write_page(vnode
->cache
, page
, GFP_KERNEL
) != 0) {
201 fscache_uncache_page(vnode
->cache
, page
);
202 BUG_ON(PageFsCache(page
));
214 _leave(" = %d", ret
);
219 * read a set of pages
221 static int afs_readpages(struct file
*file
, struct address_space
*mapping
,
222 struct list_head
*pages
, unsigned nr_pages
)
224 struct afs_vnode
*vnode
;
227 _enter(",{%lu},,%d", mapping
->host
->i_ino
, nr_pages
);
229 vnode
= AFS_FS_I(mapping
->host
);
230 if (vnode
->flags
& AFS_VNODE_DELETED
) {
231 _leave(" = -ESTALE");
235 /* attempt to read as many of the pages as possible */
236 #ifdef CONFIG_AFS_FSCACHE
237 ret
= fscache_read_or_alloc_pages(vnode
->cache
,
241 afs_file_readpage_read_complete
,
243 mapping_gfp_mask(mapping
));
249 /* all pages are being read from the cache */
251 BUG_ON(!list_empty(pages
));
252 BUG_ON(nr_pages
!= 0);
253 _leave(" = 0 [reading all]");
256 /* there were pages that couldn't be read from the cache */
263 _leave(" = %d", ret
);
267 /* load the missing pages from the network */
268 ret
= read_cache_pages(mapping
, pages
, (void *) afs_readpage
, file
);
270 _leave(" = %d [netting]", ret
);
275 * write back a dirty page
277 static int afs_launder_page(struct page
*page
)
279 _enter("{%lu}", page
->index
);
285 * invalidate part or all of a page
286 * - release a page and clean up its private data if offset is 0 (indicating
289 static void afs_invalidatepage(struct page
*page
, unsigned long offset
)
291 struct afs_writeback
*wb
= (struct afs_writeback
*) page_private(page
);
293 _enter("{%lu},%lu", page
->index
, offset
);
295 BUG_ON(!PageLocked(page
));
297 /* we clean up only if the entire page is being invalidated */
299 #ifdef CONFIG_AFS_FSCACHE
300 if (PageFsCache(page
)) {
301 struct afs_vnode
*vnode
= AFS_FS_I(page
->mapping
->host
);
302 fscache_wait_on_page_write(vnode
->cache
, page
);
303 fscache_uncache_page(vnode
->cache
, page
);
304 ClearPageFsCache(page
);
308 if (PagePrivate(page
)) {
309 if (wb
&& !PageWriteback(page
)) {
310 set_page_private(page
, 0);
311 afs_put_writeback(wb
);
314 if (!page_private(page
))
315 ClearPagePrivate(page
);
323 * release a page and clean up its private state if it's not busy
324 * - return true if the page can now be released, false if not
326 static int afs_releasepage(struct page
*page
, gfp_t gfp_flags
)
328 struct afs_writeback
*wb
= (struct afs_writeback
*) page_private(page
);
329 struct afs_vnode
*vnode
= AFS_FS_I(page
->mapping
->host
);
331 _enter("{{%x:%u}[%lu],%lx},%x",
332 vnode
->fid
.vid
, vnode
->fid
.vnode
, page
->index
, page
->flags
,
335 /* deny if page is being written to the cache and the caller hasn't
337 #ifdef CONFIG_AFS_FSCACHE
338 if (PageFsCache(page
)) {
339 if (fscache_check_page_write(vnode
->cache
, page
)) {
340 if (!(gfp_flags
& __GFP_WAIT
)) {
341 _leave(" = F [cache busy]");
344 fscache_wait_on_page_write(vnode
->cache
, page
);
347 fscache_uncache_page(vnode
->cache
, page
);
348 ClearPageFsCache(page
);
352 if (PagePrivate(page
)) {
354 set_page_private(page
, 0);
355 afs_put_writeback(wb
);
357 ClearPagePrivate(page
);
360 /* indicate that the page can be released */