1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2020 Mellanox Technologies, Ltd 3 */ 4 5 #ifndef RTE_PMD_MLX5_FLOW_OS_H_ 6 #define RTE_PMD_MLX5_FLOW_OS_H_ 7 8 #include "mlx5_flow.h" 9 10 #ifdef HAVE_IBV_FLOW_DV_SUPPORT 11 extern const struct mlx5_flow_driver_ops mlx5_flow_dv_drv_ops; 12 #endif 13 14 /** 15 * Get OS enforced flow type. MLX5_FLOW_TYPE_MAX means "non enforced type". 16 * 17 * @return 18 * Flow type (MLX5_FLOW_TYPE_MAX) 19 */ 20 static inline enum mlx5_flow_drv_type 21 mlx5_flow_os_get_type(void) 22 { 23 return MLX5_FLOW_TYPE_MAX; 24 } 25 26 /** 27 * Check if item type is supported. 28 * 29 * @param item 30 * Item type to check. 31 * 32 * @return 33 * True is this item type is supported, false if not supported. 34 */ 35 static inline bool 36 mlx5_flow_os_item_supported(int item __rte_unused) 37 { 38 return true; 39 } 40 41 /** 42 * Check if action type is supported. 43 * 44 * @param action 45 * Action type to check. 46 * 47 * @return 48 * True is this action type is supported, false if not supported. 49 */ 50 static inline bool 51 mlx5_flow_os_action_supported(int action __rte_unused) 52 { 53 return true; 54 } 55 56 /** 57 * Create flow rule. 58 * 59 * @param[in] matcher 60 * Pointer to match mask structure. 61 * @param[in] match_value 62 * Pointer to match value structure. 63 * @param[in] num_actions 64 * Number of actions in flow rule. 65 * @param[in] actions 66 * Pointer to array of flow rule actions. 67 * @param[out] flow 68 * Pointer to a valid flow rule object on success, NULL otherwise. 69 * 70 * @return 71 * 0 on success, or -1 on failure and errno is set. 72 */ 73 static inline int 74 mlx5_flow_os_create_flow(void *matcher, void *match_value, 75 size_t num_actions, void *actions[], void **flow) 76 { 77 *flow = mlx5_glue->dv_create_flow(matcher, match_value, 78 num_actions, actions); 79 return (*flow) ? 0 : -1; 80 } 81 82 /** 83 * Destroy flow rule. 84 * 85 * @param[in] drv_flow_ptr 86 * Pointer to flow rule object. 87 * 88 * @return 89 * 0 on success, or the value of errno on failure. 90 */ 91 static inline int 92 mlx5_flow_os_destroy_flow(void *drv_flow_ptr) 93 { 94 return mlx5_glue->dv_destroy_flow(drv_flow_ptr); 95 } 96 97 /** 98 * Create flow table. 99 * 100 * @param[in] domain 101 * Pointer to relevant domain. 102 * @param[in] table_id 103 * Table ID. 104 * @param[out] table 105 * Pointer to a valid flow table object on success, NULL otherwise. 106 * 107 * @return 108 * 0 on success, or -1 on failure and errno is set. 109 */ 110 static inline int 111 mlx5_flow_os_create_flow_tbl(void *domain, uint32_t table_id, void **table) 112 { 113 *table = mlx5_glue->dr_create_flow_tbl(domain, table_id); 114 return (*table) ? 0 : -1; 115 } 116 117 /** 118 * Destroy flow table. 119 * 120 * @param[in] table 121 * Pointer to table object to destroy. 122 * 123 * @return 124 * 0 on success, or the value of errno on failure. 125 */ 126 static inline int 127 mlx5_flow_os_destroy_flow_tbl(void *table) 128 { 129 return mlx5_glue->dr_destroy_flow_tbl(table); 130 } 131 132 /** 133 * Create flow matcher in a flow table. 134 * 135 * @param[in] ctx 136 * Pointer to relevant device context. 137 * @param[in] attr 138 * Pointer to relevant attributes. 139 * @param[in] table 140 * Pointer to table object. 141 * @param[out] matcher 142 * Pointer to a valid flow matcher object on success, NULL otherwise. 143 * 144 * @return 145 * 0 on success, or -1 on failure and errno is set. 146 */ 147 static inline int 148 mlx5_flow_os_create_flow_matcher(void *ctx, void *attr, void *table, 149 void **matcher) 150 { 151 *matcher = mlx5_glue->dv_create_flow_matcher(ctx, attr, table); 152 return (*matcher) ? 0 : -1; 153 } 154 155 /** 156 * Destroy flow matcher. 157 * 158 * @param[in] matcher 159 * Pointer to matcher object to destroy. 160 * 161 * @return 162 * 0 on success, or the value of errno on failure. 163 */ 164 static inline int 165 mlx5_flow_os_destroy_flow_matcher(void *matcher) 166 { 167 return mlx5_glue->dv_destroy_flow_matcher(matcher); 168 } 169 170 /** 171 * Create flow action: packet reformat. 172 * 173 * @param[in] ctx 174 * Pointer to relevant device context. 175 * @param[in] domain 176 * Pointer to domain handler. 177 * @param[in] resource 178 * Pointer to action data resource. 179 * @param[out] action 180 * Pointer to a valid action on success, NULL otherwise. 181 * 182 * 183 * @return 184 * 0 on success, or -1 on failure and errno is set. 185 */ 186 static inline int 187 mlx5_flow_os_create_flow_action_packet_reformat(void *ctx, void *domain, 188 void *resource, void **action) 189 { 190 struct mlx5_flow_dv_encap_decap_resource *res = 191 (struct mlx5_flow_dv_encap_decap_resource *)resource; 192 193 *action = mlx5_glue->dv_create_flow_action_packet_reformat 194 (ctx, res->reformat_type, res->ft_type, 195 domain, res->flags, res->size, 196 (res->size ? res->buf : NULL)); 197 return (*action) ? 0 : -1; 198 } 199 200 /** 201 * Create flow action: modify header. 202 * 203 * @param[in] ctx 204 * Pointer to relevant device context. 205 * @param[in] domain 206 * Pointer to domain handler. 207 * @param[in] resource 208 * Pointer to action data resource. 209 * @param[in] actions_len 210 * Total length of actions data in resource. 211 * @param[out] action 212 * Pointer to a valid action on success, NULL otherwise. 213 * 214 * 215 * @return 216 * 0 on success, or -1 on failure and errno is set. 217 */ 218 static inline int 219 mlx5_flow_os_create_flow_action_modify_header(void *ctx, void *domain, 220 void *resource, 221 uint32_t actions_len, 222 void **action) 223 { 224 struct mlx5_flow_dv_modify_hdr_resource *res = 225 (struct mlx5_flow_dv_modify_hdr_resource *)resource; 226 227 *action = mlx5_glue->dv_create_flow_action_modify_header 228 (ctx, res->ft_type, domain, res->root ? 229 MLX5DV_DR_ACTION_FLAGS_ROOT_LEVEL : 0, 230 actions_len, (uint64_t *)res->actions); 231 return (*action) ? 0 : -1; 232 } 233 234 /** 235 * Create flow action: destination flow table. 236 * 237 * @param[in] tbl_obj 238 * Pointer to destination table object. 239 * @param[out] action 240 * Pointer to a valid action on success, NULL otherwise. 241 * 242 * @return 243 * 0 on success, or -1 on failure and errno is set. 244 */ 245 static inline int 246 mlx5_flow_os_create_flow_action_dest_flow_tbl(void *tbl_obj, void **action) 247 { 248 *action = mlx5_glue->dr_create_flow_action_dest_flow_tbl(tbl_obj); 249 return (*action) ? 0 : -1; 250 } 251 252 /** 253 * Create flow action: destination port. 254 * 255 * @param[in] domain 256 * Pointer to domain handler. 257 * @param[in] port_id 258 * Destination port ID. 259 * @param[out] action 260 * Pointer to a valid action on success, NULL otherwise. 261 * 262 * @return 263 * 0 on success, or -1 on failure and errno is set. 264 */ 265 static inline int 266 mlx5_flow_os_create_flow_action_dest_port(void *domain, uint32_t port_id, 267 void **action) 268 { 269 /* 270 * Depending on rdma_core version the glue routine calls 271 * either mlx5dv_dr_action_create_dest_ib_port(domain, dev_port) 272 * or mlx5dv_dr_action_create_dest_vport(domain, vport_id). 273 */ 274 *action = mlx5_glue->dr_create_flow_action_dest_port(domain, port_id); 275 return (*action) ? 0 : -1; 276 } 277 278 /** 279 * Create flow action: push vlan. 280 * 281 * @param[in] domain 282 * Pointer to domain handler. 283 * @param[in] vlan_tag 284 * VLAN tag value. 285 * @param[out] action 286 * Pointer to a valid action on success, NULL otherwise. 287 * 288 * @return 289 * 0 on success, or -1 on failure and errno is set. 290 */ 291 static inline int 292 mlx5_flow_os_create_flow_action_push_vlan(void *domain, rte_be32_t vlan_tag, 293 void **action) 294 { 295 *action = mlx5_glue->dr_create_flow_action_push_vlan(domain, vlan_tag); 296 return (*action) ? 0 : -1; 297 } 298 299 /** 300 * Create flow action: count. 301 * 302 * @param[in] cnt_obj 303 * Pointer to DevX counter object. 304 * @param[in] offset 305 * Offset of counter in array. 306 * @param[out] action 307 * Pointer to a valid action on success, NULL otherwise. 308 * 309 * @return 310 * 0 on success, or -1 on failure and errno is set. 311 */ 312 static inline int 313 mlx5_flow_os_create_flow_action_count(void *cnt_obj, uint16_t offset, 314 void **action) 315 { 316 *action = mlx5_glue->dv_create_flow_action_counter(cnt_obj, offset); 317 return (*action) ? 0 : -1; 318 } 319 320 /** 321 * Create flow action: tag. 322 * 323 * @param[in] tag 324 * Tag value. 325 * @param[out] action 326 * Pointer to a valid action on success, NULL otherwise. 327 * 328 * @return 329 * 0 on success, or -1 on failure and errno is set. 330 */ 331 static inline int 332 mlx5_flow_os_create_flow_action_tag(uint32_t tag, void **action) 333 { 334 *action = mlx5_glue->dv_create_flow_action_tag(tag); 335 return (*action) ? 0 : -1; 336 } 337 338 /** 339 * Create flow action: drop. 340 * 341 * @param[out] action 342 * Pointer to a valid action on success, NULL otherwise. 343 * 344 * @return 345 * 0 on success, or -1 on failure and errno is set. 346 */ 347 static inline int 348 mlx5_flow_os_create_flow_action_drop(void **action) 349 { 350 *action = mlx5_glue->dr_create_flow_action_drop(); 351 return (*action) ? 0 : -1; 352 } 353 354 /** 355 * Create flow action: default miss. 356 * 357 * @param[out] action 358 * Pointer to a valid action on success, NULL otherwise. 359 * 360 * @return 361 * 0 on success, or -1 on failure and errno is set. 362 */ 363 static inline int 364 mlx5_flow_os_create_flow_action_default_miss(void **action) 365 { 366 *action = mlx5_glue->dr_create_flow_action_default_miss(); 367 return (*action) ? 0 : -1; 368 } 369 370 /** 371 * Create flow action: dest_devx_tir 372 * 373 * @param[in] tir 374 * Pointer to DevX tir object 375 * @param[out] action 376 * Pointer to a valid action on success, NULL otherwise. 377 * 378 * @return 379 * 0 on success, or -1 on failure and errno is set. 380 */ 381 static inline int 382 mlx5_flow_os_create_flow_action_dest_devx_tir(struct mlx5_devx_obj *tir, 383 void **action) 384 { 385 #ifdef HAVE_IBV_FLOW_DV_SUPPORT 386 *action = mlx5_glue->dv_create_flow_action_dest_devx_tir(tir->obj); 387 return (*action) ? 0 : -1; 388 #else 389 /* If no DV support - skip the operation and return success */ 390 RTE_SET_USED(tir); 391 *action = 0; 392 return 0; 393 #endif 394 } 395 396 /** 397 * Create flow action: sampler 398 * 399 * @param[in] attr 400 * Pointer to sampler attribute 401 * @param[out] action 402 * Pointer to a valid action on success, NULL otherwise. 403 * 404 * @return 405 * 0 on success, or -1 on failure and errno is set. 406 */ 407 static inline int 408 mlx5_os_flow_dr_create_flow_action_sampler 409 (struct mlx5dv_dr_flow_sampler_attr *attr, 410 void **action) 411 { 412 *action = mlx5_glue->dr_create_flow_action_sampler(attr); 413 return (*action) ? 0 : -1; 414 } 415 416 /** 417 * Create flow action: dest_array 418 * 419 * @param[in] domain 420 * Pointer to relevant domain. 421 * @param[in] num_dest 422 * Number of destinations array. 423 * @param[in] dests 424 * Array of destination attributes. 425 * @param[out] action 426 * Pointer to a valid action on success, NULL otherwise. 427 * 428 * @return 429 * 0 on success, or -1 on failure and errno is set. 430 */ 431 static inline int 432 mlx5_os_flow_dr_create_flow_action_dest_array 433 (void *domain, 434 size_t num_dest, 435 struct mlx5dv_dr_action_dest_attr *dests[], 436 void **action) 437 { 438 *action = mlx5_glue->dr_create_flow_action_dest_array( 439 domain, num_dest, dests); 440 return (*action) ? 0 : -1; 441 } 442 443 /** 444 * Destroy flow action. 445 * 446 * @param[in] action 447 * Pointer to action object to destroy. 448 * 449 * @return 450 * 0 on success, or the value of errno on failure. 451 */ 452 static inline int 453 mlx5_flow_os_destroy_flow_action(void *action) 454 { 455 return mlx5_glue->destroy_flow_action(action); 456 } 457 458 /** 459 * OS wrapper over Verbs API. 460 * Adjust flow priority based on the highest layer and the request priority. 461 * 462 * @param[in] dev 463 * Pointer to the Ethernet device structure. 464 * @param[in] priority 465 * The rule base priority. 466 * @param[in] subpriority 467 * The priority based on the items. 468 * 469 * @return 470 * The new priority. 471 */ 472 static inline uint32_t 473 mlx5_os_flow_adjust_priority(struct rte_eth_dev *dev, int32_t priority, 474 uint32_t subpriority) 475 { 476 return mlx5_flow_adjust_priority(dev, priority, subpriority); 477 } 478 479 static inline int 480 mlx5_os_flow_dr_sync_domain(void *domain, uint32_t flags) 481 { 482 return mlx5_glue->dr_sync_domain(domain, flags); 483 } 484 #endif /* RTE_PMD_MLX5_FLOW_OS_H_ */ 485