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