1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB 2 /* Copyright (c) 2019 Mellanox Technologies */ 3 4 #include <linux/mlx5/vport.h> 5 #include "mlx5_core.h" 6 #include "fs_core.h" 7 #include "fs_cmd.h" 8 #include "mlx5dr.h" 9 #include "fs_dr.h" 10 11 static bool mlx5_dr_is_fw_table(u32 flags) 12 { 13 if (flags & MLX5_FLOW_TABLE_TERMINATION) 14 return true; 15 16 return false; 17 } 18 19 static int mlx5_cmd_dr_update_root_ft(struct mlx5_flow_root_namespace *ns, 20 struct mlx5_flow_table *ft, 21 u32 underlay_qpn, 22 bool disconnect) 23 { 24 return mlx5_fs_cmd_get_fw_cmds()->update_root_ft(ns, ft, underlay_qpn, 25 disconnect); 26 } 27 28 static int set_miss_action(struct mlx5_flow_root_namespace *ns, 29 struct mlx5_flow_table *ft, 30 struct mlx5_flow_table *next_ft) 31 { 32 struct mlx5dr_action *old_miss_action; 33 struct mlx5dr_action *action = NULL; 34 struct mlx5dr_table *next_tbl; 35 int err; 36 37 next_tbl = next_ft ? next_ft->fs_dr_table.dr_table : NULL; 38 if (next_tbl) { 39 action = mlx5dr_action_create_dest_table(next_tbl); 40 if (!action) 41 return -EINVAL; 42 } 43 old_miss_action = ft->fs_dr_table.miss_action; 44 err = mlx5dr_table_set_miss_action(ft->fs_dr_table.dr_table, action); 45 if (err && action) { 46 err = mlx5dr_action_destroy(action); 47 if (err) 48 mlx5_core_err(ns->dev, 49 "Failed to destroy action (%d)\n", err); 50 action = NULL; 51 } 52 ft->fs_dr_table.miss_action = action; 53 if (old_miss_action) { 54 err = mlx5dr_action_destroy(old_miss_action); 55 if (err) 56 mlx5_core_err(ns->dev, "Failed to destroy action (%d)\n", 57 err); 58 } 59 60 return err; 61 } 62 63 static int mlx5_cmd_dr_create_flow_table(struct mlx5_flow_root_namespace *ns, 64 struct mlx5_flow_table *ft, 65 struct mlx5_flow_table_attr *ft_attr, 66 struct mlx5_flow_table *next_ft) 67 { 68 struct mlx5dr_table *tbl; 69 u32 flags; 70 int err; 71 72 if (mlx5_dr_is_fw_table(ft->flags)) 73 return mlx5_fs_cmd_get_fw_cmds()->create_flow_table(ns, ft, 74 ft_attr, 75 next_ft); 76 flags = ft->flags; 77 /* turn off encap/decap if not supported for sw-str by fw */ 78 if (!MLX5_CAP_FLOWTABLE(ns->dev, sw_owner_reformat_supported)) 79 flags = ft->flags & ~(MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT | 80 MLX5_FLOW_TABLE_TUNNEL_EN_DECAP); 81 82 tbl = mlx5dr_table_create(ns->fs_dr_domain.dr_domain, ft->level, flags, 83 ft_attr->uid); 84 if (!tbl) { 85 mlx5_core_err(ns->dev, "Failed creating dr flow_table\n"); 86 return -EINVAL; 87 } 88 89 ft->fs_dr_table.dr_table = tbl; 90 ft->id = mlx5dr_table_get_id(tbl); 91 92 if (next_ft) { 93 err = set_miss_action(ns, ft, next_ft); 94 if (err) { 95 mlx5dr_table_destroy(tbl); 96 ft->fs_dr_table.dr_table = NULL; 97 return err; 98 } 99 } 100 101 ft->max_fte = INT_MAX; 102 103 return 0; 104 } 105 106 static int mlx5_cmd_dr_destroy_flow_table(struct mlx5_flow_root_namespace *ns, 107 struct mlx5_flow_table *ft) 108 { 109 struct mlx5dr_action *action = ft->fs_dr_table.miss_action; 110 int err; 111 112 if (mlx5_dr_is_fw_table(ft->flags)) 113 return mlx5_fs_cmd_get_fw_cmds()->destroy_flow_table(ns, ft); 114 115 err = mlx5dr_table_destroy(ft->fs_dr_table.dr_table); 116 if (err) { 117 mlx5_core_err(ns->dev, "Failed to destroy flow_table (%d)\n", 118 err); 119 return err; 120 } 121 if (action) { 122 err = mlx5dr_action_destroy(action); 123 if (err) { 124 mlx5_core_err(ns->dev, "Failed to destroy action(%d)\n", 125 err); 126 return err; 127 } 128 } 129 130 return err; 131 } 132 133 static int mlx5_cmd_dr_modify_flow_table(struct mlx5_flow_root_namespace *ns, 134 struct mlx5_flow_table *ft, 135 struct mlx5_flow_table *next_ft) 136 { 137 if (mlx5_dr_is_fw_table(ft->flags)) 138 return mlx5_fs_cmd_get_fw_cmds()->modify_flow_table(ns, ft, next_ft); 139 140 return set_miss_action(ns, ft, next_ft); 141 } 142 143 static int mlx5_cmd_dr_create_flow_group(struct mlx5_flow_root_namespace *ns, 144 struct mlx5_flow_table *ft, 145 u32 *in, 146 struct mlx5_flow_group *fg) 147 { 148 struct mlx5dr_matcher *matcher; 149 u32 priority = MLX5_GET(create_flow_group_in, in, 150 start_flow_index); 151 u8 match_criteria_enable = MLX5_GET(create_flow_group_in, 152 in, 153 match_criteria_enable); 154 struct mlx5dr_match_parameters mask; 155 156 if (mlx5_dr_is_fw_table(ft->flags)) 157 return mlx5_fs_cmd_get_fw_cmds()->create_flow_group(ns, ft, in, 158 fg); 159 160 mask.match_buf = MLX5_ADDR_OF(create_flow_group_in, 161 in, match_criteria); 162 mask.match_sz = sizeof(fg->mask.match_criteria); 163 164 matcher = mlx5dr_matcher_create(ft->fs_dr_table.dr_table, 165 priority, 166 match_criteria_enable, 167 &mask); 168 if (!matcher) { 169 mlx5_core_err(ns->dev, "Failed creating matcher\n"); 170 return -EINVAL; 171 } 172 173 fg->fs_dr_matcher.dr_matcher = matcher; 174 return 0; 175 } 176 177 static int mlx5_cmd_dr_destroy_flow_group(struct mlx5_flow_root_namespace *ns, 178 struct mlx5_flow_table *ft, 179 struct mlx5_flow_group *fg) 180 { 181 if (mlx5_dr_is_fw_table(ft->flags)) 182 return mlx5_fs_cmd_get_fw_cmds()->destroy_flow_group(ns, ft, fg); 183 184 return mlx5dr_matcher_destroy(fg->fs_dr_matcher.dr_matcher); 185 } 186 187 static struct mlx5dr_action *create_vport_action(struct mlx5dr_domain *domain, 188 struct mlx5_flow_rule *dst) 189 { 190 struct mlx5_flow_destination *dest_attr = &dst->dest_attr; 191 192 return mlx5dr_action_create_dest_vport(domain, dest_attr->vport.num, 193 dest_attr->vport.flags & 194 MLX5_FLOW_DEST_VPORT_VHCA_ID, 195 dest_attr->vport.vhca_id); 196 } 197 198 static struct mlx5dr_action *create_uplink_action(struct mlx5dr_domain *domain, 199 struct mlx5_flow_rule *dst) 200 { 201 struct mlx5_flow_destination *dest_attr = &dst->dest_attr; 202 203 return mlx5dr_action_create_dest_vport(domain, MLX5_VPORT_UPLINK, 1, 204 dest_attr->vport.vhca_id); 205 } 206 207 static struct mlx5dr_action *create_ft_action(struct mlx5dr_domain *domain, 208 struct mlx5_flow_rule *dst) 209 { 210 struct mlx5_flow_table *dest_ft = dst->dest_attr.ft; 211 212 if (mlx5_dr_is_fw_table(dest_ft->flags)) 213 return mlx5dr_action_create_dest_flow_fw_table(domain, dest_ft); 214 return mlx5dr_action_create_dest_table(dest_ft->fs_dr_table.dr_table); 215 } 216 217 static struct mlx5dr_action *create_action_push_vlan(struct mlx5dr_domain *domain, 218 struct mlx5_fs_vlan *vlan) 219 { 220 u16 n_ethtype = vlan->ethtype; 221 u8 prio = vlan->prio; 222 u16 vid = vlan->vid; 223 u32 vlan_hdr; 224 225 vlan_hdr = (u32)n_ethtype << 16 | (u32)(prio) << 12 | (u32)vid; 226 return mlx5dr_action_create_push_vlan(domain, htonl(vlan_hdr)); 227 } 228 229 static bool contain_vport_reformat_action(struct mlx5_flow_rule *dst) 230 { 231 return (dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_VPORT || 232 dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_UPLINK) && 233 dst->dest_attr.vport.flags & MLX5_FLOW_DEST_VPORT_REFORMAT_ID; 234 } 235 236 /* We want to support a rule with 32 destinations, which means we need to 237 * account for 32 destinations plus usually a counter plus one more action 238 * for a multi-destination flow table. 239 */ 240 #define MLX5_FLOW_CONTEXT_ACTION_MAX 34 241 static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 242 struct mlx5_flow_table *ft, 243 struct mlx5_flow_group *group, 244 struct fs_fte *fte) 245 { 246 struct mlx5dr_domain *domain = ns->fs_dr_domain.dr_domain; 247 struct mlx5dr_action_dest *term_actions; 248 struct mlx5dr_match_parameters params; 249 struct mlx5_core_dev *dev = ns->dev; 250 struct mlx5dr_action **fs_dr_actions; 251 struct mlx5dr_action *tmp_action; 252 struct mlx5dr_action **actions; 253 bool delay_encap_set = false; 254 struct mlx5dr_rule *rule; 255 struct mlx5_flow_rule *dst; 256 int fs_dr_num_actions = 0; 257 int num_term_actions = 0; 258 int num_actions = 0; 259 size_t match_sz; 260 int err = 0; 261 int i; 262 263 if (mlx5_dr_is_fw_table(ft->flags)) 264 return mlx5_fs_cmd_get_fw_cmds()->create_fte(ns, ft, group, fte); 265 266 actions = kcalloc(MLX5_FLOW_CONTEXT_ACTION_MAX, sizeof(*actions), 267 GFP_KERNEL); 268 if (!actions) { 269 err = -ENOMEM; 270 goto out_err; 271 } 272 273 fs_dr_actions = kcalloc(MLX5_FLOW_CONTEXT_ACTION_MAX, 274 sizeof(*fs_dr_actions), GFP_KERNEL); 275 if (!fs_dr_actions) { 276 err = -ENOMEM; 277 goto free_actions_alloc; 278 } 279 280 term_actions = kcalloc(MLX5_FLOW_CONTEXT_ACTION_MAX, 281 sizeof(*term_actions), GFP_KERNEL); 282 if (!term_actions) { 283 err = -ENOMEM; 284 goto free_fs_dr_actions_alloc; 285 } 286 287 match_sz = sizeof(fte->val); 288 289 /* Drop reformat action bit if destination vport set with reformat */ 290 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) { 291 list_for_each_entry(dst, &fte->node.children, node.list) { 292 if (!contain_vport_reformat_action(dst)) 293 continue; 294 295 fte->action.action &= ~MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT; 296 break; 297 } 298 } 299 300 /* The order of the actions are must to be keep, only the following 301 * order is supported by SW steering: 302 * TX: modify header -> push vlan -> encap 303 * RX: decap -> pop vlan -> modify header 304 */ 305 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_DECAP) { 306 enum mlx5dr_action_reformat_type decap_type = 307 DR_ACTION_REFORMAT_TYP_TNL_L2_TO_L2; 308 309 tmp_action = mlx5dr_action_create_packet_reformat(domain, 310 decap_type, 311 0, 0, 0, 312 NULL); 313 if (!tmp_action) { 314 err = -ENOMEM; 315 goto free_actions; 316 } 317 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 318 actions[num_actions++] = tmp_action; 319 } 320 321 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT) { 322 bool is_decap = fte->action.pkt_reformat->reformat_type == 323 MLX5_REFORMAT_TYPE_L3_TUNNEL_TO_L2; 324 325 if (is_decap) 326 actions[num_actions++] = 327 fte->action.pkt_reformat->action.dr_action; 328 else 329 delay_encap_set = true; 330 } 331 332 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP) { 333 tmp_action = 334 mlx5dr_action_create_pop_vlan(); 335 if (!tmp_action) { 336 err = -ENOMEM; 337 goto free_actions; 338 } 339 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 340 actions[num_actions++] = tmp_action; 341 } 342 343 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP_2) { 344 tmp_action = 345 mlx5dr_action_create_pop_vlan(); 346 if (!tmp_action) { 347 err = -ENOMEM; 348 goto free_actions; 349 } 350 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 351 actions[num_actions++] = tmp_action; 352 } 353 354 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR) 355 actions[num_actions++] = 356 fte->action.modify_hdr->action.dr_action; 357 358 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH) { 359 tmp_action = create_action_push_vlan(domain, &fte->action.vlan[0]); 360 if (!tmp_action) { 361 err = -ENOMEM; 362 goto free_actions; 363 } 364 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 365 actions[num_actions++] = tmp_action; 366 } 367 368 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2) { 369 tmp_action = create_action_push_vlan(domain, &fte->action.vlan[1]); 370 if (!tmp_action) { 371 err = -ENOMEM; 372 goto free_actions; 373 } 374 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 375 actions[num_actions++] = tmp_action; 376 } 377 378 if (delay_encap_set) 379 actions[num_actions++] = 380 fte->action.pkt_reformat->action.dr_action; 381 382 /* The order of the actions below is not important */ 383 384 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_DROP) { 385 tmp_action = mlx5dr_action_create_drop(); 386 if (!tmp_action) { 387 err = -ENOMEM; 388 goto free_actions; 389 } 390 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 391 term_actions[num_term_actions++].dest = tmp_action; 392 } 393 394 if (fte->flow_context.flow_tag) { 395 tmp_action = 396 mlx5dr_action_create_tag(fte->flow_context.flow_tag); 397 if (!tmp_action) { 398 err = -ENOMEM; 399 goto free_actions; 400 } 401 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 402 actions[num_actions++] = tmp_action; 403 } 404 405 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) { 406 list_for_each_entry(dst, &fte->node.children, node.list) { 407 enum mlx5_flow_destination_type type = dst->dest_attr.type; 408 u32 id; 409 410 if (fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX || 411 num_term_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) { 412 err = -EOPNOTSUPP; 413 goto free_actions; 414 } 415 416 if (type == MLX5_FLOW_DESTINATION_TYPE_COUNTER) 417 continue; 418 419 switch (type) { 420 case MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE: 421 tmp_action = create_ft_action(domain, dst); 422 if (!tmp_action) { 423 err = -ENOMEM; 424 goto free_actions; 425 } 426 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 427 term_actions[num_term_actions++].dest = tmp_action; 428 break; 429 case MLX5_FLOW_DESTINATION_TYPE_UPLINK: 430 case MLX5_FLOW_DESTINATION_TYPE_VPORT: 431 tmp_action = type == MLX5_FLOW_DESTINATION_TYPE_VPORT ? 432 create_vport_action(domain, dst) : 433 create_uplink_action(domain, dst); 434 if (!tmp_action) { 435 err = -ENOMEM; 436 goto free_actions; 437 } 438 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 439 term_actions[num_term_actions].dest = tmp_action; 440 441 if (dst->dest_attr.vport.flags & 442 MLX5_FLOW_DEST_VPORT_REFORMAT_ID) 443 term_actions[num_term_actions].reformat = 444 dst->dest_attr.vport.pkt_reformat->action.dr_action; 445 446 num_term_actions++; 447 break; 448 case MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE_NUM: 449 id = dst->dest_attr.ft_num; 450 tmp_action = mlx5dr_action_create_dest_table_num(domain, 451 id); 452 if (!tmp_action) { 453 err = -ENOMEM; 454 goto free_actions; 455 } 456 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 457 term_actions[num_term_actions++].dest = tmp_action; 458 break; 459 case MLX5_FLOW_DESTINATION_TYPE_FLOW_SAMPLER: 460 id = dst->dest_attr.sampler_id; 461 tmp_action = mlx5dr_action_create_flow_sampler(domain, 462 id); 463 if (!tmp_action) { 464 err = -ENOMEM; 465 goto free_actions; 466 } 467 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 468 term_actions[num_term_actions++].dest = tmp_action; 469 break; 470 default: 471 err = -EOPNOTSUPP; 472 goto free_actions; 473 } 474 } 475 } 476 477 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) { 478 list_for_each_entry(dst, &fte->node.children, node.list) { 479 u32 id; 480 481 if (dst->dest_attr.type != 482 MLX5_FLOW_DESTINATION_TYPE_COUNTER) 483 continue; 484 485 if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX || 486 fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) { 487 err = -EOPNOTSUPP; 488 goto free_actions; 489 } 490 491 id = dst->dest_attr.counter_id; 492 tmp_action = 493 mlx5dr_action_create_flow_counter(id); 494 if (!tmp_action) { 495 err = -ENOMEM; 496 goto free_actions; 497 } 498 499 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 500 actions[num_actions++] = tmp_action; 501 } 502 } 503 504 if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_EXECUTE_ASO) { 505 if (fte->action.exe_aso.type != MLX5_EXE_ASO_FLOW_METER) { 506 err = -EOPNOTSUPP; 507 goto free_actions; 508 } 509 510 tmp_action = 511 mlx5dr_action_create_aso(domain, 512 fte->action.exe_aso.object_id, 513 fte->action.exe_aso.return_reg_id, 514 fte->action.exe_aso.type, 515 fte->action.exe_aso.flow_meter.init_color, 516 fte->action.exe_aso.flow_meter.meter_idx); 517 if (!tmp_action) { 518 err = -ENOMEM; 519 goto free_actions; 520 } 521 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 522 actions[num_actions++] = tmp_action; 523 } 524 525 params.match_sz = match_sz; 526 params.match_buf = (u64 *)fte->val; 527 if (num_term_actions == 1) { 528 if (term_actions->reformat) { 529 if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) { 530 err = -EOPNOTSUPP; 531 goto free_actions; 532 } 533 actions[num_actions++] = term_actions->reformat; 534 } 535 536 if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) { 537 err = -EOPNOTSUPP; 538 goto free_actions; 539 } 540 actions[num_actions++] = term_actions->dest; 541 } else if (num_term_actions > 1) { 542 bool ignore_flow_level = 543 !!(fte->action.flags & FLOW_ACT_IGNORE_FLOW_LEVEL); 544 u32 flow_source = fte->flow_context.flow_source; 545 546 if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX || 547 fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) { 548 err = -EOPNOTSUPP; 549 goto free_actions; 550 } 551 tmp_action = mlx5dr_action_create_mult_dest_tbl(domain, 552 term_actions, 553 num_term_actions, 554 ignore_flow_level, 555 flow_source); 556 if (!tmp_action) { 557 err = -EOPNOTSUPP; 558 goto free_actions; 559 } 560 fs_dr_actions[fs_dr_num_actions++] = tmp_action; 561 actions[num_actions++] = tmp_action; 562 } 563 564 rule = mlx5dr_rule_create(group->fs_dr_matcher.dr_matcher, 565 ¶ms, 566 num_actions, 567 actions, 568 fte->flow_context.flow_source); 569 if (!rule) { 570 err = -EINVAL; 571 goto free_actions; 572 } 573 574 kfree(term_actions); 575 kfree(actions); 576 577 fte->fs_dr_rule.dr_rule = rule; 578 fte->fs_dr_rule.num_actions = fs_dr_num_actions; 579 fte->fs_dr_rule.dr_actions = fs_dr_actions; 580 581 return 0; 582 583 free_actions: 584 /* Free in reverse order to handle action dependencies */ 585 for (i = fs_dr_num_actions - 1; i >= 0; i--) 586 if (!IS_ERR_OR_NULL(fs_dr_actions[i])) 587 mlx5dr_action_destroy(fs_dr_actions[i]); 588 589 kfree(term_actions); 590 free_fs_dr_actions_alloc: 591 kfree(fs_dr_actions); 592 free_actions_alloc: 593 kfree(actions); 594 out_err: 595 mlx5_core_err(dev, "Failed to create dr rule err(%d)\n", err); 596 return err; 597 } 598 599 static int mlx5_cmd_dr_packet_reformat_alloc(struct mlx5_flow_root_namespace *ns, 600 struct mlx5_pkt_reformat_params *params, 601 enum mlx5_flow_namespace_type namespace, 602 struct mlx5_pkt_reformat *pkt_reformat) 603 { 604 struct mlx5dr_domain *dr_domain = ns->fs_dr_domain.dr_domain; 605 struct mlx5dr_action *action; 606 int dr_reformat; 607 608 switch (params->type) { 609 case MLX5_REFORMAT_TYPE_L2_TO_VXLAN: 610 case MLX5_REFORMAT_TYPE_L2_TO_NVGRE: 611 case MLX5_REFORMAT_TYPE_L2_TO_L2_TUNNEL: 612 dr_reformat = DR_ACTION_REFORMAT_TYP_L2_TO_TNL_L2; 613 break; 614 case MLX5_REFORMAT_TYPE_L3_TUNNEL_TO_L2: 615 dr_reformat = DR_ACTION_REFORMAT_TYP_TNL_L3_TO_L2; 616 break; 617 case MLX5_REFORMAT_TYPE_L2_TO_L3_TUNNEL: 618 dr_reformat = DR_ACTION_REFORMAT_TYP_L2_TO_TNL_L3; 619 break; 620 case MLX5_REFORMAT_TYPE_INSERT_HDR: 621 dr_reformat = DR_ACTION_REFORMAT_TYP_INSERT_HDR; 622 break; 623 case MLX5_REFORMAT_TYPE_REMOVE_HDR: 624 dr_reformat = DR_ACTION_REFORMAT_TYP_REMOVE_HDR; 625 break; 626 default: 627 mlx5_core_err(ns->dev, "Packet-reformat not supported(%d)\n", 628 params->type); 629 return -EOPNOTSUPP; 630 } 631 632 action = mlx5dr_action_create_packet_reformat(dr_domain, 633 dr_reformat, 634 params->param_0, 635 params->param_1, 636 params->size, 637 params->data); 638 if (!action) { 639 mlx5_core_err(ns->dev, "Failed allocating packet-reformat action\n"); 640 return -EINVAL; 641 } 642 643 pkt_reformat->action.dr_action = action; 644 645 return 0; 646 } 647 648 static void mlx5_cmd_dr_packet_reformat_dealloc(struct mlx5_flow_root_namespace *ns, 649 struct mlx5_pkt_reformat *pkt_reformat) 650 { 651 mlx5dr_action_destroy(pkt_reformat->action.dr_action); 652 } 653 654 static int mlx5_cmd_dr_modify_header_alloc(struct mlx5_flow_root_namespace *ns, 655 u8 namespace, u8 num_actions, 656 void *modify_actions, 657 struct mlx5_modify_hdr *modify_hdr) 658 { 659 struct mlx5dr_domain *dr_domain = ns->fs_dr_domain.dr_domain; 660 struct mlx5dr_action *action; 661 size_t actions_sz; 662 663 actions_sz = MLX5_UN_SZ_BYTES(set_add_copy_action_in_auto) * 664 num_actions; 665 action = mlx5dr_action_create_modify_header(dr_domain, 0, 666 actions_sz, 667 modify_actions); 668 if (!action) { 669 mlx5_core_err(ns->dev, "Failed allocating modify-header action\n"); 670 return -EINVAL; 671 } 672 673 modify_hdr->action.dr_action = action; 674 675 return 0; 676 } 677 678 static void mlx5_cmd_dr_modify_header_dealloc(struct mlx5_flow_root_namespace *ns, 679 struct mlx5_modify_hdr *modify_hdr) 680 { 681 mlx5dr_action_destroy(modify_hdr->action.dr_action); 682 } 683 684 static int 685 mlx5_cmd_dr_destroy_match_definer(struct mlx5_flow_root_namespace *ns, 686 int definer_id) 687 { 688 return -EOPNOTSUPP; 689 } 690 691 static int mlx5_cmd_dr_create_match_definer(struct mlx5_flow_root_namespace *ns, 692 u16 format_id, u32 *match_mask) 693 { 694 return -EOPNOTSUPP; 695 } 696 697 static int mlx5_cmd_dr_delete_fte(struct mlx5_flow_root_namespace *ns, 698 struct mlx5_flow_table *ft, 699 struct fs_fte *fte) 700 { 701 struct mlx5_fs_dr_rule *rule = &fte->fs_dr_rule; 702 int err; 703 int i; 704 705 if (mlx5_dr_is_fw_table(ft->flags)) 706 return mlx5_fs_cmd_get_fw_cmds()->delete_fte(ns, ft, fte); 707 708 err = mlx5dr_rule_destroy(rule->dr_rule); 709 if (err) 710 return err; 711 712 /* Free in reverse order to handle action dependencies */ 713 for (i = rule->num_actions - 1; i >= 0; i--) 714 if (!IS_ERR_OR_NULL(rule->dr_actions[i])) 715 mlx5dr_action_destroy(rule->dr_actions[i]); 716 717 kfree(rule->dr_actions); 718 return 0; 719 } 720 721 static int mlx5_cmd_dr_update_fte(struct mlx5_flow_root_namespace *ns, 722 struct mlx5_flow_table *ft, 723 struct mlx5_flow_group *group, 724 int modify_mask, 725 struct fs_fte *fte) 726 { 727 struct fs_fte fte_tmp = {}; 728 int ret; 729 730 if (mlx5_dr_is_fw_table(ft->flags)) 731 return mlx5_fs_cmd_get_fw_cmds()->update_fte(ns, ft, group, modify_mask, fte); 732 733 /* Backup current dr rule details */ 734 fte_tmp.fs_dr_rule = fte->fs_dr_rule; 735 memset(&fte->fs_dr_rule, 0, sizeof(struct mlx5_fs_dr_rule)); 736 737 /* First add the new updated rule, then delete the old rule */ 738 ret = mlx5_cmd_dr_create_fte(ns, ft, group, fte); 739 if (ret) 740 goto restore_fte; 741 742 ret = mlx5_cmd_dr_delete_fte(ns, ft, &fte_tmp); 743 WARN_ONCE(ret, "dr update fte duplicate rule deletion failed\n"); 744 return ret; 745 746 restore_fte: 747 fte->fs_dr_rule = fte_tmp.fs_dr_rule; 748 return ret; 749 } 750 751 static int mlx5_cmd_dr_set_peer(struct mlx5_flow_root_namespace *ns, 752 struct mlx5_flow_root_namespace *peer_ns) 753 { 754 struct mlx5dr_domain *peer_domain = NULL; 755 756 if (peer_ns) 757 peer_domain = peer_ns->fs_dr_domain.dr_domain; 758 mlx5dr_domain_set_peer(ns->fs_dr_domain.dr_domain, 759 peer_domain); 760 return 0; 761 } 762 763 static int mlx5_cmd_dr_create_ns(struct mlx5_flow_root_namespace *ns) 764 { 765 ns->fs_dr_domain.dr_domain = 766 mlx5dr_domain_create(ns->dev, 767 MLX5DR_DOMAIN_TYPE_FDB); 768 if (!ns->fs_dr_domain.dr_domain) { 769 mlx5_core_err(ns->dev, "Failed to create dr flow namespace\n"); 770 return -EOPNOTSUPP; 771 } 772 return 0; 773 } 774 775 static int mlx5_cmd_dr_destroy_ns(struct mlx5_flow_root_namespace *ns) 776 { 777 return mlx5dr_domain_destroy(ns->fs_dr_domain.dr_domain); 778 } 779 780 static u32 mlx5_cmd_dr_get_capabilities(struct mlx5_flow_root_namespace *ns, 781 enum fs_flow_table_type ft_type) 782 { 783 if (ft_type != FS_FT_FDB || 784 MLX5_CAP_GEN(ns->dev, steering_format_version) == MLX5_STEERING_FORMAT_CONNECTX_5) 785 return 0; 786 787 return MLX5_FLOW_STEERING_CAP_VLAN_PUSH_ON_RX | MLX5_FLOW_STEERING_CAP_VLAN_POP_ON_TX; 788 } 789 790 bool mlx5_fs_dr_is_supported(struct mlx5_core_dev *dev) 791 { 792 return mlx5dr_is_supported(dev); 793 } 794 795 static const struct mlx5_flow_cmds mlx5_flow_cmds_dr = { 796 .create_flow_table = mlx5_cmd_dr_create_flow_table, 797 .destroy_flow_table = mlx5_cmd_dr_destroy_flow_table, 798 .modify_flow_table = mlx5_cmd_dr_modify_flow_table, 799 .create_flow_group = mlx5_cmd_dr_create_flow_group, 800 .destroy_flow_group = mlx5_cmd_dr_destroy_flow_group, 801 .create_fte = mlx5_cmd_dr_create_fte, 802 .update_fte = mlx5_cmd_dr_update_fte, 803 .delete_fte = mlx5_cmd_dr_delete_fte, 804 .update_root_ft = mlx5_cmd_dr_update_root_ft, 805 .packet_reformat_alloc = mlx5_cmd_dr_packet_reformat_alloc, 806 .packet_reformat_dealloc = mlx5_cmd_dr_packet_reformat_dealloc, 807 .modify_header_alloc = mlx5_cmd_dr_modify_header_alloc, 808 .modify_header_dealloc = mlx5_cmd_dr_modify_header_dealloc, 809 .create_match_definer = mlx5_cmd_dr_create_match_definer, 810 .destroy_match_definer = mlx5_cmd_dr_destroy_match_definer, 811 .set_peer = mlx5_cmd_dr_set_peer, 812 .create_ns = mlx5_cmd_dr_create_ns, 813 .destroy_ns = mlx5_cmd_dr_destroy_ns, 814 .get_capabilities = mlx5_cmd_dr_get_capabilities, 815 }; 816 817 const struct mlx5_flow_cmds *mlx5_fs_cmd_get_dr_cmds(void) 818 { 819 return &mlx5_flow_cmds_dr; 820 } 821