RPC/RDMA: maintain the RPC task bytes-sent statistic.

[safe/jmp/linux-2.6] / include / net / sch_generic.h

diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index f396dff..e556962 100644 (file)
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -27,6 +27,14 @@ enum qdisc_state_t
 {
        __QDISC_STATE_RUNNING,
        __QDISC_STATE_SCHED,
+       __QDISC_STATE_DEACTIVATED,
+};
+
+struct qdisc_size_table {
+       struct list_head        list;
+       struct tc_sizespec      szopts;
+       int                     refcnt;
+       u16                     data[];
 };
 
 struct Qdisc
@@ -39,6 +47,7 @@ struct Qdisc
 #define TCQ_F_INGRESS  4
        int                     padded;
        struct Qdisc_ops        *ops;
+       struct qdisc_size_table *stab;
        u32                     handle;
        u32                     parent;
        atomic_t                refcnt;
@@ -52,7 +61,6 @@ struct Qdisc
        struct gnet_stats_basic bstats;
        struct gnet_stats_queue qstats;
        struct gnet_stats_rate_est      rate_est;
-       struct rcu_head         q_rcu;
        int                     (*reshape_fail)(struct sk_buff *skb,
                                        struct Qdisc *q);
 
@@ -165,6 +173,16 @@ struct tcf_proto
        struct tcf_proto_ops    *ops;
 };
 
+struct qdisc_skb_cb {
+       unsigned int            pkt_len;
+       char                    data[];
+};
+
+static inline struct qdisc_skb_cb *qdisc_skb_cb(struct sk_buff *skb)
+{
+       return (struct qdisc_skb_cb *)skb->cb;
+}
+
 static inline spinlock_t *qdisc_lock(struct Qdisc *qdisc)
 {
        return &qdisc->q.lock;
@@ -175,10 +193,35 @@ static inline struct Qdisc *qdisc_root(struct Qdisc *qdisc)
        return qdisc->dev_queue->qdisc;
 }
 
+static inline struct Qdisc *qdisc_root_sleeping(struct Qdisc *qdisc)
+{
+       return qdisc->dev_queue->qdisc_sleeping;
+}
+
+/* The qdisc root lock is a mechanism by which to top level
+ * of a qdisc tree can be locked from any qdisc node in the
+ * forest.  This allows changing the configuration of some
+ * aspect of the qdisc tree while blocking out asynchronous
+ * qdisc access in the packet processing paths.
+ *
+ * It is only legal to do this when the root will not change
+ * on us.  Otherwise we'll potentially lock the wrong qdisc
+ * root.  This is enforced by holding the RTNL semaphore, which
+ * all users of this lock accessor must do.
+ */
 static inline spinlock_t *qdisc_root_lock(struct Qdisc *qdisc)
 {
        struct Qdisc *root = qdisc_root(qdisc);
 
+       ASSERT_RTNL();
+       return qdisc_lock(root);
+}
+
+static inline spinlock_t *qdisc_root_sleeping_lock(struct Qdisc *qdisc)
+{
+       struct Qdisc *root = qdisc_root_sleeping(qdisc);
+
+       ASSERT_RTNL();
        return qdisc_lock(root);
 }
 
@@ -189,12 +232,12 @@ static inline struct net_device *qdisc_dev(struct Qdisc *qdisc)
 
 static inline void sch_tree_lock(struct Qdisc *q)
 {
-       spin_lock_bh(qdisc_root_lock(q));
+       spin_lock_bh(qdisc_root_sleeping_lock(q));
 }
 
 static inline void sch_tree_unlock(struct Qdisc *q)
 {
-       spin_unlock_bh(qdisc_root_lock(q));
+       spin_unlock_bh(qdisc_root_sleeping_lock(q));
 }
 
 #define tcf_tree_lock(tp)      sch_tree_lock((tp)->q)
@@ -257,6 +300,8 @@ extern struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
 extern struct Qdisc *qdisc_create_dflt(struct net_device *dev,
                                       struct netdev_queue *dev_queue,
                                       struct Qdisc_ops *ops, u32 parentid);
+extern void qdisc_calculate_pkt_len(struct sk_buff *skb,
+                                  struct qdisc_size_table *stab);
 extern void tcf_destroy(struct tcf_proto *tp);
 extern void tcf_destroy_chain(struct tcf_proto **fl);
 
@@ -306,22 +351,44 @@ static inline bool qdisc_tx_is_noop(const struct net_device *dev)
        return true;
 }
 
+static inline unsigned int qdisc_pkt_len(struct sk_buff *skb)
+{
+       return qdisc_skb_cb(skb)->pkt_len;
+}
+
+/* additional qdisc xmit flags (NET_XMIT_MASK in linux/netdevice.h) */
+enum net_xmit_qdisc_t {
+       __NET_XMIT_STOLEN = 0x00010000,
+       __NET_XMIT_BYPASS = 0x00020000,
+};
+
+#ifdef CONFIG_NET_CLS_ACT
+#define net_xmit_drop_count(e) ((e) & __NET_XMIT_STOLEN ? 0 : 1)
+#else
+#define net_xmit_drop_count(e) (1)
+#endif
+
 static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
+#ifdef CONFIG_NET_SCHED
+       if (sch->stab)
+               qdisc_calculate_pkt_len(skb, sch->stab);
+#endif
        return sch->enqueue(skb, sch);
 }
 
 static inline int qdisc_enqueue_root(struct sk_buff *skb, struct Qdisc *sch)
 {
-       return qdisc_enqueue(skb, sch);
+       qdisc_skb_cb(skb)->pkt_len = skb->len;
+       return qdisc_enqueue(skb, sch) & NET_XMIT_MASK;
 }
 
 static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
                                       struct sk_buff_head *list)
 {
        __skb_queue_tail(list, skb);
-       sch->qstats.backlog += skb->len;
-       sch->bstats.bytes += skb->len;
+       sch->qstats.backlog += qdisc_pkt_len(skb);
+       sch->bstats.bytes += qdisc_pkt_len(skb);
        sch->bstats.packets++;
 
        return NET_XMIT_SUCCESS;
@@ -338,7 +405,7 @@ static inline struct sk_buff *__qdisc_dequeue_head(struct Qdisc *sch,
        struct sk_buff *skb = __skb_dequeue(list);
 
        if (likely(skb != NULL))
-               sch->qstats.backlog -= skb->len;
+               sch->qstats.backlog -= qdisc_pkt_len(skb);
 
        return skb;
 }
@@ -354,7 +421,7 @@ static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,
        struct sk_buff *skb = __skb_dequeue_tail(list);
 
        if (likely(skb != NULL))
-               sch->qstats.backlog -= skb->len;
+               sch->qstats.backlog -= qdisc_pkt_len(skb);
 
        return skb;
 }
@@ -368,7 +435,7 @@ static inline int __qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch,
                                  struct sk_buff_head *list)
 {
        __skb_queue_head(list, skb);
-       sch->qstats.backlog += skb->len;
+       sch->qstats.backlog += qdisc_pkt_len(skb);
        sch->qstats.requeues++;
 
        return NET_XMIT_SUCCESS;
@@ -401,7 +468,7 @@ static inline unsigned int __qdisc_queue_drop(struct Qdisc *sch,
        struct sk_buff *skb = __qdisc_dequeue_tail(sch, list);
 
        if (likely(skb != NULL)) {
-               unsigned int len = skb->len;
+               unsigned int len = qdisc_pkt_len(skb);
                kfree_skb(skb);
                return len;
        }