string: factorize skip_spaces and export it to be generally available

[safe/jmp/linux-2.6] / net / sched / sch_netem.c

diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index 1aa4345..d8b10e0 100644 (file)
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -46,9 +46,6 @@
         layering other disciplines.  It does not need to do bandwidth
         control either since that can be handled by using token
         bucket or other rate control.
-
-        The simulator is limited by the Linux timer resolution
-        and will create packet bursts on the HZ boundary (1ms).
 */
 
 struct netem_sched_data {
@@ -202,9 +199,9 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         * 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))) {
+               if (!(skb = skb_unshare(skb, GFP_ATOMIC)) ||
+                   (skb->ip_summed == CHECKSUM_PARTIAL &&
+                    skb_checksum_help(skb))) {
                        sch->qstats.drops++;
                        return NET_XMIT_DROP;
                }
@@ -213,9 +210,9 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        }
 
        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)) {
+       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;
 
@@ -252,20 +249,6 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        return ret;
 }
 
-/* Requeue packets but don't change time stamp */
-static int netem_requeue(struct sk_buff *skb, struct Qdisc *sch)
-{
-       struct netem_sched_data *q = qdisc_priv(sch);
-       int ret;
-
-       if ((ret = q->qdisc->ops->requeue(skb, q->qdisc)) == 0) {
-               sch->q.qlen++;
-               sch->qstats.requeues++;
-       }
-
-       return ret;
-}
-
 static unsigned int netem_drop(struct Qdisc* sch)
 {
        struct netem_sched_data *q = qdisc_priv(sch);
@@ -283,7 +266,6 @@ static struct sk_buff *netem_dequeue(struct Qdisc *sch)
        struct netem_sched_data *q = qdisc_priv(sch);
        struct sk_buff *skb;
 
-       smp_mb();
        if (sch->flags & TCQ_F_THROTTLED)
                return NULL;
 
@@ -298,6 +280,14 @@ static struct sk_buff *netem_dequeue(struct Qdisc *sch)
                        if (unlikely(!skb))
                                return NULL;
 
+#ifdef CONFIG_NET_CLS_ACT
+                       /*
+                        * If it's at ingress let's pretend the delay is
+                        * from the network (tstamp will be updated).
+                        */
+                       if (G_TC_FROM(skb->tc_verd) & AT_INGRESS)
+                               skb->tstamp.tv64 = 0;
+#endif
                        pr_debug("netem_dequeue: return skb=%p\n", skb);
                        sch->q.qlen--;
                        return skb;
@@ -345,14 +335,13 @@ static int get_dist_table(struct Qdisc *sch, const struct nlattr *attr)
        root_lock = qdisc_root_sleeping_lock(sch);
 
        spin_lock_bh(root_lock);
-       d = xchg(&q->delay_dist, d);
+       kfree(q->delay_dist);
+       q->delay_dist = d;
        spin_unlock_bh(root_lock);
-
-       kfree(d);
        return 0;
 }
 
-static int get_correlation(struct Qdisc *sch, const struct nlattr *attr)
+static void get_correlation(struct Qdisc *sch, const struct nlattr *attr)
 {
        struct netem_sched_data *q = qdisc_priv(sch);
        const struct tc_netem_corr *c = nla_data(attr);
@@ -360,27 +349,24 @@ static int get_correlation(struct Qdisc *sch, const struct nlattr *attr)
        init_crandom(&q->delay_cor, c->delay_corr);
        init_crandom(&q->loss_cor, c->loss_corr);
        init_crandom(&q->dup_cor, c->dup_corr);
-       return 0;
 }
 
-static int get_reorder(struct Qdisc *sch, const struct nlattr *attr)
+static void get_reorder(struct Qdisc *sch, const struct nlattr *attr)
 {
        struct netem_sched_data *q = qdisc_priv(sch);
        const struct tc_netem_reorder *r = nla_data(attr);
 
        q->reorder = r->probability;
        init_crandom(&q->reorder_cor, r->correlation);
-       return 0;
 }
 
-static int get_corrupt(struct Qdisc *sch, const struct nlattr *attr)
+static void get_corrupt(struct Qdisc *sch, const struct nlattr *attr)
 {
        struct netem_sched_data *q = qdisc_priv(sch);
        const struct tc_netem_corrupt *r = nla_data(attr);
 
        q->corrupt = r->probability;
        init_crandom(&q->corrupt_cor, r->correlation);
-       return 0;
 }
 
 static const struct nla_policy netem_policy[TCA_NETEM_MAX + 1] = {
@@ -439,11 +425,8 @@ static int netem_change(struct Qdisc *sch, struct nlattr *opt)
        if (q->gap)
                q->reorder = ~0;
 
-       if (tb[TCA_NETEM_CORR]) {
-               ret = get_correlation(sch, tb[TCA_NETEM_CORR]);
-               if (ret)
-                       return ret;
-       }
+       if (tb[TCA_NETEM_CORR])
+               get_correlation(sch, tb[TCA_NETEM_CORR]);
 
        if (tb[TCA_NETEM_DELAY_DIST]) {
                ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST]);
@@ -451,17 +434,11 @@ static int netem_change(struct Qdisc *sch, struct nlattr *opt)
                        return ret;
        }
 
-       if (tb[TCA_NETEM_REORDER]) {
-               ret = get_reorder(sch, tb[TCA_NETEM_REORDER]);
-               if (ret)
-                       return ret;
-       }
+       if (tb[TCA_NETEM_REORDER])
+               get_reorder(sch, tb[TCA_NETEM_REORDER]);
 
-       if (tb[TCA_NETEM_CORRUPT]) {
-               ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT]);
-               if (ret)
-                       return ret;
-       }
+       if (tb[TCA_NETEM_CORRUPT])
+               get_corrupt(sch, tb[TCA_NETEM_CORRUPT]);
 
        return 0;
 }
@@ -543,7 +520,6 @@ static struct Qdisc_ops tfifo_qdisc_ops __read_mostly = {
        .enqueue        =       tfifo_enqueue,
        .dequeue        =       qdisc_dequeue_head,
        .peek           =       qdisc_peek_head,
-       .requeue        =       qdisc_requeue,
        .drop           =       qdisc_queue_drop,
        .init           =       tfifo_init,
        .reset          =       qdisc_reset_queue,
@@ -632,7 +608,6 @@ static struct Qdisc_ops netem_qdisc_ops __read_mostly = {
        .enqueue        =       netem_enqueue,
        .dequeue        =       netem_dequeue,
        .peek           =       qdisc_peek_dequeued,
-       .requeue        =       netem_requeue,
        .drop           =       netem_drop,
        .init           =       netem_init,
        .reset          =       netem_reset,