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