[-V3] tools/kvm/9p: Add encode/decode routines for protocol data

Commit Message

Aneesh Kumar K.V June 27, 2011, 10:27 a.m. UTC

The protocol data is in little-endian format.

Signed-off-by: Aneesh Kumar K.V <[e-mail]>
---
 tools/kvm/Makefile                |    1 +
 tools/kvm/include/kvm/virtio-9p.h |   80 ++++++-
 tools/kvm/virtio/9p-pdu.c         |  239 ++++++++++++++++++
 tools/kvm/virtio/9p.c             |  479 ++++++++++++++++---------------------
 4 files changed, 529 insertions(+), 270 deletions(-)
 create mode 100644 tools/kvm/virtio/9p-pdu.c

Comments

Sasha Levin June 27, 2011, 11:39 p.m. UTC | #1

On Mon, 2011-06-27 at 15:57 +0530, Aneesh Kumar K.V wrote:
> The protocol data is in little-endian format.
> 
> Signed-off-by: Aneesh Kumar K.V <[e-mail]>

What about the suggestion regarding using a pipe in the pdu read/write
functions?

> ---
>  tools/kvm/Makefile                |    1 +
>  tools/kvm/include/kvm/virtio-9p.h |   80 ++++++-
>  tools/kvm/virtio/9p-pdu.c         |  239 ++++++++++++++++++
>  tools/kvm/virtio/9p.c             |  479 ++++++++++++++++---------------------
>  4 files changed, 529 insertions(+), 270 deletions(-)
>  create mode 100644 tools/kvm/virtio/9p-pdu.c
> 
> diff --git a/tools/kvm/Makefile b/tools/kvm/Makefile
> index d368c22..559fefc 100644
> --- a/tools/kvm/Makefile
> +++ b/tools/kvm/Makefile
> @@ -57,6 +57,7 @@ OBJS	+= util/parse-options.o
>  OBJS	+= util/rbtree-interval.o
>  OBJS	+= util/strbuf.o
>  OBJS	+= virtio/9p.o
> +OBJS	+= virtio/9p-pdu.o
>  OBJS	+= hw/vesa.o
>  OBJS	+= hw/i8042.o
>  
> diff --git a/tools/kvm/include/kvm/virtio-9p.h b/tools/kvm/include/kvm/virtio-9p.h
> index d99bf96..27f52aa 100644
> --- a/tools/kvm/include/kvm/virtio-9p.h
> +++ b/tools/kvm/include/kvm/virtio-9p.h
> @@ -1,8 +1,86 @@
>  #ifndef KVM__VIRTIO_9P_H
>  #define KVM__VIRTIO_9P_H
> +#include "kvm/virtio-pci-dev.h"
> +#include "kvm/virtio.h"
> +#include "kvm/ioport.h"
> +#include "kvm/mutex.h"
> +#include "kvm/util.h"
> +#include "kvm/kvm.h"
> +#include "kvm/pci.h"
> +#include "kvm/threadpool.h"
> +#include "kvm/irq.h"
> +#include "kvm/ioeventfd.h"
> +
> +#include <fcntl.h>
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <pthread.h>
> +#include <dirent.h>
> +
> +#include <linux/virtio_ring.h>
> +#include <linux/virtio_9p.h>
> +
> +#define NUM_VIRT_QUEUES		1
> +#define VIRTQUEUE_NUM		128
> +#define	VIRTIO_P9_DEFAULT_TAG	"kvm_9p"
> +#define VIRTIO_P9_HDR_LEN	(sizeof(u32)+sizeof(u8)+sizeof(u16))
> +#define VIRTIO_P9_MAX_FID	128
> +#define VIRTIO_P9_VERSION	"9P2000"
> +#define MAX_TAG_LEN		32
> +
> +
> +struct p9_msg {
> +	u32			size;
> +	u8			cmd;
> +	u16			tag;
> +	u8			msg[0];
> +} __attribute__((packed));
> +
> +struct p9_fid {
> +	u32			fid;
> +	u8			is_dir;
> +	char			abs_path[PATH_MAX];
> +	char			*path;
> +	DIR			*dir;
> +	int			fd;
> +};
> +
> +struct p9_dev_job {
> +	struct virt_queue	*vq;
> +	struct p9_dev		*p9dev;
> +	void			*job_id;
> +};
> +
> +struct p9_dev {
> +	u8			status;
> +	u8			isr;
> +	u16			config_vector;
> +	u32			features;
> +	struct virtio_9p_config	*config;
> +	u16			base_addr;
> +
> +	/* virtio queue */
> +	u16			queue_selector;
> +	struct virt_queue	vqs[NUM_VIRT_QUEUES];
> +	struct p9_dev_job	jobs[NUM_VIRT_QUEUES];
> +	struct p9_fid		fids[VIRTIO_P9_MAX_FID];
> +	char			root_dir[PATH_MAX];
> +	struct pci_device_header pci_hdr;
> +};
> +
> +struct p9_pdu {
> +	u32			queue_head;
> +	size_t			read_offset;
> +	size_t			write_offset;
> +	u16			out_iov_cnt;
> +	u16			in_iov_cnt;
> +	struct iovec		in_iov[VIRTQUEUE_NUM];
> +	struct iovec		out_iov[VIRTQUEUE_NUM];
> +};
>  
>  struct kvm;
>  
>  void virtio_9p__init(struct kvm *kvm, const char *root, const char *tag_name);
> -
> +int virtio_p9_pdu_readf(struct p9_pdu *pdu, const char *fmt, ...);
> +int virtio_p9_pdu_writef(struct p9_pdu *pdu, const char *fmt, ...);
>  #endif
> diff --git a/tools/kvm/virtio/9p-pdu.c b/tools/kvm/virtio/9p-pdu.c
> new file mode 100644
> index 0000000..07cafd3
> --- /dev/null
> +++ b/tools/kvm/virtio/9p-pdu.c
> @@ -0,0 +1,239 @@
> +#include "kvm/virtio-9p.h"
> +
> +#include <endian.h>
> +
> +#include <net/9p/9p.h>
> +
> +static void virtio_p9_pdu_read(struct p9_pdu *pdu, void *data, size_t size)
> +{
> +	size_t len;
> +	int i, copied = 0;
> +	u16 iov_cnt = pdu->out_iov_cnt;
> +	size_t offset = pdu->read_offset;
> +	struct iovec *iov = pdu->out_iov;
> +
> +	for (i = 0; i < iov_cnt && size; i++) {
> +		if (offset >= iov[i].iov_len) {
> +			offset -= iov[i].iov_len;
> +			continue;
> +		} else {
> +			len = MIN(iov[i].iov_len - offset, size);
> +			memcpy(data, iov[i].iov_base + offset, len);
> +			size -= len;
> +			data += len;
> +			offset = 0;
> +			copied += len;
> +		}
> +	}
> +	pdu->read_offset += copied;
> +}
> +
> +static void virtio_p9_pdu_write(struct p9_pdu *pdu,
> +				const void *data, size_t size)
> +{
> +	size_t len;
> +	int i, copied = 0;
> +	u16 iov_cnt = pdu->in_iov_cnt;
> +	size_t offset = pdu->write_offset;
> +	struct iovec *iov = pdu->in_iov;
> +
> +	for (i = 0; i < iov_cnt && size; i++) {
> +		if (offset >= iov[i].iov_len) {
> +			offset -= iov[i].iov_len;
> +			continue;
> +		} else {
> +			len = MIN(iov[i].iov_len - offset, size);
> +			memcpy(iov[i].iov_base + offset, data, len);
> +			size -= len;
> +			data += len;
> +			offset = 0;
> +			copied += len;
> +		}
> +	}
> +	pdu->write_offset += copied;
> +}
> +
> +static void virtio_p9_wstat_free(struct p9_wstat *stbuf)
> +{
> +	free(stbuf->name);
> +	free(stbuf->uid);
> +	free(stbuf->gid);
> +	free(stbuf->muid);
> +}
> +
> +static int virtio_p9_decode(struct p9_pdu *pdu, const char *fmt, va_list ap)
> +{
> +	int retval = 0;
> +	const char *ptr;
> +
> +	for (ptr = fmt; *ptr; ptr++) {
> +		switch (*ptr) {
> +		case 'b':
> +		{
> +			int8_t *val = va_arg(ap, int8_t *);
> +			virtio_p9_pdu_read(pdu, val, sizeof(*val));
> +		}
> +		break;
> +		case 'w':
> +		{
> +			int16_t le_val;
> +			int16_t *val = va_arg(ap, int16_t *);
> +			virtio_p9_pdu_read(pdu, &le_val, sizeof(le_val));
> +			*val = le16toh(le_val);
> +		}
> +		break;
> +		case 'd':
> +		{
> +			int32_t le_val;
> +			int32_t *val = va_arg(ap, int32_t *);
> +			virtio_p9_pdu_read(pdu, &le_val, sizeof(le_val));
> +			*val = le32toh(le_val);
> +		}
> +		break;
> +		case 'q':
> +		{
> +			int64_t le_val;
> +			int64_t *val = va_arg(ap, int64_t *);
> +			virtio_p9_pdu_read(pdu, &le_val, sizeof(le_val));
> +			*val = le64toh(le_val);
> +		}
> +		break;
> +		case 's':
> +		{
> +			int16_t len;
> +			char **str = va_arg(ap, char **);
> +
> +			virtio_p9_pdu_readf(pdu, "w", &len);
> +			*str = malloc(len + 1);
> +			if (*str == NULL) {
> +				retval = ENOMEM;
> +				break;
> +			}
> +			virtio_p9_pdu_read(pdu, *str, len);
> +			(*str)[len] = 0;
> +		}
> +		break;
> +		case 'Q':
> +		{
> +			struct p9_qid *qid = va_arg(ap, struct p9_qid *);
> +			retval = virtio_p9_pdu_readf(pdu, "bdq",
> +						     &qid->type, &qid->version,
> +						     &qid->path);
> +		}
> +		break;
> +		case 'S':
> +		{
> +			struct p9_wstat *stbuf = va_arg(ap, struct p9_wstat *);
> +			memset(stbuf, 0, sizeof(struct p9_wstat));
> +			stbuf->n_uid = stbuf->n_gid = stbuf->n_muid = -1;
> +			retval = virtio_p9_pdu_readf(pdu, "wwdQdddqssss",
> +						&stbuf->size, &stbuf->type,
> +						&stbuf->dev, &stbuf->qid,
> +						&stbuf->mode, &stbuf->atime,
> +						&stbuf->mtime, &stbuf->length,
> +						&stbuf->name, &stbuf->uid,
> +						&stbuf->gid, &stbuf->muid);
> +			if (retval)
> +				virtio_p9_wstat_free(stbuf);
> +		}
> +		break;
> +		default:
> +			retval = EINVAL;
> +			break;
> +		}
> +	}
> +	return retval;
> +}
> +
> +static int virtio_p9_pdu_encode(struct p9_pdu *pdu, const char *fmt, va_list ap)
> +{
> +	int retval = 0;
> +	const char *ptr;
> +
> +	for (ptr = fmt; *ptr; ptr++) {
> +		switch (*ptr) {
> +		case 'b':
> +		{
> +			int8_t val = va_arg(ap, int);
> +			virtio_p9_pdu_write(pdu, &val, sizeof(val));
> +		}
> +		break;
> +		case 'w':
> +		{
> +			int16_t val = htole16(va_arg(ap, int));
> +			virtio_p9_pdu_write(pdu, &val, sizeof(val));
> +		}
> +		break;
> +		case 'd':
> +		{
> +			int32_t val = htole32(va_arg(ap, int32_t));
> +			virtio_p9_pdu_write(pdu, &val, sizeof(val));
> +		}
> +		break;
> +		case 'q':
> +		{
> +			int64_t val = htole64(va_arg(ap, int64_t));
> +			virtio_p9_pdu_write(pdu, &val, sizeof(val));
> +		}
> +		break;
> +		case 's':
> +		{
> +			uint16_t len = 0;
> +			const char *s = va_arg(ap, char *);
> +			if (s)
> +				len = MIN(strlen(s), USHRT_MAX);
> +			virtio_p9_pdu_writef(pdu, "w", len);
> +			virtio_p9_pdu_write(pdu, s, len);
> +		}
> +		break;
> +		case 'Q':
> +		{
> +			struct p9_qid *qid = va_arg(ap, struct p9_qid *);
> +			retval = virtio_p9_pdu_writef(pdu, "bdq",
> +						      qid->type, qid->version,
> +						      qid->path);
> +		}
> +		break;
> +		case 'S':
> +		{
> +			struct p9_wstat *stbuf = va_arg(ap, struct p9_wstat *);
> +			retval = virtio_p9_pdu_writef(pdu, "wwdQdddqssss",
> +						stbuf->size, stbuf->type,
> +						stbuf->dev, &stbuf->qid,
> +						stbuf->mode, stbuf->atime,
> +						stbuf->mtime, stbuf->length,
> +						stbuf->name, stbuf->uid,
> +						stbuf->gid, stbuf->muid);
> +		}
> +		break;
> +		default:
> +			retval = EINVAL;
> +			break;
> +		}
> +	}
> +	return retval;
> +}
> +
> +int virtio_p9_pdu_readf(struct p9_pdu *pdu, const char *fmt, ...)
> +{
> +	int ret;
> +	va_list ap;
> +
> +	va_start(ap, fmt);
> +	ret = virtio_p9_decode(pdu, fmt, ap);
> +	va_end(ap);
> +
> +	return ret;
> +}
> +
> +int virtio_p9_pdu_writef(struct p9_pdu *pdu, const char *fmt, ...)
> +{
> +	int ret;
> +	va_list ap;
> +
> +	va_start(ap, fmt);
> +	ret = virtio_p9_pdu_encode(pdu, fmt, ap);
> +	va_end(ap);
> +
> +	return ret;
> +}
> diff --git a/tools/kvm/virtio/9p.c b/tools/kvm/virtio/9p.c
> index d2d738d..a08d7ec 100644
> --- a/tools/kvm/virtio/9p.c
> +++ b/tools/kvm/virtio/9p.c
> @@ -1,81 +1,6 @@
>  #include "kvm/virtio-9p.h"
> -#include "kvm/virtio-pci-dev.h"
> -#include "kvm/virtio.h"
> -#include "kvm/ioport.h"
> -#include "kvm/mutex.h"
> -#include "kvm/util.h"
> -#include "kvm/kvm.h"
> -#include "kvm/pci.h"
> -#include "kvm/threadpool.h"
> -#include "kvm/irq.h"
> -#include "kvm/ioeventfd.h"
> -
> -#include <fcntl.h>
> -#include <sys/types.h>
> -#include <sys/stat.h>
> -#include <pthread.h>
> -#include <dirent.h>
> -
> -#include <linux/virtio_ring.h>
> -#include <linux/virtio_9p.h>
> -#include <net/9p/9p.h>
> -
> -#define NUM_VIRT_QUEUES		1
> -#define VIRTQUEUE_NUM		128
> -#define	VIRTIO_P9_DEFAULT_TAG	"kvm_9p"
> -#define VIRTIO_P9_HDR_LEN	(sizeof(u32)+sizeof(u8)+sizeof(u16))
> -#define VIRTIO_P9_MAX_FID	128
> -#define VIRTIO_P9_VERSION	"9P2000"
> -#define MAX_TAG_LEN		32
> -
> -
> -struct p9_msg {
> -	u32			size;
> -	u8			cmd;
> -	u16			tag;
> -	u8			msg[0];
> -} __attribute__((packed));
> -
> -struct p9_fid {
> -	u32			fid;
> -	u8			is_dir;
> -	char			abs_path[PATH_MAX];
> -	char			*path;
> -	DIR			*dir;
> -	int			fd;
> -};
> -
> -struct p9_dev_job {
> -	struct virt_queue		*vq;
> -	struct p9_dev			*p9dev;
> -	void				*job_id;
> -};
> -
> -struct p9_dev {
> -	u8			status;
> -	u8			isr;
> -	u16			config_vector;
> -	u32			features;
> -	struct virtio_9p_config	*config;
> -	u16			base_addr;
> -
> -	/* virtio queue */
> -	u16			queue_selector;
> -	struct virt_queue	vqs[NUM_VIRT_QUEUES];
> -	struct p9_dev_job	jobs[NUM_VIRT_QUEUES];
> -	struct p9_fid		fids[VIRTIO_P9_MAX_FID];
> -	char			root_dir[PATH_MAX];
> -	struct pci_device_header pci_hdr;
> -};
>  
> -struct p9_pdu {
> -	u32 queue_head;
> -	int offset;
> -	u16 out_iov_cnt;
> -	u16 in_iov_cnt;
> -	struct iovec in_iov[VIRTQUEUE_NUM];
> -	struct iovec out_iov[VIRTQUEUE_NUM];
> -};
> +#include <net/9p/9p.h>
>  
>  /* Warning: Immediately use value returned from this function */
>  static const char *rel_to_abs(struct p9_dev *p9dev,
> @@ -185,13 +110,16 @@ static void close_fid(struct p9_dev *p9dev, u32 fid)
>  	}
>  }
>  
> -static void set_p9msg_hdr(struct p9_msg *msg, u32 size, u8 cmd, u16 tag)
> +static void virtio_p9_set_reply_header(struct p9_pdu *pdu, u32 size)
>  {
> -	*msg = (struct p9_msg) {
> -		.size	= size,
> -		.tag	= tag,
> -		.cmd	= cmd,
> -	};
> +	u8 cmd;
> +	u16 tag;
> +
> +	pdu->read_offset = sizeof(u32);
> +	virtio_p9_pdu_readf(pdu, "bw", &cmd, &tag);
> +	pdu->write_offset = 0;
> +	/* cmd + 1 is the reply message */
> +	virtio_p9_pdu_writef(pdu, "dbw", size, cmd + 1, tag);
>  }
>  
>  static u16 virtio_p9_update_iov_cnt(struct iovec iov[], u32 count, int iov_cnt)
> @@ -213,67 +141,61 @@ static u16 virtio_p9_update_iov_cnt(struct iovec iov[], u32 count, int iov_cnt)
>  static void virtio_p9_error_reply(struct p9_dev *p9dev,
>  				  struct p9_pdu *pdu, int err, u32 *outlen)
>  {
> +	u16 tag;
>  	char *err_str;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_rerror *rerror  = (struct p9_rerror *)inmsg->msg;
>  
>  	err_str = strerror(err);
> -	rerror->error.len = strlen(err_str);
> -	memcpy(&rerror->error.str, err_str, rerror->error.len);
> +	pdu->write_offset = VIRTIO_P9_HDR_LEN;
> +	virtio_p9_pdu_writef(pdu, "s", err_str);
> +	*outlen = pdu->write_offset;
> +
> +	pdu->read_offset = sizeof(u32) + sizeof(u8);
> +	virtio_p9_pdu_readf(pdu, "w", &tag);
>  
> -	*outlen = VIRTIO_P9_HDR_LEN + rerror->error.len + sizeof(u16);
> -	set_p9msg_hdr(inmsg, *outlen, P9_RERROR, outmsg->tag);
> +	pdu->write_offset = 0;
> +	virtio_p9_pdu_writef(pdu, "dbw", *outlen, P9_RERROR, tag);
>  }
>  
>  static void virtio_p9_version(struct p9_dev *p9dev,
>  			      struct p9_pdu *pdu, u32 *outlen)
>  {
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_rversion *rversion = (struct p9_rversion *)inmsg->msg;
> -
> -	rversion->msize		= 4096;
> -	rversion->version.len	= strlen(VIRTIO_P9_VERSION);
> -	memcpy(&rversion->version.str, VIRTIO_P9_VERSION, rversion->version.len);
> -
> -	*outlen = VIRTIO_P9_HDR_LEN +
> -		rversion->version.len + sizeof(u16) + sizeof(u32);
> -	set_p9msg_hdr(inmsg, *outlen, P9_RVERSION, outmsg->tag);
> +	virtio_p9_pdu_writef(pdu, "ds", 4096, VIRTIO_P9_VERSION);
>  
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  }
>  
>  static void virtio_p9_clunk(struct p9_dev *p9dev,
>  			    struct p9_pdu *pdu, u32 *outlen)
>  {
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_tclunk *tclunk = (struct p9_tclunk *)outmsg->msg;
> -
> -	close_fid(p9dev, tclunk->fid);
> +	u32 fid;
>  
> -	*outlen = VIRTIO_P9_HDR_LEN;
> -	set_p9msg_hdr(inmsg, *outlen, P9_RCLUNK, outmsg->tag);
> +	virtio_p9_pdu_readf(pdu, "d", &fid);
> +	close_fid(p9dev, fid);
>  
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  }
>  
>  static void virtio_p9_open(struct p9_dev *p9dev,
>  			   struct p9_pdu *pdu, u32 *outlen)
>  {
> +	u8 mode;
> +	u32 fid;
>  	struct stat st;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_topen *topen	= (struct p9_topen *)outmsg->msg;
> -	struct p9_ropen *ropen	= (struct p9_ropen *)inmsg->msg;
> -	struct p9_fid *new_fid	= &p9dev->fids[topen->fid];
> +	struct p9_qid qid;
> +	struct p9_fid *new_fid;
> +
> +
> +	virtio_p9_pdu_readf(pdu, "db", &fid, &mode);
> +	new_fid = &p9dev->fids[fid];
>  
>  	if (lstat(new_fid->abs_path, &st) < 0)
>  		goto err_out;
>  
> -	st2qid(&st, &ropen->qid);
> -	ropen->iounit = 0;
> +	st2qid(&st, &qid);
>  
>  	if (new_fid->is_dir) {
>  		new_fid->dir = opendir(new_fid->abs_path);
> @@ -281,12 +203,14 @@ static void virtio_p9_open(struct p9_dev *p9dev,
>  			goto err_out;
>  	} else {
>  		new_fid->fd  = open(new_fid->abs_path,
> -				   omode2uflags(topen->mode) | O_NOFOLLOW);
> +				    omode2uflags(mode) | O_NOFOLLOW);
>  		if (new_fid->fd < 0)
>  			goto err_out;
>  	}
> -	*outlen = VIRTIO_P9_HDR_LEN + sizeof(*ropen);
> -	set_p9msg_hdr(inmsg, *outlen, P9_ROPEN, outmsg->tag);
> +	virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
> +
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  err_out:
>  	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
> @@ -298,39 +222,33 @@ static void virtio_p9_create(struct p9_dev *p9dev,
>  {
>  	u8 mode;
>  	u32 perm;
> +	char *name;
> +	u32 fid_val;
>  	struct stat st;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_tcreate *tcreate	= (struct p9_tcreate *)outmsg->msg;
> -	struct p9_rcreate *rcreate	= (struct p9_rcreate *)inmsg->msg;
> -	struct p9_fid *fid		= &p9dev->fids[tcreate->fid];
> -
> -
> -	rcreate->iounit = 0;
> -
> -	/* Get last byte of the variable length struct */
> -	mode = *((u8 *)outmsg + outmsg->size - 1);
> -	perm = *(u32 *)((u8 *)outmsg + outmsg->size - 5);
> +	struct p9_qid qid;
> +	struct p9_fid *fid;
>  
> -	sprintf(fid->path, "%s/%.*s", fid->path, tcreate->name.len, (char *)&tcreate->name.str);
> +	virtio_p9_pdu_readf(pdu, "dsdb", &fid_val, &name, &perm, &mode);
> +	fid = &p9dev->fids[fid_val];
>  
> -	close_fid(p9dev, tcreate->fid);
> +	sprintf(fid->path, "%s/%.*s", fid->path, (int)strlen(name), name);
> +	close_fid(p9dev, fid_val);
>  
>  	if (perm & P9_DMDIR) {
>  		mkdir(fid->abs_path, perm & 0xFFFF);
>  		fid->dir = opendir(fid->abs_path);
>  		fid->is_dir = 1;
>  	} else {
> -		fid->fd = open(fid->abs_path, omode2uflags(mode) | O_CREAT, 0777);
> +		fid->fd = open(fid->abs_path,
> +			       omode2uflags(mode) | O_CREAT, 0777);
>  	}
> -
>  	if (lstat(fid->abs_path, &st) < 0)
>  		goto err_out;
>  
> -	st2qid(&st, &rcreate->qid);
> -
> -	*outlen = VIRTIO_P9_HDR_LEN + sizeof(*rcreate);
> -	set_p9msg_hdr(inmsg, *outlen, P9_RCREATE, outmsg->tag);
> +	st2qid(&st, &qid);
> +	virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  err_out:
>  	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
> @@ -341,45 +259,57 @@ static void virtio_p9_walk(struct p9_dev *p9dev,
>  			   struct p9_pdu *pdu, u32 *outlen)
>  {
>  	u8 i;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_twalk *twalk	= (struct p9_twalk *)outmsg->msg;
> -	struct p9_rwalk *rwalk	= (struct p9_rwalk *)inmsg->msg;
> -	struct p9_str *str	= twalk->wnames;
> -	struct p9_fid *new_fid	= &p9dev->fids[twalk->newfid];
> +	u16 nwqid;
> +	char *str;
> +	u16 nwname;
> +	u32 fid_val;
> +	u32 newfid_val;
> +	struct p9_qid wqid;
> +	struct p9_fid *new_fid;
> +
>  
> +	virtio_p9_pdu_readf(pdu, "ddw", &fid_val, &newfid_val, &nwname);
> +	new_fid	= &p9dev->fids[newfid_val];
>  
> -	rwalk->nwqid = 0;
> -	if (twalk->nwname) {
> -		struct p9_fid *fid = &p9dev->fids[twalk->fid];
> +	nwqid = 0;
> +	if (nwname) {
> +		struct p9_fid *fid = &p9dev->fids[fid_val];
>  
> -		for (i = 0; i < twalk->nwname; i++) {
> +		/* skip the space for count */
> +		pdu->write_offset += sizeof(u16);
> +		for (i = 0; i < nwname; i++) {
> +			struct stat st;
>  			char tmp[PATH_MAX] = {0};
>  			char full_path[PATH_MAX];
> -			struct stat st;
>  
> -			/* Format the new path we're 'walk'ing into */
> -			sprintf(tmp, "%s/%.*s", fid->path,
> -				str->len, (char *)&str->str);
> +			virtio_p9_pdu_readf(pdu, "s", &str);
>  
> +			/* Format the new path we're 'walk'ing into */
> +			sprintf(tmp, "%s/%.*s",
> +				fid->path, (int)strlen(str), str);
>  			if (lstat(rel_to_abs(p9dev, tmp, full_path), &st) < 0)
>  				goto err_out;
>  
> -			st2qid(&st, &rwalk->wqids[i]);
> +			st2qid(&st, &wqid);
>  			new_fid->is_dir = S_ISDIR(st.st_mode);
>  			strcpy(new_fid->path, tmp);
> -			new_fid->fid = twalk->newfid;
> -			rwalk->nwqid++;
> +			new_fid->fid = newfid_val;
> +			nwqid++;
> +			virtio_p9_pdu_writef(pdu, "Q", &wqid);
>  		}
>  	} else {
> -		new_fid->is_dir = p9dev->fids[twalk->fid].is_dir;
> -		strcpy(new_fid->path, p9dev->fids[twalk->fid].path);
> -		new_fid->fid	= twalk->newfid;
> +		/*
> +		 * update write_offset so our outlen get correct value
> +		 */
> +		pdu->write_offset += sizeof(u16);
> +		new_fid->is_dir = p9dev->fids[fid_val].is_dir;
> +		strcpy(new_fid->path, p9dev->fids[fid_val].path);
> +		new_fid->fid	= newfid_val;
>  	}
> -
> -	*outlen = VIRTIO_P9_HDR_LEN + sizeof(u16) +
> -		sizeof(struct p9_qid)*rwalk->nwqid;
> -	set_p9msg_hdr(inmsg, *outlen, P9_RWALK, outmsg->tag);
> +	*outlen = pdu->write_offset;
> +	pdu->write_offset = VIRTIO_P9_HDR_LEN;
> +	virtio_p9_pdu_writef(pdu, "d", nwqid);
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  err_out:
>  	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
> @@ -390,12 +320,15 @@ static void virtio_p9_attach(struct p9_dev *p9dev,
>  			     struct p9_pdu *pdu, u32 *outlen)
>  {
>  	u32 i;
> +	u32 fid_val;
> +	u32 afid;
> +	char *uname;
> +	char *aname;
>  	struct stat st;
> +	struct p9_qid qid;
>  	struct p9_fid *fid;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_rattach *rattach = (struct p9_rattach *)inmsg->msg;
> -	struct p9_tattach *tattach = (struct p9_tattach *)outmsg->msg;
> +
> +	virtio_p9_pdu_readf(pdu, "ddss", &fid_val, &afid, &uname, &aname);
>  
>  	/* Reset everything */
>  	for (i = 0; i < VIRTIO_P9_MAX_FID; i++)
> @@ -404,103 +337,106 @@ static void virtio_p9_attach(struct p9_dev *p9dev,
>  	if (lstat(p9dev->root_dir, &st) < 0)
>  		goto err_out;
>  
> -	st2qid(&st, &rattach->qid);
> +	st2qid(&st, &qid);
>  
> -	fid = &p9dev->fids[tattach->fid];
> -	fid->fid = tattach->fid;
> +	fid = &p9dev->fids[fid_val];
> +	fid->fid = fid_val;
>  	fid->is_dir = 1;
>  	strcpy(fid->path, "/");
>  
> -	*outlen = VIRTIO_P9_HDR_LEN + sizeof(*rattach);
> -	set_p9msg_hdr(inmsg, *outlen, P9_RATTACH, outmsg->tag);
> +	virtio_p9_pdu_writef(pdu, "Q", &qid);
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  err_out:
>  	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
>  	return;
>  }
>  
> -static u32 virtio_p9_fill_stat(struct p9_dev *p9dev, const char *name,
> -			       struct stat *st, struct p9_rstat *rstat)
> +static void virtio_p9_fill_stat(struct p9_dev *p9dev, const char *name,
> +				struct stat *st, struct p9_wstat *wstat)
>  {
> -	struct p9_str *str;
> -
> -	rstat->stat.type = 0;
> -	rstat->stat.dev = 0;
> -	st2qid(st, &rstat->stat.qid);
> -	rstat->stat.mode = st->st_mode;
> -	rstat->stat.length = st->st_size;
> +	wstat->type = 0;
> +	wstat->dev = 0;
> +	st2qid(st, &wstat->qid);
> +	wstat->mode = st->st_mode;
> +	wstat->length = st->st_size;
>  	if (S_ISDIR(st->st_mode)) {
> -		rstat->stat.length = 0;
> -		rstat->stat.mode |= P9_DMDIR;
> +		wstat->length = 0;
> +		wstat->mode |= P9_DMDIR;
>  	}
>  
> -	rstat->stat.atime = st->st_atime;
> -	rstat->stat.mtime = st->st_mtime;
> -
> -	str = (struct p9_str *)&rstat->stat.name;
> -	str->len = strlen(name);
> -	memcpy(&str->str, name, str->len);
> -	str = (void *)str + str->len + sizeof(u16);
> -
> -	/* TODO: Pass usernames to the client */
> -	str->len = 0;
> -	str = (void *)str + sizeof(u16);
> -	str->len = 0;
> -	str = (void *)str + sizeof(u16);
> -	str->len = 0;
> -	str = (void *)str + sizeof(u16);
> -
> -	/*
> -	 * We subtract a u16 here because rstat->size
> -	 * doesn't include rstat->size itself
> -	 */
> -	rstat->stat.size = (void *)str - (void *)&rstat->stat - sizeof(u16);
> -
> -	return rstat->stat.size + sizeof(u16);
> +	wstat->atime = st->st_atime;
> +	wstat->mtime = st->st_mtime;
> +
> +	wstat->name = strdup(name);
> +	wstat->uid = NULL;
> +	wstat->gid = NULL;
> +	wstat->muid = NULL;
> +
> +	/* NOTE: size shouldn't include its own length */
> +	/* size[2] type[2] dev[4] qid[13] */
> +	/* mode[4] atime[4] mtime[4] length[8]*/
> +	/* name[s] uid[s] gid[s] muid[s] */
> +	wstat->size = 2+4+13+4+4+4+8+2+2+2+2;
> +	if (wstat->name)
> +		wstat->size += strlen(wstat->name);
>  }
>  
>  static void virtio_p9_read(struct p9_dev *p9dev,
>  			   struct p9_pdu *pdu, u32 *outlen)
>  {
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_tread *tread	= (struct p9_tread *)outmsg->msg;
> -	struct p9_rread *rread	= (struct p9_rread *)inmsg->msg;
> -	struct p9_rstat *rstat	= (struct p9_rstat *)pdu->in_iov[1].iov_base;
> -	struct p9_fid *fid	= &p9dev->fids[tread->fid];
> +	u64 offset;
> +	u32 fid_val;
> +	u32 count, rcount;
>  	struct stat st;
> +	struct p9_fid *fid;
> +	struct p9_wstat wstat;
>  
> -	rread->count = 0;
> -
> +	rcount = 0;
> +	virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
> +	fid = &p9dev->fids[fid_val];
>  	if (fid->is_dir) {
>  		/* If reading a dir, fill the buffer with p9_stat entries */
> -		struct dirent *cur = readdir(fid->dir);
>  		char full_path[PATH_MAX];
> +		struct dirent *cur = readdir(fid->dir);
>  
> +		/* Skip the space for writing count */
> +		pdu->write_offset += sizeof(u32);
>  		while (cur) {
>  			u32 read;
>  
>  			lstat(rel_to_abs(p9dev, cur->d_name, full_path), &st);
> -			read = virtio_p9_fill_stat(p9dev, cur->d_name,
> -						   &st, rstat);
> -			rread->count += read;
> -			rstat = (void *)rstat + read;
> +			virtio_p9_fill_stat(p9dev, cur->d_name, &st, &wstat);
> +
> +			read = pdu->write_offset;
> +			virtio_p9_pdu_writef(pdu, "S", &wstat);
> +			rcount += pdu->write_offset - read;
> +
>  			cur = readdir(fid->dir);
>  		}
>  	} else {
>  		pdu->in_iov[0].iov_base += VIRTIO_P9_HDR_LEN + sizeof(u32);
>  		pdu->in_iov[0].iov_len -= VIRTIO_P9_HDR_LEN + sizeof(u32);
>  		pdu->in_iov_cnt = virtio_p9_update_iov_cnt(pdu->in_iov,
> -							    tread->count,
> -							    pdu->in_iov_cnt);
> -		rread->count = preadv(fid->fd, pdu->in_iov,
> -				      pdu->in_iov_cnt, tread->offset);
> -		if (rread->count > tread->count)
> -			rread->count = tread->count;
> -	}
> +							   count,
> +							   pdu->in_iov_cnt);
> +		rcount = preadv(fid->fd, pdu->in_iov,
> +				pdu->in_iov_cnt, offset);
> +		if (rcount > count)
> +			rcount = count;
> +		/*
> +		 * Update the iov_base back, so that rest of
> +		 * pdu_writef works correctly.
> +		 */
> +		pdu->in_iov[0].iov_base -= VIRTIO_P9_HDR_LEN + sizeof(u32);
> +		pdu->in_iov[0].iov_len += VIRTIO_P9_HDR_LEN + sizeof(u32);
>  
> -	*outlen = VIRTIO_P9_HDR_LEN + sizeof(u32) + rread->count;
> -	set_p9msg_hdr(inmsg, *outlen, P9_RREAD, outmsg->tag);
> +	}
> +	pdu->write_offset = VIRTIO_P9_HDR_LEN;
> +	virtio_p9_pdu_writef(pdu, "d", rcount);
> +	*outlen = pdu->write_offset + rcount;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  
>  	return;
>  }
> @@ -508,21 +444,21 @@ static void virtio_p9_read(struct p9_dev *p9dev,
>  static void virtio_p9_stat(struct p9_dev *p9dev,
>  			   struct p9_pdu *pdu, u32 *outlen)
>  {
> -	u32 ret;
> +	u32 fid_val;
>  	struct stat st;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_tstat *tstat = (struct p9_tstat *)outmsg->msg;
> -	struct p9_rstat *rstat = (struct p9_rstat *)(inmsg->msg + sizeof(u16));
> -	struct p9_fid *fid = &p9dev->fids[tstat->fid];
> +	struct p9_fid *fid;
> +	struct p9_wstat wstat;
>  
> +	virtio_p9_pdu_readf(pdu, "d", &fid_val);
> +	fid = &p9dev->fids[fid_val];
>  	if (lstat(fid->abs_path, &st) < 0)
>  		goto err_out;
>  
> -	ret = virtio_p9_fill_stat(p9dev, fid->path, &st, rstat);
> +	virtio_p9_fill_stat(p9dev, fid->path, &st, &wstat);
>  
> -	*outlen = VIRTIO_P9_HDR_LEN + ret + sizeof(u16);
> -	set_p9msg_hdr(inmsg, *outlen, P9_RSTAT, outmsg->tag);
> +	virtio_p9_pdu_writef(pdu, "wS", 0, &wstat);
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  err_out:
>  	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
> @@ -533,21 +469,21 @@ static void virtio_p9_wstat(struct p9_dev *p9dev,
>  			    struct p9_pdu *pdu, u32 *outlen)
>  {
>  	int res = 0;
> -	struct p9_str *str;
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_twstat *twstat = (struct p9_twstat *)outmsg->msg;
> -	struct p9_fid *fid = &p9dev->fids[twstat->fid];
> +	u32 fid_val;
> +	u16 unused;
> +	struct p9_fid *fid;
> +	struct p9_wstat wstat;
>  
> +	virtio_p9_pdu_readf(pdu, "dwS", &fid_val, &unused, &wstat);
> +	fid = &p9dev->fids[fid_val];
>  
> -	if (twstat->stat.length != -1UL)
> -		res = ftruncate(fid->fd, twstat->stat.length);
> +	if (wstat.length != -1UL)
> +		res = ftruncate(fid->fd, wstat.length);
>  
> -	if (twstat->stat.mode != -1U)
> -		chmod(fid->abs_path, twstat->stat.mode & 0xFFFF);
> +	if (wstat.mode != -1U)
> +		chmod(fid->abs_path, wstat.mode & 0xFFFF);
>  
> -	str = (void *)&twstat->stat.name + sizeof(u16);
> -	if (str->len > 0) {
> +	if (strlen(wstat.name) > 0) {
>  		char new_name[PATH_MAX] = {0};
>  		char full_path[PATH_MAX];
>  		char *last_dir = strrchr(fid->path, '/');
> @@ -556,57 +492,59 @@ static void virtio_p9_wstat(struct p9_dev *p9dev,
>  		if (last_dir)
>  			strncpy(new_name, fid->path, last_dir - fid->path + 1);
>  
> -		memcpy(new_name + strlen(new_name), &str->str, str->len);
> +		memcpy(new_name + strlen(new_name),
> +		       wstat.name, strlen(wstat.name));
>  
>  		/* fid is reused for the new file */
>  		rename(fid->abs_path, rel_to_abs(p9dev, new_name, full_path));
>  		sprintf(fid->path, "%s", new_name);
>  	}
> -
>  	*outlen = VIRTIO_P9_HDR_LEN;
> -	set_p9msg_hdr(inmsg, *outlen, P9_RWSTAT, outmsg->tag);
> -
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  }
>  
>  static void virtio_p9_remove(struct p9_dev *p9dev,
>  			     struct p9_pdu *pdu, u32 *outlen)
>  {
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_tremove *tremove = (struct p9_tremove *)outmsg->msg;
> -	struct p9_fid *fid = &p9dev->fids[tremove->fid];
> +	u32 fid_val;
> +	struct p9_fid *fid;
>  
> -	close_fid(p9dev, tremove->fid);
> +	virtio_p9_pdu_readf(pdu, "d", &fid_val);
> +	fid = &p9dev->fids[fid_val];
> +	close_fid(p9dev, fid_val);
>  	if (fid->is_dir)
>  		rmdir(fid->abs_path);
>  	else
>  		unlink(fid->abs_path);
>  
>  	*outlen = VIRTIO_P9_HDR_LEN;
> -	set_p9msg_hdr(inmsg, *outlen, P9_RREMOVE, outmsg->tag);
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  }
>  
>  static void virtio_p9_write(struct p9_dev *p9dev,
>  			    struct p9_pdu *pdu, u32 *outlen)
>  {
> -	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
> -	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
> -	struct p9_twrite *twrite = (struct p9_twrite *)outmsg->msg;
> -	struct p9_rwrite *rwrite = (struct p9_rwrite *)inmsg->msg;
> -	struct p9_fid *fid = &p9dev->fids[twrite->fid];
> +	u64 offset;
> +	u32 fid_val;
> +	u32 count, rcount;
> +	struct p9_fid *fid;
>  
> +	virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
> +	fid = &p9dev->fids[fid_val];
>  
> -	pdu->out_iov[0].iov_base += (sizeof(*outmsg) + sizeof(*twrite));
> -	pdu->out_iov[0].iov_len -= (sizeof(*outmsg) + sizeof(*twrite));
> -	pdu->out_iov_cnt = virtio_p9_update_iov_cnt(pdu->out_iov, twrite->count,
> +	/* Adjust the iovec to skip the header and meta data */
> +	pdu->out_iov[0].iov_base += (sizeof(struct p9_msg) +
> +				     sizeof(struct p9_twrite));
> +	pdu->out_iov[0].iov_len -=  (sizeof(struct p9_msg) +
> +				     sizeof(struct p9_twrite));
> +	pdu->out_iov_cnt = virtio_p9_update_iov_cnt(pdu->out_iov, count,
>  						    pdu->out_iov_cnt);
> -	rwrite->count = pwritev(fid->fd, pdu->out_iov,
> -				pdu->out_iov_cnt, twrite->offset);
> -	*outlen = VIRTIO_P9_HDR_LEN + sizeof(u32);
> -	set_p9msg_hdr(inmsg, *outlen, P9_RWRITE, outmsg->tag);
> -
> +	rcount = pwritev(fid->fd, pdu->out_iov, pdu->out_iov_cnt, offset);
> +	virtio_p9_pdu_writef(pdu, "d", rcount);
> +	*outlen = pdu->write_offset;
> +	virtio_p9_set_reply_header(pdu, *outlen);
>  	return;
>  }
>  
> @@ -633,6 +571,9 @@ static struct p9_pdu *virtio_p9_pdu_init(struct kvm *kvm, struct virt_queue *vq)
>  	if (!pdu)
>  		return NULL;
>  
> +	/* skip the pdu header p9_msg */
> +	pdu->read_offset  = VIRTIO_P9_HDR_LEN;
> +	pdu->write_offset = VIRTIO_P9_HDR_LEN;
>  	pdu->queue_head  = virt_queue__get_inout_iov(kvm, vq, pdu->in_iov,
>  						     pdu->out_iov,
>  						     &pdu->in_iov_cnt,

Patch

diff --git a/tools/kvm/Makefile b/tools/kvm/Makefile
index d368c22..559fefc 100644
--- a/tools/kvm/Makefile
+++ b/tools/kvm/Makefile
@@ -57,6 +57,7 @@  OBJS	+= util/parse-options.o
 OBJS	+= util/rbtree-interval.o
 OBJS	+= util/strbuf.o
 OBJS	+= virtio/9p.o
+OBJS	+= virtio/9p-pdu.o
 OBJS	+= hw/vesa.o
 OBJS	+= hw/i8042.o
 
diff --git a/tools/kvm/include/kvm/virtio-9p.h b/tools/kvm/include/kvm/virtio-9p.h
index d99bf96..27f52aa 100644
--- a/tools/kvm/include/kvm/virtio-9p.h
+++ b/tools/kvm/include/kvm/virtio-9p.h
@@ -1,8 +1,86 @@ 
 #ifndef KVM__VIRTIO_9P_H
 #define KVM__VIRTIO_9P_H
+#include "kvm/virtio-pci-dev.h"
+#include "kvm/virtio.h"
+#include "kvm/ioport.h"
+#include "kvm/mutex.h"
+#include "kvm/util.h"
+#include "kvm/kvm.h"
+#include "kvm/pci.h"
+#include "kvm/threadpool.h"
+#include "kvm/irq.h"
+#include "kvm/ioeventfd.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pthread.h>
+#include <dirent.h>
+
+#include <linux/virtio_ring.h>
+#include <linux/virtio_9p.h>
+
+#define NUM_VIRT_QUEUES		1
+#define VIRTQUEUE_NUM		128
+#define	VIRTIO_P9_DEFAULT_TAG	"kvm_9p"
+#define VIRTIO_P9_HDR_LEN	(sizeof(u32)+sizeof(u8)+sizeof(u16))
+#define VIRTIO_P9_MAX_FID	128
+#define VIRTIO_P9_VERSION	"9P2000"
+#define MAX_TAG_LEN		32
+
+
+struct p9_msg {
+	u32			size;
+	u8			cmd;
+	u16			tag;
+	u8			msg[0];
+} __attribute__((packed));
+
+struct p9_fid {
+	u32			fid;
+	u8			is_dir;
+	char			abs_path[PATH_MAX];
+	char			*path;
+	DIR			*dir;
+	int			fd;
+};
+
+struct p9_dev_job {
+	struct virt_queue	*vq;
+	struct p9_dev		*p9dev;
+	void			*job_id;
+};
+
+struct p9_dev {
+	u8			status;
+	u8			isr;
+	u16			config_vector;
+	u32			features;
+	struct virtio_9p_config	*config;
+	u16			base_addr;
+
+	/* virtio queue */
+	u16			queue_selector;
+	struct virt_queue	vqs[NUM_VIRT_QUEUES];
+	struct p9_dev_job	jobs[NUM_VIRT_QUEUES];
+	struct p9_fid		fids[VIRTIO_P9_MAX_FID];
+	char			root_dir[PATH_MAX];
+	struct pci_device_header pci_hdr;
+};
+
+struct p9_pdu {
+	u32			queue_head;
+	size_t			read_offset;
+	size_t			write_offset;
+	u16			out_iov_cnt;
+	u16			in_iov_cnt;
+	struct iovec		in_iov[VIRTQUEUE_NUM];
+	struct iovec		out_iov[VIRTQUEUE_NUM];
+};
 
 struct kvm;
 
 void virtio_9p__init(struct kvm *kvm, const char *root, const char *tag_name);
-
+int virtio_p9_pdu_readf(struct p9_pdu *pdu, const char *fmt, ...);
+int virtio_p9_pdu_writef(struct p9_pdu *pdu, const char *fmt, ...);
 #endif
diff --git a/tools/kvm/virtio/9p-pdu.c b/tools/kvm/virtio/9p-pdu.c
new file mode 100644
index 0000000..07cafd3
--- /dev/null
+++ b/tools/kvm/virtio/9p-pdu.c
@@ -0,0 +1,239 @@ 
+#include "kvm/virtio-9p.h"
+
+#include <endian.h>
+
+#include <net/9p/9p.h>
+
+static void virtio_p9_pdu_read(struct p9_pdu *pdu, void *data, size_t size)
+{
+	size_t len;
+	int i, copied = 0;
+	u16 iov_cnt = pdu->out_iov_cnt;
+	size_t offset = pdu->read_offset;
+	struct iovec *iov = pdu->out_iov;
+
+	for (i = 0; i < iov_cnt && size; i++) {
+		if (offset >= iov[i].iov_len) {
+			offset -= iov[i].iov_len;
+			continue;
+		} else {
+			len = MIN(iov[i].iov_len - offset, size);
+			memcpy(data, iov[i].iov_base + offset, len);
+			size -= len;
+			data += len;
+			offset = 0;
+			copied += len;
+		}
+	}
+	pdu->read_offset += copied;
+}
+
+static void virtio_p9_pdu_write(struct p9_pdu *pdu,
+				const void *data, size_t size)
+{
+	size_t len;
+	int i, copied = 0;
+	u16 iov_cnt = pdu->in_iov_cnt;
+	size_t offset = pdu->write_offset;
+	struct iovec *iov = pdu->in_iov;
+
+	for (i = 0; i < iov_cnt && size; i++) {
+		if (offset >= iov[i].iov_len) {
+			offset -= iov[i].iov_len;
+			continue;
+		} else {
+			len = MIN(iov[i].iov_len - offset, size);
+			memcpy(iov[i].iov_base + offset, data, len);
+			size -= len;
+			data += len;
+			offset = 0;
+			copied += len;
+		}
+	}
+	pdu->write_offset += copied;
+}
+
+static void virtio_p9_wstat_free(struct p9_wstat *stbuf)
+{
+	free(stbuf->name);
+	free(stbuf->uid);
+	free(stbuf->gid);
+	free(stbuf->muid);
+}
+
+static int virtio_p9_decode(struct p9_pdu *pdu, const char *fmt, va_list ap)
+{
+	int retval = 0;
+	const char *ptr;
+
+	for (ptr = fmt; *ptr; ptr++) {
+		switch (*ptr) {
+		case 'b':
+		{
+			int8_t *val = va_arg(ap, int8_t *);
+			virtio_p9_pdu_read(pdu, val, sizeof(*val));
+		}
+		break;
+		case 'w':
+		{
+			int16_t le_val;
+			int16_t *val = va_arg(ap, int16_t *);
+			virtio_p9_pdu_read(pdu, &le_val, sizeof(le_val));
+			*val = le16toh(le_val);
+		}
+		break;
+		case 'd':
+		{
+			int32_t le_val;
+			int32_t *val = va_arg(ap, int32_t *);
+			virtio_p9_pdu_read(pdu, &le_val, sizeof(le_val));
+			*val = le32toh(le_val);
+		}
+		break;
+		case 'q':
+		{
+			int64_t le_val;
+			int64_t *val = va_arg(ap, int64_t *);
+			virtio_p9_pdu_read(pdu, &le_val, sizeof(le_val));
+			*val = le64toh(le_val);
+		}
+		break;
+		case 's':
+		{
+			int16_t len;
+			char **str = va_arg(ap, char **);
+
+			virtio_p9_pdu_readf(pdu, "w", &len);
+			*str = malloc(len + 1);
+			if (*str == NULL) {
+				retval = ENOMEM;
+				break;
+			}
+			virtio_p9_pdu_read(pdu, *str, len);
+			(*str)[len] = 0;
+		}
+		break;
+		case 'Q':
+		{
+			struct p9_qid *qid = va_arg(ap, struct p9_qid *);
+			retval = virtio_p9_pdu_readf(pdu, "bdq",
+						     &qid->type, &qid->version,
+						     &qid->path);
+		}
+		break;
+		case 'S':
+		{
+			struct p9_wstat *stbuf = va_arg(ap, struct p9_wstat *);
+			memset(stbuf, 0, sizeof(struct p9_wstat));
+			stbuf->n_uid = stbuf->n_gid = stbuf->n_muid = -1;
+			retval = virtio_p9_pdu_readf(pdu, "wwdQdddqssss",
+						&stbuf->size, &stbuf->type,
+						&stbuf->dev, &stbuf->qid,
+						&stbuf->mode, &stbuf->atime,
+						&stbuf->mtime, &stbuf->length,
+						&stbuf->name, &stbuf->uid,
+						&stbuf->gid, &stbuf->muid);
+			if (retval)
+				virtio_p9_wstat_free(stbuf);
+		}
+		break;
+		default:
+			retval = EINVAL;
+			break;
+		}
+	}
+	return retval;
+}
+
+static int virtio_p9_pdu_encode(struct p9_pdu *pdu, const char *fmt, va_list ap)
+{
+	int retval = 0;
+	const char *ptr;
+
+	for (ptr = fmt; *ptr; ptr++) {
+		switch (*ptr) {
+		case 'b':
+		{
+			int8_t val = va_arg(ap, int);
+			virtio_p9_pdu_write(pdu, &val, sizeof(val));
+		}
+		break;
+		case 'w':
+		{
+			int16_t val = htole16(va_arg(ap, int));
+			virtio_p9_pdu_write(pdu, &val, sizeof(val));
+		}
+		break;
+		case 'd':
+		{
+			int32_t val = htole32(va_arg(ap, int32_t));
+			virtio_p9_pdu_write(pdu, &val, sizeof(val));
+		}
+		break;
+		case 'q':
+		{
+			int64_t val = htole64(va_arg(ap, int64_t));
+			virtio_p9_pdu_write(pdu, &val, sizeof(val));
+		}
+		break;
+		case 's':
+		{
+			uint16_t len = 0;
+			const char *s = va_arg(ap, char *);
+			if (s)
+				len = MIN(strlen(s), USHRT_MAX);
+			virtio_p9_pdu_writef(pdu, "w", len);
+			virtio_p9_pdu_write(pdu, s, len);
+		}
+		break;
+		case 'Q':
+		{
+			struct p9_qid *qid = va_arg(ap, struct p9_qid *);
+			retval = virtio_p9_pdu_writef(pdu, "bdq",
+						      qid->type, qid->version,
+						      qid->path);
+		}
+		break;
+		case 'S':
+		{
+			struct p9_wstat *stbuf = va_arg(ap, struct p9_wstat *);
+			retval = virtio_p9_pdu_writef(pdu, "wwdQdddqssss",
+						stbuf->size, stbuf->type,
+						stbuf->dev, &stbuf->qid,
+						stbuf->mode, stbuf->atime,
+						stbuf->mtime, stbuf->length,
+						stbuf->name, stbuf->uid,
+						stbuf->gid, stbuf->muid);
+		}
+		break;
+		default:
+			retval = EINVAL;
+			break;
+		}
+	}
+	return retval;
+}
+
+int virtio_p9_pdu_readf(struct p9_pdu *pdu, const char *fmt, ...)
+{
+	int ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = virtio_p9_decode(pdu, fmt, ap);
+	va_end(ap);
+
+	return ret;
+}
+
+int virtio_p9_pdu_writef(struct p9_pdu *pdu, const char *fmt, ...)
+{
+	int ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = virtio_p9_pdu_encode(pdu, fmt, ap);
+	va_end(ap);
+
+	return ret;
+}
diff --git a/tools/kvm/virtio/9p.c b/tools/kvm/virtio/9p.c
index d2d738d..a08d7ec 100644
--- a/tools/kvm/virtio/9p.c
+++ b/tools/kvm/virtio/9p.c
@@ -1,81 +1,6 @@ 
 #include "kvm/virtio-9p.h"
-#include "kvm/virtio-pci-dev.h"
-#include "kvm/virtio.h"
-#include "kvm/ioport.h"
-#include "kvm/mutex.h"
-#include "kvm/util.h"
-#include "kvm/kvm.h"
-#include "kvm/pci.h"
-#include "kvm/threadpool.h"
-#include "kvm/irq.h"
-#include "kvm/ioeventfd.h"
-
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <pthread.h>
-#include <dirent.h>
-
-#include <linux/virtio_ring.h>
-#include <linux/virtio_9p.h>
-#include <net/9p/9p.h>
-
-#define NUM_VIRT_QUEUES		1
-#define VIRTQUEUE_NUM		128
-#define	VIRTIO_P9_DEFAULT_TAG	"kvm_9p"
-#define VIRTIO_P9_HDR_LEN	(sizeof(u32)+sizeof(u8)+sizeof(u16))
-#define VIRTIO_P9_MAX_FID	128
-#define VIRTIO_P9_VERSION	"9P2000"
-#define MAX_TAG_LEN		32
-
-
-struct p9_msg {
-	u32			size;
-	u8			cmd;
-	u16			tag;
-	u8			msg[0];
-} __attribute__((packed));
-
-struct p9_fid {
-	u32			fid;
-	u8			is_dir;
-	char			abs_path[PATH_MAX];
-	char			*path;
-	DIR			*dir;
-	int			fd;
-};
-
-struct p9_dev_job {
-	struct virt_queue		*vq;
-	struct p9_dev			*p9dev;
-	void				*job_id;
-};
-
-struct p9_dev {
-	u8			status;
-	u8			isr;
-	u16			config_vector;
-	u32			features;
-	struct virtio_9p_config	*config;
-	u16			base_addr;
-
-	/* virtio queue */
-	u16			queue_selector;
-	struct virt_queue	vqs[NUM_VIRT_QUEUES];
-	struct p9_dev_job	jobs[NUM_VIRT_QUEUES];
-	struct p9_fid		fids[VIRTIO_P9_MAX_FID];
-	char			root_dir[PATH_MAX];
-	struct pci_device_header pci_hdr;
-};
 
-struct p9_pdu {
-	u32 queue_head;
-	int offset;
-	u16 out_iov_cnt;
-	u16 in_iov_cnt;
-	struct iovec in_iov[VIRTQUEUE_NUM];
-	struct iovec out_iov[VIRTQUEUE_NUM];
-};
+#include <net/9p/9p.h>
 
 /* Warning: Immediately use value returned from this function */
 static const char *rel_to_abs(struct p9_dev *p9dev,
@@ -185,13 +110,16 @@  static void close_fid(struct p9_dev *p9dev, u32 fid)
 	}
 }
 
-static void set_p9msg_hdr(struct p9_msg *msg, u32 size, u8 cmd, u16 tag)
+static void virtio_p9_set_reply_header(struct p9_pdu *pdu, u32 size)
 {
-	*msg = (struct p9_msg) {
-		.size	= size,
-		.tag	= tag,
-		.cmd	= cmd,
-	};
+	u8 cmd;
+	u16 tag;
+
+	pdu->read_offset = sizeof(u32);
+	virtio_p9_pdu_readf(pdu, "bw", &cmd, &tag);
+	pdu->write_offset = 0;
+	/* cmd + 1 is the reply message */
+	virtio_p9_pdu_writef(pdu, "dbw", size, cmd + 1, tag);
 }
 
 static u16 virtio_p9_update_iov_cnt(struct iovec iov[], u32 count, int iov_cnt)
@@ -213,67 +141,61 @@  static u16 virtio_p9_update_iov_cnt(struct iovec iov[], u32 count, int iov_cnt)
 static void virtio_p9_error_reply(struct p9_dev *p9dev,
 				  struct p9_pdu *pdu, int err, u32 *outlen)
 {
+	u16 tag;
 	char *err_str;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_rerror *rerror  = (struct p9_rerror *)inmsg->msg;
 
 	err_str = strerror(err);
-	rerror->error.len = strlen(err_str);
-	memcpy(&rerror->error.str, err_str, rerror->error.len);
+	pdu->write_offset = VIRTIO_P9_HDR_LEN;
+	virtio_p9_pdu_writef(pdu, "s", err_str);
+	*outlen = pdu->write_offset;
+
+	pdu->read_offset = sizeof(u32) + sizeof(u8);
+	virtio_p9_pdu_readf(pdu, "w", &tag);
 
-	*outlen = VIRTIO_P9_HDR_LEN + rerror->error.len + sizeof(u16);
-	set_p9msg_hdr(inmsg, *outlen, P9_RERROR, outmsg->tag);
+	pdu->write_offset = 0;
+	virtio_p9_pdu_writef(pdu, "dbw", *outlen, P9_RERROR, tag);
 }
 
 static void virtio_p9_version(struct p9_dev *p9dev,
 			      struct p9_pdu *pdu, u32 *outlen)
 {
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_rversion *rversion = (struct p9_rversion *)inmsg->msg;
-
-	rversion->msize		= 4096;
-	rversion->version.len	= strlen(VIRTIO_P9_VERSION);
-	memcpy(&rversion->version.str, VIRTIO_P9_VERSION, rversion->version.len);
-
-	*outlen = VIRTIO_P9_HDR_LEN +
-		rversion->version.len + sizeof(u16) + sizeof(u32);
-	set_p9msg_hdr(inmsg, *outlen, P9_RVERSION, outmsg->tag);
+	virtio_p9_pdu_writef(pdu, "ds", 4096, VIRTIO_P9_VERSION);
 
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 }
 
 static void virtio_p9_clunk(struct p9_dev *p9dev,
 			    struct p9_pdu *pdu, u32 *outlen)
 {
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_tclunk *tclunk = (struct p9_tclunk *)outmsg->msg;
-
-	close_fid(p9dev, tclunk->fid);
+	u32 fid;
 
-	*outlen = VIRTIO_P9_HDR_LEN;
-	set_p9msg_hdr(inmsg, *outlen, P9_RCLUNK, outmsg->tag);
+	virtio_p9_pdu_readf(pdu, "d", &fid);
+	close_fid(p9dev, fid);
 
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 }
 
 static void virtio_p9_open(struct p9_dev *p9dev,
 			   struct p9_pdu *pdu, u32 *outlen)
 {
+	u8 mode;
+	u32 fid;
 	struct stat st;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_topen *topen	= (struct p9_topen *)outmsg->msg;
-	struct p9_ropen *ropen	= (struct p9_ropen *)inmsg->msg;
-	struct p9_fid *new_fid	= &p9dev->fids[topen->fid];
+	struct p9_qid qid;
+	struct p9_fid *new_fid;
+
+
+	virtio_p9_pdu_readf(pdu, "db", &fid, &mode);
+	new_fid = &p9dev->fids[fid];
 
 	if (lstat(new_fid->abs_path, &st) < 0)
 		goto err_out;
 
-	st2qid(&st, &ropen->qid);
-	ropen->iounit = 0;
+	st2qid(&st, &qid);
 
 	if (new_fid->is_dir) {
 		new_fid->dir = opendir(new_fid->abs_path);
@@ -281,12 +203,14 @@  static void virtio_p9_open(struct p9_dev *p9dev,
 			goto err_out;
 	} else {
 		new_fid->fd  = open(new_fid->abs_path,
-				   omode2uflags(topen->mode) | O_NOFOLLOW);
+				    omode2uflags(mode) | O_NOFOLLOW);
 		if (new_fid->fd < 0)
 			goto err_out;
 	}
-	*outlen = VIRTIO_P9_HDR_LEN + sizeof(*ropen);
-	set_p9msg_hdr(inmsg, *outlen, P9_ROPEN, outmsg->tag);
+	virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
+
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 err_out:
 	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
@@ -298,39 +222,33 @@  static void virtio_p9_create(struct p9_dev *p9dev,
 {
 	u8 mode;
 	u32 perm;
+	char *name;
+	u32 fid_val;
 	struct stat st;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_tcreate *tcreate	= (struct p9_tcreate *)outmsg->msg;
-	struct p9_rcreate *rcreate	= (struct p9_rcreate *)inmsg->msg;
-	struct p9_fid *fid		= &p9dev->fids[tcreate->fid];
-
-
-	rcreate->iounit = 0;
-
-	/* Get last byte of the variable length struct */
-	mode = *((u8 *)outmsg + outmsg->size - 1);
-	perm = *(u32 *)((u8 *)outmsg + outmsg->size - 5);
+	struct p9_qid qid;
+	struct p9_fid *fid;
 
-	sprintf(fid->path, "%s/%.*s", fid->path, tcreate->name.len, (char *)&tcreate->name.str);
+	virtio_p9_pdu_readf(pdu, "dsdb", &fid_val, &name, &perm, &mode);
+	fid = &p9dev->fids[fid_val];
 
-	close_fid(p9dev, tcreate->fid);
+	sprintf(fid->path, "%s/%.*s", fid->path, (int)strlen(name), name);
+	close_fid(p9dev, fid_val);
 
 	if (perm & P9_DMDIR) {
 		mkdir(fid->abs_path, perm & 0xFFFF);
 		fid->dir = opendir(fid->abs_path);
 		fid->is_dir = 1;
 	} else {
-		fid->fd = open(fid->abs_path, omode2uflags(mode) | O_CREAT, 0777);
+		fid->fd = open(fid->abs_path,
+			       omode2uflags(mode) | O_CREAT, 0777);
 	}
-
 	if (lstat(fid->abs_path, &st) < 0)
 		goto err_out;
 
-	st2qid(&st, &rcreate->qid);
-
-	*outlen = VIRTIO_P9_HDR_LEN + sizeof(*rcreate);
-	set_p9msg_hdr(inmsg, *outlen, P9_RCREATE, outmsg->tag);
+	st2qid(&st, &qid);
+	virtio_p9_pdu_writef(pdu, "Qd", &qid, 0);
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 err_out:
 	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
@@ -341,45 +259,57 @@  static void virtio_p9_walk(struct p9_dev *p9dev,
 			   struct p9_pdu *pdu, u32 *outlen)
 {
 	u8 i;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_twalk *twalk	= (struct p9_twalk *)outmsg->msg;
-	struct p9_rwalk *rwalk	= (struct p9_rwalk *)inmsg->msg;
-	struct p9_str *str	= twalk->wnames;
-	struct p9_fid *new_fid	= &p9dev->fids[twalk->newfid];
+	u16 nwqid;
+	char *str;
+	u16 nwname;
+	u32 fid_val;
+	u32 newfid_val;
+	struct p9_qid wqid;
+	struct p9_fid *new_fid;
+
 
+	virtio_p9_pdu_readf(pdu, "ddw", &fid_val, &newfid_val, &nwname);
+	new_fid	= &p9dev->fids[newfid_val];
 
-	rwalk->nwqid = 0;
-	if (twalk->nwname) {
-		struct p9_fid *fid = &p9dev->fids[twalk->fid];
+	nwqid = 0;
+	if (nwname) {
+		struct p9_fid *fid = &p9dev->fids[fid_val];
 
-		for (i = 0; i < twalk->nwname; i++) {
+		/* skip the space for count */
+		pdu->write_offset += sizeof(u16);
+		for (i = 0; i < nwname; i++) {
+			struct stat st;
 			char tmp[PATH_MAX] = {0};
 			char full_path[PATH_MAX];
-			struct stat st;
 
-			/* Format the new path we're 'walk'ing into */
-			sprintf(tmp, "%s/%.*s", fid->path,
-				str->len, (char *)&str->str);
+			virtio_p9_pdu_readf(pdu, "s", &str);
 
+			/* Format the new path we're 'walk'ing into */
+			sprintf(tmp, "%s/%.*s",
+				fid->path, (int)strlen(str), str);
 			if (lstat(rel_to_abs(p9dev, tmp, full_path), &st) < 0)
 				goto err_out;
 
-			st2qid(&st, &rwalk->wqids[i]);
+			st2qid(&st, &wqid);
 			new_fid->is_dir = S_ISDIR(st.st_mode);
 			strcpy(new_fid->path, tmp);
-			new_fid->fid = twalk->newfid;
-			rwalk->nwqid++;
+			new_fid->fid = newfid_val;
+			nwqid++;
+			virtio_p9_pdu_writef(pdu, "Q", &wqid);
 		}
 	} else {
-		new_fid->is_dir = p9dev->fids[twalk->fid].is_dir;
-		strcpy(new_fid->path, p9dev->fids[twalk->fid].path);
-		new_fid->fid	= twalk->newfid;
+		/*
+		 * update write_offset so our outlen get correct value
+		 */
+		pdu->write_offset += sizeof(u16);
+		new_fid->is_dir = p9dev->fids[fid_val].is_dir;
+		strcpy(new_fid->path, p9dev->fids[fid_val].path);
+		new_fid->fid	= newfid_val;
 	}
-
-	*outlen = VIRTIO_P9_HDR_LEN + sizeof(u16) +
-		sizeof(struct p9_qid)*rwalk->nwqid;
-	set_p9msg_hdr(inmsg, *outlen, P9_RWALK, outmsg->tag);
+	*outlen = pdu->write_offset;
+	pdu->write_offset = VIRTIO_P9_HDR_LEN;
+	virtio_p9_pdu_writef(pdu, "d", nwqid);
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 err_out:
 	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
@@ -390,12 +320,15 @@  static void virtio_p9_attach(struct p9_dev *p9dev,
 			     struct p9_pdu *pdu, u32 *outlen)
 {
 	u32 i;
+	u32 fid_val;
+	u32 afid;
+	char *uname;
+	char *aname;
 	struct stat st;
+	struct p9_qid qid;
 	struct p9_fid *fid;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_rattach *rattach = (struct p9_rattach *)inmsg->msg;
-	struct p9_tattach *tattach = (struct p9_tattach *)outmsg->msg;
+
+	virtio_p9_pdu_readf(pdu, "ddss", &fid_val, &afid, &uname, &aname);
 
 	/* Reset everything */
 	for (i = 0; i < VIRTIO_P9_MAX_FID; i++)
@@ -404,103 +337,106 @@  static void virtio_p9_attach(struct p9_dev *p9dev,
 	if (lstat(p9dev->root_dir, &st) < 0)
 		goto err_out;
 
-	st2qid(&st, &rattach->qid);
+	st2qid(&st, &qid);
 
-	fid = &p9dev->fids[tattach->fid];
-	fid->fid = tattach->fid;
+	fid = &p9dev->fids[fid_val];
+	fid->fid = fid_val;
 	fid->is_dir = 1;
 	strcpy(fid->path, "/");
 
-	*outlen = VIRTIO_P9_HDR_LEN + sizeof(*rattach);
-	set_p9msg_hdr(inmsg, *outlen, P9_RATTACH, outmsg->tag);
+	virtio_p9_pdu_writef(pdu, "Q", &qid);
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 err_out:
 	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
 	return;
 }
 
-static u32 virtio_p9_fill_stat(struct p9_dev *p9dev, const char *name,
-			       struct stat *st, struct p9_rstat *rstat)
+static void virtio_p9_fill_stat(struct p9_dev *p9dev, const char *name,
+				struct stat *st, struct p9_wstat *wstat)
 {
-	struct p9_str *str;
-
-	rstat->stat.type = 0;
-	rstat->stat.dev = 0;
-	st2qid(st, &rstat->stat.qid);
-	rstat->stat.mode = st->st_mode;
-	rstat->stat.length = st->st_size;
+	wstat->type = 0;
+	wstat->dev = 0;
+	st2qid(st, &wstat->qid);
+	wstat->mode = st->st_mode;
+	wstat->length = st->st_size;
 	if (S_ISDIR(st->st_mode)) {
-		rstat->stat.length = 0;
-		rstat->stat.mode |= P9_DMDIR;
+		wstat->length = 0;
+		wstat->mode |= P9_DMDIR;
 	}
 
-	rstat->stat.atime = st->st_atime;
-	rstat->stat.mtime = st->st_mtime;
-
-	str = (struct p9_str *)&rstat->stat.name;
-	str->len = strlen(name);
-	memcpy(&str->str, name, str->len);
-	str = (void *)str + str->len + sizeof(u16);
-
-	/* TODO: Pass usernames to the client */
-	str->len = 0;
-	str = (void *)str + sizeof(u16);
-	str->len = 0;
-	str = (void *)str + sizeof(u16);
-	str->len = 0;
-	str = (void *)str + sizeof(u16);
-
-	/*
-	 * We subtract a u16 here because rstat->size
-	 * doesn't include rstat->size itself
-	 */
-	rstat->stat.size = (void *)str - (void *)&rstat->stat - sizeof(u16);
-
-	return rstat->stat.size + sizeof(u16);
+	wstat->atime = st->st_atime;
+	wstat->mtime = st->st_mtime;
+
+	wstat->name = strdup(name);
+	wstat->uid = NULL;
+	wstat->gid = NULL;
+	wstat->muid = NULL;
+
+	/* NOTE: size shouldn't include its own length */
+	/* size[2] type[2] dev[4] qid[13] */
+	/* mode[4] atime[4] mtime[4] length[8]*/
+	/* name[s] uid[s] gid[s] muid[s] */
+	wstat->size = 2+4+13+4+4+4+8+2+2+2+2;
+	if (wstat->name)
+		wstat->size += strlen(wstat->name);
 }
 
 static void virtio_p9_read(struct p9_dev *p9dev,
 			   struct p9_pdu *pdu, u32 *outlen)
 {
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_tread *tread	= (struct p9_tread *)outmsg->msg;
-	struct p9_rread *rread	= (struct p9_rread *)inmsg->msg;
-	struct p9_rstat *rstat	= (struct p9_rstat *)pdu->in_iov[1].iov_base;
-	struct p9_fid *fid	= &p9dev->fids[tread->fid];
+	u64 offset;
+	u32 fid_val;
+	u32 count, rcount;
 	struct stat st;
+	struct p9_fid *fid;
+	struct p9_wstat wstat;
 
-	rread->count = 0;
-
+	rcount = 0;
+	virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
+	fid = &p9dev->fids[fid_val];
 	if (fid->is_dir) {
 		/* If reading a dir, fill the buffer with p9_stat entries */
-		struct dirent *cur = readdir(fid->dir);
 		char full_path[PATH_MAX];
+		struct dirent *cur = readdir(fid->dir);
 
+		/* Skip the space for writing count */
+		pdu->write_offset += sizeof(u32);
 		while (cur) {
 			u32 read;
 
 			lstat(rel_to_abs(p9dev, cur->d_name, full_path), &st);
-			read = virtio_p9_fill_stat(p9dev, cur->d_name,
-						   &st, rstat);
-			rread->count += read;
-			rstat = (void *)rstat + read;
+			virtio_p9_fill_stat(p9dev, cur->d_name, &st, &wstat);
+
+			read = pdu->write_offset;
+			virtio_p9_pdu_writef(pdu, "S", &wstat);
+			rcount += pdu->write_offset - read;
+
 			cur = readdir(fid->dir);
 		}
 	} else {
 		pdu->in_iov[0].iov_base += VIRTIO_P9_HDR_LEN + sizeof(u32);
 		pdu->in_iov[0].iov_len -= VIRTIO_P9_HDR_LEN + sizeof(u32);
 		pdu->in_iov_cnt = virtio_p9_update_iov_cnt(pdu->in_iov,
-							    tread->count,
-							    pdu->in_iov_cnt);
-		rread->count = preadv(fid->fd, pdu->in_iov,
-				      pdu->in_iov_cnt, tread->offset);
-		if (rread->count > tread->count)
-			rread->count = tread->count;
-	}
+							   count,
+							   pdu->in_iov_cnt);
+		rcount = preadv(fid->fd, pdu->in_iov,
+				pdu->in_iov_cnt, offset);
+		if (rcount > count)
+			rcount = count;
+		/*
+		 * Update the iov_base back, so that rest of
+		 * pdu_writef works correctly.
+		 */
+		pdu->in_iov[0].iov_base -= VIRTIO_P9_HDR_LEN + sizeof(u32);
+		pdu->in_iov[0].iov_len += VIRTIO_P9_HDR_LEN + sizeof(u32);
 
-	*outlen = VIRTIO_P9_HDR_LEN + sizeof(u32) + rread->count;
-	set_p9msg_hdr(inmsg, *outlen, P9_RREAD, outmsg->tag);
+	}
+	pdu->write_offset = VIRTIO_P9_HDR_LEN;
+	virtio_p9_pdu_writef(pdu, "d", rcount);
+	*outlen = pdu->write_offset + rcount;
+	virtio_p9_set_reply_header(pdu, *outlen);
 
 	return;
 }
@@ -508,21 +444,21 @@  static void virtio_p9_read(struct p9_dev *p9dev,
 static void virtio_p9_stat(struct p9_dev *p9dev,
 			   struct p9_pdu *pdu, u32 *outlen)
 {
-	u32 ret;
+	u32 fid_val;
 	struct stat st;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_tstat *tstat = (struct p9_tstat *)outmsg->msg;
-	struct p9_rstat *rstat = (struct p9_rstat *)(inmsg->msg + sizeof(u16));
-	struct p9_fid *fid = &p9dev->fids[tstat->fid];
+	struct p9_fid *fid;
+	struct p9_wstat wstat;
 
+	virtio_p9_pdu_readf(pdu, "d", &fid_val);
+	fid = &p9dev->fids[fid_val];
 	if (lstat(fid->abs_path, &st) < 0)
 		goto err_out;
 
-	ret = virtio_p9_fill_stat(p9dev, fid->path, &st, rstat);
+	virtio_p9_fill_stat(p9dev, fid->path, &st, &wstat);
 
-	*outlen = VIRTIO_P9_HDR_LEN + ret + sizeof(u16);
-	set_p9msg_hdr(inmsg, *outlen, P9_RSTAT, outmsg->tag);
+	virtio_p9_pdu_writef(pdu, "wS", 0, &wstat);
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 err_out:
 	virtio_p9_error_reply(p9dev, pdu, errno, outlen);
@@ -533,21 +469,21 @@  static void virtio_p9_wstat(struct p9_dev *p9dev,
 			    struct p9_pdu *pdu, u32 *outlen)
 {
 	int res = 0;
-	struct p9_str *str;
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_twstat *twstat = (struct p9_twstat *)outmsg->msg;
-	struct p9_fid *fid = &p9dev->fids[twstat->fid];
+	u32 fid_val;
+	u16 unused;
+	struct p9_fid *fid;
+	struct p9_wstat wstat;
 
+	virtio_p9_pdu_readf(pdu, "dwS", &fid_val, &unused, &wstat);
+	fid = &p9dev->fids[fid_val];
 
-	if (twstat->stat.length != -1UL)
-		res = ftruncate(fid->fd, twstat->stat.length);
+	if (wstat.length != -1UL)
+		res = ftruncate(fid->fd, wstat.length);
 
-	if (twstat->stat.mode != -1U)
-		chmod(fid->abs_path, twstat->stat.mode & 0xFFFF);
+	if (wstat.mode != -1U)
+		chmod(fid->abs_path, wstat.mode & 0xFFFF);
 
-	str = (void *)&twstat->stat.name + sizeof(u16);
-	if (str->len > 0) {
+	if (strlen(wstat.name) > 0) {
 		char new_name[PATH_MAX] = {0};
 		char full_path[PATH_MAX];
 		char *last_dir = strrchr(fid->path, '/');
@@ -556,57 +492,59 @@  static void virtio_p9_wstat(struct p9_dev *p9dev,
 		if (last_dir)
 			strncpy(new_name, fid->path, last_dir - fid->path + 1);
 
-		memcpy(new_name + strlen(new_name), &str->str, str->len);
+		memcpy(new_name + strlen(new_name),
+		       wstat.name, strlen(wstat.name));
 
 		/* fid is reused for the new file */
 		rename(fid->abs_path, rel_to_abs(p9dev, new_name, full_path));
 		sprintf(fid->path, "%s", new_name);
 	}
-
 	*outlen = VIRTIO_P9_HDR_LEN;
-	set_p9msg_hdr(inmsg, *outlen, P9_RWSTAT, outmsg->tag);
-
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 }
 
 static void virtio_p9_remove(struct p9_dev *p9dev,
 			     struct p9_pdu *pdu, u32 *outlen)
 {
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_tremove *tremove = (struct p9_tremove *)outmsg->msg;
-	struct p9_fid *fid = &p9dev->fids[tremove->fid];
+	u32 fid_val;
+	struct p9_fid *fid;
 
-	close_fid(p9dev, tremove->fid);
+	virtio_p9_pdu_readf(pdu, "d", &fid_val);
+	fid = &p9dev->fids[fid_val];
+	close_fid(p9dev, fid_val);
 	if (fid->is_dir)
 		rmdir(fid->abs_path);
 	else
 		unlink(fid->abs_path);
 
 	*outlen = VIRTIO_P9_HDR_LEN;
-	set_p9msg_hdr(inmsg, *outlen, P9_RREMOVE, outmsg->tag);
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 }
 
 static void virtio_p9_write(struct p9_dev *p9dev,
 			    struct p9_pdu *pdu, u32 *outlen)
 {
-	struct p9_msg *inmsg  = pdu->in_iov[0].iov_base;
-	struct p9_msg *outmsg = pdu->out_iov[0].iov_base;
-	struct p9_twrite *twrite = (struct p9_twrite *)outmsg->msg;
-	struct p9_rwrite *rwrite = (struct p9_rwrite *)inmsg->msg;
-	struct p9_fid *fid = &p9dev->fids[twrite->fid];
+	u64 offset;
+	u32 fid_val;
+	u32 count, rcount;
+	struct p9_fid *fid;
 
+	virtio_p9_pdu_readf(pdu, "dqd", &fid_val, &offset, &count);
+	fid = &p9dev->fids[fid_val];
 
-	pdu->out_iov[0].iov_base += (sizeof(*outmsg) + sizeof(*twrite));
-	pdu->out_iov[0].iov_len -= (sizeof(*outmsg) + sizeof(*twrite));
-	pdu->out_iov_cnt = virtio_p9_update_iov_cnt(pdu->out_iov, twrite->count,
+	/* Adjust the iovec to skip the header and meta data */
+	pdu->out_iov[0].iov_base += (sizeof(struct p9_msg) +
+				     sizeof(struct p9_twrite));
+	pdu->out_iov[0].iov_len -=  (sizeof(struct p9_msg) +
+				     sizeof(struct p9_twrite));
+	pdu->out_iov_cnt = virtio_p9_update_iov_cnt(pdu->out_iov, count,
 						    pdu->out_iov_cnt);
-	rwrite->count = pwritev(fid->fd, pdu->out_iov,
-				pdu->out_iov_cnt, twrite->offset);
-	*outlen = VIRTIO_P9_HDR_LEN + sizeof(u32);
-	set_p9msg_hdr(inmsg, *outlen, P9_RWRITE, outmsg->tag);
-
+	rcount = pwritev(fid->fd, pdu->out_iov, pdu->out_iov_cnt, offset);
+	virtio_p9_pdu_writef(pdu, "d", rcount);
+	*outlen = pdu->write_offset;
+	virtio_p9_set_reply_header(pdu, *outlen);
 	return;
 }
 
@@ -633,6 +571,9 @@  static struct p9_pdu *virtio_p9_pdu_init(struct kvm *kvm, struct virt_queue *vq)
 	if (!pdu)
 		return NULL;
 
+	/* skip the pdu header p9_msg */
+	pdu->read_offset  = VIRTIO_P9_HDR_LEN;
+	pdu->write_offset = VIRTIO_P9_HDR_LEN;
 	pdu->queue_head  = virt_queue__get_inout_iov(kvm, vq, pdu->in_iov,
 						     pdu->out_iov,
 						     &pdu->in_iov_cnt,