net/core/devlink.c

   1 /*
   2  * net/core/devlink.c - Network physical/parent device Netlink interface
   3  *
   4  * Heavily inspired by net/wireless/
   5  * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
   6  * Copyright (c) 2016 Jiri Pirko <[email protected]>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/types.h>
  17 #include <linux/slab.h>
  18 #include <linux/gfp.h>
  19 #include <linux/device.h>
  20 #include <linux/list.h>
  21 #include <linux/netdevice.h>
  22 #include <rdma/ib_verbs.h>
  23 #include <net/netlink.h>
  24 #include <net/genetlink.h>
  25 #include <net/rtnetlink.h>
  26 #include <net/net_namespace.h>
  27 #include <net/sock.h>
  28 #include <net/devlink.h>
  29 #define CREATE_TRACE_POINTS
  30 #include <trace/events/devlink.h>
  31
  32 static struct devlink_dpipe_field devlink_dpipe_fields_ethernet[] = {
  33         {
  34                 .name = "destination mac",
  35                 .id = DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC,
  36                 .bitwidth = 48,
  37         },
  38 };
  39
  40 struct devlink_dpipe_header devlink_dpipe_header_ethernet = {
  41         .name = "ethernet",
  42         .id = DEVLINK_DPIPE_HEADER_ETHERNET,
  43         .fields = devlink_dpipe_fields_ethernet,
  44         .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ethernet),
  45         .global = true,
  46 };
  47 EXPORT_SYMBOL(devlink_dpipe_header_ethernet);
  48
  49 static struct devlink_dpipe_field devlink_dpipe_fields_ipv4[] = {
  50         {
  51                 .name = "destination ip",
  52                 .id = DEVLINK_DPIPE_FIELD_IPV4_DST_IP,
  53                 .bitwidth = 32,
  54         },
  55 };
  56
  57 struct devlink_dpipe_header devlink_dpipe_header_ipv4 = {
  58         .name = "ipv4",
  59         .id = DEVLINK_DPIPE_HEADER_IPV4,
  60         .fields = devlink_dpipe_fields_ipv4,
  61         .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv4),
  62         .global = true,
  63 };
  64 EXPORT_SYMBOL(devlink_dpipe_header_ipv4);
  65
  66 static struct devlink_dpipe_field devlink_dpipe_fields_ipv6[] = {
  67         {
  68                 .name = "destination ip",
  69                 .id = DEVLINK_DPIPE_FIELD_IPV6_DST_IP,
  70                 .bitwidth = 128,
  71         },
  72 };
  73
  74 struct devlink_dpipe_header devlink_dpipe_header_ipv6 = {
  75         .name = "ipv6",
  76         .id = DEVLINK_DPIPE_HEADER_IPV6,
  77         .fields = devlink_dpipe_fields_ipv6,
  78         .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv6),
  79         .global = true,
  80 };
  81 EXPORT_SYMBOL(devlink_dpipe_header_ipv6);
  82
  83 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg);
  84
  85 static LIST_HEAD(devlink_list);
  86
  87 /* devlink_mutex
  88  *
  89  * An overall lock guarding every operation coming from userspace.
  90  * It also guards devlink devices list and it is taken when
  91  * driver registers/unregisters it.
  92  */
  93 static DEFINE_MUTEX(devlink_mutex);
  94
  95 static struct net *devlink_net(const struct devlink *devlink)
  96 {
  97         return read_pnet(&devlink->_net);
  98 }
  99
 100 static void devlink_net_set(struct devlink *devlink, struct net *net)
 101 {
 102         write_pnet(&devlink->_net, net);
 103 }
 104
 105 static struct devlink *devlink_get_from_attrs(struct net *net,
 106                                               struct nlattr **attrs)
 107 {
 108         struct devlink *devlink;
 109         char *busname;
 110         char *devname;
 111
 112         if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
 113                 return ERR_PTR(-EINVAL);
 114
 115         busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
 116         devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
 117
 118         list_for_each_entry(devlink, &devlink_list, list) {
 119                 if (strcmp(devlink->dev->bus->name, busname) == 0 &&
 120                     strcmp(dev_name(devlink->dev), devname) == 0 &&
 121                     net_eq(devlink_net(devlink), net))
 122                         return devlink;
 123         }
 124
 125         return ERR_PTR(-ENODEV);
 126 }
 127
 128 static struct devlink *devlink_get_from_info(struct genl_info *info)
 129 {
 130         return devlink_get_from_attrs(genl_info_net(info), info->attrs);
 131 }
 132
 133 static struct devlink_port *devlink_port_get_by_index(struct devlink *devlink,
 134                                                       int port_index)
 135 {
 136         struct devlink_port *devlink_port;
 137
 138         list_for_each_entry(devlink_port, &devlink->port_list, list) {
 139                 if (devlink_port->index == port_index)
 140                         return devlink_port;
 141         }
 142         return NULL;
 143 }
 144
 145 static bool devlink_port_index_exists(struct devlink *devlink, int port_index)
 146 {
 147         return devlink_port_get_by_index(devlink, port_index);
 148 }
 149
 150 static struct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink,
 151                                                         struct nlattr **attrs)
 152 {
 153         if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
 154                 u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
 155                 struct devlink_port *devlink_port;
 156
 157                 devlink_port = devlink_port_get_by_index(devlink, port_index);
 158                 if (!devlink_port)
 159                         return ERR_PTR(-ENODEV);
 160                 return devlink_port;
 161         }
 162         return ERR_PTR(-EINVAL);
 163 }
 164
 165 static struct devlink_port *devlink_port_get_from_info(struct devlink *devlink,
 166                                                        struct genl_info *info)
 167 {
 168         return devlink_port_get_from_attrs(devlink, info->attrs);
 169 }
 170
 171 struct devlink_sb {
 172         struct list_head list;
 173         unsigned int index;
 174         u32 size;
 175         u16 ingress_pools_count;
 176         u16 egress_pools_count;
 177         u16 ingress_tc_count;
 178         u16 egress_tc_count;
 179 };
 180
 181 static u16 devlink_sb_pool_count(struct devlink_sb *devlink_sb)
 182 {
 183         return devlink_sb->ingress_pools_count + devlink_sb->egress_pools_count;
 184 }
 185
 186 static struct devlink_sb *devlink_sb_get_by_index(struct devlink *devlink,
 187                                                   unsigned int sb_index)
 188 {
 189         struct devlink_sb *devlink_sb;
 190
 191         list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
 192                 if (devlink_sb->index == sb_index)
 193                         return devlink_sb;
 194         }
 195         return NULL;
 196 }
 197
 198 static bool devlink_sb_index_exists(struct devlink *devlink,
 199                                     unsigned int sb_index)
 200 {
 201         return devlink_sb_get_by_index(devlink, sb_index);
 202 }
 203
 204 static struct devlink_sb *devlink_sb_get_from_attrs(struct devlink *devlink,
 205                                                     struct nlattr **attrs)
 206 {
 207         if (attrs[DEVLINK_ATTR_SB_INDEX]) {
 208                 u32 sb_index = nla_get_u32(attrs[DEVLINK_ATTR_SB_INDEX]);
 209                 struct devlink_sb *devlink_sb;
 210
 211                 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
 212                 if (!devlink_sb)
 213                         return ERR_PTR(-ENODEV);
 214                 return devlink_sb;
 215         }
 216         return ERR_PTR(-EINVAL);
 217 }
 218
 219 static struct devlink_sb *devlink_sb_get_from_info(struct devlink *devlink,
 220                                                    struct genl_info *info)
 221 {
 222         return devlink_sb_get_from_attrs(devlink, info->attrs);
 223 }
 224
 225 static int devlink_sb_pool_index_get_from_attrs(struct devlink_sb *devlink_sb,
 226                                                 struct nlattr **attrs,
 227                                                 u16 *p_pool_index)
 228 {
 229         u16 val;
 230
 231         if (!attrs[DEVLINK_ATTR_SB_POOL_INDEX])
 232                 return -EINVAL;
 233
 234         val = nla_get_u16(attrs[DEVLINK_ATTR_SB_POOL_INDEX]);
 235         if (val >= devlink_sb_pool_count(devlink_sb))
 236                 return -EINVAL;
 237         *p_pool_index = val;
 238         return 0;
 239 }
 240
 241 static int devlink_sb_pool_index_get_from_info(struct devlink_sb *devlink_sb,
 242                                                struct genl_info *info,
 243                                                u16 *p_pool_index)
 244 {
 245         return devlink_sb_pool_index_get_from_attrs(devlink_sb, info->attrs,
 246                                                     p_pool_index);
 247 }
 248
 249 static int
 250 devlink_sb_pool_type_get_from_attrs(struct nlattr **attrs,
 251                                     enum devlink_sb_pool_type *p_pool_type)
 252 {
 253         u8 val;
 254
 255         if (!attrs[DEVLINK_ATTR_SB_POOL_TYPE])
 256                 return -EINVAL;
 257
 258         val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_TYPE]);
 259         if (val != DEVLINK_SB_POOL_TYPE_INGRESS &&
 260             val != DEVLINK_SB_POOL_TYPE_EGRESS)
 261                 return -EINVAL;
 262         *p_pool_type = val;
 263         return 0;
 264 }
 265
 266 static int
 267 devlink_sb_pool_type_get_from_info(struct genl_info *info,
 268                                    enum devlink_sb_pool_type *p_pool_type)
 269 {
 270         return devlink_sb_pool_type_get_from_attrs(info->attrs, p_pool_type);
 271 }
 272
 273 static int
 274 devlink_sb_th_type_get_from_attrs(struct nlattr **attrs,
 275                                   enum devlink_sb_threshold_type *p_th_type)
 276 {
 277         u8 val;
 278
 279         if (!attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])
 280                 return -EINVAL;
 281
 282         val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE]);
 283         if (val != DEVLINK_SB_THRESHOLD_TYPE_STATIC &&
 284             val != DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC)
 285                 return -EINVAL;
 286         *p_th_type = val;
 287         return 0;
 288 }
 289
 290 static int
 291 devlink_sb_th_type_get_from_info(struct genl_info *info,
 292                                  enum devlink_sb_threshold_type *p_th_type)
 293 {
 294         return devlink_sb_th_type_get_from_attrs(info->attrs, p_th_type);
 295 }
 296
 297 static int
 298 devlink_sb_tc_index_get_from_attrs(struct devlink_sb *devlink_sb,
 299                                    struct nlattr **attrs,
 300                                    enum devlink_sb_pool_type pool_type,
 301                                    u16 *p_tc_index)
 302 {
 303         u16 val;
 304
 305         if (!attrs[DEVLINK_ATTR_SB_TC_INDEX])
 306                 return -EINVAL;
 307
 308         val = nla_get_u16(attrs[DEVLINK_ATTR_SB_TC_INDEX]);
 309         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS &&
 310             val >= devlink_sb->ingress_tc_count)
 311                 return -EINVAL;
 312         if (pool_type == DEVLINK_SB_POOL_TYPE_EGRESS &&
 313             val >= devlink_sb->egress_tc_count)
 314                 return -EINVAL;
 315         *p_tc_index = val;
 316         return 0;
 317 }
 318
 319 static int
 320 devlink_sb_tc_index_get_from_info(struct devlink_sb *devlink_sb,
 321                                   struct genl_info *info,
 322                                   enum devlink_sb_pool_type pool_type,
 323                                   u16 *p_tc_index)
 324 {
 325         return devlink_sb_tc_index_get_from_attrs(devlink_sb, info->attrs,
 326                                                   pool_type, p_tc_index);
 327 }
 328
 329 #define DEVLINK_NL_FLAG_NEED_DEVLINK    BIT(0)
 330 #define DEVLINK_NL_FLAG_NEED_PORT       BIT(1)
 331 #define DEVLINK_NL_FLAG_NEED_SB         BIT(2)
 332
 333 /* The per devlink instance lock is taken by default in the pre-doit
 334  * operation, yet several commands do not require this. The global
 335  * devlink lock is taken and protects from disruption by user-calls.
 336  */
 337 #define DEVLINK_NL_FLAG_NO_LOCK         BIT(3)
 338
 339 static int devlink_nl_pre_doit(const struct genl_ops *ops,
 340                                struct sk_buff *skb, struct genl_info *info)
 341 {
 342         struct devlink *devlink;
 343         int err;
 344
 345         mutex_lock(&devlink_mutex);
 346         devlink = devlink_get_from_info(info);
 347         if (IS_ERR(devlink)) {
 348                 mutex_unlock(&devlink_mutex);
 349                 return PTR_ERR(devlink);
 350         }
 351         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
 352                 mutex_lock(&devlink->lock);
 353         if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_DEVLINK) {
 354                 info->user_ptr[0] = devlink;
 355         } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_PORT) {
 356                 struct devlink_port *devlink_port;
 357
 358                 devlink_port = devlink_port_get_from_info(devlink, info);
 359                 if (IS_ERR(devlink_port)) {
 360                         err = PTR_ERR(devlink_port);
 361                         goto unlock;
 362                 }
 363                 info->user_ptr[0] = devlink_port;
 364         }
 365         if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_SB) {
 366                 struct devlink_sb *devlink_sb;
 367
 368                 devlink_sb = devlink_sb_get_from_info(devlink, info);
 369                 if (IS_ERR(devlink_sb)) {
 370                         err = PTR_ERR(devlink_sb);
 371                         goto unlock;
 372                 }
 373                 info->user_ptr[1] = devlink_sb;
 374         }
 375         return 0;
 376
 377 unlock:
 378         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
 379                 mutex_unlock(&devlink->lock);
 380         mutex_unlock(&devlink_mutex);
 381         return err;
 382 }
 383
 384 static void devlink_nl_post_doit(const struct genl_ops *ops,
 385                                  struct sk_buff *skb, struct genl_info *info)
 386 {
 387         struct devlink *devlink;
 388
 389         devlink = devlink_get_from_info(info);
 390         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
 391                 mutex_unlock(&devlink->lock);
 392         mutex_unlock(&devlink_mutex);
 393 }
 394
 395 static struct genl_family devlink_nl_family;
 396
 397 enum devlink_multicast_groups {
 398         DEVLINK_MCGRP_CONFIG,
 399 };
 400
 401 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
 402         [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
 403 };
 404
 405 static int devlink_nl_put_handle(struct sk_buff *msg, struct devlink *devlink)
 406 {
 407         if (nla_put_string(msg, DEVLINK_ATTR_BUS_NAME, devlink->dev->bus->name))
 408                 return -EMSGSIZE;
 409         if (nla_put_string(msg, DEVLINK_ATTR_DEV_NAME, dev_name(devlink->dev)))
 410                 return -EMSGSIZE;
 411         return 0;
 412 }
 413
 414 static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
 415                            enum devlink_command cmd, u32 portid,
 416                            u32 seq, int flags)
 417 {
 418         void *hdr;
 419
 420         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 421         if (!hdr)
 422                 return -EMSGSIZE;
 423
 424         if (devlink_nl_put_handle(msg, devlink))
 425                 goto nla_put_failure;
 426
 427         genlmsg_end(msg, hdr);
 428         return 0;
 429
 430 nla_put_failure:
 431         genlmsg_cancel(msg, hdr);
 432         return -EMSGSIZE;
 433 }
 434
 435 static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
 436 {
 437         struct sk_buff *msg;
 438         int err;
 439
 440         WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
 441
 442         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 443         if (!msg)
 444                 return;
 445
 446         err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
 447         if (err) {
 448                 nlmsg_free(msg);
 449                 return;
 450         }
 451
 452         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
 453                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
 454 }
 455
 456 static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
 457                                 struct devlink_port *devlink_port,
 458                                 enum devlink_command cmd, u32 portid,
 459                                 u32 seq, int flags)
 460 {
 461         void *hdr;
 462
 463         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 464         if (!hdr)
 465                 return -EMSGSIZE;
 466
 467         if (devlink_nl_put_handle(msg, devlink))
 468                 goto nla_put_failure;
 469         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
 470                 goto nla_put_failure;
 471         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
 472                 goto nla_put_failure;
 473         if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
 474             nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
 475                         devlink_port->desired_type))
 476                 goto nla_put_failure;
 477         if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
 478                 struct net_device *netdev = devlink_port->type_dev;
 479
 480                 if (netdev &&
 481                     (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
 482                                  netdev->ifindex) ||
 483                      nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
 484                                     netdev->name)))
 485                         goto nla_put_failure;
 486         }
 487         if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
 488                 struct ib_device *ibdev = devlink_port->type_dev;
 489
 490                 if (ibdev &&
 491                     nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
 492                                    ibdev->name))
 493                         goto nla_put_failure;
 494         }
 495         if (devlink_port->split &&
 496             nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP,
 497                         devlink_port->split_group))
 498                 goto nla_put_failure;
 499
 500         genlmsg_end(msg, hdr);
 501         return 0;
 502
 503 nla_put_failure:
 504         genlmsg_cancel(msg, hdr);
 505         return -EMSGSIZE;
 506 }
 507
 508 static void devlink_port_notify(struct devlink_port *devlink_port,
 509                                 enum devlink_command cmd)
 510 {
 511         struct devlink *devlink = devlink_port->devlink;
 512         struct sk_buff *msg;
 513         int err;
 514
 515         if (!devlink_port->registered)
 516                 return;
 517
 518         WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
 519
 520         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 521         if (!msg)
 522                 return;
 523
 524         err = devlink_nl_port_fill(msg, devlink, devlink_port, cmd, 0, 0, 0);
 525         if (err) {
 526                 nlmsg_free(msg);
 527                 return;
 528         }
 529
 530         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
 531                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
 532 }
 533
 534 static int devlink_nl_cmd_get_doit(struct sk_buff *skb, struct genl_info *info)
 535 {
 536         struct devlink *devlink = info->user_ptr[0];
 537         struct sk_buff *msg;
 538         int err;
 539
 540         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 541         if (!msg)
 542                 return -ENOMEM;
 543
 544         err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
 545                               info->snd_portid, info->snd_seq, 0);
 546         if (err) {
 547                 nlmsg_free(msg);
 548                 return err;
 549         }
 550
 551         return genlmsg_reply(msg, info);
 552 }
 553
 554 static int devlink_nl_cmd_get_dumpit(struct sk_buff *msg,
 555                                      struct netlink_callback *cb)
 556 {
 557         struct devlink *devlink;
 558         int start = cb->args[0];
 559         int idx = 0;
 560         int err;
 561
 562         mutex_lock(&devlink_mutex);
 563         list_for_each_entry(devlink, &devlink_list, list) {
 564                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
 565                         continue;
 566                 if (idx < start) {
 567                         idx++;
 568                         continue;
 569                 }
 570                 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
 571                                       NETLINK_CB(cb->skb).portid,
 572                                       cb->nlh->nlmsg_seq, NLM_F_MULTI);
 573                 if (err)
 574                         goto out;
 575                 idx++;
 576         }
 577 out:
 578         mutex_unlock(&devlink_mutex);
 579
 580         cb->args[0] = idx;
 581         return msg->len;
 582 }
 583
 584 static int devlink_nl_cmd_port_get_doit(struct sk_buff *skb,
 585                                         struct genl_info *info)
 586 {
 587         struct devlink_port *devlink_port = info->user_ptr[0];
 588         struct devlink *devlink = devlink_port->devlink;
 589         struct sk_buff *msg;
 590         int err;
 591
 592         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 593         if (!msg)
 594                 return -ENOMEM;
 595
 596         err = devlink_nl_port_fill(msg, devlink, devlink_port,
 597                                    DEVLINK_CMD_PORT_NEW,
 598                                    info->snd_portid, info->snd_seq, 0);
 599         if (err) {
 600                 nlmsg_free(msg);
 601                 return err;
 602         }
 603
 604         return genlmsg_reply(msg, info);
 605 }
 606
 607 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff *msg,
 608                                           struct netlink_callback *cb)
 609 {
 610         struct devlink *devlink;
 611         struct devlink_port *devlink_port;
 612         int start = cb->args[0];
 613         int idx = 0;
 614         int err;
 615
 616         mutex_lock(&devlink_mutex);
 617         list_for_each_entry(devlink, &devlink_list, list) {
 618                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
 619                         continue;
 620                 mutex_lock(&devlink->lock);
 621                 list_for_each_entry(devlink_port, &devlink->port_list, list) {
 622                         if (idx < start) {
 623                                 idx++;
 624                                 continue;
 625                         }
 626                         err = devlink_nl_port_fill(msg, devlink, devlink_port,
 627                                                    DEVLINK_CMD_NEW,
 628                                                    NETLINK_CB(cb->skb).portid,
 629                                                    cb->nlh->nlmsg_seq,
 630                                                    NLM_F_MULTI);
 631                         if (err) {
 632                                 mutex_unlock(&devlink->lock);
 633                                 goto out;
 634                         }
 635                         idx++;
 636                 }
 637                 mutex_unlock(&devlink->lock);
 638         }
 639 out:
 640         mutex_unlock(&devlink_mutex);
 641
 642         cb->args[0] = idx;
 643         return msg->len;
 644 }
 645
 646 static int devlink_port_type_set(struct devlink *devlink,
 647                                  struct devlink_port *devlink_port,
 648                                  enum devlink_port_type port_type)
 649
 650 {
 651         int err;
 652
 653         if (devlink->ops && devlink->ops->port_type_set) {
 654                 if (port_type == DEVLINK_PORT_TYPE_NOTSET)
 655                         return -EINVAL;
 656                 if (port_type == devlink_port->type)
 657                         return 0;
 658                 err = devlink->ops->port_type_set(devlink_port, port_type);
 659                 if (err)
 660                         return err;
 661                 devlink_port->desired_type = port_type;
 662                 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
 663                 return 0;
 664         }
 665         return -EOPNOTSUPP;
 666 }
 667
 668 static int devlink_nl_cmd_port_set_doit(struct sk_buff *skb,
 669                                         struct genl_info *info)
 670 {
 671         struct devlink_port *devlink_port = info->user_ptr[0];
 672         struct devlink *devlink = devlink_port->devlink;
 673         int err;
 674
 675         if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
 676                 enum devlink_port_type port_type;
 677
 678                 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
 679                 err = devlink_port_type_set(devlink, devlink_port, port_type);
 680                 if (err)
 681                         return err;
 682         }
 683         return 0;
 684 }
 685
 686 static int devlink_port_split(struct devlink *devlink,
 687                               u32 port_index, u32 count)
 688
 689 {
 690         if (devlink->ops && devlink->ops->port_split)
 691                 return devlink->ops->port_split(devlink, port_index, count);
 692         return -EOPNOTSUPP;
 693 }
 694
 695 static int devlink_nl_cmd_port_split_doit(struct sk_buff *skb,
 696                                           struct genl_info *info)
 697 {
 698         struct devlink *devlink = info->user_ptr[0];
 699         u32 port_index;
 700         u32 count;
 701
 702         if (!info->attrs[DEVLINK_ATTR_PORT_INDEX] ||
 703             !info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT])
 704                 return -EINVAL;
 705
 706         port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
 707         count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
 708         return devlink_port_split(devlink, port_index, count);
 709 }
 710
 711 static int devlink_port_unsplit(struct devlink *devlink, u32 port_index)
 712
 713 {
 714         if (devlink->ops && devlink->ops->port_unsplit)
 715                 return devlink->ops->port_unsplit(devlink, port_index);
 716         return -EOPNOTSUPP;
 717 }
 718
 719 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
 720                                             struct genl_info *info)
 721 {
 722         struct devlink *devlink = info->user_ptr[0];
 723         u32 port_index;
 724
 725         if (!info->attrs[DEVLINK_ATTR_PORT_INDEX])
 726                 return -EINVAL;
 727
 728         port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
 729         return devlink_port_unsplit(devlink, port_index);
 730 }
 731
 732 static int devlink_nl_sb_fill(struct sk_buff *msg, struct devlink *devlink,
 733                               struct devlink_sb *devlink_sb,
 734                               enum devlink_command cmd, u32 portid,
 735                               u32 seq, int flags)
 736 {
 737         void *hdr;
 738
 739         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 740         if (!hdr)
 741                 return -EMSGSIZE;
 742
 743         if (devlink_nl_put_handle(msg, devlink))
 744                 goto nla_put_failure;
 745         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
 746                 goto nla_put_failure;
 747         if (nla_put_u32(msg, DEVLINK_ATTR_SB_SIZE, devlink_sb->size))
 748                 goto nla_put_failure;
 749         if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT,
 750                         devlink_sb->ingress_pools_count))
 751                 goto nla_put_failure;
 752         if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT,
 753                         devlink_sb->egress_pools_count))
 754                 goto nla_put_failure;
 755         if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_TC_COUNT,
 756                         devlink_sb->ingress_tc_count))
 757                 goto nla_put_failure;
 758         if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_TC_COUNT,
 759                         devlink_sb->egress_tc_count))
 760                 goto nla_put_failure;
 761
 762         genlmsg_end(msg, hdr);
 763         return 0;
 764
 765 nla_put_failure:
 766         genlmsg_cancel(msg, hdr);
 767         return -EMSGSIZE;
 768 }
 769
 770 static int devlink_nl_cmd_sb_get_doit(struct sk_buff *skb,
 771                                       struct genl_info *info)
 772 {
 773         struct devlink *devlink = info->user_ptr[0];
 774         struct devlink_sb *devlink_sb = info->user_ptr[1];
 775         struct sk_buff *msg;
 776         int err;
 777
 778         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 779         if (!msg)
 780                 return -ENOMEM;
 781
 782         err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
 783                                  DEVLINK_CMD_SB_NEW,
 784                                  info->snd_portid, info->snd_seq, 0);
 785         if (err) {
 786                 nlmsg_free(msg);
 787                 return err;
 788         }
 789
 790         return genlmsg_reply(msg, info);
 791 }
 792
 793 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff *msg,
 794                                         struct netlink_callback *cb)
 795 {
 796         struct devlink *devlink;
 797         struct devlink_sb *devlink_sb;
 798         int start = cb->args[0];
 799         int idx = 0;
 800         int err;
 801
 802         mutex_lock(&devlink_mutex);
 803         list_for_each_entry(devlink, &devlink_list, list) {
 804                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
 805                         continue;
 806                 mutex_lock(&devlink->lock);
 807                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
 808                         if (idx < start) {
 809                                 idx++;
 810                                 continue;
 811                         }
 812                         err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
 813                                                  DEVLINK_CMD_SB_NEW,
 814                                                  NETLINK_CB(cb->skb).portid,
 815                                                  cb->nlh->nlmsg_seq,
 816                                                  NLM_F_MULTI);
 817                         if (err) {
 818                                 mutex_unlock(&devlink->lock);
 819                                 goto out;
 820                         }
 821                         idx++;
 822                 }
 823                 mutex_unlock(&devlink->lock);
 824         }
 825 out:
 826         mutex_unlock(&devlink_mutex);
 827
 828         cb->args[0] = idx;
 829         return msg->len;
 830 }
 831
 832 static int devlink_nl_sb_pool_fill(struct sk_buff *msg, struct devlink *devlink,
 833                                    struct devlink_sb *devlink_sb,
 834                                    u16 pool_index, enum devlink_command cmd,
 835                                    u32 portid, u32 seq, int flags)
 836 {
 837         struct devlink_sb_pool_info pool_info;
 838         void *hdr;
 839         int err;
 840
 841         err = devlink->ops->sb_pool_get(devlink, devlink_sb->index,
 842                                         pool_index, &pool_info);
 843         if (err)
 844                 return err;
 845
 846         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 847         if (!hdr)
 848                 return -EMSGSIZE;
 849
 850         if (devlink_nl_put_handle(msg, devlink))
 851                 goto nla_put_failure;
 852         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
 853                 goto nla_put_failure;
 854         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
 855                 goto nla_put_failure;
 856         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_info.pool_type))
 857                 goto nla_put_failure;
 858         if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_SIZE, pool_info.size))
 859                 goto nla_put_failure;
 860         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
 861                        pool_info.threshold_type))
 862                 goto nla_put_failure;
 863
 864         genlmsg_end(msg, hdr);
 865         return 0;
 866
 867 nla_put_failure:
 868         genlmsg_cancel(msg, hdr);
 869         return -EMSGSIZE;
 870 }
 871
 872 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff *skb,
 873                                            struct genl_info *info)
 874 {
 875         struct devlink *devlink = info->user_ptr[0];
 876         struct devlink_sb *devlink_sb = info->user_ptr[1];
 877         struct sk_buff *msg;
 878         u16 pool_index;
 879         int err;
 880
 881         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
 882                                                   &pool_index);
 883         if (err)
 884                 return err;
 885
 886         if (!devlink->ops || !devlink->ops->sb_pool_get)
 887                 return -EOPNOTSUPP;
 888
 889         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 890         if (!msg)
 891                 return -ENOMEM;
 892
 893         err = devlink_nl_sb_pool_fill(msg, devlink, devlink_sb, pool_index,
 894                                       DEVLINK_CMD_SB_POOL_NEW,
 895                                       info->snd_portid, info->snd_seq, 0);
 896         if (err) {
 897                 nlmsg_free(msg);
 898                 return err;
 899         }
 900
 901         return genlmsg_reply(msg, info);
 902 }
 903
 904 static int __sb_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
 905                                 struct devlink *devlink,
 906                                 struct devlink_sb *devlink_sb,
 907                                 u32 portid, u32 seq)
 908 {
 909         u16 pool_count = devlink_sb_pool_count(devlink_sb);
 910         u16 pool_index;
 911         int err;
 912
 913         for (pool_index = 0; pool_index < pool_count; pool_index++) {
 914                 if (*p_idx < start) {
 915                         (*p_idx)++;
 916                         continue;
 917                 }
 918                 err = devlink_nl_sb_pool_fill(msg, devlink,
 919                                               devlink_sb,
 920                                               pool_index,
 921                                               DEVLINK_CMD_SB_POOL_NEW,
 922                                               portid, seq, NLM_F_MULTI);
 923                 if (err)
 924                         return err;
 925                 (*p_idx)++;
 926         }
 927         return 0;
 928 }
 929
 930 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff *msg,
 931                                              struct netlink_callback *cb)
 932 {
 933         struct devlink *devlink;
 934         struct devlink_sb *devlink_sb;
 935         int start = cb->args[0];
 936         int idx = 0;
 937         int err;
 938
 939         mutex_lock(&devlink_mutex);
 940         list_for_each_entry(devlink, &devlink_list, list) {
 941                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
 942                     !devlink->ops || !devlink->ops->sb_pool_get)
 943                         continue;
 944                 mutex_lock(&devlink->lock);
 945                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
 946                         err = __sb_pool_get_dumpit(msg, start, &idx, devlink,
 947                                                    devlink_sb,
 948                                                    NETLINK_CB(cb->skb).portid,
 949                                                    cb->nlh->nlmsg_seq);
 950                         if (err && err != -EOPNOTSUPP) {
 951                                 mutex_unlock(&devlink->lock);
 952                                 goto out;
 953                         }
 954                 }
 955                 mutex_unlock(&devlink->lock);
 956         }
 957 out:
 958         mutex_unlock(&devlink_mutex);
 959
 960         cb->args[0] = idx;
 961         return msg->len;
 962 }
 963
 964 static int devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
 965                                u16 pool_index, u32 size,
 966                                enum devlink_sb_threshold_type threshold_type)
 967
 968 {
 969         const struct devlink_ops *ops = devlink->ops;
 970
 971         if (ops && ops->sb_pool_set)
 972                 return ops->sb_pool_set(devlink, sb_index, pool_index,
 973                                         size, threshold_type);
 974         return -EOPNOTSUPP;
 975 }
 976
 977 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb,
 978                                            struct genl_info *info)
 979 {
 980         struct devlink *devlink = info->user_ptr[0];
 981         struct devlink_sb *devlink_sb = info->user_ptr[1];
 982         enum devlink_sb_threshold_type threshold_type;
 983         u16 pool_index;
 984         u32 size;
 985         int err;
 986
 987         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
 988                                                   &pool_index);
 989         if (err)
 990                 return err;
 991
 992         err = devlink_sb_th_type_get_from_info(info, &threshold_type);
 993         if (err)
 994                 return err;
 995
 996         if (!info->attrs[DEVLINK_ATTR_SB_POOL_SIZE])
 997                 return -EINVAL;
 998
 999         size = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_POOL_SIZE]);
1000         return devlink_sb_pool_set(devlink, devlink_sb->index,
1001                                    pool_index, size, threshold_type);
1002 }
1003
1004 static int devlink_nl_sb_port_pool_fill(struct sk_buff *msg,
1005                                         struct devlink *devlink,
1006                                         struct devlink_port *devlink_port,
1007                                         struct devlink_sb *devlink_sb,
1008                                         u16 pool_index,
1009                                         enum devlink_command cmd,
1010                                         u32 portid, u32 seq, int flags)
1011 {
1012         const struct devlink_ops *ops = devlink->ops;
1013         u32 threshold;
1014         void *hdr;
1015         int err;
1016
1017         err = ops->sb_port_pool_get(devlink_port, devlink_sb->index,
1018                                     pool_index, &threshold);
1019         if (err)
1020                 return err;
1021
1022         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1023         if (!hdr)
1024                 return -EMSGSIZE;
1025
1026         if (devlink_nl_put_handle(msg, devlink))
1027                 goto nla_put_failure;
1028         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1029                 goto nla_put_failure;
1030         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1031                 goto nla_put_failure;
1032         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1033                 goto nla_put_failure;
1034         if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1035                 goto nla_put_failure;
1036
1037         if (ops->sb_occ_port_pool_get) {
1038                 u32 cur;
1039                 u32 max;
1040
1041                 err = ops->sb_occ_port_pool_get(devlink_port, devlink_sb->index,
1042                                                 pool_index, &cur, &max);
1043                 if (err && err != -EOPNOTSUPP)
1044                         return err;
1045                 if (!err) {
1046                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1047                                 goto nla_put_failure;
1048                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1049                                 goto nla_put_failure;
1050                 }
1051         }
1052
1053         genlmsg_end(msg, hdr);
1054         return 0;
1055
1056 nla_put_failure:
1057         genlmsg_cancel(msg, hdr);
1058         return -EMSGSIZE;
1059 }
1060
1061 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff *skb,
1062                                                 struct genl_info *info)
1063 {
1064         struct devlink_port *devlink_port = info->user_ptr[0];
1065         struct devlink *devlink = devlink_port->devlink;
1066         struct devlink_sb *devlink_sb = info->user_ptr[1];
1067         struct sk_buff *msg;
1068         u16 pool_index;
1069         int err;
1070
1071         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1072                                                   &pool_index);
1073         if (err)
1074                 return err;
1075
1076         if (!devlink->ops || !devlink->ops->sb_port_pool_get)
1077                 return -EOPNOTSUPP;
1078
1079         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1080         if (!msg)
1081                 return -ENOMEM;
1082
1083         err = devlink_nl_sb_port_pool_fill(msg, devlink, devlink_port,
1084                                            devlink_sb, pool_index,
1085                                            DEVLINK_CMD_SB_PORT_POOL_NEW,
1086                                            info->snd_portid, info->snd_seq, 0);
1087         if (err) {
1088                 nlmsg_free(msg);
1089                 return err;
1090         }
1091
1092         return genlmsg_reply(msg, info);
1093 }
1094
1095 static int __sb_port_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
1096                                      struct devlink *devlink,
1097                                      struct devlink_sb *devlink_sb,
1098                                      u32 portid, u32 seq)
1099 {
1100         struct devlink_port *devlink_port;
1101         u16 pool_count = devlink_sb_pool_count(devlink_sb);
1102         u16 pool_index;
1103         int err;
1104
1105         list_for_each_entry(devlink_port, &devlink->port_list, list) {
1106                 for (pool_index = 0; pool_index < pool_count; pool_index++) {
1107                         if (*p_idx < start) {
1108                                 (*p_idx)++;
1109                                 continue;
1110                         }
1111                         err = devlink_nl_sb_port_pool_fill(msg, devlink,
1112                                                            devlink_port,
1113                                                            devlink_sb,
1114                                                            pool_index,
1115                                                            DEVLINK_CMD_SB_PORT_POOL_NEW,
1116                                                            portid, seq,
1117                                                            NLM_F_MULTI);
1118                         if (err)
1119                                 return err;
1120                         (*p_idx)++;
1121                 }
1122         }
1123         return 0;
1124 }
1125
1126 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff *msg,
1127                                                   struct netlink_callback *cb)
1128 {
1129         struct devlink *devlink;
1130         struct devlink_sb *devlink_sb;
1131         int start = cb->args[0];
1132         int idx = 0;
1133         int err;
1134
1135         mutex_lock(&devlink_mutex);
1136         list_for_each_entry(devlink, &devlink_list, list) {
1137                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1138                     !devlink->ops || !devlink->ops->sb_port_pool_get)
1139                         continue;
1140                 mutex_lock(&devlink->lock);
1141                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1142                         err = __sb_port_pool_get_dumpit(msg, start, &idx,
1143                                                         devlink, devlink_sb,
1144                                                         NETLINK_CB(cb->skb).portid,
1145                                                         cb->nlh->nlmsg_seq);
1146                         if (err && err != -EOPNOTSUPP) {
1147                                 mutex_unlock(&devlink->lock);
1148                                 goto out;
1149                         }
1150                 }
1151                 mutex_unlock(&devlink->lock);
1152         }
1153 out:
1154         mutex_unlock(&devlink_mutex);
1155
1156         cb->args[0] = idx;
1157         return msg->len;
1158 }
1159
1160 static int devlink_sb_port_pool_set(struct devlink_port *devlink_port,
1161                                     unsigned int sb_index, u16 pool_index,
1162                                     u32 threshold)
1163
1164 {
1165         const struct devlink_ops *ops = devlink_port->devlink->ops;
1166
1167         if (ops && ops->sb_port_pool_set)
1168                 return ops->sb_port_pool_set(devlink_port, sb_index,
1169                                              pool_index, threshold);
1170         return -EOPNOTSUPP;
1171 }
1172
1173 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
1174                                                 struct genl_info *info)
1175 {
1176         struct devlink_port *devlink_port = info->user_ptr[0];
1177         struct devlink_sb *devlink_sb = info->user_ptr[1];
1178         u16 pool_index;
1179         u32 threshold;
1180         int err;
1181
1182         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1183                                                   &pool_index);
1184         if (err)
1185                 return err;
1186
1187         if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1188                 return -EINVAL;
1189
1190         threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1191         return devlink_sb_port_pool_set(devlink_port, devlink_sb->index,
1192                                         pool_index, threshold);
1193 }
1194
1195 static int
1196 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff *msg, struct devlink *devlink,
1197                                 struct devlink_port *devlink_port,
1198                                 struct devlink_sb *devlink_sb, u16 tc_index,
1199                                 enum devlink_sb_pool_type pool_type,
1200                                 enum devlink_command cmd,
1201                                 u32 portid, u32 seq, int flags)
1202 {
1203         const struct devlink_ops *ops = devlink->ops;
1204         u16 pool_index;
1205         u32 threshold;
1206         void *hdr;
1207         int err;
1208
1209         err = ops->sb_tc_pool_bind_get(devlink_port, devlink_sb->index,
1210                                        tc_index, pool_type,
1211                                        &pool_index, &threshold);
1212         if (err)
1213                 return err;
1214
1215         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1216         if (!hdr)
1217                 return -EMSGSIZE;
1218
1219         if (devlink_nl_put_handle(msg, devlink))
1220                 goto nla_put_failure;
1221         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1222                 goto nla_put_failure;
1223         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1224                 goto nla_put_failure;
1225         if (nla_put_u16(msg, DEVLINK_ATTR_SB_TC_INDEX, tc_index))
1226                 goto nla_put_failure;
1227         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_type))
1228                 goto nla_put_failure;
1229         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1230                 goto nla_put_failure;
1231         if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1232                 goto nla_put_failure;
1233
1234         if (ops->sb_occ_tc_port_bind_get) {
1235                 u32 cur;
1236                 u32 max;
1237
1238                 err = ops->sb_occ_tc_port_bind_get(devlink_port,
1239                                                    devlink_sb->index,
1240                                                    tc_index, pool_type,
1241                                                    &cur, &max);
1242                 if (err && err != -EOPNOTSUPP)
1243                         return err;
1244                 if (!err) {
1245                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1246                                 goto nla_put_failure;
1247                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1248                                 goto nla_put_failure;
1249                 }
1250         }
1251
1252         genlmsg_end(msg, hdr);
1253         return 0;
1254
1255 nla_put_failure:
1256         genlmsg_cancel(msg, hdr);
1257         return -EMSGSIZE;
1258 }
1259
1260 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
1261                                                    struct genl_info *info)
1262 {
1263         struct devlink_port *devlink_port = info->user_ptr[0];
1264         struct devlink *devlink = devlink_port->devlink;
1265         struct devlink_sb *devlink_sb = info->user_ptr[1];
1266         struct sk_buff *msg;
1267         enum devlink_sb_pool_type pool_type;
1268         u16 tc_index;
1269         int err;
1270
1271         err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1272         if (err)
1273                 return err;
1274
1275         err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1276                                                 pool_type, &tc_index);
1277         if (err)
1278                 return err;
1279
1280         if (!devlink->ops || !devlink->ops->sb_tc_pool_bind_get)
1281                 return -EOPNOTSUPP;
1282
1283         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1284         if (!msg)
1285                 return -ENOMEM;
1286
1287         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink, devlink_port,
1288                                               devlink_sb, tc_index, pool_type,
1289                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1290                                               info->snd_portid,
1291                                               info->snd_seq, 0);
1292         if (err) {
1293                 nlmsg_free(msg);
1294                 return err;
1295         }
1296
1297         return genlmsg_reply(msg, info);
1298 }
1299
1300 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1301                                         int start, int *p_idx,
1302                                         struct devlink *devlink,
1303                                         struct devlink_sb *devlink_sb,
1304                                         u32 portid, u32 seq)
1305 {
1306         struct devlink_port *devlink_port;
1307         u16 tc_index;
1308         int err;
1309
1310         list_for_each_entry(devlink_port, &devlink->port_list, list) {
1311                 for (tc_index = 0;
1312                      tc_index < devlink_sb->ingress_tc_count; tc_index++) {
1313                         if (*p_idx < start) {
1314                                 (*p_idx)++;
1315                                 continue;
1316                         }
1317                         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1318                                                               devlink_port,
1319                                                               devlink_sb,
1320                                                               tc_index,
1321                                                               DEVLINK_SB_POOL_TYPE_INGRESS,
1322                                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1323                                                               portid, seq,
1324                                                               NLM_F_MULTI);
1325                         if (err)
1326                                 return err;
1327                         (*p_idx)++;
1328                 }
1329                 for (tc_index = 0;
1330                      tc_index < devlink_sb->egress_tc_count; tc_index++) {
1331                         if (*p_idx < start) {
1332                                 (*p_idx)++;
1333                                 continue;
1334                         }
1335                         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1336                                                               devlink_port,
1337                                                               devlink_sb,
1338                                                               tc_index,
1339                                                               DEVLINK_SB_POOL_TYPE_EGRESS,
1340                                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1341                                                               portid, seq,
1342                                                               NLM_F_MULTI);
1343                         if (err)
1344                                 return err;
1345                         (*p_idx)++;
1346                 }
1347         }
1348         return 0;
1349 }
1350
1351 static int
1352 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1353                                           struct netlink_callback *cb)
1354 {
1355         struct devlink *devlink;
1356         struct devlink_sb *devlink_sb;
1357         int start = cb->args[0];
1358         int idx = 0;
1359         int err;
1360
1361         mutex_lock(&devlink_mutex);
1362         list_for_each_entry(devlink, &devlink_list, list) {
1363                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1364                     !devlink->ops || !devlink->ops->sb_tc_pool_bind_get)
1365                         continue;
1366
1367                 mutex_lock(&devlink->lock);
1368                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1369                         err = __sb_tc_pool_bind_get_dumpit(msg, start, &idx,
1370                                                            devlink,
1371                                                            devlink_sb,
1372                                                            NETLINK_CB(cb->skb).portid,
1373                                                            cb->nlh->nlmsg_seq);
1374                         if (err && err != -EOPNOTSUPP) {
1375                                 mutex_unlock(&devlink->lock);
1376                                 goto out;
1377                         }
1378                 }
1379                 mutex_unlock(&devlink->lock);
1380         }
1381 out:
1382         mutex_unlock(&devlink_mutex);
1383
1384         cb->args[0] = idx;
1385         return msg->len;
1386 }
1387
1388 static int devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
1389                                        unsigned int sb_index, u16 tc_index,
1390                                        enum devlink_sb_pool_type pool_type,
1391                                        u16 pool_index, u32 threshold)
1392
1393 {
1394         const struct devlink_ops *ops = devlink_port->devlink->ops;
1395
1396         if (ops && ops->sb_tc_pool_bind_set)
1397                 return ops->sb_tc_pool_bind_set(devlink_port, sb_index,
1398                                                 tc_index, pool_type,
1399                                                 pool_index, threshold);
1400         return -EOPNOTSUPP;
1401 }
1402
1403 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
1404                                                    struct genl_info *info)
1405 {
1406         struct devlink_port *devlink_port = info->user_ptr[0];
1407         struct devlink_sb *devlink_sb = info->user_ptr[1];
1408         enum devlink_sb_pool_type pool_type;
1409         u16 tc_index;
1410         u16 pool_index;
1411         u32 threshold;
1412         int err;
1413
1414         err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1415         if (err)
1416                 return err;
1417
1418         err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1419                                                 pool_type, &tc_index);
1420         if (err)
1421                 return err;
1422
1423         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1424                                                   &pool_index);
1425         if (err)
1426                 return err;
1427
1428         if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1429                 return -EINVAL;
1430
1431         threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1432         return devlink_sb_tc_pool_bind_set(devlink_port, devlink_sb->index,
1433                                            tc_index, pool_type,
1434                                            pool_index, threshold);
1435 }
1436
1437 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
1438                                                struct genl_info *info)
1439 {
1440         struct devlink *devlink = info->user_ptr[0];
1441         struct devlink_sb *devlink_sb = info->user_ptr[1];
1442         const struct devlink_ops *ops = devlink->ops;
1443
1444         if (ops && ops->sb_occ_snapshot)
1445                 return ops->sb_occ_snapshot(devlink, devlink_sb->index);
1446         return -EOPNOTSUPP;
1447 }
1448
1449 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
1450                                                 struct genl_info *info)
1451 {
1452         struct devlink *devlink = info->user_ptr[0];
1453         struct devlink_sb *devlink_sb = info->user_ptr[1];
1454         const struct devlink_ops *ops = devlink->ops;
1455
1456         if (ops && ops->sb_occ_max_clear)
1457                 return ops->sb_occ_max_clear(devlink, devlink_sb->index);
1458         return -EOPNOTSUPP;
1459 }
1460
1461 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
1462                                    enum devlink_command cmd, u32 portid,
1463                                    u32 seq, int flags)
1464 {
1465         const struct devlink_ops *ops = devlink->ops;
1466         u8 inline_mode, encap_mode;
1467         void *hdr;
1468         int err = 0;
1469         u16 mode;
1470
1471         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1472         if (!hdr)
1473                 return -EMSGSIZE;
1474
1475         err = devlink_nl_put_handle(msg, devlink);
1476         if (err)
1477                 goto nla_put_failure;
1478
1479         if (ops->eswitch_mode_get) {
1480                 err = ops->eswitch_mode_get(devlink, &mode);
1481                 if (err)
1482                         goto nla_put_failure;
1483                 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
1484                 if (err)
1485                         goto nla_put_failure;
1486         }
1487
1488         if (ops->eswitch_inline_mode_get) {
1489                 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
1490                 if (err)
1491                         goto nla_put_failure;
1492                 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
1493                                  inline_mode);
1494                 if (err)
1495                         goto nla_put_failure;
1496         }
1497
1498         if (ops->eswitch_encap_mode_get) {
1499                 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
1500                 if (err)
1501                         goto nla_put_failure;
1502                 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
1503                 if (err)
1504                         goto nla_put_failure;
1505         }
1506
1507         genlmsg_end(msg, hdr);
1508         return 0;
1509
1510 nla_put_failure:
1511         genlmsg_cancel(msg, hdr);
1512         return err;
1513 }
1514
1515 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb,
1516                                            struct genl_info *info)
1517 {
1518         struct devlink *devlink = info->user_ptr[0];
1519         const struct devlink_ops *ops = devlink->ops;
1520         struct sk_buff *msg;
1521         int err;
1522
1523         if (!ops)
1524                 return -EOPNOTSUPP;
1525
1526         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1527         if (!msg)
1528                 return -ENOMEM;
1529
1530         err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
1531                                       info->snd_portid, info->snd_seq, 0);
1532
1533         if (err) {
1534                 nlmsg_free(msg);
1535                 return err;
1536         }
1537
1538         return genlmsg_reply(msg, info);
1539 }
1540
1541 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
1542                                            struct genl_info *info)
1543 {
1544         struct devlink *devlink = info->user_ptr[0];
1545         const struct devlink_ops *ops = devlink->ops;
1546         u8 inline_mode, encap_mode;
1547         int err = 0;
1548         u16 mode;
1549
1550         if (!ops)
1551                 return -EOPNOTSUPP;
1552
1553         if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
1554                 if (!ops->eswitch_mode_set)
1555                         return -EOPNOTSUPP;
1556                 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
1557                 err = ops->eswitch_mode_set(devlink, mode);
1558                 if (err)
1559                         return err;
1560         }
1561
1562         if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
1563                 if (!ops->eswitch_inline_mode_set)
1564                         return -EOPNOTSUPP;
1565                 inline_mode = nla_get_u8(
1566                                 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
1567                 err = ops->eswitch_inline_mode_set(devlink, inline_mode);
1568                 if (err)
1569                         return err;
1570         }
1571
1572         if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
1573                 if (!ops->eswitch_encap_mode_set)
1574                         return -EOPNOTSUPP;
1575                 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
1576                 err = ops->eswitch_encap_mode_set(devlink, encap_mode);
1577                 if (err)
1578                         return err;
1579         }
1580
1581         return 0;
1582 }
1583
1584 int devlink_dpipe_match_put(struct sk_buff *skb,
1585                             struct devlink_dpipe_match *match)
1586 {
1587         struct devlink_dpipe_header *header = match->header;
1588         struct devlink_dpipe_field *field = &header->fields[match->field_id];
1589         struct nlattr *match_attr;
1590
1591         match_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_MATCH);
1592         if (!match_attr)
1593                 return -EMSGSIZE;
1594
1595         if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
1596             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
1597             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1598             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1599             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1600                 goto nla_put_failure;
1601
1602         nla_nest_end(skb, match_attr);
1603         return 0;
1604
1605 nla_put_failure:
1606         nla_nest_cancel(skb, match_attr);
1607         return -EMSGSIZE;
1608 }
1609 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
1610
1611 static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
1612                                      struct sk_buff *skb)
1613 {
1614         struct nlattr *matches_attr;
1615
1616         matches_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
1617         if (!matches_attr)
1618                 return -EMSGSIZE;
1619
1620         if (table->table_ops->matches_dump(table->priv, skb))
1621                 goto nla_put_failure;
1622
1623         nla_nest_end(skb, matches_attr);
1624         return 0;
1625
1626 nla_put_failure:
1627         nla_nest_cancel(skb, matches_attr);
1628         return -EMSGSIZE;
1629 }
1630
1631 int devlink_dpipe_action_put(struct sk_buff *skb,
1632                              struct devlink_dpipe_action *action)
1633 {
1634         struct devlink_dpipe_header *header = action->header;
1635         struct devlink_dpipe_field *field = &header->fields[action->field_id];
1636         struct nlattr *action_attr;
1637
1638         action_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_ACTION);
1639         if (!action_attr)
1640                 return -EMSGSIZE;
1641
1642         if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
1643             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
1644             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1645             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1646             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1647                 goto nla_put_failure;
1648
1649         nla_nest_end(skb, action_attr);
1650         return 0;
1651
1652 nla_put_failure:
1653         nla_nest_cancel(skb, action_attr);
1654         return -EMSGSIZE;
1655 }
1656 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
1657
1658 static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
1659                                      struct sk_buff *skb)
1660 {
1661         struct nlattr *actions_attr;
1662
1663         actions_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
1664         if (!actions_attr)
1665                 return -EMSGSIZE;
1666
1667         if (table->table_ops->actions_dump(table->priv, skb))
1668                 goto nla_put_failure;
1669
1670         nla_nest_end(skb, actions_attr);
1671         return 0;
1672
1673 nla_put_failure:
1674         nla_nest_cancel(skb, actions_attr);
1675         return -EMSGSIZE;
1676 }
1677
1678 static int devlink_dpipe_table_put(struct sk_buff *skb,
1679                                    struct devlink_dpipe_table *table)
1680 {
1681         struct nlattr *table_attr;
1682         u64 table_size;
1683
1684         table_size = table->table_ops->size_get(table->priv);
1685         table_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE);
1686         if (!table_attr)
1687                 return -EMSGSIZE;
1688
1689         if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
1690             nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
1691                               DEVLINK_ATTR_PAD))
1692                 goto nla_put_failure;
1693         if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
1694                        table->counters_enabled))
1695                 goto nla_put_failure;
1696
1697         if (table->resource_valid) {
1698                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
1699                                       table->resource_id, DEVLINK_ATTR_PAD) ||
1700                     nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
1701                                       table->resource_units, DEVLINK_ATTR_PAD))
1702                         goto nla_put_failure;
1703         }
1704         if (devlink_dpipe_matches_put(table, skb))
1705                 goto nla_put_failure;
1706
1707         if (devlink_dpipe_actions_put(table, skb))
1708                 goto nla_put_failure;
1709
1710         nla_nest_end(skb, table_attr);
1711         return 0;
1712
1713 nla_put_failure:
1714         nla_nest_cancel(skb, table_attr);
1715         return -EMSGSIZE;
1716 }
1717
1718 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
1719                                             struct genl_info *info)
1720 {
1721         int err;
1722
1723         if (*pskb) {
1724                 err = genlmsg_reply(*pskb, info);
1725                 if (err)
1726                         return err;
1727         }
1728         *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
1729         if (!*pskb)
1730                 return -ENOMEM;
1731         return 0;
1732 }
1733
1734 static int devlink_dpipe_tables_fill(struct genl_info *info,
1735                                      enum devlink_command cmd, int flags,
1736                                      struct list_head *dpipe_tables,
1737                                      const char *table_name)
1738 {
1739         struct devlink *devlink = info->user_ptr[0];
1740         struct devlink_dpipe_table *table;
1741         struct nlattr *tables_attr;
1742         struct sk_buff *skb = NULL;
1743         struct nlmsghdr *nlh;
1744         bool incomplete;
1745         void *hdr;
1746         int i;
1747         int err;
1748
1749         table = list_first_entry(dpipe_tables,
1750                                  struct devlink_dpipe_table, list);
1751 start_again:
1752         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1753         if (err)
1754                 return err;
1755
1756         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
1757                           &devlink_nl_family, NLM_F_MULTI, cmd);
1758         if (!hdr) {
1759                 nlmsg_free(skb);
1760                 return -EMSGSIZE;
1761         }
1762
1763         if (devlink_nl_put_handle(skb, devlink))
1764                 goto nla_put_failure;
1765         tables_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLES);
1766         if (!tables_attr)
1767                 goto nla_put_failure;
1768
1769         i = 0;
1770         incomplete = false;
1771         list_for_each_entry_from(table, dpipe_tables, list) {
1772                 if (!table_name) {
1773                         err = devlink_dpipe_table_put(skb, table);
1774                         if (err) {
1775                                 if (!i)
1776                                         goto err_table_put;
1777                                 incomplete = true;
1778                                 break;
1779                         }
1780                 } else {
1781                         if (!strcmp(table->name, table_name)) {
1782                                 err = devlink_dpipe_table_put(skb, table);
1783                                 if (err)
1784                                         break;
1785                         }
1786                 }
1787                 i++;
1788         }
1789
1790         nla_nest_end(skb, tables_attr);
1791         genlmsg_end(skb, hdr);
1792         if (incomplete)
1793                 goto start_again;
1794
1795 send_done:
1796         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
1797                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
1798         if (!nlh) {
1799                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1800                 if (err)
1801                         return err;
1802                 goto send_done;
1803         }
1804
1805         return genlmsg_reply(skb, info);
1806
1807 nla_put_failure:
1808         err = -EMSGSIZE;
1809 err_table_put:
1810         genlmsg_cancel(skb, hdr);
1811         nlmsg_free(skb);
1812         return err;
1813 }
1814
1815 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
1816                                           struct genl_info *info)
1817 {
1818         struct devlink *devlink = info->user_ptr[0];
1819         const char *table_name =  NULL;
1820
1821         if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
1822                 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
1823
1824         return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
1825                                          &devlink->dpipe_table_list,
1826                                          table_name);
1827 }
1828
1829 static int devlink_dpipe_value_put(struct sk_buff *skb,
1830                                    struct devlink_dpipe_value *value)
1831 {
1832         if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
1833                     value->value_size, value->value))
1834                 return -EMSGSIZE;
1835         if (value->mask)
1836                 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
1837                             value->value_size, value->mask))
1838                         return -EMSGSIZE;
1839         if (value->mapping_valid)
1840                 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
1841                                 value->mapping_value))
1842                         return -EMSGSIZE;
1843         return 0;
1844 }
1845
1846 static int devlink_dpipe_action_value_put(struct sk_buff *skb,
1847                                           struct devlink_dpipe_value *value)
1848 {
1849         if (!value->action)
1850                 return -EINVAL;
1851         if (devlink_dpipe_action_put(skb, value->action))
1852                 return -EMSGSIZE;
1853         if (devlink_dpipe_value_put(skb, value))
1854                 return -EMSGSIZE;
1855         return 0;
1856 }
1857
1858 static int devlink_dpipe_action_values_put(struct sk_buff *skb,
1859                                            struct devlink_dpipe_value *values,
1860                                            unsigned int values_count)
1861 {
1862         struct nlattr *action_attr;
1863         int i;
1864         int err;
1865
1866         for (i = 0; i < values_count; i++) {
1867                 action_attr = nla_nest_start(skb,
1868                                              DEVLINK_ATTR_DPIPE_ACTION_VALUE);
1869                 if (!action_attr)
1870                         return -EMSGSIZE;
1871                 err = devlink_dpipe_action_value_put(skb, &values[i]);
1872                 if (err)
1873                         goto err_action_value_put;
1874                 nla_nest_end(skb, action_attr);
1875         }
1876         return 0;
1877
1878 err_action_value_put:
1879         nla_nest_cancel(skb, action_attr);
1880         return err;
1881 }
1882
1883 static int devlink_dpipe_match_value_put(struct sk_buff *skb,
1884                                          struct devlink_dpipe_value *value)
1885 {
1886         if (!value->match)
1887                 return -EINVAL;
1888         if (devlink_dpipe_match_put(skb, value->match))
1889                 return -EMSGSIZE;
1890         if (devlink_dpipe_value_put(skb, value))
1891                 return -EMSGSIZE;
1892         return 0;
1893 }
1894
1895 static int devlink_dpipe_match_values_put(struct sk_buff *skb,
1896                                           struct devlink_dpipe_value *values,
1897                                           unsigned int values_count)
1898 {
1899         struct nlattr *match_attr;
1900         int i;
1901         int err;
1902
1903         for (i = 0; i < values_count; i++) {
1904                 match_attr = nla_nest_start(skb,
1905                                             DEVLINK_ATTR_DPIPE_MATCH_VALUE);
1906                 if (!match_attr)
1907                         return -EMSGSIZE;
1908                 err = devlink_dpipe_match_value_put(skb, &values[i]);
1909                 if (err)
1910                         goto err_match_value_put;
1911                 nla_nest_end(skb, match_attr);
1912         }
1913         return 0;
1914
1915 err_match_value_put:
1916         nla_nest_cancel(skb, match_attr);
1917         return err;
1918 }
1919
1920 static int devlink_dpipe_entry_put(struct sk_buff *skb,
1921                                    struct devlink_dpipe_entry *entry)
1922 {
1923         struct nlattr *entry_attr, *matches_attr, *actions_attr;
1924         int err;
1925
1926         entry_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_ENTRY);
1927         if (!entry_attr)
1928                 return  -EMSGSIZE;
1929
1930         if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
1931                               DEVLINK_ATTR_PAD))
1932                 goto nla_put_failure;
1933         if (entry->counter_valid)
1934                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
1935                                       entry->counter, DEVLINK_ATTR_PAD))
1936                         goto nla_put_failure;
1937
1938         matches_attr = nla_nest_start(skb,
1939                                       DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
1940         if (!matches_attr)
1941                 goto nla_put_failure;
1942
1943         err = devlink_dpipe_match_values_put(skb, entry->match_values,
1944                                              entry->match_values_count);
1945         if (err) {
1946                 nla_nest_cancel(skb, matches_attr);
1947                 goto err_match_values_put;
1948         }
1949         nla_nest_end(skb, matches_attr);
1950
1951         actions_attr = nla_nest_start(skb,
1952                                       DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
1953         if (!actions_attr)
1954                 goto nla_put_failure;
1955
1956         err = devlink_dpipe_action_values_put(skb, entry->action_values,
1957                                               entry->action_values_count);
1958         if (err) {
1959                 nla_nest_cancel(skb, actions_attr);
1960                 goto err_action_values_put;
1961         }
1962         nla_nest_end(skb, actions_attr);
1963
1964         nla_nest_end(skb, entry_attr);
1965         return 0;
1966
1967 nla_put_failure:
1968         err = -EMSGSIZE;
1969 err_match_values_put:
1970 err_action_values_put:
1971         nla_nest_cancel(skb, entry_attr);
1972         return err;
1973 }
1974
1975 static struct devlink_dpipe_table *
1976 devlink_dpipe_table_find(struct list_head *dpipe_tables,
1977                          const char *table_name)
1978 {
1979         struct devlink_dpipe_table *table;
1980
1981         list_for_each_entry_rcu(table, dpipe_tables, list) {
1982                 if (!strcmp(table->name, table_name))
1983                         return table;
1984         }
1985         return NULL;
1986 }
1987
1988 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
1989 {
1990         struct devlink *devlink;
1991         int err;
1992
1993         err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
1994                                                dump_ctx->info);
1995         if (err)
1996                 return err;
1997
1998         dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
1999                                     dump_ctx->info->snd_portid,
2000                                     dump_ctx->info->snd_seq,
2001                                     &devlink_nl_family, NLM_F_MULTI,
2002                                     dump_ctx->cmd);
2003         if (!dump_ctx->hdr)
2004                 goto nla_put_failure;
2005
2006         devlink = dump_ctx->info->user_ptr[0];
2007         if (devlink_nl_put_handle(dump_ctx->skb, devlink))
2008                 goto nla_put_failure;
2009         dump_ctx->nest = nla_nest_start(dump_ctx->skb,
2010                                         DEVLINK_ATTR_DPIPE_ENTRIES);
2011         if (!dump_ctx->nest)
2012                 goto nla_put_failure;
2013         return 0;
2014
2015 nla_put_failure:
2016         genlmsg_cancel(dump_ctx->skb, dump_ctx->hdr);
2017         nlmsg_free(dump_ctx->skb);
2018         return -EMSGSIZE;
2019 }
2020 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
2021
2022 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
2023                                    struct devlink_dpipe_entry *entry)
2024 {
2025         return devlink_dpipe_entry_put(dump_ctx->skb, entry);
2026 }
2027 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
2028
2029 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
2030 {
2031         nla_nest_end(dump_ctx->skb, dump_ctx->nest);
2032         genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
2033         return 0;
2034 }
2035 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
2036
2037 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
2038
2039 {
2040         unsigned int value_count, value_index;
2041         struct devlink_dpipe_value *value;
2042
2043         value = entry->action_values;
2044         value_count = entry->action_values_count;
2045         for (value_index = 0; value_index < value_count; value_index++) {
2046                 kfree(value[value_index].value);
2047                 kfree(value[value_index].mask);
2048         }
2049
2050         value = entry->match_values;
2051         value_count = entry->match_values_count;
2052         for (value_index = 0; value_index < value_count; value_index++) {
2053                 kfree(value[value_index].value);
2054                 kfree(value[value_index].mask);
2055         }
2056 }
2057 EXPORT_SYMBOL(devlink_dpipe_entry_clear);
2058
2059 static int devlink_dpipe_entries_fill(struct genl_info *info,
2060                                       enum devlink_command cmd, int flags,
2061                                       struct devlink_dpipe_table *table)
2062 {
2063         struct devlink_dpipe_dump_ctx dump_ctx;
2064         struct nlmsghdr *nlh;
2065         int err;
2066
2067         dump_ctx.skb = NULL;
2068         dump_ctx.cmd = cmd;
2069         dump_ctx.info = info;
2070
2071         err = table->table_ops->entries_dump(table->priv,
2072                                              table->counters_enabled,
2073                                              &dump_ctx);
2074         if (err)
2075                 return err;
2076
2077 send_done:
2078         nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
2079                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
2080         if (!nlh) {
2081                 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
2082                 if (err)
2083                         return err;
2084                 goto send_done;
2085         }
2086         return genlmsg_reply(dump_ctx.skb, info);
2087 }
2088
2089 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
2090                                             struct genl_info *info)
2091 {
2092         struct devlink *devlink = info->user_ptr[0];
2093         struct devlink_dpipe_table *table;
2094         const char *table_name;
2095
2096         if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
2097                 return -EINVAL;
2098
2099         table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2100         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2101                                          table_name);
2102         if (!table)
2103                 return -EINVAL;
2104
2105         if (!table->table_ops->entries_dump)
2106                 return -EINVAL;
2107
2108         return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
2109                                           0, table);
2110 }
2111
2112 static int devlink_dpipe_fields_put(struct sk_buff *skb,
2113                                     const struct devlink_dpipe_header *header)
2114 {
2115         struct devlink_dpipe_field *field;
2116         struct nlattr *field_attr;
2117         int i;
2118
2119         for (i = 0; i < header->fields_count; i++) {
2120                 field = &header->fields[i];
2121                 field_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_FIELD);
2122                 if (!field_attr)
2123                         return -EMSGSIZE;
2124                 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
2125                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2126                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
2127                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
2128                         goto nla_put_failure;
2129                 nla_nest_end(skb, field_attr);
2130         }
2131         return 0;
2132
2133 nla_put_failure:
2134         nla_nest_cancel(skb, field_attr);
2135         return -EMSGSIZE;
2136 }
2137
2138 static int devlink_dpipe_header_put(struct sk_buff *skb,
2139                                     struct devlink_dpipe_header *header)
2140 {
2141         struct nlattr *fields_attr, *header_attr;
2142         int err;
2143
2144         header_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADER);
2145         if (!header_attr)
2146                 return -EMSGSIZE;
2147
2148         if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
2149             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2150             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2151                 goto nla_put_failure;
2152
2153         fields_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
2154         if (!fields_attr)
2155                 goto nla_put_failure;
2156
2157         err = devlink_dpipe_fields_put(skb, header);
2158         if (err) {
2159                 nla_nest_cancel(skb, fields_attr);
2160                 goto nla_put_failure;
2161         }
2162         nla_nest_end(skb, fields_attr);
2163         nla_nest_end(skb, header_attr);
2164         return 0;
2165
2166 nla_put_failure:
2167         err = -EMSGSIZE;
2168         nla_nest_cancel(skb, header_attr);
2169         return err;
2170 }
2171
2172 static int devlink_dpipe_headers_fill(struct genl_info *info,
2173                                       enum devlink_command cmd, int flags,
2174                                       struct devlink_dpipe_headers *
2175                                       dpipe_headers)
2176 {
2177         struct devlink *devlink = info->user_ptr[0];
2178         struct nlattr *headers_attr;
2179         struct sk_buff *skb = NULL;
2180         struct nlmsghdr *nlh;
2181         void *hdr;
2182         int i, j;
2183         int err;
2184
2185         i = 0;
2186 start_again:
2187         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2188         if (err)
2189                 return err;
2190
2191         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2192                           &devlink_nl_family, NLM_F_MULTI, cmd);
2193         if (!hdr) {
2194                 nlmsg_free(skb);
2195                 return -EMSGSIZE;
2196         }
2197
2198         if (devlink_nl_put_handle(skb, devlink))
2199                 goto nla_put_failure;
2200         headers_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADERS);
2201         if (!headers_attr)
2202                 goto nla_put_failure;
2203
2204         j = 0;
2205         for (; i < dpipe_headers->headers_count; i++) {
2206                 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
2207                 if (err) {
2208                         if (!j)
2209                                 goto err_table_put;
2210                         break;
2211                 }
2212                 j++;
2213         }
2214         nla_nest_end(skb, headers_attr);
2215         genlmsg_end(skb, hdr);
2216         if (i != dpipe_headers->headers_count)
2217                 goto start_again;
2218
2219 send_done:
2220         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2221                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
2222         if (!nlh) {
2223                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2224                 if (err)
2225                         return err;
2226                 goto send_done;
2227         }
2228         return genlmsg_reply(skb, info);
2229
2230 nla_put_failure:
2231         err = -EMSGSIZE;
2232 err_table_put:
2233         genlmsg_cancel(skb, hdr);
2234         nlmsg_free(skb);
2235         return err;
2236 }
2237
2238 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
2239                                             struct genl_info *info)
2240 {
2241         struct devlink *devlink = info->user_ptr[0];
2242
2243         if (!devlink->dpipe_headers)
2244                 return -EOPNOTSUPP;
2245         return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
2246                                           0, devlink->dpipe_headers);
2247 }
2248
2249 static int devlink_dpipe_table_counters_set(struct devlink *devlink,
2250                                             const char *table_name,
2251                                             bool enable)
2252 {
2253         struct devlink_dpipe_table *table;
2254
2255         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2256                                          table_name);
2257         if (!table)
2258                 return -EINVAL;
2259
2260         if (table->counter_control_extern)
2261                 return -EOPNOTSUPP;
2262
2263         if (!(table->counters_enabled ^ enable))
2264                 return 0;
2265
2266         table->counters_enabled = enable;
2267         if (table->table_ops->counters_set_update)
2268                 table->table_ops->counters_set_update(table->priv, enable);
2269         return 0;
2270 }
2271
2272 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
2273                                                    struct genl_info *info)
2274 {
2275         struct devlink *devlink = info->user_ptr[0];
2276         const char *table_name;
2277         bool counters_enable;
2278
2279         if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
2280             !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
2281                 return -EINVAL;
2282
2283         table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2284         counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
2285
2286         return devlink_dpipe_table_counters_set(devlink, table_name,
2287                                                 counters_enable);
2288 }
2289
2290 static struct devlink_resource *
2291 devlink_resource_find(struct devlink *devlink,
2292                       struct devlink_resource *resource, u64 resource_id)
2293 {
2294         struct list_head *resource_list;
2295
2296         if (resource)
2297                 resource_list = &resource->resource_list;
2298         else
2299                 resource_list = &devlink->resource_list;
2300
2301         list_for_each_entry(resource, resource_list, list) {
2302                 struct devlink_resource *child_resource;
2303
2304                 if (resource->id == resource_id)
2305                         return resource;
2306
2307                 child_resource = devlink_resource_find(devlink, resource,
2308                                                        resource_id);
2309                 if (child_resource)
2310                         return child_resource;
2311         }
2312         return NULL;
2313 }
2314
2315 static void
2316 devlink_resource_validate_children(struct devlink_resource *resource)
2317 {
2318         struct devlink_resource *child_resource;
2319         bool size_valid = true;
2320         u64 parts_size = 0;
2321
2322         if (list_empty(&resource->resource_list))
2323                 goto out;
2324
2325         list_for_each_entry(child_resource, &resource->resource_list, list)
2326                 parts_size += child_resource->size_new;
2327
2328         if (parts_size > resource->size_new)
2329                 size_valid = false;
2330 out:
2331         resource->size_valid = size_valid;
2332 }
2333
2334 static int
2335 devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
2336                                struct netlink_ext_ack *extack)
2337 {
2338         u64 reminder;
2339         int err = 0;
2340
2341         if (size > resource->size_params.size_max) {
2342                 NL_SET_ERR_MSG_MOD(extack, "Size larger than maximum");
2343                 err = -EINVAL;
2344         }
2345
2346         if (size < resource->size_params.size_min) {
2347                 NL_SET_ERR_MSG_MOD(extack, "Size smaller than minimum");
2348                 err = -EINVAL;
2349         }
2350
2351         div64_u64_rem(size, resource->size_params.size_granularity, &reminder);
2352         if (reminder) {
2353                 NL_SET_ERR_MSG_MOD(extack, "Wrong granularity");
2354                 err = -EINVAL;
2355         }
2356
2357         return err;
2358 }
2359
2360 static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
2361                                        struct genl_info *info)
2362 {
2363         struct devlink *devlink = info->user_ptr[0];
2364         struct devlink_resource *resource;
2365         u64 resource_id;
2366         u64 size;
2367         int err;
2368
2369         if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
2370             !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
2371                 return -EINVAL;
2372         resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
2373
2374         resource = devlink_resource_find(devlink, NULL, resource_id);
2375         if (!resource)
2376                 return -EINVAL;
2377
2378         size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
2379         err = devlink_resource_validate_size(resource, size, info->extack);
2380         if (err)
2381                 return err;
2382
2383         resource->size_new = size;
2384         devlink_resource_validate_children(resource);
2385         if (resource->parent)
2386                 devlink_resource_validate_children(resource->parent);
2387         return 0;
2388 }
2389
2390 static int
2391 devlink_resource_size_params_put(struct devlink_resource *resource,
2392                                  struct sk_buff *skb)
2393 {
2394         struct devlink_resource_size_params *size_params;
2395
2396         size_params = &resource->size_params;
2397         if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
2398                               size_params->size_granularity, DEVLINK_ATTR_PAD) ||
2399             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
2400                               size_params->size_max, DEVLINK_ATTR_PAD) ||
2401             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
2402                               size_params->size_min, DEVLINK_ATTR_PAD) ||
2403             nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
2404                 return -EMSGSIZE;
2405         return 0;
2406 }
2407
2408 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
2409                                 struct devlink_resource *resource)
2410 {
2411         struct devlink_resource *child_resource;
2412         struct nlattr *child_resource_attr;
2413         struct nlattr *resource_attr;
2414
2415         resource_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE);
2416         if (!resource_attr)
2417                 return -EMSGSIZE;
2418
2419         if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
2420             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
2421                               DEVLINK_ATTR_PAD) ||
2422             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
2423                               DEVLINK_ATTR_PAD))
2424                 goto nla_put_failure;
2425         if (resource->size != resource->size_new)
2426                 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
2427                                   resource->size_new, DEVLINK_ATTR_PAD);
2428         if (resource->resource_ops && resource->resource_ops->occ_get)
2429                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
2430                                       resource->resource_ops->occ_get(devlink),
2431                                       DEVLINK_ATTR_PAD))
2432                         goto nla_put_failure;
2433         if (devlink_resource_size_params_put(resource, skb))
2434                 goto nla_put_failure;
2435         if (list_empty(&resource->resource_list))
2436                 goto out;
2437
2438         if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
2439                        resource->size_valid))
2440                 goto nla_put_failure;
2441
2442         child_resource_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE_LIST);
2443         if (!child_resource_attr)
2444                 goto nla_put_failure;
2445
2446         list_for_each_entry(child_resource, &resource->resource_list, list) {
2447                 if (devlink_resource_put(devlink, skb, child_resource))
2448                         goto resource_put_failure;
2449         }
2450
2451         nla_nest_end(skb, child_resource_attr);
2452 out:
2453         nla_nest_end(skb, resource_attr);
2454         return 0;
2455
2456 resource_put_failure:
2457         nla_nest_cancel(skb, child_resource_attr);
2458 nla_put_failure:
2459         nla_nest_cancel(skb, resource_attr);
2460         return -EMSGSIZE;
2461 }
2462
2463 static int devlink_resource_fill(struct genl_info *info,
2464                                  enum devlink_command cmd, int flags)
2465 {
2466         struct devlink *devlink = info->user_ptr[0];
2467         struct devlink_resource *resource;
2468         struct nlattr *resources_attr;
2469         struct sk_buff *skb = NULL;
2470         struct nlmsghdr *nlh;
2471         bool incomplete;
2472         void *hdr;
2473         int i;
2474         int err;
2475
2476         resource = list_first_entry(&devlink->resource_list,
2477                                     struct devlink_resource, list);
2478 start_again:
2479         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2480         if (err)
2481                 return err;
2482
2483         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2484                           &devlink_nl_family, NLM_F_MULTI, cmd);
2485         if (!hdr) {
2486                 nlmsg_free(skb);
2487                 return -EMSGSIZE;
2488         }
2489
2490         if (devlink_nl_put_handle(skb, devlink))
2491                 goto nla_put_failure;
2492
2493         resources_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE_LIST);
2494         if (!resources_attr)
2495                 goto nla_put_failure;
2496
2497         incomplete = false;
2498         i = 0;
2499         list_for_each_entry_from(resource, &devlink->resource_list, list) {
2500                 err = devlink_resource_put(devlink, skb, resource);
2501                 if (err) {
2502                         if (!i)
2503                                 goto err_resource_put;
2504                         incomplete = true;
2505                         break;
2506                 }
2507                 i++;
2508         }
2509         nla_nest_end(skb, resources_attr);
2510         genlmsg_end(skb, hdr);
2511         if (incomplete)
2512                 goto start_again;
2513 send_done:
2514         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2515                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
2516         if (!nlh) {
2517                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2518                 if (err)
2519                         goto err_skb_send_alloc;
2520                 goto send_done;
2521         }
2522         return genlmsg_reply(skb, info);
2523
2524 nla_put_failure:
2525         err = -EMSGSIZE;
2526 err_resource_put:
2527 err_skb_send_alloc:
2528         genlmsg_cancel(skb, hdr);
2529         nlmsg_free(skb);
2530         return err;
2531 }
2532
2533 static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
2534                                         struct genl_info *info)
2535 {
2536         struct devlink *devlink = info->user_ptr[0];
2537
2538         if (list_empty(&devlink->resource_list))
2539                 return -EOPNOTSUPP;
2540
2541         return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
2542 }
2543
2544 static int
2545 devlink_resources_validate(struct devlink *devlink,
2546                            struct devlink_resource *resource,
2547                            struct genl_info *info)
2548 {
2549         struct list_head *resource_list;
2550         int err = 0;
2551
2552         if (resource)
2553                 resource_list = &resource->resource_list;
2554         else
2555                 resource_list = &devlink->resource_list;
2556
2557         list_for_each_entry(resource, resource_list, list) {
2558                 if (!resource->size_valid)
2559                         return -EINVAL;
2560                 err = devlink_resources_validate(devlink, resource, info);
2561                 if (err)
2562                         return err;
2563         }
2564         return err;
2565 }
2566
2567 static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
2568 {
2569         struct devlink *devlink = info->user_ptr[0];
2570         int err;
2571
2572         if (!devlink->ops->reload)
2573                 return -EOPNOTSUPP;
2574
2575         err = devlink_resources_validate(devlink, NULL, info);
2576         if (err) {
2577                 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
2578                 return err;
2579         }
2580         return devlink->ops->reload(devlink);
2581 }
2582
2583 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
2584         [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
2585         [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
2586         [DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
2587         [DEVLINK_ATTR_PORT_TYPE] = { .type = NLA_U16 },
2588         [DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
2589         [DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
2590         [DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
2591         [DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
2592         [DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
2593         [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
2594         [DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
2595         [DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
2596         [DEVLINK_ATTR_ESWITCH_MODE] = { .type = NLA_U16 },
2597         [DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
2598         [DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
2599         [DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
2600         [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
2601         [DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
2602         [DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
2603 };
2604
2605 static const struct genl_ops devlink_nl_ops[] = {
2606         {
2607                 .cmd = DEVLINK_CMD_GET,
2608                 .doit = devlink_nl_cmd_get_doit,
2609                 .dumpit = devlink_nl_cmd_get_dumpit,
2610                 .policy = devlink_nl_policy,
2611                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2612                 /* can be retrieved by unprivileged users */
2613         },
2614         {
2615                 .cmd = DEVLINK_CMD_PORT_GET,
2616                 .doit = devlink_nl_cmd_port_get_doit,
2617                 .dumpit = devlink_nl_cmd_port_get_dumpit,
2618                 .policy = devlink_nl_policy,
2619                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
2620                 /* can be retrieved by unprivileged users */
2621         },
2622         {
2623                 .cmd = DEVLINK_CMD_PORT_SET,
2624                 .doit = devlink_nl_cmd_port_set_doit,
2625                 .policy = devlink_nl_policy,
2626                 .flags = GENL_ADMIN_PERM,
2627                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
2628         },
2629         {
2630                 .cmd = DEVLINK_CMD_PORT_SPLIT,
2631                 .doit = devlink_nl_cmd_port_split_doit,
2632                 .policy = devlink_nl_policy,
2633                 .flags = GENL_ADMIN_PERM,
2634                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2635                                   DEVLINK_NL_FLAG_NO_LOCK,
2636         },
2637         {
2638                 .cmd = DEVLINK_CMD_PORT_UNSPLIT,
2639                 .doit = devlink_nl_cmd_port_unsplit_doit,
2640                 .policy = devlink_nl_policy,
2641                 .flags = GENL_ADMIN_PERM,
2642                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2643                                   DEVLINK_NL_FLAG_NO_LOCK,
2644         },
2645         {
2646                 .cmd = DEVLINK_CMD_SB_GET,
2647                 .doit = devlink_nl_cmd_sb_get_doit,
2648                 .dumpit = devlink_nl_cmd_sb_get_dumpit,
2649                 .policy = devlink_nl_policy,
2650                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2651                                   DEVLINK_NL_FLAG_NEED_SB,
2652                 /* can be retrieved by unprivileged users */
2653         },
2654         {
2655                 .cmd = DEVLINK_CMD_SB_POOL_GET,
2656                 .doit = devlink_nl_cmd_sb_pool_get_doit,
2657                 .dumpit = devlink_nl_cmd_sb_pool_get_dumpit,
2658                 .policy = devlink_nl_policy,
2659                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2660                                   DEVLINK_NL_FLAG_NEED_SB,
2661                 /* can be retrieved by unprivileged users */
2662         },
2663         {
2664                 .cmd = DEVLINK_CMD_SB_POOL_SET,
2665                 .doit = devlink_nl_cmd_sb_pool_set_doit,
2666                 .policy = devlink_nl_policy,
2667                 .flags = GENL_ADMIN_PERM,
2668                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2669                                   DEVLINK_NL_FLAG_NEED_SB,
2670         },
2671         {
2672                 .cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
2673                 .doit = devlink_nl_cmd_sb_port_pool_get_doit,
2674                 .dumpit = devlink_nl_cmd_sb_port_pool_get_dumpit,
2675                 .policy = devlink_nl_policy,
2676                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2677                                   DEVLINK_NL_FLAG_NEED_SB,
2678                 /* can be retrieved by unprivileged users */
2679         },
2680         {
2681                 .cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
2682                 .doit = devlink_nl_cmd_sb_port_pool_set_doit,
2683                 .policy = devlink_nl_policy,
2684                 .flags = GENL_ADMIN_PERM,
2685                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2686                                   DEVLINK_NL_FLAG_NEED_SB,
2687         },
2688         {
2689                 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
2690                 .doit = devlink_nl_cmd_sb_tc_pool_bind_get_doit,
2691                 .dumpit = devlink_nl_cmd_sb_tc_pool_bind_get_dumpit,
2692                 .policy = devlink_nl_policy,
2693                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2694                                   DEVLINK_NL_FLAG_NEED_SB,
2695                 /* can be retrieved by unprivileged users */
2696         },
2697         {
2698                 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
2699                 .doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
2700                 .policy = devlink_nl_policy,
2701                 .flags = GENL_ADMIN_PERM,
2702                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2703                                   DEVLINK_NL_FLAG_NEED_SB,
2704         },
2705         {
2706                 .cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
2707                 .doit = devlink_nl_cmd_sb_occ_snapshot_doit,
2708                 .policy = devlink_nl_policy,
2709                 .flags = GENL_ADMIN_PERM,
2710                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2711                                   DEVLINK_NL_FLAG_NEED_SB,
2712         },
2713         {
2714                 .cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
2715                 .doit = devlink_nl_cmd_sb_occ_max_clear_doit,
2716                 .policy = devlink_nl_policy,
2717                 .flags = GENL_ADMIN_PERM,
2718                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2719                                   DEVLINK_NL_FLAG_NEED_SB,
2720         },
2721         {
2722                 .cmd = DEVLINK_CMD_ESWITCH_GET,
2723                 .doit = devlink_nl_cmd_eswitch_get_doit,
2724                 .policy = devlink_nl_policy,
2725                 .flags = GENL_ADMIN_PERM,
2726                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2727         },
2728         {
2729                 .cmd = DEVLINK_CMD_ESWITCH_SET,
2730                 .doit = devlink_nl_cmd_eswitch_set_doit,
2731                 .policy = devlink_nl_policy,
2732                 .flags = GENL_ADMIN_PERM,
2733                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2734         },
2735         {
2736                 .cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
2737                 .doit = devlink_nl_cmd_dpipe_table_get,
2738                 .policy = devlink_nl_policy,
2739                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2740                 /* can be retrieved by unprivileged users */
2741         },
2742         {
2743                 .cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
2744                 .doit = devlink_nl_cmd_dpipe_entries_get,
2745                 .policy = devlink_nl_policy,
2746                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2747                 /* can be retrieved by unprivileged users */
2748         },
2749         {
2750                 .cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
2751                 .doit = devlink_nl_cmd_dpipe_headers_get,
2752                 .policy = devlink_nl_policy,
2753                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2754                 /* can be retrieved by unprivileged users */
2755         },
2756         {
2757                 .cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
2758                 .doit = devlink_nl_cmd_dpipe_table_counters_set,
2759                 .policy = devlink_nl_policy,
2760                 .flags = GENL_ADMIN_PERM,
2761                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2762         },
2763         {
2764                 .cmd = DEVLINK_CMD_RESOURCE_SET,
2765                 .doit = devlink_nl_cmd_resource_set,
2766                 .policy = devlink_nl_policy,
2767                 .flags = GENL_ADMIN_PERM,
2768                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2769         },
2770         {
2771                 .cmd = DEVLINK_CMD_RESOURCE_DUMP,
2772                 .doit = devlink_nl_cmd_resource_dump,
2773                 .policy = devlink_nl_policy,
2774                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2775                 /* can be retrieved by unprivileged users */
2776         },
2777         {
2778                 .cmd = DEVLINK_CMD_RELOAD,
2779                 .doit = devlink_nl_cmd_reload,
2780                 .policy = devlink_nl_policy,
2781                 .flags = GENL_ADMIN_PERM,
2782                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2783                                   DEVLINK_NL_FLAG_NO_LOCK,
2784         },
2785 };
2786
2787 static struct genl_family devlink_nl_family __ro_after_init = {
2788         .name           = DEVLINK_GENL_NAME,
2789         .version        = DEVLINK_GENL_VERSION,
2790         .maxattr        = DEVLINK_ATTR_MAX,
2791         .netnsok        = true,
2792         .pre_doit       = devlink_nl_pre_doit,
2793         .post_doit      = devlink_nl_post_doit,
2794         .module         = THIS_MODULE,
2795         .ops            = devlink_nl_ops,
2796         .n_ops          = ARRAY_SIZE(devlink_nl_ops),
2797         .mcgrps         = devlink_nl_mcgrps,
2798         .n_mcgrps       = ARRAY_SIZE(devlink_nl_mcgrps),
2799 };
2800
2801 /**
2802  *      devlink_alloc - Allocate new devlink instance resources
2803  *
2804  *      @ops: ops
2805  *      @priv_size: size of user private data
2806  *
2807  *      Allocate new devlink instance resources, including devlink index
2808  *      and name.
2809  */
2810 struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size)
2811 {
2812         struct devlink *devlink;
2813
2814         devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
2815         if (!devlink)
2816                 return NULL;
2817         devlink->ops = ops;
2818         devlink_net_set(devlink, &init_net);
2819         INIT_LIST_HEAD(&devlink->port_list);
2820         INIT_LIST_HEAD(&devlink->sb_list);
2821         INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
2822         INIT_LIST_HEAD(&devlink->resource_list);
2823         mutex_init(&devlink->lock);
2824         return devlink;
2825 }
2826 EXPORT_SYMBOL_GPL(devlink_alloc);
2827
2828 /**
2829  *      devlink_register - Register devlink instance
2830  *
2831  *      @devlink: devlink
2832  */
2833 int devlink_register(struct devlink *devlink, struct device *dev)
2834 {
2835         mutex_lock(&devlink_mutex);
2836         devlink->dev = dev;
2837         list_add_tail(&devlink->list, &devlink_list);
2838         devlink_notify(devlink, DEVLINK_CMD_NEW);
2839         mutex_unlock(&devlink_mutex);
2840         return 0;
2841 }
2842 EXPORT_SYMBOL_GPL(devlink_register);
2843
2844 /**
2845  *      devlink_unregister - Unregister devlink instance
2846  *
2847  *      @devlink: devlink
2848  */
2849 void devlink_unregister(struct devlink *devlink)
2850 {
2851         mutex_lock(&devlink_mutex);
2852         devlink_notify(devlink, DEVLINK_CMD_DEL);
2853         list_del(&devlink->list);
2854         mutex_unlock(&devlink_mutex);
2855 }
2856 EXPORT_SYMBOL_GPL(devlink_unregister);
2857
2858 /**
2859  *      devlink_free - Free devlink instance resources
2860  *
2861  *      @devlink: devlink
2862  */
2863 void devlink_free(struct devlink *devlink)
2864 {
2865         kfree(devlink);
2866 }
2867 EXPORT_SYMBOL_GPL(devlink_free);
2868
2869 /**
2870  *      devlink_port_register - Register devlink port
2871  *
2872  *      @devlink: devlink
2873  *      @devlink_port: devlink port
2874  *      @port_index
2875  *
2876  *      Register devlink port with provided port index. User can use
2877  *      any indexing, even hw-related one. devlink_port structure
2878  *      is convenient to be embedded inside user driver private structure.
2879  *      Note that the caller should take care of zeroing the devlink_port
2880  *      structure.
2881  */
2882 int devlink_port_register(struct devlink *devlink,
2883                           struct devlink_port *devlink_port,
2884                           unsigned int port_index)
2885 {
2886         mutex_lock(&devlink->lock);
2887         if (devlink_port_index_exists(devlink, port_index)) {
2888                 mutex_unlock(&devlink->lock);
2889                 return -EEXIST;
2890         }
2891         devlink_port->devlink = devlink;
2892         devlink_port->index = port_index;
2893         devlink_port->registered = true;
2894         list_add_tail(&devlink_port->list, &devlink->port_list);
2895         mutex_unlock(&devlink->lock);
2896         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
2897         return 0;
2898 }
2899 EXPORT_SYMBOL_GPL(devlink_port_register);
2900
2901 /**
2902  *      devlink_port_unregister - Unregister devlink port
2903  *
2904  *      @devlink_port: devlink port
2905  */
2906 void devlink_port_unregister(struct devlink_port *devlink_port)
2907 {
2908         struct devlink *devlink = devlink_port->devlink;
2909
2910         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
2911         mutex_lock(&devlink->lock);
2912         list_del(&devlink_port->list);
2913         mutex_unlock(&devlink->lock);
2914 }
2915 EXPORT_SYMBOL_GPL(devlink_port_unregister);
2916
2917 static void __devlink_port_type_set(struct devlink_port *devlink_port,
2918                                     enum devlink_port_type type,
2919                                     void *type_dev)
2920 {
2921         devlink_port->type = type;
2922         devlink_port->type_dev = type_dev;
2923         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
2924 }
2925
2926 /**
2927  *      devlink_port_type_eth_set - Set port type to Ethernet
2928  *
2929  *      @devlink_port: devlink port
2930  *      @netdev: related netdevice
2931  */
2932 void devlink_port_type_eth_set(struct devlink_port *devlink_port,
2933                                struct net_device *netdev)
2934 {
2935         return __devlink_port_type_set(devlink_port,
2936                                        DEVLINK_PORT_TYPE_ETH, netdev);
2937 }
2938 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
2939
2940 /**
2941  *      devlink_port_type_ib_set - Set port type to InfiniBand
2942  *
2943  *      @devlink_port: devlink port
2944  *      @ibdev: related IB device
2945  */
2946 void devlink_port_type_ib_set(struct devlink_port *devlink_port,
2947                               struct ib_device *ibdev)
2948 {
2949         return __devlink_port_type_set(devlink_port,
2950                                        DEVLINK_PORT_TYPE_IB, ibdev);
2951 }
2952 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
2953
2954 /**
2955  *      devlink_port_type_clear - Clear port type
2956  *
2957  *      @devlink_port: devlink port
2958  */
2959 void devlink_port_type_clear(struct devlink_port *devlink_port)
2960 {
2961         return __devlink_port_type_set(devlink_port,
2962                                        DEVLINK_PORT_TYPE_NOTSET, NULL);
2963 }
2964 EXPORT_SYMBOL_GPL(devlink_port_type_clear);
2965
2966 /**
2967  *      devlink_port_split_set - Set port is split
2968  *
2969  *      @devlink_port: devlink port
2970  *      @split_group: split group - identifies group split port is part of
2971  */
2972 void devlink_port_split_set(struct devlink_port *devlink_port,
2973                             u32 split_group)
2974 {
2975         devlink_port->split = true;
2976         devlink_port->split_group = split_group;
2977         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
2978 }
2979 EXPORT_SYMBOL_GPL(devlink_port_split_set);
2980
2981 int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
2982                         u32 size, u16 ingress_pools_count,
2983                         u16 egress_pools_count, u16 ingress_tc_count,
2984                         u16 egress_tc_count)
2985 {
2986         struct devlink_sb *devlink_sb;
2987         int err = 0;
2988
2989         mutex_lock(&devlink->lock);
2990         if (devlink_sb_index_exists(devlink, sb_index)) {
2991                 err = -EEXIST;
2992                 goto unlock;
2993         }
2994
2995         devlink_sb = kzalloc(sizeof(*devlink_sb), GFP_KERNEL);
2996         if (!devlink_sb) {
2997                 err = -ENOMEM;
2998                 goto unlock;
2999         }
3000         devlink_sb->index = sb_index;
3001         devlink_sb->size = size;
3002         devlink_sb->ingress_pools_count = ingress_pools_count;
3003         devlink_sb->egress_pools_count = egress_pools_count;
3004         devlink_sb->ingress_tc_count = ingress_tc_count;
3005         devlink_sb->egress_tc_count = egress_tc_count;
3006         list_add_tail(&devlink_sb->list, &devlink->sb_list);
3007 unlock:
3008         mutex_unlock(&devlink->lock);
3009         return err;
3010 }
3011 EXPORT_SYMBOL_GPL(devlink_sb_register);
3012
3013 void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index)
3014 {
3015         struct devlink_sb *devlink_sb;
3016
3017         mutex_lock(&devlink->lock);
3018         devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
3019         WARN_ON(!devlink_sb);
3020         list_del(&devlink_sb->list);
3021         mutex_unlock(&devlink->lock);
3022         kfree(devlink_sb);
3023 }
3024 EXPORT_SYMBOL_GPL(devlink_sb_unregister);
3025
3026 /**
3027  *      devlink_dpipe_headers_register - register dpipe headers
3028  *
3029  *      @devlink: devlink
3030  *      @dpipe_headers: dpipe header array
3031  *
3032  *      Register the headers supported by hardware.
3033  */
3034 int devlink_dpipe_headers_register(struct devlink *devlink,
3035                                    struct devlink_dpipe_headers *dpipe_headers)
3036 {
3037         mutex_lock(&devlink->lock);
3038         devlink->dpipe_headers = dpipe_headers;
3039         mutex_unlock(&devlink->lock);
3040         return 0;
3041 }
3042 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register);
3043
3044 /**
3045  *      devlink_dpipe_headers_unregister - unregister dpipe headers
3046  *
3047  *      @devlink: devlink
3048  *
3049  *      Unregister the headers supported by hardware.
3050  */
3051 void devlink_dpipe_headers_unregister(struct devlink *devlink)
3052 {
3053         mutex_lock(&devlink->lock);
3054         devlink->dpipe_headers = NULL;
3055         mutex_unlock(&devlink->lock);
3056 }
3057 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister);
3058
3059 /**
3060  *      devlink_dpipe_table_counter_enabled - check if counter allocation
3061  *                                            required
3062  *      @devlink: devlink
3063  *      @table_name: tables name
3064  *
3065  *      Used by driver to check if counter allocation is required.
3066  *      After counter allocation is turned on the table entries
3067  *      are updated to include counter statistics.
3068  *
3069  *      After that point on the driver must respect the counter
3070  *      state so that each entry added to the table is added
3071  *      with a counter.
3072  */
3073 bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
3074                                          const char *table_name)
3075 {
3076         struct devlink_dpipe_table *table;
3077         bool enabled;
3078
3079         rcu_read_lock();
3080         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3081                                          table_name);
3082         enabled = false;
3083         if (table)
3084                 enabled = table->counters_enabled;
3085         rcu_read_unlock();
3086         return enabled;
3087 }
3088 EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
3089
3090 /**
3091  *      devlink_dpipe_table_register - register dpipe table
3092  *
3093  *      @devlink: devlink
3094  *      @table_name: table name
3095  *      @table_ops: table ops
3096  *      @priv: priv
3097  *      @counter_control_extern: external control for counters
3098  */
3099 int devlink_dpipe_table_register(struct devlink *devlink,
3100                                  const char *table_name,
3101                                  struct devlink_dpipe_table_ops *table_ops,
3102                                  void *priv, bool counter_control_extern)
3103 {
3104         struct devlink_dpipe_table *table;
3105
3106         if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name))
3107                 return -EEXIST;
3108
3109         if (WARN_ON(!table_ops->size_get))
3110                 return -EINVAL;
3111
3112         table = kzalloc(sizeof(*table), GFP_KERNEL);
3113         if (!table)
3114                 return -ENOMEM;
3115
3116         table->name = table_name;
3117         table->table_ops = table_ops;
3118         table->priv = priv;
3119         table->counter_control_extern = counter_control_extern;
3120
3121         mutex_lock(&devlink->lock);
3122         list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
3123         mutex_unlock(&devlink->lock);
3124         return 0;
3125 }
3126 EXPORT_SYMBOL_GPL(devlink_dpipe_table_register);
3127
3128 /**
3129  *      devlink_dpipe_table_unregister - unregister dpipe table
3130  *
3131  *      @devlink: devlink
3132  *      @table_name: table name
3133  */
3134 void devlink_dpipe_table_unregister(struct devlink *devlink,
3135                                     const char *table_name)
3136 {
3137         struct devlink_dpipe_table *table;
3138
3139         mutex_lock(&devlink->lock);
3140         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3141                                          table_name);
3142         if (!table)
3143                 goto unlock;
3144         list_del_rcu(&table->list);
3145         mutex_unlock(&devlink->lock);
3146         kfree_rcu(table, rcu);
3147         return;
3148 unlock:
3149         mutex_unlock(&devlink->lock);
3150 }
3151 EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister);
3152
3153 /**
3154  *      devlink_resource_register - devlink resource register
3155  *
3156  *      @devlink: devlink
3157  *      @resource_name: resource's name
3158  *      @top_hierarchy: top hierarchy
3159  *      @reload_required: reload is required for new configuration to
3160  *                        apply
3161  *      @resource_size: resource's size
3162  *      @resource_id: resource's id
3163  *      @parent_reosurce_id: resource's parent id
3164  *      @size params: size parameters
3165  *      @resource_ops: resource ops
3166  */
3167 int devlink_resource_register(struct devlink *devlink,
3168                               const char *resource_name,
3169                               u64 resource_size,
3170                               u64 resource_id,
3171                               u64 parent_resource_id,
3172                               const struct devlink_resource_size_params *size_params,
3173                               const struct devlink_resource_ops *resource_ops)
3174 {
3175         struct devlink_resource *resource;
3176         struct list_head *resource_list;
3177         bool top_hierarchy;
3178         int err = 0;
3179
3180         top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
3181
3182         mutex_lock(&devlink->lock);
3183         resource = devlink_resource_find(devlink, NULL, resource_id);
3184         if (resource) {
3185                 err = -EINVAL;
3186                 goto out;
3187         }
3188
3189         resource = kzalloc(sizeof(*resource), GFP_KERNEL);
3190         if (!resource) {
3191                 err = -ENOMEM;
3192                 goto out;
3193         }
3194
3195         if (top_hierarchy) {
3196                 resource_list = &devlink->resource_list;
3197         } else {
3198                 struct devlink_resource *parent_resource;
3199
3200                 parent_resource = devlink_resource_find(devlink, NULL,
3201                                                         parent_resource_id);
3202                 if (parent_resource) {
3203                         resource_list = &parent_resource->resource_list;
3204                         resource->parent = parent_resource;
3205                 } else {
3206                         kfree(resource);
3207                         err = -EINVAL;
3208                         goto out;
3209                 }
3210         }
3211
3212         resource->name = resource_name;
3213         resource->size = resource_size;
3214         resource->size_new = resource_size;
3215         resource->id = resource_id;
3216         resource->resource_ops = resource_ops;
3217         resource->size_valid = true;
3218         memcpy(&resource->size_params, size_params,
3219                sizeof(resource->size_params));
3220         INIT_LIST_HEAD(&resource->resource_list);
3221         list_add_tail(&resource->list, resource_list);
3222 out:
3223         mutex_unlock(&devlink->lock);
3224         return err;
3225 }
3226 EXPORT_SYMBOL_GPL(devlink_resource_register);
3227
3228 /**
3229  *      devlink_resources_unregister - free all resources
3230  *
3231  *      @devlink: devlink
3232  *      @resource: resource
3233  */
3234 void devlink_resources_unregister(struct devlink *devlink,
3235                                   struct devlink_resource *resource)
3236 {
3237         struct devlink_resource *tmp, *child_resource;
3238         struct list_head *resource_list;
3239
3240         if (resource)
3241                 resource_list = &resource->resource_list;
3242         else
3243                 resource_list = &devlink->resource_list;
3244
3245         if (!resource)
3246                 mutex_lock(&devlink->lock);
3247
3248         list_for_each_entry_safe(child_resource, tmp, resource_list, list) {
3249                 devlink_resources_unregister(devlink, child_resource);
3250                 list_del(&child_resource->list);
3251                 kfree(child_resource);
3252         }
3253
3254         if (!resource)
3255                 mutex_unlock(&devlink->lock);
3256 }
3257 EXPORT_SYMBOL_GPL(devlink_resources_unregister);
3258
3259 /**
3260  *      devlink_resource_size_get - get and update size
3261  *
3262  *      @devlink: devlink
3263  *      @resource_id: the requested resource id
3264  *      @p_resource_size: ptr to update
3265  */
3266 int devlink_resource_size_get(struct devlink *devlink,
3267                               u64 resource_id,
3268                               u64 *p_resource_size)
3269 {
3270         struct devlink_resource *resource;
3271         int err = 0;
3272
3273         mutex_lock(&devlink->lock);
3274         resource = devlink_resource_find(devlink, NULL, resource_id);
3275         if (!resource) {
3276                 err = -EINVAL;
3277                 goto out;
3278         }
3279         *p_resource_size = resource->size_new;
3280         resource->size = resource->size_new;
3281 out:
3282         mutex_unlock(&devlink->lock);
3283         return err;
3284 }
3285 EXPORT_SYMBOL_GPL(devlink_resource_size_get);
3286
3287 /**
3288  *      devlink_dpipe_table_resource_set - set the resource id
3289  *
3290  *      @devlink: devlink
3291  *      @table_name: table name
3292  *      @resource_id: resource id
3293  *      @resource_units: number of resource's units consumed per table's entry
3294  */
3295 int devlink_dpipe_table_resource_set(struct devlink *devlink,
3296                                      const char *table_name, u64 resource_id,
3297                                      u64 resource_units)
3298 {
3299         struct devlink_dpipe_table *table;
3300         int err = 0;
3301
3302         mutex_lock(&devlink->lock);
3303         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3304                                          table_name);
3305         if (!table) {
3306                 err = -EINVAL;
3307                 goto out;
3308         }
3309         table->resource_id = resource_id;
3310         table->resource_units = resource_units;
3311         table->resource_valid = true;
3312 out:
3313         mutex_unlock(&devlink->lock);
3314         return err;
3315 }
3316 EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set);
3317
3318 static int __init devlink_module_init(void)
3319 {
3320         return genl_register_family(&devlink_nl_family);
3321 }
3322
3323 static void __exit devlink_module_exit(void)
3324 {
3325         genl_unregister_family(&devlink_nl_family);
3326 }
3327
3328 module_init(devlink_module_init);
3329 module_exit(devlink_module_exit);
3330
3331 MODULE_LICENSE("GPL v2");
3332 MODULE_AUTHOR("Jiri Pirko <[email protected]>");
3333 MODULE_DESCRIPTION("Network physical device Netlink interface");
3334 MODULE_ALIAS_GENL_FAMILY(DEVLINK_GENL_NAME);