net/core/devlink.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * net/core/devlink.c - Network physical/parent device Netlink interface
   4  *
   5  * Heavily inspired by net/wireless/
   6  * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
   7  * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
   8  */
   9
  10 #include <linux/etherdevice.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/types.h>
  14 #include <linux/slab.h>
  15 #include <linux/gfp.h>
  16 #include <linux/device.h>
  17 #include <linux/list.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/refcount.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/u64_stats_sync.h>
  23 #include <linux/timekeeping.h>
  24 #include <rdma/ib_verbs.h>
  25 #include <net/netlink.h>
  26 #include <net/genetlink.h>
  27 #include <net/rtnetlink.h>
  28 #include <net/net_namespace.h>
  29 #include <net/sock.h>
  30 #include <net/devlink.h>
  31 #define CREATE_TRACE_POINTS
  32 #include <trace/events/devlink.h>
  33
  34 #define DEVLINK_RELOAD_STATS_ARRAY_SIZE \
  35         (__DEVLINK_RELOAD_LIMIT_MAX * __DEVLINK_RELOAD_ACTION_MAX)
  36
  37 struct devlink_dev_stats {
  38         u32 reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE];
  39         u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE];
  40 };
  41
  42 struct devlink {
  43         u32 index;
  44         struct list_head port_list;
  45         struct list_head rate_list;
  46         struct list_head sb_list;
  47         struct list_head dpipe_table_list;
  48         struct list_head resource_list;
  49         struct list_head param_list;
  50         struct list_head region_list;
  51         struct list_head reporter_list;
  52         struct mutex reporters_lock; /* protects reporter_list */
  53         struct devlink_dpipe_headers *dpipe_headers;
  54         struct list_head trap_list;
  55         struct list_head trap_group_list;
  56         struct list_head trap_policer_list;
  57         const struct devlink_ops *ops;
  58         u64 features;
  59         struct xarray snapshot_ids;
  60         struct devlink_dev_stats stats;
  61         struct device *dev;
  62         possible_net_t _net;
  63         /* Serializes access to devlink instance specific objects such as
  64          * port, sb, dpipe, resource, params, region, traps and more.
  65          */
  66         struct mutex lock;
  67         u8 reload_failed:1;
  68         refcount_t refcount;
  69         struct completion comp;
  70         char priv[] __aligned(NETDEV_ALIGN);
  71 };
  72
  73 /**
  74  * struct devlink_resource - devlink resource
  75  * @name: name of the resource
  76  * @id: id, per devlink instance
  77  * @size: size of the resource
  78  * @size_new: updated size of the resource, reload is needed
  79  * @size_valid: valid in case the total size of the resource is valid
  80  *              including its children
  81  * @parent: parent resource
  82  * @size_params: size parameters
  83  * @list: parent list
  84  * @resource_list: list of child resources
  85  * @occ_get: occupancy getter callback
  86  * @occ_get_priv: occupancy getter callback priv
  87  */
  88 struct devlink_resource {
  89         const char *name;
  90         u64 id;
  91         u64 size;
  92         u64 size_new;
  93         bool size_valid;
  94         struct devlink_resource *parent;
  95         struct devlink_resource_size_params size_params;
  96         struct list_head list;
  97         struct list_head resource_list;
  98         devlink_resource_occ_get_t *occ_get;
  99         void *occ_get_priv;
 100 };
 101
 102 void *devlink_priv(struct devlink *devlink)
 103 {
 104         return &devlink->priv;
 105 }
 106 EXPORT_SYMBOL_GPL(devlink_priv);
 107
 108 struct devlink *priv_to_devlink(void *priv)
 109 {
 110         return container_of(priv, struct devlink, priv);
 111 }
 112 EXPORT_SYMBOL_GPL(priv_to_devlink);
 113
 114 struct device *devlink_to_dev(const struct devlink *devlink)
 115 {
 116         return devlink->dev;
 117 }
 118 EXPORT_SYMBOL_GPL(devlink_to_dev);
 119
 120 static struct devlink_dpipe_field devlink_dpipe_fields_ethernet[] = {
 121         {
 122                 .name = "destination mac",
 123                 .id = DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC,
 124                 .bitwidth = 48,
 125         },
 126 };
 127
 128 struct devlink_dpipe_header devlink_dpipe_header_ethernet = {
 129         .name = "ethernet",
 130         .id = DEVLINK_DPIPE_HEADER_ETHERNET,
 131         .fields = devlink_dpipe_fields_ethernet,
 132         .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ethernet),
 133         .global = true,
 134 };
 135 EXPORT_SYMBOL_GPL(devlink_dpipe_header_ethernet);
 136
 137 static struct devlink_dpipe_field devlink_dpipe_fields_ipv4[] = {
 138         {
 139                 .name = "destination ip",
 140                 .id = DEVLINK_DPIPE_FIELD_IPV4_DST_IP,
 141                 .bitwidth = 32,
 142         },
 143 };
 144
 145 struct devlink_dpipe_header devlink_dpipe_header_ipv4 = {
 146         .name = "ipv4",
 147         .id = DEVLINK_DPIPE_HEADER_IPV4,
 148         .fields = devlink_dpipe_fields_ipv4,
 149         .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv4),
 150         .global = true,
 151 };
 152 EXPORT_SYMBOL_GPL(devlink_dpipe_header_ipv4);
 153
 154 static struct devlink_dpipe_field devlink_dpipe_fields_ipv6[] = {
 155         {
 156                 .name = "destination ip",
 157                 .id = DEVLINK_DPIPE_FIELD_IPV6_DST_IP,
 158                 .bitwidth = 128,
 159         },
 160 };
 161
 162 struct devlink_dpipe_header devlink_dpipe_header_ipv6 = {
 163         .name = "ipv6",
 164         .id = DEVLINK_DPIPE_HEADER_IPV6,
 165         .fields = devlink_dpipe_fields_ipv6,
 166         .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv6),
 167         .global = true,
 168 };
 169 EXPORT_SYMBOL_GPL(devlink_dpipe_header_ipv6);
 170
 171 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg);
 172 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwerr);
 173 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_trap_report);
 174
 175 static const struct nla_policy devlink_function_nl_policy[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1] = {
 176         [DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] = { .type = NLA_BINARY },
 177         [DEVLINK_PORT_FN_ATTR_STATE] =
 178                 NLA_POLICY_RANGE(NLA_U8, DEVLINK_PORT_FN_STATE_INACTIVE,
 179                                  DEVLINK_PORT_FN_STATE_ACTIVE),
 180 };
 181
 182 static DEFINE_XARRAY_FLAGS(devlinks, XA_FLAGS_ALLOC);
 183 #define DEVLINK_REGISTERED XA_MARK_1
 184
 185 /* devlink instances are open to the access from the user space after
 186  * devlink_register() call. Such logical barrier allows us to have certain
 187  * expectations related to locking.
 188  *
 189  * Before *_register() - we are in initialization stage and no parallel
 190  * access possible to the devlink instance. All drivers perform that phase
 191  * by implicitly holding device_lock.
 192  *
 193  * After *_register() - users and driver can access devlink instance at
 194  * the same time.
 195  */
 196 #define ASSERT_DEVLINK_REGISTERED(d)                                           \
 197         WARN_ON_ONCE(!xa_get_mark(&devlinks, (d)->index, DEVLINK_REGISTERED))
 198 #define ASSERT_DEVLINK_NOT_REGISTERED(d)                                       \
 199         WARN_ON_ONCE(xa_get_mark(&devlinks, (d)->index, DEVLINK_REGISTERED))
 200
 201 /* devlink_mutex
 202  *
 203  * An overall lock guarding every operation coming from userspace.
 204  * It also guards devlink devices list and it is taken when
 205  * driver registers/unregisters it.
 206  */
 207 static DEFINE_MUTEX(devlink_mutex);
 208
 209 struct net *devlink_net(const struct devlink *devlink)
 210 {
 211         return read_pnet(&devlink->_net);
 212 }
 213 EXPORT_SYMBOL_GPL(devlink_net);
 214
 215 void devlink_put(struct devlink *devlink)
 216 {
 217         if (refcount_dec_and_test(&devlink->refcount))
 218                 complete(&devlink->comp);
 219 }
 220
 221 struct devlink *__must_check devlink_try_get(struct devlink *devlink)
 222 {
 223         if (refcount_inc_not_zero(&devlink->refcount))
 224                 return devlink;
 225         return NULL;
 226 }
 227
 228 void devl_assert_locked(struct devlink *devlink)
 229 {
 230         lockdep_assert_held(&devlink->lock);
 231 }
 232 EXPORT_SYMBOL_GPL(devl_assert_locked);
 233
 234 #ifdef CONFIG_LOCKDEP
 235 /* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */
 236 bool devl_lock_is_held(struct devlink *devlink)
 237 {
 238         return lockdep_is_held(&devlink->lock);
 239 }
 240 EXPORT_SYMBOL_GPL(devl_lock_is_held);
 241 #endif
 242
 243 void devl_lock(struct devlink *devlink)
 244 {
 245         mutex_lock(&devlink->lock);
 246 }
 247 EXPORT_SYMBOL_GPL(devl_lock);
 248
 249 void devl_unlock(struct devlink *devlink)
 250 {
 251         mutex_unlock(&devlink->lock);
 252 }
 253 EXPORT_SYMBOL_GPL(devl_unlock);
 254
 255 static struct devlink *devlink_get_from_attrs(struct net *net,
 256                                               struct nlattr **attrs)
 257 {
 258         struct devlink *devlink;
 259         unsigned long index;
 260         bool found = false;
 261         char *busname;
 262         char *devname;
 263
 264         if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
 265                 return ERR_PTR(-EINVAL);
 266
 267         busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
 268         devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
 269
 270         lockdep_assert_held(&devlink_mutex);
 271
 272         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
 273                 if (strcmp(devlink->dev->bus->name, busname) == 0 &&
 274                     strcmp(dev_name(devlink->dev), devname) == 0 &&
 275                     net_eq(devlink_net(devlink), net)) {
 276                         found = true;
 277                         break;
 278                 }
 279         }
 280
 281         if (!found || !devlink_try_get(devlink))
 282                 devlink = ERR_PTR(-ENODEV);
 283
 284         return devlink;
 285 }
 286
 287 static struct devlink_port *devlink_port_get_by_index(struct devlink *devlink,
 288                                                       unsigned int port_index)
 289 {
 290         struct devlink_port *devlink_port;
 291
 292         list_for_each_entry(devlink_port, &devlink->port_list, list) {
 293                 if (devlink_port->index == port_index)
 294                         return devlink_port;
 295         }
 296         return NULL;
 297 }
 298
 299 static bool devlink_port_index_exists(struct devlink *devlink,
 300                                       unsigned int port_index)
 301 {
 302         return devlink_port_get_by_index(devlink, port_index);
 303 }
 304
 305 static struct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink,
 306                                                         struct nlattr **attrs)
 307 {
 308         if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
 309                 u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
 310                 struct devlink_port *devlink_port;
 311
 312                 devlink_port = devlink_port_get_by_index(devlink, port_index);
 313                 if (!devlink_port)
 314                         return ERR_PTR(-ENODEV);
 315                 return devlink_port;
 316         }
 317         return ERR_PTR(-EINVAL);
 318 }
 319
 320 static struct devlink_port *devlink_port_get_from_info(struct devlink *devlink,
 321                                                        struct genl_info *info)
 322 {
 323         return devlink_port_get_from_attrs(devlink, info->attrs);
 324 }
 325
 326 static inline bool
 327 devlink_rate_is_leaf(struct devlink_rate *devlink_rate)
 328 {
 329         return devlink_rate->type == DEVLINK_RATE_TYPE_LEAF;
 330 }
 331
 332 static inline bool
 333 devlink_rate_is_node(struct devlink_rate *devlink_rate)
 334 {
 335         return devlink_rate->type == DEVLINK_RATE_TYPE_NODE;
 336 }
 337
 338 static struct devlink_rate *
 339 devlink_rate_leaf_get_from_info(struct devlink *devlink, struct genl_info *info)
 340 {
 341         struct devlink_rate *devlink_rate;
 342         struct devlink_port *devlink_port;
 343
 344         devlink_port = devlink_port_get_from_attrs(devlink, info->attrs);
 345         if (IS_ERR(devlink_port))
 346                 return ERR_CAST(devlink_port);
 347         devlink_rate = devlink_port->devlink_rate;
 348         return devlink_rate ?: ERR_PTR(-ENODEV);
 349 }
 350
 351 static struct devlink_rate *
 352 devlink_rate_node_get_by_name(struct devlink *devlink, const char *node_name)
 353 {
 354         static struct devlink_rate *devlink_rate;
 355
 356         list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
 357                 if (devlink_rate_is_node(devlink_rate) &&
 358                     !strcmp(node_name, devlink_rate->name))
 359                         return devlink_rate;
 360         }
 361         return ERR_PTR(-ENODEV);
 362 }
 363
 364 static struct devlink_rate *
 365 devlink_rate_node_get_from_attrs(struct devlink *devlink, struct nlattr **attrs)
 366 {
 367         const char *rate_node_name;
 368         size_t len;
 369
 370         if (!attrs[DEVLINK_ATTR_RATE_NODE_NAME])
 371                 return ERR_PTR(-EINVAL);
 372         rate_node_name = nla_data(attrs[DEVLINK_ATTR_RATE_NODE_NAME]);
 373         len = strlen(rate_node_name);
 374         /* Name cannot be empty or decimal number */
 375         if (!len || strspn(rate_node_name, "0123456789") == len)
 376                 return ERR_PTR(-EINVAL);
 377
 378         return devlink_rate_node_get_by_name(devlink, rate_node_name);
 379 }
 380
 381 static struct devlink_rate *
 382 devlink_rate_node_get_from_info(struct devlink *devlink, struct genl_info *info)
 383 {
 384         return devlink_rate_node_get_from_attrs(devlink, info->attrs);
 385 }
 386
 387 static struct devlink_rate *
 388 devlink_rate_get_from_info(struct devlink *devlink, struct genl_info *info)
 389 {
 390         struct nlattr **attrs = info->attrs;
 391
 392         if (attrs[DEVLINK_ATTR_PORT_INDEX])
 393                 return devlink_rate_leaf_get_from_info(devlink, info);
 394         else if (attrs[DEVLINK_ATTR_RATE_NODE_NAME])
 395                 return devlink_rate_node_get_from_info(devlink, info);
 396         else
 397                 return ERR_PTR(-EINVAL);
 398 }
 399
 400 struct devlink_sb {
 401         struct list_head list;
 402         unsigned int index;
 403         u32 size;
 404         u16 ingress_pools_count;
 405         u16 egress_pools_count;
 406         u16 ingress_tc_count;
 407         u16 egress_tc_count;
 408 };
 409
 410 static u16 devlink_sb_pool_count(struct devlink_sb *devlink_sb)
 411 {
 412         return devlink_sb->ingress_pools_count + devlink_sb->egress_pools_count;
 413 }
 414
 415 static struct devlink_sb *devlink_sb_get_by_index(struct devlink *devlink,
 416                                                   unsigned int sb_index)
 417 {
 418         struct devlink_sb *devlink_sb;
 419
 420         list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
 421                 if (devlink_sb->index == sb_index)
 422                         return devlink_sb;
 423         }
 424         return NULL;
 425 }
 426
 427 static bool devlink_sb_index_exists(struct devlink *devlink,
 428                                     unsigned int sb_index)
 429 {
 430         return devlink_sb_get_by_index(devlink, sb_index);
 431 }
 432
 433 static struct devlink_sb *devlink_sb_get_from_attrs(struct devlink *devlink,
 434                                                     struct nlattr **attrs)
 435 {
 436         if (attrs[DEVLINK_ATTR_SB_INDEX]) {
 437                 u32 sb_index = nla_get_u32(attrs[DEVLINK_ATTR_SB_INDEX]);
 438                 struct devlink_sb *devlink_sb;
 439
 440                 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
 441                 if (!devlink_sb)
 442                         return ERR_PTR(-ENODEV);
 443                 return devlink_sb;
 444         }
 445         return ERR_PTR(-EINVAL);
 446 }
 447
 448 static struct devlink_sb *devlink_sb_get_from_info(struct devlink *devlink,
 449                                                    struct genl_info *info)
 450 {
 451         return devlink_sb_get_from_attrs(devlink, info->attrs);
 452 }
 453
 454 static int devlink_sb_pool_index_get_from_attrs(struct devlink_sb *devlink_sb,
 455                                                 struct nlattr **attrs,
 456                                                 u16 *p_pool_index)
 457 {
 458         u16 val;
 459
 460         if (!attrs[DEVLINK_ATTR_SB_POOL_INDEX])
 461                 return -EINVAL;
 462
 463         val = nla_get_u16(attrs[DEVLINK_ATTR_SB_POOL_INDEX]);
 464         if (val >= devlink_sb_pool_count(devlink_sb))
 465                 return -EINVAL;
 466         *p_pool_index = val;
 467         return 0;
 468 }
 469
 470 static int devlink_sb_pool_index_get_from_info(struct devlink_sb *devlink_sb,
 471                                                struct genl_info *info,
 472                                                u16 *p_pool_index)
 473 {
 474         return devlink_sb_pool_index_get_from_attrs(devlink_sb, info->attrs,
 475                                                     p_pool_index);
 476 }
 477
 478 static int
 479 devlink_sb_pool_type_get_from_attrs(struct nlattr **attrs,
 480                                     enum devlink_sb_pool_type *p_pool_type)
 481 {
 482         u8 val;
 483
 484         if (!attrs[DEVLINK_ATTR_SB_POOL_TYPE])
 485                 return -EINVAL;
 486
 487         val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_TYPE]);
 488         if (val != DEVLINK_SB_POOL_TYPE_INGRESS &&
 489             val != DEVLINK_SB_POOL_TYPE_EGRESS)
 490                 return -EINVAL;
 491         *p_pool_type = val;
 492         return 0;
 493 }
 494
 495 static int
 496 devlink_sb_pool_type_get_from_info(struct genl_info *info,
 497                                    enum devlink_sb_pool_type *p_pool_type)
 498 {
 499         return devlink_sb_pool_type_get_from_attrs(info->attrs, p_pool_type);
 500 }
 501
 502 static int
 503 devlink_sb_th_type_get_from_attrs(struct nlattr **attrs,
 504                                   enum devlink_sb_threshold_type *p_th_type)
 505 {
 506         u8 val;
 507
 508         if (!attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])
 509                 return -EINVAL;
 510
 511         val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE]);
 512         if (val != DEVLINK_SB_THRESHOLD_TYPE_STATIC &&
 513             val != DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC)
 514                 return -EINVAL;
 515         *p_th_type = val;
 516         return 0;
 517 }
 518
 519 static int
 520 devlink_sb_th_type_get_from_info(struct genl_info *info,
 521                                  enum devlink_sb_threshold_type *p_th_type)
 522 {
 523         return devlink_sb_th_type_get_from_attrs(info->attrs, p_th_type);
 524 }
 525
 526 static int
 527 devlink_sb_tc_index_get_from_attrs(struct devlink_sb *devlink_sb,
 528                                    struct nlattr **attrs,
 529                                    enum devlink_sb_pool_type pool_type,
 530                                    u16 *p_tc_index)
 531 {
 532         u16 val;
 533
 534         if (!attrs[DEVLINK_ATTR_SB_TC_INDEX])
 535                 return -EINVAL;
 536
 537         val = nla_get_u16(attrs[DEVLINK_ATTR_SB_TC_INDEX]);
 538         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS &&
 539             val >= devlink_sb->ingress_tc_count)
 540                 return -EINVAL;
 541         if (pool_type == DEVLINK_SB_POOL_TYPE_EGRESS &&
 542             val >= devlink_sb->egress_tc_count)
 543                 return -EINVAL;
 544         *p_tc_index = val;
 545         return 0;
 546 }
 547
 548 static int
 549 devlink_sb_tc_index_get_from_info(struct devlink_sb *devlink_sb,
 550                                   struct genl_info *info,
 551                                   enum devlink_sb_pool_type pool_type,
 552                                   u16 *p_tc_index)
 553 {
 554         return devlink_sb_tc_index_get_from_attrs(devlink_sb, info->attrs,
 555                                                   pool_type, p_tc_index);
 556 }
 557
 558 struct devlink_region {
 559         struct devlink *devlink;
 560         struct devlink_port *port;
 561         struct list_head list;
 562         union {
 563                 const struct devlink_region_ops *ops;
 564                 const struct devlink_port_region_ops *port_ops;
 565         };
 566         struct list_head snapshot_list;
 567         u32 max_snapshots;
 568         u32 cur_snapshots;
 569         u64 size;
 570 };
 571
 572 struct devlink_snapshot {
 573         struct list_head list;
 574         struct devlink_region *region;
 575         u8 *data;
 576         u32 id;
 577 };
 578
 579 static struct devlink_region *
 580 devlink_region_get_by_name(struct devlink *devlink, const char *region_name)
 581 {
 582         struct devlink_region *region;
 583
 584         list_for_each_entry(region, &devlink->region_list, list)
 585                 if (!strcmp(region->ops->name, region_name))
 586                         return region;
 587
 588         return NULL;
 589 }
 590
 591 static struct devlink_region *
 592 devlink_port_region_get_by_name(struct devlink_port *port,
 593                                 const char *region_name)
 594 {
 595         struct devlink_region *region;
 596
 597         list_for_each_entry(region, &port->region_list, list)
 598                 if (!strcmp(region->ops->name, region_name))
 599                         return region;
 600
 601         return NULL;
 602 }
 603
 604 static struct devlink_snapshot *
 605 devlink_region_snapshot_get_by_id(struct devlink_region *region, u32 id)
 606 {
 607         struct devlink_snapshot *snapshot;
 608
 609         list_for_each_entry(snapshot, &region->snapshot_list, list)
 610                 if (snapshot->id == id)
 611                         return snapshot;
 612
 613         return NULL;
 614 }
 615
 616 #define DEVLINK_NL_FLAG_NEED_PORT               BIT(0)
 617 #define DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT    BIT(1)
 618 #define DEVLINK_NL_FLAG_NEED_RATE               BIT(2)
 619 #define DEVLINK_NL_FLAG_NEED_RATE_NODE          BIT(3)
 620
 621 /* The per devlink instance lock is taken by default in the pre-doit
 622  * operation, yet several commands do not require this. The global
 623  * devlink lock is taken and protects from disruption by user-calls.
 624  */
 625 #define DEVLINK_NL_FLAG_NO_LOCK                 BIT(4)
 626
 627 static int devlink_nl_pre_doit(const struct genl_ops *ops,
 628                                struct sk_buff *skb, struct genl_info *info)
 629 {
 630         struct devlink_port *devlink_port;
 631         struct devlink *devlink;
 632         int err;
 633
 634         mutex_lock(&devlink_mutex);
 635         devlink = devlink_get_from_attrs(genl_info_net(info), info->attrs);
 636         if (IS_ERR(devlink)) {
 637                 mutex_unlock(&devlink_mutex);
 638                 return PTR_ERR(devlink);
 639         }
 640         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
 641                 mutex_lock(&devlink->lock);
 642         info->user_ptr[0] = devlink;
 643         if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_PORT) {
 644                 devlink_port = devlink_port_get_from_info(devlink, info);
 645                 if (IS_ERR(devlink_port)) {
 646                         err = PTR_ERR(devlink_port);
 647                         goto unlock;
 648                 }
 649                 info->user_ptr[1] = devlink_port;
 650         } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT) {
 651                 devlink_port = devlink_port_get_from_info(devlink, info);
 652                 if (!IS_ERR(devlink_port))
 653                         info->user_ptr[1] = devlink_port;
 654         } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_RATE) {
 655                 struct devlink_rate *devlink_rate;
 656
 657                 devlink_rate = devlink_rate_get_from_info(devlink, info);
 658                 if (IS_ERR(devlink_rate)) {
 659                         err = PTR_ERR(devlink_rate);
 660                         goto unlock;
 661                 }
 662                 info->user_ptr[1] = devlink_rate;
 663         } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_RATE_NODE) {
 664                 struct devlink_rate *rate_node;
 665
 666                 rate_node = devlink_rate_node_get_from_info(devlink, info);
 667                 if (IS_ERR(rate_node)) {
 668                         err = PTR_ERR(rate_node);
 669                         goto unlock;
 670                 }
 671                 info->user_ptr[1] = rate_node;
 672         }
 673         return 0;
 674
 675 unlock:
 676         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
 677                 mutex_unlock(&devlink->lock);
 678         devlink_put(devlink);
 679         mutex_unlock(&devlink_mutex);
 680         return err;
 681 }
 682
 683 static void devlink_nl_post_doit(const struct genl_ops *ops,
 684                                  struct sk_buff *skb, struct genl_info *info)
 685 {
 686         struct devlink *devlink;
 687
 688         devlink = info->user_ptr[0];
 689         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
 690                 mutex_unlock(&devlink->lock);
 691         devlink_put(devlink);
 692         mutex_unlock(&devlink_mutex);
 693 }
 694
 695 static struct genl_family devlink_nl_family;
 696
 697 enum devlink_multicast_groups {
 698         DEVLINK_MCGRP_CONFIG,
 699 };
 700
 701 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
 702         [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
 703 };
 704
 705 static int devlink_nl_put_handle(struct sk_buff *msg, struct devlink *devlink)
 706 {
 707         if (nla_put_string(msg, DEVLINK_ATTR_BUS_NAME, devlink->dev->bus->name))
 708                 return -EMSGSIZE;
 709         if (nla_put_string(msg, DEVLINK_ATTR_DEV_NAME, dev_name(devlink->dev)))
 710                 return -EMSGSIZE;
 711         return 0;
 712 }
 713
 714 struct devlink_reload_combination {
 715         enum devlink_reload_action action;
 716         enum devlink_reload_limit limit;
 717 };
 718
 719 static const struct devlink_reload_combination devlink_reload_invalid_combinations[] = {
 720         {
 721                 /* can't reinitialize driver with no down time */
 722                 .action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
 723                 .limit = DEVLINK_RELOAD_LIMIT_NO_RESET,
 724         },
 725 };
 726
 727 static bool
 728 devlink_reload_combination_is_invalid(enum devlink_reload_action action,
 729                                       enum devlink_reload_limit limit)
 730 {
 731         int i;
 732
 733         for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++)
 734                 if (devlink_reload_invalid_combinations[i].action == action &&
 735                     devlink_reload_invalid_combinations[i].limit == limit)
 736                         return true;
 737         return false;
 738 }
 739
 740 static bool
 741 devlink_reload_action_is_supported(struct devlink *devlink, enum devlink_reload_action action)
 742 {
 743         return test_bit(action, &devlink->ops->reload_actions);
 744 }
 745
 746 static bool
 747 devlink_reload_limit_is_supported(struct devlink *devlink, enum devlink_reload_limit limit)
 748 {
 749         return test_bit(limit, &devlink->ops->reload_limits);
 750 }
 751
 752 static int devlink_reload_stat_put(struct sk_buff *msg,
 753                                    enum devlink_reload_limit limit, u32 value)
 754 {
 755         struct nlattr *reload_stats_entry;
 756
 757         reload_stats_entry = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_STATS_ENTRY);
 758         if (!reload_stats_entry)
 759                 return -EMSGSIZE;
 760
 761         if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_STATS_LIMIT, limit) ||
 762             nla_put_u32(msg, DEVLINK_ATTR_RELOAD_STATS_VALUE, value))
 763                 goto nla_put_failure;
 764         nla_nest_end(msg, reload_stats_entry);
 765         return 0;
 766
 767 nla_put_failure:
 768         nla_nest_cancel(msg, reload_stats_entry);
 769         return -EMSGSIZE;
 770 }
 771
 772 static int devlink_reload_stats_put(struct sk_buff *msg, struct devlink *devlink, bool is_remote)
 773 {
 774         struct nlattr *reload_stats_attr, *act_info, *act_stats;
 775         int i, j, stat_idx;
 776         u32 value;
 777
 778         if (!is_remote)
 779                 reload_stats_attr = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_STATS);
 780         else
 781                 reload_stats_attr = nla_nest_start(msg, DEVLINK_ATTR_REMOTE_RELOAD_STATS);
 782
 783         if (!reload_stats_attr)
 784                 return -EMSGSIZE;
 785
 786         for (i = 0; i <= DEVLINK_RELOAD_ACTION_MAX; i++) {
 787                 if ((!is_remote &&
 788                      !devlink_reload_action_is_supported(devlink, i)) ||
 789                     i == DEVLINK_RELOAD_ACTION_UNSPEC)
 790                         continue;
 791                 act_info = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_ACTION_INFO);
 792                 if (!act_info)
 793                         goto nla_put_failure;
 794
 795                 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_ACTION, i))
 796                         goto action_info_nest_cancel;
 797                 act_stats = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_ACTION_STATS);
 798                 if (!act_stats)
 799                         goto action_info_nest_cancel;
 800
 801                 for (j = 0; j <= DEVLINK_RELOAD_LIMIT_MAX; j++) {
 802                         /* Remote stats are shown even if not locally supported.
 803                          * Stats of actions with unspecified limit are shown
 804                          * though drivers don't need to register unspecified
 805                          * limit.
 806                          */
 807                         if ((!is_remote && j != DEVLINK_RELOAD_LIMIT_UNSPEC &&
 808                              !devlink_reload_limit_is_supported(devlink, j)) ||
 809                             devlink_reload_combination_is_invalid(i, j))
 810                                 continue;
 811
 812                         stat_idx = j * __DEVLINK_RELOAD_ACTION_MAX + i;
 813                         if (!is_remote)
 814                                 value = devlink->stats.reload_stats[stat_idx];
 815                         else
 816                                 value = devlink->stats.remote_reload_stats[stat_idx];
 817                         if (devlink_reload_stat_put(msg, j, value))
 818                                 goto action_stats_nest_cancel;
 819                 }
 820                 nla_nest_end(msg, act_stats);
 821                 nla_nest_end(msg, act_info);
 822         }
 823         nla_nest_end(msg, reload_stats_attr);
 824         return 0;
 825
 826 action_stats_nest_cancel:
 827         nla_nest_cancel(msg, act_stats);
 828 action_info_nest_cancel:
 829         nla_nest_cancel(msg, act_info);
 830 nla_put_failure:
 831         nla_nest_cancel(msg, reload_stats_attr);
 832         return -EMSGSIZE;
 833 }
 834
 835 static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
 836                            enum devlink_command cmd, u32 portid,
 837                            u32 seq, int flags)
 838 {
 839         struct nlattr *dev_stats;
 840         void *hdr;
 841
 842         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 843         if (!hdr)
 844                 return -EMSGSIZE;
 845
 846         if (devlink_nl_put_handle(msg, devlink))
 847                 goto nla_put_failure;
 848         if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_FAILED, devlink->reload_failed))
 849                 goto nla_put_failure;
 850
 851         dev_stats = nla_nest_start(msg, DEVLINK_ATTR_DEV_STATS);
 852         if (!dev_stats)
 853                 goto nla_put_failure;
 854
 855         if (devlink_reload_stats_put(msg, devlink, false))
 856                 goto dev_stats_nest_cancel;
 857         if (devlink_reload_stats_put(msg, devlink, true))
 858                 goto dev_stats_nest_cancel;
 859
 860         nla_nest_end(msg, dev_stats);
 861         genlmsg_end(msg, hdr);
 862         return 0;
 863
 864 dev_stats_nest_cancel:
 865         nla_nest_cancel(msg, dev_stats);
 866 nla_put_failure:
 867         genlmsg_cancel(msg, hdr);
 868         return -EMSGSIZE;
 869 }
 870
 871 static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
 872 {
 873         struct sk_buff *msg;
 874         int err;
 875
 876         WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
 877         WARN_ON(!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED));
 878
 879         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 880         if (!msg)
 881                 return;
 882
 883         err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
 884         if (err) {
 885                 nlmsg_free(msg);
 886                 return;
 887         }
 888
 889         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
 890                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
 891 }
 892
 893 static int devlink_nl_port_attrs_put(struct sk_buff *msg,
 894                                      struct devlink_port *devlink_port)
 895 {
 896         struct devlink_port_attrs *attrs = &devlink_port->attrs;
 897
 898         if (!devlink_port->attrs_set)
 899                 return 0;
 900         if (attrs->lanes) {
 901                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_LANES, attrs->lanes))
 902                         return -EMSGSIZE;
 903         }
 904         if (nla_put_u8(msg, DEVLINK_ATTR_PORT_SPLITTABLE, attrs->splittable))
 905                 return -EMSGSIZE;
 906         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_FLAVOUR, attrs->flavour))
 907                 return -EMSGSIZE;
 908         switch (devlink_port->attrs.flavour) {
 909         case DEVLINK_PORT_FLAVOUR_PCI_PF:
 910                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
 911                                 attrs->pci_pf.controller) ||
 912                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_pf.pf))
 913                         return -EMSGSIZE;
 914                 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_pf.external))
 915                         return -EMSGSIZE;
 916                 break;
 917         case DEVLINK_PORT_FLAVOUR_PCI_VF:
 918                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
 919                                 attrs->pci_vf.controller) ||
 920                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_vf.pf) ||
 921                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_VF_NUMBER, attrs->pci_vf.vf))
 922                         return -EMSGSIZE;
 923                 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_vf.external))
 924                         return -EMSGSIZE;
 925                 break;
 926         case DEVLINK_PORT_FLAVOUR_PCI_SF:
 927                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
 928                                 attrs->pci_sf.controller) ||
 929                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER,
 930                                 attrs->pci_sf.pf) ||
 931                     nla_put_u32(msg, DEVLINK_ATTR_PORT_PCI_SF_NUMBER,
 932                                 attrs->pci_sf.sf))
 933                         return -EMSGSIZE;
 934                 break;
 935         case DEVLINK_PORT_FLAVOUR_PHYSICAL:
 936         case DEVLINK_PORT_FLAVOUR_CPU:
 937         case DEVLINK_PORT_FLAVOUR_DSA:
 938                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER,
 939                                 attrs->phys.port_number))
 940                         return -EMSGSIZE;
 941                 if (!attrs->split)
 942                         return 0;
 943                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP,
 944                                 attrs->phys.port_number))
 945                         return -EMSGSIZE;
 946                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER,
 947                                 attrs->phys.split_subport_number))
 948                         return -EMSGSIZE;
 949                 break;
 950         default:
 951                 break;
 952         }
 953         return 0;
 954 }
 955
 956 static int devlink_port_fn_hw_addr_fill(const struct devlink_ops *ops,
 957                                         struct devlink_port *port,
 958                                         struct sk_buff *msg,
 959                                         struct netlink_ext_ack *extack,
 960                                         bool *msg_updated)
 961 {
 962         u8 hw_addr[MAX_ADDR_LEN];
 963         int hw_addr_len;
 964         int err;
 965
 966         if (!ops->port_function_hw_addr_get)
 967                 return 0;
 968
 969         err = ops->port_function_hw_addr_get(port, hw_addr, &hw_addr_len,
 970                                              extack);
 971         if (err) {
 972                 if (err == -EOPNOTSUPP)
 973                         return 0;
 974                 return err;
 975         }
 976         err = nla_put(msg, DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR, hw_addr_len, hw_addr);
 977         if (err)
 978                 return err;
 979         *msg_updated = true;
 980         return 0;
 981 }
 982
 983 static int devlink_nl_rate_fill(struct sk_buff *msg,
 984                                 struct devlink_rate *devlink_rate,
 985                                 enum devlink_command cmd, u32 portid, u32 seq,
 986                                 int flags, struct netlink_ext_ack *extack)
 987 {
 988         struct devlink *devlink = devlink_rate->devlink;
 989         void *hdr;
 990
 991         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 992         if (!hdr)
 993                 return -EMSGSIZE;
 994
 995         if (devlink_nl_put_handle(msg, devlink))
 996                 goto nla_put_failure;
 997
 998         if (nla_put_u16(msg, DEVLINK_ATTR_RATE_TYPE, devlink_rate->type))
 999                 goto nla_put_failure;
1000
1001         if (devlink_rate_is_leaf(devlink_rate)) {
1002                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
1003                                 devlink_rate->devlink_port->index))
1004                         goto nla_put_failure;
1005         } else if (devlink_rate_is_node(devlink_rate)) {
1006                 if (nla_put_string(msg, DEVLINK_ATTR_RATE_NODE_NAME,
1007                                    devlink_rate->name))
1008                         goto nla_put_failure;
1009         }
1010
1011         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_RATE_TX_SHARE,
1012                               devlink_rate->tx_share, DEVLINK_ATTR_PAD))
1013                 goto nla_put_failure;
1014
1015         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_RATE_TX_MAX,
1016                               devlink_rate->tx_max, DEVLINK_ATTR_PAD))
1017                 goto nla_put_failure;
1018
1019         if (devlink_rate->parent)
1020                 if (nla_put_string(msg, DEVLINK_ATTR_RATE_PARENT_NODE_NAME,
1021                                    devlink_rate->parent->name))
1022                         goto nla_put_failure;
1023
1024         genlmsg_end(msg, hdr);
1025         return 0;
1026
1027 nla_put_failure:
1028         genlmsg_cancel(msg, hdr);
1029         return -EMSGSIZE;
1030 }
1031
1032 static bool
1033 devlink_port_fn_state_valid(enum devlink_port_fn_state state)
1034 {
1035         return state == DEVLINK_PORT_FN_STATE_INACTIVE ||
1036                state == DEVLINK_PORT_FN_STATE_ACTIVE;
1037 }
1038
1039 static bool
1040 devlink_port_fn_opstate_valid(enum devlink_port_fn_opstate opstate)
1041 {
1042         return opstate == DEVLINK_PORT_FN_OPSTATE_DETACHED ||
1043                opstate == DEVLINK_PORT_FN_OPSTATE_ATTACHED;
1044 }
1045
1046 static int devlink_port_fn_state_fill(const struct devlink_ops *ops,
1047                                       struct devlink_port *port,
1048                                       struct sk_buff *msg,
1049                                       struct netlink_ext_ack *extack,
1050                                       bool *msg_updated)
1051 {
1052         enum devlink_port_fn_opstate opstate;
1053         enum devlink_port_fn_state state;
1054         int err;
1055
1056         if (!ops->port_fn_state_get)
1057                 return 0;
1058
1059         err = ops->port_fn_state_get(port, &state, &opstate, extack);
1060         if (err) {
1061                 if (err == -EOPNOTSUPP)
1062                         return 0;
1063                 return err;
1064         }
1065         if (!devlink_port_fn_state_valid(state)) {
1066                 WARN_ON_ONCE(1);
1067                 NL_SET_ERR_MSG_MOD(extack, "Invalid state read from driver");
1068                 return -EINVAL;
1069         }
1070         if (!devlink_port_fn_opstate_valid(opstate)) {
1071                 WARN_ON_ONCE(1);
1072                 NL_SET_ERR_MSG_MOD(extack,
1073                                    "Invalid operational state read from driver");
1074                 return -EINVAL;
1075         }
1076         if (nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_STATE, state) ||
1077             nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_OPSTATE, opstate))
1078                 return -EMSGSIZE;
1079         *msg_updated = true;
1080         return 0;
1081 }
1082
1083 static int
1084 devlink_nl_port_function_attrs_put(struct sk_buff *msg, struct devlink_port *port,
1085                                    struct netlink_ext_ack *extack)
1086 {
1087         const struct devlink_ops *ops;
1088         struct nlattr *function_attr;
1089         bool msg_updated = false;
1090         int err;
1091
1092         function_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PORT_FUNCTION);
1093         if (!function_attr)
1094                 return -EMSGSIZE;
1095
1096         ops = port->devlink->ops;
1097         err = devlink_port_fn_hw_addr_fill(ops, port, msg, extack,
1098                                            &msg_updated);
1099         if (err)
1100                 goto out;
1101         err = devlink_port_fn_state_fill(ops, port, msg, extack, &msg_updated);
1102 out:
1103         if (err || !msg_updated)
1104                 nla_nest_cancel(msg, function_attr);
1105         else
1106                 nla_nest_end(msg, function_attr);
1107         return err;
1108 }
1109
1110 static int devlink_nl_port_fill(struct sk_buff *msg,
1111                                 struct devlink_port *devlink_port,
1112                                 enum devlink_command cmd, u32 portid, u32 seq,
1113                                 int flags, struct netlink_ext_ack *extack)
1114 {
1115         struct devlink *devlink = devlink_port->devlink;
1116         void *hdr;
1117
1118         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1119         if (!hdr)
1120                 return -EMSGSIZE;
1121
1122         if (devlink_nl_put_handle(msg, devlink))
1123                 goto nla_put_failure;
1124         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1125                 goto nla_put_failure;
1126
1127         /* Hold rtnl lock while accessing port's netdev attributes. */
1128         rtnl_lock();
1129         spin_lock_bh(&devlink_port->type_lock);
1130         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
1131                 goto nla_put_failure_type_locked;
1132         if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
1133             nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
1134                         devlink_port->desired_type))
1135                 goto nla_put_failure_type_locked;
1136         if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
1137                 struct net *net = devlink_net(devlink_port->devlink);
1138                 struct net_device *netdev = devlink_port->type_dev;
1139
1140                 if (netdev && net_eq(net, dev_net(netdev)) &&
1141                     (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
1142                                  netdev->ifindex) ||
1143                      nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
1144                                     netdev->name)))
1145                         goto nla_put_failure_type_locked;
1146         }
1147         if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
1148                 struct ib_device *ibdev = devlink_port->type_dev;
1149
1150                 if (ibdev &&
1151                     nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
1152                                    ibdev->name))
1153                         goto nla_put_failure_type_locked;
1154         }
1155         spin_unlock_bh(&devlink_port->type_lock);
1156         rtnl_unlock();
1157         if (devlink_nl_port_attrs_put(msg, devlink_port))
1158                 goto nla_put_failure;
1159         if (devlink_nl_port_function_attrs_put(msg, devlink_port, extack))
1160                 goto nla_put_failure;
1161
1162         genlmsg_end(msg, hdr);
1163         return 0;
1164
1165 nla_put_failure_type_locked:
1166         spin_unlock_bh(&devlink_port->type_lock);
1167         rtnl_unlock();
1168 nla_put_failure:
1169         genlmsg_cancel(msg, hdr);
1170         return -EMSGSIZE;
1171 }
1172
1173 static void devlink_port_notify(struct devlink_port *devlink_port,
1174                                 enum devlink_command cmd)
1175 {
1176         struct devlink *devlink = devlink_port->devlink;
1177         struct sk_buff *msg;
1178         int err;
1179
1180         WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
1181
1182         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
1183                 return;
1184
1185         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1186         if (!msg)
1187                 return;
1188
1189         err = devlink_nl_port_fill(msg, devlink_port, cmd, 0, 0, 0, NULL);
1190         if (err) {
1191                 nlmsg_free(msg);
1192                 return;
1193         }
1194
1195         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink), msg,
1196                                 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
1197 }
1198
1199 static void devlink_rate_notify(struct devlink_rate *devlink_rate,
1200                                 enum devlink_command cmd)
1201 {
1202         struct devlink *devlink = devlink_rate->devlink;
1203         struct sk_buff *msg;
1204         int err;
1205
1206         WARN_ON(cmd != DEVLINK_CMD_RATE_NEW && cmd != DEVLINK_CMD_RATE_DEL);
1207
1208         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
1209                 return;
1210
1211         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1212         if (!msg)
1213                 return;
1214
1215         err = devlink_nl_rate_fill(msg, devlink_rate, cmd, 0, 0, 0, NULL);
1216         if (err) {
1217                 nlmsg_free(msg);
1218                 return;
1219         }
1220
1221         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink), msg,
1222                                 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
1223 }
1224
1225 static int devlink_nl_cmd_rate_get_dumpit(struct sk_buff *msg,
1226                                           struct netlink_callback *cb)
1227 {
1228         struct devlink_rate *devlink_rate;
1229         struct devlink *devlink;
1230         int start = cb->args[0];
1231         unsigned long index;
1232         int idx = 0;
1233         int err = 0;
1234
1235         mutex_lock(&devlink_mutex);
1236         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
1237                 if (!devlink_try_get(devlink))
1238                         continue;
1239
1240                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
1241                         goto retry;
1242
1243                 mutex_lock(&devlink->lock);
1244                 list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
1245                         enum devlink_command cmd = DEVLINK_CMD_RATE_NEW;
1246                         u32 id = NETLINK_CB(cb->skb).portid;
1247
1248                         if (idx < start) {
1249                                 idx++;
1250                                 continue;
1251                         }
1252                         err = devlink_nl_rate_fill(msg, devlink_rate, cmd, id,
1253                                                    cb->nlh->nlmsg_seq,
1254                                                    NLM_F_MULTI, NULL);
1255                         if (err) {
1256                                 mutex_unlock(&devlink->lock);
1257                                 devlink_put(devlink);
1258                                 goto out;
1259                         }
1260                         idx++;
1261                 }
1262                 mutex_unlock(&devlink->lock);
1263 retry:
1264                 devlink_put(devlink);
1265         }
1266 out:
1267         mutex_unlock(&devlink_mutex);
1268         if (err != -EMSGSIZE)
1269                 return err;
1270
1271         cb->args[0] = idx;
1272         return msg->len;
1273 }
1274
1275 static int devlink_nl_cmd_rate_get_doit(struct sk_buff *skb,
1276                                         struct genl_info *info)
1277 {
1278         struct devlink_rate *devlink_rate = info->user_ptr[1];
1279         struct sk_buff *msg;
1280         int err;
1281
1282         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1283         if (!msg)
1284                 return -ENOMEM;
1285
1286         err = devlink_nl_rate_fill(msg, devlink_rate, DEVLINK_CMD_RATE_NEW,
1287                                    info->snd_portid, info->snd_seq, 0,
1288                                    info->extack);
1289         if (err) {
1290                 nlmsg_free(msg);
1291                 return err;
1292         }
1293
1294         return genlmsg_reply(msg, info);
1295 }
1296
1297 static bool
1298 devlink_rate_is_parent_node(struct devlink_rate *devlink_rate,
1299                             struct devlink_rate *parent)
1300 {
1301         while (parent) {
1302                 if (parent == devlink_rate)
1303                         return true;
1304                 parent = parent->parent;
1305         }
1306         return false;
1307 }
1308
1309 static int devlink_nl_cmd_get_doit(struct sk_buff *skb, struct genl_info *info)
1310 {
1311         struct devlink *devlink = info->user_ptr[0];
1312         struct sk_buff *msg;
1313         int err;
1314
1315         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1316         if (!msg)
1317                 return -ENOMEM;
1318
1319         err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
1320                               info->snd_portid, info->snd_seq, 0);
1321         if (err) {
1322                 nlmsg_free(msg);
1323                 return err;
1324         }
1325
1326         return genlmsg_reply(msg, info);
1327 }
1328
1329 static int devlink_nl_cmd_get_dumpit(struct sk_buff *msg,
1330                                      struct netlink_callback *cb)
1331 {
1332         struct devlink *devlink;
1333         int start = cb->args[0];
1334         unsigned long index;
1335         int idx = 0;
1336         int err;
1337
1338         mutex_lock(&devlink_mutex);
1339         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
1340                 if (!devlink_try_get(devlink))
1341                         continue;
1342
1343                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk))) {
1344                         devlink_put(devlink);
1345                         continue;
1346                 }
1347
1348                 if (idx < start) {
1349                         idx++;
1350                         devlink_put(devlink);
1351                         continue;
1352                 }
1353
1354                 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
1355                                       NETLINK_CB(cb->skb).portid,
1356                                       cb->nlh->nlmsg_seq, NLM_F_MULTI);
1357                 devlink_put(devlink);
1358                 if (err)
1359                         goto out;
1360                 idx++;
1361         }
1362 out:
1363         mutex_unlock(&devlink_mutex);
1364
1365         cb->args[0] = idx;
1366         return msg->len;
1367 }
1368
1369 static int devlink_nl_cmd_port_get_doit(struct sk_buff *skb,
1370                                         struct genl_info *info)
1371 {
1372         struct devlink_port *devlink_port = info->user_ptr[1];
1373         struct sk_buff *msg;
1374         int err;
1375
1376         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1377         if (!msg)
1378                 return -ENOMEM;
1379
1380         err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_PORT_NEW,
1381                                    info->snd_portid, info->snd_seq, 0,
1382                                    info->extack);
1383         if (err) {
1384                 nlmsg_free(msg);
1385                 return err;
1386         }
1387
1388         return genlmsg_reply(msg, info);
1389 }
1390
1391 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff *msg,
1392                                           struct netlink_callback *cb)
1393 {
1394         struct devlink *devlink;
1395         struct devlink_port *devlink_port;
1396         int start = cb->args[0];
1397         unsigned long index;
1398         int idx = 0;
1399         int err;
1400
1401         mutex_lock(&devlink_mutex);
1402         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
1403                 if (!devlink_try_get(devlink))
1404                         continue;
1405
1406                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
1407                         goto retry;
1408
1409                 mutex_lock(&devlink->lock);
1410                 list_for_each_entry(devlink_port, &devlink->port_list, list) {
1411                         if (idx < start) {
1412                                 idx++;
1413                                 continue;
1414                         }
1415                         err = devlink_nl_port_fill(msg, devlink_port,
1416                                                    DEVLINK_CMD_NEW,
1417                                                    NETLINK_CB(cb->skb).portid,
1418                                                    cb->nlh->nlmsg_seq,
1419                                                    NLM_F_MULTI, cb->extack);
1420                         if (err) {
1421                                 mutex_unlock(&devlink->lock);
1422                                 devlink_put(devlink);
1423                                 goto out;
1424                         }
1425                         idx++;
1426                 }
1427                 mutex_unlock(&devlink->lock);
1428 retry:
1429                 devlink_put(devlink);
1430         }
1431 out:
1432         mutex_unlock(&devlink_mutex);
1433
1434         cb->args[0] = idx;
1435         return msg->len;
1436 }
1437
1438 static int devlink_port_type_set(struct devlink_port *devlink_port,
1439                                  enum devlink_port_type port_type)
1440
1441 {
1442         int err;
1443
1444         if (!devlink_port->devlink->ops->port_type_set)
1445                 return -EOPNOTSUPP;
1446
1447         if (port_type == devlink_port->type)
1448                 return 0;
1449
1450         err = devlink_port->devlink->ops->port_type_set(devlink_port,
1451                                                         port_type);
1452         if (err)
1453                 return err;
1454
1455         devlink_port->desired_type = port_type;
1456         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
1457         return 0;
1458 }
1459
1460 static int devlink_port_function_hw_addr_set(struct devlink_port *port,
1461                                              const struct nlattr *attr,
1462                                              struct netlink_ext_ack *extack)
1463 {
1464         const struct devlink_ops *ops = port->devlink->ops;
1465         const u8 *hw_addr;
1466         int hw_addr_len;
1467
1468         hw_addr = nla_data(attr);
1469         hw_addr_len = nla_len(attr);
1470         if (hw_addr_len > MAX_ADDR_LEN) {
1471                 NL_SET_ERR_MSG_MOD(extack, "Port function hardware address too long");
1472                 return -EINVAL;
1473         }
1474         if (port->type == DEVLINK_PORT_TYPE_ETH) {
1475                 if (hw_addr_len != ETH_ALEN) {
1476                         NL_SET_ERR_MSG_MOD(extack, "Address must be 6 bytes for Ethernet device");
1477                         return -EINVAL;
1478                 }
1479                 if (!is_unicast_ether_addr(hw_addr)) {
1480                         NL_SET_ERR_MSG_MOD(extack, "Non-unicast hardware address unsupported");
1481                         return -EINVAL;
1482                 }
1483         }
1484
1485         if (!ops->port_function_hw_addr_set) {
1486                 NL_SET_ERR_MSG_MOD(extack, "Port doesn't support function attributes");
1487                 return -EOPNOTSUPP;
1488         }
1489
1490         return ops->port_function_hw_addr_set(port, hw_addr, hw_addr_len,
1491                                               extack);
1492 }
1493
1494 static int devlink_port_fn_state_set(struct devlink_port *port,
1495                                      const struct nlattr *attr,
1496                                      struct netlink_ext_ack *extack)
1497 {
1498         enum devlink_port_fn_state state;
1499         const struct devlink_ops *ops;
1500
1501         state = nla_get_u8(attr);
1502         ops = port->devlink->ops;
1503         if (!ops->port_fn_state_set) {
1504                 NL_SET_ERR_MSG_MOD(extack,
1505                                    "Function does not support state setting");
1506                 return -EOPNOTSUPP;
1507         }
1508         return ops->port_fn_state_set(port, state, extack);
1509 }
1510
1511 static int devlink_port_function_set(struct devlink_port *port,
1512                                      const struct nlattr *attr,
1513                                      struct netlink_ext_ack *extack)
1514 {
1515         struct nlattr *tb[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1];
1516         int err;
1517
1518         err = nla_parse_nested(tb, DEVLINK_PORT_FUNCTION_ATTR_MAX, attr,
1519                                devlink_function_nl_policy, extack);
1520         if (err < 0) {
1521                 NL_SET_ERR_MSG_MOD(extack, "Fail to parse port function attributes");
1522                 return err;
1523         }
1524
1525         attr = tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR];
1526         if (attr) {
1527                 err = devlink_port_function_hw_addr_set(port, attr, extack);
1528                 if (err)
1529                         return err;
1530         }
1531         /* Keep this as the last function attribute set, so that when
1532          * multiple port function attributes are set along with state,
1533          * Those can be applied first before activating the state.
1534          */
1535         attr = tb[DEVLINK_PORT_FN_ATTR_STATE];
1536         if (attr)
1537                 err = devlink_port_fn_state_set(port, attr, extack);
1538
1539         if (!err)
1540                 devlink_port_notify(port, DEVLINK_CMD_PORT_NEW);
1541         return err;
1542 }
1543
1544 static int devlink_nl_cmd_port_set_doit(struct sk_buff *skb,
1545                                         struct genl_info *info)
1546 {
1547         struct devlink_port *devlink_port = info->user_ptr[1];
1548         int err;
1549
1550         if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
1551                 enum devlink_port_type port_type;
1552
1553                 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
1554                 err = devlink_port_type_set(devlink_port, port_type);
1555                 if (err)
1556                         return err;
1557         }
1558
1559         if (info->attrs[DEVLINK_ATTR_PORT_FUNCTION]) {
1560                 struct nlattr *attr = info->attrs[DEVLINK_ATTR_PORT_FUNCTION];
1561                 struct netlink_ext_ack *extack = info->extack;
1562
1563                 err = devlink_port_function_set(devlink_port, attr, extack);
1564                 if (err)
1565                         return err;
1566         }
1567
1568         return 0;
1569 }
1570
1571 static int devlink_nl_cmd_port_split_doit(struct sk_buff *skb,
1572                                           struct genl_info *info)
1573 {
1574         struct devlink_port *devlink_port = info->user_ptr[1];
1575         struct devlink *devlink = info->user_ptr[0];
1576         u32 count;
1577
1578         if (!info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT])
1579                 return -EINVAL;
1580         if (!devlink->ops->port_split)
1581                 return -EOPNOTSUPP;
1582
1583         count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
1584
1585         if (!devlink_port->attrs.splittable) {
1586                 /* Split ports cannot be split. */
1587                 if (devlink_port->attrs.split)
1588                         NL_SET_ERR_MSG_MOD(info->extack, "Port cannot be split further");
1589                 else
1590                         NL_SET_ERR_MSG_MOD(info->extack, "Port cannot be split");
1591                 return -EINVAL;
1592         }
1593
1594         if (count < 2 || !is_power_of_2(count) || count > devlink_port->attrs.lanes) {
1595                 NL_SET_ERR_MSG_MOD(info->extack, "Invalid split count");
1596                 return -EINVAL;
1597         }
1598
1599         return devlink->ops->port_split(devlink, devlink_port, count,
1600                                         info->extack);
1601 }
1602
1603 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
1604                                             struct genl_info *info)
1605 {
1606         struct devlink_port *devlink_port = info->user_ptr[1];
1607         struct devlink *devlink = info->user_ptr[0];
1608
1609         if (!devlink->ops->port_unsplit)
1610                 return -EOPNOTSUPP;
1611         return devlink->ops->port_unsplit(devlink, devlink_port, info->extack);
1612 }
1613
1614 static int devlink_port_new_notifiy(struct devlink *devlink,
1615                                     unsigned int port_index,
1616                                     struct genl_info *info)
1617 {
1618         struct devlink_port *devlink_port;
1619         struct sk_buff *msg;
1620         int err;
1621
1622         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1623         if (!msg)
1624                 return -ENOMEM;
1625
1626         mutex_lock(&devlink->lock);
1627         devlink_port = devlink_port_get_by_index(devlink, port_index);
1628         if (!devlink_port) {
1629                 err = -ENODEV;
1630                 goto out;
1631         }
1632
1633         err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_NEW,
1634                                    info->snd_portid, info->snd_seq, 0, NULL);
1635         if (err)
1636                 goto out;
1637
1638         err = genlmsg_reply(msg, info);
1639         mutex_unlock(&devlink->lock);
1640         return err;
1641
1642 out:
1643         mutex_unlock(&devlink->lock);
1644         nlmsg_free(msg);
1645         return err;
1646 }
1647
1648 static int devlink_nl_cmd_port_new_doit(struct sk_buff *skb,
1649                                         struct genl_info *info)
1650 {
1651         struct netlink_ext_ack *extack = info->extack;
1652         struct devlink_port_new_attrs new_attrs = {};
1653         struct devlink *devlink = info->user_ptr[0];
1654         unsigned int new_port_index;
1655         int err;
1656
1657         if (!devlink->ops->port_new || !devlink->ops->port_del)
1658                 return -EOPNOTSUPP;
1659
1660         if (!info->attrs[DEVLINK_ATTR_PORT_FLAVOUR] ||
1661             !info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]) {
1662                 NL_SET_ERR_MSG_MOD(extack, "Port flavour or PCI PF are not specified");
1663                 return -EINVAL;
1664         }
1665         new_attrs.flavour = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_FLAVOUR]);
1666         new_attrs.pfnum =
1667                 nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]);
1668
1669         if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
1670                 /* Port index of the new port being created by driver. */
1671                 new_attrs.port_index =
1672                         nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
1673                 new_attrs.port_index_valid = true;
1674         }
1675         if (info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]) {
1676                 new_attrs.controller =
1677                         nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]);
1678                 new_attrs.controller_valid = true;
1679         }
1680         if (new_attrs.flavour == DEVLINK_PORT_FLAVOUR_PCI_SF &&
1681             info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]) {
1682                 new_attrs.sfnum = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]);
1683                 new_attrs.sfnum_valid = true;
1684         }
1685
1686         err = devlink->ops->port_new(devlink, &new_attrs, extack,
1687                                      &new_port_index);
1688         if (err)
1689                 return err;
1690
1691         err = devlink_port_new_notifiy(devlink, new_port_index, info);
1692         if (err && err != -ENODEV) {
1693                 /* Fail to send the response; destroy newly created port. */
1694                 devlink->ops->port_del(devlink, new_port_index, extack);
1695         }
1696         return err;
1697 }
1698
1699 static int devlink_nl_cmd_port_del_doit(struct sk_buff *skb,
1700                                         struct genl_info *info)
1701 {
1702         struct netlink_ext_ack *extack = info->extack;
1703         struct devlink *devlink = info->user_ptr[0];
1704         unsigned int port_index;
1705
1706         if (!devlink->ops->port_del)
1707                 return -EOPNOTSUPP;
1708
1709         if (!info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
1710                 NL_SET_ERR_MSG_MOD(extack, "Port index is not specified");
1711                 return -EINVAL;
1712         }
1713         port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
1714
1715         return devlink->ops->port_del(devlink, port_index, extack);
1716 }
1717
1718 static int
1719 devlink_nl_rate_parent_node_set(struct devlink_rate *devlink_rate,
1720                                 struct genl_info *info,
1721                                 struct nlattr *nla_parent)
1722 {
1723         struct devlink *devlink = devlink_rate->devlink;
1724         const char *parent_name = nla_data(nla_parent);
1725         const struct devlink_ops *ops = devlink->ops;
1726         size_t len = strlen(parent_name);
1727         struct devlink_rate *parent;
1728         int err = -EOPNOTSUPP;
1729
1730         parent = devlink_rate->parent;
1731         if (parent && len) {
1732                 NL_SET_ERR_MSG_MOD(info->extack, "Rate object already has parent.");
1733                 return -EBUSY;
1734         } else if (parent && !len) {
1735                 if (devlink_rate_is_leaf(devlink_rate))
1736                         err = ops->rate_leaf_parent_set(devlink_rate, NULL,
1737                                                         devlink_rate->priv, NULL,
1738                                                         info->extack);
1739                 else if (devlink_rate_is_node(devlink_rate))
1740                         err = ops->rate_node_parent_set(devlink_rate, NULL,
1741                                                         devlink_rate->priv, NULL,
1742                                                         info->extack);
1743                 if (err)
1744                         return err;
1745
1746                 refcount_dec(&parent->refcnt);
1747                 devlink_rate->parent = NULL;
1748         } else if (!parent && len) {
1749                 parent = devlink_rate_node_get_by_name(devlink, parent_name);
1750                 if (IS_ERR(parent))
1751                         return -ENODEV;
1752
1753                 if (parent == devlink_rate) {
1754                         NL_SET_ERR_MSG_MOD(info->extack, "Parent to self is not allowed");
1755                         return -EINVAL;
1756                 }
1757
1758                 if (devlink_rate_is_node(devlink_rate) &&
1759                     devlink_rate_is_parent_node(devlink_rate, parent->parent)) {
1760                         NL_SET_ERR_MSG_MOD(info->extack, "Node is already a parent of parent node.");
1761                         return -EEXIST;
1762                 }
1763
1764                 if (devlink_rate_is_leaf(devlink_rate))
1765                         err = ops->rate_leaf_parent_set(devlink_rate, parent,
1766                                                         devlink_rate->priv, parent->priv,
1767                                                         info->extack);
1768                 else if (devlink_rate_is_node(devlink_rate))
1769                         err = ops->rate_node_parent_set(devlink_rate, parent,
1770                                                         devlink_rate->priv, parent->priv,
1771                                                         info->extack);
1772                 if (err)
1773                         return err;
1774
1775                 refcount_inc(&parent->refcnt);
1776                 devlink_rate->parent = parent;
1777         }
1778
1779         return 0;
1780 }
1781
1782 static int devlink_nl_rate_set(struct devlink_rate *devlink_rate,
1783                                const struct devlink_ops *ops,
1784                                struct genl_info *info)
1785 {
1786         struct nlattr *nla_parent, **attrs = info->attrs;
1787         int err = -EOPNOTSUPP;
1788         u64 rate;
1789
1790         if (attrs[DEVLINK_ATTR_RATE_TX_SHARE]) {
1791                 rate = nla_get_u64(attrs[DEVLINK_ATTR_RATE_TX_SHARE]);
1792                 if (devlink_rate_is_leaf(devlink_rate))
1793                         err = ops->rate_leaf_tx_share_set(devlink_rate, devlink_rate->priv,
1794                                                           rate, info->extack);
1795                 else if (devlink_rate_is_node(devlink_rate))
1796                         err = ops->rate_node_tx_share_set(devlink_rate, devlink_rate->priv,
1797                                                           rate, info->extack);
1798                 if (err)
1799                         return err;
1800                 devlink_rate->tx_share = rate;
1801         }
1802
1803         if (attrs[DEVLINK_ATTR_RATE_TX_MAX]) {
1804                 rate = nla_get_u64(attrs[DEVLINK_ATTR_RATE_TX_MAX]);
1805                 if (devlink_rate_is_leaf(devlink_rate))
1806                         err = ops->rate_leaf_tx_max_set(devlink_rate, devlink_rate->priv,
1807                                                         rate, info->extack);
1808                 else if (devlink_rate_is_node(devlink_rate))
1809                         err = ops->rate_node_tx_max_set(devlink_rate, devlink_rate->priv,
1810                                                         rate, info->extack);
1811                 if (err)
1812                         return err;
1813                 devlink_rate->tx_max = rate;
1814         }
1815
1816         nla_parent = attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME];
1817         if (nla_parent) {
1818                 err = devlink_nl_rate_parent_node_set(devlink_rate, info,
1819                                                       nla_parent);
1820                 if (err)
1821                         return err;
1822         }
1823
1824         return 0;
1825 }
1826
1827 static bool devlink_rate_set_ops_supported(const struct devlink_ops *ops,
1828                                            struct genl_info *info,
1829                                            enum devlink_rate_type type)
1830 {
1831         struct nlattr **attrs = info->attrs;
1832
1833         if (type == DEVLINK_RATE_TYPE_LEAF) {
1834                 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE] && !ops->rate_leaf_tx_share_set) {
1835                         NL_SET_ERR_MSG_MOD(info->extack, "TX share set isn't supported for the leafs");
1836                         return false;
1837                 }
1838                 if (attrs[DEVLINK_ATTR_RATE_TX_MAX] && !ops->rate_leaf_tx_max_set) {
1839                         NL_SET_ERR_MSG_MOD(info->extack, "TX max set isn't supported for the leafs");
1840                         return false;
1841                 }
1842                 if (attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] &&
1843                     !ops->rate_leaf_parent_set) {
1844                         NL_SET_ERR_MSG_MOD(info->extack, "Parent set isn't supported for the leafs");
1845                         return false;
1846                 }
1847         } else if (type == DEVLINK_RATE_TYPE_NODE) {
1848                 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE] && !ops->rate_node_tx_share_set) {
1849                         NL_SET_ERR_MSG_MOD(info->extack, "TX share set isn't supported for the nodes");
1850                         return false;
1851                 }
1852                 if (attrs[DEVLINK_ATTR_RATE_TX_MAX] && !ops->rate_node_tx_max_set) {
1853                         NL_SET_ERR_MSG_MOD(info->extack, "TX max set isn't supported for the nodes");
1854                         return false;
1855                 }
1856                 if (attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] &&
1857                     !ops->rate_node_parent_set) {
1858                         NL_SET_ERR_MSG_MOD(info->extack, "Parent set isn't supported for the nodes");
1859                         return false;
1860                 }
1861         } else {
1862                 WARN(1, "Unknown type of rate object");
1863                 return false;
1864         }
1865
1866         return true;
1867 }
1868
1869 static int devlink_nl_cmd_rate_set_doit(struct sk_buff *skb,
1870                                         struct genl_info *info)
1871 {
1872         struct devlink_rate *devlink_rate = info->user_ptr[1];
1873         struct devlink *devlink = devlink_rate->devlink;
1874         const struct devlink_ops *ops = devlink->ops;
1875         int err;
1876
1877         if (!ops || !devlink_rate_set_ops_supported(ops, info, devlink_rate->type))
1878                 return -EOPNOTSUPP;
1879
1880         err = devlink_nl_rate_set(devlink_rate, ops, info);
1881
1882         if (!err)
1883                 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
1884         return err;
1885 }
1886
1887 static int devlink_nl_cmd_rate_new_doit(struct sk_buff *skb,
1888                                         struct genl_info *info)
1889 {
1890         struct devlink *devlink = info->user_ptr[0];
1891         struct devlink_rate *rate_node;
1892         const struct devlink_ops *ops;
1893         int err;
1894
1895         ops = devlink->ops;
1896         if (!ops || !ops->rate_node_new || !ops->rate_node_del) {
1897                 NL_SET_ERR_MSG_MOD(info->extack, "Rate nodes aren't supported");
1898                 return -EOPNOTSUPP;
1899         }
1900
1901         if (!devlink_rate_set_ops_supported(ops, info, DEVLINK_RATE_TYPE_NODE))
1902                 return -EOPNOTSUPP;
1903
1904         rate_node = devlink_rate_node_get_from_attrs(devlink, info->attrs);
1905         if (!IS_ERR(rate_node))
1906                 return -EEXIST;
1907         else if (rate_node == ERR_PTR(-EINVAL))
1908                 return -EINVAL;
1909
1910         rate_node = kzalloc(sizeof(*rate_node), GFP_KERNEL);
1911         if (!rate_node)
1912                 return -ENOMEM;
1913
1914         rate_node->devlink = devlink;
1915         rate_node->type = DEVLINK_RATE_TYPE_NODE;
1916         rate_node->name = nla_strdup(info->attrs[DEVLINK_ATTR_RATE_NODE_NAME], GFP_KERNEL);
1917         if (!rate_node->name) {
1918                 err = -ENOMEM;
1919                 goto err_strdup;
1920         }
1921
1922         err = ops->rate_node_new(rate_node, &rate_node->priv, info->extack);
1923         if (err)
1924                 goto err_node_new;
1925
1926         err = devlink_nl_rate_set(rate_node, ops, info);
1927         if (err)
1928                 goto err_rate_set;
1929
1930         refcount_set(&rate_node->refcnt, 1);
1931         list_add(&rate_node->list, &devlink->rate_list);
1932         devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_NEW);
1933         return 0;
1934
1935 err_rate_set:
1936         ops->rate_node_del(rate_node, rate_node->priv, info->extack);
1937 err_node_new:
1938         kfree(rate_node->name);
1939 err_strdup:
1940         kfree(rate_node);
1941         return err;
1942 }
1943
1944 static int devlink_nl_cmd_rate_del_doit(struct sk_buff *skb,
1945                                         struct genl_info *info)
1946 {
1947         struct devlink_rate *rate_node = info->user_ptr[1];
1948         struct devlink *devlink = rate_node->devlink;
1949         const struct devlink_ops *ops = devlink->ops;
1950         int err;
1951
1952         if (refcount_read(&rate_node->refcnt) > 1) {
1953                 NL_SET_ERR_MSG_MOD(info->extack, "Node has children. Cannot delete node.");
1954                 return -EBUSY;
1955         }
1956
1957         devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_DEL);
1958         err = ops->rate_node_del(rate_node, rate_node->priv, info->extack);
1959         if (rate_node->parent)
1960                 refcount_dec(&rate_node->parent->refcnt);
1961         list_del(&rate_node->list);
1962         kfree(rate_node->name);
1963         kfree(rate_node);
1964         return err;
1965 }
1966
1967 static int devlink_nl_sb_fill(struct sk_buff *msg, struct devlink *devlink,
1968                               struct devlink_sb *devlink_sb,
1969                               enum devlink_command cmd, u32 portid,
1970                               u32 seq, int flags)
1971 {
1972         void *hdr;
1973
1974         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1975         if (!hdr)
1976                 return -EMSGSIZE;
1977
1978         if (devlink_nl_put_handle(msg, devlink))
1979                 goto nla_put_failure;
1980         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1981                 goto nla_put_failure;
1982         if (nla_put_u32(msg, DEVLINK_ATTR_SB_SIZE, devlink_sb->size))
1983                 goto nla_put_failure;
1984         if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT,
1985                         devlink_sb->ingress_pools_count))
1986                 goto nla_put_failure;
1987         if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT,
1988                         devlink_sb->egress_pools_count))
1989                 goto nla_put_failure;
1990         if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_TC_COUNT,
1991                         devlink_sb->ingress_tc_count))
1992                 goto nla_put_failure;
1993         if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_TC_COUNT,
1994                         devlink_sb->egress_tc_count))
1995                 goto nla_put_failure;
1996
1997         genlmsg_end(msg, hdr);
1998         return 0;
1999
2000 nla_put_failure:
2001         genlmsg_cancel(msg, hdr);
2002         return -EMSGSIZE;
2003 }
2004
2005 static int devlink_nl_cmd_sb_get_doit(struct sk_buff *skb,
2006                                       struct genl_info *info)
2007 {
2008         struct devlink *devlink = info->user_ptr[0];
2009         struct devlink_sb *devlink_sb;
2010         struct sk_buff *msg;
2011         int err;
2012
2013         devlink_sb = devlink_sb_get_from_info(devlink, info);
2014         if (IS_ERR(devlink_sb))
2015                 return PTR_ERR(devlink_sb);
2016
2017         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2018         if (!msg)
2019                 return -ENOMEM;
2020
2021         err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
2022                                  DEVLINK_CMD_SB_NEW,
2023                                  info->snd_portid, info->snd_seq, 0);
2024         if (err) {
2025                 nlmsg_free(msg);
2026                 return err;
2027         }
2028
2029         return genlmsg_reply(msg, info);
2030 }
2031
2032 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff *msg,
2033                                         struct netlink_callback *cb)
2034 {
2035         struct devlink *devlink;
2036         struct devlink_sb *devlink_sb;
2037         int start = cb->args[0];
2038         unsigned long index;
2039         int idx = 0;
2040         int err;
2041
2042         mutex_lock(&devlink_mutex);
2043         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
2044                 if (!devlink_try_get(devlink))
2045                         continue;
2046
2047                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
2048                         goto retry;
2049
2050                 mutex_lock(&devlink->lock);
2051                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2052                         if (idx < start) {
2053                                 idx++;
2054                                 continue;
2055                         }
2056                         err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
2057                                                  DEVLINK_CMD_SB_NEW,
2058                                                  NETLINK_CB(cb->skb).portid,
2059                                                  cb->nlh->nlmsg_seq,
2060                                                  NLM_F_MULTI);
2061                         if (err) {
2062                                 mutex_unlock(&devlink->lock);
2063                                 devlink_put(devlink);
2064                                 goto out;
2065                         }
2066                         idx++;
2067                 }
2068                 mutex_unlock(&devlink->lock);
2069 retry:
2070                 devlink_put(devlink);
2071         }
2072 out:
2073         mutex_unlock(&devlink_mutex);
2074
2075         cb->args[0] = idx;
2076         return msg->len;
2077 }
2078
2079 static int devlink_nl_sb_pool_fill(struct sk_buff *msg, struct devlink *devlink,
2080                                    struct devlink_sb *devlink_sb,
2081                                    u16 pool_index, enum devlink_command cmd,
2082                                    u32 portid, u32 seq, int flags)
2083 {
2084         struct devlink_sb_pool_info pool_info;
2085         void *hdr;
2086         int err;
2087
2088         err = devlink->ops->sb_pool_get(devlink, devlink_sb->index,
2089                                         pool_index, &pool_info);
2090         if (err)
2091                 return err;
2092
2093         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2094         if (!hdr)
2095                 return -EMSGSIZE;
2096
2097         if (devlink_nl_put_handle(msg, devlink))
2098                 goto nla_put_failure;
2099         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
2100                 goto nla_put_failure;
2101         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
2102                 goto nla_put_failure;
2103         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_info.pool_type))
2104                 goto nla_put_failure;
2105         if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_SIZE, pool_info.size))
2106                 goto nla_put_failure;
2107         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
2108                        pool_info.threshold_type))
2109                 goto nla_put_failure;
2110         if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_CELL_SIZE,
2111                         pool_info.cell_size))
2112                 goto nla_put_failure;
2113
2114         genlmsg_end(msg, hdr);
2115         return 0;
2116
2117 nla_put_failure:
2118         genlmsg_cancel(msg, hdr);
2119         return -EMSGSIZE;
2120 }
2121
2122 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff *skb,
2123                                            struct genl_info *info)
2124 {
2125         struct devlink *devlink = info->user_ptr[0];
2126         struct devlink_sb *devlink_sb;
2127         struct sk_buff *msg;
2128         u16 pool_index;
2129         int err;
2130
2131         devlink_sb = devlink_sb_get_from_info(devlink, info);
2132         if (IS_ERR(devlink_sb))
2133                 return PTR_ERR(devlink_sb);
2134
2135         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2136                                                   &pool_index);
2137         if (err)
2138                 return err;
2139
2140         if (!devlink->ops->sb_pool_get)
2141                 return -EOPNOTSUPP;
2142
2143         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2144         if (!msg)
2145                 return -ENOMEM;
2146
2147         err = devlink_nl_sb_pool_fill(msg, devlink, devlink_sb, pool_index,
2148                                       DEVLINK_CMD_SB_POOL_NEW,
2149                                       info->snd_portid, info->snd_seq, 0);
2150         if (err) {
2151                 nlmsg_free(msg);
2152                 return err;
2153         }
2154
2155         return genlmsg_reply(msg, info);
2156 }
2157
2158 static int __sb_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
2159                                 struct devlink *devlink,
2160                                 struct devlink_sb *devlink_sb,
2161                                 u32 portid, u32 seq)
2162 {
2163         u16 pool_count = devlink_sb_pool_count(devlink_sb);
2164         u16 pool_index;
2165         int err;
2166
2167         for (pool_index = 0; pool_index < pool_count; pool_index++) {
2168                 if (*p_idx < start) {
2169                         (*p_idx)++;
2170                         continue;
2171                 }
2172                 err = devlink_nl_sb_pool_fill(msg, devlink,
2173                                               devlink_sb,
2174                                               pool_index,
2175                                               DEVLINK_CMD_SB_POOL_NEW,
2176                                               portid, seq, NLM_F_MULTI);
2177                 if (err)
2178                         return err;
2179                 (*p_idx)++;
2180         }
2181         return 0;
2182 }
2183
2184 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff *msg,
2185                                              struct netlink_callback *cb)
2186 {
2187         struct devlink *devlink;
2188         struct devlink_sb *devlink_sb;
2189         int start = cb->args[0];
2190         unsigned long index;
2191         int idx = 0;
2192         int err = 0;
2193
2194         mutex_lock(&devlink_mutex);
2195         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
2196                 if (!devlink_try_get(devlink))
2197                         continue;
2198
2199                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
2200                     !devlink->ops->sb_pool_get)
2201                         goto retry;
2202
2203                 mutex_lock(&devlink->lock);
2204                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2205                         err = __sb_pool_get_dumpit(msg, start, &idx, devlink,
2206                                                    devlink_sb,
2207                                                    NETLINK_CB(cb->skb).portid,
2208                                                    cb->nlh->nlmsg_seq);
2209                         if (err == -EOPNOTSUPP) {
2210                                 err = 0;
2211                         } else if (err) {
2212                                 mutex_unlock(&devlink->lock);
2213                                 devlink_put(devlink);
2214                                 goto out;
2215                         }
2216                 }
2217                 mutex_unlock(&devlink->lock);
2218 retry:
2219                 devlink_put(devlink);
2220         }
2221 out:
2222         mutex_unlock(&devlink_mutex);
2223
2224         if (err != -EMSGSIZE)
2225                 return err;
2226
2227         cb->args[0] = idx;
2228         return msg->len;
2229 }
2230
2231 static int devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
2232                                u16 pool_index, u32 size,
2233                                enum devlink_sb_threshold_type threshold_type,
2234                                struct netlink_ext_ack *extack)
2235
2236 {
2237         const struct devlink_ops *ops = devlink->ops;
2238
2239         if (ops->sb_pool_set)
2240                 return ops->sb_pool_set(devlink, sb_index, pool_index,
2241                                         size, threshold_type, extack);
2242         return -EOPNOTSUPP;
2243 }
2244
2245 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb,
2246                                            struct genl_info *info)
2247 {
2248         struct devlink *devlink = info->user_ptr[0];
2249         enum devlink_sb_threshold_type threshold_type;
2250         struct devlink_sb *devlink_sb;
2251         u16 pool_index;
2252         u32 size;
2253         int err;
2254
2255         devlink_sb = devlink_sb_get_from_info(devlink, info);
2256         if (IS_ERR(devlink_sb))
2257                 return PTR_ERR(devlink_sb);
2258
2259         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2260                                                   &pool_index);
2261         if (err)
2262                 return err;
2263
2264         err = devlink_sb_th_type_get_from_info(info, &threshold_type);
2265         if (err)
2266                 return err;
2267
2268         if (!info->attrs[DEVLINK_ATTR_SB_POOL_SIZE])
2269                 return -EINVAL;
2270
2271         size = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_POOL_SIZE]);
2272         return devlink_sb_pool_set(devlink, devlink_sb->index,
2273                                    pool_index, size, threshold_type,
2274                                    info->extack);
2275 }
2276
2277 static int devlink_nl_sb_port_pool_fill(struct sk_buff *msg,
2278                                         struct devlink *devlink,
2279                                         struct devlink_port *devlink_port,
2280                                         struct devlink_sb *devlink_sb,
2281                                         u16 pool_index,
2282                                         enum devlink_command cmd,
2283                                         u32 portid, u32 seq, int flags)
2284 {
2285         const struct devlink_ops *ops = devlink->ops;
2286         u32 threshold;
2287         void *hdr;
2288         int err;
2289
2290         err = ops->sb_port_pool_get(devlink_port, devlink_sb->index,
2291                                     pool_index, &threshold);
2292         if (err)
2293                 return err;
2294
2295         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2296         if (!hdr)
2297                 return -EMSGSIZE;
2298
2299         if (devlink_nl_put_handle(msg, devlink))
2300                 goto nla_put_failure;
2301         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
2302                 goto nla_put_failure;
2303         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
2304                 goto nla_put_failure;
2305         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
2306                 goto nla_put_failure;
2307         if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
2308                 goto nla_put_failure;
2309
2310         if (ops->sb_occ_port_pool_get) {
2311                 u32 cur;
2312                 u32 max;
2313
2314                 err = ops->sb_occ_port_pool_get(devlink_port, devlink_sb->index,
2315                                                 pool_index, &cur, &max);
2316                 if (err && err != -EOPNOTSUPP)
2317                         goto sb_occ_get_failure;
2318                 if (!err) {
2319                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
2320                                 goto nla_put_failure;
2321                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
2322                                 goto nla_put_failure;
2323                 }
2324         }
2325
2326         genlmsg_end(msg, hdr);
2327         return 0;
2328
2329 nla_put_failure:
2330         err = -EMSGSIZE;
2331 sb_occ_get_failure:
2332         genlmsg_cancel(msg, hdr);
2333         return err;
2334 }
2335
2336 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff *skb,
2337                                                 struct genl_info *info)
2338 {
2339         struct devlink_port *devlink_port = info->user_ptr[1];
2340         struct devlink *devlink = devlink_port->devlink;
2341         struct devlink_sb *devlink_sb;
2342         struct sk_buff *msg;
2343         u16 pool_index;
2344         int err;
2345
2346         devlink_sb = devlink_sb_get_from_info(devlink, info);
2347         if (IS_ERR(devlink_sb))
2348                 return PTR_ERR(devlink_sb);
2349
2350         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2351                                                   &pool_index);
2352         if (err)
2353                 return err;
2354
2355         if (!devlink->ops->sb_port_pool_get)
2356                 return -EOPNOTSUPP;
2357
2358         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2359         if (!msg)
2360                 return -ENOMEM;
2361
2362         err = devlink_nl_sb_port_pool_fill(msg, devlink, devlink_port,
2363                                            devlink_sb, pool_index,
2364                                            DEVLINK_CMD_SB_PORT_POOL_NEW,
2365                                            info->snd_portid, info->snd_seq, 0);
2366         if (err) {
2367                 nlmsg_free(msg);
2368                 return err;
2369         }
2370
2371         return genlmsg_reply(msg, info);
2372 }
2373
2374 static int __sb_port_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
2375                                      struct devlink *devlink,
2376                                      struct devlink_sb *devlink_sb,
2377                                      u32 portid, u32 seq)
2378 {
2379         struct devlink_port *devlink_port;
2380         u16 pool_count = devlink_sb_pool_count(devlink_sb);
2381         u16 pool_index;
2382         int err;
2383
2384         list_for_each_entry(devlink_port, &devlink->port_list, list) {
2385                 for (pool_index = 0; pool_index < pool_count; pool_index++) {
2386                         if (*p_idx < start) {
2387                                 (*p_idx)++;
2388                                 continue;
2389                         }
2390                         err = devlink_nl_sb_port_pool_fill(msg, devlink,
2391                                                            devlink_port,
2392                                                            devlink_sb,
2393                                                            pool_index,
2394                                                            DEVLINK_CMD_SB_PORT_POOL_NEW,
2395                                                            portid, seq,
2396                                                            NLM_F_MULTI);
2397                         if (err)
2398                                 return err;
2399                         (*p_idx)++;
2400                 }
2401         }
2402         return 0;
2403 }
2404
2405 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff *msg,
2406                                                   struct netlink_callback *cb)
2407 {
2408         struct devlink *devlink;
2409         struct devlink_sb *devlink_sb;
2410         int start = cb->args[0];
2411         unsigned long index;
2412         int idx = 0;
2413         int err = 0;
2414
2415         mutex_lock(&devlink_mutex);
2416         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
2417                 if (!devlink_try_get(devlink))
2418                         continue;
2419
2420                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
2421                     !devlink->ops->sb_port_pool_get)
2422                         goto retry;
2423
2424                 mutex_lock(&devlink->lock);
2425                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2426                         err = __sb_port_pool_get_dumpit(msg, start, &idx,
2427                                                         devlink, devlink_sb,
2428                                                         NETLINK_CB(cb->skb).portid,
2429                                                         cb->nlh->nlmsg_seq);
2430                         if (err == -EOPNOTSUPP) {
2431                                 err = 0;
2432                         } else if (err) {
2433                                 mutex_unlock(&devlink->lock);
2434                                 devlink_put(devlink);
2435                                 goto out;
2436                         }
2437                 }
2438                 mutex_unlock(&devlink->lock);
2439 retry:
2440                 devlink_put(devlink);
2441         }
2442 out:
2443         mutex_unlock(&devlink_mutex);
2444
2445         if (err != -EMSGSIZE)
2446                 return err;
2447
2448         cb->args[0] = idx;
2449         return msg->len;
2450 }
2451
2452 static int devlink_sb_port_pool_set(struct devlink_port *devlink_port,
2453                                     unsigned int sb_index, u16 pool_index,
2454                                     u32 threshold,
2455                                     struct netlink_ext_ack *extack)
2456
2457 {
2458         const struct devlink_ops *ops = devlink_port->devlink->ops;
2459
2460         if (ops->sb_port_pool_set)
2461                 return ops->sb_port_pool_set(devlink_port, sb_index,
2462                                              pool_index, threshold, extack);
2463         return -EOPNOTSUPP;
2464 }
2465
2466 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
2467                                                 struct genl_info *info)
2468 {
2469         struct devlink_port *devlink_port = info->user_ptr[1];
2470         struct devlink *devlink = info->user_ptr[0];
2471         struct devlink_sb *devlink_sb;
2472         u16 pool_index;
2473         u32 threshold;
2474         int err;
2475
2476         devlink_sb = devlink_sb_get_from_info(devlink, info);
2477         if (IS_ERR(devlink_sb))
2478                 return PTR_ERR(devlink_sb);
2479
2480         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2481                                                   &pool_index);
2482         if (err)
2483                 return err;
2484
2485         if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
2486                 return -EINVAL;
2487
2488         threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
2489         return devlink_sb_port_pool_set(devlink_port, devlink_sb->index,
2490                                         pool_index, threshold, info->extack);
2491 }
2492
2493 static int
2494 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff *msg, struct devlink *devlink,
2495                                 struct devlink_port *devlink_port,
2496                                 struct devlink_sb *devlink_sb, u16 tc_index,
2497                                 enum devlink_sb_pool_type pool_type,
2498                                 enum devlink_command cmd,
2499                                 u32 portid, u32 seq, int flags)
2500 {
2501         const struct devlink_ops *ops = devlink->ops;
2502         u16 pool_index;
2503         u32 threshold;
2504         void *hdr;
2505         int err;
2506
2507         err = ops->sb_tc_pool_bind_get(devlink_port, devlink_sb->index,
2508                                        tc_index, pool_type,
2509                                        &pool_index, &threshold);
2510         if (err)
2511                 return err;
2512
2513         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2514         if (!hdr)
2515                 return -EMSGSIZE;
2516
2517         if (devlink_nl_put_handle(msg, devlink))
2518                 goto nla_put_failure;
2519         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
2520                 goto nla_put_failure;
2521         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
2522                 goto nla_put_failure;
2523         if (nla_put_u16(msg, DEVLINK_ATTR_SB_TC_INDEX, tc_index))
2524                 goto nla_put_failure;
2525         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_type))
2526                 goto nla_put_failure;
2527         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
2528                 goto nla_put_failure;
2529         if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
2530                 goto nla_put_failure;
2531
2532         if (ops->sb_occ_tc_port_bind_get) {
2533                 u32 cur;
2534                 u32 max;
2535
2536                 err = ops->sb_occ_tc_port_bind_get(devlink_port,
2537                                                    devlink_sb->index,
2538                                                    tc_index, pool_type,
2539                                                    &cur, &max);
2540                 if (err && err != -EOPNOTSUPP)
2541                         return err;
2542                 if (!err) {
2543                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
2544                                 goto nla_put_failure;
2545                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
2546                                 goto nla_put_failure;
2547                 }
2548         }
2549
2550         genlmsg_end(msg, hdr);
2551         return 0;
2552
2553 nla_put_failure:
2554         genlmsg_cancel(msg, hdr);
2555         return -EMSGSIZE;
2556 }
2557
2558 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
2559                                                    struct genl_info *info)
2560 {
2561         struct devlink_port *devlink_port = info->user_ptr[1];
2562         struct devlink *devlink = devlink_port->devlink;
2563         struct devlink_sb *devlink_sb;
2564         struct sk_buff *msg;
2565         enum devlink_sb_pool_type pool_type;
2566         u16 tc_index;
2567         int err;
2568
2569         devlink_sb = devlink_sb_get_from_info(devlink, info);
2570         if (IS_ERR(devlink_sb))
2571                 return PTR_ERR(devlink_sb);
2572
2573         err = devlink_sb_pool_type_get_from_info(info, &pool_type);
2574         if (err)
2575                 return err;
2576
2577         err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
2578                                                 pool_type, &tc_index);
2579         if (err)
2580                 return err;
2581
2582         if (!devlink->ops->sb_tc_pool_bind_get)
2583                 return -EOPNOTSUPP;
2584
2585         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2586         if (!msg)
2587                 return -ENOMEM;
2588
2589         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink, devlink_port,
2590                                               devlink_sb, tc_index, pool_type,
2591                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
2592                                               info->snd_portid,
2593                                               info->snd_seq, 0);
2594         if (err) {
2595                 nlmsg_free(msg);
2596                 return err;
2597         }
2598
2599         return genlmsg_reply(msg, info);
2600 }
2601
2602 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
2603                                         int start, int *p_idx,
2604                                         struct devlink *devlink,
2605                                         struct devlink_sb *devlink_sb,
2606                                         u32 portid, u32 seq)
2607 {
2608         struct devlink_port *devlink_port;
2609         u16 tc_index;
2610         int err;
2611
2612         list_for_each_entry(devlink_port, &devlink->port_list, list) {
2613                 for (tc_index = 0;
2614                      tc_index < devlink_sb->ingress_tc_count; tc_index++) {
2615                         if (*p_idx < start) {
2616                                 (*p_idx)++;
2617                                 continue;
2618                         }
2619                         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
2620                                                               devlink_port,
2621                                                               devlink_sb,
2622                                                               tc_index,
2623                                                               DEVLINK_SB_POOL_TYPE_INGRESS,
2624                                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
2625                                                               portid, seq,
2626                                                               NLM_F_MULTI);
2627                         if (err)
2628                                 return err;
2629                         (*p_idx)++;
2630                 }
2631                 for (tc_index = 0;
2632                      tc_index < devlink_sb->egress_tc_count; tc_index++) {
2633                         if (*p_idx < start) {
2634                                 (*p_idx)++;
2635                                 continue;
2636                         }
2637                         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
2638                                                               devlink_port,
2639                                                               devlink_sb,
2640                                                               tc_index,
2641                                                               DEVLINK_SB_POOL_TYPE_EGRESS,
2642                                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
2643                                                               portid, seq,
2644                                                               NLM_F_MULTI);
2645                         if (err)
2646                                 return err;
2647                         (*p_idx)++;
2648                 }
2649         }
2650         return 0;
2651 }
2652
2653 static int
2654 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
2655                                           struct netlink_callback *cb)
2656 {
2657         struct devlink *devlink;
2658         struct devlink_sb *devlink_sb;
2659         int start = cb->args[0];
2660         unsigned long index;
2661         int idx = 0;
2662         int err = 0;
2663
2664         mutex_lock(&devlink_mutex);
2665         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
2666                 if (!devlink_try_get(devlink))
2667                         continue;
2668
2669                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
2670                     !devlink->ops->sb_tc_pool_bind_get)
2671                         goto retry;
2672
2673                 mutex_lock(&devlink->lock);
2674                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2675                         err = __sb_tc_pool_bind_get_dumpit(msg, start, &idx,
2676                                                            devlink,
2677                                                            devlink_sb,
2678                                                            NETLINK_CB(cb->skb).portid,
2679                                                            cb->nlh->nlmsg_seq);
2680                         if (err == -EOPNOTSUPP) {
2681                                 err = 0;
2682                         } else if (err) {
2683                                 mutex_unlock(&devlink->lock);
2684                                 devlink_put(devlink);
2685                                 goto out;
2686                         }
2687                 }
2688                 mutex_unlock(&devlink->lock);
2689 retry:
2690                 devlink_put(devlink);
2691         }
2692 out:
2693         mutex_unlock(&devlink_mutex);
2694
2695         if (err != -EMSGSIZE)
2696                 return err;
2697
2698         cb->args[0] = idx;
2699         return msg->len;
2700 }
2701
2702 static int devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
2703                                        unsigned int sb_index, u16 tc_index,
2704                                        enum devlink_sb_pool_type pool_type,
2705                                        u16 pool_index, u32 threshold,
2706                                        struct netlink_ext_ack *extack)
2707
2708 {
2709         const struct devlink_ops *ops = devlink_port->devlink->ops;
2710
2711         if (ops->sb_tc_pool_bind_set)
2712                 return ops->sb_tc_pool_bind_set(devlink_port, sb_index,
2713                                                 tc_index, pool_type,
2714                                                 pool_index, threshold, extack);
2715         return -EOPNOTSUPP;
2716 }
2717
2718 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
2719                                                    struct genl_info *info)
2720 {
2721         struct devlink_port *devlink_port = info->user_ptr[1];
2722         struct devlink *devlink = info->user_ptr[0];
2723         enum devlink_sb_pool_type pool_type;
2724         struct devlink_sb *devlink_sb;
2725         u16 tc_index;
2726         u16 pool_index;
2727         u32 threshold;
2728         int err;
2729
2730         devlink_sb = devlink_sb_get_from_info(devlink, info);
2731         if (IS_ERR(devlink_sb))
2732                 return PTR_ERR(devlink_sb);
2733
2734         err = devlink_sb_pool_type_get_from_info(info, &pool_type);
2735         if (err)
2736                 return err;
2737
2738         err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
2739                                                 pool_type, &tc_index);
2740         if (err)
2741                 return err;
2742
2743         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2744                                                   &pool_index);
2745         if (err)
2746                 return err;
2747
2748         if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
2749                 return -EINVAL;
2750
2751         threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
2752         return devlink_sb_tc_pool_bind_set(devlink_port, devlink_sb->index,
2753                                            tc_index, pool_type,
2754                                            pool_index, threshold, info->extack);
2755 }
2756
2757 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
2758                                                struct genl_info *info)
2759 {
2760         struct devlink *devlink = info->user_ptr[0];
2761         const struct devlink_ops *ops = devlink->ops;
2762         struct devlink_sb *devlink_sb;
2763
2764         devlink_sb = devlink_sb_get_from_info(devlink, info);
2765         if (IS_ERR(devlink_sb))
2766                 return PTR_ERR(devlink_sb);
2767
2768         if (ops->sb_occ_snapshot)
2769                 return ops->sb_occ_snapshot(devlink, devlink_sb->index);
2770         return -EOPNOTSUPP;
2771 }
2772
2773 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
2774                                                 struct genl_info *info)
2775 {
2776         struct devlink *devlink = info->user_ptr[0];
2777         const struct devlink_ops *ops = devlink->ops;
2778         struct devlink_sb *devlink_sb;
2779
2780         devlink_sb = devlink_sb_get_from_info(devlink, info);
2781         if (IS_ERR(devlink_sb))
2782                 return PTR_ERR(devlink_sb);
2783
2784         if (ops->sb_occ_max_clear)
2785                 return ops->sb_occ_max_clear(devlink, devlink_sb->index);
2786         return -EOPNOTSUPP;
2787 }
2788
2789 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
2790                                    enum devlink_command cmd, u32 portid,
2791                                    u32 seq, int flags)
2792 {
2793         const struct devlink_ops *ops = devlink->ops;
2794         enum devlink_eswitch_encap_mode encap_mode;
2795         u8 inline_mode;
2796         void *hdr;
2797         int err = 0;
2798         u16 mode;
2799
2800         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2801         if (!hdr)
2802                 return -EMSGSIZE;
2803
2804         err = devlink_nl_put_handle(msg, devlink);
2805         if (err)
2806                 goto nla_put_failure;
2807
2808         if (ops->eswitch_mode_get) {
2809                 err = ops->eswitch_mode_get(devlink, &mode);
2810                 if (err)
2811                         goto nla_put_failure;
2812                 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
2813                 if (err)
2814                         goto nla_put_failure;
2815         }
2816
2817         if (ops->eswitch_inline_mode_get) {
2818                 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
2819                 if (err)
2820                         goto nla_put_failure;
2821                 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
2822                                  inline_mode);
2823                 if (err)
2824                         goto nla_put_failure;
2825         }
2826
2827         if (ops->eswitch_encap_mode_get) {
2828                 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
2829                 if (err)
2830                         goto nla_put_failure;
2831                 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
2832                 if (err)
2833                         goto nla_put_failure;
2834         }
2835
2836         genlmsg_end(msg, hdr);
2837         return 0;
2838
2839 nla_put_failure:
2840         genlmsg_cancel(msg, hdr);
2841         return err;
2842 }
2843
2844 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb,
2845                                            struct genl_info *info)
2846 {
2847         struct devlink *devlink = info->user_ptr[0];
2848         struct sk_buff *msg;
2849         int err;
2850
2851         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2852         if (!msg)
2853                 return -ENOMEM;
2854
2855         err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
2856                                       info->snd_portid, info->snd_seq, 0);
2857
2858         if (err) {
2859                 nlmsg_free(msg);
2860                 return err;
2861         }
2862
2863         return genlmsg_reply(msg, info);
2864 }
2865
2866 static int devlink_rate_nodes_check(struct devlink *devlink, u16 mode,
2867                                     struct netlink_ext_ack *extack)
2868 {
2869         struct devlink_rate *devlink_rate;
2870
2871         list_for_each_entry(devlink_rate, &devlink->rate_list, list)
2872                 if (devlink_rate_is_node(devlink_rate)) {
2873                         NL_SET_ERR_MSG_MOD(extack, "Rate node(s) exists.");
2874                         return -EBUSY;
2875                 }
2876         return 0;
2877 }
2878
2879 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
2880                                            struct genl_info *info)
2881 {
2882         struct devlink *devlink = info->user_ptr[0];
2883         const struct devlink_ops *ops = devlink->ops;
2884         enum devlink_eswitch_encap_mode encap_mode;
2885         u8 inline_mode;
2886         int err = 0;
2887         u16 mode;
2888
2889         if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
2890                 if (!ops->eswitch_mode_set)
2891                         return -EOPNOTSUPP;
2892                 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
2893                 err = devlink_rate_nodes_check(devlink, mode, info->extack);
2894                 if (err)
2895                         return err;
2896                 err = ops->eswitch_mode_set(devlink, mode, info->extack);
2897                 if (err)
2898                         return err;
2899         }
2900
2901         if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
2902                 if (!ops->eswitch_inline_mode_set)
2903                         return -EOPNOTSUPP;
2904                 inline_mode = nla_get_u8(
2905                                 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
2906                 err = ops->eswitch_inline_mode_set(devlink, inline_mode,
2907                                                    info->extack);
2908                 if (err)
2909                         return err;
2910         }
2911
2912         if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
2913                 if (!ops->eswitch_encap_mode_set)
2914                         return -EOPNOTSUPP;
2915                 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
2916                 err = ops->eswitch_encap_mode_set(devlink, encap_mode,
2917                                                   info->extack);
2918                 if (err)
2919                         return err;
2920         }
2921
2922         return 0;
2923 }
2924
2925 int devlink_dpipe_match_put(struct sk_buff *skb,
2926                             struct devlink_dpipe_match *match)
2927 {
2928         struct devlink_dpipe_header *header = match->header;
2929         struct devlink_dpipe_field *field = &header->fields[match->field_id];
2930         struct nlattr *match_attr;
2931
2932         match_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_MATCH);
2933         if (!match_attr)
2934                 return -EMSGSIZE;
2935
2936         if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
2937             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
2938             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2939             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2940             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2941                 goto nla_put_failure;
2942
2943         nla_nest_end(skb, match_attr);
2944         return 0;
2945
2946 nla_put_failure:
2947         nla_nest_cancel(skb, match_attr);
2948         return -EMSGSIZE;
2949 }
2950 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
2951
2952 static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
2953                                      struct sk_buff *skb)
2954 {
2955         struct nlattr *matches_attr;
2956
2957         matches_attr = nla_nest_start_noflag(skb,
2958                                              DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
2959         if (!matches_attr)
2960                 return -EMSGSIZE;
2961
2962         if (table->table_ops->matches_dump(table->priv, skb))
2963                 goto nla_put_failure;
2964
2965         nla_nest_end(skb, matches_attr);
2966         return 0;
2967
2968 nla_put_failure:
2969         nla_nest_cancel(skb, matches_attr);
2970         return -EMSGSIZE;
2971 }
2972
2973 int devlink_dpipe_action_put(struct sk_buff *skb,
2974                              struct devlink_dpipe_action *action)
2975 {
2976         struct devlink_dpipe_header *header = action->header;
2977         struct devlink_dpipe_field *field = &header->fields[action->field_id];
2978         struct nlattr *action_attr;
2979
2980         action_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ACTION);
2981         if (!action_attr)
2982                 return -EMSGSIZE;
2983
2984         if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
2985             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
2986             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2987             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2988             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2989                 goto nla_put_failure;
2990
2991         nla_nest_end(skb, action_attr);
2992         return 0;
2993
2994 nla_put_failure:
2995         nla_nest_cancel(skb, action_attr);
2996         return -EMSGSIZE;
2997 }
2998 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
2999
3000 static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
3001                                      struct sk_buff *skb)
3002 {
3003         struct nlattr *actions_attr;
3004
3005         actions_attr = nla_nest_start_noflag(skb,
3006                                              DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
3007         if (!actions_attr)
3008                 return -EMSGSIZE;
3009
3010         if (table->table_ops->actions_dump(table->priv, skb))
3011                 goto nla_put_failure;
3012
3013         nla_nest_end(skb, actions_attr);
3014         return 0;
3015
3016 nla_put_failure:
3017         nla_nest_cancel(skb, actions_attr);
3018         return -EMSGSIZE;
3019 }
3020
3021 static int devlink_dpipe_table_put(struct sk_buff *skb,
3022                                    struct devlink_dpipe_table *table)
3023 {
3024         struct nlattr *table_attr;
3025         u64 table_size;
3026
3027         table_size = table->table_ops->size_get(table->priv);
3028         table_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLE);
3029         if (!table_attr)
3030                 return -EMSGSIZE;
3031
3032         if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
3033             nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
3034                               DEVLINK_ATTR_PAD))
3035                 goto nla_put_failure;
3036         if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
3037                        table->counters_enabled))
3038                 goto nla_put_failure;
3039
3040         if (table->resource_valid) {
3041                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
3042                                       table->resource_id, DEVLINK_ATTR_PAD) ||
3043                     nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
3044                                       table->resource_units, DEVLINK_ATTR_PAD))
3045                         goto nla_put_failure;
3046         }
3047         if (devlink_dpipe_matches_put(table, skb))
3048                 goto nla_put_failure;
3049
3050         if (devlink_dpipe_actions_put(table, skb))
3051                 goto nla_put_failure;
3052
3053         nla_nest_end(skb, table_attr);
3054         return 0;
3055
3056 nla_put_failure:
3057         nla_nest_cancel(skb, table_attr);
3058         return -EMSGSIZE;
3059 }
3060
3061 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
3062                                             struct genl_info *info)
3063 {
3064         int err;
3065
3066         if (*pskb) {
3067                 err = genlmsg_reply(*pskb, info);
3068                 if (err)
3069                         return err;
3070         }
3071         *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
3072         if (!*pskb)
3073                 return -ENOMEM;
3074         return 0;
3075 }
3076
3077 static int devlink_dpipe_tables_fill(struct genl_info *info,
3078                                      enum devlink_command cmd, int flags,
3079                                      struct list_head *dpipe_tables,
3080                                      const char *table_name)
3081 {
3082         struct devlink *devlink = info->user_ptr[0];
3083         struct devlink_dpipe_table *table;
3084         struct nlattr *tables_attr;
3085         struct sk_buff *skb = NULL;
3086         struct nlmsghdr *nlh;
3087         bool incomplete;
3088         void *hdr;
3089         int i;
3090         int err;
3091
3092         table = list_first_entry(dpipe_tables,
3093                                  struct devlink_dpipe_table, list);
3094 start_again:
3095         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3096         if (err)
3097                 return err;
3098
3099         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3100                           &devlink_nl_family, NLM_F_MULTI, cmd);
3101         if (!hdr) {
3102                 nlmsg_free(skb);
3103                 return -EMSGSIZE;
3104         }
3105
3106         if (devlink_nl_put_handle(skb, devlink))
3107                 goto nla_put_failure;
3108         tables_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLES);
3109         if (!tables_attr)
3110                 goto nla_put_failure;
3111
3112         i = 0;
3113         incomplete = false;
3114         list_for_each_entry_from(table, dpipe_tables, list) {
3115                 if (!table_name) {
3116                         err = devlink_dpipe_table_put(skb, table);
3117                         if (err) {
3118                                 if (!i)
3119                                         goto err_table_put;
3120                                 incomplete = true;
3121                                 break;
3122                         }
3123                 } else {
3124                         if (!strcmp(table->name, table_name)) {
3125                                 err = devlink_dpipe_table_put(skb, table);
3126                                 if (err)
3127                                         break;
3128                         }
3129                 }
3130                 i++;
3131         }
3132
3133         nla_nest_end(skb, tables_attr);
3134         genlmsg_end(skb, hdr);
3135         if (incomplete)
3136                 goto start_again;
3137
3138 send_done:
3139         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3140                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
3141         if (!nlh) {
3142                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3143                 if (err)
3144                         return err;
3145                 goto send_done;
3146         }
3147
3148         return genlmsg_reply(skb, info);
3149
3150 nla_put_failure:
3151         err = -EMSGSIZE;
3152 err_table_put:
3153         nlmsg_free(skb);
3154         return err;
3155 }
3156
3157 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
3158                                           struct genl_info *info)
3159 {
3160         struct devlink *devlink = info->user_ptr[0];
3161         const char *table_name =  NULL;
3162
3163         if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
3164                 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3165
3166         return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
3167                                          &devlink->dpipe_table_list,
3168                                          table_name);
3169 }
3170
3171 static int devlink_dpipe_value_put(struct sk_buff *skb,
3172                                    struct devlink_dpipe_value *value)
3173 {
3174         if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
3175                     value->value_size, value->value))
3176                 return -EMSGSIZE;
3177         if (value->mask)
3178                 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
3179                             value->value_size, value->mask))
3180                         return -EMSGSIZE;
3181         if (value->mapping_valid)
3182                 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
3183                                 value->mapping_value))
3184                         return -EMSGSIZE;
3185         return 0;
3186 }
3187
3188 static int devlink_dpipe_action_value_put(struct sk_buff *skb,
3189                                           struct devlink_dpipe_value *value)
3190 {
3191         if (!value->action)
3192                 return -EINVAL;
3193         if (devlink_dpipe_action_put(skb, value->action))
3194                 return -EMSGSIZE;
3195         if (devlink_dpipe_value_put(skb, value))
3196                 return -EMSGSIZE;
3197         return 0;
3198 }
3199
3200 static int devlink_dpipe_action_values_put(struct sk_buff *skb,
3201                                            struct devlink_dpipe_value *values,
3202                                            unsigned int values_count)
3203 {
3204         struct nlattr *action_attr;
3205         int i;
3206         int err;
3207
3208         for (i = 0; i < values_count; i++) {
3209                 action_attr = nla_nest_start_noflag(skb,
3210                                                     DEVLINK_ATTR_DPIPE_ACTION_VALUE);
3211                 if (!action_attr)
3212                         return -EMSGSIZE;
3213                 err = devlink_dpipe_action_value_put(skb, &values[i]);
3214                 if (err)
3215                         goto err_action_value_put;
3216                 nla_nest_end(skb, action_attr);
3217         }
3218         return 0;
3219
3220 err_action_value_put:
3221         nla_nest_cancel(skb, action_attr);
3222         return err;
3223 }
3224
3225 static int devlink_dpipe_match_value_put(struct sk_buff *skb,
3226                                          struct devlink_dpipe_value *value)
3227 {
3228         if (!value->match)
3229                 return -EINVAL;
3230         if (devlink_dpipe_match_put(skb, value->match))
3231                 return -EMSGSIZE;
3232         if (devlink_dpipe_value_put(skb, value))
3233                 return -EMSGSIZE;
3234         return 0;
3235 }
3236
3237 static int devlink_dpipe_match_values_put(struct sk_buff *skb,
3238                                           struct devlink_dpipe_value *values,
3239                                           unsigned int values_count)
3240 {
3241         struct nlattr *match_attr;
3242         int i;
3243         int err;
3244
3245         for (i = 0; i < values_count; i++) {
3246                 match_attr = nla_nest_start_noflag(skb,
3247                                                    DEVLINK_ATTR_DPIPE_MATCH_VALUE);
3248                 if (!match_attr)
3249                         return -EMSGSIZE;
3250                 err = devlink_dpipe_match_value_put(skb, &values[i]);
3251                 if (err)
3252                         goto err_match_value_put;
3253                 nla_nest_end(skb, match_attr);
3254         }
3255         return 0;
3256
3257 err_match_value_put:
3258         nla_nest_cancel(skb, match_attr);
3259         return err;
3260 }
3261
3262 static int devlink_dpipe_entry_put(struct sk_buff *skb,
3263                                    struct devlink_dpipe_entry *entry)
3264 {
3265         struct nlattr *entry_attr, *matches_attr, *actions_attr;
3266         int err;
3267
3268         entry_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ENTRY);
3269         if (!entry_attr)
3270                 return  -EMSGSIZE;
3271
3272         if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
3273                               DEVLINK_ATTR_PAD))
3274                 goto nla_put_failure;
3275         if (entry->counter_valid)
3276                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
3277                                       entry->counter, DEVLINK_ATTR_PAD))
3278                         goto nla_put_failure;
3279
3280         matches_attr = nla_nest_start_noflag(skb,
3281                                              DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
3282         if (!matches_attr)
3283                 goto nla_put_failure;
3284
3285         err = devlink_dpipe_match_values_put(skb, entry->match_values,
3286                                              entry->match_values_count);
3287         if (err) {
3288                 nla_nest_cancel(skb, matches_attr);
3289                 goto err_match_values_put;
3290         }
3291         nla_nest_end(skb, matches_attr);
3292
3293         actions_attr = nla_nest_start_noflag(skb,
3294                                              DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
3295         if (!actions_attr)
3296                 goto nla_put_failure;
3297
3298         err = devlink_dpipe_action_values_put(skb, entry->action_values,
3299                                               entry->action_values_count);
3300         if (err) {
3301                 nla_nest_cancel(skb, actions_attr);
3302                 goto err_action_values_put;
3303         }
3304         nla_nest_end(skb, actions_attr);
3305
3306         nla_nest_end(skb, entry_attr);
3307         return 0;
3308
3309 nla_put_failure:
3310         err = -EMSGSIZE;
3311 err_match_values_put:
3312 err_action_values_put:
3313         nla_nest_cancel(skb, entry_attr);
3314         return err;
3315 }
3316
3317 static struct devlink_dpipe_table *
3318 devlink_dpipe_table_find(struct list_head *dpipe_tables,
3319                          const char *table_name, struct devlink *devlink)
3320 {
3321         struct devlink_dpipe_table *table;
3322         list_for_each_entry_rcu(table, dpipe_tables, list,
3323                                 lockdep_is_held(&devlink->lock)) {
3324                 if (!strcmp(table->name, table_name))
3325                         return table;
3326         }
3327         return NULL;
3328 }
3329
3330 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
3331 {
3332         struct devlink *devlink;
3333         int err;
3334
3335         err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
3336                                                dump_ctx->info);
3337         if (err)
3338                 return err;
3339
3340         dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
3341                                     dump_ctx->info->snd_portid,
3342                                     dump_ctx->info->snd_seq,
3343                                     &devlink_nl_family, NLM_F_MULTI,
3344                                     dump_ctx->cmd);
3345         if (!dump_ctx->hdr)
3346                 goto nla_put_failure;
3347
3348         devlink = dump_ctx->info->user_ptr[0];
3349         if (devlink_nl_put_handle(dump_ctx->skb, devlink))
3350                 goto nla_put_failure;
3351         dump_ctx->nest = nla_nest_start_noflag(dump_ctx->skb,
3352                                                DEVLINK_ATTR_DPIPE_ENTRIES);
3353         if (!dump_ctx->nest)
3354                 goto nla_put_failure;
3355         return 0;
3356
3357 nla_put_failure:
3358         nlmsg_free(dump_ctx->skb);
3359         return -EMSGSIZE;
3360 }
3361 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
3362
3363 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
3364                                    struct devlink_dpipe_entry *entry)
3365 {
3366         return devlink_dpipe_entry_put(dump_ctx->skb, entry);
3367 }
3368 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
3369
3370 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
3371 {
3372         nla_nest_end(dump_ctx->skb, dump_ctx->nest);
3373         genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
3374         return 0;
3375 }
3376 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
3377
3378 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
3379
3380 {
3381         unsigned int value_count, value_index;
3382         struct devlink_dpipe_value *value;
3383
3384         value = entry->action_values;
3385         value_count = entry->action_values_count;
3386         for (value_index = 0; value_index < value_count; value_index++) {
3387                 kfree(value[value_index].value);
3388                 kfree(value[value_index].mask);
3389         }
3390
3391         value = entry->match_values;
3392         value_count = entry->match_values_count;
3393         for (value_index = 0; value_index < value_count; value_index++) {
3394                 kfree(value[value_index].value);
3395                 kfree(value[value_index].mask);
3396         }
3397 }
3398 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_clear);
3399
3400 static int devlink_dpipe_entries_fill(struct genl_info *info,
3401                                       enum devlink_command cmd, int flags,
3402                                       struct devlink_dpipe_table *table)
3403 {
3404         struct devlink_dpipe_dump_ctx dump_ctx;
3405         struct nlmsghdr *nlh;
3406         int err;
3407
3408         dump_ctx.skb = NULL;
3409         dump_ctx.cmd = cmd;
3410         dump_ctx.info = info;
3411
3412         err = table->table_ops->entries_dump(table->priv,
3413                                              table->counters_enabled,
3414                                              &dump_ctx);
3415         if (err)
3416                 return err;
3417
3418 send_done:
3419         nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
3420                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
3421         if (!nlh) {
3422                 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
3423                 if (err)
3424                         return err;
3425                 goto send_done;
3426         }
3427         return genlmsg_reply(dump_ctx.skb, info);
3428 }
3429
3430 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
3431                                             struct genl_info *info)
3432 {
3433         struct devlink *devlink = info->user_ptr[0];
3434         struct devlink_dpipe_table *table;
3435         const char *table_name;
3436
3437         if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
3438                 return -EINVAL;
3439
3440         table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3441         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3442                                          table_name, devlink);
3443         if (!table)
3444                 return -EINVAL;
3445
3446         if (!table->table_ops->entries_dump)
3447                 return -EINVAL;
3448
3449         return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
3450                                           0, table);
3451 }
3452
3453 static int devlink_dpipe_fields_put(struct sk_buff *skb,
3454                                     const struct devlink_dpipe_header *header)
3455 {
3456         struct devlink_dpipe_field *field;
3457         struct nlattr *field_attr;
3458         int i;
3459
3460         for (i = 0; i < header->fields_count; i++) {
3461                 field = &header->fields[i];
3462                 field_attr = nla_nest_start_noflag(skb,
3463                                                    DEVLINK_ATTR_DPIPE_FIELD);
3464                 if (!field_attr)
3465                         return -EMSGSIZE;
3466                 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
3467                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
3468                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
3469                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
3470                         goto nla_put_failure;
3471                 nla_nest_end(skb, field_attr);
3472         }
3473         return 0;
3474
3475 nla_put_failure:
3476         nla_nest_cancel(skb, field_attr);
3477         return -EMSGSIZE;
3478 }
3479
3480 static int devlink_dpipe_header_put(struct sk_buff *skb,
3481                                     struct devlink_dpipe_header *header)
3482 {
3483         struct nlattr *fields_attr, *header_attr;
3484         int err;
3485
3486         header_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADER);
3487         if (!header_attr)
3488                 return -EMSGSIZE;
3489
3490         if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
3491             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
3492             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
3493                 goto nla_put_failure;
3494
3495         fields_attr = nla_nest_start_noflag(skb,
3496                                             DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
3497         if (!fields_attr)
3498                 goto nla_put_failure;
3499
3500         err = devlink_dpipe_fields_put(skb, header);
3501         if (err) {
3502                 nla_nest_cancel(skb, fields_attr);
3503                 goto nla_put_failure;
3504         }
3505         nla_nest_end(skb, fields_attr);
3506         nla_nest_end(skb, header_attr);
3507         return 0;
3508
3509 nla_put_failure:
3510         err = -EMSGSIZE;
3511         nla_nest_cancel(skb, header_attr);
3512         return err;
3513 }
3514
3515 static int devlink_dpipe_headers_fill(struct genl_info *info,
3516                                       enum devlink_command cmd, int flags,
3517                                       struct devlink_dpipe_headers *
3518                                       dpipe_headers)
3519 {
3520         struct devlink *devlink = info->user_ptr[0];
3521         struct nlattr *headers_attr;
3522         struct sk_buff *skb = NULL;
3523         struct nlmsghdr *nlh;
3524         void *hdr;
3525         int i, j;
3526         int err;
3527
3528         i = 0;
3529 start_again:
3530         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3531         if (err)
3532                 return err;
3533
3534         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3535                           &devlink_nl_family, NLM_F_MULTI, cmd);
3536         if (!hdr) {
3537                 nlmsg_free(skb);
3538                 return -EMSGSIZE;
3539         }
3540
3541         if (devlink_nl_put_handle(skb, devlink))
3542                 goto nla_put_failure;
3543         headers_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADERS);
3544         if (!headers_attr)
3545                 goto nla_put_failure;
3546
3547         j = 0;
3548         for (; i < dpipe_headers->headers_count; i++) {
3549                 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
3550                 if (err) {
3551                         if (!j)
3552                                 goto err_table_put;
3553                         break;
3554                 }
3555                 j++;
3556         }
3557         nla_nest_end(skb, headers_attr);
3558         genlmsg_end(skb, hdr);
3559         if (i != dpipe_headers->headers_count)
3560                 goto start_again;
3561
3562 send_done:
3563         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3564                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
3565         if (!nlh) {
3566                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3567                 if (err)
3568                         return err;
3569                 goto send_done;
3570         }
3571         return genlmsg_reply(skb, info);
3572
3573 nla_put_failure:
3574         err = -EMSGSIZE;
3575 err_table_put:
3576         nlmsg_free(skb);
3577         return err;
3578 }
3579
3580 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
3581                                             struct genl_info *info)
3582 {
3583         struct devlink *devlink = info->user_ptr[0];
3584
3585         if (!devlink->dpipe_headers)
3586                 return -EOPNOTSUPP;
3587         return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
3588                                           0, devlink->dpipe_headers);
3589 }
3590
3591 static int devlink_dpipe_table_counters_set(struct devlink *devlink,
3592                                             const char *table_name,
3593                                             bool enable)
3594 {
3595         struct devlink_dpipe_table *table;
3596
3597         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3598                                          table_name, devlink);
3599         if (!table)
3600                 return -EINVAL;
3601
3602         if (table->counter_control_extern)
3603                 return -EOPNOTSUPP;
3604
3605         if (!(table->counters_enabled ^ enable))
3606                 return 0;
3607
3608         table->counters_enabled = enable;
3609         if (table->table_ops->counters_set_update)
3610                 table->table_ops->counters_set_update(table->priv, enable);
3611         return 0;
3612 }
3613
3614 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
3615                                                    struct genl_info *info)
3616 {
3617         struct devlink *devlink = info->user_ptr[0];
3618         const char *table_name;
3619         bool counters_enable;
3620
3621         if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
3622             !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
3623                 return -EINVAL;
3624
3625         table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3626         counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
3627
3628         return devlink_dpipe_table_counters_set(devlink, table_name,
3629                                                 counters_enable);
3630 }
3631
3632 static struct devlink_resource *
3633 devlink_resource_find(struct devlink *devlink,
3634                       struct devlink_resource *resource, u64 resource_id)
3635 {
3636         struct list_head *resource_list;
3637
3638         if (resource)
3639                 resource_list = &resource->resource_list;
3640         else
3641                 resource_list = &devlink->resource_list;
3642
3643         list_for_each_entry(resource, resource_list, list) {
3644                 struct devlink_resource *child_resource;
3645
3646                 if (resource->id == resource_id)
3647                         return resource;
3648
3649                 child_resource = devlink_resource_find(devlink, resource,
3650                                                        resource_id);
3651                 if (child_resource)
3652                         return child_resource;
3653         }
3654         return NULL;
3655 }
3656
3657 static void
3658 devlink_resource_validate_children(struct devlink_resource *resource)
3659 {
3660         struct devlink_resource *child_resource;
3661         bool size_valid = true;
3662         u64 parts_size = 0;
3663
3664         if (list_empty(&resource->resource_list))
3665                 goto out;
3666
3667         list_for_each_entry(child_resource, &resource->resource_list, list)
3668                 parts_size += child_resource->size_new;
3669
3670         if (parts_size > resource->size_new)
3671                 size_valid = false;
3672 out:
3673         resource->size_valid = size_valid;
3674 }
3675
3676 static int
3677 devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
3678                                struct netlink_ext_ack *extack)
3679 {
3680         u64 reminder;
3681         int err = 0;
3682
3683         if (size > resource->size_params.size_max) {
3684                 NL_SET_ERR_MSG_MOD(extack, "Size larger than maximum");
3685                 err = -EINVAL;
3686         }
3687
3688         if (size < resource->size_params.size_min) {
3689                 NL_SET_ERR_MSG_MOD(extack, "Size smaller than minimum");
3690                 err = -EINVAL;
3691         }
3692
3693         div64_u64_rem(size, resource->size_params.size_granularity, &reminder);
3694         if (reminder) {
3695                 NL_SET_ERR_MSG_MOD(extack, "Wrong granularity");
3696                 err = -EINVAL;
3697         }
3698
3699         return err;
3700 }
3701
3702 static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
3703                                        struct genl_info *info)
3704 {
3705         struct devlink *devlink = info->user_ptr[0];
3706         struct devlink_resource *resource;
3707         u64 resource_id;
3708         u64 size;
3709         int err;
3710
3711         if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
3712             !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
3713                 return -EINVAL;
3714         resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
3715
3716         resource = devlink_resource_find(devlink, NULL, resource_id);
3717         if (!resource)
3718                 return -EINVAL;
3719
3720         size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
3721         err = devlink_resource_validate_size(resource, size, info->extack);
3722         if (err)
3723                 return err;
3724
3725         resource->size_new = size;
3726         devlink_resource_validate_children(resource);
3727         if (resource->parent)
3728                 devlink_resource_validate_children(resource->parent);
3729         return 0;
3730 }
3731
3732 static int
3733 devlink_resource_size_params_put(struct devlink_resource *resource,
3734                                  struct sk_buff *skb)
3735 {
3736         struct devlink_resource_size_params *size_params;
3737
3738         size_params = &resource->size_params;
3739         if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
3740                               size_params->size_granularity, DEVLINK_ATTR_PAD) ||
3741             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
3742                               size_params->size_max, DEVLINK_ATTR_PAD) ||
3743             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
3744                               size_params->size_min, DEVLINK_ATTR_PAD) ||
3745             nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
3746                 return -EMSGSIZE;
3747         return 0;
3748 }
3749
3750 static int devlink_resource_occ_put(struct devlink_resource *resource,
3751                                     struct sk_buff *skb)
3752 {
3753         if (!resource->occ_get)
3754                 return 0;
3755         return nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
3756                                  resource->occ_get(resource->occ_get_priv),
3757                                  DEVLINK_ATTR_PAD);
3758 }
3759
3760 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
3761                                 struct devlink_resource *resource)
3762 {
3763         struct devlink_resource *child_resource;
3764         struct nlattr *child_resource_attr;
3765         struct nlattr *resource_attr;
3766
3767         resource_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_RESOURCE);
3768         if (!resource_attr)
3769                 return -EMSGSIZE;
3770
3771         if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
3772             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
3773                               DEVLINK_ATTR_PAD) ||
3774             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
3775                               DEVLINK_ATTR_PAD))
3776                 goto nla_put_failure;
3777         if (resource->size != resource->size_new)
3778                 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
3779                                   resource->size_new, DEVLINK_ATTR_PAD);
3780         if (devlink_resource_occ_put(resource, skb))
3781                 goto nla_put_failure;
3782         if (devlink_resource_size_params_put(resource, skb))
3783                 goto nla_put_failure;
3784         if (list_empty(&resource->resource_list))
3785                 goto out;
3786
3787         if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
3788                        resource->size_valid))
3789                 goto nla_put_failure;
3790
3791         child_resource_attr = nla_nest_start_noflag(skb,
3792                                                     DEVLINK_ATTR_RESOURCE_LIST);
3793         if (!child_resource_attr)
3794                 goto nla_put_failure;
3795
3796         list_for_each_entry(child_resource, &resource->resource_list, list) {
3797                 if (devlink_resource_put(devlink, skb, child_resource))
3798                         goto resource_put_failure;
3799         }
3800
3801         nla_nest_end(skb, child_resource_attr);
3802 out:
3803         nla_nest_end(skb, resource_attr);
3804         return 0;
3805
3806 resource_put_failure:
3807         nla_nest_cancel(skb, child_resource_attr);
3808 nla_put_failure:
3809         nla_nest_cancel(skb, resource_attr);
3810         return -EMSGSIZE;
3811 }
3812
3813 static int devlink_resource_fill(struct genl_info *info,
3814                                  enum devlink_command cmd, int flags)
3815 {
3816         struct devlink *devlink = info->user_ptr[0];
3817         struct devlink_resource *resource;
3818         struct nlattr *resources_attr;
3819         struct sk_buff *skb = NULL;
3820         struct nlmsghdr *nlh;
3821         bool incomplete;
3822         void *hdr;
3823         int i;
3824         int err;
3825
3826         resource = list_first_entry(&devlink->resource_list,
3827                                     struct devlink_resource, list);
3828 start_again:
3829         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3830         if (err)
3831                 return err;
3832
3833         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3834                           &devlink_nl_family, NLM_F_MULTI, cmd);
3835         if (!hdr) {
3836                 nlmsg_free(skb);
3837                 return -EMSGSIZE;
3838         }
3839
3840         if (devlink_nl_put_handle(skb, devlink))
3841                 goto nla_put_failure;
3842
3843         resources_attr = nla_nest_start_noflag(skb,
3844                                                DEVLINK_ATTR_RESOURCE_LIST);
3845         if (!resources_attr)
3846                 goto nla_put_failure;
3847
3848         incomplete = false;
3849         i = 0;
3850         list_for_each_entry_from(resource, &devlink->resource_list, list) {
3851                 err = devlink_resource_put(devlink, skb, resource);
3852                 if (err) {
3853                         if (!i)
3854                                 goto err_resource_put;
3855                         incomplete = true;
3856                         break;
3857                 }
3858                 i++;
3859         }
3860         nla_nest_end(skb, resources_attr);
3861         genlmsg_end(skb, hdr);
3862         if (incomplete)
3863                 goto start_again;
3864 send_done:
3865         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3866                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
3867         if (!nlh) {
3868                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3869                 if (err)
3870                         return err;
3871                 goto send_done;
3872         }
3873         return genlmsg_reply(skb, info);
3874
3875 nla_put_failure:
3876         err = -EMSGSIZE;
3877 err_resource_put:
3878         nlmsg_free(skb);
3879         return err;
3880 }
3881
3882 static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
3883                                         struct genl_info *info)
3884 {
3885         struct devlink *devlink = info->user_ptr[0];
3886
3887         if (list_empty(&devlink->resource_list))
3888                 return -EOPNOTSUPP;
3889
3890         return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
3891 }
3892
3893 static int
3894 devlink_resources_validate(struct devlink *devlink,
3895                            struct devlink_resource *resource,
3896                            struct genl_info *info)
3897 {
3898         struct list_head *resource_list;
3899         int err = 0;
3900
3901         if (resource)
3902                 resource_list = &resource->resource_list;
3903         else
3904                 resource_list = &devlink->resource_list;
3905
3906         list_for_each_entry(resource, resource_list, list) {
3907                 if (!resource->size_valid)
3908                         return -EINVAL;
3909                 err = devlink_resources_validate(devlink, resource, info);
3910                 if (err)
3911                         return err;
3912         }
3913         return err;
3914 }
3915
3916 static struct net *devlink_netns_get(struct sk_buff *skb,
3917                                      struct genl_info *info)
3918 {
3919         struct nlattr *netns_pid_attr = info->attrs[DEVLINK_ATTR_NETNS_PID];
3920         struct nlattr *netns_fd_attr = info->attrs[DEVLINK_ATTR_NETNS_FD];
3921         struct nlattr *netns_id_attr = info->attrs[DEVLINK_ATTR_NETNS_ID];
3922         struct net *net;
3923
3924         if (!!netns_pid_attr + !!netns_fd_attr + !!netns_id_attr > 1) {
3925                 NL_SET_ERR_MSG_MOD(info->extack, "multiple netns identifying attributes specified");
3926                 return ERR_PTR(-EINVAL);
3927         }
3928
3929         if (netns_pid_attr) {
3930                 net = get_net_ns_by_pid(nla_get_u32(netns_pid_attr));
3931         } else if (netns_fd_attr) {
3932                 net = get_net_ns_by_fd(nla_get_u32(netns_fd_attr));
3933         } else if (netns_id_attr) {
3934                 net = get_net_ns_by_id(sock_net(skb->sk),
3935                                        nla_get_u32(netns_id_attr));
3936                 if (!net)
3937                         net = ERR_PTR(-EINVAL);
3938         } else {
3939                 WARN_ON(1);
3940                 net = ERR_PTR(-EINVAL);
3941         }
3942         if (IS_ERR(net)) {
3943                 NL_SET_ERR_MSG_MOD(info->extack, "Unknown network namespace");
3944                 return ERR_PTR(-EINVAL);
3945         }
3946         if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
3947                 put_net(net);
3948                 return ERR_PTR(-EPERM);
3949         }
3950         return net;
3951 }
3952
3953 static void devlink_param_notify(struct devlink *devlink,
3954                                  unsigned int port_index,
3955                                  struct devlink_param_item *param_item,
3956                                  enum devlink_command cmd);
3957
3958 static void devlink_ns_change_notify(struct devlink *devlink,
3959                                      struct net *dest_net, struct net *curr_net,
3960                                      bool new)
3961 {
3962         struct devlink_param_item *param_item;
3963         enum devlink_command cmd;
3964
3965         /* Userspace needs to be notified about devlink objects
3966          * removed from original and entering new network namespace.
3967          * The rest of the devlink objects are re-created during
3968          * reload process so the notifications are generated separatelly.
3969          */
3970
3971         if (!dest_net || net_eq(dest_net, curr_net))
3972                 return;
3973
3974         if (new)
3975                 devlink_notify(devlink, DEVLINK_CMD_NEW);
3976
3977         cmd = new ? DEVLINK_CMD_PARAM_NEW : DEVLINK_CMD_PARAM_DEL;
3978         list_for_each_entry(param_item, &devlink->param_list, list)
3979                 devlink_param_notify(devlink, 0, param_item, cmd);
3980
3981         if (!new)
3982                 devlink_notify(devlink, DEVLINK_CMD_DEL);
3983 }
3984
3985 static bool devlink_reload_supported(const struct devlink_ops *ops)
3986 {
3987         return ops->reload_down && ops->reload_up;
3988 }
3989
3990 static void devlink_reload_failed_set(struct devlink *devlink,
3991                                       bool reload_failed)
3992 {
3993         if (devlink->reload_failed == reload_failed)
3994                 return;
3995         devlink->reload_failed = reload_failed;
3996         devlink_notify(devlink, DEVLINK_CMD_NEW);
3997 }
3998
3999 bool devlink_is_reload_failed(const struct devlink *devlink)
4000 {
4001         return devlink->reload_failed;
4002 }
4003 EXPORT_SYMBOL_GPL(devlink_is_reload_failed);
4004
4005 static void
4006 __devlink_reload_stats_update(struct devlink *devlink, u32 *reload_stats,
4007                               enum devlink_reload_limit limit, u32 actions_performed)
4008 {
4009         unsigned long actions = actions_performed;
4010         int stat_idx;
4011         int action;
4012
4013         for_each_set_bit(action, &actions, __DEVLINK_RELOAD_ACTION_MAX) {
4014                 stat_idx = limit * __DEVLINK_RELOAD_ACTION_MAX + action;
4015                 reload_stats[stat_idx]++;
4016         }
4017         devlink_notify(devlink, DEVLINK_CMD_NEW);
4018 }
4019
4020 static void
4021 devlink_reload_stats_update(struct devlink *devlink, enum devlink_reload_limit limit,
4022                             u32 actions_performed)
4023 {
4024         __devlink_reload_stats_update(devlink, devlink->stats.reload_stats, limit,
4025                                       actions_performed);
4026 }
4027
4028 /**
4029  *      devlink_remote_reload_actions_performed - Update devlink on reload actions
4030  *        performed which are not a direct result of devlink reload call.
4031  *
4032  *      This should be called by a driver after performing reload actions in case it was not
4033  *      a result of devlink reload call. For example fw_activate was performed as a result
4034  *      of devlink reload triggered fw_activate on another host.
4035  *      The motivation for this function is to keep data on reload actions performed on this
4036  *      function whether it was done due to direct devlink reload call or not.
4037  *
4038  *      @devlink: devlink
4039  *      @limit: reload limit
4040  *      @actions_performed: bitmask of actions performed
4041  */
4042 void devlink_remote_reload_actions_performed(struct devlink *devlink,
4043                                              enum devlink_reload_limit limit,
4044                                              u32 actions_performed)
4045 {
4046         if (WARN_ON(!actions_performed ||
4047                     actions_performed & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
4048                     actions_performed >= BIT(__DEVLINK_RELOAD_ACTION_MAX) ||
4049                     limit > DEVLINK_RELOAD_LIMIT_MAX))
4050                 return;
4051
4052         __devlink_reload_stats_update(devlink, devlink->stats.remote_reload_stats, limit,
4053                                       actions_performed);
4054 }
4055 EXPORT_SYMBOL_GPL(devlink_remote_reload_actions_performed);
4056
4057 static int devlink_reload(struct devlink *devlink, struct net *dest_net,
4058                           enum devlink_reload_action action, enum devlink_reload_limit limit,
4059                           u32 *actions_performed, struct netlink_ext_ack *extack)
4060 {
4061         u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE];
4062         struct net *curr_net;
4063         int err;
4064
4065         memcpy(remote_reload_stats, devlink->stats.remote_reload_stats,
4066                sizeof(remote_reload_stats));
4067
4068         curr_net = devlink_net(devlink);
4069         devlink_ns_change_notify(devlink, dest_net, curr_net, false);
4070         err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack);
4071         if (err)
4072                 return err;
4073
4074         if (dest_net && !net_eq(dest_net, curr_net))
4075                 write_pnet(&devlink->_net, dest_net);
4076
4077         err = devlink->ops->reload_up(devlink, action, limit, actions_performed, extack);
4078         devlink_reload_failed_set(devlink, !!err);
4079         if (err)
4080                 return err;
4081
4082         devlink_ns_change_notify(devlink, dest_net, curr_net, true);
4083         WARN_ON(!(*actions_performed & BIT(action)));
4084         /* Catch driver on updating the remote action within devlink reload */
4085         WARN_ON(memcmp(remote_reload_stats, devlink->stats.remote_reload_stats,
4086                        sizeof(remote_reload_stats)));
4087         devlink_reload_stats_update(devlink, limit, *actions_performed);
4088         return 0;
4089 }
4090
4091 static int
4092 devlink_nl_reload_actions_performed_snd(struct devlink *devlink, u32 actions_performed,
4093                                         enum devlink_command cmd, struct genl_info *info)
4094 {
4095         struct sk_buff *msg;
4096         void *hdr;
4097
4098         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4099         if (!msg)
4100                 return -ENOMEM;
4101
4102         hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &devlink_nl_family, 0, cmd);
4103         if (!hdr)
4104                 goto free_msg;
4105
4106         if (devlink_nl_put_handle(msg, devlink))
4107                 goto nla_put_failure;
4108
4109         if (nla_put_bitfield32(msg, DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED, actions_performed,
4110                                actions_performed))
4111                 goto nla_put_failure;
4112         genlmsg_end(msg, hdr);
4113
4114         return genlmsg_reply(msg, info);
4115
4116 nla_put_failure:
4117         genlmsg_cancel(msg, hdr);
4118 free_msg:
4119         nlmsg_free(msg);
4120         return -EMSGSIZE;
4121 }
4122
4123 static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
4124 {
4125         struct devlink *devlink = info->user_ptr[0];
4126         enum devlink_reload_action action;
4127         enum devlink_reload_limit limit;
4128         struct net *dest_net = NULL;
4129         u32 actions_performed;
4130         int err;
4131
4132         if (!(devlink->features & DEVLINK_F_RELOAD))
4133                 return -EOPNOTSUPP;
4134
4135         err = devlink_resources_validate(devlink, NULL, info);
4136         if (err) {
4137                 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
4138                 return err;
4139         }
4140
4141         if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION])
4142                 action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]);
4143         else
4144                 action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT;
4145
4146         if (!devlink_reload_action_is_supported(devlink, action)) {
4147                 NL_SET_ERR_MSG_MOD(info->extack,
4148                                    "Requested reload action is not supported by the driver");
4149                 return -EOPNOTSUPP;
4150         }
4151
4152         limit = DEVLINK_RELOAD_LIMIT_UNSPEC;
4153         if (info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) {
4154                 struct nla_bitfield32 limits;
4155                 u32 limits_selected;
4156
4157                 limits = nla_get_bitfield32(info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]);
4158                 limits_selected = limits.value & limits.selector;
4159                 if (!limits_selected) {
4160                         NL_SET_ERR_MSG_MOD(info->extack, "Invalid limit selected");
4161                         return -EINVAL;
4162                 }
4163                 for (limit = 0 ; limit <= DEVLINK_RELOAD_LIMIT_MAX ; limit++)
4164                         if (limits_selected & BIT(limit))
4165                                 break;
4166                 /* UAPI enables multiselection, but currently it is not used */
4167                 if (limits_selected != BIT(limit)) {
4168                         NL_SET_ERR_MSG_MOD(info->extack,
4169                                            "Multiselection of limit is not supported");
4170                         return -EOPNOTSUPP;
4171                 }
4172                 if (!devlink_reload_limit_is_supported(devlink, limit)) {
4173                         NL_SET_ERR_MSG_MOD(info->extack,
4174                                            "Requested limit is not supported by the driver");
4175                         return -EOPNOTSUPP;
4176                 }
4177                 if (devlink_reload_combination_is_invalid(action, limit)) {
4178                         NL_SET_ERR_MSG_MOD(info->extack,
4179                                            "Requested limit is invalid for this action");
4180                         return -EINVAL;
4181                 }
4182         }
4183         if (info->attrs[DEVLINK_ATTR_NETNS_PID] ||
4184             info->attrs[DEVLINK_ATTR_NETNS_FD] ||
4185             info->attrs[DEVLINK_ATTR_NETNS_ID]) {
4186                 dest_net = devlink_netns_get(skb, info);
4187                 if (IS_ERR(dest_net))
4188                         return PTR_ERR(dest_net);
4189         }
4190
4191         err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack);
4192
4193         if (dest_net)
4194                 put_net(dest_net);
4195
4196         if (err)
4197                 return err;
4198         /* For backward compatibility generate reply only if attributes used by user */
4199         if (!info->attrs[DEVLINK_ATTR_RELOAD_ACTION] && !info->attrs[DEVLINK_ATTR_RELOAD_LIMITS])
4200                 return 0;
4201
4202         return devlink_nl_reload_actions_performed_snd(devlink, actions_performed,
4203                                                        DEVLINK_CMD_RELOAD, info);
4204 }
4205
4206 static int devlink_nl_flash_update_fill(struct sk_buff *msg,
4207                                         struct devlink *devlink,
4208                                         enum devlink_command cmd,
4209                                         struct devlink_flash_notify *params)
4210 {
4211         void *hdr;
4212
4213         hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd);
4214         if (!hdr)
4215                 return -EMSGSIZE;
4216
4217         if (devlink_nl_put_handle(msg, devlink))
4218                 goto nla_put_failure;
4219
4220         if (cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS)
4221                 goto out;
4222
4223         if (params->status_msg &&
4224             nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG,
4225                            params->status_msg))
4226                 goto nla_put_failure;
4227         if (params->component &&
4228             nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT,
4229                            params->component))
4230                 goto nla_put_failure;
4231         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE,
4232                               params->done, DEVLINK_ATTR_PAD))
4233                 goto nla_put_failure;
4234         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL,
4235                               params->total, DEVLINK_ATTR_PAD))
4236                 goto nla_put_failure;
4237         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT,
4238                               params->timeout, DEVLINK_ATTR_PAD))
4239                 goto nla_put_failure;
4240
4241 out:
4242         genlmsg_end(msg, hdr);
4243         return 0;
4244
4245 nla_put_failure:
4246         genlmsg_cancel(msg, hdr);
4247         return -EMSGSIZE;
4248 }
4249
4250 static void __devlink_flash_update_notify(struct devlink *devlink,
4251                                           enum devlink_command cmd,
4252                                           struct devlink_flash_notify *params)
4253 {
4254         struct sk_buff *msg;
4255         int err;
4256
4257         WARN_ON(cmd != DEVLINK_CMD_FLASH_UPDATE &&
4258                 cmd != DEVLINK_CMD_FLASH_UPDATE_END &&
4259                 cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS);
4260
4261         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
4262                 return;
4263
4264         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4265         if (!msg)
4266                 return;
4267
4268         err = devlink_nl_flash_update_fill(msg, devlink, cmd, params);
4269         if (err)
4270                 goto out_free_msg;
4271
4272         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
4273                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
4274         return;
4275
4276 out_free_msg:
4277         nlmsg_free(msg);
4278 }
4279
4280 static void devlink_flash_update_begin_notify(struct devlink *devlink)
4281 {
4282         struct devlink_flash_notify params = {};
4283
4284         __devlink_flash_update_notify(devlink,
4285                                       DEVLINK_CMD_FLASH_UPDATE,
4286                                       &params);
4287 }
4288
4289 static void devlink_flash_update_end_notify(struct devlink *devlink)
4290 {
4291         struct devlink_flash_notify params = {};
4292
4293         __devlink_flash_update_notify(devlink,
4294                                       DEVLINK_CMD_FLASH_UPDATE_END,
4295                                       &params);
4296 }
4297
4298 void devlink_flash_update_status_notify(struct devlink *devlink,
4299                                         const char *status_msg,
4300                                         const char *component,
4301                                         unsigned long done,
4302                                         unsigned long total)
4303 {
4304         struct devlink_flash_notify params = {
4305                 .status_msg = status_msg,
4306                 .component = component,
4307                 .done = done,
4308                 .total = total,
4309         };
4310
4311         __devlink_flash_update_notify(devlink,
4312                                       DEVLINK_CMD_FLASH_UPDATE_STATUS,
4313                                       &params);
4314 }
4315 EXPORT_SYMBOL_GPL(devlink_flash_update_status_notify);
4316
4317 void devlink_flash_update_timeout_notify(struct devlink *devlink,
4318                                          const char *status_msg,
4319                                          const char *component,
4320                                          unsigned long timeout)
4321 {
4322         struct devlink_flash_notify params = {
4323                 .status_msg = status_msg,
4324                 .component = component,
4325                 .timeout = timeout,
4326         };
4327
4328         __devlink_flash_update_notify(devlink,
4329                                       DEVLINK_CMD_FLASH_UPDATE_STATUS,
4330                                       &params);
4331 }
4332 EXPORT_SYMBOL_GPL(devlink_flash_update_timeout_notify);
4333
4334 static int devlink_nl_cmd_flash_update(struct sk_buff *skb,
4335                                        struct genl_info *info)
4336 {
4337         struct nlattr *nla_component, *nla_overwrite_mask, *nla_file_name;
4338         struct devlink_flash_update_params params = {};
4339         struct devlink *devlink = info->user_ptr[0];
4340         const char *file_name;
4341         u32 supported_params;
4342         int ret;
4343
4344         if (!devlink->ops->flash_update)
4345                 return -EOPNOTSUPP;
4346
4347         if (!info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME])
4348                 return -EINVAL;
4349
4350         supported_params = devlink->ops->supported_flash_update_params;
4351
4352         nla_component = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT];
4353         if (nla_component) {
4354                 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT)) {
4355                         NL_SET_ERR_MSG_ATTR(info->extack, nla_component,
4356                                             "component update is not supported by this device");
4357                         return -EOPNOTSUPP;
4358                 }
4359                 params.component = nla_data(nla_component);
4360         }
4361
4362         nla_overwrite_mask = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK];
4363         if (nla_overwrite_mask) {
4364                 struct nla_bitfield32 sections;
4365
4366                 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK)) {
4367                         NL_SET_ERR_MSG_ATTR(info->extack, nla_overwrite_mask,
4368                                             "overwrite settings are not supported by this device");
4369                         return -EOPNOTSUPP;
4370                 }
4371                 sections = nla_get_bitfield32(nla_overwrite_mask);
4372                 params.overwrite_mask = sections.value & sections.selector;
4373         }
4374
4375         nla_file_name = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME];
4376         file_name = nla_data(nla_file_name);
4377         ret = request_firmware(&params.fw, file_name, devlink->dev);
4378         if (ret) {
4379                 NL_SET_ERR_MSG_ATTR(info->extack, nla_file_name, "failed to locate the requested firmware file");
4380                 return ret;
4381         }
4382
4383         devlink_flash_update_begin_notify(devlink);
4384         ret = devlink->ops->flash_update(devlink, &params, info->extack);
4385         devlink_flash_update_end_notify(devlink);
4386
4387         release_firmware(params.fw);
4388
4389         return ret;
4390 }
4391
4392 static const struct devlink_param devlink_param_generic[] = {
4393         {
4394                 .id = DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET,
4395                 .name = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME,
4396                 .type = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE,
4397         },
4398         {
4399                 .id = DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
4400                 .name = DEVLINK_PARAM_GENERIC_MAX_MACS_NAME,
4401                 .type = DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE,
4402         },
4403         {
4404                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV,
4405                 .name = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME,
4406                 .type = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE,
4407         },
4408         {
4409                 .id = DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT,
4410                 .name = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME,
4411                 .type = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE,
4412         },
4413         {
4414                 .id = DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI,
4415                 .name = DEVLINK_PARAM_GENERIC_IGNORE_ARI_NAME,
4416                 .type = DEVLINK_PARAM_GENERIC_IGNORE_ARI_TYPE,
4417         },
4418         {
4419                 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
4420                 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_NAME,
4421                 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_TYPE,
4422         },
4423         {
4424                 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
4425                 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_NAME,
4426                 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_TYPE,
4427         },
4428         {
4429                 .id = DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY,
4430                 .name = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_NAME,
4431                 .type = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_TYPE,
4432         },
4433         {
4434                 .id = DEVLINK_PARAM_GENERIC_ID_RESET_DEV_ON_DRV_PROBE,
4435                 .name = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_NAME,
4436                 .type = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_TYPE,
4437         },
4438         {
4439                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
4440                 .name = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_NAME,
4441                 .type = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_TYPE,
4442         },
4443         {
4444                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_REMOTE_DEV_RESET,
4445                 .name = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_NAME,
4446                 .type = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_TYPE,
4447         },
4448         {
4449                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_ETH,
4450                 .name = DEVLINK_PARAM_GENERIC_ENABLE_ETH_NAME,
4451                 .type = DEVLINK_PARAM_GENERIC_ENABLE_ETH_TYPE,
4452         },
4453         {
4454                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_RDMA,
4455                 .name = DEVLINK_PARAM_GENERIC_ENABLE_RDMA_NAME,
4456                 .type = DEVLINK_PARAM_GENERIC_ENABLE_RDMA_TYPE,
4457         },
4458         {
4459                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_VNET,
4460                 .name = DEVLINK_PARAM_GENERIC_ENABLE_VNET_NAME,
4461                 .type = DEVLINK_PARAM_GENERIC_ENABLE_VNET_TYPE,
4462         },
4463         {
4464                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_IWARP,
4465                 .name = DEVLINK_PARAM_GENERIC_ENABLE_IWARP_NAME,
4466                 .type = DEVLINK_PARAM_GENERIC_ENABLE_IWARP_TYPE,
4467         },
4468         {
4469                 .id = DEVLINK_PARAM_GENERIC_ID_IO_EQ_SIZE,
4470                 .name = DEVLINK_PARAM_GENERIC_IO_EQ_SIZE_NAME,
4471                 .type = DEVLINK_PARAM_GENERIC_IO_EQ_SIZE_TYPE,
4472         },
4473         {
4474                 .id = DEVLINK_PARAM_GENERIC_ID_EVENT_EQ_SIZE,
4475                 .name = DEVLINK_PARAM_GENERIC_EVENT_EQ_SIZE_NAME,
4476                 .type = DEVLINK_PARAM_GENERIC_EVENT_EQ_SIZE_TYPE,
4477         },
4478 };
4479
4480 static int devlink_param_generic_verify(const struct devlink_param *param)
4481 {
4482         /* verify it match generic parameter by id and name */
4483         if (param->id > DEVLINK_PARAM_GENERIC_ID_MAX)
4484                 return -EINVAL;
4485         if (strcmp(param->name, devlink_param_generic[param->id].name))
4486                 return -ENOENT;
4487
4488         WARN_ON(param->type != devlink_param_generic[param->id].type);
4489
4490         return 0;
4491 }
4492
4493 static int devlink_param_driver_verify(const struct devlink_param *param)
4494 {
4495         int i;
4496
4497         if (param->id <= DEVLINK_PARAM_GENERIC_ID_MAX)
4498                 return -EINVAL;
4499         /* verify no such name in generic params */
4500         for (i = 0; i <= DEVLINK_PARAM_GENERIC_ID_MAX; i++)
4501                 if (!strcmp(param->name, devlink_param_generic[i].name))
4502                         return -EEXIST;
4503
4504         return 0;
4505 }
4506
4507 static struct devlink_param_item *
4508 devlink_param_find_by_name(struct list_head *param_list,
4509                            const char *param_name)
4510 {
4511         struct devlink_param_item *param_item;
4512
4513         list_for_each_entry(param_item, param_list, list)
4514                 if (!strcmp(param_item->param->name, param_name))
4515                         return param_item;
4516         return NULL;
4517 }
4518
4519 static struct devlink_param_item *
4520 devlink_param_find_by_id(struct list_head *param_list, u32 param_id)
4521 {
4522         struct devlink_param_item *param_item;
4523
4524         list_for_each_entry(param_item, param_list, list)
4525                 if (param_item->param->id == param_id)
4526                         return param_item;
4527         return NULL;
4528 }
4529
4530 static bool
4531 devlink_param_cmode_is_supported(const struct devlink_param *param,
4532                                  enum devlink_param_cmode cmode)
4533 {
4534         return test_bit(cmode, &param->supported_cmodes);
4535 }
4536
4537 static int devlink_param_get(struct devlink *devlink,
4538                              const struct devlink_param *param,
4539                              struct devlink_param_gset_ctx *ctx)
4540 {
4541         if (!param->get)
4542                 return -EOPNOTSUPP;
4543         return param->get(devlink, param->id, ctx);
4544 }
4545
4546 static int devlink_param_set(struct devlink *devlink,
4547                              const struct devlink_param *param,
4548                              struct devlink_param_gset_ctx *ctx)
4549 {
4550         if (!param->set)
4551                 return -EOPNOTSUPP;
4552         return param->set(devlink, param->id, ctx);
4553 }
4554
4555 static int
4556 devlink_param_type_to_nla_type(enum devlink_param_type param_type)
4557 {
4558         switch (param_type) {
4559         case DEVLINK_PARAM_TYPE_U8:
4560                 return NLA_U8;
4561         case DEVLINK_PARAM_TYPE_U16:
4562                 return NLA_U16;
4563         case DEVLINK_PARAM_TYPE_U32:
4564                 return NLA_U32;
4565         case DEVLINK_PARAM_TYPE_STRING:
4566                 return NLA_STRING;
4567         case DEVLINK_PARAM_TYPE_BOOL:
4568                 return NLA_FLAG;
4569         default:
4570                 return -EINVAL;
4571         }
4572 }
4573
4574 static int
4575 devlink_nl_param_value_fill_one(struct sk_buff *msg,
4576                                 enum devlink_param_type type,
4577                                 enum devlink_param_cmode cmode,
4578                                 union devlink_param_value val)
4579 {
4580         struct nlattr *param_value_attr;
4581
4582         param_value_attr = nla_nest_start_noflag(msg,
4583                                                  DEVLINK_ATTR_PARAM_VALUE);
4584         if (!param_value_attr)
4585                 goto nla_put_failure;
4586
4587         if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_CMODE, cmode))
4588                 goto value_nest_cancel;
4589
4590         switch (type) {
4591         case DEVLINK_PARAM_TYPE_U8:
4592                 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu8))
4593                         goto value_nest_cancel;
4594                 break;
4595         case DEVLINK_PARAM_TYPE_U16:
4596                 if (nla_put_u16(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu16))
4597                         goto value_nest_cancel;
4598                 break;
4599         case DEVLINK_PARAM_TYPE_U32:
4600                 if (nla_put_u32(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu32))
4601                         goto value_nest_cancel;
4602                 break;
4603         case DEVLINK_PARAM_TYPE_STRING:
4604                 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_VALUE_DATA,
4605                                    val.vstr))
4606                         goto value_nest_cancel;
4607                 break;
4608         case DEVLINK_PARAM_TYPE_BOOL:
4609                 if (val.vbool &&
4610                     nla_put_flag(msg, DEVLINK_ATTR_PARAM_VALUE_DATA))
4611                         goto value_nest_cancel;
4612                 break;
4613         }
4614
4615         nla_nest_end(msg, param_value_attr);
4616         return 0;
4617
4618 value_nest_cancel:
4619         nla_nest_cancel(msg, param_value_attr);
4620 nla_put_failure:
4621         return -EMSGSIZE;
4622 }
4623
4624 static int devlink_nl_param_fill(struct sk_buff *msg, struct devlink *devlink,
4625                                  unsigned int port_index,
4626                                  struct devlink_param_item *param_item,
4627                                  enum devlink_command cmd,
4628                                  u32 portid, u32 seq, int flags)
4629 {
4630         union devlink_param_value param_value[DEVLINK_PARAM_CMODE_MAX + 1];
4631         bool param_value_set[DEVLINK_PARAM_CMODE_MAX + 1] = {};
4632         const struct devlink_param *param = param_item->param;
4633         struct devlink_param_gset_ctx ctx;
4634         struct nlattr *param_values_list;
4635         struct nlattr *param_attr;
4636         int nla_type;
4637         void *hdr;
4638         int err;
4639         int i;
4640
4641         /* Get value from driver part to driverinit configuration mode */
4642         for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
4643                 if (!devlink_param_cmode_is_supported(param, i))
4644                         continue;
4645                 if (i == DEVLINK_PARAM_CMODE_DRIVERINIT) {
4646                         if (!param_item->driverinit_value_valid)
4647                                 return -EOPNOTSUPP;
4648                         param_value[i] = param_item->driverinit_value;
4649                 } else {
4650                         ctx.cmode = i;
4651                         err = devlink_param_get(devlink, param, &ctx);
4652                         if (err)
4653                                 return err;
4654                         param_value[i] = ctx.val;
4655                 }
4656                 param_value_set[i] = true;
4657         }
4658
4659         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4660         if (!hdr)
4661                 return -EMSGSIZE;
4662
4663         if (devlink_nl_put_handle(msg, devlink))
4664                 goto genlmsg_cancel;
4665
4666         if (cmd == DEVLINK_CMD_PORT_PARAM_GET ||
4667             cmd == DEVLINK_CMD_PORT_PARAM_NEW ||
4668             cmd == DEVLINK_CMD_PORT_PARAM_DEL)
4669                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, port_index))
4670                         goto genlmsg_cancel;
4671
4672         param_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PARAM);
4673         if (!param_attr)
4674                 goto genlmsg_cancel;
4675         if (nla_put_string(msg, DEVLINK_ATTR_PARAM_NAME, param->name))
4676                 goto param_nest_cancel;
4677         if (param->generic && nla_put_flag(msg, DEVLINK_ATTR_PARAM_GENERIC))
4678                 goto param_nest_cancel;
4679
4680         nla_type = devlink_param_type_to_nla_type(param->type);
4681         if (nla_type < 0)
4682                 goto param_nest_cancel;
4683         if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_TYPE, nla_type))
4684                 goto param_nest_cancel;
4685
4686         param_values_list = nla_nest_start_noflag(msg,
4687                                                   DEVLINK_ATTR_PARAM_VALUES_LIST);
4688         if (!param_values_list)
4689                 goto param_nest_cancel;
4690
4691         for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
4692                 if (!param_value_set[i])
4693                         continue;
4694                 err = devlink_nl_param_value_fill_one(msg, param->type,
4695                                                       i, param_value[i]);
4696                 if (err)
4697                         goto values_list_nest_cancel;
4698         }
4699
4700         nla_nest_end(msg, param_values_list);
4701         nla_nest_end(msg, param_attr);
4702         genlmsg_end(msg, hdr);
4703         return 0;
4704
4705 values_list_nest_cancel:
4706         nla_nest_end(msg, param_values_list);
4707 param_nest_cancel:
4708         nla_nest_cancel(msg, param_attr);
4709 genlmsg_cancel:
4710         genlmsg_cancel(msg, hdr);
4711         return -EMSGSIZE;
4712 }
4713
4714 static void devlink_param_notify(struct devlink *devlink,
4715                                  unsigned int port_index,
4716                                  struct devlink_param_item *param_item,
4717                                  enum devlink_command cmd)
4718 {
4719         struct sk_buff *msg;
4720         int err;
4721
4722         WARN_ON(cmd != DEVLINK_CMD_PARAM_NEW && cmd != DEVLINK_CMD_PARAM_DEL &&
4723                 cmd != DEVLINK_CMD_PORT_PARAM_NEW &&
4724                 cmd != DEVLINK_CMD_PORT_PARAM_DEL);
4725         ASSERT_DEVLINK_REGISTERED(devlink);
4726
4727         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4728         if (!msg)
4729                 return;
4730         err = devlink_nl_param_fill(msg, devlink, port_index, param_item, cmd,
4731                                     0, 0, 0);
4732         if (err) {
4733                 nlmsg_free(msg);
4734                 return;
4735         }
4736
4737         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
4738                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
4739 }
4740
4741 static int devlink_nl_cmd_param_get_dumpit(struct sk_buff *msg,
4742                                            struct netlink_callback *cb)
4743 {
4744         struct devlink_param_item *param_item;
4745         struct devlink *devlink;
4746         int start = cb->args[0];
4747         unsigned long index;
4748         int idx = 0;
4749         int err = 0;
4750
4751         mutex_lock(&devlink_mutex);
4752         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
4753                 if (!devlink_try_get(devlink))
4754                         continue;
4755
4756                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4757                         goto retry;
4758
4759                 mutex_lock(&devlink->lock);
4760                 list_for_each_entry(param_item, &devlink->param_list, list) {
4761                         if (idx < start) {
4762                                 idx++;
4763                                 continue;
4764                         }
4765                         err = devlink_nl_param_fill(msg, devlink, 0, param_item,
4766                                                     DEVLINK_CMD_PARAM_GET,
4767                                                     NETLINK_CB(cb->skb).portid,
4768                                                     cb->nlh->nlmsg_seq,
4769                                                     NLM_F_MULTI);
4770                         if (err == -EOPNOTSUPP) {
4771                                 err = 0;
4772                         } else if (err) {
4773                                 mutex_unlock(&devlink->lock);
4774                                 devlink_put(devlink);
4775                                 goto out;
4776                         }
4777                         idx++;
4778                 }
4779                 mutex_unlock(&devlink->lock);
4780 retry:
4781                 devlink_put(devlink);
4782         }
4783 out:
4784         mutex_unlock(&devlink_mutex);
4785
4786         if (err != -EMSGSIZE)
4787                 return err;
4788
4789         cb->args[0] = idx;
4790         return msg->len;
4791 }
4792
4793 static int
4794 devlink_param_type_get_from_info(struct genl_info *info,
4795                                  enum devlink_param_type *param_type)
4796 {
4797         if (!info->attrs[DEVLINK_ATTR_PARAM_TYPE])
4798                 return -EINVAL;
4799
4800         switch (nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_TYPE])) {
4801         case NLA_U8:
4802                 *param_type = DEVLINK_PARAM_TYPE_U8;
4803                 break;
4804         case NLA_U16:
4805                 *param_type = DEVLINK_PARAM_TYPE_U16;
4806                 break;
4807         case NLA_U32:
4808                 *param_type = DEVLINK_PARAM_TYPE_U32;
4809                 break;
4810         case NLA_STRING:
4811                 *param_type = DEVLINK_PARAM_TYPE_STRING;
4812                 break;
4813         case NLA_FLAG:
4814                 *param_type = DEVLINK_PARAM_TYPE_BOOL;
4815                 break;
4816         default:
4817                 return -EINVAL;
4818         }
4819
4820         return 0;
4821 }
4822
4823 static int
4824 devlink_param_value_get_from_info(const struct devlink_param *param,
4825                                   struct genl_info *info,
4826                                   union devlink_param_value *value)
4827 {
4828         struct nlattr *param_data;
4829         int len;
4830
4831         param_data = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA];
4832
4833         if (param->type != DEVLINK_PARAM_TYPE_BOOL && !param_data)
4834                 return -EINVAL;
4835
4836         switch (param->type) {
4837         case DEVLINK_PARAM_TYPE_U8:
4838                 if (nla_len(param_data) != sizeof(u8))
4839                         return -EINVAL;
4840                 value->vu8 = nla_get_u8(param_data);
4841                 break;
4842         case DEVLINK_PARAM_TYPE_U16:
4843                 if (nla_len(param_data) != sizeof(u16))
4844                         return -EINVAL;
4845                 value->vu16 = nla_get_u16(param_data);
4846                 break;
4847         case DEVLINK_PARAM_TYPE_U32:
4848                 if (nla_len(param_data) != sizeof(u32))
4849                         return -EINVAL;
4850                 value->vu32 = nla_get_u32(param_data);
4851                 break;
4852         case DEVLINK_PARAM_TYPE_STRING:
4853                 len = strnlen(nla_data(param_data), nla_len(param_data));
4854                 if (len == nla_len(param_data) ||
4855                     len >= __DEVLINK_PARAM_MAX_STRING_VALUE)
4856                         return -EINVAL;
4857                 strcpy(value->vstr, nla_data(param_data));
4858                 break;
4859         case DEVLINK_PARAM_TYPE_BOOL:
4860                 if (param_data && nla_len(param_data))
4861                         return -EINVAL;
4862                 value->vbool = nla_get_flag(param_data);
4863                 break;
4864         }
4865         return 0;
4866 }
4867
4868 static struct devlink_param_item *
4869 devlink_param_get_from_info(struct list_head *param_list,
4870                             struct genl_info *info)
4871 {
4872         char *param_name;
4873
4874         if (!info->attrs[DEVLINK_ATTR_PARAM_NAME])
4875                 return NULL;
4876
4877         param_name = nla_data(info->attrs[DEVLINK_ATTR_PARAM_NAME]);
4878         return devlink_param_find_by_name(param_list, param_name);
4879 }
4880
4881 static int devlink_nl_cmd_param_get_doit(struct sk_buff *skb,
4882                                          struct genl_info *info)
4883 {
4884         struct devlink *devlink = info->user_ptr[0];
4885         struct devlink_param_item *param_item;
4886         struct sk_buff *msg;
4887         int err;
4888
4889         param_item = devlink_param_get_from_info(&devlink->param_list, info);
4890         if (!param_item)
4891                 return -EINVAL;
4892
4893         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4894         if (!msg)
4895                 return -ENOMEM;
4896
4897         err = devlink_nl_param_fill(msg, devlink, 0, param_item,
4898                                     DEVLINK_CMD_PARAM_GET,
4899                                     info->snd_portid, info->snd_seq, 0);
4900         if (err) {
4901                 nlmsg_free(msg);
4902                 return err;
4903         }
4904
4905         return genlmsg_reply(msg, info);
4906 }
4907
4908 static int __devlink_nl_cmd_param_set_doit(struct devlink *devlink,
4909                                            unsigned int port_index,
4910                                            struct list_head *param_list,
4911                                            struct genl_info *info,
4912                                            enum devlink_command cmd)
4913 {
4914         enum devlink_param_type param_type;
4915         struct devlink_param_gset_ctx ctx;
4916         enum devlink_param_cmode cmode;
4917         struct devlink_param_item *param_item;
4918         const struct devlink_param *param;
4919         union devlink_param_value value;
4920         int err = 0;
4921
4922         param_item = devlink_param_get_from_info(param_list, info);
4923         if (!param_item)
4924                 return -EINVAL;
4925         param = param_item->param;
4926         err = devlink_param_type_get_from_info(info, &param_type);
4927         if (err)
4928                 return err;
4929         if (param_type != param->type)
4930                 return -EINVAL;
4931         err = devlink_param_value_get_from_info(param, info, &value);
4932         if (err)
4933                 return err;
4934         if (param->validate) {
4935                 err = param->validate(devlink, param->id, value, info->extack);
4936                 if (err)
4937                         return err;
4938         }
4939
4940         if (!info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE])
4941                 return -EINVAL;
4942         cmode = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE]);
4943         if (!devlink_param_cmode_is_supported(param, cmode))
4944                 return -EOPNOTSUPP;
4945
4946         if (cmode == DEVLINK_PARAM_CMODE_DRIVERINIT) {
4947                 if (param->type == DEVLINK_PARAM_TYPE_STRING)
4948                         strcpy(param_item->driverinit_value.vstr, value.vstr);
4949                 else
4950                         param_item->driverinit_value = value;
4951                 param_item->driverinit_value_valid = true;
4952         } else {
4953                 if (!param->set)
4954                         return -EOPNOTSUPP;
4955                 ctx.val = value;
4956                 ctx.cmode = cmode;
4957                 err = devlink_param_set(devlink, param, &ctx);
4958                 if (err)
4959                         return err;
4960         }
4961
4962         devlink_param_notify(devlink, port_index, param_item, cmd);
4963         return 0;
4964 }
4965
4966 static int devlink_nl_cmd_param_set_doit(struct sk_buff *skb,
4967                                          struct genl_info *info)
4968 {
4969         struct devlink *devlink = info->user_ptr[0];
4970
4971         return __devlink_nl_cmd_param_set_doit(devlink, 0, &devlink->param_list,
4972                                                info, DEVLINK_CMD_PARAM_NEW);
4973 }
4974
4975 static int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg,
4976                                                 struct netlink_callback *cb)
4977 {
4978         struct devlink_param_item *param_item;
4979         struct devlink_port *devlink_port;
4980         struct devlink *devlink;
4981         int start = cb->args[0];
4982         unsigned long index;
4983         int idx = 0;
4984         int err = 0;
4985
4986         mutex_lock(&devlink_mutex);
4987         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
4988                 if (!devlink_try_get(devlink))
4989                         continue;
4990
4991                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4992                         goto retry;
4993
4994                 mutex_lock(&devlink->lock);
4995                 list_for_each_entry(devlink_port, &devlink->port_list, list) {
4996                         list_for_each_entry(param_item,
4997                                             &devlink_port->param_list, list) {
4998                                 if (idx < start) {
4999                                         idx++;
5000                                         continue;
5001                                 }
5002                                 err = devlink_nl_param_fill(msg,
5003                                                 devlink_port->devlink,
5004                                                 devlink_port->index, param_item,
5005                                                 DEVLINK_CMD_PORT_PARAM_GET,
5006                                                 NETLINK_CB(cb->skb).portid,
5007                                                 cb->nlh->nlmsg_seq,
5008                                                 NLM_F_MULTI);
5009                                 if (err == -EOPNOTSUPP) {
5010                                         err = 0;
5011                                 } else if (err) {
5012                                         mutex_unlock(&devlink->lock);
5013                                         devlink_put(devlink);
5014                                         goto out;
5015                                 }
5016                                 idx++;
5017                         }
5018                 }
5019                 mutex_unlock(&devlink->lock);
5020 retry:
5021                 devlink_put(devlink);
5022         }
5023 out:
5024         mutex_unlock(&devlink_mutex);
5025
5026         if (err != -EMSGSIZE)
5027                 return err;
5028
5029         cb->args[0] = idx;
5030         return msg->len;
5031 }
5032
5033 static int devlink_nl_cmd_port_param_get_doit(struct sk_buff *skb,
5034                                               struct genl_info *info)
5035 {
5036         struct devlink_port *devlink_port = info->user_ptr[1];
5037         struct devlink_param_item *param_item;
5038         struct sk_buff *msg;
5039         int err;
5040
5041         param_item = devlink_param_get_from_info(&devlink_port->param_list,
5042                                                  info);
5043         if (!param_item)
5044                 return -EINVAL;
5045
5046         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5047         if (!msg)
5048                 return -ENOMEM;
5049
5050         err = devlink_nl_param_fill(msg, devlink_port->devlink,
5051                                     devlink_port->index, param_item,
5052                                     DEVLINK_CMD_PORT_PARAM_GET,
5053                                     info->snd_portid, info->snd_seq, 0);
5054         if (err) {
5055                 nlmsg_free(msg);
5056                 return err;
5057         }
5058
5059         return genlmsg_reply(msg, info);
5060 }
5061
5062 static int devlink_nl_cmd_port_param_set_doit(struct sk_buff *skb,
5063                                               struct genl_info *info)
5064 {
5065         struct devlink_port *devlink_port = info->user_ptr[1];
5066
5067         return __devlink_nl_cmd_param_set_doit(devlink_port->devlink,
5068                                                devlink_port->index,
5069                                                &devlink_port->param_list, info,
5070                                                DEVLINK_CMD_PORT_PARAM_NEW);
5071 }
5072
5073 static int devlink_nl_region_snapshot_id_put(struct sk_buff *msg,
5074                                              struct devlink *devlink,
5075                                              struct devlink_snapshot *snapshot)
5076 {
5077         struct nlattr *snap_attr;
5078         int err;
5079
5080         snap_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_SNAPSHOT);
5081         if (!snap_attr)
5082                 return -EINVAL;
5083
5084         err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID, snapshot->id);
5085         if (err)
5086                 goto nla_put_failure;
5087
5088         nla_nest_end(msg, snap_attr);
5089         return 0;
5090
5091 nla_put_failure:
5092         nla_nest_cancel(msg, snap_attr);
5093         return err;
5094 }
5095
5096 static int devlink_nl_region_snapshots_id_put(struct sk_buff *msg,
5097                                               struct devlink *devlink,
5098                                               struct devlink_region *region)
5099 {
5100         struct devlink_snapshot *snapshot;
5101         struct nlattr *snapshots_attr;
5102         int err;
5103
5104         snapshots_attr = nla_nest_start_noflag(msg,
5105                                                DEVLINK_ATTR_REGION_SNAPSHOTS);
5106         if (!snapshots_attr)
5107                 return -EINVAL;
5108
5109         list_for_each_entry(snapshot, &region->snapshot_list, list) {
5110                 err = devlink_nl_region_snapshot_id_put(msg, devlink, snapshot);
5111                 if (err)
5112                         goto nla_put_failure;
5113         }
5114
5115         nla_nest_end(msg, snapshots_attr);
5116         return 0;
5117
5118 nla_put_failure:
5119         nla_nest_cancel(msg, snapshots_attr);
5120         return err;
5121 }
5122
5123 static int devlink_nl_region_fill(struct sk_buff *msg, struct devlink *devlink,
5124                                   enum devlink_command cmd, u32 portid,
5125                                   u32 seq, int flags,
5126                                   struct devlink_region *region)
5127 {
5128         void *hdr;
5129         int err;
5130
5131         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
5132         if (!hdr)
5133                 return -EMSGSIZE;
5134
5135         err = devlink_nl_put_handle(msg, devlink);
5136         if (err)
5137                 goto nla_put_failure;
5138
5139         if (region->port) {
5140                 err = nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
5141                                   region->port->index);
5142                 if (err)
5143                         goto nla_put_failure;
5144         }
5145
5146         err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME, region->ops->name);
5147         if (err)
5148                 goto nla_put_failure;
5149
5150         err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
5151                                 region->size,
5152                                 DEVLINK_ATTR_PAD);
5153         if (err)
5154                 goto nla_put_failure;
5155
5156         err = nla_put_u32(msg, DEVLINK_ATTR_REGION_MAX_SNAPSHOTS,
5157                           region->max_snapshots);
5158         if (err)
5159                 goto nla_put_failure;
5160
5161         err = devlink_nl_region_snapshots_id_put(msg, devlink, region);
5162         if (err)
5163                 goto nla_put_failure;
5164
5165         genlmsg_end(msg, hdr);
5166         return 0;
5167
5168 nla_put_failure:
5169         genlmsg_cancel(msg, hdr);
5170         return err;
5171 }
5172
5173 static struct sk_buff *
5174 devlink_nl_region_notify_build(struct devlink_region *region,
5175                                struct devlink_snapshot *snapshot,
5176                                enum devlink_command cmd, u32 portid, u32 seq)
5177 {
5178         struct devlink *devlink = region->devlink;
5179         struct sk_buff *msg;
5180         void *hdr;
5181         int err;
5182
5183
5184         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5185         if (!msg)
5186                 return ERR_PTR(-ENOMEM);
5187
5188         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, 0, cmd);
5189         if (!hdr) {
5190                 err = -EMSGSIZE;
5191                 goto out_free_msg;
5192         }
5193
5194         err = devlink_nl_put_handle(msg, devlink);
5195         if (err)
5196                 goto out_cancel_msg;
5197
5198         if (region->port) {
5199                 err = nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
5200                                   region->port->index);
5201                 if (err)
5202                         goto out_cancel_msg;
5203         }
5204
5205         err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME,
5206                              region->ops->name);
5207         if (err)
5208                 goto out_cancel_msg;
5209
5210         if (snapshot) {
5211                 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID,
5212                                   snapshot->id);
5213                 if (err)
5214                         goto out_cancel_msg;
5215         } else {
5216                 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
5217                                         region->size, DEVLINK_ATTR_PAD);
5218                 if (err)
5219                         goto out_cancel_msg;
5220         }
5221         genlmsg_end(msg, hdr);
5222
5223         return msg;
5224
5225 out_cancel_msg:
5226         genlmsg_cancel(msg, hdr);
5227 out_free_msg:
5228         nlmsg_free(msg);
5229         return ERR_PTR(err);
5230 }
5231
5232 static void devlink_nl_region_notify(struct devlink_region *region,
5233                                      struct devlink_snapshot *snapshot,
5234                                      enum devlink_command cmd)
5235 {
5236         struct devlink *devlink = region->devlink;
5237         struct sk_buff *msg;
5238
5239         WARN_ON(cmd != DEVLINK_CMD_REGION_NEW && cmd != DEVLINK_CMD_REGION_DEL);
5240         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
5241                 return;
5242
5243         msg = devlink_nl_region_notify_build(region, snapshot, cmd, 0, 0);
5244         if (IS_ERR(msg))
5245                 return;
5246
5247         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink), msg,
5248                                 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
5249 }
5250
5251 /**
5252  * __devlink_snapshot_id_increment - Increment number of snapshots using an id
5253  *      @devlink: devlink instance
5254  *      @id: the snapshot id
5255  *
5256  *      Track when a new snapshot begins using an id. Load the count for the
5257  *      given id from the snapshot xarray, increment it, and store it back.
5258  *
5259  *      Called when a new snapshot is created with the given id.
5260  *
5261  *      The id *must* have been previously allocated by
5262  *      devlink_region_snapshot_id_get().
5263  *
5264  *      Returns 0 on success, or an error on failure.
5265  */
5266 static int __devlink_snapshot_id_increment(struct devlink *devlink, u32 id)
5267 {
5268         unsigned long count;
5269         void *p;
5270
5271         lockdep_assert_held(&devlink->lock);
5272
5273         p = xa_load(&devlink->snapshot_ids, id);
5274         if (WARN_ON(!p))
5275                 return -EINVAL;
5276
5277         if (WARN_ON(!xa_is_value(p)))
5278                 return -EINVAL;
5279
5280         count = xa_to_value(p);
5281         count++;
5282
5283         return xa_err(xa_store(&devlink->snapshot_ids, id, xa_mk_value(count),
5284                                GFP_KERNEL));
5285 }
5286
5287 /**
5288  * __devlink_snapshot_id_decrement - Decrease number of snapshots using an id
5289  *      @devlink: devlink instance
5290  *      @id: the snapshot id
5291  *
5292  *      Track when a snapshot is deleted and stops using an id. Load the count
5293  *      for the given id from the snapshot xarray, decrement it, and store it
5294  *      back.
5295  *
5296  *      If the count reaches zero, erase this id from the xarray, freeing it
5297  *      up for future re-use by devlink_region_snapshot_id_get().
5298  *
5299  *      Called when a snapshot using the given id is deleted, and when the
5300  *      initial allocator of the id is finished using it.
5301  */
5302 static void __devlink_snapshot_id_decrement(struct devlink *devlink, u32 id)
5303 {
5304         unsigned long count;
5305         void *p;
5306
5307         lockdep_assert_held(&devlink->lock);
5308
5309         p = xa_load(&devlink->snapshot_ids, id);
5310         if (WARN_ON(!p))
5311                 return;
5312
5313         if (WARN_ON(!xa_is_value(p)))
5314                 return;
5315
5316         count = xa_to_value(p);
5317
5318         if (count > 1) {
5319                 count--;
5320                 xa_store(&devlink->snapshot_ids, id, xa_mk_value(count),
5321                          GFP_KERNEL);
5322         } else {
5323                 /* If this was the last user, we can erase this id */
5324                 xa_erase(&devlink->snapshot_ids, id);
5325         }
5326 }
5327
5328 /**
5329  *      __devlink_snapshot_id_insert - Insert a specific snapshot ID
5330  *      @devlink: devlink instance
5331  *      @id: the snapshot id
5332  *
5333  *      Mark the given snapshot id as used by inserting a zero value into the
5334  *      snapshot xarray.
5335  *
5336  *      This must be called while holding the devlink instance lock. Unlike
5337  *      devlink_snapshot_id_get, the initial reference count is zero, not one.
5338  *      It is expected that the id will immediately be used before
5339  *      releasing the devlink instance lock.
5340  *
5341  *      Returns zero on success, or an error code if the snapshot id could not
5342  *      be inserted.
5343  */
5344 static int __devlink_snapshot_id_insert(struct devlink *devlink, u32 id)
5345 {
5346         lockdep_assert_held(&devlink->lock);
5347
5348         if (xa_load(&devlink->snapshot_ids, id))
5349                 return -EEXIST;
5350
5351         return xa_err(xa_store(&devlink->snapshot_ids, id, xa_mk_value(0),
5352                                GFP_KERNEL));
5353 }
5354
5355 /**
5356  *      __devlink_region_snapshot_id_get - get snapshot ID
5357  *      @devlink: devlink instance
5358  *      @id: storage to return snapshot id
5359  *
5360  *      Allocates a new snapshot id. Returns zero on success, or a negative
5361  *      error on failure. Must be called while holding the devlink instance
5362  *      lock.
5363  *
5364  *      Snapshot IDs are tracked using an xarray which stores the number of
5365  *      users of the snapshot id.
5366  *
5367  *      Note that the caller of this function counts as a 'user', in order to
5368  *      avoid race conditions. The caller must release its hold on the
5369  *      snapshot by using devlink_region_snapshot_id_put.
5370  */
5371 static int __devlink_region_snapshot_id_get(struct devlink *devlink, u32 *id)
5372 {
5373         lockdep_assert_held(&devlink->lock);
5374
5375         return xa_alloc(&devlink->snapshot_ids, id, xa_mk_value(1),
5376                         xa_limit_32b, GFP_KERNEL);
5377 }
5378
5379 /**
5380  *      __devlink_region_snapshot_create - create a new snapshot
5381  *      This will add a new snapshot of a region. The snapshot
5382  *      will be stored on the region struct and can be accessed
5383  *      from devlink. This is useful for future analyses of snapshots.
5384  *      Multiple snapshots can be created on a region.
5385  *      The @snapshot_id should be obtained using the getter function.
5386  *
5387  *      Must be called only while holding the devlink instance lock.
5388  *
5389  *      @region: devlink region of the snapshot
5390  *      @data: snapshot data
5391  *      @snapshot_id: snapshot id to be created
5392  */
5393 static int
5394 __devlink_region_snapshot_create(struct devlink_region *region,
5395                                  u8 *data, u32 snapshot_id)
5396 {
5397         struct devlink *devlink = region->devlink;
5398         struct devlink_snapshot *snapshot;
5399         int err;
5400
5401         lockdep_assert_held(&devlink->lock);
5402
5403         /* check if region can hold one more snapshot */
5404         if (region->cur_snapshots == region->max_snapshots)
5405                 return -ENOSPC;
5406
5407         if (devlink_region_snapshot_get_by_id(region, snapshot_id))
5408                 return -EEXIST;
5409
5410         snapshot = kzalloc(sizeof(*snapshot), GFP_KERNEL);
5411         if (!snapshot)
5412                 return -ENOMEM;
5413
5414         err = __devlink_snapshot_id_increment(devlink, snapshot_id);
5415         if (err)
5416                 goto err_snapshot_id_increment;
5417
5418         snapshot->id = snapshot_id;
5419         snapshot->region = region;
5420         snapshot->data = data;
5421
5422         list_add_tail(&snapshot->list, &region->snapshot_list);
5423
5424         region->cur_snapshots++;
5425
5426         devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_NEW);
5427         return 0;
5428
5429 err_snapshot_id_increment:
5430         kfree(snapshot);
5431         return err;
5432 }
5433
5434 static void devlink_region_snapshot_del(struct devlink_region *region,
5435                                         struct devlink_snapshot *snapshot)
5436 {
5437         struct devlink *devlink = region->devlink;
5438
5439         lockdep_assert_held(&devlink->lock);
5440
5441         devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_DEL);
5442         region->cur_snapshots--;
5443         list_del(&snapshot->list);
5444         region->ops->destructor(snapshot->data);
5445         __devlink_snapshot_id_decrement(devlink, snapshot->id);
5446         kfree(snapshot);
5447 }
5448
5449 static int devlink_nl_cmd_region_get_doit(struct sk_buff *skb,
5450                                           struct genl_info *info)
5451 {
5452         struct devlink *devlink = info->user_ptr[0];
5453         struct devlink_port *port = NULL;
5454         struct devlink_region *region;
5455         const char *region_name;
5456         struct sk_buff *msg;
5457         unsigned int index;
5458         int err;
5459
5460         if (!info->attrs[DEVLINK_ATTR_REGION_NAME])
5461                 return -EINVAL;
5462
5463         if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5464                 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5465
5466                 port = devlink_port_get_by_index(devlink, index);
5467                 if (!port)
5468                         return -ENODEV;
5469         }
5470
5471         region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5472         if (port)
5473                 region = devlink_port_region_get_by_name(port, region_name);
5474         else
5475                 region = devlink_region_get_by_name(devlink, region_name);
5476
5477         if (!region)
5478                 return -EINVAL;
5479
5480         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5481         if (!msg)
5482                 return -ENOMEM;
5483
5484         err = devlink_nl_region_fill(msg, devlink, DEVLINK_CMD_REGION_GET,
5485                                      info->snd_portid, info->snd_seq, 0,
5486                                      region);
5487         if (err) {
5488                 nlmsg_free(msg);
5489                 return err;
5490         }
5491
5492         return genlmsg_reply(msg, info);
5493 }
5494
5495 static int devlink_nl_cmd_region_get_port_dumpit(struct sk_buff *msg,
5496                                                  struct netlink_callback *cb,
5497                                                  struct devlink_port *port,
5498                                                  int *idx,
5499                                                  int start)
5500 {
5501         struct devlink_region *region;
5502         int err = 0;
5503
5504         list_for_each_entry(region, &port->region_list, list) {
5505                 if (*idx < start) {
5506                         (*idx)++;
5507                         continue;
5508                 }
5509                 err = devlink_nl_region_fill(msg, port->devlink,
5510                                              DEVLINK_CMD_REGION_GET,
5511                                              NETLINK_CB(cb->skb).portid,
5512                                              cb->nlh->nlmsg_seq,
5513                                              NLM_F_MULTI, region);
5514                 if (err)
5515                         goto out;
5516                 (*idx)++;
5517         }
5518
5519 out:
5520         return err;
5521 }
5522
5523 static int devlink_nl_cmd_region_get_devlink_dumpit(struct sk_buff *msg,
5524                                                     struct netlink_callback *cb,
5525                                                     struct devlink *devlink,
5526                                                     int *idx,
5527                                                     int start)
5528 {
5529         struct devlink_region *region;
5530         struct devlink_port *port;
5531         int err = 0;
5532
5533         mutex_lock(&devlink->lock);
5534         list_for_each_entry(region, &devlink->region_list, list) {
5535                 if (*idx < start) {
5536                         (*idx)++;
5537                         continue;
5538                 }
5539                 err = devlink_nl_region_fill(msg, devlink,
5540                                              DEVLINK_CMD_REGION_GET,
5541                                              NETLINK_CB(cb->skb).portid,
5542                                              cb->nlh->nlmsg_seq,
5543                                              NLM_F_MULTI, region);
5544                 if (err)
5545                         goto out;
5546                 (*idx)++;
5547         }
5548
5549         list_for_each_entry(port, &devlink->port_list, list) {
5550                 err = devlink_nl_cmd_region_get_port_dumpit(msg, cb, port, idx,
5551                                                             start);
5552                 if (err)
5553                         goto out;
5554         }
5555
5556 out:
5557         mutex_unlock(&devlink->lock);
5558         return err;
5559 }
5560
5561 static int devlink_nl_cmd_region_get_dumpit(struct sk_buff *msg,
5562                                             struct netlink_callback *cb)
5563 {
5564         struct devlink *devlink;
5565         int start = cb->args[0];
5566         unsigned long index;
5567         int idx = 0;
5568         int err = 0;
5569
5570         mutex_lock(&devlink_mutex);
5571         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
5572                 if (!devlink_try_get(devlink))
5573                         continue;
5574
5575                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5576                         goto retry;
5577
5578                 err = devlink_nl_cmd_region_get_devlink_dumpit(msg, cb, devlink,
5579                                                                &idx, start);
5580 retry:
5581                 devlink_put(devlink);
5582                 if (err)
5583                         goto out;
5584         }
5585 out:
5586         mutex_unlock(&devlink_mutex);
5587         cb->args[0] = idx;
5588         return msg->len;
5589 }
5590
5591 static int devlink_nl_cmd_region_del(struct sk_buff *skb,
5592                                      struct genl_info *info)
5593 {
5594         struct devlink *devlink = info->user_ptr[0];
5595         struct devlink_snapshot *snapshot;
5596         struct devlink_port *port = NULL;
5597         struct devlink_region *region;
5598         const char *region_name;
5599         unsigned int index;
5600         u32 snapshot_id;
5601
5602         if (!info->attrs[DEVLINK_ATTR_REGION_NAME] ||
5603             !info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID])
5604                 return -EINVAL;
5605
5606         region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5607         snapshot_id = nla_get_u32(info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
5608
5609         if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5610                 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5611
5612                 port = devlink_port_get_by_index(devlink, index);
5613                 if (!port)
5614                         return -ENODEV;
5615         }
5616
5617         if (port)
5618                 region = devlink_port_region_get_by_name(port, region_name);
5619         else
5620                 region = devlink_region_get_by_name(devlink, region_name);
5621
5622         if (!region)
5623                 return -EINVAL;
5624
5625         snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
5626         if (!snapshot)
5627                 return -EINVAL;
5628
5629         devlink_region_snapshot_del(region, snapshot);
5630         return 0;
5631 }
5632
5633 static int
5634 devlink_nl_cmd_region_new(struct sk_buff *skb, struct genl_info *info)
5635 {
5636         struct devlink *devlink = info->user_ptr[0];
5637         struct devlink_snapshot *snapshot;
5638         struct devlink_port *port = NULL;
5639         struct nlattr *snapshot_id_attr;
5640         struct devlink_region *region;
5641         const char *region_name;
5642         unsigned int index;
5643         u32 snapshot_id;
5644         u8 *data;
5645         int err;
5646
5647         if (!info->attrs[DEVLINK_ATTR_REGION_NAME]) {
5648                 NL_SET_ERR_MSG_MOD(info->extack, "No region name provided");
5649                 return -EINVAL;
5650         }
5651
5652         region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5653
5654         if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5655                 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5656
5657                 port = devlink_port_get_by_index(devlink, index);
5658                 if (!port)
5659                         return -ENODEV;
5660         }
5661
5662         if (port)
5663                 region = devlink_port_region_get_by_name(port, region_name);
5664         else
5665                 region = devlink_region_get_by_name(devlink, region_name);
5666
5667         if (!region) {
5668                 NL_SET_ERR_MSG_MOD(info->extack, "The requested region does not exist");
5669                 return -EINVAL;
5670         }
5671
5672         if (!region->ops->snapshot) {
5673                 NL_SET_ERR_MSG_MOD(info->extack, "The requested region does not support taking an immediate snapshot");
5674                 return -EOPNOTSUPP;
5675         }
5676
5677         if (region->cur_snapshots == region->max_snapshots) {
5678                 NL_SET_ERR_MSG_MOD(info->extack, "The region has reached the maximum number of stored snapshots");
5679                 return -ENOSPC;
5680         }
5681
5682         snapshot_id_attr = info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID];
5683         if (snapshot_id_attr) {
5684                 snapshot_id = nla_get_u32(snapshot_id_attr);
5685
5686                 if (devlink_region_snapshot_get_by_id(region, snapshot_id)) {
5687                         NL_SET_ERR_MSG_MOD(info->extack, "The requested snapshot id is already in use");
5688                         return -EEXIST;
5689                 }
5690
5691                 err = __devlink_snapshot_id_insert(devlink, snapshot_id);
5692                 if (err)
5693                         return err;
5694         } else {
5695                 err = __devlink_region_snapshot_id_get(devlink, &snapshot_id);
5696                 if (err) {
5697                         NL_SET_ERR_MSG_MOD(info->extack, "Failed to allocate a new snapshot id");
5698                         return err;
5699                 }
5700         }
5701
5702         if (port)
5703                 err = region->port_ops->snapshot(port, region->port_ops,
5704                                                  info->extack, &data);
5705         else
5706                 err = region->ops->snapshot(devlink, region->ops,
5707                                             info->extack, &data);
5708         if (err)
5709                 goto err_snapshot_capture;
5710
5711         err = __devlink_region_snapshot_create(region, data, snapshot_id);
5712         if (err)
5713                 goto err_snapshot_create;
5714
5715         if (!snapshot_id_attr) {
5716                 struct sk_buff *msg;
5717
5718                 snapshot = devlink_region_snapshot_get_by_id(region,
5719                                                              snapshot_id);
5720                 if (WARN_ON(!snapshot))
5721                         return -EINVAL;
5722
5723                 msg = devlink_nl_region_notify_build(region, snapshot,
5724                                                      DEVLINK_CMD_REGION_NEW,
5725                                                      info->snd_portid,
5726                                                      info->snd_seq);
5727                 err = PTR_ERR_OR_ZERO(msg);
5728                 if (err)
5729                         goto err_notify;
5730
5731                 err = genlmsg_reply(msg, info);
5732                 if (err)
5733                         goto err_notify;
5734         }
5735
5736         return 0;
5737
5738 err_snapshot_create:
5739         region->ops->destructor(data);
5740 err_snapshot_capture:
5741         __devlink_snapshot_id_decrement(devlink, snapshot_id);
5742         return err;
5743
5744 err_notify:
5745         devlink_region_snapshot_del(region, snapshot);
5746         return err;
5747 }
5748
5749 static int devlink_nl_cmd_region_read_chunk_fill(struct sk_buff *msg,
5750                                                  struct devlink *devlink,
5751                                                  u8 *chunk, u32 chunk_size,
5752                                                  u64 addr)
5753 {
5754         struct nlattr *chunk_attr;
5755         int err;
5756
5757         chunk_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_CHUNK);
5758         if (!chunk_attr)
5759                 return -EINVAL;
5760
5761         err = nla_put(msg, DEVLINK_ATTR_REGION_CHUNK_DATA, chunk_size, chunk);
5762         if (err)
5763                 goto nla_put_failure;
5764
5765         err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_CHUNK_ADDR, addr,
5766                                 DEVLINK_ATTR_PAD);
5767         if (err)
5768                 goto nla_put_failure;
5769
5770         nla_nest_end(msg, chunk_attr);
5771         return 0;
5772
5773 nla_put_failure:
5774         nla_nest_cancel(msg, chunk_attr);
5775         return err;
5776 }
5777
5778 #define DEVLINK_REGION_READ_CHUNK_SIZE 256
5779
5780 static int devlink_nl_region_read_snapshot_fill(struct sk_buff *skb,
5781                                                 struct devlink *devlink,
5782                                                 struct devlink_region *region,
5783                                                 struct nlattr **attrs,
5784                                                 u64 start_offset,
5785                                                 u64 end_offset,
5786                                                 u64 *new_offset)
5787 {
5788         struct devlink_snapshot *snapshot;
5789         u64 curr_offset = start_offset;
5790         u32 snapshot_id;
5791         int err = 0;
5792
5793         *new_offset = start_offset;
5794
5795         snapshot_id = nla_get_u32(attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
5796         snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
5797         if (!snapshot)
5798                 return -EINVAL;
5799
5800         while (curr_offset < end_offset) {
5801                 u32 data_size;
5802                 u8 *data;
5803
5804                 if (end_offset - curr_offset < DEVLINK_REGION_READ_CHUNK_SIZE)
5805                         data_size = end_offset - curr_offset;
5806                 else
5807                         data_size = DEVLINK_REGION_READ_CHUNK_SIZE;
5808
5809                 data = &snapshot->data[curr_offset];
5810                 err = devlink_nl_cmd_region_read_chunk_fill(skb, devlink,
5811                                                             data, data_size,
5812                                                             curr_offset);
5813                 if (err)
5814                         break;
5815
5816                 curr_offset += data_size;
5817         }
5818         *new_offset = curr_offset;
5819
5820         return err;
5821 }
5822
5823 static int devlink_nl_cmd_region_read_dumpit(struct sk_buff *skb,
5824                                              struct netlink_callback *cb)
5825 {
5826         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
5827         u64 ret_offset, start_offset, end_offset = U64_MAX;
5828         struct nlattr **attrs = info->attrs;
5829         struct devlink_port *port = NULL;
5830         struct devlink_region *region;
5831         struct nlattr *chunks_attr;
5832         const char *region_name;
5833         struct devlink *devlink;
5834         unsigned int index;
5835         void *hdr;
5836         int err;
5837
5838         start_offset = *((u64 *)&cb->args[0]);
5839
5840         mutex_lock(&devlink_mutex);
5841         devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
5842         if (IS_ERR(devlink)) {
5843                 err = PTR_ERR(devlink);
5844                 goto out_dev;
5845         }
5846
5847         mutex_lock(&devlink->lock);
5848
5849         if (!attrs[DEVLINK_ATTR_REGION_NAME] ||
5850             !attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]) {
5851                 err = -EINVAL;
5852                 goto out_unlock;
5853         }
5854
5855         if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5856                 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5857
5858                 port = devlink_port_get_by_index(devlink, index);
5859                 if (!port) {
5860                         err = -ENODEV;
5861                         goto out_unlock;
5862                 }
5863         }
5864
5865         region_name = nla_data(attrs[DEVLINK_ATTR_REGION_NAME]);
5866
5867         if (port)
5868                 region = devlink_port_region_get_by_name(port, region_name);
5869         else
5870                 region = devlink_region_get_by_name(devlink, region_name);
5871
5872         if (!region) {
5873                 err = -EINVAL;
5874                 goto out_unlock;
5875         }
5876
5877         if (attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR] &&
5878             attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]) {
5879                 if (!start_offset)
5880                         start_offset =
5881                                 nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
5882
5883                 end_offset = nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
5884                 end_offset += nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]);
5885         }
5886
5887         if (end_offset > region->size)
5888                 end_offset = region->size;
5889
5890         /* return 0 if there is no further data to read */
5891         if (start_offset == end_offset) {
5892                 err = 0;
5893                 goto out_unlock;
5894         }
5895
5896         hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
5897                           &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI,
5898                           DEVLINK_CMD_REGION_READ);
5899         if (!hdr) {
5900                 err = -EMSGSIZE;
5901                 goto out_unlock;
5902         }
5903
5904         err = devlink_nl_put_handle(skb, devlink);
5905         if (err)
5906                 goto nla_put_failure;
5907
5908         if (region->port) {
5909                 err = nla_put_u32(skb, DEVLINK_ATTR_PORT_INDEX,
5910                                   region->port->index);
5911                 if (err)
5912                         goto nla_put_failure;
5913         }
5914
5915         err = nla_put_string(skb, DEVLINK_ATTR_REGION_NAME, region_name);
5916         if (err)
5917                 goto nla_put_failure;
5918
5919         chunks_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_REGION_CHUNKS);
5920         if (!chunks_attr) {
5921                 err = -EMSGSIZE;
5922                 goto nla_put_failure;
5923         }
5924
5925         err = devlink_nl_region_read_snapshot_fill(skb, devlink,
5926                                                    region, attrs,
5927                                                    start_offset,
5928                                                    end_offset, &ret_offset);
5929
5930         if (err && err != -EMSGSIZE)
5931                 goto nla_put_failure;
5932
5933         /* Check if there was any progress done to prevent infinite loop */
5934         if (ret_offset == start_offset) {
5935                 err = -EINVAL;
5936                 goto nla_put_failure;
5937         }
5938
5939         *((u64 *)&cb->args[0]) = ret_offset;
5940
5941         nla_nest_end(skb, chunks_attr);
5942         genlmsg_end(skb, hdr);
5943         mutex_unlock(&devlink->lock);
5944         devlink_put(devlink);
5945         mutex_unlock(&devlink_mutex);
5946
5947         return skb->len;
5948
5949 nla_put_failure:
5950         genlmsg_cancel(skb, hdr);
5951 out_unlock:
5952         mutex_unlock(&devlink->lock);
5953         devlink_put(devlink);
5954 out_dev:
5955         mutex_unlock(&devlink_mutex);
5956         return err;
5957 }
5958
5959 struct devlink_info_req {
5960         struct sk_buff *msg;
5961 };
5962
5963 int devlink_info_driver_name_put(struct devlink_info_req *req, const char *name)
5964 {
5965         return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME, name);
5966 }
5967 EXPORT_SYMBOL_GPL(devlink_info_driver_name_put);
5968
5969 int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn)
5970 {
5971         return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn);
5972 }
5973 EXPORT_SYMBOL_GPL(devlink_info_serial_number_put);
5974
5975 int devlink_info_board_serial_number_put(struct devlink_info_req *req,
5976                                          const char *bsn)
5977 {
5978         return nla_put_string(req->msg, DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER,
5979                               bsn);
5980 }
5981 EXPORT_SYMBOL_GPL(devlink_info_board_serial_number_put);
5982
5983 static int devlink_info_version_put(struct devlink_info_req *req, int attr,
5984                                     const char *version_name,
5985                                     const char *version_value)
5986 {
5987         struct nlattr *nest;
5988         int err;
5989
5990         nest = nla_nest_start_noflag(req->msg, attr);
5991         if (!nest)
5992                 return -EMSGSIZE;
5993
5994         err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME,
5995                              version_name);
5996         if (err)
5997                 goto nla_put_failure;
5998
5999         err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE,
6000                              version_value);
6001         if (err)
6002                 goto nla_put_failure;
6003
6004         nla_nest_end(req->msg, nest);
6005
6006         return 0;
6007
6008 nla_put_failure:
6009         nla_nest_cancel(req->msg, nest);
6010         return err;
6011 }
6012
6013 int devlink_info_version_fixed_put(struct devlink_info_req *req,
6014                                    const char *version_name,
6015                                    const char *version_value)
6016 {
6017         return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED,
6018                                         version_name, version_value);
6019 }
6020 EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put);
6021
6022 int devlink_info_version_stored_put(struct devlink_info_req *req,
6023                                     const char *version_name,
6024                                     const char *version_value)
6025 {
6026         return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED,
6027                                         version_name, version_value);
6028 }
6029 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put);
6030
6031 int devlink_info_version_running_put(struct devlink_info_req *req,
6032                                      const char *version_name,
6033                                      const char *version_value)
6034 {
6035         return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING,
6036                                         version_name, version_value);
6037 }
6038 EXPORT_SYMBOL_GPL(devlink_info_version_running_put);
6039
6040 static int
6041 devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink,
6042                      enum devlink_command cmd, u32 portid,
6043                      u32 seq, int flags, struct netlink_ext_ack *extack)
6044 {
6045         struct devlink_info_req req;
6046         void *hdr;
6047         int err;
6048
6049         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
6050         if (!hdr)
6051                 return -EMSGSIZE;
6052
6053         err = -EMSGSIZE;
6054         if (devlink_nl_put_handle(msg, devlink))
6055                 goto err_cancel_msg;
6056
6057         req.msg = msg;
6058         err = devlink->ops->info_get(devlink, &req, extack);
6059         if (err)
6060                 goto err_cancel_msg;
6061
6062         genlmsg_end(msg, hdr);
6063         return 0;
6064
6065 err_cancel_msg:
6066         genlmsg_cancel(msg, hdr);
6067         return err;
6068 }
6069
6070 static int devlink_nl_cmd_info_get_doit(struct sk_buff *skb,
6071                                         struct genl_info *info)
6072 {
6073         struct devlink *devlink = info->user_ptr[0];
6074         struct sk_buff *msg;
6075         int err;
6076
6077         if (!devlink->ops->info_get)
6078                 return -EOPNOTSUPP;
6079
6080         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6081         if (!msg)
6082                 return -ENOMEM;
6083
6084         err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
6085                                    info->snd_portid, info->snd_seq, 0,
6086                                    info->extack);
6087         if (err) {
6088                 nlmsg_free(msg);
6089                 return err;
6090         }
6091
6092         return genlmsg_reply(msg, info);
6093 }
6094
6095 static int devlink_nl_cmd_info_get_dumpit(struct sk_buff *msg,
6096                                           struct netlink_callback *cb)
6097 {
6098         struct devlink *devlink;
6099         int start = cb->args[0];
6100         unsigned long index;
6101         int idx = 0;
6102         int err = 0;
6103
6104         mutex_lock(&devlink_mutex);
6105         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
6106                 if (!devlink_try_get(devlink))
6107                         continue;
6108
6109                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
6110                         goto retry;
6111
6112                 if (idx < start || !devlink->ops->info_get)
6113                         goto inc;
6114
6115                 mutex_lock(&devlink->lock);
6116                 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
6117                                            NETLINK_CB(cb->skb).portid,
6118                                            cb->nlh->nlmsg_seq, NLM_F_MULTI,
6119                                            cb->extack);
6120                 mutex_unlock(&devlink->lock);
6121                 if (err == -EOPNOTSUPP)
6122                         err = 0;
6123                 else if (err) {
6124                         devlink_put(devlink);
6125                         break;
6126                 }
6127 inc:
6128                 idx++;
6129 retry:
6130                 devlink_put(devlink);
6131         }
6132         mutex_unlock(&devlink_mutex);
6133
6134         if (err != -EMSGSIZE)
6135                 return err;
6136
6137         cb->args[0] = idx;
6138         return msg->len;
6139 }
6140
6141 struct devlink_fmsg_item {
6142         struct list_head list;
6143         int attrtype;
6144         u8 nla_type;
6145         u16 len;
6146         int value[];
6147 };
6148
6149 struct devlink_fmsg {
6150         struct list_head item_list;
6151         bool putting_binary; /* This flag forces enclosing of binary data
6152                               * in an array brackets. It forces using
6153                               * of designated API:
6154                               * devlink_fmsg_binary_pair_nest_start()
6155                               * devlink_fmsg_binary_pair_nest_end()
6156                               */
6157 };
6158
6159 static struct devlink_fmsg *devlink_fmsg_alloc(void)
6160 {
6161         struct devlink_fmsg *fmsg;
6162
6163         fmsg = kzalloc(sizeof(*fmsg), GFP_KERNEL);
6164         if (!fmsg)
6165                 return NULL;
6166
6167         INIT_LIST_HEAD(&fmsg->item_list);
6168
6169         return fmsg;
6170 }
6171
6172 static void devlink_fmsg_free(struct devlink_fmsg *fmsg)
6173 {
6174         struct devlink_fmsg_item *item, *tmp;
6175
6176         list_for_each_entry_safe(item, tmp, &fmsg->item_list, list) {
6177                 list_del(&item->list);
6178                 kfree(item);
6179         }
6180         kfree(fmsg);
6181 }
6182
6183 static int devlink_fmsg_nest_common(struct devlink_fmsg *fmsg,
6184                                     int attrtype)
6185 {
6186         struct devlink_fmsg_item *item;
6187
6188         item = kzalloc(sizeof(*item), GFP_KERNEL);
6189         if (!item)
6190                 return -ENOMEM;
6191
6192         item->attrtype = attrtype;
6193         list_add_tail(&item->list, &fmsg->item_list);
6194
6195         return 0;
6196 }
6197
6198 int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
6199 {
6200         if (fmsg->putting_binary)
6201                 return -EINVAL;
6202
6203         return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
6204 }
6205 EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_start);
6206
6207 static int devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
6208 {
6209         if (fmsg->putting_binary)
6210                 return -EINVAL;
6211
6212         return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
6213 }
6214
6215 int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
6216 {
6217         if (fmsg->putting_binary)
6218                 return -EINVAL;
6219
6220         return devlink_fmsg_nest_end(fmsg);
6221 }
6222 EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_end);
6223
6224 #define DEVLINK_FMSG_MAX_SIZE (GENLMSG_DEFAULT_SIZE - GENL_HDRLEN - NLA_HDRLEN)
6225
6226 static int devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
6227 {
6228         struct devlink_fmsg_item *item;
6229
6230         if (fmsg->putting_binary)
6231                 return -EINVAL;
6232
6233         if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE)
6234                 return -EMSGSIZE;
6235
6236         item = kzalloc(sizeof(*item) + strlen(name) + 1, GFP_KERNEL);
6237         if (!item)
6238                 return -ENOMEM;
6239
6240         item->nla_type = NLA_NUL_STRING;
6241         item->len = strlen(name) + 1;
6242         item->attrtype = DEVLINK_ATTR_FMSG_OBJ_NAME;
6243         memcpy(&item->value, name, item->len);
6244         list_add_tail(&item->list, &fmsg->item_list);
6245
6246         return 0;
6247 }
6248
6249 int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
6250 {
6251         int err;
6252
6253         if (fmsg->putting_binary)
6254                 return -EINVAL;
6255
6256         err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
6257         if (err)
6258                 return err;
6259
6260         err = devlink_fmsg_put_name(fmsg, name);
6261         if (err)
6262                 return err;
6263
6264         return 0;
6265 }
6266 EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_start);
6267
6268 int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
6269 {
6270         if (fmsg->putting_binary)
6271                 return -EINVAL;
6272
6273         return devlink_fmsg_nest_end(fmsg);
6274 }
6275 EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_end);
6276
6277 int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
6278                                      const char *name)
6279 {
6280         int err;
6281
6282         if (fmsg->putting_binary)
6283                 return -EINVAL;
6284
6285         err = devlink_fmsg_pair_nest_start(fmsg, name);
6286         if (err)
6287                 return err;
6288
6289         err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
6290         if (err)
6291                 return err;
6292
6293         return 0;
6294 }
6295 EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_start);
6296
6297 int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
6298 {
6299         int err;
6300
6301         if (fmsg->putting_binary)
6302                 return -EINVAL;
6303
6304         err = devlink_fmsg_nest_end(fmsg);
6305         if (err)
6306                 return err;
6307
6308         err = devlink_fmsg_nest_end(fmsg);
6309         if (err)
6310                 return err;
6311
6312         return 0;
6313 }
6314 EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_end);
6315
6316 int devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
6317                                         const char *name)
6318 {
6319         int err;
6320
6321         err = devlink_fmsg_arr_pair_nest_start(fmsg, name);
6322         if (err)
6323                 return err;
6324
6325         fmsg->putting_binary = true;
6326         return err;
6327 }
6328 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_start);
6329
6330 int devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg)
6331 {
6332         if (!fmsg->putting_binary)
6333                 return -EINVAL;
6334
6335         fmsg->putting_binary = false;
6336         return devlink_fmsg_arr_pair_nest_end(fmsg);
6337 }
6338 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_end);
6339
6340 static int devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
6341                                   const void *value, u16 value_len,
6342                                   u8 value_nla_type)
6343 {
6344         struct devlink_fmsg_item *item;
6345
6346         if (value_len > DEVLINK_FMSG_MAX_SIZE)
6347                 return -EMSGSIZE;
6348
6349         item = kzalloc(sizeof(*item) + value_len, GFP_KERNEL);
6350         if (!item)
6351                 return -ENOMEM;
6352
6353         item->nla_type = value_nla_type;
6354         item->len = value_len;
6355         item->attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
6356         memcpy(&item->value, value, item->len);
6357         list_add_tail(&item->list, &fmsg->item_list);
6358
6359         return 0;
6360 }
6361
6362 static int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
6363 {
6364         if (fmsg->putting_binary)
6365                 return -EINVAL;
6366
6367         return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
6368 }
6369
6370 static int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
6371 {
6372         if (fmsg->putting_binary)
6373                 return -EINVAL;
6374
6375         return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
6376 }
6377
6378 int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
6379 {
6380         if (fmsg->putting_binary)
6381                 return -EINVAL;
6382
6383         return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
6384 }
6385 EXPORT_SYMBOL_GPL(devlink_fmsg_u32_put);
6386
6387 static int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
6388 {
6389         if (fmsg->putting_binary)
6390                 return -EINVAL;
6391
6392         return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
6393 }
6394
6395 int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
6396 {
6397         if (fmsg->putting_binary)
6398                 return -EINVAL;
6399
6400         return devlink_fmsg_put_value(fmsg, value, strlen(value) + 1,
6401                                       NLA_NUL_STRING);
6402 }
6403 EXPORT_SYMBOL_GPL(devlink_fmsg_string_put);
6404
6405 int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
6406                             u16 value_len)
6407 {
6408         if (!fmsg->putting_binary)
6409                 return -EINVAL;
6410
6411         return devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
6412 }
6413 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_put);
6414
6415 int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
6416                                bool value)
6417 {
6418         int err;
6419
6420         err = devlink_fmsg_pair_nest_start(fmsg, name);
6421         if (err)
6422                 return err;
6423
6424         err = devlink_fmsg_bool_put(fmsg, value);
6425         if (err)
6426                 return err;
6427
6428         err = devlink_fmsg_pair_nest_end(fmsg);
6429         if (err)
6430                 return err;
6431
6432         return 0;
6433 }
6434 EXPORT_SYMBOL_GPL(devlink_fmsg_bool_pair_put);
6435
6436 int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
6437                              u8 value)
6438 {
6439         int err;
6440
6441         err = devlink_fmsg_pair_nest_start(fmsg, name);
6442         if (err)
6443                 return err;
6444
6445         err = devlink_fmsg_u8_put(fmsg, value);
6446         if (err)
6447                 return err;
6448
6449         err = devlink_fmsg_pair_nest_end(fmsg);
6450         if (err)
6451                 return err;
6452
6453         return 0;
6454 }
6455 EXPORT_SYMBOL_GPL(devlink_fmsg_u8_pair_put);
6456
6457 int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
6458                               u32 value)
6459 {
6460         int err;
6461
6462         err = devlink_fmsg_pair_nest_start(fmsg, name);
6463         if (err)
6464                 return err;
6465
6466         err = devlink_fmsg_u32_put(fmsg, value);
6467         if (err)
6468                 return err;
6469
6470         err = devlink_fmsg_pair_nest_end(fmsg);
6471         if (err)
6472                 return err;
6473
6474         return 0;
6475 }
6476 EXPORT_SYMBOL_GPL(devlink_fmsg_u32_pair_put);
6477
6478 int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
6479                               u64 value)
6480 {
6481         int err;
6482
6483         err = devlink_fmsg_pair_nest_start(fmsg, name);
6484         if (err)
6485                 return err;
6486
6487         err = devlink_fmsg_u64_put(fmsg, value);
6488         if (err)
6489                 return err;
6490
6491         err = devlink_fmsg_pair_nest_end(fmsg);
6492         if (err)
6493                 return err;
6494
6495         return 0;
6496 }
6497 EXPORT_SYMBOL_GPL(devlink_fmsg_u64_pair_put);
6498
6499 int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
6500                                  const char *value)
6501 {
6502         int err;
6503
6504         err = devlink_fmsg_pair_nest_start(fmsg, name);
6505         if (err)
6506                 return err;
6507
6508         err = devlink_fmsg_string_put(fmsg, value);
6509         if (err)
6510                 return err;
6511
6512         err = devlink_fmsg_pair_nest_end(fmsg);
6513         if (err)
6514                 return err;
6515
6516         return 0;
6517 }
6518 EXPORT_SYMBOL_GPL(devlink_fmsg_string_pair_put);
6519
6520 int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
6521                                  const void *value, u32 value_len)
6522 {
6523         u32 data_size;
6524         int end_err;
6525         u32 offset;
6526         int err;
6527
6528         err = devlink_fmsg_binary_pair_nest_start(fmsg, name);
6529         if (err)
6530                 return err;
6531
6532         for (offset = 0; offset < value_len; offset += data_size) {
6533                 data_size = value_len - offset;
6534                 if (data_size > DEVLINK_FMSG_MAX_SIZE)
6535                         data_size = DEVLINK_FMSG_MAX_SIZE;
6536                 err = devlink_fmsg_binary_put(fmsg, value + offset, data_size);
6537                 if (err)
6538                         break;
6539                 /* Exit from loop with a break (instead of
6540                  * return) to make sure putting_binary is turned off in
6541                  * devlink_fmsg_binary_pair_nest_end
6542                  */
6543         }
6544
6545         end_err = devlink_fmsg_binary_pair_nest_end(fmsg);
6546         if (end_err)
6547                 err = end_err;
6548
6549         return err;
6550 }
6551 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_put);
6552
6553 static int
6554 devlink_fmsg_item_fill_type(struct devlink_fmsg_item *msg, struct sk_buff *skb)
6555 {
6556         switch (msg->nla_type) {
6557         case NLA_FLAG:
6558         case NLA_U8:
6559         case NLA_U32:
6560         case NLA_U64:
6561         case NLA_NUL_STRING:
6562         case NLA_BINARY:
6563                 return nla_put_u8(skb, DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE,
6564                                   msg->nla_type);
6565         default:
6566                 return -EINVAL;
6567         }
6568 }
6569
6570 static int
6571 devlink_fmsg_item_fill_data(struct devlink_fmsg_item *msg, struct sk_buff *skb)
6572 {
6573         int attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
6574         u8 tmp;
6575
6576         switch (msg->nla_type) {
6577         case NLA_FLAG:
6578                 /* Always provide flag data, regardless of its value */
6579                 tmp = *(bool *) msg->value;
6580
6581                 return nla_put_u8(skb, attrtype, tmp);
6582         case NLA_U8:
6583                 return nla_put_u8(skb, attrtype, *(u8 *) msg->value);
6584         case NLA_U32:
6585                 return nla_put_u32(skb, attrtype, *(u32 *) msg->value);
6586         case NLA_U64:
6587                 return nla_put_u64_64bit(skb, attrtype, *(u64 *) msg->value,
6588                                          DEVLINK_ATTR_PAD);
6589         case NLA_NUL_STRING:
6590                 return nla_put_string(skb, attrtype, (char *) &msg->value);
6591         case NLA_BINARY:
6592                 return nla_put(skb, attrtype, msg->len, (void *) &msg->value);
6593         default:
6594                 return -EINVAL;
6595         }
6596 }
6597
6598 static int
6599 devlink_fmsg_prepare_skb(struct devlink_fmsg *fmsg, struct sk_buff *skb,
6600                          int *start)
6601 {
6602         struct devlink_fmsg_item *item;
6603         struct nlattr *fmsg_nlattr;
6604         int i = 0;
6605         int err;
6606
6607         fmsg_nlattr = nla_nest_start_noflag(skb, DEVLINK_ATTR_FMSG);
6608         if (!fmsg_nlattr)
6609                 return -EMSGSIZE;
6610
6611         list_for_each_entry(item, &fmsg->item_list, list) {
6612                 if (i < *start) {
6613                         i++;
6614                         continue;
6615                 }
6616
6617                 switch (item->attrtype) {
6618                 case DEVLINK_ATTR_FMSG_OBJ_NEST_START:
6619                 case DEVLINK_ATTR_FMSG_PAIR_NEST_START:
6620                 case DEVLINK_ATTR_FMSG_ARR_NEST_START:
6621                 case DEVLINK_ATTR_FMSG_NEST_END:
6622                         err = nla_put_flag(skb, item->attrtype);
6623                         break;
6624                 case DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA:
6625                         err = devlink_fmsg_item_fill_type(item, skb);
6626                         if (err)
6627                                 break;
6628                         err = devlink_fmsg_item_fill_data(item, skb);
6629                         break;
6630                 case DEVLINK_ATTR_FMSG_OBJ_NAME:
6631                         err = nla_put_string(skb, item->attrtype,
6632                                              (char *) &item->value);
6633                         break;
6634                 default:
6635                         err = -EINVAL;
6636                         break;
6637                 }
6638                 if (!err)
6639                         *start = ++i;
6640                 else
6641                         break;
6642         }
6643
6644         nla_nest_end(skb, fmsg_nlattr);
6645         return err;
6646 }
6647
6648 static int devlink_fmsg_snd(struct devlink_fmsg *fmsg,
6649                             struct genl_info *info,
6650                             enum devlink_command cmd, int flags)
6651 {
6652         struct nlmsghdr *nlh;
6653         struct sk_buff *skb;
6654         bool last = false;
6655         int index = 0;
6656         void *hdr;
6657         int err;
6658
6659         while (!last) {
6660                 int tmp_index = index;
6661
6662                 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
6663                 if (!skb)
6664                         return -ENOMEM;
6665
6666                 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
6667                                   &devlink_nl_family, flags | NLM_F_MULTI, cmd);
6668                 if (!hdr) {
6669                         err = -EMSGSIZE;
6670                         goto nla_put_failure;
6671                 }
6672
6673                 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
6674                 if (!err)
6675                         last = true;
6676                 else if (err != -EMSGSIZE || tmp_index == index)
6677                         goto nla_put_failure;
6678
6679                 genlmsg_end(skb, hdr);
6680                 err = genlmsg_reply(skb, info);
6681                 if (err)
6682                         return err;
6683         }
6684
6685         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
6686         if (!skb)
6687                 return -ENOMEM;
6688         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
6689                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
6690         if (!nlh) {
6691                 err = -EMSGSIZE;
6692                 goto nla_put_failure;
6693         }
6694
6695         return genlmsg_reply(skb, info);
6696
6697 nla_put_failure:
6698         nlmsg_free(skb);
6699         return err;
6700 }
6701
6702 static int devlink_fmsg_dumpit(struct devlink_fmsg *fmsg, struct sk_buff *skb,
6703                                struct netlink_callback *cb,
6704                                enum devlink_command cmd)
6705 {
6706         int index = cb->args[0];
6707         int tmp_index = index;
6708         void *hdr;
6709         int err;
6710
6711         hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
6712                           &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI, cmd);
6713         if (!hdr) {
6714                 err = -EMSGSIZE;
6715                 goto nla_put_failure;
6716         }
6717
6718         err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
6719         if ((err && err != -EMSGSIZE) || tmp_index == index)
6720                 goto nla_put_failure;
6721
6722         cb->args[0] = index;
6723         genlmsg_end(skb, hdr);
6724         return skb->len;
6725
6726 nla_put_failure:
6727         genlmsg_cancel(skb, hdr);
6728         return err;
6729 }
6730
6731 struct devlink_health_reporter {
6732         struct list_head list;
6733         void *priv;
6734         const struct devlink_health_reporter_ops *ops;
6735         struct devlink *devlink;
6736         struct devlink_port *devlink_port;
6737         struct devlink_fmsg *dump_fmsg;
6738         struct mutex dump_lock; /* lock parallel read/write from dump buffers */
6739         u64 graceful_period;
6740         bool auto_recover;
6741         bool auto_dump;
6742         u8 health_state;
6743         u64 dump_ts;
6744         u64 dump_real_ts;
6745         u64 error_count;
6746         u64 recovery_count;
6747         u64 last_recovery_ts;
6748         refcount_t refcount;
6749 };
6750
6751 void *
6752 devlink_health_reporter_priv(struct devlink_health_reporter *reporter)
6753 {
6754         return reporter->priv;
6755 }
6756 EXPORT_SYMBOL_GPL(devlink_health_reporter_priv);
6757
6758 static struct devlink_health_reporter *
6759 __devlink_health_reporter_find_by_name(struct list_head *reporter_list,
6760                                        struct mutex *list_lock,
6761                                        const char *reporter_name)
6762 {
6763         struct devlink_health_reporter *reporter;
6764
6765         lockdep_assert_held(list_lock);
6766         list_for_each_entry(reporter, reporter_list, list)
6767                 if (!strcmp(reporter->ops->name, reporter_name))
6768                         return reporter;
6769         return NULL;
6770 }
6771
6772 static struct devlink_health_reporter *
6773 devlink_health_reporter_find_by_name(struct devlink *devlink,
6774                                      const char *reporter_name)
6775 {
6776         return __devlink_health_reporter_find_by_name(&devlink->reporter_list,
6777                                                       &devlink->reporters_lock,
6778                                                       reporter_name);
6779 }
6780
6781 static struct devlink_health_reporter *
6782 devlink_port_health_reporter_find_by_name(struct devlink_port *devlink_port,
6783                                           const char *reporter_name)
6784 {
6785         return __devlink_health_reporter_find_by_name(&devlink_port->reporter_list,
6786                                                       &devlink_port->reporters_lock,
6787                                                       reporter_name);
6788 }
6789
6790 static struct devlink_health_reporter *
6791 __devlink_health_reporter_create(struct devlink *devlink,
6792                                  const struct devlink_health_reporter_ops *ops,
6793                                  u64 graceful_period, void *priv)
6794 {
6795         struct devlink_health_reporter *reporter;
6796
6797         if (WARN_ON(graceful_period && !ops->recover))
6798                 return ERR_PTR(-EINVAL);
6799
6800         reporter = kzalloc(sizeof(*reporter), GFP_KERNEL);
6801         if (!reporter)
6802                 return ERR_PTR(-ENOMEM);
6803
6804         reporter->priv = priv;
6805         reporter->ops = ops;
6806         reporter->devlink = devlink;
6807         reporter->graceful_period = graceful_period;
6808         reporter->auto_recover = !!ops->recover;
6809         reporter->auto_dump = !!ops->dump;
6810         mutex_init(&reporter->dump_lock);
6811         refcount_set(&reporter->refcount, 1);
6812         return reporter;
6813 }
6814
6815 /**
6816  *      devlink_port_health_reporter_create - create devlink health reporter for
6817  *                                            specified port instance
6818  *
6819  *      @port: devlink_port which should contain the new reporter
6820  *      @ops: ops
6821  *      @graceful_period: to avoid recovery loops, in msecs
6822  *      @priv: priv
6823  */
6824 struct devlink_health_reporter *
6825 devlink_port_health_reporter_create(struct devlink_port *port,
6826                                     const struct devlink_health_reporter_ops *ops,
6827                                     u64 graceful_period, void *priv)
6828 {
6829         struct devlink_health_reporter *reporter;
6830
6831         mutex_lock(&port->reporters_lock);
6832         if (__devlink_health_reporter_find_by_name(&port->reporter_list,
6833                                                    &port->reporters_lock, ops->name)) {
6834                 reporter = ERR_PTR(-EEXIST);
6835                 goto unlock;
6836         }
6837
6838         reporter = __devlink_health_reporter_create(port->devlink, ops,
6839                                                     graceful_period, priv);
6840         if (IS_ERR(reporter))
6841                 goto unlock;
6842
6843         reporter->devlink_port = port;
6844         list_add_tail(&reporter->list, &port->reporter_list);
6845 unlock:
6846         mutex_unlock(&port->reporters_lock);
6847         return reporter;
6848 }
6849 EXPORT_SYMBOL_GPL(devlink_port_health_reporter_create);
6850
6851 /**
6852  *      devlink_health_reporter_create - create devlink health reporter
6853  *
6854  *      @devlink: devlink
6855  *      @ops: ops
6856  *      @graceful_period: to avoid recovery loops, in msecs
6857  *      @priv: priv
6858  */
6859 struct devlink_health_reporter *
6860 devlink_health_reporter_create(struct devlink *devlink,
6861                                const struct devlink_health_reporter_ops *ops,
6862                                u64 graceful_period, void *priv)
6863 {
6864         struct devlink_health_reporter *reporter;
6865
6866         mutex_lock(&devlink->reporters_lock);
6867         if (devlink_health_reporter_find_by_name(devlink, ops->name)) {
6868                 reporter = ERR_PTR(-EEXIST);
6869                 goto unlock;
6870         }
6871
6872         reporter = __devlink_health_reporter_create(devlink, ops,
6873                                                     graceful_period, priv);
6874         if (IS_ERR(reporter))
6875                 goto unlock;
6876
6877         list_add_tail(&reporter->list, &devlink->reporter_list);
6878 unlock:
6879         mutex_unlock(&devlink->reporters_lock);
6880         return reporter;
6881 }
6882 EXPORT_SYMBOL_GPL(devlink_health_reporter_create);
6883
6884 static void
6885 devlink_health_reporter_free(struct devlink_health_reporter *reporter)
6886 {
6887         mutex_destroy(&reporter->dump_lock);
6888         if (reporter->dump_fmsg)
6889                 devlink_fmsg_free(reporter->dump_fmsg);
6890         kfree(reporter);
6891 }
6892
6893 static void
6894 devlink_health_reporter_put(struct devlink_health_reporter *reporter)
6895 {
6896         if (refcount_dec_and_test(&reporter->refcount))
6897                 devlink_health_reporter_free(reporter);
6898 }
6899
6900 static void
6901 __devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
6902 {
6903         list_del(&reporter->list);
6904         devlink_health_reporter_put(reporter);
6905 }
6906
6907 /**
6908  *      devlink_health_reporter_destroy - destroy devlink health reporter
6909  *
6910  *      @reporter: devlink health reporter to destroy
6911  */
6912 void
6913 devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
6914 {
6915         struct mutex *lock = &reporter->devlink->reporters_lock;
6916
6917         mutex_lock(lock);
6918         __devlink_health_reporter_destroy(reporter);
6919         mutex_unlock(lock);
6920 }
6921 EXPORT_SYMBOL_GPL(devlink_health_reporter_destroy);
6922
6923 /**
6924  *      devlink_port_health_reporter_destroy - destroy devlink port health reporter
6925  *
6926  *      @reporter: devlink health reporter to destroy
6927  */
6928 void
6929 devlink_port_health_reporter_destroy(struct devlink_health_reporter *reporter)
6930 {
6931         struct mutex *lock = &reporter->devlink_port->reporters_lock;
6932
6933         mutex_lock(lock);
6934         __devlink_health_reporter_destroy(reporter);
6935         mutex_unlock(lock);
6936 }
6937 EXPORT_SYMBOL_GPL(devlink_port_health_reporter_destroy);
6938
6939 static int
6940 devlink_nl_health_reporter_fill(struct sk_buff *msg,
6941                                 struct devlink_health_reporter *reporter,
6942                                 enum devlink_command cmd, u32 portid,
6943                                 u32 seq, int flags)
6944 {
6945         struct devlink *devlink = reporter->devlink;
6946         struct nlattr *reporter_attr;
6947         void *hdr;
6948
6949         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
6950         if (!hdr)
6951                 return -EMSGSIZE;
6952
6953         if (devlink_nl_put_handle(msg, devlink))
6954                 goto genlmsg_cancel;
6955
6956         if (reporter->devlink_port) {
6957                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, reporter->devlink_port->index))
6958                         goto genlmsg_cancel;
6959         }
6960         reporter_attr = nla_nest_start_noflag(msg,
6961                                               DEVLINK_ATTR_HEALTH_REPORTER);
6962         if (!reporter_attr)
6963                 goto genlmsg_cancel;
6964         if (nla_put_string(msg, DEVLINK_ATTR_HEALTH_REPORTER_NAME,
6965                            reporter->ops->name))
6966                 goto reporter_nest_cancel;
6967         if (nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_STATE,
6968                        reporter->health_state))
6969                 goto reporter_nest_cancel;
6970         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT,
6971                               reporter->error_count, DEVLINK_ATTR_PAD))
6972                 goto reporter_nest_cancel;
6973         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT,
6974                               reporter->recovery_count, DEVLINK_ATTR_PAD))
6975                 goto reporter_nest_cancel;
6976         if (reporter->ops->recover &&
6977             nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD,
6978                               reporter->graceful_period,
6979                               DEVLINK_ATTR_PAD))
6980                 goto reporter_nest_cancel;
6981         if (reporter->ops->recover &&
6982             nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER,
6983                        reporter->auto_recover))
6984                 goto reporter_nest_cancel;
6985         if (reporter->dump_fmsg &&
6986             nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS,
6987                               jiffies_to_msecs(reporter->dump_ts),
6988                               DEVLINK_ATTR_PAD))
6989                 goto reporter_nest_cancel;
6990         if (reporter->dump_fmsg &&
6991             nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS,
6992                               reporter->dump_real_ts, DEVLINK_ATTR_PAD))
6993                 goto reporter_nest_cancel;
6994         if (reporter->ops->dump &&
6995             nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP,
6996                        reporter->auto_dump))
6997                 goto reporter_nest_cancel;
6998
6999         nla_nest_end(msg, reporter_attr);
7000         genlmsg_end(msg, hdr);
7001         return 0;
7002
7003 reporter_nest_cancel:
7004         nla_nest_end(msg, reporter_attr);
7005 genlmsg_cancel:
7006         genlmsg_cancel(msg, hdr);
7007         return -EMSGSIZE;
7008 }
7009
7010 static void devlink_recover_notify(struct devlink_health_reporter *reporter,
7011                                    enum devlink_command cmd)
7012 {
7013         struct devlink *devlink = reporter->devlink;
7014         struct sk_buff *msg;
7015         int err;
7016
7017         WARN_ON(cmd != DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
7018         WARN_ON(!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED));
7019
7020         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7021         if (!msg)
7022                 return;
7023
7024         err = devlink_nl_health_reporter_fill(msg, reporter, cmd, 0, 0, 0);
7025         if (err) {
7026                 nlmsg_free(msg);
7027                 return;
7028         }
7029
7030         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink), msg,
7031                                 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
7032 }
7033
7034 void
7035 devlink_health_reporter_recovery_done(struct devlink_health_reporter *reporter)
7036 {
7037         reporter->recovery_count++;
7038         reporter->last_recovery_ts = jiffies;
7039 }
7040 EXPORT_SYMBOL_GPL(devlink_health_reporter_recovery_done);
7041
7042 static int
7043 devlink_health_reporter_recover(struct devlink_health_reporter *reporter,
7044                                 void *priv_ctx, struct netlink_ext_ack *extack)
7045 {
7046         int err;
7047
7048         if (reporter->health_state == DEVLINK_HEALTH_REPORTER_STATE_HEALTHY)
7049                 return 0;
7050
7051         if (!reporter->ops->recover)
7052                 return -EOPNOTSUPP;
7053
7054         err = reporter->ops->recover(reporter, priv_ctx, extack);
7055         if (err)
7056                 return err;
7057
7058         devlink_health_reporter_recovery_done(reporter);
7059         reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_HEALTHY;
7060         devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
7061
7062         return 0;
7063 }
7064
7065 static void
7066 devlink_health_dump_clear(struct devlink_health_reporter *reporter)
7067 {
7068         if (!reporter->dump_fmsg)
7069                 return;
7070         devlink_fmsg_free(reporter->dump_fmsg);
7071         reporter->dump_fmsg = NULL;
7072 }
7073
7074 static int devlink_health_do_dump(struct devlink_health_reporter *reporter,
7075                                   void *priv_ctx,
7076                                   struct netlink_ext_ack *extack)
7077 {
7078         int err;
7079
7080         if (!reporter->ops->dump)
7081                 return 0;
7082
7083         if (reporter->dump_fmsg)
7084                 return 0;
7085
7086         reporter->dump_fmsg = devlink_fmsg_alloc();
7087         if (!reporter->dump_fmsg) {
7088                 err = -ENOMEM;
7089                 return err;
7090         }
7091
7092         err = devlink_fmsg_obj_nest_start(reporter->dump_fmsg);
7093         if (err)
7094                 goto dump_err;
7095
7096         err = reporter->ops->dump(reporter, reporter->dump_fmsg,
7097                                   priv_ctx, extack);
7098         if (err)
7099                 goto dump_err;
7100
7101         err = devlink_fmsg_obj_nest_end(reporter->dump_fmsg);
7102         if (err)
7103                 goto dump_err;
7104
7105         reporter->dump_ts = jiffies;
7106         reporter->dump_real_ts = ktime_get_real_ns();
7107
7108         return 0;
7109
7110 dump_err:
7111         devlink_health_dump_clear(reporter);
7112         return err;
7113 }
7114
7115 int devlink_health_report(struct devlink_health_reporter *reporter,
7116                           const char *msg, void *priv_ctx)
7117 {
7118         enum devlink_health_reporter_state prev_health_state;
7119         struct devlink *devlink = reporter->devlink;
7120         unsigned long recover_ts_threshold;
7121
7122         /* write a log message of the current error */
7123         WARN_ON(!msg);
7124         trace_devlink_health_report(devlink, reporter->ops->name, msg);
7125         reporter->error_count++;
7126         prev_health_state = reporter->health_state;
7127         reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
7128         devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
7129
7130         /* abort if the previous error wasn't recovered */
7131         recover_ts_threshold = reporter->last_recovery_ts +
7132                                msecs_to_jiffies(reporter->graceful_period);
7133         if (reporter->auto_recover &&
7134             (prev_health_state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY ||
7135              (reporter->last_recovery_ts && reporter->recovery_count &&
7136               time_is_after_jiffies(recover_ts_threshold)))) {
7137                 trace_devlink_health_recover_aborted(devlink,
7138                                                      reporter->ops->name,
7139                                                      reporter->health_state,
7140                                                      jiffies -
7141                                                      reporter->last_recovery_ts);
7142                 return -ECANCELED;
7143         }
7144
7145         reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
7146
7147         if (reporter->auto_dump) {
7148                 mutex_lock(&reporter->dump_lock);
7149                 /* store current dump of current error, for later analysis */
7150                 devlink_health_do_dump(reporter, priv_ctx, NULL);
7151                 mutex_unlock(&reporter->dump_lock);
7152         }
7153
7154         if (reporter->auto_recover)
7155                 return devlink_health_reporter_recover(reporter,
7156                                                        priv_ctx, NULL);
7157
7158         return 0;
7159 }
7160 EXPORT_SYMBOL_GPL(devlink_health_report);
7161
7162 static struct devlink_health_reporter *
7163 devlink_health_reporter_get_from_attrs(struct devlink *devlink,
7164                                        struct nlattr **attrs)
7165 {
7166         struct devlink_health_reporter *reporter;
7167         struct devlink_port *devlink_port;
7168         char *reporter_name;
7169
7170         if (!attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME])
7171                 return NULL;
7172
7173         reporter_name = nla_data(attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME]);
7174         devlink_port = devlink_port_get_from_attrs(devlink, attrs);
7175         if (IS_ERR(devlink_port)) {
7176                 mutex_lock(&devlink->reporters_lock);
7177                 reporter = devlink_health_reporter_find_by_name(devlink, reporter_name);
7178                 if (reporter)
7179                         refcount_inc(&reporter->refcount);
7180                 mutex_unlock(&devlink->reporters_lock);
7181         } else {
7182                 mutex_lock(&devlink_port->reporters_lock);
7183                 reporter = devlink_port_health_reporter_find_by_name(devlink_port, reporter_name);
7184                 if (reporter)
7185                         refcount_inc(&reporter->refcount);
7186                 mutex_unlock(&devlink_port->reporters_lock);
7187         }
7188
7189         return reporter;
7190 }
7191
7192 static struct devlink_health_reporter *
7193 devlink_health_reporter_get_from_info(struct devlink *devlink,
7194                                       struct genl_info *info)
7195 {
7196         return devlink_health_reporter_get_from_attrs(devlink, info->attrs);
7197 }
7198
7199 static struct devlink_health_reporter *
7200 devlink_health_reporter_get_from_cb(struct netlink_callback *cb)
7201 {
7202         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
7203         struct devlink_health_reporter *reporter;
7204         struct nlattr **attrs = info->attrs;
7205         struct devlink *devlink;
7206
7207         mutex_lock(&devlink_mutex);
7208         devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
7209         if (IS_ERR(devlink))
7210                 goto unlock;
7211
7212         reporter = devlink_health_reporter_get_from_attrs(devlink, attrs);
7213         devlink_put(devlink);
7214         mutex_unlock(&devlink_mutex);
7215         return reporter;
7216 unlock:
7217         mutex_unlock(&devlink_mutex);
7218         return NULL;
7219 }
7220
7221 void
7222 devlink_health_reporter_state_update(struct devlink_health_reporter *reporter,
7223                                      enum devlink_health_reporter_state state)
7224 {
7225         if (WARN_ON(state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY &&
7226                     state != DEVLINK_HEALTH_REPORTER_STATE_ERROR))
7227                 return;
7228
7229         if (reporter->health_state == state)
7230                 return;
7231
7232         reporter->health_state = state;
7233         trace_devlink_health_reporter_state_update(reporter->devlink,
7234                                                    reporter->ops->name, state);
7235         devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
7236 }
7237 EXPORT_SYMBOL_GPL(devlink_health_reporter_state_update);
7238
7239 static int devlink_nl_cmd_health_reporter_get_doit(struct sk_buff *skb,
7240                                                    struct genl_info *info)
7241 {
7242         struct devlink *devlink = info->user_ptr[0];
7243         struct devlink_health_reporter *reporter;
7244         struct sk_buff *msg;
7245         int err;
7246
7247         reporter = devlink_health_reporter_get_from_info(devlink, info);
7248         if (!reporter)
7249                 return -EINVAL;
7250
7251         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7252         if (!msg) {
7253                 err = -ENOMEM;
7254                 goto out;
7255         }
7256
7257         err = devlink_nl_health_reporter_fill(msg, reporter,
7258                                               DEVLINK_CMD_HEALTH_REPORTER_GET,
7259                                               info->snd_portid, info->snd_seq,
7260                                               0);
7261         if (err) {
7262                 nlmsg_free(msg);
7263                 goto out;
7264         }
7265
7266         err = genlmsg_reply(msg, info);
7267 out:
7268         devlink_health_reporter_put(reporter);
7269         return err;
7270 }
7271
7272 static int
7273 devlink_nl_cmd_health_reporter_get_dumpit(struct sk_buff *msg,
7274                                           struct netlink_callback *cb)
7275 {
7276         struct devlink_health_reporter *reporter;
7277         struct devlink_port *port;
7278         struct devlink *devlink;
7279         int start = cb->args[0];
7280         unsigned long index;
7281         int idx = 0;
7282         int err;
7283
7284         mutex_lock(&devlink_mutex);
7285         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
7286                 if (!devlink_try_get(devlink))
7287                         continue;
7288
7289                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7290                         goto retry_rep;
7291
7292                 mutex_lock(&devlink->reporters_lock);
7293                 list_for_each_entry(reporter, &devlink->reporter_list,
7294                                     list) {
7295                         if (idx < start) {
7296                                 idx++;
7297                                 continue;
7298                         }
7299                         err = devlink_nl_health_reporter_fill(
7300                                 msg, reporter, DEVLINK_CMD_HEALTH_REPORTER_GET,
7301                                 NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
7302                                 NLM_F_MULTI);
7303                         if (err) {
7304                                 mutex_unlock(&devlink->reporters_lock);
7305                                 devlink_put(devlink);
7306                                 goto out;
7307                         }
7308                         idx++;
7309                 }
7310                 mutex_unlock(&devlink->reporters_lock);
7311 retry_rep:
7312                 devlink_put(devlink);
7313         }
7314
7315         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
7316                 if (!devlink_try_get(devlink))
7317                         continue;
7318
7319                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7320                         goto retry_port;
7321
7322                 mutex_lock(&devlink->lock);
7323                 list_for_each_entry(port, &devlink->port_list, list) {
7324                         mutex_lock(&port->reporters_lock);
7325                         list_for_each_entry(reporter, &port->reporter_list, list) {
7326                                 if (idx < start) {
7327                                         idx++;
7328                                         continue;
7329                                 }
7330                                 err = devlink_nl_health_reporter_fill(
7331                                         msg, reporter,
7332                                         DEVLINK_CMD_HEALTH_REPORTER_GET,
7333                                         NETLINK_CB(cb->skb).portid,
7334                                         cb->nlh->nlmsg_seq, NLM_F_MULTI);
7335                                 if (err) {
7336                                         mutex_unlock(&port->reporters_lock);
7337                                         mutex_unlock(&devlink->lock);
7338                                         devlink_put(devlink);
7339                                         goto out;
7340                                 }
7341                                 idx++;
7342                         }
7343                         mutex_unlock(&port->reporters_lock);
7344                 }
7345                 mutex_unlock(&devlink->lock);
7346 retry_port:
7347                 devlink_put(devlink);
7348         }
7349 out:
7350         mutex_unlock(&devlink_mutex);
7351
7352         cb->args[0] = idx;
7353         return msg->len;
7354 }
7355
7356 static int
7357 devlink_nl_cmd_health_reporter_set_doit(struct sk_buff *skb,
7358                                         struct genl_info *info)
7359 {
7360         struct devlink *devlink = info->user_ptr[0];
7361         struct devlink_health_reporter *reporter;
7362         int err;
7363
7364         reporter = devlink_health_reporter_get_from_info(devlink, info);
7365         if (!reporter)
7366                 return -EINVAL;
7367
7368         if (!reporter->ops->recover &&
7369             (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] ||
7370              info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])) {
7371                 err = -EOPNOTSUPP;
7372                 goto out;
7373         }
7374         if (!reporter->ops->dump &&
7375             info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP]) {
7376                 err = -EOPNOTSUPP;
7377                 goto out;
7378         }
7379
7380         if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD])
7381                 reporter->graceful_period =
7382                         nla_get_u64(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD]);
7383
7384         if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])
7385                 reporter->auto_recover =
7386                         nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER]);
7387
7388         if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP])
7389                 reporter->auto_dump =
7390                 nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP]);
7391
7392         devlink_health_reporter_put(reporter);
7393         return 0;
7394 out:
7395         devlink_health_reporter_put(reporter);
7396         return err;
7397 }
7398
7399 static int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
7400                                                        struct genl_info *info)
7401 {
7402         struct devlink *devlink = info->user_ptr[0];
7403         struct devlink_health_reporter *reporter;
7404         int err;
7405
7406         reporter = devlink_health_reporter_get_from_info(devlink, info);
7407         if (!reporter)
7408                 return -EINVAL;
7409
7410         err = devlink_health_reporter_recover(reporter, NULL, info->extack);
7411
7412         devlink_health_reporter_put(reporter);
7413         return err;
7414 }
7415
7416 static int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
7417                                                         struct genl_info *info)
7418 {
7419         struct devlink *devlink = info->user_ptr[0];
7420         struct devlink_health_reporter *reporter;
7421         struct devlink_fmsg *fmsg;
7422         int err;
7423
7424         reporter = devlink_health_reporter_get_from_info(devlink, info);
7425         if (!reporter)
7426                 return -EINVAL;
7427
7428         if (!reporter->ops->diagnose) {
7429                 devlink_health_reporter_put(reporter);
7430                 return -EOPNOTSUPP;
7431         }
7432
7433         fmsg = devlink_fmsg_alloc();
7434         if (!fmsg) {
7435                 devlink_health_reporter_put(reporter);
7436                 return -ENOMEM;
7437         }
7438
7439         err = devlink_fmsg_obj_nest_start(fmsg);
7440         if (err)
7441                 goto out;
7442
7443         err = reporter->ops->diagnose(reporter, fmsg, info->extack);
7444         if (err)
7445                 goto out;
7446
7447         err = devlink_fmsg_obj_nest_end(fmsg);
7448         if (err)
7449                 goto out;
7450
7451         err = devlink_fmsg_snd(fmsg, info,
7452                                DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE, 0);
7453
7454 out:
7455         devlink_fmsg_free(fmsg);
7456         devlink_health_reporter_put(reporter);
7457         return err;
7458 }
7459
7460 static int
7461 devlink_nl_cmd_health_reporter_dump_get_dumpit(struct sk_buff *skb,
7462                                                struct netlink_callback *cb)
7463 {
7464         struct devlink_health_reporter *reporter;
7465         u64 start = cb->args[0];
7466         int err;
7467
7468         reporter = devlink_health_reporter_get_from_cb(cb);
7469         if (!reporter)
7470                 return -EINVAL;
7471
7472         if (!reporter->ops->dump) {
7473                 err = -EOPNOTSUPP;
7474                 goto out;
7475         }
7476         mutex_lock(&reporter->dump_lock);
7477         if (!start) {
7478                 err = devlink_health_do_dump(reporter, NULL, cb->extack);
7479                 if (err)
7480                         goto unlock;
7481                 cb->args[1] = reporter->dump_ts;
7482         }
7483         if (!reporter->dump_fmsg || cb->args[1] != reporter->dump_ts) {
7484                 NL_SET_ERR_MSG_MOD(cb->extack, "Dump trampled, please retry");
7485                 err = -EAGAIN;
7486                 goto unlock;
7487         }
7488
7489         err = devlink_fmsg_dumpit(reporter->dump_fmsg, skb, cb,
7490                                   DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET);
7491 unlock:
7492         mutex_unlock(&reporter->dump_lock);
7493 out:
7494         devlink_health_reporter_put(reporter);
7495         return err;
7496 }
7497
7498 static int
7499 devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
7500                                                struct genl_info *info)
7501 {
7502         struct devlink *devlink = info->user_ptr[0];
7503         struct devlink_health_reporter *reporter;
7504
7505         reporter = devlink_health_reporter_get_from_info(devlink, info);
7506         if (!reporter)
7507                 return -EINVAL;
7508
7509         if (!reporter->ops->dump) {
7510                 devlink_health_reporter_put(reporter);
7511                 return -EOPNOTSUPP;
7512         }
7513
7514         mutex_lock(&reporter->dump_lock);
7515         devlink_health_dump_clear(reporter);
7516         mutex_unlock(&reporter->dump_lock);
7517         devlink_health_reporter_put(reporter);
7518         return 0;
7519 }
7520
7521 static int devlink_nl_cmd_health_reporter_test_doit(struct sk_buff *skb,
7522                                                     struct genl_info *info)
7523 {
7524         struct devlink *devlink = info->user_ptr[0];
7525         struct devlink_health_reporter *reporter;
7526         int err;
7527
7528         reporter = devlink_health_reporter_get_from_info(devlink, info);
7529         if (!reporter)
7530                 return -EINVAL;
7531
7532         if (!reporter->ops->test) {
7533                 devlink_health_reporter_put(reporter);
7534                 return -EOPNOTSUPP;
7535         }
7536
7537         err = reporter->ops->test(reporter, info->extack);
7538
7539         devlink_health_reporter_put(reporter);
7540         return err;
7541 }
7542
7543 struct devlink_stats {
7544         u64 rx_bytes;
7545         u64 rx_packets;
7546         struct u64_stats_sync syncp;
7547 };
7548
7549 /**
7550  * struct devlink_trap_policer_item - Packet trap policer attributes.
7551  * @policer: Immutable packet trap policer attributes.
7552  * @rate: Rate in packets / sec.
7553  * @burst: Burst size in packets.
7554  * @list: trap_policer_list member.
7555  *
7556  * Describes packet trap policer attributes. Created by devlink during trap
7557  * policer registration.
7558  */
7559 struct devlink_trap_policer_item {
7560         const struct devlink_trap_policer *policer;
7561         u64 rate;
7562         u64 burst;
7563         struct list_head list;
7564 };
7565
7566 /**
7567  * struct devlink_trap_group_item - Packet trap group attributes.
7568  * @group: Immutable packet trap group attributes.
7569  * @policer_item: Associated policer item. Can be NULL.
7570  * @list: trap_group_list member.
7571  * @stats: Trap group statistics.
7572  *
7573  * Describes packet trap group attributes. Created by devlink during trap
7574  * group registration.
7575  */
7576 struct devlink_trap_group_item {
7577         const struct devlink_trap_group *group;
7578         struct devlink_trap_policer_item *policer_item;
7579         struct list_head list;
7580         struct devlink_stats __percpu *stats;
7581 };
7582
7583 /**
7584  * struct devlink_trap_item - Packet trap attributes.
7585  * @trap: Immutable packet trap attributes.
7586  * @group_item: Associated group item.
7587  * @list: trap_list member.
7588  * @action: Trap action.
7589  * @stats: Trap statistics.
7590  * @priv: Driver private information.
7591  *
7592  * Describes both mutable and immutable packet trap attributes. Created by
7593  * devlink during trap registration and used for all trap related operations.
7594  */
7595 struct devlink_trap_item {
7596         const struct devlink_trap *trap;
7597         struct devlink_trap_group_item *group_item;
7598         struct list_head list;
7599         enum devlink_trap_action action;
7600         struct devlink_stats __percpu *stats;
7601         void *priv;
7602 };
7603
7604 static struct devlink_trap_policer_item *
7605 devlink_trap_policer_item_lookup(struct devlink *devlink, u32 id)
7606 {
7607         struct devlink_trap_policer_item *policer_item;
7608
7609         list_for_each_entry(policer_item, &devlink->trap_policer_list, list) {
7610                 if (policer_item->policer->id == id)
7611                         return policer_item;
7612         }
7613
7614         return NULL;
7615 }
7616
7617 static struct devlink_trap_item *
7618 devlink_trap_item_lookup(struct devlink *devlink, const char *name)
7619 {
7620         struct devlink_trap_item *trap_item;
7621
7622         list_for_each_entry(trap_item, &devlink->trap_list, list) {
7623                 if (!strcmp(trap_item->trap->name, name))
7624                         return trap_item;
7625         }
7626
7627         return NULL;
7628 }
7629
7630 static struct devlink_trap_item *
7631 devlink_trap_item_get_from_info(struct devlink *devlink,
7632                                 struct genl_info *info)
7633 {
7634         struct nlattr *attr;
7635
7636         if (!info->attrs[DEVLINK_ATTR_TRAP_NAME])
7637                 return NULL;
7638         attr = info->attrs[DEVLINK_ATTR_TRAP_NAME];
7639
7640         return devlink_trap_item_lookup(devlink, nla_data(attr));
7641 }
7642
7643 static int
7644 devlink_trap_action_get_from_info(struct genl_info *info,
7645                                   enum devlink_trap_action *p_trap_action)
7646 {
7647         u8 val;
7648
7649         val = nla_get_u8(info->attrs[DEVLINK_ATTR_TRAP_ACTION]);
7650         switch (val) {
7651         case DEVLINK_TRAP_ACTION_DROP:
7652         case DEVLINK_TRAP_ACTION_TRAP:
7653         case DEVLINK_TRAP_ACTION_MIRROR:
7654                 *p_trap_action = val;
7655                 break;
7656         default:
7657                 return -EINVAL;
7658         }
7659
7660         return 0;
7661 }
7662
7663 static int devlink_trap_metadata_put(struct sk_buff *msg,
7664                                      const struct devlink_trap *trap)
7665 {
7666         struct nlattr *attr;
7667
7668         attr = nla_nest_start(msg, DEVLINK_ATTR_TRAP_METADATA);
7669         if (!attr)
7670                 return -EMSGSIZE;
7671
7672         if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT) &&
7673             nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT))
7674                 goto nla_put_failure;
7675         if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE) &&
7676             nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE))
7677                 goto nla_put_failure;
7678
7679         nla_nest_end(msg, attr);
7680
7681         return 0;
7682
7683 nla_put_failure:
7684         nla_nest_cancel(msg, attr);
7685         return -EMSGSIZE;
7686 }
7687
7688 static void devlink_trap_stats_read(struct devlink_stats __percpu *trap_stats,
7689                                     struct devlink_stats *stats)
7690 {
7691         int i;
7692
7693         memset(stats, 0, sizeof(*stats));
7694         for_each_possible_cpu(i) {
7695                 struct devlink_stats *cpu_stats;
7696                 u64 rx_packets, rx_bytes;
7697                 unsigned int start;
7698
7699                 cpu_stats = per_cpu_ptr(trap_stats, i);
7700                 do {
7701                         start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
7702                         rx_packets = cpu_stats->rx_packets;
7703                         rx_bytes = cpu_stats->rx_bytes;
7704                 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
7705
7706                 stats->rx_packets += rx_packets;
7707                 stats->rx_bytes += rx_bytes;
7708         }
7709 }
7710
7711 static int
7712 devlink_trap_group_stats_put(struct sk_buff *msg,
7713                              struct devlink_stats __percpu *trap_stats)
7714 {
7715         struct devlink_stats stats;
7716         struct nlattr *attr;
7717
7718         devlink_trap_stats_read(trap_stats, &stats);
7719
7720         attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
7721         if (!attr)
7722                 return -EMSGSIZE;
7723
7724         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
7725                               stats.rx_packets, DEVLINK_ATTR_PAD))
7726                 goto nla_put_failure;
7727
7728         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
7729                               stats.rx_bytes, DEVLINK_ATTR_PAD))
7730                 goto nla_put_failure;
7731
7732         nla_nest_end(msg, attr);
7733
7734         return 0;
7735
7736 nla_put_failure:
7737         nla_nest_cancel(msg, attr);
7738         return -EMSGSIZE;
7739 }
7740
7741 static int devlink_trap_stats_put(struct sk_buff *msg, struct devlink *devlink,
7742                                   const struct devlink_trap_item *trap_item)
7743 {
7744         struct devlink_stats stats;
7745         struct nlattr *attr;
7746         u64 drops = 0;
7747         int err;
7748
7749         if (devlink->ops->trap_drop_counter_get) {
7750                 err = devlink->ops->trap_drop_counter_get(devlink,
7751                                                           trap_item->trap,
7752                                                           &drops);
7753                 if (err)
7754                         return err;
7755         }
7756
7757         devlink_trap_stats_read(trap_item->stats, &stats);
7758
7759         attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
7760         if (!attr)
7761                 return -EMSGSIZE;
7762
7763         if (devlink->ops->trap_drop_counter_get &&
7764             nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_DROPPED, drops,
7765                               DEVLINK_ATTR_PAD))
7766                 goto nla_put_failure;
7767
7768         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
7769                               stats.rx_packets, DEVLINK_ATTR_PAD))
7770                 goto nla_put_failure;
7771
7772         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
7773                               stats.rx_bytes, DEVLINK_ATTR_PAD))
7774                 goto nla_put_failure;
7775
7776         nla_nest_end(msg, attr);
7777
7778         return 0;
7779
7780 nla_put_failure:
7781         nla_nest_cancel(msg, attr);
7782         return -EMSGSIZE;
7783 }
7784
7785 static int devlink_nl_trap_fill(struct sk_buff *msg, struct devlink *devlink,
7786                                 const struct devlink_trap_item *trap_item,
7787                                 enum devlink_command cmd, u32 portid, u32 seq,
7788                                 int flags)
7789 {
7790         struct devlink_trap_group_item *group_item = trap_item->group_item;
7791         void *hdr;
7792         int err;
7793
7794         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
7795         if (!hdr)
7796                 return -EMSGSIZE;
7797
7798         if (devlink_nl_put_handle(msg, devlink))
7799                 goto nla_put_failure;
7800
7801         if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
7802                            group_item->group->name))
7803                 goto nla_put_failure;
7804
7805         if (nla_put_string(msg, DEVLINK_ATTR_TRAP_NAME, trap_item->trap->name))
7806                 goto nla_put_failure;
7807
7808         if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_TYPE, trap_item->trap->type))
7809                 goto nla_put_failure;
7810
7811         if (trap_item->trap->generic &&
7812             nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
7813                 goto nla_put_failure;
7814
7815         if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_ACTION, trap_item->action))
7816                 goto nla_put_failure;
7817
7818         err = devlink_trap_metadata_put(msg, trap_item->trap);
7819         if (err)
7820                 goto nla_put_failure;
7821
7822         err = devlink_trap_stats_put(msg, devlink, trap_item);
7823         if (err)
7824                 goto nla_put_failure;
7825
7826         genlmsg_end(msg, hdr);
7827
7828         return 0;
7829
7830 nla_put_failure:
7831         genlmsg_cancel(msg, hdr);
7832         return -EMSGSIZE;
7833 }
7834
7835 static int devlink_nl_cmd_trap_get_doit(struct sk_buff *skb,
7836                                         struct genl_info *info)
7837 {
7838         struct netlink_ext_ack *extack = info->extack;
7839         struct devlink *devlink = info->user_ptr[0];
7840         struct devlink_trap_item *trap_item;
7841         struct sk_buff *msg;
7842         int err;
7843
7844         if (list_empty(&devlink->trap_list))
7845                 return -EOPNOTSUPP;
7846
7847         trap_item = devlink_trap_item_get_from_info(devlink, info);
7848         if (!trap_item) {
7849                 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
7850                 return -ENOENT;
7851         }
7852
7853         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7854         if (!msg)
7855                 return -ENOMEM;
7856
7857         err = devlink_nl_trap_fill(msg, devlink, trap_item,
7858                                    DEVLINK_CMD_TRAP_NEW, info->snd_portid,
7859                                    info->snd_seq, 0);
7860         if (err)
7861                 goto err_trap_fill;
7862
7863         return genlmsg_reply(msg, info);
7864
7865 err_trap_fill:
7866         nlmsg_free(msg);
7867         return err;
7868 }
7869
7870 static int devlink_nl_cmd_trap_get_dumpit(struct sk_buff *msg,
7871                                           struct netlink_callback *cb)
7872 {
7873         struct devlink_trap_item *trap_item;
7874         struct devlink *devlink;
7875         int start = cb->args[0];
7876         unsigned long index;
7877         int idx = 0;
7878         int err;
7879
7880         mutex_lock(&devlink_mutex);
7881         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
7882                 if (!devlink_try_get(devlink))
7883                         continue;
7884
7885                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7886                         goto retry;
7887
7888                 mutex_lock(&devlink->lock);
7889                 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7890                         if (idx < start) {
7891                                 idx++;
7892                                 continue;
7893                         }
7894                         err = devlink_nl_trap_fill(msg, devlink, trap_item,
7895                                                    DEVLINK_CMD_TRAP_NEW,
7896                                                    NETLINK_CB(cb->skb).portid,
7897                                                    cb->nlh->nlmsg_seq,
7898                                                    NLM_F_MULTI);
7899                         if (err) {
7900                                 mutex_unlock(&devlink->lock);
7901                                 devlink_put(devlink);
7902                                 goto out;
7903                         }
7904                         idx++;
7905                 }
7906                 mutex_unlock(&devlink->lock);
7907 retry:
7908                 devlink_put(devlink);
7909         }
7910 out:
7911         mutex_unlock(&devlink_mutex);
7912
7913         cb->args[0] = idx;
7914         return msg->len;
7915 }
7916
7917 static int __devlink_trap_action_set(struct devlink *devlink,
7918                                      struct devlink_trap_item *trap_item,
7919                                      enum devlink_trap_action trap_action,
7920                                      struct netlink_ext_ack *extack)
7921 {
7922         int err;
7923
7924         if (trap_item->action != trap_action &&
7925             trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP) {
7926                 NL_SET_ERR_MSG_MOD(extack, "Cannot change action of non-drop traps. Skipping");
7927                 return 0;
7928         }
7929
7930         err = devlink->ops->trap_action_set(devlink, trap_item->trap,
7931                                             trap_action, extack);
7932         if (err)
7933                 return err;
7934
7935         trap_item->action = trap_action;
7936
7937         return 0;
7938 }
7939
7940 static int devlink_trap_action_set(struct devlink *devlink,
7941                                    struct devlink_trap_item *trap_item,
7942                                    struct genl_info *info)
7943 {
7944         enum devlink_trap_action trap_action;
7945         int err;
7946
7947         if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
7948                 return 0;
7949
7950         err = devlink_trap_action_get_from_info(info, &trap_action);
7951         if (err) {
7952                 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
7953                 return -EINVAL;
7954         }
7955
7956         return __devlink_trap_action_set(devlink, trap_item, trap_action,
7957                                          info->extack);
7958 }
7959
7960 static int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb,
7961                                         struct genl_info *info)
7962 {
7963         struct netlink_ext_ack *extack = info->extack;
7964         struct devlink *devlink = info->user_ptr[0];
7965         struct devlink_trap_item *trap_item;
7966
7967         if (list_empty(&devlink->trap_list))
7968                 return -EOPNOTSUPP;
7969
7970         trap_item = devlink_trap_item_get_from_info(devlink, info);
7971         if (!trap_item) {
7972                 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
7973                 return -ENOENT;
7974         }
7975
7976         return devlink_trap_action_set(devlink, trap_item, info);
7977 }
7978
7979 static struct devlink_trap_group_item *
7980 devlink_trap_group_item_lookup(struct devlink *devlink, const char *name)
7981 {
7982         struct devlink_trap_group_item *group_item;
7983
7984         list_for_each_entry(group_item, &devlink->trap_group_list, list) {
7985                 if (!strcmp(group_item->group->name, name))
7986                         return group_item;
7987         }
7988
7989         return NULL;
7990 }
7991
7992 static struct devlink_trap_group_item *
7993 devlink_trap_group_item_lookup_by_id(struct devlink *devlink, u16 id)
7994 {
7995         struct devlink_trap_group_item *group_item;
7996
7997         list_for_each_entry(group_item, &devlink->trap_group_list, list) {
7998                 if (group_item->group->id == id)
7999                         return group_item;
8000         }
8001
8002         return NULL;
8003 }
8004
8005 static struct devlink_trap_group_item *
8006 devlink_trap_group_item_get_from_info(struct devlink *devlink,
8007                                       struct genl_info *info)
8008 {
8009         char *name;
8010
8011         if (!info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME])
8012                 return NULL;
8013         name = nla_data(info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME]);
8014
8015         return devlink_trap_group_item_lookup(devlink, name);
8016 }
8017
8018 static int
8019 devlink_nl_trap_group_fill(struct sk_buff *msg, struct devlink *devlink,
8020                            const struct devlink_trap_group_item *group_item,
8021                            enum devlink_command cmd, u32 portid, u32 seq,
8022                            int flags)
8023 {
8024         void *hdr;
8025         int err;
8026
8027         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
8028         if (!hdr)
8029                 return -EMSGSIZE;
8030
8031         if (devlink_nl_put_handle(msg, devlink))
8032                 goto nla_put_failure;
8033
8034         if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
8035                            group_item->group->name))
8036                 goto nla_put_failure;
8037
8038         if (group_item->group->generic &&
8039             nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
8040                 goto nla_put_failure;
8041
8042         if (group_item->policer_item &&
8043             nla_put_u32(msg, DEVLINK_ATTR_TRAP_POLICER_ID,
8044                         group_item->policer_item->policer->id))
8045                 goto nla_put_failure;
8046
8047         err = devlink_trap_group_stats_put(msg, group_item->stats);
8048         if (err)
8049                 goto nla_put_failure;
8050
8051         genlmsg_end(msg, hdr);
8052
8053         return 0;
8054
8055 nla_put_failure:
8056         genlmsg_cancel(msg, hdr);
8057         return -EMSGSIZE;
8058 }
8059
8060 static int devlink_nl_cmd_trap_group_get_doit(struct sk_buff *skb,
8061                                               struct genl_info *info)
8062 {
8063         struct netlink_ext_ack *extack = info->extack;
8064         struct devlink *devlink = info->user_ptr[0];
8065         struct devlink_trap_group_item *group_item;
8066         struct sk_buff *msg;
8067         int err;
8068
8069         if (list_empty(&devlink->trap_group_list))
8070                 return -EOPNOTSUPP;
8071
8072         group_item = devlink_trap_group_item_get_from_info(devlink, info);
8073         if (!group_item) {
8074                 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
8075                 return -ENOENT;
8076         }
8077
8078         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8079         if (!msg)
8080                 return -ENOMEM;
8081
8082         err = devlink_nl_trap_group_fill(msg, devlink, group_item,
8083                                          DEVLINK_CMD_TRAP_GROUP_NEW,
8084                                          info->snd_portid, info->snd_seq, 0);
8085         if (err)
8086                 goto err_trap_group_fill;
8087
8088         return genlmsg_reply(msg, info);
8089
8090 err_trap_group_fill:
8091         nlmsg_free(msg);
8092         return err;
8093 }
8094
8095 static int devlink_nl_cmd_trap_group_get_dumpit(struct sk_buff *msg,
8096                                                 struct netlink_callback *cb)
8097 {
8098         enum devlink_command cmd = DEVLINK_CMD_TRAP_GROUP_NEW;
8099         struct devlink_trap_group_item *group_item;
8100         u32 portid = NETLINK_CB(cb->skb).portid;
8101         struct devlink *devlink;
8102         int start = cb->args[0];
8103         unsigned long index;
8104         int idx = 0;
8105         int err;
8106
8107         mutex_lock(&devlink_mutex);
8108         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
8109                 if (!devlink_try_get(devlink))
8110                         continue;
8111
8112                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
8113                         goto retry;
8114
8115                 mutex_lock(&devlink->lock);
8116                 list_for_each_entry(group_item, &devlink->trap_group_list,
8117                                     list) {
8118                         if (idx < start) {
8119                                 idx++;
8120                                 continue;
8121                         }
8122                         err = devlink_nl_trap_group_fill(msg, devlink,
8123                                                          group_item, cmd,
8124                                                          portid,
8125                                                          cb->nlh->nlmsg_seq,
8126                                                          NLM_F_MULTI);
8127                         if (err) {
8128                                 mutex_unlock(&devlink->lock);
8129                                 devlink_put(devlink);
8130                                 goto out;
8131                         }
8132                         idx++;
8133                 }
8134                 mutex_unlock(&devlink->lock);
8135 retry:
8136                 devlink_put(devlink);
8137         }
8138 out:
8139         mutex_unlock(&devlink_mutex);
8140
8141         cb->args[0] = idx;
8142         return msg->len;
8143 }
8144
8145 static int
8146 __devlink_trap_group_action_set(struct devlink *devlink,
8147                                 struct devlink_trap_group_item *group_item,
8148                                 enum devlink_trap_action trap_action,
8149                                 struct netlink_ext_ack *extack)
8150 {
8151         const char *group_name = group_item->group->name;
8152         struct devlink_trap_item *trap_item;
8153         int err;
8154
8155         if (devlink->ops->trap_group_action_set) {
8156                 err = devlink->ops->trap_group_action_set(devlink, group_item->group,
8157                                                           trap_action, extack);
8158                 if (err)
8159                         return err;
8160
8161                 list_for_each_entry(trap_item, &devlink->trap_list, list) {
8162                         if (strcmp(trap_item->group_item->group->name, group_name))
8163                                 continue;
8164                         if (trap_item->action != trap_action &&
8165                             trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP)
8166                                 continue;
8167                         trap_item->action = trap_action;
8168                 }
8169
8170                 return 0;
8171         }
8172
8173         list_for_each_entry(trap_item, &devlink->trap_list, list) {
8174                 if (strcmp(trap_item->group_item->group->name, group_name))
8175                         continue;
8176                 err = __devlink_trap_action_set(devlink, trap_item,
8177                                                 trap_action, extack);
8178                 if (err)
8179                         return err;
8180         }
8181
8182         return 0;
8183 }
8184
8185 static int
8186 devlink_trap_group_action_set(struct devlink *devlink,
8187                               struct devlink_trap_group_item *group_item,
8188                               struct genl_info *info, bool *p_modified)
8189 {
8190         enum devlink_trap_action trap_action;
8191         int err;
8192
8193         if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
8194                 return 0;
8195
8196         err = devlink_trap_action_get_from_info(info, &trap_action);
8197         if (err) {
8198                 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
8199                 return -EINVAL;
8200         }
8201
8202         err = __devlink_trap_group_action_set(devlink, group_item, trap_action,
8203                                               info->extack);
8204         if (err)
8205                 return err;
8206
8207         *p_modified = true;
8208
8209         return 0;
8210 }
8211
8212 static int devlink_trap_group_set(struct devlink *devlink,
8213                                   struct devlink_trap_group_item *group_item,
8214                                   struct genl_info *info)
8215 {
8216         struct devlink_trap_policer_item *policer_item;
8217         struct netlink_ext_ack *extack = info->extack;
8218         const struct devlink_trap_policer *policer;
8219         struct nlattr **attrs = info->attrs;
8220         int err;
8221
8222         if (!attrs[DEVLINK_ATTR_TRAP_POLICER_ID])
8223                 return 0;
8224
8225         if (!devlink->ops->trap_group_set)
8226                 return -EOPNOTSUPP;
8227
8228         policer_item = group_item->policer_item;
8229         if (attrs[DEVLINK_ATTR_TRAP_POLICER_ID]) {
8230                 u32 policer_id;
8231
8232                 policer_id = nla_get_u32(attrs[DEVLINK_ATTR_TRAP_POLICER_ID]);
8233                 policer_item = devlink_trap_policer_item_lookup(devlink,
8234                                                                 policer_id);
8235                 if (policer_id && !policer_item) {
8236                         NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8237                         return -ENOENT;
8238                 }
8239         }
8240         policer = policer_item ? policer_item->policer : NULL;
8241
8242         err = devlink->ops->trap_group_set(devlink, group_item->group, policer,
8243                                            extack);
8244         if (err)
8245                 return err;
8246
8247         group_item->policer_item = policer_item;
8248
8249         return 0;
8250 }
8251
8252 static int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
8253                                               struct genl_info *info)
8254 {
8255         struct netlink_ext_ack *extack = info->extack;
8256         struct devlink *devlink = info->user_ptr[0];
8257         struct devlink_trap_group_item *group_item;
8258         bool modified = false;
8259         int err;
8260
8261         if (list_empty(&devlink->trap_group_list))
8262                 return -EOPNOTSUPP;
8263
8264         group_item = devlink_trap_group_item_get_from_info(devlink, info);
8265         if (!group_item) {
8266                 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
8267                 return -ENOENT;
8268         }
8269
8270         err = devlink_trap_group_action_set(devlink, group_item, info,
8271                                             &modified);
8272         if (err)
8273                 return err;
8274
8275         err = devlink_trap_group_set(devlink, group_item, info);
8276         if (err)
8277                 goto err_trap_group_set;
8278
8279         return 0;
8280
8281 err_trap_group_set:
8282         if (modified)
8283                 NL_SET_ERR_MSG_MOD(extack, "Trap group set failed, but some changes were committed already");
8284         return err;
8285 }
8286
8287 static struct devlink_trap_policer_item *
8288 devlink_trap_policer_item_get_from_info(struct devlink *devlink,
8289                                         struct genl_info *info)
8290 {
8291         u32 id;
8292
8293         if (!info->attrs[DEVLINK_ATTR_TRAP_POLICER_ID])
8294                 return NULL;
8295         id = nla_get_u32(info->attrs[DEVLINK_ATTR_TRAP_POLICER_ID]);
8296
8297         return devlink_trap_policer_item_lookup(devlink, id);
8298 }
8299
8300 static int
8301 devlink_trap_policer_stats_put(struct sk_buff *msg, struct devlink *devlink,
8302                                const struct devlink_trap_policer *policer)
8303 {
8304         struct nlattr *attr;
8305         u64 drops;
8306         int err;
8307
8308         if (!devlink->ops->trap_policer_counter_get)
8309                 return 0;
8310
8311         err = devlink->ops->trap_policer_counter_get(devlink, policer, &drops);
8312         if (err)
8313                 return err;
8314
8315         attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
8316         if (!attr)
8317                 return -EMSGSIZE;
8318
8319         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_DROPPED, drops,
8320                               DEVLINK_ATTR_PAD))
8321                 goto nla_put_failure;
8322
8323         nla_nest_end(msg, attr);
8324
8325         return 0;
8326
8327 nla_put_failure:
8328         nla_nest_cancel(msg, attr);
8329         return -EMSGSIZE;
8330 }
8331
8332 static int
8333 devlink_nl_trap_policer_fill(struct sk_buff *msg, struct devlink *devlink,
8334                              const struct devlink_trap_policer_item *policer_item,
8335                              enum devlink_command cmd, u32 portid, u32 seq,
8336                              int flags)
8337 {
8338         void *hdr;
8339         int err;
8340
8341         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
8342         if (!hdr)
8343                 return -EMSGSIZE;
8344
8345         if (devlink_nl_put_handle(msg, devlink))
8346                 goto nla_put_failure;
8347
8348         if (nla_put_u32(msg, DEVLINK_ATTR_TRAP_POLICER_ID,
8349                         policer_item->policer->id))
8350                 goto nla_put_failure;
8351
8352         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_TRAP_POLICER_RATE,
8353                               policer_item->rate, DEVLINK_ATTR_PAD))
8354                 goto nla_put_failure;
8355
8356         if (nla_put_u64_64bit(msg, DEVLINK_ATTR_TRAP_POLICER_BURST,
8357                               policer_item->burst, DEVLINK_ATTR_PAD))
8358                 goto nla_put_failure;
8359
8360         err = devlink_trap_policer_stats_put(msg, devlink,
8361                                              policer_item->policer);
8362         if (err)
8363                 goto nla_put_failure;
8364
8365         genlmsg_end(msg, hdr);
8366
8367         return 0;
8368
8369 nla_put_failure:
8370         genlmsg_cancel(msg, hdr);
8371         return -EMSGSIZE;
8372 }
8373
8374 static int devlink_nl_cmd_trap_policer_get_doit(struct sk_buff *skb,
8375                                                 struct genl_info *info)
8376 {
8377         struct devlink_trap_policer_item *policer_item;
8378         struct netlink_ext_ack *extack = info->extack;
8379         struct devlink *devlink = info->user_ptr[0];
8380         struct sk_buff *msg;
8381         int err;
8382
8383         if (list_empty(&devlink->trap_policer_list))
8384                 return -EOPNOTSUPP;
8385
8386         policer_item = devlink_trap_policer_item_get_from_info(devlink, info);
8387         if (!policer_item) {
8388                 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8389                 return -ENOENT;
8390         }
8391
8392         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8393         if (!msg)
8394                 return -ENOMEM;
8395
8396         err = devlink_nl_trap_policer_fill(msg, devlink, policer_item,
8397                                            DEVLINK_CMD_TRAP_POLICER_NEW,
8398                                            info->snd_portid, info->snd_seq, 0);
8399         if (err)
8400                 goto err_trap_policer_fill;
8401
8402         return genlmsg_reply(msg, info);
8403
8404 err_trap_policer_fill:
8405         nlmsg_free(msg);
8406         return err;
8407 }
8408
8409 static int devlink_nl_cmd_trap_policer_get_dumpit(struct sk_buff *msg,
8410                                                   struct netlink_callback *cb)
8411 {
8412         enum devlink_command cmd = DEVLINK_CMD_TRAP_POLICER_NEW;
8413         struct devlink_trap_policer_item *policer_item;
8414         u32 portid = NETLINK_CB(cb->skb).portid;
8415         struct devlink *devlink;
8416         int start = cb->args[0];
8417         unsigned long index;
8418         int idx = 0;
8419         int err;
8420
8421         mutex_lock(&devlink_mutex);
8422         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
8423                 if (!devlink_try_get(devlink))
8424                         continue;
8425
8426                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
8427                         goto retry;
8428
8429                 mutex_lock(&devlink->lock);
8430                 list_for_each_entry(policer_item, &devlink->trap_policer_list,
8431                                     list) {
8432                         if (idx < start) {
8433                                 idx++;
8434                                 continue;
8435                         }
8436                         err = devlink_nl_trap_policer_fill(msg, devlink,
8437                                                            policer_item, cmd,
8438                                                            portid,
8439                                                            cb->nlh->nlmsg_seq,
8440                                                            NLM_F_MULTI);
8441                         if (err) {
8442                                 mutex_unlock(&devlink->lock);
8443                                 devlink_put(devlink);
8444                                 goto out;
8445                         }
8446                         idx++;
8447                 }
8448                 mutex_unlock(&devlink->lock);
8449 retry:
8450                 devlink_put(devlink);
8451         }
8452 out:
8453         mutex_unlock(&devlink_mutex);
8454
8455         cb->args[0] = idx;
8456         return msg->len;
8457 }
8458
8459 static int
8460 devlink_trap_policer_set(struct devlink *devlink,
8461                          struct devlink_trap_policer_item *policer_item,
8462                          struct genl_info *info)
8463 {
8464         struct netlink_ext_ack *extack = info->extack;
8465         struct nlattr **attrs = info->attrs;
8466         u64 rate, burst;
8467         int err;
8468
8469         rate = policer_item->rate;
8470         burst = policer_item->burst;
8471
8472         if (attrs[DEVLINK_ATTR_TRAP_POLICER_RATE])
8473                 rate = nla_get_u64(attrs[DEVLINK_ATTR_TRAP_POLICER_RATE]);
8474
8475         if (attrs[DEVLINK_ATTR_TRAP_POLICER_BURST])
8476                 burst = nla_get_u64(attrs[DEVLINK_ATTR_TRAP_POLICER_BURST]);
8477
8478         if (rate < policer_item->policer->min_rate) {
8479                 NL_SET_ERR_MSG_MOD(extack, "Policer rate lower than limit");
8480                 return -EINVAL;
8481         }
8482
8483         if (rate > policer_item->policer->max_rate) {
8484                 NL_SET_ERR_MSG_MOD(extack, "Policer rate higher than limit");
8485                 return -EINVAL;
8486         }
8487
8488         if (burst < policer_item->policer->min_burst) {
8489                 NL_SET_ERR_MSG_MOD(extack, "Policer burst size lower than limit");
8490                 return -EINVAL;
8491         }
8492
8493         if (burst > policer_item->policer->max_burst) {
8494                 NL_SET_ERR_MSG_MOD(extack, "Policer burst size higher than limit");
8495                 return -EINVAL;
8496         }
8497
8498         err = devlink->ops->trap_policer_set(devlink, policer_item->policer,
8499                                              rate, burst, info->extack);
8500         if (err)
8501                 return err;
8502
8503         policer_item->rate = rate;
8504         policer_item->burst = burst;
8505
8506         return 0;
8507 }
8508
8509 static int devlink_nl_cmd_trap_policer_set_doit(struct sk_buff *skb,
8510                                                 struct genl_info *info)
8511 {
8512         struct devlink_trap_policer_item *policer_item;
8513         struct netlink_ext_ack *extack = info->extack;
8514         struct devlink *devlink = info->user_ptr[0];
8515
8516         if (list_empty(&devlink->trap_policer_list))
8517                 return -EOPNOTSUPP;
8518
8519         if (!devlink->ops->trap_policer_set)
8520                 return -EOPNOTSUPP;
8521
8522         policer_item = devlink_trap_policer_item_get_from_info(devlink, info);
8523         if (!policer_item) {
8524                 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8525                 return -ENOENT;
8526         }
8527
8528         return devlink_trap_policer_set(devlink, policer_item, info);
8529 }
8530
8531 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
8532         [DEVLINK_ATTR_UNSPEC] = { .strict_start_type =
8533                 DEVLINK_ATTR_TRAP_POLICER_ID },
8534         [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
8535         [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
8536         [DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
8537         [DEVLINK_ATTR_PORT_TYPE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_PORT_TYPE_AUTO,
8538                                                     DEVLINK_PORT_TYPE_IB),
8539         [DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
8540         [DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
8541         [DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
8542         [DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
8543         [DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
8544         [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
8545         [DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
8546         [DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
8547         [DEVLINK_ATTR_ESWITCH_MODE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_ESWITCH_MODE_LEGACY,
8548                                                        DEVLINK_ESWITCH_MODE_SWITCHDEV),
8549         [DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
8550         [DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
8551         [DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
8552         [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
8553         [DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
8554         [DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
8555         [DEVLINK_ATTR_PARAM_NAME] = { .type = NLA_NUL_STRING },
8556         [DEVLINK_ATTR_PARAM_TYPE] = { .type = NLA_U8 },
8557         [DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },
8558         [DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },
8559         [DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },
8560         [DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .type = NLA_U64 },
8561         [DEVLINK_ATTR_REGION_CHUNK_LEN] = { .type = NLA_U64 },
8562         [DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },
8563         [DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },
8564         [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },
8565         [DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING },
8566         [DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING },
8567         [DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK] =
8568                 NLA_POLICY_BITFIELD32(DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS),
8569         [DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING },
8570         [DEVLINK_ATTR_TRAP_ACTION] = { .type = NLA_U8 },
8571         [DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING },
8572         [DEVLINK_ATTR_NETNS_PID] = { .type = NLA_U32 },
8573         [DEVLINK_ATTR_NETNS_FD] = { .type = NLA_U32 },
8574         [DEVLINK_ATTR_NETNS_ID] = { .type = NLA_U32 },
8575         [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP] = { .type = NLA_U8 },
8576         [DEVLINK_ATTR_TRAP_POLICER_ID] = { .type = NLA_U32 },
8577         [DEVLINK_ATTR_TRAP_POLICER_RATE] = { .type = NLA_U64 },
8578         [DEVLINK_ATTR_TRAP_POLICER_BURST] = { .type = NLA_U64 },
8579         [DEVLINK_ATTR_PORT_FUNCTION] = { .type = NLA_NESTED },
8580         [DEVLINK_ATTR_RELOAD_ACTION] = NLA_POLICY_RANGE(NLA_U8, DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
8581                                                         DEVLINK_RELOAD_ACTION_MAX),
8582         [DEVLINK_ATTR_RELOAD_LIMITS] = NLA_POLICY_BITFIELD32(DEVLINK_RELOAD_LIMITS_VALID_MASK),
8583         [DEVLINK_ATTR_PORT_FLAVOUR] = { .type = NLA_U16 },
8584         [DEVLINK_ATTR_PORT_PCI_PF_NUMBER] = { .type = NLA_U16 },
8585         [DEVLINK_ATTR_PORT_PCI_SF_NUMBER] = { .type = NLA_U32 },
8586         [DEVLINK_ATTR_PORT_CONTROLLER_NUMBER] = { .type = NLA_U32 },
8587         [DEVLINK_ATTR_RATE_TYPE] = { .type = NLA_U16 },
8588         [DEVLINK_ATTR_RATE_TX_SHARE] = { .type = NLA_U64 },
8589         [DEVLINK_ATTR_RATE_TX_MAX] = { .type = NLA_U64 },
8590         [DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING },
8591         [DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .type = NLA_NUL_STRING },
8592 };
8593
8594 static const struct genl_small_ops devlink_nl_ops[] = {
8595         {
8596                 .cmd = DEVLINK_CMD_GET,
8597                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8598                 .doit = devlink_nl_cmd_get_doit,
8599                 .dumpit = devlink_nl_cmd_get_dumpit,
8600                 /* can be retrieved by unprivileged users */
8601         },
8602         {
8603                 .cmd = DEVLINK_CMD_PORT_GET,
8604                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8605                 .doit = devlink_nl_cmd_port_get_doit,
8606                 .dumpit = devlink_nl_cmd_port_get_dumpit,
8607                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8608                 /* can be retrieved by unprivileged users */
8609         },
8610         {
8611                 .cmd = DEVLINK_CMD_PORT_SET,
8612                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8613                 .doit = devlink_nl_cmd_port_set_doit,
8614                 .flags = GENL_ADMIN_PERM,
8615                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8616         },
8617         {
8618                 .cmd = DEVLINK_CMD_RATE_GET,
8619                 .doit = devlink_nl_cmd_rate_get_doit,
8620                 .dumpit = devlink_nl_cmd_rate_get_dumpit,
8621                 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE,
8622                 /* can be retrieved by unprivileged users */
8623         },
8624         {
8625                 .cmd = DEVLINK_CMD_RATE_SET,
8626                 .doit = devlink_nl_cmd_rate_set_doit,
8627                 .flags = GENL_ADMIN_PERM,
8628                 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE,
8629         },
8630         {
8631                 .cmd = DEVLINK_CMD_RATE_NEW,
8632                 .doit = devlink_nl_cmd_rate_new_doit,
8633                 .flags = GENL_ADMIN_PERM,
8634         },
8635         {
8636                 .cmd = DEVLINK_CMD_RATE_DEL,
8637                 .doit = devlink_nl_cmd_rate_del_doit,
8638                 .flags = GENL_ADMIN_PERM,
8639                 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE_NODE,
8640         },
8641         {
8642                 .cmd = DEVLINK_CMD_PORT_SPLIT,
8643                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8644                 .doit = devlink_nl_cmd_port_split_doit,
8645                 .flags = GENL_ADMIN_PERM,
8646                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8647         },
8648         {
8649                 .cmd = DEVLINK_CMD_PORT_UNSPLIT,
8650                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8651                 .doit = devlink_nl_cmd_port_unsplit_doit,
8652                 .flags = GENL_ADMIN_PERM,
8653                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8654         },
8655         {
8656                 .cmd = DEVLINK_CMD_PORT_NEW,
8657                 .doit = devlink_nl_cmd_port_new_doit,
8658                 .flags = GENL_ADMIN_PERM,
8659                 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8660         },
8661         {
8662                 .cmd = DEVLINK_CMD_PORT_DEL,
8663                 .doit = devlink_nl_cmd_port_del_doit,
8664                 .flags = GENL_ADMIN_PERM,
8665                 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8666         },
8667         {
8668                 .cmd = DEVLINK_CMD_SB_GET,
8669                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8670                 .doit = devlink_nl_cmd_sb_get_doit,
8671                 .dumpit = devlink_nl_cmd_sb_get_dumpit,
8672                 /* can be retrieved by unprivileged users */
8673         },
8674         {
8675                 .cmd = DEVLINK_CMD_SB_POOL_GET,
8676                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8677                 .doit = devlink_nl_cmd_sb_pool_get_doit,
8678                 .dumpit = devlink_nl_cmd_sb_pool_get_dumpit,
8679                 /* can be retrieved by unprivileged users */
8680         },
8681         {
8682                 .cmd = DEVLINK_CMD_SB_POOL_SET,
8683                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8684                 .doit = devlink_nl_cmd_sb_pool_set_doit,
8685                 .flags = GENL_ADMIN_PERM,
8686         },
8687         {
8688                 .cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
8689                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8690                 .doit = devlink_nl_cmd_sb_port_pool_get_doit,
8691                 .dumpit = devlink_nl_cmd_sb_port_pool_get_dumpit,
8692                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8693                 /* can be retrieved by unprivileged users */
8694         },
8695         {
8696                 .cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
8697                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8698                 .doit = devlink_nl_cmd_sb_port_pool_set_doit,
8699                 .flags = GENL_ADMIN_PERM,
8700                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8701         },
8702         {
8703                 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
8704                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8705                 .doit = devlink_nl_cmd_sb_tc_pool_bind_get_doit,
8706                 .dumpit = devlink_nl_cmd_sb_tc_pool_bind_get_dumpit,
8707                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8708                 /* can be retrieved by unprivileged users */
8709         },
8710         {
8711                 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
8712                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8713                 .doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
8714                 .flags = GENL_ADMIN_PERM,
8715                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8716         },
8717         {
8718                 .cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
8719                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8720                 .doit = devlink_nl_cmd_sb_occ_snapshot_doit,
8721                 .flags = GENL_ADMIN_PERM,
8722         },
8723         {
8724                 .cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
8725                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8726                 .doit = devlink_nl_cmd_sb_occ_max_clear_doit,
8727                 .flags = GENL_ADMIN_PERM,
8728         },
8729         {
8730                 .cmd = DEVLINK_CMD_ESWITCH_GET,
8731                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8732                 .doit = devlink_nl_cmd_eswitch_get_doit,
8733                 .flags = GENL_ADMIN_PERM,
8734         },
8735         {
8736                 .cmd = DEVLINK_CMD_ESWITCH_SET,
8737                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8738                 .doit = devlink_nl_cmd_eswitch_set_doit,
8739                 .flags = GENL_ADMIN_PERM,
8740         },
8741         {
8742                 .cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
8743                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8744                 .doit = devlink_nl_cmd_dpipe_table_get,
8745                 /* can be retrieved by unprivileged users */
8746         },
8747         {
8748                 .cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
8749                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8750                 .doit = devlink_nl_cmd_dpipe_entries_get,
8751                 /* can be retrieved by unprivileged users */
8752         },
8753         {
8754                 .cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
8755                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8756                 .doit = devlink_nl_cmd_dpipe_headers_get,
8757                 /* can be retrieved by unprivileged users */
8758         },
8759         {
8760                 .cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
8761                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8762                 .doit = devlink_nl_cmd_dpipe_table_counters_set,
8763                 .flags = GENL_ADMIN_PERM,
8764         },
8765         {
8766                 .cmd = DEVLINK_CMD_RESOURCE_SET,
8767                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8768                 .doit = devlink_nl_cmd_resource_set,
8769                 .flags = GENL_ADMIN_PERM,
8770         },
8771         {
8772                 .cmd = DEVLINK_CMD_RESOURCE_DUMP,
8773                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8774                 .doit = devlink_nl_cmd_resource_dump,
8775                 /* can be retrieved by unprivileged users */
8776         },
8777         {
8778                 .cmd = DEVLINK_CMD_RELOAD,
8779                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8780                 .doit = devlink_nl_cmd_reload,
8781                 .flags = GENL_ADMIN_PERM,
8782                 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8783         },
8784         {
8785                 .cmd = DEVLINK_CMD_PARAM_GET,
8786                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8787                 .doit = devlink_nl_cmd_param_get_doit,
8788                 .dumpit = devlink_nl_cmd_param_get_dumpit,
8789                 /* can be retrieved by unprivileged users */
8790         },
8791         {
8792                 .cmd = DEVLINK_CMD_PARAM_SET,
8793                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8794                 .doit = devlink_nl_cmd_param_set_doit,
8795                 .flags = GENL_ADMIN_PERM,
8796         },
8797         {
8798                 .cmd = DEVLINK_CMD_PORT_PARAM_GET,
8799                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8800                 .doit = devlink_nl_cmd_port_param_get_doit,
8801                 .dumpit = devlink_nl_cmd_port_param_get_dumpit,
8802                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8803                 /* can be retrieved by unprivileged users */
8804         },
8805         {
8806                 .cmd = DEVLINK_CMD_PORT_PARAM_SET,
8807                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8808                 .doit = devlink_nl_cmd_port_param_set_doit,
8809                 .flags = GENL_ADMIN_PERM,
8810                 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8811         },
8812         {
8813                 .cmd = DEVLINK_CMD_REGION_GET,
8814                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8815                 .doit = devlink_nl_cmd_region_get_doit,
8816                 .dumpit = devlink_nl_cmd_region_get_dumpit,
8817                 .flags = GENL_ADMIN_PERM,
8818         },
8819         {
8820                 .cmd = DEVLINK_CMD_REGION_NEW,
8821                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8822                 .doit = devlink_nl_cmd_region_new,
8823                 .flags = GENL_ADMIN_PERM,
8824         },
8825         {
8826                 .cmd = DEVLINK_CMD_REGION_DEL,
8827                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8828                 .doit = devlink_nl_cmd_region_del,
8829                 .flags = GENL_ADMIN_PERM,
8830         },
8831         {
8832                 .cmd = DEVLINK_CMD_REGION_READ,
8833                 .validate = GENL_DONT_VALIDATE_STRICT |
8834                             GENL_DONT_VALIDATE_DUMP_STRICT,
8835                 .dumpit = devlink_nl_cmd_region_read_dumpit,
8836                 .flags = GENL_ADMIN_PERM,
8837         },
8838         {
8839                 .cmd = DEVLINK_CMD_INFO_GET,
8840                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8841                 .doit = devlink_nl_cmd_info_get_doit,
8842                 .dumpit = devlink_nl_cmd_info_get_dumpit,
8843                 /* can be retrieved by unprivileged users */
8844         },
8845         {
8846                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_GET,
8847                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8848                 .doit = devlink_nl_cmd_health_reporter_get_doit,
8849                 .dumpit = devlink_nl_cmd_health_reporter_get_dumpit,
8850                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8851                                   DEVLINK_NL_FLAG_NO_LOCK,
8852                 /* can be retrieved by unprivileged users */
8853         },
8854         {
8855                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_SET,
8856                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8857                 .doit = devlink_nl_cmd_health_reporter_set_doit,
8858                 .flags = GENL_ADMIN_PERM,
8859                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8860                                   DEVLINK_NL_FLAG_NO_LOCK,
8861         },
8862         {
8863                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_RECOVER,
8864                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8865                 .doit = devlink_nl_cmd_health_reporter_recover_doit,
8866                 .flags = GENL_ADMIN_PERM,
8867                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8868                                   DEVLINK_NL_FLAG_NO_LOCK,
8869         },
8870         {
8871                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE,
8872                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8873                 .doit = devlink_nl_cmd_health_reporter_diagnose_doit,
8874                 .flags = GENL_ADMIN_PERM,
8875                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8876                                   DEVLINK_NL_FLAG_NO_LOCK,
8877         },
8878         {
8879                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET,
8880                 .validate = GENL_DONT_VALIDATE_STRICT |
8881                             GENL_DONT_VALIDATE_DUMP_STRICT,
8882                 .dumpit = devlink_nl_cmd_health_reporter_dump_get_dumpit,
8883                 .flags = GENL_ADMIN_PERM,
8884         },
8885         {
8886                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR,
8887                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8888                 .doit = devlink_nl_cmd_health_reporter_dump_clear_doit,
8889                 .flags = GENL_ADMIN_PERM,
8890                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8891                                   DEVLINK_NL_FLAG_NO_LOCK,
8892         },
8893         {
8894                 .cmd = DEVLINK_CMD_HEALTH_REPORTER_TEST,
8895                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8896                 .doit = devlink_nl_cmd_health_reporter_test_doit,
8897                 .flags = GENL_ADMIN_PERM,
8898                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8899                                   DEVLINK_NL_FLAG_NO_LOCK,
8900         },
8901         {
8902                 .cmd = DEVLINK_CMD_FLASH_UPDATE,
8903                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8904                 .doit = devlink_nl_cmd_flash_update,
8905                 .flags = GENL_ADMIN_PERM,
8906         },
8907         {
8908                 .cmd = DEVLINK_CMD_TRAP_GET,
8909                 .doit = devlink_nl_cmd_trap_get_doit,
8910                 .dumpit = devlink_nl_cmd_trap_get_dumpit,
8911                 /* can be retrieved by unprivileged users */
8912         },
8913         {
8914                 .cmd = DEVLINK_CMD_TRAP_SET,
8915                 .doit = devlink_nl_cmd_trap_set_doit,
8916                 .flags = GENL_ADMIN_PERM,
8917         },
8918         {
8919                 .cmd = DEVLINK_CMD_TRAP_GROUP_GET,
8920                 .doit = devlink_nl_cmd_trap_group_get_doit,
8921                 .dumpit = devlink_nl_cmd_trap_group_get_dumpit,
8922                 /* can be retrieved by unprivileged users */
8923         },
8924         {
8925                 .cmd = DEVLINK_CMD_TRAP_GROUP_SET,
8926                 .doit = devlink_nl_cmd_trap_group_set_doit,
8927                 .flags = GENL_ADMIN_PERM,
8928         },
8929         {
8930                 .cmd = DEVLINK_CMD_TRAP_POLICER_GET,
8931                 .doit = devlink_nl_cmd_trap_policer_get_doit,
8932                 .dumpit = devlink_nl_cmd_trap_policer_get_dumpit,
8933                 /* can be retrieved by unprivileged users */
8934         },
8935         {
8936                 .cmd = DEVLINK_CMD_TRAP_POLICER_SET,
8937                 .doit = devlink_nl_cmd_trap_policer_set_doit,
8938                 .flags = GENL_ADMIN_PERM,
8939         },
8940 };
8941
8942 static struct genl_family devlink_nl_family __ro_after_init = {
8943         .name           = DEVLINK_GENL_NAME,
8944         .version        = DEVLINK_GENL_VERSION,
8945         .maxattr        = DEVLINK_ATTR_MAX,
8946         .policy = devlink_nl_policy,
8947         .netnsok        = true,
8948         .pre_doit       = devlink_nl_pre_doit,
8949         .post_doit      = devlink_nl_post_doit,
8950         .module         = THIS_MODULE,
8951         .small_ops      = devlink_nl_ops,
8952         .n_small_ops    = ARRAY_SIZE(devlink_nl_ops),
8953         .mcgrps         = devlink_nl_mcgrps,
8954         .n_mcgrps       = ARRAY_SIZE(devlink_nl_mcgrps),
8955 };
8956
8957 static bool devlink_reload_actions_valid(const struct devlink_ops *ops)
8958 {
8959         const struct devlink_reload_combination *comb;
8960         int i;
8961
8962         if (!devlink_reload_supported(ops)) {
8963                 if (WARN_ON(ops->reload_actions))
8964                         return false;
8965                 return true;
8966         }
8967
8968         if (WARN_ON(!ops->reload_actions ||
8969                     ops->reload_actions & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
8970                     ops->reload_actions >= BIT(__DEVLINK_RELOAD_ACTION_MAX)))
8971                 return false;
8972
8973         if (WARN_ON(ops->reload_limits & BIT(DEVLINK_RELOAD_LIMIT_UNSPEC) ||
8974                     ops->reload_limits >= BIT(__DEVLINK_RELOAD_LIMIT_MAX)))
8975                 return false;
8976
8977         for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++)  {
8978                 comb = &devlink_reload_invalid_combinations[i];
8979                 if (ops->reload_actions == BIT(comb->action) &&
8980                     ops->reload_limits == BIT(comb->limit))
8981                         return false;
8982         }
8983         return true;
8984 }
8985
8986 /**
8987  *      devlink_set_features - Set devlink supported features
8988  *
8989  *      @devlink: devlink
8990  *      @features: devlink support features
8991  *
8992  *      This interface allows us to set reload ops separatelly from
8993  *      the devlink_alloc.
8994  */
8995 void devlink_set_features(struct devlink *devlink, u64 features)
8996 {
8997         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
8998
8999         WARN_ON(features & DEVLINK_F_RELOAD &&
9000                 !devlink_reload_supported(devlink->ops));
9001         devlink->features = features;
9002 }
9003 EXPORT_SYMBOL_GPL(devlink_set_features);
9004
9005 /**
9006  *      devlink_alloc_ns - Allocate new devlink instance resources
9007  *      in specific namespace
9008  *
9009  *      @ops: ops
9010  *      @priv_size: size of user private data
9011  *      @net: net namespace
9012  *      @dev: parent device
9013  *
9014  *      Allocate new devlink instance resources, including devlink index
9015  *      and name.
9016  */
9017 struct devlink *devlink_alloc_ns(const struct devlink_ops *ops,
9018                                  size_t priv_size, struct net *net,
9019                                  struct device *dev)
9020 {
9021         struct devlink *devlink;
9022         static u32 last_id;
9023         int ret;
9024
9025         WARN_ON(!ops || !dev);
9026         if (!devlink_reload_actions_valid(ops))
9027                 return NULL;
9028
9029         devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
9030         if (!devlink)
9031                 return NULL;
9032
9033         ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b,
9034                               &last_id, GFP_KERNEL);
9035         if (ret < 0) {
9036                 kfree(devlink);
9037                 return NULL;
9038         }
9039
9040         devlink->dev = dev;
9041         devlink->ops = ops;
9042         xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
9043         write_pnet(&devlink->_net, net);
9044         INIT_LIST_HEAD(&devlink->port_list);
9045         INIT_LIST_HEAD(&devlink->rate_list);
9046         INIT_LIST_HEAD(&devlink->sb_list);
9047         INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
9048         INIT_LIST_HEAD(&devlink->resource_list);
9049         INIT_LIST_HEAD(&devlink->param_list);
9050         INIT_LIST_HEAD(&devlink->region_list);
9051         INIT_LIST_HEAD(&devlink->reporter_list);
9052         INIT_LIST_HEAD(&devlink->trap_list);
9053         INIT_LIST_HEAD(&devlink->trap_group_list);
9054         INIT_LIST_HEAD(&devlink->trap_policer_list);
9055         mutex_init(&devlink->lock);
9056         mutex_init(&devlink->reporters_lock);
9057         refcount_set(&devlink->refcount, 1);
9058         init_completion(&devlink->comp);
9059
9060         return devlink;
9061 }
9062 EXPORT_SYMBOL_GPL(devlink_alloc_ns);
9063
9064 static void
9065 devlink_trap_policer_notify(struct devlink *devlink,
9066                             const struct devlink_trap_policer_item *policer_item,
9067                             enum devlink_command cmd);
9068 static void
9069 devlink_trap_group_notify(struct devlink *devlink,
9070                           const struct devlink_trap_group_item *group_item,
9071                           enum devlink_command cmd);
9072 static void devlink_trap_notify(struct devlink *devlink,
9073                                 const struct devlink_trap_item *trap_item,
9074                                 enum devlink_command cmd);
9075
9076 static void devlink_notify_register(struct devlink *devlink)
9077 {
9078         struct devlink_trap_policer_item *policer_item;
9079         struct devlink_trap_group_item *group_item;
9080         struct devlink_param_item *param_item;
9081         struct devlink_trap_item *trap_item;
9082         struct devlink_port *devlink_port;
9083         struct devlink_rate *rate_node;
9084         struct devlink_region *region;
9085
9086         devlink_notify(devlink, DEVLINK_CMD_NEW);
9087         list_for_each_entry(devlink_port, &devlink->port_list, list)
9088                 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
9089
9090         list_for_each_entry(policer_item, &devlink->trap_policer_list, list)
9091                 devlink_trap_policer_notify(devlink, policer_item,
9092                                             DEVLINK_CMD_TRAP_POLICER_NEW);
9093
9094         list_for_each_entry(group_item, &devlink->trap_group_list, list)
9095                 devlink_trap_group_notify(devlink, group_item,
9096                                           DEVLINK_CMD_TRAP_GROUP_NEW);
9097
9098         list_for_each_entry(trap_item, &devlink->trap_list, list)
9099                 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_NEW);
9100
9101         list_for_each_entry(rate_node, &devlink->rate_list, list)
9102                 devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_NEW);
9103
9104         list_for_each_entry(region, &devlink->region_list, list)
9105                 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
9106
9107         list_for_each_entry(param_item, &devlink->param_list, list)
9108                 devlink_param_notify(devlink, 0, param_item,
9109                                      DEVLINK_CMD_PARAM_NEW);
9110 }
9111
9112 static void devlink_notify_unregister(struct devlink *devlink)
9113 {
9114         struct devlink_trap_policer_item *policer_item;
9115         struct devlink_trap_group_item *group_item;
9116         struct devlink_param_item *param_item;
9117         struct devlink_trap_item *trap_item;
9118         struct devlink_port *devlink_port;
9119         struct devlink_rate *rate_node;
9120         struct devlink_region *region;
9121
9122         list_for_each_entry_reverse(param_item, &devlink->param_list, list)
9123                 devlink_param_notify(devlink, 0, param_item,
9124                                      DEVLINK_CMD_PARAM_DEL);
9125
9126         list_for_each_entry_reverse(region, &devlink->region_list, list)
9127                 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_DEL);
9128
9129         list_for_each_entry_reverse(rate_node, &devlink->rate_list, list)
9130                 devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_DEL);
9131
9132         list_for_each_entry_reverse(trap_item, &devlink->trap_list, list)
9133                 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_DEL);
9134
9135         list_for_each_entry_reverse(group_item, &devlink->trap_group_list, list)
9136                 devlink_trap_group_notify(devlink, group_item,
9137                                           DEVLINK_CMD_TRAP_GROUP_DEL);
9138         list_for_each_entry_reverse(policer_item, &devlink->trap_policer_list,
9139                                     list)
9140                 devlink_trap_policer_notify(devlink, policer_item,
9141                                             DEVLINK_CMD_TRAP_POLICER_DEL);
9142
9143         list_for_each_entry_reverse(devlink_port, &devlink->port_list, list)
9144                 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
9145         devlink_notify(devlink, DEVLINK_CMD_DEL);
9146 }
9147
9148 /**
9149  *      devlink_register - Register devlink instance
9150  *
9151  *      @devlink: devlink
9152  */
9153 void devlink_register(struct devlink *devlink)
9154 {
9155         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
9156         /* Make sure that we are in .probe() routine */
9157
9158         mutex_lock(&devlink_mutex);
9159         xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
9160         devlink_notify_register(devlink);
9161         mutex_unlock(&devlink_mutex);
9162 }
9163 EXPORT_SYMBOL_GPL(devlink_register);
9164
9165 /**
9166  *      devlink_unregister - Unregister devlink instance
9167  *
9168  *      @devlink: devlink
9169  */
9170 void devlink_unregister(struct devlink *devlink)
9171 {
9172         ASSERT_DEVLINK_REGISTERED(devlink);
9173         /* Make sure that we are in .remove() routine */
9174
9175         devlink_put(devlink);
9176         wait_for_completion(&devlink->comp);
9177
9178         mutex_lock(&devlink_mutex);
9179         devlink_notify_unregister(devlink);
9180         xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
9181         mutex_unlock(&devlink_mutex);
9182 }
9183 EXPORT_SYMBOL_GPL(devlink_unregister);
9184
9185 /**
9186  *      devlink_free - Free devlink instance resources
9187  *
9188  *      @devlink: devlink
9189  */
9190 void devlink_free(struct devlink *devlink)
9191 {
9192         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
9193
9194         mutex_destroy(&devlink->reporters_lock);
9195         mutex_destroy(&devlink->lock);
9196         WARN_ON(!list_empty(&devlink->trap_policer_list));
9197         WARN_ON(!list_empty(&devlink->trap_group_list));
9198         WARN_ON(!list_empty(&devlink->trap_list));
9199         WARN_ON(!list_empty(&devlink->reporter_list));
9200         WARN_ON(!list_empty(&devlink->region_list));
9201         WARN_ON(!list_empty(&devlink->param_list));
9202         WARN_ON(!list_empty(&devlink->resource_list));
9203         WARN_ON(!list_empty(&devlink->dpipe_table_list));
9204         WARN_ON(!list_empty(&devlink->sb_list));
9205         WARN_ON(!list_empty(&devlink->rate_list));
9206         WARN_ON(!list_empty(&devlink->port_list));
9207
9208         xa_destroy(&devlink->snapshot_ids);
9209         xa_erase(&devlinks, devlink->index);
9210
9211         kfree(devlink);
9212 }
9213 EXPORT_SYMBOL_GPL(devlink_free);
9214
9215 static void devlink_port_type_warn(struct work_struct *work)
9216 {
9217         WARN(true, "Type was not set for devlink port.");
9218 }
9219
9220 static bool devlink_port_type_should_warn(struct devlink_port *devlink_port)
9221 {
9222         /* Ignore CPU and DSA flavours. */
9223         return devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_CPU &&
9224                devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA &&
9225                devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_UNUSED;
9226 }
9227
9228 #define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600)
9229
9230 static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
9231 {
9232         if (!devlink_port_type_should_warn(devlink_port))
9233                 return;
9234         /* Schedule a work to WARN in case driver does not set port
9235          * type within timeout.
9236          */
9237         schedule_delayed_work(&devlink_port->type_warn_dw,
9238                               DEVLINK_PORT_TYPE_WARN_TIMEOUT);
9239 }
9240
9241 static void devlink_port_type_warn_cancel(struct devlink_port *devlink_port)
9242 {
9243         if (!devlink_port_type_should_warn(devlink_port))
9244                 return;
9245         cancel_delayed_work_sync(&devlink_port->type_warn_dw);
9246 }
9247
9248 int devl_port_register(struct devlink *devlink,
9249                        struct devlink_port *devlink_port,
9250                        unsigned int port_index)
9251 {
9252         lockdep_assert_held(&devlink->lock);
9253
9254         if (devlink_port_index_exists(devlink, port_index))
9255                 return -EEXIST;
9256
9257         WARN_ON(devlink_port->devlink);
9258         devlink_port->devlink = devlink;
9259         devlink_port->index = port_index;
9260         spin_lock_init(&devlink_port->type_lock);
9261         INIT_LIST_HEAD(&devlink_port->reporter_list);
9262         mutex_init(&devlink_port->reporters_lock);
9263         list_add_tail(&devlink_port->list, &devlink->port_list);
9264         INIT_LIST_HEAD(&devlink_port->param_list);
9265         INIT_LIST_HEAD(&devlink_port->region_list);
9266
9267         INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn);
9268         devlink_port_type_warn_schedule(devlink_port);
9269         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
9270         return 0;
9271 }
9272 EXPORT_SYMBOL_GPL(devl_port_register);
9273
9274 /**
9275  *      devlink_port_register - Register devlink port
9276  *
9277  *      @devlink: devlink
9278  *      @devlink_port: devlink port
9279  *      @port_index: driver-specific numerical identifier of the port
9280  *
9281  *      Register devlink port with provided port index. User can use
9282  *      any indexing, even hw-related one. devlink_port structure
9283  *      is convenient to be embedded inside user driver private structure.
9284  *      Note that the caller should take care of zeroing the devlink_port
9285  *      structure.
9286  */
9287 int devlink_port_register(struct devlink *devlink,
9288                           struct devlink_port *devlink_port,
9289                           unsigned int port_index)
9290 {
9291         int err;
9292
9293         mutex_lock(&devlink->lock);
9294         err = devl_port_register(devlink, devlink_port, port_index);
9295         mutex_unlock(&devlink->lock);
9296         return err;
9297 }
9298 EXPORT_SYMBOL_GPL(devlink_port_register);
9299
9300 void devl_port_unregister(struct devlink_port *devlink_port)
9301 {
9302         lockdep_assert_held(&devlink_port->devlink->lock);
9303
9304         devlink_port_type_warn_cancel(devlink_port);
9305         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
9306         list_del(&devlink_port->list);
9307         WARN_ON(!list_empty(&devlink_port->reporter_list));
9308         WARN_ON(!list_empty(&devlink_port->region_list));
9309         mutex_destroy(&devlink_port->reporters_lock);
9310 }
9311 EXPORT_SYMBOL_GPL(devl_port_unregister);
9312
9313 /**
9314  *      devlink_port_unregister - Unregister devlink port
9315  *
9316  *      @devlink_port: devlink port
9317  */
9318 void devlink_port_unregister(struct devlink_port *devlink_port)
9319 {
9320         struct devlink *devlink = devlink_port->devlink;
9321
9322         mutex_lock(&devlink->lock);
9323         devl_port_unregister(devlink_port);
9324         mutex_unlock(&devlink->lock);
9325 }
9326 EXPORT_SYMBOL_GPL(devlink_port_unregister);
9327
9328 static void __devlink_port_type_set(struct devlink_port *devlink_port,
9329                                     enum devlink_port_type type,
9330                                     void *type_dev)
9331 {
9332         if (WARN_ON(!devlink_port->devlink))
9333                 return;
9334         devlink_port_type_warn_cancel(devlink_port);
9335         spin_lock_bh(&devlink_port->type_lock);
9336         devlink_port->type = type;
9337         devlink_port->type_dev = type_dev;
9338         spin_unlock_bh(&devlink_port->type_lock);
9339         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
9340 }
9341
9342 static void devlink_port_type_netdev_checks(struct devlink_port *devlink_port,
9343                                             struct net_device *netdev)
9344 {
9345         const struct net_device_ops *ops = netdev->netdev_ops;
9346
9347         /* If driver registers devlink port, it should set devlink port
9348          * attributes accordingly so the compat functions are called
9349          * and the original ops are not used.
9350          */
9351         if (ops->ndo_get_phys_port_name) {
9352                 /* Some drivers use the same set of ndos for netdevs
9353                  * that have devlink_port registered and also for
9354                  * those who don't. Make sure that ndo_get_phys_port_name
9355                  * returns -EOPNOTSUPP here in case it is defined.
9356                  * Warn if not.
9357                  */
9358                 char name[IFNAMSIZ];
9359                 int err;
9360
9361                 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name));
9362                 WARN_ON(err != -EOPNOTSUPP);
9363         }
9364         if (ops->ndo_get_port_parent_id) {
9365                 /* Some drivers use the same set of ndos for netdevs
9366                  * that have devlink_port registered and also for
9367                  * those who don't. Make sure that ndo_get_port_parent_id
9368                  * returns -EOPNOTSUPP here in case it is defined.
9369                  * Warn if not.
9370                  */
9371                 struct netdev_phys_item_id ppid;
9372                 int err;
9373
9374                 err = ops->ndo_get_port_parent_id(netdev, &ppid);
9375                 WARN_ON(err != -EOPNOTSUPP);
9376         }
9377 }
9378
9379 /**
9380  *      devlink_port_type_eth_set - Set port type to Ethernet
9381  *
9382  *      @devlink_port: devlink port
9383  *      @netdev: related netdevice
9384  */
9385 void devlink_port_type_eth_set(struct devlink_port *devlink_port,
9386                                struct net_device *netdev)
9387 {
9388         if (netdev)
9389                 devlink_port_type_netdev_checks(devlink_port, netdev);
9390         else
9391                 dev_warn(devlink_port->devlink->dev,
9392                          "devlink port type for port %d set to Ethernet without a software interface reference, device type not supported by the kernel?\n",
9393                          devlink_port->index);
9394
9395         __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, netdev);
9396 }
9397 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
9398
9399 /**
9400  *      devlink_port_type_ib_set - Set port type to InfiniBand
9401  *
9402  *      @devlink_port: devlink port
9403  *      @ibdev: related IB device
9404  */
9405 void devlink_port_type_ib_set(struct devlink_port *devlink_port,
9406                               struct ib_device *ibdev)
9407 {
9408         __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev);
9409 }
9410 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
9411
9412 /**
9413  *      devlink_port_type_clear - Clear port type
9414  *
9415  *      @devlink_port: devlink port
9416  */
9417 void devlink_port_type_clear(struct devlink_port *devlink_port)
9418 {
9419         __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL);
9420         devlink_port_type_warn_schedule(devlink_port);
9421 }
9422 EXPORT_SYMBOL_GPL(devlink_port_type_clear);
9423
9424 static int __devlink_port_attrs_set(struct devlink_port *devlink_port,
9425                                     enum devlink_port_flavour flavour)
9426 {
9427         struct devlink_port_attrs *attrs = &devlink_port->attrs;
9428
9429         devlink_port->attrs_set = true;
9430         attrs->flavour = flavour;
9431         if (attrs->switch_id.id_len) {
9432                 devlink_port->switch_port = true;
9433                 if (WARN_ON(attrs->switch_id.id_len > MAX_PHYS_ITEM_ID_LEN))
9434                         attrs->switch_id.id_len = MAX_PHYS_ITEM_ID_LEN;
9435         } else {
9436                 devlink_port->switch_port = false;
9437         }
9438         return 0;
9439 }
9440
9441 /**
9442  *      devlink_port_attrs_set - Set port attributes
9443  *
9444  *      @devlink_port: devlink port
9445  *      @attrs: devlink port attrs
9446  */
9447 void devlink_port_attrs_set(struct devlink_port *devlink_port,
9448                             struct devlink_port_attrs *attrs)
9449 {
9450         int ret;
9451
9452         if (WARN_ON(devlink_port->devlink))
9453                 return;
9454         devlink_port->attrs = *attrs;
9455         ret = __devlink_port_attrs_set(devlink_port, attrs->flavour);
9456         if (ret)
9457                 return;
9458         WARN_ON(attrs->splittable && attrs->split);
9459 }
9460 EXPORT_SYMBOL_GPL(devlink_port_attrs_set);
9461
9462 /**
9463  *      devlink_port_attrs_pci_pf_set - Set PCI PF port attributes
9464  *
9465  *      @devlink_port: devlink port
9466  *      @controller: associated controller number for the devlink port instance
9467  *      @pf: associated PF for the devlink port instance
9468  *      @external: indicates if the port is for an external controller
9469  */
9470 void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller,
9471                                    u16 pf, bool external)
9472 {
9473         struct devlink_port_attrs *attrs = &devlink_port->attrs;
9474         int ret;
9475
9476         if (WARN_ON(devlink_port->devlink))
9477                 return;
9478         ret = __devlink_port_attrs_set(devlink_port,
9479                                        DEVLINK_PORT_FLAVOUR_PCI_PF);
9480         if (ret)
9481                 return;
9482         attrs->pci_pf.controller = controller;
9483         attrs->pci_pf.pf = pf;
9484         attrs->pci_pf.external = external;
9485 }
9486 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set);
9487
9488 /**
9489  *      devlink_port_attrs_pci_vf_set - Set PCI VF port attributes
9490  *
9491  *      @devlink_port: devlink port
9492  *      @controller: associated controller number for the devlink port instance
9493  *      @pf: associated PF for the devlink port instance
9494  *      @vf: associated VF of a PF for the devlink port instance
9495  *      @external: indicates if the port is for an external controller
9496  */
9497 void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller,
9498                                    u16 pf, u16 vf, bool external)
9499 {
9500         struct devlink_port_attrs *attrs = &devlink_port->attrs;
9501         int ret;
9502
9503         if (WARN_ON(devlink_port->devlink))
9504                 return;
9505         ret = __devlink_port_attrs_set(devlink_port,
9506                                        DEVLINK_PORT_FLAVOUR_PCI_VF);
9507         if (ret)
9508                 return;
9509         attrs->pci_vf.controller = controller;
9510         attrs->pci_vf.pf = pf;
9511         attrs->pci_vf.vf = vf;
9512         attrs->pci_vf.external = external;
9513 }
9514 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set);
9515
9516 /**
9517  *      devlink_port_attrs_pci_sf_set - Set PCI SF port attributes
9518  *
9519  *      @devlink_port: devlink port
9520  *      @controller: associated controller number for the devlink port instance
9521  *      @pf: associated PF for the devlink port instance
9522  *      @sf: associated SF of a PF for the devlink port instance
9523  *      @external: indicates if the port is for an external controller
9524  */
9525 void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller,
9526                                    u16 pf, u32 sf, bool external)
9527 {
9528         struct devlink_port_attrs *attrs = &devlink_port->attrs;
9529         int ret;
9530
9531         if (WARN_ON(devlink_port->devlink))
9532                 return;
9533         ret = __devlink_port_attrs_set(devlink_port,
9534                                        DEVLINK_PORT_FLAVOUR_PCI_SF);
9535         if (ret)
9536                 return;
9537         attrs->pci_sf.controller = controller;
9538         attrs->pci_sf.pf = pf;
9539         attrs->pci_sf.sf = sf;
9540         attrs->pci_sf.external = external;
9541 }
9542 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set);
9543
9544 /**
9545  * devl_rate_leaf_create - create devlink rate leaf
9546  * @devlink_port: devlink port object to create rate object on
9547  * @priv: driver private data
9548  *
9549  * Create devlink rate object of type leaf on provided @devlink_port.
9550  */
9551 int devl_rate_leaf_create(struct devlink_port *devlink_port, void *priv)
9552 {
9553         struct devlink *devlink = devlink_port->devlink;
9554         struct devlink_rate *devlink_rate;
9555
9556         devl_assert_locked(devlink_port->devlink);
9557
9558         if (WARN_ON(devlink_port->devlink_rate))
9559                 return -EBUSY;
9560
9561         devlink_rate = kzalloc(sizeof(*devlink_rate), GFP_KERNEL);
9562         if (!devlink_rate)
9563                 return -ENOMEM;
9564
9565         devlink_rate->type = DEVLINK_RATE_TYPE_LEAF;
9566         devlink_rate->devlink = devlink;
9567         devlink_rate->devlink_port = devlink_port;
9568         devlink_rate->priv = priv;
9569         list_add_tail(&devlink_rate->list, &devlink->rate_list);
9570         devlink_port->devlink_rate = devlink_rate;
9571         devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
9572
9573         return 0;
9574 }
9575 EXPORT_SYMBOL_GPL(devl_rate_leaf_create);
9576
9577 int
9578 devlink_rate_leaf_create(struct devlink_port *devlink_port, void *priv)
9579 {
9580         struct devlink *devlink = devlink_port->devlink;
9581         int ret;
9582
9583         mutex_lock(&devlink->lock);
9584         ret = devl_rate_leaf_create(devlink_port, priv);
9585         mutex_unlock(&devlink->lock);
9586
9587         return ret;
9588 }
9589 EXPORT_SYMBOL_GPL(devlink_rate_leaf_create);
9590
9591 void devl_rate_leaf_destroy(struct devlink_port *devlink_port)
9592 {
9593         struct devlink_rate *devlink_rate = devlink_port->devlink_rate;
9594
9595         devl_assert_locked(devlink_port->devlink);
9596         if (!devlink_rate)
9597                 return;
9598
9599         devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_DEL);
9600         if (devlink_rate->parent)
9601                 refcount_dec(&devlink_rate->parent->refcnt);
9602         list_del(&devlink_rate->list);
9603         devlink_port->devlink_rate = NULL;
9604         kfree(devlink_rate);
9605 }
9606 EXPORT_SYMBOL_GPL(devl_rate_leaf_destroy);
9607
9608 /**
9609  * devlink_rate_leaf_destroy - destroy devlink rate leaf
9610  *
9611  * @devlink_port: devlink port linked to the rate object
9612  *
9613  * Context: Takes and release devlink->lock <mutex>.
9614  */
9615 void devlink_rate_leaf_destroy(struct devlink_port *devlink_port)
9616 {
9617         struct devlink_rate *devlink_rate = devlink_port->devlink_rate;
9618         struct devlink *devlink = devlink_port->devlink;
9619
9620         if (!devlink_rate)
9621                 return;
9622
9623         mutex_lock(&devlink->lock);
9624         devl_rate_leaf_destroy(devlink_port);
9625         mutex_unlock(&devlink->lock);
9626 }
9627 EXPORT_SYMBOL_GPL(devlink_rate_leaf_destroy);
9628
9629 /**
9630  * devl_rate_nodes_destroy - destroy all devlink rate nodes on device
9631  * @devlink: devlink instance
9632  *
9633  * Unset parent for all rate objects and destroy all rate nodes
9634  * on specified device.
9635  */
9636 void devl_rate_nodes_destroy(struct devlink *devlink)
9637 {
9638         static struct devlink_rate *devlink_rate, *tmp;
9639         const struct devlink_ops *ops = devlink->ops;
9640
9641         devl_assert_locked(devlink);
9642
9643         list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
9644                 if (!devlink_rate->parent)
9645                         continue;
9646
9647                 refcount_dec(&devlink_rate->parent->refcnt);
9648                 if (devlink_rate_is_leaf(devlink_rate))
9649                         ops->rate_leaf_parent_set(devlink_rate, NULL, devlink_rate->priv,
9650                                                   NULL, NULL);
9651                 else if (devlink_rate_is_node(devlink_rate))
9652                         ops->rate_node_parent_set(devlink_rate, NULL, devlink_rate->priv,
9653                                                   NULL, NULL);
9654         }
9655         list_for_each_entry_safe(devlink_rate, tmp, &devlink->rate_list, list) {
9656                 if (devlink_rate_is_node(devlink_rate)) {
9657                         ops->rate_node_del(devlink_rate, devlink_rate->priv, NULL);
9658                         list_del(&devlink_rate->list);
9659                         kfree(devlink_rate->name);
9660                         kfree(devlink_rate);
9661                 }
9662         }
9663 }
9664 EXPORT_SYMBOL_GPL(devl_rate_nodes_destroy);
9665
9666 /**
9667  * devlink_rate_nodes_destroy - destroy all devlink rate nodes on device
9668  *
9669  * @devlink: devlink instance
9670  *
9671  * Unset parent for all rate objects and destroy all rate nodes
9672  * on specified device.
9673  *
9674  * Context: Takes and release devlink->lock <mutex>.
9675  */
9676 void devlink_rate_nodes_destroy(struct devlink *devlink)
9677 {
9678         mutex_lock(&devlink->lock);
9679         devl_rate_nodes_destroy(devlink);
9680         mutex_unlock(&devlink->lock);
9681 }
9682 EXPORT_SYMBOL_GPL(devlink_rate_nodes_destroy);
9683
9684 static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port,
9685                                              char *name, size_t len)
9686 {
9687         struct devlink_port_attrs *attrs = &devlink_port->attrs;
9688         int n = 0;
9689
9690         if (!devlink_port->attrs_set)
9691                 return -EOPNOTSUPP;
9692
9693         switch (attrs->flavour) {
9694         case DEVLINK_PORT_FLAVOUR_PHYSICAL:
9695                 n = snprintf(name, len, "p%u", attrs->phys.port_number);
9696                 if (n < len && attrs->split)
9697                         n += snprintf(name + n, len - n, "s%u",
9698                                       attrs->phys.split_subport_number);
9699                 break;
9700         case DEVLINK_PORT_FLAVOUR_CPU:
9701         case DEVLINK_PORT_FLAVOUR_DSA:
9702         case DEVLINK_PORT_FLAVOUR_UNUSED:
9703                 /* As CPU and DSA ports do not have a netdevice associated
9704                  * case should not ever happen.
9705                  */
9706                 WARN_ON(1);
9707                 return -EINVAL;
9708         case DEVLINK_PORT_FLAVOUR_PCI_PF:
9709                 if (attrs->pci_pf.external) {
9710                         n = snprintf(name, len, "c%u", attrs->pci_pf.controller);
9711                         if (n >= len)
9712                                 return -EINVAL;
9713                         len -= n;
9714                         name += n;
9715                 }
9716                 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf);
9717                 break;
9718         case DEVLINK_PORT_FLAVOUR_PCI_VF:
9719                 if (attrs->pci_vf.external) {
9720                         n = snprintf(name, len, "c%u", attrs->pci_vf.controller);
9721                         if (n >= len)
9722                                 return -EINVAL;
9723                         len -= n;
9724                         name += n;
9725                 }
9726                 n = snprintf(name, len, "pf%uvf%u",
9727                              attrs->pci_vf.pf, attrs->pci_vf.vf);
9728                 break;
9729         case DEVLINK_PORT_FLAVOUR_PCI_SF:
9730                 if (attrs->pci_sf.external) {
9731                         n = snprintf(name, len, "c%u", attrs->pci_sf.controller);
9732                         if (n >= len)
9733                                 return -EINVAL;
9734                         len -= n;
9735                         name += n;
9736                 }
9737                 n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf,
9738                              attrs->pci_sf.sf);
9739                 break;
9740         case DEVLINK_PORT_FLAVOUR_VIRTUAL:
9741                 return -EOPNOTSUPP;
9742         }
9743
9744         if (n >= len)
9745                 return -EINVAL;
9746
9747         return 0;
9748 }
9749
9750 int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
9751                         u32 size, u16 ingress_pools_count,
9752                         u16 egress_pools_count, u16 ingress_tc_count,
9753                         u16 egress_tc_count)
9754 {
9755         struct devlink_sb *devlink_sb;
9756         int err = 0;
9757
9758         mutex_lock(&devlink->lock);
9759         if (devlink_sb_index_exists(devlink, sb_index)) {
9760                 err = -EEXIST;
9761                 goto unlock;
9762         }
9763
9764         devlink_sb = kzalloc(sizeof(*devlink_sb), GFP_KERNEL);
9765         if (!devlink_sb) {
9766                 err = -ENOMEM;
9767                 goto unlock;
9768         }
9769         devlink_sb->index = sb_index;
9770         devlink_sb->size = size;
9771         devlink_sb->ingress_pools_count = ingress_pools_count;
9772         devlink_sb->egress_pools_count = egress_pools_count;
9773         devlink_sb->ingress_tc_count = ingress_tc_count;
9774         devlink_sb->egress_tc_count = egress_tc_count;
9775         list_add_tail(&devlink_sb->list, &devlink->sb_list);
9776 unlock:
9777         mutex_unlock(&devlink->lock);
9778         return err;
9779 }
9780 EXPORT_SYMBOL_GPL(devlink_sb_register);
9781
9782 void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index)
9783 {
9784         struct devlink_sb *devlink_sb;
9785
9786         mutex_lock(&devlink->lock);
9787         devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
9788         WARN_ON(!devlink_sb);
9789         list_del(&devlink_sb->list);
9790         mutex_unlock(&devlink->lock);
9791         kfree(devlink_sb);
9792 }
9793 EXPORT_SYMBOL_GPL(devlink_sb_unregister);
9794
9795 /**
9796  *      devlink_dpipe_headers_register - register dpipe headers
9797  *
9798  *      @devlink: devlink
9799  *      @dpipe_headers: dpipe header array
9800  *
9801  *      Register the headers supported by hardware.
9802  */
9803 int devlink_dpipe_headers_register(struct devlink *devlink,
9804                                    struct devlink_dpipe_headers *dpipe_headers)
9805 {
9806         mutex_lock(&devlink->lock);
9807         devlink->dpipe_headers = dpipe_headers;
9808         mutex_unlock(&devlink->lock);
9809         return 0;
9810 }
9811 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register);
9812
9813 /**
9814  *      devlink_dpipe_headers_unregister - unregister dpipe headers
9815  *
9816  *      @devlink: devlink
9817  *
9818  *      Unregister the headers supported by hardware.
9819  */
9820 void devlink_dpipe_headers_unregister(struct devlink *devlink)
9821 {
9822         mutex_lock(&devlink->lock);
9823         devlink->dpipe_headers = NULL;
9824         mutex_unlock(&devlink->lock);
9825 }
9826 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister);
9827
9828 /**
9829  *      devlink_dpipe_table_counter_enabled - check if counter allocation
9830  *                                            required
9831  *      @devlink: devlink
9832  *      @table_name: tables name
9833  *
9834  *      Used by driver to check if counter allocation is required.
9835  *      After counter allocation is turned on the table entries
9836  *      are updated to include counter statistics.
9837  *
9838  *      After that point on the driver must respect the counter
9839  *      state so that each entry added to the table is added
9840  *      with a counter.
9841  */
9842 bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
9843                                          const char *table_name)
9844 {
9845         struct devlink_dpipe_table *table;
9846         bool enabled;
9847
9848         rcu_read_lock();
9849         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
9850                                          table_name, devlink);
9851         enabled = false;
9852         if (table)
9853                 enabled = table->counters_enabled;
9854         rcu_read_unlock();
9855         return enabled;
9856 }
9857 EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
9858
9859 /**
9860  *      devlink_dpipe_table_register - register dpipe table
9861  *
9862  *      @devlink: devlink
9863  *      @table_name: table name
9864  *      @table_ops: table ops
9865  *      @priv: priv
9866  *      @counter_control_extern: external control for counters
9867  */
9868 int devlink_dpipe_table_register(struct devlink *devlink,
9869                                  const char *table_name,
9870                                  struct devlink_dpipe_table_ops *table_ops,
9871                                  void *priv, bool counter_control_extern)
9872 {
9873         struct devlink_dpipe_table *table;
9874         int err = 0;
9875
9876         if (WARN_ON(!table_ops->size_get))
9877                 return -EINVAL;
9878
9879         mutex_lock(&devlink->lock);
9880
9881         if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name,
9882                                      devlink)) {
9883                 err = -EEXIST;
9884                 goto unlock;
9885         }
9886
9887         table = kzalloc(sizeof(*table), GFP_KERNEL);
9888         if (!table) {
9889                 err = -ENOMEM;
9890                 goto unlock;
9891         }
9892
9893         table->name = table_name;
9894         table->table_ops = table_ops;
9895         table->priv = priv;
9896         table->counter_control_extern = counter_control_extern;
9897
9898         list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
9899 unlock:
9900         mutex_unlock(&devlink->lock);
9901         return err;
9902 }
9903 EXPORT_SYMBOL_GPL(devlink_dpipe_table_register);
9904
9905 /**
9906  *      devlink_dpipe_table_unregister - unregister dpipe table
9907  *
9908  *      @devlink: devlink
9909  *      @table_name: table name
9910  */
9911 void devlink_dpipe_table_unregister(struct devlink *devlink,
9912                                     const char *table_name)
9913 {
9914         struct devlink_dpipe_table *table;
9915
9916         mutex_lock(&devlink->lock);
9917         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
9918                                          table_name, devlink);
9919         if (!table)
9920                 goto unlock;
9921         list_del_rcu(&table->list);
9922         mutex_unlock(&devlink->lock);
9923         kfree_rcu(table, rcu);
9924         return;
9925 unlock:
9926         mutex_unlock(&devlink->lock);
9927 }
9928 EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister);
9929
9930 /**
9931  *      devlink_resource_register - devlink resource register
9932  *
9933  *      @devlink: devlink
9934  *      @resource_name: resource's name
9935  *      @resource_size: resource's size
9936  *      @resource_id: resource's id
9937  *      @parent_resource_id: resource's parent id
9938  *      @size_params: size parameters
9939  *
9940  *      Generic resources should reuse the same names across drivers.
9941  *      Please see the generic resources list at:
9942  *      Documentation/networking/devlink/devlink-resource.rst
9943  */
9944 int devlink_resource_register(struct devlink *devlink,
9945                               const char *resource_name,
9946                               u64 resource_size,
9947                               u64 resource_id,
9948                               u64 parent_resource_id,
9949                               const struct devlink_resource_size_params *size_params)
9950 {
9951         struct devlink_resource *resource;
9952         struct list_head *resource_list;
9953         bool top_hierarchy;
9954         int err = 0;
9955
9956         top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
9957
9958         mutex_lock(&devlink->lock);
9959         resource = devlink_resource_find(devlink, NULL, resource_id);
9960         if (resource) {
9961                 err = -EINVAL;
9962                 goto out;
9963         }
9964
9965         resource = kzalloc(sizeof(*resource), GFP_KERNEL);
9966         if (!resource) {
9967                 err = -ENOMEM;
9968                 goto out;
9969         }
9970
9971         if (top_hierarchy) {
9972                 resource_list = &devlink->resource_list;
9973         } else {
9974                 struct devlink_resource *parent_resource;
9975
9976                 parent_resource = devlink_resource_find(devlink, NULL,
9977                                                         parent_resource_id);
9978                 if (parent_resource) {
9979                         resource_list = &parent_resource->resource_list;
9980                         resource->parent = parent_resource;
9981                 } else {
9982                         kfree(resource);
9983                         err = -EINVAL;
9984                         goto out;
9985                 }
9986         }
9987
9988         resource->name = resource_name;
9989         resource->size = resource_size;
9990         resource->size_new = resource_size;
9991         resource->id = resource_id;
9992         resource->size_valid = true;
9993         memcpy(&resource->size_params, size_params,
9994                sizeof(resource->size_params));
9995         INIT_LIST_HEAD(&resource->resource_list);
9996         list_add_tail(&resource->list, resource_list);
9997 out:
9998         mutex_unlock(&devlink->lock);
9999         return err;
10000 }
10001 EXPORT_SYMBOL_GPL(devlink_resource_register);
10002
10003 static void devlink_resource_unregister(struct devlink *devlink,
10004                                         struct devlink_resource *resource)
10005 {
10006         struct devlink_resource *tmp, *child_resource;
10007
10008         list_for_each_entry_safe(child_resource, tmp, &resource->resource_list,
10009                                  list) {
10010                 devlink_resource_unregister(devlink, child_resource);
10011                 list_del(&child_resource->list);
10012                 kfree(child_resource);
10013         }
10014 }
10015
10016 /**
10017  *      devlink_resources_unregister - free all resources
10018  *
10019  *      @devlink: devlink
10020  */
10021 void devlink_resources_unregister(struct devlink *devlink)
10022 {
10023         struct devlink_resource *tmp, *child_resource;
10024
10025         mutex_lock(&devlink->lock);
10026
10027         list_for_each_entry_safe(child_resource, tmp, &devlink->resource_list,
10028                                  list) {
10029                 devlink_resource_unregister(devlink, child_resource);
10030                 list_del(&child_resource->list);
10031                 kfree(child_resource);
10032         }
10033
10034         mutex_unlock(&devlink->lock);
10035 }
10036 EXPORT_SYMBOL_GPL(devlink_resources_unregister);
10037
10038 /**
10039  *      devlink_resource_size_get - get and update size
10040  *
10041  *      @devlink: devlink
10042  *      @resource_id: the requested resource id
10043  *      @p_resource_size: ptr to update
10044  */
10045 int devlink_resource_size_get(struct devlink *devlink,
10046                               u64 resource_id,
10047                               u64 *p_resource_size)
10048 {
10049         struct devlink_resource *resource;
10050         int err = 0;
10051
10052         mutex_lock(&devlink->lock);
10053         resource = devlink_resource_find(devlink, NULL, resource_id);
10054         if (!resource) {
10055                 err = -EINVAL;
10056                 goto out;
10057         }
10058         *p_resource_size = resource->size_new;
10059         resource->size = resource->size_new;
10060 out:
10061         mutex_unlock(&devlink->lock);
10062         return err;
10063 }
10064 EXPORT_SYMBOL_GPL(devlink_resource_size_get);
10065
10066 /**
10067  *      devlink_dpipe_table_resource_set - set the resource id
10068  *
10069  *      @devlink: devlink
10070  *      @table_name: table name
10071  *      @resource_id: resource id
10072  *      @resource_units: number of resource's units consumed per table's entry
10073  */
10074 int devlink_dpipe_table_resource_set(struct devlink *devlink,
10075                                      const char *table_name, u64 resource_id,
10076                                      u64 resource_units)
10077 {
10078         struct devlink_dpipe_table *table;
10079         int err = 0;
10080
10081         mutex_lock(&devlink->lock);
10082         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
10083                                          table_name, devlink);
10084         if (!table) {
10085                 err = -EINVAL;
10086                 goto out;
10087         }
10088         table->resource_id = resource_id;
10089         table->resource_units = resource_units;
10090         table->resource_valid = true;
10091 out:
10092         mutex_unlock(&devlink->lock);
10093         return err;
10094 }
10095 EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set);
10096
10097 /**
10098  *      devlink_resource_occ_get_register - register occupancy getter
10099  *
10100  *      @devlink: devlink
10101  *      @resource_id: resource id
10102  *      @occ_get: occupancy getter callback
10103  *      @occ_get_priv: occupancy getter callback priv
10104  */
10105 void devlink_resource_occ_get_register(struct devlink *devlink,
10106                                        u64 resource_id,
10107                                        devlink_resource_occ_get_t *occ_get,
10108                                        void *occ_get_priv)
10109 {
10110         struct devlink_resource *resource;
10111
10112         mutex_lock(&devlink->lock);
10113         resource = devlink_resource_find(devlink, NULL, resource_id);
10114         if (WARN_ON(!resource))
10115                 goto out;
10116         WARN_ON(resource->occ_get);
10117
10118         resource->occ_get = occ_get;
10119         resource->occ_get_priv = occ_get_priv;
10120 out:
10121         mutex_unlock(&devlink->lock);
10122 }
10123 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_register);
10124
10125 /**
10126  *      devlink_resource_occ_get_unregister - unregister occupancy getter
10127  *
10128  *      @devlink: devlink
10129  *      @resource_id: resource id
10130  */
10131 void devlink_resource_occ_get_unregister(struct devlink *devlink,
10132                                          u64 resource_id)
10133 {
10134         struct devlink_resource *resource;
10135
10136         mutex_lock(&devlink->lock);
10137         resource = devlink_resource_find(devlink, NULL, resource_id);
10138         if (WARN_ON(!resource))
10139                 goto out;
10140         WARN_ON(!resource->occ_get);
10141
10142         resource->occ_get = NULL;
10143         resource->occ_get_priv = NULL;
10144 out:
10145         mutex_unlock(&devlink->lock);
10146 }
10147 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_unregister);
10148
10149 static int devlink_param_verify(const struct devlink_param *param)
10150 {
10151         if (!param || !param->name || !param->supported_cmodes)
10152                 return -EINVAL;
10153         if (param->generic)
10154                 return devlink_param_generic_verify(param);
10155         else
10156                 return devlink_param_driver_verify(param);
10157 }
10158
10159 /**
10160  *      devlink_params_register - register configuration parameters
10161  *
10162  *      @devlink: devlink
10163  *      @params: configuration parameters array
10164  *      @params_count: number of parameters provided
10165  *
10166  *      Register the configuration parameters supported by the driver.
10167  */
10168 int devlink_params_register(struct devlink *devlink,
10169                             const struct devlink_param *params,
10170                             size_t params_count)
10171 {
10172         const struct devlink_param *param = params;
10173         int i, err;
10174
10175         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
10176
10177         for (i = 0; i < params_count; i++, param++) {
10178                 err = devlink_param_register(devlink, param);
10179                 if (err)
10180                         goto rollback;
10181         }
10182         return 0;
10183
10184 rollback:
10185         if (!i)
10186                 return err;
10187
10188         for (param--; i > 0; i--, param--)
10189                 devlink_param_unregister(devlink, param);
10190         return err;
10191 }
10192 EXPORT_SYMBOL_GPL(devlink_params_register);
10193
10194 /**
10195  *      devlink_params_unregister - unregister configuration parameters
10196  *      @devlink: devlink
10197  *      @params: configuration parameters to unregister
10198  *      @params_count: number of parameters provided
10199  */
10200 void devlink_params_unregister(struct devlink *devlink,
10201                                const struct devlink_param *params,
10202                                size_t params_count)
10203 {
10204         const struct devlink_param *param = params;
10205         int i;
10206
10207         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
10208
10209         for (i = 0; i < params_count; i++, param++)
10210                 devlink_param_unregister(devlink, param);
10211 }
10212 EXPORT_SYMBOL_GPL(devlink_params_unregister);
10213
10214 /**
10215  * devlink_param_register - register one configuration parameter
10216  *
10217  * @devlink: devlink
10218  * @param: one configuration parameter
10219  *
10220  * Register the configuration parameter supported by the driver.
10221  * Return: returns 0 on successful registration or error code otherwise.
10222  */
10223 int devlink_param_register(struct devlink *devlink,
10224                            const struct devlink_param *param)
10225 {
10226         struct devlink_param_item *param_item;
10227
10228         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
10229
10230         WARN_ON(devlink_param_verify(param));
10231         WARN_ON(devlink_param_find_by_name(&devlink->param_list, param->name));
10232
10233         if (param->supported_cmodes == BIT(DEVLINK_PARAM_CMODE_DRIVERINIT))
10234                 WARN_ON(param->get || param->set);
10235         else
10236                 WARN_ON(!param->get || !param->set);
10237
10238         param_item = kzalloc(sizeof(*param_item), GFP_KERNEL);
10239         if (!param_item)
10240                 return -ENOMEM;
10241
10242         param_item->param = param;
10243
10244         list_add_tail(&param_item->list, &devlink->param_list);
10245         return 0;
10246 }
10247 EXPORT_SYMBOL_GPL(devlink_param_register);
10248
10249 /**
10250  * devlink_param_unregister - unregister one configuration parameter
10251  * @devlink: devlink
10252  * @param: configuration parameter to unregister
10253  */
10254 void devlink_param_unregister(struct devlink *devlink,
10255                               const struct devlink_param *param)
10256 {
10257         struct devlink_param_item *param_item;
10258
10259         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
10260
10261         param_item =
10262                 devlink_param_find_by_name(&devlink->param_list, param->name);
10263         WARN_ON(!param_item);
10264         list_del(&param_item->list);
10265         kfree(param_item);
10266 }
10267 EXPORT_SYMBOL_GPL(devlink_param_unregister);
10268
10269 /**
10270  *      devlink_param_driverinit_value_get - get configuration parameter
10271  *                                           value for driver initializing
10272  *
10273  *      @devlink: devlink
10274  *      @param_id: parameter ID
10275  *      @init_val: value of parameter in driverinit configuration mode
10276  *
10277  *      This function should be used by the driver to get driverinit
10278  *      configuration for initialization after reload command.
10279  */
10280 int devlink_param_driverinit_value_get(struct devlink *devlink, u32 param_id,
10281                                        union devlink_param_value *init_val)
10282 {
10283         struct devlink_param_item *param_item;
10284
10285         if (!devlink_reload_supported(devlink->ops))
10286                 return -EOPNOTSUPP;
10287
10288         param_item = devlink_param_find_by_id(&devlink->param_list, param_id);
10289         if (!param_item)
10290                 return -EINVAL;
10291
10292         if (!param_item->driverinit_value_valid ||
10293             !devlink_param_cmode_is_supported(param_item->param,
10294                                               DEVLINK_PARAM_CMODE_DRIVERINIT))
10295                 return -EOPNOTSUPP;
10296
10297         if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
10298                 strcpy(init_val->vstr, param_item->driverinit_value.vstr);
10299         else
10300                 *init_val = param_item->driverinit_value;
10301
10302         return 0;
10303 }
10304 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_get);
10305
10306 /**
10307  *      devlink_param_driverinit_value_set - set value of configuration
10308  *                                           parameter for driverinit
10309  *                                           configuration mode
10310  *
10311  *      @devlink: devlink
10312  *      @param_id: parameter ID
10313  *      @init_val: value of parameter to set for driverinit configuration mode
10314  *
10315  *      This function should be used by the driver to set driverinit
10316  *      configuration mode default value.
10317  */
10318 int devlink_param_driverinit_value_set(struct devlink *devlink, u32 param_id,
10319                                        union devlink_param_value init_val)
10320 {
10321         struct devlink_param_item *param_item;
10322
10323         ASSERT_DEVLINK_NOT_REGISTERED(devlink);
10324
10325         param_item = devlink_param_find_by_id(&devlink->param_list, param_id);
10326         if (!param_item)
10327                 return -EINVAL;
10328
10329         if (!devlink_param_cmode_is_supported(param_item->param,
10330                                               DEVLINK_PARAM_CMODE_DRIVERINIT))
10331                 return -EOPNOTSUPP;
10332
10333         if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
10334                 strcpy(param_item->driverinit_value.vstr, init_val.vstr);
10335         else
10336                 param_item->driverinit_value = init_val;
10337         param_item->driverinit_value_valid = true;
10338         return 0;
10339 }
10340 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_set);
10341
10342 /**
10343  *      devlink_param_value_changed - notify devlink on a parameter's value
10344  *                                    change. Should be called by the driver
10345  *                                    right after the change.
10346  *
10347  *      @devlink: devlink
10348  *      @param_id: parameter ID
10349  *
10350  *      This function should be used by the driver to notify devlink on value
10351  *      change, excluding driverinit configuration mode.
10352  *      For driverinit configuration mode driver should use the function
10353  */
10354 void devlink_param_value_changed(struct devlink *devlink, u32 param_id)
10355 {
10356         struct devlink_param_item *param_item;
10357
10358         param_item = devlink_param_find_by_id(&devlink->param_list, param_id);
10359         WARN_ON(!param_item);
10360
10361         devlink_param_notify(devlink, 0, param_item, DEVLINK_CMD_PARAM_NEW);
10362 }
10363 EXPORT_SYMBOL_GPL(devlink_param_value_changed);
10364
10365 /**
10366  *      devlink_region_create - create a new address region
10367  *
10368  *      @devlink: devlink
10369  *      @ops: region operations and name
10370  *      @region_max_snapshots: Maximum supported number of snapshots for region
10371  *      @region_size: size of region
10372  */
10373 struct devlink_region *
10374 devlink_region_create(struct devlink *devlink,
10375                       const struct devlink_region_ops *ops,
10376                       u32 region_max_snapshots, u64 region_size)
10377 {
10378         struct devlink_region *region;
10379         int err = 0;
10380
10381         if (WARN_ON(!ops) || WARN_ON(!ops->destructor))
10382                 return ERR_PTR(-EINVAL);
10383
10384         mutex_lock(&devlink->lock);
10385
10386         if (devlink_region_get_by_name(devlink, ops->name)) {
10387                 err = -EEXIST;
10388                 goto unlock;
10389         }
10390
10391         region = kzalloc(sizeof(*region), GFP_KERNEL);
10392         if (!region) {
10393                 err = -ENOMEM;
10394                 goto unlock;
10395         }
10396
10397         region->devlink = devlink;
10398         region->max_snapshots = region_max_snapshots;
10399         region->ops = ops;
10400         region->size = region_size;
10401         INIT_LIST_HEAD(&region->snapshot_list);
10402         list_add_tail(&region->list, &devlink->region_list);
10403         devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
10404
10405         mutex_unlock(&devlink->lock);
10406         return region;
10407
10408 unlock:
10409         mutex_unlock(&devlink->lock);
10410         return ERR_PTR(err);
10411 }
10412 EXPORT_SYMBOL_GPL(devlink_region_create);
10413
10414 /**
10415  *      devlink_port_region_create - create a new address region for a port
10416  *
10417  *      @port: devlink port
10418  *      @ops: region operations and name
10419  *      @region_max_snapshots: Maximum supported number of snapshots for region
10420  *      @region_size: size of region
10421  */
10422 struct devlink_region *
10423 devlink_port_region_create(struct devlink_port *port,
10424                            const struct devlink_port_region_ops *ops,
10425                            u32 region_max_snapshots, u64 region_size)
10426 {
10427         struct devlink *devlink = port->devlink;
10428         struct devlink_region *region;
10429         int err = 0;
10430
10431         if (WARN_ON(!ops) || WARN_ON(!ops->destructor))
10432                 return ERR_PTR(-EINVAL);
10433
10434         mutex_lock(&devlink->lock);
10435
10436         if (devlink_port_region_get_by_name(port, ops->name)) {
10437                 err = -EEXIST;
10438                 goto unlock;
10439         }
10440
10441         region = kzalloc(sizeof(*region), GFP_KERNEL);
10442         if (!region) {
10443                 err = -ENOMEM;
10444                 goto unlock;
10445         }
10446
10447         region->devlink = devlink;
10448         region->port = port;
10449         region->max_snapshots = region_max_snapshots;
10450         region->port_ops = ops;
10451         region->size = region_size;
10452         INIT_LIST_HEAD(&region->snapshot_list);
10453         list_add_tail(&region->list, &port->region_list);
10454         devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
10455
10456         mutex_unlock(&devlink->lock);
10457         return region;
10458
10459 unlock:
10460         mutex_unlock(&devlink->lock);
10461         return ERR_PTR(err);
10462 }
10463 EXPORT_SYMBOL_GPL(devlink_port_region_create);
10464
10465 /**
10466  *      devlink_region_destroy - destroy address region
10467  *
10468  *      @region: devlink region to destroy
10469  */
10470 void devlink_region_destroy(struct devlink_region *region)
10471 {
10472         struct devlink *devlink = region->devlink;
10473         struct devlink_snapshot *snapshot, *ts;
10474
10475         mutex_lock(&devlink->lock);
10476
10477         /* Free all snapshots of region */
10478         list_for_each_entry_safe(snapshot, ts, &region->snapshot_list, list)
10479                 devlink_region_snapshot_del(region, snapshot);
10480
10481         list_del(&region->list);
10482
10483         devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_DEL);
10484         mutex_unlock(&devlink->lock);
10485         kfree(region);
10486 }
10487 EXPORT_SYMBOL_GPL(devlink_region_destroy);
10488
10489 /**
10490  *      devlink_region_snapshot_id_get - get snapshot ID
10491  *
10492  *      This callback should be called when adding a new snapshot,
10493  *      Driver should use the same id for multiple snapshots taken
10494  *      on multiple regions at the same time/by the same trigger.
10495  *
10496  *      The caller of this function must use devlink_region_snapshot_id_put
10497  *      when finished creating regions using this id.
10498  *
10499  *      Returns zero on success, or a negative error code on failure.
10500  *
10501  *      @devlink: devlink
10502  *      @id: storage to return id
10503  */
10504 int devlink_region_snapshot_id_get(struct devlink *devlink, u32 *id)
10505 {
10506         int err;
10507
10508         mutex_lock(&devlink->lock);
10509         err = __devlink_region_snapshot_id_get(devlink, id);
10510         mutex_unlock(&devlink->lock);
10511
10512         return err;
10513 }
10514 EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_get);
10515
10516 /**
10517  *      devlink_region_snapshot_id_put - put snapshot ID reference
10518  *
10519  *      This should be called by a driver after finishing creating snapshots
10520  *      with an id. Doing so ensures that the ID can later be released in the
10521  *      event that all snapshots using it have been destroyed.
10522  *
10523  *      @devlink: devlink
10524  *      @id: id to release reference on
10525  */
10526 void devlink_region_snapshot_id_put(struct devlink *devlink, u32 id)
10527 {
10528         mutex_lock(&devlink->lock);
10529         __devlink_snapshot_id_decrement(devlink, id);
10530         mutex_unlock(&devlink->lock);
10531 }
10532 EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_put);
10533
10534 /**
10535  *      devlink_region_snapshot_create - create a new snapshot
10536  *      This will add a new snapshot of a region. The snapshot
10537  *      will be stored on the region struct and can be accessed
10538  *      from devlink. This is useful for future analyses of snapshots.
10539  *      Multiple snapshots can be created on a region.
10540  *      The @snapshot_id should be obtained using the getter function.
10541  *
10542  *      @region: devlink region of the snapshot
10543  *      @data: snapshot data
10544  *      @snapshot_id: snapshot id to be created
10545  */
10546 int devlink_region_snapshot_create(struct devlink_region *region,
10547                                    u8 *data, u32 snapshot_id)
10548 {
10549         struct devlink *devlink = region->devlink;
10550         int err;
10551
10552         mutex_lock(&devlink->lock);
10553         err = __devlink_region_snapshot_create(region, data, snapshot_id);
10554         mutex_unlock(&devlink->lock);
10555
10556         return err;
10557 }
10558 EXPORT_SYMBOL_GPL(devlink_region_snapshot_create);
10559
10560 #define DEVLINK_TRAP(_id, _type)                                              \
10561         {                                                                     \
10562                 .type = DEVLINK_TRAP_TYPE_##_type,                            \
10563                 .id = DEVLINK_TRAP_GENERIC_ID_##_id,                          \
10564                 .name = DEVLINK_TRAP_GENERIC_NAME_##_id,                      \
10565         }
10566
10567 static const struct devlink_trap devlink_trap_generic[] = {
10568         DEVLINK_TRAP(SMAC_MC, DROP),
10569         DEVLINK_TRAP(VLAN_TAG_MISMATCH, DROP),
10570         DEVLINK_TRAP(INGRESS_VLAN_FILTER, DROP),
10571         DEVLINK_TRAP(INGRESS_STP_FILTER, DROP),
10572         DEVLINK_TRAP(EMPTY_TX_LIST, DROP),
10573         DEVLINK_TRAP(PORT_LOOPBACK_FILTER, DROP),
10574         DEVLINK_TRAP(BLACKHOLE_ROUTE, DROP),
10575         DEVLINK_TRAP(TTL_ERROR, EXCEPTION),
10576         DEVLINK_TRAP(TAIL_DROP, DROP),
10577         DEVLINK_TRAP(NON_IP_PACKET, DROP),
10578         DEVLINK_TRAP(UC_DIP_MC_DMAC, DROP),
10579         DEVLINK_TRAP(DIP_LB, DROP),
10580         DEVLINK_TRAP(SIP_MC, DROP),
10581         DEVLINK_TRAP(SIP_LB, DROP),
10582         DEVLINK_TRAP(CORRUPTED_IP_HDR, DROP),
10583         DEVLINK_TRAP(IPV4_SIP_BC, DROP),
10584         DEVLINK_TRAP(IPV6_MC_DIP_RESERVED_SCOPE, DROP),
10585         DEVLINK_TRAP(IPV6_MC_DIP_INTERFACE_LOCAL_SCOPE, DROP),
10586         DEVLINK_TRAP(MTU_ERROR, EXCEPTION),
10587         DEVLINK_TRAP(UNRESOLVED_NEIGH, EXCEPTION),
10588         DEVLINK_TRAP(RPF, EXCEPTION),
10589         DEVLINK_TRAP(REJECT_ROUTE, EXCEPTION),
10590         DEVLINK_TRAP(IPV4_LPM_UNICAST_MISS, EXCEPTION),
10591         DEVLINK_TRAP(IPV6_LPM_UNICAST_MISS, EXCEPTION),
10592         DEVLINK_TRAP(NON_ROUTABLE, DROP),
10593         DEVLINK_TRAP(DECAP_ERROR, EXCEPTION),
10594         DEVLINK_TRAP(OVERLAY_SMAC_MC, DROP),
10595         DEVLINK_TRAP(INGRESS_FLOW_ACTION_DROP, DROP),
10596         DEVLINK_TRAP(EGRESS_FLOW_ACTION_DROP, DROP),
10597         DEVLINK_TRAP(STP, CONTROL),
10598         DEVLINK_TRAP(LACP, CONTROL),
10599         DEVLINK_TRAP(LLDP, CONTROL),
10600         DEVLINK_TRAP(IGMP_QUERY, CONTROL),
10601         DEVLINK_TRAP(IGMP_V1_REPORT, CONTROL),
10602         DEVLINK_TRAP(IGMP_V2_REPORT, CONTROL),
10603         DEVLINK_TRAP(IGMP_V3_REPORT, CONTROL),
10604         DEVLINK_TRAP(IGMP_V2_LEAVE, CONTROL),
10605         DEVLINK_TRAP(MLD_QUERY, CONTROL),
10606         DEVLINK_TRAP(MLD_V1_REPORT, CONTROL),
10607         DEVLINK_TRAP(MLD_V2_REPORT, CONTROL),
10608         DEVLINK_TRAP(MLD_V1_DONE, CONTROL),
10609         DEVLINK_TRAP(IPV4_DHCP, CONTROL),
10610         DEVLINK_TRAP(IPV6_DHCP, CONTROL),
10611         DEVLINK_TRAP(ARP_REQUEST, CONTROL),
10612         DEVLINK_TRAP(ARP_RESPONSE, CONTROL),
10613         DEVLINK_TRAP(ARP_OVERLAY, CONTROL),
10614         DEVLINK_TRAP(IPV6_NEIGH_SOLICIT, CONTROL),
10615         DEVLINK_TRAP(IPV6_NEIGH_ADVERT, CONTROL),
10616         DEVLINK_TRAP(IPV4_BFD, CONTROL),
10617         DEVLINK_TRAP(IPV6_BFD, CONTROL),
10618         DEVLINK_TRAP(IPV4_OSPF, CONTROL),
10619         DEVLINK_TRAP(IPV6_OSPF, CONTROL),
10620         DEVLINK_TRAP(IPV4_BGP, CONTROL),
10621         DEVLINK_TRAP(IPV6_BGP, CONTROL),
10622         DEVLINK_TRAP(IPV4_VRRP, CONTROL),
10623         DEVLINK_TRAP(IPV6_VRRP, CONTROL),
10624         DEVLINK_TRAP(IPV4_PIM, CONTROL),
10625         DEVLINK_TRAP(IPV6_PIM, CONTROL),
10626         DEVLINK_TRAP(UC_LB, CONTROL),
10627         DEVLINK_TRAP(LOCAL_ROUTE, CONTROL),
10628         DEVLINK_TRAP(EXTERNAL_ROUTE, CONTROL),
10629         DEVLINK_TRAP(IPV6_UC_DIP_LINK_LOCAL_SCOPE, CONTROL),
10630         DEVLINK_TRAP(IPV6_DIP_ALL_NODES, CONTROL),
10631         DEVLINK_TRAP(IPV6_DIP_ALL_ROUTERS, CONTROL),
10632         DEVLINK_TRAP(IPV6_ROUTER_SOLICIT, CONTROL),
10633         DEVLINK_TRAP(IPV6_ROUTER_ADVERT, CONTROL),
10634         DEVLINK_TRAP(IPV6_REDIRECT, CONTROL),
10635         DEVLINK_TRAP(IPV4_ROUTER_ALERT, CONTROL),
10636         DEVLINK_TRAP(IPV6_ROUTER_ALERT, CONTROL),
10637         DEVLINK_TRAP(PTP_EVENT, CONTROL),
10638         DEVLINK_TRAP(PTP_GENERAL, CONTROL),
10639         DEVLINK_TRAP(FLOW_ACTION_SAMPLE, CONTROL),
10640         DEVLINK_TRAP(FLOW_ACTION_TRAP, CONTROL),
10641         DEVLINK_TRAP(EARLY_DROP, DROP),
10642         DEVLINK_TRAP(VXLAN_PARSING, DROP),
10643         DEVLINK_TRAP(LLC_SNAP_PARSING, DROP),
10644         DEVLINK_TRAP(VLAN_PARSING, DROP),
10645         DEVLINK_TRAP(PPPOE_PPP_PARSING, DROP),
10646         DEVLINK_TRAP(MPLS_PARSING, DROP),
10647         DEVLINK_TRAP(ARP_PARSING, DROP),
10648         DEVLINK_TRAP(IP_1_PARSING, DROP),
10649         DEVLINK_TRAP(IP_N_PARSING, DROP),
10650         DEVLINK_TRAP(GRE_PARSING, DROP),
10651         DEVLINK_TRAP(UDP_PARSING, DROP),
10652         DEVLINK_TRAP(TCP_PARSING, DROP),
10653         DEVLINK_TRAP(IPSEC_PARSING, DROP),
10654         DEVLINK_TRAP(SCTP_PARSING, DROP),
10655         DEVLINK_TRAP(DCCP_PARSING, DROP),
10656         DEVLINK_TRAP(GTP_PARSING, DROP),
10657         DEVLINK_TRAP(ESP_PARSING, DROP),
10658         DEVLINK_TRAP(BLACKHOLE_NEXTHOP, DROP),
10659         DEVLINK_TRAP(DMAC_FILTER, DROP),
10660 };
10661
10662 #define DEVLINK_TRAP_GROUP(_id)                                               \
10663         {                                                                     \
10664                 .id = DEVLINK_TRAP_GROUP_GENERIC_ID_##_id,                    \
10665                 .name = DEVLINK_TRAP_GROUP_GENERIC_NAME_##_id,                \
10666         }
10667
10668 static const struct devlink_trap_group devlink_trap_group_generic[] = {
10669         DEVLINK_TRAP_GROUP(L2_DROPS),
10670         DEVLINK_TRAP_GROUP(L3_DROPS),
10671         DEVLINK_TRAP_GROUP(L3_EXCEPTIONS),
10672         DEVLINK_TRAP_GROUP(BUFFER_DROPS),
10673         DEVLINK_TRAP_GROUP(TUNNEL_DROPS),
10674         DEVLINK_TRAP_GROUP(ACL_DROPS),
10675         DEVLINK_TRAP_GROUP(STP),
10676         DEVLINK_TRAP_GROUP(LACP),
10677         DEVLINK_TRAP_GROUP(LLDP),
10678         DEVLINK_TRAP_GROUP(MC_SNOOPING),
10679         DEVLINK_TRAP_GROUP(DHCP),
10680         DEVLINK_TRAP_GROUP(NEIGH_DISCOVERY),
10681         DEVLINK_TRAP_GROUP(BFD),
10682         DEVLINK_TRAP_GROUP(OSPF),
10683         DEVLINK_TRAP_GROUP(BGP),
10684         DEVLINK_TRAP_GROUP(VRRP),
10685         DEVLINK_TRAP_GROUP(PIM),
10686         DEVLINK_TRAP_GROUP(UC_LB),
10687         DEVLINK_TRAP_GROUP(LOCAL_DELIVERY),
10688         DEVLINK_TRAP_GROUP(EXTERNAL_DELIVERY),
10689         DEVLINK_TRAP_GROUP(IPV6),
10690         DEVLINK_TRAP_GROUP(PTP_EVENT),
10691         DEVLINK_TRAP_GROUP(PTP_GENERAL),
10692         DEVLINK_TRAP_GROUP(ACL_SAMPLE),
10693         DEVLINK_TRAP_GROUP(ACL_TRAP),
10694         DEVLINK_TRAP_GROUP(PARSER_ERROR_DROPS),
10695 };
10696
10697 static int devlink_trap_generic_verify(const struct devlink_trap *trap)
10698 {
10699         if (trap->id > DEVLINK_TRAP_GENERIC_ID_MAX)
10700                 return -EINVAL;
10701
10702         if (strcmp(trap->name, devlink_trap_generic[trap->id].name))
10703                 return -EINVAL;
10704
10705         if (trap->type != devlink_trap_generic[trap->id].type)
10706                 return -EINVAL;
10707
10708         return 0;
10709 }
10710
10711 static int devlink_trap_driver_verify(const struct devlink_trap *trap)
10712 {
10713         int i;
10714
10715         if (trap->id <= DEVLINK_TRAP_GENERIC_ID_MAX)
10716                 return -EINVAL;
10717
10718         for (i = 0; i < ARRAY_SIZE(devlink_trap_generic); i++) {
10719                 if (!strcmp(trap->name, devlink_trap_generic[i].name))
10720                         return -EEXIST;
10721         }
10722
10723         return 0;
10724 }
10725
10726 static int devlink_trap_verify(const struct devlink_trap *trap)
10727 {
10728         if (!trap || !trap->name)
10729                 return -EINVAL;
10730
10731         if (trap->generic)
10732                 return devlink_trap_generic_verify(trap);
10733         else
10734                 return devlink_trap_driver_verify(trap);
10735 }
10736
10737 static int
10738 devlink_trap_group_generic_verify(const struct devlink_trap_group *group)
10739 {
10740         if (group->id > DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
10741                 return -EINVAL;
10742
10743         if (strcmp(group->name, devlink_trap_group_generic[group->id].name))
10744                 return -EINVAL;
10745
10746         return 0;
10747 }
10748
10749 static int
10750 devlink_trap_group_driver_verify(const struct devlink_trap_group *group)
10751 {
10752         int i;
10753
10754         if (group->id <= DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
10755                 return -EINVAL;
10756
10757         for (i = 0; i < ARRAY_SIZE(devlink_trap_group_generic); i++) {
10758                 if (!strcmp(group->name, devlink_trap_group_generic[i].name))
10759                         return -EEXIST;
10760         }
10761
10762         return 0;
10763 }
10764
10765 static int devlink_trap_group_verify(const struct devlink_trap_group *group)
10766 {
10767         if (group->generic)
10768                 return devlink_trap_group_generic_verify(group);
10769         else
10770                 return devlink_trap_group_driver_verify(group);
10771 }
10772
10773 static void
10774 devlink_trap_group_notify(struct devlink *devlink,
10775                           const struct devlink_trap_group_item *group_item,
10776                           enum devlink_command cmd)
10777 {
10778         struct sk_buff *msg;
10779         int err;
10780
10781         WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_GROUP_NEW &&
10782                      cmd != DEVLINK_CMD_TRAP_GROUP_DEL);
10783         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
10784                 return;
10785
10786         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10787         if (!msg)
10788                 return;
10789
10790         err = devlink_nl_trap_group_fill(msg, devlink, group_item, cmd, 0, 0,
10791                                          0);
10792         if (err) {
10793                 nlmsg_free(msg);
10794                 return;
10795         }
10796
10797         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
10798                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
10799 }
10800
10801 static int
10802 devlink_trap_item_group_link(struct devlink *devlink,
10803                              struct devlink_trap_item *trap_item)
10804 {
10805         u16 group_id = trap_item->trap->init_group_id;
10806         struct devlink_trap_group_item *group_item;
10807
10808         group_item = devlink_trap_group_item_lookup_by_id(devlink, group_id);
10809         if (WARN_ON_ONCE(!group_item))
10810                 return -EINVAL;
10811
10812         trap_item->group_item = group_item;
10813
10814         return 0;
10815 }
10816
10817 static void devlink_trap_notify(struct devlink *devlink,
10818                                 const struct devlink_trap_item *trap_item,
10819                                 enum devlink_command cmd)
10820 {
10821         struct sk_buff *msg;
10822         int err;
10823
10824         WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_NEW &&
10825                      cmd != DEVLINK_CMD_TRAP_DEL);
10826         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
10827                 return;
10828
10829         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10830         if (!msg)
10831                 return;
10832
10833         err = devlink_nl_trap_fill(msg, devlink, trap_item, cmd, 0, 0, 0);
10834         if (err) {
10835                 nlmsg_free(msg);
10836                 return;
10837         }
10838
10839         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
10840                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
10841 }
10842
10843 static int
10844 devlink_trap_register(struct devlink *devlink,
10845                       const struct devlink_trap *trap, void *priv)
10846 {
10847         struct devlink_trap_item *trap_item;
10848         int err;
10849
10850         if (devlink_trap_item_lookup(devlink, trap->name))
10851                 return -EEXIST;
10852
10853         trap_item = kzalloc(sizeof(*trap_item), GFP_KERNEL);
10854         if (!trap_item)
10855                 return -ENOMEM;
10856
10857         trap_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
10858         if (!trap_item->stats) {
10859                 err = -ENOMEM;
10860                 goto err_stats_alloc;
10861         }
10862
10863         trap_item->trap = trap;
10864         trap_item->action = trap->init_action;
10865         trap_item->priv = priv;
10866
10867         err = devlink_trap_item_group_link(devlink, trap_item);
10868         if (err)
10869                 goto err_group_link;
10870
10871         err = devlink->ops->trap_init(devlink, trap, trap_item);
10872         if (err)
10873                 goto err_trap_init;
10874
10875         list_add_tail(&trap_item->list, &devlink->trap_list);
10876         devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_NEW);
10877
10878         return 0;
10879
10880 err_trap_init:
10881 err_group_link:
10882         free_percpu(trap_item->stats);
10883 err_stats_alloc:
10884         kfree(trap_item);
10885         return err;
10886 }
10887
10888 static void devlink_trap_unregister(struct devlink *devlink,
10889                                     const struct devlink_trap *trap)
10890 {
10891         struct devlink_trap_item *trap_item;
10892
10893         trap_item = devlink_trap_item_lookup(devlink, trap->name);
10894         if (WARN_ON_ONCE(!trap_item))
10895                 return;
10896
10897         devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_DEL);
10898         list_del(&trap_item->list);
10899         if (devlink->ops->trap_fini)
10900                 devlink->ops->trap_fini(devlink, trap, trap_item);
10901         free_percpu(trap_item->stats);
10902         kfree(trap_item);
10903 }
10904
10905 static void devlink_trap_disable(struct devlink *devlink,
10906                                  const struct devlink_trap *trap)
10907 {
10908         struct devlink_trap_item *trap_item;
10909
10910         trap_item = devlink_trap_item_lookup(devlink, trap->name);
10911         if (WARN_ON_ONCE(!trap_item))
10912                 return;
10913
10914         devlink->ops->trap_action_set(devlink, trap, DEVLINK_TRAP_ACTION_DROP,
10915                                       NULL);
10916         trap_item->action = DEVLINK_TRAP_ACTION_DROP;
10917 }
10918
10919 /**
10920  * devlink_traps_register - Register packet traps with devlink.
10921  * @devlink: devlink.
10922  * @traps: Packet traps.
10923  * @traps_count: Count of provided packet traps.
10924  * @priv: Driver private information.
10925  *
10926  * Return: Non-zero value on failure.
10927  */
10928 int devlink_traps_register(struct devlink *devlink,
10929                            const struct devlink_trap *traps,
10930                            size_t traps_count, void *priv)
10931 {
10932         int i, err;
10933
10934         if (!devlink->ops->trap_init || !devlink->ops->trap_action_set)
10935                 return -EINVAL;
10936
10937         mutex_lock(&devlink->lock);
10938         for (i = 0; i < traps_count; i++) {
10939                 const struct devlink_trap *trap = &traps[i];
10940
10941                 err = devlink_trap_verify(trap);
10942                 if (err)
10943                         goto err_trap_verify;
10944
10945                 err = devlink_trap_register(devlink, trap, priv);
10946                 if (err)
10947                         goto err_trap_register;
10948         }
10949         mutex_unlock(&devlink->lock);
10950
10951         return 0;
10952
10953 err_trap_register:
10954 err_trap_verify:
10955         for (i--; i >= 0; i--)
10956                 devlink_trap_unregister(devlink, &traps[i]);
10957         mutex_unlock(&devlink->lock);
10958         return err;
10959 }
10960 EXPORT_SYMBOL_GPL(devlink_traps_register);
10961
10962 /**
10963  * devlink_traps_unregister - Unregister packet traps from devlink.
10964  * @devlink: devlink.
10965  * @traps: Packet traps.
10966  * @traps_count: Count of provided packet traps.
10967  */
10968 void devlink_traps_unregister(struct devlink *devlink,
10969                               const struct devlink_trap *traps,
10970                               size_t traps_count)
10971 {
10972         int i;
10973
10974         mutex_lock(&devlink->lock);
10975         /* Make sure we do not have any packets in-flight while unregistering
10976          * traps by disabling all of them and waiting for a grace period.
10977          */
10978         for (i = traps_count - 1; i >= 0; i--)
10979                 devlink_trap_disable(devlink, &traps[i]);
10980         synchronize_rcu();
10981         for (i = traps_count - 1; i >= 0; i--)
10982                 devlink_trap_unregister(devlink, &traps[i]);
10983         mutex_unlock(&devlink->lock);
10984 }
10985 EXPORT_SYMBOL_GPL(devlink_traps_unregister);
10986
10987 static void
10988 devlink_trap_stats_update(struct devlink_stats __percpu *trap_stats,
10989                           size_t skb_len)
10990 {
10991         struct devlink_stats *stats;
10992
10993         stats = this_cpu_ptr(trap_stats);
10994         u64_stats_update_begin(&stats->syncp);
10995         stats->rx_bytes += skb_len;
10996         stats->rx_packets++;
10997         u64_stats_update_end(&stats->syncp);
10998 }
10999
11000 static void
11001 devlink_trap_report_metadata_set(struct devlink_trap_metadata *metadata,
11002                                  const struct devlink_trap_item *trap_item,
11003                                  struct devlink_port *in_devlink_port,
11004                                  const struct flow_action_cookie *fa_cookie)
11005 {
11006         metadata->trap_name = trap_item->trap->name;
11007         metadata->trap_group_name = trap_item->group_item->group->name;
11008         metadata->fa_cookie = fa_cookie;
11009         metadata->trap_type = trap_item->trap->type;
11010
11011         spin_lock(&in_devlink_port->type_lock);
11012         if (in_devlink_port->type == DEVLINK_PORT_TYPE_ETH)
11013                 metadata->input_dev = in_devlink_port->type_dev;
11014         spin_unlock(&in_devlink_port->type_lock);
11015 }
11016
11017 /**
11018  * devlink_trap_report - Report trapped packet to drop monitor.
11019  * @devlink: devlink.
11020  * @skb: Trapped packet.
11021  * @trap_ctx: Trap context.
11022  * @in_devlink_port: Input devlink port.
11023  * @fa_cookie: Flow action cookie. Could be NULL.
11024  */
11025 void devlink_trap_report(struct devlink *devlink, struct sk_buff *skb,
11026                          void *trap_ctx, struct devlink_port *in_devlink_port,
11027                          const struct flow_action_cookie *fa_cookie)
11028
11029 {
11030         struct devlink_trap_item *trap_item = trap_ctx;
11031
11032         devlink_trap_stats_update(trap_item->stats, skb->len);
11033         devlink_trap_stats_update(trap_item->group_item->stats, skb->len);
11034
11035         if (trace_devlink_trap_report_enabled()) {
11036                 struct devlink_trap_metadata metadata = {};
11037
11038                 devlink_trap_report_metadata_set(&metadata, trap_item,
11039                                                  in_devlink_port, fa_cookie);
11040                 trace_devlink_trap_report(devlink, skb, &metadata);
11041         }
11042 }
11043 EXPORT_SYMBOL_GPL(devlink_trap_report);
11044
11045 /**
11046  * devlink_trap_ctx_priv - Trap context to driver private information.
11047  * @trap_ctx: Trap context.
11048  *
11049  * Return: Driver private information passed during registration.
11050  */
11051 void *devlink_trap_ctx_priv(void *trap_ctx)
11052 {
11053         struct devlink_trap_item *trap_item = trap_ctx;
11054
11055         return trap_item->priv;
11056 }
11057 EXPORT_SYMBOL_GPL(devlink_trap_ctx_priv);
11058
11059 static int
11060 devlink_trap_group_item_policer_link(struct devlink *devlink,
11061                                      struct devlink_trap_group_item *group_item)
11062 {
11063         u32 policer_id = group_item->group->init_policer_id;
11064         struct devlink_trap_policer_item *policer_item;
11065
11066         if (policer_id == 0)
11067                 return 0;
11068
11069         policer_item = devlink_trap_policer_item_lookup(devlink, policer_id);
11070         if (WARN_ON_ONCE(!policer_item))
11071                 return -EINVAL;
11072
11073         group_item->policer_item = policer_item;
11074
11075         return 0;
11076 }
11077
11078 static int
11079 devlink_trap_group_register(struct devlink *devlink,
11080                             const struct devlink_trap_group *group)
11081 {
11082         struct devlink_trap_group_item *group_item;
11083         int err;
11084
11085         if (devlink_trap_group_item_lookup(devlink, group->name))
11086                 return -EEXIST;
11087
11088         group_item = kzalloc(sizeof(*group_item), GFP_KERNEL);
11089         if (!group_item)
11090                 return -ENOMEM;
11091
11092         group_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
11093         if (!group_item->stats) {
11094                 err = -ENOMEM;
11095                 goto err_stats_alloc;
11096         }
11097
11098         group_item->group = group;
11099
11100         err = devlink_trap_group_item_policer_link(devlink, group_item);
11101         if (err)
11102                 goto err_policer_link;
11103
11104         if (devlink->ops->trap_group_init) {
11105                 err = devlink->ops->trap_group_init(devlink, group);
11106                 if (err)
11107                         goto err_group_init;
11108         }
11109
11110         list_add_tail(&group_item->list, &devlink->trap_group_list);
11111         devlink_trap_group_notify(devlink, group_item,
11112                                   DEVLINK_CMD_TRAP_GROUP_NEW);
11113
11114         return 0;
11115
11116 err_group_init:
11117 err_policer_link:
11118         free_percpu(group_item->stats);
11119 err_stats_alloc:
11120         kfree(group_item);
11121         return err;
11122 }
11123
11124 static void
11125 devlink_trap_group_unregister(struct devlink *devlink,
11126                               const struct devlink_trap_group *group)
11127 {
11128         struct devlink_trap_group_item *group_item;
11129
11130         group_item = devlink_trap_group_item_lookup(devlink, group->name);
11131         if (WARN_ON_ONCE(!group_item))
11132                 return;
11133
11134         devlink_trap_group_notify(devlink, group_item,
11135                                   DEVLINK_CMD_TRAP_GROUP_DEL);
11136         list_del(&group_item->list);
11137         free_percpu(group_item->stats);
11138         kfree(group_item);
11139 }
11140
11141 /**
11142  * devlink_trap_groups_register - Register packet trap groups with devlink.
11143  * @devlink: devlink.
11144  * @groups: Packet trap groups.
11145  * @groups_count: Count of provided packet trap groups.
11146  *
11147  * Return: Non-zero value on failure.
11148  */
11149 int devlink_trap_groups_register(struct devlink *devlink,
11150                                  const struct devlink_trap_group *groups,
11151                                  size_t groups_count)
11152 {
11153         int i, err;
11154
11155         mutex_lock(&devlink->lock);
11156         for (i = 0; i < groups_count; i++) {
11157                 const struct devlink_trap_group *group = &groups[i];
11158
11159                 err = devlink_trap_group_verify(group);
11160                 if (err)
11161                         goto err_trap_group_verify;
11162
11163                 err = devlink_trap_group_register(devlink, group);
11164                 if (err)
11165                         goto err_trap_group_register;
11166         }
11167         mutex_unlock(&devlink->lock);
11168
11169         return 0;
11170
11171 err_trap_group_register:
11172 err_trap_group_verify:
11173         for (i--; i >= 0; i--)
11174                 devlink_trap_group_unregister(devlink, &groups[i]);
11175         mutex_unlock(&devlink->lock);
11176         return err;
11177 }
11178 EXPORT_SYMBOL_GPL(devlink_trap_groups_register);
11179
11180 /**
11181  * devlink_trap_groups_unregister - Unregister packet trap groups from devlink.
11182  * @devlink: devlink.
11183  * @groups: Packet trap groups.
11184  * @groups_count: Count of provided packet trap groups.
11185  */
11186 void devlink_trap_groups_unregister(struct devlink *devlink,
11187                                     const struct devlink_trap_group *groups,
11188                                     size_t groups_count)
11189 {
11190         int i;
11191
11192         mutex_lock(&devlink->lock);
11193         for (i = groups_count - 1; i >= 0; i--)
11194                 devlink_trap_group_unregister(devlink, &groups[i]);
11195         mutex_unlock(&devlink->lock);
11196 }
11197 EXPORT_SYMBOL_GPL(devlink_trap_groups_unregister);
11198
11199 static void
11200 devlink_trap_policer_notify(struct devlink *devlink,
11201                             const struct devlink_trap_policer_item *policer_item,
11202                             enum devlink_command cmd)
11203 {
11204         struct sk_buff *msg;
11205         int err;
11206
11207         WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_POLICER_NEW &&
11208                      cmd != DEVLINK_CMD_TRAP_POLICER_DEL);
11209         if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
11210                 return;
11211
11212         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11213         if (!msg)
11214                 return;
11215
11216         err = devlink_nl_trap_policer_fill(msg, devlink, policer_item, cmd, 0,
11217                                            0, 0);
11218         if (err) {
11219                 nlmsg_free(msg);
11220                 return;
11221         }
11222
11223         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
11224                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
11225 }
11226
11227 static int
11228 devlink_trap_policer_register(struct devlink *devlink,
11229                               const struct devlink_trap_policer *policer)
11230 {
11231         struct devlink_trap_policer_item *policer_item;
11232         int err;
11233
11234         if (devlink_trap_policer_item_lookup(devlink, policer->id))
11235                 return -EEXIST;
11236
11237         policer_item = kzalloc(sizeof(*policer_item), GFP_KERNEL);
11238         if (!policer_item)
11239                 return -ENOMEM;
11240
11241         policer_item->policer = policer;
11242         policer_item->rate = policer->init_rate;
11243         policer_item->burst = policer->init_burst;
11244
11245         if (devlink->ops->trap_policer_init) {
11246                 err = devlink->ops->trap_policer_init(devlink, policer);
11247                 if (err)
11248                         goto err_policer_init;
11249         }
11250
11251         list_add_tail(&policer_item->list, &devlink->trap_policer_list);
11252         devlink_trap_policer_notify(devlink, policer_item,
11253                                     DEVLINK_CMD_TRAP_POLICER_NEW);
11254
11255         return 0;
11256
11257 err_policer_init:
11258         kfree(policer_item);
11259         return err;
11260 }
11261
11262 static void
11263 devlink_trap_policer_unregister(struct devlink *devlink,
11264                                 const struct devlink_trap_policer *policer)
11265 {
11266         struct devlink_trap_policer_item *policer_item;
11267
11268         policer_item = devlink_trap_policer_item_lookup(devlink, policer->id);
11269         if (WARN_ON_ONCE(!policer_item))
11270                 return;
11271
11272         devlink_trap_policer_notify(devlink, policer_item,
11273                                     DEVLINK_CMD_TRAP_POLICER_DEL);
11274         list_del(&policer_item->list);
11275         if (devlink->ops->trap_policer_fini)
11276                 devlink->ops->trap_policer_fini(devlink, policer);
11277         kfree(policer_item);
11278 }
11279
11280 /**
11281  * devlink_trap_policers_register - Register packet trap policers with devlink.
11282  * @devlink: devlink.
11283  * @policers: Packet trap policers.
11284  * @policers_count: Count of provided packet trap policers.
11285  *
11286  * Return: Non-zero value on failure.
11287  */
11288 int
11289 devlink_trap_policers_register(struct devlink *devlink,
11290                                const struct devlink_trap_policer *policers,
11291                                size_t policers_count)
11292 {
11293         int i, err;
11294
11295         mutex_lock(&devlink->lock);
11296         for (i = 0; i < policers_count; i++) {
11297                 const struct devlink_trap_policer *policer = &policers[i];
11298
11299                 if (WARN_ON(policer->id == 0 ||
11300                             policer->max_rate < policer->min_rate ||
11301                             policer->max_burst < policer->min_burst)) {
11302                         err = -EINVAL;
11303                         goto err_trap_policer_verify;
11304                 }
11305
11306                 err = devlink_trap_policer_register(devlink, policer);
11307                 if (err)
11308                         goto err_trap_policer_register;
11309         }
11310         mutex_unlock(&devlink->lock);
11311
11312         return 0;
11313
11314 err_trap_policer_register:
11315 err_trap_policer_verify:
11316         for (i--; i >= 0; i--)
11317                 devlink_trap_policer_unregister(devlink, &policers[i]);
11318         mutex_unlock(&devlink->lock);
11319         return err;
11320 }
11321 EXPORT_SYMBOL_GPL(devlink_trap_policers_register);
11322
11323 /**
11324  * devlink_trap_policers_unregister - Unregister packet trap policers from devlink.
11325  * @devlink: devlink.
11326  * @policers: Packet trap policers.
11327  * @policers_count: Count of provided packet trap policers.
11328  */
11329 void
11330 devlink_trap_policers_unregister(struct devlink *devlink,
11331                                  const struct devlink_trap_policer *policers,
11332                                  size_t policers_count)
11333 {
11334         int i;
11335
11336         mutex_lock(&devlink->lock);
11337         for (i = policers_count - 1; i >= 0; i--)
11338                 devlink_trap_policer_unregister(devlink, &policers[i]);
11339         mutex_unlock(&devlink->lock);
11340 }
11341 EXPORT_SYMBOL_GPL(devlink_trap_policers_unregister);
11342
11343 static void __devlink_compat_running_version(struct devlink *devlink,
11344                                              char *buf, size_t len)
11345 {
11346         const struct nlattr *nlattr;
11347         struct devlink_info_req req;
11348         struct sk_buff *msg;
11349         int rem, err;
11350
11351         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11352         if (!msg)
11353                 return;
11354
11355         req.msg = msg;
11356         err = devlink->ops->info_get(devlink, &req, NULL);
11357         if (err)
11358                 goto free_msg;
11359
11360         nla_for_each_attr(nlattr, (void *)msg->data, msg->len, rem) {
11361                 const struct nlattr *kv;
11362                 int rem_kv;
11363
11364                 if (nla_type(nlattr) != DEVLINK_ATTR_INFO_VERSION_RUNNING)
11365                         continue;
11366
11367                 nla_for_each_nested(kv, nlattr, rem_kv) {
11368                         if (nla_type(kv) != DEVLINK_ATTR_INFO_VERSION_VALUE)
11369                                 continue;
11370
11371                         strlcat(buf, nla_data(kv), len);
11372                         strlcat(buf, " ", len);
11373                 }
11374         }
11375 free_msg:
11376         nlmsg_free(msg);
11377 }
11378
11379 static struct devlink_port *netdev_to_devlink_port(struct net_device *dev)
11380 {
11381         if (!dev->netdev_ops->ndo_get_devlink_port)
11382                 return NULL;
11383
11384         return dev->netdev_ops->ndo_get_devlink_port(dev);
11385 }
11386
11387 void devlink_compat_running_version(struct devlink *devlink,
11388                                     char *buf, size_t len)
11389 {
11390         if (!devlink->ops->info_get)
11391                 return;
11392
11393         mutex_lock(&devlink->lock);
11394         __devlink_compat_running_version(devlink, buf, len);
11395         mutex_unlock(&devlink->lock);
11396 }
11397
11398 int devlink_compat_flash_update(struct devlink *devlink, const char *file_name)
11399 {
11400         struct devlink_flash_update_params params = {};
11401         int ret;
11402
11403         if (!devlink->ops->flash_update)
11404                 return -EOPNOTSUPP;
11405
11406         ret = request_firmware(&params.fw, file_name, devlink->dev);
11407         if (ret)
11408                 return ret;
11409
11410         mutex_lock(&devlink->lock);
11411         devlink_flash_update_begin_notify(devlink);
11412         ret = devlink->ops->flash_update(devlink, &params, NULL);
11413         devlink_flash_update_end_notify(devlink);
11414         mutex_unlock(&devlink->lock);
11415
11416         release_firmware(params.fw);
11417
11418         return ret;
11419 }
11420
11421 int devlink_compat_phys_port_name_get(struct net_device *dev,
11422                                       char *name, size_t len)
11423 {
11424         struct devlink_port *devlink_port;
11425
11426         /* RTNL mutex is held here which ensures that devlink_port
11427          * instance cannot disappear in the middle. No need to take
11428          * any devlink lock as only permanent values are accessed.
11429          */
11430         ASSERT_RTNL();
11431
11432         devlink_port = netdev_to_devlink_port(dev);
11433         if (!devlink_port)
11434                 return -EOPNOTSUPP;
11435
11436         return __devlink_port_phys_port_name_get(devlink_port, name, len);
11437 }
11438
11439 int devlink_compat_switch_id_get(struct net_device *dev,
11440                                  struct netdev_phys_item_id *ppid)
11441 {
11442         struct devlink_port *devlink_port;
11443
11444         /* Caller must hold RTNL mutex or reference to dev, which ensures that
11445          * devlink_port instance cannot disappear in the middle. No need to take
11446          * any devlink lock as only permanent values are accessed.
11447          */
11448         devlink_port = netdev_to_devlink_port(dev);
11449         if (!devlink_port || !devlink_port->switch_port)
11450                 return -EOPNOTSUPP;
11451
11452         memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid));
11453
11454         return 0;
11455 }
11456
11457 static void __net_exit devlink_pernet_pre_exit(struct net *net)
11458 {
11459         struct devlink *devlink;
11460         u32 actions_performed;
11461         unsigned long index;
11462         int err;
11463
11464         /* In case network namespace is getting destroyed, reload
11465          * all devlink instances from this namespace into init_net.
11466          */
11467         mutex_lock(&devlink_mutex);
11468         xa_for_each_marked(&devlinks, index, devlink, DEVLINK_REGISTERED) {
11469                 if (!devlink_try_get(devlink))
11470                         continue;
11471
11472                 if (!net_eq(devlink_net(devlink), net))
11473                         goto retry;
11474
11475                 WARN_ON(!(devlink->features & DEVLINK_F_RELOAD));
11476                 err = devlink_reload(devlink, &init_net,
11477                                      DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
11478                                      DEVLINK_RELOAD_LIMIT_UNSPEC,
11479                                      &actions_performed, NULL);
11480                 if (err && err != -EOPNOTSUPP)
11481                         pr_warn("Failed to reload devlink instance into init_net\n");
11482 retry:
11483                 devlink_put(devlink);
11484         }
11485         mutex_unlock(&devlink_mutex);
11486 }
11487
11488 static struct pernet_operations devlink_pernet_ops __net_initdata = {
11489         .pre_exit = devlink_pernet_pre_exit,
11490 };
11491
11492 static int __init devlink_init(void)
11493 {
11494         int err;
11495
11496         err = genl_register_family(&devlink_nl_family);
11497         if (err)
11498                 goto out;
11499         err = register_pernet_subsys(&devlink_pernet_ops);
11500
11501 out:
11502         WARN_ON(err);
11503         return err;
11504 }
11505
11506 subsys_initcall(devlink_init);