1 /* AFS filesystem file handling 2 * 3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. 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> 15 #include <linux/slab.h> 16 #include <linux/fs.h> 17 #include <linux/pagemap.h> 18 #include <linux/writeback.h> 19 #include "internal.h" 20 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); 25 26 static int afs_readpages(struct file *filp, struct address_space *mapping, 27 struct list_head *pages, unsigned nr_pages); 28 29 const struct file_operations afs_file_operations = { 30 .open = afs_open, 31 .release = afs_release, 32 .llseek = generic_file_llseek, 33 .read = do_sync_read, 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, 39 .fsync = afs_fsync, 40 .lock = afs_lock, 41 .flock = afs_flock, 42 }; 43 44 const struct inode_operations afs_file_inode_operations = { 45 .getattr = afs_getattr, 46 .setattr = afs_setattr, 47 .permission = afs_permission, 48 }; 49 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, 61 }; 62 63 /* 64 * open an AFS file or directory and attach a key to it 65 */ 66 int afs_open(struct inode *inode, struct file *file) 67 { 68 struct afs_vnode *vnode = AFS_FS_I(inode); 69 struct key *key; 70 int ret; 71 72 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode); 73 74 key = afs_request_key(vnode->volume->cell); 75 if (IS_ERR(key)) { 76 _leave(" = %ld [key]", PTR_ERR(key)); 77 return PTR_ERR(key); 78 } 79 80 ret = afs_validate(vnode, key); 81 if (ret < 0) { 82 _leave(" = %d [val]", ret); 83 return ret; 84 } 85 86 file->private_data = key; 87 _leave(" = 0"); 88 return 0; 89 } 90 91 /* 92 * release an AFS file or directory and discard its key 93 */ 94 int afs_release(struct inode *inode, struct file *file) 95 { 96 struct afs_vnode *vnode = AFS_FS_I(inode); 97 98 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode); 99 100 key_put(file->private_data); 101 _leave(" = 0"); 102 return 0; 103 } 104 105 /* 106 * deal with notification that a page was read from the cache 107 */ 108 static void afs_file_readpage_read_complete(struct page *page, 109 void *data, 110 int error) 111 { 112 _enter("%p,%p,%d", page, data, error); 113 114 /* if the read completes with an error, we just unlock the page and let 115 * the VM reissue the readpage */ 116 if (!error) 117 SetPageUptodate(page); 118 unlock_page(page); 119 } 120 121 /* 122 * AFS read page from file, directory or symlink 123 */ 124 static int afs_readpage(struct file *file, struct page *page) 125 { 126 struct afs_vnode *vnode; 127 struct inode *inode; 128 struct key *key; 129 size_t len; 130 off_t offset; 131 int ret; 132 133 inode = page->mapping->host; 134 135 ASSERT(file != NULL); 136 key = file->private_data; 137 ASSERT(key != NULL); 138 139 _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index); 140 141 vnode = AFS_FS_I(inode); 142 143 BUG_ON(!PageLocked(page)); 144 145 ret = -ESTALE; 146 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 147 goto error; 148 149 /* is it cached? */ 150 #ifdef CONFIG_AFS_FSCACHE 151 ret = fscache_read_or_alloc_page(vnode->cache, 152 page, 153 afs_file_readpage_read_complete, 154 NULL, 155 GFP_KERNEL); 156 #else 157 ret = -ENOBUFS; 158 #endif 159 switch (ret) { 160 /* read BIO submitted (page in cache) */ 161 case 0: 162 break; 163 164 /* page not yet cached */ 165 case -ENODATA: 166 _debug("cache said ENODATA"); 167 goto go_on; 168 169 /* page will not be cached */ 170 case -ENOBUFS: 171 _debug("cache said ENOBUFS"); 172 default: 173 go_on: 174 offset = page->index << PAGE_CACHE_SHIFT; 175 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE); 176 177 /* read the contents of the file from the server into the 178 * page */ 179 ret = afs_vnode_fetch_data(vnode, key, offset, len, page); 180 if (ret < 0) { 181 if (ret == -ENOENT) { 182 _debug("got NOENT from server" 183 " - marking file deleted and stale"); 184 set_bit(AFS_VNODE_DELETED, &vnode->flags); 185 ret = -ESTALE; 186 } 187 188 #ifdef CONFIG_AFS_FSCACHE 189 fscache_uncache_page(vnode->cache, page); 190 #endif 191 BUG_ON(PageFsCache(page)); 192 goto error; 193 } 194 195 SetPageUptodate(page); 196 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)); 203 } 204 #endif 205 unlock_page(page); 206 } 207 208 _leave(" = 0"); 209 return 0; 210 211 error: 212 SetPageError(page); 213 unlock_page(page); 214 _leave(" = %d", ret); 215 return ret; 216 } 217 218 /* 219 * read a set of pages 220 */ 221 static int afs_readpages(struct file *file, struct address_space *mapping, 222 struct list_head *pages, unsigned nr_pages) 223 { 224 struct afs_vnode *vnode; 225 int ret = 0; 226 227 _enter(",{%lu},,%d", mapping->host->i_ino, nr_pages); 228 229 vnode = AFS_FS_I(mapping->host); 230 if (vnode->flags & AFS_VNODE_DELETED) { 231 _leave(" = -ESTALE"); 232 return -ESTALE; 233 } 234 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, 238 mapping, 239 pages, 240 &nr_pages, 241 afs_file_readpage_read_complete, 242 NULL, 243 mapping_gfp_mask(mapping)); 244 #else 245 ret = -ENOBUFS; 246 #endif 247 248 switch (ret) { 249 /* all pages are being read from the cache */ 250 case 0: 251 BUG_ON(!list_empty(pages)); 252 BUG_ON(nr_pages != 0); 253 _leave(" = 0 [reading all]"); 254 return 0; 255 256 /* there were pages that couldn't be read from the cache */ 257 case -ENODATA: 258 case -ENOBUFS: 259 break; 260 261 /* other error */ 262 default: 263 _leave(" = %d", ret); 264 return ret; 265 } 266 267 /* load the missing pages from the network */ 268 ret = read_cache_pages(mapping, pages, (void *) afs_readpage, file); 269 270 _leave(" = %d [netting]", ret); 271 return ret; 272 } 273 274 /* 275 * write back a dirty page 276 */ 277 static int afs_launder_page(struct page *page) 278 { 279 _enter("{%lu}", page->index); 280 281 return 0; 282 } 283 284 /* 285 * invalidate part or all of a page 286 * - release a page and clean up its private data if offset is 0 (indicating 287 * the entire page) 288 */ 289 static void afs_invalidatepage(struct page *page, unsigned long offset) 290 { 291 struct afs_writeback *wb = (struct afs_writeback *) page_private(page); 292 293 _enter("{%lu},%lu", page->index, offset); 294 295 BUG_ON(!PageLocked(page)); 296 297 /* we clean up only if the entire page is being invalidated */ 298 if (offset == 0) { 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); 305 } 306 #endif 307 308 if (PagePrivate(page)) { 309 if (wb && !PageWriteback(page)) { 310 set_page_private(page, 0); 311 afs_put_writeback(wb); 312 } 313 314 if (!page_private(page)) 315 ClearPagePrivate(page); 316 } 317 } 318 319 _leave(""); 320 } 321 322 /* 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 325 */ 326 static int afs_releasepage(struct page *page, gfp_t gfp_flags) 327 { 328 struct afs_writeback *wb = (struct afs_writeback *) page_private(page); 329 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host); 330 331 _enter("{{%x:%u}[%lu],%lx},%x", 332 vnode->fid.vid, vnode->fid.vnode, page->index, page->flags, 333 gfp_flags); 334 335 /* deny if page is being written to the cache and the caller hasn't 336 * elected to wait */ 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]"); 342 return 0; 343 } 344 fscache_wait_on_page_write(vnode->cache, page); 345 } 346 347 fscache_uncache_page(vnode->cache, page); 348 ClearPageFsCache(page); 349 } 350 #endif 351 352 if (PagePrivate(page)) { 353 if (wb) { 354 set_page_private(page, 0); 355 afs_put_writeback(wb); 356 } 357 ClearPagePrivate(page); 358 } 359 360 /* indicate that the page can be released */ 361 _leave(" = T"); 362 return 1; 363 } 364