forked from luck/tmp_suning_uos_patched
428 lines
8.7 KiB
C
428 lines
8.7 KiB
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/sched.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;
|
|
}
|
|
|