From: Stefano Stabellini <sstabellini@kernel.org> To: xen-devel@lists.xenproject.org Cc: linux-kernel@vger.kernel.org, sstabellini@kernel.org, Stefano Stabellini <stefano@aporeto.com>, boris.ostrovsky@oracle.com, jgross@suse.com, Eric Van Hensbergen <ericvh@gmail.com>, Ron Minnich <rminnich@sandia.gov>, Latchesar Ionkov <lucho@ionkov.net>, v9fs-developer@lists.sourceforge.net Subject: [PATCH 4/7] xen/9pfs: connect to the backend Date: Mon, 6 Mar 2017 12:01:25 -0800 [thread overview] Message-ID: <1488830488-18506-4-git-send-email-sstabellini@kernel.org> (raw) In-Reply-To: <1488830488-18506-1-git-send-email-sstabellini@kernel.org> Implement functions to handle the xenbus handshake. Upon connection, allocate the rings according to the protocol specification. Initialize a work_struct and a wait_queue. The work_struct will be used to schedule work upon receiving an event channel notification from the backend. The wait_queue will be used to wait when the ring is full and we need to send a new request. Signed-off-by: Stefano Stabellini <stefano@aporeto.com> CC: boris.ostrovsky@oracle.com CC: jgross@suse.com CC: Eric Van Hensbergen <ericvh@gmail.com> CC: Ron Minnich <rminnich@sandia.gov> CC: Latchesar Ionkov <lucho@ionkov.net> CC: v9fs-developer@lists.sourceforge.net --- net/9p/trans_xen.c | 227 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) diff --git a/net/9p/trans_xen.c b/net/9p/trans_xen.c index 877dfd0..9f6cf8d 100644 --- a/net/9p/trans_xen.c +++ b/net/9p/trans_xen.c @@ -17,6 +17,36 @@ #include <net/9p/client.h> #include <net/9p/transport.h> +#define XEN_9PFS_NUM_RINGS 2 + +/* One per ring, more than one per 9pfs share */ +struct xen_9pfs_dataring { + struct xen_9pfs_front_priv *priv; + + struct xen_9pfs_data_intf *intf; + grant_ref_t ref; + int evtchn; + int irq; + spinlock_t lock; + + void *bytes; + struct xen_9pfs_data ring; + wait_queue_head_t wq; + struct work_struct work; +}; + +/* One per 9pfs share */ +struct xen_9pfs_front_priv { + struct list_head list; + struct xenbus_device *dev; + char *tag; + struct p9_client *client; + + int num_rings; + struct xen_9pfs_dataring *rings; +}; +static LIST_HEAD(xen_9pfs_devs); + static int p9_xen_cancel(struct p9_client *client, struct p9_req_t *req) { return 0; @@ -36,6 +66,21 @@ static int p9_xen_request(struct p9_client *client, struct p9_req_t *p9_req) return 0; } +static void p9_xen_response(struct work_struct *work) +{ +} + +static irqreturn_t xen_9pfs_front_event_handler(int irq, void *r) +{ + struct xen_9pfs_dataring *ring = r; + BUG_ON(!ring || !ring->priv->client); + + wake_up_interruptible(&ring->wq); + schedule_work(&ring->work); + + return IRQ_HANDLED; +} + static struct p9_trans_module p9_xen_trans = { .name = "xen", .maxsize = (1 << (XEN_9PFS_RING_ORDER + XEN_PAGE_SHIFT)), @@ -52,25 +97,207 @@ static int p9_xen_request(struct p9_client *client, struct p9_req_t *p9_req) { "" } }; +static int xen_9pfs_front_free(struct xen_9pfs_front_priv *priv) +{ + int i, j; + + list_del(&priv->list); + + for (i = 0; i < priv->num_rings; i++) { + if (priv->rings[i].intf == NULL) + break; + if (priv->rings[i].irq > 0) + unbind_from_irqhandler(priv->rings[i].irq, priv->dev); + if (priv->rings[i].bytes != NULL) { + for (j = 0; j < (1 << XEN_9PFS_RING_ORDER); j++) + gnttab_end_foreign_access(priv->rings[i].intf->ref[j], 0, 0); + free_pages((unsigned long)priv->rings[i].bytes, XEN_9PFS_RING_ORDER); + } + gnttab_end_foreign_access(priv->rings[i].ref, 0, 0); + free_page((unsigned long)priv->rings[i].intf); + } + kfree(priv->rings); + kfree(priv); + + return 0; +} + static int xen_9pfs_front_remove(struct xenbus_device *dev) { + int ret; + struct xen_9pfs_front_priv *priv = dev_get_drvdata(&dev->dev); + + dev_set_drvdata(&dev->dev, NULL); + ret = xen_9pfs_front_free(priv); + return ret; +} + +static int xen_9pfs_front_alloc_dataring(struct xenbus_device *dev, + struct xen_9pfs_dataring *ring) +{ + int i; + int ret = -ENOMEM; + + init_waitqueue_head(&ring->wq); + spin_lock_init(&ring->lock); + INIT_WORK(&ring->work, p9_xen_response); + + ring->intf = (struct xen_9pfs_data_intf *) __get_free_page(GFP_KERNEL | __GFP_ZERO); + if (!ring->intf) + goto error; + memset(ring->intf, 0, XEN_PAGE_SIZE); + ring->bytes = (void*)__get_free_pages(GFP_KERNEL | __GFP_ZERO, XEN_9PFS_RING_ORDER); + if (ring->bytes == NULL) + goto error; + for (i = 0; i < (1 << XEN_9PFS_RING_ORDER); i++) + ring->intf->ref[i] = gnttab_grant_foreign_access(dev->otherend_id, pfn_to_gfn(virt_to_pfn((void*)ring->bytes) + i), 0); + ring->ref = gnttab_grant_foreign_access(dev->otherend_id, pfn_to_gfn(virt_to_pfn((void*)ring->intf)), 0); + ring->ring.in = ring->bytes; + ring->ring.out = ring->bytes + XEN_9PFS_RING_SIZE; + + ret = xenbus_alloc_evtchn(dev, &ring->evtchn); + if (ret) + goto error; + ring->irq = bind_evtchn_to_irqhandler(ring->evtchn, xen_9pfs_front_event_handler, + 0, "xen_9pfs-frontend", ring); + if (ring->irq < 0) { + xenbus_free_evtchn(dev, ring->evtchn); + ret = ring->irq; + goto error; + } return 0; + +error: + if (ring->intf != NULL) + kfree(ring->intf); + if (ring->bytes != NULL) + kfree(ring->bytes); + return ret; } static int xen_9pfs_front_probe(struct xenbus_device *dev, const struct xenbus_device_id *id) { + int ret = -EFAULT, i; + struct xenbus_transaction xbt; + struct xen_9pfs_front_priv *priv = NULL; + char *versions; + unsigned int max_rings, max_ring_order, len; + + versions = xenbus_read(XBT_NIL, dev->otherend, "versions", &len); + if (!len || strcmp(versions, "1")) + return -EINVAL; + kfree(versions); + ret = xenbus_scanf(XBT_NIL, dev->otherend, "max-rings", "%u", &max_rings); + if (ret < 0 || max_rings < XEN_9PFS_NUM_RINGS) + return -EINVAL; + ret = xenbus_scanf(XBT_NIL, dev->otherend, "max-ring-page-order", "%u", &max_ring_order); + if (ret < 0|| max_ring_order < XEN_9PFS_RING_ORDER) + return -EINVAL; + + + priv = kzalloc(sizeof(struct xen_9pfs_front_priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->dev = dev; + priv->num_rings = XEN_9PFS_NUM_RINGS; + priv->rings = kzalloc(sizeof(struct xen_9pfs_dataring) * priv->num_rings, + GFP_KERNEL); + if (!priv->rings) { + kfree(priv); + return -ENOMEM; + } + + again: + ret = xenbus_transaction_start(&xbt); + if (ret) { + xenbus_dev_fatal(dev, ret, "starting transaction"); + goto error; + } + ret = xenbus_printf(xbt, dev->nodename, "version", "%u", 1); + if (ret) + goto error_xenbus; + ret = xenbus_printf(xbt, dev->nodename, "num-rings", "%u", priv->num_rings); + if (ret) + goto error_xenbus; + for (i = 0; i < priv->num_rings; i++) { + char str[16]; + + priv->rings[i].priv = priv; + ret = xen_9pfs_front_alloc_dataring(dev, &priv->rings[i]); + if (ret < 0) + goto error_xenbus; + + sprintf(str, "ring-ref%u", i); + ret = xenbus_printf(xbt, dev->nodename, str, "%d", priv->rings[i].ref); + if (ret) + goto error_xenbus; + + sprintf(str, "event-channel-%u", i); + ret = xenbus_printf(xbt, dev->nodename, str, "%u", priv->rings[i].evtchn); + if (ret) + goto error_xenbus; + } + priv->tag = xenbus_read(xbt, dev->nodename, "tag", NULL); + if (ret) + goto error_xenbus; + ret = xenbus_transaction_end(xbt, 0); + if (ret) { + if (ret == -EAGAIN) + goto again; + xenbus_dev_fatal(dev, ret, "completing transaction"); + goto error; + } + + + list_add_tail(&priv->list, &xen_9pfs_devs); + dev_set_drvdata(&dev->dev, priv); + xenbus_switch_state(dev, XenbusStateInitialised); + return 0; + + error_xenbus: + xenbus_transaction_end(xbt, 1); + xenbus_dev_fatal(dev, ret, "writing xenstore"); + error: + dev_set_drvdata(&dev->dev, NULL); + xen_9pfs_front_free(priv); + return ret; } static int xen_9pfs_front_resume(struct xenbus_device *dev) { + dev_warn(&dev->dev, "suspsend/resume unsupported\n"); return 0; } static void xen_9pfs_front_changed(struct xenbus_device *dev, enum xenbus_state backend_state) { + switch (backend_state) { + case XenbusStateReconfiguring: + case XenbusStateReconfigured: + case XenbusStateInitialising: + case XenbusStateInitialised: + case XenbusStateUnknown: + break; + + case XenbusStateInitWait: + break; + + case XenbusStateConnected: + xenbus_switch_state(dev, XenbusStateConnected); + break; + + case XenbusStateClosed: + if (dev->state == XenbusStateClosed) + break; + /* Missed the backend's CLOSING state -- fallthrough */ + case XenbusStateClosing: + xenbus_frontend_closed(dev); + break; + } } static struct xenbus_driver xen_9pfs_front_driver = { -- 1.9.1
WARNING: multiple messages have this Message-ID (diff)
From: Stefano Stabellini <sstabellini@kernel.org> To: xen-devel@lists.xenproject.org Cc: jgross@suse.com, Latchesar Ionkov <lucho@ionkov.net>, sstabellini@kernel.org, Eric Van Hensbergen <ericvh@gmail.com>, linux-kernel@vger.kernel.org, Stefano Stabellini <stefano@aporeto.com>, v9fs-developer@lists.sourceforge.net, Ron Minnich <rminnich@sandia.gov>, boris.ostrovsky@oracle.com Subject: [PATCH 4/7] xen/9pfs: connect to the backend Date: Mon, 6 Mar 2017 12:01:25 -0800 [thread overview] Message-ID: <1488830488-18506-4-git-send-email-sstabellini@kernel.org> (raw) In-Reply-To: <1488830488-18506-1-git-send-email-sstabellini@kernel.org> Implement functions to handle the xenbus handshake. Upon connection, allocate the rings according to the protocol specification. Initialize a work_struct and a wait_queue. The work_struct will be used to schedule work upon receiving an event channel notification from the backend. The wait_queue will be used to wait when the ring is full and we need to send a new request. Signed-off-by: Stefano Stabellini <stefano@aporeto.com> CC: boris.ostrovsky@oracle.com CC: jgross@suse.com CC: Eric Van Hensbergen <ericvh@gmail.com> CC: Ron Minnich <rminnich@sandia.gov> CC: Latchesar Ionkov <lucho@ionkov.net> CC: v9fs-developer@lists.sourceforge.net --- net/9p/trans_xen.c | 227 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) diff --git a/net/9p/trans_xen.c b/net/9p/trans_xen.c index 877dfd0..9f6cf8d 100644 --- a/net/9p/trans_xen.c +++ b/net/9p/trans_xen.c @@ -17,6 +17,36 @@ #include <net/9p/client.h> #include <net/9p/transport.h> +#define XEN_9PFS_NUM_RINGS 2 + +/* One per ring, more than one per 9pfs share */ +struct xen_9pfs_dataring { + struct xen_9pfs_front_priv *priv; + + struct xen_9pfs_data_intf *intf; + grant_ref_t ref; + int evtchn; + int irq; + spinlock_t lock; + + void *bytes; + struct xen_9pfs_data ring; + wait_queue_head_t wq; + struct work_struct work; +}; + +/* One per 9pfs share */ +struct xen_9pfs_front_priv { + struct list_head list; + struct xenbus_device *dev; + char *tag; + struct p9_client *client; + + int num_rings; + struct xen_9pfs_dataring *rings; +}; +static LIST_HEAD(xen_9pfs_devs); + static int p9_xen_cancel(struct p9_client *client, struct p9_req_t *req) { return 0; @@ -36,6 +66,21 @@ static int p9_xen_request(struct p9_client *client, struct p9_req_t *p9_req) return 0; } +static void p9_xen_response(struct work_struct *work) +{ +} + +static irqreturn_t xen_9pfs_front_event_handler(int irq, void *r) +{ + struct xen_9pfs_dataring *ring = r; + BUG_ON(!ring || !ring->priv->client); + + wake_up_interruptible(&ring->wq); + schedule_work(&ring->work); + + return IRQ_HANDLED; +} + static struct p9_trans_module p9_xen_trans = { .name = "xen", .maxsize = (1 << (XEN_9PFS_RING_ORDER + XEN_PAGE_SHIFT)), @@ -52,25 +97,207 @@ static int p9_xen_request(struct p9_client *client, struct p9_req_t *p9_req) { "" } }; +static int xen_9pfs_front_free(struct xen_9pfs_front_priv *priv) +{ + int i, j; + + list_del(&priv->list); + + for (i = 0; i < priv->num_rings; i++) { + if (priv->rings[i].intf == NULL) + break; + if (priv->rings[i].irq > 0) + unbind_from_irqhandler(priv->rings[i].irq, priv->dev); + if (priv->rings[i].bytes != NULL) { + for (j = 0; j < (1 << XEN_9PFS_RING_ORDER); j++) + gnttab_end_foreign_access(priv->rings[i].intf->ref[j], 0, 0); + free_pages((unsigned long)priv->rings[i].bytes, XEN_9PFS_RING_ORDER); + } + gnttab_end_foreign_access(priv->rings[i].ref, 0, 0); + free_page((unsigned long)priv->rings[i].intf); + } + kfree(priv->rings); + kfree(priv); + + return 0; +} + static int xen_9pfs_front_remove(struct xenbus_device *dev) { + int ret; + struct xen_9pfs_front_priv *priv = dev_get_drvdata(&dev->dev); + + dev_set_drvdata(&dev->dev, NULL); + ret = xen_9pfs_front_free(priv); + return ret; +} + +static int xen_9pfs_front_alloc_dataring(struct xenbus_device *dev, + struct xen_9pfs_dataring *ring) +{ + int i; + int ret = -ENOMEM; + + init_waitqueue_head(&ring->wq); + spin_lock_init(&ring->lock); + INIT_WORK(&ring->work, p9_xen_response); + + ring->intf = (struct xen_9pfs_data_intf *) __get_free_page(GFP_KERNEL | __GFP_ZERO); + if (!ring->intf) + goto error; + memset(ring->intf, 0, XEN_PAGE_SIZE); + ring->bytes = (void*)__get_free_pages(GFP_KERNEL | __GFP_ZERO, XEN_9PFS_RING_ORDER); + if (ring->bytes == NULL) + goto error; + for (i = 0; i < (1 << XEN_9PFS_RING_ORDER); i++) + ring->intf->ref[i] = gnttab_grant_foreign_access(dev->otherend_id, pfn_to_gfn(virt_to_pfn((void*)ring->bytes) + i), 0); + ring->ref = gnttab_grant_foreign_access(dev->otherend_id, pfn_to_gfn(virt_to_pfn((void*)ring->intf)), 0); + ring->ring.in = ring->bytes; + ring->ring.out = ring->bytes + XEN_9PFS_RING_SIZE; + + ret = xenbus_alloc_evtchn(dev, &ring->evtchn); + if (ret) + goto error; + ring->irq = bind_evtchn_to_irqhandler(ring->evtchn, xen_9pfs_front_event_handler, + 0, "xen_9pfs-frontend", ring); + if (ring->irq < 0) { + xenbus_free_evtchn(dev, ring->evtchn); + ret = ring->irq; + goto error; + } return 0; + +error: + if (ring->intf != NULL) + kfree(ring->intf); + if (ring->bytes != NULL) + kfree(ring->bytes); + return ret; } static int xen_9pfs_front_probe(struct xenbus_device *dev, const struct xenbus_device_id *id) { + int ret = -EFAULT, i; + struct xenbus_transaction xbt; + struct xen_9pfs_front_priv *priv = NULL; + char *versions; + unsigned int max_rings, max_ring_order, len; + + versions = xenbus_read(XBT_NIL, dev->otherend, "versions", &len); + if (!len || strcmp(versions, "1")) + return -EINVAL; + kfree(versions); + ret = xenbus_scanf(XBT_NIL, dev->otherend, "max-rings", "%u", &max_rings); + if (ret < 0 || max_rings < XEN_9PFS_NUM_RINGS) + return -EINVAL; + ret = xenbus_scanf(XBT_NIL, dev->otherend, "max-ring-page-order", "%u", &max_ring_order); + if (ret < 0|| max_ring_order < XEN_9PFS_RING_ORDER) + return -EINVAL; + + + priv = kzalloc(sizeof(struct xen_9pfs_front_priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->dev = dev; + priv->num_rings = XEN_9PFS_NUM_RINGS; + priv->rings = kzalloc(sizeof(struct xen_9pfs_dataring) * priv->num_rings, + GFP_KERNEL); + if (!priv->rings) { + kfree(priv); + return -ENOMEM; + } + + again: + ret = xenbus_transaction_start(&xbt); + if (ret) { + xenbus_dev_fatal(dev, ret, "starting transaction"); + goto error; + } + ret = xenbus_printf(xbt, dev->nodename, "version", "%u", 1); + if (ret) + goto error_xenbus; + ret = xenbus_printf(xbt, dev->nodename, "num-rings", "%u", priv->num_rings); + if (ret) + goto error_xenbus; + for (i = 0; i < priv->num_rings; i++) { + char str[16]; + + priv->rings[i].priv = priv; + ret = xen_9pfs_front_alloc_dataring(dev, &priv->rings[i]); + if (ret < 0) + goto error_xenbus; + + sprintf(str, "ring-ref%u", i); + ret = xenbus_printf(xbt, dev->nodename, str, "%d", priv->rings[i].ref); + if (ret) + goto error_xenbus; + + sprintf(str, "event-channel-%u", i); + ret = xenbus_printf(xbt, dev->nodename, str, "%u", priv->rings[i].evtchn); + if (ret) + goto error_xenbus; + } + priv->tag = xenbus_read(xbt, dev->nodename, "tag", NULL); + if (ret) + goto error_xenbus; + ret = xenbus_transaction_end(xbt, 0); + if (ret) { + if (ret == -EAGAIN) + goto again; + xenbus_dev_fatal(dev, ret, "completing transaction"); + goto error; + } + + + list_add_tail(&priv->list, &xen_9pfs_devs); + dev_set_drvdata(&dev->dev, priv); + xenbus_switch_state(dev, XenbusStateInitialised); + return 0; + + error_xenbus: + xenbus_transaction_end(xbt, 1); + xenbus_dev_fatal(dev, ret, "writing xenstore"); + error: + dev_set_drvdata(&dev->dev, NULL); + xen_9pfs_front_free(priv); + return ret; } static int xen_9pfs_front_resume(struct xenbus_device *dev) { + dev_warn(&dev->dev, "suspsend/resume unsupported\n"); return 0; } static void xen_9pfs_front_changed(struct xenbus_device *dev, enum xenbus_state backend_state) { + switch (backend_state) { + case XenbusStateReconfiguring: + case XenbusStateReconfigured: + case XenbusStateInitialising: + case XenbusStateInitialised: + case XenbusStateUnknown: + break; + + case XenbusStateInitWait: + break; + + case XenbusStateConnected: + xenbus_switch_state(dev, XenbusStateConnected); + break; + + case XenbusStateClosed: + if (dev->state == XenbusStateClosed) + break; + /* Missed the backend's CLOSING state -- fallthrough */ + case XenbusStateClosing: + xenbus_frontend_closed(dev); + break; + } } static struct xenbus_driver xen_9pfs_front_driver = { -- 1.9.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org https://lists.xen.org/xen-devel
next prev parent reply other threads:[~2017-03-06 20:13 UTC|newest] Thread overview: 77+ messages / expand[flat|nested] mbox.gz Atom feed top 2017-03-06 20:00 [PATCH 0/7] Xen transport for 9pfs frontend driver Stefano Stabellini 2017-03-06 20:01 ` [PATCH 1/7] xen: import new ring macros in ring.h Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini 2017-03-06 20:01 ` [PATCH 2/7] xen: introduce the header file for the Xen 9pfs transport protocol Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini 2017-03-06 21:22 ` Boris Ostrovsky 2017-03-06 21:22 ` Boris Ostrovsky 2017-03-06 21:36 ` Stefano Stabellini 2017-03-06 21:36 ` Stefano Stabellini 2017-03-06 21:42 ` Boris Ostrovsky 2017-03-06 21:42 ` Boris Ostrovsky 2017-03-06 20:01 ` [PATCH 3/7] xen/9pfs: introduce Xen 9pfs transport driver Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini [this message] 2017-03-06 20:01 ` [PATCH 4/7] xen/9pfs: connect to the backend Stefano Stabellini 2017-03-07 15:03 ` Boris Ostrovsky 2017-03-07 15:03 ` Boris Ostrovsky 2017-03-08 0:11 ` Stefano Stabellini 2017-03-08 0:11 ` Stefano Stabellini 2017-03-08 13:47 ` Boris Ostrovsky 2017-03-08 13:47 ` Boris Ostrovsky 2017-03-08 19:22 ` Stefano Stabellini 2017-03-08 19:22 ` Stefano Stabellini 2017-03-07 17:37 ` [Xen-devel] " Julien Grall 2017-03-07 17:37 ` Julien Grall 2017-03-08 0:49 ` [Xen-devel] " Stefano Stabellini 2017-03-08 0:49 ` Stefano Stabellini 2017-03-08 12:25 ` [Xen-devel] " Julien Grall 2017-03-08 12:25 ` Julien Grall 2017-03-08 19:08 ` [Xen-devel] " Stefano Stabellini 2017-03-08 19:08 ` Stefano Stabellini 2017-03-06 20:01 ` [PATCH 5/7] xen/9pfs: send requests " Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini 2017-03-07 15:27 ` Boris Ostrovsky 2017-03-07 15:27 ` Boris Ostrovsky 2017-03-08 0:55 ` Stefano Stabellini 2017-03-08 0:55 ` Stefano Stabellini 2017-03-08 13:58 ` Boris Ostrovsky 2017-03-08 13:58 ` Boris Ostrovsky 2017-03-08 19:33 ` Stefano Stabellini 2017-03-08 19:33 ` Stefano Stabellini 2017-03-08 20:02 ` Boris Ostrovsky 2017-03-08 20:02 ` Boris Ostrovsky 2017-03-08 20:56 ` Stefano Stabellini 2017-03-08 20:56 ` Stefano Stabellini 2017-03-08 21:01 ` Boris Ostrovsky 2017-03-08 21:01 ` Boris Ostrovsky 2017-03-06 20:01 ` [PATCH 6/7] xen/9pfs: receive responses Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini 2017-03-07 15:49 ` Boris Ostrovsky 2017-03-07 15:49 ` Boris Ostrovsky 2017-03-08 1:06 ` Stefano Stabellini 2017-03-08 1:06 ` Stefano Stabellini 2017-03-08 1:13 ` Stefano Stabellini 2017-03-08 1:13 ` Stefano Stabellini 2017-03-08 20:11 ` Konrad Rzeszutek Wilk 2017-03-08 20:11 ` [Xen-devel] " Konrad Rzeszutek Wilk 2017-03-08 14:33 ` Boris Ostrovsky 2017-03-08 14:33 ` Boris Ostrovsky 2017-03-08 19:26 ` Stefano Stabellini 2017-03-08 19:26 ` Stefano Stabellini 2017-03-06 20:01 ` [PATCH 7/7] xen/9pfs: build 9pfs Xen transport driver Stefano Stabellini 2017-03-06 20:01 ` Stefano Stabellini 2017-03-07 17:15 ` [Xen-devel] [PATCH 1/7] xen: import new ring macros in ring.h Julien Grall 2017-03-07 17:15 ` Julien Grall 2017-03-08 0:12 ` [Xen-devel] " Stefano Stabellini 2017-03-08 0:12 ` Stefano Stabellini 2017-03-08 11:14 ` [Xen-devel] " Julien Grall 2017-03-08 11:14 ` Julien Grall 2017-03-07 16:38 ` [Xen-devel] [PATCH 0/7] Xen transport for 9pfs frontend driver Roger Pau Monné 2017-03-07 16:38 ` Roger Pau Monné 2017-03-07 18:27 ` [Xen-devel] " Stefano Stabellini 2017-03-07 18:27 ` Stefano Stabellini 2017-03-09 3:02 ` [Xen-devel] " Roger Pau Monné 2017-03-09 3:02 ` Roger Pau Monné 2017-03-13 22:36 ` Stefano Stabellini 2017-03-13 22:36 ` [Xen-devel] " Stefano Stabellini
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=1488830488-18506-4-git-send-email-sstabellini@kernel.org \ --to=sstabellini@kernel.org \ --cc=boris.ostrovsky@oracle.com \ --cc=ericvh@gmail.com \ --cc=jgross@suse.com \ --cc=linux-kernel@vger.kernel.org \ --cc=lucho@ionkov.net \ --cc=rminnich@sandia.gov \ --cc=stefano@aporeto.com \ --cc=v9fs-developer@lists.sourceforge.net \ --cc=xen-devel@lists.xenproject.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.