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>
16 #include <linux/pagemap.h>
17 #include <linux/writeback.h>
18 #include <linux/gfp.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
);
105 #ifdef CONFIG_AFS_FSCACHE
107 * deal with notification that a page was read from the cache
109 static void afs_file_readpage_read_complete(struct page
*page
,
113 _enter("%p,%p,%d", page
, data
, error
);
115 /* if the read completes with an error, we just unlock the page and let
116 * the VM reissue the readpage */
118 SetPageUptodate(page
);
124 * read page from file, directory or symlink, given a key to use
126 int afs_page_filler(void *data
, struct page
*page
)
128 struct inode
*inode
= page
->mapping
->host
;
129 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
130 struct key
*key
= data
;
135 _enter("{%x},{%lu},{%lu}", key_serial(key
), inode
->i_ino
, page
->index
);
137 BUG_ON(!PageLocked(page
));
140 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
144 #ifdef CONFIG_AFS_FSCACHE
145 ret
= fscache_read_or_alloc_page(vnode
->cache
,
147 afs_file_readpage_read_complete
,
154 /* read BIO submitted (page in cache) */
158 /* page not yet cached */
160 _debug("cache said ENODATA");
163 /* page will not be cached */
165 _debug("cache said ENOBUFS");
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
);
182 #ifdef CONFIG_AFS_FSCACHE
183 fscache_uncache_page(vnode
->cache
, page
);
185 BUG_ON(PageFsCache(page
));
189 SetPageUptodate(page
);
191 /* send the page to the cache */
192 #ifdef CONFIG_AFS_FSCACHE
193 if (PageFsCache(page
) &&
194 fscache_write_page(vnode
->cache
, page
, GFP_KERNEL
) != 0) {
195 fscache_uncache_page(vnode
->cache
, page
);
196 BUG_ON(PageFsCache(page
));
208 _leave(" = %d", ret
);
213 * read page from file, directory or symlink, given a file to nominate the key
216 static int afs_readpage(struct file
*file
, struct page
*page
)
222 key
= file
->private_data
;
224 ret
= afs_page_filler(key
, page
);
226 struct inode
*inode
= page
->mapping
->host
;
227 key
= afs_request_key(AFS_FS_S(inode
->i_sb
)->volume
->cell
);
231 ret
= afs_page_filler(key
, page
);
239 * read a set of pages
241 static int afs_readpages(struct file
*file
, struct address_space
*mapping
,
242 struct list_head
*pages
, unsigned nr_pages
)
244 struct key
*key
= file
->private_data
;
245 struct afs_vnode
*vnode
;
248 _enter("{%d},{%lu},,%d",
249 key_serial(key
), mapping
->host
->i_ino
, nr_pages
);
253 vnode
= AFS_FS_I(mapping
->host
);
254 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
255 _leave(" = -ESTALE");
259 /* attempt to read as many of the pages as possible */
260 #ifdef CONFIG_AFS_FSCACHE
261 ret
= fscache_read_or_alloc_pages(vnode
->cache
,
265 afs_file_readpage_read_complete
,
267 mapping_gfp_mask(mapping
));
273 /* all pages are being read from the cache */
275 BUG_ON(!list_empty(pages
));
276 BUG_ON(nr_pages
!= 0);
277 _leave(" = 0 [reading all]");
280 /* there were pages that couldn't be read from the cache */
287 _leave(" = %d", ret
);
291 /* load the missing pages from the network */
292 ret
= read_cache_pages(mapping
, pages
, afs_page_filler
, key
);
294 _leave(" = %d [netting]", ret
);
299 * write back a dirty page
301 static int afs_launder_page(struct page
*page
)
303 _enter("{%lu}", page
->index
);
309 * invalidate part or all of a page
310 * - release a page and clean up its private data if offset is 0 (indicating
313 static void afs_invalidatepage(struct page
*page
, unsigned long offset
)
315 struct afs_writeback
*wb
= (struct afs_writeback
*) page_private(page
);
317 _enter("{%lu},%lu", page
->index
, offset
);
319 BUG_ON(!PageLocked(page
));
321 /* we clean up only if the entire page is being invalidated */
323 #ifdef CONFIG_AFS_FSCACHE
324 if (PageFsCache(page
)) {
325 struct afs_vnode
*vnode
= AFS_FS_I(page
->mapping
->host
);
326 fscache_wait_on_page_write(vnode
->cache
, page
);
327 fscache_uncache_page(vnode
->cache
, page
);
331 if (PagePrivate(page
)) {
332 if (wb
&& !PageWriteback(page
)) {
333 set_page_private(page
, 0);
334 afs_put_writeback(wb
);
337 if (!page_private(page
))
338 ClearPagePrivate(page
);
346 * release a page and clean up its private state if it's not busy
347 * - return true if the page can now be released, false if not
349 static int afs_releasepage(struct page
*page
, gfp_t gfp_flags
)
351 struct afs_writeback
*wb
= (struct afs_writeback
*) page_private(page
);
352 struct afs_vnode
*vnode
= AFS_FS_I(page
->mapping
->host
);
354 _enter("{{%x:%u}[%lu],%lx},%x",
355 vnode
->fid
.vid
, vnode
->fid
.vnode
, page
->index
, page
->flags
,
358 /* deny if page is being written to the cache and the caller hasn't
360 #ifdef CONFIG_AFS_FSCACHE
361 if (!fscache_maybe_release_page(vnode
->cache
, page
, gfp_flags
)) {
362 _leave(" = F [cache busy]");
367 if (PagePrivate(page
)) {
369 set_page_private(page
, 0);
370 afs_put_writeback(wb
);
372 ClearPagePrivate(page
);
375 /* indicate that the page can be released */