9p.c 8.7 KB
Newer Older
1 2 3
/*
 *  linux/fs/9p/9p.c
 *
4
 *  This file contains functions to perform synchronous 9P calls
5
 *
6
 *  Copyright (C) 2004 by Latchesar Ionkov <lucho@ionkov.net>
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
 *  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"
37
#include "conv.h"
38 39 40 41 42 43 44 45 46 47 48 49 50
#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,
51
	       char *version, struct v9fs_fcall **rcp)
52
{
53 54
	int ret;
	struct v9fs_fcall *tc;
55 56

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

59 60 61 62 63 64 65
	if (!IS_ERR(tc)) {
		ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
		kfree(tc);
	} else
		ret = PTR_ERR(tc);

	return ret;
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
}

/**
 * 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,
81
	      u32 fid, u32 afid, struct v9fs_fcall **rcp)
82
{
83 84
	int ret;
	struct v9fs_fcall* tc;
85 86 87 88

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

89 90 91 92 93 94 95 96
	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;
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
}

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);
119 120 121 122 123 124 125 126 127
}

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

129
int
130
v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
131
{
132
	int ret;
133 134
	struct v9fs_fcall *tc, *rc;

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

137 138 139 140 141 142 143 144 145
	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);
146

147 148
	v9fs_t_clunk_cb(v9ses, tc, rc, ret);
	return ret;
149 150
}

A
Adrian Bunk 已提交
151
#if 0
152 153 154 155 156 157 158
/**
 * v9fs_v9fs_t_flush - flush a pending transaction
 * @v9ses: 9P2000 session information
 * @tag: tid to release
 *
 */

159
int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
160
{
161 162
	int ret;
	struct v9fs_fcall *tc;
163

164 165 166 167 168 169 170 171 172 173
	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;
174
}
A
Adrian Bunk 已提交
175
#endif  /*  0  */
176 177 178 179 180 181 182 183 184 185

/**
 * 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
186
v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **rcp)
187
{
188 189
	int ret;
	struct v9fs_fcall *tc;
190 191 192

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

193 194 195 196 197 198 199 200 201
	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;
202 203 204 205 206 207 208 209 210 211 212 213 214
}

/**
 * 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,
215
	     struct v9fs_wstat *wstat, struct v9fs_fcall **rcp)
216
{
217 218
	int ret;
	struct v9fs_fcall *tc;
219

220 221 222 223 224 225 226 227
	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);
228

229
	return ret;
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
}

/**
 * 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,
246
	    char *name, struct v9fs_fcall **rcp)
247
{
248 249 250
	int ret;
	struct v9fs_fcall *tc;
	int nwname;
251 252

	dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
253 254 255 256 257 258 259 260 261 262 263 264 265 266

	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;
267 268 269 270 271 272 273 274 275 276 277 278 279 280
}

/**
 * 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,
281
	    struct v9fs_fcall **rcp)
282
{
283 284
	int ret;
	struct v9fs_fcall *tc;
285 286 287

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

288 289 290 291 292 293
	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);
294

295
	return ret;
296 297 298 299 300 301 302 303 304 305 306 307
}

/**
 * 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,
308
	      struct v9fs_fcall **rcp)
309
{
310 311
	int ret;
	struct v9fs_fcall *tc;
312 313

	dprintk(DEBUG_9P, "fid %d\n", fid);
314 315 316 317 318 319 320 321 322

	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;
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
}

/**
 * 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,
338
	      u32 perm, u8 mode, struct v9fs_fcall **rcp)
339
{
340 341
	int ret;
	struct v9fs_fcall *tc;
342 343 344 345

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

346 347 348 349 350 351
	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);
352

353
	return ret;
354 355 356 357 358 359 360 361 362 363 364 365 366 367
}

/**
 * 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,
368
	    u32 count, struct v9fs_fcall **rcp)
369
{
370 371
	int ret;
	struct v9fs_fcall *tc, *rc;
372

373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
	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;
391 392 393 394 395 396 397 398 399 400 401 402 403
}

/**
 * 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
404 405
v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
	const char __user *data, struct v9fs_fcall **rcp)
406
{
407 408
	int ret;
	struct v9fs_fcall *tc, *rc;
409

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

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

417 418 419 420 421 422
		if (!ret)
			ret = rc->params.rwrite.count;
		if (rcp)
			*rcp = rc;
		else
			kfree(rc);
423

424 425 426
		kfree(tc);
	} else
		ret = PTR_ERR(tc);
427

428
	return ret;
429
}
430