static bool
 tc_act_can_offload_accept(struct mlx5e_tc_act_parse_state *parse_state,
                          const struct flow_action_entry *act,
-                         int act_index)
+                         int act_index,
+                         struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
 struct mlx5e_tc_act {
        bool (*can_offload)(struct mlx5e_tc_act_parse_state *parse_state,
                            const struct flow_action_entry *act,
-                           int act_index);
+                           int act_index,
+                           struct mlx5_flow_attr *attr);
 
        int (*parse_action)(struct mlx5e_tc_act_parse_state *parse_state,
                            const struct flow_action_entry *act,
 
 static bool
 tc_act_can_offload_csum(struct mlx5e_tc_act_parse_state *parse_state,
                        const struct flow_action_entry *act,
-                       int act_index)
+                       int act_index,
+                       struct mlx5_flow_attr *attr)
 {
        struct mlx5e_tc_flow *flow = parse_state->flow;
 
-       return csum_offload_supported(flow->priv, flow->attr->action,
+       return csum_offload_supported(flow->priv, attr->action,
                                      act->csum_flags, parse_state->extack);
 }
 
 
 static bool
 tc_act_can_offload_ct(struct mlx5e_tc_act_parse_state *parse_state,
                      const struct flow_action_entry *act,
-                     int act_index)
+                     int act_index,
+                     struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
 
 
 static bool
 tc_act_can_offload_drop(struct mlx5e_tc_act_parse_state *parse_state,
                        const struct flow_action_entry *act,
-                       int act_index)
+                       int act_index,
+                       struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
 static int
 validate_goto_chain(struct mlx5e_priv *priv,
                    struct mlx5e_tc_flow *flow,
+                   struct mlx5_flow_attr *attr,
                    const struct flow_action_entry *act,
                    struct netlink_ext_ack *extack)
 {
        }
 
        if (!mlx5_chains_backwards_supported(chains) &&
-           dest_chain <= flow->attr->chain) {
+           dest_chain <= attr->chain) {
                NL_SET_ERR_MSG_MOD(extack, "Goto lower numbered chain isn't supported");
                return -EOPNOTSUPP;
        }
                return -EOPNOTSUPP;
        }
 
-       if (flow->attr->action & (MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT |
-                                 MLX5_FLOW_CONTEXT_ACTION_DECAP) &&
+       if (attr->action & (MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT |
+                           MLX5_FLOW_CONTEXT_ACTION_DECAP) &&
            !reformat_and_fwd) {
                NL_SET_ERR_MSG_MOD(extack,
                                   "Goto chain is not allowed if action has reformat or decap");
 static bool
 tc_act_can_offload_goto(struct mlx5e_tc_act_parse_state *parse_state,
                        const struct flow_action_entry *act,
-                       int act_index)
+                       int act_index,
+                       struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
        struct mlx5e_tc_flow *flow = parse_state->flow;
 
-       if (validate_goto_chain(flow->priv, flow, act, extack))
+       if (validate_goto_chain(flow->priv, flow, attr, act, extack))
                return false;
 
        return true;
 
 static bool
 tc_act_can_offload_mark(struct mlx5e_tc_act_parse_state *parse_state,
                        const struct flow_action_entry *act,
-                       int act_index)
+                       int act_index,
+                       struct mlx5_flow_attr *attr)
 {
        if (act->mark & ~MLX5E_TC_FLOW_ID_MASK) {
                NL_SET_ERR_MSG_MOD(parse_state->extack, "Bad flow mark, only 16 bit supported");
 
 static bool
 tc_act_can_offload_mirred(struct mlx5e_tc_act_parse_state *parse_state,
                          const struct flow_action_entry *act,
-                         int act_index)
+                         int act_index,
+                         struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
        struct mlx5e_tc_flow *flow = parse_state->flow;
        struct mlx5e_priv *priv = flow->priv;
        struct mlx5_esw_flow_attr *esw_attr;
 
-       parse_attr = flow->attr->parse_attr;
-       esw_attr = flow->attr->esw_attr;
+       parse_attr = attr->parse_attr;
+       esw_attr = attr->esw_attr;
 
        if (!out_dev) {
                /* out_dev is NULL when filters with
 
 static bool
 tc_act_can_offload_mirred_nic(struct mlx5e_tc_act_parse_state *parse_state,
                              const struct flow_action_entry *act,
-                             int act_index)
+                             int act_index,
+                             struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
        struct mlx5e_tc_flow *flow = parse_state->flow;
 
 static bool
 tc_act_can_offload_mpls_push(struct mlx5e_tc_act_parse_state *parse_state,
                             const struct flow_action_entry *act,
-                            int act_index)
+                            int act_index,
+                            struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
        struct mlx5e_priv *priv = parse_state->flow->priv;
 static bool
 tc_act_can_offload_mpls_pop(struct mlx5e_tc_act_parse_state *parse_state,
                            const struct flow_action_entry *act,
-                           int act_index)
+                           int act_index,
+                           struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
-       struct mlx5e_tc_flow *flow = parse_state->flow;
        struct net_device *filter_dev;
 
-       filter_dev = flow->attr->parse_attr->filter_dev;
+       filter_dev = attr->parse_attr->filter_dev;
 
        /* we only support mpls pop if it is the first action
         * and the filter net device is bareudp. Subsequent
 
 static bool
 tc_act_can_offload_pedit(struct mlx5e_tc_act_parse_state *parse_state,
                         const struct flow_action_entry *act,
-                        int act_index)
+                        int act_index,
+                        struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
 static bool
 tc_act_can_offload_ptype(struct mlx5e_tc_act_parse_state *parse_state,
                         const struct flow_action_entry *act,
-                        int act_index)
+                        int act_index,
+                        struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
 static bool
 tc_act_can_offload_redirect_ingress(struct mlx5e_tc_act_parse_state *parse_state,
                                    const struct flow_action_entry *act,
-                                   int act_index)
+                                   int act_index,
+                                   struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
-       struct mlx5e_tc_flow *flow = parse_state->flow;
        struct mlx5e_tc_flow_parse_attr *parse_attr;
        struct net_device *out_dev = act->dev;
        struct mlx5_esw_flow_attr *esw_attr;
 
-       parse_attr = flow->attr->parse_attr;
-       esw_attr = flow->attr->esw_attr;
+       parse_attr = attr->parse_attr;
+       esw_attr = attr->esw_attr;
 
        if (!out_dev)
                return false;
 
 static bool
 tc_act_can_offload_sample(struct mlx5e_tc_act_parse_state *parse_state,
                          const struct flow_action_entry *act,
-                         int act_index)
+                         int act_index,
+                         struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
 
 
 static bool
 tc_act_can_offload_trap(struct mlx5e_tc_act_parse_state *parse_state,
                        const struct flow_action_entry *act,
-                       int act_index)
+                       int act_index,
+                       struct mlx5_flow_attr *attr)
 {
        struct netlink_ext_ack *extack = parse_state->extack;
 
 
 static bool
 tc_act_can_offload_tun_encap(struct mlx5e_tc_act_parse_state *parse_state,
                             const struct flow_action_entry *act,
-                            int act_index)
+                            int act_index,
+                            struct mlx5_flow_attr *attr)
 {
        if (!act->tunnel) {
                NL_SET_ERR_MSG_MOD(parse_state->extack,
 static bool
 tc_act_can_offload_tun_decap(struct mlx5e_tc_act_parse_state *parse_state,
                             const struct flow_action_entry *act,
-                            int act_index)
+                            int act_index,
+                            struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
 static bool
 tc_act_can_offload_vlan(struct mlx5e_tc_act_parse_state *parse_state,
                        const struct flow_action_entry *act,
-                       int act_index)
+                       int act_index,
+                       struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
 static bool
 tc_act_can_offload_vlan_mangle(struct mlx5e_tc_act_parse_state *parse_state,
                               const struct flow_action_entry *act,
-                              int act_index)
+                              int act_index,
+                              struct mlx5_flow_attr *attr)
 {
        return true;
 }
 
                        return -EOPNOTSUPP;
                }
 
-               if (!tc_act->can_offload(parse_state, act, i))
+               if (!tc_act->can_offload(parse_state, act, i, attr))
                        return -EOPNOTSUPP;
 
                err = tc_act->parse_action(parse_state, act, priv, attr);
        flow_action_for_each(i, act, flow_action) {
                tc_act = mlx5e_tc_act_get(act->id, ns_type);
                if (!tc_act || !tc_act->post_parse ||
-                   !tc_act->can_offload(parse_state, act, i))
+                   !tc_act->can_offload(parse_state, act, i, attr))
                        continue;
 
                err = tc_act->post_parse(parse_state, priv, attr);