void ieee80211_requeue(struct ieee80211_local *local, int queue)
{
struct netdev_queue *txq = netdev_get_tx_queue(local->mdev, queue);
struct sk_buff_head list;
spinlock_t *root_lock;
struct Qdisc *qdisc;
u32 len;
rcu_read_lock_bh();
qdisc = rcu_dereference(txq->qdisc);
if (!qdisc || !qdisc->dequeue)
goto out_unlock;
skb_queue_head_init(&list);
root_lock = qdisc_root_lock(qdisc);
spin_lock(root_lock);
for (len = qdisc->q.qlen; len > 0; len--) {
struct sk_buff *skb = qdisc->dequeue(qdisc);
if (skb)
__skb_queue_tail(&list, skb);
}
spin_unlock(root_lock);
for (len = list.qlen; len > 0; len--) {
struct sk_buff *skb = __skb_dequeue(&list);
u16 new_queue;
BUG_ON(!skb);
new_queue = ieee80211_select_queue(local->mdev, skb);
skb_set_queue_mapping(skb, new_queue);
txq = netdev_get_tx_queue(local->mdev, new_queue);
qdisc = rcu_dereference(txq->qdisc);
root_lock = qdisc_root_lock(qdisc);
spin_lock(root_lock);
qdisc_enqueue_root(skb, qdisc);
spin_unlock(root_lock);
}
out_unlock:
rcu_read_unlock_bh();
}
/*
* Insert one skb into qdisc.
* Note: parent depends on return value to account for queue length.
* NET_XMIT_DROP: queue length didn't change.
* NET_XMIT_SUCCESS: one skb was queued.
*/
static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
struct netem_sched_data *q = qdisc_priv(sch);
/* We don't fill cb now as skb_unshare() may invalidate it */
struct netem_skb_cb *cb;
struct sk_buff *skb2;
int count = 1;
/* Random duplication */
if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
++count;
/* Drop packet? */
if (loss_event(q))
--count;
if (count == 0) {
sch->qstats.drops++;
kfree_skb(skb);
return NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
}
skb_orphan(skb);
/*
* If we need to duplicate packet, then re-insert at top of the
* qdisc tree, since parent queuer expects that only one
* skb will be queued.
*/
if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
struct Qdisc *rootq = qdisc_root(sch);
u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
q->duplicate = 0;
qdisc_enqueue_root(skb2, rootq);
q->duplicate = dupsave;
}
/*
* Randomized packet corruption.
* Make copy if needed since we are modifying
* If packet is going to be hardware checksummed, then
* do it now in software before we mangle it.
*/
if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
if (!(skb = skb_unshare(skb, GFP_ATOMIC)) ||
(skb->ip_summed == CHECKSUM_PARTIAL &&
skb_checksum_help(skb)))
return qdisc_drop(skb, sch);
skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
}
if (unlikely(skb_queue_len(&sch->q) >= sch->limit))
return qdisc_reshape_fail(skb, sch);
sch->qstats.backlog += qdisc_pkt_len(skb);
cb = netem_skb_cb(skb);
if (q->gap == 0 || /* not doing reordering */
q->counter < q->gap - 1 || /* inside last reordering gap */
q->reorder < get_crandom(&q->reorder_cor)) {
psched_time_t now;
psched_tdiff_t delay;
delay = tabledist(q->latency, q->jitter,
&q->delay_cor, q->delay_dist);
now = psched_get_time();
if (q->rate) {
struct sk_buff_head *list = &sch->q;
delay += packet_len_2_sched_time(skb->len, q);
if (!skb_queue_empty(list)) {
/*
* Last packet in queue is reference point (now).
* First packet in queue is already in flight,
* calculate this time bonus and substract
* from delay.
*/
delay -= now - netem_skb_cb(skb_peek(list))->time_to_send;
now = netem_skb_cb(skb_peek_tail(list))->time_to_send;
}
}
cb->time_to_send = now + delay;
++q->counter;
tfifo_enqueue(skb, sch);
} else {
/*
* Do re-ordering by putting one out of N packets at the front
* of the queue.
*/
cb->time_to_send = psched_get_time();
q->counter = 0;
__skb_queue_head(&sch->q, skb);
sch->qstats.requeues++;
}
return NET_XMIT_SUCCESS;
}
/*
* Insert one skb into qdisc.
* Note: parent depends on return value to account for queue length.
* NET_XMIT_DROP: queue length didn't change.
* NET_XMIT_SUCCESS: one skb was queued.
*/
static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
struct netem_sched_data *q = qdisc_priv(sch);
/* We don't fill cb now as skb_unshare() may invalidate it */
struct netem_skb_cb *cb;
struct sk_buff *skb2;
int ret;
int count = 1;
/* Random duplication */
if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
++count;
/* Drop packet? */
if (loss_event(q))
--count;
if (count == 0) {
sch->qstats.drops++;
kfree_skb(skb);
return NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
}
skb_orphan(skb);
/*
* If we need to duplicate packet, then re-insert at top of the
* qdisc tree, since parent queuer expects that only one
* skb will be queued.
*/
if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
struct Qdisc *rootq = qdisc_root(sch);
u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
q->duplicate = 0;
qdisc_enqueue_root(skb2, rootq);
q->duplicate = dupsave;
}
/*
* Randomized packet corruption.
* Make copy if needed since we are modifying
* If packet is going to be hardware checksummed, then
* do it now in software before we mangle it.
*/
if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
if (!(skb = skb_unshare(skb, GFP_ATOMIC)) ||
(skb->ip_summed == CHECKSUM_PARTIAL &&
skb_checksum_help(skb))) {
sch->qstats.drops++;
return NET_XMIT_DROP;
}
skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
}
cb = netem_skb_cb(skb);
if (q->gap == 0 || /* not doing reordering */
q->counter < q->gap || /* inside last reordering gap */
q->reorder < get_crandom(&q->reorder_cor)) {
psched_time_t now;
psched_tdiff_t delay;
delay = tabledist(q->latency, q->jitter,
&q->delay_cor, q->delay_dist);
now = psched_get_time();
cb->time_to_send = now + delay;
++q->counter;
ret = qdisc_enqueue(skb, q->qdisc);
} else {
/*
* Do re-ordering by putting one out of N packets at the front
* of the queue.
*/
cb->time_to_send = psched_get_time();
q->counter = 0;
__skb_queue_head(&q->qdisc->q, skb);
sch->qstats.backlog += qdisc_pkt_len(skb);
sch->qstats.requeues++;
ret = NET_XMIT_SUCCESS;
}
if (ret != NET_XMIT_SUCCESS) {
if (net_xmit_drop_count(ret)) {
sch->qstats.drops++;
return ret;
}
}
sch->q.qlen++;
return NET_XMIT_SUCCESS;
}
static int imq_nf_queue(struct nf_queue_entry *entry, unsigned queue_num)
{
struct net_device *dev;
struct sk_buff *skb_orig, *skb, *skb_shared;
struct Qdisc *q;
struct netdev_queue *txq;
spinlock_t *root_lock;
int users, index;
int retval = -EINVAL;
unsigned int orig_queue_index;
index = entry->skb->imq_flags & IMQ_F_IFMASK;
if (unlikely(index > numdevs - 1)) {
if (net_ratelimit())
printk(KERN_WARNING
"IMQ: invalid device specified, highest is %u\n",
numdevs - 1);
retval = -EINVAL;
goto out;
}
/* check for imq device by index from cache */
dev = imq_devs_cache[index];
if (unlikely(!dev)) {
char buf[8];
/* get device by name and cache result */
snprintf(buf, sizeof(buf), "imq%d", index);
dev = dev_get_by_name(&init_net, buf);
if (unlikely(!dev)) {
/* not found ?!*/
BUG();
retval = -ENODEV;
goto out;
}
imq_devs_cache[index] = dev;
dev_put(dev);
}
if (unlikely(!(dev->flags & IFF_UP))) {
entry->skb->imq_flags = 0;
nf_reinject(entry, NF_ACCEPT);
retval = 0;
goto out;
}
dev->last_rx = jiffies;
skb = entry->skb;
skb_orig = NULL;
/* skb has owner? => make clone */
if (unlikely(skb->destructor)) {
skb_orig = skb;
skb = skb_clone(skb, GFP_ATOMIC);
if (unlikely(!skb)) {
retval = -ENOMEM;
goto out;
}
entry->skb = skb;
}
skb->nf_queue_entry = entry;
dev->stats.rx_bytes += skb->len;
dev->stats.rx_packets++;
if (!skb->dev) {
/* skb->dev == NULL causes problems, try the find cause. */
if (net_ratelimit()) {
dev_warn(&dev->dev,
"received packet with skb->dev == NULL\n");
dump_stack();
}
skb->dev = dev;
}
/* Disables softirqs for lock below */
rcu_read_lock_bh();
/* Multi-queue selection */
orig_queue_index = skb_get_queue_mapping(skb);
txq = imq_select_queue(dev, skb);
q = rcu_dereference(txq->qdisc);
if (unlikely(!q->enqueue))
goto packet_not_eaten_by_imq_dev;
root_lock = qdisc_lock(q);
spin_lock(root_lock);
users = atomic_read(&skb->users);
skb_shared = skb_get(skb); /* increase reference count by one */
skb_save_cb(skb_shared); /* backup skb->cb, as qdisc layer will
overwrite it */
qdisc_enqueue_root(skb_shared, q); /* might kfree_skb */
if (likely(atomic_read(&skb_shared->users) == users + 1)) {
kfree_skb(skb_shared); /* decrease reference count by one */
skb->destructor = &imq_skb_destructor;
/* cloned? */
if (unlikely(skb_orig))
kfree_skb(skb_orig); /* free original */
spin_unlock(root_lock);
rcu_read_unlock_bh();
/* schedule qdisc dequeue */
__netif_schedule(q);
retval = 0;
goto out;
} else {
skb_restore_cb(skb_shared); /* restore skb->cb */
skb->nf_queue_entry = NULL;
/* qdisc dropped packet and decreased skb reference count of
* skb, so we don't really want to and try refree as that would
* actually destroy the skb. */
spin_unlock(root_lock);
goto packet_not_eaten_by_imq_dev;
}
packet_not_eaten_by_imq_dev:
skb_set_queue_mapping(skb, orig_queue_index);
rcu_read_unlock_bh();
/* cloned? restore original */
if (unlikely(skb_orig)) {
kfree_skb(skb);
entry->skb = skb_orig;
}
retval = -1;
out:
return retval;
}
