Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-26 22:21:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

[PATCH] v9fs: new multiplexer implementation

Browse Source 
New multiplexer implementation. Decreases the number of kernel threads
required. Better handling when the user process receives a signal.

Signed-off-by: Latchesar Ionkov <lucho@ionkov.net>
Cc: Eric Van Hensbergen <ericvh@ericvh.myip.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Latchesar Ionkov 2006-01-08 01:04:58 -08:00 committed by Linus Torvalds
parent f5ef3c105b
commit 3cf6429a26
16 changed files with 1223 additions and 613 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
fs/9p/9p.c
View File

@ -52,10 +52,11 @@ v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version); dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
msg.id = TVERSION; msg.id = TVERSION;
msg.tag = ~0;
msg.params.tversion.msize = msize; msg.params.tversion.msize = msize;
msg.params.tversion.version = version; msg.params.tversion.version = version;
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
} }
/** /**
@ -83,7 +84,30 @@ v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
msg.params.tattach.uname = uname; msg.params.tattach.uname = uname;
msg.params.tattach.aname = aname; msg.params.tattach.aname = aname;
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
}
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;
dprintk(DEBUG_9P, "tcall id %d rcall id %d\n", tc->id, rc->id);
v9ses = a;
if (rc->id == RCLUNK)
v9fs_put_idpool(fid, &v9ses->fidpool);
kfree(rc);
} }
/** /**
@ -93,18 +117,24 @@ v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
* @fcall: pointer to response fcall pointer * @fcall: pointer to response fcall pointer
* *
*/ */
int int
v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid, v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
struct v9fs_fcall **fcall)
{ {
struct v9fs_fcall msg; int err;
struct v9fs_fcall *tc, *rc;
tc = kmalloc(sizeof(struct v9fs_fcall), GFP_KERNEL);
dprintk(DEBUG_9P, "fid %d\n", fid); dprintk(DEBUG_9P, "fid %d\n", fid);
msg.id = TCLUNK; tc->id = TCLUNK;
msg.params.tclunk.fid = fid; tc->params.tclunk.fid = fid;
return v9fs_mux_rpc(v9ses, &msg, fcall); err = v9fs_mux_rpc(v9ses->mux, tc, &rc);
if (err >= 0) {
v9fs_t_clunk_cb(v9ses, tc, rc, 0);
}
return err;
} }
/** /**
@ -121,7 +151,7 @@ int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 tag)
dprintk(DEBUG_9P, "oldtag %d\n", tag); dprintk(DEBUG_9P, "oldtag %d\n", tag);
msg.id = TFLUSH; msg.id = TFLUSH;
msg.params.tflush.oldtag = tag; msg.params.tflush.oldtag = tag;
return v9fs_mux_rpc(v9ses, &msg, NULL); return v9fs_mux_rpc(v9ses->mux, &msg, NULL);
} }
/** /**
@ -143,7 +173,7 @@ v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **fcall)
msg.id = TSTAT; msg.id = TSTAT;
msg.params.tstat.fid = fid; msg.params.tstat.fid = fid;
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
} }
/** /**
@ -166,7 +196,7 @@ v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
msg.params.twstat.fid = fid; msg.params.twstat.fid = fid;
msg.params.twstat.stat = stat; msg.params.twstat.stat = stat;
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
} }
/** /**
@ -199,7 +229,7 @@ v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
msg.params.twalk.nwname = 0; msg.params.twalk.nwname = 0;
} }
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
} }
/** /**
@ -217,14 +247,14 @@ v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
struct v9fs_fcall **fcall) struct v9fs_fcall **fcall)
{ {
struct v9fs_fcall msg; struct v9fs_fcall msg;
long errorno = -1; int errorno = -1;
dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode); dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
msg.id = TOPEN; msg.id = TOPEN;
msg.params.topen.fid = fid; msg.params.topen.fid = fid;
msg.params.topen.mode = mode; msg.params.topen.mode = mode;
errorno = v9fs_mux_rpc(v9ses, &msg, fcall); errorno = v9fs_mux_rpc(v9ses->mux, &msg, fcall);
return errorno; return errorno;
} }
@ -246,7 +276,7 @@ v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
dprintk(DEBUG_9P, "fid %d\n", fid); dprintk(DEBUG_9P, "fid %d\n", fid);
msg.id = TREMOVE; msg.id = TREMOVE;
msg.params.tremove.fid = fid; msg.params.tremove.fid = fid;
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
} }
/** /**
@ -275,7 +305,7 @@ v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
msg.params.tcreate.perm = perm; msg.params.tcreate.perm = perm;
msg.params.tcreate.mode = mode; msg.params.tcreate.mode = mode;
return v9fs_mux_rpc(v9ses, &msg, fcall); return v9fs_mux_rpc(v9ses->mux, &msg, fcall);
} }
/** /**
@ -302,7 +332,7 @@ v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
msg.params.tread.fid = fid; msg.params.tread.fid = fid;
msg.params.tread.offset = offset; msg.params.tread.offset = offset;
msg.params.tread.count = count; msg.params.tread.count = count;
errorno = v9fs_mux_rpc(v9ses, &msg, &rc); errorno = v9fs_mux_rpc(v9ses->mux, &msg, &rc);
if (!errorno) { if (!errorno) {
errorno = rc->params.rread.count; errorno = rc->params.rread.count;
@ -345,7 +375,7 @@ v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid,
msg.params.twrite.count = count; msg.params.twrite.count = count;
msg.params.twrite.data = data; msg.params.twrite.data = data;
errorno = v9fs_mux_rpc(v9ses, &msg, &rc); errorno = v9fs_mux_rpc(v9ses->mux, &msg, &rc);
if (!errorno) if (!errorno)
errorno = rc->params.rwrite.count; errorno = rc->params.rwrite.count;

9
fs/9p/9p.h
View File

@ -100,6 +100,9 @@ enum {
V9FS_QTFILE = 0x00, V9FS_QTFILE = 0x00,
}; };
#define V9FS_NOTAG (u16)(~0)
#define V9FS_NOFID (u32)(~0)
/* ample room for Twrite/Rread header (iounit) */ /* ample room for Twrite/Rread header (iounit) */
#define V9FS_IOHDRSZ 24 #define V9FS_IOHDRSZ 24
@ -303,6 +306,9 @@ struct v9fs_fcall {
} params; } params;
}; };
#define V9FS_FCALLHDRSZ (sizeof(struct v9fs_fcall) + \
sizeof(struct v9fs_stat) + 16*sizeof(struct v9fs_qid) + 16)
#define FCALL_ERROR(fcall) (fcall ? fcall->params.rerror.error : "") #define FCALL_ERROR(fcall) (fcall ? fcall->params.rerror.error : "")
int v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize, int v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
@ -311,8 +317,7 @@ int v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
int v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname, int v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
u32 fid, u32 afid, struct v9fs_fcall **rcall); u32 fid, u32 afid, struct v9fs_fcall **rcall);
int v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid, int v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid);
struct v9fs_fcall **rcall);
int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag); int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag);

86
fs/9p/conv.c
View File

@ -208,7 +208,7 @@ static inline char *buf_get_stringb(struct cbuf *buf, struct cbuf *sbuf)
len = buf_get_int16(buf); len = buf_get_int16(buf);
if (!buf_check_overflow(buf) && buf_check_size(buf, len) && if (!buf_check_overflow(buf) && buf_check_size(buf, len) &&
buf_check_size(sbuf, len+1)) { buf_check_size(sbuf, len + 1)) {
memcpy(sbuf->p, buf->p, len); memcpy(sbuf->p, buf->p, len);
sbuf->p[len] = 0; sbuf->p[len] = 0;
@ -252,13 +252,12 @@ static inline void *buf_get_datab(struct cbuf *buf, struct cbuf *dbuf,
/** /**
* v9fs_size_stat - calculate the size of a variable length stat struct * v9fs_size_stat - calculate the size of a variable length stat struct
* @v9ses: session information
* @stat: metadata (stat) structure * @stat: metadata (stat) structure
* @extended: non-zero if 9P2000.u
* *
*/ */
static int v9fs_size_stat(struct v9fs_session_info *v9ses, static int v9fs_size_stat(struct v9fs_stat *stat, int extended)
struct v9fs_stat *stat)
{ {
int size = 0; int size = 0;
@ -288,7 +287,7 @@ static int v9fs_size_stat(struct v9fs_session_info *v9ses,
if (stat->muid) if (stat->muid)
size += strlen(stat->muid); size += strlen(stat->muid);
if (v9ses->extended) { if (extended) {
size += 4 + /* n_uid[4] */ size += 4 + /* n_uid[4] */
4 + /* n_gid[4] */ 4 + /* n_gid[4] */
4 + /* n_muid[4] */ 4 + /* n_muid[4] */
@ -302,15 +301,14 @@ static int v9fs_size_stat(struct v9fs_session_info *v9ses,
/** /**
* serialize_stat - safely format a stat structure for transmission * serialize_stat - safely format a stat structure for transmission
* @v9ses: session info
* @stat: metadata (stat) structure * @stat: metadata (stat) structure
* @bufp: buffer to serialize structure into * @bufp: buffer to serialize structure into
* @extended: non-zero if 9P2000.u
* *
*/ */
static int static int
serialize_stat(struct v9fs_session_info *v9ses, struct v9fs_stat *stat, serialize_stat(struct v9fs_stat *stat, struct cbuf *bufp, int extended)
struct cbuf *bufp)
{ {
buf_put_int16(bufp, stat->size); buf_put_int16(bufp, stat->size);
buf_put_int16(bufp, stat->type); buf_put_int16(bufp, stat->type);
@ -328,7 +326,7 @@ serialize_stat(struct v9fs_session_info *v9ses, struct v9fs_stat *stat,
buf_put_string(bufp, stat->gid); buf_put_string(bufp, stat->gid);
buf_put_string(bufp, stat->muid); buf_put_string(bufp, stat->muid);
if (v9ses->extended) { if (extended) {
buf_put_string(bufp, stat->extension); buf_put_string(bufp, stat->extension);
buf_put_int32(bufp, stat->n_uid); buf_put_int32(bufp, stat->n_uid);
buf_put_int32(bufp, stat->n_gid); buf_put_int32(bufp, stat->n_gid);
@ -343,16 +341,16 @@ serialize_stat(struct v9fs_session_info *v9ses, struct v9fs_stat *stat,
/** /**
* deserialize_stat - safely decode a recieved metadata (stat) structure * deserialize_stat - safely decode a recieved metadata (stat) structure
* @v9ses: session info
* @bufp: buffer to deserialize * @bufp: buffer to deserialize
* @stat: metadata (stat) structure * @stat: metadata (stat) structure
* @dbufp: buffer to deserialize variable strings into * @dbufp: buffer to deserialize variable strings into
* @extended: non-zero if 9P2000.u
* *
*/ */
static inline int static inline int
deserialize_stat(struct v9fs_session_info *v9ses, struct cbuf *bufp, deserialize_stat(struct cbuf *bufp, struct v9fs_stat *stat,
struct v9fs_stat *stat, struct cbuf *dbufp) struct cbuf *dbufp, int extended)
{ {
stat->size = buf_get_int16(bufp); stat->size = buf_get_int16(bufp);
@ -370,7 +368,7 @@ deserialize_stat(struct v9fs_session_info *v9ses, struct cbuf *bufp,
stat->gid = buf_get_stringb(bufp, dbufp); stat->gid = buf_get_stringb(bufp, dbufp);
stat->muid = buf_get_stringb(bufp, dbufp); stat->muid = buf_get_stringb(bufp, dbufp);
if (v9ses->extended) { if (extended) {
stat->extension = buf_get_stringb(bufp, dbufp); stat->extension = buf_get_stringb(bufp, dbufp);
stat->n_uid = buf_get_int32(bufp); stat->n_uid = buf_get_int32(bufp);
stat->n_gid = buf_get_int32(bufp); stat->n_gid = buf_get_int32(bufp);
@ -385,20 +383,20 @@ deserialize_stat(struct v9fs_session_info *v9ses, struct cbuf *bufp,
/** /**
* deserialize_statb - wrapper for decoding a received metadata structure * deserialize_statb - wrapper for decoding a received metadata structure
* @v9ses: session info
* @bufp: buffer to deserialize * @bufp: buffer to deserialize
* @dbufp: buffer to deserialize variable strings into * @dbufp: buffer to deserialize variable strings into
* @extended: non-zero if 9P2000.u
* *
*/ */
static inline struct v9fs_stat *deserialize_statb(struct v9fs_session_info static inline struct v9fs_stat *deserialize_statb(struct cbuf *bufp,
*v9ses, struct cbuf *bufp, struct cbuf *dbufp,
struct cbuf *dbufp) int extended)
{ {
struct v9fs_stat *ret = buf_alloc(dbufp, sizeof(struct v9fs_stat)); struct v9fs_stat *ret = buf_alloc(dbufp, sizeof(struct v9fs_stat));
if (ret) { if (ret) {
int n = deserialize_stat(v9ses, bufp, ret, dbufp); int n = deserialize_stat(bufp, ret, dbufp, extended);
if (n <= 0) if (n <= 0)
return NULL; return NULL;
} }
@ -408,17 +406,16 @@ static inline struct v9fs_stat *deserialize_statb(struct v9fs_session_info
/** /**
* v9fs_deserialize_stat - decode a received metadata structure * v9fs_deserialize_stat - decode a received metadata structure
* @v9ses: session info
* @buf: buffer to deserialize * @buf: buffer to deserialize
* @buflen: length of received buffer * @buflen: length of received buffer
* @stat: metadata structure to decode into * @stat: metadata structure to decode into
* @statlen: length of destination metadata structure * @statlen: length of destination metadata structure
* @extended: non-zero if 9P2000.u
* *
*/ */
int int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
v9fs_deserialize_stat(struct v9fs_session_info *v9ses, void *buf, u32 statlen, int extended)
u32 buflen, struct v9fs_stat *stat, u32 statlen)
{ {
struct cbuf buffer; struct cbuf buffer;
struct cbuf *bufp = &buffer; struct cbuf *bufp = &buffer;
@ -429,11 +426,10 @@ v9fs_deserialize_stat(struct v9fs_session_info *v9ses, void *buf,
buf_init(dbufp, (char *)stat + sizeof(struct v9fs_stat), buf_init(dbufp, (char *)stat + sizeof(struct v9fs_stat),
statlen - sizeof(struct v9fs_stat)); statlen - sizeof(struct v9fs_stat));
return deserialize_stat(v9ses, bufp, stat, dbufp); return deserialize_stat(bufp, stat, dbufp, extended);
} }
static inline int static inline int v9fs_size_fcall(struct v9fs_fcall *fcall, int extended)
v9fs_size_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall)
{ {
int size = 4 + 1 + 2; /* size[4] msg[1] tag[2] */ int size = 4 + 1 + 2; /* size[4] msg[1] tag[2] */
int i = 0; int i = 0;
@ -485,7 +481,7 @@ v9fs_size_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall)
break; break;
case TWSTAT: /* fid[4] stat[n] */ case TWSTAT: /* fid[4] stat[n] */
fcall->params.twstat.stat->size = fcall->params.twstat.stat->size =
v9fs_size_stat(v9ses, fcall->params.twstat.stat); v9fs_size_stat(fcall->params.twstat.stat, extended);
size += 4 + 2 + 2 + fcall->params.twstat.stat->size; size += 4 + 2 + 2 + fcall->params.twstat.stat->size;
} }
return size; return size;
@ -493,16 +489,16 @@ v9fs_size_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall)
/* /*
* v9fs_serialize_fcall - marshall fcall struct into a packet * v9fs_serialize_fcall - marshall fcall struct into a packet
* @v9ses: session information
* @fcall: structure to convert * @fcall: structure to convert
* @data: buffer to serialize fcall into * @data: buffer to serialize fcall into
* @datalen: length of buffer to serialize fcall into * @datalen: length of buffer to serialize fcall into
* @extended: non-zero if 9P2000.u
* *
*/ */
int int
v9fs_serialize_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall, v9fs_serialize_fcall(struct v9fs_fcall *fcall, void *data, u32 datalen,
void *data, u32 datalen) int extended)
{ {
int i = 0; int i = 0;
struct v9fs_stat *stat = NULL; struct v9fs_stat *stat = NULL;
@ -516,7 +512,7 @@ v9fs_serialize_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall,
return -EINVAL; return -EINVAL;
} }
fcall->size = v9fs_size_fcall(v9ses, fcall); fcall->size = v9fs_size_fcall(fcall, extended);
buf_put_int32(bufp, fcall->size); buf_put_int32(bufp, fcall->size);
buf_put_int8(bufp, fcall->id); buf_put_int8(bufp, fcall->id);
@ -591,31 +587,31 @@ v9fs_serialize_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall,
stat = fcall->params.twstat.stat; stat = fcall->params.twstat.stat;
buf_put_int16(bufp, stat->size + 2); buf_put_int16(bufp, stat->size + 2);
serialize_stat(v9ses, stat, bufp); serialize_stat(stat, bufp, extended);
break; break;
} }
if (buf_check_overflow(bufp)) if (buf_check_overflow(bufp)) {
dprintk(DEBUG_ERROR, "buffer overflow\n");
return -EIO; return -EIO;
}
return fcall->size; return fcall->size;
} }
/** /**
* deserialize_fcall - unmarshal a response * deserialize_fcall - unmarshal a response
* @v9ses: session information
* @msgsize: size of rcall message
* @buf: recieved buffer * @buf: recieved buffer
* @buflen: length of received buffer * @buflen: length of received buffer
* @rcall: fcall structure to populate * @rcall: fcall structure to populate
* @rcalllen: length of fcall structure to populate * @rcalllen: length of fcall structure to populate
* @extended: non-zero if 9P2000.u
* *
*/ */
int int
v9fs_deserialize_fcall(struct v9fs_session_info *v9ses, u32 msgsize, v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
void *buf, u32 buflen, struct v9fs_fcall *rcall, int rcalllen, int extended)
int rcalllen)
{ {
struct cbuf buffer; struct cbuf buffer;
@ -628,7 +624,7 @@ v9fs_deserialize_fcall(struct v9fs_session_info *v9ses, u32 msgsize,
buf_init(dbufp, (char *)rcall + sizeof(struct v9fs_fcall), buf_init(dbufp, (char *)rcall + sizeof(struct v9fs_fcall),
rcalllen - sizeof(struct v9fs_fcall)); rcalllen - sizeof(struct v9fs_fcall));
rcall->size = msgsize; rcall->size = buf_get_int32(bufp);
rcall->id = buf_get_int8(bufp); rcall->id = buf_get_int8(bufp);
rcall->tag = buf_get_int16(bufp); rcall->tag = buf_get_int16(bufp);
@ -651,6 +647,12 @@ v9fs_deserialize_fcall(struct v9fs_session_info *v9ses, u32 msgsize,
break; break;
case RWALK: case RWALK:
rcall->params.rwalk.nwqid = buf_get_int16(bufp); 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);
return -EPROTO;
}
rcall->params.rwalk.wqids = buf_alloc(dbufp, rcall->params.rwalk.wqids = buf_alloc(dbufp,
rcall->params.rwalk.nwqid * sizeof(struct v9fs_qid)); rcall->params.rwalk.nwqid * sizeof(struct v9fs_qid));
if (rcall->params.rwalk.wqids) if (rcall->params.rwalk.wqids)
@ -690,19 +692,21 @@ v9fs_deserialize_fcall(struct v9fs_session_info *v9ses, u32 msgsize,
case RSTAT: case RSTAT:
buf_get_int16(bufp); buf_get_int16(bufp);
rcall->params.rstat.stat = rcall->params.rstat.stat =
deserialize_statb(v9ses, bufp, dbufp); deserialize_statb(bufp, dbufp, extended);
break; break;
case RWSTAT: case RWSTAT:
break; break;
case RERROR: case RERROR:
rcall->params.rerror.error = buf_get_stringb(bufp, dbufp); rcall->params.rerror.error = buf_get_stringb(bufp, dbufp);
if (v9ses->extended) if (extended)
rcall->params.rerror.errno = buf_get_int16(bufp); rcall->params.rerror.errno = buf_get_int16(bufp);
break; break;
} }
if (buf_check_overflow(bufp) || buf_check_overflow(dbufp)) if (buf_check_overflow(bufp) || buf_check_overflow(dbufp)) {
dprintk(DEBUG_ERROR, "buffer overflow\n");
return -EIO; return -EIO;
}
return rcall->size; return rcall->size;
} }

13
fs/9p/conv.h
View File

@ -24,13 +24,12 @@
* *
*/ */
int v9fs_deserialize_stat(struct v9fs_session_info *, void *buf, int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
u32 buflen, struct v9fs_stat *stat, u32 statlen); u32 statlen, int extended);
int v9fs_serialize_fcall(struct v9fs_session_info *, struct v9fs_fcall *tcall, int v9fs_serialize_fcall(struct v9fs_fcall *tcall, void *buf, u32 buflen,
void *buf, u32 buflen); int extended);
int v9fs_deserialize_fcall(struct v9fs_session_info *, u32 msglen, int v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
void *buf, u32 buflen, struct v9fs_fcall *rcall, int rcalllen, int extended);
int rcalllen);
/* this one is actually in error.c right now */ /* this one is actually in error.c right now */
int v9fs_errstr2errno(char *errstr); int v9fs_errstr2errno(char *errstr);

2
fs/9p/fid.c
View File

@ -164,7 +164,7 @@ static struct v9fs_fid *v9fs_fid_walk_up(struct dentry *dentry)
return v9fs_fid_create(dentry, v9ses, fidnum, 0); return v9fs_fid_create(dentry, v9ses, fidnum, 0);
clunk_fid: clunk_fid:
v9fs_t_clunk(v9ses, fidnum, NULL); v9fs_t_clunk(v9ses, fidnum);
return ERR_PTR(err); return ERR_PTR(err);
} }

1222
fs/9p/mux.c
View File

File diff suppressed because it is too large Load Diff

40
fs/9p/mux.h
View File

@ -3,6 +3,7 @@
* *
* Multiplexer Definitions * Multiplexer Definitions
* *
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -23,19 +24,34 @@
* *
*/ */
/* structure to manage each RPC transaction */ struct v9fs_mux_data;
struct v9fs_rpcreq { /**
struct v9fs_fcall *tcall; * v9fs_mux_req_callback - callback function that is called when the
struct v9fs_fcall *rcall; * response of a request is received. The callback is called from
int err; /* error code if response failed */ * a workqueue and shouldn't block.
*
* @a - the pointer that was specified when the request was send to be
* passed to the callback
* @tc - request call
* @rc - response call
* @err - error code (non-zero if error occured)
*/
typedef void (*v9fs_mux_req_callback)(void *a, struct v9fs_fcall *tc,
struct v9fs_fcall *rc, int err);
/* XXX - could we put scatter/gather buffers here? */ void v9fs_mux_global_init(void);
void v9fs_mux_global_exit(void);
struct list_head next; struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
}; unsigned char *extended);
void v9fs_mux_destroy(struct v9fs_mux_data *);
int v9fs_mux_init(struct v9fs_session_info *v9ses, const char *dev_name); int v9fs_mux_send(struct v9fs_mux_data *m, struct v9fs_fcall *tc);
long v9fs_mux_rpc(struct v9fs_session_info *v9ses, struct v9fs_fcall *v9fs_mux_recv(struct v9fs_mux_data *m);
struct v9fs_fcall *tcall, struct v9fs_fcall **rcall); int v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc, struct v9fs_fcall **rc);
void v9fs_mux_cancel_requests(struct v9fs_session_info *v9ses, int err); int v9fs_mux_rpcnb(struct v9fs_mux_data *m, struct v9fs_fcall *tc,
v9fs_mux_req_callback cb, void *a);
void v9fs_mux_flush(struct v9fs_mux_data *m, int sendflush);
void v9fs_mux_cancel(struct v9fs_mux_data *m, int err);

49
fs/9p/trans_fd.c
View File

@ -3,6 +3,7 @@
* *
* File Descriptor Transport Layer * File Descriptor Transport Layer
* *
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com> * Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -106,9 +107,6 @@ v9fs_fd_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
return -ENOPROTOOPT; return -ENOPROTOOPT;
} }
sema_init(&trans->writelock, 1);
sema_init(&trans->readlock, 1);
ts = kmalloc(sizeof(struct v9fs_trans_fd), GFP_KERNEL); ts = kmalloc(sizeof(struct v9fs_trans_fd), GFP_KERNEL);
if (!ts) if (!ts)
@ -163,10 +161,55 @@ static void v9fs_fd_close(struct v9fs_transport *trans)
kfree(ts); kfree(ts);
} }
static unsigned int
v9fs_fd_poll(struct v9fs_transport *trans, struct poll_table_struct *pt)
{
int ret, n;
struct v9fs_trans_fd *ts;
mm_segment_t oldfs;
if (!trans)
return -EIO;
ts = trans->priv;
if (trans->status != Connected || !ts)
return -EIO;
oldfs = get_fs();
set_fs(get_ds());
if (!ts->in_file->f_op || !ts->in_file->f_op->poll) {
ret = -EIO;
goto end;
}
ret = ts->in_file->f_op->poll(ts->in_file, pt);
if (ts->out_file != ts->in_file) {
if (!ts->out_file->f_op || !ts->out_file->f_op->poll) {
ret = -EIO;
goto end;
}
n = ts->out_file->f_op->poll(ts->out_file, pt);
ret &= ~POLLOUT;
n &= ~POLLIN;
ret |= n;
}
end:
set_fs(oldfs);
return ret;
}
struct v9fs_transport v9fs_trans_fd = { struct v9fs_transport v9fs_trans_fd = {
.init = v9fs_fd_init, .init = v9fs_fd_init,
.write = v9fs_fd_send, .write = v9fs_fd_send,
.read = v9fs_fd_recv, .read = v9fs_fd_recv,
.close = v9fs_fd_close, .close = v9fs_fd_close,
.poll = v9fs_fd_poll,
}; };

163
fs/9p/trans_sock.c
View File

@ -3,6 +3,7 @@
* *
* Socket Transport Layer * Socket Transport Layer
* *
* Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com> * Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
* Copyright (C) 1995, 1996 by Olaf Kirch <okir@monad.swb.de> * Copyright (C) 1995, 1996 by Olaf Kirch <okir@monad.swb.de>
@ -36,6 +37,7 @@
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <linux/inet.h> #include <linux/inet.h>
#include <linux/idr.h> #include <linux/idr.h>
#include <linux/file.h>
#include "debug.h" #include "debug.h"
#include "v9fs.h" #include "v9fs.h"
@ -45,6 +47,7 @@
struct v9fs_trans_sock { struct v9fs_trans_sock {
struct socket *s; struct socket *s;
struct file *filp;
}; };
/** /**
@ -57,41 +60,26 @@ struct v9fs_trans_sock {
static int v9fs_sock_recv(struct v9fs_transport *trans, void *v, int len) static int v9fs_sock_recv(struct v9fs_transport *trans, void *v, int len)
{ {
struct msghdr msg; int ret;
struct kvec iov; struct v9fs_trans_sock *ts;
int result;
mm_segment_t oldfs;
struct v9fs_trans_sock *ts = trans ? trans->priv : NULL;
if (trans->status == Disconnected) if (!trans || trans->status == Disconnected) {
dprintk(DEBUG_ERROR, "disconnected ...\n");
return -EREMOTEIO; return -EREMOTEIO;
}
result = -EINVAL; ts = trans->priv;
oldfs = get_fs(); if (!(ts->filp->f_flags & O_NONBLOCK))
set_fs(get_ds()); dprintk(DEBUG_ERROR, "blocking read ...\n");
iov.iov_base = v; ret = kernel_read(ts->filp, ts->filp->f_pos, v, len);
iov.iov_len = len; if (ret <= 0) {
msg.msg_name = NULL; if (ret != -ERESTARTSYS && ret != -EAGAIN)
msg.msg_namelen = 0;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_namelen = 0;
msg.msg_flags = MSG_NOSIGNAL;
result = kernel_recvmsg(ts->s, &msg, &iov, 1, len, 0);
dprintk(DEBUG_TRANS, "socket state %d\n", ts->s->state);
set_fs(oldfs);
if (result <= 0) {
if (result != -ERESTARTSYS)
trans->status = Disconnected; trans->status = Disconnected;
} }
return result; return ret;
} }
/** /**
@ -104,40 +92,73 @@ static int v9fs_sock_recv(struct v9fs_transport *trans, void *v, int len)
static int v9fs_sock_send(struct v9fs_transport *trans, void *v, int len) static int v9fs_sock_send(struct v9fs_transport *trans, void *v, int len)
{ {
struct kvec iov; int ret;
struct msghdr msg;
int result = -1;
mm_segment_t oldfs; mm_segment_t oldfs;
struct v9fs_trans_sock *ts = trans ? trans->priv : NULL; struct v9fs_trans_sock *ts;
if (!trans || trans->status == Disconnected) {
dprintk(DEBUG_ERROR, "disconnected ...\n");
return -EREMOTEIO;
}
ts = trans->priv;
if (!ts) {
dprintk(DEBUG_ERROR, "no transport ...\n");
return -EREMOTEIO;
}
if (!(ts->filp->f_flags & O_NONBLOCK))
dprintk(DEBUG_ERROR, "blocking write ...\n");
dprintk(DEBUG_TRANS, "Sending packet size %d (%x)\n", len, len);
dump_data(v, len); dump_data(v, len);
down(&trans->writelock);
oldfs = get_fs(); oldfs = get_fs();
set_fs(get_ds()); set_fs(get_ds());
iov.iov_base = v; ret = vfs_write(ts->filp, (void __user *)v, len, &ts->filp->f_pos);
iov.iov_len = len;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_namelen = 0;
msg.msg_flags = MSG_NOSIGNAL;
result = kernel_sendmsg(ts->s, &msg, &iov, 1, len);
set_fs(oldfs); set_fs(oldfs);
if (result < 0) { if (ret < 0) {
if (result != -ERESTARTSYS) if (ret != -ERESTARTSYS)
trans->status = Disconnected; trans->status = Disconnected;
} }
up(&trans->writelock); return ret;
return result;
} }
static unsigned int v9fs_sock_poll(struct v9fs_transport *trans,
struct poll_table_struct *pt) {
int ret;
struct v9fs_trans_sock *ts;
mm_segment_t oldfs;
if (!trans) {
dprintk(DEBUG_ERROR, "no transport\n");
return -EIO;
}
ts = trans->priv;
if (trans->status != Connected || !ts) {
dprintk(DEBUG_ERROR, "transport disconnected: %d\n", trans->status);
return -EIO;
}
oldfs = get_fs();
set_fs(get_ds());
if (!ts->filp->f_op || !ts->filp->f_op->poll) {
dprintk(DEBUG_ERROR, "no poll operation\n");
ret = -EIO;
goto end;
}
ret = ts->filp->f_op->poll(ts->filp, pt);
end:
set_fs(oldfs);
return ret;
}
/** /**
* v9fs_tcp_init - initialize TCP socket * v9fs_tcp_init - initialize TCP socket
* @v9ses: session information * @v9ses: session information
@ -154,9 +175,9 @@ v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
int rc = 0; int rc = 0;
struct v9fs_trans_sock *ts = NULL; struct v9fs_trans_sock *ts = NULL;
struct v9fs_transport *trans = v9ses->transport; struct v9fs_transport *trans = v9ses->transport;
int fd;
sema_init(&trans->writelock, 1); trans->status = Disconnected;
sema_init(&trans->readlock, 1);
ts = kmalloc(sizeof(struct v9fs_trans_sock), GFP_KERNEL); ts = kmalloc(sizeof(struct v9fs_trans_sock), GFP_KERNEL);
@ -165,6 +186,7 @@ v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
trans->priv = ts; trans->priv = ts;
ts->s = NULL; ts->s = NULL;
ts->filp = NULL;
if (!addr) if (!addr)
return -EINVAL; return -EINVAL;
@ -185,7 +207,18 @@ v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
return rc; return rc;
} }
csocket->sk->sk_allocation = GFP_NOIO; csocket->sk->sk_allocation = GFP_NOIO;
fd = sock_map_fd(csocket);
if (fd < 0) {
sock_release(csocket);
kfree(ts);
trans->priv = NULL;
return fd;
}
ts->s = csocket; ts->s = csocket;
ts->filp = fget(fd);
ts->filp->f_flags |= O_NONBLOCK;
trans->status = Connected; trans->status = Connected;
return 0; return 0;
@ -203,7 +236,7 @@ static int
v9fs_unix_init(struct v9fs_session_info *v9ses, const char *dev_name, v9fs_unix_init(struct v9fs_session_info *v9ses, const char *dev_name,
char *data) char *data)
{ {
int rc; int rc, fd;
struct socket *csocket; struct socket *csocket;
struct sockaddr_un sun_server; struct sockaddr_un sun_server;
struct v9fs_transport *trans; struct v9fs_transport *trans;
@ -213,6 +246,8 @@ v9fs_unix_init(struct v9fs_session_info *v9ses, const char *dev_name,
csocket = NULL; csocket = NULL;
trans = v9ses->transport; trans = v9ses->transport;
trans->status = Disconnected;
if (strlen(dev_name) > UNIX_PATH_MAX) { if (strlen(dev_name) > UNIX_PATH_MAX) {
eprintk(KERN_ERR, "v9fs_trans_unix: address too long: %s\n", eprintk(KERN_ERR, "v9fs_trans_unix: address too long: %s\n",
dev_name); dev_name);
@ -225,9 +260,7 @@ v9fs_unix_init(struct v9fs_session_info *v9ses, const char *dev_name,
trans->priv = ts; trans->priv = ts;
ts->s = NULL; ts->s = NULL;
ts->filp = NULL;
sema_init(&trans->writelock, 1);
sema_init(&trans->readlock, 1);
sun_server.sun_family = PF_UNIX; sun_server.sun_family = PF_UNIX;
strcpy(sun_server.sun_path, dev_name); strcpy(sun_server.sun_path, dev_name);
@ -241,7 +274,18 @@ v9fs_unix_init(struct v9fs_session_info *v9ses, const char *dev_name,
return rc; return rc;
} }
csocket->sk->sk_allocation = GFP_NOIO; csocket->sk->sk_allocation = GFP_NOIO;
fd = sock_map_fd(csocket);
if (fd < 0) {
sock_release(csocket);
kfree(ts);
trans->priv = NULL;
return fd;
}
ts->s = csocket; ts->s = csocket;
ts->filp = fget(fd);
ts->filp->f_flags |= O_NONBLOCK;
trans->status = Connected; trans->status = Connected;
return 0; return 0;
@ -262,12 +306,11 @@ static void v9fs_sock_close(struct v9fs_transport *trans)
ts = trans->priv; ts = trans->priv;
if ((ts) && (ts->s)) { if ((ts) && (ts->filp)) {
dprintk(DEBUG_TRANS, "closing the socket %p\n", ts->s); fput(ts->filp);
sock_release(ts->s); ts->filp = NULL;
ts->s = NULL; ts->s = NULL;
trans->status = Disconnected; trans->status = Disconnected;
dprintk(DEBUG_TRANS, "socket closed\n");
} }
kfree(ts); kfree(ts);
@ -280,6 +323,7 @@ struct v9fs_transport v9fs_trans_tcp = {
.write = v9fs_sock_send, .write = v9fs_sock_send,
.read = v9fs_sock_recv, .read = v9fs_sock_recv,
.close = v9fs_sock_close, .close = v9fs_sock_close,
.poll = v9fs_sock_poll,
}; };
struct v9fs_transport v9fs_trans_unix = { struct v9fs_transport v9fs_trans_unix = {
@ -287,4 +331,5 @@ struct v9fs_transport v9fs_trans_unix = {
.write = v9fs_sock_send, .write = v9fs_sock_send,
.read = v9fs_sock_recv, .read = v9fs_sock_recv,
.close = v9fs_sock_close, .close = v9fs_sock_close,
.poll = v9fs_sock_poll,
}; };

4
fs/9p/transport.h
View File

@ -3,6 +3,7 @@
* *
* Transport Definition * Transport Definition
* *
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -31,14 +32,13 @@ enum v9fs_transport_status {
struct v9fs_transport { struct v9fs_transport {
enum v9fs_transport_status status; enum v9fs_transport_status status;
struct semaphore writelock;
struct semaphore readlock;
void *priv; void *priv;
int (*init) (struct v9fs_session_info *, const char *, char *); int (*init) (struct v9fs_session_info *, const char *, char *);
int (*write) (struct v9fs_transport *, void *, int); int (*write) (struct v9fs_transport *, void *, int);
int (*read) (struct v9fs_transport *, void *, int); int (*read) (struct v9fs_transport *, void *, int);
void (*close) (struct v9fs_transport *); void (*close) (struct v9fs_transport *);
unsigned int (*poll)(struct v9fs_transport *, struct poll_table_struct *);
}; };
extern struct v9fs_transport v9fs_trans_tcp; extern struct v9fs_transport v9fs_trans_tcp;

41
fs/9p/v9fs.c
View File

@ -213,7 +213,8 @@ retry:
return -1; return -1;
} }
error = idr_get_new(&p->pool, NULL, &i); /* no need to store exactly p, we just need something non-null */
error = idr_get_new(&p->pool, p, &i);
up(&p->lock); up(&p->lock);
if (error == -EAGAIN) if (error == -EAGAIN)
@ -242,6 +243,16 @@ void v9fs_put_idpool(int id, struct v9fs_idpool *p)
up(&p->lock); up(&p->lock);
} }
/**
* v9fs_check_idpool - check if the specified id is available
* @id - id to check
* @p - pool
*/
int v9fs_check_idpool(int id, struct v9fs_idpool *p)
{
return idr_find(&p->pool, id) != NULL;
}
/** /**
* v9fs_session_init - initialize session * v9fs_session_init - initialize session
* @v9ses: session information structure * @v9ses: session information structure
@ -281,9 +292,6 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
/* id pools that are session-dependent: FIDs and TIDs */ /* id pools that are session-dependent: FIDs and TIDs */
idr_init(&v9ses->fidpool.pool); idr_init(&v9ses->fidpool.pool);
init_MUTEX(&v9ses->fidpool.lock); init_MUTEX(&v9ses->fidpool.lock);
idr_init(&v9ses->tidpool.pool);
init_MUTEX(&v9ses->tidpool.lock);
switch (v9ses->proto) { switch (v9ses->proto) {
case PROTO_TCP: case PROTO_TCP:
@ -320,7 +328,12 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
v9ses->shutdown = 0; v9ses->shutdown = 0;
v9ses->session_hung = 0; v9ses->session_hung = 0;
if ((retval = v9fs_mux_init(v9ses, dev_name)) < 0) { v9ses->mux = v9fs_mux_init(v9ses->transport, v9ses->maxdata + V9FS_IOHDRSZ,
&v9ses->extended);
if (IS_ERR(v9ses->mux)) {
retval = PTR_ERR(v9ses->mux);
v9ses->mux = NULL;
dprintk(DEBUG_ERROR, "problem initializing mux\n"); dprintk(DEBUG_ERROR, "problem initializing mux\n");
goto SessCleanUp; goto SessCleanUp;
} }
@ -381,7 +394,7 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
} }
if (v9ses->afid != ~0) { if (v9ses->afid != ~0) {
if (v9fs_t_clunk(v9ses, v9ses->afid, NULL)) if (v9fs_t_clunk(v9ses, v9ses->afid))
dprintk(DEBUG_ERROR, "clunk failed\n"); dprintk(DEBUG_ERROR, "clunk failed\n");
} }
@ -403,13 +416,16 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
void v9fs_session_close(struct v9fs_session_info *v9ses) void v9fs_session_close(struct v9fs_session_info *v9ses)
{ {
if (v9ses->recvproc) { if (v9ses->mux) {
send_sig(SIGKILL, v9ses->recvproc, 1); v9fs_mux_destroy(v9ses->mux);
wait_for_completion(&v9ses->proccmpl); v9ses->mux = NULL;
} }
if (v9ses->transport) if (v9ses->transport) {
v9ses->transport->close(v9ses->transport); v9ses->transport->close(v9ses->transport);
kfree(v9ses->transport);
v9ses->transport = NULL;
}
__putname(v9ses->name); __putname(v9ses->name);
__putname(v9ses->remotename); __putname(v9ses->remotename);
@ -420,8 +436,9 @@ void v9fs_session_close(struct v9fs_session_info *v9ses)
* and cancel all pending requests. * and cancel all pending requests.
*/ */
void v9fs_session_cancel(struct v9fs_session_info *v9ses) { void v9fs_session_cancel(struct v9fs_session_info *v9ses) {
dprintk(DEBUG_ERROR, "cancel session %p\n", v9ses);
v9ses->transport->status = Disconnected; v9ses->transport->status = Disconnected;
v9fs_mux_cancel_requests(v9ses, -EIO); v9fs_mux_cancel(v9ses->mux, -EIO);
} }
extern int v9fs_error_init(void); extern int v9fs_error_init(void);
@ -437,6 +454,7 @@ static int __init init_v9fs(void)
printk(KERN_INFO "Installing v9fs 9P2000 file system support\n"); printk(KERN_INFO "Installing v9fs 9P2000 file system support\n");
v9fs_mux_global_init();
return register_filesystem(&v9fs_fs_type); return register_filesystem(&v9fs_fs_type);
} }
@ -447,6 +465,7 @@ static int __init init_v9fs(void)
static void __exit exit_v9fs(void) static void __exit exit_v9fs(void)
{ {
v9fs_mux_global_exit();
unregister_filesystem(&v9fs_fs_type); unregister_filesystem(&v9fs_fs_type);
} }

17
fs/9p/v9fs.h
View File

@ -57,24 +57,14 @@ struct v9fs_session_info {
/* book keeping */ /* book keeping */
struct v9fs_idpool fidpool; /* The FID pool for file descriptors */ struct v9fs_idpool fidpool; /* The FID pool for file descriptors */
struct v9fs_idpool tidpool; /* The TID pool for transactions ids */
/* transport information */
struct v9fs_transport *transport; struct v9fs_transport *transport;
struct v9fs_mux_data *mux;
int inprogress; /* session in progress => true */ int inprogress; /* session in progress => true */
int shutdown; /* session shutting down. no more attaches. */ int shutdown; /* session shutting down. no more attaches. */
unsigned char session_hung; unsigned char session_hung;
struct dentry *debugfs_dir;
/* mux private data */
struct v9fs_fcall *curfcall;
wait_queue_head_t read_wait;
struct completion fcread;
struct completion proccmpl;
struct task_struct *recvproc;
spinlock_t muxlock;
struct list_head mux_fcalls;
}; };
/* possible values of ->proto */ /* possible values of ->proto */
@ -84,11 +74,14 @@ enum {
PROTO_FD, PROTO_FD,
}; };
extern struct dentry *v9fs_debugfs_root;
int v9fs_session_init(struct v9fs_session_info *, const char *, char *); int v9fs_session_init(struct v9fs_session_info *, const char *, char *);
struct v9fs_session_info *v9fs_inode2v9ses(struct inode *); struct v9fs_session_info *v9fs_inode2v9ses(struct inode *);
void v9fs_session_close(struct v9fs_session_info *v9ses); void v9fs_session_close(struct v9fs_session_info *v9ses);
int v9fs_get_idpool(struct v9fs_idpool *p); int v9fs_get_idpool(struct v9fs_idpool *p);
void v9fs_put_idpool(int id, struct v9fs_idpool *p); void v9fs_put_idpool(int id, struct v9fs_idpool *p);
int v9fs_check_idpool(int id, struct v9fs_idpool *p);
void v9fs_session_cancel(struct v9fs_session_info *v9ses); void v9fs_session_cancel(struct v9fs_session_info *v9ses);
#define V9FS_MAGIC 0x01021997 #define V9FS_MAGIC 0x01021997

13
fs/9p/vfs_dentry.c
View File

@ -95,24 +95,21 @@ static int v9fs_dentry_validate(struct dentry *dentry, struct nameidata *nd)
void v9fs_dentry_release(struct dentry *dentry) void v9fs_dentry_release(struct dentry *dentry)
{ {
int err;
dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry); dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
if (dentry->d_fsdata != NULL) { if (dentry->d_fsdata != NULL) {
struct list_head *fid_list = dentry->d_fsdata; struct list_head *fid_list = dentry->d_fsdata;
struct v9fs_fid *temp = NULL; struct v9fs_fid *temp = NULL;
struct v9fs_fid *current_fid = NULL; struct v9fs_fid *current_fid = NULL;
struct v9fs_fcall *fcall = NULL;
list_for_each_entry_safe(current_fid, temp, fid_list, list) { list_for_each_entry_safe(current_fid, temp, fid_list, list) {
if (v9fs_t_clunk err = v9fs_t_clunk(current_fid->v9ses, current_fid->fid);
(current_fid->v9ses, current_fid->fid, &fcall))
dprintk(DEBUG_ERROR, "clunk failed: %s\n",
FCALL_ERROR(fcall));
v9fs_put_idpool(current_fid->fid, if (err < 0)
&current_fid->v9ses->fidpool); dprintk(DEBUG_ERROR, "clunk failed: %d\n", err);
kfree(fcall);
v9fs_fid_destroy(current_fid); v9fs_fid_destroy(current_fid);
} }

17
fs/9p/vfs_dir.c
View File

@ -74,7 +74,7 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
struct inode *inode = filp->f_dentry->d_inode; struct inode *inode = filp->f_dentry->d_inode;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode); struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
struct v9fs_fid *file = filp->private_data; struct v9fs_fid *file = filp->private_data;
unsigned int i, n; unsigned int i, n, s;
int fid = -1; int fid = -1;
int ret = 0; int ret = 0;
struct v9fs_stat *mi = NULL; struct v9fs_stat *mi = NULL;
@ -97,9 +97,9 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
n = file->rdir_fcall->params.rread.count; n = file->rdir_fcall->params.rread.count;
i = file->rdir_fpos; i = file->rdir_fpos;
while (i < n) { while (i < n) {
int s = v9fs_deserialize_stat(v9ses, s = v9fs_deserialize_stat(
file->rdir_fcall->params.rread.data + i, file->rdir_fcall->params.rread.data + i,
n - i, mi, v9ses->maxdata); n - i, mi, v9ses->maxdata, v9ses->extended);
if (s == 0) { if (s == 0) {
dprintk(DEBUG_ERROR, dprintk(DEBUG_ERROR,
@ -141,9 +141,8 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
n = ret; n = ret;
i = 0; i = 0;
while (i < n) { while (i < n) {
int s = v9fs_deserialize_stat(v9ses, s = v9fs_deserialize_stat(fcall->params.rread.data + i,
fcall->params.rread.data + i, n - i, mi, n - i, mi, v9ses->maxdata, v9ses->extended);
v9ses->maxdata);
if (s == 0) { if (s == 0) {
dprintk(DEBUG_ERROR, dprintk(DEBUG_ERROR,
@ -199,11 +198,9 @@ int v9fs_dir_release(struct inode *inode, struct file *filp)
dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen, dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
fid->fid); fid->fid);
if (v9fs_t_clunk(v9ses, fidnum, NULL)) if (v9fs_t_clunk(v9ses, fidnum))
dprintk(DEBUG_ERROR, "clunk failed\n"); dprintk(DEBUG_ERROR, "clunk failed\n");
v9fs_put_idpool(fid->fid, &v9ses->fidpool);
kfree(fid->rdir_fcall); kfree(fid->rdir_fcall);
kfree(fid); kfree(fid);

89
fs/9p/vfs_inode.c
View File

@ -318,6 +318,7 @@ v9fs_create(struct inode *dir,
int result = 0; int result = 0;
unsigned int iounit = 0; unsigned int iounit = 0;
int wfidno = -1; int wfidno = -1;
int err;
perm = unixmode2p9mode(v9ses, perm); perm = unixmode2p9mode(v9ses, perm);
@ -356,6 +357,7 @@ v9fs_create(struct inode *dir,
} }
kfree(fcall); kfree(fcall);
fcall = NULL;
result = v9fs_t_create(v9ses, newfid, (char *)file_dentry->d_name.name, result = v9fs_t_create(v9ses, newfid, (char *)file_dentry->d_name.name,
perm, open_mode, &fcall); perm, open_mode, &fcall);
@ -369,17 +371,24 @@ v9fs_create(struct inode *dir,
iounit = fcall->params.rcreate.iounit; iounit = fcall->params.rcreate.iounit;
qid = fcall->params.rcreate.qid; qid = fcall->params.rcreate.qid;
kfree(fcall); kfree(fcall);
fcall = NULL;
fid = v9fs_fid_create(file_dentry, v9ses, newfid, 1); if (!(perm&V9FS_DMDIR)) {
dprintk(DEBUG_VFS, "fid %p %d\n", fid, fid->fidcreate); fid = v9fs_fid_create(file_dentry, v9ses, newfid, 1);
if (!fid) { dprintk(DEBUG_VFS, "fid %p %d\n", fid, fid->fidcreate);
result = -ENOMEM; if (!fid) {
goto CleanUpFid; result = -ENOMEM;
goto CleanUpFid;
}
fid->qid = qid;
fid->iounit = iounit;
} else {
err = v9fs_t_clunk(v9ses, newfid);
if (err < 0)
dprintk(DEBUG_ERROR, "clunk for mkdir failed: %d\n", err);
} }
fid->qid = qid;
fid->iounit = iounit;
/* walk to the newly created file and put the fid in the dentry */ /* walk to the newly created file and put the fid in the dentry */
wfidno = v9fs_get_idpool(&v9ses->fidpool); wfidno = v9fs_get_idpool(&v9ses->fidpool);
if (newfid < 0) { if (newfid < 0) {
@ -388,18 +397,19 @@ v9fs_create(struct inode *dir,
} }
result = v9fs_t_walk(v9ses, dirfidnum, wfidno, result = v9fs_t_walk(v9ses, dirfidnum, wfidno,
(char *) file_dentry->d_name.name, NULL); (char *) file_dentry->d_name.name, &fcall);
if (result < 0) { if (result < 0) {
dprintk(DEBUG_ERROR, "clone error: %s\n", FCALL_ERROR(fcall)); dprintk(DEBUG_ERROR, "clone error: %s\n", FCALL_ERROR(fcall));
v9fs_put_idpool(wfidno, &v9ses->fidpool); v9fs_put_idpool(wfidno, &v9ses->fidpool);
wfidno = -1; wfidno = -1;
goto CleanUpFid; goto CleanUpFid;
} }
kfree(fcall);
fcall = NULL;
if (!v9fs_fid_create(file_dentry, v9ses, wfidno, 0)) { if (!v9fs_fid_create(file_dentry, v9ses, wfidno, 0)) {
if (!v9fs_t_clunk(v9ses, newfid, &fcall)) { v9fs_t_clunk(v9ses, newfid);
v9fs_put_idpool(wfidno, &v9ses->fidpool); v9fs_put_idpool(wfidno, &v9ses->fidpool);
}
goto CleanUpFid; goto CleanUpFid;
} }
@ -431,40 +441,21 @@ v9fs_create(struct inode *dir,
file_dentry->d_op = &v9fs_dentry_operations; file_dentry->d_op = &v9fs_dentry_operations;
d_instantiate(file_dentry, file_inode); d_instantiate(file_dentry, file_inode);
if (perm & V9FS_DMDIR) {
if (!v9fs_t_clunk(v9ses, newfid, &fcall))
v9fs_put_idpool(newfid, &v9ses->fidpool);
else
dprintk(DEBUG_ERROR, "clunk for mkdir failed: %s\n",
FCALL_ERROR(fcall));
kfree(fcall);
fid->fidopen = 0;
fid->fidcreate = 0;
d_drop(file_dentry);
}
return 0; return 0;
CleanUpFid: CleanUpFid:
kfree(fcall); kfree(fcall);
fcall = NULL;
if (newfid >= 0) { if (newfid >= 0) {
if (!v9fs_t_clunk(v9ses, newfid, &fcall)) err = v9fs_t_clunk(v9ses, newfid);
v9fs_put_idpool(newfid, &v9ses->fidpool); if (err < 0)
else dprintk(DEBUG_ERROR, "clunk failed: %d\n", err);
dprintk(DEBUG_ERROR, "clunk failed: %s\n",
FCALL_ERROR(fcall));
kfree(fcall);
} }
if (wfidno >= 0) { if (wfidno >= 0) {
if (!v9fs_t_clunk(v9ses, wfidno, &fcall)) err = v9fs_t_clunk(v9ses, wfidno);
v9fs_put_idpool(wfidno, &v9ses->fidpool); if (err < 0)
else dprintk(DEBUG_ERROR, "clunk failed: %d\n", err);
dprintk(DEBUG_ERROR, "clunk failed: %s\n",
FCALL_ERROR(fcall));
kfree(fcall);
} }
return result; return result;
} }
@ -972,6 +963,7 @@ v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir); struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
struct v9fs_fcall *fcall = NULL; struct v9fs_fcall *fcall = NULL;
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL); 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, dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
symname); symname);
@ -1004,9 +996,9 @@ v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
kfree(fcall); kfree(fcall);
if (v9fs_t_clunk(v9ses, newfid->fid, &fcall)) { err = v9fs_t_clunk(v9ses, newfid->fid);
dprintk(DEBUG_ERROR, "clunk for symlink failed: %s\n", if (err < 0) {
FCALL_ERROR(fcall)); dprintk(DEBUG_ERROR, "clunk for symlink failed: %d\n", err);
goto FreeFcall; goto FreeFcall;
} }
@ -1180,6 +1172,7 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry); struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
struct v9fs_fid *newfid = NULL; struct v9fs_fid *newfid = NULL;
char *symname = __getname(); char *symname = __getname();
int err;
dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name, dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
old_dentry->d_name.name); old_dentry->d_name.name);
@ -1216,9 +1209,10 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
kfree(fcall); kfree(fcall);
if (v9fs_t_clunk(v9ses, newfid->fid, &fcall)) { err = v9fs_t_clunk(v9ses, newfid->fid);
dprintk(DEBUG_ERROR, "clunk for symlink failed: %s\n",
FCALL_ERROR(fcall)); if (err < 0) {
dprintk(DEBUG_ERROR, "clunk for symlink failed: %d\n", err);
goto FreeMem; goto FreeMem;
} }
@ -1252,6 +1246,7 @@ v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
struct v9fs_fcall *fcall = NULL; struct v9fs_fcall *fcall = NULL;
struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL); struct v9fs_stat *mistat = kmalloc(v9ses->maxdata, GFP_KERNEL);
char *symname = __getname(); char *symname = __getname();
int err;
dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino, dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev)); dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
@ -1310,9 +1305,9 @@ v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
/* need to update dcache so we show up */ /* need to update dcache so we show up */
kfree(fcall); kfree(fcall);
if (v9fs_t_clunk(v9ses, newfid->fid, &fcall)) { err = v9fs_t_clunk(v9ses, newfid->fid);
dprintk(DEBUG_ERROR, "clunk for symlink failed: %s\n", if (err < 0) {
FCALL_ERROR(fcall)); dprintk(DEBUG_ERROR, "clunk for symlink failed: %d\n", err);
goto FreeMem; goto FreeMem;
} }

3
fs/9p/vfs_super.c
View File

@ -129,6 +129,7 @@ static struct super_block *v9fs_get_sb(struct file_system_type
if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) { if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) {
dprintk(DEBUG_ERROR, "problem initiating session\n"); dprintk(DEBUG_ERROR, "problem initiating session\n");
kfree(v9ses);
return ERR_PTR(newfid); return ERR_PTR(newfid);
} }
@ -157,7 +158,7 @@ static struct super_block *v9fs_get_sb(struct file_system_type
stat_result = v9fs_t_stat(v9ses, newfid, &fcall); stat_result = v9fs_t_stat(v9ses, newfid, &fcall);
if (stat_result < 0) { if (stat_result < 0) {
dprintk(DEBUG_ERROR, "stat error\n"); dprintk(DEBUG_ERROR, "stat error\n");
v9fs_t_clunk(v9ses, newfid, NULL); v9fs_t_clunk(v9ses, newfid);
v9fs_put_idpool(newfid, &v9ses->fidpool); v9fs_put_idpool(newfid, &v9ses->fidpool);
} else { } else {
/* Setup the Root Inode */ /* Setup the Root Inode */