1 /* handling of writes to regular files and writing back to the server 2 * 3 * Copyright (C) 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/backing-dev.h> 13 #include <linux/slab.h> 14 #include <linux/fs.h> 15 #include <linux/pagemap.h> 16 #include <linux/writeback.h> 17 #include <linux/pagevec.h> 18 #include "internal.h" 19 20 /* 21 * mark a page as having been made dirty and thus needing writeback 22 */ 23 int afs_set_page_dirty(struct page *page) 24 { 25 _enter(""); 26 return __set_page_dirty_nobuffers(page); 27 } 28 29 /* 30 * partly or wholly fill a page that's under preparation for writing 31 */ 32 static int afs_fill_page(struct afs_vnode *vnode, struct key *key, 33 loff_t pos, unsigned int len, struct page *page) 34 { 35 struct afs_read *req; 36 int ret; 37 38 _enter(",,%llu", (unsigned long long)pos); 39 40 req = kzalloc(sizeof(struct afs_read) + sizeof(struct page *), 41 GFP_KERNEL); 42 if (!req) 43 return -ENOMEM; 44 45 refcount_set(&req->usage, 1); 46 req->pos = pos; 47 req->len = len; 48 req->nr_pages = 1; 49 req->pages = req->array; 50 req->pages[0] = page; 51 get_page(page); 52 53 ret = afs_fetch_data(vnode, key, req); 54 afs_put_read(req); 55 if (ret < 0) { 56 if (ret == -ENOENT) { 57 _debug("got NOENT from server" 58 " - marking file deleted and stale"); 59 set_bit(AFS_VNODE_DELETED, &vnode->flags); 60 ret = -ESTALE; 61 } 62 } 63 64 _leave(" = %d", ret); 65 return ret; 66 } 67 68 /* 69 * prepare to perform part of a write to a page 70 */ 71 int afs_write_begin(struct file *file, struct address_space *mapping, 72 loff_t pos, unsigned len, unsigned flags, 73 struct page **pagep, void **fsdata) 74 { 75 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 76 struct page *page; 77 struct key *key = afs_file_key(file); 78 unsigned long priv; 79 unsigned f, from = pos & (PAGE_SIZE - 1); 80 unsigned t, to = from + len; 81 pgoff_t index = pos >> PAGE_SHIFT; 82 int ret; 83 84 _enter("{%x:%u},{%lx},%u,%u", 85 vnode->fid.vid, vnode->fid.vnode, index, from, to); 86 87 /* We want to store information about how much of a page is altered in 88 * page->private. 89 */ 90 BUILD_BUG_ON(PAGE_SIZE > 32768 && sizeof(page->private) < 8); 91 92 page = grab_cache_page_write_begin(mapping, index, flags); 93 if (!page) 94 return -ENOMEM; 95 96 if (!PageUptodate(page) && len != PAGE_SIZE) { 97 ret = afs_fill_page(vnode, key, pos & PAGE_MASK, PAGE_SIZE, page); 98 if (ret < 0) { 99 unlock_page(page); 100 put_page(page); 101 _leave(" = %d [prep]", ret); 102 return ret; 103 } 104 SetPageUptodate(page); 105 } 106 107 /* page won't leak in error case: it eventually gets cleaned off LRU */ 108 *pagep = page; 109 110 try_again: 111 /* See if this page is already partially written in a way that we can 112 * merge the new write with. 113 */ 114 t = f = 0; 115 if (PagePrivate(page)) { 116 priv = page_private(page); 117 f = priv & AFS_PRIV_MAX; 118 t = priv >> AFS_PRIV_SHIFT; 119 ASSERTCMP(f, <=, t); 120 } 121 122 if (f != t) { 123 if (PageWriteback(page)) { 124 trace_afs_page_dirty(vnode, tracepoint_string("alrdy"), 125 page->index, priv); 126 goto flush_conflicting_write; 127 } 128 /* If the file is being filled locally, allow inter-write 129 * spaces to be merged into writes. If it's not, only write 130 * back what the user gives us. 131 */ 132 if (!test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags) && 133 (to < f || from > t)) 134 goto flush_conflicting_write; 135 if (from < f) 136 f = from; 137 if (to > t) 138 t = to; 139 } else { 140 f = from; 141 t = to; 142 } 143 144 priv = (unsigned long)t << AFS_PRIV_SHIFT; 145 priv |= f; 146 trace_afs_page_dirty(vnode, tracepoint_string("begin"), 147 page->index, priv); 148 SetPagePrivate(page); 149 set_page_private(page, priv); 150 _leave(" = 0"); 151 return 0; 152 153 /* The previous write and this write aren't adjacent or overlapping, so 154 * flush the page out. 155 */ 156 flush_conflicting_write: 157 _debug("flush conflict"); 158 ret = write_one_page(page); 159 if (ret < 0) { 160 _leave(" = %d", ret); 161 return ret; 162 } 163 164 ret = lock_page_killable(page); 165 if (ret < 0) { 166 _leave(" = %d", ret); 167 return ret; 168 } 169 goto try_again; 170 } 171 172 /* 173 * finalise part of a write to a page 174 */ 175 int afs_write_end(struct file *file, struct address_space *mapping, 176 loff_t pos, unsigned len, unsigned copied, 177 struct page *page, void *fsdata) 178 { 179 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 180 struct key *key = afs_file_key(file); 181 loff_t i_size, maybe_i_size; 182 int ret; 183 184 _enter("{%x:%u},{%lx}", 185 vnode->fid.vid, vnode->fid.vnode, page->index); 186 187 maybe_i_size = pos + copied; 188 189 i_size = i_size_read(&vnode->vfs_inode); 190 if (maybe_i_size > i_size) { 191 spin_lock(&vnode->wb_lock); 192 i_size = i_size_read(&vnode->vfs_inode); 193 if (maybe_i_size > i_size) 194 i_size_write(&vnode->vfs_inode, maybe_i_size); 195 spin_unlock(&vnode->wb_lock); 196 } 197 198 if (!PageUptodate(page)) { 199 if (copied < len) { 200 /* Try and load any missing data from the server. The 201 * unmarshalling routine will take care of clearing any 202 * bits that are beyond the EOF. 203 */ 204 ret = afs_fill_page(vnode, key, pos + copied, 205 len - copied, page); 206 if (ret < 0) 207 goto out; 208 } 209 SetPageUptodate(page); 210 } 211 212 set_page_dirty(page); 213 if (PageDirty(page)) 214 _debug("dirtied"); 215 ret = copied; 216 217 out: 218 unlock_page(page); 219 put_page(page); 220 return ret; 221 } 222 223 /* 224 * kill all the pages in the given range 225 */ 226 static void afs_kill_pages(struct address_space *mapping, 227 pgoff_t first, pgoff_t last) 228 { 229 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 230 struct pagevec pv; 231 unsigned count, loop; 232 233 _enter("{%x:%u},%lx-%lx", 234 vnode->fid.vid, vnode->fid.vnode, first, last); 235 236 pagevec_init(&pv); 237 238 do { 239 _debug("kill %lx-%lx", first, last); 240 241 count = last - first + 1; 242 if (count > PAGEVEC_SIZE) 243 count = PAGEVEC_SIZE; 244 pv.nr = find_get_pages_contig(mapping, first, count, pv.pages); 245 ASSERTCMP(pv.nr, ==, count); 246 247 for (loop = 0; loop < count; loop++) { 248 struct page *page = pv.pages[loop]; 249 ClearPageUptodate(page); 250 SetPageError(page); 251 end_page_writeback(page); 252 if (page->index >= first) 253 first = page->index + 1; 254 lock_page(page); 255 generic_error_remove_page(mapping, page); 256 } 257 258 __pagevec_release(&pv); 259 } while (first <= last); 260 261 _leave(""); 262 } 263 264 /* 265 * Redirty all the pages in a given range. 266 */ 267 static void afs_redirty_pages(struct writeback_control *wbc, 268 struct address_space *mapping, 269 pgoff_t first, pgoff_t last) 270 { 271 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 272 struct pagevec pv; 273 unsigned count, loop; 274 275 _enter("{%x:%u},%lx-%lx", 276 vnode->fid.vid, vnode->fid.vnode, first, last); 277 278 pagevec_init(&pv); 279 280 do { 281 _debug("redirty %lx-%lx", first, last); 282 283 count = last - first + 1; 284 if (count > PAGEVEC_SIZE) 285 count = PAGEVEC_SIZE; 286 pv.nr = find_get_pages_contig(mapping, first, count, pv.pages); 287 ASSERTCMP(pv.nr, ==, count); 288 289 for (loop = 0; loop < count; loop++) { 290 struct page *page = pv.pages[loop]; 291 292 redirty_page_for_writepage(wbc, page); 293 end_page_writeback(page); 294 if (page->index >= first) 295 first = page->index + 1; 296 } 297 298 __pagevec_release(&pv); 299 } while (first <= last); 300 301 _leave(""); 302 } 303 304 /* 305 * write to a file 306 */ 307 static int afs_store_data(struct address_space *mapping, 308 pgoff_t first, pgoff_t last, 309 unsigned offset, unsigned to) 310 { 311 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 312 struct afs_fs_cursor fc; 313 struct afs_wb_key *wbk = NULL; 314 struct list_head *p; 315 int ret = -ENOKEY, ret2; 316 317 _enter("%s{%x:%u.%u},%lx,%lx,%x,%x", 318 vnode->volume->name, 319 vnode->fid.vid, 320 vnode->fid.vnode, 321 vnode->fid.unique, 322 first, last, offset, to); 323 324 spin_lock(&vnode->wb_lock); 325 p = vnode->wb_keys.next; 326 327 /* Iterate through the list looking for a valid key to use. */ 328 try_next_key: 329 while (p != &vnode->wb_keys) { 330 wbk = list_entry(p, struct afs_wb_key, vnode_link); 331 _debug("wbk %u", key_serial(wbk->key)); 332 ret2 = key_validate(wbk->key); 333 if (ret2 == 0) 334 goto found_key; 335 if (ret == -ENOKEY) 336 ret = ret2; 337 p = p->next; 338 } 339 340 spin_unlock(&vnode->wb_lock); 341 afs_put_wb_key(wbk); 342 _leave(" = %d [no keys]", ret); 343 return ret; 344 345 found_key: 346 refcount_inc(&wbk->usage); 347 spin_unlock(&vnode->wb_lock); 348 349 _debug("USE WB KEY %u", key_serial(wbk->key)); 350 351 ret = -ERESTARTSYS; 352 if (afs_begin_vnode_operation(&fc, vnode, wbk->key)) { 353 while (afs_select_fileserver(&fc)) { 354 fc.cb_break = vnode->cb_break + vnode->cb_s_break; 355 afs_fs_store_data(&fc, mapping, first, last, offset, to); 356 } 357 358 afs_check_for_remote_deletion(&fc, fc.vnode); 359 afs_vnode_commit_status(&fc, vnode, fc.cb_break); 360 ret = afs_end_vnode_operation(&fc); 361 } 362 363 switch (ret) { 364 case 0: 365 afs_stat_v(vnode, n_stores); 366 atomic_long_add((last * PAGE_SIZE + to) - 367 (first * PAGE_SIZE + offset), 368 &afs_v2net(vnode)->n_store_bytes); 369 break; 370 case -EACCES: 371 case -EPERM: 372 case -ENOKEY: 373 case -EKEYEXPIRED: 374 case -EKEYREJECTED: 375 case -EKEYREVOKED: 376 _debug("next"); 377 spin_lock(&vnode->wb_lock); 378 p = wbk->vnode_link.next; 379 afs_put_wb_key(wbk); 380 goto try_next_key; 381 } 382 383 afs_put_wb_key(wbk); 384 _leave(" = %d", ret); 385 return ret; 386 } 387 388 /* 389 * Synchronously write back the locked page and any subsequent non-locked dirty 390 * pages. 391 */ 392 static int afs_write_back_from_locked_page(struct address_space *mapping, 393 struct writeback_control *wbc, 394 struct page *primary_page, 395 pgoff_t final_page) 396 { 397 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 398 struct page *pages[8], *page; 399 unsigned long count, priv; 400 unsigned n, offset, to, f, t; 401 pgoff_t start, first, last; 402 int loop, ret; 403 404 _enter(",%lx", primary_page->index); 405 406 count = 1; 407 if (test_set_page_writeback(primary_page)) 408 BUG(); 409 410 /* Find all consecutive lockable dirty pages that have contiguous 411 * written regions, stopping when we find a page that is not 412 * immediately lockable, is not dirty or is missing, or we reach the 413 * end of the range. 414 */ 415 start = primary_page->index; 416 priv = page_private(primary_page); 417 offset = priv & AFS_PRIV_MAX; 418 to = priv >> AFS_PRIV_SHIFT; 419 trace_afs_page_dirty(vnode, tracepoint_string("store"), 420 primary_page->index, priv); 421 422 WARN_ON(offset == to); 423 if (offset == to) 424 trace_afs_page_dirty(vnode, tracepoint_string("WARN"), 425 primary_page->index, priv); 426 427 if (start >= final_page || 428 (to < PAGE_SIZE && !test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags))) 429 goto no_more; 430 431 start++; 432 do { 433 _debug("more %lx [%lx]", start, count); 434 n = final_page - start + 1; 435 if (n > ARRAY_SIZE(pages)) 436 n = ARRAY_SIZE(pages); 437 n = find_get_pages_contig(mapping, start, ARRAY_SIZE(pages), pages); 438 _debug("fgpc %u", n); 439 if (n == 0) 440 goto no_more; 441 if (pages[0]->index != start) { 442 do { 443 put_page(pages[--n]); 444 } while (n > 0); 445 goto no_more; 446 } 447 448 for (loop = 0; loop < n; loop++) { 449 page = pages[loop]; 450 if (to != PAGE_SIZE && 451 !test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags)) 452 break; 453 if (page->index > final_page) 454 break; 455 if (!trylock_page(page)) 456 break; 457 if (!PageDirty(page) || PageWriteback(page)) { 458 unlock_page(page); 459 break; 460 } 461 462 priv = page_private(page); 463 f = priv & AFS_PRIV_MAX; 464 t = priv >> AFS_PRIV_SHIFT; 465 if (f != 0 && 466 !test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags)) { 467 unlock_page(page); 468 break; 469 } 470 to = t; 471 472 trace_afs_page_dirty(vnode, tracepoint_string("store+"), 473 page->index, priv); 474 475 if (!clear_page_dirty_for_io(page)) 476 BUG(); 477 if (test_set_page_writeback(page)) 478 BUG(); 479 unlock_page(page); 480 put_page(page); 481 } 482 count += loop; 483 if (loop < n) { 484 for (; loop < n; loop++) 485 put_page(pages[loop]); 486 goto no_more; 487 } 488 489 start += loop; 490 } while (start <= final_page && count < 65536); 491 492 no_more: 493 /* We now have a contiguous set of dirty pages, each with writeback 494 * set; the first page is still locked at this point, but all the rest 495 * have been unlocked. 496 */ 497 unlock_page(primary_page); 498 499 first = primary_page->index; 500 last = first + count - 1; 501 502 _debug("write back %lx[%u..] to %lx[..%u]", first, offset, last, to); 503 504 ret = afs_store_data(mapping, first, last, offset, to); 505 switch (ret) { 506 case 0: 507 ret = count; 508 break; 509 510 default: 511 pr_notice("kAFS: Unexpected error from FS.StoreData %d\n", ret); 512 /* Fall through */ 513 case -EACCES: 514 case -EPERM: 515 case -ENOKEY: 516 case -EKEYEXPIRED: 517 case -EKEYREJECTED: 518 case -EKEYREVOKED: 519 afs_redirty_pages(wbc, mapping, first, last); 520 mapping_set_error(mapping, ret); 521 break; 522 523 case -EDQUOT: 524 case -ENOSPC: 525 afs_redirty_pages(wbc, mapping, first, last); 526 mapping_set_error(mapping, -ENOSPC); 527 break; 528 529 case -EROFS: 530 case -EIO: 531 case -EREMOTEIO: 532 case -EFBIG: 533 case -ENOENT: 534 case -ENOMEDIUM: 535 case -ENXIO: 536 afs_kill_pages(mapping, first, last); 537 mapping_set_error(mapping, ret); 538 break; 539 } 540 541 _leave(" = %d", ret); 542 return ret; 543 } 544 545 /* 546 * write a page back to the server 547 * - the caller locked the page for us 548 */ 549 int afs_writepage(struct page *page, struct writeback_control *wbc) 550 { 551 int ret; 552 553 _enter("{%lx},", page->index); 554 555 ret = afs_write_back_from_locked_page(page->mapping, wbc, page, 556 wbc->range_end >> PAGE_SHIFT); 557 if (ret < 0) { 558 _leave(" = %d", ret); 559 return 0; 560 } 561 562 wbc->nr_to_write -= ret; 563 564 _leave(" = 0"); 565 return 0; 566 } 567 568 /* 569 * write a region of pages back to the server 570 */ 571 static int afs_writepages_region(struct address_space *mapping, 572 struct writeback_control *wbc, 573 pgoff_t index, pgoff_t end, pgoff_t *_next) 574 { 575 struct page *page; 576 int ret, n; 577 578 _enter(",,%lx,%lx,", index, end); 579 580 do { 581 n = find_get_pages_range_tag(mapping, &index, end, 582 PAGECACHE_TAG_DIRTY, 1, &page); 583 if (!n) 584 break; 585 586 _debug("wback %lx", page->index); 587 588 /* at this point we hold neither mapping->tree_lock nor lock on 589 * the page itself: the page may be truncated or invalidated 590 * (changing page->mapping to NULL), or even swizzled back from 591 * swapper_space to tmpfs file mapping 592 */ 593 ret = lock_page_killable(page); 594 if (ret < 0) { 595 put_page(page); 596 _leave(" = %d", ret); 597 return ret; 598 } 599 600 if (page->mapping != mapping || !PageDirty(page)) { 601 unlock_page(page); 602 put_page(page); 603 continue; 604 } 605 606 if (PageWriteback(page)) { 607 unlock_page(page); 608 if (wbc->sync_mode != WB_SYNC_NONE) 609 wait_on_page_writeback(page); 610 put_page(page); 611 continue; 612 } 613 614 if (!clear_page_dirty_for_io(page)) 615 BUG(); 616 ret = afs_write_back_from_locked_page(mapping, wbc, page, end); 617 put_page(page); 618 if (ret < 0) { 619 _leave(" = %d", ret); 620 return ret; 621 } 622 623 wbc->nr_to_write -= ret; 624 625 cond_resched(); 626 } while (index < end && wbc->nr_to_write > 0); 627 628 *_next = index; 629 _leave(" = 0 [%lx]", *_next); 630 return 0; 631 } 632 633 /* 634 * write some of the pending data back to the server 635 */ 636 int afs_writepages(struct address_space *mapping, 637 struct writeback_control *wbc) 638 { 639 pgoff_t start, end, next; 640 int ret; 641 642 _enter(""); 643 644 if (wbc->range_cyclic) { 645 start = mapping->writeback_index; 646 end = -1; 647 ret = afs_writepages_region(mapping, wbc, start, end, &next); 648 if (start > 0 && wbc->nr_to_write > 0 && ret == 0) 649 ret = afs_writepages_region(mapping, wbc, 0, start, 650 &next); 651 mapping->writeback_index = next; 652 } else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) { 653 end = (pgoff_t)(LLONG_MAX >> PAGE_SHIFT); 654 ret = afs_writepages_region(mapping, wbc, 0, end, &next); 655 if (wbc->nr_to_write > 0) 656 mapping->writeback_index = next; 657 } else { 658 start = wbc->range_start >> PAGE_SHIFT; 659 end = wbc->range_end >> PAGE_SHIFT; 660 ret = afs_writepages_region(mapping, wbc, start, end, &next); 661 } 662 663 _leave(" = %d", ret); 664 return ret; 665 } 666 667 /* 668 * completion of write to server 669 */ 670 void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call) 671 { 672 struct pagevec pv; 673 unsigned long priv; 674 unsigned count, loop; 675 pgoff_t first = call->first, last = call->last; 676 677 _enter("{%x:%u},{%lx-%lx}", 678 vnode->fid.vid, vnode->fid.vnode, first, last); 679 680 pagevec_init(&pv); 681 682 do { 683 _debug("done %lx-%lx", first, last); 684 685 count = last - first + 1; 686 if (count > PAGEVEC_SIZE) 687 count = PAGEVEC_SIZE; 688 pv.nr = find_get_pages_contig(vnode->vfs_inode.i_mapping, 689 first, count, pv.pages); 690 ASSERTCMP(pv.nr, ==, count); 691 692 for (loop = 0; loop < count; loop++) { 693 priv = page_private(pv.pages[loop]); 694 trace_afs_page_dirty(vnode, tracepoint_string("clear"), 695 pv.pages[loop]->index, priv); 696 set_page_private(pv.pages[loop], 0); 697 end_page_writeback(pv.pages[loop]); 698 } 699 first += count; 700 __pagevec_release(&pv); 701 } while (first <= last); 702 703 afs_prune_wb_keys(vnode); 704 _leave(""); 705 } 706 707 /* 708 * write to an AFS file 709 */ 710 ssize_t afs_file_write(struct kiocb *iocb, struct iov_iter *from) 711 { 712 struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp)); 713 ssize_t result; 714 size_t count = iov_iter_count(from); 715 716 _enter("{%x.%u},{%zu},", 717 vnode->fid.vid, vnode->fid.vnode, count); 718 719 if (IS_SWAPFILE(&vnode->vfs_inode)) { 720 printk(KERN_INFO 721 "AFS: Attempt to write to active swap file!\n"); 722 return -EBUSY; 723 } 724 725 if (!count) 726 return 0; 727 728 result = generic_file_write_iter(iocb, from); 729 730 _leave(" = %zd", result); 731 return result; 732 } 733 734 /* 735 * flush any dirty pages for this process, and check for write errors. 736 * - the return status from this call provides a reliable indication of 737 * whether any write errors occurred for this process. 738 */ 739 int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 740 { 741 struct inode *inode = file_inode(file); 742 struct afs_vnode *vnode = AFS_FS_I(inode); 743 744 _enter("{%x:%u},{n=%pD},%d", 745 vnode->fid.vid, vnode->fid.vnode, file, 746 datasync); 747 748 return file_write_and_wait_range(file, start, end); 749 } 750 751 /* 752 * notification that a previously read-only page is about to become writable 753 * - if it returns an error, the caller will deliver a bus error signal 754 */ 755 int afs_page_mkwrite(struct vm_fault *vmf) 756 { 757 struct file *file = vmf->vma->vm_file; 758 struct inode *inode = file_inode(file); 759 struct afs_vnode *vnode = AFS_FS_I(inode); 760 unsigned long priv; 761 762 _enter("{{%x:%u}},{%lx}", 763 vnode->fid.vid, vnode->fid.vnode, vmf->page->index); 764 765 sb_start_pagefault(inode->i_sb); 766 767 /* Wait for the page to be written to the cache before we allow it to 768 * be modified. We then assume the entire page will need writing back. 769 */ 770 #ifdef CONFIG_AFS_FSCACHE 771 fscache_wait_on_page_write(vnode->cache, vmf->page); 772 #endif 773 774 if (PageWriteback(vmf->page) && 775 wait_on_page_bit_killable(vmf->page, PG_writeback) < 0) 776 return VM_FAULT_RETRY; 777 778 if (lock_page_killable(vmf->page) < 0) 779 return VM_FAULT_RETRY; 780 781 /* We mustn't change page->private until writeback is complete as that 782 * details the portion of the page we need to write back and we might 783 * need to redirty the page if there's a problem. 784 */ 785 wait_on_page_writeback(vmf->page); 786 787 priv = (unsigned long)PAGE_SIZE << AFS_PRIV_SHIFT; /* To */ 788 priv |= 0; /* From */ 789 trace_afs_page_dirty(vnode, tracepoint_string("mkwrite"), 790 vmf->page->index, priv); 791 SetPagePrivate(vmf->page); 792 set_page_private(vmf->page, priv); 793 794 sb_end_pagefault(inode->i_sb); 795 return VM_FAULT_LOCKED; 796 } 797 798 /* 799 * Prune the keys cached for writeback. The caller must hold vnode->wb_lock. 800 */ 801 void afs_prune_wb_keys(struct afs_vnode *vnode) 802 { 803 LIST_HEAD(graveyard); 804 struct afs_wb_key *wbk, *tmp; 805 806 /* Discard unused keys */ 807 spin_lock(&vnode->wb_lock); 808 809 if (!mapping_tagged(&vnode->vfs_inode.i_data, PAGECACHE_TAG_WRITEBACK) && 810 !mapping_tagged(&vnode->vfs_inode.i_data, PAGECACHE_TAG_DIRTY)) { 811 list_for_each_entry_safe(wbk, tmp, &vnode->wb_keys, vnode_link) { 812 if (refcount_read(&wbk->usage) == 1) 813 list_move(&wbk->vnode_link, &graveyard); 814 } 815 } 816 817 spin_unlock(&vnode->wb_lock); 818 819 while (!list_empty(&graveyard)) { 820 wbk = list_entry(graveyard.next, struct afs_wb_key, vnode_link); 821 list_del(&wbk->vnode_link); 822 afs_put_wb_key(wbk); 823 } 824 } 825 826 /* 827 * Clean up a page during invalidation. 828 */ 829 int afs_launder_page(struct page *page) 830 { 831 struct address_space *mapping = page->mapping; 832 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 833 unsigned long priv; 834 unsigned int f, t; 835 int ret = 0; 836 837 _enter("{%lx}", page->index); 838 839 priv = page_private(page); 840 if (clear_page_dirty_for_io(page)) { 841 f = 0; 842 t = PAGE_SIZE; 843 if (PagePrivate(page)) { 844 f = priv & AFS_PRIV_MAX; 845 t = priv >> AFS_PRIV_SHIFT; 846 } 847 848 trace_afs_page_dirty(vnode, tracepoint_string("launder"), 849 page->index, priv); 850 ret = afs_store_data(mapping, page->index, page->index, t, f); 851 } 852 853 trace_afs_page_dirty(vnode, tracepoint_string("laundered"), 854 page->index, priv); 855 set_page_private(page, 0); 856 ClearPagePrivate(page); 857 858 #ifdef CONFIG_AFS_FSCACHE 859 if (PageFsCache(page)) { 860 fscache_wait_on_page_write(vnode->cache, page); 861 fscache_uncache_page(vnode->cache, page); 862 } 863 #endif 864 return ret; 865 } 866