1b2441318SGreg Kroah-Hartman /* SPDX-License-Identifier: GPL-2.0 */ 21da177e4SLinus Torvalds #ifndef __NET_PKT_CLS_H 31da177e4SLinus Torvalds #define __NET_PKT_CLS_H 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds #include <linux/pkt_cls.h> 67aa0045dSCong Wang #include <linux/workqueue.h> 71da177e4SLinus Torvalds #include <net/sch_generic.h> 81da177e4SLinus Torvalds #include <net/act_api.h> 91da177e4SLinus Torvalds 101da177e4SLinus Torvalds /* Basic packet classifier frontend definitions. */ 111da177e4SLinus Torvalds 12fd2c3ef7SEric Dumazet struct tcf_walker { 131da177e4SLinus Torvalds int stop; 141da177e4SLinus Torvalds int skip; 151da177e4SLinus Torvalds int count; 1601683a14SVlad Buslov unsigned long cookie; 178113c095SWANG Cong int (*fn)(struct tcf_proto *, void *node, struct tcf_walker *); 181da177e4SLinus Torvalds }; 191da177e4SLinus Torvalds 205c15257fSJoe Perches int register_tcf_proto_ops(struct tcf_proto_ops *ops); 215c15257fSJoe Perches int unregister_tcf_proto_ops(struct tcf_proto_ops *ops); 221da177e4SLinus Torvalds 238c4083b3SJiri Pirko enum tcf_block_binder_type { 248c4083b3SJiri Pirko TCF_BLOCK_BINDER_TYPE_UNSPEC, 256e40cf2dSJiri Pirko TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS, 266e40cf2dSJiri Pirko TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS, 278c4083b3SJiri Pirko }; 288c4083b3SJiri Pirko 298c4083b3SJiri Pirko struct tcf_block_ext_info { 308c4083b3SJiri Pirko enum tcf_block_binder_type binder_type; 31c7eb7d72SJiri Pirko tcf_chain_head_change_t *chain_head_change; 32c7eb7d72SJiri Pirko void *chain_head_change_priv; 3348617387SJiri Pirko u32 block_index; 348c4083b3SJiri Pirko }; 358c4083b3SJiri Pirko 36acb67442SJiri Pirko struct tcf_block_cb; 37aaa908ffSCong Wang bool tcf_queue_work(struct rcu_work *rwork, work_func_t func); 38acb67442SJiri Pirko 398ae70032SJiri Pirko #ifdef CONFIG_NET_CLS 40367a8ce8SWANG Cong struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index, 41367a8ce8SWANG Cong bool create); 421f3ed383SJiri Pirko struct tcf_chain *tcf_chain_get_by_act(struct tcf_block *block, 431f3ed383SJiri Pirko u32 chain_index); 445bc17018SJiri Pirko void tcf_chain_put(struct tcf_chain *chain); 451f3ed383SJiri Pirko void tcf_chain_put_by_act(struct tcf_chain *chain); 46f36fe1c4SJiri Pirko void tcf_block_netif_keep_dst(struct tcf_block *block); 476529eabaSJiri Pirko int tcf_block_get(struct tcf_block **p_block, 488d1a77f9SAlexander Aring struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q, 498d1a77f9SAlexander Aring struct netlink_ext_ack *extack); 50c7eb7d72SJiri Pirko int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q, 518d1a77f9SAlexander Aring struct tcf_block_ext_info *ei, 528d1a77f9SAlexander Aring struct netlink_ext_ack *extack); 536529eabaSJiri Pirko void tcf_block_put(struct tcf_block *block); 54c7eb7d72SJiri Pirko void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q, 558c4083b3SJiri Pirko struct tcf_block_ext_info *ei); 5644186460SJiri Pirko 5748617387SJiri Pirko static inline bool tcf_block_shared(struct tcf_block *block) 5848617387SJiri Pirko { 5948617387SJiri Pirko return block->index; 6048617387SJiri Pirko } 6148617387SJiri Pirko 6244186460SJiri Pirko static inline struct Qdisc *tcf_block_q(struct tcf_block *block) 6344186460SJiri Pirko { 6448617387SJiri Pirko WARN_ON(tcf_block_shared(block)); 6544186460SJiri Pirko return block->q; 6644186460SJiri Pirko } 6744186460SJiri Pirko 6844186460SJiri Pirko static inline struct net_device *tcf_block_dev(struct tcf_block *block) 6944186460SJiri Pirko { 7044186460SJiri Pirko return tcf_block_q(block)->dev_queue->dev; 7144186460SJiri Pirko } 7244186460SJiri Pirko 73acb67442SJiri Pirko void *tcf_block_cb_priv(struct tcf_block_cb *block_cb); 74acb67442SJiri Pirko struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block, 75acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident); 76acb67442SJiri Pirko void tcf_block_cb_incref(struct tcf_block_cb *block_cb); 77acb67442SJiri Pirko unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb); 78acb67442SJiri Pirko struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block, 79acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident, 8060513bd8SJohn Hurley void *cb_priv, 8160513bd8SJohn Hurley struct netlink_ext_ack *extack); 82acb67442SJiri Pirko int tcf_block_cb_register(struct tcf_block *block, 83acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident, 8460513bd8SJohn Hurley void *cb_priv, struct netlink_ext_ack *extack); 8532636742SJohn Hurley void __tcf_block_cb_unregister(struct tcf_block *block, 8632636742SJohn Hurley struct tcf_block_cb *block_cb); 87acb67442SJiri Pirko void tcf_block_cb_unregister(struct tcf_block *block, 88acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident); 89acb67442SJiri Pirko 9087d83093SJiri Pirko int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp, 9187d83093SJiri Pirko struct tcf_result *res, bool compat_mode); 9287d83093SJiri Pirko 938ae70032SJiri Pirko #else 946529eabaSJiri Pirko static inline 956529eabaSJiri Pirko int tcf_block_get(struct tcf_block **p_block, 963c149091SSudip Mukherjee struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q, 973c149091SSudip Mukherjee struct netlink_ext_ack *extack) 986529eabaSJiri Pirko { 996529eabaSJiri Pirko return 0; 1006529eabaSJiri Pirko } 1016529eabaSJiri Pirko 1028c4083b3SJiri Pirko static inline 103c7eb7d72SJiri Pirko int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q, 10433c30a8bSQuentin Monnet struct tcf_block_ext_info *ei, 10533c30a8bSQuentin Monnet struct netlink_ext_ack *extack) 1068c4083b3SJiri Pirko { 1078c4083b3SJiri Pirko return 0; 1088c4083b3SJiri Pirko } 1098c4083b3SJiri Pirko 1106529eabaSJiri Pirko static inline void tcf_block_put(struct tcf_block *block) 1118ae70032SJiri Pirko { 1128ae70032SJiri Pirko } 11387d83093SJiri Pirko 1148c4083b3SJiri Pirko static inline 115c7eb7d72SJiri Pirko void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q, 1168c4083b3SJiri Pirko struct tcf_block_ext_info *ei) 1178c4083b3SJiri Pirko { 1188c4083b3SJiri Pirko } 1198c4083b3SJiri Pirko 12044186460SJiri Pirko static inline struct Qdisc *tcf_block_q(struct tcf_block *block) 12144186460SJiri Pirko { 12244186460SJiri Pirko return NULL; 12344186460SJiri Pirko } 12444186460SJiri Pirko 12544186460SJiri Pirko static inline struct net_device *tcf_block_dev(struct tcf_block *block) 12644186460SJiri Pirko { 12744186460SJiri Pirko return NULL; 12844186460SJiri Pirko } 12944186460SJiri Pirko 130acb67442SJiri Pirko static inline 131acb67442SJiri Pirko int tc_setup_cb_block_register(struct tcf_block *block, tc_setup_cb_t *cb, 132acb67442SJiri Pirko void *cb_priv) 133acb67442SJiri Pirko { 134acb67442SJiri Pirko return 0; 135acb67442SJiri Pirko } 136acb67442SJiri Pirko 137acb67442SJiri Pirko static inline 138acb67442SJiri Pirko void tc_setup_cb_block_unregister(struct tcf_block *block, tc_setup_cb_t *cb, 139acb67442SJiri Pirko void *cb_priv) 140acb67442SJiri Pirko { 141acb67442SJiri Pirko } 142acb67442SJiri Pirko 143acb67442SJiri Pirko static inline 144acb67442SJiri Pirko void *tcf_block_cb_priv(struct tcf_block_cb *block_cb) 145acb67442SJiri Pirko { 146acb67442SJiri Pirko return NULL; 147acb67442SJiri Pirko } 148acb67442SJiri Pirko 149acb67442SJiri Pirko static inline 150acb67442SJiri Pirko struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block, 151acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident) 152acb67442SJiri Pirko { 153acb67442SJiri Pirko return NULL; 154acb67442SJiri Pirko } 155acb67442SJiri Pirko 156acb67442SJiri Pirko static inline 157acb67442SJiri Pirko void tcf_block_cb_incref(struct tcf_block_cb *block_cb) 158acb67442SJiri Pirko { 159acb67442SJiri Pirko } 160acb67442SJiri Pirko 161acb67442SJiri Pirko static inline 162acb67442SJiri Pirko unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb) 163acb67442SJiri Pirko { 164acb67442SJiri Pirko return 0; 165acb67442SJiri Pirko } 166acb67442SJiri Pirko 167acb67442SJiri Pirko static inline 168acb67442SJiri Pirko struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block, 169acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident, 17060513bd8SJohn Hurley void *cb_priv, 17160513bd8SJohn Hurley struct netlink_ext_ack *extack) 172acb67442SJiri Pirko { 173acb67442SJiri Pirko return NULL; 174acb67442SJiri Pirko } 175acb67442SJiri Pirko 176acb67442SJiri Pirko static inline 177acb67442SJiri Pirko int tcf_block_cb_register(struct tcf_block *block, 178acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident, 17960513bd8SJohn Hurley void *cb_priv, struct netlink_ext_ack *extack) 180acb67442SJiri Pirko { 181acb67442SJiri Pirko return 0; 182acb67442SJiri Pirko } 183acb67442SJiri Pirko 184acb67442SJiri Pirko static inline 18532636742SJohn Hurley void __tcf_block_cb_unregister(struct tcf_block *block, 18632636742SJohn Hurley struct tcf_block_cb *block_cb) 187acb67442SJiri Pirko { 188acb67442SJiri Pirko } 189acb67442SJiri Pirko 190acb67442SJiri Pirko static inline 191acb67442SJiri Pirko void tcf_block_cb_unregister(struct tcf_block *block, 192acb67442SJiri Pirko tc_setup_cb_t *cb, void *cb_ident) 193acb67442SJiri Pirko { 194acb67442SJiri Pirko } 195acb67442SJiri Pirko 19687d83093SJiri Pirko static inline int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp, 19787d83093SJiri Pirko struct tcf_result *res, bool compat_mode) 19887d83093SJiri Pirko { 19987d83093SJiri Pirko return TC_ACT_UNSPEC; 20087d83093SJiri Pirko } 2018ae70032SJiri Pirko #endif 202cf1facdaSJiri Pirko 2031da177e4SLinus Torvalds static inline unsigned long 2041da177e4SLinus Torvalds __cls_set_class(unsigned long *clp, unsigned long cl) 2051da177e4SLinus Torvalds { 206a0efb80cSWANG Cong return xchg(clp, cl); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds static inline unsigned long 21034e3759cSJiri Pirko cls_set_class(struct Qdisc *q, unsigned long *clp, unsigned long cl) 2111da177e4SLinus Torvalds { 2121da177e4SLinus Torvalds unsigned long old_cl; 2131da177e4SLinus Torvalds 21434e3759cSJiri Pirko sch_tree_lock(q); 2151da177e4SLinus Torvalds old_cl = __cls_set_class(clp, cl); 21634e3759cSJiri Pirko sch_tree_unlock(q); 2171da177e4SLinus Torvalds return old_cl; 2181da177e4SLinus Torvalds } 2191da177e4SLinus Torvalds 2201da177e4SLinus Torvalds static inline void 2211da177e4SLinus Torvalds tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base) 2221da177e4SLinus Torvalds { 22334e3759cSJiri Pirko struct Qdisc *q = tp->chain->block->q; 2241da177e4SLinus Torvalds unsigned long cl; 2251da177e4SLinus Torvalds 22634e3759cSJiri Pirko /* Check q as it is not set for shared blocks. In that case, 22734e3759cSJiri Pirko * setting class is not supported. 22834e3759cSJiri Pirko */ 22934e3759cSJiri Pirko if (!q) 23034e3759cSJiri Pirko return; 23134e3759cSJiri Pirko cl = q->ops->cl_ops->bind_tcf(q, base, r->classid); 23234e3759cSJiri Pirko cl = cls_set_class(q, &r->class, cl); 2331da177e4SLinus Torvalds if (cl) 23434e3759cSJiri Pirko q->ops->cl_ops->unbind_tcf(q, cl); 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds static inline void 2381da177e4SLinus Torvalds tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r) 2391da177e4SLinus Torvalds { 24034e3759cSJiri Pirko struct Qdisc *q = tp->chain->block->q; 2411da177e4SLinus Torvalds unsigned long cl; 2421da177e4SLinus Torvalds 24334e3759cSJiri Pirko if (!q) 24434e3759cSJiri Pirko return; 2451da177e4SLinus Torvalds if ((cl = __cls_set_class(&r->class, 0)) != 0) 24634e3759cSJiri Pirko q->ops->cl_ops->unbind_tcf(q, cl); 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds 249fd2c3ef7SEric Dumazet struct tcf_exts { 2501da177e4SLinus Torvalds #ifdef CONFIG_NET_CLS_ACT 25133be6271SWANG Cong __u32 type; /* for backward compat(TCA_OLD_COMPAT) */ 25222dc13c8SWANG Cong int nr_actions; 25322dc13c8SWANG Cong struct tc_action **actions; 254e4b95c41SCong Wang struct net *net; 2551da177e4SLinus Torvalds #endif 2561da177e4SLinus Torvalds /* Map to export classifier specific extension TLV types to the 2571da177e4SLinus Torvalds * generic extensions API. Unsupported extensions must be set to 0. 2581da177e4SLinus Torvalds */ 2591da177e4SLinus Torvalds int action; 2601da177e4SLinus Torvalds int police; 2611da177e4SLinus Torvalds }; 2621da177e4SLinus Torvalds 263b9a24bb7SWANG Cong static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police) 26433be6271SWANG Cong { 26533be6271SWANG Cong #ifdef CONFIG_NET_CLS_ACT 2665da57f42SWANG Cong exts->type = 0; 26722dc13c8SWANG Cong exts->nr_actions = 0; 268e4b95c41SCong Wang exts->net = NULL; 26922dc13c8SWANG Cong exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *), 27022dc13c8SWANG Cong GFP_KERNEL); 271b9a24bb7SWANG Cong if (!exts->actions) 272b9a24bb7SWANG Cong return -ENOMEM; 27333be6271SWANG Cong #endif 2745da57f42SWANG Cong exts->action = action; 2755da57f42SWANG Cong exts->police = police; 276b9a24bb7SWANG Cong return 0; 27733be6271SWANG Cong } 27833be6271SWANG Cong 279e4b95c41SCong Wang /* Return false if the netns is being destroyed in cleanup_net(). Callers 280e4b95c41SCong Wang * need to do cleanup synchronously in this case, otherwise may race with 281e4b95c41SCong Wang * tc_action_net_exit(). Return true for other cases. 282e4b95c41SCong Wang */ 283e4b95c41SCong Wang static inline bool tcf_exts_get_net(struct tcf_exts *exts) 284e4b95c41SCong Wang { 285e4b95c41SCong Wang #ifdef CONFIG_NET_CLS_ACT 286e4b95c41SCong Wang exts->net = maybe_get_net(exts->net); 287e4b95c41SCong Wang return exts->net != NULL; 288e4b95c41SCong Wang #else 289e4b95c41SCong Wang return true; 290e4b95c41SCong Wang #endif 291e4b95c41SCong Wang } 292e4b95c41SCong Wang 293e4b95c41SCong Wang static inline void tcf_exts_put_net(struct tcf_exts *exts) 294e4b95c41SCong Wang { 295e4b95c41SCong Wang #ifdef CONFIG_NET_CLS_ACT 296e4b95c41SCong Wang if (exts->net) 297e4b95c41SCong Wang put_net(exts->net); 298e4b95c41SCong Wang #endif 299e4b95c41SCong Wang } 300e4b95c41SCong Wang 30122dc13c8SWANG Cong static inline void tcf_exts_to_list(const struct tcf_exts *exts, 30222dc13c8SWANG Cong struct list_head *actions) 30322dc13c8SWANG Cong { 30422dc13c8SWANG Cong #ifdef CONFIG_NET_CLS_ACT 30522dc13c8SWANG Cong int i; 30622dc13c8SWANG Cong 30722dc13c8SWANG Cong for (i = 0; i < exts->nr_actions; i++) { 30822dc13c8SWANG Cong struct tc_action *a = exts->actions[i]; 30922dc13c8SWANG Cong 310fa5effe7SHadar Hen Zion list_add_tail(&a->list, actions); 31122dc13c8SWANG Cong } 31222dc13c8SWANG Cong #endif 31322dc13c8SWANG Cong } 31422dc13c8SWANG Cong 315d897a638SJakub Kicinski static inline void 316d897a638SJakub Kicinski tcf_exts_stats_update(const struct tcf_exts *exts, 317d897a638SJakub Kicinski u64 bytes, u64 packets, u64 lastuse) 318d897a638SJakub Kicinski { 319d897a638SJakub Kicinski #ifdef CONFIG_NET_CLS_ACT 320d897a638SJakub Kicinski int i; 321d897a638SJakub Kicinski 322d897a638SJakub Kicinski preempt_disable(); 323d897a638SJakub Kicinski 324d897a638SJakub Kicinski for (i = 0; i < exts->nr_actions; i++) { 325d897a638SJakub Kicinski struct tc_action *a = exts->actions[i]; 326d897a638SJakub Kicinski 327d897a638SJakub Kicinski tcf_action_stats_update(a, bytes, packets, lastuse); 328d897a638SJakub Kicinski } 329d897a638SJakub Kicinski 330d897a638SJakub Kicinski preempt_enable(); 331d897a638SJakub Kicinski #endif 332d897a638SJakub Kicinski } 333d897a638SJakub Kicinski 3341da177e4SLinus Torvalds /** 3353bcc0cecSJiri Pirko * tcf_exts_has_actions - check if at least one action is present 3363bcc0cecSJiri Pirko * @exts: tc filter extensions handle 3373bcc0cecSJiri Pirko * 3383bcc0cecSJiri Pirko * Returns true if at least one action is present. 3393bcc0cecSJiri Pirko */ 3403bcc0cecSJiri Pirko static inline bool tcf_exts_has_actions(struct tcf_exts *exts) 3413bcc0cecSJiri Pirko { 3422734437eSWANG Cong #ifdef CONFIG_NET_CLS_ACT 3433bcc0cecSJiri Pirko return exts->nr_actions; 3443bcc0cecSJiri Pirko #else 3453bcc0cecSJiri Pirko return false; 3463bcc0cecSJiri Pirko #endif 3473bcc0cecSJiri Pirko } 3482734437eSWANG Cong 3493bcc0cecSJiri Pirko /** 3503bcc0cecSJiri Pirko * tcf_exts_has_one_action - check if exactly one action is present 3513bcc0cecSJiri Pirko * @exts: tc filter extensions handle 3523bcc0cecSJiri Pirko * 3533bcc0cecSJiri Pirko * Returns true if exactly one action is present. 3543bcc0cecSJiri Pirko */ 3553bcc0cecSJiri Pirko static inline bool tcf_exts_has_one_action(struct tcf_exts *exts) 3563bcc0cecSJiri Pirko { 3573bcc0cecSJiri Pirko #ifdef CONFIG_NET_CLS_ACT 3583bcc0cecSJiri Pirko return exts->nr_actions == 1; 3593bcc0cecSJiri Pirko #else 3603bcc0cecSJiri Pirko return false; 3613bcc0cecSJiri Pirko #endif 3623bcc0cecSJiri Pirko } 3632734437eSWANG Cong 364af69afc5SJiri Pirko /** 365af69afc5SJiri Pirko * tcf_exts_exec - execute tc filter extensions 366af69afc5SJiri Pirko * @skb: socket buffer 367af69afc5SJiri Pirko * @exts: tc filter extensions handle 368af69afc5SJiri Pirko * @res: desired result 369af69afc5SJiri Pirko * 370af089e70SJiri Pirko * Executes all configured extensions. Returns TC_ACT_OK on a normal execution, 371af69afc5SJiri Pirko * a negative number if the filter must be considered unmatched or 372af69afc5SJiri Pirko * a positive action code (TC_ACT_*) which must be returned to the 373af69afc5SJiri Pirko * underlying layer. 374af69afc5SJiri Pirko */ 375af69afc5SJiri Pirko static inline int 376af69afc5SJiri Pirko tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts, 377af69afc5SJiri Pirko struct tcf_result *res) 378af69afc5SJiri Pirko { 379af69afc5SJiri Pirko #ifdef CONFIG_NET_CLS_ACT 380ec1a9ccaSJiri Pirko return tcf_action_exec(skb, exts->actions, exts->nr_actions, res); 381af69afc5SJiri Pirko #endif 382af089e70SJiri Pirko return TC_ACT_OK; 383af69afc5SJiri Pirko } 384af69afc5SJiri Pirko 3855c15257fSJoe Perches int tcf_exts_validate(struct net *net, struct tcf_proto *tp, 386c1b52739SBenjamin LaHaise struct nlattr **tb, struct nlattr *rate_tlv, 38750a56190SAlexander Aring struct tcf_exts *exts, bool ovr, 38850a56190SAlexander Aring struct netlink_ext_ack *extack); 38918d0264fSWANG Cong void tcf_exts_destroy(struct tcf_exts *exts); 3909b0d4446SJiri Pirko void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src); 3915da57f42SWANG Cong int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts); 3925da57f42SWANG Cong int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds /** 3951da177e4SLinus Torvalds * struct tcf_pkt_info - packet information 3961da177e4SLinus Torvalds */ 397fd2c3ef7SEric Dumazet struct tcf_pkt_info { 3981da177e4SLinus Torvalds unsigned char * ptr; 3991da177e4SLinus Torvalds int nexthdr; 4001da177e4SLinus Torvalds }; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds #ifdef CONFIG_NET_EMATCH 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds struct tcf_ematch_ops; 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds /** 4071da177e4SLinus Torvalds * struct tcf_ematch - extended match (ematch) 4081da177e4SLinus Torvalds * 4091da177e4SLinus Torvalds * @matchid: identifier to allow userspace to reidentify a match 4101da177e4SLinus Torvalds * @flags: flags specifying attributes and the relation to other matches 4111da177e4SLinus Torvalds * @ops: the operations lookup table of the corresponding ematch module 4121da177e4SLinus Torvalds * @datalen: length of the ematch specific configuration data 4131da177e4SLinus Torvalds * @data: ematch specific data 4141da177e4SLinus Torvalds */ 415fd2c3ef7SEric Dumazet struct tcf_ematch { 4161da177e4SLinus Torvalds struct tcf_ematch_ops * ops; 4171da177e4SLinus Torvalds unsigned long data; 4181da177e4SLinus Torvalds unsigned int datalen; 4191da177e4SLinus Torvalds u16 matchid; 4201da177e4SLinus Torvalds u16 flags; 42182a470f1SJohn Fastabend struct net *net; 4221da177e4SLinus Torvalds }; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds static inline int tcf_em_is_container(struct tcf_ematch *em) 4251da177e4SLinus Torvalds { 4261da177e4SLinus Torvalds return !em->ops; 4271da177e4SLinus Torvalds } 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds static inline int tcf_em_is_simple(struct tcf_ematch *em) 4301da177e4SLinus Torvalds { 4311da177e4SLinus Torvalds return em->flags & TCF_EM_SIMPLE; 4321da177e4SLinus Torvalds } 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds static inline int tcf_em_is_inverted(struct tcf_ematch *em) 4351da177e4SLinus Torvalds { 4361da177e4SLinus Torvalds return em->flags & TCF_EM_INVERT; 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds static inline int tcf_em_last_match(struct tcf_ematch *em) 4401da177e4SLinus Torvalds { 4411da177e4SLinus Torvalds return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END; 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds static inline int tcf_em_early_end(struct tcf_ematch *em, int result) 4451da177e4SLinus Torvalds { 4461da177e4SLinus Torvalds if (tcf_em_last_match(em)) 4471da177e4SLinus Torvalds return 1; 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds if (result == 0 && em->flags & TCF_EM_REL_AND) 4501da177e4SLinus Torvalds return 1; 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds if (result != 0 && em->flags & TCF_EM_REL_OR) 4531da177e4SLinus Torvalds return 1; 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds return 0; 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds /** 4591da177e4SLinus Torvalds * struct tcf_ematch_tree - ematch tree handle 4601da177e4SLinus Torvalds * 4611da177e4SLinus Torvalds * @hdr: ematch tree header supplied by userspace 4621da177e4SLinus Torvalds * @matches: array of ematches 4631da177e4SLinus Torvalds */ 464fd2c3ef7SEric Dumazet struct tcf_ematch_tree { 4651da177e4SLinus Torvalds struct tcf_ematch_tree_hdr hdr; 4661da177e4SLinus Torvalds struct tcf_ematch * matches; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds }; 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /** 4711da177e4SLinus Torvalds * struct tcf_ematch_ops - ematch module operations 4721da177e4SLinus Torvalds * 4731da177e4SLinus Torvalds * @kind: identifier (kind) of this ematch module 4741da177e4SLinus Torvalds * @datalen: length of expected configuration data (optional) 4751da177e4SLinus Torvalds * @change: called during validation (optional) 4761da177e4SLinus Torvalds * @match: called during ematch tree evaluation, must return 1/0 4771da177e4SLinus Torvalds * @destroy: called during destroyage (optional) 4781da177e4SLinus Torvalds * @dump: called during dumping process (optional) 4791da177e4SLinus Torvalds * @owner: owner, must be set to THIS_MODULE 4801da177e4SLinus Torvalds * @link: link to previous/next ematch module (internal use) 4811da177e4SLinus Torvalds */ 482fd2c3ef7SEric Dumazet struct tcf_ematch_ops { 4831da177e4SLinus Torvalds int kind; 4841da177e4SLinus Torvalds int datalen; 48582a470f1SJohn Fastabend int (*change)(struct net *net, void *, 4861da177e4SLinus Torvalds int, struct tcf_ematch *); 4871da177e4SLinus Torvalds int (*match)(struct sk_buff *, struct tcf_ematch *, 4881da177e4SLinus Torvalds struct tcf_pkt_info *); 48982a470f1SJohn Fastabend void (*destroy)(struct tcf_ematch *); 4901da177e4SLinus Torvalds int (*dump)(struct sk_buff *, struct tcf_ematch *); 4911da177e4SLinus Torvalds struct module *owner; 4921da177e4SLinus Torvalds struct list_head link; 4931da177e4SLinus Torvalds }; 4941da177e4SLinus Torvalds 4955c15257fSJoe Perches int tcf_em_register(struct tcf_ematch_ops *); 4965c15257fSJoe Perches void tcf_em_unregister(struct tcf_ematch_ops *); 4975c15257fSJoe Perches int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *, 4981da177e4SLinus Torvalds struct tcf_ematch_tree *); 49982a470f1SJohn Fastabend void tcf_em_tree_destroy(struct tcf_ematch_tree *); 5005c15257fSJoe Perches int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int); 5015c15257fSJoe Perches int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *, 5021da177e4SLinus Torvalds struct tcf_pkt_info *); 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds /** 5051da177e4SLinus Torvalds * tcf_em_tree_match - evaulate an ematch tree 5061da177e4SLinus Torvalds * 5071da177e4SLinus Torvalds * @skb: socket buffer of the packet in question 5081da177e4SLinus Torvalds * @tree: ematch tree to be used for evaluation 5091da177e4SLinus Torvalds * @info: packet information examined by classifier 5101da177e4SLinus Torvalds * 5111da177e4SLinus Torvalds * This function matches @skb against the ematch tree in @tree by going 5121da177e4SLinus Torvalds * through all ematches respecting their logic relations returning 5131da177e4SLinus Torvalds * as soon as the result is obvious. 5141da177e4SLinus Torvalds * 5151da177e4SLinus Torvalds * Returns 1 if the ematch tree as-one matches, no ematches are configured 5161da177e4SLinus Torvalds * or ematch is not enabled in the kernel, otherwise 0 is returned. 5171da177e4SLinus Torvalds */ 5181da177e4SLinus Torvalds static inline int tcf_em_tree_match(struct sk_buff *skb, 5191da177e4SLinus Torvalds struct tcf_ematch_tree *tree, 5201da177e4SLinus Torvalds struct tcf_pkt_info *info) 5211da177e4SLinus Torvalds { 5221da177e4SLinus Torvalds if (tree->hdr.nmatches) 5231da177e4SLinus Torvalds return __tcf_em_tree_match(skb, tree, info); 5241da177e4SLinus Torvalds else 5251da177e4SLinus Torvalds return 1; 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds 528db3d99c0SPatrick McHardy #define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind)) 529db3d99c0SPatrick McHardy 5301da177e4SLinus Torvalds #else /* CONFIG_NET_EMATCH */ 5311da177e4SLinus Torvalds 532fd2c3ef7SEric Dumazet struct tcf_ematch_tree { 5331da177e4SLinus Torvalds }; 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0) 53682a470f1SJohn Fastabend #define tcf_em_tree_destroy(t) do { (void)(t); } while(0) 5371da177e4SLinus Torvalds #define tcf_em_tree_dump(skb, t, tlv) (0) 5381da177e4SLinus Torvalds #define tcf_em_tree_match(skb, t, info) ((void)(info), 1) 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds #endif /* CONFIG_NET_EMATCH */ 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer) 5431da177e4SLinus Torvalds { 5441da177e4SLinus Torvalds switch (layer) { 5451da177e4SLinus Torvalds case TCF_LAYER_LINK: 546d3303a65SWolfgang Bumiller return skb_mac_header(skb); 5471da177e4SLinus Torvalds case TCF_LAYER_NETWORK: 548d56f90a7SArnaldo Carvalho de Melo return skb_network_header(skb); 5491da177e4SLinus Torvalds case TCF_LAYER_TRANSPORT: 5509c70220bSArnaldo Carvalho de Melo return skb_transport_header(skb); 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds return NULL; 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 556eddc9ec5SArnaldo Carvalho de Melo static inline int tcf_valid_offset(const struct sk_buff *skb, 557eddc9ec5SArnaldo Carvalho de Melo const unsigned char *ptr, const int len) 5581da177e4SLinus Torvalds { 559da521b2cSDavid S. Miller return likely((ptr + len) <= skb_tail_pointer(skb) && 560da521b2cSDavid S. Miller ptr >= skb->head && 561da521b2cSDavid S. Miller (ptr <= (ptr + len))); 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds #ifdef CONFIG_NET_CLS_IND 5650eeb8ffcSDenis V. Lunev #include <net/net_namespace.h> 5660eeb8ffcSDenis V. Lunev 5671da177e4SLinus Torvalds static inline int 5681057c55fSAlexander Aring tcf_change_indev(struct net *net, struct nlattr *indev_tlv, 5691057c55fSAlexander Aring struct netlink_ext_ack *extack) 5701da177e4SLinus Torvalds { 5712519a602SWANG Cong char indev[IFNAMSIZ]; 572c01003c2SPatrick McHardy struct net_device *dev; 573c01003c2SPatrick McHardy 5741057c55fSAlexander Aring if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ) { 5751057c55fSAlexander Aring NL_SET_ERR_MSG(extack, "Interface name too long"); 5762519a602SWANG Cong return -EINVAL; 5771057c55fSAlexander Aring } 5782519a602SWANG Cong dev = __dev_get_by_name(net, indev); 5792519a602SWANG Cong if (!dev) 5802519a602SWANG Cong return -ENODEV; 5812519a602SWANG Cong return dev->ifindex; 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5842519a602SWANG Cong static inline bool 5852519a602SWANG Cong tcf_match_indev(struct sk_buff *skb, int ifindex) 5862519a602SWANG Cong { 5872519a602SWANG Cong if (!ifindex) 5882519a602SWANG Cong return true; 5892519a602SWANG Cong if (!skb->skb_iif) 5902519a602SWANG Cong return false; 5912519a602SWANG Cong return ifindex == skb->skb_iif; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds #endif /* CONFIG_NET_CLS_IND */ 5941da177e4SLinus Torvalds 595208c0f4bSJiri Pirko int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts, 596208c0f4bSJiri Pirko enum tc_setup_type type, void *type_data, bool err_stop); 597717503b9SJiri Pirko 5988c4083b3SJiri Pirko enum tc_block_command { 5998c4083b3SJiri Pirko TC_BLOCK_BIND, 6008c4083b3SJiri Pirko TC_BLOCK_UNBIND, 6018c4083b3SJiri Pirko }; 6028c4083b3SJiri Pirko 6038c4083b3SJiri Pirko struct tc_block_offload { 6048c4083b3SJiri Pirko enum tc_block_command command; 6058c4083b3SJiri Pirko enum tcf_block_binder_type binder_type; 6068c4083b3SJiri Pirko struct tcf_block *block; 60760513bd8SJohn Hurley struct netlink_ext_ack *extack; 6088c4083b3SJiri Pirko }; 6098c4083b3SJiri Pirko 6105fd9fc4eSJiri Pirko struct tc_cls_common_offload { 6115fd9fc4eSJiri Pirko u32 chain_index; 6125fd9fc4eSJiri Pirko __be16 protocol; 613d7c1c8d2SJiri Pirko u32 prio; 6148f0b425aSQuentin Monnet struct netlink_ext_ack *extack; 6155fd9fc4eSJiri Pirko }; 6165fd9fc4eSJiri Pirko 617a1b7c5fdSJohn Fastabend struct tc_cls_u32_knode { 618a1b7c5fdSJohn Fastabend struct tcf_exts *exts; 619e014860eSJohn Fastabend struct tc_u32_sel *sel; 620a1b7c5fdSJohn Fastabend u32 handle; 621a1b7c5fdSJohn Fastabend u32 val; 622a1b7c5fdSJohn Fastabend u32 mask; 623a1b7c5fdSJohn Fastabend u32 link_handle; 624e014860eSJohn Fastabend u8 fshift; 625a1b7c5fdSJohn Fastabend }; 626a1b7c5fdSJohn Fastabend 627a1b7c5fdSJohn Fastabend struct tc_cls_u32_hnode { 628a1b7c5fdSJohn Fastabend u32 handle; 629a1b7c5fdSJohn Fastabend u32 prio; 630a1b7c5fdSJohn Fastabend unsigned int divisor; 631a1b7c5fdSJohn Fastabend }; 632a1b7c5fdSJohn Fastabend 633a1b7c5fdSJohn Fastabend enum tc_clsu32_command { 634a1b7c5fdSJohn Fastabend TC_CLSU32_NEW_KNODE, 635a1b7c5fdSJohn Fastabend TC_CLSU32_REPLACE_KNODE, 636a1b7c5fdSJohn Fastabend TC_CLSU32_DELETE_KNODE, 637a1b7c5fdSJohn Fastabend TC_CLSU32_NEW_HNODE, 638a1b7c5fdSJohn Fastabend TC_CLSU32_REPLACE_HNODE, 639a1b7c5fdSJohn Fastabend TC_CLSU32_DELETE_HNODE, 640a1b7c5fdSJohn Fastabend }; 641a1b7c5fdSJohn Fastabend 642a1b7c5fdSJohn Fastabend struct tc_cls_u32_offload { 6435fd9fc4eSJiri Pirko struct tc_cls_common_offload common; 644a1b7c5fdSJohn Fastabend /* knode values */ 645a1b7c5fdSJohn Fastabend enum tc_clsu32_command command; 646a1b7c5fdSJohn Fastabend union { 647a1b7c5fdSJohn Fastabend struct tc_cls_u32_knode knode; 648a1b7c5fdSJohn Fastabend struct tc_cls_u32_hnode hnode; 649a1b7c5fdSJohn Fastabend }; 650a1b7c5fdSJohn Fastabend }; 651a1b7c5fdSJohn Fastabend 6527b06e8aeSJiri Pirko static inline bool tc_can_offload(const struct net_device *dev) 6536843e7a2SJohn Fastabend { 65470b5aee4SJiri Pirko return dev->features & NETIF_F_HW_TC; 6556843e7a2SJohn Fastabend } 6566843e7a2SJohn Fastabend 657f9eda14fSQuentin Monnet static inline bool tc_can_offload_extack(const struct net_device *dev, 658f9eda14fSQuentin Monnet struct netlink_ext_ack *extack) 659f9eda14fSQuentin Monnet { 660f9eda14fSQuentin Monnet bool can = tc_can_offload(dev); 661f9eda14fSQuentin Monnet 662f9eda14fSQuentin Monnet if (!can) 663f9eda14fSQuentin Monnet NL_SET_ERR_MSG(extack, "TC offload is disabled on net device"); 664f9eda14fSQuentin Monnet 665f9eda14fSQuentin Monnet return can; 666f9eda14fSQuentin Monnet } 667f9eda14fSQuentin Monnet 668878db9f0SJakub Kicinski static inline bool 669878db9f0SJakub Kicinski tc_cls_can_offload_and_chain0(const struct net_device *dev, 670878db9f0SJakub Kicinski struct tc_cls_common_offload *common) 671878db9f0SJakub Kicinski { 672878db9f0SJakub Kicinski if (!tc_can_offload_extack(dev, common->extack)) 673878db9f0SJakub Kicinski return false; 674878db9f0SJakub Kicinski if (common->chain_index) { 675878db9f0SJakub Kicinski NL_SET_ERR_MSG(common->extack, 676878db9f0SJakub Kicinski "Driver supports only offload of chain 0"); 677878db9f0SJakub Kicinski return false; 678878db9f0SJakub Kicinski } 679878db9f0SJakub Kicinski return true; 680878db9f0SJakub Kicinski } 681878db9f0SJakub Kicinski 68255330f05SHadar Hen Zion static inline bool tc_skip_hw(u32 flags) 68355330f05SHadar Hen Zion { 68455330f05SHadar Hen Zion return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false; 68555330f05SHadar Hen Zion } 68655330f05SHadar Hen Zion 687d34e3e18SSamudrala, Sridhar static inline bool tc_skip_sw(u32 flags) 688d34e3e18SSamudrala, Sridhar { 689d34e3e18SSamudrala, Sridhar return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false; 690d34e3e18SSamudrala, Sridhar } 691d34e3e18SSamudrala, Sridhar 692d34e3e18SSamudrala, Sridhar /* SKIP_HW and SKIP_SW are mutually exclusive flags. */ 693d34e3e18SSamudrala, Sridhar static inline bool tc_flags_valid(u32 flags) 694d34e3e18SSamudrala, Sridhar { 69581c7288bSMarcelo Ricardo Leitner if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW | 69681c7288bSMarcelo Ricardo Leitner TCA_CLS_FLAGS_VERBOSE)) 697d34e3e18SSamudrala, Sridhar return false; 698d34e3e18SSamudrala, Sridhar 69981c7288bSMarcelo Ricardo Leitner flags &= TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW; 700d34e3e18SSamudrala, Sridhar if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))) 701d34e3e18SSamudrala, Sridhar return false; 702d34e3e18SSamudrala, Sridhar 703d34e3e18SSamudrala, Sridhar return true; 704d34e3e18SSamudrala, Sridhar } 705d34e3e18SSamudrala, Sridhar 706e696028aSOr Gerlitz static inline bool tc_in_hw(u32 flags) 707e696028aSOr Gerlitz { 708e696028aSOr Gerlitz return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false; 709e696028aSOr Gerlitz } 710e696028aSOr Gerlitz 71134832e1cSJakub Kicinski static inline void 71234832e1cSJakub Kicinski tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common, 71334832e1cSJakub Kicinski const struct tcf_proto *tp, u32 flags, 71434832e1cSJakub Kicinski struct netlink_ext_ack *extack) 71534832e1cSJakub Kicinski { 71634832e1cSJakub Kicinski cls_common->chain_index = tp->chain->index; 71734832e1cSJakub Kicinski cls_common->protocol = tp->protocol; 71834832e1cSJakub Kicinski cls_common->prio = tp->prio; 71981c7288bSMarcelo Ricardo Leitner if (tc_skip_sw(flags) || flags & TCA_CLS_FLAGS_VERBOSE) 72034832e1cSJakub Kicinski cls_common->extack = extack; 72134832e1cSJakub Kicinski } 72234832e1cSJakub Kicinski 7235b33f488SAmir Vadai enum tc_fl_command { 7245b33f488SAmir Vadai TC_CLSFLOWER_REPLACE, 7255b33f488SAmir Vadai TC_CLSFLOWER_DESTROY, 72610cbc684SAmir Vadai TC_CLSFLOWER_STATS, 72734738452SJiri Pirko TC_CLSFLOWER_TMPLT_CREATE, 72834738452SJiri Pirko TC_CLSFLOWER_TMPLT_DESTROY, 7295b33f488SAmir Vadai }; 7305b33f488SAmir Vadai 7315b33f488SAmir Vadai struct tc_cls_flower_offload { 7325fd9fc4eSJiri Pirko struct tc_cls_common_offload common; 7335b33f488SAmir Vadai enum tc_fl_command command; 7348208d21bSAmir Vadai unsigned long cookie; 7355b33f488SAmir Vadai struct flow_dissector *dissector; 7365b33f488SAmir Vadai struct fl_flow_key *mask; 7375b33f488SAmir Vadai struct fl_flow_key *key; 7385b33f488SAmir Vadai struct tcf_exts *exts; 739384c181eSAmritha Nambiar u32 classid; 7405b33f488SAmir Vadai }; 7415b33f488SAmir Vadai 742b87f7936SYotam Gigi enum tc_matchall_command { 743b87f7936SYotam Gigi TC_CLSMATCHALL_REPLACE, 744b87f7936SYotam Gigi TC_CLSMATCHALL_DESTROY, 745b87f7936SYotam Gigi }; 746b87f7936SYotam Gigi 747b87f7936SYotam Gigi struct tc_cls_matchall_offload { 7485fd9fc4eSJiri Pirko struct tc_cls_common_offload common; 749b87f7936SYotam Gigi enum tc_matchall_command command; 750b87f7936SYotam Gigi struct tcf_exts *exts; 751b87f7936SYotam Gigi unsigned long cookie; 752b87f7936SYotam Gigi }; 753b87f7936SYotam Gigi 754332ae8e2SJakub Kicinski enum tc_clsbpf_command { 755102740bdSJakub Kicinski TC_CLSBPF_OFFLOAD, 75668d64063SJakub Kicinski TC_CLSBPF_STATS, 757332ae8e2SJakub Kicinski }; 758332ae8e2SJakub Kicinski 759332ae8e2SJakub Kicinski struct tc_cls_bpf_offload { 7605fd9fc4eSJiri Pirko struct tc_cls_common_offload common; 761332ae8e2SJakub Kicinski enum tc_clsbpf_command command; 762332ae8e2SJakub Kicinski struct tcf_exts *exts; 763332ae8e2SJakub Kicinski struct bpf_prog *prog; 764102740bdSJakub Kicinski struct bpf_prog *oldprog; 765332ae8e2SJakub Kicinski const char *name; 766332ae8e2SJakub Kicinski bool exts_integrated; 767332ae8e2SJakub Kicinski }; 768332ae8e2SJakub Kicinski 7694e8b86c0SAmritha Nambiar struct tc_mqprio_qopt_offload { 7704e8b86c0SAmritha Nambiar /* struct tc_mqprio_qopt must always be the first element */ 7714e8b86c0SAmritha Nambiar struct tc_mqprio_qopt qopt; 7724e8b86c0SAmritha Nambiar u16 mode; 7734e8b86c0SAmritha Nambiar u16 shaper; 7744e8b86c0SAmritha Nambiar u32 flags; 7754e8b86c0SAmritha Nambiar u64 min_rate[TC_QOPT_MAX_QUEUE]; 7764e8b86c0SAmritha Nambiar u64 max_rate[TC_QOPT_MAX_QUEUE]; 7774e8b86c0SAmritha Nambiar }; 7781045ba77SJamal Hadi Salim 7791045ba77SJamal Hadi Salim /* This structure holds cookie structure that is passed from user 7801045ba77SJamal Hadi Salim * to the kernel for actions and classifiers 7811045ba77SJamal Hadi Salim */ 7821045ba77SJamal Hadi Salim struct tc_cookie { 7831045ba77SJamal Hadi Salim u8 *data; 7841045ba77SJamal Hadi Salim u32 len; 785eec94fdbSVlad Buslov struct rcu_head rcu; 7861045ba77SJamal Hadi Salim }; 787602f3bafSNogah Frankel 788f34b4aacSNogah Frankel struct tc_qopt_offload_stats { 789f34b4aacSNogah Frankel struct gnet_stats_basic_packed *bstats; 790f34b4aacSNogah Frankel struct gnet_stats_queue *qstats; 791f34b4aacSNogah Frankel }; 792f34b4aacSNogah Frankel 793f971b132SJakub Kicinski enum tc_mq_command { 794f971b132SJakub Kicinski TC_MQ_CREATE, 795f971b132SJakub Kicinski TC_MQ_DESTROY, 79647c669a4SJakub Kicinski TC_MQ_STATS, 797f971b132SJakub Kicinski }; 798f971b132SJakub Kicinski 799f971b132SJakub Kicinski struct tc_mq_qopt_offload { 800f971b132SJakub Kicinski enum tc_mq_command command; 801f971b132SJakub Kicinski u32 handle; 80247c669a4SJakub Kicinski struct tc_qopt_offload_stats stats; 803f971b132SJakub Kicinski }; 804f971b132SJakub Kicinski 805602f3bafSNogah Frankel enum tc_red_command { 806602f3bafSNogah Frankel TC_RED_REPLACE, 807602f3bafSNogah Frankel TC_RED_DESTROY, 808602f3bafSNogah Frankel TC_RED_STATS, 809602f3bafSNogah Frankel TC_RED_XSTATS, 810602f3bafSNogah Frankel }; 811602f3bafSNogah Frankel 812602f3bafSNogah Frankel struct tc_red_qopt_offload_params { 813602f3bafSNogah Frankel u32 min; 814602f3bafSNogah Frankel u32 max; 815602f3bafSNogah Frankel u32 probability; 816602f3bafSNogah Frankel bool is_ecn; 817416ef9b1SJakub Kicinski struct gnet_stats_queue *qstats; 818602f3bafSNogah Frankel }; 819602f3bafSNogah Frankel 820602f3bafSNogah Frankel struct tc_red_qopt_offload { 821602f3bafSNogah Frankel enum tc_red_command command; 822602f3bafSNogah Frankel u32 handle; 823602f3bafSNogah Frankel u32 parent; 824602f3bafSNogah Frankel union { 825602f3bafSNogah Frankel struct tc_red_qopt_offload_params set; 826f34b4aacSNogah Frankel struct tc_qopt_offload_stats stats; 827602f3bafSNogah Frankel struct red_stats *xstats; 828602f3bafSNogah Frankel }; 829602f3bafSNogah Frankel }; 830602f3bafSNogah Frankel 8317fdb61b4SNogah Frankel enum tc_prio_command { 8327fdb61b4SNogah Frankel TC_PRIO_REPLACE, 8337fdb61b4SNogah Frankel TC_PRIO_DESTROY, 8347fdb61b4SNogah Frankel TC_PRIO_STATS, 835b9c7a7acSNogah Frankel TC_PRIO_GRAFT, 8367fdb61b4SNogah Frankel }; 8377fdb61b4SNogah Frankel 8387fdb61b4SNogah Frankel struct tc_prio_qopt_offload_params { 8397fdb61b4SNogah Frankel int bands; 8407fdb61b4SNogah Frankel u8 priomap[TC_PRIO_MAX + 1]; 8417fdb61b4SNogah Frankel /* In case that a prio qdisc is offloaded and now is changed to a 8427fdb61b4SNogah Frankel * non-offloadedable config, it needs to update the backlog & qlen 8437fdb61b4SNogah Frankel * values to negate the HW backlog & qlen values (and only them). 8447fdb61b4SNogah Frankel */ 8457fdb61b4SNogah Frankel struct gnet_stats_queue *qstats; 8467fdb61b4SNogah Frankel }; 8477fdb61b4SNogah Frankel 848b9c7a7acSNogah Frankel struct tc_prio_qopt_offload_graft_params { 849b9c7a7acSNogah Frankel u8 band; 850b9c7a7acSNogah Frankel u32 child_handle; 851b9c7a7acSNogah Frankel }; 852b9c7a7acSNogah Frankel 8537fdb61b4SNogah Frankel struct tc_prio_qopt_offload { 8547fdb61b4SNogah Frankel enum tc_prio_command command; 8557fdb61b4SNogah Frankel u32 handle; 8567fdb61b4SNogah Frankel u32 parent; 8577fdb61b4SNogah Frankel union { 8587fdb61b4SNogah Frankel struct tc_prio_qopt_offload_params replace_params; 8597fdb61b4SNogah Frankel struct tc_qopt_offload_stats stats; 860b9c7a7acSNogah Frankel struct tc_prio_qopt_offload_graft_params graft_params; 8617fdb61b4SNogah Frankel }; 8627fdb61b4SNogah Frankel }; 863b9c7a7acSNogah Frankel 8641da177e4SLinus Torvalds #endif 865