Commit b9f2b0ff authored by Stefano Garzarella's avatar Stefano Garzarella Committed by David S. Miller
Browse files

vsock: handle buffer_size sockopts in the core 



virtio_transport and vmci_transport handle the buffer_size
sockopts in a very similar way.

In order to support multiple transports, this patch moves this
handling in the core to allow the user to change the options
also if the socket is not yet assigned to any transport.

This patch also adds the '.notify_buffer_size' callback in the
'struct virtio_transport' in order to inform the transport,
when the buffer_size is changed by the user. It is also useful
to limit the 'buffer_size' requested (e.g. virtio transports).

Acked-by: default avatarDexuan Cui <decui@microsoft.com>
Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: default avatarJorgen Hansen <jhansen@vmware.com>
Signed-off-by: default avatarStefano Garzarella <sgarzare@redhat.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent daabfbca

drivers/vhost/vsock.c

+1 −6
Original line number Diff line number Diff line
@@ -418,13 +418,8 @@ static struct virtio_transport vhost_transport = { 
		.notify_send_pre_block    = virtio_transport_notify_send_pre_block,

		.notify_send_pre_enqueue  = virtio_transport_notify_send_pre_enqueue,

		.notify_send_post_enqueue = virtio_transport_notify_send_post_enqueue,

		.notify_buffer_size       = virtio_transport_notify_buffer_size,



		.set_buffer_size          = virtio_transport_set_buffer_size,

		.set_min_buffer_size      = virtio_transport_set_min_buffer_size,

		.set_max_buffer_size      = virtio_transport_set_max_buffer_size,

		.get_buffer_size          = virtio_transport_get_buffer_size,

		.get_min_buffer_size      = virtio_transport_get_min_buffer_size,

		.get_max_buffer_size      = virtio_transport_get_max_buffer_size,

	},



	.send_pkt = vhost_transport_send_pkt,

include/linux/virtio_vsock.h

+1 −14
Original line number Diff line number Diff line
@@ -7,9 +7,6 @@ 
#include <net/sock.h>

#include <net/af_vsock.h>



#define VIRTIO_VSOCK_DEFAULT_MIN_BUF_SIZE	128

#define VIRTIO_VSOCK_DEFAULT_BUF_SIZE		(1024 * 256)

#define VIRTIO_VSOCK_DEFAULT_MAX_BUF_SIZE	(1024 * 256)

#define VIRTIO_VSOCK_DEFAULT_RX_BUF_SIZE	(1024 * 4)

#define VIRTIO_VSOCK_MAX_BUF_SIZE		0xFFFFFFFFUL

#define VIRTIO_VSOCK_MAX_PKT_BUF_SIZE		(1024 * 64)
@@ -25,11 +22,6 @@ enum { 
struct virtio_vsock_sock {

	struct vsock_sock *vsk;



	/* Protected by lock_sock(sk_vsock(trans->vsk)) */

	u32 buf_size;

	u32 buf_size_min;

	u32 buf_size_max;



	spinlock_t tx_lock;

	spinlock_t rx_lock;
@@ -92,12 +84,6 @@ s64 virtio_transport_stream_has_space(struct vsock_sock *vsk); 


int virtio_transport_do_socket_init(struct vsock_sock *vsk,

				 struct vsock_sock *psk);

u64 virtio_transport_get_buffer_size(struct vsock_sock *vsk);

u64 virtio_transport_get_min_buffer_size(struct vsock_sock *vsk);

u64 virtio_transport_get_max_buffer_size(struct vsock_sock *vsk);

void virtio_transport_set_buffer_size(struct vsock_sock *vsk, u64 val);

void virtio_transport_set_min_buffer_size(struct vsock_sock *vsk, u64 val);

void virtio_transport_set_max_buffer_size(struct vsock_sock *vs, u64 val);

int

virtio_transport_notify_poll_in(struct vsock_sock *vsk,

				size_t target,
@@ -124,6 +110,7 @@ int virtio_transport_notify_send_pre_enqueue(struct vsock_sock *vsk, 
	struct vsock_transport_send_notify_data *data);

int virtio_transport_notify_send_post_enqueue(struct vsock_sock *vsk,

	ssize_t written, struct vsock_transport_send_notify_data *data);

void virtio_transport_notify_buffer_size(struct vsock_sock *vsk, u64 *val);



u64 virtio_transport_stream_rcvhiwat(struct vsock_sock *vsk);

bool virtio_transport_stream_is_active(struct vsock_sock *vsk);

include/net/af_vsock.h

+7 −8
Original line number Diff line number Diff line
@@ -65,6 +65,11 @@ struct vsock_sock { 
	bool sent_request;

	bool ignore_connecting_rst;



	/* Protected by lock_sock(sk) */

	u64 buffer_size;

	u64 buffer_min_size;

	u64 buffer_max_size;



	/* Private to transport. */

	void *trans;

};
@@ -140,18 +145,12 @@ struct vsock_transport { 
		struct vsock_transport_send_notify_data *);

	int (*notify_send_post_enqueue)(struct vsock_sock *, ssize_t,

		struct vsock_transport_send_notify_data *);

	/* sk_lock held by the caller */

	void (*notify_buffer_size)(struct vsock_sock *, u64 *);



	/* Shutdown. */

	int (*shutdown)(struct vsock_sock *, int);



	/* Buffer sizes. */

	void (*set_buffer_size)(struct vsock_sock *, u64);

	void (*set_min_buffer_size)(struct vsock_sock *, u64);

	void (*set_max_buffer_size)(struct vsock_sock *, u64);

	u64 (*get_buffer_size)(struct vsock_sock *);

	u64 (*get_min_buffer_size)(struct vsock_sock *);

	u64 (*get_max_buffer_size)(struct vsock_sock *);



	/* Addressing. */

	u32 (*get_local_cid)(void);

};

net/vmw_vsock/af_vsock.c

+35 −8
Original line number Diff line number Diff line
@@ -126,6 +126,10 @@ static struct proto vsock_proto = { 
 */

#define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)



#define VSOCK_DEFAULT_BUFFER_SIZE     (1024 * 256)

#define VSOCK_DEFAULT_BUFFER_MAX_SIZE (1024 * 256)

#define VSOCK_DEFAULT_BUFFER_MIN_SIZE 128



static const struct vsock_transport *transport_single;

static DEFINE_MUTEX(vsock_register_mutex);
@@ -613,10 +617,16 @@ struct sock *__vsock_create(struct net *net, 
		vsk->trusted = psk->trusted;

		vsk->owner = get_cred(psk->owner);

		vsk->connect_timeout = psk->connect_timeout;

		vsk->buffer_size = psk->buffer_size;

		vsk->buffer_min_size = psk->buffer_min_size;

		vsk->buffer_max_size = psk->buffer_max_size;

	} else {

		vsk->trusted = capable(CAP_NET_ADMIN);

		vsk->owner = get_current_cred();

		vsk->connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT;

		vsk->buffer_size = VSOCK_DEFAULT_BUFFER_SIZE;

		vsk->buffer_min_size = VSOCK_DEFAULT_BUFFER_MIN_SIZE;

		vsk->buffer_max_size = VSOCK_DEFAULT_BUFFER_MAX_SIZE;

	}



	if (vsk->transport->init(vsk, psk) < 0) {
@@ -1366,6 +1376,23 @@ out: 
	return err;

}



static void vsock_update_buffer_size(struct vsock_sock *vsk,

				     const struct vsock_transport *transport,

				     u64 val)

{

	if (val > vsk->buffer_max_size)

		val = vsk->buffer_max_size;



	if (val < vsk->buffer_min_size)

		val = vsk->buffer_min_size;



	if (val != vsk->buffer_size &&

	    transport && transport->notify_buffer_size)

		transport->notify_buffer_size(vsk, &val);



	vsk->buffer_size = val;

}



static int vsock_stream_setsockopt(struct socket *sock,

				   int level,

				   int optname,
@@ -1403,17 +1430,19 @@ static int vsock_stream_setsockopt(struct socket *sock, 
	switch (optname) {

	case SO_VM_SOCKETS_BUFFER_SIZE:

		COPY_IN(val);

		transport->set_buffer_size(vsk, val);

		vsock_update_buffer_size(vsk, transport, val);

		break;



	case SO_VM_SOCKETS_BUFFER_MAX_SIZE:

		COPY_IN(val);

		transport->set_max_buffer_size(vsk, val);

		vsk->buffer_max_size = val;

		vsock_update_buffer_size(vsk, transport, vsk->buffer_size);

		break;



	case SO_VM_SOCKETS_BUFFER_MIN_SIZE:

		COPY_IN(val);

		transport->set_min_buffer_size(vsk, val);

		vsk->buffer_min_size = val;

		vsock_update_buffer_size(vsk, transport, vsk->buffer_size);

		break;



	case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
@@ -1454,7 +1483,6 @@ static int vsock_stream_getsockopt(struct socket *sock, 
	int len;

	struct sock *sk;

	struct vsock_sock *vsk;

	const struct vsock_transport *transport;

	u64 val;



	if (level != AF_VSOCK)
@@ -1478,21 +1506,20 @@ static int vsock_stream_getsockopt(struct socket *sock, 
	err = 0;

	sk = sock->sk;

	vsk = vsock_sk(sk);

	transport = vsk->transport;



	switch (optname) {

	case SO_VM_SOCKETS_BUFFER_SIZE:

		val = transport->get_buffer_size(vsk);

		val = vsk->buffer_size;

		COPY_OUT(val);

		break;



	case SO_VM_SOCKETS_BUFFER_MAX_SIZE:

		val = transport->get_max_buffer_size(vsk);

		val = vsk->buffer_max_size;

		COPY_OUT(val);

		break;



	case SO_VM_SOCKETS_BUFFER_MIN_SIZE:

		val = transport->get_min_buffer_size(vsk);

		val = vsk->buffer_min_size;

		COPY_OUT(val);

		break;

net/vmw_vsock/hyperv_transport.c

+0 −36
Original line number Diff line number Diff line
@@ -845,36 +845,6 @@ int hvs_notify_send_post_enqueue(struct vsock_sock *vsk, ssize_t written, 
	return 0;

}



static void hvs_set_buffer_size(struct vsock_sock *vsk, u64 val)

{

	/* Ignored. */

}



static void hvs_set_min_buffer_size(struct vsock_sock *vsk, u64 val)

{

	/* Ignored. */

}



static void hvs_set_max_buffer_size(struct vsock_sock *vsk, u64 val)

{

	/* Ignored. */

}



static u64 hvs_get_buffer_size(struct vsock_sock *vsk)

{

	return -ENOPROTOOPT;

}



static u64 hvs_get_min_buffer_size(struct vsock_sock *vsk)

{

	return -ENOPROTOOPT;

}



static u64 hvs_get_max_buffer_size(struct vsock_sock *vsk)

{

	return -ENOPROTOOPT;

}



static struct vsock_transport hvs_transport = {

	.get_local_cid            = hvs_get_local_cid,
@@ -908,12 +878,6 @@ static struct vsock_transport hvs_transport = { 
	.notify_send_pre_enqueue  = hvs_notify_send_pre_enqueue,

	.notify_send_post_enqueue = hvs_notify_send_post_enqueue,



	.set_buffer_size          = hvs_set_buffer_size,

	.set_min_buffer_size      = hvs_set_min_buffer_size,

	.set_max_buffer_size      = hvs_set_max_buffer_size,

	.get_buffer_size          = hvs_get_buffer_size,

	.get_min_buffer_size      = hvs_get_min_buffer_size,

	.get_max_buffer_size      = hvs_get_max_buffer_size,

};



static int hvs_probe(struct hv_device *hdev,

CRA Git | Maintained and supported by SUSTech CRA and CCSE