net/devlink/rate.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
   5  */
   6
   7 #include "devl_internal.h"
   8
   9 static inline bool
  10 devlink_rate_is_leaf(struct devlink_rate *devlink_rate)
  11 {
  12         return devlink_rate->type == DEVLINK_RATE_TYPE_LEAF;
  13 }
  14
  15 static inline bool
  16 devlink_rate_is_node(struct devlink_rate *devlink_rate)
  17 {
  18         return devlink_rate->type == DEVLINK_RATE_TYPE_NODE;
  19 }
  20
  21 static struct devlink_rate *
  22 devlink_rate_leaf_get_from_info(struct devlink *devlink, struct genl_info *info)
  23 {
  24         struct devlink_rate *devlink_rate;
  25         struct devlink_port *devlink_port;
  26
  27         devlink_port = devlink_port_get_from_attrs(devlink, info->attrs);
  28         if (IS_ERR(devlink_port))
  29                 return ERR_CAST(devlink_port);
  30         devlink_rate = devlink_port->devlink_rate;
  31         return devlink_rate ?: ERR_PTR(-ENODEV);
  32 }
  33
  34 static struct devlink_rate *
  35 devlink_rate_node_get_by_name(struct devlink *devlink, const char *node_name)
  36 {
  37         static struct devlink_rate *devlink_rate;
  38
  39         list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
  40                 if (devlink_rate_is_node(devlink_rate) &&
  41                     !strcmp(node_name, devlink_rate->name))
  42                         return devlink_rate;
  43         }
  44         return ERR_PTR(-ENODEV);
  45 }
  46
  47 static struct devlink_rate *
  48 devlink_rate_node_get_from_attrs(struct devlink *devlink, struct nlattr **attrs)
  49 {
  50         const char *rate_node_name;
  51         size_t len;
  52
  53         if (!attrs[DEVLINK_ATTR_RATE_NODE_NAME])
  54                 return ERR_PTR(-EINVAL);
  55         rate_node_name = nla_data(attrs[DEVLINK_ATTR_RATE_NODE_NAME]);
  56         len = strlen(rate_node_name);
  57         /* Name cannot be empty or decimal number */
  58         if (!len || strspn(rate_node_name, "0123456789") == len)
  59                 return ERR_PTR(-EINVAL);
  60
  61         return devlink_rate_node_get_by_name(devlink, rate_node_name);
  62 }
  63
  64 static struct devlink_rate *
  65 devlink_rate_node_get_from_info(struct devlink *devlink, struct genl_info *info)
  66 {
  67         return devlink_rate_node_get_from_attrs(devlink, info->attrs);
  68 }
  69
  70 static struct devlink_rate *
  71 devlink_rate_get_from_info(struct devlink *devlink, struct genl_info *info)
  72 {
  73         struct nlattr **attrs = info->attrs;
  74
  75         if (attrs[DEVLINK_ATTR_PORT_INDEX])
  76                 return devlink_rate_leaf_get_from_info(devlink, info);
  77         else if (attrs[DEVLINK_ATTR_RATE_NODE_NAME])
  78                 return devlink_rate_node_get_from_info(devlink, info);
  79         else
  80                 return ERR_PTR(-EINVAL);
  81 }
  82
  83 static int devlink_nl_rate_fill(struct sk_buff *msg,
  84                                 struct devlink_rate *devlink_rate,
  85                                 enum devlink_command cmd, u32 portid, u32 seq,
  86                                 int flags, struct netlink_ext_ack *extack)
  87 {
  88         struct devlink *devlink = devlink_rate->devlink;
  89         void *hdr;
  90
  91         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
  92         if (!hdr)
  93                 return -EMSGSIZE;
  94
  95         if (devlink_nl_put_handle(msg, devlink))
  96                 goto nla_put_failure;
  97
  98         if (nla_put_u16(msg, DEVLINK_ATTR_RATE_TYPE, devlink_rate->type))
  99                 goto nla_put_failure;
 100
 101         if (devlink_rate_is_leaf(devlink_rate)) {
 102                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
 103                                 devlink_rate->devlink_port->index))
 104                         goto nla_put_failure;
 105         } else if (devlink_rate_is_node(devlink_rate)) {
 106                 if (nla_put_string(msg, DEVLINK_ATTR_RATE_NODE_NAME,
 107                                    devlink_rate->name))
 108                         goto nla_put_failure;
 109         }
 110
 111         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_RATE_TX_SHARE,
 112                               devlink_rate->tx_share, DEVLINK_ATTR_PAD))
 113                 goto nla_put_failure;
 114
 115         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_RATE_TX_MAX,
 116                               devlink_rate->tx_max, DEVLINK_ATTR_PAD))
 117                 goto nla_put_failure;
 118
 119         if (nla_put_u32(msg, DEVLINK_ATTR_RATE_TX_PRIORITY,
 120                         devlink_rate->tx_priority))
 121                 goto nla_put_failure;
 122
 123         if (nla_put_u32(msg, DEVLINK_ATTR_RATE_TX_WEIGHT,
 124                         devlink_rate->tx_weight))
 125                 goto nla_put_failure;
 126
 127         if (devlink_rate->parent)
 128                 if (nla_put_string(msg, DEVLINK_ATTR_RATE_PARENT_NODE_NAME,
 129                                    devlink_rate->parent->name))
 130                         goto nla_put_failure;
 131
 132         genlmsg_end(msg, hdr);
 133         return 0;
 134
 135 nla_put_failure:
 136         genlmsg_cancel(msg, hdr);
 137         return -EMSGSIZE;
 138 }
 139
 140 static void devlink_rate_notify(struct devlink_rate *devlink_rate,
 141                                 enum devlink_command cmd)
 142 {
 143         struct devlink *devlink = devlink_rate->devlink;
 144         struct sk_buff *msg;
 145         int err;
 146
 147         WARN_ON(cmd != DEVLINK_CMD_RATE_NEW && cmd != DEVLINK_CMD_RATE_DEL);
 148
 149         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
 150                 return;
 151
 152         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 153         if (!msg)
 154                 return;
 155
 156         err = devlink_nl_rate_fill(msg, devlink_rate, cmd, 0, 0, 0, NULL);
 157         if (err) {
 158                 nlmsg_free(msg);
 159                 return;
 160         }
 161
 162         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink), msg,
 163                                 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
 164 }
 165
 166 void devlink_rates_notify_register(struct devlink *devlink)
 167 {
 168         struct devlink_rate *rate_node;
 169
 170         list_for_each_entry(rate_node, &devlink->rate_list, list)
 171                 devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_NEW);
 172 }
 173
 174 void devlink_rates_notify_unregister(struct devlink *devlink)
 175 {
 176         struct devlink_rate *rate_node;
 177
 178         list_for_each_entry_reverse(rate_node, &devlink->rate_list, list)
 179                 devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_DEL);
 180 }
 181
 182 static int
 183 devlink_nl_rate_get_dump_one(struct sk_buff *msg, struct devlink *devlink,
 184                              struct netlink_callback *cb, int flags)
 185 {
 186         struct devlink_nl_dump_state *state = devlink_dump_state(cb);
 187         struct devlink_rate *devlink_rate;
 188         int idx = 0;
 189         int err = 0;
 190
 191         list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
 192                 enum devlink_command cmd = DEVLINK_CMD_RATE_NEW;
 193                 u32 id = NETLINK_CB(cb->skb).portid;
 194
 195                 if (idx < state->idx) {
 196                         idx++;
 197                         continue;
 198                 }
 199                 err = devlink_nl_rate_fill(msg, devlink_rate, cmd, id,
 200                                            cb->nlh->nlmsg_seq, flags, NULL);
 201                 if (err) {
 202                         state->idx = idx;
 203                         break;
 204                 }
 205                 idx++;
 206         }
 207
 208         return err;
 209 }
 210
 211 int devlink_nl_rate_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
 212 {
 213         return devlink_nl_dumpit(skb, cb, devlink_nl_rate_get_dump_one);
 214 }
 215
 216 int devlink_nl_rate_get_doit(struct sk_buff *skb, struct genl_info *info)
 217 {
 218         struct devlink *devlink = info->user_ptr[0];
 219         struct devlink_rate *devlink_rate;
 220         struct sk_buff *msg;
 221         int err;
 222
 223         devlink_rate = devlink_rate_get_from_info(devlink, info);
 224         if (IS_ERR(devlink_rate))
 225                 return PTR_ERR(devlink_rate);
 226
 227         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 228         if (!msg)
 229                 return -ENOMEM;
 230
 231         err = devlink_nl_rate_fill(msg, devlink_rate, DEVLINK_CMD_RATE_NEW,
 232                                    info->snd_portid, info->snd_seq, 0,
 233                                    info->extack);
 234         if (err) {
 235                 nlmsg_free(msg);
 236                 return err;
 237         }
 238
 239         return genlmsg_reply(msg, info);
 240 }
 241
 242 static bool
 243 devlink_rate_is_parent_node(struct devlink_rate *devlink_rate,
 244                             struct devlink_rate *parent)
 245 {
 246         while (parent) {
 247                 if (parent == devlink_rate)
 248                         return true;
 249                 parent = parent->parent;
 250         }
 251         return false;
 252 }
 253
 254 static int
 255 devlink_nl_rate_parent_node_set(struct devlink_rate *devlink_rate,
 256                                 struct genl_info *info,
 257                                 struct nlattr *nla_parent)
 258 {
 259         struct devlink *devlink = devlink_rate->devlink;
 260         const char *parent_name = nla_data(nla_parent);
 261         const struct devlink_ops *ops = devlink->ops;
 262         size_t len = strlen(parent_name);
 263         struct devlink_rate *parent;
 264         int err = -EOPNOTSUPP;
 265
 266         parent = devlink_rate->parent;
 267
 268         if (parent && !len) {
 269                 if (devlink_rate_is_leaf(devlink_rate))
 270                         err = ops->rate_leaf_parent_set(devlink_rate, NULL,
 271                                                         devlink_rate->priv, NULL,
 272                                                         info->extack);
 273                 else if (devlink_rate_is_node(devlink_rate))
 274                         err = ops->rate_node_parent_set(devlink_rate, NULL,
 275                                                         devlink_rate->priv, NULL,
 276                                                         info->extack);
 277                 if (err)
 278                         return err;
 279
 280                 refcount_dec(&parent->refcnt);
 281                 devlink_rate->parent = NULL;
 282         } else if (len) {
 283                 parent = devlink_rate_node_get_by_name(devlink, parent_name);
 284                 if (IS_ERR(parent))
 285                         return -ENODEV;
 286
 287                 if (parent == devlink_rate) {
 288                         NL_SET_ERR_MSG(info->extack, "Parent to self is not allowed");
 289                         return -EINVAL;
 290                 }
 291
 292                 if (devlink_rate_is_node(devlink_rate) &&
 293                     devlink_rate_is_parent_node(devlink_rate, parent->parent)) {
 294                         NL_SET_ERR_MSG(info->extack, "Node is already a parent of parent node.");
 295                         return -EEXIST;
 296                 }
 297
 298                 if (devlink_rate_is_leaf(devlink_rate))
 299                         err = ops->rate_leaf_parent_set(devlink_rate, parent,
 300                                                         devlink_rate->priv, parent->priv,
 301                                                         info->extack);
 302                 else if (devlink_rate_is_node(devlink_rate))
 303                         err = ops->rate_node_parent_set(devlink_rate, parent,
 304                                                         devlink_rate->priv, parent->priv,
 305                                                         info->extack);
 306                 if (err)
 307                         return err;
 308
 309                 if (devlink_rate->parent)
 310                         /* we're reassigning to other parent in this case */
 311                         refcount_dec(&devlink_rate->parent->refcnt);
 312
 313                 refcount_inc(&parent->refcnt);
 314                 devlink_rate->parent = parent;
 315         }
 316
 317         return 0;
 318 }
 319
 320 static int devlink_nl_rate_set(struct devlink_rate *devlink_rate,
 321                                const struct devlink_ops *ops,
 322                                struct genl_info *info)
 323 {
 324         struct nlattr *nla_parent, **attrs = info->attrs;
 325         int err = -EOPNOTSUPP;
 326         u32 priority;
 327         u32 weight;
 328         u64 rate;
 329
 330         if (attrs[DEVLINK_ATTR_RATE_TX_SHARE]) {
 331                 rate = nla_get_u64(attrs[DEVLINK_ATTR_RATE_TX_SHARE]);
 332                 if (devlink_rate_is_leaf(devlink_rate))
 333                         err = ops->rate_leaf_tx_share_set(devlink_rate, devlink_rate->priv,
 334                                                           rate, info->extack);
 335                 else if (devlink_rate_is_node(devlink_rate))
 336                         err = ops->rate_node_tx_share_set(devlink_rate, devlink_rate->priv,
 337                                                           rate, info->extack);
 338                 if (err)
 339                         return err;
 340                 devlink_rate->tx_share = rate;
 341         }
 342
 343         if (attrs[DEVLINK_ATTR_RATE_TX_MAX]) {
 344                 rate = nla_get_u64(attrs[DEVLINK_ATTR_RATE_TX_MAX]);
 345                 if (devlink_rate_is_leaf(devlink_rate))
 346                         err = ops->rate_leaf_tx_max_set(devlink_rate, devlink_rate->priv,
 347                                                         rate, info->extack);
 348                 else if (devlink_rate_is_node(devlink_rate))
 349                         err = ops->rate_node_tx_max_set(devlink_rate, devlink_rate->priv,
 350                                                         rate, info->extack);
 351                 if (err)
 352                         return err;
 353                 devlink_rate->tx_max = rate;
 354         }
 355
 356         if (attrs[DEVLINK_ATTR_RATE_TX_PRIORITY]) {
 357                 priority = nla_get_u32(attrs[DEVLINK_ATTR_RATE_TX_PRIORITY]);
 358                 if (devlink_rate_is_leaf(devlink_rate))
 359                         err = ops->rate_leaf_tx_priority_set(devlink_rate, devlink_rate->priv,
 360                                                              priority, info->extack);
 361                 else if (devlink_rate_is_node(devlink_rate))
 362                         err = ops->rate_node_tx_priority_set(devlink_rate, devlink_rate->priv,
 363                                                              priority, info->extack);
 364
 365                 if (err)
 366                         return err;
 367                 devlink_rate->tx_priority = priority;
 368         }
 369
 370         if (attrs[DEVLINK_ATTR_RATE_TX_WEIGHT]) {
 371                 weight = nla_get_u32(attrs[DEVLINK_ATTR_RATE_TX_WEIGHT]);
 372                 if (devlink_rate_is_leaf(devlink_rate))
 373                         err = ops->rate_leaf_tx_weight_set(devlink_rate, devlink_rate->priv,
 374                                                            weight, info->extack);
 375                 else if (devlink_rate_is_node(devlink_rate))
 376                         err = ops->rate_node_tx_weight_set(devlink_rate, devlink_rate->priv,
 377                                                            weight, info->extack);
 378
 379                 if (err)
 380                         return err;
 381                 devlink_rate->tx_weight = weight;
 382         }
 383
 384         nla_parent = attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME];
 385         if (nla_parent) {
 386                 err = devlink_nl_rate_parent_node_set(devlink_rate, info,
 387                                                       nla_parent);
 388                 if (err)
 389                         return err;
 390         }
 391
 392         return 0;
 393 }
 394
 395 static bool devlink_rate_set_ops_supported(const struct devlink_ops *ops,
 396                                            struct genl_info *info,
 397                                            enum devlink_rate_type type)
 398 {
 399         struct nlattr **attrs = info->attrs;
 400
 401         if (type == DEVLINK_RATE_TYPE_LEAF) {
 402                 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE] && !ops->rate_leaf_tx_share_set) {
 403                         NL_SET_ERR_MSG(info->extack, "TX share set isn't supported for the leafs");
 404                         return false;
 405                 }
 406                 if (attrs[DEVLINK_ATTR_RATE_TX_MAX] && !ops->rate_leaf_tx_max_set) {
 407                         NL_SET_ERR_MSG(info->extack, "TX max set isn't supported for the leafs");
 408                         return false;
 409                 }
 410                 if (attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] &&
 411                     !ops->rate_leaf_parent_set) {
 412                         NL_SET_ERR_MSG(info->extack, "Parent set isn't supported for the leafs");
 413                         return false;
 414                 }
 415                 if (attrs[DEVLINK_ATTR_RATE_TX_PRIORITY] && !ops->rate_leaf_tx_priority_set) {
 416                         NL_SET_ERR_MSG_ATTR(info->extack,
 417                                             attrs[DEVLINK_ATTR_RATE_TX_PRIORITY],
 418                                             "TX priority set isn't supported for the leafs");
 419                         return false;
 420                 }
 421                 if (attrs[DEVLINK_ATTR_RATE_TX_WEIGHT] && !ops->rate_leaf_tx_weight_set) {
 422                         NL_SET_ERR_MSG_ATTR(info->extack,
 423                                             attrs[DEVLINK_ATTR_RATE_TX_WEIGHT],
 424                                             "TX weight set isn't supported for the leafs");
 425                         return false;
 426                 }
 427         } else if (type == DEVLINK_RATE_TYPE_NODE) {
 428                 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE] && !ops->rate_node_tx_share_set) {
 429                         NL_SET_ERR_MSG(info->extack, "TX share set isn't supported for the nodes");
 430                         return false;
 431                 }
 432                 if (attrs[DEVLINK_ATTR_RATE_TX_MAX] && !ops->rate_node_tx_max_set) {
 433                         NL_SET_ERR_MSG(info->extack, "TX max set isn't supported for the nodes");
 434                         return false;
 435                 }
 436                 if (attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] &&
 437                     !ops->rate_node_parent_set) {
 438                         NL_SET_ERR_MSG(info->extack, "Parent set isn't supported for the nodes");
 439                         return false;
 440                 }
 441                 if (attrs[DEVLINK_ATTR_RATE_TX_PRIORITY] && !ops->rate_node_tx_priority_set) {
 442                         NL_SET_ERR_MSG_ATTR(info->extack,
 443                                             attrs[DEVLINK_ATTR_RATE_TX_PRIORITY],
 444                                             "TX priority set isn't supported for the nodes");
 445                         return false;
 446                 }
 447                 if (attrs[DEVLINK_ATTR_RATE_TX_WEIGHT] && !ops->rate_node_tx_weight_set) {
 448                         NL_SET_ERR_MSG_ATTR(info->extack,
 449                                             attrs[DEVLINK_ATTR_RATE_TX_WEIGHT],
 450                                             "TX weight set isn't supported for the nodes");
 451                         return false;
 452                 }
 453         } else {
 454                 WARN(1, "Unknown type of rate object");
 455                 return false;
 456         }
 457
 458         return true;
 459 }
 460
 461 int devlink_nl_cmd_rate_set_doit(struct sk_buff *skb, struct genl_info *info)
 462 {
 463         struct devlink *devlink = info->user_ptr[0];
 464         struct devlink_rate *devlink_rate;
 465         const struct devlink_ops *ops;
 466         int err;
 467
 468         devlink_rate = devlink_rate_get_from_info(devlink, info);
 469         if (IS_ERR(devlink_rate))
 470                 return PTR_ERR(devlink_rate);
 471
 472         ops = devlink->ops;
 473         if (!ops || !devlink_rate_set_ops_supported(ops, info, devlink_rate->type))
 474                 return -EOPNOTSUPP;
 475
 476         err = devlink_nl_rate_set(devlink_rate, ops, info);
 477
 478         if (!err)
 479                 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
 480         return err;
 481 }
 482
 483 int devlink_nl_cmd_rate_new_doit(struct sk_buff *skb, struct genl_info *info)
 484 {
 485         struct devlink *devlink = info->user_ptr[0];
 486         struct devlink_rate *rate_node;
 487         const struct devlink_ops *ops;
 488         int err;
 489
 490         ops = devlink->ops;
 491         if (!ops || !ops->rate_node_new || !ops->rate_node_del) {
 492                 NL_SET_ERR_MSG(info->extack, "Rate nodes aren't supported");
 493                 return -EOPNOTSUPP;
 494         }
 495
 496         if (!devlink_rate_set_ops_supported(ops, info, DEVLINK_RATE_TYPE_NODE))
 497                 return -EOPNOTSUPP;
 498
 499         rate_node = devlink_rate_node_get_from_attrs(devlink, info->attrs);
 500         if (!IS_ERR(rate_node))
 501                 return -EEXIST;
 502         else if (rate_node == ERR_PTR(-EINVAL))
 503                 return -EINVAL;
 504
 505         rate_node = kzalloc(sizeof(*rate_node), GFP_KERNEL);
 506         if (!rate_node)
 507                 return -ENOMEM;
 508
 509         rate_node->devlink = devlink;
 510         rate_node->type = DEVLINK_RATE_TYPE_NODE;
 511         rate_node->name = nla_strdup(info->attrs[DEVLINK_ATTR_RATE_NODE_NAME], GFP_KERNEL);
 512         if (!rate_node->name) {
 513                 err = -ENOMEM;
 514                 goto err_strdup;
 515         }
 516
 517         err = ops->rate_node_new(rate_node, &rate_node->priv, info->extack);
 518         if (err)
 519                 goto err_node_new;
 520
 521         err = devlink_nl_rate_set(rate_node, ops, info);
 522         if (err)
 523                 goto err_rate_set;
 524
 525         refcount_set(&rate_node->refcnt, 1);
 526         list_add(&rate_node->list, &devlink->rate_list);
 527         devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_NEW);
 528         return 0;
 529
 530 err_rate_set:
 531         ops->rate_node_del(rate_node, rate_node->priv, info->extack);
 532 err_node_new:
 533         kfree(rate_node->name);
 534 err_strdup:
 535         kfree(rate_node);
 536         return err;
 537 }
 538
 539 int devlink_nl_cmd_rate_del_doit(struct sk_buff *skb, struct genl_info *info)
 540 {
 541         struct devlink *devlink = info->user_ptr[0];
 542         struct devlink_rate *rate_node;
 543         int err;
 544
 545         rate_node = devlink_rate_node_get_from_info(devlink, info);
 546         if (IS_ERR(rate_node))
 547                 return PTR_ERR(rate_node);
 548
 549         if (refcount_read(&rate_node->refcnt) > 1) {
 550                 NL_SET_ERR_MSG(info->extack, "Node has children. Cannot delete node.");
 551                 return -EBUSY;
 552         }
 553
 554         devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_DEL);
 555         err = devlink->ops->rate_node_del(rate_node, rate_node->priv,
 556                                           info->extack);
 557         if (rate_node->parent)
 558                 refcount_dec(&rate_node->parent->refcnt);
 559         list_del(&rate_node->list);
 560         kfree(rate_node->name);
 561         kfree(rate_node);
 562         return err;
 563 }
 564
 565 int devlink_rate_nodes_check(struct devlink *devlink, u16 mode,
 566                              struct netlink_ext_ack *extack)
 567 {
 568         struct devlink_rate *devlink_rate;
 569
 570         list_for_each_entry(devlink_rate, &devlink->rate_list, list)
 571                 if (devlink_rate_is_node(devlink_rate)) {
 572                         NL_SET_ERR_MSG(extack, "Rate node(s) exists.");
 573                         return -EBUSY;
 574                 }
 575         return 0;
 576 }
 577
 578 /**
 579  * devl_rate_node_create - create devlink rate node
 580  * @devlink: devlink instance
 581  * @priv: driver private data
 582  * @node_name: name of the resulting node
 583  * @parent: parent devlink_rate struct
 584  *
 585  * Create devlink rate object of type node
 586  */
 587 struct devlink_rate *
 588 devl_rate_node_create(struct devlink *devlink, void *priv, char *node_name,
 589                       struct devlink_rate *parent)
 590 {
 591         struct devlink_rate *rate_node;
 592
 593         rate_node = devlink_rate_node_get_by_name(devlink, node_name);
 594         if (!IS_ERR(rate_node))
 595                 return ERR_PTR(-EEXIST);
 596
 597         rate_node = kzalloc(sizeof(*rate_node), GFP_KERNEL);
 598         if (!rate_node)
 599                 return ERR_PTR(-ENOMEM);
 600
 601         if (parent) {
 602                 rate_node->parent = parent;
 603                 refcount_inc(&rate_node->parent->refcnt);
 604         }
 605
 606         rate_node->type = DEVLINK_RATE_TYPE_NODE;
 607         rate_node->devlink = devlink;
 608         rate_node->priv = priv;
 609
 610         rate_node->name = kstrdup(node_name, GFP_KERNEL);
 611         if (!rate_node->name) {
 612                 kfree(rate_node);
 613                 return ERR_PTR(-ENOMEM);
 614         }
 615
 616         refcount_set(&rate_node->refcnt, 1);
 617         list_add(&rate_node->list, &devlink->rate_list);
 618         devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_NEW);
 619         return rate_node;
 620 }
 621 EXPORT_SYMBOL_GPL(devl_rate_node_create);
 622
 623 /**
 624  * devl_rate_leaf_create - create devlink rate leaf
 625  * @devlink_port: devlink port object to create rate object on
 626  * @priv: driver private data
 627  * @parent: parent devlink_rate struct
 628  *
 629  * Create devlink rate object of type leaf on provided @devlink_port.
 630  */
 631 int devl_rate_leaf_create(struct devlink_port *devlink_port, void *priv,
 632                           struct devlink_rate *parent)
 633 {
 634         struct devlink *devlink = devlink_port->devlink;
 635         struct devlink_rate *devlink_rate;
 636
 637         devl_assert_locked(devlink_port->devlink);
 638
 639         if (WARN_ON(devlink_port->devlink_rate))
 640                 return -EBUSY;
 641
 642         devlink_rate = kzalloc(sizeof(*devlink_rate), GFP_KERNEL);
 643         if (!devlink_rate)
 644                 return -ENOMEM;
 645
 646         if (parent) {
 647                 devlink_rate->parent = parent;
 648                 refcount_inc(&devlink_rate->parent->refcnt);
 649         }
 650
 651         devlink_rate->type = DEVLINK_RATE_TYPE_LEAF;
 652         devlink_rate->devlink = devlink;
 653         devlink_rate->devlink_port = devlink_port;
 654         devlink_rate->priv = priv;
 655         list_add_tail(&devlink_rate->list, &devlink->rate_list);
 656         devlink_port->devlink_rate = devlink_rate;
 657         devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
 658
 659         return 0;
 660 }
 661 EXPORT_SYMBOL_GPL(devl_rate_leaf_create);
 662
 663 /**
 664  * devl_rate_leaf_destroy - destroy devlink rate leaf
 665  *
 666  * @devlink_port: devlink port linked to the rate object
 667  *
 668  * Destroy the devlink rate object of type leaf on provided @devlink_port.
 669  */
 670 void devl_rate_leaf_destroy(struct devlink_port *devlink_port)
 671 {
 672         struct devlink_rate *devlink_rate = devlink_port->devlink_rate;
 673
 674         devl_assert_locked(devlink_port->devlink);
 675         if (!devlink_rate)
 676                 return;
 677
 678         devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_DEL);
 679         if (devlink_rate->parent)
 680                 refcount_dec(&devlink_rate->parent->refcnt);
 681         list_del(&devlink_rate->list);
 682         devlink_port->devlink_rate = NULL;
 683         kfree(devlink_rate);
 684 }
 685 EXPORT_SYMBOL_GPL(devl_rate_leaf_destroy);
 686
 687 /**
 688  * devl_rate_nodes_destroy - destroy all devlink rate nodes on device
 689  * @devlink: devlink instance
 690  *
 691  * Unset parent for all rate objects and destroy all rate nodes
 692  * on specified device.
 693  */
 694 void devl_rate_nodes_destroy(struct devlink *devlink)
 695 {
 696         static struct devlink_rate *devlink_rate, *tmp;
 697         const struct devlink_ops *ops = devlink->ops;
 698
 699         devl_assert_locked(devlink);
 700
 701         list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
 702                 if (!devlink_rate->parent)
 703                         continue;
 704
 705                 refcount_dec(&devlink_rate->parent->refcnt);
 706                 if (devlink_rate_is_leaf(devlink_rate))
 707                         ops->rate_leaf_parent_set(devlink_rate, NULL, devlink_rate->priv,
 708                                                   NULL, NULL);
 709                 else if (devlink_rate_is_node(devlink_rate))
 710                         ops->rate_node_parent_set(devlink_rate, NULL, devlink_rate->priv,
 711                                                   NULL, NULL);
 712         }
 713         list_for_each_entry_safe(devlink_rate, tmp, &devlink->rate_list, list) {
 714                 if (devlink_rate_is_node(devlink_rate)) {
 715                         ops->rate_node_del(devlink_rate, devlink_rate->priv, NULL);
 716                         list_del(&devlink_rate->list);
 717                         kfree(devlink_rate->name);
 718                         kfree(devlink_rate);
 719                 }
 720         }
 721 }
 722 EXPORT_SYMBOL_GPL(devl_rate_nodes_destroy);