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 return xchg(clp, cl); 24 } 25 26 static inline unsigned long 27 cls_set_class(struct tcf_proto *tp, unsigned long *clp, 28 unsigned long cl) 29 { 30 unsigned long old_cl; 31 32 tcf_tree_lock(tp); 33 old_cl = __cls_set_class(clp, cl); 34 tcf_tree_unlock(tp); 35 36 return old_cl; 37 } 38 39 static inline void 40 tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base) 41 { 42 unsigned long cl; 43 44 cl = tp->q->ops->cl_ops->bind_tcf(tp->q, base, r->classid); 45 cl = cls_set_class(tp, &r->class, cl); 46 if (cl) 47 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl); 48 } 49 50 static inline void 51 tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r) 52 { 53 unsigned long cl; 54 55 if ((cl = __cls_set_class(&r->class, 0)) != 0) 56 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl); 57 } 58 59 struct tcf_exts { 60 #ifdef CONFIG_NET_CLS_ACT 61 __u32 type; /* for backward compat(TCA_OLD_COMPAT) */ 62 int nr_actions; 63 struct tc_action **actions; 64 #endif 65 /* Map to export classifier specific extension TLV types to the 66 * generic extensions API. Unsupported extensions must be set to 0. 67 */ 68 int action; 69 int police; 70 }; 71 72 static inline void tcf_exts_init(struct tcf_exts *exts, int action, int police) 73 { 74 #ifdef CONFIG_NET_CLS_ACT 75 exts->type = 0; 76 exts->nr_actions = 0; 77 exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *), 78 GFP_KERNEL); 79 WARN_ON(!exts->actions); /* TODO: propagate the error to callers */ 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 exts->nr_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 static inline void tcf_exts_to_list(const struct tcf_exts *exts, 116 struct list_head *actions) 117 { 118 #ifdef CONFIG_NET_CLS_ACT 119 int i; 120 121 for (i = 0; i < exts->nr_actions; i++) { 122 struct tc_action *a = exts->actions[i]; 123 124 list_add(&a->list, actions); 125 } 126 #endif 127 } 128 129 /** 130 * tcf_exts_exec - execute tc filter extensions 131 * @skb: socket buffer 132 * @exts: tc filter extensions handle 133 * @res: desired result 134 * 135 * Executes all configured extensions. Returns 0 on a normal execution, 136 * a negative number if the filter must be considered unmatched or 137 * a positive action code (TC_ACT_*) which must be returned to the 138 * underlying layer. 139 */ 140 static inline int 141 tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts, 142 struct tcf_result *res) 143 { 144 #ifdef CONFIG_NET_CLS_ACT 145 if (exts->nr_actions) 146 return tcf_action_exec(skb, exts->actions, exts->nr_actions, 147 res); 148 #endif 149 return 0; 150 } 151 152 #ifdef CONFIG_NET_CLS_ACT 153 154 #define tc_no_actions(_exts) ((_exts)->nr_actions == 0) 155 #define tc_single_action(_exts) ((_exts)->nr_actions == 1) 156 157 #else /* CONFIG_NET_CLS_ACT */ 158 159 #define tc_no_actions(_exts) true 160 #define tc_single_action(_exts) false 161 162 #endif /* CONFIG_NET_CLS_ACT */ 163 164 int tcf_exts_validate(struct net *net, struct tcf_proto *tp, 165 struct nlattr **tb, struct nlattr *rate_tlv, 166 struct tcf_exts *exts, bool ovr); 167 void tcf_exts_destroy(struct tcf_exts *exts); 168 void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst, 169 struct tcf_exts *src); 170 int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts); 171 int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts); 172 173 /** 174 * struct tcf_pkt_info - packet information 175 */ 176 struct tcf_pkt_info { 177 unsigned char * ptr; 178 int nexthdr; 179 }; 180 181 #ifdef CONFIG_NET_EMATCH 182 183 struct tcf_ematch_ops; 184 185 /** 186 * struct tcf_ematch - extended match (ematch) 187 * 188 * @matchid: identifier to allow userspace to reidentify a match 189 * @flags: flags specifying attributes and the relation to other matches 190 * @ops: the operations lookup table of the corresponding ematch module 191 * @datalen: length of the ematch specific configuration data 192 * @data: ematch specific data 193 */ 194 struct tcf_ematch { 195 struct tcf_ematch_ops * ops; 196 unsigned long data; 197 unsigned int datalen; 198 u16 matchid; 199 u16 flags; 200 struct net *net; 201 }; 202 203 static inline int tcf_em_is_container(struct tcf_ematch *em) 204 { 205 return !em->ops; 206 } 207 208 static inline int tcf_em_is_simple(struct tcf_ematch *em) 209 { 210 return em->flags & TCF_EM_SIMPLE; 211 } 212 213 static inline int tcf_em_is_inverted(struct tcf_ematch *em) 214 { 215 return em->flags & TCF_EM_INVERT; 216 } 217 218 static inline int tcf_em_last_match(struct tcf_ematch *em) 219 { 220 return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END; 221 } 222 223 static inline int tcf_em_early_end(struct tcf_ematch *em, int result) 224 { 225 if (tcf_em_last_match(em)) 226 return 1; 227 228 if (result == 0 && em->flags & TCF_EM_REL_AND) 229 return 1; 230 231 if (result != 0 && em->flags & TCF_EM_REL_OR) 232 return 1; 233 234 return 0; 235 } 236 237 /** 238 * struct tcf_ematch_tree - ematch tree handle 239 * 240 * @hdr: ematch tree header supplied by userspace 241 * @matches: array of ematches 242 */ 243 struct tcf_ematch_tree { 244 struct tcf_ematch_tree_hdr hdr; 245 struct tcf_ematch * matches; 246 247 }; 248 249 /** 250 * struct tcf_ematch_ops - ematch module operations 251 * 252 * @kind: identifier (kind) of this ematch module 253 * @datalen: length of expected configuration data (optional) 254 * @change: called during validation (optional) 255 * @match: called during ematch tree evaluation, must return 1/0 256 * @destroy: called during destroyage (optional) 257 * @dump: called during dumping process (optional) 258 * @owner: owner, must be set to THIS_MODULE 259 * @link: link to previous/next ematch module (internal use) 260 */ 261 struct tcf_ematch_ops { 262 int kind; 263 int datalen; 264 int (*change)(struct net *net, void *, 265 int, struct tcf_ematch *); 266 int (*match)(struct sk_buff *, struct tcf_ematch *, 267 struct tcf_pkt_info *); 268 void (*destroy)(struct tcf_ematch *); 269 int (*dump)(struct sk_buff *, struct tcf_ematch *); 270 struct module *owner; 271 struct list_head link; 272 }; 273 274 int tcf_em_register(struct tcf_ematch_ops *); 275 void tcf_em_unregister(struct tcf_ematch_ops *); 276 int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *, 277 struct tcf_ematch_tree *); 278 void tcf_em_tree_destroy(struct tcf_ematch_tree *); 279 int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int); 280 int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *, 281 struct tcf_pkt_info *); 282 283 /** 284 * tcf_em_tree_change - replace ematch tree of a running classifier 285 * 286 * @tp: classifier kind handle 287 * @dst: destination ematch tree variable 288 * @src: source ematch tree (temporary tree from tcf_em_tree_validate) 289 * 290 * This functions replaces the ematch tree in @dst with the ematch 291 * tree in @src. The classifier in charge of the ematch tree may be 292 * running. 293 */ 294 static inline void tcf_em_tree_change(struct tcf_proto *tp, 295 struct tcf_ematch_tree *dst, 296 struct tcf_ematch_tree *src) 297 { 298 tcf_tree_lock(tp); 299 memcpy(dst, src, sizeof(*dst)); 300 tcf_tree_unlock(tp); 301 } 302 303 /** 304 * tcf_em_tree_match - evaulate an ematch tree 305 * 306 * @skb: socket buffer of the packet in question 307 * @tree: ematch tree to be used for evaluation 308 * @info: packet information examined by classifier 309 * 310 * This function matches @skb against the ematch tree in @tree by going 311 * through all ematches respecting their logic relations returning 312 * as soon as the result is obvious. 313 * 314 * Returns 1 if the ematch tree as-one matches, no ematches are configured 315 * or ematch is not enabled in the kernel, otherwise 0 is returned. 316 */ 317 static inline int tcf_em_tree_match(struct sk_buff *skb, 318 struct tcf_ematch_tree *tree, 319 struct tcf_pkt_info *info) 320 { 321 if (tree->hdr.nmatches) 322 return __tcf_em_tree_match(skb, tree, info); 323 else 324 return 1; 325 } 326 327 #define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind)) 328 329 #else /* CONFIG_NET_EMATCH */ 330 331 struct tcf_ematch_tree { 332 }; 333 334 #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0) 335 #define tcf_em_tree_destroy(t) do { (void)(t); } while(0) 336 #define tcf_em_tree_dump(skb, t, tlv) (0) 337 #define tcf_em_tree_change(tp, dst, src) do { } while(0) 338 #define tcf_em_tree_match(skb, t, info) ((void)(info), 1) 339 340 #endif /* CONFIG_NET_EMATCH */ 341 342 static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer) 343 { 344 switch (layer) { 345 case TCF_LAYER_LINK: 346 return skb->data; 347 case TCF_LAYER_NETWORK: 348 return skb_network_header(skb); 349 case TCF_LAYER_TRANSPORT: 350 return skb_transport_header(skb); 351 } 352 353 return NULL; 354 } 355 356 static inline int tcf_valid_offset(const struct sk_buff *skb, 357 const unsigned char *ptr, const int len) 358 { 359 return likely((ptr + len) <= skb_tail_pointer(skb) && 360 ptr >= skb->head && 361 (ptr <= (ptr + len))); 362 } 363 364 #ifdef CONFIG_NET_CLS_IND 365 #include <net/net_namespace.h> 366 367 static inline int 368 tcf_change_indev(struct net *net, struct nlattr *indev_tlv) 369 { 370 char indev[IFNAMSIZ]; 371 struct net_device *dev; 372 373 if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ) 374 return -EINVAL; 375 dev = __dev_get_by_name(net, indev); 376 if (!dev) 377 return -ENODEV; 378 return dev->ifindex; 379 } 380 381 static inline bool 382 tcf_match_indev(struct sk_buff *skb, int ifindex) 383 { 384 if (!ifindex) 385 return true; 386 if (!skb->skb_iif) 387 return false; 388 return ifindex == skb->skb_iif; 389 } 390 #endif /* CONFIG_NET_CLS_IND */ 391 392 struct tc_cls_u32_knode { 393 struct tcf_exts *exts; 394 struct tc_u32_sel *sel; 395 u32 handle; 396 u32 val; 397 u32 mask; 398 u32 link_handle; 399 u8 fshift; 400 }; 401 402 struct tc_cls_u32_hnode { 403 u32 handle; 404 u32 prio; 405 unsigned int divisor; 406 }; 407 408 enum tc_clsu32_command { 409 TC_CLSU32_NEW_KNODE, 410 TC_CLSU32_REPLACE_KNODE, 411 TC_CLSU32_DELETE_KNODE, 412 TC_CLSU32_NEW_HNODE, 413 TC_CLSU32_REPLACE_HNODE, 414 TC_CLSU32_DELETE_HNODE, 415 }; 416 417 struct tc_cls_u32_offload { 418 /* knode values */ 419 enum tc_clsu32_command command; 420 union { 421 struct tc_cls_u32_knode knode; 422 struct tc_cls_u32_hnode hnode; 423 }; 424 }; 425 426 static inline bool tc_should_offload(const struct net_device *dev, 427 const struct tcf_proto *tp, u32 flags) 428 { 429 const struct Qdisc *sch = tp->q; 430 const struct Qdisc_class_ops *cops = sch->ops->cl_ops; 431 432 if (!(dev->features & NETIF_F_HW_TC)) 433 return false; 434 if (flags & TCA_CLS_FLAGS_SKIP_HW) 435 return false; 436 if (!dev->netdev_ops->ndo_setup_tc) 437 return false; 438 if (cops && cops->tcf_cl_offload) 439 return cops->tcf_cl_offload(tp->classid); 440 441 return true; 442 } 443 444 static inline bool tc_skip_sw(u32 flags) 445 { 446 return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false; 447 } 448 449 /* SKIP_HW and SKIP_SW are mutually exclusive flags. */ 450 static inline bool tc_flags_valid(u32 flags) 451 { 452 if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW)) 453 return false; 454 455 if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))) 456 return false; 457 458 return true; 459 } 460 461 enum tc_fl_command { 462 TC_CLSFLOWER_REPLACE, 463 TC_CLSFLOWER_DESTROY, 464 TC_CLSFLOWER_STATS, 465 }; 466 467 struct tc_cls_flower_offload { 468 enum tc_fl_command command; 469 unsigned long cookie; 470 struct flow_dissector *dissector; 471 struct fl_flow_key *mask; 472 struct fl_flow_key *key; 473 struct tcf_exts *exts; 474 }; 475 476 enum tc_matchall_command { 477 TC_CLSMATCHALL_REPLACE, 478 TC_CLSMATCHALL_DESTROY, 479 }; 480 481 struct tc_cls_matchall_offload { 482 enum tc_matchall_command command; 483 struct tcf_exts *exts; 484 unsigned long cookie; 485 }; 486 487 #endif 488