NFSv4.1: layoutcommit (863a3c6c) · Commits · e / devices / android_kernel_teracube_2e

fs/nfs/file.c

+3 −0

Original line number	Diff line number	Diff line
		@@ -326,6 +326,9 @@ nfs_file_fsync(struct file *file, int datasync)
		ret = xchg(&ctx->error, 0);
		if (!ret && status < 0)
		ret = status;
		if (!ret && !datasync)
		/* application has asked for meta-data sync */
		ret = pnfs_layoutcommit_inode(inode, 1);
		return ret;
		}

fs/nfs/nfs4_fs.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -262,6 +262,8 @@ extern int nfs4_proc_destroy_session(struct nfs4_session *);
		extern int nfs4_init_session(struct nfs_server *server);
		extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
		struct nfs_fsinfo *fsinfo);
		extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
		int sync);

		static inline bool
		is_ds_only_client(struct nfs_client *clp)

fs/nfs/nfs4filelayout.c

+18 −0

Original line number	Diff line number	Diff line
		@@ -153,6 +153,23 @@ static int filelayout_read_done_cb(struct rpc_task *task,
		return 0;
		}

		/*
		* We reference the rpc_cred of the first WRITE that triggers the need for
		* a LAYOUTCOMMIT, and use it to send the layoutcommit compound.
		* rfc5661 is not clear about which credential should be used.
		*/
		static void
		filelayout_set_layoutcommit(struct nfs_write_data *wdata)
		{
		if (FILELAYOUT_LSEG(wdata->lseg)->commit_through_mds \|\|
		wdata->res.verf->committed == NFS_FILE_SYNC)
		return;

		pnfs_set_layoutcommit(wdata);
		dprintk("%s ionde %lu pls_end_pos %lu\n", __func__, wdata->inode->i_ino,
		(unsigned long) wdata->lseg->pls_end_pos);
		}

		/*
		* Call ops for the async read/write cases
		* In the case of dense layouts, the offset needs to be reset to its
		@@ -210,6 +227,7 @@ static int filelayout_write_done_cb(struct rpc_task *task,
		return -EAGAIN;
		}

		filelayout_set_layoutcommit(data);
		return 0;
		}

fs/nfs/nfs4proc.c

+94 −0

Original line number	Diff line number	Diff line
		@@ -5616,6 +5616,100 @@ int nfs4_proc_getdeviceinfo(struct nfs_server server, struct pnfs_device pdev)
		}
		EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);

		static void nfs4_layoutcommit_prepare(struct rpc_task task, void calldata)
		{
		struct nfs4_layoutcommit_data *data = calldata;
		struct nfs_server *server = NFS_SERVER(data->args.inode);

		if (nfs4_setup_sequence(server, &data->args.seq_args,
		&data->res.seq_res, 1, task))
		return;
		rpc_call_start(task);
		}

		static void
		nfs4_layoutcommit_done(struct rpc_task task, void calldata)
		{
		struct nfs4_layoutcommit_data *data = calldata;
		struct nfs_server *server = NFS_SERVER(data->args.inode);

		if (!nfs4_sequence_done(task, &data->res.seq_res))
		return;

		switch (task->tk_status) { /* Just ignore these failures */
		case NFS4ERR_DELEG_REVOKED: /* layout was recalled */
		case NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
		case NFS4ERR_BADLAYOUT: /* no layout */
		case NFS4ERR_GRACE: /* loca_recalim always false */
		task->tk_status = 0;
		}

		if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
		nfs_restart_rpc(task, server->nfs_client);
		return;
		}

		if (task->tk_status == 0)
		nfs_post_op_update_inode_force_wcc(data->args.inode,
		data->res.fattr);
		}

		static void nfs4_layoutcommit_release(void *calldata)
		{
		struct nfs4_layoutcommit_data *data = calldata;

		/* Matched by references in pnfs_set_layoutcommit */
		put_lseg(data->lseg);
		put_rpccred(data->cred);
		kfree(data);
		}

		static const struct rpc_call_ops nfs4_layoutcommit_ops = {
		.rpc_call_prepare = nfs4_layoutcommit_prepare,
		.rpc_call_done = nfs4_layoutcommit_done,
		.rpc_release = nfs4_layoutcommit_release,
		};

		int
		nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, int sync)
		{
		struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
		.rpc_argp = &data->args,
		.rpc_resp = &data->res,
		.rpc_cred = data->cred,
		};
		struct rpc_task_setup task_setup_data = {
		.task = &data->task,
		.rpc_client = NFS_CLIENT(data->args.inode),
		.rpc_message = &msg,
		.callback_ops = &nfs4_layoutcommit_ops,
		.callback_data = data,
		.flags = RPC_TASK_ASYNC,
		};
		struct rpc_task *task;
		int status = 0;

		dprintk("NFS: %4d initiating layoutcommit call. sync %d "
		"lbw: %llu inode %lu\n",
		data->task.tk_pid, sync,
		data->args.lastbytewritten,
		data->args.inode->i_ino);

		task = rpc_run_task(&task_setup_data);
		if (IS_ERR(task))
		return PTR_ERR(task);
		if (!sync)
		goto out;
		status = nfs4_wait_for_completion_rpc_task(task);
		if (status != 0)
		goto out;
		status = task->tk_status;
		out:
		dprintk("%s: status %d\n", __func__, status);
		rpc_put_task(task);
		return status;
		}
		#endif /* CONFIG_NFS_V4_1 */

		struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {

fs/nfs/nfs4xdr.c

+129 −0

Original line number	Diff line number	Diff line
		@@ -324,6 +324,18 @@ static int nfs4_stat_to_errno(int);
		#define decode_layoutget_maxsz (op_decode_hdr_maxsz + 8 + \
		decode_stateid_maxsz + \
		XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE))
		#define encode_layoutcommit_maxsz (op_encode_hdr_maxsz + \
		2 /* offset */ + \
		2 /* length */ + \
		1 /* reclaim */ + \
		encode_stateid_maxsz + \
		1 /* new offset (true) */ + \
		2 /* last byte written */ + \
		1 /* nt_timechanged (false) */ + \
		1 /* layoutupdate4 layout type */ + \
		1 /* NULL filelayout layoutupdate4 payload */)
		#define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)

		#else /* CONFIG_NFS_V4_1 */
		#define encode_sequence_maxsz 0
		#define decode_sequence_maxsz 0
		@@ -727,6 +739,17 @@ static int nfs4_stat_to_errno(int);
		decode_sequence_maxsz + \
		decode_putfh_maxsz + \
		decode_layoutget_maxsz)
		#define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
		encode_sequence_maxsz +\
		encode_putfh_maxsz + \
		encode_layoutcommit_maxsz + \
		encode_getattr_maxsz)
		#define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
		decode_sequence_maxsz + \
		decode_putfh_maxsz + \
		decode_layoutcommit_maxsz + \
		decode_getattr_maxsz)


		const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
		compound_encode_hdr_maxsz +
		@@ -1816,6 +1839,34 @@ encode_layoutget(struct xdr_stream *xdr,
		hdr->nops++;
		hdr->replen += decode_layoutget_maxsz;
		}

		static int
		encode_layoutcommit(struct xdr_stream *xdr,
		const struct nfs4_layoutcommit_args *args,
		struct compound_hdr *hdr)
		{
		__be32 *p;

		dprintk("%s: lbw: %llu type: %d\n", __func__, args->lastbytewritten,
		NFS_SERVER(args->inode)->pnfs_curr_ld->id);

		p = reserve_space(xdr, 48 + NFS4_STATEID_SIZE);
		*p++ = cpu_to_be32(OP_LAYOUTCOMMIT);
		/* Only whole file layouts */
		p = xdr_encode_hyper(p, 0); /* offset */
		p = xdr_encode_hyper(p, NFS4_MAX_UINT64); /* length */
		p++ = cpu_to_be32(0); / reclaim */
		p = xdr_encode_opaque_fixed(p, args->stateid.data, NFS4_STATEID_SIZE);
		p++ = cpu_to_be32(1); / newoffset = TRUE */
		p = xdr_encode_hyper(p, args->lastbytewritten);
		p++ = cpu_to_be32(0); / Never send time_modify_changed */
		p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/ type */
		p++ = cpu_to_be32(0); / no file layout payload */

		hdr->nops++;
		hdr->replen += decode_layoutcommit_maxsz;
		return 0;
		}
		#endif /* CONFIG_NFS_V4_1 */

		/*
		@@ -2607,6 +2658,26 @@ static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
		encode_layoutget(xdr, args, &hdr);
		encode_nops(&hdr);
		}

		/*
		* Encode LAYOUTCOMMIT request
		*/
		static int nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
		struct xdr_stream *xdr,
		struct nfs4_layoutcommit_args *args)
		{
		struct compound_hdr hdr = {
		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
		};

		encode_compound_hdr(xdr, req, &hdr);
		encode_sequence(xdr, &args->seq_args, &hdr);
		encode_putfh(xdr, NFS_FH(args->inode), &hdr);
		encode_layoutcommit(xdr, args, &hdr);
		encode_getfattr(xdr, args->bitmask, &hdr);
		encode_nops(&hdr);
		return 0;
		}
		#endif /* CONFIG_NFS_V4_1 */

		static void print_overflow_msg(const char func, const struct xdr_stream xdr)
		@@ -5007,6 +5078,35 @@ static int decode_layoutget(struct xdr_stream xdr, struct rpc_rqst req,
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int decode_layoutcommit(struct xdr_stream *xdr,
		struct rpc_rqst *req,
		struct nfs4_layoutcommit_res *res)
		{
		__be32 *p;
		__u32 sizechanged;
		int status;

		status = decode_op_hdr(xdr, OP_LAYOUTCOMMIT);
		if (status)
		return status;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(!p))
		goto out_overflow;
		sizechanged = be32_to_cpup(p);

		if (sizechanged) {
		/* throw away new size */
		p = xdr_inline_decode(xdr, 8);
		if (unlikely(!p))
		goto out_overflow;
		}
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}
		#endif /* CONFIG_NFS_V4_1 */

		/*
		@@ -6068,6 +6168,34 @@ static int nfs4_xdr_dec_layoutget(struct rpc_rqst *rqstp,
		out:
		return status;
		}

		/*
		* Decode LAYOUTCOMMIT response
		*/
		static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
		struct xdr_stream *xdr,
		struct nfs4_layoutcommit_res *res)
		{
		struct compound_hdr hdr;
		int status;

		status = decode_compound_hdr(xdr, &hdr);
		if (status)
		goto out;
		status = decode_sequence(xdr, &res->seq_res, rqstp);
		if (status)
		goto out;
		status = decode_putfh(xdr);
		if (status)
		goto out;
		status = decode_layoutcommit(xdr, rqstp, res);
		if (status)
		goto out;
		decode_getfattr(xdr, res->fattr, res->server,
		!RPC_IS_ASYNC(rqstp->rq_task));
		out:
		return status;
		}
		#endif /* CONFIG_NFS_V4_1 */

		/**
		@@ -6269,6 +6397,7 @@ struct rpc_procinfo nfs4_procedures[] = {
		PROC(RECLAIM_COMPLETE, enc_reclaim_complete, dec_reclaim_complete),
		PROC(GETDEVICEINFO, enc_getdeviceinfo, dec_getdeviceinfo),
		PROC(LAYOUTGET, enc_layoutget, dec_layoutget),
		PROC(LAYOUTCOMMIT, enc_layoutcommit, dec_layoutcommit),
		#endif /* CONFIG_NFS_V4_1 */
		};