1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net/core/devlink.c - Network physical/parent device Netlink interface
5 * Heavily inspired by net/wireless/
6 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
7 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/slab.h>
14 #include <linux/gfp.h>
15 #include <linux/device.h>
16 #include <linux/list.h>
17 #include <linux/netdevice.h>
18 #include <linux/spinlock.h>
19 #include <linux/refcount.h>
20 #include <linux/workqueue.h>
21 #include <linux/u64_stats_sync.h>
22 #include <linux/timekeeping.h>
23 #include <rdma/ib_verbs.h>
24 #include <net/netlink.h>
25 #include <net/genetlink.h>
26 #include <net/rtnetlink.h>
27 #include <net/net_namespace.h>
29 #include <net/devlink.h>
30 #define CREATE_TRACE_POINTS
31 #include <trace/events/devlink.h>
33 static struct devlink_dpipe_field devlink_dpipe_fields_ethernet[] = {
35 .name = "destination mac",
36 .id = DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC,
41 struct devlink_dpipe_header devlink_dpipe_header_ethernet = {
43 .id = DEVLINK_DPIPE_HEADER_ETHERNET,
44 .fields = devlink_dpipe_fields_ethernet,
45 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ethernet),
48 EXPORT_SYMBOL(devlink_dpipe_header_ethernet);
50 static struct devlink_dpipe_field devlink_dpipe_fields_ipv4[] = {
52 .name = "destination ip",
53 .id = DEVLINK_DPIPE_FIELD_IPV4_DST_IP,
58 struct devlink_dpipe_header devlink_dpipe_header_ipv4 = {
60 .id = DEVLINK_DPIPE_HEADER_IPV4,
61 .fields = devlink_dpipe_fields_ipv4,
62 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv4),
65 EXPORT_SYMBOL(devlink_dpipe_header_ipv4);
67 static struct devlink_dpipe_field devlink_dpipe_fields_ipv6[] = {
69 .name = "destination ip",
70 .id = DEVLINK_DPIPE_FIELD_IPV6_DST_IP,
75 struct devlink_dpipe_header devlink_dpipe_header_ipv6 = {
77 .id = DEVLINK_DPIPE_HEADER_IPV6,
78 .fields = devlink_dpipe_fields_ipv6,
79 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv6),
82 EXPORT_SYMBOL(devlink_dpipe_header_ipv6);
84 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg);
85 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwerr);
86 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_trap_report);
88 static const struct nla_policy devlink_function_nl_policy[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1] = {
89 [DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] = { .type = NLA_BINARY },
90 [DEVLINK_PORT_FN_ATTR_STATE] =
91 NLA_POLICY_RANGE(NLA_U8, DEVLINK_PORT_FN_STATE_INACTIVE,
92 DEVLINK_PORT_FN_STATE_ACTIVE),
95 static LIST_HEAD(devlink_list);
99 * An overall lock guarding every operation coming from userspace.
100 * It also guards devlink devices list and it is taken when
101 * driver registers/unregisters it.
103 static DEFINE_MUTEX(devlink_mutex);
105 struct net *devlink_net(const struct devlink *devlink)
107 return read_pnet(&devlink->_net);
109 EXPORT_SYMBOL_GPL(devlink_net);
111 static void __devlink_net_set(struct devlink *devlink, struct net *net)
113 write_pnet(&devlink->_net, net);
116 void devlink_net_set(struct devlink *devlink, struct net *net)
118 if (WARN_ON(devlink->registered))
120 __devlink_net_set(devlink, net);
122 EXPORT_SYMBOL_GPL(devlink_net_set);
124 static struct devlink *devlink_get_from_attrs(struct net *net,
125 struct nlattr **attrs)
127 struct devlink *devlink;
131 if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
132 return ERR_PTR(-EINVAL);
134 busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
135 devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
137 lockdep_assert_held(&devlink_mutex);
139 list_for_each_entry(devlink, &devlink_list, list) {
140 if (strcmp(devlink->dev->bus->name, busname) == 0 &&
141 strcmp(dev_name(devlink->dev), devname) == 0 &&
142 net_eq(devlink_net(devlink), net))
146 return ERR_PTR(-ENODEV);
149 static struct devlink *devlink_get_from_info(struct genl_info *info)
151 return devlink_get_from_attrs(genl_info_net(info), info->attrs);
154 static struct devlink_port *devlink_port_get_by_index(struct devlink *devlink,
155 unsigned int port_index)
157 struct devlink_port *devlink_port;
159 list_for_each_entry(devlink_port, &devlink->port_list, list) {
160 if (devlink_port->index == port_index)
166 static bool devlink_port_index_exists(struct devlink *devlink,
167 unsigned int port_index)
169 return devlink_port_get_by_index(devlink, port_index);
172 static struct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink,
173 struct nlattr **attrs)
175 if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
176 u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
177 struct devlink_port *devlink_port;
179 devlink_port = devlink_port_get_by_index(devlink, port_index);
181 return ERR_PTR(-ENODEV);
184 return ERR_PTR(-EINVAL);
187 static struct devlink_port *devlink_port_get_from_info(struct devlink *devlink,
188 struct genl_info *info)
190 return devlink_port_get_from_attrs(devlink, info->attrs);
194 devlink_rate_is_leaf(struct devlink_rate *devlink_rate)
196 return devlink_rate->type == DEVLINK_RATE_TYPE_LEAF;
200 devlink_rate_is_node(struct devlink_rate *devlink_rate)
202 return devlink_rate->type == DEVLINK_RATE_TYPE_NODE;
205 static struct devlink_rate *
206 devlink_rate_leaf_get_from_info(struct devlink *devlink, struct genl_info *info)
208 struct devlink_rate *devlink_rate;
209 struct devlink_port *devlink_port;
211 devlink_port = devlink_port_get_from_attrs(devlink, info->attrs);
212 if (IS_ERR(devlink_port))
213 return ERR_CAST(devlink_port);
214 devlink_rate = devlink_port->devlink_rate;
215 return devlink_rate ?: ERR_PTR(-ENODEV);
218 static struct devlink_rate *
219 devlink_rate_node_get_by_name(struct devlink *devlink, const char *node_name)
221 static struct devlink_rate *devlink_rate;
223 list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
224 if (devlink_rate_is_node(devlink_rate) &&
225 !strcmp(node_name, devlink_rate->name))
228 return ERR_PTR(-ENODEV);
231 static struct devlink_rate *
232 devlink_rate_node_get_from_attrs(struct devlink *devlink, struct nlattr **attrs)
234 const char *rate_node_name;
237 if (!attrs[DEVLINK_ATTR_RATE_NODE_NAME])
238 return ERR_PTR(-EINVAL);
239 rate_node_name = nla_data(attrs[DEVLINK_ATTR_RATE_NODE_NAME]);
240 len = strlen(rate_node_name);
241 /* Name cannot be empty or decimal number */
242 if (!len || strspn(rate_node_name, "0123456789") == len)
243 return ERR_PTR(-EINVAL);
245 return devlink_rate_node_get_by_name(devlink, rate_node_name);
248 static struct devlink_rate *
249 devlink_rate_node_get_from_info(struct devlink *devlink, struct genl_info *info)
251 return devlink_rate_node_get_from_attrs(devlink, info->attrs);
254 static struct devlink_rate *
255 devlink_rate_get_from_info(struct devlink *devlink, struct genl_info *info)
257 struct nlattr **attrs = info->attrs;
259 if (attrs[DEVLINK_ATTR_PORT_INDEX])
260 return devlink_rate_leaf_get_from_info(devlink, info);
261 else if (attrs[DEVLINK_ATTR_RATE_NODE_NAME])
262 return devlink_rate_node_get_from_info(devlink, info);
264 return ERR_PTR(-EINVAL);
268 struct list_head list;
271 u16 ingress_pools_count;
272 u16 egress_pools_count;
273 u16 ingress_tc_count;
277 static u16 devlink_sb_pool_count(struct devlink_sb *devlink_sb)
279 return devlink_sb->ingress_pools_count + devlink_sb->egress_pools_count;
282 static struct devlink_sb *devlink_sb_get_by_index(struct devlink *devlink,
283 unsigned int sb_index)
285 struct devlink_sb *devlink_sb;
287 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
288 if (devlink_sb->index == sb_index)
294 static bool devlink_sb_index_exists(struct devlink *devlink,
295 unsigned int sb_index)
297 return devlink_sb_get_by_index(devlink, sb_index);
300 static struct devlink_sb *devlink_sb_get_from_attrs(struct devlink *devlink,
301 struct nlattr **attrs)
303 if (attrs[DEVLINK_ATTR_SB_INDEX]) {
304 u32 sb_index = nla_get_u32(attrs[DEVLINK_ATTR_SB_INDEX]);
305 struct devlink_sb *devlink_sb;
307 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
309 return ERR_PTR(-ENODEV);
312 return ERR_PTR(-EINVAL);
315 static struct devlink_sb *devlink_sb_get_from_info(struct devlink *devlink,
316 struct genl_info *info)
318 return devlink_sb_get_from_attrs(devlink, info->attrs);
321 static int devlink_sb_pool_index_get_from_attrs(struct devlink_sb *devlink_sb,
322 struct nlattr **attrs,
327 if (!attrs[DEVLINK_ATTR_SB_POOL_INDEX])
330 val = nla_get_u16(attrs[DEVLINK_ATTR_SB_POOL_INDEX]);
331 if (val >= devlink_sb_pool_count(devlink_sb))
337 static int devlink_sb_pool_index_get_from_info(struct devlink_sb *devlink_sb,
338 struct genl_info *info,
341 return devlink_sb_pool_index_get_from_attrs(devlink_sb, info->attrs,
346 devlink_sb_pool_type_get_from_attrs(struct nlattr **attrs,
347 enum devlink_sb_pool_type *p_pool_type)
351 if (!attrs[DEVLINK_ATTR_SB_POOL_TYPE])
354 val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_TYPE]);
355 if (val != DEVLINK_SB_POOL_TYPE_INGRESS &&
356 val != DEVLINK_SB_POOL_TYPE_EGRESS)
363 devlink_sb_pool_type_get_from_info(struct genl_info *info,
364 enum devlink_sb_pool_type *p_pool_type)
366 return devlink_sb_pool_type_get_from_attrs(info->attrs, p_pool_type);
370 devlink_sb_th_type_get_from_attrs(struct nlattr **attrs,
371 enum devlink_sb_threshold_type *p_th_type)
375 if (!attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])
378 val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE]);
379 if (val != DEVLINK_SB_THRESHOLD_TYPE_STATIC &&
380 val != DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC)
387 devlink_sb_th_type_get_from_info(struct genl_info *info,
388 enum devlink_sb_threshold_type *p_th_type)
390 return devlink_sb_th_type_get_from_attrs(info->attrs, p_th_type);
394 devlink_sb_tc_index_get_from_attrs(struct devlink_sb *devlink_sb,
395 struct nlattr **attrs,
396 enum devlink_sb_pool_type pool_type,
401 if (!attrs[DEVLINK_ATTR_SB_TC_INDEX])
404 val = nla_get_u16(attrs[DEVLINK_ATTR_SB_TC_INDEX]);
405 if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS &&
406 val >= devlink_sb->ingress_tc_count)
408 if (pool_type == DEVLINK_SB_POOL_TYPE_EGRESS &&
409 val >= devlink_sb->egress_tc_count)
416 devlink_sb_tc_index_get_from_info(struct devlink_sb *devlink_sb,
417 struct genl_info *info,
418 enum devlink_sb_pool_type pool_type,
421 return devlink_sb_tc_index_get_from_attrs(devlink_sb, info->attrs,
422 pool_type, p_tc_index);
425 struct devlink_region {
426 struct devlink *devlink;
427 struct devlink_port *port;
428 struct list_head list;
430 const struct devlink_region_ops *ops;
431 const struct devlink_port_region_ops *port_ops;
433 struct list_head snapshot_list;
439 struct devlink_snapshot {
440 struct list_head list;
441 struct devlink_region *region;
446 static struct devlink_region *
447 devlink_region_get_by_name(struct devlink *devlink, const char *region_name)
449 struct devlink_region *region;
451 list_for_each_entry(region, &devlink->region_list, list)
452 if (!strcmp(region->ops->name, region_name))
458 static struct devlink_region *
459 devlink_port_region_get_by_name(struct devlink_port *port,
460 const char *region_name)
462 struct devlink_region *region;
464 list_for_each_entry(region, &port->region_list, list)
465 if (!strcmp(region->ops->name, region_name))
471 static struct devlink_snapshot *
472 devlink_region_snapshot_get_by_id(struct devlink_region *region, u32 id)
474 struct devlink_snapshot *snapshot;
476 list_for_each_entry(snapshot, ®ion->snapshot_list, list)
477 if (snapshot->id == id)
483 #define DEVLINK_NL_FLAG_NEED_PORT BIT(0)
484 #define DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT BIT(1)
485 #define DEVLINK_NL_FLAG_NEED_RATE BIT(2)
486 #define DEVLINK_NL_FLAG_NEED_RATE_NODE BIT(3)
488 /* The per devlink instance lock is taken by default in the pre-doit
489 * operation, yet several commands do not require this. The global
490 * devlink lock is taken and protects from disruption by user-calls.
492 #define DEVLINK_NL_FLAG_NO_LOCK BIT(4)
494 static int devlink_nl_pre_doit(const struct genl_ops *ops,
495 struct sk_buff *skb, struct genl_info *info)
497 struct devlink_port *devlink_port;
498 struct devlink *devlink;
501 mutex_lock(&devlink_mutex);
502 devlink = devlink_get_from_info(info);
503 if (IS_ERR(devlink)) {
504 mutex_unlock(&devlink_mutex);
505 return PTR_ERR(devlink);
507 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
508 mutex_lock(&devlink->lock);
509 info->user_ptr[0] = devlink;
510 if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_PORT) {
511 devlink_port = devlink_port_get_from_info(devlink, info);
512 if (IS_ERR(devlink_port)) {
513 err = PTR_ERR(devlink_port);
516 info->user_ptr[1] = devlink_port;
517 } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT) {
518 devlink_port = devlink_port_get_from_info(devlink, info);
519 if (!IS_ERR(devlink_port))
520 info->user_ptr[1] = devlink_port;
521 } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_RATE) {
522 struct devlink_rate *devlink_rate;
524 devlink_rate = devlink_rate_get_from_info(devlink, info);
525 if (IS_ERR(devlink_rate)) {
526 err = PTR_ERR(devlink_rate);
529 info->user_ptr[1] = devlink_rate;
530 } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_RATE_NODE) {
531 struct devlink_rate *rate_node;
533 rate_node = devlink_rate_node_get_from_info(devlink, info);
534 if (IS_ERR(rate_node)) {
535 err = PTR_ERR(rate_node);
538 info->user_ptr[1] = rate_node;
543 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
544 mutex_unlock(&devlink->lock);
545 mutex_unlock(&devlink_mutex);
549 static void devlink_nl_post_doit(const struct genl_ops *ops,
550 struct sk_buff *skb, struct genl_info *info)
552 struct devlink *devlink;
554 devlink = info->user_ptr[0];
555 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
556 mutex_unlock(&devlink->lock);
557 mutex_unlock(&devlink_mutex);
560 static struct genl_family devlink_nl_family;
562 enum devlink_multicast_groups {
563 DEVLINK_MCGRP_CONFIG,
566 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
567 [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
570 static int devlink_nl_put_handle(struct sk_buff *msg, struct devlink *devlink)
572 if (nla_put_string(msg, DEVLINK_ATTR_BUS_NAME, devlink->dev->bus->name))
574 if (nla_put_string(msg, DEVLINK_ATTR_DEV_NAME, dev_name(devlink->dev)))
579 struct devlink_reload_combination {
580 enum devlink_reload_action action;
581 enum devlink_reload_limit limit;
584 static const struct devlink_reload_combination devlink_reload_invalid_combinations[] = {
586 /* can't reinitialize driver with no down time */
587 .action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
588 .limit = DEVLINK_RELOAD_LIMIT_NO_RESET,
593 devlink_reload_combination_is_invalid(enum devlink_reload_action action,
594 enum devlink_reload_limit limit)
598 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++)
599 if (devlink_reload_invalid_combinations[i].action == action &&
600 devlink_reload_invalid_combinations[i].limit == limit)
606 devlink_reload_action_is_supported(struct devlink *devlink, enum devlink_reload_action action)
608 return test_bit(action, &devlink->ops->reload_actions);
612 devlink_reload_limit_is_supported(struct devlink *devlink, enum devlink_reload_limit limit)
614 return test_bit(limit, &devlink->ops->reload_limits);
617 static int devlink_reload_stat_put(struct sk_buff *msg,
618 enum devlink_reload_limit limit, u32 value)
620 struct nlattr *reload_stats_entry;
622 reload_stats_entry = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_STATS_ENTRY);
623 if (!reload_stats_entry)
626 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_STATS_LIMIT, limit) ||
627 nla_put_u32(msg, DEVLINK_ATTR_RELOAD_STATS_VALUE, value))
628 goto nla_put_failure;
629 nla_nest_end(msg, reload_stats_entry);
633 nla_nest_cancel(msg, reload_stats_entry);
637 static int devlink_reload_stats_put(struct sk_buff *msg, struct devlink *devlink, bool is_remote)
639 struct nlattr *reload_stats_attr, *act_info, *act_stats;
644 reload_stats_attr = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_STATS);
646 reload_stats_attr = nla_nest_start(msg, DEVLINK_ATTR_REMOTE_RELOAD_STATS);
648 if (!reload_stats_attr)
651 for (i = 0; i <= DEVLINK_RELOAD_ACTION_MAX; i++) {
653 !devlink_reload_action_is_supported(devlink, i)) ||
654 i == DEVLINK_RELOAD_ACTION_UNSPEC)
656 act_info = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_ACTION_INFO);
658 goto nla_put_failure;
660 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_ACTION, i))
661 goto action_info_nest_cancel;
662 act_stats = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_ACTION_STATS);
664 goto action_info_nest_cancel;
666 for (j = 0; j <= DEVLINK_RELOAD_LIMIT_MAX; j++) {
667 /* Remote stats are shown even if not locally supported.
668 * Stats of actions with unspecified limit are shown
669 * though drivers don't need to register unspecified
672 if ((!is_remote && j != DEVLINK_RELOAD_LIMIT_UNSPEC &&
673 !devlink_reload_limit_is_supported(devlink, j)) ||
674 devlink_reload_combination_is_invalid(i, j))
677 stat_idx = j * __DEVLINK_RELOAD_ACTION_MAX + i;
679 value = devlink->stats.reload_stats[stat_idx];
681 value = devlink->stats.remote_reload_stats[stat_idx];
682 if (devlink_reload_stat_put(msg, j, value))
683 goto action_stats_nest_cancel;
685 nla_nest_end(msg, act_stats);
686 nla_nest_end(msg, act_info);
688 nla_nest_end(msg, reload_stats_attr);
691 action_stats_nest_cancel:
692 nla_nest_cancel(msg, act_stats);
693 action_info_nest_cancel:
694 nla_nest_cancel(msg, act_info);
696 nla_nest_cancel(msg, reload_stats_attr);
700 static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
701 enum devlink_command cmd, u32 portid,
704 struct nlattr *dev_stats;
707 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
711 if (devlink_nl_put_handle(msg, devlink))
712 goto nla_put_failure;
713 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_FAILED, devlink->reload_failed))
714 goto nla_put_failure;
716 dev_stats = nla_nest_start(msg, DEVLINK_ATTR_DEV_STATS);
718 goto nla_put_failure;
720 if (devlink_reload_stats_put(msg, devlink, false))
721 goto dev_stats_nest_cancel;
722 if (devlink_reload_stats_put(msg, devlink, true))
723 goto dev_stats_nest_cancel;
725 nla_nest_end(msg, dev_stats);
726 genlmsg_end(msg, hdr);
729 dev_stats_nest_cancel:
730 nla_nest_cancel(msg, dev_stats);
732 genlmsg_cancel(msg, hdr);
736 static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
741 WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
743 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
747 err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
753 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
754 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
757 static int devlink_nl_port_attrs_put(struct sk_buff *msg,
758 struct devlink_port *devlink_port)
760 struct devlink_port_attrs *attrs = &devlink_port->attrs;
762 if (!devlink_port->attrs_set)
765 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_LANES, attrs->lanes))
768 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_SPLITTABLE, attrs->splittable))
770 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_FLAVOUR, attrs->flavour))
772 switch (devlink_port->attrs.flavour) {
773 case DEVLINK_PORT_FLAVOUR_PCI_PF:
774 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
775 attrs->pci_pf.controller) ||
776 nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_pf.pf))
778 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_pf.external))
781 case DEVLINK_PORT_FLAVOUR_PCI_VF:
782 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
783 attrs->pci_vf.controller) ||
784 nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_vf.pf) ||
785 nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_VF_NUMBER, attrs->pci_vf.vf))
787 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_vf.external))
790 case DEVLINK_PORT_FLAVOUR_PCI_SF:
791 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
792 attrs->pci_sf.controller) ||
793 nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER,
795 nla_put_u32(msg, DEVLINK_ATTR_PORT_PCI_SF_NUMBER,
799 case DEVLINK_PORT_FLAVOUR_PHYSICAL:
800 case DEVLINK_PORT_FLAVOUR_CPU:
801 case DEVLINK_PORT_FLAVOUR_DSA:
802 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER,
803 attrs->phys.port_number))
807 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP,
808 attrs->phys.port_number))
810 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER,
811 attrs->phys.split_subport_number))
821 devlink_port_fn_hw_addr_fill(struct devlink *devlink, const struct devlink_ops *ops,
822 struct devlink_port *port, struct sk_buff *msg,
823 struct netlink_ext_ack *extack, bool *msg_updated)
825 u8 hw_addr[MAX_ADDR_LEN];
829 if (!ops->port_function_hw_addr_get)
832 err = ops->port_function_hw_addr_get(devlink, port, hw_addr, &hw_addr_len, extack);
834 if (err == -EOPNOTSUPP)
838 err = nla_put(msg, DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR, hw_addr_len, hw_addr);
845 static int devlink_nl_rate_fill(struct sk_buff *msg,
846 struct devlink *devlink,
847 struct devlink_rate *devlink_rate,
848 enum devlink_command cmd, u32 portid,
850 struct netlink_ext_ack *extack)
854 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
858 if (devlink_nl_put_handle(msg, devlink))
859 goto nla_put_failure;
861 if (nla_put_u16(msg, DEVLINK_ATTR_RATE_TYPE, devlink_rate->type))
862 goto nla_put_failure;
864 if (devlink_rate_is_leaf(devlink_rate)) {
865 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
866 devlink_rate->devlink_port->index))
867 goto nla_put_failure;
868 } else if (devlink_rate_is_node(devlink_rate)) {
869 if (nla_put_string(msg, DEVLINK_ATTR_RATE_NODE_NAME,
871 goto nla_put_failure;
874 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_RATE_TX_SHARE,
875 devlink_rate->tx_share, DEVLINK_ATTR_PAD))
876 goto nla_put_failure;
878 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_RATE_TX_MAX,
879 devlink_rate->tx_max, DEVLINK_ATTR_PAD))
880 goto nla_put_failure;
882 if (devlink_rate->parent)
883 if (nla_put_string(msg, DEVLINK_ATTR_RATE_PARENT_NODE_NAME,
884 devlink_rate->parent->name))
885 goto nla_put_failure;
887 genlmsg_end(msg, hdr);
891 genlmsg_cancel(msg, hdr);
896 devlink_port_fn_state_valid(enum devlink_port_fn_state state)
898 return state == DEVLINK_PORT_FN_STATE_INACTIVE ||
899 state == DEVLINK_PORT_FN_STATE_ACTIVE;
903 devlink_port_fn_opstate_valid(enum devlink_port_fn_opstate opstate)
905 return opstate == DEVLINK_PORT_FN_OPSTATE_DETACHED ||
906 opstate == DEVLINK_PORT_FN_OPSTATE_ATTACHED;
910 devlink_port_fn_state_fill(struct devlink *devlink,
911 const struct devlink_ops *ops,
912 struct devlink_port *port, struct sk_buff *msg,
913 struct netlink_ext_ack *extack,
916 enum devlink_port_fn_opstate opstate;
917 enum devlink_port_fn_state state;
920 if (!ops->port_fn_state_get)
923 err = ops->port_fn_state_get(devlink, port, &state, &opstate, extack);
925 if (err == -EOPNOTSUPP)
929 if (!devlink_port_fn_state_valid(state)) {
931 NL_SET_ERR_MSG_MOD(extack, "Invalid state read from driver");
934 if (!devlink_port_fn_opstate_valid(opstate)) {
936 NL_SET_ERR_MSG_MOD(extack,
937 "Invalid operational state read from driver");
940 if (nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_STATE, state) ||
941 nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_OPSTATE, opstate))
948 devlink_nl_port_function_attrs_put(struct sk_buff *msg, struct devlink_port *port,
949 struct netlink_ext_ack *extack)
951 struct devlink *devlink = port->devlink;
952 const struct devlink_ops *ops;
953 struct nlattr *function_attr;
954 bool msg_updated = false;
957 function_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PORT_FUNCTION);
962 err = devlink_port_fn_hw_addr_fill(devlink, ops, port, msg,
963 extack, &msg_updated);
966 err = devlink_port_fn_state_fill(devlink, ops, port, msg, extack,
969 if (err || !msg_updated)
970 nla_nest_cancel(msg, function_attr);
972 nla_nest_end(msg, function_attr);
976 static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
977 struct devlink_port *devlink_port,
978 enum devlink_command cmd, u32 portid,
980 struct netlink_ext_ack *extack)
984 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
988 if (devlink_nl_put_handle(msg, devlink))
989 goto nla_put_failure;
990 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
991 goto nla_put_failure;
993 /* Hold rtnl lock while accessing port's netdev attributes. */
995 spin_lock_bh(&devlink_port->type_lock);
996 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
997 goto nla_put_failure_type_locked;
998 if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
999 nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
1000 devlink_port->desired_type))
1001 goto nla_put_failure_type_locked;
1002 if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
1003 struct net *net = devlink_net(devlink_port->devlink);
1004 struct net_device *netdev = devlink_port->type_dev;
1006 if (netdev && net_eq(net, dev_net(netdev)) &&
1007 (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
1009 nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
1011 goto nla_put_failure_type_locked;
1013 if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
1014 struct ib_device *ibdev = devlink_port->type_dev;
1017 nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
1019 goto nla_put_failure_type_locked;
1021 spin_unlock_bh(&devlink_port->type_lock);
1023 if (devlink_nl_port_attrs_put(msg, devlink_port))
1024 goto nla_put_failure;
1025 if (devlink_nl_port_function_attrs_put(msg, devlink_port, extack))
1026 goto nla_put_failure;
1028 genlmsg_end(msg, hdr);
1031 nla_put_failure_type_locked:
1032 spin_unlock_bh(&devlink_port->type_lock);
1035 genlmsg_cancel(msg, hdr);
1039 static void devlink_port_notify(struct devlink_port *devlink_port,
1040 enum devlink_command cmd)
1042 struct devlink *devlink = devlink_port->devlink;
1043 struct sk_buff *msg;
1046 if (!devlink_port->registered)
1049 WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
1051 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1055 err = devlink_nl_port_fill(msg, devlink, devlink_port, cmd, 0, 0, 0,
1062 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
1063 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
1066 static void devlink_rate_notify(struct devlink_rate *devlink_rate,
1067 enum devlink_command cmd)
1069 struct devlink *devlink = devlink_rate->devlink;
1070 struct sk_buff *msg;
1073 WARN_ON(cmd != DEVLINK_CMD_RATE_NEW &&
1074 cmd != DEVLINK_CMD_RATE_DEL);
1076 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1080 err = devlink_nl_rate_fill(msg, devlink, devlink_rate,
1081 cmd, 0, 0, 0, NULL);
1087 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
1088 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
1091 static int devlink_nl_cmd_rate_get_dumpit(struct sk_buff *msg,
1092 struct netlink_callback *cb)
1094 struct devlink_rate *devlink_rate;
1095 struct devlink *devlink;
1096 int start = cb->args[0];
1100 mutex_lock(&devlink_mutex);
1101 list_for_each_entry(devlink, &devlink_list, list) {
1102 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
1104 mutex_lock(&devlink->lock);
1105 list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
1106 enum devlink_command cmd = DEVLINK_CMD_RATE_NEW;
1107 u32 id = NETLINK_CB(cb->skb).portid;
1113 err = devlink_nl_rate_fill(msg, devlink,
1119 mutex_unlock(&devlink->lock);
1124 mutex_unlock(&devlink->lock);
1127 mutex_unlock(&devlink_mutex);
1128 if (err != -EMSGSIZE)
1135 static int devlink_nl_cmd_rate_get_doit(struct sk_buff *skb,
1136 struct genl_info *info)
1138 struct devlink_rate *devlink_rate = info->user_ptr[1];
1139 struct devlink *devlink = devlink_rate->devlink;
1140 struct sk_buff *msg;
1143 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1147 err = devlink_nl_rate_fill(msg, devlink, devlink_rate,
1148 DEVLINK_CMD_RATE_NEW,
1149 info->snd_portid, info->snd_seq, 0,
1156 return genlmsg_reply(msg, info);
1160 devlink_rate_is_parent_node(struct devlink_rate *devlink_rate,
1161 struct devlink_rate *parent)
1164 if (parent == devlink_rate)
1166 parent = parent->parent;
1171 static int devlink_nl_cmd_get_doit(struct sk_buff *skb, struct genl_info *info)
1173 struct devlink *devlink = info->user_ptr[0];
1174 struct sk_buff *msg;
1177 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1181 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
1182 info->snd_portid, info->snd_seq, 0);
1188 return genlmsg_reply(msg, info);
1191 static int devlink_nl_cmd_get_dumpit(struct sk_buff *msg,
1192 struct netlink_callback *cb)
1194 struct devlink *devlink;
1195 int start = cb->args[0];
1199 mutex_lock(&devlink_mutex);
1200 list_for_each_entry(devlink, &devlink_list, list) {
1201 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
1207 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
1208 NETLINK_CB(cb->skb).portid,
1209 cb->nlh->nlmsg_seq, NLM_F_MULTI);
1215 mutex_unlock(&devlink_mutex);
1221 static int devlink_nl_cmd_port_get_doit(struct sk_buff *skb,
1222 struct genl_info *info)
1224 struct devlink_port *devlink_port = info->user_ptr[1];
1225 struct devlink *devlink = devlink_port->devlink;
1226 struct sk_buff *msg;
1229 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1233 err = devlink_nl_port_fill(msg, devlink, devlink_port,
1234 DEVLINK_CMD_PORT_NEW,
1235 info->snd_portid, info->snd_seq, 0,
1242 return genlmsg_reply(msg, info);
1245 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff *msg,
1246 struct netlink_callback *cb)
1248 struct devlink *devlink;
1249 struct devlink_port *devlink_port;
1250 int start = cb->args[0];
1254 mutex_lock(&devlink_mutex);
1255 list_for_each_entry(devlink, &devlink_list, list) {
1256 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
1258 mutex_lock(&devlink->lock);
1259 list_for_each_entry(devlink_port, &devlink->port_list, list) {
1264 err = devlink_nl_port_fill(msg, devlink, devlink_port,
1266 NETLINK_CB(cb->skb).portid,
1271 mutex_unlock(&devlink->lock);
1276 mutex_unlock(&devlink->lock);
1279 mutex_unlock(&devlink_mutex);
1285 static int devlink_port_type_set(struct devlink *devlink,
1286 struct devlink_port *devlink_port,
1287 enum devlink_port_type port_type)
1292 if (devlink->ops->port_type_set) {
1293 if (port_type == devlink_port->type)
1295 err = devlink->ops->port_type_set(devlink_port, port_type);
1298 devlink_port->desired_type = port_type;
1299 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
1306 devlink_port_function_hw_addr_set(struct devlink *devlink, struct devlink_port *port,
1307 const struct nlattr *attr, struct netlink_ext_ack *extack)
1309 const struct devlink_ops *ops;
1313 hw_addr = nla_data(attr);
1314 hw_addr_len = nla_len(attr);
1315 if (hw_addr_len > MAX_ADDR_LEN) {
1316 NL_SET_ERR_MSG_MOD(extack, "Port function hardware address too long");
1319 if (port->type == DEVLINK_PORT_TYPE_ETH) {
1320 if (hw_addr_len != ETH_ALEN) {
1321 NL_SET_ERR_MSG_MOD(extack, "Address must be 6 bytes for Ethernet device");
1324 if (!is_unicast_ether_addr(hw_addr)) {
1325 NL_SET_ERR_MSG_MOD(extack, "Non-unicast hardware address unsupported");
1331 if (!ops->port_function_hw_addr_set) {
1332 NL_SET_ERR_MSG_MOD(extack, "Port doesn't support function attributes");
1336 return ops->port_function_hw_addr_set(devlink, port, hw_addr, hw_addr_len, extack);
1339 static int devlink_port_fn_state_set(struct devlink *devlink,
1340 struct devlink_port *port,
1341 const struct nlattr *attr,
1342 struct netlink_ext_ack *extack)
1344 enum devlink_port_fn_state state;
1345 const struct devlink_ops *ops;
1347 state = nla_get_u8(attr);
1349 if (!ops->port_fn_state_set) {
1350 NL_SET_ERR_MSG_MOD(extack,
1351 "Function does not support state setting");
1354 return ops->port_fn_state_set(devlink, port, state, extack);
1358 devlink_port_function_set(struct devlink *devlink, struct devlink_port *port,
1359 const struct nlattr *attr, struct netlink_ext_ack *extack)
1361 struct nlattr *tb[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1];
1364 err = nla_parse_nested(tb, DEVLINK_PORT_FUNCTION_ATTR_MAX, attr,
1365 devlink_function_nl_policy, extack);
1367 NL_SET_ERR_MSG_MOD(extack, "Fail to parse port function attributes");
1371 attr = tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR];
1373 err = devlink_port_function_hw_addr_set(devlink, port, attr, extack);
1377 /* Keep this as the last function attribute set, so that when
1378 * multiple port function attributes are set along with state,
1379 * Those can be applied first before activating the state.
1381 attr = tb[DEVLINK_PORT_FN_ATTR_STATE];
1383 err = devlink_port_fn_state_set(devlink, port, attr, extack);
1386 devlink_port_notify(port, DEVLINK_CMD_PORT_NEW);
1390 static int devlink_nl_cmd_port_set_doit(struct sk_buff *skb,
1391 struct genl_info *info)
1393 struct devlink_port *devlink_port = info->user_ptr[1];
1394 struct devlink *devlink = devlink_port->devlink;
1397 if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
1398 enum devlink_port_type port_type;
1400 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
1401 err = devlink_port_type_set(devlink, devlink_port, port_type);
1406 if (info->attrs[DEVLINK_ATTR_PORT_FUNCTION]) {
1407 struct nlattr *attr = info->attrs[DEVLINK_ATTR_PORT_FUNCTION];
1408 struct netlink_ext_ack *extack = info->extack;
1410 err = devlink_port_function_set(devlink, devlink_port, attr, extack);
1418 static int devlink_port_split(struct devlink *devlink, u32 port_index,
1419 u32 count, struct netlink_ext_ack *extack)
1422 if (devlink->ops->port_split)
1423 return devlink->ops->port_split(devlink, port_index, count,
1428 static int devlink_nl_cmd_port_split_doit(struct sk_buff *skb,
1429 struct genl_info *info)
1431 struct devlink *devlink = info->user_ptr[0];
1432 struct devlink_port *devlink_port;
1436 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX] ||
1437 !info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT])
1440 devlink_port = devlink_port_get_from_info(devlink, info);
1441 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
1442 count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
1444 if (IS_ERR(devlink_port))
1447 if (!devlink_port->attrs.splittable) {
1448 /* Split ports cannot be split. */
1449 if (devlink_port->attrs.split)
1450 NL_SET_ERR_MSG_MOD(info->extack, "Port cannot be split further");
1452 NL_SET_ERR_MSG_MOD(info->extack, "Port cannot be split");
1456 if (count < 2 || !is_power_of_2(count) || count > devlink_port->attrs.lanes) {
1457 NL_SET_ERR_MSG_MOD(info->extack, "Invalid split count");
1461 return devlink_port_split(devlink, port_index, count, info->extack);
1464 static int devlink_port_unsplit(struct devlink *devlink, u32 port_index,
1465 struct netlink_ext_ack *extack)
1468 if (devlink->ops->port_unsplit)
1469 return devlink->ops->port_unsplit(devlink, port_index, extack);
1473 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
1474 struct genl_info *info)
1476 struct devlink *devlink = info->user_ptr[0];
1479 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX])
1482 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
1483 return devlink_port_unsplit(devlink, port_index, info->extack);
1486 static int devlink_port_new_notifiy(struct devlink *devlink,
1487 unsigned int port_index,
1488 struct genl_info *info)
1490 struct devlink_port *devlink_port;
1491 struct sk_buff *msg;
1494 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1498 mutex_lock(&devlink->lock);
1499 devlink_port = devlink_port_get_by_index(devlink, port_index);
1500 if (!devlink_port) {
1505 err = devlink_nl_port_fill(msg, devlink, devlink_port,
1506 DEVLINK_CMD_NEW, info->snd_portid,
1507 info->snd_seq, 0, NULL);
1511 err = genlmsg_reply(msg, info);
1512 mutex_unlock(&devlink->lock);
1516 mutex_unlock(&devlink->lock);
1521 static int devlink_nl_cmd_port_new_doit(struct sk_buff *skb,
1522 struct genl_info *info)
1524 struct netlink_ext_ack *extack = info->extack;
1525 struct devlink_port_new_attrs new_attrs = {};
1526 struct devlink *devlink = info->user_ptr[0];
1527 unsigned int new_port_index;
1530 if (!devlink->ops->port_new || !devlink->ops->port_del)
1533 if (!info->attrs[DEVLINK_ATTR_PORT_FLAVOUR] ||
1534 !info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]) {
1535 NL_SET_ERR_MSG_MOD(extack, "Port flavour or PCI PF are not specified");
1538 new_attrs.flavour = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_FLAVOUR]);
1540 nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]);
1542 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
1543 /* Port index of the new port being created by driver. */
1544 new_attrs.port_index =
1545 nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
1546 new_attrs.port_index_valid = true;
1548 if (info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]) {
1549 new_attrs.controller =
1550 nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]);
1551 new_attrs.controller_valid = true;
1553 if (new_attrs.flavour == DEVLINK_PORT_FLAVOUR_PCI_SF &&
1554 info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]) {
1555 new_attrs.sfnum = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]);
1556 new_attrs.sfnum_valid = true;
1559 err = devlink->ops->port_new(devlink, &new_attrs, extack,
1564 err = devlink_port_new_notifiy(devlink, new_port_index, info);
1565 if (err && err != -ENODEV) {
1566 /* Fail to send the response; destroy newly created port. */
1567 devlink->ops->port_del(devlink, new_port_index, extack);
1572 static int devlink_nl_cmd_port_del_doit(struct sk_buff *skb,
1573 struct genl_info *info)
1575 struct netlink_ext_ack *extack = info->extack;
1576 struct devlink *devlink = info->user_ptr[0];
1577 unsigned int port_index;
1579 if (!devlink->ops->port_del)
1582 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
1583 NL_SET_ERR_MSG_MOD(extack, "Port index is not specified");
1586 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
1588 return devlink->ops->port_del(devlink, port_index, extack);
1592 devlink_nl_rate_parent_node_set(struct devlink_rate *devlink_rate,
1593 struct genl_info *info,
1594 struct nlattr *nla_parent)
1596 struct devlink *devlink = devlink_rate->devlink;
1597 const char *parent_name = nla_data(nla_parent);
1598 const struct devlink_ops *ops = devlink->ops;
1599 size_t len = strlen(parent_name);
1600 struct devlink_rate *parent;
1601 int err = -EOPNOTSUPP;
1603 parent = devlink_rate->parent;
1604 if (parent && len) {
1605 NL_SET_ERR_MSG_MOD(info->extack, "Rate object already has parent.");
1607 } else if (parent && !len) {
1608 if (devlink_rate_is_leaf(devlink_rate))
1609 err = ops->rate_leaf_parent_set(devlink_rate, NULL,
1610 devlink_rate->priv, NULL,
1612 else if (devlink_rate_is_node(devlink_rate))
1613 err = ops->rate_node_parent_set(devlink_rate, NULL,
1614 devlink_rate->priv, NULL,
1619 refcount_dec(&parent->refcnt);
1620 devlink_rate->parent = NULL;
1621 } else if (!parent && len) {
1622 parent = devlink_rate_node_get_by_name(devlink, parent_name);
1626 if (parent == devlink_rate) {
1627 NL_SET_ERR_MSG_MOD(info->extack, "Parent to self is not allowed");
1631 if (devlink_rate_is_node(devlink_rate) &&
1632 devlink_rate_is_parent_node(devlink_rate, parent->parent)) {
1633 NL_SET_ERR_MSG_MOD(info->extack, "Node is already a parent of parent node.");
1637 if (devlink_rate_is_leaf(devlink_rate))
1638 err = ops->rate_leaf_parent_set(devlink_rate, parent,
1639 devlink_rate->priv, parent->priv,
1641 else if (devlink_rate_is_node(devlink_rate))
1642 err = ops->rate_node_parent_set(devlink_rate, parent,
1643 devlink_rate->priv, parent->priv,
1648 refcount_inc(&parent->refcnt);
1649 devlink_rate->parent = parent;
1655 static int devlink_nl_rate_set(struct devlink_rate *devlink_rate,
1656 const struct devlink_ops *ops,
1657 struct genl_info *info)
1659 struct nlattr *nla_parent, **attrs = info->attrs;
1660 int err = -EOPNOTSUPP;
1663 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE]) {
1664 rate = nla_get_u64(attrs[DEVLINK_ATTR_RATE_TX_SHARE]);
1665 if (devlink_rate_is_leaf(devlink_rate))
1666 err = ops->rate_leaf_tx_share_set(devlink_rate, devlink_rate->priv,
1667 rate, info->extack);
1668 else if (devlink_rate_is_node(devlink_rate))
1669 err = ops->rate_node_tx_share_set(devlink_rate, devlink_rate->priv,
1670 rate, info->extack);
1673 devlink_rate->tx_share = rate;
1676 if (attrs[DEVLINK_ATTR_RATE_TX_MAX]) {
1677 rate = nla_get_u64(attrs[DEVLINK_ATTR_RATE_TX_MAX]);
1678 if (devlink_rate_is_leaf(devlink_rate))
1679 err = ops->rate_leaf_tx_max_set(devlink_rate, devlink_rate->priv,
1680 rate, info->extack);
1681 else if (devlink_rate_is_node(devlink_rate))
1682 err = ops->rate_node_tx_max_set(devlink_rate, devlink_rate->priv,
1683 rate, info->extack);
1686 devlink_rate->tx_max = rate;
1689 nla_parent = attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME];
1691 err = devlink_nl_rate_parent_node_set(devlink_rate, info,
1700 static bool devlink_rate_set_ops_supported(const struct devlink_ops *ops,
1701 struct genl_info *info,
1702 enum devlink_rate_type type)
1704 struct nlattr **attrs = info->attrs;
1706 if (type == DEVLINK_RATE_TYPE_LEAF) {
1707 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE] && !ops->rate_leaf_tx_share_set) {
1708 NL_SET_ERR_MSG_MOD(info->extack, "TX share set isn't supported for the leafs");
1711 if (attrs[DEVLINK_ATTR_RATE_TX_MAX] && !ops->rate_leaf_tx_max_set) {
1712 NL_SET_ERR_MSG_MOD(info->extack, "TX max set isn't supported for the leafs");
1715 if (attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] &&
1716 !ops->rate_leaf_parent_set) {
1717 NL_SET_ERR_MSG_MOD(info->extack, "Parent set isn't supported for the leafs");
1720 } else if (type == DEVLINK_RATE_TYPE_NODE) {
1721 if (attrs[DEVLINK_ATTR_RATE_TX_SHARE] && !ops->rate_node_tx_share_set) {
1722 NL_SET_ERR_MSG_MOD(info->extack, "TX share set isn't supported for the nodes");
1725 if (attrs[DEVLINK_ATTR_RATE_TX_MAX] && !ops->rate_node_tx_max_set) {
1726 NL_SET_ERR_MSG_MOD(info->extack, "TX max set isn't supported for the nodes");
1729 if (attrs[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] &&
1730 !ops->rate_node_parent_set) {
1731 NL_SET_ERR_MSG_MOD(info->extack, "Parent set isn't supported for the nodes");
1735 WARN(1, "Unknown type of rate object");
1742 static int devlink_nl_cmd_rate_set_doit(struct sk_buff *skb,
1743 struct genl_info *info)
1745 struct devlink_rate *devlink_rate = info->user_ptr[1];
1746 struct devlink *devlink = devlink_rate->devlink;
1747 const struct devlink_ops *ops = devlink->ops;
1750 if (!ops || !devlink_rate_set_ops_supported(ops, info, devlink_rate->type))
1753 err = devlink_nl_rate_set(devlink_rate, ops, info);
1756 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
1760 static int devlink_nl_cmd_rate_new_doit(struct sk_buff *skb,
1761 struct genl_info *info)
1763 struct devlink *devlink = info->user_ptr[0];
1764 struct devlink_rate *rate_node;
1765 const struct devlink_ops *ops;
1769 if (!ops || !ops->rate_node_new || !ops->rate_node_del) {
1770 NL_SET_ERR_MSG_MOD(info->extack, "Rate nodes aren't supported");
1774 if (!devlink_rate_set_ops_supported(ops, info, DEVLINK_RATE_TYPE_NODE))
1777 rate_node = devlink_rate_node_get_from_attrs(devlink, info->attrs);
1778 if (!IS_ERR(rate_node))
1780 else if (rate_node == ERR_PTR(-EINVAL))
1783 rate_node = kzalloc(sizeof(*rate_node), GFP_KERNEL);
1787 rate_node->devlink = devlink;
1788 rate_node->type = DEVLINK_RATE_TYPE_NODE;
1789 rate_node->name = nla_strdup(info->attrs[DEVLINK_ATTR_RATE_NODE_NAME], GFP_KERNEL);
1790 if (!rate_node->name) {
1795 err = ops->rate_node_new(rate_node, &rate_node->priv, info->extack);
1799 err = devlink_nl_rate_set(rate_node, ops, info);
1803 refcount_set(&rate_node->refcnt, 1);
1804 list_add(&rate_node->list, &devlink->rate_list);
1805 devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_NEW);
1809 ops->rate_node_del(rate_node, rate_node->priv, info->extack);
1811 kfree(rate_node->name);
1817 static int devlink_nl_cmd_rate_del_doit(struct sk_buff *skb,
1818 struct genl_info *info)
1820 struct devlink_rate *rate_node = info->user_ptr[1];
1821 struct devlink *devlink = rate_node->devlink;
1822 const struct devlink_ops *ops = devlink->ops;
1825 if (refcount_read(&rate_node->refcnt) > 1) {
1826 NL_SET_ERR_MSG_MOD(info->extack, "Node has children. Cannot delete node.");
1830 devlink_rate_notify(rate_node, DEVLINK_CMD_RATE_DEL);
1831 err = ops->rate_node_del(rate_node, rate_node->priv, info->extack);
1832 if (rate_node->parent)
1833 refcount_dec(&rate_node->parent->refcnt);
1834 list_del(&rate_node->list);
1835 kfree(rate_node->name);
1840 static int devlink_nl_sb_fill(struct sk_buff *msg, struct devlink *devlink,
1841 struct devlink_sb *devlink_sb,
1842 enum devlink_command cmd, u32 portid,
1847 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1851 if (devlink_nl_put_handle(msg, devlink))
1852 goto nla_put_failure;
1853 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1854 goto nla_put_failure;
1855 if (nla_put_u32(msg, DEVLINK_ATTR_SB_SIZE, devlink_sb->size))
1856 goto nla_put_failure;
1857 if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT,
1858 devlink_sb->ingress_pools_count))
1859 goto nla_put_failure;
1860 if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT,
1861 devlink_sb->egress_pools_count))
1862 goto nla_put_failure;
1863 if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_TC_COUNT,
1864 devlink_sb->ingress_tc_count))
1865 goto nla_put_failure;
1866 if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_TC_COUNT,
1867 devlink_sb->egress_tc_count))
1868 goto nla_put_failure;
1870 genlmsg_end(msg, hdr);
1874 genlmsg_cancel(msg, hdr);
1878 static int devlink_nl_cmd_sb_get_doit(struct sk_buff *skb,
1879 struct genl_info *info)
1881 struct devlink *devlink = info->user_ptr[0];
1882 struct devlink_sb *devlink_sb;
1883 struct sk_buff *msg;
1886 devlink_sb = devlink_sb_get_from_info(devlink, info);
1887 if (IS_ERR(devlink_sb))
1888 return PTR_ERR(devlink_sb);
1890 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1894 err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
1896 info->snd_portid, info->snd_seq, 0);
1902 return genlmsg_reply(msg, info);
1905 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff *msg,
1906 struct netlink_callback *cb)
1908 struct devlink *devlink;
1909 struct devlink_sb *devlink_sb;
1910 int start = cb->args[0];
1914 mutex_lock(&devlink_mutex);
1915 list_for_each_entry(devlink, &devlink_list, list) {
1916 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
1918 mutex_lock(&devlink->lock);
1919 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1924 err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
1926 NETLINK_CB(cb->skb).portid,
1930 mutex_unlock(&devlink->lock);
1935 mutex_unlock(&devlink->lock);
1938 mutex_unlock(&devlink_mutex);
1944 static int devlink_nl_sb_pool_fill(struct sk_buff *msg, struct devlink *devlink,
1945 struct devlink_sb *devlink_sb,
1946 u16 pool_index, enum devlink_command cmd,
1947 u32 portid, u32 seq, int flags)
1949 struct devlink_sb_pool_info pool_info;
1953 err = devlink->ops->sb_pool_get(devlink, devlink_sb->index,
1954 pool_index, &pool_info);
1958 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1962 if (devlink_nl_put_handle(msg, devlink))
1963 goto nla_put_failure;
1964 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1965 goto nla_put_failure;
1966 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1967 goto nla_put_failure;
1968 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_info.pool_type))
1969 goto nla_put_failure;
1970 if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_SIZE, pool_info.size))
1971 goto nla_put_failure;
1972 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
1973 pool_info.threshold_type))
1974 goto nla_put_failure;
1975 if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_CELL_SIZE,
1976 pool_info.cell_size))
1977 goto nla_put_failure;
1979 genlmsg_end(msg, hdr);
1983 genlmsg_cancel(msg, hdr);
1987 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff *skb,
1988 struct genl_info *info)
1990 struct devlink *devlink = info->user_ptr[0];
1991 struct devlink_sb *devlink_sb;
1992 struct sk_buff *msg;
1996 devlink_sb = devlink_sb_get_from_info(devlink, info);
1997 if (IS_ERR(devlink_sb))
1998 return PTR_ERR(devlink_sb);
2000 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2005 if (!devlink->ops->sb_pool_get)
2008 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2012 err = devlink_nl_sb_pool_fill(msg, devlink, devlink_sb, pool_index,
2013 DEVLINK_CMD_SB_POOL_NEW,
2014 info->snd_portid, info->snd_seq, 0);
2020 return genlmsg_reply(msg, info);
2023 static int __sb_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
2024 struct devlink *devlink,
2025 struct devlink_sb *devlink_sb,
2026 u32 portid, u32 seq)
2028 u16 pool_count = devlink_sb_pool_count(devlink_sb);
2032 for (pool_index = 0; pool_index < pool_count; pool_index++) {
2033 if (*p_idx < start) {
2037 err = devlink_nl_sb_pool_fill(msg, devlink,
2040 DEVLINK_CMD_SB_POOL_NEW,
2041 portid, seq, NLM_F_MULTI);
2049 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff *msg,
2050 struct netlink_callback *cb)
2052 struct devlink *devlink;
2053 struct devlink_sb *devlink_sb;
2054 int start = cb->args[0];
2058 mutex_lock(&devlink_mutex);
2059 list_for_each_entry(devlink, &devlink_list, list) {
2060 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
2061 !devlink->ops->sb_pool_get)
2063 mutex_lock(&devlink->lock);
2064 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2065 err = __sb_pool_get_dumpit(msg, start, &idx, devlink,
2067 NETLINK_CB(cb->skb).portid,
2068 cb->nlh->nlmsg_seq);
2069 if (err == -EOPNOTSUPP) {
2072 mutex_unlock(&devlink->lock);
2076 mutex_unlock(&devlink->lock);
2079 mutex_unlock(&devlink_mutex);
2081 if (err != -EMSGSIZE)
2088 static int devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
2089 u16 pool_index, u32 size,
2090 enum devlink_sb_threshold_type threshold_type,
2091 struct netlink_ext_ack *extack)
2094 const struct devlink_ops *ops = devlink->ops;
2096 if (ops->sb_pool_set)
2097 return ops->sb_pool_set(devlink, sb_index, pool_index,
2098 size, threshold_type, extack);
2102 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb,
2103 struct genl_info *info)
2105 struct devlink *devlink = info->user_ptr[0];
2106 enum devlink_sb_threshold_type threshold_type;
2107 struct devlink_sb *devlink_sb;
2112 devlink_sb = devlink_sb_get_from_info(devlink, info);
2113 if (IS_ERR(devlink_sb))
2114 return PTR_ERR(devlink_sb);
2116 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2121 err = devlink_sb_th_type_get_from_info(info, &threshold_type);
2125 if (!info->attrs[DEVLINK_ATTR_SB_POOL_SIZE])
2128 size = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_POOL_SIZE]);
2129 return devlink_sb_pool_set(devlink, devlink_sb->index,
2130 pool_index, size, threshold_type,
2134 static int devlink_nl_sb_port_pool_fill(struct sk_buff *msg,
2135 struct devlink *devlink,
2136 struct devlink_port *devlink_port,
2137 struct devlink_sb *devlink_sb,
2139 enum devlink_command cmd,
2140 u32 portid, u32 seq, int flags)
2142 const struct devlink_ops *ops = devlink->ops;
2147 err = ops->sb_port_pool_get(devlink_port, devlink_sb->index,
2148 pool_index, &threshold);
2152 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2156 if (devlink_nl_put_handle(msg, devlink))
2157 goto nla_put_failure;
2158 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
2159 goto nla_put_failure;
2160 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
2161 goto nla_put_failure;
2162 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
2163 goto nla_put_failure;
2164 if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
2165 goto nla_put_failure;
2167 if (ops->sb_occ_port_pool_get) {
2171 err = ops->sb_occ_port_pool_get(devlink_port, devlink_sb->index,
2172 pool_index, &cur, &max);
2173 if (err && err != -EOPNOTSUPP)
2174 goto sb_occ_get_failure;
2176 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
2177 goto nla_put_failure;
2178 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
2179 goto nla_put_failure;
2183 genlmsg_end(msg, hdr);
2189 genlmsg_cancel(msg, hdr);
2193 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff *skb,
2194 struct genl_info *info)
2196 struct devlink_port *devlink_port = info->user_ptr[1];
2197 struct devlink *devlink = devlink_port->devlink;
2198 struct devlink_sb *devlink_sb;
2199 struct sk_buff *msg;
2203 devlink_sb = devlink_sb_get_from_info(devlink, info);
2204 if (IS_ERR(devlink_sb))
2205 return PTR_ERR(devlink_sb);
2207 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2212 if (!devlink->ops->sb_port_pool_get)
2215 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2219 err = devlink_nl_sb_port_pool_fill(msg, devlink, devlink_port,
2220 devlink_sb, pool_index,
2221 DEVLINK_CMD_SB_PORT_POOL_NEW,
2222 info->snd_portid, info->snd_seq, 0);
2228 return genlmsg_reply(msg, info);
2231 static int __sb_port_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
2232 struct devlink *devlink,
2233 struct devlink_sb *devlink_sb,
2234 u32 portid, u32 seq)
2236 struct devlink_port *devlink_port;
2237 u16 pool_count = devlink_sb_pool_count(devlink_sb);
2241 list_for_each_entry(devlink_port, &devlink->port_list, list) {
2242 for (pool_index = 0; pool_index < pool_count; pool_index++) {
2243 if (*p_idx < start) {
2247 err = devlink_nl_sb_port_pool_fill(msg, devlink,
2251 DEVLINK_CMD_SB_PORT_POOL_NEW,
2262 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff *msg,
2263 struct netlink_callback *cb)
2265 struct devlink *devlink;
2266 struct devlink_sb *devlink_sb;
2267 int start = cb->args[0];
2271 mutex_lock(&devlink_mutex);
2272 list_for_each_entry(devlink, &devlink_list, list) {
2273 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
2274 !devlink->ops->sb_port_pool_get)
2276 mutex_lock(&devlink->lock);
2277 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2278 err = __sb_port_pool_get_dumpit(msg, start, &idx,
2279 devlink, devlink_sb,
2280 NETLINK_CB(cb->skb).portid,
2281 cb->nlh->nlmsg_seq);
2282 if (err == -EOPNOTSUPP) {
2285 mutex_unlock(&devlink->lock);
2289 mutex_unlock(&devlink->lock);
2292 mutex_unlock(&devlink_mutex);
2294 if (err != -EMSGSIZE)
2301 static int devlink_sb_port_pool_set(struct devlink_port *devlink_port,
2302 unsigned int sb_index, u16 pool_index,
2304 struct netlink_ext_ack *extack)
2307 const struct devlink_ops *ops = devlink_port->devlink->ops;
2309 if (ops->sb_port_pool_set)
2310 return ops->sb_port_pool_set(devlink_port, sb_index,
2311 pool_index, threshold, extack);
2315 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
2316 struct genl_info *info)
2318 struct devlink_port *devlink_port = info->user_ptr[1];
2319 struct devlink *devlink = info->user_ptr[0];
2320 struct devlink_sb *devlink_sb;
2325 devlink_sb = devlink_sb_get_from_info(devlink, info);
2326 if (IS_ERR(devlink_sb))
2327 return PTR_ERR(devlink_sb);
2329 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2334 if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
2337 threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
2338 return devlink_sb_port_pool_set(devlink_port, devlink_sb->index,
2339 pool_index, threshold, info->extack);
2343 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff *msg, struct devlink *devlink,
2344 struct devlink_port *devlink_port,
2345 struct devlink_sb *devlink_sb, u16 tc_index,
2346 enum devlink_sb_pool_type pool_type,
2347 enum devlink_command cmd,
2348 u32 portid, u32 seq, int flags)
2350 const struct devlink_ops *ops = devlink->ops;
2356 err = ops->sb_tc_pool_bind_get(devlink_port, devlink_sb->index,
2357 tc_index, pool_type,
2358 &pool_index, &threshold);
2362 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2366 if (devlink_nl_put_handle(msg, devlink))
2367 goto nla_put_failure;
2368 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
2369 goto nla_put_failure;
2370 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
2371 goto nla_put_failure;
2372 if (nla_put_u16(msg, DEVLINK_ATTR_SB_TC_INDEX, tc_index))
2373 goto nla_put_failure;
2374 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_type))
2375 goto nla_put_failure;
2376 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
2377 goto nla_put_failure;
2378 if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
2379 goto nla_put_failure;
2381 if (ops->sb_occ_tc_port_bind_get) {
2385 err = ops->sb_occ_tc_port_bind_get(devlink_port,
2387 tc_index, pool_type,
2389 if (err && err != -EOPNOTSUPP)
2392 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
2393 goto nla_put_failure;
2394 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
2395 goto nla_put_failure;
2399 genlmsg_end(msg, hdr);
2403 genlmsg_cancel(msg, hdr);
2407 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
2408 struct genl_info *info)
2410 struct devlink_port *devlink_port = info->user_ptr[1];
2411 struct devlink *devlink = devlink_port->devlink;
2412 struct devlink_sb *devlink_sb;
2413 struct sk_buff *msg;
2414 enum devlink_sb_pool_type pool_type;
2418 devlink_sb = devlink_sb_get_from_info(devlink, info);
2419 if (IS_ERR(devlink_sb))
2420 return PTR_ERR(devlink_sb);
2422 err = devlink_sb_pool_type_get_from_info(info, &pool_type);
2426 err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
2427 pool_type, &tc_index);
2431 if (!devlink->ops->sb_tc_pool_bind_get)
2434 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2438 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink, devlink_port,
2439 devlink_sb, tc_index, pool_type,
2440 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
2448 return genlmsg_reply(msg, info);
2451 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
2452 int start, int *p_idx,
2453 struct devlink *devlink,
2454 struct devlink_sb *devlink_sb,
2455 u32 portid, u32 seq)
2457 struct devlink_port *devlink_port;
2461 list_for_each_entry(devlink_port, &devlink->port_list, list) {
2463 tc_index < devlink_sb->ingress_tc_count; tc_index++) {
2464 if (*p_idx < start) {
2468 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
2472 DEVLINK_SB_POOL_TYPE_INGRESS,
2473 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
2481 tc_index < devlink_sb->egress_tc_count; tc_index++) {
2482 if (*p_idx < start) {
2486 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
2490 DEVLINK_SB_POOL_TYPE_EGRESS,
2491 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
2503 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
2504 struct netlink_callback *cb)
2506 struct devlink *devlink;
2507 struct devlink_sb *devlink_sb;
2508 int start = cb->args[0];
2512 mutex_lock(&devlink_mutex);
2513 list_for_each_entry(devlink, &devlink_list, list) {
2514 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
2515 !devlink->ops->sb_tc_pool_bind_get)
2518 mutex_lock(&devlink->lock);
2519 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
2520 err = __sb_tc_pool_bind_get_dumpit(msg, start, &idx,
2523 NETLINK_CB(cb->skb).portid,
2524 cb->nlh->nlmsg_seq);
2525 if (err == -EOPNOTSUPP) {
2528 mutex_unlock(&devlink->lock);
2532 mutex_unlock(&devlink->lock);
2535 mutex_unlock(&devlink_mutex);
2537 if (err != -EMSGSIZE)
2544 static int devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
2545 unsigned int sb_index, u16 tc_index,
2546 enum devlink_sb_pool_type pool_type,
2547 u16 pool_index, u32 threshold,
2548 struct netlink_ext_ack *extack)
2551 const struct devlink_ops *ops = devlink_port->devlink->ops;
2553 if (ops->sb_tc_pool_bind_set)
2554 return ops->sb_tc_pool_bind_set(devlink_port, sb_index,
2555 tc_index, pool_type,
2556 pool_index, threshold, extack);
2560 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
2561 struct genl_info *info)
2563 struct devlink_port *devlink_port = info->user_ptr[1];
2564 struct devlink *devlink = info->user_ptr[0];
2565 enum devlink_sb_pool_type pool_type;
2566 struct devlink_sb *devlink_sb;
2572 devlink_sb = devlink_sb_get_from_info(devlink, info);
2573 if (IS_ERR(devlink_sb))
2574 return PTR_ERR(devlink_sb);
2576 err = devlink_sb_pool_type_get_from_info(info, &pool_type);
2580 err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
2581 pool_type, &tc_index);
2585 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
2590 if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
2593 threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
2594 return devlink_sb_tc_pool_bind_set(devlink_port, devlink_sb->index,
2595 tc_index, pool_type,
2596 pool_index, threshold, info->extack);
2599 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
2600 struct genl_info *info)
2602 struct devlink *devlink = info->user_ptr[0];
2603 const struct devlink_ops *ops = devlink->ops;
2604 struct devlink_sb *devlink_sb;
2606 devlink_sb = devlink_sb_get_from_info(devlink, info);
2607 if (IS_ERR(devlink_sb))
2608 return PTR_ERR(devlink_sb);
2610 if (ops->sb_occ_snapshot)
2611 return ops->sb_occ_snapshot(devlink, devlink_sb->index);
2615 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
2616 struct genl_info *info)
2618 struct devlink *devlink = info->user_ptr[0];
2619 const struct devlink_ops *ops = devlink->ops;
2620 struct devlink_sb *devlink_sb;
2622 devlink_sb = devlink_sb_get_from_info(devlink, info);
2623 if (IS_ERR(devlink_sb))
2624 return PTR_ERR(devlink_sb);
2626 if (ops->sb_occ_max_clear)
2627 return ops->sb_occ_max_clear(devlink, devlink_sb->index);
2631 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
2632 enum devlink_command cmd, u32 portid,
2635 const struct devlink_ops *ops = devlink->ops;
2636 enum devlink_eswitch_encap_mode encap_mode;
2642 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2646 err = devlink_nl_put_handle(msg, devlink);
2648 goto nla_put_failure;
2650 if (ops->eswitch_mode_get) {
2651 err = ops->eswitch_mode_get(devlink, &mode);
2653 goto nla_put_failure;
2654 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
2656 goto nla_put_failure;
2659 if (ops->eswitch_inline_mode_get) {
2660 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
2662 goto nla_put_failure;
2663 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
2666 goto nla_put_failure;
2669 if (ops->eswitch_encap_mode_get) {
2670 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
2672 goto nla_put_failure;
2673 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
2675 goto nla_put_failure;
2678 genlmsg_end(msg, hdr);
2682 genlmsg_cancel(msg, hdr);
2686 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb,
2687 struct genl_info *info)
2689 struct devlink *devlink = info->user_ptr[0];
2690 struct sk_buff *msg;
2693 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2697 err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
2698 info->snd_portid, info->snd_seq, 0);
2705 return genlmsg_reply(msg, info);
2708 static int devlink_rate_nodes_check(struct devlink *devlink, u16 mode,
2709 struct netlink_ext_ack *extack)
2711 struct devlink_rate *devlink_rate;
2713 /* Take the lock to sync with devlink_rate_nodes_destroy() */
2714 mutex_lock(&devlink->lock);
2715 list_for_each_entry(devlink_rate, &devlink->rate_list, list)
2716 if (devlink_rate_is_node(devlink_rate)) {
2717 mutex_unlock(&devlink->lock);
2718 NL_SET_ERR_MSG_MOD(extack, "Rate node(s) exists.");
2721 mutex_unlock(&devlink->lock);
2725 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
2726 struct genl_info *info)
2728 struct devlink *devlink = info->user_ptr[0];
2729 const struct devlink_ops *ops = devlink->ops;
2730 enum devlink_eswitch_encap_mode encap_mode;
2735 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
2736 if (!ops->eswitch_mode_set)
2738 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
2739 err = devlink_rate_nodes_check(devlink, mode, info->extack);
2742 err = ops->eswitch_mode_set(devlink, mode, info->extack);
2747 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
2748 if (!ops->eswitch_inline_mode_set)
2750 inline_mode = nla_get_u8(
2751 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
2752 err = ops->eswitch_inline_mode_set(devlink, inline_mode,
2758 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
2759 if (!ops->eswitch_encap_mode_set)
2761 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
2762 err = ops->eswitch_encap_mode_set(devlink, encap_mode,
2771 int devlink_dpipe_match_put(struct sk_buff *skb,
2772 struct devlink_dpipe_match *match)
2774 struct devlink_dpipe_header *header = match->header;
2775 struct devlink_dpipe_field *field = &header->fields[match->field_id];
2776 struct nlattr *match_attr;
2778 match_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_MATCH);
2782 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
2783 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
2784 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2785 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2786 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2787 goto nla_put_failure;
2789 nla_nest_end(skb, match_attr);
2793 nla_nest_cancel(skb, match_attr);
2796 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
2798 static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
2799 struct sk_buff *skb)
2801 struct nlattr *matches_attr;
2803 matches_attr = nla_nest_start_noflag(skb,
2804 DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
2808 if (table->table_ops->matches_dump(table->priv, skb))
2809 goto nla_put_failure;
2811 nla_nest_end(skb, matches_attr);
2815 nla_nest_cancel(skb, matches_attr);
2819 int devlink_dpipe_action_put(struct sk_buff *skb,
2820 struct devlink_dpipe_action *action)
2822 struct devlink_dpipe_header *header = action->header;
2823 struct devlink_dpipe_field *field = &header->fields[action->field_id];
2824 struct nlattr *action_attr;
2826 action_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ACTION);
2830 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
2831 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
2832 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2833 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2834 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2835 goto nla_put_failure;
2837 nla_nest_end(skb, action_attr);
2841 nla_nest_cancel(skb, action_attr);
2844 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
2846 static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
2847 struct sk_buff *skb)
2849 struct nlattr *actions_attr;
2851 actions_attr = nla_nest_start_noflag(skb,
2852 DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
2856 if (table->table_ops->actions_dump(table->priv, skb))
2857 goto nla_put_failure;
2859 nla_nest_end(skb, actions_attr);
2863 nla_nest_cancel(skb, actions_attr);
2867 static int devlink_dpipe_table_put(struct sk_buff *skb,
2868 struct devlink_dpipe_table *table)
2870 struct nlattr *table_attr;
2873 table_size = table->table_ops->size_get(table->priv);
2874 table_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLE);
2878 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
2879 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
2881 goto nla_put_failure;
2882 if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
2883 table->counters_enabled))
2884 goto nla_put_failure;
2886 if (table->resource_valid) {
2887 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
2888 table->resource_id, DEVLINK_ATTR_PAD) ||
2889 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
2890 table->resource_units, DEVLINK_ATTR_PAD))
2891 goto nla_put_failure;
2893 if (devlink_dpipe_matches_put(table, skb))
2894 goto nla_put_failure;
2896 if (devlink_dpipe_actions_put(table, skb))
2897 goto nla_put_failure;
2899 nla_nest_end(skb, table_attr);
2903 nla_nest_cancel(skb, table_attr);
2907 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
2908 struct genl_info *info)
2913 err = genlmsg_reply(*pskb, info);
2917 *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2923 static int devlink_dpipe_tables_fill(struct genl_info *info,
2924 enum devlink_command cmd, int flags,
2925 struct list_head *dpipe_tables,
2926 const char *table_name)
2928 struct devlink *devlink = info->user_ptr[0];
2929 struct devlink_dpipe_table *table;
2930 struct nlattr *tables_attr;
2931 struct sk_buff *skb = NULL;
2932 struct nlmsghdr *nlh;
2938 table = list_first_entry(dpipe_tables,
2939 struct devlink_dpipe_table, list);
2941 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2945 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2946 &devlink_nl_family, NLM_F_MULTI, cmd);
2952 if (devlink_nl_put_handle(skb, devlink))
2953 goto nla_put_failure;
2954 tables_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLES);
2956 goto nla_put_failure;
2960 list_for_each_entry_from(table, dpipe_tables, list) {
2962 err = devlink_dpipe_table_put(skb, table);
2970 if (!strcmp(table->name, table_name)) {
2971 err = devlink_dpipe_table_put(skb, table);
2979 nla_nest_end(skb, tables_attr);
2980 genlmsg_end(skb, hdr);
2985 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2986 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2988 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2994 return genlmsg_reply(skb, info);
3003 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
3004 struct genl_info *info)
3006 struct devlink *devlink = info->user_ptr[0];
3007 const char *table_name = NULL;
3009 if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
3010 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3012 return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
3013 &devlink->dpipe_table_list,
3017 static int devlink_dpipe_value_put(struct sk_buff *skb,
3018 struct devlink_dpipe_value *value)
3020 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
3021 value->value_size, value->value))
3024 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
3025 value->value_size, value->mask))
3027 if (value->mapping_valid)
3028 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
3029 value->mapping_value))
3034 static int devlink_dpipe_action_value_put(struct sk_buff *skb,
3035 struct devlink_dpipe_value *value)
3039 if (devlink_dpipe_action_put(skb, value->action))
3041 if (devlink_dpipe_value_put(skb, value))
3046 static int devlink_dpipe_action_values_put(struct sk_buff *skb,
3047 struct devlink_dpipe_value *values,
3048 unsigned int values_count)
3050 struct nlattr *action_attr;
3054 for (i = 0; i < values_count; i++) {
3055 action_attr = nla_nest_start_noflag(skb,
3056 DEVLINK_ATTR_DPIPE_ACTION_VALUE);
3059 err = devlink_dpipe_action_value_put(skb, &values[i]);
3061 goto err_action_value_put;
3062 nla_nest_end(skb, action_attr);
3066 err_action_value_put:
3067 nla_nest_cancel(skb, action_attr);
3071 static int devlink_dpipe_match_value_put(struct sk_buff *skb,
3072 struct devlink_dpipe_value *value)
3076 if (devlink_dpipe_match_put(skb, value->match))
3078 if (devlink_dpipe_value_put(skb, value))
3083 static int devlink_dpipe_match_values_put(struct sk_buff *skb,
3084 struct devlink_dpipe_value *values,
3085 unsigned int values_count)
3087 struct nlattr *match_attr;
3091 for (i = 0; i < values_count; i++) {
3092 match_attr = nla_nest_start_noflag(skb,
3093 DEVLINK_ATTR_DPIPE_MATCH_VALUE);
3096 err = devlink_dpipe_match_value_put(skb, &values[i]);
3098 goto err_match_value_put;
3099 nla_nest_end(skb, match_attr);
3103 err_match_value_put:
3104 nla_nest_cancel(skb, match_attr);
3108 static int devlink_dpipe_entry_put(struct sk_buff *skb,
3109 struct devlink_dpipe_entry *entry)
3111 struct nlattr *entry_attr, *matches_attr, *actions_attr;
3114 entry_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ENTRY);
3118 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
3120 goto nla_put_failure;
3121 if (entry->counter_valid)
3122 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
3123 entry->counter, DEVLINK_ATTR_PAD))
3124 goto nla_put_failure;
3126 matches_attr = nla_nest_start_noflag(skb,
3127 DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
3129 goto nla_put_failure;
3131 err = devlink_dpipe_match_values_put(skb, entry->match_values,
3132 entry->match_values_count);
3134 nla_nest_cancel(skb, matches_attr);
3135 goto err_match_values_put;
3137 nla_nest_end(skb, matches_attr);
3139 actions_attr = nla_nest_start_noflag(skb,
3140 DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
3142 goto nla_put_failure;
3144 err = devlink_dpipe_action_values_put(skb, entry->action_values,
3145 entry->action_values_count);
3147 nla_nest_cancel(skb, actions_attr);
3148 goto err_action_values_put;
3150 nla_nest_end(skb, actions_attr);
3152 nla_nest_end(skb, entry_attr);
3157 err_match_values_put:
3158 err_action_values_put:
3159 nla_nest_cancel(skb, entry_attr);
3163 static struct devlink_dpipe_table *
3164 devlink_dpipe_table_find(struct list_head *dpipe_tables,
3165 const char *table_name, struct devlink *devlink)
3167 struct devlink_dpipe_table *table;
3168 list_for_each_entry_rcu(table, dpipe_tables, list,
3169 lockdep_is_held(&devlink->lock)) {
3170 if (!strcmp(table->name, table_name))
3176 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
3178 struct devlink *devlink;
3181 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
3186 dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
3187 dump_ctx->info->snd_portid,
3188 dump_ctx->info->snd_seq,
3189 &devlink_nl_family, NLM_F_MULTI,
3192 goto nla_put_failure;
3194 devlink = dump_ctx->info->user_ptr[0];
3195 if (devlink_nl_put_handle(dump_ctx->skb, devlink))
3196 goto nla_put_failure;
3197 dump_ctx->nest = nla_nest_start_noflag(dump_ctx->skb,
3198 DEVLINK_ATTR_DPIPE_ENTRIES);
3199 if (!dump_ctx->nest)
3200 goto nla_put_failure;
3204 nlmsg_free(dump_ctx->skb);
3207 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
3209 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
3210 struct devlink_dpipe_entry *entry)
3212 return devlink_dpipe_entry_put(dump_ctx->skb, entry);
3214 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
3216 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
3218 nla_nest_end(dump_ctx->skb, dump_ctx->nest);
3219 genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
3222 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
3224 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
3227 unsigned int value_count, value_index;
3228 struct devlink_dpipe_value *value;
3230 value = entry->action_values;
3231 value_count = entry->action_values_count;
3232 for (value_index = 0; value_index < value_count; value_index++) {
3233 kfree(value[value_index].value);
3234 kfree(value[value_index].mask);
3237 value = entry->match_values;
3238 value_count = entry->match_values_count;
3239 for (value_index = 0; value_index < value_count; value_index++) {
3240 kfree(value[value_index].value);
3241 kfree(value[value_index].mask);
3244 EXPORT_SYMBOL(devlink_dpipe_entry_clear);
3246 static int devlink_dpipe_entries_fill(struct genl_info *info,
3247 enum devlink_command cmd, int flags,
3248 struct devlink_dpipe_table *table)
3250 struct devlink_dpipe_dump_ctx dump_ctx;
3251 struct nlmsghdr *nlh;
3254 dump_ctx.skb = NULL;
3256 dump_ctx.info = info;
3258 err = table->table_ops->entries_dump(table->priv,
3259 table->counters_enabled,
3265 nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
3266 NLMSG_DONE, 0, flags | NLM_F_MULTI);
3268 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
3273 return genlmsg_reply(dump_ctx.skb, info);
3276 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
3277 struct genl_info *info)
3279 struct devlink *devlink = info->user_ptr[0];
3280 struct devlink_dpipe_table *table;
3281 const char *table_name;
3283 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
3286 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3287 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3288 table_name, devlink);
3292 if (!table->table_ops->entries_dump)
3295 return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
3299 static int devlink_dpipe_fields_put(struct sk_buff *skb,
3300 const struct devlink_dpipe_header *header)
3302 struct devlink_dpipe_field *field;
3303 struct nlattr *field_attr;
3306 for (i = 0; i < header->fields_count; i++) {
3307 field = &header->fields[i];
3308 field_attr = nla_nest_start_noflag(skb,
3309 DEVLINK_ATTR_DPIPE_FIELD);
3312 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
3313 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
3314 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
3315 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
3316 goto nla_put_failure;
3317 nla_nest_end(skb, field_attr);
3322 nla_nest_cancel(skb, field_attr);
3326 static int devlink_dpipe_header_put(struct sk_buff *skb,
3327 struct devlink_dpipe_header *header)
3329 struct nlattr *fields_attr, *header_attr;
3332 header_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADER);
3336 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
3337 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
3338 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
3339 goto nla_put_failure;
3341 fields_attr = nla_nest_start_noflag(skb,
3342 DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
3344 goto nla_put_failure;
3346 err = devlink_dpipe_fields_put(skb, header);
3348 nla_nest_cancel(skb, fields_attr);
3349 goto nla_put_failure;
3351 nla_nest_end(skb, fields_attr);
3352 nla_nest_end(skb, header_attr);
3357 nla_nest_cancel(skb, header_attr);
3361 static int devlink_dpipe_headers_fill(struct genl_info *info,
3362 enum devlink_command cmd, int flags,
3363 struct devlink_dpipe_headers *
3366 struct devlink *devlink = info->user_ptr[0];
3367 struct nlattr *headers_attr;
3368 struct sk_buff *skb = NULL;
3369 struct nlmsghdr *nlh;
3376 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3380 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3381 &devlink_nl_family, NLM_F_MULTI, cmd);
3387 if (devlink_nl_put_handle(skb, devlink))
3388 goto nla_put_failure;
3389 headers_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADERS);
3391 goto nla_put_failure;
3394 for (; i < dpipe_headers->headers_count; i++) {
3395 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
3403 nla_nest_end(skb, headers_attr);
3404 genlmsg_end(skb, hdr);
3405 if (i != dpipe_headers->headers_count)
3409 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3410 NLMSG_DONE, 0, flags | NLM_F_MULTI);
3412 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3417 return genlmsg_reply(skb, info);
3426 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
3427 struct genl_info *info)
3429 struct devlink *devlink = info->user_ptr[0];
3431 if (!devlink->dpipe_headers)
3433 return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
3434 0, devlink->dpipe_headers);
3437 static int devlink_dpipe_table_counters_set(struct devlink *devlink,
3438 const char *table_name,
3441 struct devlink_dpipe_table *table;
3443 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3444 table_name, devlink);
3448 if (table->counter_control_extern)
3451 if (!(table->counters_enabled ^ enable))
3454 table->counters_enabled = enable;
3455 if (table->table_ops->counters_set_update)
3456 table->table_ops->counters_set_update(table->priv, enable);
3460 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
3461 struct genl_info *info)
3463 struct devlink *devlink = info->user_ptr[0];
3464 const char *table_name;
3465 bool counters_enable;
3467 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
3468 !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
3471 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3472 counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
3474 return devlink_dpipe_table_counters_set(devlink, table_name,
3478 static struct devlink_resource *
3479 devlink_resource_find(struct devlink *devlink,
3480 struct devlink_resource *resource, u64 resource_id)
3482 struct list_head *resource_list;
3485 resource_list = &resource->resource_list;
3487 resource_list = &devlink->resource_list;
3489 list_for_each_entry(resource, resource_list, list) {
3490 struct devlink_resource *child_resource;
3492 if (resource->id == resource_id)
3495 child_resource = devlink_resource_find(devlink, resource,
3498 return child_resource;
3504 devlink_resource_validate_children(struct devlink_resource *resource)
3506 struct devlink_resource *child_resource;
3507 bool size_valid = true;
3510 if (list_empty(&resource->resource_list))
3513 list_for_each_entry(child_resource, &resource->resource_list, list)
3514 parts_size += child_resource->size_new;
3516 if (parts_size > resource->size_new)
3519 resource->size_valid = size_valid;
3523 devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
3524 struct netlink_ext_ack *extack)
3529 if (size > resource->size_params.size_max) {
3530 NL_SET_ERR_MSG_MOD(extack, "Size larger than maximum");
3534 if (size < resource->size_params.size_min) {
3535 NL_SET_ERR_MSG_MOD(extack, "Size smaller than minimum");
3539 div64_u64_rem(size, resource->size_params.size_granularity, &reminder);
3541 NL_SET_ERR_MSG_MOD(extack, "Wrong granularity");
3548 static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
3549 struct genl_info *info)
3551 struct devlink *devlink = info->user_ptr[0];
3552 struct devlink_resource *resource;
3557 if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
3558 !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
3560 resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
3562 resource = devlink_resource_find(devlink, NULL, resource_id);
3566 size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
3567 err = devlink_resource_validate_size(resource, size, info->extack);
3571 resource->size_new = size;
3572 devlink_resource_validate_children(resource);
3573 if (resource->parent)
3574 devlink_resource_validate_children(resource->parent);
3579 devlink_resource_size_params_put(struct devlink_resource *resource,
3580 struct sk_buff *skb)
3582 struct devlink_resource_size_params *size_params;
3584 size_params = &resource->size_params;
3585 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
3586 size_params->size_granularity, DEVLINK_ATTR_PAD) ||
3587 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
3588 size_params->size_max, DEVLINK_ATTR_PAD) ||
3589 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
3590 size_params->size_min, DEVLINK_ATTR_PAD) ||
3591 nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
3596 static int devlink_resource_occ_put(struct devlink_resource *resource,
3597 struct sk_buff *skb)
3599 if (!resource->occ_get)
3601 return nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
3602 resource->occ_get(resource->occ_get_priv),
3606 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
3607 struct devlink_resource *resource)
3609 struct devlink_resource *child_resource;
3610 struct nlattr *child_resource_attr;
3611 struct nlattr *resource_attr;
3613 resource_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_RESOURCE);
3617 if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
3618 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
3619 DEVLINK_ATTR_PAD) ||
3620 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
3622 goto nla_put_failure;
3623 if (resource->size != resource->size_new)
3624 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
3625 resource->size_new, DEVLINK_ATTR_PAD);
3626 if (devlink_resource_occ_put(resource, skb))
3627 goto nla_put_failure;
3628 if (devlink_resource_size_params_put(resource, skb))
3629 goto nla_put_failure;
3630 if (list_empty(&resource->resource_list))
3633 if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
3634 resource->size_valid))
3635 goto nla_put_failure;
3637 child_resource_attr = nla_nest_start_noflag(skb,
3638 DEVLINK_ATTR_RESOURCE_LIST);
3639 if (!child_resource_attr)
3640 goto nla_put_failure;
3642 list_for_each_entry(child_resource, &resource->resource_list, list) {
3643 if (devlink_resource_put(devlink, skb, child_resource))
3644 goto resource_put_failure;
3647 nla_nest_end(skb, child_resource_attr);
3649 nla_nest_end(skb, resource_attr);
3652 resource_put_failure:
3653 nla_nest_cancel(skb, child_resource_attr);
3655 nla_nest_cancel(skb, resource_attr);
3659 static int devlink_resource_fill(struct genl_info *info,
3660 enum devlink_command cmd, int flags)
3662 struct devlink *devlink = info->user_ptr[0];
3663 struct devlink_resource *resource;
3664 struct nlattr *resources_attr;
3665 struct sk_buff *skb = NULL;
3666 struct nlmsghdr *nlh;
3672 resource = list_first_entry(&devlink->resource_list,
3673 struct devlink_resource, list);
3675 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3679 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3680 &devlink_nl_family, NLM_F_MULTI, cmd);
3686 if (devlink_nl_put_handle(skb, devlink))
3687 goto nla_put_failure;
3689 resources_attr = nla_nest_start_noflag(skb,
3690 DEVLINK_ATTR_RESOURCE_LIST);
3691 if (!resources_attr)
3692 goto nla_put_failure;
3696 list_for_each_entry_from(resource, &devlink->resource_list, list) {
3697 err = devlink_resource_put(devlink, skb, resource);
3700 goto err_resource_put;
3706 nla_nest_end(skb, resources_attr);
3707 genlmsg_end(skb, hdr);
3711 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3712 NLMSG_DONE, 0, flags | NLM_F_MULTI);
3714 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3719 return genlmsg_reply(skb, info);
3728 static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
3729 struct genl_info *info)
3731 struct devlink *devlink = info->user_ptr[0];
3733 if (list_empty(&devlink->resource_list))
3736 return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
3740 devlink_resources_validate(struct devlink *devlink,
3741 struct devlink_resource *resource,
3742 struct genl_info *info)
3744 struct list_head *resource_list;
3748 resource_list = &resource->resource_list;
3750 resource_list = &devlink->resource_list;
3752 list_for_each_entry(resource, resource_list, list) {
3753 if (!resource->size_valid)
3755 err = devlink_resources_validate(devlink, resource, info);
3762 static struct net *devlink_netns_get(struct sk_buff *skb,
3763 struct genl_info *info)
3765 struct nlattr *netns_pid_attr = info->attrs[DEVLINK_ATTR_NETNS_PID];
3766 struct nlattr *netns_fd_attr = info->attrs[DEVLINK_ATTR_NETNS_FD];
3767 struct nlattr *netns_id_attr = info->attrs[DEVLINK_ATTR_NETNS_ID];
3770 if (!!netns_pid_attr + !!netns_fd_attr + !!netns_id_attr > 1) {
3771 NL_SET_ERR_MSG_MOD(info->extack, "multiple netns identifying attributes specified");
3772 return ERR_PTR(-EINVAL);
3775 if (netns_pid_attr) {
3776 net = get_net_ns_by_pid(nla_get_u32(netns_pid_attr));
3777 } else if (netns_fd_attr) {
3778 net = get_net_ns_by_fd(nla_get_u32(netns_fd_attr));
3779 } else if (netns_id_attr) {
3780 net = get_net_ns_by_id(sock_net(skb->sk),
3781 nla_get_u32(netns_id_attr));
3783 net = ERR_PTR(-EINVAL);
3786 net = ERR_PTR(-EINVAL);
3789 NL_SET_ERR_MSG_MOD(info->extack, "Unknown network namespace");
3790 return ERR_PTR(-EINVAL);
3792 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
3794 return ERR_PTR(-EPERM);
3799 static void devlink_param_notify(struct devlink *devlink,
3800 unsigned int port_index,
3801 struct devlink_param_item *param_item,
3802 enum devlink_command cmd);
3804 static void devlink_reload_netns_change(struct devlink *devlink,
3805 struct net *dest_net)
3807 struct devlink_param_item *param_item;
3809 /* Userspace needs to be notified about devlink objects
3810 * removed from original and entering new network namespace.
3811 * The rest of the devlink objects are re-created during
3812 * reload process so the notifications are generated separatelly.
3815 list_for_each_entry(param_item, &devlink->param_list, list)
3816 devlink_param_notify(devlink, 0, param_item,
3817 DEVLINK_CMD_PARAM_DEL);
3818 devlink_notify(devlink, DEVLINK_CMD_DEL);
3820 __devlink_net_set(devlink, dest_net);
3822 devlink_notify(devlink, DEVLINK_CMD_NEW);
3823 list_for_each_entry(param_item, &devlink->param_list, list)
3824 devlink_param_notify(devlink, 0, param_item,
3825 DEVLINK_CMD_PARAM_NEW);
3828 static bool devlink_reload_supported(const struct devlink_ops *ops)
3830 return ops->reload_down && ops->reload_up;
3833 static void devlink_reload_failed_set(struct devlink *devlink,
3836 if (devlink->reload_failed == reload_failed)
3838 devlink->reload_failed = reload_failed;
3839 devlink_notify(devlink, DEVLINK_CMD_NEW);
3842 bool devlink_is_reload_failed(const struct devlink *devlink)
3844 return devlink->reload_failed;
3846 EXPORT_SYMBOL_GPL(devlink_is_reload_failed);
3849 __devlink_reload_stats_update(struct devlink *devlink, u32 *reload_stats,
3850 enum devlink_reload_limit limit, u32 actions_performed)
3852 unsigned long actions = actions_performed;
3856 for_each_set_bit(action, &actions, __DEVLINK_RELOAD_ACTION_MAX) {
3857 stat_idx = limit * __DEVLINK_RELOAD_ACTION_MAX + action;
3858 reload_stats[stat_idx]++;
3860 devlink_notify(devlink, DEVLINK_CMD_NEW);
3864 devlink_reload_stats_update(struct devlink *devlink, enum devlink_reload_limit limit,
3865 u32 actions_performed)
3867 __devlink_reload_stats_update(devlink, devlink->stats.reload_stats, limit,
3872 * devlink_remote_reload_actions_performed - Update devlink on reload actions
3873 * performed which are not a direct result of devlink reload call.
3875 * This should be called by a driver after performing reload actions in case it was not
3876 * a result of devlink reload call. For example fw_activate was performed as a result
3877 * of devlink reload triggered fw_activate on another host.
3878 * The motivation for this function is to keep data on reload actions performed on this
3879 * function whether it was done due to direct devlink reload call or not.
3882 * @limit: reload limit
3883 * @actions_performed: bitmask of actions performed
3885 void devlink_remote_reload_actions_performed(struct devlink *devlink,
3886 enum devlink_reload_limit limit,
3887 u32 actions_performed)
3889 if (WARN_ON(!actions_performed ||
3890 actions_performed & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
3891 actions_performed >= BIT(__DEVLINK_RELOAD_ACTION_MAX) ||
3892 limit > DEVLINK_RELOAD_LIMIT_MAX))
3895 __devlink_reload_stats_update(devlink, devlink->stats.remote_reload_stats, limit,
3898 EXPORT_SYMBOL_GPL(devlink_remote_reload_actions_performed);
3900 static int devlink_reload(struct devlink *devlink, struct net *dest_net,
3901 enum devlink_reload_action action, enum devlink_reload_limit limit,
3902 u32 *actions_performed, struct netlink_ext_ack *extack)
3904 u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE];
3907 if (!devlink->reload_enabled)
3910 memcpy(remote_reload_stats, devlink->stats.remote_reload_stats,
3911 sizeof(remote_reload_stats));
3912 err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack);
3916 if (dest_net && !net_eq(dest_net, devlink_net(devlink)))
3917 devlink_reload_netns_change(devlink, dest_net);
3919 err = devlink->ops->reload_up(devlink, action, limit, actions_performed, extack);
3920 devlink_reload_failed_set(devlink, !!err);
3924 WARN_ON(!(*actions_performed & BIT(action)));
3925 /* Catch driver on updating the remote action within devlink reload */
3926 WARN_ON(memcmp(remote_reload_stats, devlink->stats.remote_reload_stats,
3927 sizeof(remote_reload_stats)));
3928 devlink_reload_stats_update(devlink, limit, *actions_performed);
3933 devlink_nl_reload_actions_performed_snd(struct devlink *devlink, u32 actions_performed,
3934 enum devlink_command cmd, struct genl_info *info)
3936 struct sk_buff *msg;
3939 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3943 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &devlink_nl_family, 0, cmd);
3947 if (devlink_nl_put_handle(msg, devlink))
3948 goto nla_put_failure;
3950 if (nla_put_bitfield32(msg, DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED, actions_performed,
3952 goto nla_put_failure;
3953 genlmsg_end(msg, hdr);
3955 return genlmsg_reply(msg, info);
3958 genlmsg_cancel(msg, hdr);
3964 static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
3966 struct devlink *devlink = info->user_ptr[0];
3967 enum devlink_reload_action action;
3968 enum devlink_reload_limit limit;
3969 struct net *dest_net = NULL;
3970 u32 actions_performed;
3973 if (!devlink_reload_supported(devlink->ops))
3976 err = devlink_resources_validate(devlink, NULL, info);
3978 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
3982 if (info->attrs[DEVLINK_ATTR_NETNS_PID] ||
3983 info->attrs[DEVLINK_ATTR_NETNS_FD] ||
3984 info->attrs[DEVLINK_ATTR_NETNS_ID]) {
3985 dest_net = devlink_netns_get(skb, info);
3986 if (IS_ERR(dest_net))
3987 return PTR_ERR(dest_net);
3990 if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION])
3991 action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]);
3993 action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT;
3995 if (!devlink_reload_action_is_supported(devlink, action)) {
3996 NL_SET_ERR_MSG_MOD(info->extack,
3997 "Requested reload action is not supported by the driver");
4001 limit = DEVLINK_RELOAD_LIMIT_UNSPEC;
4002 if (info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) {
4003 struct nla_bitfield32 limits;
4004 u32 limits_selected;
4006 limits = nla_get_bitfield32(info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]);
4007 limits_selected = limits.value & limits.selector;
4008 if (!limits_selected) {
4009 NL_SET_ERR_MSG_MOD(info->extack, "Invalid limit selected");
4012 for (limit = 0 ; limit <= DEVLINK_RELOAD_LIMIT_MAX ; limit++)
4013 if (limits_selected & BIT(limit))
4015 /* UAPI enables multiselection, but currently it is not used */
4016 if (limits_selected != BIT(limit)) {
4017 NL_SET_ERR_MSG_MOD(info->extack,
4018 "Multiselection of limit is not supported");
4021 if (!devlink_reload_limit_is_supported(devlink, limit)) {
4022 NL_SET_ERR_MSG_MOD(info->extack,
4023 "Requested limit is not supported by the driver");
4026 if (devlink_reload_combination_is_invalid(action, limit)) {
4027 NL_SET_ERR_MSG_MOD(info->extack,
4028 "Requested limit is invalid for this action");
4032 err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack);
4039 /* For backward compatibility generate reply only if attributes used by user */
4040 if (!info->attrs[DEVLINK_ATTR_RELOAD_ACTION] && !info->attrs[DEVLINK_ATTR_RELOAD_LIMITS])
4043 return devlink_nl_reload_actions_performed_snd(devlink, actions_performed,
4044 DEVLINK_CMD_RELOAD, info);
4047 static int devlink_nl_flash_update_fill(struct sk_buff *msg,
4048 struct devlink *devlink,
4049 enum devlink_command cmd,
4050 struct devlink_flash_notify *params)
4054 hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd);
4058 if (devlink_nl_put_handle(msg, devlink))
4059 goto nla_put_failure;
4061 if (cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS)
4064 if (params->status_msg &&
4065 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG,
4066 params->status_msg))
4067 goto nla_put_failure;
4068 if (params->component &&
4069 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT,
4071 goto nla_put_failure;
4072 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE,
4073 params->done, DEVLINK_ATTR_PAD))
4074 goto nla_put_failure;
4075 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL,
4076 params->total, DEVLINK_ATTR_PAD))
4077 goto nla_put_failure;
4078 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT,
4079 params->timeout, DEVLINK_ATTR_PAD))
4080 goto nla_put_failure;
4083 genlmsg_end(msg, hdr);
4087 genlmsg_cancel(msg, hdr);
4091 static void __devlink_flash_update_notify(struct devlink *devlink,
4092 enum devlink_command cmd,
4093 struct devlink_flash_notify *params)
4095 struct sk_buff *msg;
4098 WARN_ON(cmd != DEVLINK_CMD_FLASH_UPDATE &&
4099 cmd != DEVLINK_CMD_FLASH_UPDATE_END &&
4100 cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS);
4102 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4106 err = devlink_nl_flash_update_fill(msg, devlink, cmd, params);
4110 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
4111 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
4118 static void devlink_flash_update_begin_notify(struct devlink *devlink)
4120 struct devlink_flash_notify params = { 0 };
4122 __devlink_flash_update_notify(devlink,
4123 DEVLINK_CMD_FLASH_UPDATE,
4127 static void devlink_flash_update_end_notify(struct devlink *devlink)
4129 struct devlink_flash_notify params = { 0 };
4131 __devlink_flash_update_notify(devlink,
4132 DEVLINK_CMD_FLASH_UPDATE_END,
4136 void devlink_flash_update_status_notify(struct devlink *devlink,
4137 const char *status_msg,
4138 const char *component,
4140 unsigned long total)
4142 struct devlink_flash_notify params = {
4143 .status_msg = status_msg,
4144 .component = component,
4149 __devlink_flash_update_notify(devlink,
4150 DEVLINK_CMD_FLASH_UPDATE_STATUS,
4153 EXPORT_SYMBOL_GPL(devlink_flash_update_status_notify);
4155 void devlink_flash_update_timeout_notify(struct devlink *devlink,
4156 const char *status_msg,
4157 const char *component,
4158 unsigned long timeout)
4160 struct devlink_flash_notify params = {
4161 .status_msg = status_msg,
4162 .component = component,
4166 __devlink_flash_update_notify(devlink,
4167 DEVLINK_CMD_FLASH_UPDATE_STATUS,
4170 EXPORT_SYMBOL_GPL(devlink_flash_update_timeout_notify);
4172 static int devlink_nl_cmd_flash_update(struct sk_buff *skb,
4173 struct genl_info *info)
4175 struct nlattr *nla_component, *nla_overwrite_mask, *nla_file_name;
4176 struct devlink_flash_update_params params = {};
4177 struct devlink *devlink = info->user_ptr[0];
4178 const char *file_name;
4179 u32 supported_params;
4182 if (!devlink->ops->flash_update)
4185 if (!info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME])
4188 supported_params = devlink->ops->supported_flash_update_params;
4190 nla_component = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT];
4191 if (nla_component) {
4192 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT)) {
4193 NL_SET_ERR_MSG_ATTR(info->extack, nla_component,
4194 "component update is not supported by this device");
4197 params.component = nla_data(nla_component);
4200 nla_overwrite_mask = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK];
4201 if (nla_overwrite_mask) {
4202 struct nla_bitfield32 sections;
4204 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK)) {
4205 NL_SET_ERR_MSG_ATTR(info->extack, nla_overwrite_mask,
4206 "overwrite settings are not supported by this device");
4209 sections = nla_get_bitfield32(nla_overwrite_mask);
4210 params.overwrite_mask = sections.value & sections.selector;
4213 nla_file_name = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME];
4214 file_name = nla_data(nla_file_name);
4215 ret = request_firmware(¶ms.fw, file_name, devlink->dev);
4217 NL_SET_ERR_MSG_ATTR(info->extack, nla_file_name, "failed to locate the requested firmware file");
4221 devlink_flash_update_begin_notify(devlink);
4222 ret = devlink->ops->flash_update(devlink, ¶ms, info->extack);
4223 devlink_flash_update_end_notify(devlink);
4225 release_firmware(params.fw);
4230 static const struct devlink_param devlink_param_generic[] = {
4232 .id = DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET,
4233 .name = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME,
4234 .type = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE,
4237 .id = DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
4238 .name = DEVLINK_PARAM_GENERIC_MAX_MACS_NAME,
4239 .type = DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE,
4242 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV,
4243 .name = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME,
4244 .type = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE,
4247 .id = DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT,
4248 .name = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME,
4249 .type = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE,
4252 .id = DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI,
4253 .name = DEVLINK_PARAM_GENERIC_IGNORE_ARI_NAME,
4254 .type = DEVLINK_PARAM_GENERIC_IGNORE_ARI_TYPE,
4257 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
4258 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_NAME,
4259 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_TYPE,
4262 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
4263 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_NAME,
4264 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_TYPE,
4267 .id = DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY,
4268 .name = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_NAME,
4269 .type = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_TYPE,
4272 .id = DEVLINK_PARAM_GENERIC_ID_RESET_DEV_ON_DRV_PROBE,
4273 .name = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_NAME,
4274 .type = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_TYPE,
4277 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
4278 .name = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_NAME,
4279 .type = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_TYPE,
4282 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_REMOTE_DEV_RESET,
4283 .name = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_NAME,
4284 .type = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_TYPE,
4288 static int devlink_param_generic_verify(const struct devlink_param *param)
4290 /* verify it match generic parameter by id and name */
4291 if (param->id > DEVLINK_PARAM_GENERIC_ID_MAX)
4293 if (strcmp(param->name, devlink_param_generic[param->id].name))
4296 WARN_ON(param->type != devlink_param_generic[param->id].type);
4301 static int devlink_param_driver_verify(const struct devlink_param *param)
4305 if (param->id <= DEVLINK_PARAM_GENERIC_ID_MAX)
4307 /* verify no such name in generic params */
4308 for (i = 0; i <= DEVLINK_PARAM_GENERIC_ID_MAX; i++)
4309 if (!strcmp(param->name, devlink_param_generic[i].name))
4315 static struct devlink_param_item *
4316 devlink_param_find_by_name(struct list_head *param_list,
4317 const char *param_name)
4319 struct devlink_param_item *param_item;
4321 list_for_each_entry(param_item, param_list, list)
4322 if (!strcmp(param_item->param->name, param_name))
4327 static struct devlink_param_item *
4328 devlink_param_find_by_id(struct list_head *param_list, u32 param_id)
4330 struct devlink_param_item *param_item;
4332 list_for_each_entry(param_item, param_list, list)
4333 if (param_item->param->id == param_id)
4339 devlink_param_cmode_is_supported(const struct devlink_param *param,
4340 enum devlink_param_cmode cmode)
4342 return test_bit(cmode, ¶m->supported_cmodes);
4345 static int devlink_param_get(struct devlink *devlink,
4346 const struct devlink_param *param,
4347 struct devlink_param_gset_ctx *ctx)
4351 return param->get(devlink, param->id, ctx);
4354 static int devlink_param_set(struct devlink *devlink,
4355 const struct devlink_param *param,
4356 struct devlink_param_gset_ctx *ctx)
4360 return param->set(devlink, param->id, ctx);
4364 devlink_param_type_to_nla_type(enum devlink_param_type param_type)
4366 switch (param_type) {
4367 case DEVLINK_PARAM_TYPE_U8:
4369 case DEVLINK_PARAM_TYPE_U16:
4371 case DEVLINK_PARAM_TYPE_U32:
4373 case DEVLINK_PARAM_TYPE_STRING:
4375 case DEVLINK_PARAM_TYPE_BOOL:
4383 devlink_nl_param_value_fill_one(struct sk_buff *msg,
4384 enum devlink_param_type type,
4385 enum devlink_param_cmode cmode,
4386 union devlink_param_value val)
4388 struct nlattr *param_value_attr;
4390 param_value_attr = nla_nest_start_noflag(msg,
4391 DEVLINK_ATTR_PARAM_VALUE);
4392 if (!param_value_attr)
4393 goto nla_put_failure;
4395 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_CMODE, cmode))
4396 goto value_nest_cancel;
4399 case DEVLINK_PARAM_TYPE_U8:
4400 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu8))
4401 goto value_nest_cancel;
4403 case DEVLINK_PARAM_TYPE_U16:
4404 if (nla_put_u16(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu16))
4405 goto value_nest_cancel;
4407 case DEVLINK_PARAM_TYPE_U32:
4408 if (nla_put_u32(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu32))
4409 goto value_nest_cancel;
4411 case DEVLINK_PARAM_TYPE_STRING:
4412 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_VALUE_DATA,
4414 goto value_nest_cancel;
4416 case DEVLINK_PARAM_TYPE_BOOL:
4418 nla_put_flag(msg, DEVLINK_ATTR_PARAM_VALUE_DATA))
4419 goto value_nest_cancel;
4423 nla_nest_end(msg, param_value_attr);
4427 nla_nest_cancel(msg, param_value_attr);
4432 static int devlink_nl_param_fill(struct sk_buff *msg, struct devlink *devlink,
4433 unsigned int port_index,
4434 struct devlink_param_item *param_item,
4435 enum devlink_command cmd,
4436 u32 portid, u32 seq, int flags)
4438 union devlink_param_value param_value[DEVLINK_PARAM_CMODE_MAX + 1];
4439 bool param_value_set[DEVLINK_PARAM_CMODE_MAX + 1] = {};
4440 const struct devlink_param *param = param_item->param;
4441 struct devlink_param_gset_ctx ctx;
4442 struct nlattr *param_values_list;
4443 struct nlattr *param_attr;
4449 /* Get value from driver part to driverinit configuration mode */
4450 for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
4451 if (!devlink_param_cmode_is_supported(param, i))
4453 if (i == DEVLINK_PARAM_CMODE_DRIVERINIT) {
4454 if (!param_item->driverinit_value_valid)
4456 param_value[i] = param_item->driverinit_value;
4458 if (!param_item->published)
4461 err = devlink_param_get(devlink, param, &ctx);
4464 param_value[i] = ctx.val;
4466 param_value_set[i] = true;
4469 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4473 if (devlink_nl_put_handle(msg, devlink))
4474 goto genlmsg_cancel;
4476 if (cmd == DEVLINK_CMD_PORT_PARAM_GET ||
4477 cmd == DEVLINK_CMD_PORT_PARAM_NEW ||
4478 cmd == DEVLINK_CMD_PORT_PARAM_DEL)
4479 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, port_index))
4480 goto genlmsg_cancel;
4482 param_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PARAM);
4484 goto genlmsg_cancel;
4485 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_NAME, param->name))
4486 goto param_nest_cancel;
4487 if (param->generic && nla_put_flag(msg, DEVLINK_ATTR_PARAM_GENERIC))
4488 goto param_nest_cancel;
4490 nla_type = devlink_param_type_to_nla_type(param->type);
4492 goto param_nest_cancel;
4493 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_TYPE, nla_type))
4494 goto param_nest_cancel;
4496 param_values_list = nla_nest_start_noflag(msg,
4497 DEVLINK_ATTR_PARAM_VALUES_LIST);
4498 if (!param_values_list)
4499 goto param_nest_cancel;
4501 for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
4502 if (!param_value_set[i])
4504 err = devlink_nl_param_value_fill_one(msg, param->type,
4507 goto values_list_nest_cancel;
4510 nla_nest_end(msg, param_values_list);
4511 nla_nest_end(msg, param_attr);
4512 genlmsg_end(msg, hdr);
4515 values_list_nest_cancel:
4516 nla_nest_end(msg, param_values_list);
4518 nla_nest_cancel(msg, param_attr);
4520 genlmsg_cancel(msg, hdr);
4524 static void devlink_param_notify(struct devlink *devlink,
4525 unsigned int port_index,
4526 struct devlink_param_item *param_item,
4527 enum devlink_command cmd)
4529 struct sk_buff *msg;
4532 WARN_ON(cmd != DEVLINK_CMD_PARAM_NEW && cmd != DEVLINK_CMD_PARAM_DEL &&
4533 cmd != DEVLINK_CMD_PORT_PARAM_NEW &&
4534 cmd != DEVLINK_CMD_PORT_PARAM_DEL);
4536 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4539 err = devlink_nl_param_fill(msg, devlink, port_index, param_item, cmd,
4546 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
4547 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
4550 static int devlink_nl_cmd_param_get_dumpit(struct sk_buff *msg,
4551 struct netlink_callback *cb)
4553 struct devlink_param_item *param_item;
4554 struct devlink *devlink;
4555 int start = cb->args[0];
4559 mutex_lock(&devlink_mutex);
4560 list_for_each_entry(devlink, &devlink_list, list) {
4561 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4563 mutex_lock(&devlink->lock);
4564 list_for_each_entry(param_item, &devlink->param_list, list) {
4569 err = devlink_nl_param_fill(msg, devlink, 0, param_item,
4570 DEVLINK_CMD_PARAM_GET,
4571 NETLINK_CB(cb->skb).portid,
4574 if (err == -EOPNOTSUPP) {
4577 mutex_unlock(&devlink->lock);
4582 mutex_unlock(&devlink->lock);
4585 mutex_unlock(&devlink_mutex);
4587 if (err != -EMSGSIZE)
4595 devlink_param_type_get_from_info(struct genl_info *info,
4596 enum devlink_param_type *param_type)
4598 if (!info->attrs[DEVLINK_ATTR_PARAM_TYPE])
4601 switch (nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_TYPE])) {
4603 *param_type = DEVLINK_PARAM_TYPE_U8;
4606 *param_type = DEVLINK_PARAM_TYPE_U16;
4609 *param_type = DEVLINK_PARAM_TYPE_U32;
4612 *param_type = DEVLINK_PARAM_TYPE_STRING;
4615 *param_type = DEVLINK_PARAM_TYPE_BOOL;
4625 devlink_param_value_get_from_info(const struct devlink_param *param,
4626 struct genl_info *info,
4627 union devlink_param_value *value)
4629 struct nlattr *param_data;
4632 param_data = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA];
4634 if (param->type != DEVLINK_PARAM_TYPE_BOOL && !param_data)
4637 switch (param->type) {
4638 case DEVLINK_PARAM_TYPE_U8:
4639 if (nla_len(param_data) != sizeof(u8))
4641 value->vu8 = nla_get_u8(param_data);
4643 case DEVLINK_PARAM_TYPE_U16:
4644 if (nla_len(param_data) != sizeof(u16))
4646 value->vu16 = nla_get_u16(param_data);
4648 case DEVLINK_PARAM_TYPE_U32:
4649 if (nla_len(param_data) != sizeof(u32))
4651 value->vu32 = nla_get_u32(param_data);
4653 case DEVLINK_PARAM_TYPE_STRING:
4654 len = strnlen(nla_data(param_data), nla_len(param_data));
4655 if (len == nla_len(param_data) ||
4656 len >= __DEVLINK_PARAM_MAX_STRING_VALUE)
4658 strcpy(value->vstr, nla_data(param_data));
4660 case DEVLINK_PARAM_TYPE_BOOL:
4661 if (param_data && nla_len(param_data))
4663 value->vbool = nla_get_flag(param_data);
4669 static struct devlink_param_item *
4670 devlink_param_get_from_info(struct list_head *param_list,
4671 struct genl_info *info)
4675 if (!info->attrs[DEVLINK_ATTR_PARAM_NAME])
4678 param_name = nla_data(info->attrs[DEVLINK_ATTR_PARAM_NAME]);
4679 return devlink_param_find_by_name(param_list, param_name);
4682 static int devlink_nl_cmd_param_get_doit(struct sk_buff *skb,
4683 struct genl_info *info)
4685 struct devlink *devlink = info->user_ptr[0];
4686 struct devlink_param_item *param_item;
4687 struct sk_buff *msg;
4690 param_item = devlink_param_get_from_info(&devlink->param_list, info);
4694 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4698 err = devlink_nl_param_fill(msg, devlink, 0, param_item,
4699 DEVLINK_CMD_PARAM_GET,
4700 info->snd_portid, info->snd_seq, 0);
4706 return genlmsg_reply(msg, info);
4709 static int __devlink_nl_cmd_param_set_doit(struct devlink *devlink,
4710 unsigned int port_index,
4711 struct list_head *param_list,
4712 struct genl_info *info,
4713 enum devlink_command cmd)
4715 enum devlink_param_type param_type;
4716 struct devlink_param_gset_ctx ctx;
4717 enum devlink_param_cmode cmode;
4718 struct devlink_param_item *param_item;
4719 const struct devlink_param *param;
4720 union devlink_param_value value;
4723 param_item = devlink_param_get_from_info(param_list, info);
4726 param = param_item->param;
4727 err = devlink_param_type_get_from_info(info, ¶m_type);
4730 if (param_type != param->type)
4732 err = devlink_param_value_get_from_info(param, info, &value);
4735 if (param->validate) {
4736 err = param->validate(devlink, param->id, value, info->extack);
4741 if (!info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE])
4743 cmode = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE]);
4744 if (!devlink_param_cmode_is_supported(param, cmode))
4747 if (cmode == DEVLINK_PARAM_CMODE_DRIVERINIT) {
4748 if (param->type == DEVLINK_PARAM_TYPE_STRING)
4749 strcpy(param_item->driverinit_value.vstr, value.vstr);
4751 param_item->driverinit_value = value;
4752 param_item->driverinit_value_valid = true;
4758 err = devlink_param_set(devlink, param, &ctx);
4763 devlink_param_notify(devlink, port_index, param_item, cmd);
4767 static int devlink_nl_cmd_param_set_doit(struct sk_buff *skb,
4768 struct genl_info *info)
4770 struct devlink *devlink = info->user_ptr[0];
4772 return __devlink_nl_cmd_param_set_doit(devlink, 0, &devlink->param_list,
4773 info, DEVLINK_CMD_PARAM_NEW);
4776 static int devlink_param_register_one(struct devlink *devlink,
4777 unsigned int port_index,
4778 struct list_head *param_list,
4779 const struct devlink_param *param,
4780 enum devlink_command cmd)
4782 struct devlink_param_item *param_item;
4784 if (devlink_param_find_by_name(param_list, param->name))
4787 if (param->supported_cmodes == BIT(DEVLINK_PARAM_CMODE_DRIVERINIT))
4788 WARN_ON(param->get || param->set);
4790 WARN_ON(!param->get || !param->set);
4792 param_item = kzalloc(sizeof(*param_item), GFP_KERNEL);
4795 param_item->param = param;
4797 list_add_tail(¶m_item->list, param_list);
4798 devlink_param_notify(devlink, port_index, param_item, cmd);
4802 static void devlink_param_unregister_one(struct devlink *devlink,
4803 unsigned int port_index,
4804 struct list_head *param_list,
4805 const struct devlink_param *param,
4806 enum devlink_command cmd)
4808 struct devlink_param_item *param_item;
4810 param_item = devlink_param_find_by_name(param_list, param->name);
4811 WARN_ON(!param_item);
4812 devlink_param_notify(devlink, port_index, param_item, cmd);
4813 list_del(¶m_item->list);
4817 static int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg,
4818 struct netlink_callback *cb)
4820 struct devlink_param_item *param_item;
4821 struct devlink_port *devlink_port;
4822 struct devlink *devlink;
4823 int start = cb->args[0];
4827 mutex_lock(&devlink_mutex);
4828 list_for_each_entry(devlink, &devlink_list, list) {
4829 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4831 mutex_lock(&devlink->lock);
4832 list_for_each_entry(devlink_port, &devlink->port_list, list) {
4833 list_for_each_entry(param_item,
4834 &devlink_port->param_list, list) {
4839 err = devlink_nl_param_fill(msg,
4840 devlink_port->devlink,
4841 devlink_port->index, param_item,
4842 DEVLINK_CMD_PORT_PARAM_GET,
4843 NETLINK_CB(cb->skb).portid,
4846 if (err == -EOPNOTSUPP) {
4849 mutex_unlock(&devlink->lock);
4855 mutex_unlock(&devlink->lock);
4858 mutex_unlock(&devlink_mutex);
4860 if (err != -EMSGSIZE)
4867 static int devlink_nl_cmd_port_param_get_doit(struct sk_buff *skb,
4868 struct genl_info *info)
4870 struct devlink_port *devlink_port = info->user_ptr[1];
4871 struct devlink_param_item *param_item;
4872 struct sk_buff *msg;
4875 param_item = devlink_param_get_from_info(&devlink_port->param_list,
4880 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4884 err = devlink_nl_param_fill(msg, devlink_port->devlink,
4885 devlink_port->index, param_item,
4886 DEVLINK_CMD_PORT_PARAM_GET,
4887 info->snd_portid, info->snd_seq, 0);
4893 return genlmsg_reply(msg, info);
4896 static int devlink_nl_cmd_port_param_set_doit(struct sk_buff *skb,
4897 struct genl_info *info)
4899 struct devlink_port *devlink_port = info->user_ptr[1];
4901 return __devlink_nl_cmd_param_set_doit(devlink_port->devlink,
4902 devlink_port->index,
4903 &devlink_port->param_list, info,
4904 DEVLINK_CMD_PORT_PARAM_NEW);
4907 static int devlink_nl_region_snapshot_id_put(struct sk_buff *msg,
4908 struct devlink *devlink,
4909 struct devlink_snapshot *snapshot)
4911 struct nlattr *snap_attr;
4914 snap_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_SNAPSHOT);
4918 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID, snapshot->id);
4920 goto nla_put_failure;
4922 nla_nest_end(msg, snap_attr);
4926 nla_nest_cancel(msg, snap_attr);
4930 static int devlink_nl_region_snapshots_id_put(struct sk_buff *msg,
4931 struct devlink *devlink,
4932 struct devlink_region *region)
4934 struct devlink_snapshot *snapshot;
4935 struct nlattr *snapshots_attr;
4938 snapshots_attr = nla_nest_start_noflag(msg,
4939 DEVLINK_ATTR_REGION_SNAPSHOTS);
4940 if (!snapshots_attr)
4943 list_for_each_entry(snapshot, ®ion->snapshot_list, list) {
4944 err = devlink_nl_region_snapshot_id_put(msg, devlink, snapshot);
4946 goto nla_put_failure;
4949 nla_nest_end(msg, snapshots_attr);
4953 nla_nest_cancel(msg, snapshots_attr);
4957 static int devlink_nl_region_fill(struct sk_buff *msg, struct devlink *devlink,
4958 enum devlink_command cmd, u32 portid,
4960 struct devlink_region *region)
4965 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4969 err = devlink_nl_put_handle(msg, devlink);
4971 goto nla_put_failure;
4974 err = nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
4975 region->port->index);
4977 goto nla_put_failure;
4980 err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME, region->ops->name);
4982 goto nla_put_failure;
4984 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
4988 goto nla_put_failure;
4990 err = devlink_nl_region_snapshots_id_put(msg, devlink, region);
4992 goto nla_put_failure;
4994 genlmsg_end(msg, hdr);
4998 genlmsg_cancel(msg, hdr);
5002 static struct sk_buff *
5003 devlink_nl_region_notify_build(struct devlink_region *region,
5004 struct devlink_snapshot *snapshot,
5005 enum devlink_command cmd, u32 portid, u32 seq)
5007 struct devlink *devlink = region->devlink;
5008 struct sk_buff *msg;
5013 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5015 return ERR_PTR(-ENOMEM);
5017 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, 0, cmd);
5023 err = devlink_nl_put_handle(msg, devlink);
5025 goto out_cancel_msg;
5028 err = nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
5029 region->port->index);
5031 goto out_cancel_msg;
5034 err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME,
5037 goto out_cancel_msg;
5040 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID,
5043 goto out_cancel_msg;
5045 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
5046 region->size, DEVLINK_ATTR_PAD);
5048 goto out_cancel_msg;
5050 genlmsg_end(msg, hdr);
5055 genlmsg_cancel(msg, hdr);
5058 return ERR_PTR(err);
5061 static void devlink_nl_region_notify(struct devlink_region *region,
5062 struct devlink_snapshot *snapshot,
5063 enum devlink_command cmd)
5065 struct devlink *devlink = region->devlink;
5066 struct sk_buff *msg;
5068 WARN_ON(cmd != DEVLINK_CMD_REGION_NEW && cmd != DEVLINK_CMD_REGION_DEL);
5070 msg = devlink_nl_region_notify_build(region, snapshot, cmd, 0, 0);
5074 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
5075 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
5079 * __devlink_snapshot_id_increment - Increment number of snapshots using an id
5080 * @devlink: devlink instance
5081 * @id: the snapshot id
5083 * Track when a new snapshot begins using an id. Load the count for the
5084 * given id from the snapshot xarray, increment it, and store it back.
5086 * Called when a new snapshot is created with the given id.
5088 * The id *must* have been previously allocated by
5089 * devlink_region_snapshot_id_get().
5091 * Returns 0 on success, or an error on failure.
5093 static int __devlink_snapshot_id_increment(struct devlink *devlink, u32 id)
5095 unsigned long count;
5098 lockdep_assert_held(&devlink->lock);
5100 p = xa_load(&devlink->snapshot_ids, id);
5104 if (WARN_ON(!xa_is_value(p)))
5107 count = xa_to_value(p);
5110 return xa_err(xa_store(&devlink->snapshot_ids, id, xa_mk_value(count),
5115 * __devlink_snapshot_id_decrement - Decrease number of snapshots using an id
5116 * @devlink: devlink instance
5117 * @id: the snapshot id
5119 * Track when a snapshot is deleted and stops using an id. Load the count
5120 * for the given id from the snapshot xarray, decrement it, and store it
5123 * If the count reaches zero, erase this id from the xarray, freeing it
5124 * up for future re-use by devlink_region_snapshot_id_get().
5126 * Called when a snapshot using the given id is deleted, and when the
5127 * initial allocator of the id is finished using it.
5129 static void __devlink_snapshot_id_decrement(struct devlink *devlink, u32 id)
5131 unsigned long count;
5134 lockdep_assert_held(&devlink->lock);
5136 p = xa_load(&devlink->snapshot_ids, id);
5140 if (WARN_ON(!xa_is_value(p)))
5143 count = xa_to_value(p);
5147 xa_store(&devlink->snapshot_ids, id, xa_mk_value(count),
5150 /* If this was the last user, we can erase this id */
5151 xa_erase(&devlink->snapshot_ids, id);
5156 * __devlink_snapshot_id_insert - Insert a specific snapshot ID
5157 * @devlink: devlink instance
5158 * @id: the snapshot id
5160 * Mark the given snapshot id as used by inserting a zero value into the
5163 * This must be called while holding the devlink instance lock. Unlike
5164 * devlink_snapshot_id_get, the initial reference count is zero, not one.
5165 * It is expected that the id will immediately be used before
5166 * releasing the devlink instance lock.
5168 * Returns zero on success, or an error code if the snapshot id could not
5171 static int __devlink_snapshot_id_insert(struct devlink *devlink, u32 id)
5173 lockdep_assert_held(&devlink->lock);
5175 if (xa_load(&devlink->snapshot_ids, id))
5178 return xa_err(xa_store(&devlink->snapshot_ids, id, xa_mk_value(0),
5183 * __devlink_region_snapshot_id_get - get snapshot ID
5184 * @devlink: devlink instance
5185 * @id: storage to return snapshot id
5187 * Allocates a new snapshot id. Returns zero on success, or a negative
5188 * error on failure. Must be called while holding the devlink instance
5191 * Snapshot IDs are tracked using an xarray which stores the number of
5192 * users of the snapshot id.
5194 * Note that the caller of this function counts as a 'user', in order to
5195 * avoid race conditions. The caller must release its hold on the
5196 * snapshot by using devlink_region_snapshot_id_put.
5198 static int __devlink_region_snapshot_id_get(struct devlink *devlink, u32 *id)
5200 lockdep_assert_held(&devlink->lock);
5202 return xa_alloc(&devlink->snapshot_ids, id, xa_mk_value(1),
5203 xa_limit_32b, GFP_KERNEL);
5207 * __devlink_region_snapshot_create - create a new snapshot
5208 * This will add a new snapshot of a region. The snapshot
5209 * will be stored on the region struct and can be accessed
5210 * from devlink. This is useful for future analyses of snapshots.
5211 * Multiple snapshots can be created on a region.
5212 * The @snapshot_id should be obtained using the getter function.
5214 * Must be called only while holding the devlink instance lock.
5216 * @region: devlink region of the snapshot
5217 * @data: snapshot data
5218 * @snapshot_id: snapshot id to be created
5221 __devlink_region_snapshot_create(struct devlink_region *region,
5222 u8 *data, u32 snapshot_id)
5224 struct devlink *devlink = region->devlink;
5225 struct devlink_snapshot *snapshot;
5228 lockdep_assert_held(&devlink->lock);
5230 /* check if region can hold one more snapshot */
5231 if (region->cur_snapshots == region->max_snapshots)
5234 if (devlink_region_snapshot_get_by_id(region, snapshot_id))
5237 snapshot = kzalloc(sizeof(*snapshot), GFP_KERNEL);
5241 err = __devlink_snapshot_id_increment(devlink, snapshot_id);
5243 goto err_snapshot_id_increment;
5245 snapshot->id = snapshot_id;
5246 snapshot->region = region;
5247 snapshot->data = data;
5249 list_add_tail(&snapshot->list, ®ion->snapshot_list);
5251 region->cur_snapshots++;
5253 devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_NEW);
5256 err_snapshot_id_increment:
5261 static void devlink_region_snapshot_del(struct devlink_region *region,
5262 struct devlink_snapshot *snapshot)
5264 struct devlink *devlink = region->devlink;
5266 lockdep_assert_held(&devlink->lock);
5268 devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_DEL);
5269 region->cur_snapshots--;
5270 list_del(&snapshot->list);
5271 region->ops->destructor(snapshot->data);
5272 __devlink_snapshot_id_decrement(devlink, snapshot->id);
5276 static int devlink_nl_cmd_region_get_doit(struct sk_buff *skb,
5277 struct genl_info *info)
5279 struct devlink *devlink = info->user_ptr[0];
5280 struct devlink_port *port = NULL;
5281 struct devlink_region *region;
5282 const char *region_name;
5283 struct sk_buff *msg;
5287 if (!info->attrs[DEVLINK_ATTR_REGION_NAME])
5290 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5291 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5293 port = devlink_port_get_by_index(devlink, index);
5298 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5300 region = devlink_port_region_get_by_name(port, region_name);
5302 region = devlink_region_get_by_name(devlink, region_name);
5307 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5311 err = devlink_nl_region_fill(msg, devlink, DEVLINK_CMD_REGION_GET,
5312 info->snd_portid, info->snd_seq, 0,
5319 return genlmsg_reply(msg, info);
5322 static int devlink_nl_cmd_region_get_port_dumpit(struct sk_buff *msg,
5323 struct netlink_callback *cb,
5324 struct devlink_port *port,
5328 struct devlink_region *region;
5331 list_for_each_entry(region, &port->region_list, list) {
5336 err = devlink_nl_region_fill(msg, port->devlink,
5337 DEVLINK_CMD_REGION_GET,
5338 NETLINK_CB(cb->skb).portid,
5340 NLM_F_MULTI, region);
5350 static int devlink_nl_cmd_region_get_devlink_dumpit(struct sk_buff *msg,
5351 struct netlink_callback *cb,
5352 struct devlink *devlink,
5356 struct devlink_region *region;
5357 struct devlink_port *port;
5360 mutex_lock(&devlink->lock);
5361 list_for_each_entry(region, &devlink->region_list, list) {
5366 err = devlink_nl_region_fill(msg, devlink,
5367 DEVLINK_CMD_REGION_GET,
5368 NETLINK_CB(cb->skb).portid,
5370 NLM_F_MULTI, region);
5376 list_for_each_entry(port, &devlink->port_list, list) {
5377 err = devlink_nl_cmd_region_get_port_dumpit(msg, cb, port, idx,
5384 mutex_unlock(&devlink->lock);
5388 static int devlink_nl_cmd_region_get_dumpit(struct sk_buff *msg,
5389 struct netlink_callback *cb)
5391 struct devlink *devlink;
5392 int start = cb->args[0];
5396 mutex_lock(&devlink_mutex);
5397 list_for_each_entry(devlink, &devlink_list, list) {
5398 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5400 err = devlink_nl_cmd_region_get_devlink_dumpit(msg, cb, devlink,
5406 mutex_unlock(&devlink_mutex);
5411 static int devlink_nl_cmd_region_del(struct sk_buff *skb,
5412 struct genl_info *info)
5414 struct devlink *devlink = info->user_ptr[0];
5415 struct devlink_snapshot *snapshot;
5416 struct devlink_port *port = NULL;
5417 struct devlink_region *region;
5418 const char *region_name;
5422 if (!info->attrs[DEVLINK_ATTR_REGION_NAME] ||
5423 !info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID])
5426 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5427 snapshot_id = nla_get_u32(info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
5429 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5430 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5432 port = devlink_port_get_by_index(devlink, index);
5438 region = devlink_port_region_get_by_name(port, region_name);
5440 region = devlink_region_get_by_name(devlink, region_name);
5445 snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
5449 devlink_region_snapshot_del(region, snapshot);
5454 devlink_nl_cmd_region_new(struct sk_buff *skb, struct genl_info *info)
5456 struct devlink *devlink = info->user_ptr[0];
5457 struct devlink_snapshot *snapshot;
5458 struct devlink_port *port = NULL;
5459 struct nlattr *snapshot_id_attr;
5460 struct devlink_region *region;
5461 const char *region_name;
5467 if (!info->attrs[DEVLINK_ATTR_REGION_NAME]) {
5468 NL_SET_ERR_MSG_MOD(info->extack, "No region name provided");
5472 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5474 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5475 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5477 port = devlink_port_get_by_index(devlink, index);
5483 region = devlink_port_region_get_by_name(port, region_name);
5485 region = devlink_region_get_by_name(devlink, region_name);
5488 NL_SET_ERR_MSG_MOD(info->extack, "The requested region does not exist");
5492 if (!region->ops->snapshot) {
5493 NL_SET_ERR_MSG_MOD(info->extack, "The requested region does not support taking an immediate snapshot");
5497 if (region->cur_snapshots == region->max_snapshots) {
5498 NL_SET_ERR_MSG_MOD(info->extack, "The region has reached the maximum number of stored snapshots");
5502 snapshot_id_attr = info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID];
5503 if (snapshot_id_attr) {
5504 snapshot_id = nla_get_u32(snapshot_id_attr);
5506 if (devlink_region_snapshot_get_by_id(region, snapshot_id)) {
5507 NL_SET_ERR_MSG_MOD(info->extack, "The requested snapshot id is already in use");
5511 err = __devlink_snapshot_id_insert(devlink, snapshot_id);
5515 err = __devlink_region_snapshot_id_get(devlink, &snapshot_id);
5517 NL_SET_ERR_MSG_MOD(info->extack, "Failed to allocate a new snapshot id");
5523 err = region->port_ops->snapshot(port, region->port_ops,
5524 info->extack, &data);
5526 err = region->ops->snapshot(devlink, region->ops,
5527 info->extack, &data);
5529 goto err_snapshot_capture;
5531 err = __devlink_region_snapshot_create(region, data, snapshot_id);
5533 goto err_snapshot_create;
5535 if (!snapshot_id_attr) {
5536 struct sk_buff *msg;
5538 snapshot = devlink_region_snapshot_get_by_id(region,
5540 if (WARN_ON(!snapshot))
5543 msg = devlink_nl_region_notify_build(region, snapshot,
5544 DEVLINK_CMD_REGION_NEW,
5547 err = PTR_ERR_OR_ZERO(msg);
5551 err = genlmsg_reply(msg, info);
5558 err_snapshot_create:
5559 region->ops->destructor(data);
5560 err_snapshot_capture:
5561 __devlink_snapshot_id_decrement(devlink, snapshot_id);
5565 devlink_region_snapshot_del(region, snapshot);
5569 static int devlink_nl_cmd_region_read_chunk_fill(struct sk_buff *msg,
5570 struct devlink *devlink,
5571 u8 *chunk, u32 chunk_size,
5574 struct nlattr *chunk_attr;
5577 chunk_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_CHUNK);
5581 err = nla_put(msg, DEVLINK_ATTR_REGION_CHUNK_DATA, chunk_size, chunk);
5583 goto nla_put_failure;
5585 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_CHUNK_ADDR, addr,
5588 goto nla_put_failure;
5590 nla_nest_end(msg, chunk_attr);
5594 nla_nest_cancel(msg, chunk_attr);
5598 #define DEVLINK_REGION_READ_CHUNK_SIZE 256
5600 static int devlink_nl_region_read_snapshot_fill(struct sk_buff *skb,
5601 struct devlink *devlink,
5602 struct devlink_region *region,
5603 struct nlattr **attrs,
5608 struct devlink_snapshot *snapshot;
5609 u64 curr_offset = start_offset;
5613 *new_offset = start_offset;
5615 snapshot_id = nla_get_u32(attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
5616 snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
5620 while (curr_offset < end_offset) {
5624 if (end_offset - curr_offset < DEVLINK_REGION_READ_CHUNK_SIZE)
5625 data_size = end_offset - curr_offset;
5627 data_size = DEVLINK_REGION_READ_CHUNK_SIZE;
5629 data = &snapshot->data[curr_offset];
5630 err = devlink_nl_cmd_region_read_chunk_fill(skb, devlink,
5636 curr_offset += data_size;
5638 *new_offset = curr_offset;
5643 static int devlink_nl_cmd_region_read_dumpit(struct sk_buff *skb,
5644 struct netlink_callback *cb)
5646 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
5647 u64 ret_offset, start_offset, end_offset = U64_MAX;
5648 struct nlattr **attrs = info->attrs;
5649 struct devlink_port *port = NULL;
5650 struct devlink_region *region;
5651 struct nlattr *chunks_attr;
5652 const char *region_name;
5653 struct devlink *devlink;
5658 start_offset = *((u64 *)&cb->args[0]);
5660 mutex_lock(&devlink_mutex);
5661 devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
5662 if (IS_ERR(devlink)) {
5663 err = PTR_ERR(devlink);
5667 mutex_lock(&devlink->lock);
5669 if (!attrs[DEVLINK_ATTR_REGION_NAME] ||
5670 !attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]) {
5675 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5676 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5678 port = devlink_port_get_by_index(devlink, index);
5685 region_name = nla_data(attrs[DEVLINK_ATTR_REGION_NAME]);
5688 region = devlink_port_region_get_by_name(port, region_name);
5690 region = devlink_region_get_by_name(devlink, region_name);
5697 if (attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR] &&
5698 attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]) {
5701 nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
5703 end_offset = nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
5704 end_offset += nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]);
5707 if (end_offset > region->size)
5708 end_offset = region->size;
5710 /* return 0 if there is no further data to read */
5711 if (start_offset == end_offset) {
5716 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
5717 &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI,
5718 DEVLINK_CMD_REGION_READ);
5724 err = devlink_nl_put_handle(skb, devlink);
5726 goto nla_put_failure;
5729 err = nla_put_u32(skb, DEVLINK_ATTR_PORT_INDEX,
5730 region->port->index);
5732 goto nla_put_failure;
5735 err = nla_put_string(skb, DEVLINK_ATTR_REGION_NAME, region_name);
5737 goto nla_put_failure;
5739 chunks_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_REGION_CHUNKS);
5742 goto nla_put_failure;
5745 err = devlink_nl_region_read_snapshot_fill(skb, devlink,
5748 end_offset, &ret_offset);
5750 if (err && err != -EMSGSIZE)
5751 goto nla_put_failure;
5753 /* Check if there was any progress done to prevent infinite loop */
5754 if (ret_offset == start_offset) {
5756 goto nla_put_failure;
5759 *((u64 *)&cb->args[0]) = ret_offset;
5761 nla_nest_end(skb, chunks_attr);
5762 genlmsg_end(skb, hdr);
5763 mutex_unlock(&devlink->lock);
5764 mutex_unlock(&devlink_mutex);
5769 genlmsg_cancel(skb, hdr);
5771 mutex_unlock(&devlink->lock);
5773 mutex_unlock(&devlink_mutex);
5777 struct devlink_info_req {
5778 struct sk_buff *msg;
5781 int devlink_info_driver_name_put(struct devlink_info_req *req, const char *name)
5783 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME, name);
5785 EXPORT_SYMBOL_GPL(devlink_info_driver_name_put);
5787 int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn)
5789 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn);
5791 EXPORT_SYMBOL_GPL(devlink_info_serial_number_put);
5793 int devlink_info_board_serial_number_put(struct devlink_info_req *req,
5796 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER,
5799 EXPORT_SYMBOL_GPL(devlink_info_board_serial_number_put);
5801 static int devlink_info_version_put(struct devlink_info_req *req, int attr,
5802 const char *version_name,
5803 const char *version_value)
5805 struct nlattr *nest;
5808 nest = nla_nest_start_noflag(req->msg, attr);
5812 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME,
5815 goto nla_put_failure;
5817 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE,
5820 goto nla_put_failure;
5822 nla_nest_end(req->msg, nest);
5827 nla_nest_cancel(req->msg, nest);
5831 int devlink_info_version_fixed_put(struct devlink_info_req *req,
5832 const char *version_name,
5833 const char *version_value)
5835 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED,
5836 version_name, version_value);
5838 EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put);
5840 int devlink_info_version_stored_put(struct devlink_info_req *req,
5841 const char *version_name,
5842 const char *version_value)
5844 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED,
5845 version_name, version_value);
5847 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put);
5849 int devlink_info_version_running_put(struct devlink_info_req *req,
5850 const char *version_name,
5851 const char *version_value)
5853 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING,
5854 version_name, version_value);
5856 EXPORT_SYMBOL_GPL(devlink_info_version_running_put);
5859 devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink,
5860 enum devlink_command cmd, u32 portid,
5861 u32 seq, int flags, struct netlink_ext_ack *extack)
5863 struct devlink_info_req req;
5867 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
5872 if (devlink_nl_put_handle(msg, devlink))
5873 goto err_cancel_msg;
5876 err = devlink->ops->info_get(devlink, &req, extack);
5878 goto err_cancel_msg;
5880 genlmsg_end(msg, hdr);
5884 genlmsg_cancel(msg, hdr);
5888 static int devlink_nl_cmd_info_get_doit(struct sk_buff *skb,
5889 struct genl_info *info)
5891 struct devlink *devlink = info->user_ptr[0];
5892 struct sk_buff *msg;
5895 if (!devlink->ops->info_get)
5898 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5902 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
5903 info->snd_portid, info->snd_seq, 0,
5910 return genlmsg_reply(msg, info);
5913 static int devlink_nl_cmd_info_get_dumpit(struct sk_buff *msg,
5914 struct netlink_callback *cb)
5916 struct devlink *devlink;
5917 int start = cb->args[0];
5921 mutex_lock(&devlink_mutex);
5922 list_for_each_entry(devlink, &devlink_list, list) {
5923 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5930 if (!devlink->ops->info_get) {
5935 mutex_lock(&devlink->lock);
5936 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
5937 NETLINK_CB(cb->skb).portid,
5938 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5940 mutex_unlock(&devlink->lock);
5941 if (err == -EOPNOTSUPP)
5947 mutex_unlock(&devlink_mutex);
5949 if (err != -EMSGSIZE)
5956 struct devlink_fmsg_item {
5957 struct list_head list;
5964 struct devlink_fmsg {
5965 struct list_head item_list;
5966 bool putting_binary; /* This flag forces enclosing of binary data
5967 * in an array brackets. It forces using
5968 * of designated API:
5969 * devlink_fmsg_binary_pair_nest_start()
5970 * devlink_fmsg_binary_pair_nest_end()
5974 static struct devlink_fmsg *devlink_fmsg_alloc(void)
5976 struct devlink_fmsg *fmsg;
5978 fmsg = kzalloc(sizeof(*fmsg), GFP_KERNEL);
5982 INIT_LIST_HEAD(&fmsg->item_list);
5987 static void devlink_fmsg_free(struct devlink_fmsg *fmsg)
5989 struct devlink_fmsg_item *item, *tmp;
5991 list_for_each_entry_safe(item, tmp, &fmsg->item_list, list) {
5992 list_del(&item->list);
5998 static int devlink_fmsg_nest_common(struct devlink_fmsg *fmsg,
6001 struct devlink_fmsg_item *item;
6003 item = kzalloc(sizeof(*item), GFP_KERNEL);
6007 item->attrtype = attrtype;
6008 list_add_tail(&item->list, &fmsg->item_list);
6013 int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
6015 if (fmsg->putting_binary)
6018 return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
6020 EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_start);
6022 static int devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
6024 if (fmsg->putting_binary)
6027 return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
6030 int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
6032 if (fmsg->putting_binary)
6035 return devlink_fmsg_nest_end(fmsg);
6037 EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_end);
6039 #define DEVLINK_FMSG_MAX_SIZE (GENLMSG_DEFAULT_SIZE - GENL_HDRLEN - NLA_HDRLEN)
6041 static int devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
6043 struct devlink_fmsg_item *item;
6045 if (fmsg->putting_binary)
6048 if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE)
6051 item = kzalloc(sizeof(*item) + strlen(name) + 1, GFP_KERNEL);
6055 item->nla_type = NLA_NUL_STRING;
6056 item->len = strlen(name) + 1;
6057 item->attrtype = DEVLINK_ATTR_FMSG_OBJ_NAME;
6058 memcpy(&item->value, name, item->len);
6059 list_add_tail(&item->list, &fmsg->item_list);
6064 int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
6068 if (fmsg->putting_binary)
6071 err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
6075 err = devlink_fmsg_put_name(fmsg, name);
6081 EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_start);
6083 int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
6085 if (fmsg->putting_binary)
6088 return devlink_fmsg_nest_end(fmsg);
6090 EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_end);
6092 int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
6097 if (fmsg->putting_binary)
6100 err = devlink_fmsg_pair_nest_start(fmsg, name);
6104 err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
6110 EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_start);
6112 int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
6116 if (fmsg->putting_binary)
6119 err = devlink_fmsg_nest_end(fmsg);
6123 err = devlink_fmsg_nest_end(fmsg);
6129 EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_end);
6131 int devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
6136 err = devlink_fmsg_arr_pair_nest_start(fmsg, name);
6140 fmsg->putting_binary = true;
6143 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_start);
6145 int devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg)
6147 if (!fmsg->putting_binary)
6150 fmsg->putting_binary = false;
6151 return devlink_fmsg_arr_pair_nest_end(fmsg);
6153 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_end);
6155 static int devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
6156 const void *value, u16 value_len,
6159 struct devlink_fmsg_item *item;
6161 if (value_len > DEVLINK_FMSG_MAX_SIZE)
6164 item = kzalloc(sizeof(*item) + value_len, GFP_KERNEL);
6168 item->nla_type = value_nla_type;
6169 item->len = value_len;
6170 item->attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
6171 memcpy(&item->value, value, item->len);
6172 list_add_tail(&item->list, &fmsg->item_list);
6177 int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
6179 if (fmsg->putting_binary)
6182 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
6184 EXPORT_SYMBOL_GPL(devlink_fmsg_bool_put);
6186 int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
6188 if (fmsg->putting_binary)
6191 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
6193 EXPORT_SYMBOL_GPL(devlink_fmsg_u8_put);
6195 int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
6197 if (fmsg->putting_binary)
6200 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
6202 EXPORT_SYMBOL_GPL(devlink_fmsg_u32_put);
6204 int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
6206 if (fmsg->putting_binary)
6209 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
6211 EXPORT_SYMBOL_GPL(devlink_fmsg_u64_put);
6213 int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
6215 if (fmsg->putting_binary)
6218 return devlink_fmsg_put_value(fmsg, value, strlen(value) + 1,
6221 EXPORT_SYMBOL_GPL(devlink_fmsg_string_put);
6223 int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
6226 if (!fmsg->putting_binary)
6229 return devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
6231 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_put);
6233 int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
6238 err = devlink_fmsg_pair_nest_start(fmsg, name);
6242 err = devlink_fmsg_bool_put(fmsg, value);
6246 err = devlink_fmsg_pair_nest_end(fmsg);
6252 EXPORT_SYMBOL_GPL(devlink_fmsg_bool_pair_put);
6254 int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
6259 err = devlink_fmsg_pair_nest_start(fmsg, name);
6263 err = devlink_fmsg_u8_put(fmsg, value);
6267 err = devlink_fmsg_pair_nest_end(fmsg);
6273 EXPORT_SYMBOL_GPL(devlink_fmsg_u8_pair_put);
6275 int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
6280 err = devlink_fmsg_pair_nest_start(fmsg, name);
6284 err = devlink_fmsg_u32_put(fmsg, value);
6288 err = devlink_fmsg_pair_nest_end(fmsg);
6294 EXPORT_SYMBOL_GPL(devlink_fmsg_u32_pair_put);
6296 int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
6301 err = devlink_fmsg_pair_nest_start(fmsg, name);
6305 err = devlink_fmsg_u64_put(fmsg, value);
6309 err = devlink_fmsg_pair_nest_end(fmsg);
6315 EXPORT_SYMBOL_GPL(devlink_fmsg_u64_pair_put);
6317 int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
6322 err = devlink_fmsg_pair_nest_start(fmsg, name);
6326 err = devlink_fmsg_string_put(fmsg, value);
6330 err = devlink_fmsg_pair_nest_end(fmsg);
6336 EXPORT_SYMBOL_GPL(devlink_fmsg_string_pair_put);
6338 int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
6339 const void *value, u32 value_len)
6346 err = devlink_fmsg_binary_pair_nest_start(fmsg, name);
6350 for (offset = 0; offset < value_len; offset += data_size) {
6351 data_size = value_len - offset;
6352 if (data_size > DEVLINK_FMSG_MAX_SIZE)
6353 data_size = DEVLINK_FMSG_MAX_SIZE;
6354 err = devlink_fmsg_binary_put(fmsg, value + offset, data_size);
6357 /* Exit from loop with a break (instead of
6358 * return) to make sure putting_binary is turned off in
6359 * devlink_fmsg_binary_pair_nest_end
6363 end_err = devlink_fmsg_binary_pair_nest_end(fmsg);
6369 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_put);
6372 devlink_fmsg_item_fill_type(struct devlink_fmsg_item *msg, struct sk_buff *skb)
6374 switch (msg->nla_type) {
6379 case NLA_NUL_STRING:
6381 return nla_put_u8(skb, DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE,
6389 devlink_fmsg_item_fill_data(struct devlink_fmsg_item *msg, struct sk_buff *skb)
6391 int attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
6394 switch (msg->nla_type) {
6396 /* Always provide flag data, regardless of its value */
6397 tmp = *(bool *) msg->value;
6399 return nla_put_u8(skb, attrtype, tmp);
6401 return nla_put_u8(skb, attrtype, *(u8 *) msg->value);
6403 return nla_put_u32(skb, attrtype, *(u32 *) msg->value);
6405 return nla_put_u64_64bit(skb, attrtype, *(u64 *) msg->value,
6407 case NLA_NUL_STRING:
6408 return nla_put_string(skb, attrtype, (char *) &msg->value);
6410 return nla_put(skb, attrtype, msg->len, (void *) &msg->value);
6417 devlink_fmsg_prepare_skb(struct devlink_fmsg *fmsg, struct sk_buff *skb,
6420 struct devlink_fmsg_item *item;
6421 struct nlattr *fmsg_nlattr;
6425 fmsg_nlattr = nla_nest_start_noflag(skb, DEVLINK_ATTR_FMSG);
6429 list_for_each_entry(item, &fmsg->item_list, list) {
6435 switch (item->attrtype) {
6436 case DEVLINK_ATTR_FMSG_OBJ_NEST_START:
6437 case DEVLINK_ATTR_FMSG_PAIR_NEST_START:
6438 case DEVLINK_ATTR_FMSG_ARR_NEST_START:
6439 case DEVLINK_ATTR_FMSG_NEST_END:
6440 err = nla_put_flag(skb, item->attrtype);
6442 case DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA:
6443 err = devlink_fmsg_item_fill_type(item, skb);
6446 err = devlink_fmsg_item_fill_data(item, skb);
6448 case DEVLINK_ATTR_FMSG_OBJ_NAME:
6449 err = nla_put_string(skb, item->attrtype,
6450 (char *) &item->value);
6462 nla_nest_end(skb, fmsg_nlattr);
6466 static int devlink_fmsg_snd(struct devlink_fmsg *fmsg,
6467 struct genl_info *info,
6468 enum devlink_command cmd, int flags)
6470 struct nlmsghdr *nlh;
6471 struct sk_buff *skb;
6478 int tmp_index = index;
6480 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
6484 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
6485 &devlink_nl_family, flags | NLM_F_MULTI, cmd);
6488 goto nla_put_failure;
6491 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
6494 else if (err != -EMSGSIZE || tmp_index == index)
6495 goto nla_put_failure;
6497 genlmsg_end(skb, hdr);
6498 err = genlmsg_reply(skb, info);
6503 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
6506 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
6507 NLMSG_DONE, 0, flags | NLM_F_MULTI);
6510 goto nla_put_failure;
6513 return genlmsg_reply(skb, info);
6520 static int devlink_fmsg_dumpit(struct devlink_fmsg *fmsg, struct sk_buff *skb,
6521 struct netlink_callback *cb,
6522 enum devlink_command cmd)
6524 int index = cb->args[0];
6525 int tmp_index = index;
6529 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
6530 &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI, cmd);
6533 goto nla_put_failure;
6536 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
6537 if ((err && err != -EMSGSIZE) || tmp_index == index)
6538 goto nla_put_failure;
6540 cb->args[0] = index;
6541 genlmsg_end(skb, hdr);
6545 genlmsg_cancel(skb, hdr);
6549 struct devlink_health_reporter {
6550 struct list_head list;
6552 const struct devlink_health_reporter_ops *ops;
6553 struct devlink *devlink;
6554 struct devlink_port *devlink_port;
6555 struct devlink_fmsg *dump_fmsg;
6556 struct mutex dump_lock; /* lock parallel read/write from dump buffers */
6557 u64 graceful_period;
6565 u64 last_recovery_ts;
6566 refcount_t refcount;
6570 devlink_health_reporter_priv(struct devlink_health_reporter *reporter)
6572 return reporter->priv;
6574 EXPORT_SYMBOL_GPL(devlink_health_reporter_priv);
6576 static struct devlink_health_reporter *
6577 __devlink_health_reporter_find_by_name(struct list_head *reporter_list,
6578 struct mutex *list_lock,
6579 const char *reporter_name)
6581 struct devlink_health_reporter *reporter;
6583 lockdep_assert_held(list_lock);
6584 list_for_each_entry(reporter, reporter_list, list)
6585 if (!strcmp(reporter->ops->name, reporter_name))
6590 static struct devlink_health_reporter *
6591 devlink_health_reporter_find_by_name(struct devlink *devlink,
6592 const char *reporter_name)
6594 return __devlink_health_reporter_find_by_name(&devlink->reporter_list,
6595 &devlink->reporters_lock,
6599 static struct devlink_health_reporter *
6600 devlink_port_health_reporter_find_by_name(struct devlink_port *devlink_port,
6601 const char *reporter_name)
6603 return __devlink_health_reporter_find_by_name(&devlink_port->reporter_list,
6604 &devlink_port->reporters_lock,
6608 static struct devlink_health_reporter *
6609 __devlink_health_reporter_create(struct devlink *devlink,
6610 const struct devlink_health_reporter_ops *ops,
6611 u64 graceful_period, void *priv)
6613 struct devlink_health_reporter *reporter;
6615 if (WARN_ON(graceful_period && !ops->recover))
6616 return ERR_PTR(-EINVAL);
6618 reporter = kzalloc(sizeof(*reporter), GFP_KERNEL);
6620 return ERR_PTR(-ENOMEM);
6622 reporter->priv = priv;
6623 reporter->ops = ops;
6624 reporter->devlink = devlink;
6625 reporter->graceful_period = graceful_period;
6626 reporter->auto_recover = !!ops->recover;
6627 reporter->auto_dump = !!ops->dump;
6628 mutex_init(&reporter->dump_lock);
6629 refcount_set(&reporter->refcount, 1);
6634 * devlink_port_health_reporter_create - create devlink health reporter for
6635 * specified port instance
6637 * @port: devlink_port which should contain the new reporter
6639 * @graceful_period: to avoid recovery loops, in msecs
6642 struct devlink_health_reporter *
6643 devlink_port_health_reporter_create(struct devlink_port *port,
6644 const struct devlink_health_reporter_ops *ops,
6645 u64 graceful_period, void *priv)
6647 struct devlink_health_reporter *reporter;
6649 mutex_lock(&port->reporters_lock);
6650 if (__devlink_health_reporter_find_by_name(&port->reporter_list,
6651 &port->reporters_lock, ops->name)) {
6652 reporter = ERR_PTR(-EEXIST);
6656 reporter = __devlink_health_reporter_create(port->devlink, ops,
6657 graceful_period, priv);
6658 if (IS_ERR(reporter))
6661 reporter->devlink_port = port;
6662 list_add_tail(&reporter->list, &port->reporter_list);
6664 mutex_unlock(&port->reporters_lock);
6667 EXPORT_SYMBOL_GPL(devlink_port_health_reporter_create);
6670 * devlink_health_reporter_create - create devlink health reporter
6674 * @graceful_period: to avoid recovery loops, in msecs
6677 struct devlink_health_reporter *
6678 devlink_health_reporter_create(struct devlink *devlink,
6679 const struct devlink_health_reporter_ops *ops,
6680 u64 graceful_period, void *priv)
6682 struct devlink_health_reporter *reporter;
6684 mutex_lock(&devlink->reporters_lock);
6685 if (devlink_health_reporter_find_by_name(devlink, ops->name)) {
6686 reporter = ERR_PTR(-EEXIST);
6690 reporter = __devlink_health_reporter_create(devlink, ops,
6691 graceful_period, priv);
6692 if (IS_ERR(reporter))
6695 list_add_tail(&reporter->list, &devlink->reporter_list);
6697 mutex_unlock(&devlink->reporters_lock);
6700 EXPORT_SYMBOL_GPL(devlink_health_reporter_create);
6703 devlink_health_reporter_free(struct devlink_health_reporter *reporter)
6705 mutex_destroy(&reporter->dump_lock);
6706 if (reporter->dump_fmsg)
6707 devlink_fmsg_free(reporter->dump_fmsg);
6712 devlink_health_reporter_put(struct devlink_health_reporter *reporter)
6714 if (refcount_dec_and_test(&reporter->refcount))
6715 devlink_health_reporter_free(reporter);
6719 __devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
6721 list_del(&reporter->list);
6722 devlink_health_reporter_put(reporter);
6726 * devlink_health_reporter_destroy - destroy devlink health reporter
6728 * @reporter: devlink health reporter to destroy
6731 devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
6733 struct mutex *lock = &reporter->devlink->reporters_lock;
6736 __devlink_health_reporter_destroy(reporter);
6739 EXPORT_SYMBOL_GPL(devlink_health_reporter_destroy);
6742 * devlink_port_health_reporter_destroy - destroy devlink port health reporter
6744 * @reporter: devlink health reporter to destroy
6747 devlink_port_health_reporter_destroy(struct devlink_health_reporter *reporter)
6749 struct mutex *lock = &reporter->devlink_port->reporters_lock;
6752 __devlink_health_reporter_destroy(reporter);
6755 EXPORT_SYMBOL_GPL(devlink_port_health_reporter_destroy);
6758 devlink_nl_health_reporter_fill(struct sk_buff *msg,
6759 struct devlink *devlink,
6760 struct devlink_health_reporter *reporter,
6761 enum devlink_command cmd, u32 portid,
6764 struct nlattr *reporter_attr;
6767 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
6771 if (devlink_nl_put_handle(msg, devlink))
6772 goto genlmsg_cancel;
6774 if (reporter->devlink_port) {
6775 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, reporter->devlink_port->index))
6776 goto genlmsg_cancel;
6778 reporter_attr = nla_nest_start_noflag(msg,
6779 DEVLINK_ATTR_HEALTH_REPORTER);
6781 goto genlmsg_cancel;
6782 if (nla_put_string(msg, DEVLINK_ATTR_HEALTH_REPORTER_NAME,
6783 reporter->ops->name))
6784 goto reporter_nest_cancel;
6785 if (nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_STATE,
6786 reporter->health_state))
6787 goto reporter_nest_cancel;
6788 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT,
6789 reporter->error_count, DEVLINK_ATTR_PAD))
6790 goto reporter_nest_cancel;
6791 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT,
6792 reporter->recovery_count, DEVLINK_ATTR_PAD))
6793 goto reporter_nest_cancel;
6794 if (reporter->ops->recover &&
6795 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD,
6796 reporter->graceful_period,
6798 goto reporter_nest_cancel;
6799 if (reporter->ops->recover &&
6800 nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER,
6801 reporter->auto_recover))
6802 goto reporter_nest_cancel;
6803 if (reporter->dump_fmsg &&
6804 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS,
6805 jiffies_to_msecs(reporter->dump_ts),
6807 goto reporter_nest_cancel;
6808 if (reporter->dump_fmsg &&
6809 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS,
6810 reporter->dump_real_ts, DEVLINK_ATTR_PAD))
6811 goto reporter_nest_cancel;
6812 if (reporter->ops->dump &&
6813 nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP,
6814 reporter->auto_dump))
6815 goto reporter_nest_cancel;
6817 nla_nest_end(msg, reporter_attr);
6818 genlmsg_end(msg, hdr);
6821 reporter_nest_cancel:
6822 nla_nest_end(msg, reporter_attr);
6824 genlmsg_cancel(msg, hdr);
6828 static void devlink_recover_notify(struct devlink_health_reporter *reporter,
6829 enum devlink_command cmd)
6831 struct sk_buff *msg;
6834 WARN_ON(cmd != DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
6836 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6840 err = devlink_nl_health_reporter_fill(msg, reporter->devlink,
6841 reporter, cmd, 0, 0, 0);
6847 genlmsg_multicast_netns(&devlink_nl_family,
6848 devlink_net(reporter->devlink),
6849 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
6853 devlink_health_reporter_recovery_done(struct devlink_health_reporter *reporter)
6855 reporter->recovery_count++;
6856 reporter->last_recovery_ts = jiffies;
6858 EXPORT_SYMBOL_GPL(devlink_health_reporter_recovery_done);
6861 devlink_health_reporter_recover(struct devlink_health_reporter *reporter,
6862 void *priv_ctx, struct netlink_ext_ack *extack)
6866 if (reporter->health_state == DEVLINK_HEALTH_REPORTER_STATE_HEALTHY)
6869 if (!reporter->ops->recover)
6872 err = reporter->ops->recover(reporter, priv_ctx, extack);
6876 devlink_health_reporter_recovery_done(reporter);
6877 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_HEALTHY;
6878 devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
6884 devlink_health_dump_clear(struct devlink_health_reporter *reporter)
6886 if (!reporter->dump_fmsg)
6888 devlink_fmsg_free(reporter->dump_fmsg);
6889 reporter->dump_fmsg = NULL;
6892 static int devlink_health_do_dump(struct devlink_health_reporter *reporter,
6894 struct netlink_ext_ack *extack)
6898 if (!reporter->ops->dump)
6901 if (reporter->dump_fmsg)
6904 reporter->dump_fmsg = devlink_fmsg_alloc();
6905 if (!reporter->dump_fmsg) {
6910 err = devlink_fmsg_obj_nest_start(reporter->dump_fmsg);
6914 err = reporter->ops->dump(reporter, reporter->dump_fmsg,
6919 err = devlink_fmsg_obj_nest_end(reporter->dump_fmsg);
6923 reporter->dump_ts = jiffies;
6924 reporter->dump_real_ts = ktime_get_real_ns();
6929 devlink_health_dump_clear(reporter);
6933 int devlink_health_report(struct devlink_health_reporter *reporter,
6934 const char *msg, void *priv_ctx)
6936 enum devlink_health_reporter_state prev_health_state;
6937 struct devlink *devlink = reporter->devlink;
6938 unsigned long recover_ts_threshold;
6940 /* write a log message of the current error */
6942 trace_devlink_health_report(devlink, reporter->ops->name, msg);
6943 reporter->error_count++;
6944 prev_health_state = reporter->health_state;
6945 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
6946 devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
6948 /* abort if the previous error wasn't recovered */
6949 recover_ts_threshold = reporter->last_recovery_ts +
6950 msecs_to_jiffies(reporter->graceful_period);
6951 if (reporter->auto_recover &&
6952 (prev_health_state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY ||
6953 (reporter->last_recovery_ts && reporter->recovery_count &&
6954 time_is_after_jiffies(recover_ts_threshold)))) {
6955 trace_devlink_health_recover_aborted(devlink,
6956 reporter->ops->name,
6957 reporter->health_state,
6959 reporter->last_recovery_ts);
6963 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
6965 if (reporter->auto_dump) {
6966 mutex_lock(&reporter->dump_lock);
6967 /* store current dump of current error, for later analysis */
6968 devlink_health_do_dump(reporter, priv_ctx, NULL);
6969 mutex_unlock(&reporter->dump_lock);
6972 if (reporter->auto_recover)
6973 return devlink_health_reporter_recover(reporter,
6978 EXPORT_SYMBOL_GPL(devlink_health_report);
6980 static struct devlink_health_reporter *
6981 devlink_health_reporter_get_from_attrs(struct devlink *devlink,
6982 struct nlattr **attrs)
6984 struct devlink_health_reporter *reporter;
6985 struct devlink_port *devlink_port;
6986 char *reporter_name;
6988 if (!attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME])
6991 reporter_name = nla_data(attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME]);
6992 devlink_port = devlink_port_get_from_attrs(devlink, attrs);
6993 if (IS_ERR(devlink_port)) {
6994 mutex_lock(&devlink->reporters_lock);
6995 reporter = devlink_health_reporter_find_by_name(devlink, reporter_name);
6997 refcount_inc(&reporter->refcount);
6998 mutex_unlock(&devlink->reporters_lock);
7000 mutex_lock(&devlink_port->reporters_lock);
7001 reporter = devlink_port_health_reporter_find_by_name(devlink_port, reporter_name);
7003 refcount_inc(&reporter->refcount);
7004 mutex_unlock(&devlink_port->reporters_lock);
7010 static struct devlink_health_reporter *
7011 devlink_health_reporter_get_from_info(struct devlink *devlink,
7012 struct genl_info *info)
7014 return devlink_health_reporter_get_from_attrs(devlink, info->attrs);
7017 static struct devlink_health_reporter *
7018 devlink_health_reporter_get_from_cb(struct netlink_callback *cb)
7020 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
7021 struct devlink_health_reporter *reporter;
7022 struct nlattr **attrs = info->attrs;
7023 struct devlink *devlink;
7025 mutex_lock(&devlink_mutex);
7026 devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
7027 if (IS_ERR(devlink))
7030 reporter = devlink_health_reporter_get_from_attrs(devlink, attrs);
7031 mutex_unlock(&devlink_mutex);
7034 mutex_unlock(&devlink_mutex);
7039 devlink_health_reporter_state_update(struct devlink_health_reporter *reporter,
7040 enum devlink_health_reporter_state state)
7042 if (WARN_ON(state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY &&
7043 state != DEVLINK_HEALTH_REPORTER_STATE_ERROR))
7046 if (reporter->health_state == state)
7049 reporter->health_state = state;
7050 trace_devlink_health_reporter_state_update(reporter->devlink,
7051 reporter->ops->name, state);
7052 devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
7054 EXPORT_SYMBOL_GPL(devlink_health_reporter_state_update);
7056 static int devlink_nl_cmd_health_reporter_get_doit(struct sk_buff *skb,
7057 struct genl_info *info)
7059 struct devlink *devlink = info->user_ptr[0];
7060 struct devlink_health_reporter *reporter;
7061 struct sk_buff *msg;
7064 reporter = devlink_health_reporter_get_from_info(devlink, info);
7068 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7074 err = devlink_nl_health_reporter_fill(msg, devlink, reporter,
7075 DEVLINK_CMD_HEALTH_REPORTER_GET,
7076 info->snd_portid, info->snd_seq,
7083 err = genlmsg_reply(msg, info);
7085 devlink_health_reporter_put(reporter);
7090 devlink_nl_cmd_health_reporter_get_dumpit(struct sk_buff *msg,
7091 struct netlink_callback *cb)
7093 struct devlink_health_reporter *reporter;
7094 struct devlink_port *port;
7095 struct devlink *devlink;
7096 int start = cb->args[0];
7100 mutex_lock(&devlink_mutex);
7101 list_for_each_entry(devlink, &devlink_list, list) {
7102 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7104 mutex_lock(&devlink->reporters_lock);
7105 list_for_each_entry(reporter, &devlink->reporter_list,
7111 err = devlink_nl_health_reporter_fill(msg, devlink,
7113 DEVLINK_CMD_HEALTH_REPORTER_GET,
7114 NETLINK_CB(cb->skb).portid,
7118 mutex_unlock(&devlink->reporters_lock);
7123 mutex_unlock(&devlink->reporters_lock);
7126 list_for_each_entry(devlink, &devlink_list, list) {
7127 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7129 mutex_lock(&devlink->lock);
7130 list_for_each_entry(port, &devlink->port_list, list) {
7131 mutex_lock(&port->reporters_lock);
7132 list_for_each_entry(reporter, &port->reporter_list, list) {
7137 err = devlink_nl_health_reporter_fill(msg, devlink, reporter,
7138 DEVLINK_CMD_HEALTH_REPORTER_GET,
7139 NETLINK_CB(cb->skb).portid,
7143 mutex_unlock(&port->reporters_lock);
7144 mutex_unlock(&devlink->lock);
7149 mutex_unlock(&port->reporters_lock);
7151 mutex_unlock(&devlink->lock);
7154 mutex_unlock(&devlink_mutex);
7161 devlink_nl_cmd_health_reporter_set_doit(struct sk_buff *skb,
7162 struct genl_info *info)
7164 struct devlink *devlink = info->user_ptr[0];
7165 struct devlink_health_reporter *reporter;
7168 reporter = devlink_health_reporter_get_from_info(devlink, info);
7172 if (!reporter->ops->recover &&
7173 (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] ||
7174 info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])) {
7178 if (!reporter->ops->dump &&
7179 info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP]) {
7184 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD])
7185 reporter->graceful_period =
7186 nla_get_u64(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD]);
7188 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])
7189 reporter->auto_recover =
7190 nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER]);
7192 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP])
7193 reporter->auto_dump =
7194 nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP]);
7196 devlink_health_reporter_put(reporter);
7199 devlink_health_reporter_put(reporter);
7203 static int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
7204 struct genl_info *info)
7206 struct devlink *devlink = info->user_ptr[0];
7207 struct devlink_health_reporter *reporter;
7210 reporter = devlink_health_reporter_get_from_info(devlink, info);
7214 err = devlink_health_reporter_recover(reporter, NULL, info->extack);
7216 devlink_health_reporter_put(reporter);
7220 static int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
7221 struct genl_info *info)
7223 struct devlink *devlink = info->user_ptr[0];
7224 struct devlink_health_reporter *reporter;
7225 struct devlink_fmsg *fmsg;
7228 reporter = devlink_health_reporter_get_from_info(devlink, info);
7232 if (!reporter->ops->diagnose) {
7233 devlink_health_reporter_put(reporter);
7237 fmsg = devlink_fmsg_alloc();
7239 devlink_health_reporter_put(reporter);
7243 err = devlink_fmsg_obj_nest_start(fmsg);
7247 err = reporter->ops->diagnose(reporter, fmsg, info->extack);
7251 err = devlink_fmsg_obj_nest_end(fmsg);
7255 err = devlink_fmsg_snd(fmsg, info,
7256 DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE, 0);
7259 devlink_fmsg_free(fmsg);
7260 devlink_health_reporter_put(reporter);
7265 devlink_nl_cmd_health_reporter_dump_get_dumpit(struct sk_buff *skb,
7266 struct netlink_callback *cb)
7268 struct devlink_health_reporter *reporter;
7269 u64 start = cb->args[0];
7272 reporter = devlink_health_reporter_get_from_cb(cb);
7276 if (!reporter->ops->dump) {
7280 mutex_lock(&reporter->dump_lock);
7282 err = devlink_health_do_dump(reporter, NULL, cb->extack);
7285 cb->args[1] = reporter->dump_ts;
7287 if (!reporter->dump_fmsg || cb->args[1] != reporter->dump_ts) {
7288 NL_SET_ERR_MSG_MOD(cb->extack, "Dump trampled, please retry");
7293 err = devlink_fmsg_dumpit(reporter->dump_fmsg, skb, cb,
7294 DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET);
7296 mutex_unlock(&reporter->dump_lock);
7298 devlink_health_reporter_put(reporter);
7303 devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
7304 struct genl_info *info)
7306 struct devlink *devlink = info->user_ptr[0];
7307 struct devlink_health_reporter *reporter;
7309 reporter = devlink_health_reporter_get_from_info(devlink, info);
7313 if (!reporter->ops->dump) {
7314 devlink_health_reporter_put(reporter);
7318 mutex_lock(&reporter->dump_lock);
7319 devlink_health_dump_clear(reporter);
7320 mutex_unlock(&reporter->dump_lock);
7321 devlink_health_reporter_put(reporter);
7325 static int devlink_nl_cmd_health_reporter_test_doit(struct sk_buff *skb,
7326 struct genl_info *info)
7328 struct devlink *devlink = info->user_ptr[0];
7329 struct devlink_health_reporter *reporter;
7332 reporter = devlink_health_reporter_get_from_info(devlink, info);
7336 if (!reporter->ops->test) {
7337 devlink_health_reporter_put(reporter);
7341 err = reporter->ops->test(reporter, info->extack);
7343 devlink_health_reporter_put(reporter);
7347 struct devlink_stats {
7350 struct u64_stats_sync syncp;
7354 * struct devlink_trap_policer_item - Packet trap policer attributes.
7355 * @policer: Immutable packet trap policer attributes.
7356 * @rate: Rate in packets / sec.
7357 * @burst: Burst size in packets.
7358 * @list: trap_policer_list member.
7360 * Describes packet trap policer attributes. Created by devlink during trap
7361 * policer registration.
7363 struct devlink_trap_policer_item {
7364 const struct devlink_trap_policer *policer;
7367 struct list_head list;
7371 * struct devlink_trap_group_item - Packet trap group attributes.
7372 * @group: Immutable packet trap group attributes.
7373 * @policer_item: Associated policer item. Can be NULL.
7374 * @list: trap_group_list member.
7375 * @stats: Trap group statistics.
7377 * Describes packet trap group attributes. Created by devlink during trap
7378 * group registration.
7380 struct devlink_trap_group_item {
7381 const struct devlink_trap_group *group;
7382 struct devlink_trap_policer_item *policer_item;
7383 struct list_head list;
7384 struct devlink_stats __percpu *stats;
7388 * struct devlink_trap_item - Packet trap attributes.
7389 * @trap: Immutable packet trap attributes.
7390 * @group_item: Associated group item.
7391 * @list: trap_list member.
7392 * @action: Trap action.
7393 * @stats: Trap statistics.
7394 * @priv: Driver private information.
7396 * Describes both mutable and immutable packet trap attributes. Created by
7397 * devlink during trap registration and used for all trap related operations.
7399 struct devlink_trap_item {
7400 const struct devlink_trap *trap;
7401 struct devlink_trap_group_item *group_item;
7402 struct list_head list;
7403 enum devlink_trap_action action;
7404 struct devlink_stats __percpu *stats;
7408 static struct devlink_trap_policer_item *
7409 devlink_trap_policer_item_lookup(struct devlink *devlink, u32 id)
7411 struct devlink_trap_policer_item *policer_item;
7413 list_for_each_entry(policer_item, &devlink->trap_policer_list, list) {
7414 if (policer_item->policer->id == id)
7415 return policer_item;
7421 static struct devlink_trap_item *
7422 devlink_trap_item_lookup(struct devlink *devlink, const char *name)
7424 struct devlink_trap_item *trap_item;
7426 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7427 if (!strcmp(trap_item->trap->name, name))
7434 static struct devlink_trap_item *
7435 devlink_trap_item_get_from_info(struct devlink *devlink,
7436 struct genl_info *info)
7438 struct nlattr *attr;
7440 if (!info->attrs[DEVLINK_ATTR_TRAP_NAME])
7442 attr = info->attrs[DEVLINK_ATTR_TRAP_NAME];
7444 return devlink_trap_item_lookup(devlink, nla_data(attr));
7448 devlink_trap_action_get_from_info(struct genl_info *info,
7449 enum devlink_trap_action *p_trap_action)
7453 val = nla_get_u8(info->attrs[DEVLINK_ATTR_TRAP_ACTION]);
7455 case DEVLINK_TRAP_ACTION_DROP:
7456 case DEVLINK_TRAP_ACTION_TRAP:
7457 case DEVLINK_TRAP_ACTION_MIRROR:
7458 *p_trap_action = val;
7467 static int devlink_trap_metadata_put(struct sk_buff *msg,
7468 const struct devlink_trap *trap)
7470 struct nlattr *attr;
7472 attr = nla_nest_start(msg, DEVLINK_ATTR_TRAP_METADATA);
7476 if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT) &&
7477 nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT))
7478 goto nla_put_failure;
7479 if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE) &&
7480 nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE))
7481 goto nla_put_failure;
7483 nla_nest_end(msg, attr);
7488 nla_nest_cancel(msg, attr);
7492 static void devlink_trap_stats_read(struct devlink_stats __percpu *trap_stats,
7493 struct devlink_stats *stats)
7497 memset(stats, 0, sizeof(*stats));
7498 for_each_possible_cpu(i) {
7499 struct devlink_stats *cpu_stats;
7500 u64 rx_packets, rx_bytes;
7503 cpu_stats = per_cpu_ptr(trap_stats, i);
7505 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
7506 rx_packets = cpu_stats->rx_packets;
7507 rx_bytes = cpu_stats->rx_bytes;
7508 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
7510 stats->rx_packets += rx_packets;
7511 stats->rx_bytes += rx_bytes;
7516 devlink_trap_group_stats_put(struct sk_buff *msg,
7517 struct devlink_stats __percpu *trap_stats)
7519 struct devlink_stats stats;
7520 struct nlattr *attr;
7522 devlink_trap_stats_read(trap_stats, &stats);
7524 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
7528 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
7529 stats.rx_packets, DEVLINK_ATTR_PAD))
7530 goto nla_put_failure;
7532 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
7533 stats.rx_bytes, DEVLINK_ATTR_PAD))
7534 goto nla_put_failure;
7536 nla_nest_end(msg, attr);
7541 nla_nest_cancel(msg, attr);
7545 static int devlink_trap_stats_put(struct sk_buff *msg, struct devlink *devlink,
7546 const struct devlink_trap_item *trap_item)
7548 struct devlink_stats stats;
7549 struct nlattr *attr;
7553 if (devlink->ops->trap_drop_counter_get) {
7554 err = devlink->ops->trap_drop_counter_get(devlink,
7561 devlink_trap_stats_read(trap_item->stats, &stats);
7563 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
7567 if (devlink->ops->trap_drop_counter_get &&
7568 nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_DROPPED, drops,
7570 goto nla_put_failure;
7572 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
7573 stats.rx_packets, DEVLINK_ATTR_PAD))
7574 goto nla_put_failure;
7576 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
7577 stats.rx_bytes, DEVLINK_ATTR_PAD))
7578 goto nla_put_failure;
7580 nla_nest_end(msg, attr);
7585 nla_nest_cancel(msg, attr);
7589 static int devlink_nl_trap_fill(struct sk_buff *msg, struct devlink *devlink,
7590 const struct devlink_trap_item *trap_item,
7591 enum devlink_command cmd, u32 portid, u32 seq,
7594 struct devlink_trap_group_item *group_item = trap_item->group_item;
7598 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
7602 if (devlink_nl_put_handle(msg, devlink))
7603 goto nla_put_failure;
7605 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
7606 group_item->group->name))
7607 goto nla_put_failure;
7609 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_NAME, trap_item->trap->name))
7610 goto nla_put_failure;
7612 if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_TYPE, trap_item->trap->type))
7613 goto nla_put_failure;
7615 if (trap_item->trap->generic &&
7616 nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
7617 goto nla_put_failure;
7619 if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_ACTION, trap_item->action))
7620 goto nla_put_failure;
7622 err = devlink_trap_metadata_put(msg, trap_item->trap);
7624 goto nla_put_failure;
7626 err = devlink_trap_stats_put(msg, devlink, trap_item);
7628 goto nla_put_failure;
7630 genlmsg_end(msg, hdr);
7635 genlmsg_cancel(msg, hdr);
7639 static int devlink_nl_cmd_trap_get_doit(struct sk_buff *skb,
7640 struct genl_info *info)
7642 struct netlink_ext_ack *extack = info->extack;
7643 struct devlink *devlink = info->user_ptr[0];
7644 struct devlink_trap_item *trap_item;
7645 struct sk_buff *msg;
7648 if (list_empty(&devlink->trap_list))
7651 trap_item = devlink_trap_item_get_from_info(devlink, info);
7653 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
7657 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7661 err = devlink_nl_trap_fill(msg, devlink, trap_item,
7662 DEVLINK_CMD_TRAP_NEW, info->snd_portid,
7667 return genlmsg_reply(msg, info);
7674 static int devlink_nl_cmd_trap_get_dumpit(struct sk_buff *msg,
7675 struct netlink_callback *cb)
7677 struct devlink_trap_item *trap_item;
7678 struct devlink *devlink;
7679 int start = cb->args[0];
7683 mutex_lock(&devlink_mutex);
7684 list_for_each_entry(devlink, &devlink_list, list) {
7685 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7687 mutex_lock(&devlink->lock);
7688 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7693 err = devlink_nl_trap_fill(msg, devlink, trap_item,
7694 DEVLINK_CMD_TRAP_NEW,
7695 NETLINK_CB(cb->skb).portid,
7699 mutex_unlock(&devlink->lock);
7704 mutex_unlock(&devlink->lock);
7707 mutex_unlock(&devlink_mutex);
7713 static int __devlink_trap_action_set(struct devlink *devlink,
7714 struct devlink_trap_item *trap_item,
7715 enum devlink_trap_action trap_action,
7716 struct netlink_ext_ack *extack)
7720 if (trap_item->action != trap_action &&
7721 trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP) {
7722 NL_SET_ERR_MSG_MOD(extack, "Cannot change action of non-drop traps. Skipping");
7726 err = devlink->ops->trap_action_set(devlink, trap_item->trap,
7727 trap_action, extack);
7731 trap_item->action = trap_action;
7736 static int devlink_trap_action_set(struct devlink *devlink,
7737 struct devlink_trap_item *trap_item,
7738 struct genl_info *info)
7740 enum devlink_trap_action trap_action;
7743 if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
7746 err = devlink_trap_action_get_from_info(info, &trap_action);
7748 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
7752 return __devlink_trap_action_set(devlink, trap_item, trap_action,
7756 static int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb,
7757 struct genl_info *info)
7759 struct netlink_ext_ack *extack = info->extack;
7760 struct devlink *devlink = info->user_ptr[0];
7761 struct devlink_trap_item *trap_item;
7763 if (list_empty(&devlink->trap_list))
7766 trap_item = devlink_trap_item_get_from_info(devlink, info);
7768 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
7772 return devlink_trap_action_set(devlink, trap_item, info);
7775 static struct devlink_trap_group_item *
7776 devlink_trap_group_item_lookup(struct devlink *devlink, const char *name)
7778 struct devlink_trap_group_item *group_item;
7780 list_for_each_entry(group_item, &devlink->trap_group_list, list) {
7781 if (!strcmp(group_item->group->name, name))
7788 static struct devlink_trap_group_item *
7789 devlink_trap_group_item_lookup_by_id(struct devlink *devlink, u16 id)
7791 struct devlink_trap_group_item *group_item;
7793 list_for_each_entry(group_item, &devlink->trap_group_list, list) {
7794 if (group_item->group->id == id)
7801 static struct devlink_trap_group_item *
7802 devlink_trap_group_item_get_from_info(struct devlink *devlink,
7803 struct genl_info *info)
7807 if (!info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME])
7809 name = nla_data(info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME]);
7811 return devlink_trap_group_item_lookup(devlink, name);
7815 devlink_nl_trap_group_fill(struct sk_buff *msg, struct devlink *devlink,
7816 const struct devlink_trap_group_item *group_item,
7817 enum devlink_command cmd, u32 portid, u32 seq,
7823 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
7827 if (devlink_nl_put_handle(msg, devlink))
7828 goto nla_put_failure;
7830 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
7831 group_item->group->name))
7832 goto nla_put_failure;
7834 if (group_item->group->generic &&
7835 nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
7836 goto nla_put_failure;
7838 if (group_item->policer_item &&
7839 nla_put_u32(msg, DEVLINK_ATTR_TRAP_POLICER_ID,
7840 group_item->policer_item->policer->id))
7841 goto nla_put_failure;
7843 err = devlink_trap_group_stats_put(msg, group_item->stats);
7845 goto nla_put_failure;
7847 genlmsg_end(msg, hdr);
7852 genlmsg_cancel(msg, hdr);
7856 static int devlink_nl_cmd_trap_group_get_doit(struct sk_buff *skb,
7857 struct genl_info *info)
7859 struct netlink_ext_ack *extack = info->extack;
7860 struct devlink *devlink = info->user_ptr[0];
7861 struct devlink_trap_group_item *group_item;
7862 struct sk_buff *msg;
7865 if (list_empty(&devlink->trap_group_list))
7868 group_item = devlink_trap_group_item_get_from_info(devlink, info);
7870 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
7874 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7878 err = devlink_nl_trap_group_fill(msg, devlink, group_item,
7879 DEVLINK_CMD_TRAP_GROUP_NEW,
7880 info->snd_portid, info->snd_seq, 0);
7882 goto err_trap_group_fill;
7884 return genlmsg_reply(msg, info);
7886 err_trap_group_fill:
7891 static int devlink_nl_cmd_trap_group_get_dumpit(struct sk_buff *msg,
7892 struct netlink_callback *cb)
7894 enum devlink_command cmd = DEVLINK_CMD_TRAP_GROUP_NEW;
7895 struct devlink_trap_group_item *group_item;
7896 u32 portid = NETLINK_CB(cb->skb).portid;
7897 struct devlink *devlink;
7898 int start = cb->args[0];
7902 mutex_lock(&devlink_mutex);
7903 list_for_each_entry(devlink, &devlink_list, list) {
7904 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7906 mutex_lock(&devlink->lock);
7907 list_for_each_entry(group_item, &devlink->trap_group_list,
7913 err = devlink_nl_trap_group_fill(msg, devlink,
7919 mutex_unlock(&devlink->lock);
7924 mutex_unlock(&devlink->lock);
7927 mutex_unlock(&devlink_mutex);
7934 __devlink_trap_group_action_set(struct devlink *devlink,
7935 struct devlink_trap_group_item *group_item,
7936 enum devlink_trap_action trap_action,
7937 struct netlink_ext_ack *extack)
7939 const char *group_name = group_item->group->name;
7940 struct devlink_trap_item *trap_item;
7943 if (devlink->ops->trap_group_action_set) {
7944 err = devlink->ops->trap_group_action_set(devlink, group_item->group,
7945 trap_action, extack);
7949 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7950 if (strcmp(trap_item->group_item->group->name, group_name))
7952 if (trap_item->action != trap_action &&
7953 trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP)
7955 trap_item->action = trap_action;
7961 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7962 if (strcmp(trap_item->group_item->group->name, group_name))
7964 err = __devlink_trap_action_set(devlink, trap_item,
7965 trap_action, extack);
7974 devlink_trap_group_action_set(struct devlink *devlink,
7975 struct devlink_trap_group_item *group_item,
7976 struct genl_info *info, bool *p_modified)
7978 enum devlink_trap_action trap_action;
7981 if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
7984 err = devlink_trap_action_get_from_info(info, &trap_action);
7986 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
7990 err = __devlink_trap_group_action_set(devlink, group_item, trap_action,
8000 static int devlink_trap_group_set(struct devlink *devlink,
8001 struct devlink_trap_group_item *group_item,
8002 struct genl_info *info)
8004 struct devlink_trap_policer_item *policer_item;
8005 struct netlink_ext_ack *extack = info->extack;
8006 const struct devlink_trap_policer *policer;
8007 struct nlattr **attrs = info->attrs;
8010 if (!attrs[DEVLINK_ATTR_TRAP_POLICER_ID])
8013 if (!devlink->ops->trap_group_set)
8016 policer_item = group_item->policer_item;
8017 if (attrs[DEVLINK_ATTR_TRAP_POLICER_ID]) {
8020 policer_id = nla_get_u32(attrs[DEVLINK_ATTR_TRAP_POLICER_ID]);
8021 policer_item = devlink_trap_policer_item_lookup(devlink,
8023 if (policer_id && !policer_item) {
8024 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8028 policer = policer_item ? policer_item->policer : NULL;
8030 err = devlink->ops->trap_group_set(devlink, group_item->group, policer,
8035 group_item->policer_item = policer_item;
8040 static int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
8041 struct genl_info *info)
8043 struct netlink_ext_ack *extack = info->extack;
8044 struct devlink *devlink = info->user_ptr[0];
8045 struct devlink_trap_group_item *group_item;
8046 bool modified = false;
8049 if (list_empty(&devlink->trap_group_list))
8052 group_item = devlink_trap_group_item_get_from_info(devlink, info);
8054 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
8058 err = devlink_trap_group_action_set(devlink, group_item, info,
8063 err = devlink_trap_group_set(devlink, group_item, info);
8065 goto err_trap_group_set;
8071 NL_SET_ERR_MSG_MOD(extack, "Trap group set failed, but some changes were committed already");
8075 static struct devlink_trap_policer_item *
8076 devlink_trap_policer_item_get_from_info(struct devlink *devlink,
8077 struct genl_info *info)
8081 if (!info->attrs[DEVLINK_ATTR_TRAP_POLICER_ID])
8083 id = nla_get_u32(info->attrs[DEVLINK_ATTR_TRAP_POLICER_ID]);
8085 return devlink_trap_policer_item_lookup(devlink, id);
8089 devlink_trap_policer_stats_put(struct sk_buff *msg, struct devlink *devlink,
8090 const struct devlink_trap_policer *policer)
8092 struct nlattr *attr;
8096 if (!devlink->ops->trap_policer_counter_get)
8099 err = devlink->ops->trap_policer_counter_get(devlink, policer, &drops);
8103 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
8107 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_DROPPED, drops,
8109 goto nla_put_failure;
8111 nla_nest_end(msg, attr);
8116 nla_nest_cancel(msg, attr);
8121 devlink_nl_trap_policer_fill(struct sk_buff *msg, struct devlink *devlink,
8122 const struct devlink_trap_policer_item *policer_item,
8123 enum devlink_command cmd, u32 portid, u32 seq,
8129 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
8133 if (devlink_nl_put_handle(msg, devlink))
8134 goto nla_put_failure;
8136 if (nla_put_u32(msg, DEVLINK_ATTR_TRAP_POLICER_ID,
8137 policer_item->policer->id))
8138 goto nla_put_failure;
8140 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_TRAP_POLICER_RATE,
8141 policer_item->rate, DEVLINK_ATTR_PAD))
8142 goto nla_put_failure;
8144 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_TRAP_POLICER_BURST,
8145 policer_item->burst, DEVLINK_ATTR_PAD))
8146 goto nla_put_failure;
8148 err = devlink_trap_policer_stats_put(msg, devlink,
8149 policer_item->policer);
8151 goto nla_put_failure;
8153 genlmsg_end(msg, hdr);
8158 genlmsg_cancel(msg, hdr);
8162 static int devlink_nl_cmd_trap_policer_get_doit(struct sk_buff *skb,
8163 struct genl_info *info)
8165 struct devlink_trap_policer_item *policer_item;
8166 struct netlink_ext_ack *extack = info->extack;
8167 struct devlink *devlink = info->user_ptr[0];
8168 struct sk_buff *msg;
8171 if (list_empty(&devlink->trap_policer_list))
8174 policer_item = devlink_trap_policer_item_get_from_info(devlink, info);
8175 if (!policer_item) {
8176 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8180 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8184 err = devlink_nl_trap_policer_fill(msg, devlink, policer_item,
8185 DEVLINK_CMD_TRAP_POLICER_NEW,
8186 info->snd_portid, info->snd_seq, 0);
8188 goto err_trap_policer_fill;
8190 return genlmsg_reply(msg, info);
8192 err_trap_policer_fill:
8197 static int devlink_nl_cmd_trap_policer_get_dumpit(struct sk_buff *msg,
8198 struct netlink_callback *cb)
8200 enum devlink_command cmd = DEVLINK_CMD_TRAP_POLICER_NEW;
8201 struct devlink_trap_policer_item *policer_item;
8202 u32 portid = NETLINK_CB(cb->skb).portid;
8203 struct devlink *devlink;
8204 int start = cb->args[0];
8208 mutex_lock(&devlink_mutex);
8209 list_for_each_entry(devlink, &devlink_list, list) {
8210 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
8212 mutex_lock(&devlink->lock);
8213 list_for_each_entry(policer_item, &devlink->trap_policer_list,
8219 err = devlink_nl_trap_policer_fill(msg, devlink,
8225 mutex_unlock(&devlink->lock);
8230 mutex_unlock(&devlink->lock);
8233 mutex_unlock(&devlink_mutex);
8240 devlink_trap_policer_set(struct devlink *devlink,
8241 struct devlink_trap_policer_item *policer_item,
8242 struct genl_info *info)
8244 struct netlink_ext_ack *extack = info->extack;
8245 struct nlattr **attrs = info->attrs;
8249 rate = policer_item->rate;
8250 burst = policer_item->burst;
8252 if (attrs[DEVLINK_ATTR_TRAP_POLICER_RATE])
8253 rate = nla_get_u64(attrs[DEVLINK_ATTR_TRAP_POLICER_RATE]);
8255 if (attrs[DEVLINK_ATTR_TRAP_POLICER_BURST])
8256 burst = nla_get_u64(attrs[DEVLINK_ATTR_TRAP_POLICER_BURST]);
8258 if (rate < policer_item->policer->min_rate) {
8259 NL_SET_ERR_MSG_MOD(extack, "Policer rate lower than limit");
8263 if (rate > policer_item->policer->max_rate) {
8264 NL_SET_ERR_MSG_MOD(extack, "Policer rate higher than limit");
8268 if (burst < policer_item->policer->min_burst) {
8269 NL_SET_ERR_MSG_MOD(extack, "Policer burst size lower than limit");
8273 if (burst > policer_item->policer->max_burst) {
8274 NL_SET_ERR_MSG_MOD(extack, "Policer burst size higher than limit");
8278 err = devlink->ops->trap_policer_set(devlink, policer_item->policer,
8279 rate, burst, info->extack);
8283 policer_item->rate = rate;
8284 policer_item->burst = burst;
8289 static int devlink_nl_cmd_trap_policer_set_doit(struct sk_buff *skb,
8290 struct genl_info *info)
8292 struct devlink_trap_policer_item *policer_item;
8293 struct netlink_ext_ack *extack = info->extack;
8294 struct devlink *devlink = info->user_ptr[0];
8296 if (list_empty(&devlink->trap_policer_list))
8299 if (!devlink->ops->trap_policer_set)
8302 policer_item = devlink_trap_policer_item_get_from_info(devlink, info);
8303 if (!policer_item) {
8304 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8308 return devlink_trap_policer_set(devlink, policer_item, info);
8311 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
8312 [DEVLINK_ATTR_UNSPEC] = { .strict_start_type =
8313 DEVLINK_ATTR_TRAP_POLICER_ID },
8314 [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
8315 [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
8316 [DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
8317 [DEVLINK_ATTR_PORT_TYPE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_PORT_TYPE_AUTO,
8318 DEVLINK_PORT_TYPE_IB),
8319 [DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
8320 [DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
8321 [DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
8322 [DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
8323 [DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
8324 [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
8325 [DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
8326 [DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
8327 [DEVLINK_ATTR_ESWITCH_MODE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_ESWITCH_MODE_LEGACY,
8328 DEVLINK_ESWITCH_MODE_SWITCHDEV),
8329 [DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
8330 [DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
8331 [DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
8332 [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
8333 [DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
8334 [DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
8335 [DEVLINK_ATTR_PARAM_NAME] = { .type = NLA_NUL_STRING },
8336 [DEVLINK_ATTR_PARAM_TYPE] = { .type = NLA_U8 },
8337 [DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },
8338 [DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },
8339 [DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },
8340 [DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .type = NLA_U64 },
8341 [DEVLINK_ATTR_REGION_CHUNK_LEN] = { .type = NLA_U64 },
8342 [DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },
8343 [DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },
8344 [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },
8345 [DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING },
8346 [DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING },
8347 [DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK] =
8348 NLA_POLICY_BITFIELD32(DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS),
8349 [DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING },
8350 [DEVLINK_ATTR_TRAP_ACTION] = { .type = NLA_U8 },
8351 [DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING },
8352 [DEVLINK_ATTR_NETNS_PID] = { .type = NLA_U32 },
8353 [DEVLINK_ATTR_NETNS_FD] = { .type = NLA_U32 },
8354 [DEVLINK_ATTR_NETNS_ID] = { .type = NLA_U32 },
8355 [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP] = { .type = NLA_U8 },
8356 [DEVLINK_ATTR_TRAP_POLICER_ID] = { .type = NLA_U32 },
8357 [DEVLINK_ATTR_TRAP_POLICER_RATE] = { .type = NLA_U64 },
8358 [DEVLINK_ATTR_TRAP_POLICER_BURST] = { .type = NLA_U64 },
8359 [DEVLINK_ATTR_PORT_FUNCTION] = { .type = NLA_NESTED },
8360 [DEVLINK_ATTR_RELOAD_ACTION] = NLA_POLICY_RANGE(NLA_U8, DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
8361 DEVLINK_RELOAD_ACTION_MAX),
8362 [DEVLINK_ATTR_RELOAD_LIMITS] = NLA_POLICY_BITFIELD32(DEVLINK_RELOAD_LIMITS_VALID_MASK),
8363 [DEVLINK_ATTR_PORT_FLAVOUR] = { .type = NLA_U16 },
8364 [DEVLINK_ATTR_PORT_PCI_PF_NUMBER] = { .type = NLA_U16 },
8365 [DEVLINK_ATTR_PORT_PCI_SF_NUMBER] = { .type = NLA_U32 },
8366 [DEVLINK_ATTR_PORT_CONTROLLER_NUMBER] = { .type = NLA_U32 },
8367 [DEVLINK_ATTR_RATE_TYPE] = { .type = NLA_U16 },
8368 [DEVLINK_ATTR_RATE_TX_SHARE] = { .type = NLA_U64 },
8369 [DEVLINK_ATTR_RATE_TX_MAX] = { .type = NLA_U64 },
8370 [DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING },
8371 [DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .type = NLA_NUL_STRING },
8374 static const struct genl_small_ops devlink_nl_ops[] = {
8376 .cmd = DEVLINK_CMD_GET,
8377 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8378 .doit = devlink_nl_cmd_get_doit,
8379 .dumpit = devlink_nl_cmd_get_dumpit,
8380 /* can be retrieved by unprivileged users */
8383 .cmd = DEVLINK_CMD_PORT_GET,
8384 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8385 .doit = devlink_nl_cmd_port_get_doit,
8386 .dumpit = devlink_nl_cmd_port_get_dumpit,
8387 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8388 /* can be retrieved by unprivileged users */
8391 .cmd = DEVLINK_CMD_PORT_SET,
8392 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8393 .doit = devlink_nl_cmd_port_set_doit,
8394 .flags = GENL_ADMIN_PERM,
8395 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8398 .cmd = DEVLINK_CMD_RATE_GET,
8399 .doit = devlink_nl_cmd_rate_get_doit,
8400 .dumpit = devlink_nl_cmd_rate_get_dumpit,
8401 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE,
8402 /* can be retrieved by unprivileged users */
8405 .cmd = DEVLINK_CMD_RATE_SET,
8406 .doit = devlink_nl_cmd_rate_set_doit,
8407 .flags = GENL_ADMIN_PERM,
8408 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE,
8411 .cmd = DEVLINK_CMD_RATE_NEW,
8412 .doit = devlink_nl_cmd_rate_new_doit,
8413 .flags = GENL_ADMIN_PERM,
8416 .cmd = DEVLINK_CMD_RATE_DEL,
8417 .doit = devlink_nl_cmd_rate_del_doit,
8418 .flags = GENL_ADMIN_PERM,
8419 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE_NODE,
8422 .cmd = DEVLINK_CMD_PORT_SPLIT,
8423 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8424 .doit = devlink_nl_cmd_port_split_doit,
8425 .flags = GENL_ADMIN_PERM,
8426 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8429 .cmd = DEVLINK_CMD_PORT_UNSPLIT,
8430 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8431 .doit = devlink_nl_cmd_port_unsplit_doit,
8432 .flags = GENL_ADMIN_PERM,
8433 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8436 .cmd = DEVLINK_CMD_PORT_NEW,
8437 .doit = devlink_nl_cmd_port_new_doit,
8438 .flags = GENL_ADMIN_PERM,
8439 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8442 .cmd = DEVLINK_CMD_PORT_DEL,
8443 .doit = devlink_nl_cmd_port_del_doit,
8444 .flags = GENL_ADMIN_PERM,
8445 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8448 .cmd = DEVLINK_CMD_SB_GET,
8449 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8450 .doit = devlink_nl_cmd_sb_get_doit,
8451 .dumpit = devlink_nl_cmd_sb_get_dumpit,
8452 /* can be retrieved by unprivileged users */
8455 .cmd = DEVLINK_CMD_SB_POOL_GET,
8456 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8457 .doit = devlink_nl_cmd_sb_pool_get_doit,
8458 .dumpit = devlink_nl_cmd_sb_pool_get_dumpit,
8459 /* can be retrieved by unprivileged users */
8462 .cmd = DEVLINK_CMD_SB_POOL_SET,
8463 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8464 .doit = devlink_nl_cmd_sb_pool_set_doit,
8465 .flags = GENL_ADMIN_PERM,
8468 .cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
8469 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8470 .doit = devlink_nl_cmd_sb_port_pool_get_doit,
8471 .dumpit = devlink_nl_cmd_sb_port_pool_get_dumpit,
8472 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8473 /* can be retrieved by unprivileged users */
8476 .cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
8477 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8478 .doit = devlink_nl_cmd_sb_port_pool_set_doit,
8479 .flags = GENL_ADMIN_PERM,
8480 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8483 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
8484 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8485 .doit = devlink_nl_cmd_sb_tc_pool_bind_get_doit,
8486 .dumpit = devlink_nl_cmd_sb_tc_pool_bind_get_dumpit,
8487 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8488 /* can be retrieved by unprivileged users */
8491 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
8492 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8493 .doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
8494 .flags = GENL_ADMIN_PERM,
8495 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8498 .cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
8499 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8500 .doit = devlink_nl_cmd_sb_occ_snapshot_doit,
8501 .flags = GENL_ADMIN_PERM,
8504 .cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
8505 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8506 .doit = devlink_nl_cmd_sb_occ_max_clear_doit,
8507 .flags = GENL_ADMIN_PERM,
8510 .cmd = DEVLINK_CMD_ESWITCH_GET,
8511 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8512 .doit = devlink_nl_cmd_eswitch_get_doit,
8513 .flags = GENL_ADMIN_PERM,
8514 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8517 .cmd = DEVLINK_CMD_ESWITCH_SET,
8518 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8519 .doit = devlink_nl_cmd_eswitch_set_doit,
8520 .flags = GENL_ADMIN_PERM,
8521 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8524 .cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
8525 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8526 .doit = devlink_nl_cmd_dpipe_table_get,
8527 /* can be retrieved by unprivileged users */
8530 .cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
8531 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8532 .doit = devlink_nl_cmd_dpipe_entries_get,
8533 /* can be retrieved by unprivileged users */
8536 .cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
8537 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8538 .doit = devlink_nl_cmd_dpipe_headers_get,
8539 /* can be retrieved by unprivileged users */
8542 .cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
8543 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8544 .doit = devlink_nl_cmd_dpipe_table_counters_set,
8545 .flags = GENL_ADMIN_PERM,
8548 .cmd = DEVLINK_CMD_RESOURCE_SET,
8549 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8550 .doit = devlink_nl_cmd_resource_set,
8551 .flags = GENL_ADMIN_PERM,
8554 .cmd = DEVLINK_CMD_RESOURCE_DUMP,
8555 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8556 .doit = devlink_nl_cmd_resource_dump,
8557 /* can be retrieved by unprivileged users */
8560 .cmd = DEVLINK_CMD_RELOAD,
8561 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8562 .doit = devlink_nl_cmd_reload,
8563 .flags = GENL_ADMIN_PERM,
8564 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8567 .cmd = DEVLINK_CMD_PARAM_GET,
8568 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8569 .doit = devlink_nl_cmd_param_get_doit,
8570 .dumpit = devlink_nl_cmd_param_get_dumpit,
8571 /* can be retrieved by unprivileged users */
8574 .cmd = DEVLINK_CMD_PARAM_SET,
8575 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8576 .doit = devlink_nl_cmd_param_set_doit,
8577 .flags = GENL_ADMIN_PERM,
8580 .cmd = DEVLINK_CMD_PORT_PARAM_GET,
8581 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8582 .doit = devlink_nl_cmd_port_param_get_doit,
8583 .dumpit = devlink_nl_cmd_port_param_get_dumpit,
8584 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8585 /* can be retrieved by unprivileged users */
8588 .cmd = DEVLINK_CMD_PORT_PARAM_SET,
8589 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8590 .doit = devlink_nl_cmd_port_param_set_doit,
8591 .flags = GENL_ADMIN_PERM,
8592 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8595 .cmd = DEVLINK_CMD_REGION_GET,
8596 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8597 .doit = devlink_nl_cmd_region_get_doit,
8598 .dumpit = devlink_nl_cmd_region_get_dumpit,
8599 .flags = GENL_ADMIN_PERM,
8602 .cmd = DEVLINK_CMD_REGION_NEW,
8603 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8604 .doit = devlink_nl_cmd_region_new,
8605 .flags = GENL_ADMIN_PERM,
8608 .cmd = DEVLINK_CMD_REGION_DEL,
8609 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8610 .doit = devlink_nl_cmd_region_del,
8611 .flags = GENL_ADMIN_PERM,
8614 .cmd = DEVLINK_CMD_REGION_READ,
8615 .validate = GENL_DONT_VALIDATE_STRICT |
8616 GENL_DONT_VALIDATE_DUMP_STRICT,
8617 .dumpit = devlink_nl_cmd_region_read_dumpit,
8618 .flags = GENL_ADMIN_PERM,
8621 .cmd = DEVLINK_CMD_INFO_GET,
8622 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8623 .doit = devlink_nl_cmd_info_get_doit,
8624 .dumpit = devlink_nl_cmd_info_get_dumpit,
8625 /* can be retrieved by unprivileged users */
8628 .cmd = DEVLINK_CMD_HEALTH_REPORTER_GET,
8629 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8630 .doit = devlink_nl_cmd_health_reporter_get_doit,
8631 .dumpit = devlink_nl_cmd_health_reporter_get_dumpit,
8632 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8633 DEVLINK_NL_FLAG_NO_LOCK,
8634 /* can be retrieved by unprivileged users */
8637 .cmd = DEVLINK_CMD_HEALTH_REPORTER_SET,
8638 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8639 .doit = devlink_nl_cmd_health_reporter_set_doit,
8640 .flags = GENL_ADMIN_PERM,
8641 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8642 DEVLINK_NL_FLAG_NO_LOCK,
8645 .cmd = DEVLINK_CMD_HEALTH_REPORTER_RECOVER,
8646 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8647 .doit = devlink_nl_cmd_health_reporter_recover_doit,
8648 .flags = GENL_ADMIN_PERM,
8649 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8650 DEVLINK_NL_FLAG_NO_LOCK,
8653 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE,
8654 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8655 .doit = devlink_nl_cmd_health_reporter_diagnose_doit,
8656 .flags = GENL_ADMIN_PERM,
8657 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8658 DEVLINK_NL_FLAG_NO_LOCK,
8661 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET,
8662 .validate = GENL_DONT_VALIDATE_STRICT |
8663 GENL_DONT_VALIDATE_DUMP_STRICT,
8664 .dumpit = devlink_nl_cmd_health_reporter_dump_get_dumpit,
8665 .flags = GENL_ADMIN_PERM,
8666 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8667 DEVLINK_NL_FLAG_NO_LOCK,
8670 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR,
8671 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8672 .doit = devlink_nl_cmd_health_reporter_dump_clear_doit,
8673 .flags = GENL_ADMIN_PERM,
8674 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8675 DEVLINK_NL_FLAG_NO_LOCK,
8678 .cmd = DEVLINK_CMD_HEALTH_REPORTER_TEST,
8679 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8680 .doit = devlink_nl_cmd_health_reporter_test_doit,
8681 .flags = GENL_ADMIN_PERM,
8682 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8683 DEVLINK_NL_FLAG_NO_LOCK,
8686 .cmd = DEVLINK_CMD_FLASH_UPDATE,
8687 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8688 .doit = devlink_nl_cmd_flash_update,
8689 .flags = GENL_ADMIN_PERM,
8692 .cmd = DEVLINK_CMD_TRAP_GET,
8693 .doit = devlink_nl_cmd_trap_get_doit,
8694 .dumpit = devlink_nl_cmd_trap_get_dumpit,
8695 /* can be retrieved by unprivileged users */
8698 .cmd = DEVLINK_CMD_TRAP_SET,
8699 .doit = devlink_nl_cmd_trap_set_doit,
8700 .flags = GENL_ADMIN_PERM,
8703 .cmd = DEVLINK_CMD_TRAP_GROUP_GET,
8704 .doit = devlink_nl_cmd_trap_group_get_doit,
8705 .dumpit = devlink_nl_cmd_trap_group_get_dumpit,
8706 /* can be retrieved by unprivileged users */
8709 .cmd = DEVLINK_CMD_TRAP_GROUP_SET,
8710 .doit = devlink_nl_cmd_trap_group_set_doit,
8711 .flags = GENL_ADMIN_PERM,
8714 .cmd = DEVLINK_CMD_TRAP_POLICER_GET,
8715 .doit = devlink_nl_cmd_trap_policer_get_doit,
8716 .dumpit = devlink_nl_cmd_trap_policer_get_dumpit,
8717 /* can be retrieved by unprivileged users */
8720 .cmd = DEVLINK_CMD_TRAP_POLICER_SET,
8721 .doit = devlink_nl_cmd_trap_policer_set_doit,
8722 .flags = GENL_ADMIN_PERM,
8726 static struct genl_family devlink_nl_family __ro_after_init = {
8727 .name = DEVLINK_GENL_NAME,
8728 .version = DEVLINK_GENL_VERSION,
8729 .maxattr = DEVLINK_ATTR_MAX,
8730 .policy = devlink_nl_policy,
8732 .pre_doit = devlink_nl_pre_doit,
8733 .post_doit = devlink_nl_post_doit,
8734 .module = THIS_MODULE,
8735 .small_ops = devlink_nl_ops,
8736 .n_small_ops = ARRAY_SIZE(devlink_nl_ops),
8737 .mcgrps = devlink_nl_mcgrps,
8738 .n_mcgrps = ARRAY_SIZE(devlink_nl_mcgrps),
8741 static bool devlink_reload_actions_valid(const struct devlink_ops *ops)
8743 const struct devlink_reload_combination *comb;
8746 if (!devlink_reload_supported(ops)) {
8747 if (WARN_ON(ops->reload_actions))
8752 if (WARN_ON(!ops->reload_actions ||
8753 ops->reload_actions & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
8754 ops->reload_actions >= BIT(__DEVLINK_RELOAD_ACTION_MAX)))
8757 if (WARN_ON(ops->reload_limits & BIT(DEVLINK_RELOAD_LIMIT_UNSPEC) ||
8758 ops->reload_limits >= BIT(__DEVLINK_RELOAD_LIMIT_MAX)))
8761 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++) {
8762 comb = &devlink_reload_invalid_combinations[i];
8763 if (ops->reload_actions == BIT(comb->action) &&
8764 ops->reload_limits == BIT(comb->limit))
8771 * devlink_alloc - Allocate new devlink instance resources
8774 * @priv_size: size of user private data
8776 * Allocate new devlink instance resources, including devlink index
8779 struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size)
8781 struct devlink *devlink;
8786 if (!devlink_reload_actions_valid(ops))
8789 devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
8793 xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
8794 __devlink_net_set(devlink, &init_net);
8795 INIT_LIST_HEAD(&devlink->port_list);
8796 INIT_LIST_HEAD(&devlink->rate_list);
8797 INIT_LIST_HEAD(&devlink->sb_list);
8798 INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
8799 INIT_LIST_HEAD(&devlink->resource_list);
8800 INIT_LIST_HEAD(&devlink->param_list);
8801 INIT_LIST_HEAD(&devlink->region_list);
8802 INIT_LIST_HEAD(&devlink->reporter_list);
8803 INIT_LIST_HEAD(&devlink->trap_list);
8804 INIT_LIST_HEAD(&devlink->trap_group_list);
8805 INIT_LIST_HEAD(&devlink->trap_policer_list);
8806 mutex_init(&devlink->lock);
8807 mutex_init(&devlink->reporters_lock);
8810 EXPORT_SYMBOL_GPL(devlink_alloc);
8813 * devlink_register - Register devlink instance
8816 * @dev: parent device
8818 int devlink_register(struct devlink *devlink, struct device *dev)
8821 devlink->registered = true;
8822 mutex_lock(&devlink_mutex);
8823 list_add_tail(&devlink->list, &devlink_list);
8824 devlink_notify(devlink, DEVLINK_CMD_NEW);
8825 mutex_unlock(&devlink_mutex);
8828 EXPORT_SYMBOL_GPL(devlink_register);
8831 * devlink_unregister - Unregister devlink instance
8835 void devlink_unregister(struct devlink *devlink)
8837 mutex_lock(&devlink_mutex);
8838 WARN_ON(devlink_reload_supported(devlink->ops) &&
8839 devlink->reload_enabled);
8840 devlink_notify(devlink, DEVLINK_CMD_DEL);
8841 list_del(&devlink->list);
8842 mutex_unlock(&devlink_mutex);
8844 EXPORT_SYMBOL_GPL(devlink_unregister);
8847 * devlink_reload_enable - Enable reload of devlink instance
8851 * Should be called at end of device initialization
8852 * process when reload operation is supported.
8854 void devlink_reload_enable(struct devlink *devlink)
8856 mutex_lock(&devlink_mutex);
8857 devlink->reload_enabled = true;
8858 mutex_unlock(&devlink_mutex);
8860 EXPORT_SYMBOL_GPL(devlink_reload_enable);
8863 * devlink_reload_disable - Disable reload of devlink instance
8867 * Should be called at the beginning of device cleanup
8868 * process when reload operation is supported.
8870 void devlink_reload_disable(struct devlink *devlink)
8872 mutex_lock(&devlink_mutex);
8873 /* Mutex is taken which ensures that no reload operation is in
8874 * progress while setting up forbidded flag.
8876 devlink->reload_enabled = false;
8877 mutex_unlock(&devlink_mutex);
8879 EXPORT_SYMBOL_GPL(devlink_reload_disable);
8882 * devlink_free - Free devlink instance resources
8886 void devlink_free(struct devlink *devlink)
8888 mutex_destroy(&devlink->reporters_lock);
8889 mutex_destroy(&devlink->lock);
8890 WARN_ON(!list_empty(&devlink->trap_policer_list));
8891 WARN_ON(!list_empty(&devlink->trap_group_list));
8892 WARN_ON(!list_empty(&devlink->trap_list));
8893 WARN_ON(!list_empty(&devlink->reporter_list));
8894 WARN_ON(!list_empty(&devlink->region_list));
8895 WARN_ON(!list_empty(&devlink->param_list));
8896 WARN_ON(!list_empty(&devlink->resource_list));
8897 WARN_ON(!list_empty(&devlink->dpipe_table_list));
8898 WARN_ON(!list_empty(&devlink->sb_list));
8899 WARN_ON(!list_empty(&devlink->rate_list));
8900 WARN_ON(!list_empty(&devlink->port_list));
8902 xa_destroy(&devlink->snapshot_ids);
8906 EXPORT_SYMBOL_GPL(devlink_free);
8908 static void devlink_port_type_warn(struct work_struct *work)
8910 WARN(true, "Type was not set for devlink port.");
8913 static bool devlink_port_type_should_warn(struct devlink_port *devlink_port)
8915 /* Ignore CPU and DSA flavours. */
8916 return devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_CPU &&
8917 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA &&
8918 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_UNUSED;
8921 #define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600)
8923 static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
8925 if (!devlink_port_type_should_warn(devlink_port))
8927 /* Schedule a work to WARN in case driver does not set port
8928 * type within timeout.
8930 schedule_delayed_work(&devlink_port->type_warn_dw,
8931 DEVLINK_PORT_TYPE_WARN_TIMEOUT);
8934 static void devlink_port_type_warn_cancel(struct devlink_port *devlink_port)
8936 if (!devlink_port_type_should_warn(devlink_port))
8938 cancel_delayed_work_sync(&devlink_port->type_warn_dw);
8942 * devlink_port_register - Register devlink port
8945 * @devlink_port: devlink port
8946 * @port_index: driver-specific numerical identifier of the port
8948 * Register devlink port with provided port index. User can use
8949 * any indexing, even hw-related one. devlink_port structure
8950 * is convenient to be embedded inside user driver private structure.
8951 * Note that the caller should take care of zeroing the devlink_port
8954 int devlink_port_register(struct devlink *devlink,
8955 struct devlink_port *devlink_port,
8956 unsigned int port_index)
8958 mutex_lock(&devlink->lock);
8959 if (devlink_port_index_exists(devlink, port_index)) {
8960 mutex_unlock(&devlink->lock);
8963 devlink_port->devlink = devlink;
8964 devlink_port->index = port_index;
8965 devlink_port->registered = true;
8966 spin_lock_init(&devlink_port->type_lock);
8967 INIT_LIST_HEAD(&devlink_port->reporter_list);
8968 mutex_init(&devlink_port->reporters_lock);
8969 list_add_tail(&devlink_port->list, &devlink->port_list);
8970 INIT_LIST_HEAD(&devlink_port->param_list);
8971 INIT_LIST_HEAD(&devlink_port->region_list);
8972 mutex_unlock(&devlink->lock);
8973 INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn);
8974 devlink_port_type_warn_schedule(devlink_port);
8975 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
8978 EXPORT_SYMBOL_GPL(devlink_port_register);
8981 * devlink_port_unregister - Unregister devlink port
8983 * @devlink_port: devlink port
8985 void devlink_port_unregister(struct devlink_port *devlink_port)
8987 struct devlink *devlink = devlink_port->devlink;
8989 devlink_port_type_warn_cancel(devlink_port);
8990 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
8991 mutex_lock(&devlink->lock);
8992 list_del(&devlink_port->list);
8993 mutex_unlock(&devlink->lock);
8994 WARN_ON(!list_empty(&devlink_port->reporter_list));
8995 WARN_ON(!list_empty(&devlink_port->region_list));
8996 mutex_destroy(&devlink_port->reporters_lock);
8998 EXPORT_SYMBOL_GPL(devlink_port_unregister);
9000 static void __devlink_port_type_set(struct devlink_port *devlink_port,
9001 enum devlink_port_type type,
9004 if (WARN_ON(!devlink_port->registered))
9006 devlink_port_type_warn_cancel(devlink_port);
9007 spin_lock_bh(&devlink_port->type_lock);
9008 devlink_port->type = type;
9009 devlink_port->type_dev = type_dev;
9010 spin_unlock_bh(&devlink_port->type_lock);
9011 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
9014 static void devlink_port_type_netdev_checks(struct devlink_port *devlink_port,
9015 struct net_device *netdev)
9017 const struct net_device_ops *ops = netdev->netdev_ops;
9019 /* If driver registers devlink port, it should set devlink port
9020 * attributes accordingly so the compat functions are called
9021 * and the original ops are not used.
9023 if (ops->ndo_get_phys_port_name) {
9024 /* Some drivers use the same set of ndos for netdevs
9025 * that have devlink_port registered and also for
9026 * those who don't. Make sure that ndo_get_phys_port_name
9027 * returns -EOPNOTSUPP here in case it is defined.
9030 char name[IFNAMSIZ];
9033 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name));
9034 WARN_ON(err != -EOPNOTSUPP);
9036 if (ops->ndo_get_port_parent_id) {
9037 /* Some drivers use the same set of ndos for netdevs
9038 * that have devlink_port registered and also for
9039 * those who don't. Make sure that ndo_get_port_parent_id
9040 * returns -EOPNOTSUPP here in case it is defined.
9043 struct netdev_phys_item_id ppid;
9046 err = ops->ndo_get_port_parent_id(netdev, &ppid);
9047 WARN_ON(err != -EOPNOTSUPP);
9052 * devlink_port_type_eth_set - Set port type to Ethernet
9054 * @devlink_port: devlink port
9055 * @netdev: related netdevice
9057 void devlink_port_type_eth_set(struct devlink_port *devlink_port,
9058 struct net_device *netdev)
9061 devlink_port_type_netdev_checks(devlink_port, netdev);
9063 dev_warn(devlink_port->devlink->dev,
9064 "devlink port type for port %d set to Ethernet without a software interface reference, device type not supported by the kernel?\n",
9065 devlink_port->index);
9067 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, netdev);
9069 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
9072 * devlink_port_type_ib_set - Set port type to InfiniBand
9074 * @devlink_port: devlink port
9075 * @ibdev: related IB device
9077 void devlink_port_type_ib_set(struct devlink_port *devlink_port,
9078 struct ib_device *ibdev)
9080 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev);
9082 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
9085 * devlink_port_type_clear - Clear port type
9087 * @devlink_port: devlink port
9089 void devlink_port_type_clear(struct devlink_port *devlink_port)
9091 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL);
9092 devlink_port_type_warn_schedule(devlink_port);
9094 EXPORT_SYMBOL_GPL(devlink_port_type_clear);
9096 static int __devlink_port_attrs_set(struct devlink_port *devlink_port,
9097 enum devlink_port_flavour flavour)
9099 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9101 devlink_port->attrs_set = true;
9102 attrs->flavour = flavour;
9103 if (attrs->switch_id.id_len) {
9104 devlink_port->switch_port = true;
9105 if (WARN_ON(attrs->switch_id.id_len > MAX_PHYS_ITEM_ID_LEN))
9106 attrs->switch_id.id_len = MAX_PHYS_ITEM_ID_LEN;
9108 devlink_port->switch_port = false;
9114 * devlink_port_attrs_set - Set port attributes
9116 * @devlink_port: devlink port
9117 * @attrs: devlink port attrs
9119 void devlink_port_attrs_set(struct devlink_port *devlink_port,
9120 struct devlink_port_attrs *attrs)
9124 if (WARN_ON(devlink_port->registered))
9126 devlink_port->attrs = *attrs;
9127 ret = __devlink_port_attrs_set(devlink_port, attrs->flavour);
9130 WARN_ON(attrs->splittable && attrs->split);
9132 EXPORT_SYMBOL_GPL(devlink_port_attrs_set);
9135 * devlink_port_attrs_pci_pf_set - Set PCI PF port attributes
9137 * @devlink_port: devlink port
9138 * @controller: associated controller number for the devlink port instance
9139 * @pf: associated PF for the devlink port instance
9140 * @external: indicates if the port is for an external controller
9142 void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller,
9143 u16 pf, bool external)
9145 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9148 if (WARN_ON(devlink_port->registered))
9150 ret = __devlink_port_attrs_set(devlink_port,
9151 DEVLINK_PORT_FLAVOUR_PCI_PF);
9154 attrs->pci_pf.controller = controller;
9155 attrs->pci_pf.pf = pf;
9156 attrs->pci_pf.external = external;
9158 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set);
9161 * devlink_port_attrs_pci_vf_set - Set PCI VF port attributes
9163 * @devlink_port: devlink port
9164 * @controller: associated controller number for the devlink port instance
9165 * @pf: associated PF for the devlink port instance
9166 * @vf: associated VF of a PF for the devlink port instance
9167 * @external: indicates if the port is for an external controller
9169 void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller,
9170 u16 pf, u16 vf, bool external)
9172 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9175 if (WARN_ON(devlink_port->registered))
9177 ret = __devlink_port_attrs_set(devlink_port,
9178 DEVLINK_PORT_FLAVOUR_PCI_VF);
9181 attrs->pci_vf.controller = controller;
9182 attrs->pci_vf.pf = pf;
9183 attrs->pci_vf.vf = vf;
9184 attrs->pci_vf.external = external;
9186 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set);
9189 * devlink_port_attrs_pci_sf_set - Set PCI SF port attributes
9191 * @devlink_port: devlink port
9192 * @controller: associated controller number for the devlink port instance
9193 * @pf: associated PF for the devlink port instance
9194 * @sf: associated SF of a PF for the devlink port instance
9195 * @external: indicates if the port is for an external controller
9197 void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller,
9198 u16 pf, u32 sf, bool external)
9200 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9203 if (WARN_ON(devlink_port->registered))
9205 ret = __devlink_port_attrs_set(devlink_port,
9206 DEVLINK_PORT_FLAVOUR_PCI_SF);
9209 attrs->pci_sf.controller = controller;
9210 attrs->pci_sf.pf = pf;
9211 attrs->pci_sf.sf = sf;
9212 attrs->pci_sf.external = external;
9214 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set);
9217 * devlink_rate_leaf_create - create devlink rate leaf
9219 * @devlink_port: devlink port object to create rate object on
9220 * @priv: driver private data
9222 * Create devlink rate object of type leaf on provided @devlink_port.
9223 * Throws call trace if @devlink_port already has a devlink rate object.
9225 * Context: Takes and release devlink->lock <mutex>.
9227 * Return: -ENOMEM if failed to allocate rate object, 0 otherwise.
9230 devlink_rate_leaf_create(struct devlink_port *devlink_port, void *priv)
9232 struct devlink *devlink = devlink_port->devlink;
9233 struct devlink_rate *devlink_rate;
9235 devlink_rate = kzalloc(sizeof(*devlink_rate), GFP_KERNEL);
9239 mutex_lock(&devlink->lock);
9240 WARN_ON(devlink_port->devlink_rate);
9241 devlink_rate->type = DEVLINK_RATE_TYPE_LEAF;
9242 devlink_rate->devlink = devlink;
9243 devlink_rate->devlink_port = devlink_port;
9244 devlink_rate->priv = priv;
9245 list_add_tail(&devlink_rate->list, &devlink->rate_list);
9246 devlink_port->devlink_rate = devlink_rate;
9247 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
9248 mutex_unlock(&devlink->lock);
9252 EXPORT_SYMBOL_GPL(devlink_rate_leaf_create);
9255 * devlink_rate_leaf_destroy - destroy devlink rate leaf
9257 * @devlink_port: devlink port linked to the rate object
9259 * Context: Takes and release devlink->lock <mutex>.
9261 void devlink_rate_leaf_destroy(struct devlink_port *devlink_port)
9263 struct devlink_rate *devlink_rate = devlink_port->devlink_rate;
9264 struct devlink *devlink = devlink_port->devlink;
9269 mutex_lock(&devlink->lock);
9270 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_DEL);
9271 if (devlink_rate->parent)
9272 refcount_dec(&devlink_rate->parent->refcnt);
9273 list_del(&devlink_rate->list);
9274 devlink_port->devlink_rate = NULL;
9275 mutex_unlock(&devlink->lock);
9276 kfree(devlink_rate);
9278 EXPORT_SYMBOL_GPL(devlink_rate_leaf_destroy);
9281 * devlink_rate_nodes_destroy - destroy all devlink rate nodes on device
9283 * @devlink: devlink instance
9285 * Unset parent for all rate objects and destroy all rate nodes
9286 * on specified device.
9288 * Context: Takes and release devlink->lock <mutex>.
9290 void devlink_rate_nodes_destroy(struct devlink *devlink)
9292 static struct devlink_rate *devlink_rate, *tmp;
9293 const struct devlink_ops *ops = devlink->ops;
9295 mutex_lock(&devlink->lock);
9296 list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
9297 if (!devlink_rate->parent)
9300 refcount_dec(&devlink_rate->parent->refcnt);
9301 if (devlink_rate_is_leaf(devlink_rate))
9302 ops->rate_leaf_parent_set(devlink_rate, NULL, devlink_rate->priv,
9304 else if (devlink_rate_is_node(devlink_rate))
9305 ops->rate_node_parent_set(devlink_rate, NULL, devlink_rate->priv,
9308 list_for_each_entry_safe(devlink_rate, tmp, &devlink->rate_list, list) {
9309 if (devlink_rate_is_node(devlink_rate)) {
9310 ops->rate_node_del(devlink_rate, devlink_rate->priv, NULL);
9311 list_del(&devlink_rate->list);
9312 kfree(devlink_rate->name);
9313 kfree(devlink_rate);
9316 mutex_unlock(&devlink->lock);
9318 EXPORT_SYMBOL_GPL(devlink_rate_nodes_destroy);
9320 static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port,
9321 char *name, size_t len)
9323 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9326 if (!devlink_port->attrs_set)
9329 switch (attrs->flavour) {
9330 case DEVLINK_PORT_FLAVOUR_PHYSICAL:
9331 n = snprintf(name, len, "p%u", attrs->phys.port_number);
9332 if (n < len && attrs->split)
9333 n += snprintf(name + n, len - n, "s%u",
9334 attrs->phys.split_subport_number);
9336 case DEVLINK_PORT_FLAVOUR_CPU:
9337 case DEVLINK_PORT_FLAVOUR_DSA:
9338 case DEVLINK_PORT_FLAVOUR_UNUSED:
9339 /* As CPU and DSA ports do not have a netdevice associated
9340 * case should not ever happen.
9344 case DEVLINK_PORT_FLAVOUR_PCI_PF:
9345 if (attrs->pci_pf.external) {
9346 n = snprintf(name, len, "c%u", attrs->pci_pf.controller);
9352 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf);
9354 case DEVLINK_PORT_FLAVOUR_PCI_VF:
9355 if (attrs->pci_vf.external) {
9356 n = snprintf(name, len, "c%u", attrs->pci_vf.controller);
9362 n = snprintf(name, len, "pf%uvf%u",
9363 attrs->pci_vf.pf, attrs->pci_vf.vf);
9365 case DEVLINK_PORT_FLAVOUR_PCI_SF:
9366 if (attrs->pci_sf.external) {
9367 n = snprintf(name, len, "c%u", attrs->pci_sf.controller);
9373 n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf,
9376 case DEVLINK_PORT_FLAVOUR_VIRTUAL:
9386 int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
9387 u32 size, u16 ingress_pools_count,
9388 u16 egress_pools_count, u16 ingress_tc_count,
9389 u16 egress_tc_count)
9391 struct devlink_sb *devlink_sb;
9394 mutex_lock(&devlink->lock);
9395 if (devlink_sb_index_exists(devlink, sb_index)) {
9400 devlink_sb = kzalloc(sizeof(*devlink_sb), GFP_KERNEL);
9405 devlink_sb->index = sb_index;
9406 devlink_sb->size = size;
9407 devlink_sb->ingress_pools_count = ingress_pools_count;
9408 devlink_sb->egress_pools_count = egress_pools_count;
9409 devlink_sb->ingress_tc_count = ingress_tc_count;
9410 devlink_sb->egress_tc_count = egress_tc_count;
9411 list_add_tail(&devlink_sb->list, &devlink->sb_list);
9413 mutex_unlock(&devlink->lock);
9416 EXPORT_SYMBOL_GPL(devlink_sb_register);
9418 void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index)
9420 struct devlink_sb *devlink_sb;
9422 mutex_lock(&devlink->lock);
9423 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
9424 WARN_ON(!devlink_sb);
9425 list_del(&devlink_sb->list);
9426 mutex_unlock(&devlink->lock);
9429 EXPORT_SYMBOL_GPL(devlink_sb_unregister);
9432 * devlink_dpipe_headers_register - register dpipe headers
9435 * @dpipe_headers: dpipe header array
9437 * Register the headers supported by hardware.
9439 int devlink_dpipe_headers_register(struct devlink *devlink,
9440 struct devlink_dpipe_headers *dpipe_headers)
9442 mutex_lock(&devlink->lock);
9443 devlink->dpipe_headers = dpipe_headers;
9444 mutex_unlock(&devlink->lock);
9447 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register);
9450 * devlink_dpipe_headers_unregister - unregister dpipe headers
9454 * Unregister the headers supported by hardware.
9456 void devlink_dpipe_headers_unregister(struct devlink *devlink)
9458 mutex_lock(&devlink->lock);
9459 devlink->dpipe_headers = NULL;
9460 mutex_unlock(&devlink->lock);
9462 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister);
9465 * devlink_dpipe_table_counter_enabled - check if counter allocation
9468 * @table_name: tables name
9470 * Used by driver to check if counter allocation is required.
9471 * After counter allocation is turned on the table entries
9472 * are updated to include counter statistics.
9474 * After that point on the driver must respect the counter
9475 * state so that each entry added to the table is added
9478 bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
9479 const char *table_name)
9481 struct devlink_dpipe_table *table;
9485 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
9486 table_name, devlink);
9489 enabled = table->counters_enabled;
9493 EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
9496 * devlink_dpipe_table_register - register dpipe table
9499 * @table_name: table name
9500 * @table_ops: table ops
9502 * @counter_control_extern: external control for counters
9504 int devlink_dpipe_table_register(struct devlink *devlink,
9505 const char *table_name,
9506 struct devlink_dpipe_table_ops *table_ops,
9507 void *priv, bool counter_control_extern)
9509 struct devlink_dpipe_table *table;
9512 if (WARN_ON(!table_ops->size_get))
9515 mutex_lock(&devlink->lock);
9517 if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name,
9523 table = kzalloc(sizeof(*table), GFP_KERNEL);
9529 table->name = table_name;
9530 table->table_ops = table_ops;
9532 table->counter_control_extern = counter_control_extern;
9534 list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
9536 mutex_unlock(&devlink->lock);
9539 EXPORT_SYMBOL_GPL(devlink_dpipe_table_register);
9542 * devlink_dpipe_table_unregister - unregister dpipe table
9545 * @table_name: table name
9547 void devlink_dpipe_table_unregister(struct devlink *devlink,
9548 const char *table_name)
9550 struct devlink_dpipe_table *table;
9552 mutex_lock(&devlink->lock);
9553 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
9554 table_name, devlink);
9557 list_del_rcu(&table->list);
9558 mutex_unlock(&devlink->lock);
9559 kfree_rcu(table, rcu);
9562 mutex_unlock(&devlink->lock);
9564 EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister);
9567 * devlink_resource_register - devlink resource register
9570 * @resource_name: resource's name
9571 * @resource_size: resource's size
9572 * @resource_id: resource's id
9573 * @parent_resource_id: resource's parent id
9574 * @size_params: size parameters
9576 * Generic resources should reuse the same names across drivers.
9577 * Please see the generic resources list at:
9578 * Documentation/networking/devlink/devlink-resource.rst
9580 int devlink_resource_register(struct devlink *devlink,
9581 const char *resource_name,
9584 u64 parent_resource_id,
9585 const struct devlink_resource_size_params *size_params)
9587 struct devlink_resource *resource;
9588 struct list_head *resource_list;
9592 top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
9594 mutex_lock(&devlink->lock);
9595 resource = devlink_resource_find(devlink, NULL, resource_id);
9601 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
9607 if (top_hierarchy) {
9608 resource_list = &devlink->resource_list;
9610 struct devlink_resource *parent_resource;
9612 parent_resource = devlink_resource_find(devlink, NULL,
9613 parent_resource_id);
9614 if (parent_resource) {
9615 resource_list = &parent_resource->resource_list;
9616 resource->parent = parent_resource;
9624 resource->name = resource_name;
9625 resource->size = resource_size;
9626 resource->size_new = resource_size;
9627 resource->id = resource_id;
9628 resource->size_valid = true;
9629 memcpy(&resource->size_params, size_params,
9630 sizeof(resource->size_params));
9631 INIT_LIST_HEAD(&resource->resource_list);
9632 list_add_tail(&resource->list, resource_list);
9634 mutex_unlock(&devlink->lock);
9637 EXPORT_SYMBOL_GPL(devlink_resource_register);
9640 * devlink_resources_unregister - free all resources
9643 * @resource: resource
9645 void devlink_resources_unregister(struct devlink *devlink,
9646 struct devlink_resource *resource)
9648 struct devlink_resource *tmp, *child_resource;
9649 struct list_head *resource_list;
9652 resource_list = &resource->resource_list;
9654 resource_list = &devlink->resource_list;
9657 mutex_lock(&devlink->lock);
9659 list_for_each_entry_safe(child_resource, tmp, resource_list, list) {
9660 devlink_resources_unregister(devlink, child_resource);
9661 list_del(&child_resource->list);
9662 kfree(child_resource);
9666 mutex_unlock(&devlink->lock);
9668 EXPORT_SYMBOL_GPL(devlink_resources_unregister);
9671 * devlink_resource_size_get - get and update size
9674 * @resource_id: the requested resource id
9675 * @p_resource_size: ptr to update
9677 int devlink_resource_size_get(struct devlink *devlink,
9679 u64 *p_resource_size)
9681 struct devlink_resource *resource;
9684 mutex_lock(&devlink->lock);
9685 resource = devlink_resource_find(devlink, NULL, resource_id);
9690 *p_resource_size = resource->size_new;
9691 resource->size = resource->size_new;
9693 mutex_unlock(&devlink->lock);
9696 EXPORT_SYMBOL_GPL(devlink_resource_size_get);
9699 * devlink_dpipe_table_resource_set - set the resource id
9702 * @table_name: table name
9703 * @resource_id: resource id
9704 * @resource_units: number of resource's units consumed per table's entry
9706 int devlink_dpipe_table_resource_set(struct devlink *devlink,
9707 const char *table_name, u64 resource_id,
9710 struct devlink_dpipe_table *table;
9713 mutex_lock(&devlink->lock);
9714 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
9715 table_name, devlink);
9720 table->resource_id = resource_id;
9721 table->resource_units = resource_units;
9722 table->resource_valid = true;
9724 mutex_unlock(&devlink->lock);
9727 EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set);
9730 * devlink_resource_occ_get_register - register occupancy getter
9733 * @resource_id: resource id
9734 * @occ_get: occupancy getter callback
9735 * @occ_get_priv: occupancy getter callback priv
9737 void devlink_resource_occ_get_register(struct devlink *devlink,
9739 devlink_resource_occ_get_t *occ_get,
9742 struct devlink_resource *resource;
9744 mutex_lock(&devlink->lock);
9745 resource = devlink_resource_find(devlink, NULL, resource_id);
9746 if (WARN_ON(!resource))
9748 WARN_ON(resource->occ_get);
9750 resource->occ_get = occ_get;
9751 resource->occ_get_priv = occ_get_priv;
9753 mutex_unlock(&devlink->lock);
9755 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_register);
9758 * devlink_resource_occ_get_unregister - unregister occupancy getter
9761 * @resource_id: resource id
9763 void devlink_resource_occ_get_unregister(struct devlink *devlink,
9766 struct devlink_resource *resource;
9768 mutex_lock(&devlink->lock);
9769 resource = devlink_resource_find(devlink, NULL, resource_id);
9770 if (WARN_ON(!resource))
9772 WARN_ON(!resource->occ_get);
9774 resource->occ_get = NULL;
9775 resource->occ_get_priv = NULL;
9777 mutex_unlock(&devlink->lock);
9779 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_unregister);
9781 static int devlink_param_verify(const struct devlink_param *param)
9783 if (!param || !param->name || !param->supported_cmodes)
9786 return devlink_param_generic_verify(param);
9788 return devlink_param_driver_verify(param);
9791 static int __devlink_params_register(struct devlink *devlink,
9792 unsigned int port_index,
9793 struct list_head *param_list,
9794 const struct devlink_param *params,
9795 size_t params_count,
9796 enum devlink_command reg_cmd,
9797 enum devlink_command unreg_cmd)
9799 const struct devlink_param *param = params;
9803 mutex_lock(&devlink->lock);
9804 for (i = 0; i < params_count; i++, param++) {
9805 err = devlink_param_verify(param);
9809 err = devlink_param_register_one(devlink, port_index,
9810 param_list, param, reg_cmd);
9815 mutex_unlock(&devlink->lock);
9821 for (param--; i > 0; i--, param--)
9822 devlink_param_unregister_one(devlink, port_index, param_list,
9825 mutex_unlock(&devlink->lock);
9829 static void __devlink_params_unregister(struct devlink *devlink,
9830 unsigned int port_index,
9831 struct list_head *param_list,
9832 const struct devlink_param *params,
9833 size_t params_count,
9834 enum devlink_command cmd)
9836 const struct devlink_param *param = params;
9839 mutex_lock(&devlink->lock);
9840 for (i = 0; i < params_count; i++, param++)
9841 devlink_param_unregister_one(devlink, 0, param_list, param,
9843 mutex_unlock(&devlink->lock);
9847 * devlink_params_register - register configuration parameters
9850 * @params: configuration parameters array
9851 * @params_count: number of parameters provided
9853 * Register the configuration parameters supported by the driver.
9855 int devlink_params_register(struct devlink *devlink,
9856 const struct devlink_param *params,
9857 size_t params_count)
9859 return __devlink_params_register(devlink, 0, &devlink->param_list,
9860 params, params_count,
9861 DEVLINK_CMD_PARAM_NEW,
9862 DEVLINK_CMD_PARAM_DEL);
9864 EXPORT_SYMBOL_GPL(devlink_params_register);
9867 * devlink_params_unregister - unregister configuration parameters
9869 * @params: configuration parameters to unregister
9870 * @params_count: number of parameters provided
9872 void devlink_params_unregister(struct devlink *devlink,
9873 const struct devlink_param *params,
9874 size_t params_count)
9876 return __devlink_params_unregister(devlink, 0, &devlink->param_list,
9877 params, params_count,
9878 DEVLINK_CMD_PARAM_DEL);
9880 EXPORT_SYMBOL_GPL(devlink_params_unregister);
9883 * devlink_params_publish - publish configuration parameters
9887 * Publish previously registered configuration parameters.
9889 void devlink_params_publish(struct devlink *devlink)
9891 struct devlink_param_item *param_item;
9893 list_for_each_entry(param_item, &devlink->param_list, list) {
9894 if (param_item->published)
9896 param_item->published = true;
9897 devlink_param_notify(devlink, 0, param_item,
9898 DEVLINK_CMD_PARAM_NEW);
9901 EXPORT_SYMBOL_GPL(devlink_params_publish);
9904 * devlink_params_unpublish - unpublish configuration parameters
9908 * Unpublish previously registered configuration parameters.
9910 void devlink_params_unpublish(struct devlink *devlink)
9912 struct devlink_param_item *param_item;
9914 list_for_each_entry(param_item, &devlink->param_list, list) {
9915 if (!param_item->published)
9917 param_item->published = false;
9918 devlink_param_notify(devlink, 0, param_item,
9919 DEVLINK_CMD_PARAM_DEL);
9922 EXPORT_SYMBOL_GPL(devlink_params_unpublish);
9925 * devlink_port_params_register - register port configuration parameters
9927 * @devlink_port: devlink port
9928 * @params: configuration parameters array
9929 * @params_count: number of parameters provided
9931 * Register the configuration parameters supported by the port.
9933 int devlink_port_params_register(struct devlink_port *devlink_port,
9934 const struct devlink_param *params,
9935 size_t params_count)
9937 return __devlink_params_register(devlink_port->devlink,
9938 devlink_port->index,
9939 &devlink_port->param_list, params,
9941 DEVLINK_CMD_PORT_PARAM_NEW,
9942 DEVLINK_CMD_PORT_PARAM_DEL);
9944 EXPORT_SYMBOL_GPL(devlink_port_params_register);
9947 * devlink_port_params_unregister - unregister port configuration
9950 * @devlink_port: devlink port
9951 * @params: configuration parameters array
9952 * @params_count: number of parameters provided
9954 void devlink_port_params_unregister(struct devlink_port *devlink_port,
9955 const struct devlink_param *params,
9956 size_t params_count)
9958 return __devlink_params_unregister(devlink_port->devlink,
9959 devlink_port->index,
9960 &devlink_port->param_list,
9961 params, params_count,
9962 DEVLINK_CMD_PORT_PARAM_DEL);
9964 EXPORT_SYMBOL_GPL(devlink_port_params_unregister);
9967 __devlink_param_driverinit_value_get(struct list_head *param_list, u32 param_id,
9968 union devlink_param_value *init_val)
9970 struct devlink_param_item *param_item;
9972 param_item = devlink_param_find_by_id(param_list, param_id);
9976 if (!param_item->driverinit_value_valid ||
9977 !devlink_param_cmode_is_supported(param_item->param,
9978 DEVLINK_PARAM_CMODE_DRIVERINIT))
9981 if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
9982 strcpy(init_val->vstr, param_item->driverinit_value.vstr);
9984 *init_val = param_item->driverinit_value;
9990 __devlink_param_driverinit_value_set(struct devlink *devlink,
9991 unsigned int port_index,
9992 struct list_head *param_list, u32 param_id,
9993 union devlink_param_value init_val,
9994 enum devlink_command cmd)
9996 struct devlink_param_item *param_item;
9998 param_item = devlink_param_find_by_id(param_list, param_id);
10002 if (!devlink_param_cmode_is_supported(param_item->param,
10003 DEVLINK_PARAM_CMODE_DRIVERINIT))
10004 return -EOPNOTSUPP;
10006 if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
10007 strcpy(param_item->driverinit_value.vstr, init_val.vstr);
10009 param_item->driverinit_value = init_val;
10010 param_item->driverinit_value_valid = true;
10012 devlink_param_notify(devlink, port_index, param_item, cmd);
10017 * devlink_param_driverinit_value_get - get configuration parameter
10018 * value for driver initializing
10020 * @devlink: devlink
10021 * @param_id: parameter ID
10022 * @init_val: value of parameter in driverinit configuration mode
10024 * This function should be used by the driver to get driverinit
10025 * configuration for initialization after reload command.
10027 int devlink_param_driverinit_value_get(struct devlink *devlink, u32 param_id,
10028 union devlink_param_value *init_val)
10030 if (!devlink_reload_supported(devlink->ops))
10031 return -EOPNOTSUPP;
10033 return __devlink_param_driverinit_value_get(&devlink->param_list,
10034 param_id, init_val);
10036 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_get);
10039 * devlink_param_driverinit_value_set - set value of configuration
10040 * parameter for driverinit
10041 * configuration mode
10043 * @devlink: devlink
10044 * @param_id: parameter ID
10045 * @init_val: value of parameter to set for driverinit configuration mode
10047 * This function should be used by the driver to set driverinit
10048 * configuration mode default value.
10050 int devlink_param_driverinit_value_set(struct devlink *devlink, u32 param_id,
10051 union devlink_param_value init_val)
10053 return __devlink_param_driverinit_value_set(devlink, 0,
10054 &devlink->param_list,
10055 param_id, init_val,
10056 DEVLINK_CMD_PARAM_NEW);
10058 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_set);
10061 * devlink_port_param_driverinit_value_get - get configuration parameter
10062 * value for driver initializing
10064 * @devlink_port: devlink_port
10065 * @param_id: parameter ID
10066 * @init_val: value of parameter in driverinit configuration mode
10068 * This function should be used by the driver to get driverinit
10069 * configuration for initialization after reload command.
10071 int devlink_port_param_driverinit_value_get(struct devlink_port *devlink_port,
10073 union devlink_param_value *init_val)
10075 struct devlink *devlink = devlink_port->devlink;
10077 if (!devlink_reload_supported(devlink->ops))
10078 return -EOPNOTSUPP;
10080 return __devlink_param_driverinit_value_get(&devlink_port->param_list,
10081 param_id, init_val);
10083 EXPORT_SYMBOL_GPL(devlink_port_param_driverinit_value_get);
10086 * devlink_port_param_driverinit_value_set - set value of configuration
10087 * parameter for driverinit
10088 * configuration mode
10090 * @devlink_port: devlink_port
10091 * @param_id: parameter ID
10092 * @init_val: value of parameter to set for driverinit configuration mode
10094 * This function should be used by the driver to set driverinit
10095 * configuration mode default value.
10097 int devlink_port_param_driverinit_value_set(struct devlink_port *devlink_port,
10099 union devlink_param_value init_val)
10101 return __devlink_param_driverinit_value_set(devlink_port->devlink,
10102 devlink_port->index,
10103 &devlink_port->param_list,
10104 param_id, init_val,
10105 DEVLINK_CMD_PORT_PARAM_NEW);
10107 EXPORT_SYMBOL_GPL(devlink_port_param_driverinit_value_set);
10110 * devlink_param_value_changed - notify devlink on a parameter's value
10111 * change. Should be called by the driver
10112 * right after the change.
10114 * @devlink: devlink
10115 * @param_id: parameter ID
10117 * This function should be used by the driver to notify devlink on value
10118 * change, excluding driverinit configuration mode.
10119 * For driverinit configuration mode driver should use the function
10121 void devlink_param_value_changed(struct devlink *devlink, u32 param_id)
10123 struct devlink_param_item *param_item;
10125 param_item = devlink_param_find_by_id(&devlink->param_list, param_id);
10126 WARN_ON(!param_item);
10128 devlink_param_notify(devlink, 0, param_item, DEVLINK_CMD_PARAM_NEW);
10130 EXPORT_SYMBOL_GPL(devlink_param_value_changed);
10133 * devlink_port_param_value_changed - notify devlink on a parameter's value
10134 * change. Should be called by the driver
10135 * right after the change.
10137 * @devlink_port: devlink_port
10138 * @param_id: parameter ID
10140 * This function should be used by the driver to notify devlink on value
10141 * change, excluding driverinit configuration mode.
10142 * For driverinit configuration mode driver should use the function
10143 * devlink_port_param_driverinit_value_set() instead.
10145 void devlink_port_param_value_changed(struct devlink_port *devlink_port,
10148 struct devlink_param_item *param_item;
10150 param_item = devlink_param_find_by_id(&devlink_port->param_list,
10152 WARN_ON(!param_item);
10154 devlink_param_notify(devlink_port->devlink, devlink_port->index,
10155 param_item, DEVLINK_CMD_PORT_PARAM_NEW);
10157 EXPORT_SYMBOL_GPL(devlink_port_param_value_changed);
10160 * devlink_param_value_str_fill - Safely fill-up the string preventing
10161 * from overflow of the preallocated buffer
10163 * @dst_val: destination devlink_param_value
10164 * @src: source buffer
10166 void devlink_param_value_str_fill(union devlink_param_value *dst_val,
10171 len = strlcpy(dst_val->vstr, src, __DEVLINK_PARAM_MAX_STRING_VALUE);
10172 WARN_ON(len >= __DEVLINK_PARAM_MAX_STRING_VALUE);
10174 EXPORT_SYMBOL_GPL(devlink_param_value_str_fill);
10177 * devlink_region_create - create a new address region
10179 * @devlink: devlink
10180 * @ops: region operations and name
10181 * @region_max_snapshots: Maximum supported number of snapshots for region
10182 * @region_size: size of region
10184 struct devlink_region *
10185 devlink_region_create(struct devlink *devlink,
10186 const struct devlink_region_ops *ops,
10187 u32 region_max_snapshots, u64 region_size)
10189 struct devlink_region *region;
10192 if (WARN_ON(!ops) || WARN_ON(!ops->destructor))
10193 return ERR_PTR(-EINVAL);
10195 mutex_lock(&devlink->lock);
10197 if (devlink_region_get_by_name(devlink, ops->name)) {
10202 region = kzalloc(sizeof(*region), GFP_KERNEL);
10208 region->devlink = devlink;
10209 region->max_snapshots = region_max_snapshots;
10211 region->size = region_size;
10212 INIT_LIST_HEAD(®ion->snapshot_list);
10213 list_add_tail(®ion->list, &devlink->region_list);
10214 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
10216 mutex_unlock(&devlink->lock);
10220 mutex_unlock(&devlink->lock);
10221 return ERR_PTR(err);
10223 EXPORT_SYMBOL_GPL(devlink_region_create);
10226 * devlink_port_region_create - create a new address region for a port
10228 * @port: devlink port
10229 * @ops: region operations and name
10230 * @region_max_snapshots: Maximum supported number of snapshots for region
10231 * @region_size: size of region
10233 struct devlink_region *
10234 devlink_port_region_create(struct devlink_port *port,
10235 const struct devlink_port_region_ops *ops,
10236 u32 region_max_snapshots, u64 region_size)
10238 struct devlink *devlink = port->devlink;
10239 struct devlink_region *region;
10242 if (WARN_ON(!ops) || WARN_ON(!ops->destructor))
10243 return ERR_PTR(-EINVAL);
10245 mutex_lock(&devlink->lock);
10247 if (devlink_port_region_get_by_name(port, ops->name)) {
10252 region = kzalloc(sizeof(*region), GFP_KERNEL);
10258 region->devlink = devlink;
10259 region->port = port;
10260 region->max_snapshots = region_max_snapshots;
10261 region->port_ops = ops;
10262 region->size = region_size;
10263 INIT_LIST_HEAD(®ion->snapshot_list);
10264 list_add_tail(®ion->list, &port->region_list);
10265 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
10267 mutex_unlock(&devlink->lock);
10271 mutex_unlock(&devlink->lock);
10272 return ERR_PTR(err);
10274 EXPORT_SYMBOL_GPL(devlink_port_region_create);
10277 * devlink_region_destroy - destroy address region
10279 * @region: devlink region to destroy
10281 void devlink_region_destroy(struct devlink_region *region)
10283 struct devlink *devlink = region->devlink;
10284 struct devlink_snapshot *snapshot, *ts;
10286 mutex_lock(&devlink->lock);
10288 /* Free all snapshots of region */
10289 list_for_each_entry_safe(snapshot, ts, ®ion->snapshot_list, list)
10290 devlink_region_snapshot_del(region, snapshot);
10292 list_del(®ion->list);
10294 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_DEL);
10295 mutex_unlock(&devlink->lock);
10298 EXPORT_SYMBOL_GPL(devlink_region_destroy);
10301 * devlink_region_snapshot_id_get - get snapshot ID
10303 * This callback should be called when adding a new snapshot,
10304 * Driver should use the same id for multiple snapshots taken
10305 * on multiple regions at the same time/by the same trigger.
10307 * The caller of this function must use devlink_region_snapshot_id_put
10308 * when finished creating regions using this id.
10310 * Returns zero on success, or a negative error code on failure.
10312 * @devlink: devlink
10313 * @id: storage to return id
10315 int devlink_region_snapshot_id_get(struct devlink *devlink, u32 *id)
10319 mutex_lock(&devlink->lock);
10320 err = __devlink_region_snapshot_id_get(devlink, id);
10321 mutex_unlock(&devlink->lock);
10325 EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_get);
10328 * devlink_region_snapshot_id_put - put snapshot ID reference
10330 * This should be called by a driver after finishing creating snapshots
10331 * with an id. Doing so ensures that the ID can later be released in the
10332 * event that all snapshots using it have been destroyed.
10334 * @devlink: devlink
10335 * @id: id to release reference on
10337 void devlink_region_snapshot_id_put(struct devlink *devlink, u32 id)
10339 mutex_lock(&devlink->lock);
10340 __devlink_snapshot_id_decrement(devlink, id);
10341 mutex_unlock(&devlink->lock);
10343 EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_put);
10346 * devlink_region_snapshot_create - create a new snapshot
10347 * This will add a new snapshot of a region. The snapshot
10348 * will be stored on the region struct and can be accessed
10349 * from devlink. This is useful for future analyses of snapshots.
10350 * Multiple snapshots can be created on a region.
10351 * The @snapshot_id should be obtained using the getter function.
10353 * @region: devlink region of the snapshot
10354 * @data: snapshot data
10355 * @snapshot_id: snapshot id to be created
10357 int devlink_region_snapshot_create(struct devlink_region *region,
10358 u8 *data, u32 snapshot_id)
10360 struct devlink *devlink = region->devlink;
10363 mutex_lock(&devlink->lock);
10364 err = __devlink_region_snapshot_create(region, data, snapshot_id);
10365 mutex_unlock(&devlink->lock);
10369 EXPORT_SYMBOL_GPL(devlink_region_snapshot_create);
10371 #define DEVLINK_TRAP(_id, _type) \
10373 .type = DEVLINK_TRAP_TYPE_##_type, \
10374 .id = DEVLINK_TRAP_GENERIC_ID_##_id, \
10375 .name = DEVLINK_TRAP_GENERIC_NAME_##_id, \
10378 static const struct devlink_trap devlink_trap_generic[] = {
10379 DEVLINK_TRAP(SMAC_MC, DROP),
10380 DEVLINK_TRAP(VLAN_TAG_MISMATCH, DROP),
10381 DEVLINK_TRAP(INGRESS_VLAN_FILTER, DROP),
10382 DEVLINK_TRAP(INGRESS_STP_FILTER, DROP),
10383 DEVLINK_TRAP(EMPTY_TX_LIST, DROP),
10384 DEVLINK_TRAP(PORT_LOOPBACK_FILTER, DROP),
10385 DEVLINK_TRAP(BLACKHOLE_ROUTE, DROP),
10386 DEVLINK_TRAP(TTL_ERROR, EXCEPTION),
10387 DEVLINK_TRAP(TAIL_DROP, DROP),
10388 DEVLINK_TRAP(NON_IP_PACKET, DROP),
10389 DEVLINK_TRAP(UC_DIP_MC_DMAC, DROP),
10390 DEVLINK_TRAP(DIP_LB, DROP),
10391 DEVLINK_TRAP(SIP_MC, DROP),
10392 DEVLINK_TRAP(SIP_LB, DROP),
10393 DEVLINK_TRAP(CORRUPTED_IP_HDR, DROP),
10394 DEVLINK_TRAP(IPV4_SIP_BC, DROP),
10395 DEVLINK_TRAP(IPV6_MC_DIP_RESERVED_SCOPE, DROP),
10396 DEVLINK_TRAP(IPV6_MC_DIP_INTERFACE_LOCAL_SCOPE, DROP),
10397 DEVLINK_TRAP(MTU_ERROR, EXCEPTION),
10398 DEVLINK_TRAP(UNRESOLVED_NEIGH, EXCEPTION),
10399 DEVLINK_TRAP(RPF, EXCEPTION),
10400 DEVLINK_TRAP(REJECT_ROUTE, EXCEPTION),
10401 DEVLINK_TRAP(IPV4_LPM_UNICAST_MISS, EXCEPTION),
10402 DEVLINK_TRAP(IPV6_LPM_UNICAST_MISS, EXCEPTION),
10403 DEVLINK_TRAP(NON_ROUTABLE, DROP),
10404 DEVLINK_TRAP(DECAP_ERROR, EXCEPTION),
10405 DEVLINK_TRAP(OVERLAY_SMAC_MC, DROP),
10406 DEVLINK_TRAP(INGRESS_FLOW_ACTION_DROP, DROP),
10407 DEVLINK_TRAP(EGRESS_FLOW_ACTION_DROP, DROP),
10408 DEVLINK_TRAP(STP, CONTROL),
10409 DEVLINK_TRAP(LACP, CONTROL),
10410 DEVLINK_TRAP(LLDP, CONTROL),
10411 DEVLINK_TRAP(IGMP_QUERY, CONTROL),
10412 DEVLINK_TRAP(IGMP_V1_REPORT, CONTROL),
10413 DEVLINK_TRAP(IGMP_V2_REPORT, CONTROL),
10414 DEVLINK_TRAP(IGMP_V3_REPORT, CONTROL),
10415 DEVLINK_TRAP(IGMP_V2_LEAVE, CONTROL),
10416 DEVLINK_TRAP(MLD_QUERY, CONTROL),
10417 DEVLINK_TRAP(MLD_V1_REPORT, CONTROL),
10418 DEVLINK_TRAP(MLD_V2_REPORT, CONTROL),
10419 DEVLINK_TRAP(MLD_V1_DONE, CONTROL),
10420 DEVLINK_TRAP(IPV4_DHCP, CONTROL),
10421 DEVLINK_TRAP(IPV6_DHCP, CONTROL),
10422 DEVLINK_TRAP(ARP_REQUEST, CONTROL),
10423 DEVLINK_TRAP(ARP_RESPONSE, CONTROL),
10424 DEVLINK_TRAP(ARP_OVERLAY, CONTROL),
10425 DEVLINK_TRAP(IPV6_NEIGH_SOLICIT, CONTROL),
10426 DEVLINK_TRAP(IPV6_NEIGH_ADVERT, CONTROL),
10427 DEVLINK_TRAP(IPV4_BFD, CONTROL),
10428 DEVLINK_TRAP(IPV6_BFD, CONTROL),
10429 DEVLINK_TRAP(IPV4_OSPF, CONTROL),
10430 DEVLINK_TRAP(IPV6_OSPF, CONTROL),
10431 DEVLINK_TRAP(IPV4_BGP, CONTROL),
10432 DEVLINK_TRAP(IPV6_BGP, CONTROL),
10433 DEVLINK_TRAP(IPV4_VRRP, CONTROL),
10434 DEVLINK_TRAP(IPV6_VRRP, CONTROL),
10435 DEVLINK_TRAP(IPV4_PIM, CONTROL),
10436 DEVLINK_TRAP(IPV6_PIM, CONTROL),
10437 DEVLINK_TRAP(UC_LB, CONTROL),
10438 DEVLINK_TRAP(LOCAL_ROUTE, CONTROL),
10439 DEVLINK_TRAP(EXTERNAL_ROUTE, CONTROL),
10440 DEVLINK_TRAP(IPV6_UC_DIP_LINK_LOCAL_SCOPE, CONTROL),
10441 DEVLINK_TRAP(IPV6_DIP_ALL_NODES, CONTROL),
10442 DEVLINK_TRAP(IPV6_DIP_ALL_ROUTERS, CONTROL),
10443 DEVLINK_TRAP(IPV6_ROUTER_SOLICIT, CONTROL),
10444 DEVLINK_TRAP(IPV6_ROUTER_ADVERT, CONTROL),
10445 DEVLINK_TRAP(IPV6_REDIRECT, CONTROL),
10446 DEVLINK_TRAP(IPV4_ROUTER_ALERT, CONTROL),
10447 DEVLINK_TRAP(IPV6_ROUTER_ALERT, CONTROL),
10448 DEVLINK_TRAP(PTP_EVENT, CONTROL),
10449 DEVLINK_TRAP(PTP_GENERAL, CONTROL),
10450 DEVLINK_TRAP(FLOW_ACTION_SAMPLE, CONTROL),
10451 DEVLINK_TRAP(FLOW_ACTION_TRAP, CONTROL),
10452 DEVLINK_TRAP(EARLY_DROP, DROP),
10453 DEVLINK_TRAP(VXLAN_PARSING, DROP),
10454 DEVLINK_TRAP(LLC_SNAP_PARSING, DROP),
10455 DEVLINK_TRAP(VLAN_PARSING, DROP),
10456 DEVLINK_TRAP(PPPOE_PPP_PARSING, DROP),
10457 DEVLINK_TRAP(MPLS_PARSING, DROP),
10458 DEVLINK_TRAP(ARP_PARSING, DROP),
10459 DEVLINK_TRAP(IP_1_PARSING, DROP),
10460 DEVLINK_TRAP(IP_N_PARSING, DROP),
10461 DEVLINK_TRAP(GRE_PARSING, DROP),
10462 DEVLINK_TRAP(UDP_PARSING, DROP),
10463 DEVLINK_TRAP(TCP_PARSING, DROP),
10464 DEVLINK_TRAP(IPSEC_PARSING, DROP),
10465 DEVLINK_TRAP(SCTP_PARSING, DROP),
10466 DEVLINK_TRAP(DCCP_PARSING, DROP),
10467 DEVLINK_TRAP(GTP_PARSING, DROP),
10468 DEVLINK_TRAP(ESP_PARSING, DROP),
10469 DEVLINK_TRAP(BLACKHOLE_NEXTHOP, DROP),
10470 DEVLINK_TRAP(DMAC_FILTER, DROP),
10473 #define DEVLINK_TRAP_GROUP(_id) \
10475 .id = DEVLINK_TRAP_GROUP_GENERIC_ID_##_id, \
10476 .name = DEVLINK_TRAP_GROUP_GENERIC_NAME_##_id, \
10479 static const struct devlink_trap_group devlink_trap_group_generic[] = {
10480 DEVLINK_TRAP_GROUP(L2_DROPS),
10481 DEVLINK_TRAP_GROUP(L3_DROPS),
10482 DEVLINK_TRAP_GROUP(L3_EXCEPTIONS),
10483 DEVLINK_TRAP_GROUP(BUFFER_DROPS),
10484 DEVLINK_TRAP_GROUP(TUNNEL_DROPS),
10485 DEVLINK_TRAP_GROUP(ACL_DROPS),
10486 DEVLINK_TRAP_GROUP(STP),
10487 DEVLINK_TRAP_GROUP(LACP),
10488 DEVLINK_TRAP_GROUP(LLDP),
10489 DEVLINK_TRAP_GROUP(MC_SNOOPING),
10490 DEVLINK_TRAP_GROUP(DHCP),
10491 DEVLINK_TRAP_GROUP(NEIGH_DISCOVERY),
10492 DEVLINK_TRAP_GROUP(BFD),
10493 DEVLINK_TRAP_GROUP(OSPF),
10494 DEVLINK_TRAP_GROUP(BGP),
10495 DEVLINK_TRAP_GROUP(VRRP),
10496 DEVLINK_TRAP_GROUP(PIM),
10497 DEVLINK_TRAP_GROUP(UC_LB),
10498 DEVLINK_TRAP_GROUP(LOCAL_DELIVERY),
10499 DEVLINK_TRAP_GROUP(EXTERNAL_DELIVERY),
10500 DEVLINK_TRAP_GROUP(IPV6),
10501 DEVLINK_TRAP_GROUP(PTP_EVENT),
10502 DEVLINK_TRAP_GROUP(PTP_GENERAL),
10503 DEVLINK_TRAP_GROUP(ACL_SAMPLE),
10504 DEVLINK_TRAP_GROUP(ACL_TRAP),
10505 DEVLINK_TRAP_GROUP(PARSER_ERROR_DROPS),
10508 static int devlink_trap_generic_verify(const struct devlink_trap *trap)
10510 if (trap->id > DEVLINK_TRAP_GENERIC_ID_MAX)
10513 if (strcmp(trap->name, devlink_trap_generic[trap->id].name))
10516 if (trap->type != devlink_trap_generic[trap->id].type)
10522 static int devlink_trap_driver_verify(const struct devlink_trap *trap)
10526 if (trap->id <= DEVLINK_TRAP_GENERIC_ID_MAX)
10529 for (i = 0; i < ARRAY_SIZE(devlink_trap_generic); i++) {
10530 if (!strcmp(trap->name, devlink_trap_generic[i].name))
10537 static int devlink_trap_verify(const struct devlink_trap *trap)
10539 if (!trap || !trap->name)
10543 return devlink_trap_generic_verify(trap);
10545 return devlink_trap_driver_verify(trap);
10549 devlink_trap_group_generic_verify(const struct devlink_trap_group *group)
10551 if (group->id > DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
10554 if (strcmp(group->name, devlink_trap_group_generic[group->id].name))
10561 devlink_trap_group_driver_verify(const struct devlink_trap_group *group)
10565 if (group->id <= DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
10568 for (i = 0; i < ARRAY_SIZE(devlink_trap_group_generic); i++) {
10569 if (!strcmp(group->name, devlink_trap_group_generic[i].name))
10576 static int devlink_trap_group_verify(const struct devlink_trap_group *group)
10578 if (group->generic)
10579 return devlink_trap_group_generic_verify(group);
10581 return devlink_trap_group_driver_verify(group);
10585 devlink_trap_group_notify(struct devlink *devlink,
10586 const struct devlink_trap_group_item *group_item,
10587 enum devlink_command cmd)
10589 struct sk_buff *msg;
10592 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_GROUP_NEW &&
10593 cmd != DEVLINK_CMD_TRAP_GROUP_DEL);
10595 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10599 err = devlink_nl_trap_group_fill(msg, devlink, group_item, cmd, 0, 0,
10606 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
10607 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
10611 devlink_trap_item_group_link(struct devlink *devlink,
10612 struct devlink_trap_item *trap_item)
10614 u16 group_id = trap_item->trap->init_group_id;
10615 struct devlink_trap_group_item *group_item;
10617 group_item = devlink_trap_group_item_lookup_by_id(devlink, group_id);
10618 if (WARN_ON_ONCE(!group_item))
10621 trap_item->group_item = group_item;
10626 static void devlink_trap_notify(struct devlink *devlink,
10627 const struct devlink_trap_item *trap_item,
10628 enum devlink_command cmd)
10630 struct sk_buff *msg;
10633 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_NEW &&
10634 cmd != DEVLINK_CMD_TRAP_DEL);
10636 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10640 err = devlink_nl_trap_fill(msg, devlink, trap_item, cmd, 0, 0, 0);
10646 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
10647 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
10651 devlink_trap_register(struct devlink *devlink,
10652 const struct devlink_trap *trap, void *priv)
10654 struct devlink_trap_item *trap_item;
10657 if (devlink_trap_item_lookup(devlink, trap->name))
10660 trap_item = kzalloc(sizeof(*trap_item), GFP_KERNEL);
10664 trap_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
10665 if (!trap_item->stats) {
10667 goto err_stats_alloc;
10670 trap_item->trap = trap;
10671 trap_item->action = trap->init_action;
10672 trap_item->priv = priv;
10674 err = devlink_trap_item_group_link(devlink, trap_item);
10676 goto err_group_link;
10678 err = devlink->ops->trap_init(devlink, trap, trap_item);
10680 goto err_trap_init;
10682 list_add_tail(&trap_item->list, &devlink->trap_list);
10683 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_NEW);
10689 free_percpu(trap_item->stats);
10695 static void devlink_trap_unregister(struct devlink *devlink,
10696 const struct devlink_trap *trap)
10698 struct devlink_trap_item *trap_item;
10700 trap_item = devlink_trap_item_lookup(devlink, trap->name);
10701 if (WARN_ON_ONCE(!trap_item))
10704 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_DEL);
10705 list_del(&trap_item->list);
10706 if (devlink->ops->trap_fini)
10707 devlink->ops->trap_fini(devlink, trap, trap_item);
10708 free_percpu(trap_item->stats);
10712 static void devlink_trap_disable(struct devlink *devlink,
10713 const struct devlink_trap *trap)
10715 struct devlink_trap_item *trap_item;
10717 trap_item = devlink_trap_item_lookup(devlink, trap->name);
10718 if (WARN_ON_ONCE(!trap_item))
10721 devlink->ops->trap_action_set(devlink, trap, DEVLINK_TRAP_ACTION_DROP,
10723 trap_item->action = DEVLINK_TRAP_ACTION_DROP;
10727 * devlink_traps_register - Register packet traps with devlink.
10728 * @devlink: devlink.
10729 * @traps: Packet traps.
10730 * @traps_count: Count of provided packet traps.
10731 * @priv: Driver private information.
10733 * Return: Non-zero value on failure.
10735 int devlink_traps_register(struct devlink *devlink,
10736 const struct devlink_trap *traps,
10737 size_t traps_count, void *priv)
10741 if (!devlink->ops->trap_init || !devlink->ops->trap_action_set)
10744 mutex_lock(&devlink->lock);
10745 for (i = 0; i < traps_count; i++) {
10746 const struct devlink_trap *trap = &traps[i];
10748 err = devlink_trap_verify(trap);
10750 goto err_trap_verify;
10752 err = devlink_trap_register(devlink, trap, priv);
10754 goto err_trap_register;
10756 mutex_unlock(&devlink->lock);
10762 for (i--; i >= 0; i--)
10763 devlink_trap_unregister(devlink, &traps[i]);
10764 mutex_unlock(&devlink->lock);
10767 EXPORT_SYMBOL_GPL(devlink_traps_register);
10770 * devlink_traps_unregister - Unregister packet traps from devlink.
10771 * @devlink: devlink.
10772 * @traps: Packet traps.
10773 * @traps_count: Count of provided packet traps.
10775 void devlink_traps_unregister(struct devlink *devlink,
10776 const struct devlink_trap *traps,
10777 size_t traps_count)
10781 mutex_lock(&devlink->lock);
10782 /* Make sure we do not have any packets in-flight while unregistering
10783 * traps by disabling all of them and waiting for a grace period.
10785 for (i = traps_count - 1; i >= 0; i--)
10786 devlink_trap_disable(devlink, &traps[i]);
10788 for (i = traps_count - 1; i >= 0; i--)
10789 devlink_trap_unregister(devlink, &traps[i]);
10790 mutex_unlock(&devlink->lock);
10792 EXPORT_SYMBOL_GPL(devlink_traps_unregister);
10795 devlink_trap_stats_update(struct devlink_stats __percpu *trap_stats,
10798 struct devlink_stats *stats;
10800 stats = this_cpu_ptr(trap_stats);
10801 u64_stats_update_begin(&stats->syncp);
10802 stats->rx_bytes += skb_len;
10803 stats->rx_packets++;
10804 u64_stats_update_end(&stats->syncp);
10808 devlink_trap_report_metadata_set(struct devlink_trap_metadata *metadata,
10809 const struct devlink_trap_item *trap_item,
10810 struct devlink_port *in_devlink_port,
10811 const struct flow_action_cookie *fa_cookie)
10813 metadata->trap_name = trap_item->trap->name;
10814 metadata->trap_group_name = trap_item->group_item->group->name;
10815 metadata->fa_cookie = fa_cookie;
10816 metadata->trap_type = trap_item->trap->type;
10818 spin_lock(&in_devlink_port->type_lock);
10819 if (in_devlink_port->type == DEVLINK_PORT_TYPE_ETH)
10820 metadata->input_dev = in_devlink_port->type_dev;
10821 spin_unlock(&in_devlink_port->type_lock);
10825 * devlink_trap_report - Report trapped packet to drop monitor.
10826 * @devlink: devlink.
10827 * @skb: Trapped packet.
10828 * @trap_ctx: Trap context.
10829 * @in_devlink_port: Input devlink port.
10830 * @fa_cookie: Flow action cookie. Could be NULL.
10832 void devlink_trap_report(struct devlink *devlink, struct sk_buff *skb,
10833 void *trap_ctx, struct devlink_port *in_devlink_port,
10834 const struct flow_action_cookie *fa_cookie)
10837 struct devlink_trap_item *trap_item = trap_ctx;
10839 devlink_trap_stats_update(trap_item->stats, skb->len);
10840 devlink_trap_stats_update(trap_item->group_item->stats, skb->len);
10842 if (trace_devlink_trap_report_enabled()) {
10843 struct devlink_trap_metadata metadata = {};
10845 devlink_trap_report_metadata_set(&metadata, trap_item,
10846 in_devlink_port, fa_cookie);
10847 trace_devlink_trap_report(devlink, skb, &metadata);
10850 EXPORT_SYMBOL_GPL(devlink_trap_report);
10853 * devlink_trap_ctx_priv - Trap context to driver private information.
10854 * @trap_ctx: Trap context.
10856 * Return: Driver private information passed during registration.
10858 void *devlink_trap_ctx_priv(void *trap_ctx)
10860 struct devlink_trap_item *trap_item = trap_ctx;
10862 return trap_item->priv;
10864 EXPORT_SYMBOL_GPL(devlink_trap_ctx_priv);
10867 devlink_trap_group_item_policer_link(struct devlink *devlink,
10868 struct devlink_trap_group_item *group_item)
10870 u32 policer_id = group_item->group->init_policer_id;
10871 struct devlink_trap_policer_item *policer_item;
10873 if (policer_id == 0)
10876 policer_item = devlink_trap_policer_item_lookup(devlink, policer_id);
10877 if (WARN_ON_ONCE(!policer_item))
10880 group_item->policer_item = policer_item;
10886 devlink_trap_group_register(struct devlink *devlink,
10887 const struct devlink_trap_group *group)
10889 struct devlink_trap_group_item *group_item;
10892 if (devlink_trap_group_item_lookup(devlink, group->name))
10895 group_item = kzalloc(sizeof(*group_item), GFP_KERNEL);
10899 group_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
10900 if (!group_item->stats) {
10902 goto err_stats_alloc;
10905 group_item->group = group;
10907 err = devlink_trap_group_item_policer_link(devlink, group_item);
10909 goto err_policer_link;
10911 if (devlink->ops->trap_group_init) {
10912 err = devlink->ops->trap_group_init(devlink, group);
10914 goto err_group_init;
10917 list_add_tail(&group_item->list, &devlink->trap_group_list);
10918 devlink_trap_group_notify(devlink, group_item,
10919 DEVLINK_CMD_TRAP_GROUP_NEW);
10925 free_percpu(group_item->stats);
10932 devlink_trap_group_unregister(struct devlink *devlink,
10933 const struct devlink_trap_group *group)
10935 struct devlink_trap_group_item *group_item;
10937 group_item = devlink_trap_group_item_lookup(devlink, group->name);
10938 if (WARN_ON_ONCE(!group_item))
10941 devlink_trap_group_notify(devlink, group_item,
10942 DEVLINK_CMD_TRAP_GROUP_DEL);
10943 list_del(&group_item->list);
10944 free_percpu(group_item->stats);
10949 * devlink_trap_groups_register - Register packet trap groups with devlink.
10950 * @devlink: devlink.
10951 * @groups: Packet trap groups.
10952 * @groups_count: Count of provided packet trap groups.
10954 * Return: Non-zero value on failure.
10956 int devlink_trap_groups_register(struct devlink *devlink,
10957 const struct devlink_trap_group *groups,
10958 size_t groups_count)
10962 mutex_lock(&devlink->lock);
10963 for (i = 0; i < groups_count; i++) {
10964 const struct devlink_trap_group *group = &groups[i];
10966 err = devlink_trap_group_verify(group);
10968 goto err_trap_group_verify;
10970 err = devlink_trap_group_register(devlink, group);
10972 goto err_trap_group_register;
10974 mutex_unlock(&devlink->lock);
10978 err_trap_group_register:
10979 err_trap_group_verify:
10980 for (i--; i >= 0; i--)
10981 devlink_trap_group_unregister(devlink, &groups[i]);
10982 mutex_unlock(&devlink->lock);
10985 EXPORT_SYMBOL_GPL(devlink_trap_groups_register);
10988 * devlink_trap_groups_unregister - Unregister packet trap groups from devlink.
10989 * @devlink: devlink.
10990 * @groups: Packet trap groups.
10991 * @groups_count: Count of provided packet trap groups.
10993 void devlink_trap_groups_unregister(struct devlink *devlink,
10994 const struct devlink_trap_group *groups,
10995 size_t groups_count)
10999 mutex_lock(&devlink->lock);
11000 for (i = groups_count - 1; i >= 0; i--)
11001 devlink_trap_group_unregister(devlink, &groups[i]);
11002 mutex_unlock(&devlink->lock);
11004 EXPORT_SYMBOL_GPL(devlink_trap_groups_unregister);
11007 devlink_trap_policer_notify(struct devlink *devlink,
11008 const struct devlink_trap_policer_item *policer_item,
11009 enum devlink_command cmd)
11011 struct sk_buff *msg;
11014 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_POLICER_NEW &&
11015 cmd != DEVLINK_CMD_TRAP_POLICER_DEL);
11017 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11021 err = devlink_nl_trap_policer_fill(msg, devlink, policer_item, cmd, 0,
11028 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
11029 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
11033 devlink_trap_policer_register(struct devlink *devlink,
11034 const struct devlink_trap_policer *policer)
11036 struct devlink_trap_policer_item *policer_item;
11039 if (devlink_trap_policer_item_lookup(devlink, policer->id))
11042 policer_item = kzalloc(sizeof(*policer_item), GFP_KERNEL);
11046 policer_item->policer = policer;
11047 policer_item->rate = policer->init_rate;
11048 policer_item->burst = policer->init_burst;
11050 if (devlink->ops->trap_policer_init) {
11051 err = devlink->ops->trap_policer_init(devlink, policer);
11053 goto err_policer_init;
11056 list_add_tail(&policer_item->list, &devlink->trap_policer_list);
11057 devlink_trap_policer_notify(devlink, policer_item,
11058 DEVLINK_CMD_TRAP_POLICER_NEW);
11063 kfree(policer_item);
11068 devlink_trap_policer_unregister(struct devlink *devlink,
11069 const struct devlink_trap_policer *policer)
11071 struct devlink_trap_policer_item *policer_item;
11073 policer_item = devlink_trap_policer_item_lookup(devlink, policer->id);
11074 if (WARN_ON_ONCE(!policer_item))
11077 devlink_trap_policer_notify(devlink, policer_item,
11078 DEVLINK_CMD_TRAP_POLICER_DEL);
11079 list_del(&policer_item->list);
11080 if (devlink->ops->trap_policer_fini)
11081 devlink->ops->trap_policer_fini(devlink, policer);
11082 kfree(policer_item);
11086 * devlink_trap_policers_register - Register packet trap policers with devlink.
11087 * @devlink: devlink.
11088 * @policers: Packet trap policers.
11089 * @policers_count: Count of provided packet trap policers.
11091 * Return: Non-zero value on failure.
11094 devlink_trap_policers_register(struct devlink *devlink,
11095 const struct devlink_trap_policer *policers,
11096 size_t policers_count)
11100 mutex_lock(&devlink->lock);
11101 for (i = 0; i < policers_count; i++) {
11102 const struct devlink_trap_policer *policer = &policers[i];
11104 if (WARN_ON(policer->id == 0 ||
11105 policer->max_rate < policer->min_rate ||
11106 policer->max_burst < policer->min_burst)) {
11108 goto err_trap_policer_verify;
11111 err = devlink_trap_policer_register(devlink, policer);
11113 goto err_trap_policer_register;
11115 mutex_unlock(&devlink->lock);
11119 err_trap_policer_register:
11120 err_trap_policer_verify:
11121 for (i--; i >= 0; i--)
11122 devlink_trap_policer_unregister(devlink, &policers[i]);
11123 mutex_unlock(&devlink->lock);
11126 EXPORT_SYMBOL_GPL(devlink_trap_policers_register);
11129 * devlink_trap_policers_unregister - Unregister packet trap policers from devlink.
11130 * @devlink: devlink.
11131 * @policers: Packet trap policers.
11132 * @policers_count: Count of provided packet trap policers.
11135 devlink_trap_policers_unregister(struct devlink *devlink,
11136 const struct devlink_trap_policer *policers,
11137 size_t policers_count)
11141 mutex_lock(&devlink->lock);
11142 for (i = policers_count - 1; i >= 0; i--)
11143 devlink_trap_policer_unregister(devlink, &policers[i]);
11144 mutex_unlock(&devlink->lock);
11146 EXPORT_SYMBOL_GPL(devlink_trap_policers_unregister);
11148 static void __devlink_compat_running_version(struct devlink *devlink,
11149 char *buf, size_t len)
11151 const struct nlattr *nlattr;
11152 struct devlink_info_req req;
11153 struct sk_buff *msg;
11156 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11161 err = devlink->ops->info_get(devlink, &req, NULL);
11165 nla_for_each_attr(nlattr, (void *)msg->data, msg->len, rem) {
11166 const struct nlattr *kv;
11169 if (nla_type(nlattr) != DEVLINK_ATTR_INFO_VERSION_RUNNING)
11172 nla_for_each_nested(kv, nlattr, rem_kv) {
11173 if (nla_type(kv) != DEVLINK_ATTR_INFO_VERSION_VALUE)
11176 strlcat(buf, nla_data(kv), len);
11177 strlcat(buf, " ", len);
11184 void devlink_compat_running_version(struct net_device *dev,
11185 char *buf, size_t len)
11187 struct devlink *devlink;
11192 devlink = netdev_to_devlink(dev);
11193 if (!devlink || !devlink->ops->info_get)
11196 mutex_lock(&devlink->lock);
11197 __devlink_compat_running_version(devlink, buf, len);
11198 mutex_unlock(&devlink->lock);
11205 int devlink_compat_flash_update(struct net_device *dev, const char *file_name)
11207 struct devlink_flash_update_params params = {};
11208 struct devlink *devlink;
11214 devlink = netdev_to_devlink(dev);
11215 if (!devlink || !devlink->ops->flash_update) {
11220 ret = request_firmware(¶ms.fw, file_name, devlink->dev);
11224 mutex_lock(&devlink->lock);
11225 devlink_flash_update_begin_notify(devlink);
11226 ret = devlink->ops->flash_update(devlink, ¶ms, NULL);
11227 devlink_flash_update_end_notify(devlink);
11228 mutex_unlock(&devlink->lock);
11230 release_firmware(params.fw);
11239 int devlink_compat_phys_port_name_get(struct net_device *dev,
11240 char *name, size_t len)
11242 struct devlink_port *devlink_port;
11244 /* RTNL mutex is held here which ensures that devlink_port
11245 * instance cannot disappear in the middle. No need to take
11246 * any devlink lock as only permanent values are accessed.
11250 devlink_port = netdev_to_devlink_port(dev);
11252 return -EOPNOTSUPP;
11254 return __devlink_port_phys_port_name_get(devlink_port, name, len);
11257 int devlink_compat_switch_id_get(struct net_device *dev,
11258 struct netdev_phys_item_id *ppid)
11260 struct devlink_port *devlink_port;
11262 /* Caller must hold RTNL mutex or reference to dev, which ensures that
11263 * devlink_port instance cannot disappear in the middle. No need to take
11264 * any devlink lock as only permanent values are accessed.
11266 devlink_port = netdev_to_devlink_port(dev);
11267 if (!devlink_port || !devlink_port->switch_port)
11268 return -EOPNOTSUPP;
11270 memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid));
11275 static void __net_exit devlink_pernet_pre_exit(struct net *net)
11277 struct devlink *devlink;
11278 u32 actions_performed;
11281 /* In case network namespace is getting destroyed, reload
11282 * all devlink instances from this namespace into init_net.
11284 mutex_lock(&devlink_mutex);
11285 list_for_each_entry(devlink, &devlink_list, list) {
11286 if (net_eq(devlink_net(devlink), net)) {
11287 if (WARN_ON(!devlink_reload_supported(devlink->ops)))
11289 err = devlink_reload(devlink, &init_net,
11290 DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
11291 DEVLINK_RELOAD_LIMIT_UNSPEC,
11292 &actions_performed, NULL);
11293 if (err && err != -EOPNOTSUPP)
11294 pr_warn("Failed to reload devlink instance into init_net\n");
11297 mutex_unlock(&devlink_mutex);
11300 static struct pernet_operations devlink_pernet_ops __net_initdata = {
11301 .pre_exit = devlink_pernet_pre_exit,
11304 static int __init devlink_init(void)
11308 err = genl_register_family(&devlink_nl_family);
11311 err = register_pernet_subsys(&devlink_pernet_ops);
11318 subsys_initcall(devlink_init);