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 #include "mlx5_malloc.h" 10 11 #if defined(HAVE_IBV_FLOW_DV_SUPPORT) || !defined(HAVE_INFINIBAND_VERBS_H) 12 extern const struct mlx5_flow_driver_ops mlx5_flow_dv_drv_ops; 13 #endif 14 15 /** 16 * Get OS enforced flow type. MLX5_FLOW_TYPE_MAX means "non enforced type". 17 * 18 * @return 19 * Flow type (MLX5_FLOW_TYPE_MAX) 20 */ 21 static inline enum mlx5_flow_drv_type 22 mlx5_flow_os_get_type(void) 23 { 24 return MLX5_FLOW_TYPE_DV; 25 } 26 27 /** 28 * Check if item type is supported. 29 * 30 * @param item 31 * Item type to check. 32 * 33 * @return 34 * True is this item type is supported, false if not supported. 35 */ 36 static inline bool 37 mlx5_flow_os_item_supported(int item) 38 { 39 switch (item) { 40 case RTE_FLOW_ITEM_TYPE_END: 41 case RTE_FLOW_ITEM_TYPE_VOID: 42 case RTE_FLOW_ITEM_TYPE_ETH: 43 case RTE_FLOW_ITEM_TYPE_IPV4: 44 case RTE_FLOW_ITEM_TYPE_UDP: 45 return true; 46 default: 47 return false; 48 } 49 } 50 51 /** 52 * Check if action type is supported. 53 * 54 * @param action 55 * Action type to check. 56 * 57 * @return 58 * True is this action type is supported, false if not supported. 59 */ 60 static inline bool 61 mlx5_flow_os_action_supported(int action) 62 { 63 switch (action) { 64 case RTE_FLOW_ACTION_TYPE_END: 65 case RTE_FLOW_ACTION_TYPE_VOID: 66 case RTE_FLOW_ACTION_TYPE_QUEUE: 67 case RTE_FLOW_ACTION_TYPE_RSS: 68 return true; 69 default: 70 return false; 71 } 72 } 73 74 /** 75 * Create flow table. 76 * 77 * @param[in] domain 78 * Pointer to relevant domain. 79 * @param[in] table_id 80 * Table ID. 81 * @param[out] table 82 * NULL (no table object required) 83 * 84 * @return 85 * 0 if table_id is 0, negative value otherwise and errno is set. 86 */ 87 static inline int 88 mlx5_flow_os_create_flow_tbl(void *domain, uint32_t table_id, void **table) 89 { 90 RTE_SET_USED(domain); 91 *table = NULL; 92 if (table_id) { 93 rte_errno = ENOTSUP; 94 return -rte_errno; 95 } 96 return 0; 97 } 98 99 /** 100 * Destroy flow table. 101 * 102 * @param table 103 * Pointer to table to destroy. 104 * 105 * @return 106 * 0 on success (silently ignored). 107 */ 108 static inline int 109 mlx5_flow_os_destroy_flow_tbl(void *table) 110 { 111 RTE_SET_USED(table); 112 /* Silently ignore */ 113 return 0; 114 } 115 116 /** 117 * Create flow action: packet reformat. 118 * 119 * @param[in] ctx 120 * Pointer to relevant device context. 121 * @param[in] domain 122 * Pointer to domain handler. 123 * @param[in] resource 124 * Pointer to action data resource. 125 * @param[out] action 126 * Pointer to a valid action on success, NULL otherwise. 127 * 128 * 129 * @return 130 * 0 on success, or negative value on failure and errno is set. 131 */ 132 static inline int 133 mlx5_flow_os_create_flow_action_packet_reformat(void *ctx, void *domain, 134 void *resource, void **action) 135 { 136 RTE_SET_USED(ctx); 137 RTE_SET_USED(domain); 138 RTE_SET_USED(resource); 139 RTE_SET_USED(action); 140 rte_errno = ENOTSUP; 141 return -rte_errno; 142 } 143 144 /** 145 * Create flow action: modify header. 146 * 147 * @param[in] ctx 148 * Pointer to relevant device context. 149 * @param[in] domain 150 * Pointer to domain handler. 151 * @param[in] resource 152 * Pointer to action data resource. 153 * @param[in] actions_len 154 * Total length of actions data in resource. 155 * @param[out] action 156 * Pointer to a valid action on success, NULL otherwise. 157 * 158 * 159 * @return 160 * 0 on success, or -1 on failure and errno is set. 161 */ 162 static inline int 163 mlx5_flow_os_create_flow_action_modify_header(void *ctx, 164 void *domain, 165 void *resource, 166 uint32_t actions_len, 167 void **action) 168 { 169 RTE_SET_USED(ctx); 170 RTE_SET_USED(domain); 171 RTE_SET_USED(resource); 172 RTE_SET_USED(actions_len); 173 RTE_SET_USED(action); 174 rte_errno = ENOTSUP; 175 return -rte_errno; 176 } 177 178 /** 179 * Create flow action: destination flow table. 180 * 181 * @param[in] tbl_obj 182 * Pointer to destination table object. 183 * @param[out] action 184 * Pointer to a valid action on success, NULL otherwise. 185 * 186 * @return 187 * 0 on success, or negative value on failure and errno is set. 188 */ 189 static inline int 190 mlx5_flow_os_create_flow_action_dest_flow_tbl(void *tbl_obj, void **action) 191 { 192 RTE_SET_USED(tbl_obj); 193 RTE_SET_USED(action); 194 rte_errno = ENOTSUP; 195 return -rte_errno; 196 } 197 198 /** 199 * Create flow action: destination port. 200 * 201 * @param[in] domain 202 * Pointer to domain handler. 203 * @param[in] port_id 204 * Destination port ID. 205 * @param[out] action 206 * Pointer to a valid action on success, NULL otherwise. 207 * 208 * @return 209 * 0 on success, or negative value on failure and errno is set. 210 */ 211 static inline int 212 mlx5_flow_os_create_flow_action_dest_port(void *domain, uint32_t port_id, 213 void **action) 214 { 215 RTE_SET_USED(domain); 216 RTE_SET_USED(port_id); 217 *action = NULL; 218 rte_errno = ENOTSUP; 219 return -rte_errno; 220 } 221 222 /** 223 * Create flow action: push vlan. 224 * 225 * @param[in] domain 226 * Pointer to domain handler. 227 * @param[in] vlan_tag 228 * VLAN tag value. 229 * @param[out] action 230 * Pointer to a valid action on success, NULL otherwise. 231 * 232 * @return 233 * 0 on success, or negative value on failure and errno is set. 234 */ 235 static inline int 236 mlx5_flow_os_create_flow_action_push_vlan(void *domain, rte_be32_t vlan_tag, 237 void **action) 238 { 239 RTE_SET_USED(domain); 240 RTE_SET_USED(vlan_tag); 241 *action = NULL; 242 rte_errno = ENOTSUP; 243 return -rte_errno; 244 } 245 246 /** 247 * Create flow action: count. 248 * 249 * @param[in] cnt_obj 250 * Pointer to DevX counter object. 251 * @param[in] offset 252 * Offset of counter in array. 253 * @param[out] action 254 * Pointer to a valid action on success, NULL otherwise. 255 * 256 * @return 257 * 0 on success, or negative value on failure and errno is set. 258 */ 259 static inline int 260 mlx5_flow_os_create_flow_action_count(void *cnt_obj, uint16_t offset, 261 void **action) 262 { 263 RTE_SET_USED(cnt_obj); 264 RTE_SET_USED(offset); 265 *action = NULL; 266 rte_errno = ENOTSUP; 267 return -rte_errno; 268 } 269 270 /** 271 * Create flow action: tag. 272 * 273 * @param[in] tag 274 * Tag value. 275 * @param[out] action 276 * Pointer to a valid action on success, NULL otherwise. 277 * 278 * @return 279 * 0 on success, or negative value on failure and errno is set. 280 */ 281 static inline int 282 mlx5_flow_os_create_flow_action_tag(uint32_t tag, void **action) 283 { 284 RTE_SET_USED(tag); 285 *action = NULL; 286 rte_errno = ENOTSUP; 287 return -rte_errno; 288 } 289 290 /** 291 * Create flow action: drop. 292 * 293 * @param[out] action 294 * Pointer to a valid action on success, NULL otherwise. 295 * 296 * @return 297 * 0 on success, or negative value on failure and errno is set. 298 */ 299 static inline int 300 mlx5_flow_os_create_flow_action_drop(void **action) 301 { 302 *action = NULL; 303 rte_errno = ENOTSUP; 304 return -rte_errno; 305 } 306 307 /** 308 * Create flow action: default miss. 309 * 310 * @param[out] action 311 * NULL action pointer. 312 * 313 * @return 314 * 0 as success. 315 */ 316 static inline int 317 mlx5_flow_os_create_flow_action_default_miss(void **action) 318 { 319 *action = 0; 320 /* Silently ignore */ 321 return 0; 322 } 323 324 /** 325 * Create flow action: sampler 326 * 327 * @param[in] attr 328 * Pointer to sampler attribute 329 * @param[out] action 330 * Pointer to a valid action on success, NULL otherwise. 331 * 332 * @return 333 * 0 on success, or -1 on failure and errno is set. 334 */ 335 static inline int 336 mlx5_os_flow_dr_create_flow_action_sampler 337 (struct mlx5dv_dr_flow_sampler_attr *attr, 338 void **action) 339 { 340 RTE_SET_USED(attr); 341 *action = NULL; 342 rte_errno = ENOTSUP; 343 return -rte_errno; 344 } 345 346 /** 347 * Create flow action: dest_array 348 * 349 * @param[in] domain 350 * Pointer to relevant domain. 351 * @param[in] num_dest 352 * Number of destinations array. 353 * @param[in] dests 354 * Array of destination attributes. 355 * @param[out] action 356 * Pointer to a valid action on success, NULL otherwise. 357 * 358 * @return 359 * 0 on success, or -1 on failure and errno is set. 360 */ 361 static inline int 362 mlx5_os_flow_dr_create_flow_action_dest_array 363 (void *domain, 364 size_t num_dest, 365 struct mlx5dv_dr_action_dest_attr *dests[], 366 void **action) 367 { 368 RTE_SET_USED(domain); 369 RTE_SET_USED(num_dest); 370 RTE_SET_USED(dests); 371 *action = NULL; 372 rte_errno = ENOTSUP; 373 return -rte_errno; 374 } 375 376 /** 377 * OS stub for mlx5_flow_adjust_priority() API. 378 * Windows only supports flow priority 0 that cannot be adjusted. 379 * 380 * @param[in] dev 381 * Pointer to the Ethernet device structure. 382 * @param[in] priority 383 * The rule base priority. 384 * @param[in] subpriority 385 * The priority based on the items. 386 * 387 * @return 388 * 0 389 */ 390 static inline uint32_t 391 mlx5_os_flow_adjust_priority(struct rte_eth_dev *dev, int32_t priority, 392 uint32_t subpriority) 393 { 394 RTE_SET_USED(dev); 395 RTE_SET_USED(priority); 396 RTE_SET_USED(subpriority); 397 return 0; 398 } 399 400 static inline int 401 mlx5_os_flow_dr_sync_domain(void *domain, uint32_t flags) 402 { 403 RTE_SET_USED(domain); 404 RTE_SET_USED(flags); 405 errno = ENOTSUP; 406 return errno; 407 } 408 409 int mlx5_flow_os_validate_flow_attributes(struct rte_eth_dev *dev, 410 const struct rte_flow_attr *attributes, 411 bool external, 412 struct rte_flow_error *error); 413 int mlx5_flow_os_create_flow_matcher(void *ctx, 414 void *attr, 415 void *table, 416 void **matcher); 417 int mlx5_flow_os_destroy_flow_matcher(void *matcher); 418 int mlx5_flow_os_create_flow_action_dest_devx_tir(struct mlx5_devx_obj *tir, 419 void **action); 420 int mlx5_flow_os_destroy_flow_action(void *action); 421 int mlx5_flow_os_create_flow(void *matcher, void *match_value, 422 size_t num_actions, 423 void *actions[], void **flow); 424 int mlx5_flow_os_destroy_flow(void *drv_flow_ptr); 425 #endif /* RTE_PMD_MLX5_FLOW_OS_H_ */ 426