1 /* 2 * linux/fs/nfs/write.c 3 * 4 * Write file data over NFS. 5 * 6 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de> 7 */ 8 9 #include <linux/types.h> 10 #include <linux/slab.h> 11 #include <linux/mm.h> 12 #include <linux/pagemap.h> 13 #include <linux/file.h> 14 #include <linux/writeback.h> 15 #include <linux/swap.h> 16 #include <linux/migrate.h> 17 18 #include <linux/sunrpc/clnt.h> 19 #include <linux/nfs_fs.h> 20 #include <linux/nfs_mount.h> 21 #include <linux/nfs_page.h> 22 #include <linux/backing-dev.h> 23 24 #include <asm/uaccess.h> 25 26 #include "delegation.h" 27 #include "internal.h" 28 #include "iostat.h" 29 #include "nfs4_fs.h" 30 #include "fscache.h" 31 32 #define NFSDBG_FACILITY NFSDBG_PAGECACHE 33 34 #define MIN_POOL_WRITE (32) 35 #define MIN_POOL_COMMIT (4) 36 37 /* 38 * Local function declarations 39 */ 40 static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc, 41 struct inode *inode, int ioflags); 42 static void nfs_redirty_request(struct nfs_page *req); 43 static const struct rpc_call_ops nfs_write_partial_ops; 44 static const struct rpc_call_ops nfs_write_full_ops; 45 static const struct rpc_call_ops nfs_commit_ops; 46 47 static struct kmem_cache *nfs_wdata_cachep; 48 static mempool_t *nfs_wdata_mempool; 49 static mempool_t *nfs_commit_mempool; 50 51 struct nfs_write_data *nfs_commitdata_alloc(void) 52 { 53 struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS); 54 55 if (p) { 56 memset(p, 0, sizeof(*p)); 57 INIT_LIST_HEAD(&p->pages); 58 } 59 return p; 60 } 61 62 void nfs_commit_free(struct nfs_write_data *p) 63 { 64 if (p && (p->pagevec != &p->page_array[0])) 65 kfree(p->pagevec); 66 mempool_free(p, nfs_commit_mempool); 67 } 68 69 struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount) 70 { 71 struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS); 72 73 if (p) { 74 memset(p, 0, sizeof(*p)); 75 INIT_LIST_HEAD(&p->pages); 76 p->npages = pagecount; 77 if (pagecount <= ARRAY_SIZE(p->page_array)) 78 p->pagevec = p->page_array; 79 else { 80 p->pagevec = kcalloc(pagecount, sizeof(struct page *), GFP_NOFS); 81 if (!p->pagevec) { 82 mempool_free(p, nfs_wdata_mempool); 83 p = NULL; 84 } 85 } 86 } 87 return p; 88 } 89 90 void nfs_writedata_free(struct nfs_write_data *p) 91 { 92 if (p && (p->pagevec != &p->page_array[0])) 93 kfree(p->pagevec); 94 mempool_free(p, nfs_wdata_mempool); 95 } 96 97 static void nfs_writedata_release(struct nfs_write_data *wdata) 98 { 99 put_nfs_open_context(wdata->args.context); 100 nfs_writedata_free(wdata); 101 } 102 103 static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error) 104 { 105 ctx->error = error; 106 smp_wmb(); 107 set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 108 } 109 110 static struct nfs_page *nfs_page_find_request_locked(struct page *page) 111 { 112 struct nfs_page *req = NULL; 113 114 if (PagePrivate(page)) { 115 req = (struct nfs_page *)page_private(page); 116 if (req != NULL) 117 kref_get(&req->wb_kref); 118 } 119 return req; 120 } 121 122 static struct nfs_page *nfs_page_find_request(struct page *page) 123 { 124 struct inode *inode = page->mapping->host; 125 struct nfs_page *req = NULL; 126 127 spin_lock(&inode->i_lock); 128 req = nfs_page_find_request_locked(page); 129 spin_unlock(&inode->i_lock); 130 return req; 131 } 132 133 /* Adjust the file length if we're writing beyond the end */ 134 static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count) 135 { 136 struct inode *inode = page->mapping->host; 137 loff_t end, i_size; 138 pgoff_t end_index; 139 140 spin_lock(&inode->i_lock); 141 i_size = i_size_read(inode); 142 end_index = (i_size - 1) >> PAGE_CACHE_SHIFT; 143 if (i_size > 0 && page->index < end_index) 144 goto out; 145 end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + ((loff_t)offset+count); 146 if (i_size >= end) 147 goto out; 148 i_size_write(inode, end); 149 nfs_inc_stats(inode, NFSIOS_EXTENDWRITE); 150 out: 151 spin_unlock(&inode->i_lock); 152 } 153 154 /* A writeback failed: mark the page as bad, and invalidate the page cache */ 155 static void nfs_set_pageerror(struct page *page) 156 { 157 SetPageError(page); 158 nfs_zap_mapping(page->mapping->host, page->mapping); 159 } 160 161 /* We can set the PG_uptodate flag if we see that a write request 162 * covers the full page. 163 */ 164 static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count) 165 { 166 if (PageUptodate(page)) 167 return; 168 if (base != 0) 169 return; 170 if (count != nfs_page_length(page)) 171 return; 172 SetPageUptodate(page); 173 } 174 175 static int wb_priority(struct writeback_control *wbc) 176 { 177 if (wbc->for_reclaim) 178 return FLUSH_HIGHPRI | FLUSH_STABLE; 179 if (wbc->for_kupdate || wbc->for_background) 180 return FLUSH_LOWPRI; 181 return 0; 182 } 183 184 /* 185 * NFS congestion control 186 */ 187 188 int nfs_congestion_kb; 189 190 #define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10)) 191 #define NFS_CONGESTION_OFF_THRESH \ 192 (NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2)) 193 194 static int nfs_set_page_writeback(struct page *page) 195 { 196 int ret = test_set_page_writeback(page); 197 198 if (!ret) { 199 struct inode *inode = page->mapping->host; 200 struct nfs_server *nfss = NFS_SERVER(inode); 201 202 page_cache_get(page); 203 if (atomic_long_inc_return(&nfss->writeback) > 204 NFS_CONGESTION_ON_THRESH) { 205 set_bdi_congested(&nfss->backing_dev_info, 206 BLK_RW_ASYNC); 207 } 208 } 209 return ret; 210 } 211 212 static void nfs_end_page_writeback(struct page *page) 213 { 214 struct inode *inode = page->mapping->host; 215 struct nfs_server *nfss = NFS_SERVER(inode); 216 217 end_page_writeback(page); 218 page_cache_release(page); 219 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) 220 clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC); 221 } 222 223 static struct nfs_page *nfs_find_and_lock_request(struct page *page, bool nonblock) 224 { 225 struct inode *inode = page->mapping->host; 226 struct nfs_page *req; 227 int ret; 228 229 spin_lock(&inode->i_lock); 230 for (;;) { 231 req = nfs_page_find_request_locked(page); 232 if (req == NULL) 233 break; 234 if (nfs_set_page_tag_locked(req)) 235 break; 236 /* Note: If we hold the page lock, as is the case in nfs_writepage, 237 * then the call to nfs_set_page_tag_locked() will always 238 * succeed provided that someone hasn't already marked the 239 * request as dirty (in which case we don't care). 240 */ 241 spin_unlock(&inode->i_lock); 242 if (!nonblock) 243 ret = nfs_wait_on_request(req); 244 else 245 ret = -EAGAIN; 246 nfs_release_request(req); 247 if (ret != 0) 248 return ERR_PTR(ret); 249 spin_lock(&inode->i_lock); 250 } 251 spin_unlock(&inode->i_lock); 252 return req; 253 } 254 255 /* 256 * Find an associated nfs write request, and prepare to flush it out 257 * May return an error if the user signalled nfs_wait_on_request(). 258 */ 259 static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio, 260 struct page *page, bool nonblock) 261 { 262 struct nfs_page *req; 263 int ret = 0; 264 265 req = nfs_find_and_lock_request(page, nonblock); 266 if (!req) 267 goto out; 268 ret = PTR_ERR(req); 269 if (IS_ERR(req)) 270 goto out; 271 272 ret = nfs_set_page_writeback(page); 273 BUG_ON(ret != 0); 274 BUG_ON(test_bit(PG_CLEAN, &req->wb_flags)); 275 276 if (!nfs_pageio_add_request(pgio, req)) { 277 nfs_redirty_request(req); 278 ret = pgio->pg_error; 279 } 280 out: 281 return ret; 282 } 283 284 static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio) 285 { 286 struct inode *inode = page->mapping->host; 287 int ret; 288 289 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE); 290 nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1); 291 292 nfs_pageio_cond_complete(pgio, page->index); 293 ret = nfs_page_async_flush(pgio, page, wbc->sync_mode == WB_SYNC_NONE); 294 if (ret == -EAGAIN) { 295 redirty_page_for_writepage(wbc, page); 296 ret = 0; 297 } 298 return ret; 299 } 300 301 /* 302 * Write an mmapped page to the server. 303 */ 304 static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc) 305 { 306 struct nfs_pageio_descriptor pgio; 307 int err; 308 309 nfs_pageio_init_write(&pgio, page->mapping->host, wb_priority(wbc)); 310 err = nfs_do_writepage(page, wbc, &pgio); 311 nfs_pageio_complete(&pgio); 312 if (err < 0) 313 return err; 314 if (pgio.pg_error < 0) 315 return pgio.pg_error; 316 return 0; 317 } 318 319 int nfs_writepage(struct page *page, struct writeback_control *wbc) 320 { 321 int ret; 322 323 ret = nfs_writepage_locked(page, wbc); 324 unlock_page(page); 325 return ret; 326 } 327 328 static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data) 329 { 330 int ret; 331 332 ret = nfs_do_writepage(page, wbc, data); 333 unlock_page(page); 334 return ret; 335 } 336 337 int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc) 338 { 339 struct inode *inode = mapping->host; 340 unsigned long *bitlock = &NFS_I(inode)->flags; 341 struct nfs_pageio_descriptor pgio; 342 int err; 343 344 /* Stop dirtying of new pages while we sync */ 345 err = wait_on_bit_lock(bitlock, NFS_INO_FLUSHING, 346 nfs_wait_bit_killable, TASK_KILLABLE); 347 if (err) 348 goto out_err; 349 350 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES); 351 352 nfs_pageio_init_write(&pgio, inode, wb_priority(wbc)); 353 err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio); 354 nfs_pageio_complete(&pgio); 355 356 clear_bit_unlock(NFS_INO_FLUSHING, bitlock); 357 smp_mb__after_clear_bit(); 358 wake_up_bit(bitlock, NFS_INO_FLUSHING); 359 360 if (err < 0) 361 goto out_err; 362 err = pgio.pg_error; 363 if (err < 0) 364 goto out_err; 365 return 0; 366 out_err: 367 return err; 368 } 369 370 /* 371 * Insert a write request into an inode 372 */ 373 static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req) 374 { 375 struct nfs_inode *nfsi = NFS_I(inode); 376 int error; 377 378 error = radix_tree_preload(GFP_NOFS); 379 if (error != 0) 380 goto out; 381 382 /* Lock the request! */ 383 nfs_lock_request_dontget(req); 384 385 spin_lock(&inode->i_lock); 386 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req); 387 BUG_ON(error); 388 if (!nfsi->npages) { 389 igrab(inode); 390 if (nfs_have_delegation(inode, FMODE_WRITE)) 391 nfsi->change_attr++; 392 } 393 set_bit(PG_MAPPED, &req->wb_flags); 394 SetPagePrivate(req->wb_page); 395 set_page_private(req->wb_page, (unsigned long)req); 396 nfsi->npages++; 397 kref_get(&req->wb_kref); 398 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, 399 NFS_PAGE_TAG_LOCKED); 400 spin_unlock(&inode->i_lock); 401 radix_tree_preload_end(); 402 out: 403 return error; 404 } 405 406 /* 407 * Remove a write request from an inode 408 */ 409 static void nfs_inode_remove_request(struct nfs_page *req) 410 { 411 struct inode *inode = req->wb_context->path.dentry->d_inode; 412 struct nfs_inode *nfsi = NFS_I(inode); 413 414 BUG_ON (!NFS_WBACK_BUSY(req)); 415 416 spin_lock(&inode->i_lock); 417 set_page_private(req->wb_page, 0); 418 ClearPagePrivate(req->wb_page); 419 clear_bit(PG_MAPPED, &req->wb_flags); 420 radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index); 421 nfsi->npages--; 422 if (!nfsi->npages) { 423 spin_unlock(&inode->i_lock); 424 iput(inode); 425 } else 426 spin_unlock(&inode->i_lock); 427 nfs_release_request(req); 428 } 429 430 static void 431 nfs_mark_request_dirty(struct nfs_page *req) 432 { 433 __set_page_dirty_nobuffers(req->wb_page); 434 __mark_inode_dirty(req->wb_page->mapping->host, I_DIRTY_DATASYNC); 435 } 436 437 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) 438 /* 439 * Add a request to the inode's commit list. 440 */ 441 static void 442 nfs_mark_request_commit(struct nfs_page *req) 443 { 444 struct inode *inode = req->wb_context->path.dentry->d_inode; 445 struct nfs_inode *nfsi = NFS_I(inode); 446 447 spin_lock(&inode->i_lock); 448 set_bit(PG_CLEAN, &(req)->wb_flags); 449 radix_tree_tag_set(&nfsi->nfs_page_tree, 450 req->wb_index, 451 NFS_PAGE_TAG_COMMIT); 452 nfsi->ncommit++; 453 spin_unlock(&inode->i_lock); 454 inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS); 455 inc_bdi_stat(req->wb_page->mapping->backing_dev_info, BDI_RECLAIMABLE); 456 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 457 } 458 459 static int 460 nfs_clear_request_commit(struct nfs_page *req) 461 { 462 struct page *page = req->wb_page; 463 464 if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) { 465 dec_zone_page_state(page, NR_UNSTABLE_NFS); 466 dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE); 467 return 1; 468 } 469 return 0; 470 } 471 472 static inline 473 int nfs_write_need_commit(struct nfs_write_data *data) 474 { 475 return data->verf.committed != NFS_FILE_SYNC; 476 } 477 478 static inline 479 int nfs_reschedule_unstable_write(struct nfs_page *req) 480 { 481 if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) { 482 nfs_mark_request_commit(req); 483 return 1; 484 } 485 if (test_and_clear_bit(PG_NEED_RESCHED, &req->wb_flags)) { 486 nfs_mark_request_dirty(req); 487 return 1; 488 } 489 return 0; 490 } 491 #else 492 static inline void 493 nfs_mark_request_commit(struct nfs_page *req) 494 { 495 } 496 497 static inline int 498 nfs_clear_request_commit(struct nfs_page *req) 499 { 500 return 0; 501 } 502 503 static inline 504 int nfs_write_need_commit(struct nfs_write_data *data) 505 { 506 return 0; 507 } 508 509 static inline 510 int nfs_reschedule_unstable_write(struct nfs_page *req) 511 { 512 return 0; 513 } 514 #endif 515 516 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) 517 static int 518 nfs_need_commit(struct nfs_inode *nfsi) 519 { 520 return radix_tree_tagged(&nfsi->nfs_page_tree, NFS_PAGE_TAG_COMMIT); 521 } 522 523 /* 524 * nfs_scan_commit - Scan an inode for commit requests 525 * @inode: NFS inode to scan 526 * @dst: destination list 527 * @idx_start: lower bound of page->index to scan. 528 * @npages: idx_start + npages sets the upper bound to scan. 529 * 530 * Moves requests from the inode's 'commit' request list. 531 * The requests are *not* checked to ensure that they form a contiguous set. 532 */ 533 static int 534 nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages) 535 { 536 struct nfs_inode *nfsi = NFS_I(inode); 537 int ret; 538 539 if (!nfs_need_commit(nfsi)) 540 return 0; 541 542 ret = nfs_scan_list(nfsi, dst, idx_start, npages, NFS_PAGE_TAG_COMMIT); 543 if (ret > 0) 544 nfsi->ncommit -= ret; 545 if (nfs_need_commit(NFS_I(inode))) 546 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 547 return ret; 548 } 549 #else 550 static inline int nfs_need_commit(struct nfs_inode *nfsi) 551 { 552 return 0; 553 } 554 555 static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, unsigned int npages) 556 { 557 return 0; 558 } 559 #endif 560 561 /* 562 * Search for an existing write request, and attempt to update 563 * it to reflect a new dirty region on a given page. 564 * 565 * If the attempt fails, then the existing request is flushed out 566 * to disk. 567 */ 568 static struct nfs_page *nfs_try_to_update_request(struct inode *inode, 569 struct page *page, 570 unsigned int offset, 571 unsigned int bytes) 572 { 573 struct nfs_page *req; 574 unsigned int rqend; 575 unsigned int end; 576 int error; 577 578 if (!PagePrivate(page)) 579 return NULL; 580 581 end = offset + bytes; 582 spin_lock(&inode->i_lock); 583 584 for (;;) { 585 req = nfs_page_find_request_locked(page); 586 if (req == NULL) 587 goto out_unlock; 588 589 rqend = req->wb_offset + req->wb_bytes; 590 /* 591 * Tell the caller to flush out the request if 592 * the offsets are non-contiguous. 593 * Note: nfs_flush_incompatible() will already 594 * have flushed out requests having wrong owners. 595 */ 596 if (offset > rqend 597 || end < req->wb_offset) 598 goto out_flushme; 599 600 if (nfs_set_page_tag_locked(req)) 601 break; 602 603 /* The request is locked, so wait and then retry */ 604 spin_unlock(&inode->i_lock); 605 error = nfs_wait_on_request(req); 606 nfs_release_request(req); 607 if (error != 0) 608 goto out_err; 609 spin_lock(&inode->i_lock); 610 } 611 612 if (nfs_clear_request_commit(req) && 613 radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree, 614 req->wb_index, NFS_PAGE_TAG_COMMIT) != NULL) 615 NFS_I(inode)->ncommit--; 616 617 /* Okay, the request matches. Update the region */ 618 if (offset < req->wb_offset) { 619 req->wb_offset = offset; 620 req->wb_pgbase = offset; 621 } 622 if (end > rqend) 623 req->wb_bytes = end - req->wb_offset; 624 else 625 req->wb_bytes = rqend - req->wb_offset; 626 out_unlock: 627 spin_unlock(&inode->i_lock); 628 return req; 629 out_flushme: 630 spin_unlock(&inode->i_lock); 631 nfs_release_request(req); 632 error = nfs_wb_page(inode, page); 633 out_err: 634 return ERR_PTR(error); 635 } 636 637 /* 638 * Try to update an existing write request, or create one if there is none. 639 * 640 * Note: Should always be called with the Page Lock held to prevent races 641 * if we have to add a new request. Also assumes that the caller has 642 * already called nfs_flush_incompatible() if necessary. 643 */ 644 static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx, 645 struct page *page, unsigned int offset, unsigned int bytes) 646 { 647 struct inode *inode = page->mapping->host; 648 struct nfs_page *req; 649 int error; 650 651 req = nfs_try_to_update_request(inode, page, offset, bytes); 652 if (req != NULL) 653 goto out; 654 req = nfs_create_request(ctx, inode, page, offset, bytes); 655 if (IS_ERR(req)) 656 goto out; 657 error = nfs_inode_add_request(inode, req); 658 if (error != 0) { 659 nfs_release_request(req); 660 req = ERR_PTR(error); 661 } 662 out: 663 return req; 664 } 665 666 static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page, 667 unsigned int offset, unsigned int count) 668 { 669 struct nfs_page *req; 670 671 req = nfs_setup_write_request(ctx, page, offset, count); 672 if (IS_ERR(req)) 673 return PTR_ERR(req); 674 nfs_mark_request_dirty(req); 675 /* Update file length */ 676 nfs_grow_file(page, offset, count); 677 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes); 678 nfs_mark_request_dirty(req); 679 nfs_clear_page_tag_locked(req); 680 return 0; 681 } 682 683 int nfs_flush_incompatible(struct file *file, struct page *page) 684 { 685 struct nfs_open_context *ctx = nfs_file_open_context(file); 686 struct nfs_page *req; 687 int do_flush, status; 688 /* 689 * Look for a request corresponding to this page. If there 690 * is one, and it belongs to another file, we flush it out 691 * before we try to copy anything into the page. Do this 692 * due to the lack of an ACCESS-type call in NFSv2. 693 * Also do the same if we find a request from an existing 694 * dropped page. 695 */ 696 do { 697 req = nfs_page_find_request(page); 698 if (req == NULL) 699 return 0; 700 do_flush = req->wb_page != page || req->wb_context != ctx || 701 req->wb_lock_context->lockowner != current->files || 702 req->wb_lock_context->pid != current->tgid; 703 nfs_release_request(req); 704 if (!do_flush) 705 return 0; 706 status = nfs_wb_page(page->mapping->host, page); 707 } while (status == 0); 708 return status; 709 } 710 711 /* 712 * If the page cache is marked as unsafe or invalid, then we can't rely on 713 * the PageUptodate() flag. In this case, we will need to turn off 714 * write optimisations that depend on the page contents being correct. 715 */ 716 static int nfs_write_pageuptodate(struct page *page, struct inode *inode) 717 { 718 return PageUptodate(page) && 719 !(NFS_I(inode)->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA)); 720 } 721 722 /* 723 * Update and possibly write a cached page of an NFS file. 724 * 725 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad 726 * things with a page scheduled for an RPC call (e.g. invalidate it). 727 */ 728 int nfs_updatepage(struct file *file, struct page *page, 729 unsigned int offset, unsigned int count) 730 { 731 struct nfs_open_context *ctx = nfs_file_open_context(file); 732 struct inode *inode = page->mapping->host; 733 int status = 0; 734 735 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE); 736 737 dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n", 738 file->f_path.dentry->d_parent->d_name.name, 739 file->f_path.dentry->d_name.name, count, 740 (long long)(page_offset(page) + offset)); 741 742 /* If we're not using byte range locks, and we know the page 743 * is up to date, it may be more efficient to extend the write 744 * to cover the entire page in order to avoid fragmentation 745 * inefficiencies. 746 */ 747 if (nfs_write_pageuptodate(page, inode) && 748 inode->i_flock == NULL && 749 !(file->f_flags & O_DSYNC)) { 750 count = max(count + offset, nfs_page_length(page)); 751 offset = 0; 752 } 753 754 status = nfs_writepage_setup(ctx, page, offset, count); 755 if (status < 0) 756 nfs_set_pageerror(page); 757 758 dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n", 759 status, (long long)i_size_read(inode)); 760 return status; 761 } 762 763 static void nfs_writepage_release(struct nfs_page *req) 764 { 765 struct page *page = req->wb_page; 766 767 if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req)) 768 nfs_inode_remove_request(req); 769 nfs_clear_page_tag_locked(req); 770 nfs_end_page_writeback(page); 771 } 772 773 static int flush_task_priority(int how) 774 { 775 switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) { 776 case FLUSH_HIGHPRI: 777 return RPC_PRIORITY_HIGH; 778 case FLUSH_LOWPRI: 779 return RPC_PRIORITY_LOW; 780 } 781 return RPC_PRIORITY_NORMAL; 782 } 783 784 /* 785 * Set up the argument/result storage required for the RPC call. 786 */ 787 static int nfs_write_rpcsetup(struct nfs_page *req, 788 struct nfs_write_data *data, 789 const struct rpc_call_ops *call_ops, 790 unsigned int count, unsigned int offset, 791 int how) 792 { 793 struct inode *inode = req->wb_context->path.dentry->d_inode; 794 int priority = flush_task_priority(how); 795 struct rpc_task *task; 796 struct rpc_message msg = { 797 .rpc_argp = &data->args, 798 .rpc_resp = &data->res, 799 .rpc_cred = req->wb_context->cred, 800 }; 801 struct rpc_task_setup task_setup_data = { 802 .rpc_client = NFS_CLIENT(inode), 803 .task = &data->task, 804 .rpc_message = &msg, 805 .callback_ops = call_ops, 806 .callback_data = data, 807 .workqueue = nfsiod_workqueue, 808 .flags = RPC_TASK_ASYNC, 809 .priority = priority, 810 }; 811 int ret = 0; 812 813 /* Set up the RPC argument and reply structs 814 * NB: take care not to mess about with data->commit et al. */ 815 816 data->req = req; 817 data->inode = inode = req->wb_context->path.dentry->d_inode; 818 data->cred = msg.rpc_cred; 819 820 data->args.fh = NFS_FH(inode); 821 data->args.offset = req_offset(req) + offset; 822 data->args.pgbase = req->wb_pgbase + offset; 823 data->args.pages = data->pagevec; 824 data->args.count = count; 825 data->args.context = get_nfs_open_context(req->wb_context); 826 data->args.lock_context = req->wb_lock_context; 827 data->args.stable = NFS_UNSTABLE; 828 if (how & FLUSH_STABLE) { 829 data->args.stable = NFS_DATA_SYNC; 830 if (!nfs_need_commit(NFS_I(inode))) 831 data->args.stable = NFS_FILE_SYNC; 832 } 833 834 data->res.fattr = &data->fattr; 835 data->res.count = count; 836 data->res.verf = &data->verf; 837 nfs_fattr_init(&data->fattr); 838 839 /* Set up the initial task struct. */ 840 NFS_PROTO(inode)->write_setup(data, &msg); 841 842 dprintk("NFS: %5u initiated write call " 843 "(req %s/%lld, %u bytes @ offset %llu)\n", 844 data->task.tk_pid, 845 inode->i_sb->s_id, 846 (long long)NFS_FILEID(inode), 847 count, 848 (unsigned long long)data->args.offset); 849 850 task = rpc_run_task(&task_setup_data); 851 if (IS_ERR(task)) { 852 ret = PTR_ERR(task); 853 goto out; 854 } 855 if (how & FLUSH_SYNC) { 856 ret = rpc_wait_for_completion_task(task); 857 if (ret == 0) 858 ret = task->tk_status; 859 } 860 rpc_put_task(task); 861 out: 862 return ret; 863 } 864 865 /* If a nfs_flush_* function fails, it should remove reqs from @head and 866 * call this on each, which will prepare them to be retried on next 867 * writeback using standard nfs. 868 */ 869 static void nfs_redirty_request(struct nfs_page *req) 870 { 871 struct page *page = req->wb_page; 872 873 nfs_mark_request_dirty(req); 874 nfs_clear_page_tag_locked(req); 875 nfs_end_page_writeback(page); 876 } 877 878 /* 879 * Generate multiple small requests to write out a single 880 * contiguous dirty area on one page. 881 */ 882 static int nfs_flush_multi(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how) 883 { 884 struct nfs_page *req = nfs_list_entry(head->next); 885 struct page *page = req->wb_page; 886 struct nfs_write_data *data; 887 size_t wsize = NFS_SERVER(inode)->wsize, nbytes; 888 unsigned int offset; 889 int requests = 0; 890 int ret = 0; 891 LIST_HEAD(list); 892 893 nfs_list_remove_request(req); 894 895 nbytes = count; 896 do { 897 size_t len = min(nbytes, wsize); 898 899 data = nfs_writedata_alloc(1); 900 if (!data) 901 goto out_bad; 902 list_add(&data->pages, &list); 903 requests++; 904 nbytes -= len; 905 } while (nbytes != 0); 906 atomic_set(&req->wb_complete, requests); 907 908 ClearPageError(page); 909 offset = 0; 910 nbytes = count; 911 do { 912 int ret2; 913 914 data = list_entry(list.next, struct nfs_write_data, pages); 915 list_del_init(&data->pages); 916 917 data->pagevec[0] = page; 918 919 if (nbytes < wsize) 920 wsize = nbytes; 921 ret2 = nfs_write_rpcsetup(req, data, &nfs_write_partial_ops, 922 wsize, offset, how); 923 if (ret == 0) 924 ret = ret2; 925 offset += wsize; 926 nbytes -= wsize; 927 } while (nbytes != 0); 928 929 return ret; 930 931 out_bad: 932 while (!list_empty(&list)) { 933 data = list_entry(list.next, struct nfs_write_data, pages); 934 list_del(&data->pages); 935 nfs_writedata_release(data); 936 } 937 nfs_redirty_request(req); 938 return -ENOMEM; 939 } 940 941 /* 942 * Create an RPC task for the given write request and kick it. 943 * The page must have been locked by the caller. 944 * 945 * It may happen that the page we're passed is not marked dirty. 946 * This is the case if nfs_updatepage detects a conflicting request 947 * that has been written but not committed. 948 */ 949 static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned int npages, size_t count, int how) 950 { 951 struct nfs_page *req; 952 struct page **pages; 953 struct nfs_write_data *data; 954 955 data = nfs_writedata_alloc(npages); 956 if (!data) 957 goto out_bad; 958 959 pages = data->pagevec; 960 while (!list_empty(head)) { 961 req = nfs_list_entry(head->next); 962 nfs_list_remove_request(req); 963 nfs_list_add_request(req, &data->pages); 964 ClearPageError(req->wb_page); 965 *pages++ = req->wb_page; 966 } 967 req = nfs_list_entry(data->pages.next); 968 969 /* Set up the argument struct */ 970 return nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how); 971 out_bad: 972 while (!list_empty(head)) { 973 req = nfs_list_entry(head->next); 974 nfs_list_remove_request(req); 975 nfs_redirty_request(req); 976 } 977 return -ENOMEM; 978 } 979 980 static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio, 981 struct inode *inode, int ioflags) 982 { 983 size_t wsize = NFS_SERVER(inode)->wsize; 984 985 if (wsize < PAGE_CACHE_SIZE) 986 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags); 987 else 988 nfs_pageio_init(pgio, inode, nfs_flush_one, wsize, ioflags); 989 } 990 991 /* 992 * Handle a write reply that flushed part of a page. 993 */ 994 static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata) 995 { 996 struct nfs_write_data *data = calldata; 997 998 dprintk("NFS: %5u write(%s/%lld %d@%lld)", 999 task->tk_pid, 1000 data->req->wb_context->path.dentry->d_inode->i_sb->s_id, 1001 (long long) 1002 NFS_FILEID(data->req->wb_context->path.dentry->d_inode), 1003 data->req->wb_bytes, (long long)req_offset(data->req)); 1004 1005 nfs_writeback_done(task, data); 1006 } 1007 1008 static void nfs_writeback_release_partial(void *calldata) 1009 { 1010 struct nfs_write_data *data = calldata; 1011 struct nfs_page *req = data->req; 1012 struct page *page = req->wb_page; 1013 int status = data->task.tk_status; 1014 1015 if (status < 0) { 1016 nfs_set_pageerror(page); 1017 nfs_context_set_write_error(req->wb_context, status); 1018 dprintk(", error = %d\n", status); 1019 goto out; 1020 } 1021 1022 if (nfs_write_need_commit(data)) { 1023 struct inode *inode = page->mapping->host; 1024 1025 spin_lock(&inode->i_lock); 1026 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) { 1027 /* Do nothing we need to resend the writes */ 1028 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) { 1029 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf)); 1030 dprintk(" defer commit\n"); 1031 } else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf))) { 1032 set_bit(PG_NEED_RESCHED, &req->wb_flags); 1033 clear_bit(PG_NEED_COMMIT, &req->wb_flags); 1034 dprintk(" server reboot detected\n"); 1035 } 1036 spin_unlock(&inode->i_lock); 1037 } else 1038 dprintk(" OK\n"); 1039 1040 out: 1041 if (atomic_dec_and_test(&req->wb_complete)) 1042 nfs_writepage_release(req); 1043 nfs_writedata_release(calldata); 1044 } 1045 1046 #if defined(CONFIG_NFS_V4_1) 1047 void nfs_write_prepare(struct rpc_task *task, void *calldata) 1048 { 1049 struct nfs_write_data *data = calldata; 1050 1051 if (nfs4_setup_sequence(NFS_SERVER(data->inode), 1052 &data->args.seq_args, 1053 &data->res.seq_res, 1, task)) 1054 return; 1055 rpc_call_start(task); 1056 } 1057 #endif /* CONFIG_NFS_V4_1 */ 1058 1059 static const struct rpc_call_ops nfs_write_partial_ops = { 1060 #if defined(CONFIG_NFS_V4_1) 1061 .rpc_call_prepare = nfs_write_prepare, 1062 #endif /* CONFIG_NFS_V4_1 */ 1063 .rpc_call_done = nfs_writeback_done_partial, 1064 .rpc_release = nfs_writeback_release_partial, 1065 }; 1066 1067 /* 1068 * Handle a write reply that flushes a whole page. 1069 * 1070 * FIXME: There is an inherent race with invalidate_inode_pages and 1071 * writebacks since the page->count is kept > 1 for as long 1072 * as the page has a write request pending. 1073 */ 1074 static void nfs_writeback_done_full(struct rpc_task *task, void *calldata) 1075 { 1076 struct nfs_write_data *data = calldata; 1077 1078 nfs_writeback_done(task, data); 1079 } 1080 1081 static void nfs_writeback_release_full(void *calldata) 1082 { 1083 struct nfs_write_data *data = calldata; 1084 int status = data->task.tk_status; 1085 1086 /* Update attributes as result of writeback. */ 1087 while (!list_empty(&data->pages)) { 1088 struct nfs_page *req = nfs_list_entry(data->pages.next); 1089 struct page *page = req->wb_page; 1090 1091 nfs_list_remove_request(req); 1092 1093 dprintk("NFS: %5u write (%s/%lld %d@%lld)", 1094 data->task.tk_pid, 1095 req->wb_context->path.dentry->d_inode->i_sb->s_id, 1096 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode), 1097 req->wb_bytes, 1098 (long long)req_offset(req)); 1099 1100 if (status < 0) { 1101 nfs_set_pageerror(page); 1102 nfs_context_set_write_error(req->wb_context, status); 1103 dprintk(", error = %d\n", status); 1104 goto remove_request; 1105 } 1106 1107 if (nfs_write_need_commit(data)) { 1108 memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf)); 1109 nfs_mark_request_commit(req); 1110 dprintk(" marked for commit\n"); 1111 goto next; 1112 } 1113 dprintk(" OK\n"); 1114 remove_request: 1115 nfs_inode_remove_request(req); 1116 next: 1117 nfs_clear_page_tag_locked(req); 1118 nfs_end_page_writeback(page); 1119 } 1120 nfs_writedata_release(calldata); 1121 } 1122 1123 static const struct rpc_call_ops nfs_write_full_ops = { 1124 #if defined(CONFIG_NFS_V4_1) 1125 .rpc_call_prepare = nfs_write_prepare, 1126 #endif /* CONFIG_NFS_V4_1 */ 1127 .rpc_call_done = nfs_writeback_done_full, 1128 .rpc_release = nfs_writeback_release_full, 1129 }; 1130 1131 1132 /* 1133 * This function is called when the WRITE call is complete. 1134 */ 1135 int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data) 1136 { 1137 struct nfs_writeargs *argp = &data->args; 1138 struct nfs_writeres *resp = &data->res; 1139 struct nfs_server *server = NFS_SERVER(data->inode); 1140 int status; 1141 1142 dprintk("NFS: %5u nfs_writeback_done (status %d)\n", 1143 task->tk_pid, task->tk_status); 1144 1145 /* 1146 * ->write_done will attempt to use post-op attributes to detect 1147 * conflicting writes by other clients. A strict interpretation 1148 * of close-to-open would allow us to continue caching even if 1149 * another writer had changed the file, but some applications 1150 * depend on tighter cache coherency when writing. 1151 */ 1152 status = NFS_PROTO(data->inode)->write_done(task, data); 1153 if (status != 0) 1154 return status; 1155 nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count); 1156 1157 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) 1158 if (resp->verf->committed < argp->stable && task->tk_status >= 0) { 1159 /* We tried a write call, but the server did not 1160 * commit data to stable storage even though we 1161 * requested it. 1162 * Note: There is a known bug in Tru64 < 5.0 in which 1163 * the server reports NFS_DATA_SYNC, but performs 1164 * NFS_FILE_SYNC. We therefore implement this checking 1165 * as a dprintk() in order to avoid filling syslog. 1166 */ 1167 static unsigned long complain; 1168 1169 if (time_before(complain, jiffies)) { 1170 dprintk("NFS: faulty NFS server %s:" 1171 " (committed = %d) != (stable = %d)\n", 1172 server->nfs_client->cl_hostname, 1173 resp->verf->committed, argp->stable); 1174 complain = jiffies + 300 * HZ; 1175 } 1176 } 1177 #endif 1178 /* Is this a short write? */ 1179 if (task->tk_status >= 0 && resp->count < argp->count) { 1180 static unsigned long complain; 1181 1182 nfs_inc_stats(data->inode, NFSIOS_SHORTWRITE); 1183 1184 /* Has the server at least made some progress? */ 1185 if (resp->count != 0) { 1186 /* Was this an NFSv2 write or an NFSv3 stable write? */ 1187 if (resp->verf->committed != NFS_UNSTABLE) { 1188 /* Resend from where the server left off */ 1189 argp->offset += resp->count; 1190 argp->pgbase += resp->count; 1191 argp->count -= resp->count; 1192 } else { 1193 /* Resend as a stable write in order to avoid 1194 * headaches in the case of a server crash. 1195 */ 1196 argp->stable = NFS_FILE_SYNC; 1197 } 1198 nfs_restart_rpc(task, server->nfs_client); 1199 return -EAGAIN; 1200 } 1201 if (time_before(complain, jiffies)) { 1202 printk(KERN_WARNING 1203 "NFS: Server wrote zero bytes, expected %u.\n", 1204 argp->count); 1205 complain = jiffies + 300 * HZ; 1206 } 1207 /* Can't do anything about it except throw an error. */ 1208 task->tk_status = -EIO; 1209 } 1210 return 0; 1211 } 1212 1213 1214 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) 1215 static int nfs_commit_set_lock(struct nfs_inode *nfsi, int may_wait) 1216 { 1217 if (!test_and_set_bit(NFS_INO_COMMIT, &nfsi->flags)) 1218 return 1; 1219 if (may_wait && !out_of_line_wait_on_bit_lock(&nfsi->flags, 1220 NFS_INO_COMMIT, nfs_wait_bit_killable, 1221 TASK_KILLABLE)) 1222 return 1; 1223 return 0; 1224 } 1225 1226 static void nfs_commit_clear_lock(struct nfs_inode *nfsi) 1227 { 1228 clear_bit(NFS_INO_COMMIT, &nfsi->flags); 1229 smp_mb__after_clear_bit(); 1230 wake_up_bit(&nfsi->flags, NFS_INO_COMMIT); 1231 } 1232 1233 1234 static void nfs_commitdata_release(void *data) 1235 { 1236 struct nfs_write_data *wdata = data; 1237 1238 put_nfs_open_context(wdata->args.context); 1239 nfs_commit_free(wdata); 1240 } 1241 1242 /* 1243 * Set up the argument/result storage required for the RPC call. 1244 */ 1245 static int nfs_commit_rpcsetup(struct list_head *head, 1246 struct nfs_write_data *data, 1247 int how) 1248 { 1249 struct nfs_page *first = nfs_list_entry(head->next); 1250 struct inode *inode = first->wb_context->path.dentry->d_inode; 1251 int priority = flush_task_priority(how); 1252 struct rpc_task *task; 1253 struct rpc_message msg = { 1254 .rpc_argp = &data->args, 1255 .rpc_resp = &data->res, 1256 .rpc_cred = first->wb_context->cred, 1257 }; 1258 struct rpc_task_setup task_setup_data = { 1259 .task = &data->task, 1260 .rpc_client = NFS_CLIENT(inode), 1261 .rpc_message = &msg, 1262 .callback_ops = &nfs_commit_ops, 1263 .callback_data = data, 1264 .workqueue = nfsiod_workqueue, 1265 .flags = RPC_TASK_ASYNC, 1266 .priority = priority, 1267 }; 1268 1269 /* Set up the RPC argument and reply structs 1270 * NB: take care not to mess about with data->commit et al. */ 1271 1272 list_splice_init(head, &data->pages); 1273 1274 data->inode = inode; 1275 data->cred = msg.rpc_cred; 1276 1277 data->args.fh = NFS_FH(data->inode); 1278 /* Note: we always request a commit of the entire inode */ 1279 data->args.offset = 0; 1280 data->args.count = 0; 1281 data->args.context = get_nfs_open_context(first->wb_context); 1282 data->res.count = 0; 1283 data->res.fattr = &data->fattr; 1284 data->res.verf = &data->verf; 1285 nfs_fattr_init(&data->fattr); 1286 1287 /* Set up the initial task struct. */ 1288 NFS_PROTO(inode)->commit_setup(data, &msg); 1289 1290 dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid); 1291 1292 task = rpc_run_task(&task_setup_data); 1293 if (IS_ERR(task)) 1294 return PTR_ERR(task); 1295 rpc_put_task(task); 1296 return 0; 1297 } 1298 1299 /* 1300 * Commit dirty pages 1301 */ 1302 static int 1303 nfs_commit_list(struct inode *inode, struct list_head *head, int how) 1304 { 1305 struct nfs_write_data *data; 1306 struct nfs_page *req; 1307 1308 data = nfs_commitdata_alloc(); 1309 1310 if (!data) 1311 goto out_bad; 1312 1313 /* Set up the argument struct */ 1314 return nfs_commit_rpcsetup(head, data, how); 1315 out_bad: 1316 while (!list_empty(head)) { 1317 req = nfs_list_entry(head->next); 1318 nfs_list_remove_request(req); 1319 nfs_mark_request_commit(req); 1320 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS); 1321 dec_bdi_stat(req->wb_page->mapping->backing_dev_info, 1322 BDI_RECLAIMABLE); 1323 nfs_clear_page_tag_locked(req); 1324 } 1325 nfs_commit_clear_lock(NFS_I(inode)); 1326 return -ENOMEM; 1327 } 1328 1329 /* 1330 * COMMIT call returned 1331 */ 1332 static void nfs_commit_done(struct rpc_task *task, void *calldata) 1333 { 1334 struct nfs_write_data *data = calldata; 1335 1336 dprintk("NFS: %5u nfs_commit_done (status %d)\n", 1337 task->tk_pid, task->tk_status); 1338 1339 /* Call the NFS version-specific code */ 1340 if (NFS_PROTO(data->inode)->commit_done(task, data) != 0) 1341 return; 1342 } 1343 1344 static void nfs_commit_release(void *calldata) 1345 { 1346 struct nfs_write_data *data = calldata; 1347 struct nfs_page *req; 1348 int status = data->task.tk_status; 1349 1350 while (!list_empty(&data->pages)) { 1351 req = nfs_list_entry(data->pages.next); 1352 nfs_list_remove_request(req); 1353 nfs_clear_request_commit(req); 1354 1355 dprintk("NFS: commit (%s/%lld %d@%lld)", 1356 req->wb_context->path.dentry->d_inode->i_sb->s_id, 1357 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode), 1358 req->wb_bytes, 1359 (long long)req_offset(req)); 1360 if (status < 0) { 1361 nfs_context_set_write_error(req->wb_context, status); 1362 nfs_inode_remove_request(req); 1363 dprintk(", error = %d\n", status); 1364 goto next; 1365 } 1366 1367 /* Okay, COMMIT succeeded, apparently. Check the verifier 1368 * returned by the server against all stored verfs. */ 1369 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) { 1370 /* We have a match */ 1371 nfs_inode_remove_request(req); 1372 dprintk(" OK\n"); 1373 goto next; 1374 } 1375 /* We have a mismatch. Write the page again */ 1376 dprintk(" mismatch\n"); 1377 nfs_mark_request_dirty(req); 1378 next: 1379 nfs_clear_page_tag_locked(req); 1380 } 1381 nfs_commit_clear_lock(NFS_I(data->inode)); 1382 nfs_commitdata_release(calldata); 1383 } 1384 1385 static const struct rpc_call_ops nfs_commit_ops = { 1386 #if defined(CONFIG_NFS_V4_1) 1387 .rpc_call_prepare = nfs_write_prepare, 1388 #endif /* CONFIG_NFS_V4_1 */ 1389 .rpc_call_done = nfs_commit_done, 1390 .rpc_release = nfs_commit_release, 1391 }; 1392 1393 int nfs_commit_inode(struct inode *inode, int how) 1394 { 1395 LIST_HEAD(head); 1396 int may_wait = how & FLUSH_SYNC; 1397 int res = 0; 1398 1399 if (!nfs_commit_set_lock(NFS_I(inode), may_wait)) 1400 goto out_mark_dirty; 1401 spin_lock(&inode->i_lock); 1402 res = nfs_scan_commit(inode, &head, 0, 0); 1403 spin_unlock(&inode->i_lock); 1404 if (res) { 1405 int error = nfs_commit_list(inode, &head, how); 1406 if (error < 0) 1407 return error; 1408 if (may_wait) 1409 wait_on_bit(&NFS_I(inode)->flags, NFS_INO_COMMIT, 1410 nfs_wait_bit_killable, 1411 TASK_KILLABLE); 1412 else 1413 goto out_mark_dirty; 1414 } else 1415 nfs_commit_clear_lock(NFS_I(inode)); 1416 return res; 1417 /* Note: If we exit without ensuring that the commit is complete, 1418 * we must mark the inode as dirty. Otherwise, future calls to 1419 * sync_inode() with the WB_SYNC_ALL flag set will fail to ensure 1420 * that the data is on the disk. 1421 */ 1422 out_mark_dirty: 1423 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 1424 return res; 1425 } 1426 1427 static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc) 1428 { 1429 struct nfs_inode *nfsi = NFS_I(inode); 1430 int flags = FLUSH_SYNC; 1431 int ret = 0; 1432 1433 if (wbc->sync_mode == WB_SYNC_NONE) { 1434 /* Don't commit yet if this is a non-blocking flush and there 1435 * are a lot of outstanding writes for this mapping. 1436 */ 1437 if (nfsi->ncommit <= (nfsi->npages >> 1)) 1438 goto out_mark_dirty; 1439 1440 /* don't wait for the COMMIT response */ 1441 flags = 0; 1442 } 1443 1444 ret = nfs_commit_inode(inode, flags); 1445 if (ret >= 0) { 1446 if (wbc->sync_mode == WB_SYNC_NONE) { 1447 if (ret < wbc->nr_to_write) 1448 wbc->nr_to_write -= ret; 1449 else 1450 wbc->nr_to_write = 0; 1451 } 1452 return 0; 1453 } 1454 out_mark_dirty: 1455 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 1456 return ret; 1457 } 1458 #else 1459 static int nfs_commit_unstable_pages(struct inode *inode, struct writeback_control *wbc) 1460 { 1461 return 0; 1462 } 1463 #endif 1464 1465 int nfs_write_inode(struct inode *inode, struct writeback_control *wbc) 1466 { 1467 return nfs_commit_unstable_pages(inode, wbc); 1468 } 1469 1470 /* 1471 * flush the inode to disk. 1472 */ 1473 int nfs_wb_all(struct inode *inode) 1474 { 1475 struct writeback_control wbc = { 1476 .sync_mode = WB_SYNC_ALL, 1477 .nr_to_write = LONG_MAX, 1478 .range_start = 0, 1479 .range_end = LLONG_MAX, 1480 }; 1481 1482 return sync_inode(inode, &wbc); 1483 } 1484 1485 int nfs_wb_page_cancel(struct inode *inode, struct page *page) 1486 { 1487 struct nfs_page *req; 1488 int ret = 0; 1489 1490 BUG_ON(!PageLocked(page)); 1491 for (;;) { 1492 wait_on_page_writeback(page); 1493 req = nfs_page_find_request(page); 1494 if (req == NULL) 1495 break; 1496 if (nfs_lock_request_dontget(req)) { 1497 nfs_inode_remove_request(req); 1498 /* 1499 * In case nfs_inode_remove_request has marked the 1500 * page as being dirty 1501 */ 1502 cancel_dirty_page(page, PAGE_CACHE_SIZE); 1503 nfs_unlock_request(req); 1504 break; 1505 } 1506 ret = nfs_wait_on_request(req); 1507 nfs_release_request(req); 1508 if (ret < 0) 1509 break; 1510 } 1511 return ret; 1512 } 1513 1514 /* 1515 * Write back all requests on one page - we do this before reading it. 1516 */ 1517 int nfs_wb_page(struct inode *inode, struct page *page) 1518 { 1519 loff_t range_start = page_offset(page); 1520 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1); 1521 struct writeback_control wbc = { 1522 .sync_mode = WB_SYNC_ALL, 1523 .nr_to_write = 0, 1524 .range_start = range_start, 1525 .range_end = range_end, 1526 }; 1527 int ret; 1528 1529 for (;;) { 1530 wait_on_page_writeback(page); 1531 if (clear_page_dirty_for_io(page)) { 1532 ret = nfs_writepage_locked(page, &wbc); 1533 if (ret < 0) 1534 goto out_error; 1535 continue; 1536 } 1537 if (!PagePrivate(page)) 1538 break; 1539 ret = nfs_commit_inode(inode, FLUSH_SYNC); 1540 if (ret < 0) 1541 goto out_error; 1542 } 1543 return 0; 1544 out_error: 1545 return ret; 1546 } 1547 1548 #ifdef CONFIG_MIGRATION 1549 int nfs_migrate_page(struct address_space *mapping, struct page *newpage, 1550 struct page *page) 1551 { 1552 struct nfs_page *req; 1553 int ret; 1554 1555 nfs_fscache_release_page(page, GFP_KERNEL); 1556 1557 req = nfs_find_and_lock_request(page, false); 1558 ret = PTR_ERR(req); 1559 if (IS_ERR(req)) 1560 goto out; 1561 1562 ret = migrate_page(mapping, newpage, page); 1563 if (!req) 1564 goto out; 1565 if (ret) 1566 goto out_unlock; 1567 page_cache_get(newpage); 1568 spin_lock(&mapping->host->i_lock); 1569 req->wb_page = newpage; 1570 SetPagePrivate(newpage); 1571 set_page_private(newpage, (unsigned long)req); 1572 ClearPagePrivate(page); 1573 set_page_private(page, 0); 1574 spin_unlock(&mapping->host->i_lock); 1575 page_cache_release(page); 1576 out_unlock: 1577 nfs_clear_page_tag_locked(req); 1578 out: 1579 return ret; 1580 } 1581 #endif 1582 1583 int __init nfs_init_writepagecache(void) 1584 { 1585 nfs_wdata_cachep = kmem_cache_create("nfs_write_data", 1586 sizeof(struct nfs_write_data), 1587 0, SLAB_HWCACHE_ALIGN, 1588 NULL); 1589 if (nfs_wdata_cachep == NULL) 1590 return -ENOMEM; 1591 1592 nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE, 1593 nfs_wdata_cachep); 1594 if (nfs_wdata_mempool == NULL) 1595 return -ENOMEM; 1596 1597 nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT, 1598 nfs_wdata_cachep); 1599 if (nfs_commit_mempool == NULL) 1600 return -ENOMEM; 1601 1602 /* 1603 * NFS congestion size, scale with available memory. 1604 * 1605 * 64MB: 8192k 1606 * 128MB: 11585k 1607 * 256MB: 16384k 1608 * 512MB: 23170k 1609 * 1GB: 32768k 1610 * 2GB: 46340k 1611 * 4GB: 65536k 1612 * 8GB: 92681k 1613 * 16GB: 131072k 1614 * 1615 * This allows larger machines to have larger/more transfers. 1616 * Limit the default to 256M 1617 */ 1618 nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10); 1619 if (nfs_congestion_kb > 256*1024) 1620 nfs_congestion_kb = 256*1024; 1621 1622 return 0; 1623 } 1624 1625 void nfs_destroy_writepagecache(void) 1626 { 1627 mempool_destroy(nfs_commit_mempool); 1628 mempool_destroy(nfs_wdata_mempool); 1629 kmem_cache_destroy(nfs_wdata_cachep); 1630 } 1631 1632