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