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 360