SAFE public projects git trees. - safe/jmp/linux-2.6/blob - include/net/sch_generic.h

   1 #ifndef __NET_SCHED_GENERIC_H
   2 #define __NET_SCHED_GENERIC_H
   3
   4 #include <linux/netdevice.h>
   5 #include <linux/types.h>
   6 #include <linux/rcupdate.h>
   7 #include <linux/module.h>
   8 #include <linux/pkt_sched.h>
   9 #include <linux/pkt_cls.h>
  10 #include <net/gen_stats.h>
  11 #include <net/rtnetlink.h>
  12
  13 struct Qdisc_ops;
  14 struct qdisc_walker;
  15 struct tcf_walker;
  16 struct module;
  17
  18 struct qdisc_rate_table
  19 {
  20         struct tc_ratespec rate;
  21         u32             data[256];
  22         struct qdisc_rate_table *next;
  23         int             refcnt;
  24 };
  25
  26 enum qdisc_state_t
  27 {
  28         __QDISC_STATE_RUNNING,
  29         __QDISC_STATE_SCHED,
  30 };
  31
  32 struct Qdisc
  33 {
  34         int                     (*enqueue)(struct sk_buff *skb, struct Qdisc *dev);
  35         struct sk_buff *        (*dequeue)(struct Qdisc *dev);
  36         unsigned                flags;
  37 #define TCQ_F_BUILTIN   1
  38 #define TCQ_F_THROTTLED 2
  39 #define TCQ_F_INGRESS   4
  40         int                     padded;
  41         struct Qdisc_ops        *ops;
  42         u32                     handle;
  43         u32                     parent;
  44         atomic_t                refcnt;
  45         unsigned long           state;
  46         struct sk_buff          *gso_skb;
  47         struct sk_buff_head     q;
  48         struct netdev_queue     *dev_queue;
  49         struct Qdisc            *next_sched;
  50         struct list_head        list;
  51
  52         struct gnet_stats_basic bstats;
  53         struct gnet_stats_queue qstats;
  54         struct gnet_stats_rate_est      rate_est;
  55         struct rcu_head         q_rcu;
  56         int                     (*reshape_fail)(struct sk_buff *skb,
  57                                         struct Qdisc *q);
  58
  59         void                    *u32_node;
  60
  61         /* This field is deprecated, but it is still used by CBQ
  62          * and it will live until better solution will be invented.
  63          */
  64         struct Qdisc            *__parent;
  65 };
  66
  67 struct Qdisc_class_ops
  68 {
  69         /* Child qdisc manipulation */
  70         int                     (*graft)(struct Qdisc *, unsigned long cl,
  71                                         struct Qdisc *, struct Qdisc **);
  72         struct Qdisc *          (*leaf)(struct Qdisc *, unsigned long cl);
  73         void                    (*qlen_notify)(struct Qdisc *, unsigned long);
  74
  75         /* Class manipulation routines */
  76         unsigned long           (*get)(struct Qdisc *, u32 classid);
  77         void                    (*put)(struct Qdisc *, unsigned long);
  78         int                     (*change)(struct Qdisc *, u32, u32,
  79                                         struct nlattr **, unsigned long *);
  80         int                     (*delete)(struct Qdisc *, unsigned long);
  81         void                    (*walk)(struct Qdisc *, struct qdisc_walker * arg);
  82
  83         /* Filter manipulation */
  84         struct tcf_proto **     (*tcf_chain)(struct Qdisc *, unsigned long);
  85         unsigned long           (*bind_tcf)(struct Qdisc *, unsigned long,
  86                                         u32 classid);
  87         void                    (*unbind_tcf)(struct Qdisc *, unsigned long);
  88
  89         /* rtnetlink specific */
  90         int                     (*dump)(struct Qdisc *, unsigned long,
  91                                         struct sk_buff *skb, struct tcmsg*);
  92         int                     (*dump_stats)(struct Qdisc *, unsigned long,
  93                                         struct gnet_dump *);
  94 };
  95
  96 struct Qdisc_ops
  97 {
  98         struct Qdisc_ops        *next;
  99         const struct Qdisc_class_ops    *cl_ops;
 100         char                    id[IFNAMSIZ];
 101         int                     priv_size;
 102
 103         int                     (*enqueue)(struct sk_buff *, struct Qdisc *);
 104         struct sk_buff *        (*dequeue)(struct Qdisc *);
 105         int                     (*requeue)(struct sk_buff *, struct Qdisc *);
 106         unsigned int            (*drop)(struct Qdisc *);
 107
 108         int                     (*init)(struct Qdisc *, struct nlattr *arg);
 109         void                    (*reset)(struct Qdisc *);
 110         void                    (*destroy)(struct Qdisc *);
 111         int                     (*change)(struct Qdisc *, struct nlattr *arg);
 112
 113         int                     (*dump)(struct Qdisc *, struct sk_buff *);
 114         int                     (*dump_stats)(struct Qdisc *, struct gnet_dump *);
 115
 116         struct module           *owner;
 117 };
 118
 119
 120 struct tcf_result
 121 {
 122         unsigned long   class;
 123         u32             classid;
 124 };
 125
 126 struct tcf_proto_ops
 127 {
 128         struct tcf_proto_ops    *next;
 129         char                    kind[IFNAMSIZ];
 130
 131         int                     (*classify)(struct sk_buff*, struct tcf_proto*,
 132                                         struct tcf_result *);
 133         int                     (*init)(struct tcf_proto*);
 134         void                    (*destroy)(struct tcf_proto*);
 135
 136         unsigned long           (*get)(struct tcf_proto*, u32 handle);
 137         void                    (*put)(struct tcf_proto*, unsigned long);
 138         int                     (*change)(struct tcf_proto*, unsigned long,
 139                                         u32 handle, struct nlattr **,
 140                                         unsigned long *);
 141         int                     (*delete)(struct tcf_proto*, unsigned long);
 142         void                    (*walk)(struct tcf_proto*, struct tcf_walker *arg);
 143
 144         /* rtnetlink specific */
 145         int                     (*dump)(struct tcf_proto*, unsigned long,
 146                                         struct sk_buff *skb, struct tcmsg*);
 147
 148         struct module           *owner;
 149 };
 150
 151 struct tcf_proto
 152 {
 153         /* Fast access part */
 154         struct tcf_proto        *next;
 155         void                    *root;
 156         int                     (*classify)(struct sk_buff*, struct tcf_proto*,
 157                                         struct tcf_result *);
 158         __be16                  protocol;
 159
 160         /* All the rest */
 161         u32                     prio;
 162         u32                     classid;
 163         struct Qdisc            *q;
 164         void                    *data;
 165         struct tcf_proto_ops    *ops;
 166 };
 167
 168 static inline spinlock_t *qdisc_lock(struct Qdisc *qdisc)
 169 {
 170         return &qdisc->q.lock;
 171 }
 172
 173 static inline struct Qdisc *qdisc_root(struct Qdisc *qdisc)
 174 {
 175         return qdisc->dev_queue->qdisc;
 176 }
 177
 178 static inline spinlock_t *qdisc_root_lock(struct Qdisc *qdisc)
 179 {
 180         struct Qdisc *root = qdisc_root(qdisc);
 181
 182         return qdisc_lock(root);
 183 }
 184
 185 static inline struct net_device *qdisc_dev(struct Qdisc *qdisc)
 186 {
 187         return qdisc->dev_queue->dev;
 188 }
 189
 190 static inline void sch_tree_lock(struct Qdisc *q)
 191 {
 192         spin_lock_bh(qdisc_root_lock(q));
 193 }
 194
 195 static inline void sch_tree_unlock(struct Qdisc *q)
 196 {
 197         spin_unlock_bh(qdisc_root_lock(q));
 198 }
 199
 200 #define tcf_tree_lock(tp)       sch_tree_lock((tp)->q)
 201 #define tcf_tree_unlock(tp)     sch_tree_unlock((tp)->q)
 202
 203 extern struct Qdisc noop_qdisc;
 204 extern struct Qdisc_ops noop_qdisc_ops;
 205
 206 struct Qdisc_class_common
 207 {
 208         u32                     classid;
 209         struct hlist_node       hnode;
 210 };
 211
 212 struct Qdisc_class_hash
 213 {
 214         struct hlist_head       *hash;
 215         unsigned int            hashsize;
 216         unsigned int            hashmask;
 217         unsigned int            hashelems;
 218 };
 219
 220 static inline unsigned int qdisc_class_hash(u32 id, u32 mask)
 221 {
 222         id ^= id >> 8;
 223         id ^= id >> 4;
 224         return id & mask;
 225 }
 226
 227 static inline struct Qdisc_class_common *
 228 qdisc_class_find(struct Qdisc_class_hash *hash, u32 id)
 229 {
 230         struct Qdisc_class_common *cl;
 231         struct hlist_node *n;
 232         unsigned int h;
 233
 234         h = qdisc_class_hash(id, hash->hashmask);
 235         hlist_for_each_entry(cl, n, &hash->hash[h], hnode) {
 236                 if (cl->classid == id)
 237                         return cl;
 238         }
 239         return NULL;
 240 }
 241
 242 extern int qdisc_class_hash_init(struct Qdisc_class_hash *);
 243 extern void qdisc_class_hash_insert(struct Qdisc_class_hash *, struct Qdisc_class_common *);
 244 extern void qdisc_class_hash_remove(struct Qdisc_class_hash *, struct Qdisc_class_common *);
 245 extern void qdisc_class_hash_grow(struct Qdisc *, struct Qdisc_class_hash *);
 246 extern void qdisc_class_hash_destroy(struct Qdisc_class_hash *);
 247
 248 extern void dev_init_scheduler(struct net_device *dev);
 249 extern void dev_shutdown(struct net_device *dev);
 250 extern void dev_activate(struct net_device *dev);
 251 extern void dev_deactivate(struct net_device *dev);
 252 extern void qdisc_reset(struct Qdisc *qdisc);
 253 extern void qdisc_destroy(struct Qdisc *qdisc);
 254 extern void qdisc_tree_decrease_qlen(struct Qdisc *qdisc, unsigned int n);
 255 extern struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
 256                                  struct Qdisc_ops *ops);
 257 extern struct Qdisc *qdisc_create_dflt(struct net_device *dev,
 258                                        struct netdev_queue *dev_queue,
 259                                        struct Qdisc_ops *ops, u32 parentid);
 260 extern void tcf_destroy(struct tcf_proto *tp);
 261 extern void tcf_destroy_chain(struct tcf_proto **fl);
 262
 263 /* Reset all TX qdiscs of a device.  */
 264 static inline void qdisc_reset_all_tx(struct net_device *dev)
 265 {
 266         unsigned int i;
 267         for (i = 0; i < dev->num_tx_queues; i++)
 268                 qdisc_reset(netdev_get_tx_queue(dev, i)->qdisc);
 269 }
 270
 271 /* Are all TX queues of the device empty?  */
 272 static inline bool qdisc_all_tx_empty(const struct net_device *dev)
 273 {
 274         unsigned int i;
 275         for (i = 0; i < dev->num_tx_queues; i++) {
 276                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 277                 const struct Qdisc *q = txq->qdisc;
 278
 279                 if (q->q.qlen)
 280                         return false;
 281         }
 282         return true;
 283 }
 284
 285 /* Are any of the TX qdiscs changing?  */
 286 static inline bool qdisc_tx_changing(struct net_device *dev)
 287 {
 288         unsigned int i;
 289         for (i = 0; i < dev->num_tx_queues; i++) {
 290                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 291                 if (txq->qdisc != txq->qdisc_sleeping)
 292                         return true;
 293         }
 294         return false;
 295 }
 296
 297 /* Is the device using the noop qdisc on all queues?  */
 298 static inline bool qdisc_tx_is_noop(const struct net_device *dev)
 299 {
 300         unsigned int i;
 301         for (i = 0; i < dev->num_tx_queues; i++) {
 302                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 303                 if (txq->qdisc != &noop_qdisc)
 304                         return false;
 305         }
 306         return true;
 307 }
 308
 309 static inline unsigned int qdisc_pkt_len(struct sk_buff *skb)
 310 {
 311         return skb->len;
 312 }
 313
 314 static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 315 {
 316         return sch->enqueue(skb, sch);
 317 }
 318
 319 static inline int qdisc_enqueue_root(struct sk_buff *skb, struct Qdisc *sch)
 320 {
 321         return qdisc_enqueue(skb, sch);
 322 }
 323
 324 static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
 325                                        struct sk_buff_head *list)
 326 {
 327         __skb_queue_tail(list, skb);
 328         sch->qstats.backlog += qdisc_pkt_len(skb);
 329         sch->bstats.bytes += qdisc_pkt_len(skb);
 330         sch->bstats.packets++;
 331
 332         return NET_XMIT_SUCCESS;
 333 }
 334
 335 static inline int qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch)
 336 {
 337         return __qdisc_enqueue_tail(skb, sch, &sch->q);
 338 }
 339
 340 static inline struct sk_buff *__qdisc_dequeue_head(struct Qdisc *sch,
 341                                                    struct sk_buff_head *list)
 342 {
 343         struct sk_buff *skb = __skb_dequeue(list);
 344
 345         if (likely(skb != NULL))
 346                 sch->qstats.backlog -= qdisc_pkt_len(skb);
 347
 348         return skb;
 349 }
 350
 351 static inline struct sk_buff *qdisc_dequeue_head(struct Qdisc *sch)
 352 {
 353         return __qdisc_dequeue_head(sch, &sch->q);
 354 }
 355
 356 static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,
 357                                                    struct sk_buff_head *list)
 358 {
 359         struct sk_buff *skb = __skb_dequeue_tail(list);
 360
 361         if (likely(skb != NULL))
 362                 sch->qstats.backlog -= qdisc_pkt_len(skb);
 363
 364         return skb;
 365 }
 366
 367 static inline struct sk_buff *qdisc_dequeue_tail(struct Qdisc *sch)
 368 {
 369         return __qdisc_dequeue_tail(sch, &sch->q);
 370 }
 371
 372 static inline int __qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch,
 373                                   struct sk_buff_head *list)
 374 {
 375         __skb_queue_head(list, skb);
 376         sch->qstats.backlog += qdisc_pkt_len(skb);
 377         sch->qstats.requeues++;
 378
 379         return NET_XMIT_SUCCESS;
 380 }
 381
 382 static inline int qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch)
 383 {
 384         return __qdisc_requeue(skb, sch, &sch->q);
 385 }
 386
 387 static inline void __qdisc_reset_queue(struct Qdisc *sch,
 388                                        struct sk_buff_head *list)
 389 {
 390         /*
 391          * We do not know the backlog in bytes of this list, it
 392          * is up to the caller to correct it
 393          */
 394         __skb_queue_purge(list);
 395 }
 396
 397 static inline void qdisc_reset_queue(struct Qdisc *sch)
 398 {
 399         __qdisc_reset_queue(sch, &sch->q);
 400         sch->qstats.backlog = 0;
 401 }
 402
 403 static inline unsigned int __qdisc_queue_drop(struct Qdisc *sch,
 404                                               struct sk_buff_head *list)
 405 {
 406         struct sk_buff *skb = __qdisc_dequeue_tail(sch, list);
 407
 408         if (likely(skb != NULL)) {
 409                 unsigned int len = qdisc_pkt_len(skb);
 410                 kfree_skb(skb);
 411                 return len;
 412         }
 413
 414         return 0;
 415 }
 416
 417 static inline unsigned int qdisc_queue_drop(struct Qdisc *sch)
 418 {
 419         return __qdisc_queue_drop(sch, &sch->q);
 420 }
 421
 422 static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
 423 {
 424         kfree_skb(skb);
 425         sch->qstats.drops++;
 426
 427         return NET_XMIT_DROP;
 428 }
 429
 430 static inline int qdisc_reshape_fail(struct sk_buff *skb, struct Qdisc *sch)
 431 {
 432         sch->qstats.drops++;
 433
 434 #ifdef CONFIG_NET_CLS_ACT
 435         if (sch->reshape_fail == NULL || sch->reshape_fail(skb, sch))
 436                 goto drop;
 437
 438         return NET_XMIT_SUCCESS;
 439
 440 drop:
 441 #endif
 442         kfree_skb(skb);
 443         return NET_XMIT_DROP;
 444 }
 445
 446 /* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how
 447    long it will take to send a packet given its size.
 448  */
 449 static inline u32 qdisc_l2t(struct qdisc_rate_table* rtab, unsigned int pktlen)
 450 {
 451         int slot = pktlen + rtab->rate.cell_align + rtab->rate.overhead;
 452         if (slot < 0)
 453                 slot = 0;
 454         slot >>= rtab->rate.cell_log;
 455         if (slot > 255)
 456                 return (rtab->data[255]*(slot >> 8) + rtab->data[slot & 0xFF]);
 457         return rtab->data[slot];
 458 }
 459
 460 #ifdef CONFIG_NET_CLS_ACT
 461 static inline struct sk_buff *skb_act_clone(struct sk_buff *skb, gfp_t gfp_mask)
 462 {
 463         struct sk_buff *n = skb_clone(skb, gfp_mask);
 464
 465         if (n) {
 466                 n->tc_verd = SET_TC_VERD(n->tc_verd, 0);
 467                 n->tc_verd = CLR_TC_OK2MUNGE(n->tc_verd);
 468                 n->tc_verd = CLR_TC_MUNGED(n->tc_verd);
 469         }
 470         return n;
 471 }
 472 #endif
 473
 474 #endif