nfs: merge nfs_pgio_data into _header (d45f60c6) · Commits · 戴 / test

fs/nfs/blocklayout/blocklayout.c

+47 −51

Original line number	Diff line number	Diff line
		@@ -210,8 +210,7 @@ static void bl_end_io_read(struct bio *bio, int err)
		SetPageUptodate(bvec->bv_page);

		if (err) {
		struct nfs_pgio_data *rdata = par->data;
		struct nfs_pgio_header *header = rdata->header;
		struct nfs_pgio_header *header = par->data;

		if (!header->pnfs_error)
		header->pnfs_error = -EIO;
		@@ -224,44 +223,44 @@ static void bl_end_io_read(struct bio *bio, int err)
		static void bl_read_cleanup(struct work_struct *work)
		{
		struct rpc_task *task;
		struct nfs_pgio_data *rdata;
		struct nfs_pgio_header *hdr;
		dprintk("%s enter\n", __func__);
		task = container_of(work, struct rpc_task, u.tk_work);
		rdata = container_of(task, struct nfs_pgio_data, task);
		pnfs_ld_read_done(rdata);
		hdr = container_of(task, struct nfs_pgio_header, task);
		pnfs_ld_read_done(hdr);
		}

		static void
		bl_end_par_io_read(void *data, int unused)
		{
		struct nfs_pgio_data *rdata = data;
		struct nfs_pgio_header *hdr = data;

		rdata->task.tk_status = rdata->header->pnfs_error;
		INIT_WORK(&rdata->task.u.tk_work, bl_read_cleanup);
		schedule_work(&rdata->task.u.tk_work);
		hdr->task.tk_status = hdr->pnfs_error;
		INIT_WORK(&hdr->task.u.tk_work, bl_read_cleanup);
		schedule_work(&hdr->task.u.tk_work);
		}

		static enum pnfs_try_status
		bl_read_pagelist(struct nfs_pgio_data *rdata)
		bl_read_pagelist(struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *header = rdata->header;
		struct nfs_pgio_header *header = hdr;
		int i, hole;
		struct bio *bio = NULL;
		struct pnfs_block_extent be = NULL, cow_read = NULL;
		sector_t isect, extent_length = 0;
		struct parallel_io *par;
		loff_t f_offset = rdata->args.offset;
		size_t bytes_left = rdata->args.count;
		loff_t f_offset = hdr->args.offset;
		size_t bytes_left = hdr->args.count;
		unsigned int pg_offset, pg_len;
		struct page **pages = rdata->args.pages;
		int pg_index = rdata->args.pgbase >> PAGE_CACHE_SHIFT;
		struct page **pages = hdr->args.pages;
		int pg_index = hdr->args.pgbase >> PAGE_CACHE_SHIFT;
		const bool is_dio = (header->dreq != NULL);

		dprintk("%s enter nr_pages %u offset %lld count %u\n", __func__,
		rdata->page_array.npages, f_offset,
		(unsigned int)rdata->args.count);
		hdr->page_array.npages, f_offset,
		(unsigned int)hdr->args.count);

		par = alloc_parallel(rdata);
		par = alloc_parallel(hdr);
		if (!par)
		goto use_mds;
		par->pnfs_callback = bl_end_par_io_read;
		@@ -269,7 +268,7 @@ bl_read_pagelist(struct nfs_pgio_data *rdata)

		isect = (sector_t) (f_offset >> SECTOR_SHIFT);
		/* Code assumes extents are page-aligned */
		for (i = pg_index; i < rdata->page_array.npages; i++) {
		for (i = pg_index; i < hdr->page_array.npages; i++) {
		if (!extent_length) {
		/* We've used up the previous extent */
		bl_put_extent(be);
		@@ -319,7 +318,7 @@ bl_read_pagelist(struct nfs_pgio_data *rdata)

		be_read = (hole && cow_read) ? cow_read : be;
		bio = do_add_page_to_bio(bio,
		rdata->page_array.npages - i,
		hdr->page_array.npages - i,
		READ,
		isect, pages[i], be_read,
		bl_end_io_read, par,
		@@ -334,10 +333,10 @@ bl_read_pagelist(struct nfs_pgio_data *rdata)
		extent_length -= PAGE_CACHE_SECTORS;
		}
		if ((isect << SECTOR_SHIFT) >= header->inode->i_size) {
		rdata->res.eof = 1;
		rdata->res.count = header->inode->i_size - rdata->args.offset;
		hdr->res.eof = 1;
		hdr->res.count = header->inode->i_size - hdr->args.offset;
		} else {
		rdata->res.count = (isect << SECTOR_SHIFT) - rdata->args.offset;
		hdr->res.count = (isect << SECTOR_SHIFT) - hdr->args.offset;
		}
		out:
		bl_put_extent(be);
		@@ -392,8 +391,7 @@ static void bl_end_io_write_zero(struct bio *bio, int err)
		}

		if (unlikely(err)) {
		struct nfs_pgio_data *data = par->data;
		struct nfs_pgio_header *header = data->header;
		struct nfs_pgio_header *header = par->data;

		if (!header->pnfs_error)
		header->pnfs_error = -EIO;
		@@ -407,8 +405,7 @@ static void bl_end_io_write(struct bio *bio, int err)
		{
		struct parallel_io *par = bio->bi_private;
		const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
		struct nfs_pgio_data *data = par->data;
		struct nfs_pgio_header *header = data->header;
		struct nfs_pgio_header *header = par->data;

		if (!uptodate) {
		if (!header->pnfs_error)
		@@ -425,32 +422,32 @@ static void bl_end_io_write(struct bio *bio, int err)
		static void bl_write_cleanup(struct work_struct *work)
		{
		struct rpc_task *task;
		struct nfs_pgio_data *wdata;
		struct nfs_pgio_header *hdr;
		dprintk("%s enter\n", __func__);
		task = container_of(work, struct rpc_task, u.tk_work);
		wdata = container_of(task, struct nfs_pgio_data, task);
		if (likely(!wdata->header->pnfs_error)) {
		hdr = container_of(task, struct nfs_pgio_header, task);
		if (likely(!hdr->pnfs_error)) {
		/* Marks for LAYOUTCOMMIT */
		mark_extents_written(BLK_LSEG2EXT(wdata->header->lseg),
		wdata->args.offset, wdata->args.count);
		mark_extents_written(BLK_LSEG2EXT(hdr->lseg),
		hdr->args.offset, hdr->args.count);
		}
		pnfs_ld_write_done(wdata);
		pnfs_ld_write_done(hdr);
		}

		/* Called when last of bios associated with a bl_write_pagelist call finishes */
		static void bl_end_par_io_write(void *data, int num_se)
		{
		struct nfs_pgio_data *wdata = data;
		struct nfs_pgio_header *hdr = data;

		if (unlikely(wdata->header->pnfs_error)) {
		bl_free_short_extents(&BLK_LSEG2EXT(wdata->header->lseg)->bl_inval,
		if (unlikely(hdr->pnfs_error)) {
		bl_free_short_extents(&BLK_LSEG2EXT(hdr->lseg)->bl_inval,
		num_se);
		}

		wdata->task.tk_status = wdata->header->pnfs_error;
		wdata->writeverf.committed = NFS_FILE_SYNC;
		INIT_WORK(&wdata->task.u.tk_work, bl_write_cleanup);
		schedule_work(&wdata->task.u.tk_work);
		hdr->task.tk_status = hdr->pnfs_error;
		hdr->writeverf.committed = NFS_FILE_SYNC;
		INIT_WORK(&hdr->task.u.tk_work, bl_write_cleanup);
		schedule_work(&hdr->task.u.tk_work);
		}

		/* FIXME STUB - mark intersection of layout and page as bad, so is not
		@@ -675,18 +672,17 @@ check_page:
		}

		static enum pnfs_try_status
		bl_write_pagelist(struct nfs_pgio_data *wdata, int sync)
		bl_write_pagelist(struct nfs_pgio_header *header, int sync)
		{
		struct nfs_pgio_header *header = wdata->header;
		int i, ret, npg_zero, pg_index, last = 0;
		struct bio *bio = NULL;
		struct pnfs_block_extent be = NULL, cow_read = NULL;
		sector_t isect, last_isect = 0, extent_length = 0;
		struct parallel_io *par = NULL;
		loff_t offset = wdata->args.offset;
		size_t count = wdata->args.count;
		loff_t offset = header->args.offset;
		size_t count = header->args.count;
		unsigned int pg_offset, pg_len, saved_len;
		struct page **pages = wdata->args.pages;
		struct page **pages = header->args.pages;
		struct page *page;
		pgoff_t index;
		u64 temp;
		@@ -701,11 +697,11 @@ bl_write_pagelist(struct nfs_pgio_data *wdata, int sync)
		dprintk("pnfsblock nonblock aligned DIO writes. Resend MDS\n");
		goto out_mds;
		}
		/* At this point, wdata->page_aray is a (sequential) list of nfs_pages.
		/* At this point, header->page_aray is a (sequential) list of nfs_pages.
		* We want to write each, and if there is an error set pnfs_error
		* to have it redone using nfs.
		*/
		par = alloc_parallel(wdata);
		par = alloc_parallel(header);
		if (!par)
		goto out_mds;
		par->pnfs_callback = bl_end_par_io_write;
		@@ -792,8 +788,8 @@ next_page:
		bio = bl_submit_bio(WRITE, bio);

		/* Middle pages */
		pg_index = wdata->args.pgbase >> PAGE_CACHE_SHIFT;
		for (i = pg_index; i < wdata->page_array.npages; i++) {
		pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
		for (i = pg_index; i < header->page_array.npages; i++) {
		if (!extent_length) {
		/* We've used up the previous extent */
		bl_put_extent(be);
		@@ -864,7 +860,7 @@ next_page:
		}


		bio = do_add_page_to_bio(bio, wdata->page_array.npages - i,
		bio = do_add_page_to_bio(bio, header->page_array.npages - i,
		WRITE,
		isect, pages[i], be,
		bl_end_io_write, par,
		@@ -893,7 +889,7 @@ next_page:
		}

		write_done:
		wdata->res.count = wdata->args.count;
		header->res.count = header->args.count;
		out:
		bl_put_extent(be);
		bl_put_extent(cow_read);

fs/nfs/direct.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -148,8 +148,8 @@ static void nfs_direct_set_hdr_verf(struct nfs_direct_req *dreq,
		{
		struct nfs_writeverf *verfp;

		verfp = nfs_direct_select_verf(dreq, hdr->data.ds_clp,
		hdr->data.ds_idx);
		verfp = nfs_direct_select_verf(dreq, hdr->ds_clp,
		hdr->ds_idx);
		WARN_ON_ONCE(verfp->committed >= 0);
		memcpy(verfp, &hdr->verf, sizeof(struct nfs_writeverf));
		WARN_ON_ONCE(verfp->committed < 0);
		@@ -169,8 +169,8 @@ static int nfs_direct_set_or_cmp_hdr_verf(struct nfs_direct_req *dreq,
		{
		struct nfs_writeverf *verfp;

		verfp = nfs_direct_select_verf(dreq, hdr->data.ds_clp,
		hdr->data.ds_idx);
		verfp = nfs_direct_select_verf(dreq, hdr->ds_clp,
		hdr->ds_idx);
		if (verfp->committed < 0) {
		nfs_direct_set_hdr_verf(dreq, hdr);
		return 0;

fs/nfs/filelayout/filelayout.c

+81 −89

Original line number	Diff line number	Diff line
		@@ -84,19 +84,18 @@ filelayout_get_dserver_offset(struct pnfs_layout_segment *lseg, loff_t offset)
		BUG();
		}

		static void filelayout_reset_write(struct nfs_pgio_data *data)
		static void filelayout_reset_write(struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *hdr = data->header;
		struct rpc_task *task = &data->task;
		struct rpc_task *task = &hdr->task;

		if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
		dprintk("%s Reset task %5u for i/o through MDS "
		"(req %s/%llu, %u bytes @ offset %llu)\n", __func__,
		data->task.tk_pid,
		hdr->task.tk_pid,
		hdr->inode->i_sb->s_id,
		(unsigned long long)NFS_FILEID(hdr->inode),
		data->args.count,
		(unsigned long long)data->args.offset);
		hdr->args.count,
		(unsigned long long)hdr->args.offset);

		task->tk_status = pnfs_write_done_resend_to_mds(hdr->inode,
		&hdr->pages,
		@@ -105,19 +104,18 @@ static void filelayout_reset_write(struct nfs_pgio_data *data)
		}
		}

		static void filelayout_reset_read(struct nfs_pgio_data *data)
		static void filelayout_reset_read(struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *hdr = data->header;
		struct rpc_task *task = &data->task;
		struct rpc_task *task = &hdr->task;

		if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
		dprintk("%s Reset task %5u for i/o through MDS "
		"(req %s/%llu, %u bytes @ offset %llu)\n", __func__,
		data->task.tk_pid,
		hdr->task.tk_pid,
		hdr->inode->i_sb->s_id,
		(unsigned long long)NFS_FILEID(hdr->inode),
		data->args.count,
		(unsigned long long)data->args.offset);
		hdr->args.count,
		(unsigned long long)hdr->args.offset);

		task->tk_status = pnfs_read_done_resend_to_mds(hdr->inode,
		&hdr->pages,
		@@ -243,18 +241,17 @@ wait_on_recovery:
		/* NFS_PROTO call done callback routines */

		static int filelayout_read_done_cb(struct rpc_task *task,
		struct nfs_pgio_data *data)
		struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *hdr = data->header;
		int err;

		trace_nfs4_pnfs_read(data, task->tk_status);
		err = filelayout_async_handle_error(task, data->args.context->state,
		data->ds_clp, hdr->lseg);
		trace_nfs4_pnfs_read(hdr, task->tk_status);
		err = filelayout_async_handle_error(task, hdr->args.context->state,
		hdr->ds_clp, hdr->lseg);

		switch (err) {
		case -NFS4ERR_RESET_TO_MDS:
		filelayout_reset_read(data);
		filelayout_reset_read(hdr);
		return task->tk_status;
		case -EAGAIN:
		rpc_restart_call_prepare(task);
		@@ -270,15 +267,14 @@ static int filelayout_read_done_cb(struct rpc_task *task,
		* rfc5661 is not clear about which credential should be used.
		*/
		static void
		filelayout_set_layoutcommit(struct nfs_pgio_data *wdata)
		filelayout_set_layoutcommit(struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *hdr = wdata->header;

		if (FILELAYOUT_LSEG(hdr->lseg)->commit_through_mds \|\|
		wdata->res.verf->committed == NFS_FILE_SYNC)
		hdr->res.verf->committed == NFS_FILE_SYNC)
		return;

		pnfs_set_layoutcommit(wdata);
		pnfs_set_layoutcommit(hdr);
		dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
		(unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
		}
		@@ -305,83 +301,82 @@ filelayout_reset_to_mds(struct pnfs_layout_segment *lseg)
		*/
		static void filelayout_read_prepare(struct rpc_task task, void data)
		{
		struct nfs_pgio_data *rdata = data;
		struct nfs_pgio_header *hdr = data;

		if (unlikely(test_bit(NFS_CONTEXT_BAD, &rdata->args.context->flags))) {
		if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
		rpc_exit(task, -EIO);
		return;
		}
		if (filelayout_reset_to_mds(rdata->header->lseg)) {
		if (filelayout_reset_to_mds(hdr->lseg)) {
		dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid);
		filelayout_reset_read(rdata);
		filelayout_reset_read(hdr);
		rpc_exit(task, 0);
		return;
		}
		rdata->pgio_done_cb = filelayout_read_done_cb;
		hdr->pgio_done_cb = filelayout_read_done_cb;

		if (nfs41_setup_sequence(rdata->ds_clp->cl_session,
		&rdata->args.seq_args,
		&rdata->res.seq_res,
		if (nfs41_setup_sequence(hdr->ds_clp->cl_session,
		&hdr->args.seq_args,
		&hdr->res.seq_res,
		task))
		return;
		if (nfs4_set_rw_stateid(&rdata->args.stateid, rdata->args.context,
		rdata->args.lock_context, FMODE_READ) == -EIO)
		if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
		hdr->args.lock_context, FMODE_READ) == -EIO)
		rpc_exit(task, -EIO); /* lost lock, terminate I/O */
		}

		static void filelayout_read_call_done(struct rpc_task task, void data)
		{
		struct nfs_pgio_data *rdata = data;
		struct nfs_pgio_header *hdr = data;

		dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status);

		if (test_bit(NFS_IOHDR_REDO, &rdata->header->flags) &&
		if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
		task->tk_status == 0) {
		nfs41_sequence_done(task, &rdata->res.seq_res);
		nfs41_sequence_done(task, &hdr->res.seq_res);
		return;
		}

		/* Note this may cause RPC to be resent */
		rdata->header->mds_ops->rpc_call_done(task, data);
		hdr->mds_ops->rpc_call_done(task, data);
		}

		static void filelayout_read_count_stats(struct rpc_task task, void data)
		{
		struct nfs_pgio_data *rdata = data;
		struct nfs_pgio_header *hdr = data;

		rpc_count_iostats(task, NFS_SERVER(rdata->header->inode)->client->cl_metrics);
		rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics);
		}

		static void filelayout_read_release(void *data)
		{
		struct nfs_pgio_data *rdata = data;
		struct pnfs_layout_hdr *lo = rdata->header->lseg->pls_layout;
		struct nfs_pgio_header *hdr = data;
		struct pnfs_layout_hdr *lo = hdr->lseg->pls_layout;

		filelayout_fenceme(lo->plh_inode, lo);
		nfs_put_client(rdata->ds_clp);
		rdata->header->mds_ops->rpc_release(data);
		nfs_put_client(hdr->ds_clp);
		hdr->mds_ops->rpc_release(data);
		}

		static int filelayout_write_done_cb(struct rpc_task *task,
		struct nfs_pgio_data *data)
		struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *hdr = data->header;
		int err;

		trace_nfs4_pnfs_write(data, task->tk_status);
		err = filelayout_async_handle_error(task, data->args.context->state,
		data->ds_clp, hdr->lseg);
		trace_nfs4_pnfs_write(hdr, task->tk_status);
		err = filelayout_async_handle_error(task, hdr->args.context->state,
		hdr->ds_clp, hdr->lseg);

		switch (err) {
		case -NFS4ERR_RESET_TO_MDS:
		filelayout_reset_write(data);
		filelayout_reset_write(hdr);
		return task->tk_status;
		case -EAGAIN:
		rpc_restart_call_prepare(task);
		return -EAGAIN;
		}

		filelayout_set_layoutcommit(data);
		filelayout_set_layoutcommit(hdr);
		return 0;
		}

		@@ -419,57 +414,57 @@ static int filelayout_commit_done_cb(struct rpc_task *task,

		static void filelayout_write_prepare(struct rpc_task task, void data)
		{
		struct nfs_pgio_data *wdata = data;
		struct nfs_pgio_header *hdr = data;

		if (unlikely(test_bit(NFS_CONTEXT_BAD, &wdata->args.context->flags))) {
		if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
		rpc_exit(task, -EIO);
		return;
		}
		if (filelayout_reset_to_mds(wdata->header->lseg)) {
		if (filelayout_reset_to_mds(hdr->lseg)) {
		dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid);
		filelayout_reset_write(wdata);
		filelayout_reset_write(hdr);
		rpc_exit(task, 0);
		return;
		}
		if (nfs41_setup_sequence(wdata->ds_clp->cl_session,
		&wdata->args.seq_args,
		&wdata->res.seq_res,
		if (nfs41_setup_sequence(hdr->ds_clp->cl_session,
		&hdr->args.seq_args,
		&hdr->res.seq_res,
		task))
		return;
		if (nfs4_set_rw_stateid(&wdata->args.stateid, wdata->args.context,
		wdata->args.lock_context, FMODE_WRITE) == -EIO)
		if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
		hdr->args.lock_context, FMODE_WRITE) == -EIO)
		rpc_exit(task, -EIO); /* lost lock, terminate I/O */
		}

		static void filelayout_write_call_done(struct rpc_task task, void data)
		{
		struct nfs_pgio_data *wdata = data;
		struct nfs_pgio_header *hdr = data;

		if (test_bit(NFS_IOHDR_REDO, &wdata->header->flags) &&
		if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
		task->tk_status == 0) {
		nfs41_sequence_done(task, &wdata->res.seq_res);
		nfs41_sequence_done(task, &hdr->res.seq_res);
		return;
		}

		/* Note this may cause RPC to be resent */
		wdata->header->mds_ops->rpc_call_done(task, data);
		hdr->mds_ops->rpc_call_done(task, data);
		}

		static void filelayout_write_count_stats(struct rpc_task task, void data)
		{
		struct nfs_pgio_data *wdata = data;
		struct nfs_pgio_header *hdr = data;

		rpc_count_iostats(task, NFS_SERVER(wdata->header->inode)->client->cl_metrics);
		rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics);
		}

		static void filelayout_write_release(void *data)
		{
		struct nfs_pgio_data *wdata = data;
		struct pnfs_layout_hdr *lo = wdata->header->lseg->pls_layout;
		struct nfs_pgio_header *hdr = data;
		struct pnfs_layout_hdr *lo = hdr->lseg->pls_layout;

		filelayout_fenceme(lo->plh_inode, lo);
		nfs_put_client(wdata->ds_clp);
		wdata->header->mds_ops->rpc_release(data);
		nfs_put_client(hdr->ds_clp);
		hdr->mds_ops->rpc_release(data);
		}

		static void filelayout_commit_prepare(struct rpc_task task, void data)
		@@ -529,19 +524,18 @@ static const struct rpc_call_ops filelayout_commit_call_ops = {
		};

		static enum pnfs_try_status
		filelayout_read_pagelist(struct nfs_pgio_data *data)
		filelayout_read_pagelist(struct nfs_pgio_header *hdr)
		{
		struct nfs_pgio_header *hdr = data->header;
		struct pnfs_layout_segment *lseg = hdr->lseg;
		struct nfs4_pnfs_ds *ds;
		struct rpc_clnt *ds_clnt;
		loff_t offset = data->args.offset;
		loff_t offset = hdr->args.offset;
		u32 j, idx;
		struct nfs_fh *fh;

		dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n",
		__func__, hdr->inode->i_ino,
		data->args.pgbase, (size_t)data->args.count, offset);
		hdr->args.pgbase, (size_t)hdr->args.count, offset);

		/* Retrieve the correct rpc_client for the byte range */
		j = nfs4_fl_calc_j_index(lseg, offset);
		@@ -559,30 +553,29 @@ filelayout_read_pagelist(struct nfs_pgio_data *data)

		/* No multipath support. Use first DS */
		atomic_inc(&ds->ds_clp->cl_count);
		data->ds_clp = ds->ds_clp;
		data->ds_idx = idx;
		hdr->ds_clp = ds->ds_clp;
		hdr->ds_idx = idx;
		fh = nfs4_fl_select_ds_fh(lseg, j);
		if (fh)
		data->args.fh = fh;
		hdr->args.fh = fh;

		data->args.offset = filelayout_get_dserver_offset(lseg, offset);
		data->mds_offset = offset;
		hdr->args.offset = filelayout_get_dserver_offset(lseg, offset);
		hdr->mds_offset = offset;

		/* Perform an asynchronous read to ds */
		nfs_initiate_pgio(ds_clnt, data,
		nfs_initiate_pgio(ds_clnt, hdr,
		&filelayout_read_call_ops, 0, RPC_TASK_SOFTCONN);
		return PNFS_ATTEMPTED;
		}

		/* Perform async writes. */
		static enum pnfs_try_status
		filelayout_write_pagelist(struct nfs_pgio_data *data, int sync)
		filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync)
		{
		struct nfs_pgio_header *hdr = data->header;
		struct pnfs_layout_segment *lseg = hdr->lseg;
		struct nfs4_pnfs_ds *ds;
		struct rpc_clnt *ds_clnt;
		loff_t offset = data->args.offset;
		loff_t offset = hdr->args.offset;
		u32 j, idx;
		struct nfs_fh *fh;

		@@ -598,21 +591,20 @@ filelayout_write_pagelist(struct nfs_pgio_data *data, int sync)
		return PNFS_NOT_ATTEMPTED;

		dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s cl_count %d\n",
		__func__, hdr->inode->i_ino, sync, (size_t) data->args.count,
		__func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count,
		offset, ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count));

		data->pgio_done_cb = filelayout_write_done_cb;
		hdr->pgio_done_cb = filelayout_write_done_cb;
		atomic_inc(&ds->ds_clp->cl_count);
		data->ds_clp = ds->ds_clp;
		data->ds_idx = idx;
		hdr->ds_clp = ds->ds_clp;
		hdr->ds_idx = idx;
		fh = nfs4_fl_select_ds_fh(lseg, j);
		if (fh)
		data->args.fh = fh;

		data->args.offset = filelayout_get_dserver_offset(lseg, offset);
		hdr->args.fh = fh;
		hdr->args.offset = filelayout_get_dserver_offset(lseg, offset);

		/* Perform an asynchronous write */
		nfs_initiate_pgio(ds_clnt, data,
		nfs_initiate_pgio(ds_clnt, hdr,
		&filelayout_write_call_ops, sync,
		RPC_TASK_SOFTCONN);
		return PNFS_ATTEMPTED;

fs/nfs/internal.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -240,9 +240,9 @@ int nfs_iocounter_wait(struct nfs_io_counter *c);
		extern const struct nfs_pageio_ops nfs_pgio_rw_ops;
		struct nfs_pgio_header nfs_pgio_header_alloc(const struct nfs_rw_ops );
		void nfs_pgio_header_free(struct nfs_pgio_header *);
		void nfs_pgio_data_destroy(struct nfs_pgio_data *);
		void nfs_pgio_data_destroy(struct nfs_pgio_header *);
		int nfs_generic_pgio(struct nfs_pageio_descriptor , struct nfs_pgio_header );
		int nfs_initiate_pgio(struct rpc_clnt , struct nfs_pgio_data ,
		int nfs_initiate_pgio(struct rpc_clnt , struct nfs_pgio_header ,
		const struct rpc_call_ops *, int, int);

		static inline void nfs_iocounter_init(struct nfs_io_counter *c)
		@@ -481,7 +481,7 @@ static inline void nfs_inode_dio_wait(struct inode *inode)
		extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);

		/* nfs4proc.c */
		extern void __nfs4_read_done_cb(struct nfs_pgio_data *);
		extern void __nfs4_read_done_cb(struct nfs_pgio_header *);
		extern struct nfs_client nfs4_init_client(struct nfs_client clp,
		const struct rpc_timeout *timeparms,
		const char *ip_addr);

fs/nfs/nfs3proc.c

+12 −9

Original line number	Diff line number	Diff line
		@@ -795,41 +795,44 @@ nfs3_proc_pathconf(struct nfs_server server, struct nfs_fh fhandle,
		return status;
		}

		static int nfs3_read_done(struct rpc_task task, struct nfs_pgio_data data)
		static int nfs3_read_done(struct rpc_task task, struct nfs_pgio_header hdr)
		{
		struct inode *inode = data->header->inode;
		struct inode *inode = hdr->inode;

		if (nfs3_async_handle_jukebox(task, inode))
		return -EAGAIN;

		nfs_invalidate_atime(inode);
		nfs_refresh_inode(inode, &data->fattr);
		nfs_refresh_inode(inode, &hdr->fattr);
		return 0;
		}

		static void nfs3_proc_read_setup(struct nfs_pgio_data data, struct rpc_message msg)
		static void nfs3_proc_read_setup(struct nfs_pgio_header *hdr,
		struct rpc_message *msg)
		{
		msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
		}

		static int nfs3_proc_pgio_rpc_prepare(struct rpc_task task, struct nfs_pgio_data data)
		static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task,
		struct nfs_pgio_header *hdr)
		{
		rpc_call_start(task);
		return 0;
		}

		static int nfs3_write_done(struct rpc_task task, struct nfs_pgio_data data)
		static int nfs3_write_done(struct rpc_task task, struct nfs_pgio_header hdr)
		{
		struct inode *inode = data->header->inode;
		struct inode *inode = hdr->inode;

		if (nfs3_async_handle_jukebox(task, inode))
		return -EAGAIN;
		if (task->tk_status >= 0)
		nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
		nfs_post_op_update_inode_force_wcc(inode, hdr->res.fattr);
		return 0;
		}

		static void nfs3_proc_write_setup(struct nfs_pgio_data data, struct rpc_message msg)
		static void nfs3_proc_write_setup(struct nfs_pgio_header *hdr,
		struct rpc_message *msg)
		{
		msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
		}

Admin message