Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ae0d0405 authored by Stefano Stabellini's avatar Stefano Stabellini Committed by Boris Ostrovsky
Browse files

xen/pvcalls: implement recvmsg 



Implement recvmsg by copying data from the "in" ring. If not enough data
is available and the recvmsg call is blocking, then wait on the
inflight_conn_req waitqueue. Take the active socket in_mutex so that
only one function can access the ring at any given time.

Signed-off-by: default avatarStefano Stabellini <stefano@aporeto.com>
Reviewed-by: default avatarBoris Ostrovsky <boris.ostrovsky@oracle.com>
CC: boris.ostrovsky@oracle.com
CC: jgross@suse.com
Signed-off-by: default avatarBoris Ostrovsky <boris.ostrovsky@oracle.com>
parent 45ddce21

drivers/xen/pvcalls-front.c

+111 −0
Original line number Original line Diff line number Diff line
@@ -117,6 +117,20 @@ static bool pvcalls_front_write_todo(struct sock_mapping *map) 
	return !!(size - pvcalls_queued(prod, cons, size));

	return !!(size - pvcalls_queued(prod, cons, size));

}

}





static bool pvcalls_front_read_todo(struct sock_mapping *map)

{

	struct pvcalls_data_intf *intf = map->active.ring;

	RING_IDX cons, prod;

	int32_t error;



	cons = intf->in_cons;

	prod = intf->in_prod;

	error = intf->in_error;

	return (error != 0 ||

		pvcalls_queued(prod, cons,

			       XEN_FLEX_RING_SIZE(PVCALLS_RING_ORDER)) != 0);

}



static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id)

static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id)

{

{

	struct xenbus_device *dev = dev_id;

	struct xenbus_device *dev = dev_id;
@@ -484,6 +498,103 @@ int pvcalls_front_sendmsg(struct socket *sock, struct msghdr *msg, 
	return tot_sent;

	return tot_sent;

}

}





static int __read_ring(struct pvcalls_data_intf *intf,

		       struct pvcalls_data *data,

		       struct iov_iter *msg_iter,

		       size_t len, int flags)

{

	RING_IDX cons, prod, size, masked_prod, masked_cons;

	RING_IDX array_size = XEN_FLEX_RING_SIZE(PVCALLS_RING_ORDER);

	int32_t error;



	cons = intf->in_cons;

	prod = intf->in_prod;

	error = intf->in_error;

	/* get pointers before reading from the ring */

	virt_rmb();

	if (error < 0)

		return error;



	size = pvcalls_queued(prod, cons, array_size);

	masked_prod = pvcalls_mask(prod, array_size);

	masked_cons = pvcalls_mask(cons, array_size);



	if (size == 0)

		return 0;



	if (len > size)

		len = size;



	if (masked_prod > masked_cons) {

		len = copy_to_iter(data->in + masked_cons, len, msg_iter);

	} else {

		if (len > (array_size - masked_cons)) {

			int ret = copy_to_iter(data->in + masked_cons,

				     array_size - masked_cons, msg_iter);

			if (ret != array_size - masked_cons) {

				len = ret;

				goto out;

			}

			len = ret + copy_to_iter(data->in, len - ret, msg_iter);

		} else {

			len = copy_to_iter(data->in + masked_cons, len, msg_iter);

		}

	}

out:

	/* read data from the ring before increasing the index */

	virt_mb();

	if (!(flags & MSG_PEEK))

		intf->in_cons += len;



	return len;

}



int pvcalls_front_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,

		     int flags)

{

	struct pvcalls_bedata *bedata;

	int ret;

	struct sock_mapping *map;



	if (flags & (MSG_CMSG_CLOEXEC|MSG_ERRQUEUE|MSG_OOB|MSG_TRUNC))

		return -EOPNOTSUPP;



	pvcalls_enter();

	if (!pvcalls_front_dev) {

		pvcalls_exit();

		return -ENOTCONN;

	}

	bedata = dev_get_drvdata(&pvcalls_front_dev->dev);



	map = (struct sock_mapping *) sock->sk->sk_send_head;

	if (!map) {

		pvcalls_exit();

		return -ENOTSOCK;

	}



	mutex_lock(&map->active.in_mutex);

	if (len > XEN_FLEX_RING_SIZE(PVCALLS_RING_ORDER))

		len = XEN_FLEX_RING_SIZE(PVCALLS_RING_ORDER);



	while (!(flags & MSG_DONTWAIT) && !pvcalls_front_read_todo(map)) {

		wait_event_interruptible(map->active.inflight_conn_req,

					 pvcalls_front_read_todo(map));

	}

	ret = __read_ring(map->active.ring, &map->active.data,

			  &msg->msg_iter, len, flags);



	if (ret > 0)

		notify_remote_via_irq(map->active.irq);

	if (ret == 0)

		ret = (flags & MSG_DONTWAIT) ? -EAGAIN : 0;

	if (ret == -ENOTCONN)

		ret = 0;



	mutex_unlock(&map->active.in_mutex);

	pvcalls_exit();

	return ret;

}



int pvcalls_front_bind(struct socket *sock, struct sockaddr *addr, int addr_len)

int pvcalls_front_bind(struct socket *sock, struct sockaddr *addr, int addr_len)

{

{

	struct pvcalls_bedata *bedata;

	struct pvcalls_bedata *bedata;

drivers/xen/pvcalls-front.h

+4 −0
Original line number Original line Diff line number Diff line
@@ -16,5 +16,9 @@ int pvcalls_front_accept(struct socket *sock, 
int pvcalls_front_sendmsg(struct socket *sock,

int pvcalls_front_sendmsg(struct socket *sock,

			  struct msghdr *msg,

			  struct msghdr *msg,

			  size_t len);

			  size_t len);

int pvcalls_front_recvmsg(struct socket *sock,

			  struct msghdr *msg,

			  size_t len,

			  int flags);





#endif
 
#endif