Skip to content

L
linux
Commit 531b1094 authored by Latchesar Ionkov's avatar Latchesar Ionkov Committed by Linus Torvalds
Browse files
Options

[PATCH] v9fs: zero copy implementation 

Performance enhancement reducing the number of copies in the data and
stat paths.
Signed-off-by: default avatarLatchesar Ionkov <lucho@ionkov.net>
Cc: Eric Van Hensbergen <ericvh@ericvh.myip.org>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent d8da097a
Hide whitespace changes
Inline Side-by-side
Showing with 1083 additions and 1047 deletions
fs/9p/9p.c
View file @ 531b1094
/*
* linux/fs/9p/9p.c
*
* This file contains functions 9P2000 functions
* 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>
*
......@@ -33,6 +34,7 @@
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
#include "mux.h"
/**
......@@ -46,17 +48,21 @@
int
v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
char *version, struct v9fs_fcall **fcall)
char *version, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
msg.id = TVERSION;
msg.tag = ~0;
msg.params.tversion.msize = msize;
msg.params.tversion.version = version;
tc = v9fs_create_tversion(msize, version);
return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
......@@ -72,19 +78,23 @@ v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
int
v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
u32 fid, u32 afid, struct v9fs_fcall **fcall)
u32 fid, u32 afid, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall* tc;
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->mux, &msg, fcall);
ret = -ENOMEM;
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,
......@@ -117,24 +127,28 @@ static void v9fs_t_clunk_cb(void *a, struct v9fs_fcall *tc,
* @fcall: pointer to response fcall pointer
*
*/
int
v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
{
int err;
int ret;
struct v9fs_fcall *tc, *rc;
tc = kmalloc(sizeof(struct v9fs_fcall), GFP_KERNEL);
dprintk(DEBUG_9P, "fid %d\n", fid);
tc->id = TCLUNK;
tc->params.tclunk.fid = fid;
err = v9fs_mux_rpc(v9ses->mux, tc, &rc);
if (err >= 0) {
v9fs_t_clunk_cb(v9ses, tc, rc, 0);
}
ret = -ENOMEM;
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);
return err;
v9fs_t_clunk_cb(v9ses, tc, rc, ret);
return ret;
}
/**
......@@ -144,14 +158,22 @@ v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
*
*/
int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 tag)
int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "oldtag %d\n", tag);
msg.id = TFLUSH;
msg.params.tflush.oldtag = tag;
return v9fs_mux_rpc(v9ses->mux, &msg, NULL);
dprintk(DEBUG_9P, "oldtag %d\n", oldtag);
ret = -ENOMEM;
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;
}
/**
......@@ -163,17 +185,22 @@ int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 tag)
*/
int
v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **fcall)
v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d\n", fid);
if (fcall)
*fcall = NULL;
msg.id = TSTAT;
msg.params.tstat.fid = fid;
return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
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;
}
/**
......@@ -187,16 +214,22 @@ v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **fcall)
int
v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_stat *stat, struct v9fs_fcall **fcall)
struct v9fs_wstat *wstat, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
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;
dprintk(DEBUG_9P, "fid %d\n", fid);
ret = -ENOMEM;
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 v9fs_mux_rpc(v9ses->mux, &msg, fcall);
return ret;
}
/**
......@@ -213,23 +246,28 @@ v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
int
v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
char *name, struct v9fs_fcall **fcall)
char *name, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
int nwname;
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->mux, &msg, fcall);
if (name)
nwname = 1;
else
nwname = 0;
ret = -ENOMEM;
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;
}
/**
......@@ -244,19 +282,22 @@ v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
int
v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
struct v9fs_fcall **fcall)
struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int errorno = -1;
int ret;
struct v9fs_fcall *tc;
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->mux, &msg, fcall);
ret = -ENOMEM;
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 errorno;
return ret;
}
/**
......@@ -269,14 +310,22 @@ v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
int
v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_fcall **fcall)
struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d\n", fid);
msg.id = TREMOVE;
msg.params.tremove.fid = fid;
return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
ret = -ENOMEM;
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;
}
/**
......@@ -292,20 +341,23 @@ v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
int
v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
u32 perm, u8 mode, struct v9fs_fcall **fcall)
u32 perm, u8 mode, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
int ret;
struct v9fs_fcall *tc;
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;
ret = -ENOMEM;
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);
return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
return ret;
}
/**
......@@ -320,31 +372,30 @@ v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
int
v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
u32 count, struct v9fs_fcall **fcall)
u32 count, struct v9fs_fcall **rcp)
{
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->mux, &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);
int ret;
struct v9fs_fcall *tc, *rc;
return errorno;
dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
(long long unsigned) offset, count);
ret = -ENOMEM;
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;
}
/**
......@@ -358,32 +409,31 @@ v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
*/
int
v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid,
u64 offset, u32 count, void *data, struct v9fs_fcall **fcall)
v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
const char __user *data, struct v9fs_fcall **rcp)
{
struct v9fs_fcall msg;
struct v9fs_fcall *rc = NULL;
long errorno = -1;
int ret;
struct v9fs_fcall *tc, *rc;
dprintk(DEBUG_9P, "fid %d offset 0x%llx count 0x%x\n", fid,
(unsigned long long)offset, count);
dump_data(data, count);
dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
(long long unsigned) offset, count);
msg.id = TWRITE;
msg.params.twrite.fid = fid;
msg.params.twrite.offset = offset;
msg.params.twrite.count = count;
msg.params.twrite.data = data;
ret = -ENOMEM;
tc = v9fs_create_twrite(fid, offset, count, data);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
errorno = v9fs_mux_rpc(v9ses->mux, &msg, &rc);
if (!ret)
ret = rc->params.rwrite.count;
if (rcp)
*rcp = rc;
else
kfree(rc);
if (!errorno)
errorno = rc->params.rwrite.count;
kfree(tc);
} else
ret = PTR_ERR(tc);
if (fcall)
*fcall = rc;
else
kfree(rc);
return errorno;
return ret;
}
fs/9p/9p.h
View file @ 531b1094
......@@ -3,6 +3,7 @@
*
* 9P protocol definitions.
*
* Copyright (C) 2005 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>
*
......@@ -102,10 +103,16 @@ enum {
#define V9FS_NOTAG (u16)(~0)
#define V9FS_NOFID (u32)(~0)
#define V9FS_MAXWELEM 16
/* ample room for Twrite/Rread header (iounit) */
#define V9FS_IOHDRSZ 24
struct v9fs_str {
u16 len;
char *str;
};
/* qids are the unique ID for a file (like an inode */
struct v9fs_qid {
u8 type;
......@@ -115,6 +122,29 @@ struct v9fs_qid {
/* Plan 9 file metadata (stat) structure */
struct v9fs_stat {
u16 size;
u16 type;
u32 dev;
struct v9fs_qid qid;
u32 mode;
u32 atime;
u32 mtime;
u64 length;
struct v9fs_str name;
struct v9fs_str uid;
struct v9fs_str gid;
struct v9fs_str muid;
struct v9fs_str extension; /* 9p2000.u extensions */
u32 n_uid; /* 9p2000.u extensions */
u32 n_gid; /* 9p2000.u extensions */
u32 n_muid; /* 9p2000.u extensions */
};
/* file metadata (stat) structure used to create Twstat message
The is similar to v9fs_stat, but the strings don't point to
the same memory block and should be freed separately
*/
struct v9fs_wstat {
u16 size;
u16 type;
u32 dev;
......@@ -131,25 +161,24 @@ struct v9fs_stat {
u32 n_uid; /* 9p2000.u extensions */
u32 n_gid; /* 9p2000.u extensions */
u32 n_muid; /* 9p2000.u extensions */
char data[0];
};
/* Structures for Protocol Operations */
struct Tversion {
u32 msize;
char *version;
struct v9fs_str version;
};
struct Rversion {
u32 msize;
char *version;
struct v9fs_str version;
};
struct Tauth {
u32 afid;
char *uname;
char *aname;
struct v9fs_str uname;
struct v9fs_str aname;
};
struct Rauth {
......@@ -157,12 +186,12 @@ struct Rauth {
};
struct Rerror {
char *error;
struct v9fs_str error;
u32 errno; /* 9p2000.u extension */
};
struct Tflush {
u32 oldtag;
u16 oldtag;
};
struct Rflush {
......@@ -171,8 +200,8 @@ struct Rflush {
struct Tattach {
u32 fid;
u32 afid;
char *uname;
char *aname;
struct v9fs_str uname;
struct v9fs_str aname;
};
struct Rattach {
......@@ -182,13 +211,13 @@ struct Rattach {
struct Twalk {
u32 fid;
u32 newfid;
u32 nwname;
char **wnames;
u16 nwname;
struct v9fs_str wnames[16];
};
struct Rwalk {
u32 nwqid;
struct v9fs_qid *wqids;
u16 nwqid;
struct v9fs_qid wqids[16];
};
struct Topen {
......@@ -203,7 +232,7 @@ struct Ropen {
struct Tcreate {
u32 fid;
char *name;
struct v9fs_str name;
u32 perm;
u8 mode;
};
......@@ -254,12 +283,12 @@ struct Tstat {
};
struct Rstat {
struct v9fs_stat *stat;
struct v9fs_stat stat;
};
struct Twstat {
u32 fid;
struct v9fs_stat *stat;
struct v9fs_stat stat;
};
struct Rwstat {
......@@ -274,6 +303,7 @@ struct v9fs_fcall {
u32 size;
u8 id;
u16 tag;
void *sdata;
union {
struct Tversion tversion;
......@@ -306,10 +336,12 @@ struct v9fs_fcall {
} params;
};
#define V9FS_FCALLHDRSZ (sizeof(struct v9fs_fcall) + \
sizeof(struct v9fs_stat) + 16*sizeof(struct v9fs_qid) + 16)
#define PRINT_FCALL_ERROR(s, fcall) dprintk(DEBUG_ERROR, "%s: %.*s\n", s, \
fcall?fcall->params.rerror.error.len:0, \
fcall?fcall->params.rerror.error.str:"");
#define FCALL_ERROR(fcall) (fcall ? fcall->params.rerror.error : "")
char *v9fs_str_copy(char *buf, int buflen, struct v9fs_str *str);
int v9fs_str_compare(char *buf, struct v9fs_str *str);
int v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
char *version, struct v9fs_fcall **rcall);
......@@ -325,7 +357,7 @@ int v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_fcall **rcall);
int v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_stat *stat, struct v9fs_fcall **rcall);
struct v9fs_wstat *wstat, struct v9fs_fcall **rcall);
int v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
char *name, struct v9fs_fcall **rcall);
......@@ -343,4 +375,5 @@ int v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid,
u64 offset, u32 count, struct v9fs_fcall **rcall);
int v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
u32 count, void *data, struct v9fs_fcall **rcall);
u32 count, const char __user * data,
struct v9fs_fcall **rcall);
fs/9p/Makefile
View file @ 531b1094
obj-$(CONFIG_9P_FS) := 9p2000.o
9p2000-objs := \
trans_fd.o \
trans_sock.o \
mux.o \
9p.o \
conv.o \
vfs_super.o \
vfs_inode.o \
vfs_file.o \
vfs_dir.o \
vfs_dentry.o \
error.o \
mux.o \
trans_fd.o \
trans_sock.o \
9p.o \
conv.o \
v9fs.o \
fid.o
fs/9p/conv.c
View file @ 531b1094
......@@ -30,7 +30,7 @@
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <asm/uaccess.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
......@@ -45,6 +45,37 @@ struct cbuf {
unsigned char *ep;
};
char *v9fs_str_copy(char *buf, int buflen, struct v9fs_str *str)
{
int n;
if (buflen < str->len)
n = buflen;
else
n = str->len;
memmove(buf, str->str, n - 1);
return buf;
}
int v9fs_str_compare(char *buf, struct v9fs_str *str)
{
int n, ret;
ret = strncmp(buf, str->str, str->len);
if (!ret) {
n = strlen(buf);
if (n < str->len)
ret = -1;
else if (n > str->len)
ret = 1;
}
return ret;
}
static inline void buf_init(struct cbuf *buf, void *data, int datalen)
{
buf->sp = buf->p = data;
......@@ -58,12 +89,12 @@ static inline int buf_check_overflow(struct cbuf *buf)
static inline int buf_check_size(struct cbuf *buf, int len)
{
if (buf->p+len > buf->ep) {
if (buf->p < buf->ep) {
eprintk(KERN_ERR, "buffer overflow\n");
buf->p = buf->ep + 1;
return 0;
}
if (buf->p + len > buf->ep && buf->p < buf->ep) {
eprintk(KERN_ERR, "buffer overflow: want %d has %d\n",
len, (int)(buf->ep - buf->p));
dump_stack();
buf->p = buf->ep + 1;
return 0;
}
return 1;
......@@ -127,14 +158,6 @@ static inline void buf_put_string(struct cbuf *buf, const char *s)
buf_put_stringn(buf, s, strlen(s));
}
static inline void buf_put_data(struct cbuf *buf, void *data, u32 datalen)
{
if (buf_check_size(buf, datalen)) {
memcpy(buf->p, data, datalen);
buf->p += datalen;
}
}
static inline u8 buf_get_int8(struct cbuf *buf)
{
u8 ret = 0;
......@@ -183,85 +206,37 @@ static inline u64 buf_get_int64(struct cbuf *buf)
return ret;
}
static inline int
buf_get_string(struct cbuf *buf, char *data, unsigned int datalen)
{
u16 len = 0;
len = buf_get_int16(buf);
if (!buf_check_overflow(buf) && buf_check_size(buf, len) && len+1>datalen) {
memcpy(data, buf->p, len);
data[len] = 0;
buf->p += len;
len++;
}
return len;
}
static inline char *buf_get_stringb(struct cbuf *buf, struct cbuf *sbuf)
{
char *ret;
u16 len;
ret = NULL;
len = buf_get_int16(buf);
if (!buf_check_overflow(buf) && buf_check_size(buf, len) &&
buf_check_size(sbuf, len + 1)) {
memcpy(sbuf->p, buf->p, len);
sbuf->p[len] = 0;
ret = sbuf->p;
buf->p += len;
sbuf->p += len + 1;
}
return ret;
}
static inline int buf_get_data(struct cbuf *buf, void *data, int datalen)
static inline void buf_get_str(struct cbuf *buf, struct v9fs_str *vstr)
{
int ret = 0;
if (buf_check_size(buf, datalen)) {
memcpy(data, buf->p, datalen);
buf->p += datalen;
ret = datalen;
vstr->len = buf_get_int16(buf);
if (!buf_check_overflow(buf) && buf_check_size(buf, vstr->len)) {
vstr->str = buf->p;
buf->p += vstr->len;
} else {
vstr->len = 0;
vstr->str = NULL;
}
return ret;
}
static inline void *buf_get_datab(struct cbuf *buf, struct cbuf *dbuf,
int datalen)
static inline void buf_get_qid(struct cbuf *bufp, struct v9fs_qid *qid)
{
char *ret = NULL;
int n = 0;
if (buf_check_size(dbuf, datalen)) {
n = buf_get_data(buf, dbuf->p, datalen);
if (n > 0) {
ret = dbuf->p;
dbuf->p += n;
}
}
return ret;
qid->type = buf_get_int8(bufp);
qid->version = buf_get_int32(bufp);
qid->path = buf_get_int64(bufp);
}
/**
* v9fs_size_stat - calculate the size of a variable length stat struct
* v9fs_size_wstat - calculate the size of a variable length stat struct
* @stat: metadata (stat) structure
* @extended: non-zero if 9P2000.u
*
*/
static int v9fs_size_stat(struct v9fs_stat *stat, int extended)
static int v9fs_size_wstat(struct v9fs_wstat *wstat, int extended)
{
int size = 0;
if (stat == NULL) {
if (wstat == NULL) {
eprintk(KERN_ERR, "v9fs_size_stat: got a NULL stat pointer\n");
return 0;
}
......@@ -278,81 +253,38 @@ static int v9fs_size_stat(struct v9fs_stat *stat, int extended)
8 + /* length[8] */
8; /* minimum sum of string lengths */
if (stat->name)
size += strlen(stat->name);
if (stat->uid)
size += strlen(stat->uid);
if (stat->gid)
size += strlen(stat->gid);
if (stat->muid)
size += strlen(stat->muid);
if (wstat->name)
size += strlen(wstat->name);
if (wstat->uid)
size += strlen(wstat->uid);
if (wstat->gid)
size += strlen(wstat->gid);
if (wstat->muid)
size += strlen(wstat->muid);
if (extended) {
size += 4 + /* n_uid[4] */
4 + /* n_gid[4] */
4 + /* n_muid[4] */
2; /* string length of extension[4] */
if (stat->extension)
size += strlen(stat->extension);
if (wstat->extension)
size += strlen(wstat->extension);
}
return size;
}
/**
* serialize_stat - safely format a stat structure for transmission
* @stat: metadata (stat) structure
* @bufp: buffer to serialize structure into
* @extended: non-zero if 9P2000.u
*
*/
static int
serialize_stat(struct v9fs_stat *stat, struct cbuf *bufp, int extended)
{
buf_put_int16(bufp, stat->size);
buf_put_int16(bufp, stat->type);
buf_put_int32(bufp, stat->dev);
buf_put_int8(bufp, stat->qid.type);
buf_put_int32(bufp, stat->qid.version);
buf_put_int64(bufp, stat->qid.path);
buf_put_int32(bufp, stat->mode);
buf_put_int32(bufp, stat->atime);
buf_put_int32(bufp, stat->mtime);
buf_put_int64(bufp, stat->length);
buf_put_string(bufp, stat->name);
buf_put_string(bufp, stat->uid);
buf_put_string(bufp, stat->gid);
buf_put_string(bufp, stat->muid);
if (extended) {
buf_put_string(bufp, stat->extension);
buf_put_int32(bufp, stat->n_uid);
buf_put_int32(bufp, stat->n_gid);
buf_put_int32(bufp, stat->n_muid);
}
if (buf_check_overflow(bufp))
return 0;
return stat->size;
}
/**
* deserialize_stat - safely decode a recieved metadata (stat) structure
* buf_get_stat - safely decode a recieved metadata (stat) structure
* @bufp: buffer to deserialize
* @stat: metadata (stat) structure
* @dbufp: buffer to deserialize variable strings into
* @extended: non-zero if 9P2000.u
*
*/
static inline int
deserialize_stat(struct cbuf *bufp, struct v9fs_stat *stat,
struct cbuf *dbufp, int extended)
static inline void
buf_get_stat(struct cbuf *bufp, struct v9fs_stat *stat, int extended)
{
stat->size = buf_get_int16(bufp);
stat->type = buf_get_int16(bufp);
stat->dev = buf_get_int32(bufp);
......@@ -363,45 +295,17 @@ deserialize_stat(struct cbuf *bufp, struct v9fs_stat *stat,
stat->atime = buf_get_int32(bufp);
stat->mtime = buf_get_int32(bufp);
stat->length = buf_get_int64(bufp);
stat->name = buf_get_stringb(bufp, dbufp);
stat->uid = buf_get_stringb(bufp, dbufp);
stat->gid = buf_get_stringb(bufp, dbufp);
stat->muid = buf_get_stringb(bufp, dbufp);
buf_get_str(bufp, &stat->name);
buf_get_str(bufp, &stat->uid);
buf_get_str(bufp, &stat->gid);
buf_get_str(bufp, &stat->muid);
if (extended) {
stat->extension = buf_get_stringb(bufp, dbufp);
buf_get_str(bufp, &stat->extension);
stat->n_uid = buf_get_int32(bufp);
stat->n_gid = buf_get_int32(bufp);
stat->n_muid = buf_get_int32(bufp);
}
if (buf_check_overflow(bufp) || buf_check_overflow(dbufp))
return 0;
return stat->size + 2;
}
/**
* deserialize_statb - wrapper for decoding a received metadata structure
* @bufp: buffer to deserialize
* @dbufp: buffer to deserialize variable strings into
* @extended: non-zero if 9P2000.u
*
*/
static inline struct v9fs_stat *deserialize_statb(struct cbuf *bufp,
struct cbuf *dbufp,
int extended)
{
struct v9fs_stat *ret = buf_alloc(dbufp, sizeof(struct v9fs_stat));
if (ret) {
int n = deserialize_stat(bufp, ret, dbufp, extended);
if (n <= 0)
return NULL;
}
return ret;
}
/**
......@@ -409,194 +313,27 @@ static inline struct v9fs_stat *deserialize_statb(struct cbuf *bufp,
* @buf: buffer to deserialize
* @buflen: length of received buffer
* @stat: metadata structure to decode into
* @statlen: length of destination metadata structure
* @extended: non-zero if 9P2000.u
*
* Note: stat will point to the buf region.
*/
int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
u32 statlen, int extended)
int
v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
int extended)
{
struct cbuf buffer;
struct cbuf *bufp = &buffer;
struct cbuf dbuffer;
struct cbuf *dbufp = &dbuffer;
unsigned char *p;
buf_init(bufp, buf, buflen);
buf_init(dbufp, (char *)stat + sizeof(struct v9fs_stat),
statlen - sizeof(struct v9fs_stat));
return deserialize_stat(bufp, stat, dbufp, extended);
}
static inline int v9fs_size_fcall(struct v9fs_fcall *fcall, int extended)
{
int size = 4 + 1 + 2; /* size[4] msg[1] tag[2] */
int i = 0;
p = bufp->p;
buf_get_stat(bufp, stat, extended);
switch (fcall->id) {
default:
eprintk(KERN_ERR, "bad msg type %d\n", fcall->id);
if (buf_check_overflow(bufp))
return 0;
case TVERSION: /* msize[4] version[s] */
size += 4 + 2 + strlen(fcall->params.tversion.version);
break;
case TAUTH: /* afid[4] uname[s] aname[s] */
size += 4 + 2 + strlen(fcall->params.tauth.uname) +
2 + strlen(fcall->params.tauth.aname);
break;
case TFLUSH: /* oldtag[2] */
size += 2;
break;
case TATTACH: /* fid[4] afid[4] uname[s] aname[s] */
size += 4 + 4 + 2 + strlen(fcall->params.tattach.uname) +
2 + strlen(fcall->params.tattach.aname);
break;
case TWALK: /* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
size += 4 + 4 + 2;
/* now compute total for the array of names */
for (i = 0; i < fcall->params.twalk.nwname; i++)
size += 2 + strlen(fcall->params.twalk.wnames[i]);
break;
case TOPEN: /* fid[4] mode[1] */
size += 4 + 1;
break;
case TCREATE: /* fid[4] name[s] perm[4] mode[1] */
size += 4 + 2 + strlen(fcall->params.tcreate.name) + 4 + 1;
break;
case TREAD: /* fid[4] offset[8] count[4] */
size += 4 + 8 + 4;
break;
case TWRITE: /* fid[4] offset[8] count[4] data[count] */
size += 4 + 8 + 4 + fcall->params.twrite.count;
break;
case TCLUNK: /* fid[4] */
size += 4;
break;
case TREMOVE: /* fid[4] */
size += 4;
break;
case TSTAT: /* fid[4] */
size += 4;
break;
case TWSTAT: /* fid[4] stat[n] */
fcall->params.twstat.stat->size =
v9fs_size_stat(fcall->params.twstat.stat, extended);
size += 4 + 2 + 2 + fcall->params.twstat.stat->size;
}
return size;
}
/*
* v9fs_serialize_fcall - marshall fcall struct into a packet
* @fcall: structure to convert
* @data: buffer to serialize fcall into
* @datalen: length of buffer to serialize fcall into
* @extended: non-zero if 9P2000.u
*
*/
int
v9fs_serialize_fcall(struct v9fs_fcall *fcall, void *data, u32 datalen,
int extended)
{
int i = 0;
struct v9fs_stat *stat = NULL;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
buf_init(bufp, data, datalen);
if (!fcall) {
eprintk(KERN_ERR, "no fcall\n");
return -EINVAL;
}
fcall->size = v9fs_size_fcall(fcall, extended);
buf_put_int32(bufp, fcall->size);
buf_put_int8(bufp, fcall->id);
buf_put_int16(bufp, fcall->tag);
dprintk(DEBUG_CONV, "size %d id %d tag %d\n", fcall->size, fcall->id,
fcall->tag);
/* now encode it */
switch (fcall->id) {
default:
eprintk(KERN_ERR, "bad msg type: %d\n", fcall->id);
return -EPROTO;
case TVERSION:
buf_put_int32(bufp, fcall->params.tversion.msize);
buf_put_string(bufp, fcall->params.tversion.version);
break;
case TAUTH:
buf_put_int32(bufp, fcall->params.tauth.afid);
buf_put_string(bufp, fcall->params.tauth.uname);
buf_put_string(bufp, fcall->params.tauth.aname);
break;
case TFLUSH:
buf_put_int16(bufp, fcall->params.tflush.oldtag);
break;
case TATTACH:
buf_put_int32(bufp, fcall->params.tattach.fid);
buf_put_int32(bufp, fcall->params.tattach.afid);
buf_put_string(bufp, fcall->params.tattach.uname);
buf_put_string(bufp, fcall->params.tattach.aname);
break;
case TWALK:
buf_put_int32(bufp, fcall->params.twalk.fid);
buf_put_int32(bufp, fcall->params.twalk.newfid);
buf_put_int16(bufp, fcall->params.twalk.nwname);
for (i = 0; i < fcall->params.twalk.nwname; i++)
buf_put_string(bufp, fcall->params.twalk.wnames[i]);
break;
case TOPEN:
buf_put_int32(bufp, fcall->params.topen.fid);
buf_put_int8(bufp, fcall->params.topen.mode);
break;
case TCREATE:
buf_put_int32(bufp, fcall->params.tcreate.fid);
buf_put_string(bufp, fcall->params.tcreate.name);
buf_put_int32(bufp, fcall->params.tcreate.perm);
buf_put_int8(bufp, fcall->params.tcreate.mode);
break;
case TREAD:
buf_put_int32(bufp, fcall->params.tread.fid);
buf_put_int64(bufp, fcall->params.tread.offset);
buf_put_int32(bufp, fcall->params.tread.count);
break;
case TWRITE:
buf_put_int32(bufp, fcall->params.twrite.fid);
buf_put_int64(bufp, fcall->params.twrite.offset);
buf_put_int32(bufp, fcall->params.twrite.count);
buf_put_data(bufp, fcall->params.twrite.data,
fcall->params.twrite.count);
break;
case TCLUNK:
buf_put_int32(bufp, fcall->params.tclunk.fid);
break;
case TREMOVE:
buf_put_int32(bufp, fcall->params.tremove.fid);
break;
case TSTAT:
buf_put_int32(bufp, fcall->params.tstat.fid);
break;
case TWSTAT:
buf_put_int32(bufp, fcall->params.twstat.fid);
stat = fcall->params.twstat.stat;
buf_put_int16(bufp, stat->size + 2);
serialize_stat(stat, bufp, extended);
break;
}
if (buf_check_overflow(bufp)) {
dprintk(DEBUG_ERROR, "buffer overflow\n");
return -EIO;
}
return fcall->size;
else
return bufp->p - p;
}
/**
......@@ -611,18 +348,14 @@ v9fs_serialize_fcall(struct v9fs_fcall *fcall, void *data, u32 datalen,
int
v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
int rcalllen, int extended)
int extended)
{
struct cbuf buffer;
struct cbuf *bufp = &buffer;
struct cbuf dbuffer;
struct cbuf *dbufp = &dbuffer;
int i = 0;
buf_init(bufp, buf, buflen);
buf_init(dbufp, (char *)rcall + sizeof(struct v9fs_fcall),
rcalllen - sizeof(struct v9fs_fcall));
rcall->size = buf_get_int32(bufp);
rcall->id = buf_get_int8(bufp);
......@@ -630,13 +363,14 @@ v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
dprintk(DEBUG_CONV, "size %d id %d tag %d\n", rcall->size, rcall->id,
rcall->tag);
switch (rcall->id) {
default:
eprintk(KERN_ERR, "unknown message type: %d\n", rcall->id);
return -EPROTO;
case RVERSION:
rcall->params.rversion.msize = buf_get_int32(bufp);
rcall->params.rversion.version = buf_get_stringb(bufp, dbufp);
buf_get_str(bufp, &rcall->params.rversion.version);
break;
case RFLUSH:
break;
......@@ -647,40 +381,27 @@ v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
break;
case RWALK:
rcall->params.rwalk.nwqid = buf_get_int16(bufp);
if (rcall->params.rwalk.nwqid > 16) {
eprintk(KERN_ERR, "Rwalk with more than 16 qids: %d\n",
rcall->params.rwalk.nwqid);
if (rcall->params.rwalk.nwqid > V9FS_MAXWELEM) {
eprintk(KERN_ERR, "Rwalk with more than %d qids: %d\n",
V9FS_MAXWELEM, rcall->params.rwalk.nwqid);
return -EPROTO;
}
rcall->params.rwalk.wqids = buf_alloc(dbufp,
rcall->params.rwalk.nwqid * sizeof(struct v9fs_qid));
if (rcall->params.rwalk.wqids)
for (i = 0; i < rcall->params.rwalk.nwqid; i++) {
rcall->params.rwalk.wqids[i].type =
buf_get_int8(bufp);
rcall->params.rwalk.wqids[i].version =
buf_get_int16(bufp);
rcall->params.rwalk.wqids[i].path =
buf_get_int64(bufp);
}
for (i = 0; i < rcall->params.rwalk.nwqid; i++)
buf_get_qid(bufp, &rcall->params.rwalk.wqids[i]);
break;
case ROPEN:
rcall->params.ropen.qid.type = buf_get_int8(bufp);
rcall->params.ropen.qid.version = buf_get_int32(bufp);
rcall->params.ropen.qid.path = buf_get_int64(bufp);
buf_get_qid(bufp, &rcall->params.ropen.qid);
rcall->params.ropen.iounit = buf_get_int32(bufp);
break;
case RCREATE:
rcall->params.rcreate.qid.type = buf_get_int8(bufp);
rcall->params.rcreate.qid.version = buf_get_int32(bufp);
rcall->params.rcreate.qid.path = buf_get_int64(bufp);
buf_get_qid(bufp, &rcall->params.rcreate.qid);
rcall->params.rcreate.iounit = buf_get_int32(bufp);
break;
case RREAD:
rcall->params.rread.count = buf_get_int32(bufp);
rcall->params.rread.data = buf_get_datab(bufp, dbufp,
rcall->params.rread.count);
rcall->params.rread.data = bufp->p;
buf_check_size(bufp, rcall->params.rread.count);
break;
case RWRITE:
rcall->params.rwrite.count = buf_get_int32(bufp);
......@@ -691,22 +412,442 @@ v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
break;
case RSTAT:
buf_get_int16(bufp);
rcall->params.rstat.stat =
deserialize_statb(bufp, dbufp, extended);
buf_get_stat(bufp, &rcall->params.rstat.stat, extended);
break;
case RWSTAT:
break;
case RERROR:
rcall->params.rerror.error = buf_get_stringb(bufp, dbufp);
buf_get_str(bufp, &rcall->params.rerror.error);
if (extended)
rcall->params.rerror.errno = buf_get_int16(bufp);
break;
}
if (buf_check_overflow(bufp) || buf_check_overflow(dbufp)) {
if (buf_check_overflow(bufp)) {
dprintk(DEBUG_ERROR, "buffer overflow\n");
return -EIO;
}
return rcall->size;
return bufp->p - bufp->sp;
}
static inline void v9fs_put_int8(struct cbuf *bufp, u8 val, u8 * p)
{
*p = val;
buf_put_int8(bufp, val);
}
static inline void v9fs_put_int16(struct cbuf *bufp, u16 val, u16 * p)
{
*p = val;
buf_put_int16(bufp, val);
}
static inline void v9fs_put_int32(struct cbuf *bufp, u32 val, u32 * p)
{
*p = val;
buf_put_int32(bufp, val);
}
static inline void v9fs_put_int64(struct cbuf *bufp, u64 val, u64 * p)
{
*p = val;
buf_put_int64(bufp, val);
}
static inline void
v9fs_put_str(struct cbuf *bufp, char *data, struct v9fs_str *str)
{
if (data) {
str->len = strlen(data);
str->str = bufp->p;
} else {
str->len = 0;
str->str = NULL;
}
buf_put_stringn(bufp, data, str->len);
}
static inline int
v9fs_put_user_data(struct cbuf *bufp, const char __user * data, int count,
unsigned char **pdata)
{
*pdata = buf_alloc(bufp, count);
return copy_from_user(*pdata, data, count);
}
static void
v9fs_put_wstat(struct cbuf *bufp, struct v9fs_wstat *wstat,
struct v9fs_stat *stat, int statsz, int extended)
{
v9fs_put_int16(bufp, statsz, &stat->size);
v9fs_put_int16(bufp, wstat->type, &stat->type);
v9fs_put_int32(bufp, wstat->dev, &stat->dev);
v9fs_put_int8(bufp, wstat->qid.type, &stat->qid.type);
v9fs_put_int32(bufp, wstat->qid.version, &stat->qid.version);
v9fs_put_int64(bufp, wstat->qid.path, &stat->qid.path);
v9fs_put_int32(bufp, wstat->mode, &stat->mode);
v9fs_put_int32(bufp, wstat->atime, &stat->atime);
v9fs_put_int32(bufp, wstat->mtime, &stat->mtime);
v9fs_put_int64(bufp, wstat->length, &stat->length);
v9fs_put_str(bufp, wstat->name, &stat->name);
v9fs_put_str(bufp, wstat->uid, &stat->uid);
v9fs_put_str(bufp, wstat->gid, &stat->gid);
v9fs_put_str(bufp, wstat->muid, &stat->muid);
if (extended) {
v9fs_put_str(bufp, wstat->extension, &stat->extension);
v9fs_put_int32(bufp, wstat->n_uid, &stat->n_uid);
v9fs_put_int32(bufp, wstat->n_gid, &stat->n_gid);
v9fs_put_int32(bufp, wstat->n_muid, &stat->n_muid);
}
}
static struct v9fs_fcall *
v9fs_create_common(struct cbuf *bufp, u32 size, u8 id)
{
struct v9fs_fcall *fc;
size += 4 + 1 + 2; /* size[4] id[1] tag[2] */
fc = kmalloc(sizeof(struct v9fs_fcall) + size, GFP_KERNEL);
if (!fc)
return ERR_PTR(-ENOMEM);
fc->sdata = (char *)fc + sizeof(*fc);
buf_init(bufp, (char *)fc->sdata, size);
v9fs_put_int32(bufp, size, &fc->size);
v9fs_put_int8(bufp, id, &fc->id);
v9fs_put_int16(bufp, V9FS_NOTAG, &fc->tag);
return fc;
}
void v9fs_set_tag(struct v9fs_fcall *fc, u16 tag)
{
*(__le16 *) (fc->sdata + 5) = cpu_to_le16(tag);
}
struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 2 + strlen(version); /* msize[4] version[s] */
fc = v9fs_create_common(bufp, size, TVERSION);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, msize, &fc->params.tversion.msize);
v9fs_put_str(bufp, version, &fc->params.tversion.version);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tauth(u32 afid, char *uname, char *aname)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 2 + strlen(uname) + 2 + strlen(aname); /* afid[4] uname[s] aname[s] */
fc = v9fs_create_common(bufp, size, TAUTH);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, afid, &fc->params.tauth.afid);
v9fs_put_str(bufp, uname, &fc->params.tauth.uname);
v9fs_put_str(bufp, aname, &fc->params.tauth.aname);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *
v9fs_create_tattach(u32 fid, u32 afid, char *uname, char *aname)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 4 + 2 + strlen(uname) + 2 + strlen(aname); /* fid[4] afid[4] uname[s] aname[s] */
fc = v9fs_create_common(bufp, size, TATTACH);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tattach.fid);
v9fs_put_int32(bufp, afid, &fc->params.tattach.afid);
v9fs_put_str(bufp, uname, &fc->params.tattach.uname);
v9fs_put_str(bufp, aname, &fc->params.tattach.aname);
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tflush(u16 oldtag)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 2; /* oldtag[2] */
fc = v9fs_create_common(bufp, size, TFLUSH);
if (IS_ERR(fc))
goto error;
v9fs_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
char **wnames)
{
int i, size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
if (nwname > V9FS_MAXWELEM) {
dprintk(DEBUG_ERROR, "nwname > %d\n", V9FS_MAXWELEM);
return NULL;
}
size = 4 + 4 + 2; /* fid[4] newfid[4] nwname[2] ... */
for (i = 0; i < nwname; i++) {
size += 2 + strlen(wnames[i]); /* wname[s] */
}
fc = v9fs_create_common(bufp, size, TWALK);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.twalk.fid);
v9fs_put_int32(bufp, newfid, &fc->params.twalk.newfid);
v9fs_put_int16(bufp, nwname, &fc->params.twalk.nwname);
for (i = 0; i < nwname; i++) {
v9fs_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
}
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 1; /* fid[4] mode[1] */
fc = v9fs_create_common(bufp, size, TOPEN);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.topen.fid);
v9fs_put_int8(bufp, mode, &fc->params.topen.mode);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 2 + strlen(name) + 4 + 1; /* fid[4] name[s] perm[4] mode[1] */
fc = v9fs_create_common(bufp, size, TCREATE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tcreate.fid);
v9fs_put_str(bufp, name, &fc->params.tcreate.name);
v9fs_put_int32(bufp, perm, &fc->params.tcreate.perm);
v9fs_put_int8(bufp, mode, &fc->params.tcreate.mode);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 8 + 4; /* fid[4] offset[8] count[4] */
fc = v9fs_create_common(bufp, size, TREAD);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tread.fid);
v9fs_put_int64(bufp, offset, &fc->params.tread.offset);
v9fs_put_int32(bufp, count, &fc->params.tread.count);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
const char __user * data)
{
int size, err;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 8 + 4 + count; /* fid[4] offset[8] count[4] data[count] */
fc = v9fs_create_common(bufp, size, TWRITE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.twrite.fid);
v9fs_put_int64(bufp, offset, &fc->params.twrite.offset);
v9fs_put_int32(bufp, count, &fc->params.twrite.count);
err = v9fs_put_user_data(bufp, data, count, &fc->params.twrite.data);
if (err) {
kfree(fc);
fc = ERR_PTR(err);
}
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tclunk(u32 fid)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = v9fs_create_common(bufp, size, TCLUNK);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tclunk.fid);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tremove(u32 fid)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = v9fs_create_common(bufp, size, TREMOVE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tremove.fid);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_tstat(u32 fid)
{
int size;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = v9fs_create_common(bufp, size, TSTAT);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tstat.fid);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
int extended)
{
int size, statsz;
struct v9fs_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
statsz = v9fs_size_wstat(wstat, extended);
size = 4 + 2 + 2 + statsz; /* fid[4] stat[n] */
fc = v9fs_create_common(bufp, size, TWSTAT);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.twstat.fid);
buf_put_int16(bufp, statsz + 2);
v9fs_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, extended);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
fs/9p/conv.h
View file @ 531b1094
/*
* linux/fs/9p/conv.h
*
* 9P protocol conversion definitions
* 9P protocol conversion definitions.
*
* Copyright (C) 2005 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>
*
......@@ -25,11 +26,26 @@
*/
int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
u32 statlen, int extended);
int v9fs_serialize_fcall(struct v9fs_fcall *tcall, void *buf, u32 buflen,
int extended);
int v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
int rcalllen, int extended);
int extended);
void v9fs_set_tag(struct v9fs_fcall *fc, u16 tag);
/* this one is actually in error.c right now */
int v9fs_errstr2errno(char *errstr);
struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version);
struct v9fs_fcall *v9fs_create_tauth(u32 afid, char *uname, char *aname);
struct v9fs_fcall *v9fs_create_tattach(u32 fid, u32 afid, char *uname,
char *aname);
struct v9fs_fcall *v9fs_create_tflush(u16 oldtag);
struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
char **wnames);
struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode);
struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode);
struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count);
struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
const char __user *data);
struct v9fs_fcall *v9fs_create_tclunk(u32 fid);
struct v9fs_fcall *v9fs_create_tremove(u32 fid);
struct v9fs_fcall *v9fs_create_tstat(u32 fid);
struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
int extended);
fs/9p/debug.h
View file @ 531b1094
......@@ -51,16 +51,23 @@ do { \
#if DEBUG_DUMP_PKT
static inline void dump_data(const unsigned char *data, unsigned int datalen)
{
int i, j;
int len = datalen;
int i, n;
char buf[5*8];
printk(KERN_DEBUG "data ");
for (i = 0; i < len; i += 4) {
for (j = 0; (j < 4) && (i + j < len); j++)
printk(KERN_DEBUG "%02x", data[i + j]);
printk(KERN_DEBUG " ");
n = 0;
i = 0;
while (i < datalen) {
n += snprintf(buf+n, sizeof(buf)-n, "%02x", data[i++]);
if (i%4 == 0)
n += snprintf(buf+n, sizeof(buf)-n, " ");
if (i%16 == 0) {
dprintk(DEBUG_ERROR, "%s\n", buf);
n = 0;
}
}
printk(KERN_DEBUG "\n");
dprintk(DEBUG_ERROR, "%s\n", buf);
}
#else /* DEBUG_DUMP_PKT */
static inline void dump_data(const unsigned char *data, unsigned int datalen)
......
fs/9p/error.c
View file @ 531b1094
......@@ -33,7 +33,6 @@
#include <linux/list.h>
#include <linux/jhash.h>
#include <linux/string.h>
#include "debug.h"
#include "error.h"
......@@ -55,7 +54,8 @@ int v9fs_error_init(void)
/* load initial error map into hash table */
for (c = errmap; c->name != NULL; c++) {
bucket = jhash(c->name, strlen(c->name), 0) % ERRHASHSZ;
c->namelen = strlen(c->name);
bucket = jhash(c->name, c->namelen, 0) % ERRHASHSZ;
INIT_HLIST_NODE(&c->list);
hlist_add_head(&c->list, &hash_errmap[bucket]);
}
......@@ -69,15 +69,15 @@ int v9fs_error_init(void)
*
*/
int v9fs_errstr2errno(char *errstr)
int v9fs_errstr2errno(char *errstr, int len)
{
int errno = 0;
struct hlist_node *p = NULL;
struct errormap *c = NULL;
int bucket = jhash(errstr, strlen(errstr), 0) % ERRHASHSZ;
int bucket = jhash(errstr, len, 0) % ERRHASHSZ;
hlist_for_each_entry(c, p, &hash_errmap[bucket], list) {
if (!strcmp(c->name, errstr)) {
if (c->namelen==len && !memcmp(c->name, errstr, len)) {
errno = c->val;
break;
}
......
fs/9p/error.h
View file @ 531b1094
......@@ -36,6 +36,7 @@ struct errormap {
char *name;
int val;
int namelen;
struct hlist_node list;
};
......@@ -175,4 +176,4 @@ static struct errormap errmap[] = {
};
extern int v9fs_error_init(void);
extern int v9fs_errstr2errno(char *errstr);
extern int v9fs_errstr2errno(char *errstr, int len);
fs/9p/fid.c
View file @ 531b1094
......@@ -31,9 +31,6 @@
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "transport.h"
#include "mux.h"
#include "conv.h"
#include "fid.h"
/**
......
fs/9p/mux.c
View file @ 531b1094
......@@ -35,8 +35,8 @@
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "transport.h"
#include "conv.h"
#include "transport.h"
#include "mux.h"
#define ERREQFLUSH 1
......@@ -74,6 +74,7 @@ struct v9fs_mux_data {
wait_queue_head_t equeue;
struct list_head req_list;
struct list_head unsent_req_list;
struct v9fs_fcall *rcall;
int rpos;
char *rbuf;
int wpos;
......@@ -101,11 +102,15 @@ struct v9fs_mux_rpc {
wait_queue_head_t wqueue;
};
extern int v9fs_errstr2errno(char *str, int len);
static int v9fs_poll_proc(void *);
static void v9fs_read_work(void *);
static void v9fs_write_work(void *);
static void v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address,
poll_table * p);
static u16 v9fs_mux_get_tag(struct v9fs_mux_data *);
static void v9fs_mux_put_tag(struct v9fs_mux_data *, u16);
static DECLARE_MUTEX(v9fs_mux_task_lock);
static struct workqueue_struct *v9fs_mux_wq;
......@@ -166,8 +171,9 @@ static void v9fs_mux_poll_start(struct v9fs_mux_data *m)
if (v9fs_mux_poll_tasks[i].task == NULL) {
vpt = &v9fs_mux_poll_tasks[i];
dprintk(DEBUG_MUX, "create proc %p\n", vpt);
vpt->task = kthread_create(v9fs_poll_proc,
vpt, "v9fs-poll");
vpt->task =
kthread_create(v9fs_poll_proc, vpt,
"v9fs-poll");
INIT_LIST_HEAD(&vpt->mux_list);
vpt->muxnum = 0;
v9fs_mux_poll_task_num++;
......@@ -253,7 +259,7 @@ struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
struct v9fs_mux_data *m, *mtmp;
dprintk(DEBUG_MUX, "transport %p msize %d\n", trans, msize);
m = kmalloc(sizeof(struct v9fs_mux_data) + 2 * msize, GFP_KERNEL);
m = kmalloc(sizeof(struct v9fs_mux_data), GFP_KERNEL);
if (!m)
return ERR_PTR(-ENOMEM);
......@@ -268,10 +274,11 @@ struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
init_waitqueue_head(&m->equeue);
INIT_LIST_HEAD(&m->req_list);
INIT_LIST_HEAD(&m->unsent_req_list);
m->rcall = NULL;
m->rpos = 0;
m->rbuf = (char *)m + sizeof(struct v9fs_mux_data);
m->rbuf = NULL;
m->wpos = m->wsize = 0;
m->wbuf = m->rbuf + msize;
m->wbuf = NULL;
INIT_WORK(&m->rq, v9fs_read_work, m);
INIT_WORK(&m->wq, v9fs_write_work, m);
m->wsched = 0;
......@@ -427,29 +434,6 @@ static int v9fs_poll_proc(void *a)
return 0;
}
static inline int v9fs_write_req(struct v9fs_mux_data *m, struct v9fs_req *req)
{
int n;
list_move_tail(&req->req_list, &m->req_list);
n = v9fs_serialize_fcall(req->tcall, m->wbuf, m->msize, *m->extended);
if (n < 0) {
req->err = n;
list_del(&req->req_list);
if (req->cb) {
spin_unlock(&m->lock);
(*req->cb) (req->cba, req->tcall, req->rcall, req->err);
req->cb = NULL;
spin_lock(&m->lock);
} else
kfree(req->rcall);
kfree(req);
}
return n;
}
/**
* v9fs_write_work - called when a transport can send some data
*/
......@@ -457,7 +441,7 @@ static void v9fs_write_work(void *a)
{
int n, err;
struct v9fs_mux_data *m;
struct v9fs_req *req, *rtmp;
struct v9fs_req *req;
m = a;
......@@ -472,17 +456,15 @@ static void v9fs_write_work(void *a)
return;
}
err = 0;
spin_lock(&m->lock);
list_for_each_entry_safe(req, rtmp, &m->unsent_req_list,
req_list) {
err = v9fs_write_req(m, req);
if (err > 0)
break;
}
m->wsize = err;
req =
list_entry(m->unsent_req_list.next, struct v9fs_req,
req_list);
list_move_tail(&req->req_list, &m->req_list);
m->wbuf = req->tcall->sdata;
m->wsize = req->tcall->size;
m->wpos = 0;
dump_data(m->wbuf, m->wsize);
spin_unlock(&m->lock);
}
......@@ -526,24 +508,23 @@ static void v9fs_write_work(void *a)
static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
{
int ecode, tag;
char *ename;
struct v9fs_str *ename;
tag = req->tag;
if (req->rcall->id == RERROR && !req->err) {
ecode = req->rcall->params.rerror.errno;
ename = req->rcall->params.rerror.error;
ename = &req->rcall->params.rerror.error;
dprintk(DEBUG_MUX, "Rerror %s\n", ename);
dprintk(DEBUG_MUX, "Rerror %.*s\n", ename->len, ename->str);
if (*m->extended)
req->err = -ecode;
if (!req->err) {
req->err = v9fs_errstr2errno(ename);
req->err = v9fs_errstr2errno(ename->str, ename->len);
if (!req->err) { /* string match failed */
dprintk(DEBUG_ERROR, "unknown error: %s\n",
ename);
PRINT_FCALL_ERROR("unknown error", req->rcall);
}
if (!req->err)
......@@ -565,8 +546,7 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
} else
kfree(req->rcall);
if (tag != V9FS_NOTAG)
v9fs_put_idpool(tag, &m->tidpool);
v9fs_mux_put_tag(m, tag);
wake_up(&m->equeue);
kfree(req);
......@@ -577,10 +557,11 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
*/
static void v9fs_read_work(void *a)
{
int n, err, rcallen;
int n, err;
struct v9fs_mux_data *m;
struct v9fs_req *req, *rptr, *rreq;
struct v9fs_fcall *rcall;
char *rbuf;
m = a;
......@@ -589,6 +570,19 @@ static void v9fs_read_work(void *a)
rcall = NULL;
dprintk(DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
if (!m->rcall) {
m->rcall =
kmalloc(sizeof(struct v9fs_fcall) + m->msize, GFP_KERNEL);
if (!m->rcall) {
err = -ENOMEM;
goto error;
}
m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
m->rpos = 0;
}
clear_bit(Rpending, &m->wsched);
err = m->trans->read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
dprintk(DEBUG_MUX, "mux %p got %d bytes\n", m, err);
......@@ -613,21 +607,32 @@ static void v9fs_read_work(void *a)
if (m->rpos < n)
break;
rcallen = n + V9FS_FCALLHDRSZ;
rcall = kmalloc(rcallen, GFP_KERNEL);
if (!rcall) {
err = -ENOMEM;
goto error;
}
dump_data(m->rbuf, n);
err = v9fs_deserialize_fcall(m->rbuf, n, rcall, rcallen,
*m->extended);
err =
v9fs_deserialize_fcall(m->rbuf, n, m->rcall, *m->extended);
if (err < 0) {
kfree(rcall);
goto error;
}
rcall = m->rcall;
rbuf = m->rbuf;
if (m->rpos > n) {
m->rcall = kmalloc(sizeof(struct v9fs_fcall) + m->msize,
GFP_KERNEL);
if (!m->rcall) {
err = -ENOMEM;
goto error;
}
m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
memmove(m->rbuf, rbuf + n, m->rpos - n);
m->rpos -= n;
} else {
m->rcall = NULL;
m->rbuf = NULL;
m->rpos = 0;
}
dprintk(DEBUG_MUX, "mux %p fcall id %d tag %d\n", m, rcall->id,
rcall->tag);
......@@ -642,6 +647,7 @@ static void v9fs_read_work(void *a)
process_request(m, req);
break;
}
}
if (!req) {
......@@ -652,10 +658,6 @@ static void v9fs_read_work(void *a)
m, rcall->id, rcall->tag);
kfree(rcall);
}
if (m->rpos > n)
memmove(m->rbuf, m->rbuf + n, m->rpos - n);
m->rpos -= n;
}
if (!list_empty(&m->req_list)) {
......@@ -710,12 +712,13 @@ static struct v9fs_req *v9fs_send_request(struct v9fs_mux_data *m,
if (tc->id == TVERSION)
n = V9FS_NOTAG;
else
n = v9fs_get_idpool(&m->tidpool);
n = v9fs_mux_get_tag(m);
if (n < 0)
return ERR_PTR(-ENOMEM);
tc->tag = n;
v9fs_set_tag(tc, n);
req->tag = n;
req->tcall = tc;
req->rcall = NULL;
......@@ -773,9 +776,7 @@ v9fs_mux_flush_cb(void *a, struct v9fs_fcall *tc, struct v9fs_fcall *rc,
if (!cb)
spin_unlock(&m->lock);
if (v9fs_check_idpool(tag, &m->tidpool))
v9fs_put_idpool(tag, &m->tidpool);
v9fs_mux_put_tag(m, tag);
kfree(tc);
kfree(rc);
}
......@@ -787,10 +788,7 @@ v9fs_mux_flush_request(struct v9fs_mux_data *m, struct v9fs_req *req)
dprintk(DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
fc = kmalloc(sizeof(struct v9fs_fcall), GFP_KERNEL);
fc->id = TFLUSH;
fc->params.tflush.oldtag = req->tag;
fc = v9fs_create_tflush(req->tag);
v9fs_send_request(m, fc, v9fs_mux_flush_cb, m);
}
......@@ -939,3 +937,20 @@ void v9fs_mux_cancel(struct v9fs_mux_data *m, int err)
wake_up(&m->equeue);
}
static u16 v9fs_mux_get_tag(struct v9fs_mux_data *m)
{
int tag;
tag = v9fs_get_idpool(&m->tidpool);
if (tag < 0)
return V9FS_NOTAG;
else
return (u16) tag;
}
static void v9fs_mux_put_tag(struct v9fs_mux_data *m, u16 tag)
{
if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tidpool))
v9fs_put_idpool(tag, &m->tidpool);
}
fs/9p/trans_sock.c
View file @ 531b1094
......@@ -110,7 +110,6 @@ static int v9fs_sock_send(struct v9fs_transport *trans, void *v, int len)
if (!(ts->filp->f_flags & O_NONBLOCK))
dprintk(DEBUG_ERROR, "blocking write ...\n");
dump_data(v, len);
oldfs = get_fs();
set_fs(get_ds());
ret = vfs_write(ts->filp, (void __user *)v, len, &ts->filp->f_pos);
......
fs/9p/v9fs.c
View file @ 531b1094
......@@ -37,7 +37,6 @@
#include "v9fs_vfs.h"
#include "transport.h"
#include "mux.h"
#include "conv.h"
/* TODO: sysfs or debugfs interface */
int v9fs_debug_level = 0; /* feature-rific global debug level */
......@@ -353,7 +352,7 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
}
/* Really should check for 9P1 and report error */
if (!strcmp(fcall->params.rversion.version, "9P2000.u")) {
if (!v9fs_str_compare("9P2000.u", &fcall->params.rversion.version)) {
dprintk(DEBUG_9P, "9P2000 UNIX extensions enabled\n");
v9ses->extended = 1;
} else {
......
fs/9p/v9fs_vfs.h
View file @ 531b1094
......@@ -45,9 +45,8 @@ extern struct dentry_operations v9fs_dentry_operations;
struct inode *v9fs_get_inode(struct super_block *sb, int mode);
ino_t v9fs_qid2ino(struct v9fs_qid *qid);
void v9fs_mistat2inode(struct v9fs_stat *, struct inode *,
struct super_block *);
void v9fs_stat2inode(struct v9fs_stat *, struct inode *, struct super_block *);
int v9fs_dir_release(struct inode *inode, struct file *filp);
int v9fs_file_open(struct inode *inode, struct file *file);
void v9fs_inode2mistat(struct inode *inode, struct v9fs_stat *mistat);
void v9fs_inode2stat(struct inode *inode, struct v9fs_stat *stat);
void v9fs_dentry_release(struct dentry *);
fs/9p/vfs_dentry.c
View file @ 531b1094
......@@ -40,7 +40,6 @@
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "conv.h"
#include "fid.h"
/**
......@@ -108,7 +107,8 @@ void v9fs_dentry_release(struct dentry *dentry)
err = v9fs_t_clunk(current_fid->v9ses, current_fid->fid);
if (err < 0)
dprintk(DEBUG_ERROR, "clunk failed: %d\n", err);
dprintk(DEBUG_ERROR, "clunk failed: %d name %s\n",
err, dentry->d_iname);
v9fs_fid_destroy(current_fid);
}
......
fs/9p/vfs_dir.c
View file @ 531b1094
......@@ -37,8 +37,8 @@
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "conv.h"
#include "v9fs_vfs.h"
#include "fid.h"
/**
......@@ -77,17 +77,13 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
unsigned int i, n, s;
int fid = -1;
int ret = 0;
struct v9fs_stat *mi = NULL;
struct v9fs_stat stat;
int over = 0;
dprintk(DEBUG_VFS, "name %s\n", filp->f_dentry->d_name.name);
fid = file->fid;
mi = kmalloc(v9ses->maxdata, GFP_KERNEL);
if (!mi)
return -ENOMEM;
if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
kfree(file->rdir_fcall);
file->rdir_fcall = NULL;
......@@ -99,18 +95,18 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
while (i < n) {
s = v9fs_deserialize_stat(
file->rdir_fcall->params.rread.data + i,
n - i, mi, v9ses->maxdata, v9ses->extended);
n - i, &stat, v9ses->extended);
if (s == 0) {
dprintk(DEBUG_ERROR,
"error while deserializing mistat\n");
"error while deserializing stat\n");
ret = -EIO;
goto FreeStructs;
}
over = filldir(dirent, mi->name, strlen(mi->name),
filp->f_pos, v9fs_qid2ino(&mi->qid),
dt_type(mi));
over = filldir(dirent, stat.name.str, stat.name.len,
filp->f_pos, v9fs_qid2ino(&stat.qid),
dt_type(&stat));
if (over) {
file->rdir_fpos = i;
......@@ -130,7 +126,7 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
while (!over) {
ret = v9fs_t_read(v9ses, fid, filp->f_pos,
v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
if (ret < 0) {
dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
ret, fcall);
......@@ -142,17 +138,17 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
i = 0;
while (i < n) {
s = v9fs_deserialize_stat(fcall->params.rread.data + i,
n - i, mi, v9ses->maxdata, v9ses->extended);
n - i, &stat, v9ses->extended);
if (s == 0) {
dprintk(DEBUG_ERROR,
"error while deserializing mistat\n");
"error while deserializing stat\n");
return -EIO;
}
over = filldir(dirent, mi->name, strlen(mi->name),
filp->f_pos, v9fs_qid2ino(&mi->qid),
dt_type(mi));
over = filldir(dirent, stat.name.str, stat.name.len,
filp->f_pos, v9fs_qid2ino(&stat.qid),
dt_type(&stat));
if (over) {
file->rdir_fcall = fcall;
......@@ -171,7 +167,6 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
FreeStructs:
kfree(fcall);
kfree(mi);
return ret;
}
......
fs/9p/vfs_file.c
View file @ 531b1094
......@@ -32,6 +32,7 @@
#include <linux/string.h>
#include <linux/smp_lock.h>
#include <linux/inet.h>
#include <linux/version.h>
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/idr.h>
......@@ -117,9 +118,7 @@ int v9fs_file_open(struct inode *inode, struct file *file)
result = v9fs_t_open(v9ses, newfid, open_mode, &fcall);
if (result < 0) {
dprintk(DEBUG_ERROR,
"open failed, open_mode 0x%x: %s\n", open_mode,
FCALL_ERROR(fcall));
PRINT_FCALL_ERROR("open failed", fcall);
kfree(fcall);
return result;
}
......@@ -256,7 +255,6 @@ v9fs_file_write(struct file *filp, const char __user * data,
int result = -EIO;
int rsize = 0;
int total = 0;
char *buf;
dprintk(DEBUG_VFS, "data %p count %d offset %x\n", data, (int)count,
(int)*offset);
......@@ -264,28 +262,14 @@ v9fs_file_write(struct file *filp, const char __user * data,
if (v9fid->iounit != 0 && rsize > v9fid->iounit)
rsize = v9fid->iounit;
buf = kmalloc(v9ses->maxdata - V9FS_IOHDRSZ, GFP_KERNEL);
if (!buf)
return -ENOMEM;
do {
if (count < rsize)
rsize = count;
result = copy_from_user(buf, data, rsize);
if (result) {
dprintk(DEBUG_ERROR, "Problem copying from user\n");
kfree(buf);
return -EFAULT;
}
dump_data(buf, rsize);
result = v9fs_t_write(v9ses, fid, *offset, rsize, buf, &fcall);
result = v9fs_t_write(v9ses, fid, *offset, rsize, data, &fcall);
if (result < 0) {
eprintk(KERN_ERR, "error while writing: %s(%d)\n",
FCALL_ERROR(fcall), result);
PRINT_FCALL_ERROR("error while writing", fcall);
kfree(fcall);
kfree(buf);
return result;
} else
*offset += result;
......@@ -305,7 +289,6 @@ v9fs_file_write(struct file *filp, const char __user * data,
total += result;
} while (count);
kfree(buf);
return total;
}
......
fs/9p/vfs_inode.c
View file @ 531b1094
......@@ -40,7 +40,6 @@
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "conv.h"
#include "fid.h"
static struct inode_operations v9fs_dir_inode_operations;
......@@ -127,100 +126,32 @@ static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
}
/**
* v9fs_blank_mistat - helper function to setup a 9P stat structure
* v9fs_blank_wstat - helper function to setup a 9P stat structure
* @v9ses: 9P session info (for determining extended mode)
* @mistat: structure to initialize
* @wstat: structure to initialize
*
*/
static void
v9fs_blank_mistat(struct v9fs_session_info *v9ses, struct v9fs_stat *mistat)
v9fs_blank_wstat(struct v9fs_wstat *wstat)
{
mistat->type = ~0;
mistat->dev = ~0;
mistat->qid.type = ~0;
mistat->qid.version = ~0;
*((long long *)&mistat->qid.path) = ~0;
mistat->mode = ~0;
mistat->atime = ~0;
mistat->mtime = ~0;
mistat->length = ~0;
mistat->name = mistat->data;
mistat->uid = mistat->data;
mistat->gid = mistat->data;
mistat->muid = mistat->data;
if (v9ses->extended) {
mistat->n_uid = ~0;
mistat->n_gid = ~0;
mistat->n_muid = ~0;
mistat->extension = mistat->data;
}
*mistat->data = 0;
}
/**
* v9fs_mistat2unix - convert mistat to unix stat
* @mistat: Plan 9 metadata (mistat) structure
* @buf: unix metadata (stat) structure to populate
* @sb: superblock
*
*/
static void
v9fs_mistat2unix(struct v9fs_stat *mistat, struct stat *buf,
struct super_block *sb)
{
struct v9fs_session_info *v9ses = sb ? sb->s_fs_info : NULL;
buf->st_nlink = 1;
buf->st_atime = mistat->atime;
buf->st_mtime = mistat->mtime;
buf->st_ctime = mistat->mtime;
buf->st_uid = (unsigned short)-1;
buf->st_gid = (unsigned short)-1;
if (v9ses && v9ses->extended) {
/* TODO: string to uid mapping via user-space daemon */
if (mistat->n_uid != -1)
sscanf(mistat->uid, "%x", (unsigned int *)&buf->st_uid);
if (mistat->n_gid != -1)
sscanf(mistat->gid, "%x", (unsigned int *)&buf->st_gid);
}
if (buf->st_uid == (unsigned short)-1)
buf->st_uid = v9ses->uid;
if (buf->st_gid == (unsigned short)-1)
buf->st_gid = v9ses->gid;
buf->st_mode = p9mode2unixmode(v9ses, mistat->mode);
if ((S_ISBLK(buf->st_mode)) || (S_ISCHR(buf->st_mode))) {
char type = 0;
int major = -1;
int minor = -1;
sscanf(mistat->extension, "%c %u %u", &type, &major, &minor);
switch (type) {
case 'c':
buf->st_mode &= ~S_IFBLK;
buf->st_mode |= S_IFCHR;
break;
case 'b':
break;
default:
dprintk(DEBUG_ERROR, "Unknown special type %c (%s)\n",
type, mistat->extension);
};
buf->st_rdev = MKDEV(major, minor);
} else
buf->st_rdev = 0;
buf->st_size = mistat->length;
buf->st_blksize = sb->s_blocksize;
buf->st_blocks =
(buf->st_size + buf->st_blksize - 1) >> sb->s_blocksize_bits;
wstat->type = ~0;
wstat->dev = ~0;
wstat->qid.type = ~0;
wstat->qid.version = ~0;
*((long long *)&wstat->qid.path) = ~0;
wstat->mode = ~0;
wstat->atime = ~0;
wstat->mtime = ~0;
wstat->length = ~0;
wstat->name = NULL;
wstat->uid = NULL;
wstat->gid = NULL;
wstat->muid = NULL;
wstat->n_uid = ~0;
wstat->n_gid = ~0;
wstat->n_muid = ~0;
wstat->extension = NULL;
}
/**
......@@ -312,7 +243,6 @@ v9fs_create(struct inode *dir,
struct inode *file_inode = NULL;
struct v9fs_fcall *fcall = NULL;
struct v9fs_qid qid;
struct stat newstat;
int dirfidnum = -1;
long newfid = -1;
int result = 0;
......@@ -350,7 +280,7 @@ v9fs_create(struct inode *dir,
result = v9fs_t_walk(v9ses, dirfidnum, newfid, NULL, &fcall);
if (result < 0) {
dprintk(DEBUG_ERROR, "clone error: %s\n", FCALL_ERROR(fcall));
PRINT_FCALL_ERROR("clone error", fcall);
v9fs_put_idpool(newfid, &v9ses->fidpool);
newfid = -1;
goto CleanUpFid;
......@@ -362,9 +292,7 @@ v9fs_create(struct inode *dir,
result = v9fs_t_create(v9ses, newfid, (char *)file_dentry->d_name.name,
perm, open_mode, &fcall);
if (result < 0) {
dprintk(DEBUG_ERROR, "create fails: %s(%d)\n",
FCALL_ERROR(fcall), result);
PRINT_FCALL_ERROR("create fails", fcall);
goto CleanUpFid;
}
......@@ -400,7 +328,7 @@ v9fs_create(struct inode *dir,
result = v9fs_t_walk(v9ses, dirfidnum, wfidno,
(char *) file_dentry->d_name.name, &fcall);
if (result < 0) {
dprintk(DEBUG_ERROR, "clone error: %s\n", FCALL_ERROR(fcall));
PRINT_FCALL_ERROR("clone error", fcall);
v9fs_put_idpool(wfidno, &v9ses->fidpool);
wfidno = -1;
goto CleanUpFid;
......@@ -421,21 +349,21 @@ v9fs_create(struct inode *dir,
result = v9fs_t_stat(v9ses, wfidno, &fcall);
if (result < 0) {
dprintk(DEBUG_ERROR, "stat error: %s(%d)\n", FCALL_ERROR(fcall),
result);
PRINT_FCALL_ERROR("stat error", fcall);
goto CleanUpFid;
}
v9fs_mistat2unix(fcall->params.rstat.stat, &newstat, sb);
file_inode = v9fs_get_inode(sb, newstat.st_mode);
file_inode = v9fs_get_inode(sb,
p9mode2unixmode(v9ses, fcall->params.rstat.stat.mode));
if ((!file_inode) || IS_ERR(file_inode)) {
dprintk(DEBUG_ERROR, "create inode failed\n");
result = -EBADF;
goto CleanUpFid;
}
v9fs_mistat2inode(fcall->params.rstat.stat, file_inode, sb);
v9fs_stat2inode(&fcall->params.rstat.stat, file_inode, sb);
kfree(fcall);
fcall = NULL;
file_dentry->d_op = &v9fs_dentry_operations;
......@@ -500,10 +428,9 @@ static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
}
result = v9fs_t_remove(v9ses, fid, &fcall);
if (result < 0)
dprintk(DEBUG_ERROR, "remove of file fails: %s(%d)\n",
FCALL_ERROR(fcall), result);
else {
if (result < 0) {
PRINT_FCALL_ERROR("remove fails", fcall);
} else {
v9fs_put_idpool(fid, &v9ses->fidpool);
v9fs_fid_destroy(v9fid);
}
......@@ -558,7 +485,6 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
struct v9fs_fid *fid;
struct inode *inode;
struct v9fs_fcall *fcall = NULL;
struct stat newstat;
int dirfidnum = -1;
int newfid = -1;
int result = 0;
......@@ -611,8 +537,8 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
goto FreeFcall;
}
v9fs_mistat2unix(fcall->params.rstat.stat, &newstat, sb);
inode = v9fs_get_inode(sb, newstat.st_mode);
inode = v9fs_get_inode(sb, p9mode2unixmode(v9ses,
fcall->params.rstat.stat.mode));
if (IS_ERR(inode) && (PTR_ERR(inode) == -ENOSPC)) {
eprintk(KERN_WARNING, "inode alloc failes, returns %ld\n",
......@@ -622,7 +548,7 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
goto FreeFcall;
}
inode->i_ino = v9fs_qid2ino(&fcall->params.rstat.stat->qid);
inode->i_ino = v9fs_qid2ino(&fcall->params.rstat.stat.qid);
fid = v9fs_fid_create(dentry, v9ses, newfid, 0);
if (fid == NULL) {
......@@ -631,10 +557,10 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
goto FreeFcall;
}
fid->qid = fcall->params.rstat.stat->qid;
fid->qid = fcall->params.rstat.stat.qid;
dentry->d_op = &v9fs_dentry_operations;
v9fs_mistat2inode(fcall->params.rstat.stat, inode, inode->i_sb);
v9fs_stat2inode(&fcall->params.rstat.stat, inode, inode->i_sb);
d_add(dentry, inode);
kfree(fcall);
......@@ -690,7 +616,7 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
v9fs_fid_lookup(old_dentry->d_parent);
struct v9fs_fid *newdirfid =
v9fs_fid_lookup(new_dentry->d_parent);
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL);
struct v9fs_wstat wstat;
struct v9fs_fcall *fcall = NULL;
int fid = -1;
int olddirfidnum = -1;
......@@ -699,9 +625,6 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
dprintk(DEBUG_VFS, "\n");
if (!mistat)
return -ENOMEM;
if ((!oldfid) || (!olddirfid) || (!newdirfid)) {
dprintk(DEBUG_ERROR, "problem with arguments\n");
return -EBADF;
......@@ -725,26 +648,15 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
goto FreeFcallnBail;
}
v9fs_blank_mistat(v9ses, mistat);
strcpy(mistat->data + 1, v9ses->name);
mistat->name = mistat->data + 1 + strlen(v9ses->name);
if (new_dentry->d_name.len >
(v9ses->maxdata - strlen(v9ses->name) - sizeof(struct v9fs_stat))) {
dprintk(DEBUG_ERROR, "new name too long\n");
goto FreeFcallnBail;
}
v9fs_blank_wstat(&wstat);
wstat.muid = v9ses->name;
wstat.name = (char *) new_dentry->d_name.name;
strcpy(mistat->name, new_dentry->d_name.name);
retval = v9fs_t_wstat(v9ses, fid, mistat, &fcall);
retval = v9fs_t_wstat(v9ses, fid, &wstat, &fcall);
FreeFcallnBail:
kfree(mistat);
if (retval < 0)
dprintk(DEBUG_ERROR, "v9fs_t_wstat error: %s\n",
FCALL_ERROR(fcall));
PRINT_FCALL_ERROR("wstat error", fcall);
kfree(fcall);
return retval;
......@@ -779,7 +691,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
if (err < 0)
dprintk(DEBUG_ERROR, "stat error\n");
else {
v9fs_mistat2inode(fcall->params.rstat.stat, dentry->d_inode,
v9fs_stat2inode(&fcall->params.rstat.stat, dentry->d_inode,
dentry->d_inode->i_sb);
generic_fillattr(dentry->d_inode, stat);
}
......@@ -800,57 +712,44 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
struct v9fs_fcall *fcall = NULL;
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL);
struct v9fs_wstat wstat;
int res = -EPERM;
dprintk(DEBUG_VFS, "\n");
if (!mistat)
return -ENOMEM;
if (!fid) {
dprintk(DEBUG_ERROR,
"Couldn't find fid associated with dentry\n");
return -EBADF;
}
v9fs_blank_mistat(v9ses, mistat);
v9fs_blank_wstat(&wstat);
if (iattr->ia_valid & ATTR_MODE)
mistat->mode = unixmode2p9mode(v9ses, iattr->ia_mode);
wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
if (iattr->ia_valid & ATTR_MTIME)
mistat->mtime = iattr->ia_mtime.tv_sec;
wstat.mtime = iattr->ia_mtime.tv_sec;
if (iattr->ia_valid & ATTR_ATIME)
mistat->atime = iattr->ia_atime.tv_sec;
wstat.atime = iattr->ia_atime.tv_sec;
if (iattr->ia_valid & ATTR_SIZE)
mistat->length = iattr->ia_size;
wstat.length = iattr->ia_size;
if (v9ses->extended) {
char *ptr = mistat->data+1;
if (iattr->ia_valid & ATTR_UID)
wstat.n_uid = iattr->ia_uid;
if (iattr->ia_valid & ATTR_UID) {
mistat->uid = ptr;
ptr += 1+sprintf(ptr, "%08x", iattr->ia_uid);
mistat->n_uid = iattr->ia_uid;
}
if (iattr->ia_valid & ATTR_GID) {
mistat->gid = ptr;
ptr += 1+sprintf(ptr, "%08x", iattr->ia_gid);
mistat->n_gid = iattr->ia_gid;
}
if (iattr->ia_valid & ATTR_GID)
wstat.n_gid = iattr->ia_gid;
}
res = v9fs_t_wstat(v9ses, fid->fid, mistat, &fcall);
res = v9fs_t_wstat(v9ses, fid->fid, &wstat, &fcall);
if (res < 0)
dprintk(DEBUG_ERROR, "wstat error: %s\n", FCALL_ERROR(fcall));
PRINT_FCALL_ERROR("wstat error", fcall);
kfree(mistat);
kfree(fcall);
if (res >= 0)
res = inode_setattr(dentry->d_inode, iattr);
......@@ -858,51 +757,42 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
}
/**
* v9fs_mistat2inode - populate an inode structure with mistat info
* @mistat: Plan 9 metadata (mistat) structure
* v9fs_stat2inode - populate an inode structure with mistat info
* @stat: Plan 9 metadata (mistat) structure
* @inode: inode to populate
* @sb: superblock of filesystem
*
*/
void
v9fs_mistat2inode(struct v9fs_stat *mistat, struct inode *inode,
struct super_block *sb)
v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
struct super_block *sb)
{
char ext[32];
struct v9fs_session_info *v9ses = sb->s_fs_info;
inode->i_nlink = 1;
inode->i_atime.tv_sec = mistat->atime;
inode->i_mtime.tv_sec = mistat->mtime;
inode->i_ctime.tv_sec = mistat->mtime;
inode->i_atime.tv_sec = stat->atime;
inode->i_mtime.tv_sec = stat->mtime;
inode->i_ctime.tv_sec = stat->mtime;
inode->i_uid = -1;
inode->i_gid = -1;
inode->i_uid = v9ses->uid;
inode->i_gid = v9ses->gid;
if (v9ses->extended) {
/* TODO: string to uid mapping via user-space daemon */
inode->i_uid = mistat->n_uid;
inode->i_gid = mistat->n_gid;
if (mistat->n_uid == -1)
sscanf(mistat->uid, "%x", &inode->i_uid);
if (mistat->n_gid == -1)
sscanf(mistat->gid, "%x", &inode->i_gid);
inode->i_uid = stat->n_uid;
inode->i_gid = stat->n_gid;
}
if (inode->i_uid == -1)
inode->i_uid = v9ses->uid;
if (inode->i_gid == -1)
inode->i_gid = v9ses->gid;
inode->i_mode = p9mode2unixmode(v9ses, mistat->mode);
inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
char type = 0;
int major = -1;
int minor = -1;
sscanf(mistat->extension, "%c %u %u", &type, &major, &minor);
v9fs_str_copy(ext, sizeof(ext), &stat->extension);
sscanf(ext, "%c %u %u", &type, &major, &minor);
switch (type) {
case 'c':
inode->i_mode &= ~S_IFBLK;
......@@ -911,14 +801,14 @@ v9fs_mistat2inode(struct v9fs_stat *mistat, struct inode *inode,
case 'b':
break;
default:
dprintk(DEBUG_ERROR, "Unknown special type %c (%s)\n",
type, mistat->extension);
dprintk(DEBUG_ERROR, "Unknown special type %c (%.*s)\n",
type, stat->extension.len, stat->extension.str);
};
inode->i_rdev = MKDEV(major, minor);
} else
inode->i_rdev = 0;
inode->i_size = mistat->length;
inode->i_size = stat->length;
inode->i_blksize = sb->s_blocksize;
inode->i_blocks =
......@@ -945,72 +835,6 @@ ino_t v9fs_qid2ino(struct v9fs_qid *qid)
return i;
}
/**
* v9fs_vfs_symlink - helper function to create symlinks
* @dir: directory inode containing symlink
* @dentry: dentry for symlink
* @symname: symlink data
*
* See 9P2000.u RFC for more information
*
*/
static int
v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
{
int retval = -EPERM;
struct v9fs_fid *newfid;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
struct v9fs_fcall *fcall = NULL;
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL);
int err;
dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
symname);
if (!mistat)
return -ENOMEM;
if (!v9ses->extended) {
dprintk(DEBUG_ERROR, "not extended\n");
goto FreeFcall;
}
/* issue a create */
retval = v9fs_create(dir, dentry, S_IFLNK, 0);
if (retval != 0)
goto FreeFcall;
newfid = v9fs_fid_lookup(dentry);
/* issue a twstat */
v9fs_blank_mistat(v9ses, mistat);
strcpy(mistat->data + 1, symname);
mistat->extension = mistat->data + 1;
retval = v9fs_t_wstat(v9ses, newfid->fid, mistat, &fcall);
if (retval < 0) {
dprintk(DEBUG_ERROR, "v9fs_t_wstat error: %s\n",
FCALL_ERROR(fcall));
goto FreeFcall;
}
kfree(fcall);
err = v9fs_t_clunk(v9ses, newfid->fid);
if (err < 0) {
dprintk(DEBUG_ERROR, "clunk for symlink failed: %d\n", err);
goto FreeFcall;
}
d_drop(dentry); /* FID - will this also clunk? */
FreeFcall:
kfree(mistat);
kfree(fcall);
return retval;
}
/**
* v9fs_readlink - read a symlink's location (internal version)
* @dentry: dentry for symlink
......@@ -1050,16 +874,17 @@ static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
if (!fcall)
return -EIO;
if (!(fcall->params.rstat.stat->mode & V9FS_DMSYMLINK)) {
if (!(fcall->params.rstat.stat.mode & V9FS_DMSYMLINK)) {
retval = -EINVAL;
goto FreeFcall;
}
/* copy extension buffer into buffer */
if (strlen(fcall->params.rstat.stat->extension) < buflen)
buflen = strlen(fcall->params.rstat.stat->extension);
if (fcall->params.rstat.stat.extension.len < buflen)
buflen = fcall->params.rstat.stat.extension.len;
memcpy(buffer, fcall->params.rstat.stat->extension, buflen + 1);
memcpy(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
buffer[buflen-1] = 0;
retval = buflen;
......@@ -1149,82 +974,111 @@ static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void
__putname(s);
}
/**
* v9fs_vfs_link - create a hardlink
* @old_dentry: dentry for file to link to
* @dir: inode destination for new link
* @dentry: dentry for link
*
*/
/* XXX - lots of code dup'd from symlink and creates,
* figure out a better reuse strategy
*/
static int
v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
int mode, const char *extension)
{
int retval = -EPERM;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
struct v9fs_fcall *fcall = NULL;
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL);
struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
struct v9fs_fid *newfid = NULL;
char *symname = __getname();
int err;
int err, retval;
struct v9fs_session_info *v9ses;
struct v9fs_fcall *fcall;
struct v9fs_fid *fid;
struct v9fs_wstat wstat;
dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
old_dentry->d_name.name);
v9ses = v9fs_inode2v9ses(dir);
retval = -EPERM;
fcall = NULL;
if (!v9ses->extended) {
dprintk(DEBUG_ERROR, "not extended\n");
goto FreeMem;
goto free_mem;
}
/* get fid of old_dentry */
sprintf(symname, "hardlink(%d)\n", oldfid->fid);
/* issue a create */
retval = v9fs_create(dir, dentry, V9FS_DMLINK, 0);
retval = v9fs_create(dir, dentry, mode, 0);
if (retval != 0)
goto FreeMem;
goto free_mem;
newfid = v9fs_fid_lookup(dentry);
if (!newfid) {
fid = v9fs_fid_get_created(dentry);
if (!fid) {
dprintk(DEBUG_ERROR, "couldn't resolve fid from dentry\n");
goto FreeMem;
goto free_mem;
}
/* issue a twstat */
v9fs_blank_mistat(v9ses, mistat);
strcpy(mistat->data + 1, symname);
mistat->extension = mistat->data + 1;
retval = v9fs_t_wstat(v9ses, newfid->fid, mistat, &fcall);
/* issue a Twstat */
v9fs_blank_wstat(&wstat);
wstat.muid = v9ses->name;
wstat.extension = (char *) extension;
retval = v9fs_t_wstat(v9ses, fid->fid, &wstat, &fcall);
if (retval < 0) {
dprintk(DEBUG_ERROR, "v9fs_t_wstat error: %s\n",
FCALL_ERROR(fcall));
goto FreeMem;
PRINT_FCALL_ERROR("wstat error", fcall);
goto free_mem;
}
kfree(fcall);
err = v9fs_t_clunk(v9ses, newfid->fid);
err = v9fs_t_clunk(v9ses, fid->fid);
if (err < 0) {
dprintk(DEBUG_ERROR, "clunk for symlink failed: %d\n", err);
goto FreeMem;
dprintk(DEBUG_ERROR, "clunk failed: %d\n", err);
goto free_mem;
}
d_drop(dentry); /* FID - will this also clunk? */
free_mem:
kfree(fcall);
fcall = NULL;
return retval;
}
/**
* v9fs_vfs_symlink - helper function to create symlinks
* @dir: directory inode containing symlink
* @dentry: dentry for symlink
* @symname: symlink data
*
* See 9P2000.u RFC for more information
*
*/
static int
v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
{
dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
symname);
return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
}
/**
* v9fs_vfs_link - create a hardlink
* @old_dentry: dentry for file to link to
* @dir: inode destination for new link
* @dentry: dentry for link
*
*/
/* XXX - lots of code dup'd from symlink and creates,
* figure out a better reuse strategy
*/
static int
v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
int retval;
struct v9fs_fid *oldfid;
char *name;
dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
old_dentry->d_name.name);
oldfid = v9fs_fid_lookup(old_dentry);
if (!oldfid) {
dprintk(DEBUG_ERROR, "can't find oldfid\n");
return -EPERM;
}
name = __getname();
sprintf(name, "hardlink(%d)\n", oldfid->fid);
retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
__putname(name);
FreeMem:
kfree(mistat);
kfree(fcall);
__putname(symname);
return retval;
}
......@@ -1240,83 +1094,30 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
static int
v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
{
int retval = -EPERM;
struct v9fs_fid *newfid;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
struct v9fs_fcall *fcall = NULL;
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL);
char *symname = __getname();
int err;
int retval;
char *name;
dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
if (!mistat)
return -ENOMEM;
if (!new_valid_dev(rdev)) {
retval = -EINVAL;
goto FreeMem;
}
if (!v9ses->extended) {
dprintk(DEBUG_ERROR, "not extended\n");
goto FreeMem;
}
/* issue a create */
retval = v9fs_create(dir, dentry, mode, 0);
if (retval != 0)
goto FreeMem;
newfid = v9fs_fid_lookup(dentry);
if (!newfid) {
dprintk(DEBUG_ERROR, "coudn't resove fid from dentry\n");
retval = -EINVAL;
goto FreeMem;
}
if (!new_valid_dev(rdev))
return -EINVAL;
name = __getname();
/* build extension */
if (S_ISBLK(mode))
sprintf(symname, "b %u %u", MAJOR(rdev), MINOR(rdev));
sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
else if (S_ISCHR(mode))
sprintf(symname, "c %u %u", MAJOR(rdev), MINOR(rdev));
sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
else if (S_ISFIFO(mode))
; /* DO NOTHING */
*name = 0;
else {
retval = -EINVAL;
goto FreeMem;
__putname(name);
return -EINVAL;
}
if (!S_ISFIFO(mode)) {
/* issue a twstat */
v9fs_blank_mistat(v9ses, mistat);
strcpy(mistat->data + 1, symname);
mistat->extension = mistat->data + 1;
retval = v9fs_t_wstat(v9ses, newfid->fid, mistat, &fcall);
if (retval < 0) {
dprintk(DEBUG_ERROR, "v9fs_t_wstat error: %s\n",
FCALL_ERROR(fcall));
goto FreeMem;
}
}
/* need to update dcache so we show up */
kfree(fcall);
err = v9fs_t_clunk(v9ses, newfid->fid);
if (err < 0) {
dprintk(DEBUG_ERROR, "clunk for symlink failed: %d\n", err);
goto FreeMem;
}
d_drop(dentry); /* FID - will this also clunk? */
FreeMem:
kfree(mistat);
kfree(fcall);
__putname(symname);
retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
__putname(name);
return retval;
}
......
fs/9p/vfs_super.c
View file @ 531b1094
......@@ -44,7 +44,6 @@
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "conv.h"
#include "fid.h"
static void v9fs_clear_inode(struct inode *);
......@@ -123,10 +122,11 @@ static struct super_block *v9fs_get_sb(struct file_system_type
dprintk(DEBUG_VFS, " \n");
v9ses = kcalloc(1, sizeof(struct v9fs_session_info), GFP_KERNEL);
v9ses = kmalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
if (!v9ses)
return ERR_PTR(-ENOMEM);
memset(v9ses, 0, sizeof(struct v9fs_session_info));
if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) {
dprintk(DEBUG_ERROR, "problem initiating session\n");
kfree(v9ses);
......@@ -168,10 +168,10 @@ static struct super_block *v9fs_get_sb(struct file_system_type
goto put_back_sb;
}
root_fid->qid = fcall->params.rstat.stat->qid;
root_fid->qid = fcall->params.rstat.stat.qid;
root->d_inode->i_ino =
v9fs_qid2ino(&fcall->params.rstat.stat->qid);
v9fs_mistat2inode(fcall->params.rstat.stat, root->d_inode, sb);
v9fs_qid2ino(&fcall->params.rstat.stat.qid);
v9fs_stat2inode(&fcall->params.rstat.stat, root->d_inode, sb);
}
kfree(fcall);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7