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 = afs_calc_vnode_cb_break(vnode); 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 trace_afs_file_error(vnode, ret, afs_file_error_writeback_fail); 537 afs_kill_pages(mapping, first, last); 538 mapping_set_error(mapping, ret); 539 break; 540 } 541 542 _leave(" = %d", ret); 543 return ret; 544 } 545 546 /* 547 * write a page back to the server 548 * - the caller locked the page for us 549 */ 550 int afs_writepage(struct page *page, struct writeback_control *wbc) 551 { 552 int ret; 553 554 _enter("{%lx},", page->index); 555 556 ret = afs_write_back_from_locked_page(page->mapping, wbc, page, 557 wbc->range_end >> PAGE_SHIFT); 558 if (ret < 0) { 559 _leave(" = %d", ret); 560 return 0; 561 } 562 563 wbc->nr_to_write -= ret; 564 565 _leave(" = 0"); 566 return 0; 567 } 568 569 /* 570 * write a region of pages back to the server 571 */ 572 static int afs_writepages_region(struct address_space *mapping, 573 struct writeback_control *wbc, 574 pgoff_t index, pgoff_t end, pgoff_t *_next) 575 { 576 struct page *page; 577 int ret, n; 578 579 _enter(",,%lx,%lx,", index, end); 580 581 do { 582 n = find_get_pages_range_tag(mapping, &index, end, 583 PAGECACHE_TAG_DIRTY, 1, &page); 584 if (!n) 585 break; 586 587 _debug("wback %lx", page->index); 588 589 /* 590 * at this point we hold neither the i_pages lock nor the 591 * page lock: the page may be truncated or invalidated 592 * (changing page->mapping to NULL), or even swizzled 593 * back from swapper_space to tmpfs file mapping 594 */ 595 ret = lock_page_killable(page); 596 if (ret < 0) { 597 put_page(page); 598 _leave(" = %d", ret); 599 return ret; 600 } 601 602 if (page->mapping != mapping || !PageDirty(page)) { 603 unlock_page(page); 604 put_page(page); 605 continue; 606 } 607 608 if (PageWriteback(page)) { 609 unlock_page(page); 610 if (wbc->sync_mode != WB_SYNC_NONE) 611 wait_on_page_writeback(page); 612 put_page(page); 613 continue; 614 } 615 616 if (!clear_page_dirty_for_io(page)) 617 BUG(); 618 ret = afs_write_back_from_locked_page(mapping, wbc, page, end); 619 put_page(page); 620 if (ret < 0) { 621 _leave(" = %d", ret); 622 return ret; 623 } 624 625 wbc->nr_to_write -= ret; 626 627 cond_resched(); 628 } while (index < end && wbc->nr_to_write > 0); 629 630 *_next = index; 631 _leave(" = 0 [%lx]", *_next); 632 return 0; 633 } 634 635 /* 636 * write some of the pending data back to the server 637 */ 638 int afs_writepages(struct address_space *mapping, 639 struct writeback_control *wbc) 640 { 641 pgoff_t start, end, next; 642 int ret; 643 644 _enter(""); 645 646 if (wbc->range_cyclic) { 647 start = mapping->writeback_index; 648 end = -1; 649 ret = afs_writepages_region(mapping, wbc, start, end, &next); 650 if (start > 0 && wbc->nr_to_write > 0 && ret == 0) 651 ret = afs_writepages_region(mapping, wbc, 0, start, 652 &next); 653 mapping->writeback_index = next; 654 } else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) { 655 end = (pgoff_t)(LLONG_MAX >> PAGE_SHIFT); 656 ret = afs_writepages_region(mapping, wbc, 0, end, &next); 657 if (wbc->nr_to_write > 0) 658 mapping->writeback_index = next; 659 } else { 660 start = wbc->range_start >> PAGE_SHIFT; 661 end = wbc->range_end >> PAGE_SHIFT; 662 ret = afs_writepages_region(mapping, wbc, start, end, &next); 663 } 664 665 _leave(" = %d", ret); 666 return ret; 667 } 668 669 /* 670 * completion of write to server 671 */ 672 void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call) 673 { 674 struct pagevec pv; 675 unsigned long priv; 676 unsigned count, loop; 677 pgoff_t first = call->first, last = call->last; 678 679 _enter("{%x:%u},{%lx-%lx}", 680 vnode->fid.vid, vnode->fid.vnode, first, last); 681 682 pagevec_init(&pv); 683 684 do { 685 _debug("done %lx-%lx", first, last); 686 687 count = last - first + 1; 688 if (count > PAGEVEC_SIZE) 689 count = PAGEVEC_SIZE; 690 pv.nr = find_get_pages_contig(vnode->vfs_inode.i_mapping, 691 first, count, pv.pages); 692 ASSERTCMP(pv.nr, ==, count); 693 694 for (loop = 0; loop < count; loop++) { 695 priv = page_private(pv.pages[loop]); 696 trace_afs_page_dirty(vnode, tracepoint_string("clear"), 697 pv.pages[loop]->index, priv); 698 set_page_private(pv.pages[loop], 0); 699 end_page_writeback(pv.pages[loop]); 700 } 701 first += count; 702 __pagevec_release(&pv); 703 } while (first <= last); 704 705 afs_prune_wb_keys(vnode); 706 _leave(""); 707 } 708 709 /* 710 * write to an AFS file 711 */ 712 ssize_t afs_file_write(struct kiocb *iocb, struct iov_iter *from) 713 { 714 struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp)); 715 ssize_t result; 716 size_t count = iov_iter_count(from); 717 718 _enter("{%x.%u},{%zu},", 719 vnode->fid.vid, vnode->fid.vnode, count); 720 721 if (IS_SWAPFILE(&vnode->vfs_inode)) { 722 printk(KERN_INFO 723 "AFS: Attempt to write to active swap file!\n"); 724 return -EBUSY; 725 } 726 727 if (!count) 728 return 0; 729 730 result = generic_file_write_iter(iocb, from); 731 732 _leave(" = %zd", result); 733 return result; 734 } 735 736 /* 737 * flush any dirty pages for this process, and check for write errors. 738 * - the return status from this call provides a reliable indication of 739 * whether any write errors occurred for this process. 740 */ 741 int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 742 { 743 struct inode *inode = file_inode(file); 744 struct afs_vnode *vnode = AFS_FS_I(inode); 745 746 _enter("{%x:%u},{n=%pD},%d", 747 vnode->fid.vid, vnode->fid.vnode, file, 748 datasync); 749 750 return file_write_and_wait_range(file, start, end); 751 } 752 753 /* 754 * notification that a previously read-only page is about to become writable 755 * - if it returns an error, the caller will deliver a bus error signal 756 */ 757 vm_fault_t afs_page_mkwrite(struct vm_fault *vmf) 758 { 759 struct file *file = vmf->vma->vm_file; 760 struct inode *inode = file_inode(file); 761 struct afs_vnode *vnode = AFS_FS_I(inode); 762 unsigned long priv; 763 764 _enter("{{%x:%u}},{%lx}", 765 vnode->fid.vid, vnode->fid.vnode, vmf->page->index); 766 767 sb_start_pagefault(inode->i_sb); 768 769 /* Wait for the page to be written to the cache before we allow it to 770 * be modified. We then assume the entire page will need writing back. 771 */ 772 #ifdef CONFIG_AFS_FSCACHE 773 fscache_wait_on_page_write(vnode->cache, vmf->page); 774 #endif 775 776 if (PageWriteback(vmf->page) && 777 wait_on_page_bit_killable(vmf->page, PG_writeback) < 0) 778 return VM_FAULT_RETRY; 779 780 if (lock_page_killable(vmf->page) < 0) 781 return VM_FAULT_RETRY; 782 783 /* We mustn't change page->private until writeback is complete as that 784 * details the portion of the page we need to write back and we might 785 * need to redirty the page if there's a problem. 786 */ 787 wait_on_page_writeback(vmf->page); 788 789 priv = (unsigned long)PAGE_SIZE << AFS_PRIV_SHIFT; /* To */ 790 priv |= 0; /* From */ 791 trace_afs_page_dirty(vnode, tracepoint_string("mkwrite"), 792 vmf->page->index, priv); 793 SetPagePrivate(vmf->page); 794 set_page_private(vmf->page, priv); 795 796 sb_end_pagefault(inode->i_sb); 797 return VM_FAULT_LOCKED; 798 } 799 800 /* 801 * Prune the keys cached for writeback. The caller must hold vnode->wb_lock. 802 */ 803 void afs_prune_wb_keys(struct afs_vnode *vnode) 804 { 805 LIST_HEAD(graveyard); 806 struct afs_wb_key *wbk, *tmp; 807 808 /* Discard unused keys */ 809 spin_lock(&vnode->wb_lock); 810 811 if (!mapping_tagged(&vnode->vfs_inode.i_data, PAGECACHE_TAG_WRITEBACK) && 812 !mapping_tagged(&vnode->vfs_inode.i_data, PAGECACHE_TAG_DIRTY)) { 813 list_for_each_entry_safe(wbk, tmp, &vnode->wb_keys, vnode_link) { 814 if (refcount_read(&wbk->usage) == 1) 815 list_move(&wbk->vnode_link, &graveyard); 816 } 817 } 818 819 spin_unlock(&vnode->wb_lock); 820 821 while (!list_empty(&graveyard)) { 822 wbk = list_entry(graveyard.next, struct afs_wb_key, vnode_link); 823 list_del(&wbk->vnode_link); 824 afs_put_wb_key(wbk); 825 } 826 } 827 828 /* 829 * Clean up a page during invalidation. 830 */ 831 int afs_launder_page(struct page *page) 832 { 833 struct address_space *mapping = page->mapping; 834 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 835 unsigned long priv; 836 unsigned int f, t; 837 int ret = 0; 838 839 _enter("{%lx}", page->index); 840 841 priv = page_private(page); 842 if (clear_page_dirty_for_io(page)) { 843 f = 0; 844 t = PAGE_SIZE; 845 if (PagePrivate(page)) { 846 f = priv & AFS_PRIV_MAX; 847 t = priv >> AFS_PRIV_SHIFT; 848 } 849 850 trace_afs_page_dirty(vnode, tracepoint_string("launder"), 851 page->index, priv); 852 ret = afs_store_data(mapping, page->index, page->index, t, f); 853 } 854 855 trace_afs_page_dirty(vnode, tracepoint_string("laundered"), 856 page->index, priv); 857 set_page_private(page, 0); 858 ClearPagePrivate(page); 859 860 #ifdef CONFIG_AFS_FSCACHE 861 if (PageFsCache(page)) { 862 fscache_wait_on_page_write(vnode->cache, page); 863 fscache_uncache_page(vnode->cache, page); 864 } 865 #endif 866 return ret; 867 } 868