include/net/pkt_cls.h

   1 #ifndef __NET_PKT_CLS_H
   2 #define __NET_PKT_CLS_H
   3
   4 #include <linux/pkt_cls.h>
   5 #include <net/sch_generic.h>
   6 #include <net/act_api.h>
   7
   8 /* Basic packet classifier frontend definitions. */
   9
  10 struct tcf_walker {
  11         int     stop;
  12         int     skip;
  13         int     count;
  14         int     (*fn)(struct tcf_proto *, unsigned long node, struct tcf_walker *);
  15 };
  16
  17 extern int register_tcf_proto_ops(struct tcf_proto_ops *ops);
  18 extern int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
  19
  20 static inline unsigned long
  21 __cls_set_class(unsigned long *clp, unsigned long cl)
  22 {
  23         unsigned long old_cl;
  24
  25         old_cl = *clp;
  26         *clp = cl;
  27         return old_cl;
  28 }
  29
  30 static inline unsigned long
  31 cls_set_class(struct tcf_proto *tp, unsigned long *clp,
  32         unsigned long cl)
  33 {
  34         unsigned long old_cl;
  35
  36         tcf_tree_lock(tp);
  37         old_cl = __cls_set_class(clp, cl);
  38         tcf_tree_unlock(tp);
  39
  40         return old_cl;
  41 }
  42
  43 static inline void
  44 tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
  45 {
  46         unsigned long cl;
  47
  48         cl = tp->q->ops->cl_ops->bind_tcf(tp->q, base, r->classid);
  49         cl = cls_set_class(tp, &r->class, cl);
  50         if (cl)
  51                 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
  52 }
  53
  54 static inline void
  55 tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
  56 {
  57         unsigned long cl;
  58
  59         if ((cl = __cls_set_class(&r->class, 0)) != 0)
  60                 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
  61 }
  62
  63 struct tcf_exts {
  64 #ifdef CONFIG_NET_CLS_ACT
  65         struct tc_action *action;
  66 #endif
  67 };
  68
  69 /* Map to export classifier specific extension TLV types to the
  70  * generic extensions API. Unsupported extensions must be set to 0.
  71  */
  72 struct tcf_ext_map {
  73         int action;
  74         int police;
  75 };
  76
  77 /**
  78  * tcf_exts_is_predicative - check if a predicative extension is present
  79  * @exts: tc filter extensions handle
  80  *
  81  * Returns 1 if a predicative extension is present, i.e. an extension which
  82  * might cause further actions and thus overrule the regular tcf_result.
  83  */
  84 static inline int
  85 tcf_exts_is_predicative(struct tcf_exts *exts)
  86 {
  87 #ifdef CONFIG_NET_CLS_ACT
  88         return !!exts->action;
  89 #else
  90         return 0;
  91 #endif
  92 }
  93
  94 /**
  95  * tcf_exts_is_available - check if at least one extension is present
  96  * @exts: tc filter extensions handle
  97  *
  98  * Returns 1 if at least one extension is present.
  99  */
 100 static inline int
 101 tcf_exts_is_available(struct tcf_exts *exts)
 102 {
 103         /* All non-predicative extensions must be added here. */
 104         return tcf_exts_is_predicative(exts);
 105 }
 106
 107 /**
 108  * tcf_exts_exec - execute tc filter extensions
 109  * @skb: socket buffer
 110  * @exts: tc filter extensions handle
 111  * @res: desired result
 112  *
 113  * Executes all configured extensions. Returns 0 on a normal execution,
 114  * a negative number if the filter must be considered unmatched or
 115  * a positive action code (TC_ACT_*) which must be returned to the
 116  * underlying layer.
 117  */
 118 static inline int
 119 tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
 120                struct tcf_result *res)
 121 {
 122 #ifdef CONFIG_NET_CLS_ACT
 123         if (exts->action)
 124                 return tcf_action_exec(skb, exts->action, res);
 125 #endif
 126         return 0;
 127 }
 128
 129 extern int tcf_exts_validate(struct tcf_proto *tp, struct nlattr **tb,
 130                              struct nlattr *rate_tlv, struct tcf_exts *exts,
 131                              const struct tcf_ext_map *map);
 132 extern void tcf_exts_destroy(struct tcf_proto *tp, struct tcf_exts *exts);
 133 extern void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
 134                              struct tcf_exts *src);
 135 extern int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts,
 136                          const struct tcf_ext_map *map);
 137 extern int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts,
 138                                const struct tcf_ext_map *map);
 139
 140 /**
 141  * struct tcf_pkt_info - packet information
 142  */
 143 struct tcf_pkt_info {
 144         unsigned char *         ptr;
 145         int                     nexthdr;
 146 };
 147
 148 #ifdef CONFIG_NET_EMATCH
 149
 150 struct tcf_ematch_ops;
 151
 152 /**
 153  * struct tcf_ematch - extended match (ematch)
 154  *
 155  * @matchid: identifier to allow userspace to reidentify a match
 156  * @flags: flags specifying attributes and the relation to other matches
 157  * @ops: the operations lookup table of the corresponding ematch module
 158  * @datalen: length of the ematch specific configuration data
 159  * @data: ematch specific data
 160  */
 161 struct tcf_ematch {
 162         struct tcf_ematch_ops * ops;
 163         unsigned long           data;
 164         unsigned int            datalen;
 165         u16                     matchid;
 166         u16                     flags;
 167 };
 168
 169 static inline int tcf_em_is_container(struct tcf_ematch *em)
 170 {
 171         return !em->ops;
 172 }
 173
 174 static inline int tcf_em_is_simple(struct tcf_ematch *em)
 175 {
 176         return em->flags & TCF_EM_SIMPLE;
 177 }
 178
 179 static inline int tcf_em_is_inverted(struct tcf_ematch *em)
 180 {
 181         return em->flags & TCF_EM_INVERT;
 182 }
 183
 184 static inline int tcf_em_last_match(struct tcf_ematch *em)
 185 {
 186         return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END;
 187 }
 188
 189 static inline int tcf_em_early_end(struct tcf_ematch *em, int result)
 190 {
 191         if (tcf_em_last_match(em))
 192                 return 1;
 193
 194         if (result == 0 && em->flags & TCF_EM_REL_AND)
 195                 return 1;
 196
 197         if (result != 0 && em->flags & TCF_EM_REL_OR)
 198                 return 1;
 199
 200         return 0;
 201 }
 202
 203 /**
 204  * struct tcf_ematch_tree - ematch tree handle
 205  *
 206  * @hdr: ematch tree header supplied by userspace
 207  * @matches: array of ematches
 208  */
 209 struct tcf_ematch_tree {
 210         struct tcf_ematch_tree_hdr hdr;
 211         struct tcf_ematch *     matches;
 212
 213 };
 214
 215 /**
 216  * struct tcf_ematch_ops - ematch module operations
 217  *
 218  * @kind: identifier (kind) of this ematch module
 219  * @datalen: length of expected configuration data (optional)
 220  * @change: called during validation (optional)
 221  * @match: called during ematch tree evaluation, must return 1/0
 222  * @destroy: called during destroyage (optional)
 223  * @dump: called during dumping process (optional)
 224  * @owner: owner, must be set to THIS_MODULE
 225  * @link: link to previous/next ematch module (internal use)
 226  */
 227 struct tcf_ematch_ops {
 228         int                     kind;
 229         int                     datalen;
 230         int                     (*change)(struct tcf_proto *, void *,
 231                                           int, struct tcf_ematch *);
 232         int                     (*match)(struct sk_buff *, struct tcf_ematch *,
 233                                          struct tcf_pkt_info *);
 234         void                    (*destroy)(struct tcf_proto *,
 235                                            struct tcf_ematch *);
 236         int                     (*dump)(struct sk_buff *, struct tcf_ematch *);
 237         struct module           *owner;
 238         struct list_head        link;
 239 };
 240
 241 extern int tcf_em_register(struct tcf_ematch_ops *);
 242 extern void tcf_em_unregister(struct tcf_ematch_ops *);
 243 extern int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
 244                                 struct tcf_ematch_tree *);
 245 extern void tcf_em_tree_destroy(struct tcf_proto *, struct tcf_ematch_tree *);
 246 extern int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int);
 247 extern int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *,
 248                                struct tcf_pkt_info *);
 249
 250 /**
 251  * tcf_em_tree_change - replace ematch tree of a running classifier
 252  *
 253  * @tp: classifier kind handle
 254  * @dst: destination ematch tree variable
 255  * @src: source ematch tree (temporary tree from tcf_em_tree_validate)
 256  *
 257  * This functions replaces the ematch tree in @dst with the ematch
 258  * tree in @src. The classifier in charge of the ematch tree may be
 259  * running.
 260  */
 261 static inline void tcf_em_tree_change(struct tcf_proto *tp,
 262                                       struct tcf_ematch_tree *dst,
 263                                       struct tcf_ematch_tree *src)
 264 {
 265         tcf_tree_lock(tp);
 266         memcpy(dst, src, sizeof(*dst));
 267         tcf_tree_unlock(tp);
 268 }
 269
 270 /**
 271  * tcf_em_tree_match - evaulate an ematch tree
 272  *
 273  * @skb: socket buffer of the packet in question
 274  * @tree: ematch tree to be used for evaluation
 275  * @info: packet information examined by classifier
 276  *
 277  * This function matches @skb against the ematch tree in @tree by going
 278  * through all ematches respecting their logic relations returning
 279  * as soon as the result is obvious.
 280  *
 281  * Returns 1 if the ematch tree as-one matches, no ematches are configured
 282  * or ematch is not enabled in the kernel, otherwise 0 is returned.
 283  */
 284 static inline int tcf_em_tree_match(struct sk_buff *skb,
 285                                     struct tcf_ematch_tree *tree,
 286                                     struct tcf_pkt_info *info)
 287 {
 288         if (tree->hdr.nmatches)
 289                 return __tcf_em_tree_match(skb, tree, info);
 290         else
 291                 return 1;
 292 }
 293
 294 #define MODULE_ALIAS_TCF_EMATCH(kind)   MODULE_ALIAS("ematch-kind-" __stringify(kind))
 295
 296 #else /* CONFIG_NET_EMATCH */
 297
 298 struct tcf_ematch_tree {
 299 };
 300
 301 #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
 302 #define tcf_em_tree_destroy(tp, t) do { (void)(t); } while(0)
 303 #define tcf_em_tree_dump(skb, t, tlv) (0)
 304 #define tcf_em_tree_change(tp, dst, src) do { } while(0)
 305 #define tcf_em_tree_match(skb, t, info) ((void)(info), 1)
 306
 307 #endif /* CONFIG_NET_EMATCH */
 308
 309 static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
 310 {
 311         switch (layer) {
 312                 case TCF_LAYER_LINK:
 313                         return skb->data;
 314                 case TCF_LAYER_NETWORK:
 315                         return skb_network_header(skb);
 316                 case TCF_LAYER_TRANSPORT:
 317                         return skb_transport_header(skb);
 318         }
 319
 320         return NULL;
 321 }
 322
 323 static inline int tcf_valid_offset(const struct sk_buff *skb,
 324                                    const unsigned char *ptr, const int len)
 325 {
 326         return likely((ptr + len) <= skb_tail_pointer(skb) &&
 327                       ptr >= skb->head &&
 328                       (ptr <= (ptr + len)));
 329 }
 330
 331 #ifdef CONFIG_NET_CLS_IND
 332 #include <net/net_namespace.h>
 333
 334 static inline int
 335 tcf_change_indev(struct tcf_proto *tp, char *indev, struct nlattr *indev_tlv)
 336 {
 337         if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
 338                 return -EINVAL;
 339         return 0;
 340 }
 341
 342 static inline int
 343 tcf_match_indev(struct sk_buff *skb, char *indev)
 344 {
 345         struct net_device *dev;
 346
 347         if (indev[0]) {
 348                 if  (!skb->skb_iif)
 349                         return 0;
 350                 dev = __dev_get_by_index(dev_net(skb->dev), skb->skb_iif);
 351                 if (!dev || strcmp(indev, dev->name))
 352                         return 0;
 353         }
 354
 355         return 1;
 356 }
 357 #endif /* CONFIG_NET_CLS_IND */
 358
 359 #endif