From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751749AbdGXTki (ORCPT ); Mon, 24 Jul 2017 15:40:38 -0400 Received: from mx2.suse.de ([195.135.220.15]:44799 "EHLO mx1.suse.de" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1750970AbdGXTkb (ORCPT ); Mon, 24 Jul 2017 15:40:31 -0400 Subject: Re: [PATCH v1 04/13] xen/pvcalls: implement connect command To: Stefano Stabellini , xen-devel@lists.xen.org Cc: linux-kernel@vger.kernel.org, boris.ostrovsky@oracle.com, Stefano Stabellini References: <1500682323-25940-1-git-send-email-sstabellini@kernel.org> <1500682323-25940-4-git-send-email-sstabellini@kernel.org> From: Juergen Gross Message-ID: <7da9743d-61fd-9f1d-a8c4-ea65b953f878@suse.com> Date: Mon, 24 Jul 2017 21:40:19 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.2.1 MIME-Version: 1.0 In-Reply-To: <1500682323-25940-4-git-send-email-sstabellini@kernel.org> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 22/07/17 02:11, Stefano Stabellini wrote: > Send PVCALLS_CONNECT to the backend. Allocate a new ring and evtchn for > the active socket. > > Introduce a data structure to keep track of sockets. Introduce a > waitqueue to allow the frontend to wait on data coming from the backend > on the active socket (recvmsg command). > > Two mutexes (one of reads and one for writes) will be used to protect > the active socket in and out rings from concurrent accesses. > > sock->sk->sk_send_head is not used for ip sockets: reuse the field to > store a pointer to the struct sock_mapping corresponding to the socket. > This way, we can easily get the struct sock_mapping from the struct > socket. > > Convert the struct socket pointer into an uint64_t and use it as id for > the new socket to pass to the backend. > > Signed-off-by: Stefano Stabellini > CC: boris.ostrovsky@oracle.com > CC: jgross@suse.com > --- > drivers/xen/pvcalls-front.c | 153 ++++++++++++++++++++++++++++++++++++++++++++ > drivers/xen/pvcalls-front.h | 2 + > 2 files changed, 155 insertions(+) > > diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c > index 7933c73..0d305e0 100644 > --- a/drivers/xen/pvcalls-front.c > +++ b/drivers/xen/pvcalls-front.c > @@ -13,6 +13,8 @@ > */ > > #include > +#include > +#include > > #include > #include > @@ -20,6 +22,8 @@ > #include > #include > > +#include > + > #define PVCALLS_INVALID_ID (UINT_MAX) > #define RING_ORDER XENBUS_MAX_RING_GRANT_ORDER > #define PVCALLS_NR_REQ_PER_RING __CONST_RING_SIZE(xen_pvcalls, XEN_PAGE_SIZE) > @@ -38,6 +42,24 @@ struct pvcalls_bedata { > }; > struct xenbus_device *pvcalls_front_dev; > > +struct sock_mapping { > + bool active_socket; > + struct list_head list; > + struct socket *sock; > + union { > + struct { > + int irq; > + grant_ref_t ref; > + struct pvcalls_data_intf *ring; > + struct pvcalls_data data; > + struct mutex in_mutex; > + struct mutex out_mutex; > + > + wait_queue_head_t inflight_conn_req; > + } active; > + }; > +}; > + > static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id) > { > struct xenbus_device *dev = dev_id; > @@ -80,6 +102,18 @@ static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id) > return IRQ_HANDLED; > } > > +static irqreturn_t pvcalls_front_conn_handler(int irq, void *sock_map) > +{ > + struct sock_mapping *map = sock_map; > + > + if (map == NULL) > + return IRQ_HANDLED; > + > + wake_up_interruptible(&map->active.inflight_conn_req); > + > + return IRQ_HANDLED; > +} > + > int pvcalls_front_socket(struct socket *sock) > { > struct pvcalls_bedata *bedata; > @@ -134,6 +168,125 @@ int pvcalls_front_socket(struct socket *sock) > return ret; > } > > +static struct sock_mapping *create_active(int *evtchn) > +{ > + struct sock_mapping *map = NULL; > + void *bytes; > + int ret, irq = -1, i; > + > + map = kzalloc(sizeof(*map), GFP_KERNEL); > + if (map == NULL) > + return NULL; > + > + init_waitqueue_head(&map->active.inflight_conn_req); > + > + map->active.ring = (struct pvcalls_data_intf *) > + __get_free_page(GFP_KERNEL | __GFP_ZERO); > + if (map->active.ring == NULL) > + goto out_error; > + memset(map->active.ring, 0, XEN_PAGE_SIZE); > + map->active.ring->ring_order = RING_ORDER; > + bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, > + map->active.ring->ring_order); > + if (bytes == NULL) > + goto out_error; > + for (i = 0; i < (1 << map->active.ring->ring_order); i++) > + map->active.ring->ref[i] = gnttab_grant_foreign_access( > + pvcalls_front_dev->otherend_id, > + pfn_to_gfn(virt_to_pfn(bytes) + i), 0); > + > + map->active.ref = gnttab_grant_foreign_access( > + pvcalls_front_dev->otherend_id, > + pfn_to_gfn(virt_to_pfn((void *)map->active.ring)), 0); > + > + ret = xenbus_alloc_evtchn(pvcalls_front_dev, evtchn); > + if (ret) > + goto out_error; You are leaking bytes here in case of error. > + map->active.data.in = bytes; > + map->active.data.out = bytes + > + XEN_FLEX_RING_SIZE(map->active.ring->ring_order); > + irq = bind_evtchn_to_irqhandler(*evtchn, pvcalls_front_conn_handler, > + 0, "pvcalls-frontend", map); > + if (irq < 0) > + goto out_error; > + > + map->active.irq = irq; > + map->active_socket = true; > + mutex_init(&map->active.in_mutex); > + mutex_init(&map->active.out_mutex); > + > + return map; > + > +out_error: > + if (irq >= 0) > + unbind_from_irqhandler(irq, map); > + else if (*evtchn >= 0) > + xenbus_free_evtchn(pvcalls_front_dev, *evtchn); > + kfree(map->active.data.in); > + kfree(map->active.ring); > + kfree(map); > + return NULL; > +} > + > +int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr, > + int addr_len, int flags) > +{ > + struct pvcalls_bedata *bedata; > + struct sock_mapping *map = NULL; > + struct xen_pvcalls_request *req; > + int notify, req_id, ret, evtchn; > + > + if (!pvcalls_front_dev) > + return -ENETUNREACH; > + if (addr->sa_family != AF_INET || sock->type != SOCK_STREAM) > + return -ENOTSUPP; > + > + bedata = dev_get_drvdata(&pvcalls_front_dev->dev); > + > + spin_lock(&bedata->pvcallss_lock); > + req_id = bedata->ring.req_prod_pvt & (RING_SIZE(&bedata->ring) - 1); > + BUG_ON(req_id >= PVCALLS_NR_REQ_PER_RING); > + if (RING_FULL(&bedata->ring) || > + READ_ONCE(bedata->rsp[req_id].req_id) != PVCALLS_INVALID_ID) { > + spin_unlock(&bedata->pvcallss_lock); > + return -EAGAIN; > + } > + > + map = create_active(&evtchn); > + if (!map) > + return -ENOMEM; spin_unlock()? Juergen > + > + req = RING_GET_REQUEST(&bedata->ring, req_id); > + req->req_id = req_id; > + req->cmd = PVCALLS_CONNECT; > + req->u.connect.id = (uint64_t)sock; > + memcpy(req->u.connect.addr, addr, sizeof(*addr)); > + req->u.connect.len = addr_len; > + req->u.connect.flags = flags; > + req->u.connect.ref = map->active.ref; > + req->u.connect.evtchn = evtchn; > + > + list_add_tail(&map->list, &bedata->socket_mappings); > + map->sock = sock; > + WRITE_ONCE(sock->sk->sk_send_head, (void *)map); > + > + bedata->ring.req_prod_pvt++; > + RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&bedata->ring, notify); > + spin_unlock(&bedata->pvcallss_lock); > + > + if (notify) > + notify_remote_via_irq(bedata->irq); > + > + wait_event(bedata->inflight_req, > + READ_ONCE(bedata->rsp[req_id].req_id) == req_id); > + > + ret = bedata->rsp[req_id].ret; > + /* read ret, then set this rsp slot to be reused */ > + smp_mb(); > + WRITE_ONCE(bedata->rsp[req_id].req_id, PVCALLS_INVALID_ID); > + return ret; > +} > + > static const struct xenbus_device_id pvcalls_front_ids[] = { > { "pvcalls" }, > { "" } > diff --git a/drivers/xen/pvcalls-front.h b/drivers/xen/pvcalls-front.h > index b7dabed..63b0417 100644 > --- a/drivers/xen/pvcalls-front.h > +++ b/drivers/xen/pvcalls-front.h > @@ -4,5 +4,7 @@ > #include > > int pvcalls_front_socket(struct socket *sock); > +int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr, > + int addr_len, int flags); > > #endif >