.action = attr->action,
                .flow_tag = attr->flow_tag,
                .encap_id = 0,
-               .modify_id = attr->mod_hdr_id,
        };
        struct mlx5_fc *counter = NULL;
        struct mlx5_flow_handle *rule;
                                               parse_attr->num_mod_hdr_actions,
                                               parse_attr->mod_hdr_actions,
                                               &attr->mod_hdr_id);
+               flow_act.modify_id = attr->mod_hdr_id;
                kfree(parse_attr->mod_hdr_actions);
                if (err) {
                        rule = ERR_PTR(err);
                goto err_add_vlan;
        }
 
+       if (attr->action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR) {
+               err = mlx5_modify_header_alloc(priv->mdev, MLX5_FLOW_NAMESPACE_FDB,
+                                              parse_attr->num_mod_hdr_actions,
+                                              parse_attr->mod_hdr_actions,
+                                              &attr->mod_hdr_id);
+               kfree(parse_attr->mod_hdr_actions);
+               if (err) {
+                       rule = ERR_PTR(err);
+                       goto err_mod_hdr;
+               }
+       }
+
        rule = mlx5_eswitch_add_offloaded_rule(esw, &parse_attr->spec, attr);
        if (IS_ERR(rule))
                goto err_add_rule;
        return rule;
 
 err_add_rule:
+       if (flow->esw_attr->action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)
+               mlx5_modify_header_dealloc(priv->mdev,
+                                          attr->mod_hdr_id);
+err_mod_hdr:
        mlx5_eswitch_del_vlan_action(esw, attr);
 err_add_vlan:
        if (attr->action & MLX5_FLOW_CONTEXT_ACTION_ENCAP)
                mlx5e_detach_encap(priv, flow);
-
        return rule;
 }
 
                                  struct mlx5e_tc_flow *flow)
 {
        struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
+       struct mlx5_esw_flow_attr *attr = flow->esw_attr;
 
        mlx5_eswitch_del_offloaded_rule(esw, flow->rule, flow->esw_attr);
 
 
        if (flow->esw_attr->action & MLX5_FLOW_CONTEXT_ACTION_ENCAP)
                mlx5e_detach_encap(priv, flow);
+
+       if (flow->esw_attr->action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)
+               mlx5_modify_header_dealloc(priv->mdev,
+                                          attr->mod_hdr_id);
 }
 
 static void mlx5e_detach_encap(struct mlx5e_priv *priv,
 }
 
 static int parse_tc_fdb_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,
+                               struct mlx5e_tc_flow_parse_attr *parse_attr,
                                struct mlx5e_tc_flow *flow)
 {
        struct mlx5_esw_flow_attr *attr = flow->esw_attr;
                        continue;
                }
 
+               if (is_tcf_pedit(a)) {
+                       err = parse_tc_pedit_action(priv, a, MLX5_FLOW_NAMESPACE_FDB,
+                                                   parse_attr);
+                       if (err)
+                               return err;
+
+                       attr->action |= MLX5_FLOW_CONTEXT_ACTION_MOD_HDR;
+                       continue;
+               }
+
                if (is_tcf_mirred_egress_redirect(a)) {
                        int ifindex = tcf_mirred_ifindex(a);
                        struct net_device *out_dev;
                goto err_free;
 
        if (flow->flags & MLX5E_TC_FLOW_ESWITCH) {
-               err = parse_tc_fdb_actions(priv, f->exts, flow);
+               err = parse_tc_fdb_actions(priv, f->exts, parse_attr, flow);
                if (err < 0)
                        goto err_free;
                flow->rule = mlx5e_tc_add_fdb_flow(priv, parse_attr, flow);