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