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