1 /* 2 * linux/fs/nfs/pagelist.c 3 * 4 * A set of helper functions for managing NFS read and write requests. 5 * The main purpose of these routines is to provide support for the 6 * coalescing of several requests into a single RPC call. 7 * 8 * Copyright 2000, 2001 (c) Trond Myklebust <trond.myklebust@fys.uio.no> 9 * 10 */ 11 12 #include <linux/slab.h> 13 #include <linux/file.h> 14 #include <linux/sched.h> 15 #include <linux/sunrpc/clnt.h> 16 #include <linux/nfs.h> 17 #include <linux/nfs3.h> 18 #include <linux/nfs4.h> 19 #include <linux/nfs_page.h> 20 #include <linux/nfs_fs.h> 21 #include <linux/nfs_mount.h> 22 #include <linux/export.h> 23 24 #include "internal.h" 25 #include "pnfs.h" 26 27 #define NFSDBG_FACILITY NFSDBG_PAGECACHE 28 29 static struct kmem_cache *nfs_page_cachep; 30 static const struct rpc_call_ops nfs_pgio_common_ops; 31 32 struct nfs_pgio_mirror * 33 nfs_pgio_current_mirror(struct nfs_pageio_descriptor *desc) 34 { 35 return nfs_pgio_has_mirroring(desc) ? 36 &desc->pg_mirrors[desc->pg_mirror_idx] : 37 &desc->pg_mirrors[0]; 38 } 39 EXPORT_SYMBOL_GPL(nfs_pgio_current_mirror); 40 41 void nfs_pgheader_init(struct nfs_pageio_descriptor *desc, 42 struct nfs_pgio_header *hdr, 43 void (*release)(struct nfs_pgio_header *hdr)) 44 { 45 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 46 47 48 hdr->req = nfs_list_entry(mirror->pg_list.next); 49 hdr->inode = desc->pg_inode; 50 hdr->cred = hdr->req->wb_context->cred; 51 hdr->io_start = req_offset(hdr->req); 52 hdr->good_bytes = mirror->pg_count; 53 hdr->io_completion = desc->pg_io_completion; 54 hdr->dreq = desc->pg_dreq; 55 hdr->release = release; 56 hdr->completion_ops = desc->pg_completion_ops; 57 if (hdr->completion_ops->init_hdr) 58 hdr->completion_ops->init_hdr(hdr); 59 60 hdr->pgio_mirror_idx = desc->pg_mirror_idx; 61 } 62 EXPORT_SYMBOL_GPL(nfs_pgheader_init); 63 64 void nfs_set_pgio_error(struct nfs_pgio_header *hdr, int error, loff_t pos) 65 { 66 spin_lock(&hdr->lock); 67 if (!test_and_set_bit(NFS_IOHDR_ERROR, &hdr->flags) 68 || pos < hdr->io_start + hdr->good_bytes) { 69 clear_bit(NFS_IOHDR_EOF, &hdr->flags); 70 hdr->good_bytes = pos - hdr->io_start; 71 hdr->error = error; 72 } 73 spin_unlock(&hdr->lock); 74 } 75 76 static inline struct nfs_page * 77 nfs_page_alloc(void) 78 { 79 struct nfs_page *p = kmem_cache_zalloc(nfs_page_cachep, GFP_NOIO); 80 if (p) 81 INIT_LIST_HEAD(&p->wb_list); 82 return p; 83 } 84 85 static inline void 86 nfs_page_free(struct nfs_page *p) 87 { 88 kmem_cache_free(nfs_page_cachep, p); 89 } 90 91 /** 92 * nfs_iocounter_wait - wait for i/o to complete 93 * @l_ctx: nfs_lock_context with io_counter to use 94 * 95 * returns -ERESTARTSYS if interrupted by a fatal signal. 96 * Otherwise returns 0 once the io_count hits 0. 97 */ 98 int 99 nfs_iocounter_wait(struct nfs_lock_context *l_ctx) 100 { 101 return wait_on_atomic_t(&l_ctx->io_count, nfs_wait_atomic_killable, 102 TASK_KILLABLE); 103 } 104 105 /** 106 * nfs_async_iocounter_wait - wait on a rpc_waitqueue for I/O 107 * to complete 108 * @task: the rpc_task that should wait 109 * @l_ctx: nfs_lock_context with io_counter to check 110 * 111 * Returns true if there is outstanding I/O to wait on and the 112 * task has been put to sleep. 113 */ 114 bool 115 nfs_async_iocounter_wait(struct rpc_task *task, struct nfs_lock_context *l_ctx) 116 { 117 struct inode *inode = d_inode(l_ctx->open_context->dentry); 118 bool ret = false; 119 120 if (atomic_read(&l_ctx->io_count) > 0) { 121 rpc_sleep_on(&NFS_SERVER(inode)->uoc_rpcwaitq, task, NULL); 122 ret = true; 123 } 124 125 if (atomic_read(&l_ctx->io_count) == 0) { 126 rpc_wake_up_queued_task(&NFS_SERVER(inode)->uoc_rpcwaitq, task); 127 ret = false; 128 } 129 130 return ret; 131 } 132 EXPORT_SYMBOL_GPL(nfs_async_iocounter_wait); 133 134 /* 135 * nfs_page_group_lock - lock the head of the page group 136 * @req - request in group that is to be locked 137 * @nonblock - if true don't block waiting for lock 138 * 139 * this lock must be held if modifying the page group list 140 * 141 * return 0 on success, < 0 on error: -EDELAY if nonblocking or the 142 * result from wait_on_bit_lock 143 * 144 * NOTE: calling with nonblock=false should always have set the 145 * lock bit (see fs/buffer.c and other uses of wait_on_bit_lock 146 * with TASK_UNINTERRUPTIBLE), so there is no need to check the result. 147 */ 148 int 149 nfs_page_group_lock(struct nfs_page *req, bool nonblock) 150 { 151 struct nfs_page *head = req->wb_head; 152 153 WARN_ON_ONCE(head != head->wb_head); 154 155 if (!test_and_set_bit(PG_HEADLOCK, &head->wb_flags)) 156 return 0; 157 158 if (!nonblock) { 159 set_bit(PG_CONTENDED1, &head->wb_flags); 160 smp_mb__after_atomic(); 161 return wait_on_bit_lock(&head->wb_flags, PG_HEADLOCK, 162 TASK_UNINTERRUPTIBLE); 163 } 164 165 return -EAGAIN; 166 } 167 168 /* 169 * nfs_page_group_lock_wait - wait for the lock to clear, but don't grab it 170 * @req - a request in the group 171 * 172 * This is a blocking call to wait for the group lock to be cleared. 173 */ 174 void 175 nfs_page_group_lock_wait(struct nfs_page *req) 176 { 177 struct nfs_page *head = req->wb_head; 178 179 WARN_ON_ONCE(head != head->wb_head); 180 181 if (!test_bit(PG_HEADLOCK, &head->wb_flags)) 182 return; 183 set_bit(PG_CONTENDED1, &head->wb_flags); 184 smp_mb__after_atomic(); 185 wait_on_bit(&head->wb_flags, PG_HEADLOCK, 186 TASK_UNINTERRUPTIBLE); 187 } 188 189 /* 190 * nfs_page_group_unlock - unlock the head of the page group 191 * @req - request in group that is to be unlocked 192 */ 193 void 194 nfs_page_group_unlock(struct nfs_page *req) 195 { 196 struct nfs_page *head = req->wb_head; 197 198 WARN_ON_ONCE(head != head->wb_head); 199 200 smp_mb__before_atomic(); 201 clear_bit(PG_HEADLOCK, &head->wb_flags); 202 smp_mb__after_atomic(); 203 if (!test_bit(PG_CONTENDED1, &head->wb_flags)) 204 return; 205 wake_up_bit(&head->wb_flags, PG_HEADLOCK); 206 } 207 208 /* 209 * nfs_page_group_sync_on_bit_locked 210 * 211 * must be called with page group lock held 212 */ 213 static bool 214 nfs_page_group_sync_on_bit_locked(struct nfs_page *req, unsigned int bit) 215 { 216 struct nfs_page *head = req->wb_head; 217 struct nfs_page *tmp; 218 219 WARN_ON_ONCE(!test_bit(PG_HEADLOCK, &head->wb_flags)); 220 WARN_ON_ONCE(test_and_set_bit(bit, &req->wb_flags)); 221 222 tmp = req->wb_this_page; 223 while (tmp != req) { 224 if (!test_bit(bit, &tmp->wb_flags)) 225 return false; 226 tmp = tmp->wb_this_page; 227 } 228 229 /* true! reset all bits */ 230 tmp = req; 231 do { 232 clear_bit(bit, &tmp->wb_flags); 233 tmp = tmp->wb_this_page; 234 } while (tmp != req); 235 236 return true; 237 } 238 239 /* 240 * nfs_page_group_sync_on_bit - set bit on current request, but only 241 * return true if the bit is set for all requests in page group 242 * @req - request in page group 243 * @bit - PG_* bit that is used to sync page group 244 */ 245 bool nfs_page_group_sync_on_bit(struct nfs_page *req, unsigned int bit) 246 { 247 bool ret; 248 249 nfs_page_group_lock(req, false); 250 ret = nfs_page_group_sync_on_bit_locked(req, bit); 251 nfs_page_group_unlock(req); 252 253 return ret; 254 } 255 256 /* 257 * nfs_page_group_init - Initialize the page group linkage for @req 258 * @req - a new nfs request 259 * @prev - the previous request in page group, or NULL if @req is the first 260 * or only request in the group (the head). 261 */ 262 static inline void 263 nfs_page_group_init(struct nfs_page *req, struct nfs_page *prev) 264 { 265 struct inode *inode; 266 WARN_ON_ONCE(prev == req); 267 268 if (!prev) { 269 /* a head request */ 270 req->wb_head = req; 271 req->wb_this_page = req; 272 } else { 273 /* a subrequest */ 274 WARN_ON_ONCE(prev->wb_this_page != prev->wb_head); 275 WARN_ON_ONCE(!test_bit(PG_HEADLOCK, &prev->wb_head->wb_flags)); 276 req->wb_head = prev->wb_head; 277 req->wb_this_page = prev->wb_this_page; 278 prev->wb_this_page = req; 279 280 /* All subrequests take a ref on the head request until 281 * nfs_page_group_destroy is called */ 282 kref_get(&req->wb_head->wb_kref); 283 284 /* grab extra ref and bump the request count if head request 285 * has extra ref from the write/commit path to handle handoff 286 * between write and commit lists. */ 287 if (test_bit(PG_INODE_REF, &prev->wb_head->wb_flags)) { 288 inode = page_file_mapping(req->wb_page)->host; 289 set_bit(PG_INODE_REF, &req->wb_flags); 290 kref_get(&req->wb_kref); 291 spin_lock(&inode->i_lock); 292 NFS_I(inode)->nrequests++; 293 spin_unlock(&inode->i_lock); 294 } 295 } 296 } 297 298 /* 299 * nfs_page_group_destroy - sync the destruction of page groups 300 * @req - request that no longer needs the page group 301 * 302 * releases the page group reference from each member once all 303 * members have called this function. 304 */ 305 static void 306 nfs_page_group_destroy(struct kref *kref) 307 { 308 struct nfs_page *req = container_of(kref, struct nfs_page, wb_kref); 309 struct nfs_page *tmp, *next; 310 311 /* subrequests must release the ref on the head request */ 312 if (req->wb_head != req) 313 nfs_release_request(req->wb_head); 314 315 if (!nfs_page_group_sync_on_bit(req, PG_TEARDOWN)) 316 return; 317 318 tmp = req; 319 do { 320 next = tmp->wb_this_page; 321 /* unlink and free */ 322 tmp->wb_this_page = tmp; 323 tmp->wb_head = tmp; 324 nfs_free_request(tmp); 325 tmp = next; 326 } while (tmp != req); 327 } 328 329 /** 330 * nfs_create_request - Create an NFS read/write request. 331 * @ctx: open context to use 332 * @page: page to write 333 * @last: last nfs request created for this page group or NULL if head 334 * @offset: starting offset within the page for the write 335 * @count: number of bytes to read/write 336 * 337 * The page must be locked by the caller. This makes sure we never 338 * create two different requests for the same page. 339 * User should ensure it is safe to sleep in this function. 340 */ 341 struct nfs_page * 342 nfs_create_request(struct nfs_open_context *ctx, struct page *page, 343 struct nfs_page *last, unsigned int offset, 344 unsigned int count) 345 { 346 struct nfs_page *req; 347 struct nfs_lock_context *l_ctx; 348 349 if (test_bit(NFS_CONTEXT_BAD, &ctx->flags)) 350 return ERR_PTR(-EBADF); 351 /* try to allocate the request struct */ 352 req = nfs_page_alloc(); 353 if (req == NULL) 354 return ERR_PTR(-ENOMEM); 355 356 /* get lock context early so we can deal with alloc failures */ 357 l_ctx = nfs_get_lock_context(ctx); 358 if (IS_ERR(l_ctx)) { 359 nfs_page_free(req); 360 return ERR_CAST(l_ctx); 361 } 362 req->wb_lock_context = l_ctx; 363 atomic_inc(&l_ctx->io_count); 364 365 /* Initialize the request struct. Initially, we assume a 366 * long write-back delay. This will be adjusted in 367 * update_nfs_request below if the region is not locked. */ 368 req->wb_page = page; 369 if (page) { 370 req->wb_index = page_index(page); 371 get_page(page); 372 } 373 req->wb_offset = offset; 374 req->wb_pgbase = offset; 375 req->wb_bytes = count; 376 req->wb_context = get_nfs_open_context(ctx); 377 kref_init(&req->wb_kref); 378 nfs_page_group_init(req, last); 379 return req; 380 } 381 382 /** 383 * nfs_unlock_request - Unlock request and wake up sleepers. 384 * @req: 385 */ 386 void nfs_unlock_request(struct nfs_page *req) 387 { 388 if (!NFS_WBACK_BUSY(req)) { 389 printk(KERN_ERR "NFS: Invalid unlock attempted\n"); 390 BUG(); 391 } 392 smp_mb__before_atomic(); 393 clear_bit(PG_BUSY, &req->wb_flags); 394 smp_mb__after_atomic(); 395 if (!test_bit(PG_CONTENDED2, &req->wb_flags)) 396 return; 397 wake_up_bit(&req->wb_flags, PG_BUSY); 398 } 399 400 /** 401 * nfs_unlock_and_release_request - Unlock request and release the nfs_page 402 * @req: 403 */ 404 void nfs_unlock_and_release_request(struct nfs_page *req) 405 { 406 nfs_unlock_request(req); 407 nfs_release_request(req); 408 } 409 410 /* 411 * nfs_clear_request - Free up all resources allocated to the request 412 * @req: 413 * 414 * Release page and open context resources associated with a read/write 415 * request after it has completed. 416 */ 417 static void nfs_clear_request(struct nfs_page *req) 418 { 419 struct page *page = req->wb_page; 420 struct nfs_open_context *ctx = req->wb_context; 421 struct nfs_lock_context *l_ctx = req->wb_lock_context; 422 423 if (page != NULL) { 424 put_page(page); 425 req->wb_page = NULL; 426 } 427 if (l_ctx != NULL) { 428 if (atomic_dec_and_test(&l_ctx->io_count)) { 429 wake_up_atomic_t(&l_ctx->io_count); 430 if (test_bit(NFS_CONTEXT_UNLOCK, &ctx->flags)) 431 rpc_wake_up(&NFS_SERVER(d_inode(ctx->dentry))->uoc_rpcwaitq); 432 } 433 nfs_put_lock_context(l_ctx); 434 req->wb_lock_context = NULL; 435 } 436 if (ctx != NULL) { 437 put_nfs_open_context(ctx); 438 req->wb_context = NULL; 439 } 440 } 441 442 /** 443 * nfs_release_request - Release the count on an NFS read/write request 444 * @req: request to release 445 * 446 * Note: Should never be called with the spinlock held! 447 */ 448 void nfs_free_request(struct nfs_page *req) 449 { 450 WARN_ON_ONCE(req->wb_this_page != req); 451 452 /* extra debug: make sure no sync bits are still set */ 453 WARN_ON_ONCE(test_bit(PG_TEARDOWN, &req->wb_flags)); 454 WARN_ON_ONCE(test_bit(PG_UNLOCKPAGE, &req->wb_flags)); 455 WARN_ON_ONCE(test_bit(PG_UPTODATE, &req->wb_flags)); 456 WARN_ON_ONCE(test_bit(PG_WB_END, &req->wb_flags)); 457 WARN_ON_ONCE(test_bit(PG_REMOVE, &req->wb_flags)); 458 459 /* Release struct file and open context */ 460 nfs_clear_request(req); 461 nfs_page_free(req); 462 } 463 464 void nfs_release_request(struct nfs_page *req) 465 { 466 kref_put(&req->wb_kref, nfs_page_group_destroy); 467 } 468 469 /** 470 * nfs_wait_on_request - Wait for a request to complete. 471 * @req: request to wait upon. 472 * 473 * Interruptible by fatal signals only. 474 * The user is responsible for holding a count on the request. 475 */ 476 int 477 nfs_wait_on_request(struct nfs_page *req) 478 { 479 if (!test_bit(PG_BUSY, &req->wb_flags)) 480 return 0; 481 set_bit(PG_CONTENDED2, &req->wb_flags); 482 smp_mb__after_atomic(); 483 return wait_on_bit_io(&req->wb_flags, PG_BUSY, 484 TASK_UNINTERRUPTIBLE); 485 } 486 487 /* 488 * nfs_generic_pg_test - determine if requests can be coalesced 489 * @desc: pointer to descriptor 490 * @prev: previous request in desc, or NULL 491 * @req: this request 492 * 493 * Returns zero if @req can be coalesced into @desc, otherwise it returns 494 * the size of the request. 495 */ 496 size_t nfs_generic_pg_test(struct nfs_pageio_descriptor *desc, 497 struct nfs_page *prev, struct nfs_page *req) 498 { 499 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 500 501 502 if (mirror->pg_count > mirror->pg_bsize) { 503 /* should never happen */ 504 WARN_ON_ONCE(1); 505 return 0; 506 } 507 508 /* 509 * Limit the request size so that we can still allocate a page array 510 * for it without upsetting the slab allocator. 511 */ 512 if (((mirror->pg_count + req->wb_bytes) >> PAGE_SHIFT) * 513 sizeof(struct page *) > PAGE_SIZE) 514 return 0; 515 516 return min(mirror->pg_bsize - mirror->pg_count, (size_t)req->wb_bytes); 517 } 518 EXPORT_SYMBOL_GPL(nfs_generic_pg_test); 519 520 struct nfs_pgio_header *nfs_pgio_header_alloc(const struct nfs_rw_ops *ops) 521 { 522 struct nfs_pgio_header *hdr = ops->rw_alloc_header(); 523 524 if (hdr) { 525 INIT_LIST_HEAD(&hdr->pages); 526 spin_lock_init(&hdr->lock); 527 hdr->rw_ops = ops; 528 } 529 return hdr; 530 } 531 EXPORT_SYMBOL_GPL(nfs_pgio_header_alloc); 532 533 /* 534 * nfs_pgio_header_free - Free a read or write header 535 * @hdr: The header to free 536 */ 537 void nfs_pgio_header_free(struct nfs_pgio_header *hdr) 538 { 539 hdr->rw_ops->rw_free_header(hdr); 540 } 541 EXPORT_SYMBOL_GPL(nfs_pgio_header_free); 542 543 /** 544 * nfs_pgio_data_destroy - make @hdr suitable for reuse 545 * 546 * Frees memory and releases refs from nfs_generic_pgio, so that it may 547 * be called again. 548 * 549 * @hdr: A header that has had nfs_generic_pgio called 550 */ 551 void nfs_pgio_data_destroy(struct nfs_pgio_header *hdr) 552 { 553 if (hdr->args.context) 554 put_nfs_open_context(hdr->args.context); 555 if (hdr->page_array.pagevec != hdr->page_array.page_array) 556 kfree(hdr->page_array.pagevec); 557 } 558 EXPORT_SYMBOL_GPL(nfs_pgio_data_destroy); 559 560 /** 561 * nfs_pgio_rpcsetup - Set up arguments for a pageio call 562 * @hdr: The pageio hdr 563 * @count: Number of bytes to read 564 * @offset: Initial offset 565 * @how: How to commit data (writes only) 566 * @cinfo: Commit information for the call (writes only) 567 */ 568 static void nfs_pgio_rpcsetup(struct nfs_pgio_header *hdr, 569 unsigned int count, unsigned int offset, 570 int how, struct nfs_commit_info *cinfo) 571 { 572 struct nfs_page *req = hdr->req; 573 574 /* Set up the RPC argument and reply structs 575 * NB: take care not to mess about with hdr->commit et al. */ 576 577 hdr->args.fh = NFS_FH(hdr->inode); 578 hdr->args.offset = req_offset(req) + offset; 579 /* pnfs_set_layoutcommit needs this */ 580 hdr->mds_offset = hdr->args.offset; 581 hdr->args.pgbase = req->wb_pgbase + offset; 582 hdr->args.pages = hdr->page_array.pagevec; 583 hdr->args.count = count; 584 hdr->args.context = get_nfs_open_context(req->wb_context); 585 hdr->args.lock_context = req->wb_lock_context; 586 hdr->args.stable = NFS_UNSTABLE; 587 switch (how & (FLUSH_STABLE | FLUSH_COND_STABLE)) { 588 case 0: 589 break; 590 case FLUSH_COND_STABLE: 591 if (nfs_reqs_to_commit(cinfo)) 592 break; 593 default: 594 hdr->args.stable = NFS_FILE_SYNC; 595 } 596 597 hdr->res.fattr = &hdr->fattr; 598 hdr->res.count = count; 599 hdr->res.eof = 0; 600 hdr->res.verf = &hdr->verf; 601 nfs_fattr_init(&hdr->fattr); 602 } 603 604 /** 605 * nfs_pgio_prepare - Prepare pageio hdr to go over the wire 606 * @task: The current task 607 * @calldata: pageio header to prepare 608 */ 609 static void nfs_pgio_prepare(struct rpc_task *task, void *calldata) 610 { 611 struct nfs_pgio_header *hdr = calldata; 612 int err; 613 err = NFS_PROTO(hdr->inode)->pgio_rpc_prepare(task, hdr); 614 if (err) 615 rpc_exit(task, err); 616 } 617 618 int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr, 619 struct rpc_cred *cred, const struct nfs_rpc_ops *rpc_ops, 620 const struct rpc_call_ops *call_ops, int how, int flags) 621 { 622 struct rpc_task *task; 623 struct rpc_message msg = { 624 .rpc_argp = &hdr->args, 625 .rpc_resp = &hdr->res, 626 .rpc_cred = cred, 627 }; 628 struct rpc_task_setup task_setup_data = { 629 .rpc_client = clnt, 630 .task = &hdr->task, 631 .rpc_message = &msg, 632 .callback_ops = call_ops, 633 .callback_data = hdr, 634 .workqueue = nfsiod_workqueue, 635 .flags = RPC_TASK_ASYNC | flags, 636 }; 637 int ret = 0; 638 639 hdr->rw_ops->rw_initiate(hdr, &msg, rpc_ops, &task_setup_data, how); 640 641 dprintk("NFS: initiated pgio call " 642 "(req %s/%llu, %u bytes @ offset %llu)\n", 643 hdr->inode->i_sb->s_id, 644 (unsigned long long)NFS_FILEID(hdr->inode), 645 hdr->args.count, 646 (unsigned long long)hdr->args.offset); 647 648 task = rpc_run_task(&task_setup_data); 649 if (IS_ERR(task)) { 650 ret = PTR_ERR(task); 651 goto out; 652 } 653 if (how & FLUSH_SYNC) { 654 ret = rpc_wait_for_completion_task(task); 655 if (ret == 0) 656 ret = task->tk_status; 657 } 658 rpc_put_task(task); 659 out: 660 return ret; 661 } 662 EXPORT_SYMBOL_GPL(nfs_initiate_pgio); 663 664 /** 665 * nfs_pgio_error - Clean up from a pageio error 666 * @desc: IO descriptor 667 * @hdr: pageio header 668 */ 669 static void nfs_pgio_error(struct nfs_pgio_header *hdr) 670 { 671 set_bit(NFS_IOHDR_REDO, &hdr->flags); 672 nfs_pgio_data_destroy(hdr); 673 hdr->completion_ops->completion(hdr); 674 } 675 676 /** 677 * nfs_pgio_release - Release pageio data 678 * @calldata: The pageio header to release 679 */ 680 static void nfs_pgio_release(void *calldata) 681 { 682 struct nfs_pgio_header *hdr = calldata; 683 nfs_pgio_data_destroy(hdr); 684 hdr->completion_ops->completion(hdr); 685 } 686 687 static void nfs_pageio_mirror_init(struct nfs_pgio_mirror *mirror, 688 unsigned int bsize) 689 { 690 INIT_LIST_HEAD(&mirror->pg_list); 691 mirror->pg_bytes_written = 0; 692 mirror->pg_count = 0; 693 mirror->pg_bsize = bsize; 694 mirror->pg_base = 0; 695 mirror->pg_recoalesce = 0; 696 } 697 698 /** 699 * nfs_pageio_init - initialise a page io descriptor 700 * @desc: pointer to descriptor 701 * @inode: pointer to inode 702 * @pg_ops: pointer to pageio operations 703 * @compl_ops: pointer to pageio completion operations 704 * @rw_ops: pointer to nfs read/write operations 705 * @bsize: io block size 706 * @io_flags: extra parameters for the io function 707 */ 708 void nfs_pageio_init(struct nfs_pageio_descriptor *desc, 709 struct inode *inode, 710 const struct nfs_pageio_ops *pg_ops, 711 const struct nfs_pgio_completion_ops *compl_ops, 712 const struct nfs_rw_ops *rw_ops, 713 size_t bsize, 714 int io_flags, 715 gfp_t gfp_flags) 716 { 717 struct nfs_pgio_mirror *new; 718 int i; 719 720 desc->pg_moreio = 0; 721 desc->pg_inode = inode; 722 desc->pg_ops = pg_ops; 723 desc->pg_completion_ops = compl_ops; 724 desc->pg_rw_ops = rw_ops; 725 desc->pg_ioflags = io_flags; 726 desc->pg_error = 0; 727 desc->pg_lseg = NULL; 728 desc->pg_io_completion = NULL; 729 desc->pg_dreq = NULL; 730 desc->pg_bsize = bsize; 731 732 desc->pg_mirror_count = 1; 733 desc->pg_mirror_idx = 0; 734 735 if (pg_ops->pg_get_mirror_count) { 736 /* until we have a request, we don't have an lseg and no 737 * idea how many mirrors there will be */ 738 new = kcalloc(NFS_PAGEIO_DESCRIPTOR_MIRROR_MAX, 739 sizeof(struct nfs_pgio_mirror), gfp_flags); 740 desc->pg_mirrors_dynamic = new; 741 desc->pg_mirrors = new; 742 743 for (i = 0; i < NFS_PAGEIO_DESCRIPTOR_MIRROR_MAX; i++) 744 nfs_pageio_mirror_init(&desc->pg_mirrors[i], bsize); 745 } else { 746 desc->pg_mirrors_dynamic = NULL; 747 desc->pg_mirrors = desc->pg_mirrors_static; 748 nfs_pageio_mirror_init(&desc->pg_mirrors[0], bsize); 749 } 750 } 751 EXPORT_SYMBOL_GPL(nfs_pageio_init); 752 753 /** 754 * nfs_pgio_result - Basic pageio error handling 755 * @task: The task that ran 756 * @calldata: Pageio header to check 757 */ 758 static void nfs_pgio_result(struct rpc_task *task, void *calldata) 759 { 760 struct nfs_pgio_header *hdr = calldata; 761 struct inode *inode = hdr->inode; 762 763 dprintk("NFS: %s: %5u, (status %d)\n", __func__, 764 task->tk_pid, task->tk_status); 765 766 if (hdr->rw_ops->rw_done(task, hdr, inode) != 0) 767 return; 768 if (task->tk_status < 0) 769 nfs_set_pgio_error(hdr, task->tk_status, hdr->args.offset); 770 else 771 hdr->rw_ops->rw_result(task, hdr); 772 } 773 774 /* 775 * Create an RPC task for the given read or write request and kick it. 776 * The page must have been locked by the caller. 777 * 778 * It may happen that the page we're passed is not marked dirty. 779 * This is the case if nfs_updatepage detects a conflicting request 780 * that has been written but not committed. 781 */ 782 int nfs_generic_pgio(struct nfs_pageio_descriptor *desc, 783 struct nfs_pgio_header *hdr) 784 { 785 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 786 787 struct nfs_page *req; 788 struct page **pages, 789 *last_page; 790 struct list_head *head = &mirror->pg_list; 791 struct nfs_commit_info cinfo; 792 struct nfs_page_array *pg_array = &hdr->page_array; 793 unsigned int pagecount, pageused; 794 gfp_t gfp_flags = GFP_KERNEL; 795 796 pagecount = nfs_page_array_len(mirror->pg_base, mirror->pg_count); 797 pg_array->npages = pagecount; 798 799 if (pagecount <= ARRAY_SIZE(pg_array->page_array)) 800 pg_array->pagevec = pg_array->page_array; 801 else { 802 if (hdr->rw_mode == FMODE_WRITE) 803 gfp_flags = GFP_NOIO; 804 pg_array->pagevec = kcalloc(pagecount, sizeof(struct page *), gfp_flags); 805 if (!pg_array->pagevec) { 806 pg_array->npages = 0; 807 nfs_pgio_error(hdr); 808 desc->pg_error = -ENOMEM; 809 return desc->pg_error; 810 } 811 } 812 813 nfs_init_cinfo(&cinfo, desc->pg_inode, desc->pg_dreq); 814 pages = hdr->page_array.pagevec; 815 last_page = NULL; 816 pageused = 0; 817 while (!list_empty(head)) { 818 req = nfs_list_entry(head->next); 819 nfs_list_remove_request(req); 820 nfs_list_add_request(req, &hdr->pages); 821 822 if (!last_page || last_page != req->wb_page) { 823 pageused++; 824 if (pageused > pagecount) 825 break; 826 *pages++ = last_page = req->wb_page; 827 } 828 } 829 if (WARN_ON_ONCE(pageused != pagecount)) { 830 nfs_pgio_error(hdr); 831 desc->pg_error = -EINVAL; 832 return desc->pg_error; 833 } 834 835 if ((desc->pg_ioflags & FLUSH_COND_STABLE) && 836 (desc->pg_moreio || nfs_reqs_to_commit(&cinfo))) 837 desc->pg_ioflags &= ~FLUSH_COND_STABLE; 838 839 /* Set up the argument struct */ 840 nfs_pgio_rpcsetup(hdr, mirror->pg_count, 0, desc->pg_ioflags, &cinfo); 841 desc->pg_rpc_callops = &nfs_pgio_common_ops; 842 return 0; 843 } 844 EXPORT_SYMBOL_GPL(nfs_generic_pgio); 845 846 static int nfs_generic_pg_pgios(struct nfs_pageio_descriptor *desc) 847 { 848 struct nfs_pgio_header *hdr; 849 int ret; 850 851 hdr = nfs_pgio_header_alloc(desc->pg_rw_ops); 852 if (!hdr) { 853 desc->pg_error = -ENOMEM; 854 return desc->pg_error; 855 } 856 nfs_pgheader_init(desc, hdr, nfs_pgio_header_free); 857 ret = nfs_generic_pgio(desc, hdr); 858 if (ret == 0) 859 ret = nfs_initiate_pgio(NFS_CLIENT(hdr->inode), 860 hdr, 861 hdr->cred, 862 NFS_PROTO(hdr->inode), 863 desc->pg_rpc_callops, 864 desc->pg_ioflags, 0); 865 return ret; 866 } 867 868 /* 869 * nfs_pageio_setup_mirroring - determine if mirroring is to be used 870 * by calling the pg_get_mirror_count op 871 */ 872 static int nfs_pageio_setup_mirroring(struct nfs_pageio_descriptor *pgio, 873 struct nfs_page *req) 874 { 875 int mirror_count = 1; 876 877 if (!pgio->pg_ops->pg_get_mirror_count) 878 return 0; 879 880 mirror_count = pgio->pg_ops->pg_get_mirror_count(pgio, req); 881 882 if (pgio->pg_error < 0) 883 return pgio->pg_error; 884 885 if (!mirror_count || mirror_count > NFS_PAGEIO_DESCRIPTOR_MIRROR_MAX) 886 return -EINVAL; 887 888 if (WARN_ON_ONCE(!pgio->pg_mirrors_dynamic)) 889 return -EINVAL; 890 891 pgio->pg_mirror_count = mirror_count; 892 893 return 0; 894 } 895 896 /* 897 * nfs_pageio_stop_mirroring - stop using mirroring (set mirror count to 1) 898 */ 899 void nfs_pageio_stop_mirroring(struct nfs_pageio_descriptor *pgio) 900 { 901 pgio->pg_mirror_count = 1; 902 pgio->pg_mirror_idx = 0; 903 } 904 905 static void nfs_pageio_cleanup_mirroring(struct nfs_pageio_descriptor *pgio) 906 { 907 pgio->pg_mirror_count = 1; 908 pgio->pg_mirror_idx = 0; 909 pgio->pg_mirrors = pgio->pg_mirrors_static; 910 kfree(pgio->pg_mirrors_dynamic); 911 pgio->pg_mirrors_dynamic = NULL; 912 } 913 914 static bool nfs_match_lock_context(const struct nfs_lock_context *l1, 915 const struct nfs_lock_context *l2) 916 { 917 return l1->lockowner == l2->lockowner; 918 } 919 920 /** 921 * nfs_can_coalesce_requests - test two requests for compatibility 922 * @prev: pointer to nfs_page 923 * @req: pointer to nfs_page 924 * 925 * The nfs_page structures 'prev' and 'req' are compared to ensure that the 926 * page data area they describe is contiguous, and that their RPC 927 * credentials, NFSv4 open state, and lockowners are the same. 928 * 929 * Return 'true' if this is the case, else return 'false'. 930 */ 931 static bool nfs_can_coalesce_requests(struct nfs_page *prev, 932 struct nfs_page *req, 933 struct nfs_pageio_descriptor *pgio) 934 { 935 size_t size; 936 struct file_lock_context *flctx; 937 938 if (prev) { 939 if (!nfs_match_open_context(req->wb_context, prev->wb_context)) 940 return false; 941 flctx = d_inode(req->wb_context->dentry)->i_flctx; 942 if (flctx != NULL && 943 !(list_empty_careful(&flctx->flc_posix) && 944 list_empty_careful(&flctx->flc_flock)) && 945 !nfs_match_lock_context(req->wb_lock_context, 946 prev->wb_lock_context)) 947 return false; 948 if (req_offset(req) != req_offset(prev) + prev->wb_bytes) 949 return false; 950 if (req->wb_page == prev->wb_page) { 951 if (req->wb_pgbase != prev->wb_pgbase + prev->wb_bytes) 952 return false; 953 } else { 954 if (req->wb_pgbase != 0 || 955 prev->wb_pgbase + prev->wb_bytes != PAGE_SIZE) 956 return false; 957 } 958 } 959 size = pgio->pg_ops->pg_test(pgio, prev, req); 960 WARN_ON_ONCE(size > req->wb_bytes); 961 if (size && size < req->wb_bytes) 962 req->wb_bytes = size; 963 return size > 0; 964 } 965 966 /** 967 * nfs_pageio_do_add_request - Attempt to coalesce a request into a page list. 968 * @desc: destination io descriptor 969 * @req: request 970 * 971 * Returns true if the request 'req' was successfully coalesced into the 972 * existing list of pages 'desc'. 973 */ 974 static int nfs_pageio_do_add_request(struct nfs_pageio_descriptor *desc, 975 struct nfs_page *req) 976 { 977 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 978 979 struct nfs_page *prev = NULL; 980 981 if (mirror->pg_count != 0) { 982 prev = nfs_list_entry(mirror->pg_list.prev); 983 } else { 984 if (desc->pg_ops->pg_init) 985 desc->pg_ops->pg_init(desc, req); 986 if (desc->pg_error < 0) 987 return 0; 988 mirror->pg_base = req->wb_pgbase; 989 } 990 if (!nfs_can_coalesce_requests(prev, req, desc)) 991 return 0; 992 nfs_list_remove_request(req); 993 nfs_list_add_request(req, &mirror->pg_list); 994 mirror->pg_count += req->wb_bytes; 995 return 1; 996 } 997 998 /* 999 * Helper for nfs_pageio_add_request and nfs_pageio_complete 1000 */ 1001 static void nfs_pageio_doio(struct nfs_pageio_descriptor *desc) 1002 { 1003 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 1004 1005 1006 if (!list_empty(&mirror->pg_list)) { 1007 int error = desc->pg_ops->pg_doio(desc); 1008 if (error < 0) 1009 desc->pg_error = error; 1010 else 1011 mirror->pg_bytes_written += mirror->pg_count; 1012 } 1013 if (list_empty(&mirror->pg_list)) { 1014 mirror->pg_count = 0; 1015 mirror->pg_base = 0; 1016 } 1017 } 1018 1019 /** 1020 * nfs_pageio_add_request - Attempt to coalesce a request into a page list. 1021 * @desc: destination io descriptor 1022 * @req: request 1023 * 1024 * This may split a request into subrequests which are all part of the 1025 * same page group. 1026 * 1027 * Returns true if the request 'req' was successfully coalesced into the 1028 * existing list of pages 'desc'. 1029 */ 1030 static int __nfs_pageio_add_request(struct nfs_pageio_descriptor *desc, 1031 struct nfs_page *req) 1032 { 1033 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 1034 1035 struct nfs_page *subreq; 1036 unsigned int bytes_left = 0; 1037 unsigned int offset, pgbase; 1038 1039 nfs_page_group_lock(req, false); 1040 1041 subreq = req; 1042 bytes_left = subreq->wb_bytes; 1043 offset = subreq->wb_offset; 1044 pgbase = subreq->wb_pgbase; 1045 1046 do { 1047 if (!nfs_pageio_do_add_request(desc, subreq)) { 1048 /* make sure pg_test call(s) did nothing */ 1049 WARN_ON_ONCE(subreq->wb_bytes != bytes_left); 1050 WARN_ON_ONCE(subreq->wb_offset != offset); 1051 WARN_ON_ONCE(subreq->wb_pgbase != pgbase); 1052 1053 nfs_page_group_unlock(req); 1054 desc->pg_moreio = 1; 1055 nfs_pageio_doio(desc); 1056 if (desc->pg_error < 0) 1057 return 0; 1058 if (mirror->pg_recoalesce) 1059 return 0; 1060 /* retry add_request for this subreq */ 1061 nfs_page_group_lock(req, false); 1062 continue; 1063 } 1064 1065 /* check for buggy pg_test call(s) */ 1066 WARN_ON_ONCE(subreq->wb_bytes + subreq->wb_pgbase > PAGE_SIZE); 1067 WARN_ON_ONCE(subreq->wb_bytes > bytes_left); 1068 WARN_ON_ONCE(subreq->wb_bytes == 0); 1069 1070 bytes_left -= subreq->wb_bytes; 1071 offset += subreq->wb_bytes; 1072 pgbase += subreq->wb_bytes; 1073 1074 if (bytes_left) { 1075 subreq = nfs_create_request(req->wb_context, 1076 req->wb_page, 1077 subreq, pgbase, bytes_left); 1078 if (IS_ERR(subreq)) 1079 goto err_ptr; 1080 nfs_lock_request(subreq); 1081 subreq->wb_offset = offset; 1082 subreq->wb_index = req->wb_index; 1083 } 1084 } while (bytes_left > 0); 1085 1086 nfs_page_group_unlock(req); 1087 return 1; 1088 err_ptr: 1089 desc->pg_error = PTR_ERR(subreq); 1090 nfs_page_group_unlock(req); 1091 return 0; 1092 } 1093 1094 static int nfs_do_recoalesce(struct nfs_pageio_descriptor *desc) 1095 { 1096 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 1097 LIST_HEAD(head); 1098 1099 do { 1100 list_splice_init(&mirror->pg_list, &head); 1101 mirror->pg_bytes_written -= mirror->pg_count; 1102 mirror->pg_count = 0; 1103 mirror->pg_base = 0; 1104 mirror->pg_recoalesce = 0; 1105 1106 while (!list_empty(&head)) { 1107 struct nfs_page *req; 1108 1109 req = list_first_entry(&head, struct nfs_page, wb_list); 1110 nfs_list_remove_request(req); 1111 if (__nfs_pageio_add_request(desc, req)) 1112 continue; 1113 if (desc->pg_error < 0) { 1114 list_splice_tail(&head, &mirror->pg_list); 1115 mirror->pg_recoalesce = 1; 1116 return 0; 1117 } 1118 break; 1119 } 1120 } while (mirror->pg_recoalesce); 1121 return 1; 1122 } 1123 1124 static int nfs_pageio_add_request_mirror(struct nfs_pageio_descriptor *desc, 1125 struct nfs_page *req) 1126 { 1127 int ret; 1128 1129 do { 1130 ret = __nfs_pageio_add_request(desc, req); 1131 if (ret) 1132 break; 1133 if (desc->pg_error < 0) 1134 break; 1135 ret = nfs_do_recoalesce(desc); 1136 } while (ret); 1137 1138 return ret; 1139 } 1140 1141 int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc, 1142 struct nfs_page *req) 1143 { 1144 u32 midx; 1145 unsigned int pgbase, offset, bytes; 1146 struct nfs_page *dupreq, *lastreq; 1147 1148 pgbase = req->wb_pgbase; 1149 offset = req->wb_offset; 1150 bytes = req->wb_bytes; 1151 1152 nfs_pageio_setup_mirroring(desc, req); 1153 if (desc->pg_error < 0) 1154 goto out_failed; 1155 1156 for (midx = 0; midx < desc->pg_mirror_count; midx++) { 1157 if (midx) { 1158 nfs_page_group_lock(req, false); 1159 1160 /* find the last request */ 1161 for (lastreq = req->wb_head; 1162 lastreq->wb_this_page != req->wb_head; 1163 lastreq = lastreq->wb_this_page) 1164 ; 1165 1166 dupreq = nfs_create_request(req->wb_context, 1167 req->wb_page, lastreq, pgbase, bytes); 1168 1169 if (IS_ERR(dupreq)) { 1170 nfs_page_group_unlock(req); 1171 desc->pg_error = PTR_ERR(dupreq); 1172 goto out_failed; 1173 } 1174 1175 nfs_lock_request(dupreq); 1176 nfs_page_group_unlock(req); 1177 dupreq->wb_offset = offset; 1178 dupreq->wb_index = req->wb_index; 1179 } else 1180 dupreq = req; 1181 1182 if (nfs_pgio_has_mirroring(desc)) 1183 desc->pg_mirror_idx = midx; 1184 if (!nfs_pageio_add_request_mirror(desc, dupreq)) 1185 goto out_failed; 1186 } 1187 1188 return 1; 1189 1190 out_failed: 1191 /* 1192 * We might have failed before sending any reqs over wire. 1193 * Clean up rest of the reqs in mirror pg_list. 1194 */ 1195 if (desc->pg_error) { 1196 struct nfs_pgio_mirror *mirror; 1197 void (*func)(struct list_head *); 1198 1199 /* remember fatal errors */ 1200 if (nfs_error_is_fatal(desc->pg_error)) 1201 mapping_set_error(desc->pg_inode->i_mapping, 1202 desc->pg_error); 1203 1204 func = desc->pg_completion_ops->error_cleanup; 1205 for (midx = 0; midx < desc->pg_mirror_count; midx++) { 1206 mirror = &desc->pg_mirrors[midx]; 1207 func(&mirror->pg_list); 1208 } 1209 } 1210 return 0; 1211 } 1212 1213 /* 1214 * nfs_pageio_complete_mirror - Complete I/O on the current mirror of an 1215 * nfs_pageio_descriptor 1216 * @desc: pointer to io descriptor 1217 * @mirror_idx: pointer to mirror index 1218 */ 1219 static void nfs_pageio_complete_mirror(struct nfs_pageio_descriptor *desc, 1220 u32 mirror_idx) 1221 { 1222 struct nfs_pgio_mirror *mirror = &desc->pg_mirrors[mirror_idx]; 1223 u32 restore_idx = desc->pg_mirror_idx; 1224 1225 if (nfs_pgio_has_mirroring(desc)) 1226 desc->pg_mirror_idx = mirror_idx; 1227 for (;;) { 1228 nfs_pageio_doio(desc); 1229 if (!mirror->pg_recoalesce) 1230 break; 1231 if (!nfs_do_recoalesce(desc)) 1232 break; 1233 } 1234 desc->pg_mirror_idx = restore_idx; 1235 } 1236 1237 /* 1238 * nfs_pageio_resend - Transfer requests to new descriptor and resend 1239 * @hdr - the pgio header to move request from 1240 * @desc - the pageio descriptor to add requests to 1241 * 1242 * Try to move each request (nfs_page) from @hdr to @desc then attempt 1243 * to send them. 1244 * 1245 * Returns 0 on success and < 0 on error. 1246 */ 1247 int nfs_pageio_resend(struct nfs_pageio_descriptor *desc, 1248 struct nfs_pgio_header *hdr) 1249 { 1250 LIST_HEAD(failed); 1251 1252 desc->pg_io_completion = hdr->io_completion; 1253 desc->pg_dreq = hdr->dreq; 1254 while (!list_empty(&hdr->pages)) { 1255 struct nfs_page *req = nfs_list_entry(hdr->pages.next); 1256 1257 nfs_list_remove_request(req); 1258 if (!nfs_pageio_add_request(desc, req)) 1259 nfs_list_add_request(req, &failed); 1260 } 1261 nfs_pageio_complete(desc); 1262 if (!list_empty(&failed)) { 1263 list_move(&failed, &hdr->pages); 1264 return desc->pg_error < 0 ? desc->pg_error : -EIO; 1265 } 1266 return 0; 1267 } 1268 EXPORT_SYMBOL_GPL(nfs_pageio_resend); 1269 1270 /** 1271 * nfs_pageio_complete - Complete I/O then cleanup an nfs_pageio_descriptor 1272 * @desc: pointer to io descriptor 1273 */ 1274 void nfs_pageio_complete(struct nfs_pageio_descriptor *desc) 1275 { 1276 u32 midx; 1277 1278 for (midx = 0; midx < desc->pg_mirror_count; midx++) 1279 nfs_pageio_complete_mirror(desc, midx); 1280 1281 if (desc->pg_ops->pg_cleanup) 1282 desc->pg_ops->pg_cleanup(desc); 1283 nfs_pageio_cleanup_mirroring(desc); 1284 } 1285 1286 /** 1287 * nfs_pageio_cond_complete - Conditional I/O completion 1288 * @desc: pointer to io descriptor 1289 * @index: page index 1290 * 1291 * It is important to ensure that processes don't try to take locks 1292 * on non-contiguous ranges of pages as that might deadlock. This 1293 * function should be called before attempting to wait on a locked 1294 * nfs_page. It will complete the I/O if the page index 'index' 1295 * is not contiguous with the existing list of pages in 'desc'. 1296 */ 1297 void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc, pgoff_t index) 1298 { 1299 struct nfs_pgio_mirror *mirror; 1300 struct nfs_page *prev; 1301 u32 midx; 1302 1303 for (midx = 0; midx < desc->pg_mirror_count; midx++) { 1304 mirror = &desc->pg_mirrors[midx]; 1305 if (!list_empty(&mirror->pg_list)) { 1306 prev = nfs_list_entry(mirror->pg_list.prev); 1307 if (index != prev->wb_index + 1) { 1308 nfs_pageio_complete(desc); 1309 break; 1310 } 1311 } 1312 } 1313 } 1314 1315 int __init nfs_init_nfspagecache(void) 1316 { 1317 nfs_page_cachep = kmem_cache_create("nfs_page", 1318 sizeof(struct nfs_page), 1319 0, SLAB_HWCACHE_ALIGN, 1320 NULL); 1321 if (nfs_page_cachep == NULL) 1322 return -ENOMEM; 1323 1324 return 0; 1325 } 1326 1327 void nfs_destroy_nfspagecache(void) 1328 { 1329 kmem_cache_destroy(nfs_page_cachep); 1330 } 1331 1332 static const struct rpc_call_ops nfs_pgio_common_ops = { 1333 .rpc_call_prepare = nfs_pgio_prepare, 1334 .rpc_call_done = nfs_pgio_result, 1335 .rpc_release = nfs_pgio_release, 1336 }; 1337 1338 const struct nfs_pageio_ops nfs_pgio_rw_ops = { 1339 .pg_test = nfs_generic_pg_test, 1340 .pg_doio = nfs_generic_pg_pgios, 1341 }; 1342