lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rt2x00: Serialize TX operations on a queue.

Browse Source 
The rt2x00 driver gets frequent occurrences of the following error message
when operating under load:
phy0 -> rt2x00queue_write_tx_frame: Error - Arrived at non-free entry in the
non-full queue 2.

This is caused by simultaneous attempts from mac80211 to send a frame via
rt2x00, which are not properly serialized inside rt2x00queue_write_tx_frame,
causing the second frame to fail sending with the above mentioned error
message.

Fix this by introducing a per-queue spinlock to serialize the TX operations
on that queue.

Reported-by: Andreas Hartmann <andihartmann@01019freenet.de>
Signed-off-by: Gertjan van Wingerde <gwingerde@gmail.com>
Acked-by: Helmut Schaa <helmut.schaa@googlemail.com>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Gertjan van Wingerde
2011-07-06 22:56:24 +02:00
committed by John W. Linville
parent 9352f69c91
commit 77a861c405
2 changed files with 18 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
drivers/net/wireless/rt2x00/rt2x00queue.c
View File

@@ -555,15 +555,21 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
bool local) bool local)
{ {
struct ieee80211_tx_info *tx_info; struct ieee80211_tx_info *tx_info;
struct queue_entry *entry = rt2x00queue_get_entry(queue, Q_INDEX); struct queue_entry *entry;
struct txentry_desc txdesc; struct txentry_desc txdesc;
struct skb_frame_desc *skbdesc; struct skb_frame_desc *skbdesc;
u8 rate_idx, rate_flags; u8 rate_idx, rate_flags;
int ret = 0;
spin_lock(&queue->tx_lock);
entry = rt2x00queue_get_entry(queue, Q_INDEX);
if (unlikely(rt2x00queue_full(queue))) { if (unlikely(rt2x00queue_full(queue))) {
ERROR(queue->rt2x00dev, ERROR(queue->rt2x00dev,
"Dropping frame due to full tx queue %d.\n", queue->qid); "Dropping frame due to full tx queue %d.\n", queue->qid);
return -ENOBUFS; ret = -ENOBUFS;
goto out;
} }
if (unlikely(test_and_set_bit(ENTRY_OWNER_DEVICE_DATA, if (unlikely(test_and_set_bit(ENTRY_OWNER_DEVICE_DATA,
@@ -572,7 +578,8 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
"Arrived at non-free entry in the non-full queue %d.\n" "Arrived at non-free entry in the non-full queue %d.\n"
"Please file bug report to %s.\n", "Please file bug report to %s.\n",
queue->qid, DRV_PROJECT); queue->qid, DRV_PROJECT);
return -EINVAL; ret = -EINVAL;
goto out;
} }
/* /*
@@ -634,7 +641,8 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
if (unlikely(rt2x00queue_write_tx_data(entry, &txdesc))) { if (unlikely(rt2x00queue_write_tx_data(entry, &txdesc))) {
clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags); clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
entry->skb = NULL; entry->skb = NULL;
return -EIO; ret = -EIO;
goto out;
} }
set_bit(ENTRY_DATA_PENDING, &entry->flags); set_bit(ENTRY_DATA_PENDING, &entry->flags);
@@ -643,7 +651,9 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
rt2x00queue_write_tx_descriptor(entry, &txdesc); rt2x00queue_write_tx_descriptor(entry, &txdesc);
rt2x00queue_kick_tx_queue(queue, &txdesc); rt2x00queue_kick_tx_queue(queue, &txdesc);
return 0; out:
spin_unlock(&queue->tx_lock);
return ret;
} }
int rt2x00queue_clear_beacon(struct rt2x00_dev *rt2x00dev, int rt2x00queue_clear_beacon(struct rt2x00_dev *rt2x00dev,
@@ -1184,6 +1194,7 @@ static void rt2x00queue_init(struct rt2x00_dev *rt2x00dev,
struct data_queue *queue, enum data_queue_qid qid) struct data_queue *queue, enum data_queue_qid qid)
{ {
mutex_init(&queue->status_lock); mutex_init(&queue->status_lock);
spin_lock_init(&queue->tx_lock);
spin_lock_init(&queue->index_lock); spin_lock_init(&queue->index_lock);
queue->rt2x00dev = rt2x00dev; queue->rt2x00dev = rt2x00dev;

2
drivers/net/wireless/rt2x00/rt2x00queue.h
View File

@@ -432,6 +432,7 @@ enum data_queue_flags {
* @flags: Entry flags, see &enum queue_entry_flags. * @flags: Entry flags, see &enum queue_entry_flags.
* @status_lock: The mutex for protecting the start/stop/flush * @status_lock: The mutex for protecting the start/stop/flush
* handling on this queue. * handling on this queue.
* @tx_lock: Spinlock to serialize tx operations on this queue.
* @index_lock: Spinlock to protect index handling. Whenever @index, @index_done or * @index_lock: Spinlock to protect index handling. Whenever @index, @index_done or
* @index_crypt needs to be changed this lock should be grabbed to prevent * @index_crypt needs to be changed this lock should be grabbed to prevent
* index corruption due to concurrency. * index corruption due to concurrency.
@@ -458,6 +459,7 @@ struct data_queue {
unsigned long flags; unsigned long flags;
struct mutex status_lock; struct mutex status_lock;
spinlock_t tx_lock;
spinlock_t index_lock; spinlock_t index_lock;
unsigned int count; unsigned int count;