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