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