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 #include <net/drop_monitor.h>
31 #define CREATE_TRACE_POINTS
32 #include <trace/events/devlink.h>
34 static struct devlink_dpipe_field devlink_dpipe_fields_ethernet[] = {
36 .name = "destination mac",
37 .id = DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC,
42 struct devlink_dpipe_header devlink_dpipe_header_ethernet = {
44 .id = DEVLINK_DPIPE_HEADER_ETHERNET,
45 .fields = devlink_dpipe_fields_ethernet,
46 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ethernet),
49 EXPORT_SYMBOL(devlink_dpipe_header_ethernet);
51 static struct devlink_dpipe_field devlink_dpipe_fields_ipv4[] = {
53 .name = "destination ip",
54 .id = DEVLINK_DPIPE_FIELD_IPV4_DST_IP,
59 struct devlink_dpipe_header devlink_dpipe_header_ipv4 = {
61 .id = DEVLINK_DPIPE_HEADER_IPV4,
62 .fields = devlink_dpipe_fields_ipv4,
63 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv4),
66 EXPORT_SYMBOL(devlink_dpipe_header_ipv4);
68 static struct devlink_dpipe_field devlink_dpipe_fields_ipv6[] = {
70 .name = "destination ip",
71 .id = DEVLINK_DPIPE_FIELD_IPV6_DST_IP,
76 struct devlink_dpipe_header devlink_dpipe_header_ipv6 = {
78 .id = DEVLINK_DPIPE_HEADER_IPV6,
79 .fields = devlink_dpipe_fields_ipv6,
80 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv6),
83 EXPORT_SYMBOL(devlink_dpipe_header_ipv6);
85 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg);
86 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwerr);
88 static LIST_HEAD(devlink_list);
92 * An overall lock guarding every operation coming from userspace.
93 * It also guards devlink devices list and it is taken when
94 * driver registers/unregisters it.
96 static DEFINE_MUTEX(devlink_mutex);
98 struct net *devlink_net(const struct devlink *devlink)
100 return read_pnet(&devlink->_net);
102 EXPORT_SYMBOL_GPL(devlink_net);
104 static void devlink_net_set(struct devlink *devlink, struct net *net)
106 write_pnet(&devlink->_net, net);
109 static struct devlink *devlink_get_from_attrs(struct net *net,
110 struct nlattr **attrs)
112 struct devlink *devlink;
116 if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
117 return ERR_PTR(-EINVAL);
119 busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
120 devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
122 lockdep_assert_held(&devlink_mutex);
124 list_for_each_entry(devlink, &devlink_list, list) {
125 if (strcmp(devlink->dev->bus->name, busname) == 0 &&
126 strcmp(dev_name(devlink->dev), devname) == 0 &&
127 net_eq(devlink_net(devlink), net))
131 return ERR_PTR(-ENODEV);
134 static struct devlink *devlink_get_from_info(struct genl_info *info)
136 return devlink_get_from_attrs(genl_info_net(info), info->attrs);
139 static struct devlink_port *devlink_port_get_by_index(struct devlink *devlink,
140 unsigned int port_index)
142 struct devlink_port *devlink_port;
144 list_for_each_entry(devlink_port, &devlink->port_list, list) {
145 if (devlink_port->index == port_index)
151 static bool devlink_port_index_exists(struct devlink *devlink,
152 unsigned int port_index)
154 return devlink_port_get_by_index(devlink, port_index);
157 static struct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink,
158 struct nlattr **attrs)
160 if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
161 u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
162 struct devlink_port *devlink_port;
164 devlink_port = devlink_port_get_by_index(devlink, port_index);
166 return ERR_PTR(-ENODEV);
169 return ERR_PTR(-EINVAL);
172 static struct devlink_port *devlink_port_get_from_info(struct devlink *devlink,
173 struct genl_info *info)
175 return devlink_port_get_from_attrs(devlink, info->attrs);
179 struct list_head list;
182 u16 ingress_pools_count;
183 u16 egress_pools_count;
184 u16 ingress_tc_count;
188 static u16 devlink_sb_pool_count(struct devlink_sb *devlink_sb)
190 return devlink_sb->ingress_pools_count + devlink_sb->egress_pools_count;
193 static struct devlink_sb *devlink_sb_get_by_index(struct devlink *devlink,
194 unsigned int sb_index)
196 struct devlink_sb *devlink_sb;
198 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
199 if (devlink_sb->index == sb_index)
205 static bool devlink_sb_index_exists(struct devlink *devlink,
206 unsigned int sb_index)
208 return devlink_sb_get_by_index(devlink, sb_index);
211 static struct devlink_sb *devlink_sb_get_from_attrs(struct devlink *devlink,
212 struct nlattr **attrs)
214 if (attrs[DEVLINK_ATTR_SB_INDEX]) {
215 u32 sb_index = nla_get_u32(attrs[DEVLINK_ATTR_SB_INDEX]);
216 struct devlink_sb *devlink_sb;
218 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
220 return ERR_PTR(-ENODEV);
223 return ERR_PTR(-EINVAL);
226 static struct devlink_sb *devlink_sb_get_from_info(struct devlink *devlink,
227 struct genl_info *info)
229 return devlink_sb_get_from_attrs(devlink, info->attrs);
232 static int devlink_sb_pool_index_get_from_attrs(struct devlink_sb *devlink_sb,
233 struct nlattr **attrs,
238 if (!attrs[DEVLINK_ATTR_SB_POOL_INDEX])
241 val = nla_get_u16(attrs[DEVLINK_ATTR_SB_POOL_INDEX]);
242 if (val >= devlink_sb_pool_count(devlink_sb))
248 static int devlink_sb_pool_index_get_from_info(struct devlink_sb *devlink_sb,
249 struct genl_info *info,
252 return devlink_sb_pool_index_get_from_attrs(devlink_sb, info->attrs,
257 devlink_sb_pool_type_get_from_attrs(struct nlattr **attrs,
258 enum devlink_sb_pool_type *p_pool_type)
262 if (!attrs[DEVLINK_ATTR_SB_POOL_TYPE])
265 val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_TYPE]);
266 if (val != DEVLINK_SB_POOL_TYPE_INGRESS &&
267 val != DEVLINK_SB_POOL_TYPE_EGRESS)
274 devlink_sb_pool_type_get_from_info(struct genl_info *info,
275 enum devlink_sb_pool_type *p_pool_type)
277 return devlink_sb_pool_type_get_from_attrs(info->attrs, p_pool_type);
281 devlink_sb_th_type_get_from_attrs(struct nlattr **attrs,
282 enum devlink_sb_threshold_type *p_th_type)
286 if (!attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])
289 val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE]);
290 if (val != DEVLINK_SB_THRESHOLD_TYPE_STATIC &&
291 val != DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC)
298 devlink_sb_th_type_get_from_info(struct genl_info *info,
299 enum devlink_sb_threshold_type *p_th_type)
301 return devlink_sb_th_type_get_from_attrs(info->attrs, p_th_type);
305 devlink_sb_tc_index_get_from_attrs(struct devlink_sb *devlink_sb,
306 struct nlattr **attrs,
307 enum devlink_sb_pool_type pool_type,
312 if (!attrs[DEVLINK_ATTR_SB_TC_INDEX])
315 val = nla_get_u16(attrs[DEVLINK_ATTR_SB_TC_INDEX]);
316 if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS &&
317 val >= devlink_sb->ingress_tc_count)
319 if (pool_type == DEVLINK_SB_POOL_TYPE_EGRESS &&
320 val >= devlink_sb->egress_tc_count)
327 devlink_sb_tc_index_get_from_info(struct devlink_sb *devlink_sb,
328 struct genl_info *info,
329 enum devlink_sb_pool_type pool_type,
332 return devlink_sb_tc_index_get_from_attrs(devlink_sb, info->attrs,
333 pool_type, p_tc_index);
336 struct devlink_region {
337 struct devlink *devlink;
338 struct list_head list;
340 struct list_head snapshot_list;
346 struct devlink_snapshot {
347 struct list_head list;
348 struct devlink_region *region;
349 devlink_snapshot_data_dest_t *data_destructor;
354 static struct devlink_region *
355 devlink_region_get_by_name(struct devlink *devlink, const char *region_name)
357 struct devlink_region *region;
359 list_for_each_entry(region, &devlink->region_list, list)
360 if (!strcmp(region->name, region_name))
366 static struct devlink_snapshot *
367 devlink_region_snapshot_get_by_id(struct devlink_region *region, u32 id)
369 struct devlink_snapshot *snapshot;
371 list_for_each_entry(snapshot, ®ion->snapshot_list, list)
372 if (snapshot->id == id)
378 #define DEVLINK_NL_FLAG_NEED_DEVLINK BIT(0)
379 #define DEVLINK_NL_FLAG_NEED_PORT BIT(1)
380 #define DEVLINK_NL_FLAG_NEED_SB BIT(2)
382 /* The per devlink instance lock is taken by default in the pre-doit
383 * operation, yet several commands do not require this. The global
384 * devlink lock is taken and protects from disruption by user-calls.
386 #define DEVLINK_NL_FLAG_NO_LOCK BIT(3)
388 static int devlink_nl_pre_doit(const struct genl_ops *ops,
389 struct sk_buff *skb, struct genl_info *info)
391 struct devlink *devlink;
394 mutex_lock(&devlink_mutex);
395 devlink = devlink_get_from_info(info);
396 if (IS_ERR(devlink)) {
397 mutex_unlock(&devlink_mutex);
398 return PTR_ERR(devlink);
400 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
401 mutex_lock(&devlink->lock);
402 if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_DEVLINK) {
403 info->user_ptr[0] = devlink;
404 } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_PORT) {
405 struct devlink_port *devlink_port;
407 devlink_port = devlink_port_get_from_info(devlink, info);
408 if (IS_ERR(devlink_port)) {
409 err = PTR_ERR(devlink_port);
412 info->user_ptr[0] = devlink_port;
414 if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_SB) {
415 struct devlink_sb *devlink_sb;
417 devlink_sb = devlink_sb_get_from_info(devlink, info);
418 if (IS_ERR(devlink_sb)) {
419 err = PTR_ERR(devlink_sb);
422 info->user_ptr[1] = devlink_sb;
427 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
428 mutex_unlock(&devlink->lock);
429 mutex_unlock(&devlink_mutex);
433 static void devlink_nl_post_doit(const struct genl_ops *ops,
434 struct sk_buff *skb, struct genl_info *info)
436 struct devlink *devlink;
438 devlink = devlink_get_from_info(info);
439 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
440 mutex_unlock(&devlink->lock);
441 mutex_unlock(&devlink_mutex);
444 static struct genl_family devlink_nl_family;
446 enum devlink_multicast_groups {
447 DEVLINK_MCGRP_CONFIG,
450 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
451 [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
454 static int devlink_nl_put_handle(struct sk_buff *msg, struct devlink *devlink)
456 if (nla_put_string(msg, DEVLINK_ATTR_BUS_NAME, devlink->dev->bus->name))
458 if (nla_put_string(msg, DEVLINK_ATTR_DEV_NAME, dev_name(devlink->dev)))
463 static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
464 enum devlink_command cmd, u32 portid,
469 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
473 if (devlink_nl_put_handle(msg, devlink))
474 goto nla_put_failure;
475 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_FAILED, devlink->reload_failed))
476 goto nla_put_failure;
478 genlmsg_end(msg, hdr);
482 genlmsg_cancel(msg, hdr);
486 static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
491 WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
493 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
497 err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
503 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
504 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
507 static int devlink_nl_port_attrs_put(struct sk_buff *msg,
508 struct devlink_port *devlink_port)
510 struct devlink_port_attrs *attrs = &devlink_port->attrs;
514 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_FLAVOUR, attrs->flavour))
516 switch (devlink_port->attrs.flavour) {
517 case DEVLINK_PORT_FLAVOUR_PCI_PF:
518 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER,
522 case DEVLINK_PORT_FLAVOUR_PCI_VF:
523 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER,
525 nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_VF_NUMBER,
529 case DEVLINK_PORT_FLAVOUR_PHYSICAL:
530 case DEVLINK_PORT_FLAVOUR_CPU:
531 case DEVLINK_PORT_FLAVOUR_DSA:
532 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER,
533 attrs->phys.port_number))
537 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP,
538 attrs->phys.port_number))
540 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER,
541 attrs->phys.split_subport_number))
550 static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
551 struct devlink_port *devlink_port,
552 enum devlink_command cmd, u32 portid,
557 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
561 if (devlink_nl_put_handle(msg, devlink))
562 goto nla_put_failure;
563 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
564 goto nla_put_failure;
566 spin_lock_bh(&devlink_port->type_lock);
567 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
568 goto nla_put_failure_type_locked;
569 if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
570 nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
571 devlink_port->desired_type))
572 goto nla_put_failure_type_locked;
573 if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
574 struct net_device *netdev = devlink_port->type_dev;
577 (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
579 nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
581 goto nla_put_failure_type_locked;
583 if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
584 struct ib_device *ibdev = devlink_port->type_dev;
587 nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
589 goto nla_put_failure_type_locked;
591 spin_unlock_bh(&devlink_port->type_lock);
592 if (devlink_nl_port_attrs_put(msg, devlink_port))
593 goto nla_put_failure;
595 genlmsg_end(msg, hdr);
598 nla_put_failure_type_locked:
599 spin_unlock_bh(&devlink_port->type_lock);
601 genlmsg_cancel(msg, hdr);
605 static void devlink_port_notify(struct devlink_port *devlink_port,
606 enum devlink_command cmd)
608 struct devlink *devlink = devlink_port->devlink;
612 if (!devlink_port->registered)
615 WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
617 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
621 err = devlink_nl_port_fill(msg, devlink, devlink_port, cmd, 0, 0, 0);
627 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
628 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
631 static int devlink_nl_cmd_get_doit(struct sk_buff *skb, struct genl_info *info)
633 struct devlink *devlink = info->user_ptr[0];
637 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
641 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
642 info->snd_portid, info->snd_seq, 0);
648 return genlmsg_reply(msg, info);
651 static int devlink_nl_cmd_get_dumpit(struct sk_buff *msg,
652 struct netlink_callback *cb)
654 struct devlink *devlink;
655 int start = cb->args[0];
659 mutex_lock(&devlink_mutex);
660 list_for_each_entry(devlink, &devlink_list, list) {
661 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
667 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
668 NETLINK_CB(cb->skb).portid,
669 cb->nlh->nlmsg_seq, NLM_F_MULTI);
675 mutex_unlock(&devlink_mutex);
681 static int devlink_nl_cmd_port_get_doit(struct sk_buff *skb,
682 struct genl_info *info)
684 struct devlink_port *devlink_port = info->user_ptr[0];
685 struct devlink *devlink = devlink_port->devlink;
689 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
693 err = devlink_nl_port_fill(msg, devlink, devlink_port,
694 DEVLINK_CMD_PORT_NEW,
695 info->snd_portid, info->snd_seq, 0);
701 return genlmsg_reply(msg, info);
704 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff *msg,
705 struct netlink_callback *cb)
707 struct devlink *devlink;
708 struct devlink_port *devlink_port;
709 int start = cb->args[0];
713 mutex_lock(&devlink_mutex);
714 list_for_each_entry(devlink, &devlink_list, list) {
715 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
717 mutex_lock(&devlink->lock);
718 list_for_each_entry(devlink_port, &devlink->port_list, list) {
723 err = devlink_nl_port_fill(msg, devlink, devlink_port,
725 NETLINK_CB(cb->skb).portid,
729 mutex_unlock(&devlink->lock);
734 mutex_unlock(&devlink->lock);
737 mutex_unlock(&devlink_mutex);
743 static int devlink_port_type_set(struct devlink *devlink,
744 struct devlink_port *devlink_port,
745 enum devlink_port_type port_type)
750 if (devlink->ops->port_type_set) {
751 if (port_type == DEVLINK_PORT_TYPE_NOTSET)
753 if (port_type == devlink_port->type)
755 err = devlink->ops->port_type_set(devlink_port, port_type);
758 devlink_port->desired_type = port_type;
759 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
765 static int devlink_nl_cmd_port_set_doit(struct sk_buff *skb,
766 struct genl_info *info)
768 struct devlink_port *devlink_port = info->user_ptr[0];
769 struct devlink *devlink = devlink_port->devlink;
772 if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
773 enum devlink_port_type port_type;
775 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
776 err = devlink_port_type_set(devlink, devlink_port, port_type);
783 static int devlink_port_split(struct devlink *devlink, u32 port_index,
784 u32 count, struct netlink_ext_ack *extack)
787 if (devlink->ops->port_split)
788 return devlink->ops->port_split(devlink, port_index, count,
793 static int devlink_nl_cmd_port_split_doit(struct sk_buff *skb,
794 struct genl_info *info)
796 struct devlink *devlink = info->user_ptr[0];
800 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX] ||
801 !info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT])
804 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
805 count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
806 return devlink_port_split(devlink, port_index, count, info->extack);
809 static int devlink_port_unsplit(struct devlink *devlink, u32 port_index,
810 struct netlink_ext_ack *extack)
813 if (devlink->ops->port_unsplit)
814 return devlink->ops->port_unsplit(devlink, port_index, extack);
818 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
819 struct genl_info *info)
821 struct devlink *devlink = info->user_ptr[0];
824 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX])
827 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
828 return devlink_port_unsplit(devlink, port_index, info->extack);
831 static int devlink_nl_sb_fill(struct sk_buff *msg, struct devlink *devlink,
832 struct devlink_sb *devlink_sb,
833 enum devlink_command cmd, u32 portid,
838 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
842 if (devlink_nl_put_handle(msg, devlink))
843 goto nla_put_failure;
844 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
845 goto nla_put_failure;
846 if (nla_put_u32(msg, DEVLINK_ATTR_SB_SIZE, devlink_sb->size))
847 goto nla_put_failure;
848 if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT,
849 devlink_sb->ingress_pools_count))
850 goto nla_put_failure;
851 if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT,
852 devlink_sb->egress_pools_count))
853 goto nla_put_failure;
854 if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_TC_COUNT,
855 devlink_sb->ingress_tc_count))
856 goto nla_put_failure;
857 if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_TC_COUNT,
858 devlink_sb->egress_tc_count))
859 goto nla_put_failure;
861 genlmsg_end(msg, hdr);
865 genlmsg_cancel(msg, hdr);
869 static int devlink_nl_cmd_sb_get_doit(struct sk_buff *skb,
870 struct genl_info *info)
872 struct devlink *devlink = info->user_ptr[0];
873 struct devlink_sb *devlink_sb = info->user_ptr[1];
877 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
881 err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
883 info->snd_portid, info->snd_seq, 0);
889 return genlmsg_reply(msg, info);
892 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff *msg,
893 struct netlink_callback *cb)
895 struct devlink *devlink;
896 struct devlink_sb *devlink_sb;
897 int start = cb->args[0];
901 mutex_lock(&devlink_mutex);
902 list_for_each_entry(devlink, &devlink_list, list) {
903 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
905 mutex_lock(&devlink->lock);
906 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
911 err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
913 NETLINK_CB(cb->skb).portid,
917 mutex_unlock(&devlink->lock);
922 mutex_unlock(&devlink->lock);
925 mutex_unlock(&devlink_mutex);
931 static int devlink_nl_sb_pool_fill(struct sk_buff *msg, struct devlink *devlink,
932 struct devlink_sb *devlink_sb,
933 u16 pool_index, enum devlink_command cmd,
934 u32 portid, u32 seq, int flags)
936 struct devlink_sb_pool_info pool_info;
940 err = devlink->ops->sb_pool_get(devlink, devlink_sb->index,
941 pool_index, &pool_info);
945 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
949 if (devlink_nl_put_handle(msg, devlink))
950 goto nla_put_failure;
951 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
952 goto nla_put_failure;
953 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
954 goto nla_put_failure;
955 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_info.pool_type))
956 goto nla_put_failure;
957 if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_SIZE, pool_info.size))
958 goto nla_put_failure;
959 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
960 pool_info.threshold_type))
961 goto nla_put_failure;
962 if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_CELL_SIZE,
963 pool_info.cell_size))
964 goto nla_put_failure;
966 genlmsg_end(msg, hdr);
970 genlmsg_cancel(msg, hdr);
974 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff *skb,
975 struct genl_info *info)
977 struct devlink *devlink = info->user_ptr[0];
978 struct devlink_sb *devlink_sb = info->user_ptr[1];
983 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
988 if (!devlink->ops->sb_pool_get)
991 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
995 err = devlink_nl_sb_pool_fill(msg, devlink, devlink_sb, pool_index,
996 DEVLINK_CMD_SB_POOL_NEW,
997 info->snd_portid, info->snd_seq, 0);
1003 return genlmsg_reply(msg, info);
1006 static int __sb_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
1007 struct devlink *devlink,
1008 struct devlink_sb *devlink_sb,
1009 u32 portid, u32 seq)
1011 u16 pool_count = devlink_sb_pool_count(devlink_sb);
1015 for (pool_index = 0; pool_index < pool_count; pool_index++) {
1016 if (*p_idx < start) {
1020 err = devlink_nl_sb_pool_fill(msg, devlink,
1023 DEVLINK_CMD_SB_POOL_NEW,
1024 portid, seq, NLM_F_MULTI);
1032 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff *msg,
1033 struct netlink_callback *cb)
1035 struct devlink *devlink;
1036 struct devlink_sb *devlink_sb;
1037 int start = cb->args[0];
1041 mutex_lock(&devlink_mutex);
1042 list_for_each_entry(devlink, &devlink_list, list) {
1043 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1044 !devlink->ops->sb_pool_get)
1046 mutex_lock(&devlink->lock);
1047 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1048 err = __sb_pool_get_dumpit(msg, start, &idx, devlink,
1050 NETLINK_CB(cb->skb).portid,
1051 cb->nlh->nlmsg_seq);
1052 if (err && err != -EOPNOTSUPP) {
1053 mutex_unlock(&devlink->lock);
1057 mutex_unlock(&devlink->lock);
1060 mutex_unlock(&devlink_mutex);
1066 static int devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
1067 u16 pool_index, u32 size,
1068 enum devlink_sb_threshold_type threshold_type,
1069 struct netlink_ext_ack *extack)
1072 const struct devlink_ops *ops = devlink->ops;
1074 if (ops->sb_pool_set)
1075 return ops->sb_pool_set(devlink, sb_index, pool_index,
1076 size, threshold_type, extack);
1080 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb,
1081 struct genl_info *info)
1083 struct devlink *devlink = info->user_ptr[0];
1084 struct devlink_sb *devlink_sb = info->user_ptr[1];
1085 enum devlink_sb_threshold_type threshold_type;
1090 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1095 err = devlink_sb_th_type_get_from_info(info, &threshold_type);
1099 if (!info->attrs[DEVLINK_ATTR_SB_POOL_SIZE])
1102 size = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_POOL_SIZE]);
1103 return devlink_sb_pool_set(devlink, devlink_sb->index,
1104 pool_index, size, threshold_type,
1108 static int devlink_nl_sb_port_pool_fill(struct sk_buff *msg,
1109 struct devlink *devlink,
1110 struct devlink_port *devlink_port,
1111 struct devlink_sb *devlink_sb,
1113 enum devlink_command cmd,
1114 u32 portid, u32 seq, int flags)
1116 const struct devlink_ops *ops = devlink->ops;
1121 err = ops->sb_port_pool_get(devlink_port, devlink_sb->index,
1122 pool_index, &threshold);
1126 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1130 if (devlink_nl_put_handle(msg, devlink))
1131 goto nla_put_failure;
1132 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1133 goto nla_put_failure;
1134 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1135 goto nla_put_failure;
1136 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1137 goto nla_put_failure;
1138 if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1139 goto nla_put_failure;
1141 if (ops->sb_occ_port_pool_get) {
1145 err = ops->sb_occ_port_pool_get(devlink_port, devlink_sb->index,
1146 pool_index, &cur, &max);
1147 if (err && err != -EOPNOTSUPP)
1150 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1151 goto nla_put_failure;
1152 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1153 goto nla_put_failure;
1157 genlmsg_end(msg, hdr);
1161 genlmsg_cancel(msg, hdr);
1165 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff *skb,
1166 struct genl_info *info)
1168 struct devlink_port *devlink_port = info->user_ptr[0];
1169 struct devlink *devlink = devlink_port->devlink;
1170 struct devlink_sb *devlink_sb = info->user_ptr[1];
1171 struct sk_buff *msg;
1175 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1180 if (!devlink->ops->sb_port_pool_get)
1183 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1187 err = devlink_nl_sb_port_pool_fill(msg, devlink, devlink_port,
1188 devlink_sb, pool_index,
1189 DEVLINK_CMD_SB_PORT_POOL_NEW,
1190 info->snd_portid, info->snd_seq, 0);
1196 return genlmsg_reply(msg, info);
1199 static int __sb_port_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
1200 struct devlink *devlink,
1201 struct devlink_sb *devlink_sb,
1202 u32 portid, u32 seq)
1204 struct devlink_port *devlink_port;
1205 u16 pool_count = devlink_sb_pool_count(devlink_sb);
1209 list_for_each_entry(devlink_port, &devlink->port_list, list) {
1210 for (pool_index = 0; pool_index < pool_count; pool_index++) {
1211 if (*p_idx < start) {
1215 err = devlink_nl_sb_port_pool_fill(msg, devlink,
1219 DEVLINK_CMD_SB_PORT_POOL_NEW,
1230 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff *msg,
1231 struct netlink_callback *cb)
1233 struct devlink *devlink;
1234 struct devlink_sb *devlink_sb;
1235 int start = cb->args[0];
1239 mutex_lock(&devlink_mutex);
1240 list_for_each_entry(devlink, &devlink_list, list) {
1241 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1242 !devlink->ops->sb_port_pool_get)
1244 mutex_lock(&devlink->lock);
1245 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1246 err = __sb_port_pool_get_dumpit(msg, start, &idx,
1247 devlink, devlink_sb,
1248 NETLINK_CB(cb->skb).portid,
1249 cb->nlh->nlmsg_seq);
1250 if (err && err != -EOPNOTSUPP) {
1251 mutex_unlock(&devlink->lock);
1255 mutex_unlock(&devlink->lock);
1258 mutex_unlock(&devlink_mutex);
1264 static int devlink_sb_port_pool_set(struct devlink_port *devlink_port,
1265 unsigned int sb_index, u16 pool_index,
1267 struct netlink_ext_ack *extack)
1270 const struct devlink_ops *ops = devlink_port->devlink->ops;
1272 if (ops->sb_port_pool_set)
1273 return ops->sb_port_pool_set(devlink_port, sb_index,
1274 pool_index, threshold, extack);
1278 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
1279 struct genl_info *info)
1281 struct devlink_port *devlink_port = info->user_ptr[0];
1282 struct devlink_sb *devlink_sb = info->user_ptr[1];
1287 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1292 if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1295 threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1296 return devlink_sb_port_pool_set(devlink_port, devlink_sb->index,
1297 pool_index, threshold, info->extack);
1301 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff *msg, struct devlink *devlink,
1302 struct devlink_port *devlink_port,
1303 struct devlink_sb *devlink_sb, u16 tc_index,
1304 enum devlink_sb_pool_type pool_type,
1305 enum devlink_command cmd,
1306 u32 portid, u32 seq, int flags)
1308 const struct devlink_ops *ops = devlink->ops;
1314 err = ops->sb_tc_pool_bind_get(devlink_port, devlink_sb->index,
1315 tc_index, pool_type,
1316 &pool_index, &threshold);
1320 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1324 if (devlink_nl_put_handle(msg, devlink))
1325 goto nla_put_failure;
1326 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1327 goto nla_put_failure;
1328 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1329 goto nla_put_failure;
1330 if (nla_put_u16(msg, DEVLINK_ATTR_SB_TC_INDEX, tc_index))
1331 goto nla_put_failure;
1332 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_type))
1333 goto nla_put_failure;
1334 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1335 goto nla_put_failure;
1336 if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1337 goto nla_put_failure;
1339 if (ops->sb_occ_tc_port_bind_get) {
1343 err = ops->sb_occ_tc_port_bind_get(devlink_port,
1345 tc_index, pool_type,
1347 if (err && err != -EOPNOTSUPP)
1350 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1351 goto nla_put_failure;
1352 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1353 goto nla_put_failure;
1357 genlmsg_end(msg, hdr);
1361 genlmsg_cancel(msg, hdr);
1365 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
1366 struct genl_info *info)
1368 struct devlink_port *devlink_port = info->user_ptr[0];
1369 struct devlink *devlink = devlink_port->devlink;
1370 struct devlink_sb *devlink_sb = info->user_ptr[1];
1371 struct sk_buff *msg;
1372 enum devlink_sb_pool_type pool_type;
1376 err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1380 err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1381 pool_type, &tc_index);
1385 if (!devlink->ops->sb_tc_pool_bind_get)
1388 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1392 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink, devlink_port,
1393 devlink_sb, tc_index, pool_type,
1394 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1402 return genlmsg_reply(msg, info);
1405 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1406 int start, int *p_idx,
1407 struct devlink *devlink,
1408 struct devlink_sb *devlink_sb,
1409 u32 portid, u32 seq)
1411 struct devlink_port *devlink_port;
1415 list_for_each_entry(devlink_port, &devlink->port_list, list) {
1417 tc_index < devlink_sb->ingress_tc_count; tc_index++) {
1418 if (*p_idx < start) {
1422 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1426 DEVLINK_SB_POOL_TYPE_INGRESS,
1427 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1435 tc_index < devlink_sb->egress_tc_count; tc_index++) {
1436 if (*p_idx < start) {
1440 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1444 DEVLINK_SB_POOL_TYPE_EGRESS,
1445 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1457 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1458 struct netlink_callback *cb)
1460 struct devlink *devlink;
1461 struct devlink_sb *devlink_sb;
1462 int start = cb->args[0];
1466 mutex_lock(&devlink_mutex);
1467 list_for_each_entry(devlink, &devlink_list, list) {
1468 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1469 !devlink->ops->sb_tc_pool_bind_get)
1472 mutex_lock(&devlink->lock);
1473 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1474 err = __sb_tc_pool_bind_get_dumpit(msg, start, &idx,
1477 NETLINK_CB(cb->skb).portid,
1478 cb->nlh->nlmsg_seq);
1479 if (err && err != -EOPNOTSUPP) {
1480 mutex_unlock(&devlink->lock);
1484 mutex_unlock(&devlink->lock);
1487 mutex_unlock(&devlink_mutex);
1493 static int devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
1494 unsigned int sb_index, u16 tc_index,
1495 enum devlink_sb_pool_type pool_type,
1496 u16 pool_index, u32 threshold,
1497 struct netlink_ext_ack *extack)
1500 const struct devlink_ops *ops = devlink_port->devlink->ops;
1502 if (ops->sb_tc_pool_bind_set)
1503 return ops->sb_tc_pool_bind_set(devlink_port, sb_index,
1504 tc_index, pool_type,
1505 pool_index, threshold, extack);
1509 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
1510 struct genl_info *info)
1512 struct devlink_port *devlink_port = info->user_ptr[0];
1513 struct devlink_sb *devlink_sb = info->user_ptr[1];
1514 enum devlink_sb_pool_type pool_type;
1520 err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1524 err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1525 pool_type, &tc_index);
1529 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1534 if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1537 threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1538 return devlink_sb_tc_pool_bind_set(devlink_port, devlink_sb->index,
1539 tc_index, pool_type,
1540 pool_index, threshold, info->extack);
1543 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
1544 struct genl_info *info)
1546 struct devlink *devlink = info->user_ptr[0];
1547 struct devlink_sb *devlink_sb = info->user_ptr[1];
1548 const struct devlink_ops *ops = devlink->ops;
1550 if (ops->sb_occ_snapshot)
1551 return ops->sb_occ_snapshot(devlink, devlink_sb->index);
1555 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
1556 struct genl_info *info)
1558 struct devlink *devlink = info->user_ptr[0];
1559 struct devlink_sb *devlink_sb = info->user_ptr[1];
1560 const struct devlink_ops *ops = devlink->ops;
1562 if (ops->sb_occ_max_clear)
1563 return ops->sb_occ_max_clear(devlink, devlink_sb->index);
1567 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
1568 enum devlink_command cmd, u32 portid,
1571 const struct devlink_ops *ops = devlink->ops;
1572 enum devlink_eswitch_encap_mode encap_mode;
1578 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1582 err = devlink_nl_put_handle(msg, devlink);
1584 goto nla_put_failure;
1586 if (ops->eswitch_mode_get) {
1587 err = ops->eswitch_mode_get(devlink, &mode);
1589 goto nla_put_failure;
1590 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
1592 goto nla_put_failure;
1595 if (ops->eswitch_inline_mode_get) {
1596 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
1598 goto nla_put_failure;
1599 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
1602 goto nla_put_failure;
1605 if (ops->eswitch_encap_mode_get) {
1606 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
1608 goto nla_put_failure;
1609 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
1611 goto nla_put_failure;
1614 genlmsg_end(msg, hdr);
1618 genlmsg_cancel(msg, hdr);
1622 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb,
1623 struct genl_info *info)
1625 struct devlink *devlink = info->user_ptr[0];
1626 struct sk_buff *msg;
1629 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1633 err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
1634 info->snd_portid, info->snd_seq, 0);
1641 return genlmsg_reply(msg, info);
1644 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
1645 struct genl_info *info)
1647 struct devlink *devlink = info->user_ptr[0];
1648 const struct devlink_ops *ops = devlink->ops;
1649 enum devlink_eswitch_encap_mode encap_mode;
1654 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
1655 if (!ops->eswitch_mode_set)
1657 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
1658 err = ops->eswitch_mode_set(devlink, mode, info->extack);
1663 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
1664 if (!ops->eswitch_inline_mode_set)
1666 inline_mode = nla_get_u8(
1667 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
1668 err = ops->eswitch_inline_mode_set(devlink, inline_mode,
1674 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
1675 if (!ops->eswitch_encap_mode_set)
1677 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
1678 err = ops->eswitch_encap_mode_set(devlink, encap_mode,
1687 int devlink_dpipe_match_put(struct sk_buff *skb,
1688 struct devlink_dpipe_match *match)
1690 struct devlink_dpipe_header *header = match->header;
1691 struct devlink_dpipe_field *field = &header->fields[match->field_id];
1692 struct nlattr *match_attr;
1694 match_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_MATCH);
1698 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
1699 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
1700 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1701 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1702 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1703 goto nla_put_failure;
1705 nla_nest_end(skb, match_attr);
1709 nla_nest_cancel(skb, match_attr);
1712 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
1714 static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
1715 struct sk_buff *skb)
1717 struct nlattr *matches_attr;
1719 matches_attr = nla_nest_start_noflag(skb,
1720 DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
1724 if (table->table_ops->matches_dump(table->priv, skb))
1725 goto nla_put_failure;
1727 nla_nest_end(skb, matches_attr);
1731 nla_nest_cancel(skb, matches_attr);
1735 int devlink_dpipe_action_put(struct sk_buff *skb,
1736 struct devlink_dpipe_action *action)
1738 struct devlink_dpipe_header *header = action->header;
1739 struct devlink_dpipe_field *field = &header->fields[action->field_id];
1740 struct nlattr *action_attr;
1742 action_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ACTION);
1746 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
1747 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
1748 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1749 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1750 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1751 goto nla_put_failure;
1753 nla_nest_end(skb, action_attr);
1757 nla_nest_cancel(skb, action_attr);
1760 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
1762 static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
1763 struct sk_buff *skb)
1765 struct nlattr *actions_attr;
1767 actions_attr = nla_nest_start_noflag(skb,
1768 DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
1772 if (table->table_ops->actions_dump(table->priv, skb))
1773 goto nla_put_failure;
1775 nla_nest_end(skb, actions_attr);
1779 nla_nest_cancel(skb, actions_attr);
1783 static int devlink_dpipe_table_put(struct sk_buff *skb,
1784 struct devlink_dpipe_table *table)
1786 struct nlattr *table_attr;
1789 table_size = table->table_ops->size_get(table->priv);
1790 table_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLE);
1794 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
1795 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
1797 goto nla_put_failure;
1798 if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
1799 table->counters_enabled))
1800 goto nla_put_failure;
1802 if (table->resource_valid) {
1803 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
1804 table->resource_id, DEVLINK_ATTR_PAD) ||
1805 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
1806 table->resource_units, DEVLINK_ATTR_PAD))
1807 goto nla_put_failure;
1809 if (devlink_dpipe_matches_put(table, skb))
1810 goto nla_put_failure;
1812 if (devlink_dpipe_actions_put(table, skb))
1813 goto nla_put_failure;
1815 nla_nest_end(skb, table_attr);
1819 nla_nest_cancel(skb, table_attr);
1823 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
1824 struct genl_info *info)
1829 err = genlmsg_reply(*pskb, info);
1833 *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
1839 static int devlink_dpipe_tables_fill(struct genl_info *info,
1840 enum devlink_command cmd, int flags,
1841 struct list_head *dpipe_tables,
1842 const char *table_name)
1844 struct devlink *devlink = info->user_ptr[0];
1845 struct devlink_dpipe_table *table;
1846 struct nlattr *tables_attr;
1847 struct sk_buff *skb = NULL;
1848 struct nlmsghdr *nlh;
1854 table = list_first_entry(dpipe_tables,
1855 struct devlink_dpipe_table, list);
1857 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1861 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
1862 &devlink_nl_family, NLM_F_MULTI, cmd);
1868 if (devlink_nl_put_handle(skb, devlink))
1869 goto nla_put_failure;
1870 tables_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLES);
1872 goto nla_put_failure;
1876 list_for_each_entry_from(table, dpipe_tables, list) {
1878 err = devlink_dpipe_table_put(skb, table);
1886 if (!strcmp(table->name, table_name)) {
1887 err = devlink_dpipe_table_put(skb, table);
1895 nla_nest_end(skb, tables_attr);
1896 genlmsg_end(skb, hdr);
1901 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
1902 NLMSG_DONE, 0, flags | NLM_F_MULTI);
1904 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1910 return genlmsg_reply(skb, info);
1919 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
1920 struct genl_info *info)
1922 struct devlink *devlink = info->user_ptr[0];
1923 const char *table_name = NULL;
1925 if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
1926 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
1928 return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
1929 &devlink->dpipe_table_list,
1933 static int devlink_dpipe_value_put(struct sk_buff *skb,
1934 struct devlink_dpipe_value *value)
1936 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
1937 value->value_size, value->value))
1940 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
1941 value->value_size, value->mask))
1943 if (value->mapping_valid)
1944 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
1945 value->mapping_value))
1950 static int devlink_dpipe_action_value_put(struct sk_buff *skb,
1951 struct devlink_dpipe_value *value)
1955 if (devlink_dpipe_action_put(skb, value->action))
1957 if (devlink_dpipe_value_put(skb, value))
1962 static int devlink_dpipe_action_values_put(struct sk_buff *skb,
1963 struct devlink_dpipe_value *values,
1964 unsigned int values_count)
1966 struct nlattr *action_attr;
1970 for (i = 0; i < values_count; i++) {
1971 action_attr = nla_nest_start_noflag(skb,
1972 DEVLINK_ATTR_DPIPE_ACTION_VALUE);
1975 err = devlink_dpipe_action_value_put(skb, &values[i]);
1977 goto err_action_value_put;
1978 nla_nest_end(skb, action_attr);
1982 err_action_value_put:
1983 nla_nest_cancel(skb, action_attr);
1987 static int devlink_dpipe_match_value_put(struct sk_buff *skb,
1988 struct devlink_dpipe_value *value)
1992 if (devlink_dpipe_match_put(skb, value->match))
1994 if (devlink_dpipe_value_put(skb, value))
1999 static int devlink_dpipe_match_values_put(struct sk_buff *skb,
2000 struct devlink_dpipe_value *values,
2001 unsigned int values_count)
2003 struct nlattr *match_attr;
2007 for (i = 0; i < values_count; i++) {
2008 match_attr = nla_nest_start_noflag(skb,
2009 DEVLINK_ATTR_DPIPE_MATCH_VALUE);
2012 err = devlink_dpipe_match_value_put(skb, &values[i]);
2014 goto err_match_value_put;
2015 nla_nest_end(skb, match_attr);
2019 err_match_value_put:
2020 nla_nest_cancel(skb, match_attr);
2024 static int devlink_dpipe_entry_put(struct sk_buff *skb,
2025 struct devlink_dpipe_entry *entry)
2027 struct nlattr *entry_attr, *matches_attr, *actions_attr;
2030 entry_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ENTRY);
2034 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
2036 goto nla_put_failure;
2037 if (entry->counter_valid)
2038 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
2039 entry->counter, DEVLINK_ATTR_PAD))
2040 goto nla_put_failure;
2042 matches_attr = nla_nest_start_noflag(skb,
2043 DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
2045 goto nla_put_failure;
2047 err = devlink_dpipe_match_values_put(skb, entry->match_values,
2048 entry->match_values_count);
2050 nla_nest_cancel(skb, matches_attr);
2051 goto err_match_values_put;
2053 nla_nest_end(skb, matches_attr);
2055 actions_attr = nla_nest_start_noflag(skb,
2056 DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
2058 goto nla_put_failure;
2060 err = devlink_dpipe_action_values_put(skb, entry->action_values,
2061 entry->action_values_count);
2063 nla_nest_cancel(skb, actions_attr);
2064 goto err_action_values_put;
2066 nla_nest_end(skb, actions_attr);
2068 nla_nest_end(skb, entry_attr);
2073 err_match_values_put:
2074 err_action_values_put:
2075 nla_nest_cancel(skb, entry_attr);
2079 static struct devlink_dpipe_table *
2080 devlink_dpipe_table_find(struct list_head *dpipe_tables,
2081 const char *table_name)
2083 struct devlink_dpipe_table *table;
2085 list_for_each_entry_rcu(table, dpipe_tables, list) {
2086 if (!strcmp(table->name, table_name))
2092 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
2094 struct devlink *devlink;
2097 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
2102 dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
2103 dump_ctx->info->snd_portid,
2104 dump_ctx->info->snd_seq,
2105 &devlink_nl_family, NLM_F_MULTI,
2108 goto nla_put_failure;
2110 devlink = dump_ctx->info->user_ptr[0];
2111 if (devlink_nl_put_handle(dump_ctx->skb, devlink))
2112 goto nla_put_failure;
2113 dump_ctx->nest = nla_nest_start_noflag(dump_ctx->skb,
2114 DEVLINK_ATTR_DPIPE_ENTRIES);
2115 if (!dump_ctx->nest)
2116 goto nla_put_failure;
2120 nlmsg_free(dump_ctx->skb);
2123 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
2125 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
2126 struct devlink_dpipe_entry *entry)
2128 return devlink_dpipe_entry_put(dump_ctx->skb, entry);
2130 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
2132 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
2134 nla_nest_end(dump_ctx->skb, dump_ctx->nest);
2135 genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
2138 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
2140 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
2143 unsigned int value_count, value_index;
2144 struct devlink_dpipe_value *value;
2146 value = entry->action_values;
2147 value_count = entry->action_values_count;
2148 for (value_index = 0; value_index < value_count; value_index++) {
2149 kfree(value[value_index].value);
2150 kfree(value[value_index].mask);
2153 value = entry->match_values;
2154 value_count = entry->match_values_count;
2155 for (value_index = 0; value_index < value_count; value_index++) {
2156 kfree(value[value_index].value);
2157 kfree(value[value_index].mask);
2160 EXPORT_SYMBOL(devlink_dpipe_entry_clear);
2162 static int devlink_dpipe_entries_fill(struct genl_info *info,
2163 enum devlink_command cmd, int flags,
2164 struct devlink_dpipe_table *table)
2166 struct devlink_dpipe_dump_ctx dump_ctx;
2167 struct nlmsghdr *nlh;
2170 dump_ctx.skb = NULL;
2172 dump_ctx.info = info;
2174 err = table->table_ops->entries_dump(table->priv,
2175 table->counters_enabled,
2181 nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
2182 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2184 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
2189 return genlmsg_reply(dump_ctx.skb, info);
2192 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
2193 struct genl_info *info)
2195 struct devlink *devlink = info->user_ptr[0];
2196 struct devlink_dpipe_table *table;
2197 const char *table_name;
2199 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
2202 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2203 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2208 if (!table->table_ops->entries_dump)
2211 return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
2215 static int devlink_dpipe_fields_put(struct sk_buff *skb,
2216 const struct devlink_dpipe_header *header)
2218 struct devlink_dpipe_field *field;
2219 struct nlattr *field_attr;
2222 for (i = 0; i < header->fields_count; i++) {
2223 field = &header->fields[i];
2224 field_attr = nla_nest_start_noflag(skb,
2225 DEVLINK_ATTR_DPIPE_FIELD);
2228 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
2229 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2230 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
2231 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
2232 goto nla_put_failure;
2233 nla_nest_end(skb, field_attr);
2238 nla_nest_cancel(skb, field_attr);
2242 static int devlink_dpipe_header_put(struct sk_buff *skb,
2243 struct devlink_dpipe_header *header)
2245 struct nlattr *fields_attr, *header_attr;
2248 header_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADER);
2252 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
2253 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2254 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2255 goto nla_put_failure;
2257 fields_attr = nla_nest_start_noflag(skb,
2258 DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
2260 goto nla_put_failure;
2262 err = devlink_dpipe_fields_put(skb, header);
2264 nla_nest_cancel(skb, fields_attr);
2265 goto nla_put_failure;
2267 nla_nest_end(skb, fields_attr);
2268 nla_nest_end(skb, header_attr);
2273 nla_nest_cancel(skb, header_attr);
2277 static int devlink_dpipe_headers_fill(struct genl_info *info,
2278 enum devlink_command cmd, int flags,
2279 struct devlink_dpipe_headers *
2282 struct devlink *devlink = info->user_ptr[0];
2283 struct nlattr *headers_attr;
2284 struct sk_buff *skb = NULL;
2285 struct nlmsghdr *nlh;
2292 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2296 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2297 &devlink_nl_family, NLM_F_MULTI, cmd);
2303 if (devlink_nl_put_handle(skb, devlink))
2304 goto nla_put_failure;
2305 headers_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADERS);
2307 goto nla_put_failure;
2310 for (; i < dpipe_headers->headers_count; i++) {
2311 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
2319 nla_nest_end(skb, headers_attr);
2320 genlmsg_end(skb, hdr);
2321 if (i != dpipe_headers->headers_count)
2325 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2326 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2328 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2333 return genlmsg_reply(skb, info);
2342 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
2343 struct genl_info *info)
2345 struct devlink *devlink = info->user_ptr[0];
2347 if (!devlink->dpipe_headers)
2349 return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
2350 0, devlink->dpipe_headers);
2353 static int devlink_dpipe_table_counters_set(struct devlink *devlink,
2354 const char *table_name,
2357 struct devlink_dpipe_table *table;
2359 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2364 if (table->counter_control_extern)
2367 if (!(table->counters_enabled ^ enable))
2370 table->counters_enabled = enable;
2371 if (table->table_ops->counters_set_update)
2372 table->table_ops->counters_set_update(table->priv, enable);
2376 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
2377 struct genl_info *info)
2379 struct devlink *devlink = info->user_ptr[0];
2380 const char *table_name;
2381 bool counters_enable;
2383 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
2384 !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
2387 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2388 counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
2390 return devlink_dpipe_table_counters_set(devlink, table_name,
2394 static struct devlink_resource *
2395 devlink_resource_find(struct devlink *devlink,
2396 struct devlink_resource *resource, u64 resource_id)
2398 struct list_head *resource_list;
2401 resource_list = &resource->resource_list;
2403 resource_list = &devlink->resource_list;
2405 list_for_each_entry(resource, resource_list, list) {
2406 struct devlink_resource *child_resource;
2408 if (resource->id == resource_id)
2411 child_resource = devlink_resource_find(devlink, resource,
2414 return child_resource;
2420 devlink_resource_validate_children(struct devlink_resource *resource)
2422 struct devlink_resource *child_resource;
2423 bool size_valid = true;
2426 if (list_empty(&resource->resource_list))
2429 list_for_each_entry(child_resource, &resource->resource_list, list)
2430 parts_size += child_resource->size_new;
2432 if (parts_size > resource->size_new)
2435 resource->size_valid = size_valid;
2439 devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
2440 struct netlink_ext_ack *extack)
2445 if (size > resource->size_params.size_max) {
2446 NL_SET_ERR_MSG_MOD(extack, "Size larger than maximum");
2450 if (size < resource->size_params.size_min) {
2451 NL_SET_ERR_MSG_MOD(extack, "Size smaller than minimum");
2455 div64_u64_rem(size, resource->size_params.size_granularity, &reminder);
2457 NL_SET_ERR_MSG_MOD(extack, "Wrong granularity");
2464 static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
2465 struct genl_info *info)
2467 struct devlink *devlink = info->user_ptr[0];
2468 struct devlink_resource *resource;
2473 if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
2474 !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
2476 resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
2478 resource = devlink_resource_find(devlink, NULL, resource_id);
2482 size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
2483 err = devlink_resource_validate_size(resource, size, info->extack);
2487 resource->size_new = size;
2488 devlink_resource_validate_children(resource);
2489 if (resource->parent)
2490 devlink_resource_validate_children(resource->parent);
2495 devlink_resource_size_params_put(struct devlink_resource *resource,
2496 struct sk_buff *skb)
2498 struct devlink_resource_size_params *size_params;
2500 size_params = &resource->size_params;
2501 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
2502 size_params->size_granularity, DEVLINK_ATTR_PAD) ||
2503 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
2504 size_params->size_max, DEVLINK_ATTR_PAD) ||
2505 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
2506 size_params->size_min, DEVLINK_ATTR_PAD) ||
2507 nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
2512 static int devlink_resource_occ_put(struct devlink_resource *resource,
2513 struct sk_buff *skb)
2515 if (!resource->occ_get)
2517 return nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
2518 resource->occ_get(resource->occ_get_priv),
2522 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
2523 struct devlink_resource *resource)
2525 struct devlink_resource *child_resource;
2526 struct nlattr *child_resource_attr;
2527 struct nlattr *resource_attr;
2529 resource_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_RESOURCE);
2533 if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
2534 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
2535 DEVLINK_ATTR_PAD) ||
2536 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
2538 goto nla_put_failure;
2539 if (resource->size != resource->size_new)
2540 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
2541 resource->size_new, DEVLINK_ATTR_PAD);
2542 if (devlink_resource_occ_put(resource, skb))
2543 goto nla_put_failure;
2544 if (devlink_resource_size_params_put(resource, skb))
2545 goto nla_put_failure;
2546 if (list_empty(&resource->resource_list))
2549 if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
2550 resource->size_valid))
2551 goto nla_put_failure;
2553 child_resource_attr = nla_nest_start_noflag(skb,
2554 DEVLINK_ATTR_RESOURCE_LIST);
2555 if (!child_resource_attr)
2556 goto nla_put_failure;
2558 list_for_each_entry(child_resource, &resource->resource_list, list) {
2559 if (devlink_resource_put(devlink, skb, child_resource))
2560 goto resource_put_failure;
2563 nla_nest_end(skb, child_resource_attr);
2565 nla_nest_end(skb, resource_attr);
2568 resource_put_failure:
2569 nla_nest_cancel(skb, child_resource_attr);
2571 nla_nest_cancel(skb, resource_attr);
2575 static int devlink_resource_fill(struct genl_info *info,
2576 enum devlink_command cmd, int flags)
2578 struct devlink *devlink = info->user_ptr[0];
2579 struct devlink_resource *resource;
2580 struct nlattr *resources_attr;
2581 struct sk_buff *skb = NULL;
2582 struct nlmsghdr *nlh;
2588 resource = list_first_entry(&devlink->resource_list,
2589 struct devlink_resource, list);
2591 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2595 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2596 &devlink_nl_family, NLM_F_MULTI, cmd);
2602 if (devlink_nl_put_handle(skb, devlink))
2603 goto nla_put_failure;
2605 resources_attr = nla_nest_start_noflag(skb,
2606 DEVLINK_ATTR_RESOURCE_LIST);
2607 if (!resources_attr)
2608 goto nla_put_failure;
2612 list_for_each_entry_from(resource, &devlink->resource_list, list) {
2613 err = devlink_resource_put(devlink, skb, resource);
2616 goto err_resource_put;
2622 nla_nest_end(skb, resources_attr);
2623 genlmsg_end(skb, hdr);
2627 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2628 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2630 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2635 return genlmsg_reply(skb, info);
2644 static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
2645 struct genl_info *info)
2647 struct devlink *devlink = info->user_ptr[0];
2649 if (list_empty(&devlink->resource_list))
2652 return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
2656 devlink_resources_validate(struct devlink *devlink,
2657 struct devlink_resource *resource,
2658 struct genl_info *info)
2660 struct list_head *resource_list;
2664 resource_list = &resource->resource_list;
2666 resource_list = &devlink->resource_list;
2668 list_for_each_entry(resource, resource_list, list) {
2669 if (!resource->size_valid)
2671 err = devlink_resources_validate(devlink, resource, info);
2678 static bool devlink_reload_supported(struct devlink *devlink)
2680 return devlink->ops->reload_down && devlink->ops->reload_up;
2683 static void devlink_reload_failed_set(struct devlink *devlink,
2686 if (devlink->reload_failed == reload_failed)
2688 devlink->reload_failed = reload_failed;
2689 devlink_notify(devlink, DEVLINK_CMD_NEW);
2692 bool devlink_is_reload_failed(const struct devlink *devlink)
2694 return devlink->reload_failed;
2696 EXPORT_SYMBOL_GPL(devlink_is_reload_failed);
2698 static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
2700 struct devlink *devlink = info->user_ptr[0];
2703 if (!devlink_reload_supported(devlink))
2706 err = devlink_resources_validate(devlink, NULL, info);
2708 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
2711 err = devlink->ops->reload_down(devlink, info->extack);
2714 err = devlink->ops->reload_up(devlink, info->extack);
2715 devlink_reload_failed_set(devlink, !!err);
2719 static int devlink_nl_flash_update_fill(struct sk_buff *msg,
2720 struct devlink *devlink,
2721 enum devlink_command cmd,
2722 const char *status_msg,
2723 const char *component,
2724 unsigned long done, unsigned long total)
2728 hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd);
2732 if (devlink_nl_put_handle(msg, devlink))
2733 goto nla_put_failure;
2735 if (cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS)
2739 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG,
2741 goto nla_put_failure;
2743 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT,
2745 goto nla_put_failure;
2746 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE,
2747 done, DEVLINK_ATTR_PAD))
2748 goto nla_put_failure;
2749 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL,
2750 total, DEVLINK_ATTR_PAD))
2751 goto nla_put_failure;
2754 genlmsg_end(msg, hdr);
2758 genlmsg_cancel(msg, hdr);
2762 static void __devlink_flash_update_notify(struct devlink *devlink,
2763 enum devlink_command cmd,
2764 const char *status_msg,
2765 const char *component,
2767 unsigned long total)
2769 struct sk_buff *msg;
2772 WARN_ON(cmd != DEVLINK_CMD_FLASH_UPDATE &&
2773 cmd != DEVLINK_CMD_FLASH_UPDATE_END &&
2774 cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS);
2776 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2780 err = devlink_nl_flash_update_fill(msg, devlink, cmd, status_msg,
2781 component, done, total);
2785 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
2786 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
2793 void devlink_flash_update_begin_notify(struct devlink *devlink)
2795 __devlink_flash_update_notify(devlink,
2796 DEVLINK_CMD_FLASH_UPDATE,
2799 EXPORT_SYMBOL_GPL(devlink_flash_update_begin_notify);
2801 void devlink_flash_update_end_notify(struct devlink *devlink)
2803 __devlink_flash_update_notify(devlink,
2804 DEVLINK_CMD_FLASH_UPDATE_END,
2807 EXPORT_SYMBOL_GPL(devlink_flash_update_end_notify);
2809 void devlink_flash_update_status_notify(struct devlink *devlink,
2810 const char *status_msg,
2811 const char *component,
2813 unsigned long total)
2815 __devlink_flash_update_notify(devlink,
2816 DEVLINK_CMD_FLASH_UPDATE_STATUS,
2817 status_msg, component, done, total);
2819 EXPORT_SYMBOL_GPL(devlink_flash_update_status_notify);
2821 static int devlink_nl_cmd_flash_update(struct sk_buff *skb,
2822 struct genl_info *info)
2824 struct devlink *devlink = info->user_ptr[0];
2825 const char *file_name, *component;
2826 struct nlattr *nla_component;
2828 if (!devlink->ops->flash_update)
2831 if (!info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME])
2833 file_name = nla_data(info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME]);
2835 nla_component = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT];
2836 component = nla_component ? nla_data(nla_component) : NULL;
2838 return devlink->ops->flash_update(devlink, file_name, component,
2842 static const struct devlink_param devlink_param_generic[] = {
2844 .id = DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET,
2845 .name = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME,
2846 .type = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE,
2849 .id = DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
2850 .name = DEVLINK_PARAM_GENERIC_MAX_MACS_NAME,
2851 .type = DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE,
2854 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV,
2855 .name = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME,
2856 .type = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE,
2859 .id = DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT,
2860 .name = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME,
2861 .type = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE,
2864 .id = DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI,
2865 .name = DEVLINK_PARAM_GENERIC_IGNORE_ARI_NAME,
2866 .type = DEVLINK_PARAM_GENERIC_IGNORE_ARI_TYPE,
2869 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
2870 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_NAME,
2871 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_TYPE,
2874 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
2875 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_NAME,
2876 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_TYPE,
2879 .id = DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY,
2880 .name = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_NAME,
2881 .type = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_TYPE,
2884 .id = DEVLINK_PARAM_GENERIC_ID_RESET_DEV_ON_DRV_PROBE,
2885 .name = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_NAME,
2886 .type = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_TYPE,
2890 static int devlink_param_generic_verify(const struct devlink_param *param)
2892 /* verify it match generic parameter by id and name */
2893 if (param->id > DEVLINK_PARAM_GENERIC_ID_MAX)
2895 if (strcmp(param->name, devlink_param_generic[param->id].name))
2898 WARN_ON(param->type != devlink_param_generic[param->id].type);
2903 static int devlink_param_driver_verify(const struct devlink_param *param)
2907 if (param->id <= DEVLINK_PARAM_GENERIC_ID_MAX)
2909 /* verify no such name in generic params */
2910 for (i = 0; i <= DEVLINK_PARAM_GENERIC_ID_MAX; i++)
2911 if (!strcmp(param->name, devlink_param_generic[i].name))
2917 static struct devlink_param_item *
2918 devlink_param_find_by_name(struct list_head *param_list,
2919 const char *param_name)
2921 struct devlink_param_item *param_item;
2923 list_for_each_entry(param_item, param_list, list)
2924 if (!strcmp(param_item->param->name, param_name))
2929 static struct devlink_param_item *
2930 devlink_param_find_by_id(struct list_head *param_list, u32 param_id)
2932 struct devlink_param_item *param_item;
2934 list_for_each_entry(param_item, param_list, list)
2935 if (param_item->param->id == param_id)
2941 devlink_param_cmode_is_supported(const struct devlink_param *param,
2942 enum devlink_param_cmode cmode)
2944 return test_bit(cmode, ¶m->supported_cmodes);
2947 static int devlink_param_get(struct devlink *devlink,
2948 const struct devlink_param *param,
2949 struct devlink_param_gset_ctx *ctx)
2953 return param->get(devlink, param->id, ctx);
2956 static int devlink_param_set(struct devlink *devlink,
2957 const struct devlink_param *param,
2958 struct devlink_param_gset_ctx *ctx)
2962 return param->set(devlink, param->id, ctx);
2966 devlink_param_type_to_nla_type(enum devlink_param_type param_type)
2968 switch (param_type) {
2969 case DEVLINK_PARAM_TYPE_U8:
2971 case DEVLINK_PARAM_TYPE_U16:
2973 case DEVLINK_PARAM_TYPE_U32:
2975 case DEVLINK_PARAM_TYPE_STRING:
2977 case DEVLINK_PARAM_TYPE_BOOL:
2985 devlink_nl_param_value_fill_one(struct sk_buff *msg,
2986 enum devlink_param_type type,
2987 enum devlink_param_cmode cmode,
2988 union devlink_param_value val)
2990 struct nlattr *param_value_attr;
2992 param_value_attr = nla_nest_start_noflag(msg,
2993 DEVLINK_ATTR_PARAM_VALUE);
2994 if (!param_value_attr)
2995 goto nla_put_failure;
2997 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_CMODE, cmode))
2998 goto value_nest_cancel;
3001 case DEVLINK_PARAM_TYPE_U8:
3002 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu8))
3003 goto value_nest_cancel;
3005 case DEVLINK_PARAM_TYPE_U16:
3006 if (nla_put_u16(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu16))
3007 goto value_nest_cancel;
3009 case DEVLINK_PARAM_TYPE_U32:
3010 if (nla_put_u32(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu32))
3011 goto value_nest_cancel;
3013 case DEVLINK_PARAM_TYPE_STRING:
3014 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_VALUE_DATA,
3016 goto value_nest_cancel;
3018 case DEVLINK_PARAM_TYPE_BOOL:
3020 nla_put_flag(msg, DEVLINK_ATTR_PARAM_VALUE_DATA))
3021 goto value_nest_cancel;
3025 nla_nest_end(msg, param_value_attr);
3029 nla_nest_cancel(msg, param_value_attr);
3034 static int devlink_nl_param_fill(struct sk_buff *msg, struct devlink *devlink,
3035 unsigned int port_index,
3036 struct devlink_param_item *param_item,
3037 enum devlink_command cmd,
3038 u32 portid, u32 seq, int flags)
3040 union devlink_param_value param_value[DEVLINK_PARAM_CMODE_MAX + 1];
3041 bool param_value_set[DEVLINK_PARAM_CMODE_MAX + 1] = {};
3042 const struct devlink_param *param = param_item->param;
3043 struct devlink_param_gset_ctx ctx;
3044 struct nlattr *param_values_list;
3045 struct nlattr *param_attr;
3051 /* Get value from driver part to driverinit configuration mode */
3052 for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
3053 if (!devlink_param_cmode_is_supported(param, i))
3055 if (i == DEVLINK_PARAM_CMODE_DRIVERINIT) {
3056 if (!param_item->driverinit_value_valid)
3058 param_value[i] = param_item->driverinit_value;
3060 if (!param_item->published)
3063 err = devlink_param_get(devlink, param, &ctx);
3066 param_value[i] = ctx.val;
3068 param_value_set[i] = true;
3071 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
3075 if (devlink_nl_put_handle(msg, devlink))
3076 goto genlmsg_cancel;
3078 if (cmd == DEVLINK_CMD_PORT_PARAM_GET ||
3079 cmd == DEVLINK_CMD_PORT_PARAM_NEW ||
3080 cmd == DEVLINK_CMD_PORT_PARAM_DEL)
3081 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, port_index))
3082 goto genlmsg_cancel;
3084 param_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PARAM);
3086 goto genlmsg_cancel;
3087 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_NAME, param->name))
3088 goto param_nest_cancel;
3089 if (param->generic && nla_put_flag(msg, DEVLINK_ATTR_PARAM_GENERIC))
3090 goto param_nest_cancel;
3092 nla_type = devlink_param_type_to_nla_type(param->type);
3094 goto param_nest_cancel;
3095 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_TYPE, nla_type))
3096 goto param_nest_cancel;
3098 param_values_list = nla_nest_start_noflag(msg,
3099 DEVLINK_ATTR_PARAM_VALUES_LIST);
3100 if (!param_values_list)
3101 goto param_nest_cancel;
3103 for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
3104 if (!param_value_set[i])
3106 err = devlink_nl_param_value_fill_one(msg, param->type,
3109 goto values_list_nest_cancel;
3112 nla_nest_end(msg, param_values_list);
3113 nla_nest_end(msg, param_attr);
3114 genlmsg_end(msg, hdr);
3117 values_list_nest_cancel:
3118 nla_nest_end(msg, param_values_list);
3120 nla_nest_cancel(msg, param_attr);
3122 genlmsg_cancel(msg, hdr);
3126 static void devlink_param_notify(struct devlink *devlink,
3127 unsigned int port_index,
3128 struct devlink_param_item *param_item,
3129 enum devlink_command cmd)
3131 struct sk_buff *msg;
3134 WARN_ON(cmd != DEVLINK_CMD_PARAM_NEW && cmd != DEVLINK_CMD_PARAM_DEL &&
3135 cmd != DEVLINK_CMD_PORT_PARAM_NEW &&
3136 cmd != DEVLINK_CMD_PORT_PARAM_DEL);
3138 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3141 err = devlink_nl_param_fill(msg, devlink, port_index, param_item, cmd,
3148 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
3149 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
3152 static int devlink_nl_cmd_param_get_dumpit(struct sk_buff *msg,
3153 struct netlink_callback *cb)
3155 struct devlink_param_item *param_item;
3156 struct devlink *devlink;
3157 int start = cb->args[0];
3161 mutex_lock(&devlink_mutex);
3162 list_for_each_entry(devlink, &devlink_list, list) {
3163 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
3165 mutex_lock(&devlink->lock);
3166 list_for_each_entry(param_item, &devlink->param_list, list) {
3171 err = devlink_nl_param_fill(msg, devlink, 0, param_item,
3172 DEVLINK_CMD_PARAM_GET,
3173 NETLINK_CB(cb->skb).portid,
3177 mutex_unlock(&devlink->lock);
3182 mutex_unlock(&devlink->lock);
3185 mutex_unlock(&devlink_mutex);
3192 devlink_param_type_get_from_info(struct genl_info *info,
3193 enum devlink_param_type *param_type)
3195 if (!info->attrs[DEVLINK_ATTR_PARAM_TYPE])
3198 switch (nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_TYPE])) {
3200 *param_type = DEVLINK_PARAM_TYPE_U8;
3203 *param_type = DEVLINK_PARAM_TYPE_U16;
3206 *param_type = DEVLINK_PARAM_TYPE_U32;
3209 *param_type = DEVLINK_PARAM_TYPE_STRING;
3212 *param_type = DEVLINK_PARAM_TYPE_BOOL;
3222 devlink_param_value_get_from_info(const struct devlink_param *param,
3223 struct genl_info *info,
3224 union devlink_param_value *value)
3228 if (param->type != DEVLINK_PARAM_TYPE_BOOL &&
3229 !info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA])
3232 switch (param->type) {
3233 case DEVLINK_PARAM_TYPE_U8:
3234 value->vu8 = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3236 case DEVLINK_PARAM_TYPE_U16:
3237 value->vu16 = nla_get_u16(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3239 case DEVLINK_PARAM_TYPE_U32:
3240 value->vu32 = nla_get_u32(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3242 case DEVLINK_PARAM_TYPE_STRING:
3243 len = strnlen(nla_data(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]),
3244 nla_len(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]));
3245 if (len == nla_len(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]) ||
3246 len >= __DEVLINK_PARAM_MAX_STRING_VALUE)
3249 nla_data(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]));
3251 case DEVLINK_PARAM_TYPE_BOOL:
3252 value->vbool = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA] ?
3259 static struct devlink_param_item *
3260 devlink_param_get_from_info(struct list_head *param_list,
3261 struct genl_info *info)
3265 if (!info->attrs[DEVLINK_ATTR_PARAM_NAME])
3268 param_name = nla_data(info->attrs[DEVLINK_ATTR_PARAM_NAME]);
3269 return devlink_param_find_by_name(param_list, param_name);
3272 static int devlink_nl_cmd_param_get_doit(struct sk_buff *skb,
3273 struct genl_info *info)
3275 struct devlink *devlink = info->user_ptr[0];
3276 struct devlink_param_item *param_item;
3277 struct sk_buff *msg;
3280 param_item = devlink_param_get_from_info(&devlink->param_list, info);
3284 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3288 err = devlink_nl_param_fill(msg, devlink, 0, param_item,
3289 DEVLINK_CMD_PARAM_GET,
3290 info->snd_portid, info->snd_seq, 0);
3296 return genlmsg_reply(msg, info);
3299 static int __devlink_nl_cmd_param_set_doit(struct devlink *devlink,
3300 unsigned int port_index,
3301 struct list_head *param_list,
3302 struct genl_info *info,
3303 enum devlink_command cmd)
3305 enum devlink_param_type param_type;
3306 struct devlink_param_gset_ctx ctx;
3307 enum devlink_param_cmode cmode;
3308 struct devlink_param_item *param_item;
3309 const struct devlink_param *param;
3310 union devlink_param_value value;
3313 param_item = devlink_param_get_from_info(param_list, info);
3316 param = param_item->param;
3317 err = devlink_param_type_get_from_info(info, ¶m_type);
3320 if (param_type != param->type)
3322 err = devlink_param_value_get_from_info(param, info, &value);
3325 if (param->validate) {
3326 err = param->validate(devlink, param->id, value, info->extack);
3331 if (!info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE])
3333 cmode = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE]);
3334 if (!devlink_param_cmode_is_supported(param, cmode))
3337 if (cmode == DEVLINK_PARAM_CMODE_DRIVERINIT) {
3338 if (param->type == DEVLINK_PARAM_TYPE_STRING)
3339 strcpy(param_item->driverinit_value.vstr, value.vstr);
3341 param_item->driverinit_value = value;
3342 param_item->driverinit_value_valid = true;
3348 err = devlink_param_set(devlink, param, &ctx);
3353 devlink_param_notify(devlink, port_index, param_item, cmd);
3357 static int devlink_nl_cmd_param_set_doit(struct sk_buff *skb,
3358 struct genl_info *info)
3360 struct devlink *devlink = info->user_ptr[0];
3362 return __devlink_nl_cmd_param_set_doit(devlink, 0, &devlink->param_list,
3363 info, DEVLINK_CMD_PARAM_NEW);
3366 static int devlink_param_register_one(struct devlink *devlink,
3367 unsigned int port_index,
3368 struct list_head *param_list,
3369 const struct devlink_param *param,
3370 enum devlink_command cmd)
3372 struct devlink_param_item *param_item;
3374 if (devlink_param_find_by_name(param_list, param->name))
3377 if (param->supported_cmodes == BIT(DEVLINK_PARAM_CMODE_DRIVERINIT))
3378 WARN_ON(param->get || param->set);
3380 WARN_ON(!param->get || !param->set);
3382 param_item = kzalloc(sizeof(*param_item), GFP_KERNEL);
3385 param_item->param = param;
3387 list_add_tail(¶m_item->list, param_list);
3388 devlink_param_notify(devlink, port_index, param_item, cmd);
3392 static void devlink_param_unregister_one(struct devlink *devlink,
3393 unsigned int port_index,
3394 struct list_head *param_list,
3395 const struct devlink_param *param,
3396 enum devlink_command cmd)
3398 struct devlink_param_item *param_item;
3400 param_item = devlink_param_find_by_name(param_list, param->name);
3401 WARN_ON(!param_item);
3402 devlink_param_notify(devlink, port_index, param_item, cmd);
3403 list_del(¶m_item->list);
3407 static int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg,
3408 struct netlink_callback *cb)
3410 struct devlink_param_item *param_item;
3411 struct devlink_port *devlink_port;
3412 struct devlink *devlink;
3413 int start = cb->args[0];
3417 mutex_lock(&devlink_mutex);
3418 list_for_each_entry(devlink, &devlink_list, list) {
3419 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
3421 mutex_lock(&devlink->lock);
3422 list_for_each_entry(devlink_port, &devlink->port_list, list) {
3423 list_for_each_entry(param_item,
3424 &devlink_port->param_list, list) {
3429 err = devlink_nl_param_fill(msg,
3430 devlink_port->devlink,
3431 devlink_port->index, param_item,
3432 DEVLINK_CMD_PORT_PARAM_GET,
3433 NETLINK_CB(cb->skb).portid,
3437 mutex_unlock(&devlink->lock);
3443 mutex_unlock(&devlink->lock);
3446 mutex_unlock(&devlink_mutex);
3452 static int devlink_nl_cmd_port_param_get_doit(struct sk_buff *skb,
3453 struct genl_info *info)
3455 struct devlink_port *devlink_port = info->user_ptr[0];
3456 struct devlink_param_item *param_item;
3457 struct sk_buff *msg;
3460 param_item = devlink_param_get_from_info(&devlink_port->param_list,
3465 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3469 err = devlink_nl_param_fill(msg, devlink_port->devlink,
3470 devlink_port->index, param_item,
3471 DEVLINK_CMD_PORT_PARAM_GET,
3472 info->snd_portid, info->snd_seq, 0);
3478 return genlmsg_reply(msg, info);
3481 static int devlink_nl_cmd_port_param_set_doit(struct sk_buff *skb,
3482 struct genl_info *info)
3484 struct devlink_port *devlink_port = info->user_ptr[0];
3486 return __devlink_nl_cmd_param_set_doit(devlink_port->devlink,
3487 devlink_port->index,
3488 &devlink_port->param_list, info,
3489 DEVLINK_CMD_PORT_PARAM_NEW);
3492 static int devlink_nl_region_snapshot_id_put(struct sk_buff *msg,
3493 struct devlink *devlink,
3494 struct devlink_snapshot *snapshot)
3496 struct nlattr *snap_attr;
3499 snap_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_SNAPSHOT);
3503 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID, snapshot->id);
3505 goto nla_put_failure;
3507 nla_nest_end(msg, snap_attr);
3511 nla_nest_cancel(msg, snap_attr);
3515 static int devlink_nl_region_snapshots_id_put(struct sk_buff *msg,
3516 struct devlink *devlink,
3517 struct devlink_region *region)
3519 struct devlink_snapshot *snapshot;
3520 struct nlattr *snapshots_attr;
3523 snapshots_attr = nla_nest_start_noflag(msg,
3524 DEVLINK_ATTR_REGION_SNAPSHOTS);
3525 if (!snapshots_attr)
3528 list_for_each_entry(snapshot, ®ion->snapshot_list, list) {
3529 err = devlink_nl_region_snapshot_id_put(msg, devlink, snapshot);
3531 goto nla_put_failure;
3534 nla_nest_end(msg, snapshots_attr);
3538 nla_nest_cancel(msg, snapshots_attr);
3542 static int devlink_nl_region_fill(struct sk_buff *msg, struct devlink *devlink,
3543 enum devlink_command cmd, u32 portid,
3545 struct devlink_region *region)
3550 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
3554 err = devlink_nl_put_handle(msg, devlink);
3556 goto nla_put_failure;
3558 err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME, region->name);
3560 goto nla_put_failure;
3562 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
3566 goto nla_put_failure;
3568 err = devlink_nl_region_snapshots_id_put(msg, devlink, region);
3570 goto nla_put_failure;
3572 genlmsg_end(msg, hdr);
3576 genlmsg_cancel(msg, hdr);
3580 static void devlink_nl_region_notify(struct devlink_region *region,
3581 struct devlink_snapshot *snapshot,
3582 enum devlink_command cmd)
3584 struct devlink *devlink = region->devlink;
3585 struct sk_buff *msg;
3589 WARN_ON(cmd != DEVLINK_CMD_REGION_NEW && cmd != DEVLINK_CMD_REGION_DEL);
3591 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3595 hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd);
3599 err = devlink_nl_put_handle(msg, devlink);
3601 goto out_cancel_msg;
3603 err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME,
3606 goto out_cancel_msg;
3609 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID,
3612 goto out_cancel_msg;
3614 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
3615 region->size, DEVLINK_ATTR_PAD);
3617 goto out_cancel_msg;
3619 genlmsg_end(msg, hdr);
3621 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
3622 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
3627 genlmsg_cancel(msg, hdr);
3632 static void devlink_region_snapshot_del(struct devlink_region *region,
3633 struct devlink_snapshot *snapshot)
3635 devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_DEL);
3636 region->cur_snapshots--;
3637 list_del(&snapshot->list);
3638 (*snapshot->data_destructor)(snapshot->data);
3642 static int devlink_nl_cmd_region_get_doit(struct sk_buff *skb,
3643 struct genl_info *info)
3645 struct devlink *devlink = info->user_ptr[0];
3646 struct devlink_region *region;
3647 const char *region_name;
3648 struct sk_buff *msg;
3651 if (!info->attrs[DEVLINK_ATTR_REGION_NAME])
3654 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
3655 region = devlink_region_get_by_name(devlink, region_name);
3659 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3663 err = devlink_nl_region_fill(msg, devlink, DEVLINK_CMD_REGION_GET,
3664 info->snd_portid, info->snd_seq, 0,
3671 return genlmsg_reply(msg, info);
3674 static int devlink_nl_cmd_region_get_dumpit(struct sk_buff *msg,
3675 struct netlink_callback *cb)
3677 struct devlink_region *region;
3678 struct devlink *devlink;
3679 int start = cb->args[0];
3683 mutex_lock(&devlink_mutex);
3684 list_for_each_entry(devlink, &devlink_list, list) {
3685 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
3688 mutex_lock(&devlink->lock);
3689 list_for_each_entry(region, &devlink->region_list, list) {
3694 err = devlink_nl_region_fill(msg, devlink,
3695 DEVLINK_CMD_REGION_GET,
3696 NETLINK_CB(cb->skb).portid,
3698 NLM_F_MULTI, region);
3700 mutex_unlock(&devlink->lock);
3705 mutex_unlock(&devlink->lock);
3708 mutex_unlock(&devlink_mutex);
3713 static int devlink_nl_cmd_region_del(struct sk_buff *skb,
3714 struct genl_info *info)
3716 struct devlink *devlink = info->user_ptr[0];
3717 struct devlink_snapshot *snapshot;
3718 struct devlink_region *region;
3719 const char *region_name;
3722 if (!info->attrs[DEVLINK_ATTR_REGION_NAME] ||
3723 !info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID])
3726 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
3727 snapshot_id = nla_get_u32(info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
3729 region = devlink_region_get_by_name(devlink, region_name);
3733 snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
3737 devlink_region_snapshot_del(region, snapshot);
3741 static int devlink_nl_cmd_region_read_chunk_fill(struct sk_buff *msg,
3742 struct devlink *devlink,
3743 u8 *chunk, u32 chunk_size,
3746 struct nlattr *chunk_attr;
3749 chunk_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_CHUNK);
3753 err = nla_put(msg, DEVLINK_ATTR_REGION_CHUNK_DATA, chunk_size, chunk);
3755 goto nla_put_failure;
3757 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_CHUNK_ADDR, addr,
3760 goto nla_put_failure;
3762 nla_nest_end(msg, chunk_attr);
3766 nla_nest_cancel(msg, chunk_attr);
3770 #define DEVLINK_REGION_READ_CHUNK_SIZE 256
3772 static int devlink_nl_region_read_snapshot_fill(struct sk_buff *skb,
3773 struct devlink *devlink,
3774 struct devlink_region *region,
3775 struct nlattr **attrs,
3781 struct devlink_snapshot *snapshot;
3782 u64 curr_offset = start_offset;
3786 *new_offset = start_offset;
3788 snapshot_id = nla_get_u32(attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
3789 snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
3793 if (end_offset > region->size || dump)
3794 end_offset = region->size;
3796 while (curr_offset < end_offset) {
3800 if (end_offset - curr_offset < DEVLINK_REGION_READ_CHUNK_SIZE)
3801 data_size = end_offset - curr_offset;
3803 data_size = DEVLINK_REGION_READ_CHUNK_SIZE;
3805 data = &snapshot->data[curr_offset];
3806 err = devlink_nl_cmd_region_read_chunk_fill(skb, devlink,
3812 curr_offset += data_size;
3814 *new_offset = curr_offset;
3819 static int devlink_nl_cmd_region_read_dumpit(struct sk_buff *skb,
3820 struct netlink_callback *cb)
3822 u64 ret_offset, start_offset, end_offset = 0;
3823 struct devlink_region *region;
3824 struct nlattr *chunks_attr;
3825 const char *region_name;
3826 struct devlink *devlink;
3827 struct nlattr **attrs;
3832 start_offset = *((u64 *)&cb->args[0]);
3834 attrs = kmalloc_array(DEVLINK_ATTR_MAX + 1, sizeof(*attrs), GFP_KERNEL);
3838 err = nlmsg_parse_deprecated(cb->nlh,
3839 GENL_HDRLEN + devlink_nl_family.hdrsize,
3840 attrs, DEVLINK_ATTR_MAX,
3841 devlink_nl_family.policy, cb->extack);
3845 mutex_lock(&devlink_mutex);
3846 devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
3847 if (IS_ERR(devlink)) {
3848 err = PTR_ERR(devlink);
3852 mutex_lock(&devlink->lock);
3854 if (!attrs[DEVLINK_ATTR_REGION_NAME] ||
3855 !attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]) {
3860 region_name = nla_data(attrs[DEVLINK_ATTR_REGION_NAME]);
3861 region = devlink_region_get_by_name(devlink, region_name);
3867 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
3868 &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI,
3869 DEVLINK_CMD_REGION_READ);
3875 err = devlink_nl_put_handle(skb, devlink);
3877 goto nla_put_failure;
3879 err = nla_put_string(skb, DEVLINK_ATTR_REGION_NAME, region_name);
3881 goto nla_put_failure;
3883 chunks_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_REGION_CHUNKS);
3886 goto nla_put_failure;
3889 if (attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR] &&
3890 attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]) {
3893 nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
3895 end_offset = nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
3896 end_offset += nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]);
3900 err = devlink_nl_region_read_snapshot_fill(skb, devlink,
3906 if (err && err != -EMSGSIZE)
3907 goto nla_put_failure;
3909 /* Check if there was any progress done to prevent infinite loop */
3910 if (ret_offset == start_offset) {
3912 goto nla_put_failure;
3915 *((u64 *)&cb->args[0]) = ret_offset;
3917 nla_nest_end(skb, chunks_attr);
3918 genlmsg_end(skb, hdr);
3919 mutex_unlock(&devlink->lock);
3920 mutex_unlock(&devlink_mutex);
3926 genlmsg_cancel(skb, hdr);
3928 mutex_unlock(&devlink->lock);
3930 mutex_unlock(&devlink_mutex);
3936 struct devlink_info_req {
3937 struct sk_buff *msg;
3940 int devlink_info_driver_name_put(struct devlink_info_req *req, const char *name)
3942 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME, name);
3944 EXPORT_SYMBOL_GPL(devlink_info_driver_name_put);
3946 int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn)
3948 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn);
3950 EXPORT_SYMBOL_GPL(devlink_info_serial_number_put);
3952 static int devlink_info_version_put(struct devlink_info_req *req, int attr,
3953 const char *version_name,
3954 const char *version_value)
3956 struct nlattr *nest;
3959 nest = nla_nest_start_noflag(req->msg, attr);
3963 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME,
3966 goto nla_put_failure;
3968 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE,
3971 goto nla_put_failure;
3973 nla_nest_end(req->msg, nest);
3978 nla_nest_cancel(req->msg, nest);
3982 int devlink_info_version_fixed_put(struct devlink_info_req *req,
3983 const char *version_name,
3984 const char *version_value)
3986 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED,
3987 version_name, version_value);
3989 EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put);
3991 int devlink_info_version_stored_put(struct devlink_info_req *req,
3992 const char *version_name,
3993 const char *version_value)
3995 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED,
3996 version_name, version_value);
3998 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put);
4000 int devlink_info_version_running_put(struct devlink_info_req *req,
4001 const char *version_name,
4002 const char *version_value)
4004 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING,
4005 version_name, version_value);
4007 EXPORT_SYMBOL_GPL(devlink_info_version_running_put);
4010 devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink,
4011 enum devlink_command cmd, u32 portid,
4012 u32 seq, int flags, struct netlink_ext_ack *extack)
4014 struct devlink_info_req req;
4018 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4023 if (devlink_nl_put_handle(msg, devlink))
4024 goto err_cancel_msg;
4027 err = devlink->ops->info_get(devlink, &req, extack);
4029 goto err_cancel_msg;
4031 genlmsg_end(msg, hdr);
4035 genlmsg_cancel(msg, hdr);
4039 static int devlink_nl_cmd_info_get_doit(struct sk_buff *skb,
4040 struct genl_info *info)
4042 struct devlink *devlink = info->user_ptr[0];
4043 struct sk_buff *msg;
4046 if (!devlink->ops->info_get)
4049 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4053 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
4054 info->snd_portid, info->snd_seq, 0,
4061 return genlmsg_reply(msg, info);
4064 static int devlink_nl_cmd_info_get_dumpit(struct sk_buff *msg,
4065 struct netlink_callback *cb)
4067 struct devlink *devlink;
4068 int start = cb->args[0];
4072 mutex_lock(&devlink_mutex);
4073 list_for_each_entry(devlink, &devlink_list, list) {
4074 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4081 if (!devlink->ops->info_get) {
4086 mutex_lock(&devlink->lock);
4087 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
4088 NETLINK_CB(cb->skb).portid,
4089 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4091 mutex_unlock(&devlink->lock);
4096 mutex_unlock(&devlink_mutex);
4102 struct devlink_fmsg_item {
4103 struct list_head list;
4110 struct devlink_fmsg {
4111 struct list_head item_list;
4114 static struct devlink_fmsg *devlink_fmsg_alloc(void)
4116 struct devlink_fmsg *fmsg;
4118 fmsg = kzalloc(sizeof(*fmsg), GFP_KERNEL);
4122 INIT_LIST_HEAD(&fmsg->item_list);
4127 static void devlink_fmsg_free(struct devlink_fmsg *fmsg)
4129 struct devlink_fmsg_item *item, *tmp;
4131 list_for_each_entry_safe(item, tmp, &fmsg->item_list, list) {
4132 list_del(&item->list);
4138 static int devlink_fmsg_nest_common(struct devlink_fmsg *fmsg,
4141 struct devlink_fmsg_item *item;
4143 item = kzalloc(sizeof(*item), GFP_KERNEL);
4147 item->attrtype = attrtype;
4148 list_add_tail(&item->list, &fmsg->item_list);
4153 int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
4155 return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
4157 EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_start);
4159 static int devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
4161 return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
4164 int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
4166 return devlink_fmsg_nest_end(fmsg);
4168 EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_end);
4170 #define DEVLINK_FMSG_MAX_SIZE (GENLMSG_DEFAULT_SIZE - GENL_HDRLEN - NLA_HDRLEN)
4172 static int devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
4174 struct devlink_fmsg_item *item;
4176 if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE)
4179 item = kzalloc(sizeof(*item) + strlen(name) + 1, GFP_KERNEL);
4183 item->nla_type = NLA_NUL_STRING;
4184 item->len = strlen(name) + 1;
4185 item->attrtype = DEVLINK_ATTR_FMSG_OBJ_NAME;
4186 memcpy(&item->value, name, item->len);
4187 list_add_tail(&item->list, &fmsg->item_list);
4192 int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
4196 err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
4200 err = devlink_fmsg_put_name(fmsg, name);
4206 EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_start);
4208 int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
4210 return devlink_fmsg_nest_end(fmsg);
4212 EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_end);
4214 int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
4219 err = devlink_fmsg_pair_nest_start(fmsg, name);
4223 err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
4229 EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_start);
4231 int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
4235 err = devlink_fmsg_nest_end(fmsg);
4239 err = devlink_fmsg_nest_end(fmsg);
4245 EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_end);
4247 static int devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
4248 const void *value, u16 value_len,
4251 struct devlink_fmsg_item *item;
4253 if (value_len > DEVLINK_FMSG_MAX_SIZE)
4256 item = kzalloc(sizeof(*item) + value_len, GFP_KERNEL);
4260 item->nla_type = value_nla_type;
4261 item->len = value_len;
4262 item->attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
4263 memcpy(&item->value, value, item->len);
4264 list_add_tail(&item->list, &fmsg->item_list);
4269 int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
4271 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
4273 EXPORT_SYMBOL_GPL(devlink_fmsg_bool_put);
4275 int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
4277 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
4279 EXPORT_SYMBOL_GPL(devlink_fmsg_u8_put);
4281 int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
4283 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
4285 EXPORT_SYMBOL_GPL(devlink_fmsg_u32_put);
4287 int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
4289 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
4291 EXPORT_SYMBOL_GPL(devlink_fmsg_u64_put);
4293 int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
4295 return devlink_fmsg_put_value(fmsg, value, strlen(value) + 1,
4298 EXPORT_SYMBOL_GPL(devlink_fmsg_string_put);
4300 int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
4303 return devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
4305 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_put);
4307 int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
4312 err = devlink_fmsg_pair_nest_start(fmsg, name);
4316 err = devlink_fmsg_bool_put(fmsg, value);
4320 err = devlink_fmsg_pair_nest_end(fmsg);
4326 EXPORT_SYMBOL_GPL(devlink_fmsg_bool_pair_put);
4328 int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
4333 err = devlink_fmsg_pair_nest_start(fmsg, name);
4337 err = devlink_fmsg_u8_put(fmsg, value);
4341 err = devlink_fmsg_pair_nest_end(fmsg);
4347 EXPORT_SYMBOL_GPL(devlink_fmsg_u8_pair_put);
4349 int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
4354 err = devlink_fmsg_pair_nest_start(fmsg, name);
4358 err = devlink_fmsg_u32_put(fmsg, value);
4362 err = devlink_fmsg_pair_nest_end(fmsg);
4368 EXPORT_SYMBOL_GPL(devlink_fmsg_u32_pair_put);
4370 int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
4375 err = devlink_fmsg_pair_nest_start(fmsg, name);
4379 err = devlink_fmsg_u64_put(fmsg, value);
4383 err = devlink_fmsg_pair_nest_end(fmsg);
4389 EXPORT_SYMBOL_GPL(devlink_fmsg_u64_pair_put);
4391 int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
4396 err = devlink_fmsg_pair_nest_start(fmsg, name);
4400 err = devlink_fmsg_string_put(fmsg, value);
4404 err = devlink_fmsg_pair_nest_end(fmsg);
4410 EXPORT_SYMBOL_GPL(devlink_fmsg_string_pair_put);
4412 int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
4413 const void *value, u16 value_len)
4417 err = devlink_fmsg_pair_nest_start(fmsg, name);
4421 err = devlink_fmsg_binary_put(fmsg, value, value_len);
4425 err = devlink_fmsg_pair_nest_end(fmsg);
4431 EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_put);
4434 devlink_fmsg_item_fill_type(struct devlink_fmsg_item *msg, struct sk_buff *skb)
4436 switch (msg->nla_type) {
4441 case NLA_NUL_STRING:
4443 return nla_put_u8(skb, DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE,
4451 devlink_fmsg_item_fill_data(struct devlink_fmsg_item *msg, struct sk_buff *skb)
4453 int attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
4456 switch (msg->nla_type) {
4458 /* Always provide flag data, regardless of its value */
4459 tmp = *(bool *) msg->value;
4461 return nla_put_u8(skb, attrtype, tmp);
4463 return nla_put_u8(skb, attrtype, *(u8 *) msg->value);
4465 return nla_put_u32(skb, attrtype, *(u32 *) msg->value);
4467 return nla_put_u64_64bit(skb, attrtype, *(u64 *) msg->value,
4469 case NLA_NUL_STRING:
4470 return nla_put_string(skb, attrtype, (char *) &msg->value);
4472 return nla_put(skb, attrtype, msg->len, (void *) &msg->value);
4479 devlink_fmsg_prepare_skb(struct devlink_fmsg *fmsg, struct sk_buff *skb,
4482 struct devlink_fmsg_item *item;
4483 struct nlattr *fmsg_nlattr;
4487 fmsg_nlattr = nla_nest_start_noflag(skb, DEVLINK_ATTR_FMSG);
4491 list_for_each_entry(item, &fmsg->item_list, list) {
4497 switch (item->attrtype) {
4498 case DEVLINK_ATTR_FMSG_OBJ_NEST_START:
4499 case DEVLINK_ATTR_FMSG_PAIR_NEST_START:
4500 case DEVLINK_ATTR_FMSG_ARR_NEST_START:
4501 case DEVLINK_ATTR_FMSG_NEST_END:
4502 err = nla_put_flag(skb, item->attrtype);
4504 case DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA:
4505 err = devlink_fmsg_item_fill_type(item, skb);
4508 err = devlink_fmsg_item_fill_data(item, skb);
4510 case DEVLINK_ATTR_FMSG_OBJ_NAME:
4511 err = nla_put_string(skb, item->attrtype,
4512 (char *) &item->value);
4524 nla_nest_end(skb, fmsg_nlattr);
4528 static int devlink_fmsg_snd(struct devlink_fmsg *fmsg,
4529 struct genl_info *info,
4530 enum devlink_command cmd, int flags)
4532 struct nlmsghdr *nlh;
4533 struct sk_buff *skb;
4540 int tmp_index = index;
4542 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
4546 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
4547 &devlink_nl_family, flags | NLM_F_MULTI, cmd);
4550 goto nla_put_failure;
4553 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
4556 else if (err != -EMSGSIZE || tmp_index == index)
4557 goto nla_put_failure;
4559 genlmsg_end(skb, hdr);
4560 err = genlmsg_reply(skb, info);
4565 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
4568 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
4569 NLMSG_DONE, 0, flags | NLM_F_MULTI);
4572 goto nla_put_failure;
4575 return genlmsg_reply(skb, info);
4582 static int devlink_fmsg_dumpit(struct devlink_fmsg *fmsg, struct sk_buff *skb,
4583 struct netlink_callback *cb,
4584 enum devlink_command cmd)
4586 int index = cb->args[0];
4587 int tmp_index = index;
4591 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
4592 &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI, cmd);
4595 goto nla_put_failure;
4598 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
4599 if ((err && err != -EMSGSIZE) || tmp_index == index)
4600 goto nla_put_failure;
4602 cb->args[0] = index;
4603 genlmsg_end(skb, hdr);
4607 genlmsg_cancel(skb, hdr);
4611 struct devlink_health_reporter {
4612 struct list_head list;
4614 const struct devlink_health_reporter_ops *ops;
4615 struct devlink *devlink;
4616 struct devlink_fmsg *dump_fmsg;
4617 struct mutex dump_lock; /* lock parallel read/write from dump buffers */
4618 u64 graceful_period;
4624 u64 last_recovery_ts;
4625 refcount_t refcount;
4629 devlink_health_reporter_priv(struct devlink_health_reporter *reporter)
4631 return reporter->priv;
4633 EXPORT_SYMBOL_GPL(devlink_health_reporter_priv);
4635 static struct devlink_health_reporter *
4636 devlink_health_reporter_find_by_name(struct devlink *devlink,
4637 const char *reporter_name)
4639 struct devlink_health_reporter *reporter;
4641 lockdep_assert_held(&devlink->reporters_lock);
4642 list_for_each_entry(reporter, &devlink->reporter_list, list)
4643 if (!strcmp(reporter->ops->name, reporter_name))
4649 * devlink_health_reporter_create - create devlink health reporter
4653 * @graceful_period: to avoid recovery loops, in msecs
4654 * @auto_recover: auto recover when error occurs
4657 struct devlink_health_reporter *
4658 devlink_health_reporter_create(struct devlink *devlink,
4659 const struct devlink_health_reporter_ops *ops,
4660 u64 graceful_period, bool auto_recover,
4663 struct devlink_health_reporter *reporter;
4665 mutex_lock(&devlink->reporters_lock);
4666 if (devlink_health_reporter_find_by_name(devlink, ops->name)) {
4667 reporter = ERR_PTR(-EEXIST);
4671 if (WARN_ON(auto_recover && !ops->recover) ||
4672 WARN_ON(graceful_period && !ops->recover)) {
4673 reporter = ERR_PTR(-EINVAL);
4677 reporter = kzalloc(sizeof(*reporter), GFP_KERNEL);
4679 reporter = ERR_PTR(-ENOMEM);
4683 reporter->priv = priv;
4684 reporter->ops = ops;
4685 reporter->devlink = devlink;
4686 reporter->graceful_period = graceful_period;
4687 reporter->auto_recover = auto_recover;
4688 mutex_init(&reporter->dump_lock);
4689 refcount_set(&reporter->refcount, 1);
4690 list_add_tail(&reporter->list, &devlink->reporter_list);
4692 mutex_unlock(&devlink->reporters_lock);
4695 EXPORT_SYMBOL_GPL(devlink_health_reporter_create);
4698 * devlink_health_reporter_destroy - destroy devlink health reporter
4700 * @reporter: devlink health reporter to destroy
4703 devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
4705 mutex_lock(&reporter->devlink->reporters_lock);
4706 list_del(&reporter->list);
4707 mutex_unlock(&reporter->devlink->reporters_lock);
4708 while (refcount_read(&reporter->refcount) > 1)
4710 mutex_destroy(&reporter->dump_lock);
4711 if (reporter->dump_fmsg)
4712 devlink_fmsg_free(reporter->dump_fmsg);
4715 EXPORT_SYMBOL_GPL(devlink_health_reporter_destroy);
4718 devlink_health_reporter_state_update(struct devlink_health_reporter *reporter,
4719 enum devlink_health_reporter_state state)
4721 if (WARN_ON(state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY &&
4722 state != DEVLINK_HEALTH_REPORTER_STATE_ERROR))
4725 if (reporter->health_state == state)
4728 reporter->health_state = state;
4729 trace_devlink_health_reporter_state_update(reporter->devlink,
4730 reporter->ops->name, state);
4732 EXPORT_SYMBOL_GPL(devlink_health_reporter_state_update);
4735 devlink_health_reporter_recover(struct devlink_health_reporter *reporter,
4740 if (!reporter->ops->recover)
4743 err = reporter->ops->recover(reporter, priv_ctx);
4747 reporter->recovery_count++;
4748 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_HEALTHY;
4749 reporter->last_recovery_ts = jiffies;
4755 devlink_health_dump_clear(struct devlink_health_reporter *reporter)
4757 if (!reporter->dump_fmsg)
4759 devlink_fmsg_free(reporter->dump_fmsg);
4760 reporter->dump_fmsg = NULL;
4763 static int devlink_health_do_dump(struct devlink_health_reporter *reporter,
4768 if (!reporter->ops->dump)
4771 if (reporter->dump_fmsg)
4774 reporter->dump_fmsg = devlink_fmsg_alloc();
4775 if (!reporter->dump_fmsg) {
4780 err = devlink_fmsg_obj_nest_start(reporter->dump_fmsg);
4784 err = reporter->ops->dump(reporter, reporter->dump_fmsg,
4789 err = devlink_fmsg_obj_nest_end(reporter->dump_fmsg);
4793 reporter->dump_ts = jiffies;
4798 devlink_health_dump_clear(reporter);
4802 int devlink_health_report(struct devlink_health_reporter *reporter,
4803 const char *msg, void *priv_ctx)
4805 enum devlink_health_reporter_state prev_health_state;
4806 struct devlink *devlink = reporter->devlink;
4808 /* write a log message of the current error */
4810 trace_devlink_health_report(devlink, reporter->ops->name, msg);
4811 reporter->error_count++;
4812 prev_health_state = reporter->health_state;
4813 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
4815 /* abort if the previous error wasn't recovered */
4816 if (reporter->auto_recover &&
4817 (prev_health_state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY ||
4818 jiffies - reporter->last_recovery_ts <
4819 msecs_to_jiffies(reporter->graceful_period))) {
4820 trace_devlink_health_recover_aborted(devlink,
4821 reporter->ops->name,
4822 reporter->health_state,
4824 reporter->last_recovery_ts);
4828 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
4830 mutex_lock(&reporter->dump_lock);
4831 /* store current dump of current error, for later analysis */
4832 devlink_health_do_dump(reporter, priv_ctx);
4833 mutex_unlock(&reporter->dump_lock);
4835 if (reporter->auto_recover)
4836 return devlink_health_reporter_recover(reporter, priv_ctx);
4840 EXPORT_SYMBOL_GPL(devlink_health_report);
4842 static struct devlink_health_reporter *
4843 devlink_health_reporter_get_from_attrs(struct devlink *devlink,
4844 struct nlattr **attrs)
4846 struct devlink_health_reporter *reporter;
4847 char *reporter_name;
4849 if (!attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME])
4852 reporter_name = nla_data(attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME]);
4853 mutex_lock(&devlink->reporters_lock);
4854 reporter = devlink_health_reporter_find_by_name(devlink, reporter_name);
4856 refcount_inc(&reporter->refcount);
4857 mutex_unlock(&devlink->reporters_lock);
4861 static struct devlink_health_reporter *
4862 devlink_health_reporter_get_from_info(struct devlink *devlink,
4863 struct genl_info *info)
4865 return devlink_health_reporter_get_from_attrs(devlink, info->attrs);
4868 static struct devlink_health_reporter *
4869 devlink_health_reporter_get_from_cb(struct netlink_callback *cb)
4871 struct devlink_health_reporter *reporter;
4872 struct devlink *devlink;
4873 struct nlattr **attrs;
4876 attrs = kmalloc_array(DEVLINK_ATTR_MAX + 1, sizeof(*attrs), GFP_KERNEL);
4880 err = nlmsg_parse_deprecated(cb->nlh,
4881 GENL_HDRLEN + devlink_nl_family.hdrsize,
4882 attrs, DEVLINK_ATTR_MAX,
4883 devlink_nl_family.policy, cb->extack);
4887 mutex_lock(&devlink_mutex);
4888 devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
4889 if (IS_ERR(devlink))
4892 reporter = devlink_health_reporter_get_from_attrs(devlink, attrs);
4893 mutex_unlock(&devlink_mutex);
4897 mutex_unlock(&devlink_mutex);
4904 devlink_health_reporter_put(struct devlink_health_reporter *reporter)
4906 refcount_dec(&reporter->refcount);
4910 devlink_nl_health_reporter_fill(struct sk_buff *msg,
4911 struct devlink *devlink,
4912 struct devlink_health_reporter *reporter,
4913 enum devlink_command cmd, u32 portid,
4916 struct nlattr *reporter_attr;
4919 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4923 if (devlink_nl_put_handle(msg, devlink))
4924 goto genlmsg_cancel;
4926 reporter_attr = nla_nest_start_noflag(msg,
4927 DEVLINK_ATTR_HEALTH_REPORTER);
4929 goto genlmsg_cancel;
4930 if (nla_put_string(msg, DEVLINK_ATTR_HEALTH_REPORTER_NAME,
4931 reporter->ops->name))
4932 goto reporter_nest_cancel;
4933 if (nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_STATE,
4934 reporter->health_state))
4935 goto reporter_nest_cancel;
4936 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT,
4937 reporter->error_count, DEVLINK_ATTR_PAD))
4938 goto reporter_nest_cancel;
4939 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT,
4940 reporter->recovery_count, DEVLINK_ATTR_PAD))
4941 goto reporter_nest_cancel;
4942 if (reporter->ops->recover &&
4943 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD,
4944 reporter->graceful_period,
4946 goto reporter_nest_cancel;
4947 if (reporter->ops->recover &&
4948 nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER,
4949 reporter->auto_recover))
4950 goto reporter_nest_cancel;
4951 if (reporter->dump_fmsg &&
4952 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS,
4953 jiffies_to_msecs(reporter->dump_ts),
4955 goto reporter_nest_cancel;
4957 nla_nest_end(msg, reporter_attr);
4958 genlmsg_end(msg, hdr);
4961 reporter_nest_cancel:
4962 nla_nest_end(msg, reporter_attr);
4964 genlmsg_cancel(msg, hdr);
4968 static int devlink_nl_cmd_health_reporter_get_doit(struct sk_buff *skb,
4969 struct genl_info *info)
4971 struct devlink *devlink = info->user_ptr[0];
4972 struct devlink_health_reporter *reporter;
4973 struct sk_buff *msg;
4976 reporter = devlink_health_reporter_get_from_info(devlink, info);
4980 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4986 err = devlink_nl_health_reporter_fill(msg, devlink, reporter,
4987 DEVLINK_CMD_HEALTH_REPORTER_GET,
4988 info->snd_portid, info->snd_seq,
4995 err = genlmsg_reply(msg, info);
4997 devlink_health_reporter_put(reporter);
5002 devlink_nl_cmd_health_reporter_get_dumpit(struct sk_buff *msg,
5003 struct netlink_callback *cb)
5005 struct devlink_health_reporter *reporter;
5006 struct devlink *devlink;
5007 int start = cb->args[0];
5011 mutex_lock(&devlink_mutex);
5012 list_for_each_entry(devlink, &devlink_list, list) {
5013 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5015 mutex_lock(&devlink->reporters_lock);
5016 list_for_each_entry(reporter, &devlink->reporter_list,
5022 err = devlink_nl_health_reporter_fill(msg, devlink,
5024 DEVLINK_CMD_HEALTH_REPORTER_GET,
5025 NETLINK_CB(cb->skb).portid,
5029 mutex_unlock(&devlink->reporters_lock);
5034 mutex_unlock(&devlink->reporters_lock);
5037 mutex_unlock(&devlink_mutex);
5044 devlink_nl_cmd_health_reporter_set_doit(struct sk_buff *skb,
5045 struct genl_info *info)
5047 struct devlink *devlink = info->user_ptr[0];
5048 struct devlink_health_reporter *reporter;
5051 reporter = devlink_health_reporter_get_from_info(devlink, info);
5055 if (!reporter->ops->recover &&
5056 (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] ||
5057 info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])) {
5062 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD])
5063 reporter->graceful_period =
5064 nla_get_u64(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD]);
5066 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])
5067 reporter->auto_recover =
5068 nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER]);
5070 devlink_health_reporter_put(reporter);
5073 devlink_health_reporter_put(reporter);
5077 static int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
5078 struct genl_info *info)
5080 struct devlink *devlink = info->user_ptr[0];
5081 struct devlink_health_reporter *reporter;
5084 reporter = devlink_health_reporter_get_from_info(devlink, info);
5088 err = devlink_health_reporter_recover(reporter, NULL);
5090 devlink_health_reporter_put(reporter);
5094 static int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
5095 struct genl_info *info)
5097 struct devlink *devlink = info->user_ptr[0];
5098 struct devlink_health_reporter *reporter;
5099 struct devlink_fmsg *fmsg;
5102 reporter = devlink_health_reporter_get_from_info(devlink, info);
5106 if (!reporter->ops->diagnose) {
5107 devlink_health_reporter_put(reporter);
5111 fmsg = devlink_fmsg_alloc();
5113 devlink_health_reporter_put(reporter);
5117 err = devlink_fmsg_obj_nest_start(fmsg);
5121 err = reporter->ops->diagnose(reporter, fmsg);
5125 err = devlink_fmsg_obj_nest_end(fmsg);
5129 err = devlink_fmsg_snd(fmsg, info,
5130 DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE, 0);
5133 devlink_fmsg_free(fmsg);
5134 devlink_health_reporter_put(reporter);
5139 devlink_nl_cmd_health_reporter_dump_get_dumpit(struct sk_buff *skb,
5140 struct netlink_callback *cb)
5142 struct devlink_health_reporter *reporter;
5143 u64 start = cb->args[0];
5146 reporter = devlink_health_reporter_get_from_cb(cb);
5150 if (!reporter->ops->dump) {
5154 mutex_lock(&reporter->dump_lock);
5156 err = devlink_health_do_dump(reporter, NULL);
5159 cb->args[1] = reporter->dump_ts;
5161 if (!reporter->dump_fmsg || cb->args[1] != reporter->dump_ts) {
5162 NL_SET_ERR_MSG_MOD(cb->extack, "Dump trampled, please retry");
5167 err = devlink_fmsg_dumpit(reporter->dump_fmsg, skb, cb,
5168 DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET);
5170 mutex_unlock(&reporter->dump_lock);
5172 devlink_health_reporter_put(reporter);
5177 devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
5178 struct genl_info *info)
5180 struct devlink *devlink = info->user_ptr[0];
5181 struct devlink_health_reporter *reporter;
5183 reporter = devlink_health_reporter_get_from_info(devlink, info);
5187 if (!reporter->ops->dump) {
5188 devlink_health_reporter_put(reporter);
5192 mutex_lock(&reporter->dump_lock);
5193 devlink_health_dump_clear(reporter);
5194 mutex_unlock(&reporter->dump_lock);
5195 devlink_health_reporter_put(reporter);
5199 struct devlink_stats {
5202 struct u64_stats_sync syncp;
5206 * struct devlink_trap_group_item - Packet trap group attributes.
5207 * @group: Immutable packet trap group attributes.
5208 * @refcount: Number of trap items using the group.
5209 * @list: trap_group_list member.
5210 * @stats: Trap group statistics.
5212 * Describes packet trap group attributes. Created by devlink during trap
5215 struct devlink_trap_group_item {
5216 const struct devlink_trap_group *group;
5217 refcount_t refcount;
5218 struct list_head list;
5219 struct devlink_stats __percpu *stats;
5223 * struct devlink_trap_item - Packet trap attributes.
5224 * @trap: Immutable packet trap attributes.
5225 * @group_item: Associated group item.
5226 * @list: trap_list member.
5227 * @action: Trap action.
5228 * @stats: Trap statistics.
5229 * @priv: Driver private information.
5231 * Describes both mutable and immutable packet trap attributes. Created by
5232 * devlink during trap registration and used for all trap related operations.
5234 struct devlink_trap_item {
5235 const struct devlink_trap *trap;
5236 struct devlink_trap_group_item *group_item;
5237 struct list_head list;
5238 enum devlink_trap_action action;
5239 struct devlink_stats __percpu *stats;
5243 static struct devlink_trap_item *
5244 devlink_trap_item_lookup(struct devlink *devlink, const char *name)
5246 struct devlink_trap_item *trap_item;
5248 list_for_each_entry(trap_item, &devlink->trap_list, list) {
5249 if (!strcmp(trap_item->trap->name, name))
5256 static struct devlink_trap_item *
5257 devlink_trap_item_get_from_info(struct devlink *devlink,
5258 struct genl_info *info)
5260 struct nlattr *attr;
5262 if (!info->attrs[DEVLINK_ATTR_TRAP_NAME])
5264 attr = info->attrs[DEVLINK_ATTR_TRAP_NAME];
5266 return devlink_trap_item_lookup(devlink, nla_data(attr));
5270 devlink_trap_action_get_from_info(struct genl_info *info,
5271 enum devlink_trap_action *p_trap_action)
5275 val = nla_get_u8(info->attrs[DEVLINK_ATTR_TRAP_ACTION]);
5277 case DEVLINK_TRAP_ACTION_DROP: /* fall-through */
5278 case DEVLINK_TRAP_ACTION_TRAP:
5279 *p_trap_action = val;
5288 static int devlink_trap_metadata_put(struct sk_buff *msg,
5289 const struct devlink_trap *trap)
5291 struct nlattr *attr;
5293 attr = nla_nest_start(msg, DEVLINK_ATTR_TRAP_METADATA);
5297 if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT) &&
5298 nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT))
5299 goto nla_put_failure;
5301 nla_nest_end(msg, attr);
5306 nla_nest_cancel(msg, attr);
5310 static void devlink_trap_stats_read(struct devlink_stats __percpu *trap_stats,
5311 struct devlink_stats *stats)
5315 memset(stats, 0, sizeof(*stats));
5316 for_each_possible_cpu(i) {
5317 struct devlink_stats *cpu_stats;
5318 u64 rx_packets, rx_bytes;
5321 cpu_stats = per_cpu_ptr(trap_stats, i);
5323 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
5324 rx_packets = cpu_stats->rx_packets;
5325 rx_bytes = cpu_stats->rx_bytes;
5326 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
5328 stats->rx_packets += rx_packets;
5329 stats->rx_bytes += rx_bytes;
5333 static int devlink_trap_stats_put(struct sk_buff *msg,
5334 struct devlink_stats __percpu *trap_stats)
5336 struct devlink_stats stats;
5337 struct nlattr *attr;
5339 devlink_trap_stats_read(trap_stats, &stats);
5341 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
5345 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
5346 stats.rx_packets, DEVLINK_ATTR_PAD))
5347 goto nla_put_failure;
5349 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
5350 stats.rx_bytes, DEVLINK_ATTR_PAD))
5351 goto nla_put_failure;
5353 nla_nest_end(msg, attr);
5358 nla_nest_cancel(msg, attr);
5362 static int devlink_nl_trap_fill(struct sk_buff *msg, struct devlink *devlink,
5363 const struct devlink_trap_item *trap_item,
5364 enum devlink_command cmd, u32 portid, u32 seq,
5367 struct devlink_trap_group_item *group_item = trap_item->group_item;
5371 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
5375 if (devlink_nl_put_handle(msg, devlink))
5376 goto nla_put_failure;
5378 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
5379 group_item->group->name))
5380 goto nla_put_failure;
5382 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_NAME, trap_item->trap->name))
5383 goto nla_put_failure;
5385 if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_TYPE, trap_item->trap->type))
5386 goto nla_put_failure;
5388 if (trap_item->trap->generic &&
5389 nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
5390 goto nla_put_failure;
5392 if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_ACTION, trap_item->action))
5393 goto nla_put_failure;
5395 err = devlink_trap_metadata_put(msg, trap_item->trap);
5397 goto nla_put_failure;
5399 err = devlink_trap_stats_put(msg, trap_item->stats);
5401 goto nla_put_failure;
5403 genlmsg_end(msg, hdr);
5408 genlmsg_cancel(msg, hdr);
5412 static int devlink_nl_cmd_trap_get_doit(struct sk_buff *skb,
5413 struct genl_info *info)
5415 struct netlink_ext_ack *extack = info->extack;
5416 struct devlink *devlink = info->user_ptr[0];
5417 struct devlink_trap_item *trap_item;
5418 struct sk_buff *msg;
5421 if (list_empty(&devlink->trap_list))
5424 trap_item = devlink_trap_item_get_from_info(devlink, info);
5426 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
5430 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5434 err = devlink_nl_trap_fill(msg, devlink, trap_item,
5435 DEVLINK_CMD_TRAP_NEW, info->snd_portid,
5440 return genlmsg_reply(msg, info);
5447 static int devlink_nl_cmd_trap_get_dumpit(struct sk_buff *msg,
5448 struct netlink_callback *cb)
5450 struct devlink_trap_item *trap_item;
5451 struct devlink *devlink;
5452 int start = cb->args[0];
5456 mutex_lock(&devlink_mutex);
5457 list_for_each_entry(devlink, &devlink_list, list) {
5458 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5460 mutex_lock(&devlink->lock);
5461 list_for_each_entry(trap_item, &devlink->trap_list, list) {
5466 err = devlink_nl_trap_fill(msg, devlink, trap_item,
5467 DEVLINK_CMD_TRAP_NEW,
5468 NETLINK_CB(cb->skb).portid,
5472 mutex_unlock(&devlink->lock);
5477 mutex_unlock(&devlink->lock);
5480 mutex_unlock(&devlink_mutex);
5486 static int __devlink_trap_action_set(struct devlink *devlink,
5487 struct devlink_trap_item *trap_item,
5488 enum devlink_trap_action trap_action,
5489 struct netlink_ext_ack *extack)
5493 if (trap_item->action != trap_action &&
5494 trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP) {
5495 NL_SET_ERR_MSG_MOD(extack, "Cannot change action of non-drop traps. Skipping");
5499 err = devlink->ops->trap_action_set(devlink, trap_item->trap,
5504 trap_item->action = trap_action;
5509 static int devlink_trap_action_set(struct devlink *devlink,
5510 struct devlink_trap_item *trap_item,
5511 struct genl_info *info)
5513 enum devlink_trap_action trap_action;
5516 if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
5519 err = devlink_trap_action_get_from_info(info, &trap_action);
5521 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
5525 return __devlink_trap_action_set(devlink, trap_item, trap_action,
5529 static int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb,
5530 struct genl_info *info)
5532 struct netlink_ext_ack *extack = info->extack;
5533 struct devlink *devlink = info->user_ptr[0];
5534 struct devlink_trap_item *trap_item;
5537 if (list_empty(&devlink->trap_list))
5540 trap_item = devlink_trap_item_get_from_info(devlink, info);
5542 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
5546 err = devlink_trap_action_set(devlink, trap_item, info);
5553 static struct devlink_trap_group_item *
5554 devlink_trap_group_item_lookup(struct devlink *devlink, const char *name)
5556 struct devlink_trap_group_item *group_item;
5558 list_for_each_entry(group_item, &devlink->trap_group_list, list) {
5559 if (!strcmp(group_item->group->name, name))
5566 static struct devlink_trap_group_item *
5567 devlink_trap_group_item_get_from_info(struct devlink *devlink,
5568 struct genl_info *info)
5572 if (!info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME])
5574 name = nla_data(info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME]);
5576 return devlink_trap_group_item_lookup(devlink, name);
5580 devlink_nl_trap_group_fill(struct sk_buff *msg, struct devlink *devlink,
5581 const struct devlink_trap_group_item *group_item,
5582 enum devlink_command cmd, u32 portid, u32 seq,
5588 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
5592 if (devlink_nl_put_handle(msg, devlink))
5593 goto nla_put_failure;
5595 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
5596 group_item->group->name))
5597 goto nla_put_failure;
5599 if (group_item->group->generic &&
5600 nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
5601 goto nla_put_failure;
5603 err = devlink_trap_stats_put(msg, group_item->stats);
5605 goto nla_put_failure;
5607 genlmsg_end(msg, hdr);
5612 genlmsg_cancel(msg, hdr);
5616 static int devlink_nl_cmd_trap_group_get_doit(struct sk_buff *skb,
5617 struct genl_info *info)
5619 struct netlink_ext_ack *extack = info->extack;
5620 struct devlink *devlink = info->user_ptr[0];
5621 struct devlink_trap_group_item *group_item;
5622 struct sk_buff *msg;
5625 if (list_empty(&devlink->trap_group_list))
5628 group_item = devlink_trap_group_item_get_from_info(devlink, info);
5630 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
5634 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5638 err = devlink_nl_trap_group_fill(msg, devlink, group_item,
5639 DEVLINK_CMD_TRAP_GROUP_NEW,
5640 info->snd_portid, info->snd_seq, 0);
5642 goto err_trap_group_fill;
5644 return genlmsg_reply(msg, info);
5646 err_trap_group_fill:
5651 static int devlink_nl_cmd_trap_group_get_dumpit(struct sk_buff *msg,
5652 struct netlink_callback *cb)
5654 enum devlink_command cmd = DEVLINK_CMD_TRAP_GROUP_NEW;
5655 struct devlink_trap_group_item *group_item;
5656 u32 portid = NETLINK_CB(cb->skb).portid;
5657 struct devlink *devlink;
5658 int start = cb->args[0];
5662 mutex_lock(&devlink_mutex);
5663 list_for_each_entry(devlink, &devlink_list, list) {
5664 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5666 mutex_lock(&devlink->lock);
5667 list_for_each_entry(group_item, &devlink->trap_group_list,
5673 err = devlink_nl_trap_group_fill(msg, devlink,
5679 mutex_unlock(&devlink->lock);
5684 mutex_unlock(&devlink->lock);
5687 mutex_unlock(&devlink_mutex);
5694 __devlink_trap_group_action_set(struct devlink *devlink,
5695 struct devlink_trap_group_item *group_item,
5696 enum devlink_trap_action trap_action,
5697 struct netlink_ext_ack *extack)
5699 const char *group_name = group_item->group->name;
5700 struct devlink_trap_item *trap_item;
5703 list_for_each_entry(trap_item, &devlink->trap_list, list) {
5704 if (strcmp(trap_item->trap->group.name, group_name))
5706 err = __devlink_trap_action_set(devlink, trap_item,
5707 trap_action, extack);
5716 devlink_trap_group_action_set(struct devlink *devlink,
5717 struct devlink_trap_group_item *group_item,
5718 struct genl_info *info)
5720 enum devlink_trap_action trap_action;
5723 if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
5726 err = devlink_trap_action_get_from_info(info, &trap_action);
5728 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
5732 err = __devlink_trap_group_action_set(devlink, group_item, trap_action,
5740 static int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
5741 struct genl_info *info)
5743 struct netlink_ext_ack *extack = info->extack;
5744 struct devlink *devlink = info->user_ptr[0];
5745 struct devlink_trap_group_item *group_item;
5748 if (list_empty(&devlink->trap_group_list))
5751 group_item = devlink_trap_group_item_get_from_info(devlink, info);
5753 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
5757 err = devlink_trap_group_action_set(devlink, group_item, info);
5764 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
5765 [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
5766 [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
5767 [DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
5768 [DEVLINK_ATTR_PORT_TYPE] = { .type = NLA_U16 },
5769 [DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
5770 [DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
5771 [DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
5772 [DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
5773 [DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
5774 [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
5775 [DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
5776 [DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
5777 [DEVLINK_ATTR_ESWITCH_MODE] = { .type = NLA_U16 },
5778 [DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
5779 [DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
5780 [DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
5781 [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
5782 [DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
5783 [DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
5784 [DEVLINK_ATTR_PARAM_NAME] = { .type = NLA_NUL_STRING },
5785 [DEVLINK_ATTR_PARAM_TYPE] = { .type = NLA_U8 },
5786 [DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },
5787 [DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },
5788 [DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },
5789 [DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },
5790 [DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },
5791 [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },
5792 [DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING },
5793 [DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING },
5794 [DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING },
5795 [DEVLINK_ATTR_TRAP_ACTION] = { .type = NLA_U8 },
5796 [DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING },
5799 static const struct genl_ops devlink_nl_ops[] = {
5801 .cmd = DEVLINK_CMD_GET,
5802 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5803 .doit = devlink_nl_cmd_get_doit,
5804 .dumpit = devlink_nl_cmd_get_dumpit,
5805 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5806 /* can be retrieved by unprivileged users */
5809 .cmd = DEVLINK_CMD_PORT_GET,
5810 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5811 .doit = devlink_nl_cmd_port_get_doit,
5812 .dumpit = devlink_nl_cmd_port_get_dumpit,
5813 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
5814 /* can be retrieved by unprivileged users */
5817 .cmd = DEVLINK_CMD_PORT_SET,
5818 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5819 .doit = devlink_nl_cmd_port_set_doit,
5820 .flags = GENL_ADMIN_PERM,
5821 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
5824 .cmd = DEVLINK_CMD_PORT_SPLIT,
5825 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5826 .doit = devlink_nl_cmd_port_split_doit,
5827 .flags = GENL_ADMIN_PERM,
5828 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5829 DEVLINK_NL_FLAG_NO_LOCK,
5832 .cmd = DEVLINK_CMD_PORT_UNSPLIT,
5833 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5834 .doit = devlink_nl_cmd_port_unsplit_doit,
5835 .flags = GENL_ADMIN_PERM,
5836 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5837 DEVLINK_NL_FLAG_NO_LOCK,
5840 .cmd = DEVLINK_CMD_SB_GET,
5841 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5842 .doit = devlink_nl_cmd_sb_get_doit,
5843 .dumpit = devlink_nl_cmd_sb_get_dumpit,
5844 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5845 DEVLINK_NL_FLAG_NEED_SB,
5846 /* can be retrieved by unprivileged users */
5849 .cmd = DEVLINK_CMD_SB_POOL_GET,
5850 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5851 .doit = devlink_nl_cmd_sb_pool_get_doit,
5852 .dumpit = devlink_nl_cmd_sb_pool_get_dumpit,
5853 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5854 DEVLINK_NL_FLAG_NEED_SB,
5855 /* can be retrieved by unprivileged users */
5858 .cmd = DEVLINK_CMD_SB_POOL_SET,
5859 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5860 .doit = devlink_nl_cmd_sb_pool_set_doit,
5861 .flags = GENL_ADMIN_PERM,
5862 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5863 DEVLINK_NL_FLAG_NEED_SB,
5866 .cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
5867 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5868 .doit = devlink_nl_cmd_sb_port_pool_get_doit,
5869 .dumpit = devlink_nl_cmd_sb_port_pool_get_dumpit,
5870 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
5871 DEVLINK_NL_FLAG_NEED_SB,
5872 /* can be retrieved by unprivileged users */
5875 .cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
5876 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5877 .doit = devlink_nl_cmd_sb_port_pool_set_doit,
5878 .flags = GENL_ADMIN_PERM,
5879 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
5880 DEVLINK_NL_FLAG_NEED_SB,
5883 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
5884 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5885 .doit = devlink_nl_cmd_sb_tc_pool_bind_get_doit,
5886 .dumpit = devlink_nl_cmd_sb_tc_pool_bind_get_dumpit,
5887 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
5888 DEVLINK_NL_FLAG_NEED_SB,
5889 /* can be retrieved by unprivileged users */
5892 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
5893 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5894 .doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
5895 .flags = GENL_ADMIN_PERM,
5896 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
5897 DEVLINK_NL_FLAG_NEED_SB,
5900 .cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
5901 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5902 .doit = devlink_nl_cmd_sb_occ_snapshot_doit,
5903 .flags = GENL_ADMIN_PERM,
5904 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5905 DEVLINK_NL_FLAG_NEED_SB,
5908 .cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
5909 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5910 .doit = devlink_nl_cmd_sb_occ_max_clear_doit,
5911 .flags = GENL_ADMIN_PERM,
5912 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5913 DEVLINK_NL_FLAG_NEED_SB,
5916 .cmd = DEVLINK_CMD_ESWITCH_GET,
5917 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5918 .doit = devlink_nl_cmd_eswitch_get_doit,
5919 .flags = GENL_ADMIN_PERM,
5920 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5923 .cmd = DEVLINK_CMD_ESWITCH_SET,
5924 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5925 .doit = devlink_nl_cmd_eswitch_set_doit,
5926 .flags = GENL_ADMIN_PERM,
5927 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5928 DEVLINK_NL_FLAG_NO_LOCK,
5931 .cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
5932 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5933 .doit = devlink_nl_cmd_dpipe_table_get,
5934 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5935 /* can be retrieved by unprivileged users */
5938 .cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
5939 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5940 .doit = devlink_nl_cmd_dpipe_entries_get,
5941 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5942 /* can be retrieved by unprivileged users */
5945 .cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
5946 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5947 .doit = devlink_nl_cmd_dpipe_headers_get,
5948 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5949 /* can be retrieved by unprivileged users */
5952 .cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
5953 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5954 .doit = devlink_nl_cmd_dpipe_table_counters_set,
5955 .flags = GENL_ADMIN_PERM,
5956 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5959 .cmd = DEVLINK_CMD_RESOURCE_SET,
5960 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5961 .doit = devlink_nl_cmd_resource_set,
5962 .flags = GENL_ADMIN_PERM,
5963 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5966 .cmd = DEVLINK_CMD_RESOURCE_DUMP,
5967 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5968 .doit = devlink_nl_cmd_resource_dump,
5969 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5970 /* can be retrieved by unprivileged users */
5973 .cmd = DEVLINK_CMD_RELOAD,
5974 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5975 .doit = devlink_nl_cmd_reload,
5976 .flags = GENL_ADMIN_PERM,
5977 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
5978 DEVLINK_NL_FLAG_NO_LOCK,
5981 .cmd = DEVLINK_CMD_PARAM_GET,
5982 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5983 .doit = devlink_nl_cmd_param_get_doit,
5984 .dumpit = devlink_nl_cmd_param_get_dumpit,
5985 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5986 /* can be retrieved by unprivileged users */
5989 .cmd = DEVLINK_CMD_PARAM_SET,
5990 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5991 .doit = devlink_nl_cmd_param_set_doit,
5992 .flags = GENL_ADMIN_PERM,
5993 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
5996 .cmd = DEVLINK_CMD_PORT_PARAM_GET,
5997 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
5998 .doit = devlink_nl_cmd_port_param_get_doit,
5999 .dumpit = devlink_nl_cmd_port_param_get_dumpit,
6000 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
6001 /* can be retrieved by unprivileged users */
6004 .cmd = DEVLINK_CMD_PORT_PARAM_SET,
6005 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6006 .doit = devlink_nl_cmd_port_param_set_doit,
6007 .flags = GENL_ADMIN_PERM,
6008 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
6011 .cmd = DEVLINK_CMD_REGION_GET,
6012 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6013 .doit = devlink_nl_cmd_region_get_doit,
6014 .dumpit = devlink_nl_cmd_region_get_dumpit,
6015 .flags = GENL_ADMIN_PERM,
6016 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6019 .cmd = DEVLINK_CMD_REGION_DEL,
6020 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6021 .doit = devlink_nl_cmd_region_del,
6022 .flags = GENL_ADMIN_PERM,
6023 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6026 .cmd = DEVLINK_CMD_REGION_READ,
6027 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6028 .dumpit = devlink_nl_cmd_region_read_dumpit,
6029 .flags = GENL_ADMIN_PERM,
6030 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6033 .cmd = DEVLINK_CMD_INFO_GET,
6034 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6035 .doit = devlink_nl_cmd_info_get_doit,
6036 .dumpit = devlink_nl_cmd_info_get_dumpit,
6037 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6038 /* can be retrieved by unprivileged users */
6041 .cmd = DEVLINK_CMD_HEALTH_REPORTER_GET,
6042 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6043 .doit = devlink_nl_cmd_health_reporter_get_doit,
6044 .dumpit = devlink_nl_cmd_health_reporter_get_dumpit,
6045 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
6046 DEVLINK_NL_FLAG_NO_LOCK,
6047 /* can be retrieved by unprivileged users */
6050 .cmd = DEVLINK_CMD_HEALTH_REPORTER_SET,
6051 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6052 .doit = devlink_nl_cmd_health_reporter_set_doit,
6053 .flags = GENL_ADMIN_PERM,
6054 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
6055 DEVLINK_NL_FLAG_NO_LOCK,
6058 .cmd = DEVLINK_CMD_HEALTH_REPORTER_RECOVER,
6059 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6060 .doit = devlink_nl_cmd_health_reporter_recover_doit,
6061 .flags = GENL_ADMIN_PERM,
6062 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
6063 DEVLINK_NL_FLAG_NO_LOCK,
6066 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE,
6067 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6068 .doit = devlink_nl_cmd_health_reporter_diagnose_doit,
6069 .flags = GENL_ADMIN_PERM,
6070 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
6071 DEVLINK_NL_FLAG_NO_LOCK,
6074 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET,
6075 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6076 .dumpit = devlink_nl_cmd_health_reporter_dump_get_dumpit,
6077 .flags = GENL_ADMIN_PERM,
6078 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
6079 DEVLINK_NL_FLAG_NO_LOCK,
6082 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR,
6083 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6084 .doit = devlink_nl_cmd_health_reporter_dump_clear_doit,
6085 .flags = GENL_ADMIN_PERM,
6086 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
6087 DEVLINK_NL_FLAG_NO_LOCK,
6090 .cmd = DEVLINK_CMD_FLASH_UPDATE,
6091 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
6092 .doit = devlink_nl_cmd_flash_update,
6093 .flags = GENL_ADMIN_PERM,
6094 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6097 .cmd = DEVLINK_CMD_TRAP_GET,
6098 .doit = devlink_nl_cmd_trap_get_doit,
6099 .dumpit = devlink_nl_cmd_trap_get_dumpit,
6100 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6101 /* can be retrieved by unprivileged users */
6104 .cmd = DEVLINK_CMD_TRAP_SET,
6105 .doit = devlink_nl_cmd_trap_set_doit,
6106 .flags = GENL_ADMIN_PERM,
6107 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6110 .cmd = DEVLINK_CMD_TRAP_GROUP_GET,
6111 .doit = devlink_nl_cmd_trap_group_get_doit,
6112 .dumpit = devlink_nl_cmd_trap_group_get_dumpit,
6113 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6114 /* can be retrieved by unprivileged users */
6117 .cmd = DEVLINK_CMD_TRAP_GROUP_SET,
6118 .doit = devlink_nl_cmd_trap_group_set_doit,
6119 .flags = GENL_ADMIN_PERM,
6120 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
6124 static struct genl_family devlink_nl_family __ro_after_init = {
6125 .name = DEVLINK_GENL_NAME,
6126 .version = DEVLINK_GENL_VERSION,
6127 .maxattr = DEVLINK_ATTR_MAX,
6128 .policy = devlink_nl_policy,
6130 .pre_doit = devlink_nl_pre_doit,
6131 .post_doit = devlink_nl_post_doit,
6132 .module = THIS_MODULE,
6133 .ops = devlink_nl_ops,
6134 .n_ops = ARRAY_SIZE(devlink_nl_ops),
6135 .mcgrps = devlink_nl_mcgrps,
6136 .n_mcgrps = ARRAY_SIZE(devlink_nl_mcgrps),
6140 * devlink_alloc - Allocate new devlink instance resources
6143 * @priv_size: size of user private data
6145 * Allocate new devlink instance resources, including devlink index
6148 struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size)
6150 struct devlink *devlink;
6155 devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
6159 devlink_net_set(devlink, &init_net);
6160 INIT_LIST_HEAD(&devlink->port_list);
6161 INIT_LIST_HEAD(&devlink->sb_list);
6162 INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
6163 INIT_LIST_HEAD(&devlink->resource_list);
6164 INIT_LIST_HEAD(&devlink->param_list);
6165 INIT_LIST_HEAD(&devlink->region_list);
6166 INIT_LIST_HEAD(&devlink->reporter_list);
6167 INIT_LIST_HEAD(&devlink->trap_list);
6168 INIT_LIST_HEAD(&devlink->trap_group_list);
6169 mutex_init(&devlink->lock);
6170 mutex_init(&devlink->reporters_lock);
6173 EXPORT_SYMBOL_GPL(devlink_alloc);
6176 * devlink_register - Register devlink instance
6179 * @dev: parent device
6181 int devlink_register(struct devlink *devlink, struct device *dev)
6183 mutex_lock(&devlink_mutex);
6185 list_add_tail(&devlink->list, &devlink_list);
6186 devlink_notify(devlink, DEVLINK_CMD_NEW);
6187 mutex_unlock(&devlink_mutex);
6190 EXPORT_SYMBOL_GPL(devlink_register);
6193 * devlink_unregister - Unregister devlink instance
6197 void devlink_unregister(struct devlink *devlink)
6199 mutex_lock(&devlink_mutex);
6200 devlink_notify(devlink, DEVLINK_CMD_DEL);
6201 list_del(&devlink->list);
6202 mutex_unlock(&devlink_mutex);
6204 EXPORT_SYMBOL_GPL(devlink_unregister);
6207 * devlink_free - Free devlink instance resources
6211 void devlink_free(struct devlink *devlink)
6213 mutex_destroy(&devlink->reporters_lock);
6214 mutex_destroy(&devlink->lock);
6215 WARN_ON(!list_empty(&devlink->trap_group_list));
6216 WARN_ON(!list_empty(&devlink->trap_list));
6217 WARN_ON(!list_empty(&devlink->reporter_list));
6218 WARN_ON(!list_empty(&devlink->region_list));
6219 WARN_ON(!list_empty(&devlink->param_list));
6220 WARN_ON(!list_empty(&devlink->resource_list));
6221 WARN_ON(!list_empty(&devlink->dpipe_table_list));
6222 WARN_ON(!list_empty(&devlink->sb_list));
6223 WARN_ON(!list_empty(&devlink->port_list));
6227 EXPORT_SYMBOL_GPL(devlink_free);
6229 static void devlink_port_type_warn(struct work_struct *work)
6231 WARN(true, "Type was not set for devlink port.");
6234 static bool devlink_port_type_should_warn(struct devlink_port *devlink_port)
6236 /* Ignore CPU and DSA flavours. */
6237 return devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_CPU &&
6238 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA;
6241 #define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 30)
6243 static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
6245 if (!devlink_port_type_should_warn(devlink_port))
6247 /* Schedule a work to WARN in case driver does not set port
6248 * type within timeout.
6250 schedule_delayed_work(&devlink_port->type_warn_dw,
6251 DEVLINK_PORT_TYPE_WARN_TIMEOUT);
6254 static void devlink_port_type_warn_cancel(struct devlink_port *devlink_port)
6256 if (!devlink_port_type_should_warn(devlink_port))
6258 cancel_delayed_work_sync(&devlink_port->type_warn_dw);
6262 * devlink_port_register - Register devlink port
6265 * @devlink_port: devlink port
6266 * @port_index: driver-specific numerical identifier of the port
6268 * Register devlink port with provided port index. User can use
6269 * any indexing, even hw-related one. devlink_port structure
6270 * is convenient to be embedded inside user driver private structure.
6271 * Note that the caller should take care of zeroing the devlink_port
6274 int devlink_port_register(struct devlink *devlink,
6275 struct devlink_port *devlink_port,
6276 unsigned int port_index)
6278 mutex_lock(&devlink->lock);
6279 if (devlink_port_index_exists(devlink, port_index)) {
6280 mutex_unlock(&devlink->lock);
6283 devlink_port->devlink = devlink;
6284 devlink_port->index = port_index;
6285 devlink_port->registered = true;
6286 spin_lock_init(&devlink_port->type_lock);
6287 list_add_tail(&devlink_port->list, &devlink->port_list);
6288 INIT_LIST_HEAD(&devlink_port->param_list);
6289 mutex_unlock(&devlink->lock);
6290 INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn);
6291 devlink_port_type_warn_schedule(devlink_port);
6292 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
6295 EXPORT_SYMBOL_GPL(devlink_port_register);
6298 * devlink_port_unregister - Unregister devlink port
6300 * @devlink_port: devlink port
6302 void devlink_port_unregister(struct devlink_port *devlink_port)
6304 struct devlink *devlink = devlink_port->devlink;
6306 devlink_port_type_warn_cancel(devlink_port);
6307 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
6308 mutex_lock(&devlink->lock);
6309 list_del(&devlink_port->list);
6310 mutex_unlock(&devlink->lock);
6312 EXPORT_SYMBOL_GPL(devlink_port_unregister);
6314 static void __devlink_port_type_set(struct devlink_port *devlink_port,
6315 enum devlink_port_type type,
6318 if (WARN_ON(!devlink_port->registered))
6320 devlink_port_type_warn_cancel(devlink_port);
6321 spin_lock_bh(&devlink_port->type_lock);
6322 devlink_port->type = type;
6323 devlink_port->type_dev = type_dev;
6324 spin_unlock_bh(&devlink_port->type_lock);
6325 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
6329 * devlink_port_type_eth_set - Set port type to Ethernet
6331 * @devlink_port: devlink port
6332 * @netdev: related netdevice
6334 void devlink_port_type_eth_set(struct devlink_port *devlink_port,
6335 struct net_device *netdev)
6337 const struct net_device_ops *ops = netdev->netdev_ops;
6339 /* If driver registers devlink port, it should set devlink port
6340 * attributes accordingly so the compat functions are called
6341 * and the original ops are not used.
6343 if (ops->ndo_get_phys_port_name) {
6344 /* Some drivers use the same set of ndos for netdevs
6345 * that have devlink_port registered and also for
6346 * those who don't. Make sure that ndo_get_phys_port_name
6347 * returns -EOPNOTSUPP here in case it is defined.
6350 char name[IFNAMSIZ];
6353 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name));
6354 WARN_ON(err != -EOPNOTSUPP);
6356 if (ops->ndo_get_port_parent_id) {
6357 /* Some drivers use the same set of ndos for netdevs
6358 * that have devlink_port registered and also for
6359 * those who don't. Make sure that ndo_get_port_parent_id
6360 * returns -EOPNOTSUPP here in case it is defined.
6363 struct netdev_phys_item_id ppid;
6366 err = ops->ndo_get_port_parent_id(netdev, &ppid);
6367 WARN_ON(err != -EOPNOTSUPP);
6369 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, netdev);
6371 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
6374 * devlink_port_type_ib_set - Set port type to InfiniBand
6376 * @devlink_port: devlink port
6377 * @ibdev: related IB device
6379 void devlink_port_type_ib_set(struct devlink_port *devlink_port,
6380 struct ib_device *ibdev)
6382 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev);
6384 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
6387 * devlink_port_type_clear - Clear port type
6389 * @devlink_port: devlink port
6391 void devlink_port_type_clear(struct devlink_port *devlink_port)
6393 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL);
6394 devlink_port_type_warn_schedule(devlink_port);
6396 EXPORT_SYMBOL_GPL(devlink_port_type_clear);
6398 static int __devlink_port_attrs_set(struct devlink_port *devlink_port,
6399 enum devlink_port_flavour flavour,
6400 const unsigned char *switch_id,
6401 unsigned char switch_id_len)
6403 struct devlink_port_attrs *attrs = &devlink_port->attrs;
6405 if (WARN_ON(devlink_port->registered))
6408 attrs->flavour = flavour;
6410 attrs->switch_port = true;
6411 if (WARN_ON(switch_id_len > MAX_PHYS_ITEM_ID_LEN))
6412 switch_id_len = MAX_PHYS_ITEM_ID_LEN;
6413 memcpy(attrs->switch_id.id, switch_id, switch_id_len);
6414 attrs->switch_id.id_len = switch_id_len;
6416 attrs->switch_port = false;
6422 * devlink_port_attrs_set - Set port attributes
6424 * @devlink_port: devlink port
6425 * @flavour: flavour of the port
6426 * @port_number: number of the port that is facing user, for example
6427 * the front panel port number
6428 * @split: indicates if this is split port
6429 * @split_subport_number: if the port is split, this is the number
6431 * @switch_id: if the port is part of switch, this is buffer with ID,
6432 * otwerwise this is NULL
6433 * @switch_id_len: length of the switch_id buffer
6435 void devlink_port_attrs_set(struct devlink_port *devlink_port,
6436 enum devlink_port_flavour flavour,
6437 u32 port_number, bool split,
6438 u32 split_subport_number,
6439 const unsigned char *switch_id,
6440 unsigned char switch_id_len)
6442 struct devlink_port_attrs *attrs = &devlink_port->attrs;
6445 ret = __devlink_port_attrs_set(devlink_port, flavour,
6446 switch_id, switch_id_len);
6449 attrs->split = split;
6450 attrs->phys.port_number = port_number;
6451 attrs->phys.split_subport_number = split_subport_number;
6453 EXPORT_SYMBOL_GPL(devlink_port_attrs_set);
6456 * devlink_port_attrs_pci_pf_set - Set PCI PF port attributes
6458 * @devlink_port: devlink port
6459 * @pf: associated PF for the devlink port instance
6460 * @switch_id: if the port is part of switch, this is buffer with ID,
6461 * otherwise this is NULL
6462 * @switch_id_len: length of the switch_id buffer
6464 void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port,
6465 const unsigned char *switch_id,
6466 unsigned char switch_id_len, u16 pf)
6468 struct devlink_port_attrs *attrs = &devlink_port->attrs;
6471 ret = __devlink_port_attrs_set(devlink_port,
6472 DEVLINK_PORT_FLAVOUR_PCI_PF,
6473 switch_id, switch_id_len);
6477 attrs->pci_pf.pf = pf;
6479 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set);
6482 * devlink_port_attrs_pci_vf_set - Set PCI VF port attributes
6484 * @devlink_port: devlink port
6485 * @pf: associated PF for the devlink port instance
6486 * @vf: associated VF of a PF for the devlink port instance
6487 * @switch_id: if the port is part of switch, this is buffer with ID,
6488 * otherwise this is NULL
6489 * @switch_id_len: length of the switch_id buffer
6491 void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port,
6492 const unsigned char *switch_id,
6493 unsigned char switch_id_len,
6496 struct devlink_port_attrs *attrs = &devlink_port->attrs;
6499 ret = __devlink_port_attrs_set(devlink_port,
6500 DEVLINK_PORT_FLAVOUR_PCI_VF,
6501 switch_id, switch_id_len);
6504 attrs->pci_vf.pf = pf;
6505 attrs->pci_vf.vf = vf;
6507 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set);
6509 static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port,
6510 char *name, size_t len)
6512 struct devlink_port_attrs *attrs = &devlink_port->attrs;
6518 switch (attrs->flavour) {
6519 case DEVLINK_PORT_FLAVOUR_PHYSICAL:
6521 n = snprintf(name, len, "p%u", attrs->phys.port_number);
6523 n = snprintf(name, len, "p%us%u",
6524 attrs->phys.port_number,
6525 attrs->phys.split_subport_number);
6527 case DEVLINK_PORT_FLAVOUR_CPU:
6528 case DEVLINK_PORT_FLAVOUR_DSA:
6529 /* As CPU and DSA ports do not have a netdevice associated
6530 * case should not ever happen.
6534 case DEVLINK_PORT_FLAVOUR_PCI_PF:
6535 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf);
6537 case DEVLINK_PORT_FLAVOUR_PCI_VF:
6538 n = snprintf(name, len, "pf%uvf%u",
6539 attrs->pci_vf.pf, attrs->pci_vf.vf);
6549 int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
6550 u32 size, u16 ingress_pools_count,
6551 u16 egress_pools_count, u16 ingress_tc_count,
6552 u16 egress_tc_count)
6554 struct devlink_sb *devlink_sb;
6557 mutex_lock(&devlink->lock);
6558 if (devlink_sb_index_exists(devlink, sb_index)) {
6563 devlink_sb = kzalloc(sizeof(*devlink_sb), GFP_KERNEL);
6568 devlink_sb->index = sb_index;
6569 devlink_sb->size = size;
6570 devlink_sb->ingress_pools_count = ingress_pools_count;
6571 devlink_sb->egress_pools_count = egress_pools_count;
6572 devlink_sb->ingress_tc_count = ingress_tc_count;
6573 devlink_sb->egress_tc_count = egress_tc_count;
6574 list_add_tail(&devlink_sb->list, &devlink->sb_list);
6576 mutex_unlock(&devlink->lock);
6579 EXPORT_SYMBOL_GPL(devlink_sb_register);
6581 void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index)
6583 struct devlink_sb *devlink_sb;
6585 mutex_lock(&devlink->lock);
6586 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
6587 WARN_ON(!devlink_sb);
6588 list_del(&devlink_sb->list);
6589 mutex_unlock(&devlink->lock);
6592 EXPORT_SYMBOL_GPL(devlink_sb_unregister);
6595 * devlink_dpipe_headers_register - register dpipe headers
6598 * @dpipe_headers: dpipe header array
6600 * Register the headers supported by hardware.
6602 int devlink_dpipe_headers_register(struct devlink *devlink,
6603 struct devlink_dpipe_headers *dpipe_headers)
6605 mutex_lock(&devlink->lock);
6606 devlink->dpipe_headers = dpipe_headers;
6607 mutex_unlock(&devlink->lock);
6610 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register);
6613 * devlink_dpipe_headers_unregister - unregister dpipe headers
6617 * Unregister the headers supported by hardware.
6619 void devlink_dpipe_headers_unregister(struct devlink *devlink)
6621 mutex_lock(&devlink->lock);
6622 devlink->dpipe_headers = NULL;
6623 mutex_unlock(&devlink->lock);
6625 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister);
6628 * devlink_dpipe_table_counter_enabled - check if counter allocation
6631 * @table_name: tables name
6633 * Used by driver to check if counter allocation is required.
6634 * After counter allocation is turned on the table entries
6635 * are updated to include counter statistics.
6637 * After that point on the driver must respect the counter
6638 * state so that each entry added to the table is added
6641 bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
6642 const char *table_name)
6644 struct devlink_dpipe_table *table;
6648 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
6652 enabled = table->counters_enabled;
6656 EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
6659 * devlink_dpipe_table_register - register dpipe table
6662 * @table_name: table name
6663 * @table_ops: table ops
6665 * @counter_control_extern: external control for counters
6667 int devlink_dpipe_table_register(struct devlink *devlink,
6668 const char *table_name,
6669 struct devlink_dpipe_table_ops *table_ops,
6670 void *priv, bool counter_control_extern)
6672 struct devlink_dpipe_table *table;
6674 if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name))
6677 if (WARN_ON(!table_ops->size_get))
6680 table = kzalloc(sizeof(*table), GFP_KERNEL);
6684 table->name = table_name;
6685 table->table_ops = table_ops;
6687 table->counter_control_extern = counter_control_extern;
6689 mutex_lock(&devlink->lock);
6690 list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
6691 mutex_unlock(&devlink->lock);
6694 EXPORT_SYMBOL_GPL(devlink_dpipe_table_register);
6697 * devlink_dpipe_table_unregister - unregister dpipe table
6700 * @table_name: table name
6702 void devlink_dpipe_table_unregister(struct devlink *devlink,
6703 const char *table_name)
6705 struct devlink_dpipe_table *table;
6707 mutex_lock(&devlink->lock);
6708 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
6712 list_del_rcu(&table->list);
6713 mutex_unlock(&devlink->lock);
6714 kfree_rcu(table, rcu);
6717 mutex_unlock(&devlink->lock);
6719 EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister);
6722 * devlink_resource_register - devlink resource register
6725 * @resource_name: resource's name
6726 * @resource_size: resource's size
6727 * @resource_id: resource's id
6728 * @parent_resource_id: resource's parent id
6729 * @size_params: size parameters
6731 int devlink_resource_register(struct devlink *devlink,
6732 const char *resource_name,
6735 u64 parent_resource_id,
6736 const struct devlink_resource_size_params *size_params)
6738 struct devlink_resource *resource;
6739 struct list_head *resource_list;
6743 top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
6745 mutex_lock(&devlink->lock);
6746 resource = devlink_resource_find(devlink, NULL, resource_id);
6752 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
6758 if (top_hierarchy) {
6759 resource_list = &devlink->resource_list;
6761 struct devlink_resource *parent_resource;
6763 parent_resource = devlink_resource_find(devlink, NULL,
6764 parent_resource_id);
6765 if (parent_resource) {
6766 resource_list = &parent_resource->resource_list;
6767 resource->parent = parent_resource;
6775 resource->name = resource_name;
6776 resource->size = resource_size;
6777 resource->size_new = resource_size;
6778 resource->id = resource_id;
6779 resource->size_valid = true;
6780 memcpy(&resource->size_params, size_params,
6781 sizeof(resource->size_params));
6782 INIT_LIST_HEAD(&resource->resource_list);
6783 list_add_tail(&resource->list, resource_list);
6785 mutex_unlock(&devlink->lock);
6788 EXPORT_SYMBOL_GPL(devlink_resource_register);
6791 * devlink_resources_unregister - free all resources
6794 * @resource: resource
6796 void devlink_resources_unregister(struct devlink *devlink,
6797 struct devlink_resource *resource)
6799 struct devlink_resource *tmp, *child_resource;
6800 struct list_head *resource_list;
6803 resource_list = &resource->resource_list;
6805 resource_list = &devlink->resource_list;
6808 mutex_lock(&devlink->lock);
6810 list_for_each_entry_safe(child_resource, tmp, resource_list, list) {
6811 devlink_resources_unregister(devlink, child_resource);
6812 list_del(&child_resource->list);
6813 kfree(child_resource);
6817 mutex_unlock(&devlink->lock);
6819 EXPORT_SYMBOL_GPL(devlink_resources_unregister);
6822 * devlink_resource_size_get - get and update size
6825 * @resource_id: the requested resource id
6826 * @p_resource_size: ptr to update
6828 int devlink_resource_size_get(struct devlink *devlink,
6830 u64 *p_resource_size)
6832 struct devlink_resource *resource;
6835 mutex_lock(&devlink->lock);
6836 resource = devlink_resource_find(devlink, NULL, resource_id);
6841 *p_resource_size = resource->size_new;
6842 resource->size = resource->size_new;
6844 mutex_unlock(&devlink->lock);
6847 EXPORT_SYMBOL_GPL(devlink_resource_size_get);
6850 * devlink_dpipe_table_resource_set - set the resource id
6853 * @table_name: table name
6854 * @resource_id: resource id
6855 * @resource_units: number of resource's units consumed per table's entry
6857 int devlink_dpipe_table_resource_set(struct devlink *devlink,
6858 const char *table_name, u64 resource_id,
6861 struct devlink_dpipe_table *table;
6864 mutex_lock(&devlink->lock);
6865 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
6871 table->resource_id = resource_id;
6872 table->resource_units = resource_units;
6873 table->resource_valid = true;
6875 mutex_unlock(&devlink->lock);
6878 EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set);
6881 * devlink_resource_occ_get_register - register occupancy getter
6884 * @resource_id: resource id
6885 * @occ_get: occupancy getter callback
6886 * @occ_get_priv: occupancy getter callback priv
6888 void devlink_resource_occ_get_register(struct devlink *devlink,
6890 devlink_resource_occ_get_t *occ_get,
6893 struct devlink_resource *resource;
6895 mutex_lock(&devlink->lock);
6896 resource = devlink_resource_find(devlink, NULL, resource_id);
6897 if (WARN_ON(!resource))
6899 WARN_ON(resource->occ_get);
6901 resource->occ_get = occ_get;
6902 resource->occ_get_priv = occ_get_priv;
6904 mutex_unlock(&devlink->lock);
6906 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_register);
6909 * devlink_resource_occ_get_unregister - unregister occupancy getter
6912 * @resource_id: resource id
6914 void devlink_resource_occ_get_unregister(struct devlink *devlink,
6917 struct devlink_resource *resource;
6919 mutex_lock(&devlink->lock);
6920 resource = devlink_resource_find(devlink, NULL, resource_id);
6921 if (WARN_ON(!resource))
6923 WARN_ON(!resource->occ_get);
6925 resource->occ_get = NULL;
6926 resource->occ_get_priv = NULL;
6928 mutex_unlock(&devlink->lock);
6930 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_unregister);
6932 static int devlink_param_verify(const struct devlink_param *param)
6934 if (!param || !param->name || !param->supported_cmodes)
6937 return devlink_param_generic_verify(param);
6939 return devlink_param_driver_verify(param);
6942 static int __devlink_params_register(struct devlink *devlink,
6943 unsigned int port_index,
6944 struct list_head *param_list,
6945 const struct devlink_param *params,
6946 size_t params_count,
6947 enum devlink_command reg_cmd,
6948 enum devlink_command unreg_cmd)
6950 const struct devlink_param *param = params;
6954 mutex_lock(&devlink->lock);
6955 for (i = 0; i < params_count; i++, param++) {
6956 err = devlink_param_verify(param);
6960 err = devlink_param_register_one(devlink, port_index,
6961 param_list, param, reg_cmd);
6966 mutex_unlock(&devlink->lock);
6972 for (param--; i > 0; i--, param--)
6973 devlink_param_unregister_one(devlink, port_index, param_list,
6976 mutex_unlock(&devlink->lock);
6980 static void __devlink_params_unregister(struct devlink *devlink,
6981 unsigned int port_index,
6982 struct list_head *param_list,
6983 const struct devlink_param *params,
6984 size_t params_count,
6985 enum devlink_command cmd)
6987 const struct devlink_param *param = params;
6990 mutex_lock(&devlink->lock);
6991 for (i = 0; i < params_count; i++, param++)
6992 devlink_param_unregister_one(devlink, 0, param_list, param,
6994 mutex_unlock(&devlink->lock);
6998 * devlink_params_register - register configuration parameters
7001 * @params: configuration parameters array
7002 * @params_count: number of parameters provided
7004 * Register the configuration parameters supported by the driver.
7006 int devlink_params_register(struct devlink *devlink,
7007 const struct devlink_param *params,
7008 size_t params_count)
7010 return __devlink_params_register(devlink, 0, &devlink->param_list,
7011 params, params_count,
7012 DEVLINK_CMD_PARAM_NEW,
7013 DEVLINK_CMD_PARAM_DEL);
7015 EXPORT_SYMBOL_GPL(devlink_params_register);
7018 * devlink_params_unregister - unregister configuration parameters
7020 * @params: configuration parameters to unregister
7021 * @params_count: number of parameters provided
7023 void devlink_params_unregister(struct devlink *devlink,
7024 const struct devlink_param *params,
7025 size_t params_count)
7027 return __devlink_params_unregister(devlink, 0, &devlink->param_list,
7028 params, params_count,
7029 DEVLINK_CMD_PARAM_DEL);
7031 EXPORT_SYMBOL_GPL(devlink_params_unregister);
7034 * devlink_params_publish - publish configuration parameters
7038 * Publish previously registered configuration parameters.
7040 void devlink_params_publish(struct devlink *devlink)
7042 struct devlink_param_item *param_item;
7044 list_for_each_entry(param_item, &devlink->param_list, list) {
7045 if (param_item->published)
7047 param_item->published = true;
7048 devlink_param_notify(devlink, 0, param_item,
7049 DEVLINK_CMD_PARAM_NEW);
7052 EXPORT_SYMBOL_GPL(devlink_params_publish);
7055 * devlink_params_unpublish - unpublish configuration parameters
7059 * Unpublish previously registered configuration parameters.
7061 void devlink_params_unpublish(struct devlink *devlink)
7063 struct devlink_param_item *param_item;
7065 list_for_each_entry(param_item, &devlink->param_list, list) {
7066 if (!param_item->published)
7068 param_item->published = false;
7069 devlink_param_notify(devlink, 0, param_item,
7070 DEVLINK_CMD_PARAM_DEL);
7073 EXPORT_SYMBOL_GPL(devlink_params_unpublish);
7076 * devlink_port_params_register - register port configuration parameters
7078 * @devlink_port: devlink port
7079 * @params: configuration parameters array
7080 * @params_count: number of parameters provided
7082 * Register the configuration parameters supported by the port.
7084 int devlink_port_params_register(struct devlink_port *devlink_port,
7085 const struct devlink_param *params,
7086 size_t params_count)
7088 return __devlink_params_register(devlink_port->devlink,
7089 devlink_port->index,
7090 &devlink_port->param_list, params,
7092 DEVLINK_CMD_PORT_PARAM_NEW,
7093 DEVLINK_CMD_PORT_PARAM_DEL);
7095 EXPORT_SYMBOL_GPL(devlink_port_params_register);
7098 * devlink_port_params_unregister - unregister port configuration
7101 * @devlink_port: devlink port
7102 * @params: configuration parameters array
7103 * @params_count: number of parameters provided
7105 void devlink_port_params_unregister(struct devlink_port *devlink_port,
7106 const struct devlink_param *params,
7107 size_t params_count)
7109 return __devlink_params_unregister(devlink_port->devlink,
7110 devlink_port->index,
7111 &devlink_port->param_list,
7112 params, params_count,
7113 DEVLINK_CMD_PORT_PARAM_DEL);
7115 EXPORT_SYMBOL_GPL(devlink_port_params_unregister);
7118 __devlink_param_driverinit_value_get(struct list_head *param_list, u32 param_id,
7119 union devlink_param_value *init_val)
7121 struct devlink_param_item *param_item;
7123 param_item = devlink_param_find_by_id(param_list, param_id);
7127 if (!param_item->driverinit_value_valid ||
7128 !devlink_param_cmode_is_supported(param_item->param,
7129 DEVLINK_PARAM_CMODE_DRIVERINIT))
7132 if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
7133 strcpy(init_val->vstr, param_item->driverinit_value.vstr);
7135 *init_val = param_item->driverinit_value;
7141 __devlink_param_driverinit_value_set(struct devlink *devlink,
7142 unsigned int port_index,
7143 struct list_head *param_list, u32 param_id,
7144 union devlink_param_value init_val,
7145 enum devlink_command cmd)
7147 struct devlink_param_item *param_item;
7149 param_item = devlink_param_find_by_id(param_list, param_id);
7153 if (!devlink_param_cmode_is_supported(param_item->param,
7154 DEVLINK_PARAM_CMODE_DRIVERINIT))
7157 if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
7158 strcpy(param_item->driverinit_value.vstr, init_val.vstr);
7160 param_item->driverinit_value = init_val;
7161 param_item->driverinit_value_valid = true;
7163 devlink_param_notify(devlink, port_index, param_item, cmd);
7168 * devlink_param_driverinit_value_get - get configuration parameter
7169 * value for driver initializing
7172 * @param_id: parameter ID
7173 * @init_val: value of parameter in driverinit configuration mode
7175 * This function should be used by the driver to get driverinit
7176 * configuration for initialization after reload command.
7178 int devlink_param_driverinit_value_get(struct devlink *devlink, u32 param_id,
7179 union devlink_param_value *init_val)
7181 if (!devlink_reload_supported(devlink))
7184 return __devlink_param_driverinit_value_get(&devlink->param_list,
7185 param_id, init_val);
7187 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_get);
7190 * devlink_param_driverinit_value_set - set value of configuration
7191 * parameter for driverinit
7192 * configuration mode
7195 * @param_id: parameter ID
7196 * @init_val: value of parameter to set for driverinit configuration mode
7198 * This function should be used by the driver to set driverinit
7199 * configuration mode default value.
7201 int devlink_param_driverinit_value_set(struct devlink *devlink, u32 param_id,
7202 union devlink_param_value init_val)
7204 return __devlink_param_driverinit_value_set(devlink, 0,
7205 &devlink->param_list,
7207 DEVLINK_CMD_PARAM_NEW);
7209 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_set);
7212 * devlink_port_param_driverinit_value_get - get configuration parameter
7213 * value for driver initializing
7215 * @devlink_port: devlink_port
7216 * @param_id: parameter ID
7217 * @init_val: value of parameter in driverinit configuration mode
7219 * This function should be used by the driver to get driverinit
7220 * configuration for initialization after reload command.
7222 int devlink_port_param_driverinit_value_get(struct devlink_port *devlink_port,
7224 union devlink_param_value *init_val)
7226 struct devlink *devlink = devlink_port->devlink;
7228 if (!devlink_reload_supported(devlink))
7231 return __devlink_param_driverinit_value_get(&devlink_port->param_list,
7232 param_id, init_val);
7234 EXPORT_SYMBOL_GPL(devlink_port_param_driverinit_value_get);
7237 * devlink_port_param_driverinit_value_set - set value of configuration
7238 * parameter for driverinit
7239 * configuration mode
7241 * @devlink_port: devlink_port
7242 * @param_id: parameter ID
7243 * @init_val: value of parameter to set for driverinit configuration mode
7245 * This function should be used by the driver to set driverinit
7246 * configuration mode default value.
7248 int devlink_port_param_driverinit_value_set(struct devlink_port *devlink_port,
7250 union devlink_param_value init_val)
7252 return __devlink_param_driverinit_value_set(devlink_port->devlink,
7253 devlink_port->index,
7254 &devlink_port->param_list,
7256 DEVLINK_CMD_PORT_PARAM_NEW);
7258 EXPORT_SYMBOL_GPL(devlink_port_param_driverinit_value_set);
7261 * devlink_param_value_changed - notify devlink on a parameter's value
7262 * change. Should be called by the driver
7263 * right after the change.
7266 * @param_id: parameter ID
7268 * This function should be used by the driver to notify devlink on value
7269 * change, excluding driverinit configuration mode.
7270 * For driverinit configuration mode driver should use the function
7272 void devlink_param_value_changed(struct devlink *devlink, u32 param_id)
7274 struct devlink_param_item *param_item;
7276 param_item = devlink_param_find_by_id(&devlink->param_list, param_id);
7277 WARN_ON(!param_item);
7279 devlink_param_notify(devlink, 0, param_item, DEVLINK_CMD_PARAM_NEW);
7281 EXPORT_SYMBOL_GPL(devlink_param_value_changed);
7284 * devlink_port_param_value_changed - notify devlink on a parameter's value
7285 * change. Should be called by the driver
7286 * right after the change.
7288 * @devlink_port: devlink_port
7289 * @param_id: parameter ID
7291 * This function should be used by the driver to notify devlink on value
7292 * change, excluding driverinit configuration mode.
7293 * For driverinit configuration mode driver should use the function
7294 * devlink_port_param_driverinit_value_set() instead.
7296 void devlink_port_param_value_changed(struct devlink_port *devlink_port,
7299 struct devlink_param_item *param_item;
7301 param_item = devlink_param_find_by_id(&devlink_port->param_list,
7303 WARN_ON(!param_item);
7305 devlink_param_notify(devlink_port->devlink, devlink_port->index,
7306 param_item, DEVLINK_CMD_PORT_PARAM_NEW);
7308 EXPORT_SYMBOL_GPL(devlink_port_param_value_changed);
7311 * devlink_param_value_str_fill - Safely fill-up the string preventing
7312 * from overflow of the preallocated buffer
7314 * @dst_val: destination devlink_param_value
7315 * @src: source buffer
7317 void devlink_param_value_str_fill(union devlink_param_value *dst_val,
7322 len = strlcpy(dst_val->vstr, src, __DEVLINK_PARAM_MAX_STRING_VALUE);
7323 WARN_ON(len >= __DEVLINK_PARAM_MAX_STRING_VALUE);
7325 EXPORT_SYMBOL_GPL(devlink_param_value_str_fill);
7328 * devlink_region_create - create a new address region
7331 * @region_name: region name
7332 * @region_max_snapshots: Maximum supported number of snapshots for region
7333 * @region_size: size of region
7335 struct devlink_region *devlink_region_create(struct devlink *devlink,
7336 const char *region_name,
7337 u32 region_max_snapshots,
7340 struct devlink_region *region;
7343 mutex_lock(&devlink->lock);
7345 if (devlink_region_get_by_name(devlink, region_name)) {
7350 region = kzalloc(sizeof(*region), GFP_KERNEL);
7356 region->devlink = devlink;
7357 region->max_snapshots = region_max_snapshots;
7358 region->name = region_name;
7359 region->size = region_size;
7360 INIT_LIST_HEAD(®ion->snapshot_list);
7361 list_add_tail(®ion->list, &devlink->region_list);
7362 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
7364 mutex_unlock(&devlink->lock);
7368 mutex_unlock(&devlink->lock);
7369 return ERR_PTR(err);
7371 EXPORT_SYMBOL_GPL(devlink_region_create);
7374 * devlink_region_destroy - destroy address region
7376 * @region: devlink region to destroy
7378 void devlink_region_destroy(struct devlink_region *region)
7380 struct devlink *devlink = region->devlink;
7381 struct devlink_snapshot *snapshot, *ts;
7383 mutex_lock(&devlink->lock);
7385 /* Free all snapshots of region */
7386 list_for_each_entry_safe(snapshot, ts, ®ion->snapshot_list, list)
7387 devlink_region_snapshot_del(region, snapshot);
7389 list_del(®ion->list);
7391 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_DEL);
7392 mutex_unlock(&devlink->lock);
7395 EXPORT_SYMBOL_GPL(devlink_region_destroy);
7398 * devlink_region_shapshot_id_get - get snapshot ID
7400 * This callback should be called when adding a new snapshot,
7401 * Driver should use the same id for multiple snapshots taken
7402 * on multiple regions at the same time/by the same trigger.
7406 u32 devlink_region_shapshot_id_get(struct devlink *devlink)
7410 mutex_lock(&devlink->lock);
7411 id = ++devlink->snapshot_id;
7412 mutex_unlock(&devlink->lock);
7416 EXPORT_SYMBOL_GPL(devlink_region_shapshot_id_get);
7419 * devlink_region_snapshot_create - create a new snapshot
7420 * This will add a new snapshot of a region. The snapshot
7421 * will be stored on the region struct and can be accessed
7422 * from devlink. This is useful for future analyses of snapshots.
7423 * Multiple snapshots can be created on a region.
7424 * The @snapshot_id should be obtained using the getter function.
7426 * @region: devlink region of the snapshot
7427 * @data: snapshot data
7428 * @snapshot_id: snapshot id to be created
7429 * @data_destructor: pointer to destructor function to free data
7431 int devlink_region_snapshot_create(struct devlink_region *region,
7432 u8 *data, u32 snapshot_id,
7433 devlink_snapshot_data_dest_t *data_destructor)
7435 struct devlink *devlink = region->devlink;
7436 struct devlink_snapshot *snapshot;
7439 mutex_lock(&devlink->lock);
7441 /* check if region can hold one more snapshot */
7442 if (region->cur_snapshots == region->max_snapshots) {
7447 if (devlink_region_snapshot_get_by_id(region, snapshot_id)) {
7452 snapshot = kzalloc(sizeof(*snapshot), GFP_KERNEL);
7458 snapshot->id = snapshot_id;
7459 snapshot->region = region;
7460 snapshot->data = data;
7461 snapshot->data_destructor = data_destructor;
7463 list_add_tail(&snapshot->list, ®ion->snapshot_list);
7465 region->cur_snapshots++;
7467 devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_NEW);
7468 mutex_unlock(&devlink->lock);
7472 mutex_unlock(&devlink->lock);
7475 EXPORT_SYMBOL_GPL(devlink_region_snapshot_create);
7477 #define DEVLINK_TRAP(_id, _type) \
7479 .type = DEVLINK_TRAP_TYPE_##_type, \
7480 .id = DEVLINK_TRAP_GENERIC_ID_##_id, \
7481 .name = DEVLINK_TRAP_GENERIC_NAME_##_id, \
7484 static const struct devlink_trap devlink_trap_generic[] = {
7485 DEVLINK_TRAP(SMAC_MC, DROP),
7486 DEVLINK_TRAP(VLAN_TAG_MISMATCH, DROP),
7487 DEVLINK_TRAP(INGRESS_VLAN_FILTER, DROP),
7488 DEVLINK_TRAP(INGRESS_STP_FILTER, DROP),
7489 DEVLINK_TRAP(EMPTY_TX_LIST, DROP),
7490 DEVLINK_TRAP(PORT_LOOPBACK_FILTER, DROP),
7491 DEVLINK_TRAP(BLACKHOLE_ROUTE, DROP),
7492 DEVLINK_TRAP(TTL_ERROR, EXCEPTION),
7493 DEVLINK_TRAP(TAIL_DROP, DROP),
7496 #define DEVLINK_TRAP_GROUP(_id) \
7498 .id = DEVLINK_TRAP_GROUP_GENERIC_ID_##_id, \
7499 .name = DEVLINK_TRAP_GROUP_GENERIC_NAME_##_id, \
7502 static const struct devlink_trap_group devlink_trap_group_generic[] = {
7503 DEVLINK_TRAP_GROUP(L2_DROPS),
7504 DEVLINK_TRAP_GROUP(L3_DROPS),
7505 DEVLINK_TRAP_GROUP(BUFFER_DROPS),
7508 static int devlink_trap_generic_verify(const struct devlink_trap *trap)
7510 if (trap->id > DEVLINK_TRAP_GENERIC_ID_MAX)
7513 if (strcmp(trap->name, devlink_trap_generic[trap->id].name))
7516 if (trap->type != devlink_trap_generic[trap->id].type)
7522 static int devlink_trap_driver_verify(const struct devlink_trap *trap)
7526 if (trap->id <= DEVLINK_TRAP_GENERIC_ID_MAX)
7529 for (i = 0; i < ARRAY_SIZE(devlink_trap_generic); i++) {
7530 if (!strcmp(trap->name, devlink_trap_generic[i].name))
7537 static int devlink_trap_verify(const struct devlink_trap *trap)
7539 if (!trap || !trap->name || !trap->group.name)
7543 return devlink_trap_generic_verify(trap);
7545 return devlink_trap_driver_verify(trap);
7549 devlink_trap_group_generic_verify(const struct devlink_trap_group *group)
7551 if (group->id > DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
7554 if (strcmp(group->name, devlink_trap_group_generic[group->id].name))
7561 devlink_trap_group_driver_verify(const struct devlink_trap_group *group)
7565 if (group->id <= DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
7568 for (i = 0; i < ARRAY_SIZE(devlink_trap_group_generic); i++) {
7569 if (!strcmp(group->name, devlink_trap_group_generic[i].name))
7576 static int devlink_trap_group_verify(const struct devlink_trap_group *group)
7579 return devlink_trap_group_generic_verify(group);
7581 return devlink_trap_group_driver_verify(group);
7585 devlink_trap_group_notify(struct devlink *devlink,
7586 const struct devlink_trap_group_item *group_item,
7587 enum devlink_command cmd)
7589 struct sk_buff *msg;
7592 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_GROUP_NEW &&
7593 cmd != DEVLINK_CMD_TRAP_GROUP_DEL);
7595 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7599 err = devlink_nl_trap_group_fill(msg, devlink, group_item, cmd, 0, 0,
7606 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
7607 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
7610 static struct devlink_trap_group_item *
7611 devlink_trap_group_item_create(struct devlink *devlink,
7612 const struct devlink_trap_group *group)
7614 struct devlink_trap_group_item *group_item;
7617 err = devlink_trap_group_verify(group);
7619 return ERR_PTR(err);
7621 group_item = kzalloc(sizeof(*group_item), GFP_KERNEL);
7623 return ERR_PTR(-ENOMEM);
7625 group_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
7626 if (!group_item->stats) {
7628 goto err_stats_alloc;
7631 group_item->group = group;
7632 refcount_set(&group_item->refcount, 1);
7634 if (devlink->ops->trap_group_init) {
7635 err = devlink->ops->trap_group_init(devlink, group);
7637 goto err_group_init;
7640 list_add_tail(&group_item->list, &devlink->trap_group_list);
7641 devlink_trap_group_notify(devlink, group_item,
7642 DEVLINK_CMD_TRAP_GROUP_NEW);
7647 free_percpu(group_item->stats);
7650 return ERR_PTR(err);
7654 devlink_trap_group_item_destroy(struct devlink *devlink,
7655 struct devlink_trap_group_item *group_item)
7657 devlink_trap_group_notify(devlink, group_item,
7658 DEVLINK_CMD_TRAP_GROUP_DEL);
7659 list_del(&group_item->list);
7660 free_percpu(group_item->stats);
7664 static struct devlink_trap_group_item *
7665 devlink_trap_group_item_get(struct devlink *devlink,
7666 const struct devlink_trap_group *group)
7668 struct devlink_trap_group_item *group_item;
7670 group_item = devlink_trap_group_item_lookup(devlink, group->name);
7672 refcount_inc(&group_item->refcount);
7676 return devlink_trap_group_item_create(devlink, group);
7680 devlink_trap_group_item_put(struct devlink *devlink,
7681 struct devlink_trap_group_item *group_item)
7683 if (!refcount_dec_and_test(&group_item->refcount))
7686 devlink_trap_group_item_destroy(devlink, group_item);
7690 devlink_trap_item_group_link(struct devlink *devlink,
7691 struct devlink_trap_item *trap_item)
7693 struct devlink_trap_group_item *group_item;
7695 group_item = devlink_trap_group_item_get(devlink,
7696 &trap_item->trap->group);
7697 if (IS_ERR(group_item))
7698 return PTR_ERR(group_item);
7700 trap_item->group_item = group_item;
7706 devlink_trap_item_group_unlink(struct devlink *devlink,
7707 struct devlink_trap_item *trap_item)
7709 devlink_trap_group_item_put(devlink, trap_item->group_item);
7712 static void devlink_trap_notify(struct devlink *devlink,
7713 const struct devlink_trap_item *trap_item,
7714 enum devlink_command cmd)
7716 struct sk_buff *msg;
7719 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_NEW &&
7720 cmd != DEVLINK_CMD_TRAP_DEL);
7722 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7726 err = devlink_nl_trap_fill(msg, devlink, trap_item, cmd, 0, 0, 0);
7732 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
7733 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
7737 devlink_trap_register(struct devlink *devlink,
7738 const struct devlink_trap *trap, void *priv)
7740 struct devlink_trap_item *trap_item;
7743 if (devlink_trap_item_lookup(devlink, trap->name))
7746 trap_item = kzalloc(sizeof(*trap_item), GFP_KERNEL);
7750 trap_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
7751 if (!trap_item->stats) {
7753 goto err_stats_alloc;
7756 trap_item->trap = trap;
7757 trap_item->action = trap->init_action;
7758 trap_item->priv = priv;
7760 err = devlink_trap_item_group_link(devlink, trap_item);
7762 goto err_group_link;
7764 err = devlink->ops->trap_init(devlink, trap, trap_item);
7768 list_add_tail(&trap_item->list, &devlink->trap_list);
7769 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_NEW);
7774 devlink_trap_item_group_unlink(devlink, trap_item);
7776 free_percpu(trap_item->stats);
7782 static void devlink_trap_unregister(struct devlink *devlink,
7783 const struct devlink_trap *trap)
7785 struct devlink_trap_item *trap_item;
7787 trap_item = devlink_trap_item_lookup(devlink, trap->name);
7788 if (WARN_ON_ONCE(!trap_item))
7791 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_DEL);
7792 list_del(&trap_item->list);
7793 if (devlink->ops->trap_fini)
7794 devlink->ops->trap_fini(devlink, trap, trap_item);
7795 devlink_trap_item_group_unlink(devlink, trap_item);
7796 free_percpu(trap_item->stats);
7800 static void devlink_trap_disable(struct devlink *devlink,
7801 const struct devlink_trap *trap)
7803 struct devlink_trap_item *trap_item;
7805 trap_item = devlink_trap_item_lookup(devlink, trap->name);
7806 if (WARN_ON_ONCE(!trap_item))
7809 devlink->ops->trap_action_set(devlink, trap, DEVLINK_TRAP_ACTION_DROP);
7810 trap_item->action = DEVLINK_TRAP_ACTION_DROP;
7814 * devlink_traps_register - Register packet traps with devlink.
7815 * @devlink: devlink.
7816 * @traps: Packet traps.
7817 * @traps_count: Count of provided packet traps.
7818 * @priv: Driver private information.
7820 * Return: Non-zero value on failure.
7822 int devlink_traps_register(struct devlink *devlink,
7823 const struct devlink_trap *traps,
7824 size_t traps_count, void *priv)
7828 if (!devlink->ops->trap_init || !devlink->ops->trap_action_set)
7831 mutex_lock(&devlink->lock);
7832 for (i = 0; i < traps_count; i++) {
7833 const struct devlink_trap *trap = &traps[i];
7835 err = devlink_trap_verify(trap);
7837 goto err_trap_verify;
7839 err = devlink_trap_register(devlink, trap, priv);
7841 goto err_trap_register;
7843 mutex_unlock(&devlink->lock);
7849 for (i--; i >= 0; i--)
7850 devlink_trap_unregister(devlink, &traps[i]);
7851 mutex_unlock(&devlink->lock);
7854 EXPORT_SYMBOL_GPL(devlink_traps_register);
7857 * devlink_traps_unregister - Unregister packet traps from devlink.
7858 * @devlink: devlink.
7859 * @traps: Packet traps.
7860 * @traps_count: Count of provided packet traps.
7862 void devlink_traps_unregister(struct devlink *devlink,
7863 const struct devlink_trap *traps,
7868 mutex_lock(&devlink->lock);
7869 /* Make sure we do not have any packets in-flight while unregistering
7870 * traps by disabling all of them and waiting for a grace period.
7872 for (i = traps_count - 1; i >= 0; i--)
7873 devlink_trap_disable(devlink, &traps[i]);
7875 for (i = traps_count - 1; i >= 0; i--)
7876 devlink_trap_unregister(devlink, &traps[i]);
7877 mutex_unlock(&devlink->lock);
7879 EXPORT_SYMBOL_GPL(devlink_traps_unregister);
7882 devlink_trap_stats_update(struct devlink_stats __percpu *trap_stats,
7885 struct devlink_stats *stats;
7887 stats = this_cpu_ptr(trap_stats);
7888 u64_stats_update_begin(&stats->syncp);
7889 stats->rx_bytes += skb_len;
7890 stats->rx_packets++;
7891 u64_stats_update_end(&stats->syncp);
7895 devlink_trap_report_metadata_fill(struct net_dm_hw_metadata *hw_metadata,
7896 const struct devlink_trap_item *trap_item,
7897 struct devlink_port *in_devlink_port)
7899 struct devlink_trap_group_item *group_item = trap_item->group_item;
7901 hw_metadata->trap_group_name = group_item->group->name;
7902 hw_metadata->trap_name = trap_item->trap->name;
7904 spin_lock(&in_devlink_port->type_lock);
7905 if (in_devlink_port->type == DEVLINK_PORT_TYPE_ETH)
7906 hw_metadata->input_dev = in_devlink_port->type_dev;
7907 spin_unlock(&in_devlink_port->type_lock);
7911 * devlink_trap_report - Report trapped packet to drop monitor.
7912 * @devlink: devlink.
7913 * @skb: Trapped packet.
7914 * @trap_ctx: Trap context.
7915 * @in_devlink_port: Input devlink port.
7917 void devlink_trap_report(struct devlink *devlink, struct sk_buff *skb,
7918 void *trap_ctx, struct devlink_port *in_devlink_port)
7920 struct devlink_trap_item *trap_item = trap_ctx;
7921 struct net_dm_hw_metadata hw_metadata = {};
7923 devlink_trap_stats_update(trap_item->stats, skb->len);
7924 devlink_trap_stats_update(trap_item->group_item->stats, skb->len);
7926 devlink_trap_report_metadata_fill(&hw_metadata, trap_item,
7928 net_dm_hw_report(skb, &hw_metadata);
7930 EXPORT_SYMBOL_GPL(devlink_trap_report);
7933 * devlink_trap_ctx_priv - Trap context to driver private information.
7934 * @trap_ctx: Trap context.
7936 * Return: Driver private information passed during registration.
7938 void *devlink_trap_ctx_priv(void *trap_ctx)
7940 struct devlink_trap_item *trap_item = trap_ctx;
7942 return trap_item->priv;
7944 EXPORT_SYMBOL_GPL(devlink_trap_ctx_priv);
7946 static void __devlink_compat_running_version(struct devlink *devlink,
7947 char *buf, size_t len)
7949 const struct nlattr *nlattr;
7950 struct devlink_info_req req;
7951 struct sk_buff *msg;
7954 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7959 err = devlink->ops->info_get(devlink, &req, NULL);
7963 nla_for_each_attr(nlattr, (void *)msg->data, msg->len, rem) {
7964 const struct nlattr *kv;
7967 if (nla_type(nlattr) != DEVLINK_ATTR_INFO_VERSION_RUNNING)
7970 nla_for_each_nested(kv, nlattr, rem_kv) {
7971 if (nla_type(kv) != DEVLINK_ATTR_INFO_VERSION_VALUE)
7974 strlcat(buf, nla_data(kv), len);
7975 strlcat(buf, " ", len);
7982 void devlink_compat_running_version(struct net_device *dev,
7983 char *buf, size_t len)
7985 struct devlink *devlink;
7990 devlink = netdev_to_devlink(dev);
7991 if (!devlink || !devlink->ops->info_get)
7994 mutex_lock(&devlink->lock);
7995 __devlink_compat_running_version(devlink, buf, len);
7996 mutex_unlock(&devlink->lock);
8003 int devlink_compat_flash_update(struct net_device *dev, const char *file_name)
8005 struct devlink *devlink;
8011 devlink = netdev_to_devlink(dev);
8012 if (!devlink || !devlink->ops->flash_update) {
8017 mutex_lock(&devlink->lock);
8018 ret = devlink->ops->flash_update(devlink, file_name, NULL, NULL);
8019 mutex_unlock(&devlink->lock);
8028 int devlink_compat_phys_port_name_get(struct net_device *dev,
8029 char *name, size_t len)
8031 struct devlink_port *devlink_port;
8033 /* RTNL mutex is held here which ensures that devlink_port
8034 * instance cannot disappear in the middle. No need to take
8035 * any devlink lock as only permanent values are accessed.
8039 devlink_port = netdev_to_devlink_port(dev);
8043 return __devlink_port_phys_port_name_get(devlink_port, name, len);
8046 int devlink_compat_switch_id_get(struct net_device *dev,
8047 struct netdev_phys_item_id *ppid)
8049 struct devlink_port *devlink_port;
8051 /* Caller must hold RTNL mutex or reference to dev, which ensures that
8052 * devlink_port instance cannot disappear in the middle. No need to take
8053 * any devlink lock as only permanent values are accessed.
8055 devlink_port = netdev_to_devlink_port(dev);
8056 if (!devlink_port || !devlink_port->attrs.switch_port)
8059 memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid));
8064 static int __init devlink_init(void)
8066 return genl_register_family(&devlink_nl_family);
8069 subsys_initcall(devlink_init);