bianbu-repo-mirror/bianbu-linux-6.6
1
0
Fork 0
mirror of https://gitee.com/bianbu-linux/linux-6.6 synced 2025-04-24 14:07:52 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Revert "net: sched: Pass root lock to Qdisc_ops.enqueue"

Browse source 
This reverts commit aebe4426cc.

Signed-off-by: Petr Machata <petrm@mellanox.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Petr Machata 2020-07-14 20:03:08 +03:00 • committed by Jakub Kicinski
parent 55f656cdb8
commit ac5c66f261
35 changed files with 71 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/net/sch_generic.h
View file

@ -57,7 +57,6 @@ struct qdisc_skb_head {
struct Qdisc { struct Qdisc {
int (*enqueue)(struct sk_buff *skb, int (*enqueue)(struct sk_buff *skb,
struct Qdisc *sch, struct Qdisc *sch,
spinlock_t *root_lock,
struct sk_buff **to_free); struct sk_buff **to_free);
struct sk_buff * (*dequeue)(struct Qdisc *sch); struct sk_buff * (*dequeue)(struct Qdisc *sch);
unsigned int flags; unsigned int flags;
@ -242,7 +241,6 @@ struct Qdisc_ops {
int (*enqueue)(struct sk_buff *skb, int (*enqueue)(struct sk_buff *skb,
struct Qdisc *sch, struct Qdisc *sch,
spinlock_t *root_lock,
struct sk_buff **to_free); struct sk_buff **to_free);
struct sk_buff * (*dequeue)(struct Qdisc *); struct sk_buff * (*dequeue)(struct Qdisc *);
struct sk_buff * (*peek)(struct Qdisc *); struct sk_buff * (*peek)(struct Qdisc *);
@ -790,11 +788,11 @@ static inline void qdisc_calculate_pkt_len(struct sk_buff *skb,
#endif #endif
} }
static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
qdisc_calculate_pkt_len(skb, sch); qdisc_calculate_pkt_len(skb, sch);
return sch->enqueue(skb, sch, root_lock, to_free); return sch->enqueue(skb, sch, to_free);
} }
static inline void _bstats_update(struct gnet_stats_basic_packed *bstats, static inline void _bstats_update(struct gnet_stats_basic_packed *bstats,

4
net/core/dev.c
View file

@ -3749,7 +3749,7 @@ static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
qdisc_calculate_pkt_len(skb, q); qdisc_calculate_pkt_len(skb, q);
if (q->flags & TCQ_F_NOLOCK) { if (q->flags & TCQ_F_NOLOCK) {
rc = q->enqueue(skb, q, NULL, &to_free) & NET_XMIT_MASK; rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
qdisc_run(q); qdisc_run(q);
if (unlikely(to_free)) if (unlikely(to_free))
@ -3792,7 +3792,7 @@ static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
qdisc_run_end(q); qdisc_run_end(q);
rc = NET_XMIT_SUCCESS; rc = NET_XMIT_SUCCESS;
} else { } else {
rc = q->enqueue(skb, q, root_lock, &to_free) & NET_XMIT_MASK; rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
if (qdisc_run_begin(q)) { if (qdisc_run_begin(q)) {
if (unlikely(contended)) { if (unlikely(contended)) {
spin_unlock(&q->busylock); spin_unlock(&q->busylock);

4
net/sched/sch_atm.c
View file

@ -374,7 +374,7 @@ static struct tcf_block *atm_tc_tcf_block(struct Qdisc *sch, unsigned long cl,
/* --------------------------- Qdisc operations ---------------------------- */ /* --------------------------- Qdisc operations ---------------------------- */
static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct atm_qdisc_data *p = qdisc_priv(sch); struct atm_qdisc_data *p = qdisc_priv(sch);
@ -432,7 +432,7 @@ done:
#endif #endif
} }
ret = qdisc_enqueue(skb, flow->q, root_lock, to_free); ret = qdisc_enqueue(skb, flow->q, to_free);
if (ret != NET_XMIT_SUCCESS) { if (ret != NET_XMIT_SUCCESS) {
drop: __maybe_unused drop: __maybe_unused
if (net_xmit_drop_count(ret)) { if (net_xmit_drop_count(ret)) {

2
net/sched/sch_blackhole.c
View file

@ -13,7 +13,7 @@
#include <linux/skbuff.h> #include <linux/skbuff.h>
#include <net/pkt_sched.h> #include <net/pkt_sched.h>
static int blackhole_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int blackhole_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
qdisc_drop(skb, sch, to_free); qdisc_drop(skb, sch, to_free);

2
net/sched/sch_cake.c
View file

@ -1687,7 +1687,7 @@ hash:
static void cake_reconfigure(struct Qdisc *sch); static void cake_reconfigure(struct Qdisc *sch);
static s32 cake_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static s32 cake_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct cake_sched_data *q = qdisc_priv(sch); struct cake_sched_data *q = qdisc_priv(sch);

4
net/sched/sch_cbq.c
View file

@ -356,7 +356,7 @@ cbq_mark_toplevel(struct cbq_sched_data *q, struct cbq_class *cl)
} }
static int static int
cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct cbq_sched_data *q = qdisc_priv(sch); struct cbq_sched_data *q = qdisc_priv(sch);
@ -373,7 +373,7 @@ cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock,
return ret; return ret;
} }
ret = qdisc_enqueue(skb, cl->q, root_lock, to_free); ret = qdisc_enqueue(skb, cl->q, to_free);
if (ret == NET_XMIT_SUCCESS) { if (ret == NET_XMIT_SUCCESS) {
sch->q.qlen++; sch->q.qlen++;
cbq_mark_toplevel(q, cl); cbq_mark_toplevel(q, cl);

18
net/sched/sch_cbs.c
View file

@ -77,7 +77,7 @@ struct cbs_sched_data {
s64 sendslope; /* in bytes/s */ s64 sendslope; /* in bytes/s */
s64 idleslope; /* in bytes/s */ s64 idleslope; /* in bytes/s */
struct qdisc_watchdog watchdog; struct qdisc_watchdog watchdog;
int (*enqueue)(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, int (*enqueue)(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free); struct sk_buff **to_free);
struct sk_buff *(*dequeue)(struct Qdisc *sch); struct sk_buff *(*dequeue)(struct Qdisc *sch);
struct Qdisc *qdisc; struct Qdisc *qdisc;
@ -85,13 +85,13 @@ struct cbs_sched_data {
}; };
static int cbs_child_enqueue(struct sk_buff *skb, struct Qdisc *sch, static int cbs_child_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct Qdisc *child, spinlock_t *root_lock, struct Qdisc *child,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb); unsigned int len = qdisc_pkt_len(skb);
int err; int err;
err = child->ops->enqueue(skb, child, root_lock, to_free); err = child->ops->enqueue(skb, child, to_free);
if (err != NET_XMIT_SUCCESS) if (err != NET_XMIT_SUCCESS)
return err; return err;
@ -101,16 +101,16 @@ static int cbs_child_enqueue(struct sk_buff *skb, struct Qdisc *sch,
return NET_XMIT_SUCCESS; return NET_XMIT_SUCCESS;
} }
static int cbs_enqueue_offload(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int cbs_enqueue_offload(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct cbs_sched_data *q = qdisc_priv(sch); struct cbs_sched_data *q = qdisc_priv(sch);
struct Qdisc *qdisc = q->qdisc; struct Qdisc *qdisc = q->qdisc;
return cbs_child_enqueue(skb, sch, qdisc, root_lock, to_free); return cbs_child_enqueue(skb, sch, qdisc, to_free);
} }
static int cbs_enqueue_soft(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int cbs_enqueue_soft(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct cbs_sched_data *q = qdisc_priv(sch); struct cbs_sched_data *q = qdisc_priv(sch);
@ -124,15 +124,15 @@ static int cbs_enqueue_soft(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *
q->last = ktime_get_ns(); q->last = ktime_get_ns();
} }
return cbs_child_enqueue(skb, sch, qdisc, root_lock, to_free); return cbs_child_enqueue(skb, sch, qdisc, to_free);
} }
static int cbs_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int cbs_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct cbs_sched_data *q = qdisc_priv(sch); struct cbs_sched_data *q = qdisc_priv(sch);
return q->enqueue(skb, sch, root_lock, to_free); return q->enqueue(skb, sch, to_free);
} }
/* timediff is in ns, slope is in bytes/s */ /* timediff is in ns, slope is in bytes/s */

2
net/sched/sch_choke.c
View file

@ -210,7 +210,7 @@ static bool choke_match_random(const struct choke_sched_data *q,
return choke_match_flow(oskb, nskb); return choke_match_flow(oskb, nskb);
} }
static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct choke_sched_data *q = qdisc_priv(sch); struct choke_sched_data *q = qdisc_priv(sch);

2
net/sched/sch_codel.c
View file

@ -108,7 +108,7 @@ static struct sk_buff *codel_qdisc_dequeue(struct Qdisc *sch)
return skb; return skb;
} }
static int codel_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int codel_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct codel_sched_data *q; struct codel_sched_data *q;

4
net/sched/sch_drr.c
View file

@ -337,7 +337,7 @@ static struct drr_class *drr_classify(struct sk_buff *skb, struct Qdisc *sch,
return NULL; return NULL;
} }
static int drr_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int drr_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb); unsigned int len = qdisc_pkt_len(skb);
@ -355,7 +355,7 @@ static int drr_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
} }
first = !cl->qdisc->q.qlen; first = !cl->qdisc->q.qlen;
err = qdisc_enqueue(skb, cl->qdisc, root_lock, to_free); err = qdisc_enqueue(skb, cl->qdisc, to_free);
if (unlikely(err != NET_XMIT_SUCCESS)) { if (unlikely(err != NET_XMIT_SUCCESS)) {
if (net_xmit_drop_count(err)) { if (net_xmit_drop_count(err)) {
cl->qstats.drops++; cl->qstats.drops++;

4
net/sched/sch_dsmark.c
View file

@ -198,7 +198,7 @@ static struct tcf_block *dsmark_tcf_block(struct Qdisc *sch, unsigned long cl,
/* --------------------------- Qdisc operations ---------------------------- */ /* --------------------------- Qdisc operations ---------------------------- */
static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb); unsigned int len = qdisc_pkt_len(skb);
@ -267,7 +267,7 @@ static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *ro
} }
} }
err = qdisc_enqueue(skb, p->q, root_lock, to_free); err = qdisc_enqueue(skb, p->q, to_free);
if (err != NET_XMIT_SUCCESS) { if (err != NET_XMIT_SUCCESS) {
if (net_xmit_drop_count(err)) if (net_xmit_drop_count(err))
qdisc_qstats_drop(sch); qdisc_qstats_drop(sch);

2
net/sched/sch_etf.c
View file

@ -160,7 +160,7 @@ static void report_sock_error(struct sk_buff *skb, u32 err, u8 code)
} }
static int etf_enqueue_timesortedlist(struct sk_buff *nskb, struct Qdisc *sch, static int etf_enqueue_timesortedlist(struct sk_buff *nskb, struct Qdisc *sch,
spinlock_t *root_lock, struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct etf_sched_data *q = qdisc_priv(sch); struct etf_sched_data *q = qdisc_priv(sch);
struct rb_node **p = &q->head.rb_root.rb_node, *parent = NULL; struct rb_node **p = &q->head.rb_root.rb_node, *parent = NULL;

4
net/sched/sch_ets.c
View file

@ -415,7 +415,7 @@ static struct ets_class *ets_classify(struct sk_buff *skb, struct Qdisc *sch,
return &q->classes[band]; return &q->classes[band];
} }
static int ets_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int ets_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb); unsigned int len = qdisc_pkt_len(skb);
@ -433,7 +433,7 @@ static int ets_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t
} }
first = !cl->qdisc->q.qlen; first = !cl->qdisc->q.qlen;
err = qdisc_enqueue(skb, cl->qdisc, root_lock, to_free); err = qdisc_enqueue(skb, cl->qdisc, to_free);
if (unlikely(err != NET_XMIT_SUCCESS)) { if (unlikely(err != NET_XMIT_SUCCESS)) {
if (net_xmit_drop_count(err)) { if (net_xmit_drop_count(err)) {
cl->qstats.drops++; cl->qstats.drops++;

6
net/sched/sch_fifo.c
View file

@ -16,7 +16,7 @@
/* 1 band FIFO pseudo-"scheduler" */ /* 1 band FIFO pseudo-"scheduler" */
static int bfifo_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int bfifo_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
if (likely(sch->qstats.backlog + qdisc_pkt_len(skb) <= sch->limit)) if (likely(sch->qstats.backlog + qdisc_pkt_len(skb) <= sch->limit))
@ -25,7 +25,7 @@ static int bfifo_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *roo
return qdisc_drop(skb, sch, to_free); return qdisc_drop(skb, sch, to_free);
} }
static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
if (likely(sch->q.qlen < sch->limit)) if (likely(sch->q.qlen < sch->limit))
@ -34,7 +34,7 @@ static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *roo
return qdisc_drop(skb, sch, to_free); return qdisc_drop(skb, sch, to_free);
} }
static int pfifo_tail_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int pfifo_tail_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
unsigned int prev_backlog; unsigned int prev_backlog;

2
net/sched/sch_fq.c
View file

@ -439,7 +439,7 @@ static bool fq_packet_beyond_horizon(const struct sk_buff *skb,
return unlikely((s64)skb->tstamp > (s64)(q->ktime_cache + q->horizon)); return unlikely((s64)skb->tstamp > (s64)(q->ktime_cache + q->horizon));
} }
static int fq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int fq_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct fq_sched_data *q = qdisc_priv(sch); struct fq_sched_data *q = qdisc_priv(sch);

2
net/sched/sch_fq_codel.c
View file

@ -181,7 +181,7 @@ static unsigned int fq_codel_drop(struct Qdisc *sch, unsigned int max_packets,
return idx; return idx;
} }
static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct fq_codel_sched_data *q = qdisc_priv(sch); struct fq_codel_sched_data *q = qdisc_priv(sch);

2
net/sched/sch_fq_pie.c
View file

@ -125,7 +125,7 @@ static inline void flow_queue_add(struct fq_pie_flow *flow,
skb->next = NULL; skb->next = NULL;
} }
static int fq_pie_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int fq_pie_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct fq_pie_sched_data *q = qdisc_priv(sch); struct fq_pie_sched_data *q = qdisc_priv(sch);

4
net/sched/sch_generic.c
View file

@ -520,7 +520,7 @@ EXPORT_SYMBOL(netif_carrier_off);
cheaper. cheaper.
*/ */
static int noop_enqueue(struct sk_buff *skb, struct Qdisc *qdisc, spinlock_t *root_lock, static int noop_enqueue(struct sk_buff *skb, struct Qdisc *qdisc,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
__qdisc_drop(skb, to_free); __qdisc_drop(skb, to_free);
@ -614,7 +614,7 @@ static inline struct skb_array *band2list(struct pfifo_fast_priv *priv,
return &priv->q[band]; return &priv->q[band];
} }
static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc *qdisc, spinlock_t *root_lock, static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc *qdisc,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
int band = prio2band[skb->priority & TC_PRIO_MAX]; int band = prio2band[skb->priority & TC_PRIO_MAX];

2
net/sched/sch_gred.c
View file

@ -161,7 +161,7 @@ static bool gred_per_vq_red_flags_used(struct gred_sched *table)
return false; return false;
} }
static int gred_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int gred_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct gred_sched_data *q = NULL; struct gred_sched_data *q = NULL;

6
net/sched/sch_hfsc.c
View file

@ -1528,8 +1528,8 @@ hfsc_dump_qdisc(struct Qdisc *sch, struct sk_buff *skb)
return -1; return -1;
} }
static int hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int
struct sk_buff **to_free) hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb); unsigned int len = qdisc_pkt_len(skb);
struct hfsc_class *cl; struct hfsc_class *cl;
@ -1545,7 +1545,7 @@ static int hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root
} }
first = !cl->qdisc->q.qlen; first = !cl->qdisc->q.qlen;
err = qdisc_enqueue(skb, cl->qdisc, root_lock, to_free); err = qdisc_enqueue(skb, cl->qdisc, to_free);
if (unlikely(err != NET_XMIT_SUCCESS)) { if (unlikely(err != NET_XMIT_SUCCESS)) {
if (net_xmit_drop_count(err)) { if (net_xmit_drop_count(err)) {
cl->qstats.drops++; cl->qstats.drops++;

2
net/sched/sch_hhf.c
View file

@ -368,7 +368,7 @@ static unsigned int hhf_drop(struct Qdisc *sch, struct sk_buff **to_free)
return bucket - q->buckets; return bucket - q->buckets;
} }
static int hhf_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int hhf_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct hhf_sched_data *q = qdisc_priv(sch); struct hhf_sched_data *q = qdisc_priv(sch);

4
net/sched/sch_htb.c
View file

@ -576,7 +576,7 @@ static inline void htb_deactivate(struct htb_sched *q, struct htb_class *cl)
cl->prio_activity = 0; cl->prio_activity = 0;
} }
static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
int uninitialized_var(ret); int uninitialized_var(ret);
@ -599,7 +599,7 @@ static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
__qdisc_drop(skb, to_free); __qdisc_drop(skb, to_free);
return ret; return ret;
#endif #endif
} else if ((ret = qdisc_enqueue(skb, cl->leaf.q, root_lock, } else if ((ret = qdisc_enqueue(skb, cl->leaf.q,
to_free)) != NET_XMIT_SUCCESS) { to_free)) != NET_XMIT_SUCCESS) {
if (net_xmit_drop_count(ret)) { if (net_xmit_drop_count(ret)) {
qdisc_qstats_drop(sch); qdisc_qstats_drop(sch);

4
net/sched/sch_multiq.c
View file

@ -57,7 +57,7 @@ multiq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
} }
static int static int
multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct Qdisc *qdisc; struct Qdisc *qdisc;
@ -74,7 +74,7 @@ multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock,
} }
#endif #endif
ret = qdisc_enqueue(skb, qdisc, root_lock, to_free); ret = qdisc_enqueue(skb, qdisc, to_free);
if (ret == NET_XMIT_SUCCESS) { if (ret == NET_XMIT_SUCCESS) {
sch->q.qlen++; sch->q.qlen++;
return NET_XMIT_SUCCESS; return NET_XMIT_SUCCESS;

8
net/sched/sch_netem.c
View file

@ -431,7 +431,7 @@ static struct sk_buff *netem_segment(struct sk_buff *skb, struct Qdisc *sch,
* NET_XMIT_DROP: queue length didn't change. * NET_XMIT_DROP: queue length didn't change.
* NET_XMIT_SUCCESS: one skb was queued. * NET_XMIT_SUCCESS: one skb was queued.
*/ */
static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct netem_sched_data *q = qdisc_priv(sch); struct netem_sched_data *q = qdisc_priv(sch);
@ -480,7 +480,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *roo
u32 dupsave = q->duplicate; /* prevent duplicating a dup... */ u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
q->duplicate = 0; q->duplicate = 0;
rootq->enqueue(skb2, rootq, root_lock, to_free); rootq->enqueue(skb2, rootq, to_free);
q->duplicate = dupsave; q->duplicate = dupsave;
rc_drop = NET_XMIT_SUCCESS; rc_drop = NET_XMIT_SUCCESS;
} }
@ -604,7 +604,7 @@ finish_segs:
skb_mark_not_on_list(segs); skb_mark_not_on_list(segs);
qdisc_skb_cb(segs)->pkt_len = segs->len; qdisc_skb_cb(segs)->pkt_len = segs->len;
last_len = segs->len; last_len = segs->len;
rc = qdisc_enqueue(segs, sch, root_lock, to_free); rc = qdisc_enqueue(segs, sch, to_free);
if (rc != NET_XMIT_SUCCESS) { if (rc != NET_XMIT_SUCCESS) {
if (net_xmit_drop_count(rc)) if (net_xmit_drop_count(rc))
qdisc_qstats_drop(sch); qdisc_qstats_drop(sch);
@ -720,7 +720,7 @@ deliver:
struct sk_buff *to_free = NULL; struct sk_buff *to_free = NULL;
int err; int err;
err = qdisc_enqueue(skb, q->qdisc, NULL, &to_free); err = qdisc_enqueue(skb, q->qdisc, &to_free);
kfree_skb_list(to_free); kfree_skb_list(to_free);
if (err != NET_XMIT_SUCCESS && if (err != NET_XMIT_SUCCESS &&
net_xmit_drop_count(err)) { net_xmit_drop_count(err)) {

2
net/sched/sch_pie.c
View file

@ -82,7 +82,7 @@ bool pie_drop_early(struct Qdisc *sch, struct pie_params *params,
} }
EXPORT_SYMBOL_GPL(pie_drop_early); EXPORT_SYMBOL_GPL(pie_drop_early);
static int pie_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int pie_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct pie_sched_data *q = qdisc_priv(sch); struct pie_sched_data *q = qdisc_priv(sch);

2
net/sched/sch_plug.c
View file

@ -84,7 +84,7 @@ struct plug_sched_data {
u32 pkts_to_release; u32 pkts_to_release;
}; };
static int plug_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int plug_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct plug_sched_data *q = qdisc_priv(sch); struct plug_sched_data *q = qdisc_priv(sch);

6
net/sched/sch_prio.c
View file

@ -65,8 +65,8 @@ prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
return q->queues[band]; return q->queues[band];
} }
static int prio_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int
struct sk_buff **to_free) prio_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb); unsigned int len = qdisc_pkt_len(skb);
struct Qdisc *qdisc; struct Qdisc *qdisc;
@ -83,7 +83,7 @@ static int prio_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root
} }
#endif #endif
ret = qdisc_enqueue(skb, qdisc, root_lock, to_free); ret = qdisc_enqueue(skb, qdisc, to_free);
if (ret == NET_XMIT_SUCCESS) { if (ret == NET_XMIT_SUCCESS) {
sch->qstats.backlog += len; sch->qstats.backlog += len;
sch->q.qlen++; sch->q.qlen++;

4
net/sched/sch_qfq.c
View file

@ -1194,7 +1194,7 @@ static struct qfq_aggregate *qfq_choose_next_agg(struct qfq_sched *q)
return agg; return agg;
} }
static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
unsigned int len = qdisc_pkt_len(skb), gso_segs; unsigned int len = qdisc_pkt_len(skb), gso_segs;
@ -1225,7 +1225,7 @@ static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
gso_segs = skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1; gso_segs = skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1;
first = !cl->qdisc->q.qlen; first = !cl->qdisc->q.qlen;
err = qdisc_enqueue(skb, cl->qdisc, root_lock, to_free); err = qdisc_enqueue(skb, cl->qdisc, to_free);
if (unlikely(err != NET_XMIT_SUCCESS)) { if (unlikely(err != NET_XMIT_SUCCESS)) {
pr_debug("qfq_enqueue: enqueue failed %d\n", err); pr_debug("qfq_enqueue: enqueue failed %d\n", err);
if (net_xmit_drop_count(err)) { if (net_xmit_drop_count(err)) {

4
net/sched/sch_red.c
View file

@ -67,7 +67,7 @@ static int red_use_nodrop(struct red_sched_data *q)
return q->flags & TC_RED_NODROP; return q->flags & TC_RED_NODROP;
} }
static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct red_sched_data *q = qdisc_priv(sch); struct red_sched_data *q = qdisc_priv(sch);
@ -126,7 +126,7 @@ static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
break; break;
} }
ret = qdisc_enqueue(skb, child, root_lock, to_free); ret = qdisc_enqueue(skb, child, to_free);
if (likely(ret == NET_XMIT_SUCCESS)) { if (likely(ret == NET_XMIT_SUCCESS)) {
qdisc_qstats_backlog_inc(sch, skb); qdisc_qstats_backlog_inc(sch, skb);
sch->q.qlen++; sch->q.qlen++;

4
net/sched/sch_sfb.c
View file

@ -276,7 +276,7 @@ static bool sfb_classify(struct sk_buff *skb, struct tcf_proto *fl,
return false; return false;
} }
static int sfb_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int sfb_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
@ -399,7 +399,7 @@ static int sfb_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
} }
enqueue: enqueue:
ret = qdisc_enqueue(skb, child, root_lock, to_free); ret = qdisc_enqueue(skb, child, to_free);
if (likely(ret == NET_XMIT_SUCCESS)) { if (likely(ret == NET_XMIT_SUCCESS)) {
qdisc_qstats_backlog_inc(sch, skb); qdisc_qstats_backlog_inc(sch, skb);
sch->q.qlen++; sch->q.qlen++;

2
net/sched/sch_sfq.c
View file

@ -343,7 +343,7 @@ static int sfq_headdrop(const struct sfq_sched_data *q)
} }
static int static int
sfq_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, struct sk_buff **to_free) sfq_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free)
{ {
struct sfq_sched_data *q = qdisc_priv(sch); struct sfq_sched_data *q = qdisc_priv(sch);
unsigned int hash, dropped; unsigned int hash, dropped;

2
net/sched/sch_skbprio.c
View file

@ -65,7 +65,7 @@ static u16 calc_new_low_prio(const struct skbprio_sched_data *q)
return SKBPRIO_MAX_PRIORITY - 1; return SKBPRIO_MAX_PRIORITY - 1;
} }
static int skbprio_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int skbprio_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
const unsigned int max_priority = SKBPRIO_MAX_PRIORITY - 1; const unsigned int max_priority = SKBPRIO_MAX_PRIORITY - 1;

4
net/sched/sch_taprio.c
View file

@ -410,7 +410,7 @@ done:
return txtime; return txtime;
} }
static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct taprio_sched *q = qdisc_priv(sch); struct taprio_sched *q = qdisc_priv(sch);
@ -435,7 +435,7 @@ static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *ro
qdisc_qstats_backlog_inc(sch, skb); qdisc_qstats_backlog_inc(sch, skb);
sch->q.qlen++; sch->q.qlen++;
return qdisc_enqueue(skb, child, root_lock, to_free); return qdisc_enqueue(skb, child, to_free);
} }
static struct sk_buff *taprio_peek_soft(struct Qdisc *sch) static struct sk_buff *taprio_peek_soft(struct Qdisc *sch)

10
net/sched/sch_tbf.c
View file

@ -187,7 +187,7 @@ static int tbf_offload_dump(struct Qdisc *sch)
/* GSO packet is too big, segment it so that tbf can transmit /* GSO packet is too big, segment it so that tbf can transmit
* each segment in time * each segment in time
*/ */
static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct tbf_sched_data *q = qdisc_priv(sch); struct tbf_sched_data *q = qdisc_priv(sch);
@ -206,7 +206,7 @@ static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
skb_mark_not_on_list(segs); skb_mark_not_on_list(segs);
qdisc_skb_cb(segs)->pkt_len = segs->len; qdisc_skb_cb(segs)->pkt_len = segs->len;
len += segs->len; len += segs->len;
ret = qdisc_enqueue(segs, q->qdisc, root_lock, to_free); ret = qdisc_enqueue(segs, q->qdisc, to_free);
if (ret != NET_XMIT_SUCCESS) { if (ret != NET_XMIT_SUCCESS) {
if (net_xmit_drop_count(ret)) if (net_xmit_drop_count(ret))
qdisc_qstats_drop(sch); qdisc_qstats_drop(sch);
@ -221,7 +221,7 @@ static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
return nb > 0 ? NET_XMIT_SUCCESS : NET_XMIT_DROP; return nb > 0 ? NET_XMIT_SUCCESS : NET_XMIT_DROP;
} }
static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) struct sk_buff **to_free)
{ {
struct tbf_sched_data *q = qdisc_priv(sch); struct tbf_sched_data *q = qdisc_priv(sch);
@ -231,10 +231,10 @@ static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_
if (qdisc_pkt_len(skb) > q->max_size) { if (qdisc_pkt_len(skb) > q->max_size) {
if (skb_is_gso(skb) && if (skb_is_gso(skb) &&
skb_gso_validate_mac_len(skb, q->max_size)) skb_gso_validate_mac_len(skb, q->max_size))
return tbf_segment(skb, sch, root_lock, to_free); return tbf_segment(skb, sch, to_free);
return qdisc_drop(skb, sch, to_free); return qdisc_drop(skb, sch, to_free);
} }
ret = qdisc_enqueue(skb, q->qdisc, root_lock, to_free); ret = qdisc_enqueue(skb, q->qdisc, to_free);
if (ret != NET_XMIT_SUCCESS) { if (ret != NET_XMIT_SUCCESS) {
if (net_xmit_drop_count(ret)) if (net_xmit_drop_count(ret))
qdisc_qstats_drop(sch); qdisc_qstats_drop(sch);

4
net/sched/sch_teql.c
View file

@ -72,8 +72,8 @@ struct teql_sched_data {
/* "teql*" qdisc routines */ /* "teql*" qdisc routines */
static int teql_enqueue(struct sk_buff *skb, struct Qdisc *sch, spinlock_t *root_lock, static int
struct sk_buff **to_free) teql_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free)
{ {
struct net_device *dev = qdisc_dev(sch); struct net_device *dev = qdisc_dev(sch);
struct teql_sched_data *q = qdisc_priv(sch); struct teql_sched_data *q = qdisc_priv(sch);