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