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/fs.h> 16 #include <linux/pagemap.h> 17 #include <linux/writeback.h> 18 #include <linux/gfp.h> 19 #include <linux/task_io_accounting_ops.h> 20 #include "internal.h" 21 22 static int afs_readpage(struct file *file, struct page *page); 23 static void afs_invalidatepage(struct page *page, unsigned int offset, 24 unsigned int length); 25 static int afs_releasepage(struct page *page, gfp_t gfp_flags); 26 static int afs_launder_page(struct page *page); 27 28 static int afs_readpages(struct file *filp, struct address_space *mapping, 29 struct list_head *pages, unsigned nr_pages); 30 31 const struct file_operations afs_file_operations = { 32 .open = afs_open, 33 .release = afs_release, 34 .llseek = generic_file_llseek, 35 .read_iter = generic_file_read_iter, 36 .write_iter = 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 * Dispose of a ref to a read record. 107 */ 108 void afs_put_read(struct afs_read *req) 109 { 110 int i; 111 112 if (atomic_dec_and_test(&req->usage)) { 113 for (i = 0; i < req->nr_pages; i++) 114 if (req->pages[i]) 115 put_page(req->pages[i]); 116 kfree(req); 117 } 118 } 119 120 #ifdef CONFIG_AFS_FSCACHE 121 /* 122 * deal with notification that a page was read from the cache 123 */ 124 static void afs_file_readpage_read_complete(struct page *page, 125 void *data, 126 int error) 127 { 128 _enter("%p,%p,%d", page, data, error); 129 130 /* if the read completes with an error, we just unlock the page and let 131 * the VM reissue the readpage */ 132 if (!error) 133 SetPageUptodate(page); 134 unlock_page(page); 135 } 136 #endif 137 138 /* 139 * read page from file, directory or symlink, given a key to use 140 */ 141 int afs_page_filler(void *data, struct page *page) 142 { 143 struct inode *inode = page->mapping->host; 144 struct afs_vnode *vnode = AFS_FS_I(inode); 145 struct afs_read *req; 146 struct key *key = data; 147 int ret; 148 149 _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index); 150 151 BUG_ON(!PageLocked(page)); 152 153 ret = -ESTALE; 154 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 155 goto error; 156 157 /* is it cached? */ 158 #ifdef CONFIG_AFS_FSCACHE 159 ret = fscache_read_or_alloc_page(vnode->cache, 160 page, 161 afs_file_readpage_read_complete, 162 NULL, 163 GFP_KERNEL); 164 #else 165 ret = -ENOBUFS; 166 #endif 167 switch (ret) { 168 /* read BIO submitted (page in cache) */ 169 case 0: 170 break; 171 172 /* page not yet cached */ 173 case -ENODATA: 174 _debug("cache said ENODATA"); 175 goto go_on; 176 177 /* page will not be cached */ 178 case -ENOBUFS: 179 _debug("cache said ENOBUFS"); 180 default: 181 go_on: 182 req = kzalloc(sizeof(struct afs_read) + sizeof(struct page *), 183 GFP_KERNEL); 184 if (!req) 185 goto enomem; 186 187 atomic_set(&req->usage, 1); 188 req->pos = (loff_t)page->index << PAGE_SHIFT; 189 req->len = min_t(size_t, i_size_read(inode) - req->pos, 190 PAGE_SIZE); 191 req->nr_pages = 1; 192 req->pages[0] = page; 193 get_page(page); 194 195 /* read the contents of the file from the server into the 196 * page */ 197 ret = afs_vnode_fetch_data(vnode, key, req); 198 afs_put_read(req); 199 if (ret < 0) { 200 if (ret == -ENOENT) { 201 _debug("got NOENT from server" 202 " - marking file deleted and stale"); 203 set_bit(AFS_VNODE_DELETED, &vnode->flags); 204 ret = -ESTALE; 205 } 206 207 #ifdef CONFIG_AFS_FSCACHE 208 fscache_uncache_page(vnode->cache, page); 209 #endif 210 BUG_ON(PageFsCache(page)); 211 goto error; 212 } 213 214 SetPageUptodate(page); 215 216 /* send the page to the cache */ 217 #ifdef CONFIG_AFS_FSCACHE 218 if (PageFsCache(page) && 219 fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) { 220 fscache_uncache_page(vnode->cache, page); 221 BUG_ON(PageFsCache(page)); 222 } 223 #endif 224 unlock_page(page); 225 } 226 227 _leave(" = 0"); 228 return 0; 229 230 enomem: 231 ret = -ENOMEM; 232 error: 233 SetPageError(page); 234 unlock_page(page); 235 _leave(" = %d", ret); 236 return ret; 237 } 238 239 /* 240 * read page from file, directory or symlink, given a file to nominate the key 241 * to be used 242 */ 243 static int afs_readpage(struct file *file, struct page *page) 244 { 245 struct key *key; 246 int ret; 247 248 if (file) { 249 key = file->private_data; 250 ASSERT(key != NULL); 251 ret = afs_page_filler(key, page); 252 } else { 253 struct inode *inode = page->mapping->host; 254 key = afs_request_key(AFS_FS_S(inode->i_sb)->volume->cell); 255 if (IS_ERR(key)) { 256 ret = PTR_ERR(key); 257 } else { 258 ret = afs_page_filler(key, page); 259 key_put(key); 260 } 261 } 262 return ret; 263 } 264 265 /* 266 * Make pages available as they're filled. 267 */ 268 static void afs_readpages_page_done(struct afs_call *call, struct afs_read *req) 269 { 270 #ifdef CONFIG_AFS_FSCACHE 271 struct afs_vnode *vnode = call->reply; 272 #endif 273 struct page *page = req->pages[req->index]; 274 275 req->pages[req->index] = NULL; 276 SetPageUptodate(page); 277 278 /* send the page to the cache */ 279 #ifdef CONFIG_AFS_FSCACHE 280 if (PageFsCache(page) && 281 fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) { 282 fscache_uncache_page(vnode->cache, page); 283 BUG_ON(PageFsCache(page)); 284 } 285 #endif 286 unlock_page(page); 287 put_page(page); 288 } 289 290 /* 291 * Read a contiguous set of pages. 292 */ 293 static int afs_readpages_one(struct file *file, struct address_space *mapping, 294 struct list_head *pages) 295 { 296 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 297 struct afs_read *req; 298 struct list_head *p; 299 struct page *first, *page; 300 struct key *key = file->private_data; 301 pgoff_t index; 302 int ret, n, i; 303 304 /* Count the number of contiguous pages at the front of the list. Note 305 * that the list goes prev-wards rather than next-wards. 306 */ 307 first = list_entry(pages->prev, struct page, lru); 308 index = first->index + 1; 309 n = 1; 310 for (p = first->lru.prev; p != pages; p = p->prev) { 311 page = list_entry(p, struct page, lru); 312 if (page->index != index) 313 break; 314 index++; 315 n++; 316 } 317 318 req = kzalloc(sizeof(struct afs_read) + sizeof(struct page *) * n, 319 GFP_NOFS); 320 if (!req) 321 return -ENOMEM; 322 323 atomic_set(&req->usage, 1); 324 req->page_done = afs_readpages_page_done; 325 req->pos = first->index; 326 req->pos <<= PAGE_SHIFT; 327 328 /* Transfer the pages to the request. We add them in until one fails 329 * to add to the LRU and then we stop (as that'll make a hole in the 330 * contiguous run. 331 * 332 * Note that it's possible for the file size to change whilst we're 333 * doing this, but we rely on the server returning less than we asked 334 * for if the file shrank. We also rely on this to deal with a partial 335 * page at the end of the file. 336 */ 337 do { 338 page = list_entry(pages->prev, struct page, lru); 339 list_del(&page->lru); 340 index = page->index; 341 if (add_to_page_cache_lru(page, mapping, index, 342 readahead_gfp_mask(mapping))) { 343 #ifdef CONFIG_AFS_FSCACHE 344 fscache_uncache_page(vnode->cache, page); 345 #endif 346 put_page(page); 347 break; 348 } 349 350 req->pages[req->nr_pages++] = page; 351 req->len += PAGE_SIZE; 352 } while (req->nr_pages < n); 353 354 if (req->nr_pages == 0) { 355 kfree(req); 356 return 0; 357 } 358 359 ret = afs_vnode_fetch_data(vnode, key, req); 360 if (ret < 0) 361 goto error; 362 363 task_io_account_read(PAGE_SIZE * req->nr_pages); 364 afs_put_read(req); 365 return 0; 366 367 error: 368 if (ret == -ENOENT) { 369 _debug("got NOENT from server" 370 " - marking file deleted and stale"); 371 set_bit(AFS_VNODE_DELETED, &vnode->flags); 372 ret = -ESTALE; 373 } 374 375 for (i = 0; i < req->nr_pages; i++) { 376 page = req->pages[i]; 377 if (page) { 378 #ifdef CONFIG_AFS_FSCACHE 379 fscache_uncache_page(vnode->cache, page); 380 #endif 381 SetPageError(page); 382 unlock_page(page); 383 } 384 } 385 386 afs_put_read(req); 387 return ret; 388 } 389 390 /* 391 * read a set of pages 392 */ 393 static int afs_readpages(struct file *file, struct address_space *mapping, 394 struct list_head *pages, unsigned nr_pages) 395 { 396 struct key *key = file->private_data; 397 struct afs_vnode *vnode; 398 int ret = 0; 399 400 _enter("{%d},{%lu},,%d", 401 key_serial(key), mapping->host->i_ino, nr_pages); 402 403 ASSERT(key != NULL); 404 405 vnode = AFS_FS_I(mapping->host); 406 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { 407 _leave(" = -ESTALE"); 408 return -ESTALE; 409 } 410 411 /* attempt to read as many of the pages as possible */ 412 #ifdef CONFIG_AFS_FSCACHE 413 ret = fscache_read_or_alloc_pages(vnode->cache, 414 mapping, 415 pages, 416 &nr_pages, 417 afs_file_readpage_read_complete, 418 NULL, 419 mapping_gfp_mask(mapping)); 420 #else 421 ret = -ENOBUFS; 422 #endif 423 424 switch (ret) { 425 /* all pages are being read from the cache */ 426 case 0: 427 BUG_ON(!list_empty(pages)); 428 BUG_ON(nr_pages != 0); 429 _leave(" = 0 [reading all]"); 430 return 0; 431 432 /* there were pages that couldn't be read from the cache */ 433 case -ENODATA: 434 case -ENOBUFS: 435 break; 436 437 /* other error */ 438 default: 439 _leave(" = %d", ret); 440 return ret; 441 } 442 443 while (!list_empty(pages)) { 444 ret = afs_readpages_one(file, mapping, pages); 445 if (ret < 0) 446 break; 447 } 448 449 _leave(" = %d [netting]", ret); 450 return ret; 451 } 452 453 /* 454 * write back a dirty page 455 */ 456 static int afs_launder_page(struct page *page) 457 { 458 _enter("{%lu}", page->index); 459 460 return 0; 461 } 462 463 /* 464 * invalidate part or all of a page 465 * - release a page and clean up its private data if offset is 0 (indicating 466 * the entire page) 467 */ 468 static void afs_invalidatepage(struct page *page, unsigned int offset, 469 unsigned int length) 470 { 471 struct afs_writeback *wb = (struct afs_writeback *) page_private(page); 472 473 _enter("{%lu},%u,%u", page->index, offset, length); 474 475 BUG_ON(!PageLocked(page)); 476 477 /* we clean up only if the entire page is being invalidated */ 478 if (offset == 0 && length == PAGE_SIZE) { 479 #ifdef CONFIG_AFS_FSCACHE 480 if (PageFsCache(page)) { 481 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host); 482 fscache_wait_on_page_write(vnode->cache, page); 483 fscache_uncache_page(vnode->cache, page); 484 } 485 #endif 486 487 if (PagePrivate(page)) { 488 if (wb && !PageWriteback(page)) { 489 set_page_private(page, 0); 490 afs_put_writeback(wb); 491 } 492 493 if (!page_private(page)) 494 ClearPagePrivate(page); 495 } 496 } 497 498 _leave(""); 499 } 500 501 /* 502 * release a page and clean up its private state if it's not busy 503 * - return true if the page can now be released, false if not 504 */ 505 static int afs_releasepage(struct page *page, gfp_t gfp_flags) 506 { 507 struct afs_writeback *wb = (struct afs_writeback *) page_private(page); 508 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host); 509 510 _enter("{{%x:%u}[%lu],%lx},%x", 511 vnode->fid.vid, vnode->fid.vnode, page->index, page->flags, 512 gfp_flags); 513 514 /* deny if page is being written to the cache and the caller hasn't 515 * elected to wait */ 516 #ifdef CONFIG_AFS_FSCACHE 517 if (!fscache_maybe_release_page(vnode->cache, page, gfp_flags)) { 518 _leave(" = F [cache busy]"); 519 return 0; 520 } 521 #endif 522 523 if (PagePrivate(page)) { 524 if (wb) { 525 set_page_private(page, 0); 526 afs_put_writeback(wb); 527 } 528 ClearPagePrivate(page); 529 } 530 531 /* indicate that the page can be released */ 532 _leave(" = T"); 533 return 1; 534 } 535