[net-next-2.6.git] / fs / 9p / fcall.c

/*
 *  linux/fs/9p/fcall.c
 *
 *  This file contains functions to perform synchronous 9P calls
 *
 *  Copyright (C) 2004 by Latchesar Ionkov <lucho@ionkov.net>
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  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, id;
	struct v9fs_session_info *v9ses;

	id = 0;
	fid = tc->params.tclunk.fid;
	if (rc)
		id = rc->id;

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

/**
 * 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;
}

#if 0
/**
 * v9fs_v9fs_t_flush - flush a pending transaction
 * @v9ses: 9P2000 session information
 * @tag: tag 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;
}
#endif

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