Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | #else /* CONFIG_NET_EMATCH */ |
| 310 | |
| 311 | struct tcf_ematch_tree |
| 312 | { |
| 313 | }; |
| 314 | |
| 315 | #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0) |
| 316 | #define tcf_em_tree_destroy(tp, t) do { (void)(t); } while(0) |
| 317 | #define tcf_em_tree_dump(skb, t, tlv) (0) |
| 318 | #define tcf_em_tree_change(tp, dst, src) do { } while(0) |
| 319 | #define tcf_em_tree_match(skb, t, info) ((void)(info), 1) |
| 320 | |
| 321 | #endif /* CONFIG_NET_EMATCH */ |
| 322 | |
| 323 | static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer) |
| 324 | { |
| 325 | switch (layer) { |
| 326 | case TCF_LAYER_LINK: |
| 327 | return skb->data; |
| 328 | case TCF_LAYER_NETWORK: |
Arnaldo Carvalho de Melo | d56f90a | 2007-04-10 20:50:43 -0700 | [diff] [blame] | 329 | return skb_network_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | case TCF_LAYER_TRANSPORT: |
Arnaldo Carvalho de Melo | 9c70220 | 2007-04-25 18:04:18 -0700 | [diff] [blame] | 331 | return skb_transport_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | return NULL; |
| 335 | } |
| 336 | |
Arnaldo Carvalho de Melo | eddc9ec | 2007-04-20 22:47:35 -0700 | [diff] [blame] | 337 | static inline int tcf_valid_offset(const struct sk_buff *skb, |
| 338 | const unsigned char *ptr, const int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | { |
| 340 | return unlikely((ptr + len) < skb->tail && ptr > skb->head); |
| 341 | } |
| 342 | |
| 343 | #ifdef CONFIG_NET_CLS_IND |
| 344 | static inline int |
| 345 | tcf_change_indev(struct tcf_proto *tp, char *indev, struct rtattr *indev_tlv) |
| 346 | { |
| 347 | if (rtattr_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ) |
| 348 | return -EINVAL; |
| 349 | return 0; |
| 350 | } |
| 351 | |
| 352 | static inline int |
| 353 | tcf_match_indev(struct sk_buff *skb, char *indev) |
| 354 | { |
Patrick McHardy | c01003c | 2007-03-29 11:46:52 -0700 | [diff] [blame] | 355 | struct net_device *dev; |
| 356 | |
David S. Miller | 86e65da | 2005-08-09 19:36:29 -0700 | [diff] [blame] | 357 | if (indev[0]) { |
Patrick McHardy | c01003c | 2007-03-29 11:46:52 -0700 | [diff] [blame] | 358 | if (!skb->iif) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | return 0; |
Patrick McHardy | c01003c | 2007-03-29 11:46:52 -0700 | [diff] [blame] | 360 | dev = __dev_get_by_index(skb->iif); |
| 361 | if (!dev || strcmp(indev, dev->name)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 362 | return 0; |
| 363 | } |
| 364 | |
| 365 | return 1; |
| 366 | } |
| 367 | #endif /* CONFIG_NET_CLS_IND */ |
| 368 | |
| 369 | #endif |