From patchwork Thu Jan 7 19:56:24 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wei Liu X-Patchwork-Id: 564425 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id EA78E1402BC for ; Fri, 8 Jan 2016 07:04:11 +1100 (AEDT) Received: from localhost ([::1]:60755 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1aHGn3-0008Tg-Mv for incoming@patchwork.ozlabs.org; Thu, 07 Jan 2016 15:04:09 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:39965) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1aHGmO-00077E-3Q for qemu-devel@nongnu.org; Thu, 07 Jan 2016 15:03:30 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1aHGmJ-0008V7-KI for qemu-devel@nongnu.org; Thu, 07 Jan 2016 15:03:27 -0500 Received: from smtp02.citrix.com ([66.165.176.63]:28564) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1aHGmJ-0008Uh-DH for qemu-devel@nongnu.org; Thu, 07 Jan 2016 15:03:23 -0500 X-IronPort-AV: E=Sophos;i="5.20,534,1444694400"; d="scan'208";a="329696013" From: Wei Liu To: Date: Thu, 7 Jan 2016 19:56:24 +0000 Message-ID: <1452196584-17259-28-git-send-email-wei.liu2@citrix.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1452196584-17259-1-git-send-email-wei.liu2@citrix.com> References: <1452196584-17259-1-git-send-email-wei.liu2@citrix.com> MIME-Version: 1.0 X-DLP: MIA1 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 66.165.176.63 Cc: Wei Liu , "Michael S. Tsirkin" , Alexander Graf , Christian Borntraeger , "Aneesh Kumar K.V" , Cornelia Huck , Richard Henderson , Greg Kurz Subject: [Qemu-devel] [PATCH v2 27/27] 9pfs: disentangle V9fsState X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org V9fsState now only contains generic fields. Introduce V9fsVirtioState for virtio transport. Change virtio-pci and virtio-ccw to use V9fsVirtioState. Handle transport enumeration in generic routines. Signed-off-by: Wei Liu --- hw/9pfs/9p.c | 41 ++++++++++++++++++----- hw/9pfs/9p.h | 19 +++++++---- hw/9pfs/virtio-9p-device.c | 82 ++++++++++++++++++++++++++++------------------ hw/9pfs/virtio-9p.h | 12 ++++++- hw/s390x/virtio-ccw.h | 2 +- hw/virtio/virtio-pci.h | 2 +- 6 files changed, 109 insertions(+), 49 deletions(-) diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c index 6858b21..2cf8580 100644 --- a/hw/9pfs/9p.c +++ b/hw/9pfs/9p.c @@ -45,7 +45,13 @@ ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) va_list ap; va_start(ap, fmt); - ret = virtio_pdu_vmarshal(pdu, offset, fmt, ap); + switch (pdu->transport) { + case VIRTIO: + ret = virtio_pdu_vmarshal(pdu, offset, fmt, ap); + break; + default: + ret = -1; + } va_end(ap); return ret; @@ -57,7 +63,13 @@ ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) va_list ap; va_start(ap, fmt); - ret = virtio_pdu_vunmarshal(pdu, offset, fmt, ap); + switch (pdu->transport) { + case VIRTIO: + ret = virtio_pdu_vunmarshal(pdu, offset, fmt, ap); + break; + default: + ret = -1; + } va_end(ap); return ret; @@ -65,7 +77,11 @@ ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) static void pdu_push_and_notify(V9fsPDU *pdu) { - virtio_9p_push_and_notify(pdu); + switch (pdu->transport) { + case VIRTIO: + virtio_9p_push_and_notify(pdu); + break; + } } static int omode_to_uflags(int8_t mode) @@ -1696,7 +1712,11 @@ static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu, struct iovec *iov; unsigned int niov; - virtio_init_iov_from_pdu(pdu, &iov, &niov, is_write); + switch (pdu->transport) { + case VIRTIO: + virtio_init_iov_from_pdu(pdu, &iov, &niov, is_write); + break; + } qemu_iovec_init_external(&elem, iov, niov); qemu_iovec_init(qiov, niov); @@ -3272,8 +3292,10 @@ void pdu_submit(V9fsPDU *pdu) } /* Returns 0 on success, 1 on failure. */ -int v9fs_device_realize_common(V9fsState *s, Error **errp) +int v9fs_device_realize_common(V9fsState *s, enum p9_transport transport, + Error **errp) { + V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); int i, len; struct stat stat; FsDriverEntry *fse; @@ -3284,8 +3306,10 @@ int v9fs_device_realize_common(V9fsState *s, Error **errp) QLIST_INIT(&s->free_list); QLIST_INIT(&s->active_list); for (i = 0; i < (MAX_REQ - 1); i++) { - QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next); - s->pdus[i].s = s; + QLIST_INSERT_HEAD(&s->free_list, &v->pdus[i], next); + v->pdus[i].s = s; + v->pdus[i].idx = i; + v->pdus[i].transport = transport; } v9fs_path_init(&path); @@ -3360,7 +3384,8 @@ out: return rc; } -void v9fs_device_unrealize_common(V9fsState *s, Error **errp) +void v9fs_device_unrealize_common(V9fsState *s, enum p9_transport transport, + Error **errp) { g_free(s->ctx.fs_root); g_free(s->tag); diff --git a/hw/9pfs/9p.h b/hw/9pfs/9p.h index 3fe4da4..bd8588d 100644 --- a/hw/9pfs/9p.h +++ b/hw/9pfs/9p.h @@ -14,6 +14,10 @@ #include "qemu/thread.h" #include "qemu/coroutine.h" +enum p9_transport { + VIRTIO = 0x1, +}; + enum { P9_TLERROR = 6, P9_RLERROR, @@ -131,9 +135,10 @@ struct V9fsPDU uint8_t id; uint8_t cancelled; CoQueue complete; - VirtQueueElement elem; struct V9fsState *s; QLIST_ENTRY(V9fsPDU) next; + uint32_t idx; /* index inside the array */ + enum p9_transport transport; }; @@ -205,16 +210,12 @@ struct V9fsFidState typedef struct V9fsState { - VirtIODevice parent_obj; - VirtQueue *vq; - V9fsPDU pdus[MAX_REQ]; QLIST_HEAD(, V9fsPDU) free_list; QLIST_HEAD(, V9fsPDU) active_list; V9fsFidState *fid_list; FileOperations *ops; FsContext ctx; char *tag; - size_t config_size; enum p9_proto_version proto_version; int32_t msize; /* @@ -318,8 +319,12 @@ extern void v9fs_path_free(V9fsPath *path); extern void v9fs_path_copy(V9fsPath *lhs, V9fsPath *rhs); extern int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath, const char *name, V9fsPath *path); -extern int v9fs_device_realize_common(V9fsState *s, Error **errp); -extern void v9fs_device_unrealize_common(V9fsState *s, Error **errp); + +extern int v9fs_device_realize_common(V9fsState *s, enum p9_transport transport, + Error **errp); +extern void v9fs_device_unrealize_common(V9fsState *s, + enum p9_transport transport, + Error **errp); ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...); ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...); diff --git a/hw/9pfs/virtio-9p-device.c b/hw/9pfs/virtio-9p-device.c index 4aa8a6b..ba6ba11 100644 --- a/hw/9pfs/virtio-9p-device.c +++ b/hw/9pfs/virtio-9p-device.c @@ -24,33 +24,41 @@ void virtio_9p_push_and_notify(V9fsPDU *pdu) { V9fsState *s = pdu->s; + V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); + VirtQueueElement *elem = &v->elems[pdu->idx]; /* push onto queue and notify */ - virtqueue_push(s->vq, &pdu->elem, pdu->size); + virtqueue_push(v->vq, elem, pdu->size); /* FIXME: we should batch these completions */ - virtio_notify(VIRTIO_DEVICE(s), s->vq); + virtio_notify(VIRTIO_DEVICE(v), v->vq); } static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq) { - V9fsState *s = (V9fsState *)vdev; + V9fsVirtioState *v = (V9fsVirtioState *)vdev; + V9fsState *s = &v->state; V9fsPDU *pdu; ssize_t len; - while ((pdu = pdu_alloc(s)) && - (len = virtqueue_pop(vq, &pdu->elem)) != 0) { + while ((pdu = pdu_alloc(s))) { struct { uint32_t size_le; uint8_t id; uint16_t tag_le; } QEMU_PACKED out; - int len; + VirtQueueElement *elem = &v->elems[pdu->idx]; - BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0); + len = virtqueue_pop(vq, elem); + if (!len) { + pdu_free(pdu); + break; + } + + BUG_ON(elem->out_num == 0 || elem->in_num == 0); QEMU_BUILD_BUG_ON(sizeof out != 7); - len = iov_to_buf(pdu->elem.out_sg, pdu->elem.out_num, 0, + len = iov_to_buf(elem->out_sg, elem->out_num, 0, &out, sizeof out); BUG_ON(len != sizeof out); @@ -62,7 +70,6 @@ static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq) qemu_co_queue_init(&pdu->complete); pdu_submit(pdu); } - pdu_free(pdu); } static uint64_t virtio_9p_get_features(VirtIODevice *vdev, uint64_t features, @@ -76,14 +83,15 @@ static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config) { int len; struct virtio_9p_config *cfg; - V9fsState *s = VIRTIO_9P(vdev); + V9fsVirtioState *v = VIRTIO_9P(vdev); + V9fsState *s = &v->state; len = strlen(s->tag); cfg = g_malloc0(sizeof(struct virtio_9p_config) + len); virtio_stw_p(vdev, &cfg->tag_len, len); /* We don't copy the terminating null to config space */ memcpy(cfg->tag, s->tag, len); - memcpy(config, cfg, s->config_size); + memcpy(config, cfg, v->config_size); g_free(cfg); } @@ -100,16 +108,17 @@ static int virtio_9p_load(QEMUFile *f, void *opaque, int version_id) static void virtio_9p_device_realize(DeviceState *dev, Error **errp) { VirtIODevice *vdev = VIRTIO_DEVICE(dev); - V9fsState *s = VIRTIO_9P(dev); + V9fsVirtioState *v = VIRTIO_9P(dev); + V9fsState *s = &v->state; - if (v9fs_device_realize_common(s, errp)) { + if (v9fs_device_realize_common(s, VIRTIO, errp)) { goto out; } - s->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); - virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, s->config_size); - s->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); - register_savevm(dev, "virtio-9p", -1, 1, virtio_9p_save, virtio_9p_load, s); + v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); + virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, v->config_size); + v->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); + register_savevm(dev, "virtio-9p", -1, 1, virtio_9p_save, virtio_9p_load, v); out: return; @@ -118,44 +127,55 @@ out: static void virtio_9p_device_unrealize(DeviceState *dev, Error **errp) { VirtIODevice *vdev = VIRTIO_DEVICE(dev); - V9fsState *s = VIRTIO_9P(dev); + V9fsVirtioState *v = VIRTIO_9P(dev); + V9fsState *s = &v->state; virtio_cleanup(vdev); - unregister_savevm(dev, "virtio-9p", s); - v9fs_device_unrealize_common(s, errp); + unregister_savevm(dev, "virtio-9p", v); + v9fs_device_unrealize_common(s, VIRTIO, errp); } ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, va_list ap) { - return v9fs_iov_vmarshal(pdu->elem.in_sg, pdu->elem.in_num, - offset, 1, fmt, ap); + V9fsState *s = pdu->s; + V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); + VirtQueueElement *elem = &v->elems[pdu->idx]; + + return v9fs_iov_vmarshal(elem->in_sg, elem->in_num, offset, 1, fmt, ap); } ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, va_list ap) { - return v9fs_iov_vunmarshal(pdu->elem.out_sg, pdu->elem.out_num, - offset, 1, fmt, ap); + V9fsState *s = pdu->s; + V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); + VirtQueueElement *elem = &v->elems[pdu->idx]; + + return v9fs_iov_vunmarshal(elem->out_sg, elem->out_num, offset, 1, fmt, ap); } void virtio_init_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, unsigned int *pniov, bool is_write) { + V9fsState *s = pdu->s; + V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); + VirtQueueElement *elem = &v->elems[pdu->idx]; + if (is_write) { - *piov = pdu->elem.out_sg; - *pniov = pdu->elem.out_num; + *piov = elem->out_sg; + *pniov = elem->out_num; } else { - *piov = pdu->elem.in_sg; - *pniov = pdu->elem.in_num; + *piov = elem->in_sg; + *pniov = elem->in_num; } } /* virtio-9p device */ static Property virtio_9p_properties[] = { - DEFINE_PROP_STRING("mount_tag", V9fsState, fsconf.tag), - DEFINE_PROP_STRING("fsdev", V9fsState, fsconf.fsdev_id), + DEFINE_PROP_STRING("mount_tag", V9fsVirtioState, state.fsconf.tag), + DEFINE_PROP_STRING("fsdev", V9fsVirtioState, state.fsconf.fsdev_id), DEFINE_PROP_END_OF_LIST(), }; @@ -175,7 +195,7 @@ static void virtio_9p_class_init(ObjectClass *klass, void *data) static const TypeInfo virtio_device_info = { .name = TYPE_VIRTIO_9P, .parent = TYPE_VIRTIO_DEVICE, - .instance_size = sizeof(V9fsState), + .instance_size = sizeof(V9fsVirtioState), .class_init = virtio_9p_class_init, }; diff --git a/hw/9pfs/virtio-9p.h b/hw/9pfs/virtio-9p.h index 474ab94..1cdf0a2 100644 --- a/hw/9pfs/virtio-9p.h +++ b/hw/9pfs/virtio-9p.h @@ -5,6 +5,16 @@ #include "hw/virtio/virtio.h" #include "9p.h" +typedef struct V9fsVirtioState +{ + VirtIODevice parent_obj; + VirtQueue *vq; + size_t config_size; + V9fsPDU pdus[MAX_REQ]; + VirtQueueElement elems[MAX_REQ]; + V9fsState state; +} V9fsVirtioState; + extern void virtio_9p_push_and_notify(V9fsPDU *pdu); ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, @@ -16,6 +26,6 @@ void virtio_init_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, #define TYPE_VIRTIO_9P "virtio-9p-device" #define VIRTIO_9P(obj) \ - OBJECT_CHECK(V9fsState, (obj), TYPE_VIRTIO_9P) + OBJECT_CHECK(V9fsVirtioState, (obj), TYPE_VIRTIO_9P) #endif diff --git a/hw/s390x/virtio-ccw.h b/hw/s390x/virtio-ccw.h index 7ab8367..a526d2f 100644 --- a/hw/s390x/virtio-ccw.h +++ b/hw/s390x/virtio-ccw.h @@ -210,7 +210,7 @@ VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch); typedef struct V9fsCCWState { VirtioCcwDevice parent_obj; - V9fsState vdev; + V9fsVirtioState vdev; } V9fsCCWState; #endif /* CONFIG_VIRTFS */ diff --git a/hw/virtio/virtio-pci.h b/hw/virtio/virtio-pci.h index 7cf5974..e096e98 100644 --- a/hw/virtio/virtio-pci.h +++ b/hw/virtio/virtio-pci.h @@ -242,7 +242,7 @@ struct VirtIONetPCI { typedef struct V9fsPCIState { VirtIOPCIProxy parent_obj; - V9fsState vdev; + V9fsVirtioState vdev; } V9fsPCIState; #endif