1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB 2 // Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 3 4 #include "en/tc_priv.h" 5 #include "post_meter.h" 6 #include "en/tc/post_act.h" 7 8 #define MLX5_PACKET_COLOR_BITS MLX5_REG_MAPPING_MBITS(PACKET_COLOR_TO_REG) 9 #define MLX5_PACKET_COLOR_MASK MLX5_REG_MAPPING_MASK(PACKET_COLOR_TO_REG) 10 11 struct mlx5e_post_meter_rate_table { 12 struct mlx5_flow_table *ft; 13 struct mlx5_flow_group *fg; 14 struct mlx5_flow_handle *green_rule; 15 struct mlx5_flow_attr *green_attr; 16 struct mlx5_flow_handle *red_rule; 17 struct mlx5_flow_attr *red_attr; 18 }; 19 20 struct mlx5e_post_meter_mtu_table { 21 struct mlx5_flow_table *ft; 22 struct mlx5_flow_group *fg; 23 struct mlx5_flow_handle *rule; 24 struct mlx5_flow_attr *attr; 25 }; 26 27 struct mlx5e_post_meter_mtu_tables { 28 struct mlx5e_post_meter_mtu_table green_table; 29 struct mlx5e_post_meter_mtu_table red_table; 30 }; 31 32 struct mlx5e_post_meter_priv { 33 enum mlx5e_post_meter_type type; 34 union { 35 struct mlx5e_post_meter_rate_table rate_steering_table; 36 struct mlx5e_post_meter_mtu_tables mtu_tables; 37 }; 38 }; 39 40 struct mlx5_flow_table * 41 mlx5e_post_meter_get_ft(struct mlx5e_post_meter_priv *post_meter) 42 { 43 return post_meter->rate_steering_table.ft; 44 } 45 46 struct mlx5_flow_table * 47 mlx5e_post_meter_get_mtu_true_ft(struct mlx5e_post_meter_priv *post_meter) 48 { 49 return post_meter->mtu_tables.green_table.ft; 50 } 51 52 struct mlx5_flow_table * 53 mlx5e_post_meter_get_mtu_false_ft(struct mlx5e_post_meter_priv *post_meter) 54 { 55 return post_meter->mtu_tables.red_table.ft; 56 } 57 58 static struct mlx5_flow_table * 59 mlx5e_post_meter_table_create(struct mlx5e_priv *priv, 60 enum mlx5_flow_namespace_type ns_type) 61 { 62 struct mlx5_flow_table_attr ft_attr = {}; 63 struct mlx5_flow_namespace *root_ns; 64 65 root_ns = mlx5_get_flow_namespace(priv->mdev, ns_type); 66 if (!root_ns) { 67 mlx5_core_warn(priv->mdev, "Failed to get namespace for flow meter\n"); 68 return ERR_PTR(-EOPNOTSUPP); 69 } 70 71 ft_attr.flags = MLX5_FLOW_TABLE_UNMANAGED; 72 ft_attr.prio = FDB_SLOW_PATH; 73 ft_attr.max_fte = 2; 74 ft_attr.level = 1; 75 76 return mlx5_create_flow_table(root_ns, &ft_attr); 77 } 78 79 static int 80 mlx5e_post_meter_rate_fg_create(struct mlx5e_priv *priv, 81 struct mlx5e_post_meter_priv *post_meter) 82 { 83 struct mlx5e_post_meter_rate_table *table = &post_meter->rate_steering_table; 84 int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in); 85 void *misc2, *match_criteria; 86 u32 *flow_group_in; 87 int err = 0; 88 89 flow_group_in = kvzalloc(inlen, GFP_KERNEL); 90 if (!flow_group_in) 91 return -ENOMEM; 92 93 MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, 94 MLX5_MATCH_MISC_PARAMETERS_2); 95 match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, 96 match_criteria); 97 misc2 = MLX5_ADDR_OF(fte_match_param, match_criteria, misc_parameters_2); 98 MLX5_SET(fte_match_set_misc2, misc2, metadata_reg_c_5, MLX5_PACKET_COLOR_MASK); 99 MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0); 100 MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 1); 101 102 table->fg = mlx5_create_flow_group(table->ft, flow_group_in); 103 if (IS_ERR(table->fg)) { 104 mlx5_core_warn(priv->mdev, "Failed to create post_meter flow group\n"); 105 err = PTR_ERR(table->fg); 106 } 107 108 kvfree(flow_group_in); 109 return err; 110 } 111 112 static struct mlx5_flow_handle * 113 mlx5e_post_meter_add_rule(struct mlx5e_priv *priv, 114 struct mlx5e_post_meter_priv *post_meter, 115 struct mlx5_flow_spec *spec, 116 struct mlx5_flow_attr *attr, 117 struct mlx5_fc *act_counter, 118 struct mlx5_fc *drop_counter) 119 { 120 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 121 struct mlx5_flow_handle *ret; 122 123 attr->action |= MLX5_FLOW_CONTEXT_ACTION_COUNT; 124 if (attr->action & MLX5_FLOW_CONTEXT_ACTION_DROP) 125 attr->counter = drop_counter; 126 else 127 attr->counter = act_counter; 128 129 attr->flags |= MLX5_ATTR_FLAG_NO_IN_PORT; 130 attr->outer_match_level = MLX5_MATCH_NONE; 131 attr->chain = 0; 132 attr->prio = 0; 133 134 ret = mlx5_eswitch_add_offloaded_rule(esw, spec, attr); 135 136 /* We did not create the counter, so we can't delete it. 137 * Avoid freeing the counter when the attr is deleted in free_branching_attr 138 */ 139 attr->action &= ~MLX5_FLOW_CONTEXT_ACTION_COUNT; 140 141 return ret; 142 } 143 144 static int 145 mlx5e_post_meter_rate_rules_create(struct mlx5e_priv *priv, 146 struct mlx5e_post_meter_priv *post_meter, 147 struct mlx5e_post_act *post_act, 148 struct mlx5_fc *act_counter, 149 struct mlx5_fc *drop_counter, 150 struct mlx5_flow_attr *green_attr, 151 struct mlx5_flow_attr *red_attr) 152 { 153 struct mlx5e_post_meter_rate_table *table = &post_meter->rate_steering_table; 154 struct mlx5_flow_handle *rule; 155 struct mlx5_flow_spec *spec; 156 int err; 157 158 spec = kvzalloc(sizeof(*spec), GFP_KERNEL); 159 if (!spec) 160 return -ENOMEM; 161 162 mlx5e_tc_match_to_reg_match(spec, PACKET_COLOR_TO_REG, 163 MLX5_FLOW_METER_COLOR_RED, MLX5_PACKET_COLOR_MASK); 164 red_attr->ft = post_meter->rate_steering_table.ft; 165 rule = mlx5e_post_meter_add_rule(priv, post_meter, spec, red_attr, 166 act_counter, drop_counter); 167 if (IS_ERR(rule)) { 168 mlx5_core_warn(priv->mdev, "Failed to create post_meter exceed rule\n"); 169 err = PTR_ERR(rule); 170 goto err_red; 171 } 172 table->red_rule = rule; 173 table->red_attr = red_attr; 174 175 mlx5e_tc_match_to_reg_match(spec, PACKET_COLOR_TO_REG, 176 MLX5_FLOW_METER_COLOR_GREEN, MLX5_PACKET_COLOR_MASK); 177 green_attr->ft = post_meter->rate_steering_table.ft; 178 rule = mlx5e_post_meter_add_rule(priv, post_meter, spec, green_attr, 179 act_counter, drop_counter); 180 if (IS_ERR(rule)) { 181 mlx5_core_warn(priv->mdev, "Failed to create post_meter notexceed rule\n"); 182 err = PTR_ERR(rule); 183 goto err_green; 184 } 185 table->green_rule = rule; 186 table->green_attr = green_attr; 187 188 kvfree(spec); 189 return 0; 190 191 err_green: 192 mlx5_del_flow_rules(table->red_rule); 193 err_red: 194 kvfree(spec); 195 return err; 196 } 197 198 static void 199 mlx5e_post_meter_rate_rules_destroy(struct mlx5_eswitch *esw, 200 struct mlx5e_post_meter_priv *post_meter) 201 { 202 struct mlx5e_post_meter_rate_table *rate_table = &post_meter->rate_steering_table; 203 204 mlx5_eswitch_del_offloaded_rule(esw, rate_table->red_rule, rate_table->red_attr); 205 mlx5_eswitch_del_offloaded_rule(esw, rate_table->green_rule, rate_table->green_attr); 206 } 207 208 static void 209 mlx5e_post_meter_rate_fg_destroy(struct mlx5e_post_meter_priv *post_meter) 210 { 211 mlx5_destroy_flow_group(post_meter->rate_steering_table.fg); 212 } 213 214 static void 215 mlx5e_post_meter_rate_table_destroy(struct mlx5e_post_meter_priv *post_meter) 216 { 217 mlx5_destroy_flow_table(post_meter->rate_steering_table.ft); 218 } 219 220 static void 221 mlx5e_post_meter_mtu_rules_destroy(struct mlx5e_post_meter_priv *post_meter) 222 { 223 struct mlx5e_post_meter_mtu_tables *mtu_tables = &post_meter->mtu_tables; 224 225 mlx5_del_flow_rules(mtu_tables->green_table.rule); 226 mlx5_del_flow_rules(mtu_tables->red_table.rule); 227 } 228 229 static void 230 mlx5e_post_meter_mtu_fg_destroy(struct mlx5e_post_meter_priv *post_meter) 231 { 232 struct mlx5e_post_meter_mtu_tables *mtu_tables = &post_meter->mtu_tables; 233 234 mlx5_destroy_flow_group(mtu_tables->green_table.fg); 235 mlx5_destroy_flow_group(mtu_tables->red_table.fg); 236 } 237 238 static void 239 mlx5e_post_meter_mtu_table_destroy(struct mlx5e_post_meter_priv *post_meter) 240 { 241 struct mlx5e_post_meter_mtu_tables *mtu_tables = &post_meter->mtu_tables; 242 243 mlx5_destroy_flow_table(mtu_tables->green_table.ft); 244 mlx5_destroy_flow_table(mtu_tables->red_table.ft); 245 } 246 247 static int 248 mlx5e_post_meter_rate_create(struct mlx5e_priv *priv, 249 enum mlx5_flow_namespace_type ns_type, 250 struct mlx5e_post_act *post_act, 251 struct mlx5_fc *act_counter, 252 struct mlx5_fc *drop_counter, 253 struct mlx5e_post_meter_priv *post_meter, 254 struct mlx5_flow_attr *green_attr, 255 struct mlx5_flow_attr *red_attr) 256 { 257 struct mlx5_flow_table *ft; 258 int err; 259 260 post_meter->type = MLX5E_POST_METER_RATE; 261 262 ft = mlx5e_post_meter_table_create(priv, ns_type); 263 if (IS_ERR(ft)) { 264 err = PTR_ERR(ft); 265 mlx5_core_warn(priv->mdev, "Failed to create post_meter table\n"); 266 goto err_ft; 267 } 268 269 post_meter->rate_steering_table.ft = ft; 270 271 err = mlx5e_post_meter_rate_fg_create(priv, post_meter); 272 if (err) 273 goto err_fg; 274 275 err = mlx5e_post_meter_rate_rules_create(priv, post_meter, post_act, 276 act_counter, drop_counter, 277 green_attr, red_attr); 278 if (err) 279 goto err_rules; 280 281 return 0; 282 283 err_rules: 284 mlx5e_post_meter_rate_fg_destroy(post_meter); 285 err_fg: 286 mlx5e_post_meter_rate_table_destroy(post_meter); 287 err_ft: 288 return err; 289 } 290 291 static int 292 mlx5e_post_meter_create_mtu_table(struct mlx5e_priv *priv, 293 enum mlx5_flow_namespace_type ns_type, 294 struct mlx5e_post_meter_mtu_table *table) 295 { 296 int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in); 297 struct mlx5_flow_group *fg; 298 u32 *flow_group_in; 299 int err; 300 301 flow_group_in = kvzalloc(inlen, GFP_KERNEL); 302 if (!flow_group_in) 303 return -ENOMEM; 304 305 table->ft = mlx5e_post_meter_table_create(priv, ns_type); 306 if (IS_ERR(table->ft)) { 307 err = PTR_ERR(table->ft); 308 goto err_ft; 309 } 310 311 /* create miss group */ 312 memset(flow_group_in, 0, inlen); 313 MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 1); 314 MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 1); 315 fg = mlx5_create_flow_group(table->ft, flow_group_in); 316 if (IS_ERR(fg)) { 317 err = PTR_ERR(fg); 318 goto err_miss_grp; 319 } 320 table->fg = fg; 321 322 kvfree(flow_group_in); 323 return 0; 324 325 err_miss_grp: 326 mlx5_destroy_flow_table(table->ft); 327 err_ft: 328 kvfree(flow_group_in); 329 return err; 330 } 331 332 static int 333 mlx5e_post_meter_mtu_create(struct mlx5e_priv *priv, 334 enum mlx5_flow_namespace_type ns_type, 335 struct mlx5e_post_act *post_act, 336 struct mlx5_fc *act_counter, 337 struct mlx5_fc *drop_counter, 338 struct mlx5e_post_meter_priv *post_meter, 339 struct mlx5_flow_attr *green_attr, 340 struct mlx5_flow_attr *red_attr) 341 { 342 struct mlx5e_post_meter_mtu_tables *mtu_tables = &post_meter->mtu_tables; 343 static struct mlx5_flow_spec zero_spec = {}; 344 struct mlx5_flow_handle *rule; 345 int err; 346 347 post_meter->type = MLX5E_POST_METER_MTU; 348 349 err = mlx5e_post_meter_create_mtu_table(priv, ns_type, &mtu_tables->green_table); 350 if (err) 351 goto err_green_ft; 352 353 green_attr->ft = mtu_tables->green_table.ft; 354 rule = mlx5e_post_meter_add_rule(priv, post_meter, &zero_spec, green_attr, 355 act_counter, drop_counter); 356 if (IS_ERR(rule)) { 357 mlx5_core_warn(priv->mdev, "Failed to create post_meter conform rule\n"); 358 err = PTR_ERR(rule); 359 goto err_green_rule; 360 } 361 mtu_tables->green_table.rule = rule; 362 mtu_tables->green_table.attr = green_attr; 363 364 err = mlx5e_post_meter_create_mtu_table(priv, ns_type, &mtu_tables->red_table); 365 if (err) 366 goto err_red_ft; 367 368 red_attr->ft = mtu_tables->red_table.ft; 369 rule = mlx5e_post_meter_add_rule(priv, post_meter, &zero_spec, red_attr, 370 act_counter, drop_counter); 371 if (IS_ERR(rule)) { 372 mlx5_core_warn(priv->mdev, "Failed to create post_meter exceed rule\n"); 373 err = PTR_ERR(rule); 374 goto err_red_rule; 375 } 376 mtu_tables->red_table.rule = rule; 377 mtu_tables->red_table.attr = red_attr; 378 379 return 0; 380 381 err_red_rule: 382 mlx5_destroy_flow_table(mtu_tables->red_table.ft); 383 err_red_ft: 384 mlx5_del_flow_rules(mtu_tables->green_table.rule); 385 err_green_rule: 386 mlx5_destroy_flow_table(mtu_tables->green_table.ft); 387 err_green_ft: 388 return err; 389 } 390 391 struct mlx5e_post_meter_priv * 392 mlx5e_post_meter_init(struct mlx5e_priv *priv, 393 enum mlx5_flow_namespace_type ns_type, 394 struct mlx5e_post_act *post_act, 395 enum mlx5e_post_meter_type type, 396 struct mlx5_fc *act_counter, 397 struct mlx5_fc *drop_counter, 398 struct mlx5_flow_attr *branch_true, 399 struct mlx5_flow_attr *branch_false) 400 { 401 struct mlx5e_post_meter_priv *post_meter; 402 int err; 403 404 post_meter = kzalloc(sizeof(*post_meter), GFP_KERNEL); 405 if (!post_meter) 406 return ERR_PTR(-ENOMEM); 407 408 switch (type) { 409 case MLX5E_POST_METER_MTU: 410 err = mlx5e_post_meter_mtu_create(priv, ns_type, post_act, 411 act_counter, drop_counter, post_meter, 412 branch_true, branch_false); 413 break; 414 case MLX5E_POST_METER_RATE: 415 err = mlx5e_post_meter_rate_create(priv, ns_type, post_act, 416 act_counter, drop_counter, post_meter, 417 branch_true, branch_false); 418 break; 419 default: 420 err = -EOPNOTSUPP; 421 } 422 423 if (err) 424 goto err; 425 426 return post_meter; 427 428 err: 429 kfree(post_meter); 430 return ERR_PTR(err); 431 } 432 433 static void 434 mlx5e_post_meter_rate_destroy(struct mlx5_eswitch *esw, struct mlx5e_post_meter_priv *post_meter) 435 { 436 mlx5e_post_meter_rate_rules_destroy(esw, post_meter); 437 mlx5e_post_meter_rate_fg_destroy(post_meter); 438 mlx5e_post_meter_rate_table_destroy(post_meter); 439 } 440 441 static void 442 mlx5e_post_meter_mtu_destroy(struct mlx5e_post_meter_priv *post_meter) 443 { 444 mlx5e_post_meter_mtu_rules_destroy(post_meter); 445 mlx5e_post_meter_mtu_fg_destroy(post_meter); 446 mlx5e_post_meter_mtu_table_destroy(post_meter); 447 } 448 449 void 450 mlx5e_post_meter_cleanup(struct mlx5_eswitch *esw, struct mlx5e_post_meter_priv *post_meter) 451 { 452 if (post_meter->type == MLX5E_POST_METER_RATE) 453 mlx5e_post_meter_rate_destroy(esw, post_meter); 454 else 455 mlx5e_post_meter_mtu_destroy(post_meter); 456 457 kfree(post_meter); 458 } 459 460