9 files changed, 230 insertions, 62 deletions

diff --git a/net/sched/Kconfig b/net/sched/Kconfig
index 3d1d902dd1a1..b0941186f867 100644
--- a/net/sched/Kconfig
+++ b/net/sched/Kconfig
@@ -185,7 +185,7 @@ config NET_SCH_GRED
         depends on NET_SCHED
         help
           Say Y here if you want to use the Generic Random Early Detection
-          (RED) packet scheduling algorithm for some of your network devices
+          (GRED) packet scheduling algorithm for some of your network devices
           (see the top of <file:net/sched/sch_red.c> for details and
           references about the algorithm).
 
@@ -506,3 +506,13 @@ config NET_CLS_POLICE
           Say Y to support traffic policing (bandwidth limits).  Needed for
           ingress and egress rate limiting.
 
+config NET_ACT_SIMP
+        tristate "Simple action"
+        depends on NET_CLS_ACT
+        ---help---
+        You must have new iproute2 to use this feature.
+        This adds a very simple action for demonstration purposes
+        The idea is to give action authors a basic example to look at.
+        All this action will do is print on the console the configured
+        policy string followed by _ then packet count.
+
diff --git a/net/sched/Makefile b/net/sched/Makefile
index 431e55786efd..eb3fe583eba8 100644
--- a/net/sched/Makefile
+++ b/net/sched/Makefile
@@ -6,13 +6,14 @@ obj-y	:= sch_generic.o
 
 obj-$(CONFIG_NET_SCHED)         += sch_api.o sch_fifo.o
 obj-$(CONFIG_NET_CLS)           += cls_api.o
-obj-$(CONFIG_NET_CLS_ACT)       += act_api.o
+obj-$(CONFIG_NET_CLS_ACT)       += act_api.o
 obj-$(CONFIG_NET_ACT_POLICE)    += police.o
 obj-$(CONFIG_NET_CLS_POLICE)    += police.o
-obj-$(CONFIG_NET_ACT_GACT)      += gact.o
-obj-$(CONFIG_NET_ACT_MIRRED)    += mirred.o
-obj-$(CONFIG_NET_ACT_IPT)       += ipt.o
-obj-$(CONFIG_NET_ACT_PEDIT)     += pedit.o
+obj-$(CONFIG_NET_ACT_GACT)      += gact.o
+obj-$(CONFIG_NET_ACT_MIRRED)    += mirred.o
+obj-$(CONFIG_NET_ACT_IPT)       += ipt.o
+obj-$(CONFIG_NET_ACT_PEDIT)     += pedit.o
+obj-$(CONFIG_NET_ACT_SIMP)      += simple.o
 obj-$(CONFIG_NET_SCH_CBQ)       += sch_cbq.o
 obj-$(CONFIG_NET_SCH_HTB)       += sch_htb.o
 obj-$(CONFIG_NET_SCH_HPFQ)      += sch_hpfq.o
diff --git a/net/sched/act_api.c b/net/sched/act_api.c
index 5e6cc371b39e..cafcb084098d 100644
--- a/net/sched/act_api.c
+++ b/net/sched/act_api.c
@@ -171,10 +171,10 @@ repeat:
                                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
                                 skb->tc_verd = CLR_TC_MUNGED(skb->tc_verd);
                         }
-                        if (ret != TC_ACT_PIPE)
-                                goto exec_done;
                         if (ret == TC_ACT_REPEAT)
                                 goto repeat;    /* we need a ttl - JHS */
+                        if (ret != TC_ACT_PIPE)
+                                goto exec_done;
                 }
                 act = a->next;
         }
diff --git a/net/sched/cls_fw.c b/net/sched/cls_fw.c
index fdfc83af3d1f..29d8b9a4d162 100644
--- a/net/sched/cls_fw.c
+++ b/net/sched/cls_fw.c
@@ -46,9 +46,11 @@
 #include <net/act_api.h>
 #include <net/pkt_cls.h>
 
+#define HTSIZE (PAGE_SIZE/sizeof(struct fw_filter *))
+
 struct fw_head
 {
-        struct fw_filter *ht[256];
+        struct fw_filter *ht[HTSIZE];
 };
 
 struct fw_filter
@@ -69,7 +71,28 @@ static struct tcf_ext_map fw_ext_map = {
 
 static __inline__ int fw_hash(u32 handle)
 {
-        return handle&0xFF;
+        if (HTSIZE == 4096)
+                return ((handle >> 24) & 0xFFF) ^
+                       ((handle >> 12) & 0xFFF) ^
+                       (handle & 0xFFF);
+        else if (HTSIZE == 2048)
+                return ((handle >> 22) & 0x7FF) ^
+                       ((handle >> 11) & 0x7FF) ^
+                       (handle & 0x7FF);
+        else if (HTSIZE == 1024)
+                return ((handle >> 20) & 0x3FF) ^
+                       ((handle >> 10) & 0x3FF) ^
+                       (handle & 0x3FF);
+        else if (HTSIZE == 512)
+                return (handle >> 27) ^
+                       ((handle >> 18) & 0x1FF) ^
+                       ((handle >> 9) & 0x1FF) ^
+                       (handle & 0x1FF);
+        else if (HTSIZE == 256) {
+                u8 *t = (u8 *) &handle;
+                return t[0] ^ t[1] ^ t[2] ^ t[3];
+        } else 
+                return handle & (HTSIZE - 1);
 }
 
 static int fw_classify(struct sk_buff *skb, struct tcf_proto *tp,
@@ -152,7 +175,7 @@ static void fw_destroy(struct tcf_proto *tp)
         if (head == NULL)
                 return;
 
-        for (h=0; h<256; h++) {
+        for (h=0; h<HTSIZE; h++) {
                 while ((f=head->ht[h]) != NULL) {
                         head->ht[h] = f->next;
                         fw_delete_filter(tp, f);
@@ -291,7 +314,7 @@ static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg)
         if (arg->stop)
                 return;
 
-        for (h = 0; h < 256; h++) {
+        for (h = 0; h < HTSIZE; h++) {
                 struct fw_filter *f;
 
                 for (f = head->ht[h]; f; f = f->next) {
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 4323a74eea30..07977f8f2679 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -1289,6 +1289,7 @@ static int __init pktsched_init(void)
 
 subsys_initcall(pktsched_init);
 
+EXPORT_SYMBOL(qdisc_lookup);
 EXPORT_SYMBOL(qdisc_get_rtab);
 EXPORT_SYMBOL(qdisc_put_rtab);
 EXPORT_SYMBOL(register_qdisc);
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 8c01e023f02e..87e48a4e1051 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -179,6 +179,7 @@ requeue:
                 netif_schedule(dev);
                 return 1;
         }
+        BUG_ON((int) q->q.qlen < 0);
         return q->q.qlen;
 }
 
@@ -539,6 +540,10 @@ void dev_activate(struct net_device *dev)
                 write_unlock_bh(&qdisc_tree_lock);
         }
 
+        if (!netif_carrier_ok(dev))
+                /* Delay activation until next carrier-on event */
+                return;
+
         spin_lock_bh(&dev->queue_lock);
         rcu_assign_pointer(dev->qdisc, dev->qdisc_sleeping);
         if (dev->qdisc != &noqueue_qdisc) {
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index a85935e7d53d..558cc087e602 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -717,6 +717,10 @@ static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         if (q->direct_queue.qlen < q->direct_qlen) {
             __skb_queue_tail(&q->direct_queue, skb);
             q->direct_pkts++;
+        } else {
+            kfree_skb(skb);
+            sch->qstats.drops++;
+            return NET_XMIT_DROP;
         }
 #ifdef CONFIG_NET_CLS_ACT
     } else if (!cl) {
diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index 31c29deb139d..e0c9fbe73b15 100644
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -138,38 +138,77 @@ static long tabledist(unsigned long mu, long sigma,
 }
 
 /* Put skb in the private delayed queue. */
-static int delay_skb(struct Qdisc *sch, struct sk_buff *skb)
+static int netem_delay(struct Qdisc *sch, struct sk_buff *skb)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
-        struct netem_skb_cb *cb = (struct netem_skb_cb *)skb->cb;
         psched_tdiff_t td;
         psched_time_t now;
         
         PSCHED_GET_TIME(now);
         td = tabledist(q->latency, q->jitter, &q->delay_cor, q->delay_dist);
-        PSCHED_TADD2(now, td, cb->time_to_send);
         
         /* Always queue at tail to keep packets in order */
         if (likely(q->delayed.qlen < q->limit)) {
+                struct netem_skb_cb *cb = (struct netem_skb_cb *)skb->cb;
+        
+                PSCHED_TADD2(now, td, cb->time_to_send);
+
+                pr_debug("netem_delay: skb=%p now=%llu tosend=%llu\n", skb, 
+                         now, cb->time_to_send);
+        
                 __skb_queue_tail(&q->delayed, skb);
-                if (!timer_pending(&q->timer)) {
-                        q->timer.expires = jiffies + PSCHED_US2JIFFIE(td);
-                        add_timer(&q->timer);
-                }
                 return NET_XMIT_SUCCESS;
         }
 
+        pr_debug("netem_delay: queue over limit %d\n", q->limit);
+        sch->qstats.overlimits++;
         kfree_skb(skb);
         return NET_XMIT_DROP;
 }
 
+/*
+ *  Move a packet that is ready to send from the delay holding
+ *  list to the underlying qdisc.
+ */
+static int netem_run(struct Qdisc *sch)
+{
+        struct netem_sched_data *q = qdisc_priv(sch);
+        struct sk_buff *skb;
+        psched_time_t now;
+
+        PSCHED_GET_TIME(now);
+
+        skb = skb_peek(&q->delayed);
+        if (skb) {
+                const struct netem_skb_cb *cb
+                        = (const struct netem_skb_cb *)skb->cb;
+                long delay 
+                        = PSCHED_US2JIFFIE(PSCHED_TDIFF(cb->time_to_send, now));
+                pr_debug("netem_run: skb=%p delay=%ld\n", skb, delay);
+
+                /* if more time remaining? */
+                if (delay > 0) {
+                        mod_timer(&q->timer, jiffies + delay);
+                        return 1;
+                }
+
+                __skb_unlink(skb, &q->delayed);
+                
+                if (q->qdisc->enqueue(skb, q->qdisc)) {
+                        sch->q.qlen--;
+                        sch->qstats.drops++;
+                } 
+        }
+
+        return 0;
+}
+
 static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
-        struct sk_buff *skb2;
         int ret;
 
-        pr_debug("netem_enqueue skb=%p @%lu\n", skb, jiffies);
+        pr_debug("netem_enqueue skb=%p\n", skb);
 
         /* Random packet drop 0 => none, ~0 => all */
         if (q->loss && q->loss >= get_crandom(&q->loss_cor)) {
@@ -180,11 +219,21 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         }
 
         /* Random duplication */
-        if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor)
-            && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
-                pr_debug("netem_enqueue: dup %p\n", skb2);
+        if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor)) {
+                struct sk_buff *skb2;
+
+                skb2 = skb_clone(skb, GFP_ATOMIC);
+                if (skb2 && netem_delay(sch, skb2) == NET_XMIT_SUCCESS) {
+                        struct Qdisc *qp;
+
+                        /* Since one packet can generate two packets in the
+                         * queue, the parent's qlen accounting gets confused,
+                         * so fix it.
+                         */
+                        qp = qdisc_lookup(sch->dev, TC_H_MAJ(sch->parent));
+                        if (qp)
+                                qp->q.qlen++;
 
-                if (delay_skb(sch, skb2)) {
                         sch->q.qlen++;
                         sch->bstats.bytes += skb2->len;
                         sch->bstats.packets++;
@@ -202,7 +251,8 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                 ret = q->qdisc->enqueue(skb, q->qdisc);
         } else {
                 q->counter = 0;
-                ret = delay_skb(sch, skb);
+                ret = netem_delay(sch, skb);
+                netem_run(sch);
         }
 
         if (likely(ret == NET_XMIT_SUCCESS)) {
@@ -212,6 +262,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         } else
                 sch->qstats.drops++;
 
+        pr_debug("netem: enqueue ret %d\n", ret);
         return ret;
 }
 
@@ -241,56 +292,35 @@ static unsigned int netem_drop(struct Qdisc* sch)
         return len;
 }
 
-/* Dequeue packet.
- *  Move all packets that are ready to send from the delay holding
- *  list to the underlying qdisc, then just call dequeue
- */
 static struct sk_buff *netem_dequeue(struct Qdisc *sch)
 {
         struct netem_sched_data *q = qdisc_priv(sch);
         struct sk_buff *skb;
+        int pending;
+
+        pending = netem_run(sch);
 
         skb = q->qdisc->dequeue(q->qdisc);
-        if (skb) 
+        if (skb) {
+                pr_debug("netem_dequeue: return skb=%p\n", skb);
                 sch->q.qlen--;
+                sch->flags &= ~TCQ_F_THROTTLED;
+        }
+        else if (pending) {
+                pr_debug("netem_dequeue: throttling\n");
+                sch->flags |= TCQ_F_THROTTLED;
+        } 
+
         return skb;
 }
 
 static void netem_watchdog(unsigned long arg)
 {
         struct Qdisc *sch = (struct Qdisc *)arg;
-        struct netem_sched_data *q = qdisc_priv(sch);
-        struct net_device *dev = sch->dev;
-        struct sk_buff *skb;
-        psched_time_t now;
-
-        pr_debug("netem_watchdog: fired @%lu\n", jiffies);
-
-        spin_lock_bh(&dev->queue_lock);
-        PSCHED_GET_TIME(now);
-
-        while ((skb = skb_peek(&q->delayed)) != NULL) {
-                const struct netem_skb_cb *cb
-                        = (const struct netem_skb_cb *)skb->cb;
-                long delay 
-                        = PSCHED_US2JIFFIE(PSCHED_TDIFF(cb->time_to_send, now));
-                pr_debug("netem_watchdog: skb %p@%lu %ld\n",
-                         skb, jiffies, delay);
 
-                /* if more time remaining? */
-                if (delay > 0) {
-                        mod_timer(&q->timer, jiffies + delay);
-                        break;
-                }
-                __skb_unlink(skb, &q->delayed);
-
-                if (q->qdisc->enqueue(skb, q->qdisc)) {
-                        sch->q.qlen--;
-                        sch->qstats.drops++;
-                }
-        }
-        qdisc_run(dev);
-        spin_unlock_bh(&dev->queue_lock);
+        pr_debug("netem_watchdog qlen=%d\n", sch->q.qlen);
+        sch->flags &= ~TCQ_F_THROTTLED;
+        netif_schedule(sch->dev);
 }
 
 static void netem_reset(struct Qdisc *sch)
@@ -301,6 +331,7 @@ static void netem_reset(struct Qdisc *sch)
         skb_queue_purge(&q->delayed);
 
         sch->q.qlen = 0;
+        sch->flags &= ~TCQ_F_THROTTLED;
         del_timer_sync(&q->timer);
 }
 
diff --git a/net/sched/simple.c b/net/sched/simple.c
new file mode 100644
index 000000000000..3ab4c675ab5d
--- /dev/null
+++ b/net/sched/simple.c
@@ -0,0 +1,93 @@
+/*
+ * net/sched/simp.c     Simple example of an action
+ *
+ *              This program is free software; you can redistribute it and/or
+ *              modify it under the terms of the GNU General Public License
+ *              as published by the Free Software Foundation; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ * Authors:     Jamal Hadi Salim (2005)
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+#include <linux/rtnetlink.h>
+#include <net/pkt_sched.h>
+
+#define TCA_ACT_SIMP 22
+
+/* XXX: Hide all these common elements under some macro 
+ * probably
+*/
+#include <linux/tc_act/tc_defact.h>
+#include <net/tc_act/tc_defact.h>
+
+/* use generic hash table with 8 buckets */
+#define MY_TAB_SIZE     8
+#define MY_TAB_MASK     (MY_TAB_SIZE - 1)
+static u32 idx_gen;
+static struct tcf_defact *tcf_simp_ht[MY_TAB_SIZE];
+static DEFINE_RWLOCK(simp_lock);
+
+/* override the defaults */
+#define tcf_st          tcf_defact
+#define tc_st           tc_defact
+#define tcf_t_lock      simp_lock
+#define tcf_ht          tcf_simp_ht
+
+#define CONFIG_NET_ACT_INIT 1
+#include <net/pkt_act.h>
+#include <net/act_generic.h>
+
+static int tcf_simp(struct sk_buff **pskb, struct tc_action *a)
+{
+        struct sk_buff *skb = *pskb;
+        struct tcf_defact *p = PRIV(a, defact);
+
+        spin_lock(&p->lock);
+        p->tm.lastuse = jiffies;
+        p->bstats.bytes += skb->len;
+        p->bstats.packets++;
+
+        /* print policy string followed by _ then packet count 
+         * Example if this was the 3rd packet and the string was "hello" 
+         * then it would look like "hello_3" (without quotes) 
+         **/
+        printk("simple: %s_%d\n", (char *)p->defdata, p->bstats.packets);
+        spin_unlock(&p->lock);
+        return p->action;
+}
+
+static struct tc_action_ops act_simp_ops = {
+        .kind = "simple",
+        .type = TCA_ACT_SIMP,
+        .capab = TCA_CAP_NONE,
+        .owner = THIS_MODULE,
+        .act = tcf_simp,
+        tca_use_default_ops
+};
+
+MODULE_AUTHOR("Jamal Hadi Salim(2005)");
+MODULE_DESCRIPTION("Simple example action");
+MODULE_LICENSE("GPL");
+
+static int __init simp_init_module(void)
+{
+        int ret = tcf_register_action(&act_simp_ops);
+        if (!ret)
+                printk("Simple TC action Loaded\n");
+        return ret;
+}
+
+static void __exit simp_cleanup_module(void)
+{
+        tcf_unregister_action(&act_simp_ops);
+}
+
+module_init(simp_init_module);
+module_exit(simp_cleanup_module);