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 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 10 | struct tcf_walker { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | int stop; |
| 12 | int skip; |
| 13 | int count; |
| 14 | int (*fn)(struct tcf_proto *, unsigned long node, struct tcf_walker *); |
| 15 | }; |
| 16 | |
Joe Perches | 5c15257 | 2013-07-30 22:47:13 -0700 | [diff] [blame] | 17 | int register_tcf_proto_ops(struct tcf_proto_ops *ops); |
| 18 | int unregister_tcf_proto_ops(struct tcf_proto_ops *ops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | |
| 20 | static inline unsigned long |
| 21 | __cls_set_class(unsigned long *clp, unsigned long cl) |
| 22 | { |
WANG Cong | a0efb80 | 2014-09-30 16:07:24 -0700 | [diff] [blame] | 23 | return xchg(clp, cl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 59 | struct tcf_exts { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | #ifdef CONFIG_NET_CLS_ACT |
WANG Cong | 33be627 | 2013-12-15 20:15:05 -0800 | [diff] [blame] | 61 | __u32 type; /* for backward compat(TCA_OLD_COMPAT) */ |
| 62 | struct list_head actions; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | #endif |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 64 | /* Map to export classifier specific extension TLV types to the |
| 65 | * generic extensions API. Unsupported extensions must be set to 0. |
| 66 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | int action; |
| 68 | int police; |
| 69 | }; |
| 70 | |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 71 | static inline void tcf_exts_init(struct tcf_exts *exts, int action, int police) |
WANG Cong | 33be627 | 2013-12-15 20:15:05 -0800 | [diff] [blame] | 72 | { |
| 73 | #ifdef CONFIG_NET_CLS_ACT |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 74 | exts->type = 0; |
WANG Cong | 33be627 | 2013-12-15 20:15:05 -0800 | [diff] [blame] | 75 | INIT_LIST_HEAD(&exts->actions); |
| 76 | #endif |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 77 | exts->action = action; |
| 78 | exts->police = police; |
WANG Cong | 33be627 | 2013-12-15 20:15:05 -0800 | [diff] [blame] | 79 | } |
| 80 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | /** |
| 82 | * tcf_exts_is_predicative - check if a predicative extension is present |
| 83 | * @exts: tc filter extensions handle |
| 84 | * |
| 85 | * Returns 1 if a predicative extension is present, i.e. an extension which |
| 86 | * might cause further actions and thus overrule the regular tcf_result. |
| 87 | */ |
| 88 | static inline int |
| 89 | tcf_exts_is_predicative(struct tcf_exts *exts) |
| 90 | { |
| 91 | #ifdef CONFIG_NET_CLS_ACT |
WANG Cong | 33be627 | 2013-12-15 20:15:05 -0800 | [diff] [blame] | 92 | return !list_empty(&exts->actions); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | #else |
| 94 | return 0; |
| 95 | #endif |
| 96 | } |
| 97 | |
| 98 | /** |
| 99 | * tcf_exts_is_available - check if at least one extension is present |
| 100 | * @exts: tc filter extensions handle |
| 101 | * |
| 102 | * Returns 1 if at least one extension is present. |
| 103 | */ |
| 104 | static inline int |
| 105 | tcf_exts_is_available(struct tcf_exts *exts) |
| 106 | { |
| 107 | /* All non-predicative extensions must be added here. */ |
| 108 | return tcf_exts_is_predicative(exts); |
| 109 | } |
| 110 | |
| 111 | /** |
| 112 | * tcf_exts_exec - execute tc filter extensions |
| 113 | * @skb: socket buffer |
| 114 | * @exts: tc filter extensions handle |
| 115 | * @res: desired result |
| 116 | * |
| 117 | * Executes all configured extensions. Returns 0 on a normal execution, |
| 118 | * a negative number if the filter must be considered unmatched or |
| 119 | * a positive action code (TC_ACT_*) which must be returned to the |
| 120 | * underlying layer. |
| 121 | */ |
| 122 | static inline int |
| 123 | tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts, |
| 124 | struct tcf_result *res) |
| 125 | { |
| 126 | #ifdef CONFIG_NET_CLS_ACT |
WANG Cong | 33be627 | 2013-12-15 20:15:05 -0800 | [diff] [blame] | 127 | if (!list_empty(&exts->actions)) |
| 128 | return tcf_action_exec(skb, &exts->actions, res); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | return 0; |
| 131 | } |
| 132 | |
Joe Perches | 5c15257 | 2013-07-30 22:47:13 -0700 | [diff] [blame] | 133 | int tcf_exts_validate(struct net *net, struct tcf_proto *tp, |
| 134 | struct nlattr **tb, struct nlattr *rate_tlv, |
Cong Wang | 2f7ef2f | 2014-04-25 13:54:06 -0700 | [diff] [blame] | 135 | struct tcf_exts *exts, bool ovr); |
WANG Cong | 18d0264 | 2014-09-25 10:26:37 -0700 | [diff] [blame] | 136 | void tcf_exts_destroy(struct tcf_exts *exts); |
Joe Perches | 5c15257 | 2013-07-30 22:47:13 -0700 | [diff] [blame] | 137 | void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst, |
| 138 | struct tcf_exts *src); |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 139 | int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts); |
| 140 | int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | |
| 142 | /** |
| 143 | * struct tcf_pkt_info - packet information |
| 144 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 145 | struct tcf_pkt_info { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | unsigned char * ptr; |
| 147 | int nexthdr; |
| 148 | }; |
| 149 | |
| 150 | #ifdef CONFIG_NET_EMATCH |
| 151 | |
| 152 | struct tcf_ematch_ops; |
| 153 | |
| 154 | /** |
| 155 | * struct tcf_ematch - extended match (ematch) |
| 156 | * |
| 157 | * @matchid: identifier to allow userspace to reidentify a match |
| 158 | * @flags: flags specifying attributes and the relation to other matches |
| 159 | * @ops: the operations lookup table of the corresponding ematch module |
| 160 | * @datalen: length of the ematch specific configuration data |
| 161 | * @data: ematch specific data |
| 162 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 163 | struct tcf_ematch { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | struct tcf_ematch_ops * ops; |
| 165 | unsigned long data; |
| 166 | unsigned int datalen; |
| 167 | u16 matchid; |
| 168 | u16 flags; |
John Fastabend | 82a470f | 2014-10-05 21:27:53 -0700 | [diff] [blame] | 169 | struct net *net; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | }; |
| 171 | |
| 172 | static inline int tcf_em_is_container(struct tcf_ematch *em) |
| 173 | { |
| 174 | return !em->ops; |
| 175 | } |
| 176 | |
| 177 | static inline int tcf_em_is_simple(struct tcf_ematch *em) |
| 178 | { |
| 179 | return em->flags & TCF_EM_SIMPLE; |
| 180 | } |
| 181 | |
| 182 | static inline int tcf_em_is_inverted(struct tcf_ematch *em) |
| 183 | { |
| 184 | return em->flags & TCF_EM_INVERT; |
| 185 | } |
| 186 | |
| 187 | static inline int tcf_em_last_match(struct tcf_ematch *em) |
| 188 | { |
| 189 | return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END; |
| 190 | } |
| 191 | |
| 192 | static inline int tcf_em_early_end(struct tcf_ematch *em, int result) |
| 193 | { |
| 194 | if (tcf_em_last_match(em)) |
| 195 | return 1; |
| 196 | |
| 197 | if (result == 0 && em->flags & TCF_EM_REL_AND) |
| 198 | return 1; |
| 199 | |
| 200 | if (result != 0 && em->flags & TCF_EM_REL_OR) |
| 201 | return 1; |
| 202 | |
| 203 | return 0; |
| 204 | } |
| 205 | |
| 206 | /** |
| 207 | * struct tcf_ematch_tree - ematch tree handle |
| 208 | * |
| 209 | * @hdr: ematch tree header supplied by userspace |
| 210 | * @matches: array of ematches |
| 211 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 212 | struct tcf_ematch_tree { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | struct tcf_ematch_tree_hdr hdr; |
| 214 | struct tcf_ematch * matches; |
| 215 | |
| 216 | }; |
| 217 | |
| 218 | /** |
| 219 | * struct tcf_ematch_ops - ematch module operations |
| 220 | * |
| 221 | * @kind: identifier (kind) of this ematch module |
| 222 | * @datalen: length of expected configuration data (optional) |
| 223 | * @change: called during validation (optional) |
| 224 | * @match: called during ematch tree evaluation, must return 1/0 |
| 225 | * @destroy: called during destroyage (optional) |
| 226 | * @dump: called during dumping process (optional) |
| 227 | * @owner: owner, must be set to THIS_MODULE |
| 228 | * @link: link to previous/next ematch module (internal use) |
| 229 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 230 | struct tcf_ematch_ops { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | int kind; |
| 232 | int datalen; |
John Fastabend | 82a470f | 2014-10-05 21:27:53 -0700 | [diff] [blame] | 233 | int (*change)(struct net *net, void *, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | int, struct tcf_ematch *); |
| 235 | int (*match)(struct sk_buff *, struct tcf_ematch *, |
| 236 | struct tcf_pkt_info *); |
John Fastabend | 82a470f | 2014-10-05 21:27:53 -0700 | [diff] [blame] | 237 | void (*destroy)(struct tcf_ematch *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | int (*dump)(struct sk_buff *, struct tcf_ematch *); |
| 239 | struct module *owner; |
| 240 | struct list_head link; |
| 241 | }; |
| 242 | |
Joe Perches | 5c15257 | 2013-07-30 22:47:13 -0700 | [diff] [blame] | 243 | int tcf_em_register(struct tcf_ematch_ops *); |
| 244 | void tcf_em_unregister(struct tcf_ematch_ops *); |
| 245 | int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *, |
| 246 | struct tcf_ematch_tree *); |
John Fastabend | 82a470f | 2014-10-05 21:27:53 -0700 | [diff] [blame] | 247 | void tcf_em_tree_destroy(struct tcf_ematch_tree *); |
Joe Perches | 5c15257 | 2013-07-30 22:47:13 -0700 | [diff] [blame] | 248 | int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int); |
| 249 | int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *, |
| 250 | struct tcf_pkt_info *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | |
| 252 | /** |
| 253 | * tcf_em_tree_change - replace ematch tree of a running classifier |
| 254 | * |
| 255 | * @tp: classifier kind handle |
| 256 | * @dst: destination ematch tree variable |
| 257 | * @src: source ematch tree (temporary tree from tcf_em_tree_validate) |
| 258 | * |
| 259 | * This functions replaces the ematch tree in @dst with the ematch |
| 260 | * tree in @src. The classifier in charge of the ematch tree may be |
| 261 | * running. |
| 262 | */ |
| 263 | static inline void tcf_em_tree_change(struct tcf_proto *tp, |
| 264 | struct tcf_ematch_tree *dst, |
| 265 | struct tcf_ematch_tree *src) |
| 266 | { |
| 267 | tcf_tree_lock(tp); |
| 268 | memcpy(dst, src, sizeof(*dst)); |
| 269 | tcf_tree_unlock(tp); |
| 270 | } |
| 271 | |
| 272 | /** |
| 273 | * tcf_em_tree_match - evaulate an ematch tree |
| 274 | * |
| 275 | * @skb: socket buffer of the packet in question |
| 276 | * @tree: ematch tree to be used for evaluation |
| 277 | * @info: packet information examined by classifier |
| 278 | * |
| 279 | * This function matches @skb against the ematch tree in @tree by going |
| 280 | * through all ematches respecting their logic relations returning |
| 281 | * as soon as the result is obvious. |
| 282 | * |
| 283 | * Returns 1 if the ematch tree as-one matches, no ematches are configured |
| 284 | * or ematch is not enabled in the kernel, otherwise 0 is returned. |
| 285 | */ |
| 286 | static inline int tcf_em_tree_match(struct sk_buff *skb, |
| 287 | struct tcf_ematch_tree *tree, |
| 288 | struct tcf_pkt_info *info) |
| 289 | { |
| 290 | if (tree->hdr.nmatches) |
| 291 | return __tcf_em_tree_match(skb, tree, info); |
| 292 | else |
| 293 | return 1; |
| 294 | } |
| 295 | |
Patrick McHardy | db3d99c | 2007-07-11 19:46:26 -0700 | [diff] [blame] | 296 | #define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind)) |
| 297 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | #else /* CONFIG_NET_EMATCH */ |
| 299 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 300 | struct tcf_ematch_tree { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | }; |
| 302 | |
| 303 | #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0) |
John Fastabend | 82a470f | 2014-10-05 21:27:53 -0700 | [diff] [blame] | 304 | #define tcf_em_tree_destroy(t) do { (void)(t); } while(0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | #define tcf_em_tree_dump(skb, t, tlv) (0) |
| 306 | #define tcf_em_tree_change(tp, dst, src) do { } while(0) |
| 307 | #define tcf_em_tree_match(skb, t, info) ((void)(info), 1) |
| 308 | |
| 309 | #endif /* CONFIG_NET_EMATCH */ |
| 310 | |
| 311 | static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer) |
| 312 | { |
| 313 | switch (layer) { |
| 314 | case TCF_LAYER_LINK: |
| 315 | return skb->data; |
| 316 | case TCF_LAYER_NETWORK: |
Arnaldo Carvalho de Melo | d56f90a | 2007-04-10 20:50:43 -0700 | [diff] [blame] | 317 | return skb_network_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | case TCF_LAYER_TRANSPORT: |
Arnaldo Carvalho de Melo | 9c70220 | 2007-04-25 18:04:18 -0700 | [diff] [blame] | 319 | return skb_transport_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | return NULL; |
| 323 | } |
| 324 | |
Arnaldo Carvalho de Melo | eddc9ec | 2007-04-20 22:47:35 -0700 | [diff] [blame] | 325 | static inline int tcf_valid_offset(const struct sk_buff *skb, |
| 326 | const unsigned char *ptr, const int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | { |
David S. Miller | da521b2 | 2010-12-21 12:43:16 -0800 | [diff] [blame] | 328 | return likely((ptr + len) <= skb_tail_pointer(skb) && |
| 329 | ptr >= skb->head && |
| 330 | (ptr <= (ptr + len))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | } |
| 332 | |
| 333 | #ifdef CONFIG_NET_CLS_IND |
Denis V. Lunev | 0eeb8ff | 2007-12-04 01:15:45 -0800 | [diff] [blame] | 334 | #include <net/net_namespace.h> |
| 335 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | static inline int |
WANG Cong | 2519a60 | 2014-01-09 16:14:02 -0800 | [diff] [blame] | 337 | tcf_change_indev(struct net *net, struct nlattr *indev_tlv) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | { |
WANG Cong | 2519a60 | 2014-01-09 16:14:02 -0800 | [diff] [blame] | 339 | char indev[IFNAMSIZ]; |
Patrick McHardy | c01003c | 2007-03-29 11:46:52 -0700 | [diff] [blame] | 340 | struct net_device *dev; |
| 341 | |
WANG Cong | 2519a60 | 2014-01-09 16:14:02 -0800 | [diff] [blame] | 342 | if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ) |
| 343 | return -EINVAL; |
| 344 | dev = __dev_get_by_name(net, indev); |
| 345 | if (!dev) |
| 346 | return -ENODEV; |
| 347 | return dev->ifindex; |
| 348 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | |
WANG Cong | 2519a60 | 2014-01-09 16:14:02 -0800 | [diff] [blame] | 350 | static inline bool |
| 351 | tcf_match_indev(struct sk_buff *skb, int ifindex) |
| 352 | { |
| 353 | if (!ifindex) |
| 354 | return true; |
| 355 | if (!skb->skb_iif) |
| 356 | return false; |
| 357 | return ifindex == skb->skb_iif; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | } |
| 359 | #endif /* CONFIG_NET_CLS_IND */ |
| 360 | |
John Fastabend | a1b7c5f | 2016-02-16 21:17:09 -0800 | [diff] [blame] | 361 | struct tc_cls_u32_knode { |
| 362 | struct tcf_exts *exts; |
John Fastabend | e014860 | 2016-02-17 14:59:30 -0800 | [diff] [blame] | 363 | struct tc_u32_sel *sel; |
John Fastabend | a1b7c5f | 2016-02-16 21:17:09 -0800 | [diff] [blame] | 364 | u32 handle; |
| 365 | u32 val; |
| 366 | u32 mask; |
| 367 | u32 link_handle; |
John Fastabend | e014860 | 2016-02-17 14:59:30 -0800 | [diff] [blame] | 368 | u8 fshift; |
John Fastabend | a1b7c5f | 2016-02-16 21:17:09 -0800 | [diff] [blame] | 369 | }; |
| 370 | |
| 371 | struct tc_cls_u32_hnode { |
| 372 | u32 handle; |
| 373 | u32 prio; |
| 374 | unsigned int divisor; |
| 375 | }; |
| 376 | |
| 377 | enum tc_clsu32_command { |
| 378 | TC_CLSU32_NEW_KNODE, |
| 379 | TC_CLSU32_REPLACE_KNODE, |
| 380 | TC_CLSU32_DELETE_KNODE, |
| 381 | TC_CLSU32_NEW_HNODE, |
| 382 | TC_CLSU32_REPLACE_HNODE, |
| 383 | TC_CLSU32_DELETE_HNODE, |
| 384 | }; |
| 385 | |
| 386 | struct tc_cls_u32_offload { |
| 387 | /* knode values */ |
| 388 | enum tc_clsu32_command command; |
| 389 | union { |
| 390 | struct tc_cls_u32_knode knode; |
| 391 | struct tc_cls_u32_hnode hnode; |
| 392 | }; |
| 393 | }; |
| 394 | |
John Fastabend | 9e8ce79 | 2016-02-26 07:54:39 -0800 | [diff] [blame] | 395 | static inline bool tc_should_offload(struct net_device *dev, u32 flags) |
John Fastabend | 6843e7a | 2016-02-26 07:53:49 -0800 | [diff] [blame] | 396 | { |
John Fastabend | 2b6ab0d | 2016-02-26 07:54:13 -0800 | [diff] [blame] | 397 | if (!(dev->features & NETIF_F_HW_TC)) |
| 398 | return false; |
| 399 | |
John Fastabend | 9e8ce79 | 2016-02-26 07:54:39 -0800 | [diff] [blame] | 400 | if (flags & TCA_CLS_FLAGS_SKIP_HW) |
| 401 | return false; |
| 402 | |
| 403 | if (!dev->netdev_ops->ndo_setup_tc) |
| 404 | return false; |
| 405 | |
| 406 | return true; |
John Fastabend | 6843e7a | 2016-02-26 07:53:49 -0800 | [diff] [blame] | 407 | } |
| 408 | |
Samudrala, Sridhar | d34e3e1 | 2016-05-12 17:08:23 -0700 | [diff] [blame] | 409 | static inline bool tc_skip_sw(u32 flags) |
| 410 | { |
| 411 | return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false; |
| 412 | } |
| 413 | |
| 414 | /* SKIP_HW and SKIP_SW are mutually exclusive flags. */ |
| 415 | static inline bool tc_flags_valid(u32 flags) |
| 416 | { |
| 417 | if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW)) |
| 418 | return false; |
| 419 | |
| 420 | if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))) |
| 421 | return false; |
| 422 | |
| 423 | return true; |
| 424 | } |
| 425 | |
Amir Vadai | 5b33f48 | 2016-03-08 12:42:29 +0200 | [diff] [blame] | 426 | enum tc_fl_command { |
| 427 | TC_CLSFLOWER_REPLACE, |
| 428 | TC_CLSFLOWER_DESTROY, |
Amir Vadai | 10cbc68 | 2016-05-13 12:55:37 +0000 | [diff] [blame] | 429 | TC_CLSFLOWER_STATS, |
Amir Vadai | 5b33f48 | 2016-03-08 12:42:29 +0200 | [diff] [blame] | 430 | }; |
| 431 | |
| 432 | struct tc_cls_flower_offload { |
| 433 | enum tc_fl_command command; |
Amir Vadai | 8208d21 | 2016-03-11 11:08:45 +0200 | [diff] [blame] | 434 | unsigned long cookie; |
Amir Vadai | 5b33f48 | 2016-03-08 12:42:29 +0200 | [diff] [blame] | 435 | struct flow_dissector *dissector; |
| 436 | struct fl_flow_key *mask; |
| 437 | struct fl_flow_key *key; |
| 438 | struct tcf_exts *exts; |
| 439 | }; |
| 440 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | #endif |