[linux.git] / fs / 9p / 9p.c

/*
 *  linux/fs/9p/9p.c
 *
 *  This file contains functions to perform synchronous 9P calls
 *
 *  Copyright (C) 2004 by Latchesar Ionkov <[email protected]>
 *  Copyright (C) 2004 by Eric Van Hensbergen <[email protected]>
 *  Copyright (C) 2002 by Ron Minnich <[email protected]>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/idr.h>

#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
#include "mux.h"

/**
 * v9fs_t_version - negotiate protocol parameters with sever
 * @v9ses: 9P2000 session information
 * @msize: requested max size packet
 * @version: requested version.extension string
 * @fcall: pointer to response fcall pointer
 *
 */

int
v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
	       char *version, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
	tc = v9fs_create_tversion(msize, version);

	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_attach - mount the server
 * @v9ses: 9P2000 session information
 * @uname: user name doing the attach
 * @aname: remote name being attached to
 * @fid: mount fid to attatch to root node
 * @afid: authentication fid (in this case result key)
 * @fcall: pointer to response fcall pointer
 *
 */

int
v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
	      u32 fid, u32 afid, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall* tc;

	dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
		aname, fid, afid);

	tc = v9fs_create_tattach(fid, afid, uname, aname);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

static void v9fs_t_clunk_cb(void *a, struct v9fs_fcall *tc,
	struct v9fs_fcall *rc, int err)
{
	int fid;
	struct v9fs_session_info *v9ses;

	if (err)
		return;

	fid = tc->params.tclunk.fid;
	kfree(tc);

	if (!rc)
		return;

	v9ses = a;
	if (rc->id == RCLUNK)
		v9fs_put_idpool(fid, &v9ses->fidpool);

	kfree(rc);
}

/**
 * v9fs_t_clunk - release a fid (finish a transaction)
 * @v9ses: 9P2000 session information
 * @fid: fid to release
 * @fcall: pointer to response fcall pointer
 *
 */

int
v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
{
	int ret;
	struct v9fs_fcall *tc, *rc;

	dprintk(DEBUG_9P, "fid %d\n", fid);

	rc = NULL;
	tc = v9fs_create_tclunk(fid);
	if (!IS_ERR(tc))
		ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
	else
		ret = PTR_ERR(tc);

	if (ret)
		dprintk(DEBUG_ERROR, "failed fid %d err %d\n", fid, ret);

	v9fs_t_clunk_cb(v9ses, tc, rc, ret);
	return ret;
}

/**
 * v9fs_v9fs_t_flush - flush a pending transaction
 * @v9ses: 9P2000 session information
 * @tag: tid to release
 *
 */

int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "oldtag %d\n", oldtag);

	tc = v9fs_create_tflush(oldtag);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, NULL);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_stat - read a file's meta-data
 * @v9ses: 9P2000 session information
 * @fid: fid pointing to file or directory to get info about
 * @fcall: pointer to response fcall
 *
 */

int
v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "fid %d\n", fid);

	ret = -ENOMEM;
	tc = v9fs_create_tstat(fid);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_wstat - write a file's meta-data
 * @v9ses: 9P2000 session information
 * @fid: fid pointing to file or directory to write info about
 * @stat: metadata
 * @fcall: pointer to response fcall
 *
 */

int
v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
	     struct v9fs_wstat *wstat, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "fid %d\n", fid);

	tc = v9fs_create_twstat(fid, wstat, v9ses->extended);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_walk - walk a fid to a new file or directory
 * @v9ses: 9P2000 session information
 * @fid: fid to walk
 * @newfid: new fid (for clone operations)
 * @name: path to walk fid to
 * @fcall: pointer to response fcall
 *
 */

/* TODO: support multiple walk */

int
v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
	    char *name, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;
	int nwname;

	dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);

	if (name)
		nwname = 1;
	else
		nwname = 0;

	tc = v9fs_create_twalk(fid, newfid, nwname, &name);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_open - open a file
 *
 * @v9ses - 9P2000 session information
 * @fid - fid to open
 * @mode - mode to open file (R, RW, etc)
 * @fcall - pointer to response fcall
 *
 */

int
v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
	    struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);

	tc = v9fs_create_topen(fid, mode);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_remove - remove a file or directory
 * @v9ses: 9P2000 session information
 * @fid: fid to remove
 * @fcall: pointer to response fcall
 *
 */

int
v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
	      struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "fid %d\n", fid);

	tc = v9fs_create_tremove(fid);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_create - create a file or directory
 * @v9ses: 9P2000 session information
 * @fid: fid to create
 * @name: name of the file or directory to create
 * @perm: permissions to create with
 * @mode: mode to open file (R, RW, etc)
 * @fcall: pointer to response fcall
 *
 */

int
v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
	      u32 perm, u8 mode, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc;

	dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
		fid, name, perm, mode);

	tc = v9fs_create_tcreate(fid, name, perm, mode);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_read - read data
 * @v9ses: 9P2000 session information
 * @fid: fid to read from
 * @offset: offset to start read at
 * @count: how many bytes to read
 * @fcall: pointer to response fcall (with data)
 *
 */

int
v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
	    u32 count, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc, *rc;

	dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
		(long long unsigned) offset, count);

	tc = v9fs_create_tread(fid, offset, count);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
		if (!ret)
			ret = rc->params.rread.count;
		if (rcp)
			*rcp = rc;
		else
			kfree(rc);

		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}

/**
 * v9fs_t_write - write data
 * @v9ses: 9P2000 session information
 * @fid: fid to write to
 * @offset: offset to start write at
 * @count: how many bytes to write
 * @fcall: pointer to response fcall
 *
 */

int
v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
	const char __user *data, struct v9fs_fcall **rcp)
{
	int ret;
	struct v9fs_fcall *tc, *rc;

	dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
		(long long unsigned) offset, count);

	tc = v9fs_create_twrite(fid, offset, count, data);
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);

		if (!ret)
			ret = rc->params.rwrite.count;
		if (rcp)
			*rcp = rc;
		else
			kfree(rc);

		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
}
Commit	Line	Data
b8cf945b EVH	1	/*
	2	* linux/fs/9p/9p.c
	3	*
531b1094	4	* This file contains functions to perform synchronous 9P calls
b8cf945b	5	*
531b1094	6	* Copyright (C) 2004 by Latchesar Ionkov <[email protected]>
b8cf945b EVH	7	* Copyright (C) 2004 by Eric Van Hensbergen <[email protected]>
	8	* Copyright (C) 2002 by Ron Minnich <[email protected]>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to:
	22	* Free Software Foundation
	23	* 51 Franklin Street, Fifth Floor
	24	* Boston, MA 02111-1301 USA
	25	*
	26	*/
	27
	28	#include <linux/config.h>
	29	#include <linux/module.h>
	30	#include <linux/errno.h>
	31	#include <linux/fs.h>
	32	#include <linux/idr.h>
	33
	34	#include "debug.h"
	35	#include "v9fs.h"
	36	#include "9p.h"
531b1094	37	#include "conv.h"
b8cf945b EVH	38	#include "mux.h"
	39
	40	/**
	41	* v9fs_t_version - negotiate protocol parameters with sever
	42	* @v9ses: 9P2000 session information
	43	* @msize: requested max size packet
	44	* @version: requested version.extension string
	45	* @fcall: pointer to response fcall pointer
	46	*
	47	*/
	48
	49	int
	50	v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
531b1094	51	char version, struct v9fs_fcall *rcp)
b8cf945b	52	{
531b1094 LI	53	int ret;
531b1094 LI	54	struct v9fs_fcall *tc;
b8cf945b EVH	55
b8cf945b EVH	56	dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
531b1094	57	tc = v9fs_create_tversion(msize, version);
b8cf945b	58
531b1094 LI	59	if (!IS_ERR(tc)) {
	60	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	61	kfree(tc);
	62	} else
	63	ret = PTR_ERR(tc);
	64
	65	return ret;
b8cf945b EVH	66	}
	67
	68	/**
	69	* v9fs_t_attach - mount the server
	70	* @v9ses: 9P2000 session information
	71	* @uname: user name doing the attach
	72	* @aname: remote name being attached to
	73	* @fid: mount fid to attatch to root node
	74	* @afid: authentication fid (in this case result key)
	75	* @fcall: pointer to response fcall pointer
	76	*
	77	*/
	78
	79	int
	80	v9fs_t_attach(struct v9fs_session_info v9ses, char uname, char *aname,
531b1094	81	u32 fid, u32 afid, struct v9fs_fcall **rcp)
b8cf945b	82	{
531b1094 LI	83	int ret;
531b1094 LI	84	struct v9fs_fcall* tc;
b8cf945b EVH	85
	86	dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
	87	aname, fid, afid);
b8cf945b	88
531b1094 LI	89	tc = v9fs_create_tattach(fid, afid, uname, aname);
	90	if (!IS_ERR(tc)) {
	91	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	92	kfree(tc);
	93	} else
	94	ret = PTR_ERR(tc);
	95
	96	return ret;
3cf6429a LI	97	}
	98
	99	static void v9fs_t_clunk_cb(void a, struct v9fs_fcall tc,
	100	struct v9fs_fcall *rc, int err)
	101	{
	102	int fid;
	103	struct v9fs_session_info *v9ses;
	104
	105	if (err)
	106	return;
	107
	108	fid = tc->params.tclunk.fid;
	109	kfree(tc);
	110
	111	if (!rc)
	112	return;
	113
3cf6429a LI	114	v9ses = a;
	115	if (rc->id == RCLUNK)
	116	v9fs_put_idpool(fid, &v9ses->fidpool);
	117
	118	kfree(rc);
b8cf945b EVH	119	}
	120
	121	/**
	122	* v9fs_t_clunk - release a fid (finish a transaction)
	123	* @v9ses: 9P2000 session information
	124	* @fid: fid to release
	125	* @fcall: pointer to response fcall pointer
	126	*
	127	*/
531b1094	128
b8cf945b	129	int
3cf6429a	130	v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
b8cf945b	131	{
531b1094	132	int ret;
3cf6429a LI	133	struct v9fs_fcall tc, rc;
3cf6429a LI	134
b8cf945b	135	dprintk(DEBUG_9P, "fid %d\n", fid);
b8cf945b	136
531b1094 LI	137	rc = NULL;
	138	tc = v9fs_create_tclunk(fid);
	139	if (!IS_ERR(tc))
	140	ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
	141	else
	142	ret = PTR_ERR(tc);
	143
	144	if (ret)
	145	dprintk(DEBUG_ERROR, "failed fid %d err %d\n", fid, ret);
3cf6429a	146
531b1094 LI	147	v9fs_t_clunk_cb(v9ses, tc, rc, ret);
531b1094 LI	148	return ret;
b8cf945b EVH	149	}
	150
	151	/**
	152	* v9fs_v9fs_t_flush - flush a pending transaction
	153	* @v9ses: 9P2000 session information
	154	* @tag: tid to release
	155	*
	156	*/
	157
531b1094	158	int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
b8cf945b	159	{
531b1094 LI	160	int ret;
531b1094 LI	161	struct v9fs_fcall *tc;
b8cf945b	162
531b1094 LI	163	dprintk(DEBUG_9P, "oldtag %d\n", oldtag);
531b1094 LI	164
531b1094 LI	165	tc = v9fs_create_tflush(oldtag);
	166	if (!IS_ERR(tc)) {
	167	ret = v9fs_mux_rpc(v9ses->mux, tc, NULL);
	168	kfree(tc);
	169	} else
	170	ret = PTR_ERR(tc);
	171
	172	return ret;
b8cf945b EVH	173	}
	174
	175	/**
	176	* v9fs_t_stat - read a file's meta-data
	177	* @v9ses: 9P2000 session information
	178	* @fid: fid pointing to file or directory to get info about
	179	* @fcall: pointer to response fcall
	180	*
	181	*/
	182
	183	int
531b1094	184	v9fs_t_stat(struct v9fs_session_info v9ses, u32 fid, struct v9fs_fcall *rcp)
b8cf945b	185	{
531b1094 LI	186	int ret;
531b1094 LI	187	struct v9fs_fcall *tc;
b8cf945b EVH	188
b8cf945b EVH	189	dprintk(DEBUG_9P, "fid %d\n", fid);
b8cf945b	190
531b1094 LI	191	ret = -ENOMEM;
	192	tc = v9fs_create_tstat(fid);
	193	if (!IS_ERR(tc)) {
	194	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	195	kfree(tc);
	196	} else
	197	ret = PTR_ERR(tc);
	198
	199	return ret;
b8cf945b EVH	200	}
	201
	202	/**
	203	* v9fs_t_wstat - write a file's meta-data
	204	* @v9ses: 9P2000 session information
	205	* @fid: fid pointing to file or directory to write info about
	206	* @stat: metadata
	207	* @fcall: pointer to response fcall
	208	*
	209	*/
	210
	211	int
	212	v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
531b1094	213	struct v9fs_wstat wstat, struct v9fs_fcall *rcp)
b8cf945b	214	{
531b1094 LI	215	int ret;
531b1094 LI	216	struct v9fs_fcall *tc;
b8cf945b	217
531b1094 LI	218	dprintk(DEBUG_9P, "fid %d\n", fid);
531b1094 LI	219
531b1094 LI	220	tc = v9fs_create_twstat(fid, wstat, v9ses->extended);
	221	if (!IS_ERR(tc)) {
	222	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	223	kfree(tc);
	224	} else
	225	ret = PTR_ERR(tc);
b8cf945b	226
531b1094	227	return ret;
b8cf945b EVH	228	}
	229
	230	/**
	231	* v9fs_t_walk - walk a fid to a new file or directory
	232	* @v9ses: 9P2000 session information
	233	* @fid: fid to walk
	234	* @newfid: new fid (for clone operations)
	235	* @name: path to walk fid to
	236	* @fcall: pointer to response fcall
	237	*
	238	*/
	239
	240	/* TODO: support multiple walk */
	241
	242	int
	243	v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
531b1094	244	char name, struct v9fs_fcall *rcp)
b8cf945b	245	{
531b1094 LI	246	int ret;
	247	struct v9fs_fcall *tc;
	248	int nwname;
b8cf945b EVH	249
b8cf945b EVH	250	dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
531b1094 LI	251
	252	if (name)
	253	nwname = 1;
	254	else
	255	nwname = 0;
	256
531b1094 LI	257	tc = v9fs_create_twalk(fid, newfid, nwname, &name);
	258	if (!IS_ERR(tc)) {
	259	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	260	kfree(tc);
	261	} else
	262	ret = PTR_ERR(tc);
	263
	264	return ret;
b8cf945b EVH	265	}
	266
	267	/**
	268	* v9fs_t_open - open a file
	269	*
	270	* @v9ses - 9P2000 session information
	271	* @fid - fid to open
	272	* @mode - mode to open file (R, RW, etc)
	273	* @fcall - pointer to response fcall
	274	*
	275	*/
	276
	277	int
	278	v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
531b1094	279	struct v9fs_fcall **rcp)
b8cf945b	280	{
531b1094 LI	281	int ret;
531b1094 LI	282	struct v9fs_fcall *tc;
b8cf945b EVH	283
b8cf945b EVH	284	dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
b8cf945b	285
531b1094 LI	286	tc = v9fs_create_topen(fid, mode);
	287	if (!IS_ERR(tc)) {
	288	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	289	kfree(tc);
	290	} else
	291	ret = PTR_ERR(tc);
b8cf945b	292
531b1094	293	return ret;
b8cf945b EVH	294	}
	295
	296	/**
	297	* v9fs_t_remove - remove a file or directory
	298	* @v9ses: 9P2000 session information
	299	* @fid: fid to remove
	300	* @fcall: pointer to response fcall
	301	*
	302	*/
	303
	304	int
	305	v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
531b1094	306	struct v9fs_fcall **rcp)
b8cf945b	307	{
531b1094 LI	308	int ret;
531b1094 LI	309	struct v9fs_fcall *tc;
b8cf945b EVH	310
b8cf945b EVH	311	dprintk(DEBUG_9P, "fid %d\n", fid);
531b1094	312
531b1094 LI	313	tc = v9fs_create_tremove(fid);
	314	if (!IS_ERR(tc)) {
	315	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	316	kfree(tc);
	317	} else
	318	ret = PTR_ERR(tc);
	319
	320	return ret;
b8cf945b EVH	321	}
	322
	323	/**
	324	* v9fs_t_create - create a file or directory
	325	* @v9ses: 9P2000 session information
	326	* @fid: fid to create
	327	* @name: name of the file or directory to create
	328	* @perm: permissions to create with
	329	* @mode: mode to open file (R, RW, etc)
	330	* @fcall: pointer to response fcall
	331	*
	332	*/
	333
	334	int
	335	v9fs_t_create(struct v9fs_session_info v9ses, u32 fid, char name,
531b1094	336	u32 perm, u8 mode, struct v9fs_fcall **rcp)
b8cf945b	337	{
531b1094 LI	338	int ret;
531b1094 LI	339	struct v9fs_fcall *tc;
b8cf945b EVH	340
	341	dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
	342	fid, name, perm, mode);
	343
531b1094 LI	344	tc = v9fs_create_tcreate(fid, name, perm, mode);
	345	if (!IS_ERR(tc)) {
	346	ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
	347	kfree(tc);
	348	} else
	349	ret = PTR_ERR(tc);
b8cf945b	350
531b1094	351	return ret;
b8cf945b EVH	352	}
	353
	354	/**
	355	* v9fs_t_read - read data
	356	* @v9ses: 9P2000 session information
	357	* @fid: fid to read from
	358	* @offset: offset to start read at
	359	* @count: how many bytes to read
	360	* @fcall: pointer to response fcall (with data)
	361	*
	362	*/
	363
	364	int
	365	v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
531b1094	366	u32 count, struct v9fs_fcall **rcp)
b8cf945b	367	{
531b1094 LI	368	int ret;
531b1094 LI	369	struct v9fs_fcall tc, rc;
b8cf945b	370
531b1094 LI	371	dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
	372	(long long unsigned) offset, count);
	373
531b1094 LI	374	tc = v9fs_create_tread(fid, offset, count);
	375	if (!IS_ERR(tc)) {
	376	ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
	377	if (!ret)
	378	ret = rc->params.rread.count;
	379	if (rcp)
	380	*rcp = rc;
	381	else
	382	kfree(rc);
	383
	384	kfree(tc);
	385	} else
	386	ret = PTR_ERR(tc);
	387
	388	return ret;
b8cf945b EVH	389	}
	390
	391	/**
	392	* v9fs_t_write - write data
	393	* @v9ses: 9P2000 session information
	394	* @fid: fid to write to
	395	* @offset: offset to start write at
	396	* @count: how many bytes to write
	397	* @fcall: pointer to response fcall
	398	*
	399	*/
	400
	401	int
531b1094 LI	402	v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
531b1094 LI	403	const char __user data, struct v9fs_fcall *rcp)
b8cf945b	404	{
531b1094 LI	405	int ret;
531b1094 LI	406	struct v9fs_fcall tc, rc;
b8cf945b	407
531b1094 LI	408	dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
531b1094 LI	409	(long long unsigned) offset, count);
b8cf945b	410
531b1094 LI	411	tc = v9fs_create_twrite(fid, offset, count, data);
	412	if (!IS_ERR(tc)) {
	413	ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
b8cf945b	414
531b1094 LI	415	if (!ret)
	416	ret = rc->params.rwrite.count;
	417	if (rcp)
	418	*rcp = rc;
	419	else
	420	kfree(rc);
b8cf945b	421
531b1094 LI	422	kfree(tc);
	423	} else
	424	ret = PTR_ERR(tc);
b8cf945b	425
531b1094	426	return ret;
b8cf945b	427	}
531b1094	428