[mirror_ubuntu-zesty-kernel.git] / fs / 9p / 9p.c

/*
 *  linux/fs/9p/9p.c
 *
 *  This file contains functions 9P2000 functions
 *
 *  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 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 "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 **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
	msg.id = TVERSION;
	msg.params.tversion.msize = msize;
	msg.params.tversion.version = version;

	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
		aname, fid, afid);
	msg.id = TATTACH;
	msg.params.tattach.fid = fid;
	msg.params.tattach.afid = afid;
	msg.params.tattach.uname = uname;
	msg.params.tattach.aname = aname;

	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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,
	     struct v9fs_fcall **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "fid %d\n", fid);
	msg.id = TCLUNK;
	msg.params.tclunk.fid = fid;

	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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 tag)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "oldtag %d\n", tag);
	msg.id = TFLUSH;
	msg.params.tflush.oldtag = tag;
	return v9fs_mux_rpc(v9ses, &msg, NULL);
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "fid %d\n", fid);
	if (fcall)
		*fcall = NULL;

	msg.id = TSTAT;
	msg.params.tstat.fid = fid;
	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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_stat *stat, struct v9fs_fcall **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "fid %d length %d\n", fid, (int)stat->length);
	msg.id = TWSTAT;
	msg.params.twstat.fid = fid;
	msg.params.twstat.stat = stat;

	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
	msg.id = TWALK;
	msg.params.twalk.fid = fid;
	msg.params.twalk.newfid = newfid;

	if (name) {
		msg.params.twalk.nwname = 1;
		msg.params.twalk.wnames = &name;
	} else {
		msg.params.twalk.nwname = 0;
	}

	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;
	long errorno = -1;

	dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
	msg.id = TOPEN;
	msg.params.topen.fid = fid;
	msg.params.topen.mode = mode;

	errorno = v9fs_mux_rpc(v9ses, &msg, fcall);

	return errorno;
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;

	dprintk(DEBUG_9P, "fid %d\n", fid);
	msg.id = TREMOVE;
	msg.params.tremove.fid = fid;
	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;

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

	msg.id = TCREATE;
	msg.params.tcreate.fid = fid;
	msg.params.tcreate.name = name;
	msg.params.tcreate.perm = perm;
	msg.params.tcreate.mode = mode;

	return v9fs_mux_rpc(v9ses, &msg, fcall);
}

/**
 * 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 **fcall)
{
	struct v9fs_fcall msg;
	struct v9fs_fcall *rc = NULL;
	long errorno = -1;

	dprintk(DEBUG_9P, "fid %d offset 0x%lx count 0x%x\n", fid,
		(long unsigned int)offset, count);
	msg.id = TREAD;
	msg.params.tread.fid = fid;
	msg.params.tread.offset = offset;
	msg.params.tread.count = count;
	errorno = v9fs_mux_rpc(v9ses, &msg, &rc);

	if (!errorno) {
		errorno = rc->params.rread.count;
		dump_data(rc->params.rread.data, rc->params.rread.count);
	}

	if (fcall)
		*fcall = rc;
	else
		kfree(rc);

	return errorno;
}

/**
 * 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, void *data, struct v9fs_fcall **fcall)
{
	struct v9fs_fcall msg;
	struct v9fs_fcall *rc = NULL;
	long errorno = -1;

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

	msg.id = TWRITE;
	msg.params.twrite.fid = fid;
	msg.params.twrite.offset = offset;
	msg.params.twrite.count = count;
	msg.params.twrite.data = data;

	errorno = v9fs_mux_rpc(v9ses, &msg, &rc);

	if (!errorno)
		errorno = rc->params.rwrite.count;

	if (fcall)
		*fcall = rc;
	else
		kfree(rc);

	return errorno;
}
Commit	Line	Data
b8cf945b EVH	1	/*
	2	* linux/fs/9p/9p.c
	3	*
	4	* This file contains functions 9P2000 functions
	5	*
	6	* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
	7	* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	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"
	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,
	49	char version, struct v9fs_fcall *fcall)
	50	{
	51	struct v9fs_fcall msg;
	52
	53	dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
	54	msg.id = TVERSION;
	55	msg.params.tversion.msize = msize;
	56	msg.params.tversion.version = version;
	57
	58	return v9fs_mux_rpc(v9ses, &msg, fcall);
	59	}
	60
	61	/**
	62	* v9fs_t_attach - mount the server
	63	* @v9ses: 9P2000 session information
	64	* @uname: user name doing the attach
65	* @aname: remote name being attached to
66	* @fid: mount fid to attatch to root node
67	* @afid: authentication fid (in this case result key)
68	* @fcall: pointer to response fcall pointer
69	*
70	*/
71
72	int
73	v9fs_t_attach(struct v9fs_session_info v9ses, char uname, char *aname,
74	u32 fid, u32 afid, struct v9fs_fcall **fcall)
75	{
76	struct v9fs_fcall msg;
77
78	dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
79	aname, fid, afid);
80	msg.id = TATTACH;
81	msg.params.tattach.fid = fid;
82	msg.params.tattach.afid = afid;
83	msg.params.tattach.uname = uname;
84	msg.params.tattach.aname = aname;
85
86	return v9fs_mux_rpc(v9ses, &msg, fcall);
87	}
88
89	/**
90	* v9fs_t_clunk - release a fid (finish a transaction)
91	* @v9ses: 9P2000 session information
92	* @fid: fid to release
93	* @fcall: pointer to response fcall pointer
94	*
95	*/
96
97	int
98	v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid,
99	struct v9fs_fcall **fcall)
100	{
101	struct v9fs_fcall msg;
102
103	dprintk(DEBUG_9P, "fid %d\n", fid);
104	msg.id = TCLUNK;
105	msg.params.tclunk.fid = fid;
106
107	return v9fs_mux_rpc(v9ses, &msg, fcall);
108	}
109
110	/**
111	* v9fs_v9fs_t_flush - flush a pending transaction
112	* @v9ses: 9P2000 session information
113	* @tag: tid to release
114	*
115	*/
116
117	int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 tag)
118	{
119	struct v9fs_fcall msg;
120
121	dprintk(DEBUG_9P, "oldtag %d\n", tag);
122	msg.id = TFLUSH;
123	msg.params.tflush.oldtag = tag;
124	return v9fs_mux_rpc(v9ses, &msg, NULL);
125	}
126
127	/**
128	* v9fs_t_stat - read a file's meta-data
129	* @v9ses: 9P2000 session information
130	* @fid: fid pointing to file or directory to get info about
131	* @fcall: pointer to response fcall
132	*
133	*/
134
135	int
136	v9fs_t_stat(struct v9fs_session_info v9ses, u32 fid, struct v9fs_fcall *fcall)
137	{
138	struct v9fs_fcall msg;
139
140	dprintk(DEBUG_9P, "fid %d\n", fid);
141	if (fcall)
142	*fcall = NULL;
143
144	msg.id = TSTAT;
145	msg.params.tstat.fid = fid;
146	return v9fs_mux_rpc(v9ses, &msg, fcall);
147	}
148
149	/**
150	* v9fs_t_wstat - write a file's meta-data
151	* @v9ses: 9P2000 session information
152	* @fid: fid pointing to file or directory to write info about
153	* @stat: metadata
154	* @fcall: pointer to response fcall
155	*
156	*/
157
158	int
159	v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
160	struct v9fs_stat stat, struct v9fs_fcall *fcall)
161	{
162	struct v9fs_fcall msg;
163
164	dprintk(DEBUG_9P, "fid %d length %d\n", fid, (int)stat->length);
165	msg.id = TWSTAT;
166	msg.params.twstat.fid = fid;
167	msg.params.twstat.stat = stat;
168
169	return v9fs_mux_rpc(v9ses, &msg, fcall);
170	}
171
172	/**
173	* v9fs_t_walk - walk a fid to a new file or directory
174	* @v9ses: 9P2000 session information
175	* @fid: fid to walk
176	* @newfid: new fid (for clone operations)
177	* @name: path to walk fid to
178	* @fcall: pointer to response fcall
179	*
180	*/
181
182	/* TODO: support multiple walk */
183
184	int
185	v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
186	char name, struct v9fs_fcall *fcall)
187	{
188	struct v9fs_fcall msg;
189
190	dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
191	msg.id = TWALK;
192	msg.params.twalk.fid = fid;
193	msg.params.twalk.newfid = newfid;
194
195	if (name) {
196	msg.params.twalk.nwname = 1;
197	msg.params.twalk.wnames = &name;
198	} else {
199	msg.params.twalk.nwname = 0;
200	}
201
202	return v9fs_mux_rpc(v9ses, &msg, fcall);
203	}
204
205	/**
206	* v9fs_t_open - open a file
207	*
208	* @v9ses - 9P2000 session information
209	* @fid - fid to open
210	* @mode - mode to open file (R, RW, etc)
211	* @fcall - pointer to response fcall
212	*
213	*/
214
215	int
216	v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
217	struct v9fs_fcall **fcall)
218	{
219	struct v9fs_fcall msg;
220	long errorno = -1;
221
222	dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
223	msg.id = TOPEN;
224	msg.params.topen.fid = fid;
225	msg.params.topen.mode = mode;
226
227	errorno = v9fs_mux_rpc(v9ses, &msg, fcall);
228
229	return errorno;
230	}
231
232	/**
233	* v9fs_t_remove - remove a file or directory
234	* @v9ses: 9P2000 session information
235	* @fid: fid to remove
236	* @fcall: pointer to response fcall
237	*
238	*/
239
240	int
241	v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
242	struct v9fs_fcall **fcall)
243	{
244	struct v9fs_fcall msg;
245
246	dprintk(DEBUG_9P, "fid %d\n", fid);
247	msg.id = TREMOVE;
248	msg.params.tremove.fid = fid;
249	return v9fs_mux_rpc(v9ses, &msg, fcall);
250	}
251
252	/**
253	* v9fs_t_create - create a file or directory
254	* @v9ses: 9P2000 session information
255	* @fid: fid to create
256	* @name: name of the file or directory to create
257	* @perm: permissions to create with
258	* @mode: mode to open file (R, RW, etc)
259	* @fcall: pointer to response fcall
260	*
261	*/
262
263	int
264	v9fs_t_create(struct v9fs_session_info v9ses, u32 fid, char name,
265	u32 perm, u8 mode, struct v9fs_fcall **fcall)
266	{
267	struct v9fs_fcall msg;
268
269	dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
270	fid, name, perm, mode);
271
272	msg.id = TCREATE;
273	msg.params.tcreate.fid = fid;
274	msg.params.tcreate.name = name;
275	msg.params.tcreate.perm = perm;
276	msg.params.tcreate.mode = mode;
277
278	return v9fs_mux_rpc(v9ses, &msg, fcall);
279	}
280
281	/**
282	* v9fs_t_read - read data
283	* @v9ses: 9P2000 session information
284	* @fid: fid to read from
285	* @offset: offset to start read at
286	* @count: how many bytes to read
287	* @fcall: pointer to response fcall (with data)
288	*
289	*/
290
291	int
292	v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
293	u32 count, struct v9fs_fcall **fcall)
294	{
295	struct v9fs_fcall msg;
296	struct v9fs_fcall *rc = NULL;
297	long errorno = -1;
298
299	dprintk(DEBUG_9P, "fid %d offset 0x%lx count 0x%x\n", fid,
300	(long unsigned int)offset, count);
301	msg.id = TREAD;
302	msg.params.tread.fid = fid;
303	msg.params.tread.offset = offset;
304	msg.params.tread.count = count;
305	errorno = v9fs_mux_rpc(v9ses, &msg, &rc);
306
307	if (!errorno) {
308	errorno = rc->params.rread.count;
309	dump_data(rc->params.rread.data, rc->params.rread.count);
310	}
311
312	if (fcall)
313	*fcall = rc;
314	else
315	kfree(rc);
316
317	return errorno;
318	}
319
320	/**
321	* v9fs_t_write - write data
322	* @v9ses: 9P2000 session information
323	* @fid: fid to write to
324	* @offset: offset to start write at
325	* @count: how many bytes to write
326	* @fcall: pointer to response fcall
327	*
328	*/
329
330	int
331	v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid,
332	u64 offset, u32 count, void data, struct v9fs_fcall *fcall)
333	{
334	struct v9fs_fcall msg;
335	struct v9fs_fcall *rc = NULL;
336	long errorno = -1;
337
338	dprintk(DEBUG_9P, "fid %d offset 0x%llx count 0x%x\n", fid,
339	(unsigned long long)offset, count);
340	dump_data(data, count);
341
342	msg.id = TWRITE;
343	msg.params.twrite.fid = fid;
344	msg.params.twrite.offset = offset;
345	msg.params.twrite.count = count;
346	msg.params.twrite.data = data;
347
348	errorno = v9fs_mux_rpc(v9ses, &msg, &rc);
349
350	if (!errorno)
351	errorno = rc->params.rwrite.count;
352
353	if (fcall)
354	*fcall = rc;
355	else
356	kfree(rc);
357
358	return errorno;
359	}