lkml.org 
[lkml]   [2017]   [Jul]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v2 10/13] xen/pvcalls: implement poll command
    Date
    For active sockets, check the indexes and use the inflight_conn_req
    waitqueue to wait.

    For passive sockets, send PVCALLS_POLL to the backend. Use the
    inflight_accept_req waitqueue if an accept is outstanding. Otherwise use
    the inflight_req waitqueue: inflight_req is awaken when a new response
    is received; on wakeup we check whether the POLL response is arrived by
    looking at the PVCALLS_FLAG_POLL_RET flag. We set the flag from
    pvcalls_front_event_handler, if the response was for a POLL command.

    In pvcalls_front_event_handler, get the struct socket pointer from the
    poll id (we previously converted struct socket* to uint64_t and used it
    as id).

    Signed-off-by: Stefano Stabellini <stefano@aporeto.com>
    CC: boris.ostrovsky@oracle.com
    CC: jgross@suse.com
    ---
    drivers/xen/pvcalls-front.c | 134 ++++++++++++++++++++++++++++++++++++++++----
    drivers/xen/pvcalls-front.h | 3 +
    2 files changed, 126 insertions(+), 11 deletions(-)

    diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c
    index b4ca569..833b717 100644
    --- a/drivers/xen/pvcalls-front.c
    +++ b/drivers/xen/pvcalls-front.c
    @@ -130,17 +130,35 @@ static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id)
    rsp = RING_GET_RESPONSE(&bedata->ring, bedata->ring.rsp_cons);

    req_id = rsp->req_id;
    - src = (uint8_t *)&bedata->rsp[req_id];
    - src += sizeof(rsp->req_id);
    - dst = (uint8_t *)rsp;
    - dst += sizeof(rsp->req_id);
    - memcpy(dst, src, sizeof(*rsp) - sizeof(rsp->req_id));
    - /*
    - * First copy the rest of the data, then req_id. It is
    - * paired with the barrier when accessing bedata->rsp.
    - */
    - smp_wmb();
    - WRITE_ONCE(bedata->rsp[req_id].req_id, rsp->req_id);
    + if (rsp->cmd == PVCALLS_POLL) {
    + struct socket *sock = (struct socket *) rsp->u.poll.id;
    + struct sock_mapping *map =
    + (struct sock_mapping *)
    + READ_ONCE(sock->sk->sk_send_head);
    +
    + set_bit(PVCALLS_FLAG_POLL_RET,
    + (void *)&map->passive.flags);
    + /*
    + * Set RET, then clear INFLIGHT. It pairs with
    + * the checks at the beginning of
    + * pvcalls_front_poll_passive.
    + */
    + smp_wmb();
    + clear_bit(PVCALLS_FLAG_POLL_INFLIGHT,
    + (void *)&map->passive.flags);
    + } else {
    + src = (uint8_t *)&bedata->rsp[req_id];
    + src += sizeof(rsp->req_id);
    + dst = (uint8_t *)rsp;
    + dst += sizeof(rsp->req_id);
    + memcpy(dst, src, sizeof(*rsp) - sizeof(rsp->req_id));
    + /*
    + * First copy the rest of the data, then req_id. It is
    + * paired with the barrier when accessing bedata->rsp.
    + */
    + smp_wmb();
    + WRITE_ONCE(bedata->rsp[req_id].req_id, rsp->req_id);
    + }

    done = 1;
    bedata->ring.rsp_cons++;
    @@ -707,6 +725,100 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, int flags)
    return ret;
    }

    +static unsigned int pvcalls_front_poll_passive(struct file *file,
    + struct pvcalls_bedata *bedata,
    + struct sock_mapping *map,
    + poll_table *wait)
    +{
    + int notify, req_id;
    + struct xen_pvcalls_request *req;
    +
    + if (test_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
    + (void *)&map->passive.flags)) {
    + poll_wait(file, &map->passive.inflight_accept_req, wait);
    + return 0;
    + }
    +
    + if (test_and_clear_bit(PVCALLS_FLAG_POLL_RET,
    + (void *)&map->passive.flags))
    + return POLLIN;
    +
    + /*
    + * First check RET, then INFLIGHT. No barriers necessary to
    + * ensure execution ordering because of the conditional
    + * instructions creating control dependencies.
    + */
    +
    + if (test_and_set_bit(PVCALLS_FLAG_POLL_INFLIGHT,
    + (void *)&map->passive.flags)) {
    + poll_wait(file, &bedata->inflight_req, wait);
    + return 0;
    + }
    +
    + spin_lock(&bedata->pvcallss_lock);
    + req_id = bedata->ring.req_prod_pvt & (RING_SIZE(&bedata->ring) - 1);
    + if (RING_FULL(&bedata->ring) ||
    + READ_ONCE(bedata->rsp[req_id].req_id) != PVCALLS_INVALID_ID) {
    + spin_unlock(&bedata->pvcallss_lock);
    + return -EAGAIN;
    + }
    + req = RING_GET_REQUEST(&bedata->ring, req_id);
    + req->req_id = req_id;
    + req->cmd = PVCALLS_POLL;
    + req->u.poll.id = (uint64_t) map->sock;
    +
    + 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);
    +
    + poll_wait(file, &bedata->inflight_req, wait);
    + return 0;
    +}
    +
    +static unsigned int pvcalls_front_poll_active(struct file *file,
    + struct pvcalls_bedata *bedata,
    + struct sock_mapping *map,
    + poll_table *wait)
    +{
    + unsigned int mask = 0;
    + int32_t in_error, out_error;
    + struct pvcalls_data_intf *intf = map->active.ring;
    +
    + out_error = intf->out_error;
    + in_error = intf->in_error;
    +
    + poll_wait(file, &map->active.inflight_conn_req, wait);
    + if (pvcalls_front_write_todo(map))
    + mask |= POLLOUT | POLLWRNORM;
    + if (pvcalls_front_read_todo(map))
    + mask |= POLLIN | POLLRDNORM;
    + if (in_error != 0 || out_error != 0)
    + mask |= POLLERR;
    +
    + return mask;
    +}
    +
    +unsigned int pvcalls_front_poll(struct file *file, struct socket *sock,
    + poll_table *wait)
    +{
    + struct pvcalls_bedata *bedata;
    + struct sock_mapping *map;
    +
    + if (!pvcalls_front_dev)
    + return POLLNVAL;
    + bedata = dev_get_drvdata(&pvcalls_front_dev->dev);
    +
    + map = (struct sock_mapping *) READ_ONCE(sock->sk->sk_send_head);
    + if (!map)
    + return POLLNVAL;
    + if (map->active_socket)
    + return pvcalls_front_poll_active(file, bedata, map, wait);
    + else
    + return pvcalls_front_poll_passive(file, bedata, map, wait);
    +}
    +
    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 de24041..25e05b8 100644
    --- a/drivers/xen/pvcalls-front.h
    +++ b/drivers/xen/pvcalls-front.h
    @@ -20,5 +20,8 @@ int pvcalls_front_recvmsg(struct socket *sock,
    struct msghdr *msg,
    size_t len,
    int flags);
    +unsigned int pvcalls_front_poll(struct file *file,
    + struct socket *sock,
    + poll_table *wait);

    #endif
    --
    1.9.1
    \
     
     \ /
      Last update: 2017-07-25 23:24    [W:4.039 / U:1.076 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site