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