2 * net/core/devlink.c - Network physical/parent device Netlink interface
4 * Heavily inspired by net/wireless/
5 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
6 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/slab.h>
18 #include <linux/gfp.h>
19 #include <linux/device.h>
20 #include <linux/list.h>
21 #include <linux/netdevice.h>
22 #include <rdma/ib_verbs.h>
23 #include <net/netlink.h>
24 #include <net/genetlink.h>
25 #include <net/rtnetlink.h>
26 #include <net/net_namespace.h>
28 #include <net/devlink.h>
29 #define CREATE_TRACE_POINTS
30 #include <trace/events/devlink.h>
32 static struct devlink_dpipe_field devlink_dpipe_fields_ethernet
[] = {
34 .name
= "destination mac",
35 .id
= DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC
,
40 struct devlink_dpipe_header devlink_dpipe_header_ethernet
= {
42 .id
= DEVLINK_DPIPE_HEADER_ETHERNET
,
43 .fields
= devlink_dpipe_fields_ethernet
,
44 .fields_count
= ARRAY_SIZE(devlink_dpipe_fields_ethernet
),
47 EXPORT_SYMBOL(devlink_dpipe_header_ethernet
);
49 static struct devlink_dpipe_field devlink_dpipe_fields_ipv4
[] = {
51 .name
= "destination ip",
52 .id
= DEVLINK_DPIPE_FIELD_IPV4_DST_IP
,
57 struct devlink_dpipe_header devlink_dpipe_header_ipv4
= {
59 .id
= DEVLINK_DPIPE_HEADER_IPV4
,
60 .fields
= devlink_dpipe_fields_ipv4
,
61 .fields_count
= ARRAY_SIZE(devlink_dpipe_fields_ipv4
),
64 EXPORT_SYMBOL(devlink_dpipe_header_ipv4
);
66 static struct devlink_dpipe_field devlink_dpipe_fields_ipv6
[] = {
68 .name
= "destination ip",
69 .id
= DEVLINK_DPIPE_FIELD_IPV6_DST_IP
,
74 struct devlink_dpipe_header devlink_dpipe_header_ipv6
= {
76 .id
= DEVLINK_DPIPE_HEADER_IPV6
,
77 .fields
= devlink_dpipe_fields_ipv6
,
78 .fields_count
= ARRAY_SIZE(devlink_dpipe_fields_ipv6
),
81 EXPORT_SYMBOL(devlink_dpipe_header_ipv6
);
83 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg
);
85 static LIST_HEAD(devlink_list
);
89 * An overall lock guarding every operation coming from userspace.
90 * It also guards devlink devices list and it is taken when
91 * driver registers/unregisters it.
93 static DEFINE_MUTEX(devlink_mutex
);
95 static struct net
*devlink_net(const struct devlink
*devlink
)
97 return read_pnet(&devlink
->_net
);
100 static void devlink_net_set(struct devlink
*devlink
, struct net
*net
)
102 write_pnet(&devlink
->_net
, net
);
105 static struct devlink
*devlink_get_from_attrs(struct net
*net
,
106 struct nlattr
**attrs
)
108 struct devlink
*devlink
;
112 if (!attrs
[DEVLINK_ATTR_BUS_NAME
] || !attrs
[DEVLINK_ATTR_DEV_NAME
])
113 return ERR_PTR(-EINVAL
);
115 busname
= nla_data(attrs
[DEVLINK_ATTR_BUS_NAME
]);
116 devname
= nla_data(attrs
[DEVLINK_ATTR_DEV_NAME
]);
118 list_for_each_entry(devlink
, &devlink_list
, list
) {
119 if (strcmp(devlink
->dev
->bus
->name
, busname
) == 0 &&
120 strcmp(dev_name(devlink
->dev
), devname
) == 0 &&
121 net_eq(devlink_net(devlink
), net
))
125 return ERR_PTR(-ENODEV
);
128 static struct devlink
*devlink_get_from_info(struct genl_info
*info
)
130 return devlink_get_from_attrs(genl_info_net(info
), info
->attrs
);
133 static struct devlink_port
*devlink_port_get_by_index(struct devlink
*devlink
,
136 struct devlink_port
*devlink_port
;
138 list_for_each_entry(devlink_port
, &devlink
->port_list
, list
) {
139 if (devlink_port
->index
== port_index
)
145 static bool devlink_port_index_exists(struct devlink
*devlink
, int port_index
)
147 return devlink_port_get_by_index(devlink
, port_index
);
150 static struct devlink_port
*devlink_port_get_from_attrs(struct devlink
*devlink
,
151 struct nlattr
**attrs
)
153 if (attrs
[DEVLINK_ATTR_PORT_INDEX
]) {
154 u32 port_index
= nla_get_u32(attrs
[DEVLINK_ATTR_PORT_INDEX
]);
155 struct devlink_port
*devlink_port
;
157 devlink_port
= devlink_port_get_by_index(devlink
, port_index
);
159 return ERR_PTR(-ENODEV
);
162 return ERR_PTR(-EINVAL
);
165 static struct devlink_port
*devlink_port_get_from_info(struct devlink
*devlink
,
166 struct genl_info
*info
)
168 return devlink_port_get_from_attrs(devlink
, info
->attrs
);
172 struct list_head list
;
175 u16 ingress_pools_count
;
176 u16 egress_pools_count
;
177 u16 ingress_tc_count
;
181 static u16
devlink_sb_pool_count(struct devlink_sb
*devlink_sb
)
183 return devlink_sb
->ingress_pools_count
+ devlink_sb
->egress_pools_count
;
186 static struct devlink_sb
*devlink_sb_get_by_index(struct devlink
*devlink
,
187 unsigned int sb_index
)
189 struct devlink_sb
*devlink_sb
;
191 list_for_each_entry(devlink_sb
, &devlink
->sb_list
, list
) {
192 if (devlink_sb
->index
== sb_index
)
198 static bool devlink_sb_index_exists(struct devlink
*devlink
,
199 unsigned int sb_index
)
201 return devlink_sb_get_by_index(devlink
, sb_index
);
204 static struct devlink_sb
*devlink_sb_get_from_attrs(struct devlink
*devlink
,
205 struct nlattr
**attrs
)
207 if (attrs
[DEVLINK_ATTR_SB_INDEX
]) {
208 u32 sb_index
= nla_get_u32(attrs
[DEVLINK_ATTR_SB_INDEX
]);
209 struct devlink_sb
*devlink_sb
;
211 devlink_sb
= devlink_sb_get_by_index(devlink
, sb_index
);
213 return ERR_PTR(-ENODEV
);
216 return ERR_PTR(-EINVAL
);
219 static struct devlink_sb
*devlink_sb_get_from_info(struct devlink
*devlink
,
220 struct genl_info
*info
)
222 return devlink_sb_get_from_attrs(devlink
, info
->attrs
);
225 static int devlink_sb_pool_index_get_from_attrs(struct devlink_sb
*devlink_sb
,
226 struct nlattr
**attrs
,
231 if (!attrs
[DEVLINK_ATTR_SB_POOL_INDEX
])
234 val
= nla_get_u16(attrs
[DEVLINK_ATTR_SB_POOL_INDEX
]);
235 if (val
>= devlink_sb_pool_count(devlink_sb
))
241 static int devlink_sb_pool_index_get_from_info(struct devlink_sb
*devlink_sb
,
242 struct genl_info
*info
,
245 return devlink_sb_pool_index_get_from_attrs(devlink_sb
, info
->attrs
,
250 devlink_sb_pool_type_get_from_attrs(struct nlattr
**attrs
,
251 enum devlink_sb_pool_type
*p_pool_type
)
255 if (!attrs
[DEVLINK_ATTR_SB_POOL_TYPE
])
258 val
= nla_get_u8(attrs
[DEVLINK_ATTR_SB_POOL_TYPE
]);
259 if (val
!= DEVLINK_SB_POOL_TYPE_INGRESS
&&
260 val
!= DEVLINK_SB_POOL_TYPE_EGRESS
)
267 devlink_sb_pool_type_get_from_info(struct genl_info
*info
,
268 enum devlink_sb_pool_type
*p_pool_type
)
270 return devlink_sb_pool_type_get_from_attrs(info
->attrs
, p_pool_type
);
274 devlink_sb_th_type_get_from_attrs(struct nlattr
**attrs
,
275 enum devlink_sb_threshold_type
*p_th_type
)
279 if (!attrs
[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE
])
282 val
= nla_get_u8(attrs
[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE
]);
283 if (val
!= DEVLINK_SB_THRESHOLD_TYPE_STATIC
&&
284 val
!= DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC
)
291 devlink_sb_th_type_get_from_info(struct genl_info
*info
,
292 enum devlink_sb_threshold_type
*p_th_type
)
294 return devlink_sb_th_type_get_from_attrs(info
->attrs
, p_th_type
);
298 devlink_sb_tc_index_get_from_attrs(struct devlink_sb
*devlink_sb
,
299 struct nlattr
**attrs
,
300 enum devlink_sb_pool_type pool_type
,
305 if (!attrs
[DEVLINK_ATTR_SB_TC_INDEX
])
308 val
= nla_get_u16(attrs
[DEVLINK_ATTR_SB_TC_INDEX
]);
309 if (pool_type
== DEVLINK_SB_POOL_TYPE_INGRESS
&&
310 val
>= devlink_sb
->ingress_tc_count
)
312 if (pool_type
== DEVLINK_SB_POOL_TYPE_EGRESS
&&
313 val
>= devlink_sb
->egress_tc_count
)
320 devlink_sb_tc_index_get_from_info(struct devlink_sb
*devlink_sb
,
321 struct genl_info
*info
,
322 enum devlink_sb_pool_type pool_type
,
325 return devlink_sb_tc_index_get_from_attrs(devlink_sb
, info
->attrs
,
326 pool_type
, p_tc_index
);
329 struct devlink_region
{
330 struct devlink
*devlink
;
331 struct list_head list
;
333 struct list_head snapshot_list
;
339 struct devlink_snapshot
{
340 struct list_head list
;
341 struct devlink_region
*region
;
342 devlink_snapshot_data_dest_t
*data_destructor
;
348 static struct devlink_region
*
349 devlink_region_get_by_name(struct devlink
*devlink
, const char *region_name
)
351 struct devlink_region
*region
;
353 list_for_each_entry(region
, &devlink
->region_list
, list
)
354 if (!strcmp(region
->name
, region_name
))
360 static struct devlink_snapshot
*
361 devlink_region_snapshot_get_by_id(struct devlink_region
*region
, u32 id
)
363 struct devlink_snapshot
*snapshot
;
365 list_for_each_entry(snapshot
, ®ion
->snapshot_list
, list
)
366 if (snapshot
->id
== id
)
372 static void devlink_region_snapshot_del(struct devlink_snapshot
*snapshot
)
374 snapshot
->region
->cur_snapshots
--;
375 list_del(&snapshot
->list
);
376 (*snapshot
->data_destructor
)(snapshot
->data
);
380 #define DEVLINK_NL_FLAG_NEED_DEVLINK BIT(0)
381 #define DEVLINK_NL_FLAG_NEED_PORT BIT(1)
382 #define DEVLINK_NL_FLAG_NEED_SB BIT(2)
384 /* The per devlink instance lock is taken by default in the pre-doit
385 * operation, yet several commands do not require this. The global
386 * devlink lock is taken and protects from disruption by user-calls.
388 #define DEVLINK_NL_FLAG_NO_LOCK BIT(3)
390 static int devlink_nl_pre_doit(const struct genl_ops
*ops
,
391 struct sk_buff
*skb
, struct genl_info
*info
)
393 struct devlink
*devlink
;
396 mutex_lock(&devlink_mutex
);
397 devlink
= devlink_get_from_info(info
);
398 if (IS_ERR(devlink
)) {
399 mutex_unlock(&devlink_mutex
);
400 return PTR_ERR(devlink
);
402 if (~ops
->internal_flags
& DEVLINK_NL_FLAG_NO_LOCK
)
403 mutex_lock(&devlink
->lock
);
404 if (ops
->internal_flags
& DEVLINK_NL_FLAG_NEED_DEVLINK
) {
405 info
->user_ptr
[0] = devlink
;
406 } else if (ops
->internal_flags
& DEVLINK_NL_FLAG_NEED_PORT
) {
407 struct devlink_port
*devlink_port
;
409 devlink_port
= devlink_port_get_from_info(devlink
, info
);
410 if (IS_ERR(devlink_port
)) {
411 err
= PTR_ERR(devlink_port
);
414 info
->user_ptr
[0] = devlink_port
;
416 if (ops
->internal_flags
& DEVLINK_NL_FLAG_NEED_SB
) {
417 struct devlink_sb
*devlink_sb
;
419 devlink_sb
= devlink_sb_get_from_info(devlink
, info
);
420 if (IS_ERR(devlink_sb
)) {
421 err
= PTR_ERR(devlink_sb
);
424 info
->user_ptr
[1] = devlink_sb
;
429 if (~ops
->internal_flags
& DEVLINK_NL_FLAG_NO_LOCK
)
430 mutex_unlock(&devlink
->lock
);
431 mutex_unlock(&devlink_mutex
);
435 static void devlink_nl_post_doit(const struct genl_ops
*ops
,
436 struct sk_buff
*skb
, struct genl_info
*info
)
438 struct devlink
*devlink
;
440 devlink
= devlink_get_from_info(info
);
441 if (~ops
->internal_flags
& DEVLINK_NL_FLAG_NO_LOCK
)
442 mutex_unlock(&devlink
->lock
);
443 mutex_unlock(&devlink_mutex
);
446 static struct genl_family devlink_nl_family
;
448 enum devlink_multicast_groups
{
449 DEVLINK_MCGRP_CONFIG
,
452 static const struct genl_multicast_group devlink_nl_mcgrps
[] = {
453 [DEVLINK_MCGRP_CONFIG
] = { .name
= DEVLINK_GENL_MCGRP_CONFIG_NAME
},
456 static int devlink_nl_put_handle(struct sk_buff
*msg
, struct devlink
*devlink
)
458 if (nla_put_string(msg
, DEVLINK_ATTR_BUS_NAME
, devlink
->dev
->bus
->name
))
460 if (nla_put_string(msg
, DEVLINK_ATTR_DEV_NAME
, dev_name(devlink
->dev
)))
465 static int devlink_nl_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
466 enum devlink_command cmd
, u32 portid
,
471 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
475 if (devlink_nl_put_handle(msg
, devlink
))
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 if (nla_put_u32(msg
, DEVLINK_ATTR_PORT_NUMBER
, attrs
->port_number
))
520 if (nla_put_u32(msg
, DEVLINK_ATTR_PORT_SPLIT_GROUP
, attrs
->port_number
))
522 if (nla_put_u32(msg
, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER
,
523 attrs
->split_subport_number
))
528 static int devlink_nl_port_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
529 struct devlink_port
*devlink_port
,
530 enum devlink_command cmd
, u32 portid
,
535 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
539 if (devlink_nl_put_handle(msg
, devlink
))
540 goto nla_put_failure
;
541 if (nla_put_u32(msg
, DEVLINK_ATTR_PORT_INDEX
, devlink_port
->index
))
542 goto nla_put_failure
;
543 if (nla_put_u16(msg
, DEVLINK_ATTR_PORT_TYPE
, devlink_port
->type
))
544 goto nla_put_failure
;
545 if (devlink_port
->desired_type
!= DEVLINK_PORT_TYPE_NOTSET
&&
546 nla_put_u16(msg
, DEVLINK_ATTR_PORT_DESIRED_TYPE
,
547 devlink_port
->desired_type
))
548 goto nla_put_failure
;
549 if (devlink_port
->type
== DEVLINK_PORT_TYPE_ETH
) {
550 struct net_device
*netdev
= devlink_port
->type_dev
;
553 (nla_put_u32(msg
, DEVLINK_ATTR_PORT_NETDEV_IFINDEX
,
555 nla_put_string(msg
, DEVLINK_ATTR_PORT_NETDEV_NAME
,
557 goto nla_put_failure
;
559 if (devlink_port
->type
== DEVLINK_PORT_TYPE_IB
) {
560 struct ib_device
*ibdev
= devlink_port
->type_dev
;
563 nla_put_string(msg
, DEVLINK_ATTR_PORT_IBDEV_NAME
,
565 goto nla_put_failure
;
567 if (devlink_nl_port_attrs_put(msg
, devlink_port
))
568 goto nla_put_failure
;
570 genlmsg_end(msg
, hdr
);
574 genlmsg_cancel(msg
, hdr
);
578 static void devlink_port_notify(struct devlink_port
*devlink_port
,
579 enum devlink_command cmd
)
581 struct devlink
*devlink
= devlink_port
->devlink
;
585 if (!devlink_port
->registered
)
588 WARN_ON(cmd
!= DEVLINK_CMD_PORT_NEW
&& cmd
!= DEVLINK_CMD_PORT_DEL
);
590 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
594 err
= devlink_nl_port_fill(msg
, devlink
, devlink_port
, cmd
, 0, 0, 0);
600 genlmsg_multicast_netns(&devlink_nl_family
, devlink_net(devlink
),
601 msg
, 0, DEVLINK_MCGRP_CONFIG
, GFP_KERNEL
);
604 static int devlink_nl_cmd_get_doit(struct sk_buff
*skb
, struct genl_info
*info
)
606 struct devlink
*devlink
= info
->user_ptr
[0];
610 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
614 err
= devlink_nl_fill(msg
, devlink
, DEVLINK_CMD_NEW
,
615 info
->snd_portid
, info
->snd_seq
, 0);
621 return genlmsg_reply(msg
, info
);
624 static int devlink_nl_cmd_get_dumpit(struct sk_buff
*msg
,
625 struct netlink_callback
*cb
)
627 struct devlink
*devlink
;
628 int start
= cb
->args
[0];
632 mutex_lock(&devlink_mutex
);
633 list_for_each_entry(devlink
, &devlink_list
, list
) {
634 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)))
640 err
= devlink_nl_fill(msg
, devlink
, DEVLINK_CMD_NEW
,
641 NETLINK_CB(cb
->skb
).portid
,
642 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
);
648 mutex_unlock(&devlink_mutex
);
654 static int devlink_nl_cmd_port_get_doit(struct sk_buff
*skb
,
655 struct genl_info
*info
)
657 struct devlink_port
*devlink_port
= info
->user_ptr
[0];
658 struct devlink
*devlink
= devlink_port
->devlink
;
662 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
666 err
= devlink_nl_port_fill(msg
, devlink
, devlink_port
,
667 DEVLINK_CMD_PORT_NEW
,
668 info
->snd_portid
, info
->snd_seq
, 0);
674 return genlmsg_reply(msg
, info
);
677 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff
*msg
,
678 struct netlink_callback
*cb
)
680 struct devlink
*devlink
;
681 struct devlink_port
*devlink_port
;
682 int start
= cb
->args
[0];
686 mutex_lock(&devlink_mutex
);
687 list_for_each_entry(devlink
, &devlink_list
, list
) {
688 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)))
690 mutex_lock(&devlink
->lock
);
691 list_for_each_entry(devlink_port
, &devlink
->port_list
, list
) {
696 err
= devlink_nl_port_fill(msg
, devlink
, devlink_port
,
698 NETLINK_CB(cb
->skb
).portid
,
702 mutex_unlock(&devlink
->lock
);
707 mutex_unlock(&devlink
->lock
);
710 mutex_unlock(&devlink_mutex
);
716 static int devlink_port_type_set(struct devlink
*devlink
,
717 struct devlink_port
*devlink_port
,
718 enum devlink_port_type port_type
)
723 if (devlink
->ops
&& devlink
->ops
->port_type_set
) {
724 if (port_type
== DEVLINK_PORT_TYPE_NOTSET
)
726 if (port_type
== devlink_port
->type
)
728 err
= devlink
->ops
->port_type_set(devlink_port
, port_type
);
731 devlink_port
->desired_type
= port_type
;
732 devlink_port_notify(devlink_port
, DEVLINK_CMD_PORT_NEW
);
738 static int devlink_nl_cmd_port_set_doit(struct sk_buff
*skb
,
739 struct genl_info
*info
)
741 struct devlink_port
*devlink_port
= info
->user_ptr
[0];
742 struct devlink
*devlink
= devlink_port
->devlink
;
745 if (info
->attrs
[DEVLINK_ATTR_PORT_TYPE
]) {
746 enum devlink_port_type port_type
;
748 port_type
= nla_get_u16(info
->attrs
[DEVLINK_ATTR_PORT_TYPE
]);
749 err
= devlink_port_type_set(devlink
, devlink_port
, port_type
);
756 static int devlink_port_split(struct devlink
*devlink
, u32 port_index
,
757 u32 count
, struct netlink_ext_ack
*extack
)
760 if (devlink
->ops
&& devlink
->ops
->port_split
)
761 return devlink
->ops
->port_split(devlink
, port_index
, count
,
766 static int devlink_nl_cmd_port_split_doit(struct sk_buff
*skb
,
767 struct genl_info
*info
)
769 struct devlink
*devlink
= info
->user_ptr
[0];
773 if (!info
->attrs
[DEVLINK_ATTR_PORT_INDEX
] ||
774 !info
->attrs
[DEVLINK_ATTR_PORT_SPLIT_COUNT
])
777 port_index
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_PORT_INDEX
]);
778 count
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_PORT_SPLIT_COUNT
]);
779 return devlink_port_split(devlink
, port_index
, count
, info
->extack
);
782 static int devlink_port_unsplit(struct devlink
*devlink
, u32 port_index
,
783 struct netlink_ext_ack
*extack
)
786 if (devlink
->ops
&& devlink
->ops
->port_unsplit
)
787 return devlink
->ops
->port_unsplit(devlink
, port_index
, extack
);
791 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff
*skb
,
792 struct genl_info
*info
)
794 struct devlink
*devlink
= info
->user_ptr
[0];
797 if (!info
->attrs
[DEVLINK_ATTR_PORT_INDEX
])
800 port_index
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_PORT_INDEX
]);
801 return devlink_port_unsplit(devlink
, port_index
, info
->extack
);
804 static int devlink_nl_sb_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
805 struct devlink_sb
*devlink_sb
,
806 enum devlink_command cmd
, u32 portid
,
811 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
815 if (devlink_nl_put_handle(msg
, devlink
))
816 goto nla_put_failure
;
817 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_INDEX
, devlink_sb
->index
))
818 goto nla_put_failure
;
819 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_SIZE
, devlink_sb
->size
))
820 goto nla_put_failure
;
821 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT
,
822 devlink_sb
->ingress_pools_count
))
823 goto nla_put_failure
;
824 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT
,
825 devlink_sb
->egress_pools_count
))
826 goto nla_put_failure
;
827 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_INGRESS_TC_COUNT
,
828 devlink_sb
->ingress_tc_count
))
829 goto nla_put_failure
;
830 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_EGRESS_TC_COUNT
,
831 devlink_sb
->egress_tc_count
))
832 goto nla_put_failure
;
834 genlmsg_end(msg
, hdr
);
838 genlmsg_cancel(msg
, hdr
);
842 static int devlink_nl_cmd_sb_get_doit(struct sk_buff
*skb
,
843 struct genl_info
*info
)
845 struct devlink
*devlink
= info
->user_ptr
[0];
846 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
850 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
854 err
= devlink_nl_sb_fill(msg
, devlink
, devlink_sb
,
856 info
->snd_portid
, info
->snd_seq
, 0);
862 return genlmsg_reply(msg
, info
);
865 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff
*msg
,
866 struct netlink_callback
*cb
)
868 struct devlink
*devlink
;
869 struct devlink_sb
*devlink_sb
;
870 int start
= cb
->args
[0];
874 mutex_lock(&devlink_mutex
);
875 list_for_each_entry(devlink
, &devlink_list
, list
) {
876 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)))
878 mutex_lock(&devlink
->lock
);
879 list_for_each_entry(devlink_sb
, &devlink
->sb_list
, list
) {
884 err
= devlink_nl_sb_fill(msg
, devlink
, devlink_sb
,
886 NETLINK_CB(cb
->skb
).portid
,
890 mutex_unlock(&devlink
->lock
);
895 mutex_unlock(&devlink
->lock
);
898 mutex_unlock(&devlink_mutex
);
904 static int devlink_nl_sb_pool_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
905 struct devlink_sb
*devlink_sb
,
906 u16 pool_index
, enum devlink_command cmd
,
907 u32 portid
, u32 seq
, int flags
)
909 struct devlink_sb_pool_info pool_info
;
913 err
= devlink
->ops
->sb_pool_get(devlink
, devlink_sb
->index
,
914 pool_index
, &pool_info
);
918 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
922 if (devlink_nl_put_handle(msg
, devlink
))
923 goto nla_put_failure
;
924 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_INDEX
, devlink_sb
->index
))
925 goto nla_put_failure
;
926 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_POOL_INDEX
, pool_index
))
927 goto nla_put_failure
;
928 if (nla_put_u8(msg
, DEVLINK_ATTR_SB_POOL_TYPE
, pool_info
.pool_type
))
929 goto nla_put_failure
;
930 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_POOL_SIZE
, pool_info
.size
))
931 goto nla_put_failure
;
932 if (nla_put_u8(msg
, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE
,
933 pool_info
.threshold_type
))
934 goto nla_put_failure
;
936 genlmsg_end(msg
, hdr
);
940 genlmsg_cancel(msg
, hdr
);
944 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff
*skb
,
945 struct genl_info
*info
)
947 struct devlink
*devlink
= info
->user_ptr
[0];
948 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
953 err
= devlink_sb_pool_index_get_from_info(devlink_sb
, info
,
958 if (!devlink
->ops
|| !devlink
->ops
->sb_pool_get
)
961 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
965 err
= devlink_nl_sb_pool_fill(msg
, devlink
, devlink_sb
, pool_index
,
966 DEVLINK_CMD_SB_POOL_NEW
,
967 info
->snd_portid
, info
->snd_seq
, 0);
973 return genlmsg_reply(msg
, info
);
976 static int __sb_pool_get_dumpit(struct sk_buff
*msg
, int start
, int *p_idx
,
977 struct devlink
*devlink
,
978 struct devlink_sb
*devlink_sb
,
981 u16 pool_count
= devlink_sb_pool_count(devlink_sb
);
985 for (pool_index
= 0; pool_index
< pool_count
; pool_index
++) {
986 if (*p_idx
< start
) {
990 err
= devlink_nl_sb_pool_fill(msg
, devlink
,
993 DEVLINK_CMD_SB_POOL_NEW
,
994 portid
, seq
, NLM_F_MULTI
);
1002 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff
*msg
,
1003 struct netlink_callback
*cb
)
1005 struct devlink
*devlink
;
1006 struct devlink_sb
*devlink_sb
;
1007 int start
= cb
->args
[0];
1011 mutex_lock(&devlink_mutex
);
1012 list_for_each_entry(devlink
, &devlink_list
, list
) {
1013 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)) ||
1014 !devlink
->ops
|| !devlink
->ops
->sb_pool_get
)
1016 mutex_lock(&devlink
->lock
);
1017 list_for_each_entry(devlink_sb
, &devlink
->sb_list
, list
) {
1018 err
= __sb_pool_get_dumpit(msg
, start
, &idx
, devlink
,
1020 NETLINK_CB(cb
->skb
).portid
,
1021 cb
->nlh
->nlmsg_seq
);
1022 if (err
&& err
!= -EOPNOTSUPP
) {
1023 mutex_unlock(&devlink
->lock
);
1027 mutex_unlock(&devlink
->lock
);
1030 mutex_unlock(&devlink_mutex
);
1036 static int devlink_sb_pool_set(struct devlink
*devlink
, unsigned int sb_index
,
1037 u16 pool_index
, u32 size
,
1038 enum devlink_sb_threshold_type threshold_type
)
1041 const struct devlink_ops
*ops
= devlink
->ops
;
1043 if (ops
&& ops
->sb_pool_set
)
1044 return ops
->sb_pool_set(devlink
, sb_index
, pool_index
,
1045 size
, threshold_type
);
1049 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff
*skb
,
1050 struct genl_info
*info
)
1052 struct devlink
*devlink
= info
->user_ptr
[0];
1053 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1054 enum devlink_sb_threshold_type threshold_type
;
1059 err
= devlink_sb_pool_index_get_from_info(devlink_sb
, info
,
1064 err
= devlink_sb_th_type_get_from_info(info
, &threshold_type
);
1068 if (!info
->attrs
[DEVLINK_ATTR_SB_POOL_SIZE
])
1071 size
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_SB_POOL_SIZE
]);
1072 return devlink_sb_pool_set(devlink
, devlink_sb
->index
,
1073 pool_index
, size
, threshold_type
);
1076 static int devlink_nl_sb_port_pool_fill(struct sk_buff
*msg
,
1077 struct devlink
*devlink
,
1078 struct devlink_port
*devlink_port
,
1079 struct devlink_sb
*devlink_sb
,
1081 enum devlink_command cmd
,
1082 u32 portid
, u32 seq
, int flags
)
1084 const struct devlink_ops
*ops
= devlink
->ops
;
1089 err
= ops
->sb_port_pool_get(devlink_port
, devlink_sb
->index
,
1090 pool_index
, &threshold
);
1094 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
1098 if (devlink_nl_put_handle(msg
, devlink
))
1099 goto nla_put_failure
;
1100 if (nla_put_u32(msg
, DEVLINK_ATTR_PORT_INDEX
, devlink_port
->index
))
1101 goto nla_put_failure
;
1102 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_INDEX
, devlink_sb
->index
))
1103 goto nla_put_failure
;
1104 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_POOL_INDEX
, pool_index
))
1105 goto nla_put_failure
;
1106 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_THRESHOLD
, threshold
))
1107 goto nla_put_failure
;
1109 if (ops
->sb_occ_port_pool_get
) {
1113 err
= ops
->sb_occ_port_pool_get(devlink_port
, devlink_sb
->index
,
1114 pool_index
, &cur
, &max
);
1115 if (err
&& err
!= -EOPNOTSUPP
)
1118 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_OCC_CUR
, cur
))
1119 goto nla_put_failure
;
1120 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_OCC_MAX
, max
))
1121 goto nla_put_failure
;
1125 genlmsg_end(msg
, hdr
);
1129 genlmsg_cancel(msg
, hdr
);
1133 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff
*skb
,
1134 struct genl_info
*info
)
1136 struct devlink_port
*devlink_port
= info
->user_ptr
[0];
1137 struct devlink
*devlink
= devlink_port
->devlink
;
1138 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1139 struct sk_buff
*msg
;
1143 err
= devlink_sb_pool_index_get_from_info(devlink_sb
, info
,
1148 if (!devlink
->ops
|| !devlink
->ops
->sb_port_pool_get
)
1151 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1155 err
= devlink_nl_sb_port_pool_fill(msg
, devlink
, devlink_port
,
1156 devlink_sb
, pool_index
,
1157 DEVLINK_CMD_SB_PORT_POOL_NEW
,
1158 info
->snd_portid
, info
->snd_seq
, 0);
1164 return genlmsg_reply(msg
, info
);
1167 static int __sb_port_pool_get_dumpit(struct sk_buff
*msg
, int start
, int *p_idx
,
1168 struct devlink
*devlink
,
1169 struct devlink_sb
*devlink_sb
,
1170 u32 portid
, u32 seq
)
1172 struct devlink_port
*devlink_port
;
1173 u16 pool_count
= devlink_sb_pool_count(devlink_sb
);
1177 list_for_each_entry(devlink_port
, &devlink
->port_list
, list
) {
1178 for (pool_index
= 0; pool_index
< pool_count
; pool_index
++) {
1179 if (*p_idx
< start
) {
1183 err
= devlink_nl_sb_port_pool_fill(msg
, devlink
,
1187 DEVLINK_CMD_SB_PORT_POOL_NEW
,
1198 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff
*msg
,
1199 struct netlink_callback
*cb
)
1201 struct devlink
*devlink
;
1202 struct devlink_sb
*devlink_sb
;
1203 int start
= cb
->args
[0];
1207 mutex_lock(&devlink_mutex
);
1208 list_for_each_entry(devlink
, &devlink_list
, list
) {
1209 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)) ||
1210 !devlink
->ops
|| !devlink
->ops
->sb_port_pool_get
)
1212 mutex_lock(&devlink
->lock
);
1213 list_for_each_entry(devlink_sb
, &devlink
->sb_list
, list
) {
1214 err
= __sb_port_pool_get_dumpit(msg
, start
, &idx
,
1215 devlink
, devlink_sb
,
1216 NETLINK_CB(cb
->skb
).portid
,
1217 cb
->nlh
->nlmsg_seq
);
1218 if (err
&& err
!= -EOPNOTSUPP
) {
1219 mutex_unlock(&devlink
->lock
);
1223 mutex_unlock(&devlink
->lock
);
1226 mutex_unlock(&devlink_mutex
);
1232 static int devlink_sb_port_pool_set(struct devlink_port
*devlink_port
,
1233 unsigned int sb_index
, u16 pool_index
,
1237 const struct devlink_ops
*ops
= devlink_port
->devlink
->ops
;
1239 if (ops
&& ops
->sb_port_pool_set
)
1240 return ops
->sb_port_pool_set(devlink_port
, sb_index
,
1241 pool_index
, threshold
);
1245 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff
*skb
,
1246 struct genl_info
*info
)
1248 struct devlink_port
*devlink_port
= info
->user_ptr
[0];
1249 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1254 err
= devlink_sb_pool_index_get_from_info(devlink_sb
, info
,
1259 if (!info
->attrs
[DEVLINK_ATTR_SB_THRESHOLD
])
1262 threshold
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_SB_THRESHOLD
]);
1263 return devlink_sb_port_pool_set(devlink_port
, devlink_sb
->index
,
1264 pool_index
, threshold
);
1268 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
1269 struct devlink_port
*devlink_port
,
1270 struct devlink_sb
*devlink_sb
, u16 tc_index
,
1271 enum devlink_sb_pool_type pool_type
,
1272 enum devlink_command cmd
,
1273 u32 portid
, u32 seq
, int flags
)
1275 const struct devlink_ops
*ops
= devlink
->ops
;
1281 err
= ops
->sb_tc_pool_bind_get(devlink_port
, devlink_sb
->index
,
1282 tc_index
, pool_type
,
1283 &pool_index
, &threshold
);
1287 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
1291 if (devlink_nl_put_handle(msg
, devlink
))
1292 goto nla_put_failure
;
1293 if (nla_put_u32(msg
, DEVLINK_ATTR_PORT_INDEX
, devlink_port
->index
))
1294 goto nla_put_failure
;
1295 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_INDEX
, devlink_sb
->index
))
1296 goto nla_put_failure
;
1297 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_TC_INDEX
, tc_index
))
1298 goto nla_put_failure
;
1299 if (nla_put_u8(msg
, DEVLINK_ATTR_SB_POOL_TYPE
, pool_type
))
1300 goto nla_put_failure
;
1301 if (nla_put_u16(msg
, DEVLINK_ATTR_SB_POOL_INDEX
, pool_index
))
1302 goto nla_put_failure
;
1303 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_THRESHOLD
, threshold
))
1304 goto nla_put_failure
;
1306 if (ops
->sb_occ_tc_port_bind_get
) {
1310 err
= ops
->sb_occ_tc_port_bind_get(devlink_port
,
1312 tc_index
, pool_type
,
1314 if (err
&& err
!= -EOPNOTSUPP
)
1317 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_OCC_CUR
, cur
))
1318 goto nla_put_failure
;
1319 if (nla_put_u32(msg
, DEVLINK_ATTR_SB_OCC_MAX
, max
))
1320 goto nla_put_failure
;
1324 genlmsg_end(msg
, hdr
);
1328 genlmsg_cancel(msg
, hdr
);
1332 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff
*skb
,
1333 struct genl_info
*info
)
1335 struct devlink_port
*devlink_port
= info
->user_ptr
[0];
1336 struct devlink
*devlink
= devlink_port
->devlink
;
1337 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1338 struct sk_buff
*msg
;
1339 enum devlink_sb_pool_type pool_type
;
1343 err
= devlink_sb_pool_type_get_from_info(info
, &pool_type
);
1347 err
= devlink_sb_tc_index_get_from_info(devlink_sb
, info
,
1348 pool_type
, &tc_index
);
1352 if (!devlink
->ops
|| !devlink
->ops
->sb_tc_pool_bind_get
)
1355 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1359 err
= devlink_nl_sb_tc_pool_bind_fill(msg
, devlink
, devlink_port
,
1360 devlink_sb
, tc_index
, pool_type
,
1361 DEVLINK_CMD_SB_TC_POOL_BIND_NEW
,
1369 return genlmsg_reply(msg
, info
);
1372 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff
*msg
,
1373 int start
, int *p_idx
,
1374 struct devlink
*devlink
,
1375 struct devlink_sb
*devlink_sb
,
1376 u32 portid
, u32 seq
)
1378 struct devlink_port
*devlink_port
;
1382 list_for_each_entry(devlink_port
, &devlink
->port_list
, list
) {
1384 tc_index
< devlink_sb
->ingress_tc_count
; tc_index
++) {
1385 if (*p_idx
< start
) {
1389 err
= devlink_nl_sb_tc_pool_bind_fill(msg
, devlink
,
1393 DEVLINK_SB_POOL_TYPE_INGRESS
,
1394 DEVLINK_CMD_SB_TC_POOL_BIND_NEW
,
1402 tc_index
< devlink_sb
->egress_tc_count
; tc_index
++) {
1403 if (*p_idx
< start
) {
1407 err
= devlink_nl_sb_tc_pool_bind_fill(msg
, devlink
,
1411 DEVLINK_SB_POOL_TYPE_EGRESS
,
1412 DEVLINK_CMD_SB_TC_POOL_BIND_NEW
,
1424 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff
*msg
,
1425 struct netlink_callback
*cb
)
1427 struct devlink
*devlink
;
1428 struct devlink_sb
*devlink_sb
;
1429 int start
= cb
->args
[0];
1433 mutex_lock(&devlink_mutex
);
1434 list_for_each_entry(devlink
, &devlink_list
, list
) {
1435 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)) ||
1436 !devlink
->ops
|| !devlink
->ops
->sb_tc_pool_bind_get
)
1439 mutex_lock(&devlink
->lock
);
1440 list_for_each_entry(devlink_sb
, &devlink
->sb_list
, list
) {
1441 err
= __sb_tc_pool_bind_get_dumpit(msg
, start
, &idx
,
1444 NETLINK_CB(cb
->skb
).portid
,
1445 cb
->nlh
->nlmsg_seq
);
1446 if (err
&& err
!= -EOPNOTSUPP
) {
1447 mutex_unlock(&devlink
->lock
);
1451 mutex_unlock(&devlink
->lock
);
1454 mutex_unlock(&devlink_mutex
);
1460 static int devlink_sb_tc_pool_bind_set(struct devlink_port
*devlink_port
,
1461 unsigned int sb_index
, u16 tc_index
,
1462 enum devlink_sb_pool_type pool_type
,
1463 u16 pool_index
, u32 threshold
)
1466 const struct devlink_ops
*ops
= devlink_port
->devlink
->ops
;
1468 if (ops
&& ops
->sb_tc_pool_bind_set
)
1469 return ops
->sb_tc_pool_bind_set(devlink_port
, sb_index
,
1470 tc_index
, pool_type
,
1471 pool_index
, threshold
);
1475 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff
*skb
,
1476 struct genl_info
*info
)
1478 struct devlink_port
*devlink_port
= info
->user_ptr
[0];
1479 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1480 enum devlink_sb_pool_type pool_type
;
1486 err
= devlink_sb_pool_type_get_from_info(info
, &pool_type
);
1490 err
= devlink_sb_tc_index_get_from_info(devlink_sb
, info
,
1491 pool_type
, &tc_index
);
1495 err
= devlink_sb_pool_index_get_from_info(devlink_sb
, info
,
1500 if (!info
->attrs
[DEVLINK_ATTR_SB_THRESHOLD
])
1503 threshold
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_SB_THRESHOLD
]);
1504 return devlink_sb_tc_pool_bind_set(devlink_port
, devlink_sb
->index
,
1505 tc_index
, pool_type
,
1506 pool_index
, threshold
);
1509 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff
*skb
,
1510 struct genl_info
*info
)
1512 struct devlink
*devlink
= info
->user_ptr
[0];
1513 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1514 const struct devlink_ops
*ops
= devlink
->ops
;
1516 if (ops
&& ops
->sb_occ_snapshot
)
1517 return ops
->sb_occ_snapshot(devlink
, devlink_sb
->index
);
1521 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff
*skb
,
1522 struct genl_info
*info
)
1524 struct devlink
*devlink
= info
->user_ptr
[0];
1525 struct devlink_sb
*devlink_sb
= info
->user_ptr
[1];
1526 const struct devlink_ops
*ops
= devlink
->ops
;
1528 if (ops
&& ops
->sb_occ_max_clear
)
1529 return ops
->sb_occ_max_clear(devlink
, devlink_sb
->index
);
1533 static int devlink_nl_eswitch_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
1534 enum devlink_command cmd
, u32 portid
,
1537 const struct devlink_ops
*ops
= devlink
->ops
;
1538 u8 inline_mode
, encap_mode
;
1543 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
1547 err
= devlink_nl_put_handle(msg
, devlink
);
1549 goto nla_put_failure
;
1551 if (ops
->eswitch_mode_get
) {
1552 err
= ops
->eswitch_mode_get(devlink
, &mode
);
1554 goto nla_put_failure
;
1555 err
= nla_put_u16(msg
, DEVLINK_ATTR_ESWITCH_MODE
, mode
);
1557 goto nla_put_failure
;
1560 if (ops
->eswitch_inline_mode_get
) {
1561 err
= ops
->eswitch_inline_mode_get(devlink
, &inline_mode
);
1563 goto nla_put_failure
;
1564 err
= nla_put_u8(msg
, DEVLINK_ATTR_ESWITCH_INLINE_MODE
,
1567 goto nla_put_failure
;
1570 if (ops
->eswitch_encap_mode_get
) {
1571 err
= ops
->eswitch_encap_mode_get(devlink
, &encap_mode
);
1573 goto nla_put_failure
;
1574 err
= nla_put_u8(msg
, DEVLINK_ATTR_ESWITCH_ENCAP_MODE
, encap_mode
);
1576 goto nla_put_failure
;
1579 genlmsg_end(msg
, hdr
);
1583 genlmsg_cancel(msg
, hdr
);
1587 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff
*skb
,
1588 struct genl_info
*info
)
1590 struct devlink
*devlink
= info
->user_ptr
[0];
1591 const struct devlink_ops
*ops
= devlink
->ops
;
1592 struct sk_buff
*msg
;
1598 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1602 err
= devlink_nl_eswitch_fill(msg
, devlink
, DEVLINK_CMD_ESWITCH_GET
,
1603 info
->snd_portid
, info
->snd_seq
, 0);
1610 return genlmsg_reply(msg
, info
);
1613 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff
*skb
,
1614 struct genl_info
*info
)
1616 struct devlink
*devlink
= info
->user_ptr
[0];
1617 const struct devlink_ops
*ops
= devlink
->ops
;
1618 u8 inline_mode
, encap_mode
;
1625 if (info
->attrs
[DEVLINK_ATTR_ESWITCH_MODE
]) {
1626 if (!ops
->eswitch_mode_set
)
1628 mode
= nla_get_u16(info
->attrs
[DEVLINK_ATTR_ESWITCH_MODE
]);
1629 err
= ops
->eswitch_mode_set(devlink
, mode
, info
->extack
);
1634 if (info
->attrs
[DEVLINK_ATTR_ESWITCH_INLINE_MODE
]) {
1635 if (!ops
->eswitch_inline_mode_set
)
1637 inline_mode
= nla_get_u8(
1638 info
->attrs
[DEVLINK_ATTR_ESWITCH_INLINE_MODE
]);
1639 err
= ops
->eswitch_inline_mode_set(devlink
, inline_mode
,
1645 if (info
->attrs
[DEVLINK_ATTR_ESWITCH_ENCAP_MODE
]) {
1646 if (!ops
->eswitch_encap_mode_set
)
1648 encap_mode
= nla_get_u8(info
->attrs
[DEVLINK_ATTR_ESWITCH_ENCAP_MODE
]);
1649 err
= ops
->eswitch_encap_mode_set(devlink
, encap_mode
,
1658 int devlink_dpipe_match_put(struct sk_buff
*skb
,
1659 struct devlink_dpipe_match
*match
)
1661 struct devlink_dpipe_header
*header
= match
->header
;
1662 struct devlink_dpipe_field
*field
= &header
->fields
[match
->field_id
];
1663 struct nlattr
*match_attr
;
1665 match_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_MATCH
);
1669 if (nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_MATCH_TYPE
, match
->type
) ||
1670 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_HEADER_INDEX
, match
->header_index
) ||
1671 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_HEADER_ID
, header
->id
) ||
1672 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_FIELD_ID
, field
->id
) ||
1673 nla_put_u8(skb
, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL
, header
->global
))
1674 goto nla_put_failure
;
1676 nla_nest_end(skb
, match_attr
);
1680 nla_nest_cancel(skb
, match_attr
);
1683 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put
);
1685 static int devlink_dpipe_matches_put(struct devlink_dpipe_table
*table
,
1686 struct sk_buff
*skb
)
1688 struct nlattr
*matches_attr
;
1690 matches_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_TABLE_MATCHES
);
1694 if (table
->table_ops
->matches_dump(table
->priv
, skb
))
1695 goto nla_put_failure
;
1697 nla_nest_end(skb
, matches_attr
);
1701 nla_nest_cancel(skb
, matches_attr
);
1705 int devlink_dpipe_action_put(struct sk_buff
*skb
,
1706 struct devlink_dpipe_action
*action
)
1708 struct devlink_dpipe_header
*header
= action
->header
;
1709 struct devlink_dpipe_field
*field
= &header
->fields
[action
->field_id
];
1710 struct nlattr
*action_attr
;
1712 action_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_ACTION
);
1716 if (nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_ACTION_TYPE
, action
->type
) ||
1717 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_HEADER_INDEX
, action
->header_index
) ||
1718 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_HEADER_ID
, header
->id
) ||
1719 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_FIELD_ID
, field
->id
) ||
1720 nla_put_u8(skb
, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL
, header
->global
))
1721 goto nla_put_failure
;
1723 nla_nest_end(skb
, action_attr
);
1727 nla_nest_cancel(skb
, action_attr
);
1730 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put
);
1732 static int devlink_dpipe_actions_put(struct devlink_dpipe_table
*table
,
1733 struct sk_buff
*skb
)
1735 struct nlattr
*actions_attr
;
1737 actions_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_TABLE_ACTIONS
);
1741 if (table
->table_ops
->actions_dump(table
->priv
, skb
))
1742 goto nla_put_failure
;
1744 nla_nest_end(skb
, actions_attr
);
1748 nla_nest_cancel(skb
, actions_attr
);
1752 static int devlink_dpipe_table_put(struct sk_buff
*skb
,
1753 struct devlink_dpipe_table
*table
)
1755 struct nlattr
*table_attr
;
1758 table_size
= table
->table_ops
->size_get(table
->priv
);
1759 table_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_TABLE
);
1763 if (nla_put_string(skb
, DEVLINK_ATTR_DPIPE_TABLE_NAME
, table
->name
) ||
1764 nla_put_u64_64bit(skb
, DEVLINK_ATTR_DPIPE_TABLE_SIZE
, table_size
,
1766 goto nla_put_failure
;
1767 if (nla_put_u8(skb
, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED
,
1768 table
->counters_enabled
))
1769 goto nla_put_failure
;
1771 if (table
->resource_valid
) {
1772 if (nla_put_u64_64bit(skb
, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID
,
1773 table
->resource_id
, DEVLINK_ATTR_PAD
) ||
1774 nla_put_u64_64bit(skb
, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS
,
1775 table
->resource_units
, DEVLINK_ATTR_PAD
))
1776 goto nla_put_failure
;
1778 if (devlink_dpipe_matches_put(table
, skb
))
1779 goto nla_put_failure
;
1781 if (devlink_dpipe_actions_put(table
, skb
))
1782 goto nla_put_failure
;
1784 nla_nest_end(skb
, table_attr
);
1788 nla_nest_cancel(skb
, table_attr
);
1792 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff
**pskb
,
1793 struct genl_info
*info
)
1798 err
= genlmsg_reply(*pskb
, info
);
1802 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1808 static int devlink_dpipe_tables_fill(struct genl_info
*info
,
1809 enum devlink_command cmd
, int flags
,
1810 struct list_head
*dpipe_tables
,
1811 const char *table_name
)
1813 struct devlink
*devlink
= info
->user_ptr
[0];
1814 struct devlink_dpipe_table
*table
;
1815 struct nlattr
*tables_attr
;
1816 struct sk_buff
*skb
= NULL
;
1817 struct nlmsghdr
*nlh
;
1823 table
= list_first_entry(dpipe_tables
,
1824 struct devlink_dpipe_table
, list
);
1826 err
= devlink_dpipe_send_and_alloc_skb(&skb
, info
);
1830 hdr
= genlmsg_put(skb
, info
->snd_portid
, info
->snd_seq
,
1831 &devlink_nl_family
, NLM_F_MULTI
, cmd
);
1837 if (devlink_nl_put_handle(skb
, devlink
))
1838 goto nla_put_failure
;
1839 tables_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_TABLES
);
1841 goto nla_put_failure
;
1845 list_for_each_entry_from(table
, dpipe_tables
, list
) {
1847 err
= devlink_dpipe_table_put(skb
, table
);
1855 if (!strcmp(table
->name
, table_name
)) {
1856 err
= devlink_dpipe_table_put(skb
, table
);
1864 nla_nest_end(skb
, tables_attr
);
1865 genlmsg_end(skb
, hdr
);
1870 nlh
= nlmsg_put(skb
, info
->snd_portid
, info
->snd_seq
,
1871 NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
1873 err
= devlink_dpipe_send_and_alloc_skb(&skb
, info
);
1879 return genlmsg_reply(skb
, info
);
1888 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff
*skb
,
1889 struct genl_info
*info
)
1891 struct devlink
*devlink
= info
->user_ptr
[0];
1892 const char *table_name
= NULL
;
1894 if (info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_NAME
])
1895 table_name
= nla_data(info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_NAME
]);
1897 return devlink_dpipe_tables_fill(info
, DEVLINK_CMD_DPIPE_TABLE_GET
, 0,
1898 &devlink
->dpipe_table_list
,
1902 static int devlink_dpipe_value_put(struct sk_buff
*skb
,
1903 struct devlink_dpipe_value
*value
)
1905 if (nla_put(skb
, DEVLINK_ATTR_DPIPE_VALUE
,
1906 value
->value_size
, value
->value
))
1909 if (nla_put(skb
, DEVLINK_ATTR_DPIPE_VALUE_MASK
,
1910 value
->value_size
, value
->mask
))
1912 if (value
->mapping_valid
)
1913 if (nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_VALUE_MAPPING
,
1914 value
->mapping_value
))
1919 static int devlink_dpipe_action_value_put(struct sk_buff
*skb
,
1920 struct devlink_dpipe_value
*value
)
1924 if (devlink_dpipe_action_put(skb
, value
->action
))
1926 if (devlink_dpipe_value_put(skb
, value
))
1931 static int devlink_dpipe_action_values_put(struct sk_buff
*skb
,
1932 struct devlink_dpipe_value
*values
,
1933 unsigned int values_count
)
1935 struct nlattr
*action_attr
;
1939 for (i
= 0; i
< values_count
; i
++) {
1940 action_attr
= nla_nest_start(skb
,
1941 DEVLINK_ATTR_DPIPE_ACTION_VALUE
);
1944 err
= devlink_dpipe_action_value_put(skb
, &values
[i
]);
1946 goto err_action_value_put
;
1947 nla_nest_end(skb
, action_attr
);
1951 err_action_value_put
:
1952 nla_nest_cancel(skb
, action_attr
);
1956 static int devlink_dpipe_match_value_put(struct sk_buff
*skb
,
1957 struct devlink_dpipe_value
*value
)
1961 if (devlink_dpipe_match_put(skb
, value
->match
))
1963 if (devlink_dpipe_value_put(skb
, value
))
1968 static int devlink_dpipe_match_values_put(struct sk_buff
*skb
,
1969 struct devlink_dpipe_value
*values
,
1970 unsigned int values_count
)
1972 struct nlattr
*match_attr
;
1976 for (i
= 0; i
< values_count
; i
++) {
1977 match_attr
= nla_nest_start(skb
,
1978 DEVLINK_ATTR_DPIPE_MATCH_VALUE
);
1981 err
= devlink_dpipe_match_value_put(skb
, &values
[i
]);
1983 goto err_match_value_put
;
1984 nla_nest_end(skb
, match_attr
);
1988 err_match_value_put
:
1989 nla_nest_cancel(skb
, match_attr
);
1993 static int devlink_dpipe_entry_put(struct sk_buff
*skb
,
1994 struct devlink_dpipe_entry
*entry
)
1996 struct nlattr
*entry_attr
, *matches_attr
, *actions_attr
;
1999 entry_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_ENTRY
);
2003 if (nla_put_u64_64bit(skb
, DEVLINK_ATTR_DPIPE_ENTRY_INDEX
, entry
->index
,
2005 goto nla_put_failure
;
2006 if (entry
->counter_valid
)
2007 if (nla_put_u64_64bit(skb
, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER
,
2008 entry
->counter
, DEVLINK_ATTR_PAD
))
2009 goto nla_put_failure
;
2011 matches_attr
= nla_nest_start(skb
,
2012 DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES
);
2014 goto nla_put_failure
;
2016 err
= devlink_dpipe_match_values_put(skb
, entry
->match_values
,
2017 entry
->match_values_count
);
2019 nla_nest_cancel(skb
, matches_attr
);
2020 goto err_match_values_put
;
2022 nla_nest_end(skb
, matches_attr
);
2024 actions_attr
= nla_nest_start(skb
,
2025 DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES
);
2027 goto nla_put_failure
;
2029 err
= devlink_dpipe_action_values_put(skb
, entry
->action_values
,
2030 entry
->action_values_count
);
2032 nla_nest_cancel(skb
, actions_attr
);
2033 goto err_action_values_put
;
2035 nla_nest_end(skb
, actions_attr
);
2037 nla_nest_end(skb
, entry_attr
);
2042 err_match_values_put
:
2043 err_action_values_put
:
2044 nla_nest_cancel(skb
, entry_attr
);
2048 static struct devlink_dpipe_table
*
2049 devlink_dpipe_table_find(struct list_head
*dpipe_tables
,
2050 const char *table_name
)
2052 struct devlink_dpipe_table
*table
;
2054 list_for_each_entry_rcu(table
, dpipe_tables
, list
) {
2055 if (!strcmp(table
->name
, table_name
))
2061 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx
*dump_ctx
)
2063 struct devlink
*devlink
;
2066 err
= devlink_dpipe_send_and_alloc_skb(&dump_ctx
->skb
,
2071 dump_ctx
->hdr
= genlmsg_put(dump_ctx
->skb
,
2072 dump_ctx
->info
->snd_portid
,
2073 dump_ctx
->info
->snd_seq
,
2074 &devlink_nl_family
, NLM_F_MULTI
,
2077 goto nla_put_failure
;
2079 devlink
= dump_ctx
->info
->user_ptr
[0];
2080 if (devlink_nl_put_handle(dump_ctx
->skb
, devlink
))
2081 goto nla_put_failure
;
2082 dump_ctx
->nest
= nla_nest_start(dump_ctx
->skb
,
2083 DEVLINK_ATTR_DPIPE_ENTRIES
);
2084 if (!dump_ctx
->nest
)
2085 goto nla_put_failure
;
2089 nlmsg_free(dump_ctx
->skb
);
2092 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare
);
2094 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx
*dump_ctx
,
2095 struct devlink_dpipe_entry
*entry
)
2097 return devlink_dpipe_entry_put(dump_ctx
->skb
, entry
);
2099 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append
);
2101 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx
*dump_ctx
)
2103 nla_nest_end(dump_ctx
->skb
, dump_ctx
->nest
);
2104 genlmsg_end(dump_ctx
->skb
, dump_ctx
->hdr
);
2107 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close
);
2109 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry
*entry
)
2112 unsigned int value_count
, value_index
;
2113 struct devlink_dpipe_value
*value
;
2115 value
= entry
->action_values
;
2116 value_count
= entry
->action_values_count
;
2117 for (value_index
= 0; value_index
< value_count
; value_index
++) {
2118 kfree(value
[value_index
].value
);
2119 kfree(value
[value_index
].mask
);
2122 value
= entry
->match_values
;
2123 value_count
= entry
->match_values_count
;
2124 for (value_index
= 0; value_index
< value_count
; value_index
++) {
2125 kfree(value
[value_index
].value
);
2126 kfree(value
[value_index
].mask
);
2129 EXPORT_SYMBOL(devlink_dpipe_entry_clear
);
2131 static int devlink_dpipe_entries_fill(struct genl_info
*info
,
2132 enum devlink_command cmd
, int flags
,
2133 struct devlink_dpipe_table
*table
)
2135 struct devlink_dpipe_dump_ctx dump_ctx
;
2136 struct nlmsghdr
*nlh
;
2139 dump_ctx
.skb
= NULL
;
2141 dump_ctx
.info
= info
;
2143 err
= table
->table_ops
->entries_dump(table
->priv
,
2144 table
->counters_enabled
,
2150 nlh
= nlmsg_put(dump_ctx
.skb
, info
->snd_portid
, info
->snd_seq
,
2151 NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2153 err
= devlink_dpipe_send_and_alloc_skb(&dump_ctx
.skb
, info
);
2158 return genlmsg_reply(dump_ctx
.skb
, info
);
2161 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff
*skb
,
2162 struct genl_info
*info
)
2164 struct devlink
*devlink
= info
->user_ptr
[0];
2165 struct devlink_dpipe_table
*table
;
2166 const char *table_name
;
2168 if (!info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_NAME
])
2171 table_name
= nla_data(info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_NAME
]);
2172 table
= devlink_dpipe_table_find(&devlink
->dpipe_table_list
,
2177 if (!table
->table_ops
->entries_dump
)
2180 return devlink_dpipe_entries_fill(info
, DEVLINK_CMD_DPIPE_ENTRIES_GET
,
2184 static int devlink_dpipe_fields_put(struct sk_buff
*skb
,
2185 const struct devlink_dpipe_header
*header
)
2187 struct devlink_dpipe_field
*field
;
2188 struct nlattr
*field_attr
;
2191 for (i
= 0; i
< header
->fields_count
; i
++) {
2192 field
= &header
->fields
[i
];
2193 field_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_FIELD
);
2196 if (nla_put_string(skb
, DEVLINK_ATTR_DPIPE_FIELD_NAME
, field
->name
) ||
2197 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_FIELD_ID
, field
->id
) ||
2198 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH
, field
->bitwidth
) ||
2199 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE
, field
->mapping_type
))
2200 goto nla_put_failure
;
2201 nla_nest_end(skb
, field_attr
);
2206 nla_nest_cancel(skb
, field_attr
);
2210 static int devlink_dpipe_header_put(struct sk_buff
*skb
,
2211 struct devlink_dpipe_header
*header
)
2213 struct nlattr
*fields_attr
, *header_attr
;
2216 header_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_HEADER
);
2220 if (nla_put_string(skb
, DEVLINK_ATTR_DPIPE_HEADER_NAME
, header
->name
) ||
2221 nla_put_u32(skb
, DEVLINK_ATTR_DPIPE_HEADER_ID
, header
->id
) ||
2222 nla_put_u8(skb
, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL
, header
->global
))
2223 goto nla_put_failure
;
2225 fields_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_HEADER_FIELDS
);
2227 goto nla_put_failure
;
2229 err
= devlink_dpipe_fields_put(skb
, header
);
2231 nla_nest_cancel(skb
, fields_attr
);
2232 goto nla_put_failure
;
2234 nla_nest_end(skb
, fields_attr
);
2235 nla_nest_end(skb
, header_attr
);
2240 nla_nest_cancel(skb
, header_attr
);
2244 static int devlink_dpipe_headers_fill(struct genl_info
*info
,
2245 enum devlink_command cmd
, int flags
,
2246 struct devlink_dpipe_headers
*
2249 struct devlink
*devlink
= info
->user_ptr
[0];
2250 struct nlattr
*headers_attr
;
2251 struct sk_buff
*skb
= NULL
;
2252 struct nlmsghdr
*nlh
;
2259 err
= devlink_dpipe_send_and_alloc_skb(&skb
, info
);
2263 hdr
= genlmsg_put(skb
, info
->snd_portid
, info
->snd_seq
,
2264 &devlink_nl_family
, NLM_F_MULTI
, cmd
);
2270 if (devlink_nl_put_handle(skb
, devlink
))
2271 goto nla_put_failure
;
2272 headers_attr
= nla_nest_start(skb
, DEVLINK_ATTR_DPIPE_HEADERS
);
2274 goto nla_put_failure
;
2277 for (; i
< dpipe_headers
->headers_count
; i
++) {
2278 err
= devlink_dpipe_header_put(skb
, dpipe_headers
->headers
[i
]);
2286 nla_nest_end(skb
, headers_attr
);
2287 genlmsg_end(skb
, hdr
);
2288 if (i
!= dpipe_headers
->headers_count
)
2292 nlh
= nlmsg_put(skb
, info
->snd_portid
, info
->snd_seq
,
2293 NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2295 err
= devlink_dpipe_send_and_alloc_skb(&skb
, info
);
2300 return genlmsg_reply(skb
, info
);
2309 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff
*skb
,
2310 struct genl_info
*info
)
2312 struct devlink
*devlink
= info
->user_ptr
[0];
2314 if (!devlink
->dpipe_headers
)
2316 return devlink_dpipe_headers_fill(info
, DEVLINK_CMD_DPIPE_HEADERS_GET
,
2317 0, devlink
->dpipe_headers
);
2320 static int devlink_dpipe_table_counters_set(struct devlink
*devlink
,
2321 const char *table_name
,
2324 struct devlink_dpipe_table
*table
;
2326 table
= devlink_dpipe_table_find(&devlink
->dpipe_table_list
,
2331 if (table
->counter_control_extern
)
2334 if (!(table
->counters_enabled
^ enable
))
2337 table
->counters_enabled
= enable
;
2338 if (table
->table_ops
->counters_set_update
)
2339 table
->table_ops
->counters_set_update(table
->priv
, enable
);
2343 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff
*skb
,
2344 struct genl_info
*info
)
2346 struct devlink
*devlink
= info
->user_ptr
[0];
2347 const char *table_name
;
2348 bool counters_enable
;
2350 if (!info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_NAME
] ||
2351 !info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED
])
2354 table_name
= nla_data(info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_NAME
]);
2355 counters_enable
= !!nla_get_u8(info
->attrs
[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED
]);
2357 return devlink_dpipe_table_counters_set(devlink
, table_name
,
2361 static struct devlink_resource
*
2362 devlink_resource_find(struct devlink
*devlink
,
2363 struct devlink_resource
*resource
, u64 resource_id
)
2365 struct list_head
*resource_list
;
2368 resource_list
= &resource
->resource_list
;
2370 resource_list
= &devlink
->resource_list
;
2372 list_for_each_entry(resource
, resource_list
, list
) {
2373 struct devlink_resource
*child_resource
;
2375 if (resource
->id
== resource_id
)
2378 child_resource
= devlink_resource_find(devlink
, resource
,
2381 return child_resource
;
2387 devlink_resource_validate_children(struct devlink_resource
*resource
)
2389 struct devlink_resource
*child_resource
;
2390 bool size_valid
= true;
2393 if (list_empty(&resource
->resource_list
))
2396 list_for_each_entry(child_resource
, &resource
->resource_list
, list
)
2397 parts_size
+= child_resource
->size_new
;
2399 if (parts_size
> resource
->size_new
)
2402 resource
->size_valid
= size_valid
;
2406 devlink_resource_validate_size(struct devlink_resource
*resource
, u64 size
,
2407 struct netlink_ext_ack
*extack
)
2412 if (size
> resource
->size_params
.size_max
) {
2413 NL_SET_ERR_MSG_MOD(extack
, "Size larger than maximum");
2417 if (size
< resource
->size_params
.size_min
) {
2418 NL_SET_ERR_MSG_MOD(extack
, "Size smaller than minimum");
2422 div64_u64_rem(size
, resource
->size_params
.size_granularity
, &reminder
);
2424 NL_SET_ERR_MSG_MOD(extack
, "Wrong granularity");
2431 static int devlink_nl_cmd_resource_set(struct sk_buff
*skb
,
2432 struct genl_info
*info
)
2434 struct devlink
*devlink
= info
->user_ptr
[0];
2435 struct devlink_resource
*resource
;
2440 if (!info
->attrs
[DEVLINK_ATTR_RESOURCE_ID
] ||
2441 !info
->attrs
[DEVLINK_ATTR_RESOURCE_SIZE
])
2443 resource_id
= nla_get_u64(info
->attrs
[DEVLINK_ATTR_RESOURCE_ID
]);
2445 resource
= devlink_resource_find(devlink
, NULL
, resource_id
);
2449 size
= nla_get_u64(info
->attrs
[DEVLINK_ATTR_RESOURCE_SIZE
]);
2450 err
= devlink_resource_validate_size(resource
, size
, info
->extack
);
2454 resource
->size_new
= size
;
2455 devlink_resource_validate_children(resource
);
2456 if (resource
->parent
)
2457 devlink_resource_validate_children(resource
->parent
);
2462 devlink_resource_size_params_put(struct devlink_resource
*resource
,
2463 struct sk_buff
*skb
)
2465 struct devlink_resource_size_params
*size_params
;
2467 size_params
= &resource
->size_params
;
2468 if (nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_SIZE_GRAN
,
2469 size_params
->size_granularity
, DEVLINK_ATTR_PAD
) ||
2470 nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_SIZE_MAX
,
2471 size_params
->size_max
, DEVLINK_ATTR_PAD
) ||
2472 nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_SIZE_MIN
,
2473 size_params
->size_min
, DEVLINK_ATTR_PAD
) ||
2474 nla_put_u8(skb
, DEVLINK_ATTR_RESOURCE_UNIT
, size_params
->unit
))
2479 static int devlink_resource_occ_put(struct devlink_resource
*resource
,
2480 struct sk_buff
*skb
)
2482 if (!resource
->occ_get
)
2484 return nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_OCC
,
2485 resource
->occ_get(resource
->occ_get_priv
),
2489 static int devlink_resource_put(struct devlink
*devlink
, struct sk_buff
*skb
,
2490 struct devlink_resource
*resource
)
2492 struct devlink_resource
*child_resource
;
2493 struct nlattr
*child_resource_attr
;
2494 struct nlattr
*resource_attr
;
2496 resource_attr
= nla_nest_start(skb
, DEVLINK_ATTR_RESOURCE
);
2500 if (nla_put_string(skb
, DEVLINK_ATTR_RESOURCE_NAME
, resource
->name
) ||
2501 nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_SIZE
, resource
->size
,
2502 DEVLINK_ATTR_PAD
) ||
2503 nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_ID
, resource
->id
,
2505 goto nla_put_failure
;
2506 if (resource
->size
!= resource
->size_new
)
2507 nla_put_u64_64bit(skb
, DEVLINK_ATTR_RESOURCE_SIZE_NEW
,
2508 resource
->size_new
, DEVLINK_ATTR_PAD
);
2509 if (devlink_resource_occ_put(resource
, skb
))
2510 goto nla_put_failure
;
2511 if (devlink_resource_size_params_put(resource
, skb
))
2512 goto nla_put_failure
;
2513 if (list_empty(&resource
->resource_list
))
2516 if (nla_put_u8(skb
, DEVLINK_ATTR_RESOURCE_SIZE_VALID
,
2517 resource
->size_valid
))
2518 goto nla_put_failure
;
2520 child_resource_attr
= nla_nest_start(skb
, DEVLINK_ATTR_RESOURCE_LIST
);
2521 if (!child_resource_attr
)
2522 goto nla_put_failure
;
2524 list_for_each_entry(child_resource
, &resource
->resource_list
, list
) {
2525 if (devlink_resource_put(devlink
, skb
, child_resource
))
2526 goto resource_put_failure
;
2529 nla_nest_end(skb
, child_resource_attr
);
2531 nla_nest_end(skb
, resource_attr
);
2534 resource_put_failure
:
2535 nla_nest_cancel(skb
, child_resource_attr
);
2537 nla_nest_cancel(skb
, resource_attr
);
2541 static int devlink_resource_fill(struct genl_info
*info
,
2542 enum devlink_command cmd
, int flags
)
2544 struct devlink
*devlink
= info
->user_ptr
[0];
2545 struct devlink_resource
*resource
;
2546 struct nlattr
*resources_attr
;
2547 struct sk_buff
*skb
= NULL
;
2548 struct nlmsghdr
*nlh
;
2554 resource
= list_first_entry(&devlink
->resource_list
,
2555 struct devlink_resource
, list
);
2557 err
= devlink_dpipe_send_and_alloc_skb(&skb
, info
);
2561 hdr
= genlmsg_put(skb
, info
->snd_portid
, info
->snd_seq
,
2562 &devlink_nl_family
, NLM_F_MULTI
, cmd
);
2568 if (devlink_nl_put_handle(skb
, devlink
))
2569 goto nla_put_failure
;
2571 resources_attr
= nla_nest_start(skb
, DEVLINK_ATTR_RESOURCE_LIST
);
2572 if (!resources_attr
)
2573 goto nla_put_failure
;
2577 list_for_each_entry_from(resource
, &devlink
->resource_list
, list
) {
2578 err
= devlink_resource_put(devlink
, skb
, resource
);
2581 goto err_resource_put
;
2587 nla_nest_end(skb
, resources_attr
);
2588 genlmsg_end(skb
, hdr
);
2592 nlh
= nlmsg_put(skb
, info
->snd_portid
, info
->snd_seq
,
2593 NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2595 err
= devlink_dpipe_send_and_alloc_skb(&skb
, info
);
2600 return genlmsg_reply(skb
, info
);
2609 static int devlink_nl_cmd_resource_dump(struct sk_buff
*skb
,
2610 struct genl_info
*info
)
2612 struct devlink
*devlink
= info
->user_ptr
[0];
2614 if (list_empty(&devlink
->resource_list
))
2617 return devlink_resource_fill(info
, DEVLINK_CMD_RESOURCE_DUMP
, 0);
2621 devlink_resources_validate(struct devlink
*devlink
,
2622 struct devlink_resource
*resource
,
2623 struct genl_info
*info
)
2625 struct list_head
*resource_list
;
2629 resource_list
= &resource
->resource_list
;
2631 resource_list
= &devlink
->resource_list
;
2633 list_for_each_entry(resource
, resource_list
, list
) {
2634 if (!resource
->size_valid
)
2636 err
= devlink_resources_validate(devlink
, resource
, info
);
2643 static int devlink_nl_cmd_reload(struct sk_buff
*skb
, struct genl_info
*info
)
2645 struct devlink
*devlink
= info
->user_ptr
[0];
2648 if (!devlink
->ops
->reload
)
2651 err
= devlink_resources_validate(devlink
, NULL
, info
);
2653 NL_SET_ERR_MSG_MOD(info
->extack
, "resources size validation failed");
2656 return devlink
->ops
->reload(devlink
, info
->extack
);
2659 static const struct devlink_param devlink_param_generic
[] = {
2661 .id
= DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET
,
2662 .name
= DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME
,
2663 .type
= DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE
,
2666 .id
= DEVLINK_PARAM_GENERIC_ID_MAX_MACS
,
2667 .name
= DEVLINK_PARAM_GENERIC_MAX_MACS_NAME
,
2668 .type
= DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE
,
2671 .id
= DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV
,
2672 .name
= DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME
,
2673 .type
= DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE
,
2676 .id
= DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT
,
2677 .name
= DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME
,
2678 .type
= DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE
,
2681 .id
= DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI
,
2682 .name
= DEVLINK_PARAM_GENERIC_IGNORE_ARI_NAME
,
2683 .type
= DEVLINK_PARAM_GENERIC_IGNORE_ARI_TYPE
,
2686 .id
= DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX
,
2687 .name
= DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_NAME
,
2688 .type
= DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_TYPE
,
2691 .id
= DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN
,
2692 .name
= DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_NAME
,
2693 .type
= DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_TYPE
,
2696 .id
= DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY
,
2697 .name
= DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_NAME
,
2698 .type
= DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_TYPE
,
2702 static int devlink_param_generic_verify(const struct devlink_param
*param
)
2704 /* verify it match generic parameter by id and name */
2705 if (param
->id
> DEVLINK_PARAM_GENERIC_ID_MAX
)
2707 if (strcmp(param
->name
, devlink_param_generic
[param
->id
].name
))
2710 WARN_ON(param
->type
!= devlink_param_generic
[param
->id
].type
);
2715 static int devlink_param_driver_verify(const struct devlink_param
*param
)
2719 if (param
->id
<= DEVLINK_PARAM_GENERIC_ID_MAX
)
2721 /* verify no such name in generic params */
2722 for (i
= 0; i
<= DEVLINK_PARAM_GENERIC_ID_MAX
; i
++)
2723 if (!strcmp(param
->name
, devlink_param_generic
[i
].name
))
2729 static struct devlink_param_item
*
2730 devlink_param_find_by_name(struct list_head
*param_list
,
2731 const char *param_name
)
2733 struct devlink_param_item
*param_item
;
2735 list_for_each_entry(param_item
, param_list
, list
)
2736 if (!strcmp(param_item
->param
->name
, param_name
))
2741 static struct devlink_param_item
*
2742 devlink_param_find_by_id(struct list_head
*param_list
, u32 param_id
)
2744 struct devlink_param_item
*param_item
;
2746 list_for_each_entry(param_item
, param_list
, list
)
2747 if (param_item
->param
->id
== param_id
)
2753 devlink_param_cmode_is_supported(const struct devlink_param
*param
,
2754 enum devlink_param_cmode cmode
)
2756 return test_bit(cmode
, ¶m
->supported_cmodes
);
2759 static int devlink_param_get(struct devlink
*devlink
,
2760 const struct devlink_param
*param
,
2761 struct devlink_param_gset_ctx
*ctx
)
2765 return param
->get(devlink
, param
->id
, ctx
);
2768 static int devlink_param_set(struct devlink
*devlink
,
2769 const struct devlink_param
*param
,
2770 struct devlink_param_gset_ctx
*ctx
)
2774 return param
->set(devlink
, param
->id
, ctx
);
2778 devlink_param_type_to_nla_type(enum devlink_param_type param_type
)
2780 switch (param_type
) {
2781 case DEVLINK_PARAM_TYPE_U8
:
2783 case DEVLINK_PARAM_TYPE_U16
:
2785 case DEVLINK_PARAM_TYPE_U32
:
2787 case DEVLINK_PARAM_TYPE_STRING
:
2789 case DEVLINK_PARAM_TYPE_BOOL
:
2797 devlink_nl_param_value_fill_one(struct sk_buff
*msg
,
2798 enum devlink_param_type type
,
2799 enum devlink_param_cmode cmode
,
2800 union devlink_param_value val
)
2802 struct nlattr
*param_value_attr
;
2804 param_value_attr
= nla_nest_start(msg
, DEVLINK_ATTR_PARAM_VALUE
);
2805 if (!param_value_attr
)
2806 goto nla_put_failure
;
2808 if (nla_put_u8(msg
, DEVLINK_ATTR_PARAM_VALUE_CMODE
, cmode
))
2809 goto value_nest_cancel
;
2812 case DEVLINK_PARAM_TYPE_U8
:
2813 if (nla_put_u8(msg
, DEVLINK_ATTR_PARAM_VALUE_DATA
, val
.vu8
))
2814 goto value_nest_cancel
;
2816 case DEVLINK_PARAM_TYPE_U16
:
2817 if (nla_put_u16(msg
, DEVLINK_ATTR_PARAM_VALUE_DATA
, val
.vu16
))
2818 goto value_nest_cancel
;
2820 case DEVLINK_PARAM_TYPE_U32
:
2821 if (nla_put_u32(msg
, DEVLINK_ATTR_PARAM_VALUE_DATA
, val
.vu32
))
2822 goto value_nest_cancel
;
2824 case DEVLINK_PARAM_TYPE_STRING
:
2825 if (nla_put_string(msg
, DEVLINK_ATTR_PARAM_VALUE_DATA
,
2827 goto value_nest_cancel
;
2829 case DEVLINK_PARAM_TYPE_BOOL
:
2831 nla_put_flag(msg
, DEVLINK_ATTR_PARAM_VALUE_DATA
))
2832 goto value_nest_cancel
;
2836 nla_nest_end(msg
, param_value_attr
);
2840 nla_nest_cancel(msg
, param_value_attr
);
2845 static int devlink_nl_param_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
2846 struct devlink_param_item
*param_item
,
2847 enum devlink_command cmd
,
2848 u32 portid
, u32 seq
, int flags
)
2850 union devlink_param_value param_value
[DEVLINK_PARAM_CMODE_MAX
+ 1];
2851 const struct devlink_param
*param
= param_item
->param
;
2852 struct devlink_param_gset_ctx ctx
;
2853 struct nlattr
*param_values_list
;
2854 struct nlattr
*param_attr
;
2860 /* Get value from driver part to driverinit configuration mode */
2861 for (i
= 0; i
<= DEVLINK_PARAM_CMODE_MAX
; i
++) {
2862 if (!devlink_param_cmode_is_supported(param
, i
))
2864 if (i
== DEVLINK_PARAM_CMODE_DRIVERINIT
) {
2865 if (!param_item
->driverinit_value_valid
)
2867 param_value
[i
] = param_item
->driverinit_value
;
2870 err
= devlink_param_get(devlink
, param
, &ctx
);
2873 param_value
[i
] = ctx
.val
;
2877 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
2881 if (devlink_nl_put_handle(msg
, devlink
))
2882 goto genlmsg_cancel
;
2883 param_attr
= nla_nest_start(msg
, DEVLINK_ATTR_PARAM
);
2885 goto genlmsg_cancel
;
2886 if (nla_put_string(msg
, DEVLINK_ATTR_PARAM_NAME
, param
->name
))
2887 goto param_nest_cancel
;
2888 if (param
->generic
&& nla_put_flag(msg
, DEVLINK_ATTR_PARAM_GENERIC
))
2889 goto param_nest_cancel
;
2891 nla_type
= devlink_param_type_to_nla_type(param
->type
);
2893 goto param_nest_cancel
;
2894 if (nla_put_u8(msg
, DEVLINK_ATTR_PARAM_TYPE
, nla_type
))
2895 goto param_nest_cancel
;
2897 param_values_list
= nla_nest_start(msg
, DEVLINK_ATTR_PARAM_VALUES_LIST
);
2898 if (!param_values_list
)
2899 goto param_nest_cancel
;
2901 for (i
= 0; i
<= DEVLINK_PARAM_CMODE_MAX
; i
++) {
2902 if (!devlink_param_cmode_is_supported(param
, i
))
2904 err
= devlink_nl_param_value_fill_one(msg
, param
->type
,
2907 goto values_list_nest_cancel
;
2910 nla_nest_end(msg
, param_values_list
);
2911 nla_nest_end(msg
, param_attr
);
2912 genlmsg_end(msg
, hdr
);
2915 values_list_nest_cancel
:
2916 nla_nest_end(msg
, param_values_list
);
2918 nla_nest_cancel(msg
, param_attr
);
2920 genlmsg_cancel(msg
, hdr
);
2924 static void devlink_param_notify(struct devlink
*devlink
,
2925 struct devlink_param_item
*param_item
,
2926 enum devlink_command cmd
)
2928 struct sk_buff
*msg
;
2931 WARN_ON(cmd
!= DEVLINK_CMD_PARAM_NEW
&& cmd
!= DEVLINK_CMD_PARAM_DEL
);
2933 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2936 err
= devlink_nl_param_fill(msg
, devlink
, param_item
, cmd
, 0, 0, 0);
2942 genlmsg_multicast_netns(&devlink_nl_family
, devlink_net(devlink
),
2943 msg
, 0, DEVLINK_MCGRP_CONFIG
, GFP_KERNEL
);
2946 static int devlink_nl_cmd_param_get_dumpit(struct sk_buff
*msg
,
2947 struct netlink_callback
*cb
)
2949 struct devlink_param_item
*param_item
;
2950 struct devlink
*devlink
;
2951 int start
= cb
->args
[0];
2955 mutex_lock(&devlink_mutex
);
2956 list_for_each_entry(devlink
, &devlink_list
, list
) {
2957 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)))
2959 mutex_lock(&devlink
->lock
);
2960 list_for_each_entry(param_item
, &devlink
->param_list
, list
) {
2965 err
= devlink_nl_param_fill(msg
, devlink
, param_item
,
2966 DEVLINK_CMD_PARAM_GET
,
2967 NETLINK_CB(cb
->skb
).portid
,
2971 mutex_unlock(&devlink
->lock
);
2976 mutex_unlock(&devlink
->lock
);
2979 mutex_unlock(&devlink_mutex
);
2986 devlink_param_type_get_from_info(struct genl_info
*info
,
2987 enum devlink_param_type
*param_type
)
2989 if (!info
->attrs
[DEVLINK_ATTR_PARAM_TYPE
])
2992 switch (nla_get_u8(info
->attrs
[DEVLINK_ATTR_PARAM_TYPE
])) {
2994 *param_type
= DEVLINK_PARAM_TYPE_U8
;
2997 *param_type
= DEVLINK_PARAM_TYPE_U16
;
3000 *param_type
= DEVLINK_PARAM_TYPE_U32
;
3003 *param_type
= DEVLINK_PARAM_TYPE_STRING
;
3006 *param_type
= DEVLINK_PARAM_TYPE_BOOL
;
3016 devlink_param_value_get_from_info(const struct devlink_param
*param
,
3017 struct genl_info
*info
,
3018 union devlink_param_value
*value
)
3022 if (param
->type
!= DEVLINK_PARAM_TYPE_BOOL
&&
3023 !info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
])
3026 switch (param
->type
) {
3027 case DEVLINK_PARAM_TYPE_U8
:
3028 value
->vu8
= nla_get_u8(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]);
3030 case DEVLINK_PARAM_TYPE_U16
:
3031 value
->vu16
= nla_get_u16(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]);
3033 case DEVLINK_PARAM_TYPE_U32
:
3034 value
->vu32
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]);
3036 case DEVLINK_PARAM_TYPE_STRING
:
3037 len
= strnlen(nla_data(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]),
3038 nla_len(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]));
3039 if (len
== nla_len(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]) ||
3040 len
>= __DEVLINK_PARAM_MAX_STRING_VALUE
)
3043 nla_data(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
]));
3045 case DEVLINK_PARAM_TYPE_BOOL
:
3046 value
->vbool
= info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_DATA
] ?
3053 static struct devlink_param_item
*
3054 devlink_param_get_from_info(struct devlink
*devlink
,
3055 struct genl_info
*info
)
3059 if (!info
->attrs
[DEVLINK_ATTR_PARAM_NAME
])
3062 param_name
= nla_data(info
->attrs
[DEVLINK_ATTR_PARAM_NAME
]);
3063 return devlink_param_find_by_name(&devlink
->param_list
, param_name
);
3066 static int devlink_nl_cmd_param_get_doit(struct sk_buff
*skb
,
3067 struct genl_info
*info
)
3069 struct devlink
*devlink
= info
->user_ptr
[0];
3070 struct devlink_param_item
*param_item
;
3071 struct sk_buff
*msg
;
3074 param_item
= devlink_param_get_from_info(devlink
, info
);
3078 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3082 err
= devlink_nl_param_fill(msg
, devlink
, param_item
,
3083 DEVLINK_CMD_PARAM_GET
,
3084 info
->snd_portid
, info
->snd_seq
, 0);
3090 return genlmsg_reply(msg
, info
);
3093 static int devlink_nl_cmd_param_set_doit(struct sk_buff
*skb
,
3094 struct genl_info
*info
)
3096 struct devlink
*devlink
= info
->user_ptr
[0];
3097 enum devlink_param_type param_type
;
3098 struct devlink_param_gset_ctx ctx
;
3099 enum devlink_param_cmode cmode
;
3100 struct devlink_param_item
*param_item
;
3101 const struct devlink_param
*param
;
3102 union devlink_param_value value
;
3105 param_item
= devlink_param_get_from_info(devlink
, info
);
3108 param
= param_item
->param
;
3109 err
= devlink_param_type_get_from_info(info
, ¶m_type
);
3112 if (param_type
!= param
->type
)
3114 err
= devlink_param_value_get_from_info(param
, info
, &value
);
3117 if (param
->validate
) {
3118 err
= param
->validate(devlink
, param
->id
, value
, info
->extack
);
3123 if (!info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_CMODE
])
3125 cmode
= nla_get_u8(info
->attrs
[DEVLINK_ATTR_PARAM_VALUE_CMODE
]);
3126 if (!devlink_param_cmode_is_supported(param
, cmode
))
3129 if (cmode
== DEVLINK_PARAM_CMODE_DRIVERINIT
) {
3130 if (param
->type
== DEVLINK_PARAM_TYPE_STRING
)
3131 strcpy(param_item
->driverinit_value
.vstr
, value
.vstr
);
3133 param_item
->driverinit_value
= value
;
3134 param_item
->driverinit_value_valid
= true;
3140 err
= devlink_param_set(devlink
, param
, &ctx
);
3145 devlink_param_notify(devlink
, param_item
, DEVLINK_CMD_PARAM_NEW
);
3149 static int devlink_param_register_one(struct devlink
*devlink
,
3150 const struct devlink_param
*param
)
3152 struct devlink_param_item
*param_item
;
3154 if (devlink_param_find_by_name(&devlink
->param_list
,
3158 if (param
->supported_cmodes
== BIT(DEVLINK_PARAM_CMODE_DRIVERINIT
))
3159 WARN_ON(param
->get
|| param
->set
);
3161 WARN_ON(!param
->get
|| !param
->set
);
3163 param_item
= kzalloc(sizeof(*param_item
), GFP_KERNEL
);
3166 param_item
->param
= param
;
3168 list_add_tail(¶m_item
->list
, &devlink
->param_list
);
3169 devlink_param_notify(devlink
, param_item
, DEVLINK_CMD_PARAM_NEW
);
3173 static void devlink_param_unregister_one(struct devlink
*devlink
,
3174 const struct devlink_param
*param
)
3176 struct devlink_param_item
*param_item
;
3178 param_item
= devlink_param_find_by_name(&devlink
->param_list
,
3180 WARN_ON(!param_item
);
3181 devlink_param_notify(devlink
, param_item
, DEVLINK_CMD_PARAM_DEL
);
3182 list_del(¶m_item
->list
);
3186 static int devlink_nl_region_snapshot_id_put(struct sk_buff
*msg
,
3187 struct devlink
*devlink
,
3188 struct devlink_snapshot
*snapshot
)
3190 struct nlattr
*snap_attr
;
3193 snap_attr
= nla_nest_start(msg
, DEVLINK_ATTR_REGION_SNAPSHOT
);
3197 err
= nla_put_u32(msg
, DEVLINK_ATTR_REGION_SNAPSHOT_ID
, snapshot
->id
);
3199 goto nla_put_failure
;
3201 nla_nest_end(msg
, snap_attr
);
3205 nla_nest_cancel(msg
, snap_attr
);
3209 static int devlink_nl_region_snapshots_id_put(struct sk_buff
*msg
,
3210 struct devlink
*devlink
,
3211 struct devlink_region
*region
)
3213 struct devlink_snapshot
*snapshot
;
3214 struct nlattr
*snapshots_attr
;
3217 snapshots_attr
= nla_nest_start(msg
, DEVLINK_ATTR_REGION_SNAPSHOTS
);
3218 if (!snapshots_attr
)
3221 list_for_each_entry(snapshot
, ®ion
->snapshot_list
, list
) {
3222 err
= devlink_nl_region_snapshot_id_put(msg
, devlink
, snapshot
);
3224 goto nla_put_failure
;
3227 nla_nest_end(msg
, snapshots_attr
);
3231 nla_nest_cancel(msg
, snapshots_attr
);
3235 static int devlink_nl_region_fill(struct sk_buff
*msg
, struct devlink
*devlink
,
3236 enum devlink_command cmd
, u32 portid
,
3238 struct devlink_region
*region
)
3243 hdr
= genlmsg_put(msg
, portid
, seq
, &devlink_nl_family
, flags
, cmd
);
3247 err
= devlink_nl_put_handle(msg
, devlink
);
3249 goto nla_put_failure
;
3251 err
= nla_put_string(msg
, DEVLINK_ATTR_REGION_NAME
, region
->name
);
3253 goto nla_put_failure
;
3255 err
= nla_put_u64_64bit(msg
, DEVLINK_ATTR_REGION_SIZE
,
3259 goto nla_put_failure
;
3261 err
= devlink_nl_region_snapshots_id_put(msg
, devlink
, region
);
3263 goto nla_put_failure
;
3265 genlmsg_end(msg
, hdr
);
3269 genlmsg_cancel(msg
, hdr
);
3273 static void devlink_nl_region_notify(struct devlink_region
*region
,
3274 struct devlink_snapshot
*snapshot
,
3275 enum devlink_command cmd
)
3277 struct devlink
*devlink
= region
->devlink
;
3278 struct sk_buff
*msg
;
3282 WARN_ON(cmd
!= DEVLINK_CMD_REGION_NEW
&& cmd
!= DEVLINK_CMD_REGION_DEL
);
3284 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3288 hdr
= genlmsg_put(msg
, 0, 0, &devlink_nl_family
, 0, cmd
);
3292 err
= devlink_nl_put_handle(msg
, devlink
);
3294 goto out_cancel_msg
;
3296 err
= nla_put_string(msg
, DEVLINK_ATTR_REGION_NAME
,
3299 goto out_cancel_msg
;
3302 err
= nla_put_u32(msg
, DEVLINK_ATTR_REGION_SNAPSHOT_ID
,
3305 goto out_cancel_msg
;
3307 err
= nla_put_u64_64bit(msg
, DEVLINK_ATTR_REGION_SIZE
,
3308 region
->size
, DEVLINK_ATTR_PAD
);
3310 goto out_cancel_msg
;
3312 genlmsg_end(msg
, hdr
);
3314 genlmsg_multicast_netns(&devlink_nl_family
, devlink_net(devlink
),
3315 msg
, 0, DEVLINK_MCGRP_CONFIG
, GFP_KERNEL
);
3320 genlmsg_cancel(msg
, hdr
);
3325 static int devlink_nl_cmd_region_get_doit(struct sk_buff
*skb
,
3326 struct genl_info
*info
)
3328 struct devlink
*devlink
= info
->user_ptr
[0];
3329 struct devlink_region
*region
;
3330 const char *region_name
;
3331 struct sk_buff
*msg
;
3334 if (!info
->attrs
[DEVLINK_ATTR_REGION_NAME
])
3337 region_name
= nla_data(info
->attrs
[DEVLINK_ATTR_REGION_NAME
]);
3338 region
= devlink_region_get_by_name(devlink
, region_name
);
3342 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3346 err
= devlink_nl_region_fill(msg
, devlink
, DEVLINK_CMD_REGION_GET
,
3347 info
->snd_portid
, info
->snd_seq
, 0,
3354 return genlmsg_reply(msg
, info
);
3357 static int devlink_nl_cmd_region_get_dumpit(struct sk_buff
*msg
,
3358 struct netlink_callback
*cb
)
3360 struct devlink_region
*region
;
3361 struct devlink
*devlink
;
3362 int start
= cb
->args
[0];
3366 mutex_lock(&devlink_mutex
);
3367 list_for_each_entry(devlink
, &devlink_list
, list
) {
3368 if (!net_eq(devlink_net(devlink
), sock_net(msg
->sk
)))
3371 mutex_lock(&devlink
->lock
);
3372 list_for_each_entry(region
, &devlink
->region_list
, list
) {
3377 err
= devlink_nl_region_fill(msg
, devlink
,
3378 DEVLINK_CMD_REGION_GET
,
3379 NETLINK_CB(cb
->skb
).portid
,
3381 NLM_F_MULTI
, region
);
3383 mutex_unlock(&devlink
->lock
);
3388 mutex_unlock(&devlink
->lock
);
3391 mutex_unlock(&devlink_mutex
);
3396 static int devlink_nl_cmd_region_del(struct sk_buff
*skb
,
3397 struct genl_info
*info
)
3399 struct devlink
*devlink
= info
->user_ptr
[0];
3400 struct devlink_snapshot
*snapshot
;
3401 struct devlink_region
*region
;
3402 const char *region_name
;
3405 if (!info
->attrs
[DEVLINK_ATTR_REGION_NAME
] ||
3406 !info
->attrs
[DEVLINK_ATTR_REGION_SNAPSHOT_ID
])
3409 region_name
= nla_data(info
->attrs
[DEVLINK_ATTR_REGION_NAME
]);
3410 snapshot_id
= nla_get_u32(info
->attrs
[DEVLINK_ATTR_REGION_SNAPSHOT_ID
]);
3412 region
= devlink_region_get_by_name(devlink
, region_name
);
3416 snapshot
= devlink_region_snapshot_get_by_id(region
, snapshot_id
);
3420 devlink_nl_region_notify(region
, snapshot
, DEVLINK_CMD_REGION_DEL
);
3421 devlink_region_snapshot_del(snapshot
);
3425 static int devlink_nl_cmd_region_read_chunk_fill(struct sk_buff
*msg
,
3426 struct devlink
*devlink
,
3427 u8
*chunk
, u32 chunk_size
,
3430 struct nlattr
*chunk_attr
;
3433 chunk_attr
= nla_nest_start(msg
, DEVLINK_ATTR_REGION_CHUNK
);
3437 err
= nla_put(msg
, DEVLINK_ATTR_REGION_CHUNK_DATA
, chunk_size
, chunk
);
3439 goto nla_put_failure
;
3441 err
= nla_put_u64_64bit(msg
, DEVLINK_ATTR_REGION_CHUNK_ADDR
, addr
,
3444 goto nla_put_failure
;
3446 nla_nest_end(msg
, chunk_attr
);
3450 nla_nest_cancel(msg
, chunk_attr
);
3454 #define DEVLINK_REGION_READ_CHUNK_SIZE 256
3456 static int devlink_nl_region_read_snapshot_fill(struct sk_buff
*skb
,
3457 struct devlink
*devlink
,
3458 struct devlink_region
*region
,
3459 struct nlattr
**attrs
,
3465 struct devlink_snapshot
*snapshot
;
3466 u64 curr_offset
= start_offset
;
3470 *new_offset
= start_offset
;
3472 snapshot_id
= nla_get_u32(attrs
[DEVLINK_ATTR_REGION_SNAPSHOT_ID
]);
3473 snapshot
= devlink_region_snapshot_get_by_id(region
, snapshot_id
);
3477 if (end_offset
> snapshot
->data_len
|| dump
)
3478 end_offset
= snapshot
->data_len
;
3480 while (curr_offset
< end_offset
) {
3484 if (end_offset
- curr_offset
< DEVLINK_REGION_READ_CHUNK_SIZE
)
3485 data_size
= end_offset
- curr_offset
;
3487 data_size
= DEVLINK_REGION_READ_CHUNK_SIZE
;
3489 data
= &snapshot
->data
[curr_offset
];
3490 err
= devlink_nl_cmd_region_read_chunk_fill(skb
, devlink
,
3496 curr_offset
+= data_size
;
3498 *new_offset
= curr_offset
;
3503 static int devlink_nl_cmd_region_read_dumpit(struct sk_buff
*skb
,
3504 struct netlink_callback
*cb
)
3506 u64 ret_offset
, start_offset
, end_offset
= 0;
3507 struct nlattr
*attrs
[DEVLINK_ATTR_MAX
+ 1];
3508 const struct genl_ops
*ops
= cb
->data
;
3509 struct devlink_region
*region
;
3510 struct nlattr
*chunks_attr
;
3511 const char *region_name
;
3512 struct devlink
*devlink
;
3517 start_offset
= *((u64
*)&cb
->args
[0]);
3519 err
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ devlink_nl_family
.hdrsize
,
3520 attrs
, DEVLINK_ATTR_MAX
, ops
->policy
, cb
->extack
);
3524 devlink
= devlink_get_from_attrs(sock_net(cb
->skb
->sk
), attrs
);
3525 if (IS_ERR(devlink
))
3528 mutex_lock(&devlink_mutex
);
3529 mutex_lock(&devlink
->lock
);
3531 if (!attrs
[DEVLINK_ATTR_REGION_NAME
] ||
3532 !attrs
[DEVLINK_ATTR_REGION_SNAPSHOT_ID
])
3535 region_name
= nla_data(attrs
[DEVLINK_ATTR_REGION_NAME
]);
3536 region
= devlink_region_get_by_name(devlink
, region_name
);
3540 hdr
= genlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
3541 &devlink_nl_family
, NLM_F_ACK
| NLM_F_MULTI
,
3542 DEVLINK_CMD_REGION_READ
);
3546 err
= devlink_nl_put_handle(skb
, devlink
);
3548 goto nla_put_failure
;
3550 err
= nla_put_string(skb
, DEVLINK_ATTR_REGION_NAME
, region_name
);
3552 goto nla_put_failure
;
3554 chunks_attr
= nla_nest_start(skb
, DEVLINK_ATTR_REGION_CHUNKS
);
3556 goto nla_put_failure
;
3558 if (attrs
[DEVLINK_ATTR_REGION_CHUNK_ADDR
] &&
3559 attrs
[DEVLINK_ATTR_REGION_CHUNK_LEN
]) {
3562 nla_get_u64(attrs
[DEVLINK_ATTR_REGION_CHUNK_ADDR
]);
3564 end_offset
= nla_get_u64(attrs
[DEVLINK_ATTR_REGION_CHUNK_ADDR
]);
3565 end_offset
+= nla_get_u64(attrs
[DEVLINK_ATTR_REGION_CHUNK_LEN
]);
3569 err
= devlink_nl_region_read_snapshot_fill(skb
, devlink
,
3575 if (err
&& err
!= -EMSGSIZE
)
3576 goto nla_put_failure
;
3578 /* Check if there was any progress done to prevent infinite loop */
3579 if (ret_offset
== start_offset
)
3580 goto nla_put_failure
;
3582 *((u64
*)&cb
->args
[0]) = ret_offset
;
3584 nla_nest_end(skb
, chunks_attr
);
3585 genlmsg_end(skb
, hdr
);
3586 mutex_unlock(&devlink
->lock
);
3587 mutex_unlock(&devlink_mutex
);
3592 genlmsg_cancel(skb
, hdr
);
3594 mutex_unlock(&devlink
->lock
);
3595 mutex_unlock(&devlink_mutex
);
3600 static const struct nla_policy devlink_nl_policy
[DEVLINK_ATTR_MAX
+ 1] = {
3601 [DEVLINK_ATTR_BUS_NAME
] = { .type
= NLA_NUL_STRING
},
3602 [DEVLINK_ATTR_DEV_NAME
] = { .type
= NLA_NUL_STRING
},
3603 [DEVLINK_ATTR_PORT_INDEX
] = { .type
= NLA_U32
},
3604 [DEVLINK_ATTR_PORT_TYPE
] = { .type
= NLA_U16
},
3605 [DEVLINK_ATTR_PORT_SPLIT_COUNT
] = { .type
= NLA_U32
},
3606 [DEVLINK_ATTR_SB_INDEX
] = { .type
= NLA_U32
},
3607 [DEVLINK_ATTR_SB_POOL_INDEX
] = { .type
= NLA_U16
},
3608 [DEVLINK_ATTR_SB_POOL_TYPE
] = { .type
= NLA_U8
},
3609 [DEVLINK_ATTR_SB_POOL_SIZE
] = { .type
= NLA_U32
},
3610 [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE
] = { .type
= NLA_U8
},
3611 [DEVLINK_ATTR_SB_THRESHOLD
] = { .type
= NLA_U32
},
3612 [DEVLINK_ATTR_SB_TC_INDEX
] = { .type
= NLA_U16
},
3613 [DEVLINK_ATTR_ESWITCH_MODE
] = { .type
= NLA_U16
},
3614 [DEVLINK_ATTR_ESWITCH_INLINE_MODE
] = { .type
= NLA_U8
},
3615 [DEVLINK_ATTR_ESWITCH_ENCAP_MODE
] = { .type
= NLA_U8
},
3616 [DEVLINK_ATTR_DPIPE_TABLE_NAME
] = { .type
= NLA_NUL_STRING
},
3617 [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED
] = { .type
= NLA_U8
},
3618 [DEVLINK_ATTR_RESOURCE_ID
] = { .type
= NLA_U64
},
3619 [DEVLINK_ATTR_RESOURCE_SIZE
] = { .type
= NLA_U64
},
3620 [DEVLINK_ATTR_PARAM_NAME
] = { .type
= NLA_NUL_STRING
},
3621 [DEVLINK_ATTR_PARAM_TYPE
] = { .type
= NLA_U8
},
3622 [DEVLINK_ATTR_PARAM_VALUE_CMODE
] = { .type
= NLA_U8
},
3623 [DEVLINK_ATTR_REGION_NAME
] = { .type
= NLA_NUL_STRING
},
3624 [DEVLINK_ATTR_REGION_SNAPSHOT_ID
] = { .type
= NLA_U32
},
3627 static const struct genl_ops devlink_nl_ops
[] = {
3629 .cmd
= DEVLINK_CMD_GET
,
3630 .doit
= devlink_nl_cmd_get_doit
,
3631 .dumpit
= devlink_nl_cmd_get_dumpit
,
3632 .policy
= devlink_nl_policy
,
3633 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3634 /* can be retrieved by unprivileged users */
3637 .cmd
= DEVLINK_CMD_PORT_GET
,
3638 .doit
= devlink_nl_cmd_port_get_doit
,
3639 .dumpit
= devlink_nl_cmd_port_get_dumpit
,
3640 .policy
= devlink_nl_policy
,
3641 .internal_flags
= DEVLINK_NL_FLAG_NEED_PORT
,
3642 /* can be retrieved by unprivileged users */
3645 .cmd
= DEVLINK_CMD_PORT_SET
,
3646 .doit
= devlink_nl_cmd_port_set_doit
,
3647 .policy
= devlink_nl_policy
,
3648 .flags
= GENL_ADMIN_PERM
,
3649 .internal_flags
= DEVLINK_NL_FLAG_NEED_PORT
,
3652 .cmd
= DEVLINK_CMD_PORT_SPLIT
,
3653 .doit
= devlink_nl_cmd_port_split_doit
,
3654 .policy
= devlink_nl_policy
,
3655 .flags
= GENL_ADMIN_PERM
,
3656 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3657 DEVLINK_NL_FLAG_NO_LOCK
,
3660 .cmd
= DEVLINK_CMD_PORT_UNSPLIT
,
3661 .doit
= devlink_nl_cmd_port_unsplit_doit
,
3662 .policy
= devlink_nl_policy
,
3663 .flags
= GENL_ADMIN_PERM
,
3664 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3665 DEVLINK_NL_FLAG_NO_LOCK
,
3668 .cmd
= DEVLINK_CMD_SB_GET
,
3669 .doit
= devlink_nl_cmd_sb_get_doit
,
3670 .dumpit
= devlink_nl_cmd_sb_get_dumpit
,
3671 .policy
= devlink_nl_policy
,
3672 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3673 DEVLINK_NL_FLAG_NEED_SB
,
3674 /* can be retrieved by unprivileged users */
3677 .cmd
= DEVLINK_CMD_SB_POOL_GET
,
3678 .doit
= devlink_nl_cmd_sb_pool_get_doit
,
3679 .dumpit
= devlink_nl_cmd_sb_pool_get_dumpit
,
3680 .policy
= devlink_nl_policy
,
3681 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3682 DEVLINK_NL_FLAG_NEED_SB
,
3683 /* can be retrieved by unprivileged users */
3686 .cmd
= DEVLINK_CMD_SB_POOL_SET
,
3687 .doit
= devlink_nl_cmd_sb_pool_set_doit
,
3688 .policy
= devlink_nl_policy
,
3689 .flags
= GENL_ADMIN_PERM
,
3690 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3691 DEVLINK_NL_FLAG_NEED_SB
,
3694 .cmd
= DEVLINK_CMD_SB_PORT_POOL_GET
,
3695 .doit
= devlink_nl_cmd_sb_port_pool_get_doit
,
3696 .dumpit
= devlink_nl_cmd_sb_port_pool_get_dumpit
,
3697 .policy
= devlink_nl_policy
,
3698 .internal_flags
= DEVLINK_NL_FLAG_NEED_PORT
|
3699 DEVLINK_NL_FLAG_NEED_SB
,
3700 /* can be retrieved by unprivileged users */
3703 .cmd
= DEVLINK_CMD_SB_PORT_POOL_SET
,
3704 .doit
= devlink_nl_cmd_sb_port_pool_set_doit
,
3705 .policy
= devlink_nl_policy
,
3706 .flags
= GENL_ADMIN_PERM
,
3707 .internal_flags
= DEVLINK_NL_FLAG_NEED_PORT
|
3708 DEVLINK_NL_FLAG_NEED_SB
,
3711 .cmd
= DEVLINK_CMD_SB_TC_POOL_BIND_GET
,
3712 .doit
= devlink_nl_cmd_sb_tc_pool_bind_get_doit
,
3713 .dumpit
= devlink_nl_cmd_sb_tc_pool_bind_get_dumpit
,
3714 .policy
= devlink_nl_policy
,
3715 .internal_flags
= DEVLINK_NL_FLAG_NEED_PORT
|
3716 DEVLINK_NL_FLAG_NEED_SB
,
3717 /* can be retrieved by unprivileged users */
3720 .cmd
= DEVLINK_CMD_SB_TC_POOL_BIND_SET
,
3721 .doit
= devlink_nl_cmd_sb_tc_pool_bind_set_doit
,
3722 .policy
= devlink_nl_policy
,
3723 .flags
= GENL_ADMIN_PERM
,
3724 .internal_flags
= DEVLINK_NL_FLAG_NEED_PORT
|
3725 DEVLINK_NL_FLAG_NEED_SB
,
3728 .cmd
= DEVLINK_CMD_SB_OCC_SNAPSHOT
,
3729 .doit
= devlink_nl_cmd_sb_occ_snapshot_doit
,
3730 .policy
= devlink_nl_policy
,
3731 .flags
= GENL_ADMIN_PERM
,
3732 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3733 DEVLINK_NL_FLAG_NEED_SB
,
3736 .cmd
= DEVLINK_CMD_SB_OCC_MAX_CLEAR
,
3737 .doit
= devlink_nl_cmd_sb_occ_max_clear_doit
,
3738 .policy
= devlink_nl_policy
,
3739 .flags
= GENL_ADMIN_PERM
,
3740 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3741 DEVLINK_NL_FLAG_NEED_SB
,
3744 .cmd
= DEVLINK_CMD_ESWITCH_GET
,
3745 .doit
= devlink_nl_cmd_eswitch_get_doit
,
3746 .policy
= devlink_nl_policy
,
3747 .flags
= GENL_ADMIN_PERM
,
3748 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3751 .cmd
= DEVLINK_CMD_ESWITCH_SET
,
3752 .doit
= devlink_nl_cmd_eswitch_set_doit
,
3753 .policy
= devlink_nl_policy
,
3754 .flags
= GENL_ADMIN_PERM
,
3755 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3756 DEVLINK_NL_FLAG_NO_LOCK
,
3759 .cmd
= DEVLINK_CMD_DPIPE_TABLE_GET
,
3760 .doit
= devlink_nl_cmd_dpipe_table_get
,
3761 .policy
= devlink_nl_policy
,
3762 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3763 /* can be retrieved by unprivileged users */
3766 .cmd
= DEVLINK_CMD_DPIPE_ENTRIES_GET
,
3767 .doit
= devlink_nl_cmd_dpipe_entries_get
,
3768 .policy
= devlink_nl_policy
,
3769 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3770 /* can be retrieved by unprivileged users */
3773 .cmd
= DEVLINK_CMD_DPIPE_HEADERS_GET
,
3774 .doit
= devlink_nl_cmd_dpipe_headers_get
,
3775 .policy
= devlink_nl_policy
,
3776 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3777 /* can be retrieved by unprivileged users */
3780 .cmd
= DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET
,
3781 .doit
= devlink_nl_cmd_dpipe_table_counters_set
,
3782 .policy
= devlink_nl_policy
,
3783 .flags
= GENL_ADMIN_PERM
,
3784 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3787 .cmd
= DEVLINK_CMD_RESOURCE_SET
,
3788 .doit
= devlink_nl_cmd_resource_set
,
3789 .policy
= devlink_nl_policy
,
3790 .flags
= GENL_ADMIN_PERM
,
3791 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3794 .cmd
= DEVLINK_CMD_RESOURCE_DUMP
,
3795 .doit
= devlink_nl_cmd_resource_dump
,
3796 .policy
= devlink_nl_policy
,
3797 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3798 /* can be retrieved by unprivileged users */
3801 .cmd
= DEVLINK_CMD_RELOAD
,
3802 .doit
= devlink_nl_cmd_reload
,
3803 .policy
= devlink_nl_policy
,
3804 .flags
= GENL_ADMIN_PERM
,
3805 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
|
3806 DEVLINK_NL_FLAG_NO_LOCK
,
3809 .cmd
= DEVLINK_CMD_PARAM_GET
,
3810 .doit
= devlink_nl_cmd_param_get_doit
,
3811 .dumpit
= devlink_nl_cmd_param_get_dumpit
,
3812 .policy
= devlink_nl_policy
,
3813 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3814 /* can be retrieved by unprivileged users */
3817 .cmd
= DEVLINK_CMD_PARAM_SET
,
3818 .doit
= devlink_nl_cmd_param_set_doit
,
3819 .policy
= devlink_nl_policy
,
3820 .flags
= GENL_ADMIN_PERM
,
3821 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3824 .cmd
= DEVLINK_CMD_REGION_GET
,
3825 .doit
= devlink_nl_cmd_region_get_doit
,
3826 .dumpit
= devlink_nl_cmd_region_get_dumpit
,
3827 .policy
= devlink_nl_policy
,
3828 .flags
= GENL_ADMIN_PERM
,
3829 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3832 .cmd
= DEVLINK_CMD_REGION_DEL
,
3833 .doit
= devlink_nl_cmd_region_del
,
3834 .policy
= devlink_nl_policy
,
3835 .flags
= GENL_ADMIN_PERM
,
3836 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3839 .cmd
= DEVLINK_CMD_REGION_READ
,
3840 .dumpit
= devlink_nl_cmd_region_read_dumpit
,
3841 .policy
= devlink_nl_policy
,
3842 .flags
= GENL_ADMIN_PERM
,
3843 .internal_flags
= DEVLINK_NL_FLAG_NEED_DEVLINK
,
3847 static struct genl_family devlink_nl_family __ro_after_init
= {
3848 .name
= DEVLINK_GENL_NAME
,
3849 .version
= DEVLINK_GENL_VERSION
,
3850 .maxattr
= DEVLINK_ATTR_MAX
,
3852 .pre_doit
= devlink_nl_pre_doit
,
3853 .post_doit
= devlink_nl_post_doit
,
3854 .module
= THIS_MODULE
,
3855 .ops
= devlink_nl_ops
,
3856 .n_ops
= ARRAY_SIZE(devlink_nl_ops
),
3857 .mcgrps
= devlink_nl_mcgrps
,
3858 .n_mcgrps
= ARRAY_SIZE(devlink_nl_mcgrps
),
3862 * devlink_alloc - Allocate new devlink instance resources
3865 * @priv_size: size of user private data
3867 * Allocate new devlink instance resources, including devlink index
3870 struct devlink
*devlink_alloc(const struct devlink_ops
*ops
, size_t priv_size
)
3872 struct devlink
*devlink
;
3874 devlink
= kzalloc(sizeof(*devlink
) + priv_size
, GFP_KERNEL
);
3878 devlink_net_set(devlink
, &init_net
);
3879 INIT_LIST_HEAD(&devlink
->port_list
);
3880 INIT_LIST_HEAD(&devlink
->sb_list
);
3881 INIT_LIST_HEAD_RCU(&devlink
->dpipe_table_list
);
3882 INIT_LIST_HEAD(&devlink
->resource_list
);
3883 INIT_LIST_HEAD(&devlink
->param_list
);
3884 INIT_LIST_HEAD(&devlink
->region_list
);
3885 mutex_init(&devlink
->lock
);
3888 EXPORT_SYMBOL_GPL(devlink_alloc
);
3891 * devlink_register - Register devlink instance
3895 int devlink_register(struct devlink
*devlink
, struct device
*dev
)
3897 mutex_lock(&devlink_mutex
);
3899 list_add_tail(&devlink
->list
, &devlink_list
);
3900 devlink_notify(devlink
, DEVLINK_CMD_NEW
);
3901 mutex_unlock(&devlink_mutex
);
3904 EXPORT_SYMBOL_GPL(devlink_register
);
3907 * devlink_unregister - Unregister devlink instance
3911 void devlink_unregister(struct devlink
*devlink
)
3913 mutex_lock(&devlink_mutex
);
3914 devlink_notify(devlink
, DEVLINK_CMD_DEL
);
3915 list_del(&devlink
->list
);
3916 mutex_unlock(&devlink_mutex
);
3918 EXPORT_SYMBOL_GPL(devlink_unregister
);
3921 * devlink_free - Free devlink instance resources
3925 void devlink_free(struct devlink
*devlink
)
3929 EXPORT_SYMBOL_GPL(devlink_free
);
3932 * devlink_port_register - Register devlink port
3935 * @devlink_port: devlink port
3938 * Register devlink port with provided port index. User can use
3939 * any indexing, even hw-related one. devlink_port structure
3940 * is convenient to be embedded inside user driver private structure.
3941 * Note that the caller should take care of zeroing the devlink_port
3944 int devlink_port_register(struct devlink
*devlink
,
3945 struct devlink_port
*devlink_port
,
3946 unsigned int port_index
)
3948 mutex_lock(&devlink
->lock
);
3949 if (devlink_port_index_exists(devlink
, port_index
)) {
3950 mutex_unlock(&devlink
->lock
);
3953 devlink_port
->devlink
= devlink
;
3954 devlink_port
->index
= port_index
;
3955 devlink_port
->registered
= true;
3956 list_add_tail(&devlink_port
->list
, &devlink
->port_list
);
3957 mutex_unlock(&devlink
->lock
);
3958 devlink_port_notify(devlink_port
, DEVLINK_CMD_PORT_NEW
);
3961 EXPORT_SYMBOL_GPL(devlink_port_register
);
3964 * devlink_port_unregister - Unregister devlink port
3966 * @devlink_port: devlink port
3968 void devlink_port_unregister(struct devlink_port
*devlink_port
)
3970 struct devlink
*devlink
= devlink_port
->devlink
;
3972 devlink_port_notify(devlink_port
, DEVLINK_CMD_PORT_DEL
);
3973 mutex_lock(&devlink
->lock
);
3974 list_del(&devlink_port
->list
);
3975 mutex_unlock(&devlink
->lock
);
3977 EXPORT_SYMBOL_GPL(devlink_port_unregister
);
3979 static void __devlink_port_type_set(struct devlink_port
*devlink_port
,
3980 enum devlink_port_type type
,
3983 devlink_port
->type
= type
;
3984 devlink_port
->type_dev
= type_dev
;
3985 devlink_port_notify(devlink_port
, DEVLINK_CMD_PORT_NEW
);
3989 * devlink_port_type_eth_set - Set port type to Ethernet
3991 * @devlink_port: devlink port
3992 * @netdev: related netdevice
3994 void devlink_port_type_eth_set(struct devlink_port
*devlink_port
,
3995 struct net_device
*netdev
)
3997 return __devlink_port_type_set(devlink_port
,
3998 DEVLINK_PORT_TYPE_ETH
, netdev
);
4000 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set
);
4003 * devlink_port_type_ib_set - Set port type to InfiniBand
4005 * @devlink_port: devlink port
4006 * @ibdev: related IB device
4008 void devlink_port_type_ib_set(struct devlink_port
*devlink_port
,
4009 struct ib_device
*ibdev
)
4011 return __devlink_port_type_set(devlink_port
,
4012 DEVLINK_PORT_TYPE_IB
, ibdev
);
4014 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set
);
4017 * devlink_port_type_clear - Clear port type
4019 * @devlink_port: devlink port
4021 void devlink_port_type_clear(struct devlink_port
*devlink_port
)
4023 return __devlink_port_type_set(devlink_port
,
4024 DEVLINK_PORT_TYPE_NOTSET
, NULL
);
4026 EXPORT_SYMBOL_GPL(devlink_port_type_clear
);
4029 * devlink_port_attrs_set - Set port attributes
4031 * @devlink_port: devlink port
4032 * @flavour: flavour of the port
4033 * @port_number: number of the port that is facing user, for example
4034 * the front panel port number
4035 * @split: indicates if this is split port
4036 * @split_subport_number: if the port is split, this is the number
4039 void devlink_port_attrs_set(struct devlink_port
*devlink_port
,
4040 enum devlink_port_flavour flavour
,
4041 u32 port_number
, bool split
,
4042 u32 split_subport_number
)
4044 struct devlink_port_attrs
*attrs
= &devlink_port
->attrs
;
4047 attrs
->flavour
= flavour
;
4048 attrs
->port_number
= port_number
;
4049 attrs
->split
= split
;
4050 attrs
->split_subport_number
= split_subport_number
;
4051 devlink_port_notify(devlink_port
, DEVLINK_CMD_PORT_NEW
);
4053 EXPORT_SYMBOL_GPL(devlink_port_attrs_set
);
4055 int devlink_port_get_phys_port_name(struct devlink_port
*devlink_port
,
4056 char *name
, size_t len
)
4058 struct devlink_port_attrs
*attrs
= &devlink_port
->attrs
;
4064 switch (attrs
->flavour
) {
4065 case DEVLINK_PORT_FLAVOUR_PHYSICAL
:
4067 n
= snprintf(name
, len
, "p%u", attrs
->port_number
);
4069 n
= snprintf(name
, len
, "p%us%u", attrs
->port_number
,
4070 attrs
->split_subport_number
);
4072 case DEVLINK_PORT_FLAVOUR_CPU
:
4073 case DEVLINK_PORT_FLAVOUR_DSA
:
4074 /* As CPU and DSA ports do not have a netdevice associated
4075 * case should not ever happen.
4086 EXPORT_SYMBOL_GPL(devlink_port_get_phys_port_name
);
4088 int devlink_sb_register(struct devlink
*devlink
, unsigned int sb_index
,
4089 u32 size
, u16 ingress_pools_count
,
4090 u16 egress_pools_count
, u16 ingress_tc_count
,
4091 u16 egress_tc_count
)
4093 struct devlink_sb
*devlink_sb
;
4096 mutex_lock(&devlink
->lock
);
4097 if (devlink_sb_index_exists(devlink
, sb_index
)) {
4102 devlink_sb
= kzalloc(sizeof(*devlink_sb
), GFP_KERNEL
);
4107 devlink_sb
->index
= sb_index
;
4108 devlink_sb
->size
= size
;
4109 devlink_sb
->ingress_pools_count
= ingress_pools_count
;
4110 devlink_sb
->egress_pools_count
= egress_pools_count
;
4111 devlink_sb
->ingress_tc_count
= ingress_tc_count
;
4112 devlink_sb
->egress_tc_count
= egress_tc_count
;
4113 list_add_tail(&devlink_sb
->list
, &devlink
->sb_list
);
4115 mutex_unlock(&devlink
->lock
);
4118 EXPORT_SYMBOL_GPL(devlink_sb_register
);
4120 void devlink_sb_unregister(struct devlink
*devlink
, unsigned int sb_index
)
4122 struct devlink_sb
*devlink_sb
;
4124 mutex_lock(&devlink
->lock
);
4125 devlink_sb
= devlink_sb_get_by_index(devlink
, sb_index
);
4126 WARN_ON(!devlink_sb
);
4127 list_del(&devlink_sb
->list
);
4128 mutex_unlock(&devlink
->lock
);
4131 EXPORT_SYMBOL_GPL(devlink_sb_unregister
);
4134 * devlink_dpipe_headers_register - register dpipe headers
4137 * @dpipe_headers: dpipe header array
4139 * Register the headers supported by hardware.
4141 int devlink_dpipe_headers_register(struct devlink
*devlink
,
4142 struct devlink_dpipe_headers
*dpipe_headers
)
4144 mutex_lock(&devlink
->lock
);
4145 devlink
->dpipe_headers
= dpipe_headers
;
4146 mutex_unlock(&devlink
->lock
);
4149 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register
);
4152 * devlink_dpipe_headers_unregister - unregister dpipe headers
4156 * Unregister the headers supported by hardware.
4158 void devlink_dpipe_headers_unregister(struct devlink
*devlink
)
4160 mutex_lock(&devlink
->lock
);
4161 devlink
->dpipe_headers
= NULL
;
4162 mutex_unlock(&devlink
->lock
);
4164 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister
);
4167 * devlink_dpipe_table_counter_enabled - check if counter allocation
4170 * @table_name: tables name
4172 * Used by driver to check if counter allocation is required.
4173 * After counter allocation is turned on the table entries
4174 * are updated to include counter statistics.
4176 * After that point on the driver must respect the counter
4177 * state so that each entry added to the table is added
4180 bool devlink_dpipe_table_counter_enabled(struct devlink
*devlink
,
4181 const char *table_name
)
4183 struct devlink_dpipe_table
*table
;
4187 table
= devlink_dpipe_table_find(&devlink
->dpipe_table_list
,
4191 enabled
= table
->counters_enabled
;
4195 EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled
);
4198 * devlink_dpipe_table_register - register dpipe table
4201 * @table_name: table name
4202 * @table_ops: table ops
4204 * @counter_control_extern: external control for counters
4206 int devlink_dpipe_table_register(struct devlink
*devlink
,
4207 const char *table_name
,
4208 struct devlink_dpipe_table_ops
*table_ops
,
4209 void *priv
, bool counter_control_extern
)
4211 struct devlink_dpipe_table
*table
;
4213 if (devlink_dpipe_table_find(&devlink
->dpipe_table_list
, table_name
))
4216 if (WARN_ON(!table_ops
->size_get
))
4219 table
= kzalloc(sizeof(*table
), GFP_KERNEL
);
4223 table
->name
= table_name
;
4224 table
->table_ops
= table_ops
;
4226 table
->counter_control_extern
= counter_control_extern
;
4228 mutex_lock(&devlink
->lock
);
4229 list_add_tail_rcu(&table
->list
, &devlink
->dpipe_table_list
);
4230 mutex_unlock(&devlink
->lock
);
4233 EXPORT_SYMBOL_GPL(devlink_dpipe_table_register
);
4236 * devlink_dpipe_table_unregister - unregister dpipe table
4239 * @table_name: table name
4241 void devlink_dpipe_table_unregister(struct devlink
*devlink
,
4242 const char *table_name
)
4244 struct devlink_dpipe_table
*table
;
4246 mutex_lock(&devlink
->lock
);
4247 table
= devlink_dpipe_table_find(&devlink
->dpipe_table_list
,
4251 list_del_rcu(&table
->list
);
4252 mutex_unlock(&devlink
->lock
);
4253 kfree_rcu(table
, rcu
);
4256 mutex_unlock(&devlink
->lock
);
4258 EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister
);
4261 * devlink_resource_register - devlink resource register
4264 * @resource_name: resource's name
4265 * @top_hierarchy: top hierarchy
4266 * @reload_required: reload is required for new configuration to
4268 * @resource_size: resource's size
4269 * @resource_id: resource's id
4270 * @parent_reosurce_id: resource's parent id
4271 * @size params: size parameters
4273 int devlink_resource_register(struct devlink
*devlink
,
4274 const char *resource_name
,
4277 u64 parent_resource_id
,
4278 const struct devlink_resource_size_params
*size_params
)
4280 struct devlink_resource
*resource
;
4281 struct list_head
*resource_list
;
4285 top_hierarchy
= parent_resource_id
== DEVLINK_RESOURCE_ID_PARENT_TOP
;
4287 mutex_lock(&devlink
->lock
);
4288 resource
= devlink_resource_find(devlink
, NULL
, resource_id
);
4294 resource
= kzalloc(sizeof(*resource
), GFP_KERNEL
);
4300 if (top_hierarchy
) {
4301 resource_list
= &devlink
->resource_list
;
4303 struct devlink_resource
*parent_resource
;
4305 parent_resource
= devlink_resource_find(devlink
, NULL
,
4306 parent_resource_id
);
4307 if (parent_resource
) {
4308 resource_list
= &parent_resource
->resource_list
;
4309 resource
->parent
= parent_resource
;
4317 resource
->name
= resource_name
;
4318 resource
->size
= resource_size
;
4319 resource
->size_new
= resource_size
;
4320 resource
->id
= resource_id
;
4321 resource
->size_valid
= true;
4322 memcpy(&resource
->size_params
, size_params
,
4323 sizeof(resource
->size_params
));
4324 INIT_LIST_HEAD(&resource
->resource_list
);
4325 list_add_tail(&resource
->list
, resource_list
);
4327 mutex_unlock(&devlink
->lock
);
4330 EXPORT_SYMBOL_GPL(devlink_resource_register
);
4333 * devlink_resources_unregister - free all resources
4336 * @resource: resource
4338 void devlink_resources_unregister(struct devlink
*devlink
,
4339 struct devlink_resource
*resource
)
4341 struct devlink_resource
*tmp
, *child_resource
;
4342 struct list_head
*resource_list
;
4345 resource_list
= &resource
->resource_list
;
4347 resource_list
= &devlink
->resource_list
;
4350 mutex_lock(&devlink
->lock
);
4352 list_for_each_entry_safe(child_resource
, tmp
, resource_list
, list
) {
4353 devlink_resources_unregister(devlink
, child_resource
);
4354 list_del(&child_resource
->list
);
4355 kfree(child_resource
);
4359 mutex_unlock(&devlink
->lock
);
4361 EXPORT_SYMBOL_GPL(devlink_resources_unregister
);
4364 * devlink_resource_size_get - get and update size
4367 * @resource_id: the requested resource id
4368 * @p_resource_size: ptr to update
4370 int devlink_resource_size_get(struct devlink
*devlink
,
4372 u64
*p_resource_size
)
4374 struct devlink_resource
*resource
;
4377 mutex_lock(&devlink
->lock
);
4378 resource
= devlink_resource_find(devlink
, NULL
, resource_id
);
4383 *p_resource_size
= resource
->size_new
;
4384 resource
->size
= resource
->size_new
;
4386 mutex_unlock(&devlink
->lock
);
4389 EXPORT_SYMBOL_GPL(devlink_resource_size_get
);
4392 * devlink_dpipe_table_resource_set - set the resource id
4395 * @table_name: table name
4396 * @resource_id: resource id
4397 * @resource_units: number of resource's units consumed per table's entry
4399 int devlink_dpipe_table_resource_set(struct devlink
*devlink
,
4400 const char *table_name
, u64 resource_id
,
4403 struct devlink_dpipe_table
*table
;
4406 mutex_lock(&devlink
->lock
);
4407 table
= devlink_dpipe_table_find(&devlink
->dpipe_table_list
,
4413 table
->resource_id
= resource_id
;
4414 table
->resource_units
= resource_units
;
4415 table
->resource_valid
= true;
4417 mutex_unlock(&devlink
->lock
);
4420 EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set
);
4423 * devlink_resource_occ_get_register - register occupancy getter
4426 * @resource_id: resource id
4427 * @occ_get: occupancy getter callback
4428 * @occ_get_priv: occupancy getter callback priv
4430 void devlink_resource_occ_get_register(struct devlink
*devlink
,
4432 devlink_resource_occ_get_t
*occ_get
,
4435 struct devlink_resource
*resource
;
4437 mutex_lock(&devlink
->lock
);
4438 resource
= devlink_resource_find(devlink
, NULL
, resource_id
);
4439 if (WARN_ON(!resource
))
4441 WARN_ON(resource
->occ_get
);
4443 resource
->occ_get
= occ_get
;
4444 resource
->occ_get_priv
= occ_get_priv
;
4446 mutex_unlock(&devlink
->lock
);
4448 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_register
);
4451 * devlink_resource_occ_get_unregister - unregister occupancy getter
4454 * @resource_id: resource id
4456 void devlink_resource_occ_get_unregister(struct devlink
*devlink
,
4459 struct devlink_resource
*resource
;
4461 mutex_lock(&devlink
->lock
);
4462 resource
= devlink_resource_find(devlink
, NULL
, resource_id
);
4463 if (WARN_ON(!resource
))
4465 WARN_ON(!resource
->occ_get
);
4467 resource
->occ_get
= NULL
;
4468 resource
->occ_get_priv
= NULL
;
4470 mutex_unlock(&devlink
->lock
);
4472 EXPORT_SYMBOL_GPL(devlink_resource_occ_get_unregister
);
4475 * devlink_params_register - register configuration parameters
4478 * @params: configuration parameters array
4479 * @params_count: number of parameters provided
4481 * Register the configuration parameters supported by the driver.
4483 int devlink_params_register(struct devlink
*devlink
,
4484 const struct devlink_param
*params
,
4485 size_t params_count
)
4487 const struct devlink_param
*param
= params
;
4491 mutex_lock(&devlink
->lock
);
4492 for (i
= 0; i
< params_count
; i
++, param
++) {
4493 if (!param
|| !param
->name
|| !param
->supported_cmodes
) {
4497 if (param
->generic
) {
4498 err
= devlink_param_generic_verify(param
);
4502 err
= devlink_param_driver_verify(param
);
4506 err
= devlink_param_register_one(devlink
, param
);
4511 mutex_unlock(&devlink
->lock
);
4517 for (param
--; i
> 0; i
--, param
--)
4518 devlink_param_unregister_one(devlink
, param
);
4520 mutex_unlock(&devlink
->lock
);
4523 EXPORT_SYMBOL_GPL(devlink_params_register
);
4526 * devlink_params_unregister - unregister configuration parameters
4528 * @params: configuration parameters to unregister
4529 * @params_count: number of parameters provided
4531 void devlink_params_unregister(struct devlink
*devlink
,
4532 const struct devlink_param
*params
,
4533 size_t params_count
)
4535 const struct devlink_param
*param
= params
;
4538 mutex_lock(&devlink
->lock
);
4539 for (i
= 0; i
< params_count
; i
++, param
++)
4540 devlink_param_unregister_one(devlink
, param
);
4541 mutex_unlock(&devlink
->lock
);
4543 EXPORT_SYMBOL_GPL(devlink_params_unregister
);
4546 * devlink_param_driverinit_value_get - get configuration parameter
4547 * value for driver initializing
4550 * @param_id: parameter ID
4551 * @init_val: value of parameter in driverinit configuration mode
4553 * This function should be used by the driver to get driverinit
4554 * configuration for initialization after reload command.
4556 int devlink_param_driverinit_value_get(struct devlink
*devlink
, u32 param_id
,
4557 union devlink_param_value
*init_val
)
4559 struct devlink_param_item
*param_item
;
4561 if (!devlink
->ops
|| !devlink
->ops
->reload
)
4564 param_item
= devlink_param_find_by_id(&devlink
->param_list
, param_id
);
4568 if (!param_item
->driverinit_value_valid
||
4569 !devlink_param_cmode_is_supported(param_item
->param
,
4570 DEVLINK_PARAM_CMODE_DRIVERINIT
))
4573 if (param_item
->param
->type
== DEVLINK_PARAM_TYPE_STRING
)
4574 strcpy(init_val
->vstr
, param_item
->driverinit_value
.vstr
);
4576 *init_val
= param_item
->driverinit_value
;
4580 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_get
);
4583 * devlink_param_driverinit_value_set - set value of configuration
4584 * parameter for driverinit
4585 * configuration mode
4588 * @param_id: parameter ID
4589 * @init_val: value of parameter to set for driverinit configuration mode
4591 * This function should be used by the driver to set driverinit
4592 * configuration mode default value.
4594 int devlink_param_driverinit_value_set(struct devlink
*devlink
, u32 param_id
,
4595 union devlink_param_value init_val
)
4597 struct devlink_param_item
*param_item
;
4599 param_item
= devlink_param_find_by_id(&devlink
->param_list
, param_id
);
4603 if (!devlink_param_cmode_is_supported(param_item
->param
,
4604 DEVLINK_PARAM_CMODE_DRIVERINIT
))
4607 if (param_item
->param
->type
== DEVLINK_PARAM_TYPE_STRING
)
4608 strcpy(param_item
->driverinit_value
.vstr
, init_val
.vstr
);
4610 param_item
->driverinit_value
= init_val
;
4611 param_item
->driverinit_value_valid
= true;
4613 devlink_param_notify(devlink
, param_item
, DEVLINK_CMD_PARAM_NEW
);
4616 EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_set
);
4619 * devlink_param_value_changed - notify devlink on a parameter's value
4620 * change. Should be called by the driver
4621 * right after the change.
4624 * @param_id: parameter ID
4626 * This function should be used by the driver to notify devlink on value
4627 * change, excluding driverinit configuration mode.
4628 * For driverinit configuration mode driver should use the function
4629 * devlink_param_driverinit_value_set() instead.
4631 void devlink_param_value_changed(struct devlink
*devlink
, u32 param_id
)
4633 struct devlink_param_item
*param_item
;
4635 param_item
= devlink_param_find_by_id(&devlink
->param_list
, param_id
);
4636 WARN_ON(!param_item
);
4638 devlink_param_notify(devlink
, param_item
, DEVLINK_CMD_PARAM_NEW
);
4640 EXPORT_SYMBOL_GPL(devlink_param_value_changed
);
4643 * devlink_param_value_str_fill - Safely fill-up the string preventing
4644 * from overflow of the preallocated buffer
4646 * @dst_val: destination devlink_param_value
4647 * @src: source buffer
4649 void devlink_param_value_str_fill(union devlink_param_value
*dst_val
,
4654 len
= strlcpy(dst_val
->vstr
, src
, __DEVLINK_PARAM_MAX_STRING_VALUE
);
4655 WARN_ON(len
>= __DEVLINK_PARAM_MAX_STRING_VALUE
);
4657 EXPORT_SYMBOL_GPL(devlink_param_value_str_fill
);
4660 * devlink_region_create - create a new address region
4663 * @region_name: region name
4664 * @region_max_snapshots: Maximum supported number of snapshots for region
4665 * @region_size: size of region
4667 struct devlink_region
*devlink_region_create(struct devlink
*devlink
,
4668 const char *region_name
,
4669 u32 region_max_snapshots
,
4672 struct devlink_region
*region
;
4675 mutex_lock(&devlink
->lock
);
4677 if (devlink_region_get_by_name(devlink
, region_name
)) {
4682 region
= kzalloc(sizeof(*region
), GFP_KERNEL
);
4688 region
->devlink
= devlink
;
4689 region
->max_snapshots
= region_max_snapshots
;
4690 region
->name
= region_name
;
4691 region
->size
= region_size
;
4692 INIT_LIST_HEAD(®ion
->snapshot_list
);
4693 list_add_tail(®ion
->list
, &devlink
->region_list
);
4694 devlink_nl_region_notify(region
, NULL
, DEVLINK_CMD_REGION_NEW
);
4696 mutex_unlock(&devlink
->lock
);
4700 mutex_unlock(&devlink
->lock
);
4701 return ERR_PTR(err
);
4703 EXPORT_SYMBOL_GPL(devlink_region_create
);
4706 * devlink_region_destroy - destroy address region
4708 * @region: devlink region to destroy
4710 void devlink_region_destroy(struct devlink_region
*region
)
4712 struct devlink
*devlink
= region
->devlink
;
4713 struct devlink_snapshot
*snapshot
, *ts
;
4715 mutex_lock(&devlink
->lock
);
4717 /* Free all snapshots of region */
4718 list_for_each_entry_safe(snapshot
, ts
, ®ion
->snapshot_list
, list
)
4719 devlink_region_snapshot_del(snapshot
);
4721 list_del(®ion
->list
);
4723 devlink_nl_region_notify(region
, NULL
, DEVLINK_CMD_REGION_DEL
);
4724 mutex_unlock(&devlink
->lock
);
4727 EXPORT_SYMBOL_GPL(devlink_region_destroy
);
4730 * devlink_region_shapshot_id_get - get snapshot ID
4732 * This callback should be called when adding a new snapshot,
4733 * Driver should use the same id for multiple snapshots taken
4734 * on multiple regions at the same time/by the same trigger.
4738 u32
devlink_region_shapshot_id_get(struct devlink
*devlink
)
4742 mutex_lock(&devlink
->lock
);
4743 id
= ++devlink
->snapshot_id
;
4744 mutex_unlock(&devlink
->lock
);
4748 EXPORT_SYMBOL_GPL(devlink_region_shapshot_id_get
);
4751 * devlink_region_snapshot_create - create a new snapshot
4752 * This will add a new snapshot of a region. The snapshot
4753 * will be stored on the region struct and can be accessed
4754 * from devlink. This is useful for future analyses of snapshots.
4755 * Multiple snapshots can be created on a region.
4756 * The @snapshot_id should be obtained using the getter function.
4758 * @devlink_region: devlink region of the snapshot
4759 * @data_len: size of snapshot data
4760 * @data: snapshot data
4761 * @snapshot_id: snapshot id to be created
4762 * @data_destructor: pointer to destructor function to free data
4764 int devlink_region_snapshot_create(struct devlink_region
*region
, u64 data_len
,
4765 u8
*data
, u32 snapshot_id
,
4766 devlink_snapshot_data_dest_t
*data_destructor
)
4768 struct devlink
*devlink
= region
->devlink
;
4769 struct devlink_snapshot
*snapshot
;
4772 mutex_lock(&devlink
->lock
);
4774 /* check if region can hold one more snapshot */
4775 if (region
->cur_snapshots
== region
->max_snapshots
) {
4780 if (devlink_region_snapshot_get_by_id(region
, snapshot_id
)) {
4785 snapshot
= kzalloc(sizeof(*snapshot
), GFP_KERNEL
);
4791 snapshot
->id
= snapshot_id
;
4792 snapshot
->region
= region
;
4793 snapshot
->data
= data
;
4794 snapshot
->data_len
= data_len
;
4795 snapshot
->data_destructor
= data_destructor
;
4797 list_add_tail(&snapshot
->list
, ®ion
->snapshot_list
);
4799 region
->cur_snapshots
++;
4801 devlink_nl_region_notify(region
, snapshot
, DEVLINK_CMD_REGION_NEW
);
4802 mutex_unlock(&devlink
->lock
);
4806 mutex_unlock(&devlink
->lock
);
4809 EXPORT_SYMBOL_GPL(devlink_region_snapshot_create
);
4811 static int __init
devlink_module_init(void)
4813 return genl_register_family(&devlink_nl_family
);
4816 static void __exit
devlink_module_exit(void)
4818 genl_unregister_family(&devlink_nl_family
);
4821 module_init(devlink_module_init
);
4822 module_exit(devlink_module_exit
);
4824 MODULE_LICENSE("GPL v2");
4825 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
4826 MODULE_DESCRIPTION("Network physical device Netlink interface");
4827 MODULE_ALIAS_GENL_FAMILY(DEVLINK_GENL_NAME
);