Lines Matching refs:rdata
3350 struct cifs_readdata *rdata;
3352 rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3353 if (rdata != NULL) {
3354 rdata->pages = pages;
3355 kref_init(&rdata->refcount);
3356 INIT_LIST_HEAD(&rdata->list);
3357 init_completion(&rdata->done);
3358 INIT_WORK(&rdata->work, complete);
3361 return rdata;
3383 struct cifs_readdata *rdata = container_of(refcount,
3386 if (rdata->mr) {
3387 smbd_deregister_mr(rdata->mr);
3388 rdata->mr = NULL;
3391 if (rdata->cfile)
3392 cifsFileInfo_put(rdata->cfile);
3394 kvfree(rdata->pages);
3395 kfree(rdata);
3399 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3411 rdata->pages[i] = page;
3418 put_page(rdata->pages[i]);
3419 rdata->pages[i] = NULL;
3428 struct cifs_readdata *rdata = container_of(refcount,
3432 kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3433 for (i = 0; i < rdata->nr_pages; i++) {
3434 put_page(rdata->pages[i]);
3441 * @rdata: the readdata response with list of pages holding data
3449 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3451 size_t remaining = rdata->got_bytes;
3454 for (i = 0; i < rdata->nr_pages; i++) {
3455 struct page *page = rdata->pages[i];
3478 struct cifs_readdata *rdata = container_of(work,
3481 complete(&rdata->done);
3482 collect_uncached_read_data(rdata->ctx);
3484 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3489 struct cifs_readdata *rdata, struct iov_iter *iter,
3494 unsigned int nr_pages = rdata->nr_pages;
3495 unsigned int page_offset = rdata->page_offset;
3497 rdata->got_bytes = 0;
3498 rdata->tailsz = PAGE_SIZE;
3500 struct page *page = rdata->pages[i];
3502 unsigned int segment_size = rdata->pagesz;
3512 rdata->pages[i] = NULL;
3513 rdata->nr_pages--;
3523 rdata->tailsz = len;
3530 else if (rdata->mr)
3539 rdata->got_bytes += result;
3542 return result != -ECONNABORTED && rdata->got_bytes > 0 ?
3543 rdata->got_bytes : result;
3548 struct cifs_readdata *rdata, unsigned int len)
3550 return uncached_fill_pages(server, rdata, NULL, len);
3555 struct cifs_readdata *rdata,
3558 return uncached_fill_pages(server, rdata, iter, iter->count);
3561 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3571 server = rdata->server;
3574 if (rdata->cfile->invalidHandle) {
3575 rc = cifs_reopen_file(rdata->cfile, true);
3583 * Wait for credits to resend this rdata.
3584 * Note: we are attempting to resend the whole rdata not in
3588 rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3594 if (rsize < rdata->bytes) {
3598 } while (rsize < rdata->bytes);
3599 rdata->credits = credits;
3601 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3603 if (rdata->cfile->invalidHandle)
3607 if (rdata->mr) {
3608 rdata->mr->need_invalidate = true;
3609 smbd_deregister_mr(rdata->mr);
3610 rdata->mr = NULL;
3613 rc = server->ops->async_readv(rdata);
3620 list_add_tail(&rdata->list, rdata_list);
3625 add_credits_and_wake_if(server, &rdata->credits, 0);
3629 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3638 struct cifs_readdata *rdata;
3697 rdata = cifs_readdata_direct_alloc(
3699 if (!rdata) {
3706 rdata->page_offset = start;
3707 rdata->tailsz = npages > 1 ?
3715 rdata = cifs_readdata_alloc(npages,
3717 if (!rdata) {
3723 rc = cifs_read_allocate_pages(rdata, npages);
3725 kvfree(rdata->pages);
3726 kfree(rdata);
3731 rdata->tailsz = PAGE_SIZE;
3734 rdata->server = server;
3735 rdata->cfile = cifsFileInfo_get(open_file);
3736 rdata->nr_pages = npages;
3737 rdata->offset = offset;
3738 rdata->bytes = cur_len;
3739 rdata->pid = pid;
3740 rdata->pagesz = PAGE_SIZE;
3741 rdata->read_into_pages = cifs_uncached_read_into_pages;
3742 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3743 rdata->credits = credits_on_stack;
3744 rdata->ctx = ctx;
3747 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3750 if (rdata->cfile->invalidHandle)
3753 rc = server->ops->async_readv(rdata);
3757 add_credits_and_wake_if(server, &rdata->credits, 0);
3758 kref_put(&rdata->refcount,
3767 list_add_tail(&rdata->list, rdata_list);
3778 struct cifs_readdata *rdata, *tmp;
3795 list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3797 if (!try_wait_for_completion(&rdata->done)) {
3802 if (rdata->result == -EAGAIN) {
3805 unsigned int got_bytes = rdata->got_bytes;
3807 list_del_init(&rdata->list);
3815 if (got_bytes && got_bytes < rdata->bytes) {
3818 rc = cifs_readdata_to_iov(rdata, to);
3820 kref_put(&rdata->refcount,
3828 * Re-use rdata as this is a
3832 rdata,
3836 rdata->offset + got_bytes,
3837 rdata->bytes - got_bytes,
3838 rdata->cfile, cifs_sb,
3841 kref_put(&rdata->refcount,
3848 } else if (rdata->result)
3849 rc = rdata->result;
3851 rc = cifs_readdata_to_iov(rdata, to);
3854 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3857 ctx->total_len += rdata->got_bytes;
3859 list_del_init(&rdata->list);
3860 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
4194 struct cifs_readdata *rdata = container_of(work,
4197 got_bytes = rdata->got_bytes;
4198 for (i = 0; i < rdata->nr_pages; i++) {
4199 struct page *page = rdata->pages[i];
4203 if (rdata->result == 0 ||
4204 (rdata->result == -EAGAIN && got_bytes)) {
4211 if (rdata->result == 0 ||
4212 (rdata->result == -EAGAIN && got_bytes))
4213 cifs_readpage_to_fscache(rdata->mapping->host, page);
4218 rdata->pages[i] = NULL;
4220 kref_put(&rdata->refcount, cifs_readdata_release);
4225 struct cifs_readdata *rdata, struct iov_iter *iter,
4232 unsigned int nr_pages = rdata->nr_pages;
4233 unsigned int page_offset = rdata->page_offset;
4236 eof = CIFS_I(rdata->mapping->host)->server_eof;
4240 rdata->got_bytes = 0;
4241 rdata->tailsz = PAGE_SIZE;
4243 struct page *page = rdata->pages[i];
4244 unsigned int to_read = rdata->pagesz;
4259 n = rdata->tailsz = len;
4276 rdata->pages[i] = NULL;
4277 rdata->nr_pages--;
4284 rdata->pages[i] = NULL;
4285 rdata->nr_pages--;
4293 else if (rdata->mr)
4302 rdata->got_bytes += result;
4305 return result != -ECONNABORTED && rdata->got_bytes > 0 ?
4306 rdata->got_bytes : result;
4311 struct cifs_readdata *rdata, unsigned int len)
4313 return readpages_fill_pages(server, rdata, NULL, len);
4318 struct cifs_readdata *rdata,
4321 return readpages_fill_pages(server, rdata, iter, iter->count);
4431 * the rdata->pages, then we want them in increasing order.
4437 struct cifs_readdata *rdata;
4474 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4475 if (!rdata) {
4488 rdata->cfile = cifsFileInfo_get(open_file);
4489 rdata->server = server;
4490 rdata->mapping = mapping;
4491 rdata->offset = offset;
4492 rdata->bytes = bytes;
4493 rdata->pid = pid;
4494 rdata->pagesz = PAGE_SIZE;
4495 rdata->tailsz = PAGE_SIZE;
4496 rdata->read_into_pages = cifs_readpages_read_into_pages;
4497 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4498 rdata->credits = credits_on_stack;
4502 rdata->pages[rdata->nr_pages++] = page;
4505 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4508 if (rdata->cfile->invalidHandle)
4511 rc = server->ops->async_readv(rdata);
4515 add_credits_and_wake_if(server, &rdata->credits, 0);
4516 for (i = 0; i < rdata->nr_pages; i++) {
4517 page = rdata->pages[i];
4523 kref_put(&rdata->refcount, cifs_readdata_release);
4527 kref_put(&rdata->refcount, cifs_readdata_release);