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 366