Commit 4d050f1d authored by Jouni Malinen's avatar Jouni Malinen Committed by John W. Linville
Browse files

mac80211: Add a timeout for frames in the RX reorder buffer 



This patch allows skbs to be released from the RX reorder buffer in
case they have been there for an unexpectedly long time without us
having received the missing frames before them. Previously, these
frames were only released when the reorder window moved and that could
take very long time unless new frames were received constantly (e.g.,
TCP connections could be killed more or less indefinitely).

This situation should not happen very frequently, but it looks like
there are some scenarious that trigger it for some reason. As such,
this should be considered mostly a workaround to speed up recovery
from unexpected siutation that could result in connections hanging for
long periods of time.

The changes here will only check for timeout situation when adding new
RX frames to the reorder buffer. It does not handle all possible
cases, but seems to help for most cases that could result from common
network usage (e.g., TCP retrying at least couple of times). For more
completely coverage, a timer could be used to periodically check
whether there are any frames remaining in the reorder buffer if no new
frames are received.

Signed-off-by: default avatarJouni Malinen <jouni.malinen@atheros.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent 2d3babd1

net/mac80211/agg-rx.c

+7 −1
Original line number Diff line number Diff line
@@ -68,6 +68,7 @@ void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid, 
	spin_lock_bh(&sta->lock);

	/* free resources */

	kfree(sta->ampdu_mlme.tid_rx[tid]->reorder_buf);

	kfree(sta->ampdu_mlme.tid_rx[tid]->reorder_time);



	if (!sta->ampdu_mlme.tid_rx[tid]->shutdown) {

		kfree(sta->ampdu_mlme.tid_rx[tid]);
@@ -268,13 +269,18 @@ void ieee80211_process_addba_request(struct ieee80211_local *local, 
	/* prepare reordering buffer */

	tid_agg_rx->reorder_buf =

		kcalloc(buf_size, sizeof(struct sk_buff *), GFP_ATOMIC);

	if (!tid_agg_rx->reorder_buf) {

	tid_agg_rx->reorder_time =

		kcalloc(buf_size, sizeof(unsigned long), GFP_ATOMIC);

	if (!tid_agg_rx->reorder_buf || !tid_agg_rx->reorder_time) {

#ifdef CONFIG_MAC80211_HT_DEBUG

		if (net_ratelimit())

			printk(KERN_ERR "can not allocate reordering buffer "

			       "to tid %d\n", tid);

#endif

		kfree(tid_agg_rx->reorder_buf);

		kfree(tid_agg_rx->reorder_time);

		kfree(sta->ampdu_mlme.tid_rx[tid]);

		sta->ampdu_mlme.tid_rx[tid] = NULL;

		goto end;

	}

net/mac80211/rx.c

+46 −1
Original line number Diff line number Diff line
@@ -2312,6 +2312,15 @@ no_frame: 
}





/*

 * Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If

 * the skb was added to the buffer longer than this time ago, the earlier

 * frames that have not yet been received are assumed to be lost and the skb

 * can be released for processing. This may also release other skb's from the

 * reorder buffer if there are no additional gaps between the frames.

 */

#define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)



/*

 * As it function blongs to Rx path it must be called with

 * the proper rcu_read_lock protection for its flow.
@@ -2377,13 +2386,49 @@ static u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw, 


	/* put the frame in the reordering buffer */

	tid_agg_rx->reorder_buf[index] = skb;

	tid_agg_rx->reorder_time[index] = jiffies;

	memcpy(tid_agg_rx->reorder_buf[index]->cb, rxstatus,

	       sizeof(*rxstatus));

	tid_agg_rx->stored_mpdu_num++;

	/* release the buffer until next missing frame */

	index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn)

						% tid_agg_rx->buf_size;

	while (tid_agg_rx->reorder_buf[index]) {

	if (!tid_agg_rx->reorder_buf[index] &&

	    tid_agg_rx->stored_mpdu_num > 1) {

		/*

		 * No buffers ready to be released, but check whether any

		 * frames in the reorder buffer have timed out.

		 */

		int j;

		int skipped = 1;

		for (j = (index + 1) % tid_agg_rx->buf_size; j != index;

		     j = (j + 1) % tid_agg_rx->buf_size) {

			if (tid_agg_rx->reorder_buf[j] == NULL) {

				skipped++;

				continue;

			}

			if (!time_after(jiffies, tid_agg_rx->reorder_time[j] +

					HZ / 10))

				break;



#ifdef CONFIG_MAC80211_HT_DEBUG

			if (net_ratelimit())

				printk(KERN_DEBUG "%s: release an RX reorder "

				       "frame due to timeout on earlier "

				       "frames\n",

				       wiphy_name(hw->wiphy));

#endif

			ieee80211_release_reorder_frame(hw, tid_agg_rx, j);



			/*

			 * Increment the head seq# also for the skipped slots.

			 */

			tid_agg_rx->head_seq_num =

				(tid_agg_rx->head_seq_num + skipped) &

				SEQ_MASK;

			skipped = 0;

		}

	} else while (tid_agg_rx->reorder_buf[index]) {

		ieee80211_release_reorder_frame(hw, tid_agg_rx, index);

		index =	seq_sub(tid_agg_rx->head_seq_num,

			tid_agg_rx->ssn) % tid_agg_rx->buf_size;

net/mac80211/sta_info.h

+2 −0
Original line number Diff line number Diff line
@@ -88,6 +88,7 @@ struct tid_ampdu_tx { 
 * struct tid_ampdu_rx - TID aggregation information (Rx).

 *

 * @reorder_buf: buffer to reorder incoming aggregated MPDUs

 * @reorder_time: jiffies when skb was added

 * @session_timer: check if peer keeps Tx-ing on the TID (by timeout value)

 * @head_seq_num: head sequence number in reordering buffer.

 * @stored_mpdu_num: number of MPDUs in reordering buffer
@@ -99,6 +100,7 @@ struct tid_ampdu_tx { 
 */

struct tid_ampdu_rx {

	struct sk_buff **reorder_buf;

	unsigned long *reorder_time;

	struct timer_list session_timer;

	u16 head_seq_num;

	u16 stored_mpdu_num;

CRA Git | Maintained and supported by SUSTech CRA and CCSE