1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* handling of writes to regular files and writing back to the server 3 * 4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/backing-dev.h> 9 #include <linux/slab.h> 10 #include <linux/fs.h> 11 #include <linux/pagemap.h> 12 #include <linux/writeback.h> 13 #include <linux/pagevec.h> 14 #include <linux/netfs.h> 15 #include <linux/fscache.h> 16 #include "internal.h" 17 18 /* 19 * mark a page as having been made dirty and thus needing writeback 20 */ 21 int afs_set_page_dirty(struct page *page) 22 { 23 _enter(""); 24 return __set_page_dirty_nobuffers(page); 25 } 26 27 /* 28 * prepare to perform part of a write to a page 29 */ 30 int afs_write_begin(struct file *file, struct address_space *mapping, 31 loff_t pos, unsigned len, unsigned flags, 32 struct page **_page, void **fsdata) 33 { 34 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 35 struct page *page; 36 unsigned long priv; 37 unsigned f, from; 38 unsigned t, to; 39 pgoff_t index; 40 int ret; 41 42 _enter("{%llx:%llu},%llx,%x", 43 vnode->fid.vid, vnode->fid.vnode, pos, len); 44 45 /* Prefetch area to be written into the cache if we're caching this 46 * file. We need to do this before we get a lock on the page in case 47 * there's more than one writer competing for the same cache block. 48 */ 49 ret = netfs_write_begin(file, mapping, pos, len, flags, &page, fsdata, 50 &afs_req_ops, NULL); 51 if (ret < 0) 52 return ret; 53 54 index = page->index; 55 from = pos - index * PAGE_SIZE; 56 to = from + len; 57 58 try_again: 59 /* See if this page is already partially written in a way that we can 60 * merge the new write with. 61 */ 62 if (PagePrivate(page)) { 63 priv = page_private(page); 64 f = afs_page_dirty_from(page, priv); 65 t = afs_page_dirty_to(page, priv); 66 ASSERTCMP(f, <=, t); 67 68 if (PageWriteback(page)) { 69 trace_afs_page_dirty(vnode, tracepoint_string("alrdy"), page); 70 goto flush_conflicting_write; 71 } 72 /* If the file is being filled locally, allow inter-write 73 * spaces to be merged into writes. If it's not, only write 74 * back what the user gives us. 75 */ 76 if (!test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags) && 77 (to < f || from > t)) 78 goto flush_conflicting_write; 79 } 80 81 *_page = page; 82 _leave(" = 0"); 83 return 0; 84 85 /* The previous write and this write aren't adjacent or overlapping, so 86 * flush the page out. 87 */ 88 flush_conflicting_write: 89 _debug("flush conflict"); 90 ret = write_one_page(page); 91 if (ret < 0) 92 goto error; 93 94 ret = lock_page_killable(page); 95 if (ret < 0) 96 goto error; 97 goto try_again; 98 99 error: 100 put_page(page); 101 _leave(" = %d", ret); 102 return ret; 103 } 104 105 /* 106 * finalise part of a write to a page 107 */ 108 int afs_write_end(struct file *file, struct address_space *mapping, 109 loff_t pos, unsigned len, unsigned copied, 110 struct page *page, void *fsdata) 111 { 112 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 113 unsigned long priv; 114 unsigned int f, from = pos & (thp_size(page) - 1); 115 unsigned int t, to = from + copied; 116 loff_t i_size, maybe_i_size; 117 118 _enter("{%llx:%llu},{%lx}", 119 vnode->fid.vid, vnode->fid.vnode, page->index); 120 121 if (copied == 0) 122 goto out; 123 124 maybe_i_size = pos + copied; 125 126 i_size = i_size_read(&vnode->vfs_inode); 127 if (maybe_i_size > i_size) { 128 write_seqlock(&vnode->cb_lock); 129 i_size = i_size_read(&vnode->vfs_inode); 130 if (maybe_i_size > i_size) 131 i_size_write(&vnode->vfs_inode, maybe_i_size); 132 write_sequnlock(&vnode->cb_lock); 133 } 134 135 ASSERT(PageUptodate(page)); 136 137 if (PagePrivate(page)) { 138 priv = page_private(page); 139 f = afs_page_dirty_from(page, priv); 140 t = afs_page_dirty_to(page, priv); 141 if (from < f) 142 f = from; 143 if (to > t) 144 t = to; 145 priv = afs_page_dirty(page, f, t); 146 set_page_private(page, priv); 147 trace_afs_page_dirty(vnode, tracepoint_string("dirty+"), page); 148 } else { 149 priv = afs_page_dirty(page, from, to); 150 attach_page_private(page, (void *)priv); 151 trace_afs_page_dirty(vnode, tracepoint_string("dirty"), page); 152 } 153 154 if (set_page_dirty(page)) 155 _debug("dirtied %lx", page->index); 156 157 out: 158 unlock_page(page); 159 put_page(page); 160 return copied; 161 } 162 163 /* 164 * kill all the pages in the given range 165 */ 166 static void afs_kill_pages(struct address_space *mapping, 167 loff_t start, loff_t len) 168 { 169 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 170 struct pagevec pv; 171 unsigned int loop, psize; 172 173 _enter("{%llx:%llu},%llx @%llx", 174 vnode->fid.vid, vnode->fid.vnode, len, start); 175 176 pagevec_init(&pv); 177 178 do { 179 _debug("kill %llx @%llx", len, start); 180 181 pv.nr = find_get_pages_contig(mapping, start / PAGE_SIZE, 182 PAGEVEC_SIZE, pv.pages); 183 if (pv.nr == 0) 184 break; 185 186 for (loop = 0; loop < pv.nr; loop++) { 187 struct page *page = pv.pages[loop]; 188 189 if (page->index * PAGE_SIZE >= start + len) 190 break; 191 192 psize = thp_size(page); 193 start += psize; 194 len -= psize; 195 ClearPageUptodate(page); 196 end_page_writeback(page); 197 lock_page(page); 198 generic_error_remove_page(mapping, page); 199 unlock_page(page); 200 } 201 202 __pagevec_release(&pv); 203 } while (len > 0); 204 205 _leave(""); 206 } 207 208 /* 209 * Redirty all the pages in a given range. 210 */ 211 static void afs_redirty_pages(struct writeback_control *wbc, 212 struct address_space *mapping, 213 loff_t start, loff_t len) 214 { 215 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 216 struct pagevec pv; 217 unsigned int loop, psize; 218 219 _enter("{%llx:%llu},%llx @%llx", 220 vnode->fid.vid, vnode->fid.vnode, len, start); 221 222 pagevec_init(&pv); 223 224 do { 225 _debug("redirty %llx @%llx", len, start); 226 227 pv.nr = find_get_pages_contig(mapping, start / PAGE_SIZE, 228 PAGEVEC_SIZE, pv.pages); 229 if (pv.nr == 0) 230 break; 231 232 for (loop = 0; loop < pv.nr; loop++) { 233 struct page *page = pv.pages[loop]; 234 235 if (page->index * PAGE_SIZE >= start + len) 236 break; 237 238 psize = thp_size(page); 239 start += psize; 240 len -= psize; 241 redirty_page_for_writepage(wbc, page); 242 end_page_writeback(page); 243 } 244 245 __pagevec_release(&pv); 246 } while (len > 0); 247 248 _leave(""); 249 } 250 251 /* 252 * completion of write to server 253 */ 254 static void afs_pages_written_back(struct afs_vnode *vnode, loff_t start, unsigned int len) 255 { 256 struct address_space *mapping = vnode->vfs_inode.i_mapping; 257 struct page *page; 258 pgoff_t end; 259 260 XA_STATE(xas, &mapping->i_pages, start / PAGE_SIZE); 261 262 _enter("{%llx:%llu},{%x @%llx}", 263 vnode->fid.vid, vnode->fid.vnode, len, start); 264 265 rcu_read_lock(); 266 267 end = (start + len - 1) / PAGE_SIZE; 268 xas_for_each(&xas, page, end) { 269 if (!PageWriteback(page)) { 270 kdebug("bad %x @%llx page %lx %lx", len, start, page->index, end); 271 ASSERT(PageWriteback(page)); 272 } 273 274 trace_afs_page_dirty(vnode, tracepoint_string("clear"), page); 275 detach_page_private(page); 276 page_endio(page, true, 0); 277 } 278 279 rcu_read_unlock(); 280 281 afs_prune_wb_keys(vnode); 282 _leave(""); 283 } 284 285 /* 286 * Find a key to use for the writeback. We cached the keys used to author the 287 * writes on the vnode. *_wbk will contain the last writeback key used or NULL 288 * and we need to start from there if it's set. 289 */ 290 static int afs_get_writeback_key(struct afs_vnode *vnode, 291 struct afs_wb_key **_wbk) 292 { 293 struct afs_wb_key *wbk = NULL; 294 struct list_head *p; 295 int ret = -ENOKEY, ret2; 296 297 spin_lock(&vnode->wb_lock); 298 if (*_wbk) 299 p = (*_wbk)->vnode_link.next; 300 else 301 p = vnode->wb_keys.next; 302 303 while (p != &vnode->wb_keys) { 304 wbk = list_entry(p, struct afs_wb_key, vnode_link); 305 _debug("wbk %u", key_serial(wbk->key)); 306 ret2 = key_validate(wbk->key); 307 if (ret2 == 0) { 308 refcount_inc(&wbk->usage); 309 _debug("USE WB KEY %u", key_serial(wbk->key)); 310 break; 311 } 312 313 wbk = NULL; 314 if (ret == -ENOKEY) 315 ret = ret2; 316 p = p->next; 317 } 318 319 spin_unlock(&vnode->wb_lock); 320 if (*_wbk) 321 afs_put_wb_key(*_wbk); 322 *_wbk = wbk; 323 return 0; 324 } 325 326 static void afs_store_data_success(struct afs_operation *op) 327 { 328 struct afs_vnode *vnode = op->file[0].vnode; 329 330 op->ctime = op->file[0].scb.status.mtime_client; 331 afs_vnode_commit_status(op, &op->file[0]); 332 if (op->error == 0) { 333 if (!op->store.laundering) 334 afs_pages_written_back(vnode, op->store.pos, op->store.size); 335 afs_stat_v(vnode, n_stores); 336 atomic_long_add(op->store.size, &afs_v2net(vnode)->n_store_bytes); 337 } 338 } 339 340 static const struct afs_operation_ops afs_store_data_operation = { 341 .issue_afs_rpc = afs_fs_store_data, 342 .issue_yfs_rpc = yfs_fs_store_data, 343 .success = afs_store_data_success, 344 }; 345 346 /* 347 * write to a file 348 */ 349 static int afs_store_data(struct afs_vnode *vnode, struct iov_iter *iter, loff_t pos, 350 bool laundering) 351 { 352 struct afs_operation *op; 353 struct afs_wb_key *wbk = NULL; 354 loff_t size = iov_iter_count(iter), i_size; 355 int ret = -ENOKEY; 356 357 _enter("%s{%llx:%llu.%u},%llx,%llx", 358 vnode->volume->name, 359 vnode->fid.vid, 360 vnode->fid.vnode, 361 vnode->fid.unique, 362 size, pos); 363 364 ret = afs_get_writeback_key(vnode, &wbk); 365 if (ret) { 366 _leave(" = %d [no keys]", ret); 367 return ret; 368 } 369 370 op = afs_alloc_operation(wbk->key, vnode->volume); 371 if (IS_ERR(op)) { 372 afs_put_wb_key(wbk); 373 return -ENOMEM; 374 } 375 376 i_size = i_size_read(&vnode->vfs_inode); 377 378 afs_op_set_vnode(op, 0, vnode); 379 op->file[0].dv_delta = 1; 380 op->store.write_iter = iter; 381 op->store.pos = pos; 382 op->store.size = size; 383 op->store.i_size = max(pos + size, i_size); 384 op->store.laundering = laundering; 385 op->mtime = vnode->vfs_inode.i_mtime; 386 op->flags |= AFS_OPERATION_UNINTR; 387 op->ops = &afs_store_data_operation; 388 389 try_next_key: 390 afs_begin_vnode_operation(op); 391 afs_wait_for_operation(op); 392 393 switch (op->error) { 394 case -EACCES: 395 case -EPERM: 396 case -ENOKEY: 397 case -EKEYEXPIRED: 398 case -EKEYREJECTED: 399 case -EKEYREVOKED: 400 _debug("next"); 401 402 ret = afs_get_writeback_key(vnode, &wbk); 403 if (ret == 0) { 404 key_put(op->key); 405 op->key = key_get(wbk->key); 406 goto try_next_key; 407 } 408 break; 409 } 410 411 afs_put_wb_key(wbk); 412 _leave(" = %d", op->error); 413 return afs_put_operation(op); 414 } 415 416 /* 417 * Extend the region to be written back to include subsequent contiguously 418 * dirty pages if possible, but don't sleep while doing so. 419 * 420 * If this page holds new content, then we can include filler zeros in the 421 * writeback. 422 */ 423 static void afs_extend_writeback(struct address_space *mapping, 424 struct afs_vnode *vnode, 425 long *_count, 426 loff_t start, 427 loff_t max_len, 428 bool new_content, 429 unsigned int *_len) 430 { 431 struct pagevec pvec; 432 struct page *page; 433 unsigned long priv; 434 unsigned int psize, filler = 0; 435 unsigned int f, t; 436 loff_t len = *_len; 437 pgoff_t index = (start + len) / PAGE_SIZE; 438 bool stop = true; 439 unsigned int i; 440 441 XA_STATE(xas, &mapping->i_pages, index); 442 pagevec_init(&pvec); 443 444 do { 445 /* Firstly, we gather up a batch of contiguous dirty pages 446 * under the RCU read lock - but we can't clear the dirty flags 447 * there if any of those pages are mapped. 448 */ 449 rcu_read_lock(); 450 451 xas_for_each(&xas, page, ULONG_MAX) { 452 stop = true; 453 if (xas_retry(&xas, page)) 454 continue; 455 if (xa_is_value(page)) 456 break; 457 if (page->index != index) 458 break; 459 460 if (!page_cache_get_speculative(page)) { 461 xas_reset(&xas); 462 continue; 463 } 464 465 /* Has the page moved or been split? */ 466 if (unlikely(page != xas_reload(&xas))) 467 break; 468 469 if (!trylock_page(page)) 470 break; 471 if (!PageDirty(page) || PageWriteback(page)) { 472 unlock_page(page); 473 break; 474 } 475 476 psize = thp_size(page); 477 priv = page_private(page); 478 f = afs_page_dirty_from(page, priv); 479 t = afs_page_dirty_to(page, priv); 480 if (f != 0 && !new_content) { 481 unlock_page(page); 482 break; 483 } 484 485 len += filler + t; 486 filler = psize - t; 487 if (len >= max_len || *_count <= 0) 488 stop = true; 489 else if (t == psize || new_content) 490 stop = false; 491 492 index += thp_nr_pages(page); 493 if (!pagevec_add(&pvec, page)) 494 break; 495 if (stop) 496 break; 497 } 498 499 if (!stop) 500 xas_pause(&xas); 501 rcu_read_unlock(); 502 503 /* Now, if we obtained any pages, we can shift them to being 504 * writable and mark them for caching. 505 */ 506 if (!pagevec_count(&pvec)) 507 break; 508 509 for (i = 0; i < pagevec_count(&pvec); i++) { 510 page = pvec.pages[i]; 511 trace_afs_page_dirty(vnode, tracepoint_string("store+"), page); 512 513 if (!clear_page_dirty_for_io(page)) 514 BUG(); 515 if (test_set_page_writeback(page)) 516 BUG(); 517 518 *_count -= thp_nr_pages(page); 519 unlock_page(page); 520 } 521 522 pagevec_release(&pvec); 523 cond_resched(); 524 } while (!stop); 525 526 *_len = len; 527 } 528 529 /* 530 * Synchronously write back the locked page and any subsequent non-locked dirty 531 * pages. 532 */ 533 static ssize_t afs_write_back_from_locked_page(struct address_space *mapping, 534 struct writeback_control *wbc, 535 struct page *page, 536 loff_t start, loff_t end) 537 { 538 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 539 struct iov_iter iter; 540 unsigned long priv; 541 unsigned int offset, to, len, max_len; 542 loff_t i_size = i_size_read(&vnode->vfs_inode); 543 bool new_content = test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags); 544 long count = wbc->nr_to_write; 545 int ret; 546 547 _enter(",%lx,%llx-%llx", page->index, start, end); 548 549 if (test_set_page_writeback(page)) 550 BUG(); 551 552 count -= thp_nr_pages(page); 553 554 /* Find all consecutive lockable dirty pages that have contiguous 555 * written regions, stopping when we find a page that is not 556 * immediately lockable, is not dirty or is missing, or we reach the 557 * end of the range. 558 */ 559 priv = page_private(page); 560 offset = afs_page_dirty_from(page, priv); 561 to = afs_page_dirty_to(page, priv); 562 trace_afs_page_dirty(vnode, tracepoint_string("store"), page); 563 564 len = to - offset; 565 start += offset; 566 if (start < i_size) { 567 /* Trim the write to the EOF; the extra data is ignored. Also 568 * put an upper limit on the size of a single storedata op. 569 */ 570 max_len = 65536 * 4096; 571 max_len = min_t(unsigned long long, max_len, end - start + 1); 572 max_len = min_t(unsigned long long, max_len, i_size - start); 573 574 if (len < max_len && 575 (to == thp_size(page) || new_content)) 576 afs_extend_writeback(mapping, vnode, &count, 577 start, max_len, new_content, &len); 578 len = min_t(loff_t, len, max_len); 579 } 580 581 /* We now have a contiguous set of dirty pages, each with writeback 582 * set; the first page is still locked at this point, but all the rest 583 * have been unlocked. 584 */ 585 unlock_page(page); 586 587 if (start < i_size) { 588 _debug("write back %x @%llx [%llx]", len, start, i_size); 589 590 iov_iter_xarray(&iter, WRITE, &mapping->i_pages, start, len); 591 ret = afs_store_data(vnode, &iter, start, false); 592 } else { 593 _debug("write discard %x @%llx [%llx]", len, start, i_size); 594 595 /* The dirty region was entirely beyond the EOF. */ 596 afs_pages_written_back(vnode, start, len); 597 ret = 0; 598 } 599 600 switch (ret) { 601 case 0: 602 wbc->nr_to_write = count; 603 ret = len; 604 break; 605 606 default: 607 pr_notice("kAFS: Unexpected error from FS.StoreData %d\n", ret); 608 fallthrough; 609 case -EACCES: 610 case -EPERM: 611 case -ENOKEY: 612 case -EKEYEXPIRED: 613 case -EKEYREJECTED: 614 case -EKEYREVOKED: 615 afs_redirty_pages(wbc, mapping, start, len); 616 mapping_set_error(mapping, ret); 617 break; 618 619 case -EDQUOT: 620 case -ENOSPC: 621 afs_redirty_pages(wbc, mapping, start, len); 622 mapping_set_error(mapping, -ENOSPC); 623 break; 624 625 case -EROFS: 626 case -EIO: 627 case -EREMOTEIO: 628 case -EFBIG: 629 case -ENOENT: 630 case -ENOMEDIUM: 631 case -ENXIO: 632 trace_afs_file_error(vnode, ret, afs_file_error_writeback_fail); 633 afs_kill_pages(mapping, start, len); 634 mapping_set_error(mapping, ret); 635 break; 636 } 637 638 _leave(" = %d", ret); 639 return ret; 640 } 641 642 /* 643 * write a page back to the server 644 * - the caller locked the page for us 645 */ 646 int afs_writepage(struct page *page, struct writeback_control *wbc) 647 { 648 ssize_t ret; 649 loff_t start; 650 651 _enter("{%lx},", page->index); 652 653 start = page->index * PAGE_SIZE; 654 ret = afs_write_back_from_locked_page(page->mapping, wbc, page, 655 start, LLONG_MAX - start); 656 if (ret < 0) { 657 _leave(" = %zd", ret); 658 return ret; 659 } 660 661 _leave(" = 0"); 662 return 0; 663 } 664 665 /* 666 * write a region of pages back to the server 667 */ 668 static int afs_writepages_region(struct address_space *mapping, 669 struct writeback_control *wbc, 670 loff_t start, loff_t end, loff_t *_next) 671 { 672 struct page *page; 673 ssize_t ret; 674 int n; 675 676 _enter("%llx,%llx,", start, end); 677 678 do { 679 pgoff_t index = start / PAGE_SIZE; 680 681 n = find_get_pages_range_tag(mapping, &index, end / PAGE_SIZE, 682 PAGECACHE_TAG_DIRTY, 1, &page); 683 if (!n) 684 break; 685 686 start = (loff_t)page->index * PAGE_SIZE; /* May regress with THPs */ 687 688 _debug("wback %lx", page->index); 689 690 /* At this point we hold neither the i_pages lock nor the 691 * page lock: the page may be truncated or invalidated 692 * (changing page->mapping to NULL), or even swizzled 693 * back from swapper_space to tmpfs file mapping 694 */ 695 if (wbc->sync_mode != WB_SYNC_NONE) { 696 ret = lock_page_killable(page); 697 if (ret < 0) { 698 put_page(page); 699 return ret; 700 } 701 } else { 702 if (!trylock_page(page)) { 703 put_page(page); 704 return 0; 705 } 706 } 707 708 if (page->mapping != mapping || !PageDirty(page)) { 709 start += thp_size(page); 710 unlock_page(page); 711 put_page(page); 712 continue; 713 } 714 715 if (PageWriteback(page)) { 716 unlock_page(page); 717 if (wbc->sync_mode != WB_SYNC_NONE) 718 wait_on_page_writeback(page); 719 put_page(page); 720 continue; 721 } 722 723 if (!clear_page_dirty_for_io(page)) 724 BUG(); 725 ret = afs_write_back_from_locked_page(mapping, wbc, page, start, end); 726 put_page(page); 727 if (ret < 0) { 728 _leave(" = %zd", ret); 729 return ret; 730 } 731 732 start += ret * PAGE_SIZE; 733 734 cond_resched(); 735 } while (wbc->nr_to_write > 0); 736 737 *_next = start; 738 _leave(" = 0 [%llx]", *_next); 739 return 0; 740 } 741 742 /* 743 * write some of the pending data back to the server 744 */ 745 int afs_writepages(struct address_space *mapping, 746 struct writeback_control *wbc) 747 { 748 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 749 loff_t start, next; 750 int ret; 751 752 _enter(""); 753 754 /* We have to be careful as we can end up racing with setattr() 755 * truncating the pagecache since the caller doesn't take a lock here 756 * to prevent it. 757 */ 758 if (wbc->sync_mode == WB_SYNC_ALL) 759 down_read(&vnode->validate_lock); 760 else if (!down_read_trylock(&vnode->validate_lock)) 761 return 0; 762 763 if (wbc->range_cyclic) { 764 start = mapping->writeback_index * PAGE_SIZE; 765 ret = afs_writepages_region(mapping, wbc, start, LLONG_MAX, &next); 766 if (start > 0 && wbc->nr_to_write > 0 && ret == 0) 767 ret = afs_writepages_region(mapping, wbc, 0, start, 768 &next); 769 mapping->writeback_index = next / PAGE_SIZE; 770 } else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) { 771 ret = afs_writepages_region(mapping, wbc, 0, LLONG_MAX, &next); 772 if (wbc->nr_to_write > 0) 773 mapping->writeback_index = next; 774 } else { 775 ret = afs_writepages_region(mapping, wbc, 776 wbc->range_start, wbc->range_end, &next); 777 } 778 779 up_read(&vnode->validate_lock); 780 _leave(" = %d", ret); 781 return ret; 782 } 783 784 /* 785 * write to an AFS file 786 */ 787 ssize_t afs_file_write(struct kiocb *iocb, struct iov_iter *from) 788 { 789 struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp)); 790 ssize_t result; 791 size_t count = iov_iter_count(from); 792 793 _enter("{%llx:%llu},{%zu},", 794 vnode->fid.vid, vnode->fid.vnode, count); 795 796 if (IS_SWAPFILE(&vnode->vfs_inode)) { 797 printk(KERN_INFO 798 "AFS: Attempt to write to active swap file!\n"); 799 return -EBUSY; 800 } 801 802 if (!count) 803 return 0; 804 805 result = generic_file_write_iter(iocb, from); 806 807 _leave(" = %zd", result); 808 return result; 809 } 810 811 /* 812 * flush any dirty pages for this process, and check for write errors. 813 * - the return status from this call provides a reliable indication of 814 * whether any write errors occurred for this process. 815 */ 816 int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 817 { 818 struct inode *inode = file_inode(file); 819 struct afs_vnode *vnode = AFS_FS_I(inode); 820 821 _enter("{%llx:%llu},{n=%pD},%d", 822 vnode->fid.vid, vnode->fid.vnode, file, 823 datasync); 824 825 return file_write_and_wait_range(file, start, end); 826 } 827 828 /* 829 * notification that a previously read-only page is about to become writable 830 * - if it returns an error, the caller will deliver a bus error signal 831 */ 832 vm_fault_t afs_page_mkwrite(struct vm_fault *vmf) 833 { 834 struct page *page = thp_head(vmf->page); 835 struct file *file = vmf->vma->vm_file; 836 struct inode *inode = file_inode(file); 837 struct afs_vnode *vnode = AFS_FS_I(inode); 838 unsigned long priv; 839 840 _enter("{{%llx:%llu}},{%lx}", vnode->fid.vid, vnode->fid.vnode, page->index); 841 842 sb_start_pagefault(inode->i_sb); 843 844 /* Wait for the page to be written to the cache before we allow it to 845 * be modified. We then assume the entire page will need writing back. 846 */ 847 #ifdef CONFIG_AFS_FSCACHE 848 if (PageFsCache(page) && 849 wait_on_page_fscache_killable(page) < 0) 850 return VM_FAULT_RETRY; 851 #endif 852 853 if (wait_on_page_writeback_killable(page)) 854 return VM_FAULT_RETRY; 855 856 if (lock_page_killable(page) < 0) 857 return VM_FAULT_RETRY; 858 859 /* We mustn't change page->private until writeback is complete as that 860 * details the portion of the page we need to write back and we might 861 * need to redirty the page if there's a problem. 862 */ 863 if (wait_on_page_writeback_killable(page) < 0) { 864 unlock_page(page); 865 return VM_FAULT_RETRY; 866 } 867 868 priv = afs_page_dirty(page, 0, thp_size(page)); 869 priv = afs_page_dirty_mmapped(priv); 870 if (PagePrivate(page)) { 871 set_page_private(page, priv); 872 trace_afs_page_dirty(vnode, tracepoint_string("mkwrite+"), page); 873 } else { 874 attach_page_private(page, (void *)priv); 875 trace_afs_page_dirty(vnode, tracepoint_string("mkwrite"), page); 876 } 877 file_update_time(file); 878 879 sb_end_pagefault(inode->i_sb); 880 return VM_FAULT_LOCKED; 881 } 882 883 /* 884 * Prune the keys cached for writeback. The caller must hold vnode->wb_lock. 885 */ 886 void afs_prune_wb_keys(struct afs_vnode *vnode) 887 { 888 LIST_HEAD(graveyard); 889 struct afs_wb_key *wbk, *tmp; 890 891 /* Discard unused keys */ 892 spin_lock(&vnode->wb_lock); 893 894 if (!mapping_tagged(&vnode->vfs_inode.i_data, PAGECACHE_TAG_WRITEBACK) && 895 !mapping_tagged(&vnode->vfs_inode.i_data, PAGECACHE_TAG_DIRTY)) { 896 list_for_each_entry_safe(wbk, tmp, &vnode->wb_keys, vnode_link) { 897 if (refcount_read(&wbk->usage) == 1) 898 list_move(&wbk->vnode_link, &graveyard); 899 } 900 } 901 902 spin_unlock(&vnode->wb_lock); 903 904 while (!list_empty(&graveyard)) { 905 wbk = list_entry(graveyard.next, struct afs_wb_key, vnode_link); 906 list_del(&wbk->vnode_link); 907 afs_put_wb_key(wbk); 908 } 909 } 910 911 /* 912 * Clean up a page during invalidation. 913 */ 914 int afs_launder_page(struct page *page) 915 { 916 struct address_space *mapping = page->mapping; 917 struct afs_vnode *vnode = AFS_FS_I(mapping->host); 918 struct iov_iter iter; 919 struct bio_vec bv[1]; 920 unsigned long priv; 921 unsigned int f, t; 922 int ret = 0; 923 924 _enter("{%lx}", page->index); 925 926 priv = page_private(page); 927 if (clear_page_dirty_for_io(page)) { 928 f = 0; 929 t = thp_size(page); 930 if (PagePrivate(page)) { 931 f = afs_page_dirty_from(page, priv); 932 t = afs_page_dirty_to(page, priv); 933 } 934 935 bv[0].bv_page = page; 936 bv[0].bv_offset = f; 937 bv[0].bv_len = t - f; 938 iov_iter_bvec(&iter, WRITE, bv, 1, bv[0].bv_len); 939 940 trace_afs_page_dirty(vnode, tracepoint_string("launder"), page); 941 ret = afs_store_data(vnode, &iter, (loff_t)page->index * PAGE_SIZE, 942 true); 943 } 944 945 trace_afs_page_dirty(vnode, tracepoint_string("laundered"), page); 946 detach_page_private(page); 947 wait_on_page_fscache(page); 948 return ret; 949 } 950