[thirdparty/linux.git] / net / vmw_vsock / vmci_transport_notify_qstate.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * VMware vSockets Driver
 *
 * Copyright (C) 2009-2013 VMware, Inc. All rights reserved.
 */

#include <linux/types.h>
#include <linux/socket.h>
#include <linux/stddef.h>
#include <net/sock.h>

#include "vmci_transport_notify.h"

#define PKT_FIELD(vsk, field_name) \
	(vmci_trans(vsk)->notify.pkt_q_state.field_name)

static bool vmci_transport_notify_waiting_write(struct vsock_sock *vsk)
{
	bool retval;
	u64 notify_limit;

	if (!PKT_FIELD(vsk, peer_waiting_write))
		return false;

	/* When the sender blocks, we take that as a sign that the sender is
	 * faster than the receiver. To reduce the transmit rate of the sender,
	 * we delay the sending of the read notification by decreasing the
	 * write_notify_window. The notification is delayed until the number of
	 * bytes used in the queue drops below the write_notify_window.
	 */

	if (!PKT_FIELD(vsk, peer_waiting_write_detected)) {
		PKT_FIELD(vsk, peer_waiting_write_detected) = true;
		if (PKT_FIELD(vsk, write_notify_window) < PAGE_SIZE) {
			PKT_FIELD(vsk, write_notify_window) =
			    PKT_FIELD(vsk, write_notify_min_window);
		} else {
			PKT_FIELD(vsk, write_notify_window) -= PAGE_SIZE;
			if (PKT_FIELD(vsk, write_notify_window) <
			    PKT_FIELD(vsk, write_notify_min_window))
				PKT_FIELD(vsk, write_notify_window) =
				    PKT_FIELD(vsk, write_notify_min_window);

		}
	}
	notify_limit = vmci_trans(vsk)->consume_size -
		PKT_FIELD(vsk, write_notify_window);

	/* The notify_limit is used to delay notifications in the case where
	 * flow control is enabled. Below the test is expressed in terms of
	 * free space in the queue: if free_space > ConsumeSize -
	 * write_notify_window then notify An alternate way of expressing this
	 * is to rewrite the expression to use the data ready in the receive
	 * queue: if write_notify_window > bufferReady then notify as
	 * free_space == ConsumeSize - bufferReady.
	 */

	retval = vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair) >
		notify_limit;

	if (retval) {
		/* Once we notify the peer, we reset the detected flag so the
		 * next wait will again cause a decrease in the window size.
		 */

		PKT_FIELD(vsk, peer_waiting_write_detected) = false;
	}
	return retval;
}

static void
vmci_transport_handle_read(struct sock *sk,
			   struct vmci_transport_packet *pkt,
			   bool bottom_half,
			   struct sockaddr_vm *dst, struct sockaddr_vm *src)
{
	sk->sk_write_space(sk);
}

static void
vmci_transport_handle_wrote(struct sock *sk,
			    struct vmci_transport_packet *pkt,
			    bool bottom_half,
			    struct sockaddr_vm *dst, struct sockaddr_vm *src)
{
	sk->sk_data_ready(sk);
}

static void vsock_block_update_write_window(struct sock *sk)
{
	struct vsock_sock *vsk = vsock_sk(sk);

	if (PKT_FIELD(vsk, write_notify_window) < vmci_trans(vsk)->consume_size)
		PKT_FIELD(vsk, write_notify_window) =
		    min(PKT_FIELD(vsk, write_notify_window) + PAGE_SIZE,
			vmci_trans(vsk)->consume_size);
}

static int vmci_transport_send_read_notification(struct sock *sk)
{
	struct vsock_sock *vsk;
	bool sent_read;
	unsigned int retries;
	int err;

	vsk = vsock_sk(sk);
	sent_read = false;
	retries = 0;
	err = 0;

	if (vmci_transport_notify_waiting_write(vsk)) {
		/* Notify the peer that we have read, retrying the send on
		 * failure up to our maximum value.  XXX For now we just log
		 * the failure, but later we should schedule a work item to
		 * handle the resend until it succeeds.  That would require
		 * keeping track of work items in the vsk and cleaning them up
		 * upon socket close.
		 */
		while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
		       !sent_read &&
		       retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
			err = vmci_transport_send_read(sk);
			if (err >= 0)
				sent_read = true;

			retries++;
		}

		if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS && !sent_read)
			pr_err("%p unable to send read notification to peer\n",
			       sk);
		else
			PKT_FIELD(vsk, peer_waiting_write) = false;

	}
	return err;
}

static void vmci_transport_notify_pkt_socket_init(struct sock *sk)
{
	struct vsock_sock *vsk = vsock_sk(sk);

	PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
	PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
	PKT_FIELD(vsk, peer_waiting_write) = false;
	PKT_FIELD(vsk, peer_waiting_write_detected) = false;
}

static void vmci_transport_notify_pkt_socket_destruct(struct vsock_sock *vsk)
{
	PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
	PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
	PKT_FIELD(vsk, peer_waiting_write) = false;
	PKT_FIELD(vsk, peer_waiting_write_detected) = false;
}

static int
vmci_transport_notify_pkt_poll_in(struct sock *sk,
				  size_t target, bool *data_ready_now)
{
	struct vsock_sock *vsk = vsock_sk(sk);

	if (vsock_stream_has_data(vsk)) {
		*data_ready_now = true;
	} else {
		/* We can't read right now because there is nothing in the
		 * queue. Ask for notifications when there is something to
		 * read.
		 */
		if (sk->sk_state == TCP_ESTABLISHED)
			vsock_block_update_write_window(sk);
		*data_ready_now = false;
	}

	return 0;
}

static int
vmci_transport_notify_pkt_poll_out(struct sock *sk,
				   size_t target, bool *space_avail_now)
{
	s64 produce_q_free_space;
	struct vsock_sock *vsk = vsock_sk(sk);

	produce_q_free_space = vsock_stream_has_space(vsk);
	if (produce_q_free_space > 0) {
		*space_avail_now = true;
		return 0;
	} else if (produce_q_free_space == 0) {
		/* This is a connected socket but we can't currently send data.
		 * Nothing else to do.
		 */
		*space_avail_now = false;
	}

	return 0;
}

static int
vmci_transport_notify_pkt_recv_init(
				struct sock *sk,
				size_t target,
				struct vmci_transport_recv_notify_data *data)
{
	struct vsock_sock *vsk = vsock_sk(sk);

	data->consume_head = 0;
	data->produce_tail = 0;
	data->notify_on_block = false;

	if (PKT_FIELD(vsk, write_notify_min_window) < target + 1) {
		PKT_FIELD(vsk, write_notify_min_window) = target + 1;
		if (PKT_FIELD(vsk, write_notify_window) <
		    PKT_FIELD(vsk, write_notify_min_window)) {
			/* If the current window is smaller than the new
			 * minimal window size, we need to reevaluate whether
			 * we need to notify the sender. If the number of ready
			 * bytes are smaller than the new window, we need to
			 * send a notification to the sender before we block.
			 */

			PKT_FIELD(vsk, write_notify_window) =
			    PKT_FIELD(vsk, write_notify_min_window);
			data->notify_on_block = true;
		}
	}

	return 0;
}

static int
vmci_transport_notify_pkt_recv_pre_block(
				struct sock *sk,
				size_t target,
				struct vmci_transport_recv_notify_data *data)
{
	int err = 0;

	vsock_block_update_write_window(sk);

	if (data->notify_on_block) {
		err = vmci_transport_send_read_notification(sk);
		if (err < 0)
			return err;
		data->notify_on_block = false;
	}

	return err;
}

static int
vmci_transport_notify_pkt_recv_post_dequeue(
				struct sock *sk,
				size_t target,
				ssize_t copied,
				bool data_read,
				struct vmci_transport_recv_notify_data *data)
{
	struct vsock_sock *vsk;
	int err;
	bool was_full = false;
	u64 free_space;

	vsk = vsock_sk(sk);
	err = 0;

	if (data_read) {
		smp_mb();

		free_space =
			vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair);
		was_full = free_space == copied;

		if (was_full)
			PKT_FIELD(vsk, peer_waiting_write) = true;

		err = vmci_transport_send_read_notification(sk);
		if (err < 0)
			return err;

		/* See the comment in
		 * vmci_transport_notify_pkt_send_post_enqueue().
		 */
		sk->sk_data_ready(sk);
	}

	return err;
}

static int
vmci_transport_notify_pkt_send_init(
				struct sock *sk,
				struct vmci_transport_send_notify_data *data)
{
	data->consume_head = 0;
	data->produce_tail = 0;

	return 0;
}

static int
vmci_transport_notify_pkt_send_post_enqueue(
				struct sock *sk,
				ssize_t written,
				struct vmci_transport_send_notify_data *data)
{
	int err = 0;
	struct vsock_sock *vsk;
	bool sent_wrote = false;
	bool was_empty;
	int retries = 0;

	vsk = vsock_sk(sk);

	smp_mb();

	was_empty =
		vmci_qpair_produce_buf_ready(vmci_trans(vsk)->qpair) == written;
	if (was_empty) {
		while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
		       !sent_wrote &&
		       retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
			err = vmci_transport_send_wrote(sk);
			if (err >= 0)
				sent_wrote = true;

			retries++;
		}
	}

	if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS && !sent_wrote) {
		pr_err("%p unable to send wrote notification to peer\n",
		       sk);
		return err;
	}

	return err;
}

static void
vmci_transport_notify_pkt_handle_pkt(
				struct sock *sk,
				struct vmci_transport_packet *pkt,
				bool bottom_half,
				struct sockaddr_vm *dst,
				struct sockaddr_vm *src, bool *pkt_processed)
{
	bool processed = false;

	switch (pkt->type) {
	case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
		vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);
		processed = true;
		break;
	case VMCI_TRANSPORT_PACKET_TYPE_READ:
		vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);
		processed = true;
		break;
	}

	if (pkt_processed)
		*pkt_processed = processed;
}

static void vmci_transport_notify_pkt_process_request(struct sock *sk)
{
	struct vsock_sock *vsk = vsock_sk(sk);

	PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
	if (vmci_trans(vsk)->consume_size <
		PKT_FIELD(vsk, write_notify_min_window))
		PKT_FIELD(vsk, write_notify_min_window) =
			vmci_trans(vsk)->consume_size;
}

static void vmci_transport_notify_pkt_process_negotiate(struct sock *sk)
{
	struct vsock_sock *vsk = vsock_sk(sk);

	PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
	if (vmci_trans(vsk)->consume_size <
		PKT_FIELD(vsk, write_notify_min_window))
		PKT_FIELD(vsk, write_notify_min_window) =
			vmci_trans(vsk)->consume_size;
}

static int
vmci_transport_notify_pkt_recv_pre_dequeue(
				struct sock *sk,
				size_t target,
				struct vmci_transport_recv_notify_data *data)
{
	return 0; /* NOP for QState. */
}

static int
vmci_transport_notify_pkt_send_pre_block(
				struct sock *sk,
				struct vmci_transport_send_notify_data *data)
{
	return 0; /* NOP for QState. */
}

static int
vmci_transport_notify_pkt_send_pre_enqueue(
				struct sock *sk,
				struct vmci_transport_send_notify_data *data)
{
	return 0; /* NOP for QState. */
}

/* Socket always on control packet based operations. */
const struct vmci_transport_notify_ops vmci_transport_notify_pkt_q_state_ops = {
	.socket_init = vmci_transport_notify_pkt_socket_init,
	.socket_destruct = vmci_transport_notify_pkt_socket_destruct,
	.poll_in = vmci_transport_notify_pkt_poll_in,
	.poll_out = vmci_transport_notify_pkt_poll_out,
	.handle_notify_pkt = vmci_transport_notify_pkt_handle_pkt,
	.recv_init = vmci_transport_notify_pkt_recv_init,
	.recv_pre_block = vmci_transport_notify_pkt_recv_pre_block,
	.recv_pre_dequeue = vmci_transport_notify_pkt_recv_pre_dequeue,
	.recv_post_dequeue = vmci_transport_notify_pkt_recv_post_dequeue,
	.send_init = vmci_transport_notify_pkt_send_init,
	.send_pre_block = vmci_transport_notify_pkt_send_pre_block,
	.send_pre_enqueue = vmci_transport_notify_pkt_send_pre_enqueue,
	.send_post_enqueue = vmci_transport_notify_pkt_send_post_enqueue,
	.process_request = vmci_transport_notify_pkt_process_request,
	.process_negotiate = vmci_transport_notify_pkt_process_negotiate,
};
Commit	Line	Data
685a6bf8	1	// SPDX-License-Identifier: GPL-2.0-only
d021c344 AK	2	/*
	3	* VMware vSockets Driver
	4	*
	5	* Copyright (C) 2009-2013 VMware, Inc. All rights reserved.
d021c344 AK	6	*/
	7
	8	#include <linux/types.h>
	9	#include <linux/socket.h>
	10	#include <linux/stddef.h>
	11	#include <net/sock.h>
	12
	13	#include "vmci_transport_notify.h"
	14
	15	#define PKT_FIELD(vsk, field_name) \
	16	(vmci_trans(vsk)->notify.pkt_q_state.field_name)
	17
	18	static bool vmci_transport_notify_waiting_write(struct vsock_sock *vsk)
	19	{
	20	bool retval;
	21	u64 notify_limit;
	22
	23	if (!PKT_FIELD(vsk, peer_waiting_write))
	24	return false;
	25
	26	/* When the sender blocks, we take that as a sign that the sender is
	27	* faster than the receiver. To reduce the transmit rate of the sender,
	28	* we delay the sending of the read notification by decreasing the
	29	* write_notify_window. The notification is delayed until the number of
	30	* bytes used in the queue drops below the write_notify_window.
	31	*/
	32
	33	if (!PKT_FIELD(vsk, peer_waiting_write_detected)) {
	34	PKT_FIELD(vsk, peer_waiting_write_detected) = true;
	35	if (PKT_FIELD(vsk, write_notify_window) < PAGE_SIZE) {
	36	PKT_FIELD(vsk, write_notify_window) =
	37	PKT_FIELD(vsk, write_notify_min_window);
	38	} else {
	39	PKT_FIELD(vsk, write_notify_window) -= PAGE_SIZE;
	40	if (PKT_FIELD(vsk, write_notify_window) <
	41	PKT_FIELD(vsk, write_notify_min_window))
	42	PKT_FIELD(vsk, write_notify_window) =
	43	PKT_FIELD(vsk, write_notify_min_window);
	44
	45	}
	46	}
	47	notify_limit = vmci_trans(vsk)->consume_size -
	48	PKT_FIELD(vsk, write_notify_window);
	49
	50	/* The notify_limit is used to delay notifications in the case where
	51	* flow control is enabled. Below the test is expressed in terms of
	52	* free space in the queue: if free_space > ConsumeSize -
	53	* write_notify_window then notify An alternate way of expressing this
	54	* is to rewrite the expression to use the data ready in the receive
	55	* queue: if write_notify_window > bufferReady then notify as
	56	* free_space == ConsumeSize - bufferReady.
	57	*/
	58
	59	retval = vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair) >
	60	notify_limit;
	61
	62	if (retval) {
	63	/* Once we notify the peer, we reset the detected flag so the
	64	* next wait will again cause a decrease in the window size.
	65	*/
	66
	67	PKT_FIELD(vsk, peer_waiting_write_detected) = false;
	68	}
	69	return retval;
70	}
71
72	static void
73	vmci_transport_handle_read(struct sock *sk,
74	struct vmci_transport_packet *pkt,
75	bool bottom_half,
76	struct sockaddr_vm dst, struct sockaddr_vm src)
77	{
78	sk->sk_write_space(sk);
79	}
80
81	static void
82	vmci_transport_handle_wrote(struct sock *sk,
83	struct vmci_transport_packet *pkt,
84	bool bottom_half,
85	struct sockaddr_vm dst, struct sockaddr_vm src)
86	{
676d2369	87	sk->sk_data_ready(sk);
d021c344 AK	88	}
	89
	90	static void vsock_block_update_write_window(struct sock *sk)
	91	{
	92	struct vsock_sock *vsk = vsock_sk(sk);
	93
	94	if (PKT_FIELD(vsk, write_notify_window) < vmci_trans(vsk)->consume_size)
	95	PKT_FIELD(vsk, write_notify_window) =
	96	min(PKT_FIELD(vsk, write_notify_window) + PAGE_SIZE,
	97	vmci_trans(vsk)->consume_size);
	98	}
	99
	100	static int vmci_transport_send_read_notification(struct sock *sk)
	101	{
	102	struct vsock_sock *vsk;
	103	bool sent_read;
	104	unsigned int retries;
	105	int err;
	106
	107	vsk = vsock_sk(sk);
	108	sent_read = false;
	109	retries = 0;
	110	err = 0;
	111
	112	if (vmci_transport_notify_waiting_write(vsk)) {
	113	/* Notify the peer that we have read, retrying the send on
	114	* failure up to our maximum value. XXX For now we just log
	115	* the failure, but later we should schedule a work item to
	116	* handle the resend until it succeeds. That would require
	117	* keeping track of work items in the vsk and cleaning them up
	118	* upon socket close.
	119	*/
	120	while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
	121	!sent_read &&
	122	retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
	123	err = vmci_transport_send_read(sk);
	124	if (err >= 0)
	125	sent_read = true;
	126
	127	retries++;
	128	}
	129
	130	if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS && !sent_read)
	131	pr_err("%p unable to send read notification to peer\n",
	132	sk);
	133	else
	134	PKT_FIELD(vsk, peer_waiting_write) = false;
	135
	136	}
	137	return err;
	138	}
	139
	140	static void vmci_transport_notify_pkt_socket_init(struct sock *sk)
	141	{
	142	struct vsock_sock *vsk = vsock_sk(sk);
	143
	144	PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
	145	PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
	146	PKT_FIELD(vsk, peer_waiting_write) = false;
	147	PKT_FIELD(vsk, peer_waiting_write_detected) = false;
	148	}
	149
	150	static void vmci_transport_notify_pkt_socket_destruct(struct vsock_sock *vsk)
	151	{
152	PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
153	PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
154	PKT_FIELD(vsk, peer_waiting_write) = false;
155	PKT_FIELD(vsk, peer_waiting_write_detected) = false;
156	}
157
158	static int
159	vmci_transport_notify_pkt_poll_in(struct sock *sk,
160	size_t target, bool *data_ready_now)
161	{
162	struct vsock_sock *vsk = vsock_sk(sk);
163
164	if (vsock_stream_has_data(vsk)) {
165	*data_ready_now = true;
166	} else {
167	/* We can't read right now because there is nothing in the
168	* queue. Ask for notifications when there is something to
169	* read.
170	*/
3b4477d2	171	if (sk->sk_state == TCP_ESTABLISHED)
d021c344 AK	172	vsock_block_update_write_window(sk);
	173	*data_ready_now = false;
	174	}
	175
	176	return 0;
	177	}
	178
	179	static int
	180	vmci_transport_notify_pkt_poll_out(struct sock *sk,
	181	size_t target, bool *space_avail_now)
	182	{
	183	s64 produce_q_free_space;
	184	struct vsock_sock *vsk = vsock_sk(sk);
	185
	186	produce_q_free_space = vsock_stream_has_space(vsk);
	187	if (produce_q_free_space > 0) {
	188	*space_avail_now = true;
	189	return 0;
	190	} else if (produce_q_free_space == 0) {
	191	/* This is a connected socket but we can't currently send data.
	192	* Nothing else to do.
	193	*/
	194	*space_avail_now = false;
	195	}
	196
	197	return 0;
	198	}
	199
	200	static int
	201	vmci_transport_notify_pkt_recv_init(
	202	struct sock *sk,
	203	size_t target,
	204	struct vmci_transport_recv_notify_data *data)
	205	{
	206	struct vsock_sock *vsk = vsock_sk(sk);
	207
	208	data->consume_head = 0;
	209	data->produce_tail = 0;
	210	data->notify_on_block = false;
	211
	212	if (PKT_FIELD(vsk, write_notify_min_window) < target + 1) {
	213	PKT_FIELD(vsk, write_notify_min_window) = target + 1;
	214	if (PKT_FIELD(vsk, write_notify_window) <
	215	PKT_FIELD(vsk, write_notify_min_window)) {
	216	/* If the current window is smaller than the new
	217	* minimal window size, we need to reevaluate whether
	218	* we need to notify the sender. If the number of ready
	219	* bytes are smaller than the new window, we need to
	220	* send a notification to the sender before we block.
	221	*/
	222
	223	PKT_FIELD(vsk, write_notify_window) =
	224	PKT_FIELD(vsk, write_notify_min_window);
	225	data->notify_on_block = true;
	226	}
	227	}
	228
	229	return 0;
	230	}
	231
	232	static int
	233	vmci_transport_notify_pkt_recv_pre_block(
	234	struct sock *sk,
	235	size_t target,
236	struct vmci_transport_recv_notify_data *data)
237	{
238	int err = 0;
239
240	vsock_block_update_write_window(sk);
241
242	if (data->notify_on_block) {
243	err = vmci_transport_send_read_notification(sk);
244	if (err < 0)
245	return err;
246	data->notify_on_block = false;
247	}
248
249	return err;
250	}
251
252	static int
253	vmci_transport_notify_pkt_recv_post_dequeue(
254	struct sock *sk,
255	size_t target,
256	ssize_t copied,
257	bool data_read,
258	struct vmci_transport_recv_notify_data *data)
259	{
260	struct vsock_sock *vsk;
261	int err;
262	bool was_full = false;
263	u64 free_space;
264
265	vsk = vsock_sk(sk);
266	err = 0;
267
268	if (data_read) {
269	smp_mb();
270
271	free_space =
272	vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair);
273	was_full = free_space == copied;
274
275	if (was_full)
276	PKT_FIELD(vsk, peer_waiting_write) = true;
277
278	err = vmci_transport_send_read_notification(sk);
279	if (err < 0)
280	return err;
281
282	/* See the comment in
283	* vmci_transport_notify_pkt_send_post_enqueue().
284	*/
676d2369	285	sk->sk_data_ready(sk);
d021c344 AK	286	}
	287
	288	return err;
	289	}
	290
	291	static int
	292	vmci_transport_notify_pkt_send_init(
	293	struct sock *sk,
	294	struct vmci_transport_send_notify_data *data)
	295	{
	296	data->consume_head = 0;
	297	data->produce_tail = 0;
	298
	299	return 0;
	300	}
	301
	302	static int
	303	vmci_transport_notify_pkt_send_post_enqueue(
	304	struct sock *sk,
	305	ssize_t written,
	306	struct vmci_transport_send_notify_data *data)
	307	{
	308	int err = 0;
	309	struct vsock_sock *vsk;
	310	bool sent_wrote = false;
	311	bool was_empty;
	312	int retries = 0;
	313
	314	vsk = vsock_sk(sk);
	315
	316	smp_mb();
	317
	318	was_empty =
	319	vmci_qpair_produce_buf_ready(vmci_trans(vsk)->qpair) == written;
	320	if (was_empty) {
	321	while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
	322	!sent_wrote &&
	323	retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
	324	err = vmci_transport_send_wrote(sk);
	325	if (err >= 0)
	326	sent_wrote = true;
	327
	328	retries++;
	329	}
	330	}
	331
	332	if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS && !sent_wrote) {
	333	pr_err("%p unable to send wrote notification to peer\n",
	334	sk);
	335	return err;
	336	}
	337
	338	return err;
	339	}
	340
	341	static void
	342	vmci_transport_notify_pkt_handle_pkt(
	343	struct sock *sk,
	344	struct vmci_transport_packet *pkt,
	345	bool bottom_half,
	346	struct sockaddr_vm *dst,
	347	struct sockaddr_vm src, bool pkt_processed)
	348	{
	349	bool processed = false;
350
351	switch (pkt->type) {
352	case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
353	vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);
354	processed = true;
355	break;
356	case VMCI_TRANSPORT_PACKET_TYPE_READ:
357	vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);
358	processed = true;
359	break;
360	}
361
362	if (pkt_processed)
363	*pkt_processed = processed;
364	}
365
366	static void vmci_transport_notify_pkt_process_request(struct sock *sk)
367	{
368	struct vsock_sock *vsk = vsock_sk(sk);
369
370	PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
371	if (vmci_trans(vsk)->consume_size <
372	PKT_FIELD(vsk, write_notify_min_window))
373	PKT_FIELD(vsk, write_notify_min_window) =
374	vmci_trans(vsk)->consume_size;
375	}
376
377	static void vmci_transport_notify_pkt_process_negotiate(struct sock *sk)
378	{
379	struct vsock_sock *vsk = vsock_sk(sk);
380
381	PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
382	if (vmci_trans(vsk)->consume_size <
383	PKT_FIELD(vsk, write_notify_min_window))
384	PKT_FIELD(vsk, write_notify_min_window) =
385	vmci_trans(vsk)->consume_size;
386	}
387
388	static int
389	vmci_transport_notify_pkt_recv_pre_dequeue(
390	struct sock *sk,
391	size_t target,
392	struct vmci_transport_recv_notify_data *data)
393	{
394	return 0; /* NOP for QState. */
395	}
396
397	static int
398	vmci_transport_notify_pkt_send_pre_block(
399	struct sock *sk,
400	struct vmci_transport_send_notify_data *data)
401	{
402	return 0; /* NOP for QState. */
403	}
404
405	static int
406	vmci_transport_notify_pkt_send_pre_enqueue(
407	struct sock *sk,
408	struct vmci_transport_send_notify_data *data)
409	{
410	return 0; /* NOP for QState. */
411	}
412
413	/* Socket always on control packet based operations. */
3b22dae3	414	const struct vmci_transport_notify_ops vmci_transport_notify_pkt_q_state_ops = {
99a5e178 KC	415	.socket_init = vmci_transport_notify_pkt_socket_init,
	416	.socket_destruct = vmci_transport_notify_pkt_socket_destruct,
	417	.poll_in = vmci_transport_notify_pkt_poll_in,
	418	.poll_out = vmci_transport_notify_pkt_poll_out,
	419	.handle_notify_pkt = vmci_transport_notify_pkt_handle_pkt,
	420	.recv_init = vmci_transport_notify_pkt_recv_init,
	421	.recv_pre_block = vmci_transport_notify_pkt_recv_pre_block,
	422	.recv_pre_dequeue = vmci_transport_notify_pkt_recv_pre_dequeue,
	423	.recv_post_dequeue = vmci_transport_notify_pkt_recv_post_dequeue,
	424	.send_init = vmci_transport_notify_pkt_send_init,
	425	.send_pre_block = vmci_transport_notify_pkt_send_pre_block,
	426	.send_pre_enqueue = vmci_transport_notify_pkt_send_pre_enqueue,
	427	.send_post_enqueue = vmci_transport_notify_pkt_send_post_enqueue,
	428	.process_request = vmci_transport_notify_pkt_process_request,
	429	.process_negotiate = vmci_transport_notify_pkt_process_negotiate,
d021c344	430	};