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