Revert "net: sctp: Fix a_rwnd/rwnd management to reflect real state of the receiver's buffer" (362d5204) · Commits · e / devices / android_kernel_fairphone_FP4

include/net/sctp/structs.h

+13 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1653,6 +1653,17 @@ struct sctp_association {
	/* This is the last advertised value of rwnd over a SACK chunk. */		/* This is the last advertised value of rwnd over a SACK chunk. */
	__u32 a_rwnd;		__u32 a_rwnd;

			/* Number of bytes by which the rwnd has slopped. The rwnd is allowed
			* to slop over a maximum of the association's frag_point.
			*/
			__u32 rwnd_over;

			/* Keeps treack of rwnd pressure. This happens when we have
			* a window, but not recevie buffer (i.e small packets). This one
			* is releases slowly (1 PMTU at a time ).
			*/
			__u32 rwnd_press;

	/* This is the sndbuf size in use for the association.		/* This is the sndbuf size in use for the association.
	* This corresponds to the sndbuf size for the association,		* This corresponds to the sndbuf size for the association,
	* as specified in the sk->sndbuf.		* as specified in the sk->sndbuf.
	@@ -1881,7 +1892,8 @@ void sctp_assoc_update(struct sctp_association *old,
	__u32 sctp_association_get_next_tsn(struct sctp_association *);		__u32 sctp_association_get_next_tsn(struct sctp_association *);

	void sctp_assoc_sync_pmtu(struct sock , struct sctp_association );		void sctp_assoc_sync_pmtu(struct sock , struct sctp_association );
	void sctp_assoc_rwnd_update(struct sctp_association *, bool);		void sctp_assoc_rwnd_increase(struct sctp_association *, unsigned int);
			void sctp_assoc_rwnd_decrease(struct sctp_association *, unsigned int);
	void sctp_assoc_set_primary(struct sctp_association *,		void sctp_assoc_set_primary(struct sctp_association *,
	struct sctp_transport *);		struct sctp_transport *);
	void sctp_assoc_del_nonprimary_peers(struct sctp_association *,		void sctp_assoc_del_nonprimary_peers(struct sctp_association *,

net/sctp/associola.c

+65 −17

Original line number	Original line	Diff line number	Diff line
	@@ -1395,35 +1395,44 @@ static inline bool sctp_peer_needs_update(struct sctp_association *asoc)
	return false;		return false;
	}		}

	/* Update asoc's rwnd for the approximated state in the buffer,		/* Increase asoc's rwnd by len and send any window update SACK if needed. */
	* and check whether SACK needs to be sent.		void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len)
	*/
	void sctp_assoc_rwnd_update(struct sctp_association *asoc, bool update_peer)
	{		{
	int rx_count;
	struct sctp_chunk *sack;		struct sctp_chunk *sack;
	struct timer_list *timer;		struct timer_list *timer;

	if (asoc->ep->rcvbuf_policy)		if (asoc->rwnd_over) {
	rx_count = atomic_read(&asoc->rmem_alloc);		if (asoc->rwnd_over >= len) {
	else		asoc->rwnd_over -= len;
	rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);		} else {
			asoc->rwnd += (len - asoc->rwnd_over);
			asoc->rwnd_over = 0;
			}
			} else {
			asoc->rwnd += len;
			}

	if ((asoc->base.sk->sk_rcvbuf - rx_count) > 0)		/* If we had window pressure, start recovering it
	asoc->rwnd = (asoc->base.sk->sk_rcvbuf - rx_count) >> 1;		* once our rwnd had reached the accumulated pressure
	else		* threshold. The idea is to recover slowly, but up
	asoc->rwnd = 0;		* to the initial advertised window.
			*/
			if (asoc->rwnd_press && asoc->rwnd >= asoc->rwnd_press) {
			int change = min(asoc->pathmtu, asoc->rwnd_press);
			asoc->rwnd += change;
			asoc->rwnd_press -= change;
			}

	pr_debug("%s: asoc:%p rwnd=%u, rx_count=%d, sk_rcvbuf=%d\n",		pr_debug("%s: asoc:%p rwnd increased by %d to (%u, %u) - %u\n",
	__func__, asoc, asoc->rwnd, rx_count,		__func__, asoc, len, asoc->rwnd, asoc->rwnd_over,
	asoc->base.sk->sk_rcvbuf);		asoc->a_rwnd);

	/* Send a window update SACK if the rwnd has increased by at least the		/* Send a window update SACK if the rwnd has increased by at least the
	* minimum of the association's PMTU and half of the receive buffer.		* minimum of the association's PMTU and half of the receive buffer.
	* The algorithm used is similar to the one described in		* The algorithm used is similar to the one described in
	* Section 4.2.3.3 of RFC 1122.		* Section 4.2.3.3 of RFC 1122.
	*/		*/
	if (update_peer && sctp_peer_needs_update(asoc)) {		if (sctp_peer_needs_update(asoc)) {
	asoc->a_rwnd = asoc->rwnd;		asoc->a_rwnd = asoc->rwnd;

	pr_debug("%s: sending window update SACK- asoc:%p rwnd:%u "		pr_debug("%s: sending window update SACK- asoc:%p rwnd:%u "
	@@ -1445,6 +1454,45 @@ void sctp_assoc_rwnd_update(struct sctp_association *asoc, bool update_peer)
	}		}
	}		}

			/* Decrease asoc's rwnd by len. */
			void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len)
			{
			int rx_count;
			int over = 0;

			if (unlikely(!asoc->rwnd \|\| asoc->rwnd_over))
			pr_debug("%s: association:%p has asoc->rwnd:%u, "
			"asoc->rwnd_over:%u!\n", __func__, asoc,
			asoc->rwnd, asoc->rwnd_over);

			if (asoc->ep->rcvbuf_policy)
			rx_count = atomic_read(&asoc->rmem_alloc);
			else
			rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);

			/* If we've reached or overflowed our receive buffer, announce
			* a 0 rwnd if rwnd would still be positive. Store the
			* the potential pressure overflow so that the window can be restored
			* back to original value.
			*/
			if (rx_count >= asoc->base.sk->sk_rcvbuf)
			over = 1;

			if (asoc->rwnd >= len) {
			asoc->rwnd -= len;
			if (over) {
			asoc->rwnd_press += asoc->rwnd;
			asoc->rwnd = 0;
			}
			} else {
			asoc->rwnd_over = len - asoc->rwnd;
			asoc->rwnd = 0;
			}

			pr_debug("%s: asoc:%p rwnd decreased by %d to (%u, %u, %u)\n",
			__func__, asoc, len, asoc->rwnd, asoc->rwnd_over,
			asoc->rwnd_press);
			}

	/* Build the bind address list for the association based on info from the		/* Build the bind address list for the association based on info from the
	* local endpoint and the remote peer.		* local endpoint and the remote peer.

net/sctp/sm_statefuns.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -6178,7 +6178,7 @@ static int sctp_eat_data(const struct sctp_association *asoc,
	* PMTU. In cases, such as loopback, this might be a rather		* PMTU. In cases, such as loopback, this might be a rather
	* large spill over.		* large spill over.
	*/		*/
	if ((!chunk->data_accepted) && (!asoc->rwnd \|\|		if ((!chunk->data_accepted) && (!asoc->rwnd \|\| asoc->rwnd_over \|\|
	(datalen > asoc->rwnd + asoc->frag_point))) {		(datalen > asoc->rwnd + asoc->frag_point))) {

	/* If this is the next TSN, consider reneging to make		/* If this is the next TSN, consider reneging to make

net/sctp/socket.c

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -2115,6 +2115,12 @@ static int sctp_recvmsg(struct kiocb iocb, struct sock sk,
	sctp_skb_pull(skb, copied);		sctp_skb_pull(skb, copied);
	skb_queue_head(&sk->sk_receive_queue, skb);		skb_queue_head(&sk->sk_receive_queue, skb);

			/* When only partial message is copied to the user, increase
			* rwnd by that amount. If all the data in the skb is read,
			* rwnd is updated when the event is freed.
			*/
			if (!sctp_ulpevent_is_notification(event))
			sctp_assoc_rwnd_increase(event->asoc, copied);
	goto out;		goto out;
	} else if ((event->msg_flags & MSG_NOTIFICATION) \|\|		} else if ((event->msg_flags & MSG_NOTIFICATION) \|\|
	(event->msg_flags & MSG_EOR))		(event->msg_flags & MSG_EOR))

net/sctp/ulpevent.c

+2 −6

Original line number	Original line	Diff line number	Diff line
	@@ -989,7 +989,7 @@ static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
	skb = sctp_event2skb(event);		skb = sctp_event2skb(event);
	/* Set the owner and charge rwnd for bytes received. */		/* Set the owner and charge rwnd for bytes received. */
	sctp_ulpevent_set_owner(event, asoc);		sctp_ulpevent_set_owner(event, asoc);
	sctp_assoc_rwnd_update(asoc, false);		sctp_assoc_rwnd_decrease(asoc, skb_headlen(skb));

	if (!skb->data_len)		if (!skb->data_len)
	return;		return;
	@@ -1011,7 +1011,6 @@ static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
	{		{
	struct sk_buff skb, frag;		struct sk_buff skb, frag;
	unsigned int len;		unsigned int len;
	struct sctp_association *asoc;

	/* Current stack structures assume that the rcv buffer is		/* Current stack structures assume that the rcv buffer is
	* per socket. For UDP style sockets this is not true as		* per socket. For UDP style sockets this is not true as
	@@ -1036,11 +1035,8 @@ static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
	}		}

	done:		done:
	asoc = event->asoc;		sctp_assoc_rwnd_increase(event->asoc, len);
	sctp_association_hold(asoc);
	sctp_ulpevent_release_owner(event);		sctp_ulpevent_release_owner(event);
	sctp_assoc_rwnd_update(asoc, true);
	sctp_association_put(asoc);
	}		}

	static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event)		static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event)