Revision 2cc78eb52bc1ae89f0a4fa5a00eb998dffde4a9f authored by Linus Torvalds on 17 October 2005, 16:10:15 UTC, committed by Linus Torvalds on 17 October 2005, 16:10:15 UTC
Dipankar made RCU limit the batch size to improve latency, but that approach is unworkable: it can cause the RCU queues to grow without bounds, since the batch limiter ended up limiting the callbacks. So make the limit much higher, and start planning on instead limiting the batch size by doing RCU callbacks more often if the queue looks like it might be growing too long. Signed-off-by: Linus Torvalds <torvalds@osdl.org>
1 parent de21eb6
conv.c
/*
* linux/fs/9p/conv.c
*
* 9P protocol conversion functions
*
* Copyright (C) 2004, 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>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to:
* Free Software Foundation
* 51 Franklin Street, Fifth Floor
* Boston, MA 02111-1301 USA
*
*/
#include <linux/config.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
/*
* Buffer to help with string parsing
*/
struct cbuf {
unsigned char *sp;
unsigned char *p;
unsigned char *ep;
};
static inline void buf_init(struct cbuf *buf, void *data, int datalen)
{
buf->sp = buf->p = data;
buf->ep = data + datalen;
}
static inline int buf_check_overflow(struct cbuf *buf)
{
return buf->p > buf->ep;
}
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;
}
}
return 1;
}
static inline void *buf_alloc(struct cbuf *buf, int len)
{
void *ret = NULL;
if (buf_check_size(buf, len)) {
ret = buf->p;
buf->p += len;
}
return ret;
}
static inline void buf_put_int8(struct cbuf *buf, u8 val)
{
if (buf_check_size(buf, 1)) {
buf->p[0] = val;
buf->p++;
}
}
static inline void buf_put_int16(struct cbuf *buf, u16 val)
{
if (buf_check_size(buf, 2)) {
*(__le16 *) buf->p = cpu_to_le16(val);
buf->p += 2;
}
}
static inline void buf_put_int32(struct cbuf *buf, u32 val)
{
if (buf_check_size(buf, 4)) {
*(__le32 *)buf->p = cpu_to_le32(val);
buf->p += 4;
}
}
static inline void buf_put_int64(struct cbuf *buf, u64 val)
{
if (buf_check_size(buf, 8)) {
*(__le64 *)buf->p = cpu_to_le64(val);
buf->p += 8;
}
}
static inline void buf_put_stringn(struct cbuf *buf, const char *s, u16 slen)
{
if (buf_check_size(buf, slen + 2)) {
buf_put_int16(buf, slen);
memcpy(buf->p, s, slen);
buf->p += slen;
}
}
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;
if (buf_check_size(buf, 1)) {
ret = buf->p[0];
buf->p++;
}
return ret;
}
static inline u16 buf_get_int16(struct cbuf *buf)
{
u16 ret = 0;
if (buf_check_size(buf, 2)) {
ret = le16_to_cpu(*(__le16 *)buf->p);
buf->p += 2;
}
return ret;
}
static inline u32 buf_get_int32(struct cbuf *buf)
{
u32 ret = 0;
if (buf_check_size(buf, 4)) {
ret = le32_to_cpu(*(__le32 *)buf->p);
buf->p += 4;
}
return ret;
}
static inline u64 buf_get_int64(struct cbuf *buf)
{
u64 ret = 0;
if (buf_check_size(buf, 8)) {
ret = le64_to_cpu(*(__le64 *)buf->p);
buf->p += 8;
}
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)
{
int ret = 0;
if (buf_check_size(buf, datalen)) {
memcpy(data, buf->p, datalen);
buf->p += datalen;
ret = datalen;
}
return ret;
}
static inline void *buf_get_datab(struct cbuf *buf, struct cbuf *dbuf,
int datalen)
{
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;
}
/**
* v9fs_size_stat - calculate the size of a variable length stat struct
* @v9ses: session information
* @stat: metadata (stat) structure
*
*/
static int v9fs_size_stat(struct v9fs_session_info *v9ses,
struct v9fs_stat *stat)
{
int size = 0;
if (stat == NULL) {
eprintk(KERN_ERR, "v9fs_size_stat: got a NULL stat pointer\n");
return 0;
}
size = /* 2 + *//* size[2] */
2 + /* type[2] */
4 + /* dev[4] */
1 + /* qid.type[1] */
4 + /* qid.vers[4] */
8 + /* qid.path[8] */
4 + /* mode[4] */
4 + /* atime[4] */
4 + /* mtime[4] */
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 (v9ses->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);
}
return size;
}
/**
* serialize_stat - safely format a stat structure for transmission
* @v9ses: session info
* @stat: metadata (stat) structure
* @bufp: buffer to serialize structure into
*
*/
static int
serialize_stat(struct v9fs_session_info *v9ses, struct v9fs_stat *stat,
struct cbuf *bufp)
{
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 (v9ses->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
* @v9ses: session info
* @bufp: buffer to deserialize
* @stat: metadata (stat) structure
* @dbufp: buffer to deserialize variable strings into
*
*/
static inline int
deserialize_stat(struct v9fs_session_info *v9ses, struct cbuf *bufp,
struct v9fs_stat *stat, struct cbuf *dbufp)
{
stat->size = buf_get_int16(bufp);
stat->type = buf_get_int16(bufp);
stat->dev = buf_get_int32(bufp);
stat->qid.type = buf_get_int8(bufp);
stat->qid.version = buf_get_int32(bufp);
stat->qid.path = buf_get_int64(bufp);
stat->mode = buf_get_int32(bufp);
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);
if (v9ses->extended) {
stat->extension = buf_get_stringb(bufp, dbufp);
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
* @v9ses: session info
* @bufp: buffer to deserialize
* @dbufp: buffer to deserialize variable strings into
*
*/
static inline struct v9fs_stat *deserialize_statb(struct v9fs_session_info
*v9ses, struct cbuf *bufp,
struct cbuf *dbufp)
{
struct v9fs_stat *ret = buf_alloc(dbufp, sizeof(struct v9fs_stat));
if (ret) {
int n = deserialize_stat(v9ses, bufp, ret, dbufp);
if (n <= 0)
return NULL;
}
return ret;
}
/**
* v9fs_deserialize_stat - decode a received metadata structure
* @v9ses: session info
* @buf: buffer to deserialize
* @buflen: length of received buffer
* @stat: metadata structure to decode into
* @statlen: length of destination metadata structure
*
*/
int
v9fs_deserialize_stat(struct v9fs_session_info *v9ses, void *buf,
u32 buflen, struct v9fs_stat *stat, u32 statlen)
{
struct cbuf buffer;
struct cbuf *bufp = &buffer;
struct cbuf dbuffer;
struct cbuf *dbufp = &dbuffer;
buf_init(bufp, buf, buflen);
buf_init(dbufp, (char *)stat + sizeof(struct v9fs_stat),
statlen - sizeof(struct v9fs_stat));
return deserialize_stat(v9ses, bufp, stat, dbufp);
}
static inline int
v9fs_size_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall)
{
int size = 4 + 1 + 2; /* size[4] msg[1] tag[2] */
int i = 0;
switch (fcall->id) {
default:
eprintk(KERN_ERR, "bad msg type %d\n", fcall->id);
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(v9ses, fcall->params.twstat.stat);
size += 4 + 2 + 2 + fcall->params.twstat.stat->size;
}
return size;
}
/*
* v9fs_serialize_fcall - marshall fcall struct into a packet
* @v9ses: session information
* @fcall: structure to convert
* @data: buffer to serialize fcall into
* @datalen: length of buffer to serialize fcall into
*
*/
int
v9fs_serialize_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall,
void *data, u32 datalen)
{
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(v9ses, fcall);
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(v9ses, stat, bufp);
break;
}
if (buf_check_overflow(bufp))
return -EIO;
return fcall->size;
}
/**
* deserialize_fcall - unmarshal a response
* @v9ses: session information
* @msgsize: size of rcall message
* @buf: recieved buffer
* @buflen: length of received buffer
* @rcall: fcall structure to populate
* @rcalllen: length of fcall structure to populate
*
*/
int
v9fs_deserialize_fcall(struct v9fs_session_info *v9ses, u32 msgsize,
void *buf, u32 buflen, struct v9fs_fcall *rcall,
int rcalllen)
{
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 = msgsize;
rcall->id = buf_get_int8(bufp);
rcall->tag = buf_get_int16(bufp);
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);
break;
case RFLUSH:
break;
case RATTACH:
rcall->params.rattach.qid.type = buf_get_int8(bufp);
rcall->params.rattach.qid.version = buf_get_int32(bufp);
rcall->params.rattach.qid.path = buf_get_int64(bufp);
break;
case RWALK:
rcall->params.rwalk.nwqid = buf_get_int16(bufp);
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);
}
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);
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);
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);
break;
case RWRITE:
rcall->params.rwrite.count = buf_get_int32(bufp);
break;
case RCLUNK:
break;
case RREMOVE:
break;
case RSTAT:
buf_get_int16(bufp);
rcall->params.rstat.stat =
deserialize_statb(v9ses, bufp, dbufp);
break;
case RWSTAT:
break;
case RERROR:
rcall->params.rerror.error = buf_get_stringb(bufp, dbufp);
if (v9ses->extended)
rcall->params.rerror.errno = buf_get_int16(bufp);
break;
}
if (buf_check_overflow(bufp) || buf_check_overflow(dbufp))
return -EIO;
return rcall->size;
}
Computing file changes ...
