projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
devlink: Break parameter notification sequence to be before/after unload/load driver
[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{
d7907a2b 118 if (WARN_ON(devlink->dev))
8273fd84
JP		 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
d7907a2b 1046 if (!devlink_port->devlink)
bfcd3a46
JP		 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;
a8ecb93e 2712
a3e5e579
DL		 2713 /* Take the lock to sync with devlink_rate_nodes_destroy() */
2714 mutex_lock(&devlink->lock);
a8ecb93e
DL		 2715 list_for_each_entry(devlink_rate, &devlink->rate_list, list)
2716 if (devlink_rate_is_node(devlink_rate)) {
a3e5e579 2717 mutex_unlock(&devlink->lock);
a8ecb93e
DL		 2718 NL_SET_ERR_MSG_MOD(extack, "Rate node(s) exists.");
2719 return -EBUSY;
2720 }
a3e5e579 2721 mutex_unlock(&devlink->lock);
a8ecb93e
DL		 2722 return 0;
2723}
2724
adf200f3
JP		 2725static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
2726 struct genl_info *info)
08f4b591
OG		 2727{
2728 struct devlink *devlink = info->user_ptr[0];
2729 const struct devlink_ops *ops = devlink->ops;
98fdbea5
LR		 2730 enum devlink_eswitch_encap_mode encap_mode;
2731 u8 inline_mode;
59bfde01 2732 int err = 0;
f43e9b06 2733 u16 mode;
08f4b591 2734
59bfde01
RD		 2735 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
2736 if (!ops->eswitch_mode_set)
2737 return -EOPNOTSUPP;
2738 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
a8ecb93e
DL		 2739 err = devlink_rate_nodes_check(devlink, mode, info->extack);
2740 if (err)
2741 return err;
db7ff19e 2742 err = ops->eswitch_mode_set(devlink, mode, info->extack);
59bfde01
RD		 2743 if (err)
2744 return err;
2745 }
08f4b591 2746
59bfde01
RD		 2747 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
2748 if (!ops->eswitch_inline_mode_set)
2749 return -EOPNOTSUPP;
2750 inline_mode = nla_get_u8(
2751 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
db7ff19e
EB		 2752 err = ops->eswitch_inline_mode_set(devlink, inline_mode,
2753 info->extack);
59bfde01
RD		 2754 if (err)
2755 return err;
2756 }
f43e9b06
RD		 2757
2758 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
2759 if (!ops->eswitch_encap_mode_set)
2760 return -EOPNOTSUPP;
2761 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
db7ff19e
EB		 2762 err = ops->eswitch_encap_mode_set(devlink, encap_mode,
2763 info->extack);
f43e9b06
RD		 2764 if (err)
2765 return err;
2766 }
2767
1555d204
AS		 2768 return 0;
2769}
2770
2771int devlink_dpipe_match_put(struct sk_buff *skb,
2772 struct devlink_dpipe_match *match)
2773{
2774 struct devlink_dpipe_header *header = match->header;
2775 struct devlink_dpipe_field *field = &header->fields[match->field_id];
2776 struct nlattr *match_attr;
2777
ae0be8de 2778 match_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_MATCH);
1555d204
AS		 2779 if (!match_attr)
2780 return -EMSGSIZE;
2781
2782 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
2783 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
2784 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2785 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2786 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2787 goto nla_put_failure;
2788
2789 nla_nest_end(skb, match_attr);
2790 return 0;
2791
2792nla_put_failure:
2793 nla_nest_cancel(skb, match_attr);
2794 return -EMSGSIZE;
2795}
2796EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
2797
2798static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
2799 struct sk_buff *skb)
2800{
2801 struct nlattr *matches_attr;
2802
ae0be8de
MK		 2803 matches_attr = nla_nest_start_noflag(skb,
2804 DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
1555d204
AS		 2805 if (!matches_attr)
2806 return -EMSGSIZE;
2807
2808 if (table->table_ops->matches_dump(table->priv, skb))
2809 goto nla_put_failure;
2810
2811 nla_nest_end(skb, matches_attr);
2812 return 0;
2813
2814nla_put_failure:
2815 nla_nest_cancel(skb, matches_attr);
2816 return -EMSGSIZE;
2817}
2818
2819int devlink_dpipe_action_put(struct sk_buff *skb,
2820 struct devlink_dpipe_action *action)
2821{
2822 struct devlink_dpipe_header *header = action->header;
2823 struct devlink_dpipe_field *field = &header->fields[action->field_id];
2824 struct nlattr *action_attr;
2825
ae0be8de 2826 action_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ACTION);
1555d204
AS		 2827 if (!action_attr)
2828 return -EMSGSIZE;
2829
2830 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
2831 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
2832 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2833 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2834 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2835 goto nla_put_failure;
2836
2837 nla_nest_end(skb, action_attr);
2838 return 0;
2839
2840nla_put_failure:
2841 nla_nest_cancel(skb, action_attr);
2842 return -EMSGSIZE;
2843}
2844EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
2845
2846static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
2847 struct sk_buff *skb)
2848{
2849 struct nlattr *actions_attr;
2850
ae0be8de
MK		 2851 actions_attr = nla_nest_start_noflag(skb,
2852 DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
1555d204
AS		 2853 if (!actions_attr)
2854 return -EMSGSIZE;
2855
2856 if (table->table_ops->actions_dump(table->priv, skb))
2857 goto nla_put_failure;
2858
2859 nla_nest_end(skb, actions_attr);
2860 return 0;
2861
2862nla_put_failure:
2863 nla_nest_cancel(skb, actions_attr);
2864 return -EMSGSIZE;
2865}
2866
2867static int devlink_dpipe_table_put(struct sk_buff *skb,
2868 struct devlink_dpipe_table *table)
2869{
2870 struct nlattr *table_attr;
ffd3cdcc 2871 u64 table_size;
1555d204 2872
ffd3cdcc 2873 table_size = table->table_ops->size_get(table->priv);
ae0be8de 2874 table_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLE);
1555d204
AS		 2875 if (!table_attr)
2876 return -EMSGSIZE;
2877
2878 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
ffd3cdcc 2879 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
1555d204
AS		 2880 DEVLINK_ATTR_PAD))
2881 goto nla_put_failure;
2882 if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
2883 table->counters_enabled))
2884 goto nla_put_failure;
2885
56dc7cd0 2886 if (table->resource_valid) {
3d18e4f1
AS		 2887 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
2888 table->resource_id, DEVLINK_ATTR_PAD) ||
2889 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
2890 table->resource_units, DEVLINK_ATTR_PAD))
2891 goto nla_put_failure;
56dc7cd0 2892 }
1555d204
AS		 2893 if (devlink_dpipe_matches_put(table, skb))
2894 goto nla_put_failure;
2895
2896 if (devlink_dpipe_actions_put(table, skb))
2897 goto nla_put_failure;
2898
2899 nla_nest_end(skb, table_attr);
2900 return 0;
2901
2902nla_put_failure:
2903 nla_nest_cancel(skb, table_attr);
2904 return -EMSGSIZE;
2905}
2906
2907static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
2908 struct genl_info *info)
2909{
2910 int err;
2911
2912 if (*pskb) {
2913 err = genlmsg_reply(*pskb, info);
2914 if (err)
2915 return err;
2916 }
2917 *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2918 if (!*pskb)
2919 return -ENOMEM;
2920 return 0;
2921}
2922
2923static int devlink_dpipe_tables_fill(struct genl_info *info,
2924 enum devlink_command cmd, int flags,
2925 struct list_head *dpipe_tables,
2926 const char *table_name)
2927{
2928 struct devlink *devlink = info->user_ptr[0];
2929 struct devlink_dpipe_table *table;
2930 struct nlattr *tables_attr;
2931 struct sk_buff *skb = NULL;
2932 struct nlmsghdr *nlh;
2933 bool incomplete;
2934 void *hdr;
2935 int i;
2936 int err;
2937
2938 table = list_first_entry(dpipe_tables,
2939 struct devlink_dpipe_table, list);
2940start_again:
2941 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2942 if (err)
2943 return err;
2944
2945 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2946 &devlink_nl_family, NLM_F_MULTI, cmd);
6044bd4a
HY		 2947 if (!hdr) {
2948 nlmsg_free(skb);
1555d204 2949 return -EMSGSIZE;
6044bd4a 2950 }
1555d204
AS		 2951
2952 if (devlink_nl_put_handle(skb, devlink))
2953 goto nla_put_failure;
ae0be8de 2954 tables_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLES);
1555d204
AS		 2955 if (!tables_attr)
2956 goto nla_put_failure;
2957
2958 i = 0;
2959 incomplete = false;
2960 list_for_each_entry_from(table, dpipe_tables, list) {
2961 if (!table_name) {
2962 err = devlink_dpipe_table_put(skb, table);
2963 if (err) {
2964 if (!i)
2965 goto err_table_put;
2966 incomplete = true;
2967 break;
2968 }
2969 } else {
2970 if (!strcmp(table->name, table_name)) {
2971 err = devlink_dpipe_table_put(skb, table);
2972 if (err)
2973 break;
2974 }
2975 }
2976 i++;
2977 }
2978
2979 nla_nest_end(skb, tables_attr);
2980 genlmsg_end(skb, hdr);
2981 if (incomplete)
2982 goto start_again;
2983
2984send_done:
2985 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2986 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2987 if (!nlh) {
2988 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2989 if (err)
7fe4d6dc 2990 return err;
1555d204
AS		 2991 goto send_done;
2992 }
2993
2994 return genlmsg_reply(skb, info);
2995
2996nla_put_failure:
2997 err = -EMSGSIZE;
2998err_table_put:
1555d204
AS		 2999 nlmsg_free(skb);
3000 return err;
3001}
3002
3003static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
3004 struct genl_info *info)
3005{
3006 struct devlink *devlink = info->user_ptr[0];
3007 const char *table_name = NULL;
3008
3009 if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
3010 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3011
3012 return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
3013 &devlink->dpipe_table_list,
3014 table_name);
3015}
3016
3017static int devlink_dpipe_value_put(struct sk_buff *skb,
3018 struct devlink_dpipe_value *value)
3019{
3020 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
3021 value->value_size, value->value))
3022 return -EMSGSIZE;
3023 if (value->mask)
3024 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
3025 value->value_size, value->mask))
3026 return -EMSGSIZE;
3027 if (value->mapping_valid)
3028 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
3029 value->mapping_value))
3030 return -EMSGSIZE;
3031 return 0;
3032}
3033
3034static int devlink_dpipe_action_value_put(struct sk_buff *skb,
3035 struct devlink_dpipe_value *value)
3036{
3037 if (!value->action)
3038 return -EINVAL;
3039 if (devlink_dpipe_action_put(skb, value->action))
3040 return -EMSGSIZE;
3041 if (devlink_dpipe_value_put(skb, value))
3042 return -EMSGSIZE;
3043 return 0;
3044}
3045
3046static int devlink_dpipe_action_values_put(struct sk_buff *skb,
3047 struct devlink_dpipe_value *values,
3048 unsigned int values_count)
3049{
3050 struct nlattr *action_attr;
3051 int i;
3052 int err;
3053
3054 for (i = 0; i < values_count; i++) {
ae0be8de
MK		 3055 action_attr = nla_nest_start_noflag(skb,
3056 DEVLINK_ATTR_DPIPE_ACTION_VALUE);
1555d204
AS		 3057 if (!action_attr)
3058 return -EMSGSIZE;
3059 err = devlink_dpipe_action_value_put(skb, &values[i]);
3060 if (err)
3061 goto err_action_value_put;
3062 nla_nest_end(skb, action_attr);
3063 }
3064 return 0;
3065
3066err_action_value_put:
3067 nla_nest_cancel(skb, action_attr);
3068 return err;
3069}
3070
3071static int devlink_dpipe_match_value_put(struct sk_buff *skb,
3072 struct devlink_dpipe_value *value)
3073{
3074 if (!value->match)
3075 return -EINVAL;
3076 if (devlink_dpipe_match_put(skb, value->match))
3077 return -EMSGSIZE;
3078 if (devlink_dpipe_value_put(skb, value))
3079 return -EMSGSIZE;
3080 return 0;
3081}
3082
3083static int devlink_dpipe_match_values_put(struct sk_buff *skb,
3084 struct devlink_dpipe_value *values,
3085 unsigned int values_count)
3086{
3087 struct nlattr *match_attr;
3088 int i;
3089 int err;
3090
3091 for (i = 0; i < values_count; i++) {
ae0be8de
MK		 3092 match_attr = nla_nest_start_noflag(skb,
3093 DEVLINK_ATTR_DPIPE_MATCH_VALUE);
1555d204
AS		 3094 if (!match_attr)
3095 return -EMSGSIZE;
3096 err = devlink_dpipe_match_value_put(skb, &values[i]);
3097 if (err)
3098 goto err_match_value_put;
3099 nla_nest_end(skb, match_attr);
3100 }
3101 return 0;
3102
3103err_match_value_put:
3104 nla_nest_cancel(skb, match_attr);
3105 return err;
3106}
3107
3108static int devlink_dpipe_entry_put(struct sk_buff *skb,
3109 struct devlink_dpipe_entry *entry)
3110{
3111 struct nlattr *entry_attr, *matches_attr, *actions_attr;
3112 int err;
3113
ae0be8de 3114 entry_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ENTRY);
1555d204
AS		 3115 if (!entry_attr)
3116 return -EMSGSIZE;
3117
3118 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
3119 DEVLINK_ATTR_PAD))
3120 goto nla_put_failure;
3121 if (entry->counter_valid)
3122 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
3123 entry->counter, DEVLINK_ATTR_PAD))
3124 goto nla_put_failure;
3125
ae0be8de
MK		 3126 matches_attr = nla_nest_start_noflag(skb,
3127 DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
1555d204
AS		 3128 if (!matches_attr)
3129 goto nla_put_failure;
3130
3131 err = devlink_dpipe_match_values_put(skb, entry->match_values,
3132 entry->match_values_count);
3133 if (err) {
3134 nla_nest_cancel(skb, matches_attr);
3135 goto err_match_values_put;
3136 }
3137 nla_nest_end(skb, matches_attr);
3138
ae0be8de
MK		 3139 actions_attr = nla_nest_start_noflag(skb,
3140 DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
1555d204
AS		 3141 if (!actions_attr)
3142 goto nla_put_failure;
3143
3144 err = devlink_dpipe_action_values_put(skb, entry->action_values,
3145 entry->action_values_count);
3146 if (err) {
3147 nla_nest_cancel(skb, actions_attr);
3148 goto err_action_values_put;
3149 }
3150 nla_nest_end(skb, actions_attr);
59bfde01 3151
1555d204 3152 nla_nest_end(skb, entry_attr);
59bfde01 3153 return 0;
1555d204
AS		 3154
3155nla_put_failure:
3156 err = -EMSGSIZE;
3157err_match_values_put:
3158err_action_values_put:
3159 nla_nest_cancel(skb, entry_attr);
3160 return err;
3161}
3162
3163static struct devlink_dpipe_table *
3164devlink_dpipe_table_find(struct list_head *dpipe_tables,
2eb51c75 3165 const char *table_name, struct devlink *devlink)
1555d204
AS		 3166{
3167 struct devlink_dpipe_table *table;
2eb51c75
MB		 3168 list_for_each_entry_rcu(table, dpipe_tables, list,
3169 lockdep_is_held(&devlink->lock)) {
1555d204
AS		 3170 if (!strcmp(table->name, table_name))
3171 return table;
3172 }
3173 return NULL;
3174}
3175
3176int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
3177{
3178 struct devlink *devlink;
3179 int err;
3180
3181 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
3182 dump_ctx->info);
3183 if (err)
3184 return err;
3185
3186 dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
3187 dump_ctx->info->snd_portid,
3188 dump_ctx->info->snd_seq,
3189 &devlink_nl_family, NLM_F_MULTI,
3190 dump_ctx->cmd);
3191 if (!dump_ctx->hdr)
3192 goto nla_put_failure;
3193
3194 devlink = dump_ctx->info->user_ptr[0];
3195 if (devlink_nl_put_handle(dump_ctx->skb, devlink))
3196 goto nla_put_failure;
ae0be8de
MK		 3197 dump_ctx->nest = nla_nest_start_noflag(dump_ctx->skb,
3198 DEVLINK_ATTR_DPIPE_ENTRIES);
1555d204
AS		 3199 if (!dump_ctx->nest)
3200 goto nla_put_failure;
3201 return 0;
3202
3203nla_put_failure:
1555d204
AS		 3204 nlmsg_free(dump_ctx->skb);
3205 return -EMSGSIZE;
3206}
3207EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
3208
3209int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
3210 struct devlink_dpipe_entry *entry)
3211{
3212 return devlink_dpipe_entry_put(dump_ctx->skb, entry);
3213}
3214EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
3215
3216int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
3217{
3218 nla_nest_end(dump_ctx->skb, dump_ctx->nest);
3219 genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
3220 return 0;
3221}
3222EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
3223
35807324
AS		 3224void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
3225
3226{
3227 unsigned int value_count, value_index;
3228 struct devlink_dpipe_value *value;
3229
3230 value = entry->action_values;
3231 value_count = entry->action_values_count;
3232 for (value_index = 0; value_index < value_count; value_index++) {
3233 kfree(value[value_index].value);
3234 kfree(value[value_index].mask);
3235 }
3236
3237 value = entry->match_values;
3238 value_count = entry->match_values_count;
3239 for (value_index = 0; value_index < value_count; value_index++) {
3240 kfree(value[value_index].value);
3241 kfree(value[value_index].mask);
3242 }
3243}
3244EXPORT_SYMBOL(devlink_dpipe_entry_clear);
3245
1555d204
AS		 3246static int devlink_dpipe_entries_fill(struct genl_info *info,
3247 enum devlink_command cmd, int flags,
3248 struct devlink_dpipe_table *table)
3249{
3250 struct devlink_dpipe_dump_ctx dump_ctx;
3251 struct nlmsghdr *nlh;
3252 int err;
3253
3254 dump_ctx.skb = NULL;
3255 dump_ctx.cmd = cmd;
3256 dump_ctx.info = info;
3257
3258 err = table->table_ops->entries_dump(table->priv,
3259 table->counters_enabled,
3260 &dump_ctx);
3261 if (err)
7fe4d6dc 3262 return err;
1555d204
AS		 3263
3264send_done:
3265 nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
3266 NLMSG_DONE, 0, flags | NLM_F_MULTI);
3267 if (!nlh) {
3268 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
3269 if (err)
7fe4d6dc 3270 return err;
1555d204
AS		 3271 goto send_done;
3272 }
3273 return genlmsg_reply(dump_ctx.skb, info);
1555d204
AS		 3274}
3275
3276static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
3277 struct genl_info *info)
3278{
3279 struct devlink *devlink = info->user_ptr[0];
3280 struct devlink_dpipe_table *table;
3281 const char *table_name;
3282
3283 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
3284 return -EINVAL;
3285
3286 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3287 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2eb51c75 3288 table_name, devlink);
1555d204
AS		 3289 if (!table)
3290 return -EINVAL;
3291
3292 if (!table->table_ops->entries_dump)
3293 return -EINVAL;
3294
3295 return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
3296 0, table);
3297}
3298
3299static int devlink_dpipe_fields_put(struct sk_buff *skb,
3300 const struct devlink_dpipe_header *header)
3301{
3302 struct devlink_dpipe_field *field;
3303 struct nlattr *field_attr;
3304 int i;
3305
3306 for (i = 0; i < header->fields_count; i++) {
3307 field = &header->fields[i];
ae0be8de
MK		 3308 field_attr = nla_nest_start_noflag(skb,
3309 DEVLINK_ATTR_DPIPE_FIELD);
1555d204
AS		 3310 if (!field_attr)
3311 return -EMSGSIZE;
3312 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
3313 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
3314 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
3315 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
3316 goto nla_put_failure;
3317 nla_nest_end(skb, field_attr);
3318 }
3319 return 0;
3320
3321nla_put_failure:
3322 nla_nest_cancel(skb, field_attr);
3323 return -EMSGSIZE;
3324}
3325
3326static int devlink_dpipe_header_put(struct sk_buff *skb,
3327 struct devlink_dpipe_header *header)
3328{
3329 struct nlattr *fields_attr, *header_attr;
3330 int err;
3331
ae0be8de 3332 header_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADER);
cb6bf9cf 3333 if (!header_attr)
1555d204
AS		 3334 return -EMSGSIZE;
3335
3336 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
3337 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
3338 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
3339 goto nla_put_failure;
3340
ae0be8de
MK		 3341 fields_attr = nla_nest_start_noflag(skb,
3342 DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
1555d204
AS		 3343 if (!fields_attr)
3344 goto nla_put_failure;
3345
3346 err = devlink_dpipe_fields_put(skb, header);
3347 if (err) {
3348 nla_nest_cancel(skb, fields_attr);
3349 goto nla_put_failure;
3350 }
3351 nla_nest_end(skb, fields_attr);
3352 nla_nest_end(skb, header_attr);
3353 return 0;
3354
3355nla_put_failure:
3356 err = -EMSGSIZE;
3357 nla_nest_cancel(skb, header_attr);
3358 return err;
3359}
3360
3361static int devlink_dpipe_headers_fill(struct genl_info *info,
3362 enum devlink_command cmd, int flags,
3363 struct devlink_dpipe_headers *
3364 dpipe_headers)
3365{
3366 struct devlink *devlink = info->user_ptr[0];
3367 struct nlattr *headers_attr;
3368 struct sk_buff *skb = NULL;
3369 struct nlmsghdr *nlh;
3370 void *hdr;
3371 int i, j;
3372 int err;
3373
3374 i = 0;
3375start_again:
3376 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3377 if (err)
3378 return err;
3379
3380 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3381 &devlink_nl_family, NLM_F_MULTI, cmd);
6044bd4a
HY		 3382 if (!hdr) {
3383 nlmsg_free(skb);
1555d204 3384 return -EMSGSIZE;
6044bd4a 3385 }
1555d204
AS		 3386
3387 if (devlink_nl_put_handle(skb, devlink))
3388 goto nla_put_failure;
ae0be8de 3389 headers_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADERS);
1555d204
AS		 3390 if (!headers_attr)
3391 goto nla_put_failure;
3392
3393 j = 0;
3394 for (; i < dpipe_headers->headers_count; i++) {
3395 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
3396 if (err) {
3397 if (!j)
3398 goto err_table_put;
3399 break;
3400 }
3401 j++;
3402 }
3403 nla_nest_end(skb, headers_attr);
3404 genlmsg_end(skb, hdr);
3405 if (i != dpipe_headers->headers_count)
3406 goto start_again;
3407
3408send_done:
3409 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3410 NLMSG_DONE, 0, flags | NLM_F_MULTI);
3411 if (!nlh) {
3412 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3413 if (err)
7fe4d6dc 3414 return err;
1555d204
AS		 3415 goto send_done;
3416 }
3417 return genlmsg_reply(skb, info);
3418
3419nla_put_failure:
3420 err = -EMSGSIZE;
3421err_table_put:
1555d204
AS		 3422 nlmsg_free(skb);
3423 return err;
3424}
3425
3426static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
3427 struct genl_info *info)
3428{
3429 struct devlink *devlink = info->user_ptr[0];
3430
3431 if (!devlink->dpipe_headers)
3432 return -EOPNOTSUPP;
3433 return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
3434 0, devlink->dpipe_headers);
3435}
3436
3437static int devlink_dpipe_table_counters_set(struct devlink *devlink,
3438 const char *table_name,
3439 bool enable)
3440{
3441 struct devlink_dpipe_table *table;
3442
3443 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2eb51c75 3444 table_name, devlink);
1555d204
AS		 3445 if (!table)
3446 return -EINVAL;
3447
3448 if (table->counter_control_extern)
3449 return -EOPNOTSUPP;
3450
3451 if (!(table->counters_enabled ^ enable))
3452 return 0;
3453
3454 table->counters_enabled = enable;
3455 if (table->table_ops->counters_set_update)
3456 table->table_ops->counters_set_update(table->priv, enable);
3457 return 0;
3458}
3459
3460static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
3461 struct genl_info *info)
3462{
3463 struct devlink *devlink = info->user_ptr[0];
3464 const char *table_name;
3465 bool counters_enable;
3466
3467 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
3468 !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
3469 return -EINVAL;
3470
3471 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
3472 counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
3473
3474 return devlink_dpipe_table_counters_set(devlink, table_name,
3475 counters_enable);
08f4b591
OG		 3476}
3477
43dd7512 3478static struct devlink_resource *
d9f9b9a4
AS		 3479devlink_resource_find(struct devlink *devlink,
3480 struct devlink_resource *resource, u64 resource_id)
3481{
3482 struct list_head *resource_list;
3483
3484 if (resource)
3485 resource_list = &resource->resource_list;
3486 else
3487 resource_list = &devlink->resource_list;
3488
3489 list_for_each_entry(resource, resource_list, list) {
3490 struct devlink_resource *child_resource;
3491
3492 if (resource->id == resource_id)
3493 return resource;
3494
3495 child_resource = devlink_resource_find(devlink, resource,
3496 resource_id);
3497 if (child_resource)
3498 return child_resource;
3499 }
3500 return NULL;
3501}
3502
43dd7512
WY		 3503static void
3504devlink_resource_validate_children(struct devlink_resource *resource)
d9f9b9a4
AS		 3505{
3506 struct devlink_resource *child_resource;
3507 bool size_valid = true;
3508 u64 parts_size = 0;
3509
3510 if (list_empty(&resource->resource_list))
3511 goto out;
3512
3513 list_for_each_entry(child_resource, &resource->resource_list, list)
3514 parts_size += child_resource->size_new;
3515
b9d17175 3516 if (parts_size > resource->size_new)
d9f9b9a4
AS		 3517 size_valid = false;
3518out:
3519 resource->size_valid = size_valid;
3520}
3521
cc944ead
AS		 3522static int
3523devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
3524 struct netlink_ext_ack *extack)
3525{
3526 u64 reminder;
3527 int err = 0;
3528
0f3e9c97 3529 if (size > resource->size_params.size_max) {
cc944ead
AS		 3530 NL_SET_ERR_MSG_MOD(extack, "Size larger than maximum");
3531 err = -EINVAL;
3532 }
3533
0f3e9c97 3534 if (size < resource->size_params.size_min) {
cc944ead
AS		 3535 NL_SET_ERR_MSG_MOD(extack, "Size smaller than minimum");
3536 err = -EINVAL;
3537 }
3538
0f3e9c97 3539 div64_u64_rem(size, resource->size_params.size_granularity, &reminder);
cc944ead
AS		 3540 if (reminder) {
3541 NL_SET_ERR_MSG_MOD(extack, "Wrong granularity");
3542 err = -EINVAL;
3543 }
3544
3545 return err;
3546}
3547
d9f9b9a4
AS		 3548static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
3549 struct genl_info *info)
3550{
3551 struct devlink *devlink = info->user_ptr[0];
3552 struct devlink_resource *resource;
3553 u64 resource_id;
3554 u64 size;
3555 int err;
3556
3557 if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
3558 !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
3559 return -EINVAL;
3560 resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
3561
3562 resource = devlink_resource_find(devlink, NULL, resource_id);
3563 if (!resource)
3564 return -EINVAL;
3565
d9f9b9a4 3566 size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
cc944ead 3567 err = devlink_resource_validate_size(resource, size, info->extack);
d9f9b9a4
AS		 3568 if (err)
3569 return err;
3570
3571 resource->size_new = size;
3572 devlink_resource_validate_children(resource);
3573 if (resource->parent)
3574 devlink_resource_validate_children(resource->parent);
3575 return 0;
3576}
3577
3d18e4f1 3578static int
d9f9b9a4
AS		 3579devlink_resource_size_params_put(struct devlink_resource *resource,
3580 struct sk_buff *skb)
3581{
3582 struct devlink_resource_size_params *size_params;
3583
77d27096 3584 size_params = &resource->size_params;
3d18e4f1
AS		 3585 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
3586 size_params->size_granularity, DEVLINK_ATTR_PAD) ||
3587 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
3588 size_params->size_max, DEVLINK_ATTR_PAD) ||
3589 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
3590 size_params->size_min, DEVLINK_ATTR_PAD) ||
3591 nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
3592 return -EMSGSIZE;
3593 return 0;
d9f9b9a4
AS		 3594}
3595
fc56be47
JP		 3596static int devlink_resource_occ_put(struct devlink_resource *resource,
3597 struct sk_buff *skb)
3598{
3599 if (!resource->occ_get)
3600 return 0;
3601 return nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
3602 resource->occ_get(resource->occ_get_priv),
3603 DEVLINK_ATTR_PAD);
3604}
3605
d9f9b9a4
AS		 3606static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
3607 struct devlink_resource *resource)
3608{
3609 struct devlink_resource *child_resource;
3610 struct nlattr *child_resource_attr;
3611 struct nlattr *resource_attr;
3612
ae0be8de 3613 resource_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_RESOURCE);
d9f9b9a4
AS		 3614 if (!resource_attr)
3615 return -EMSGSIZE;
3616
3617 if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
3618 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
3619 DEVLINK_ATTR_PAD) ||
3620 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
3621 DEVLINK_ATTR_PAD))
3622 goto nla_put_failure;
3623 if (resource->size != resource->size_new)
3624 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
3625 resource->size_new, DEVLINK_ATTR_PAD);
fc56be47
JP		 3626 if (devlink_resource_occ_put(resource, skb))
3627 goto nla_put_failure;
3d18e4f1
AS		 3628 if (devlink_resource_size_params_put(resource, skb))
3629 goto nla_put_failure;
d9f9b9a4
AS		 3630 if (list_empty(&resource->resource_list))
3631 goto out;
3632
3633 if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
3634 resource->size_valid))
3635 goto nla_put_failure;
3636
ae0be8de
MK		 3637 child_resource_attr = nla_nest_start_noflag(skb,
3638 DEVLINK_ATTR_RESOURCE_LIST);
d9f9b9a4
AS		 3639 if (!child_resource_attr)
3640 goto nla_put_failure;
3641
3642 list_for_each_entry(child_resource, &resource->resource_list, list) {
3643 if (devlink_resource_put(devlink, skb, child_resource))
3644 goto resource_put_failure;
3645 }
3646
3647 nla_nest_end(skb, child_resource_attr);
3648out:
3649 nla_nest_end(skb, resource_attr);
3650 return 0;
3651
3652resource_put_failure:
3653 nla_nest_cancel(skb, child_resource_attr);
3654nla_put_failure:
3655 nla_nest_cancel(skb, resource_attr);
3656 return -EMSGSIZE;
3657}
3658
3659static int devlink_resource_fill(struct genl_info *info,
3660 enum devlink_command cmd, int flags)
3661{
3662 struct devlink *devlink = info->user_ptr[0];
3663 struct devlink_resource *resource;
3664 struct nlattr *resources_attr;
3665 struct sk_buff *skb = NULL;
3666 struct nlmsghdr *nlh;
3667 bool incomplete;
3668 void *hdr;
3669 int i;
3670 int err;
3671
3672 resource = list_first_entry(&devlink->resource_list,
3673 struct devlink_resource, list);
3674start_again:
3675 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3676 if (err)
3677 return err;
3678
3679 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
3680 &devlink_nl_family, NLM_F_MULTI, cmd);
3681 if (!hdr) {
3682 nlmsg_free(skb);
3683 return -EMSGSIZE;
3684 }
3685
3686 if (devlink_nl_put_handle(skb, devlink))
3687 goto nla_put_failure;
3688
ae0be8de
MK		 3689 resources_attr = nla_nest_start_noflag(skb,
3690 DEVLINK_ATTR_RESOURCE_LIST);
d9f9b9a4
AS		 3691 if (!resources_attr)
3692 goto nla_put_failure;
3693
3694 incomplete = false;
3695 i = 0;
3696 list_for_each_entry_from(resource, &devlink->resource_list, list) {
3697 err = devlink_resource_put(devlink, skb, resource);
3698 if (err) {
3699 if (!i)
3700 goto err_resource_put;
3701 incomplete = true;
3702 break;
3703 }
3704 i++;
3705 }
3706 nla_nest_end(skb, resources_attr);
3707 genlmsg_end(skb, hdr);
3708 if (incomplete)
3709 goto start_again;
3710send_done:
3711 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
3712 NLMSG_DONE, 0, flags | NLM_F_MULTI);
3713 if (!nlh) {
3714 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
3715 if (err)
83fe9a96 3716 return err;
d9f9b9a4
AS		 3717 goto send_done;
3718 }
3719 return genlmsg_reply(skb, info);
3720
3721nla_put_failure:
3722 err = -EMSGSIZE;
3723err_resource_put:
d9f9b9a4
AS		 3724 nlmsg_free(skb);
3725 return err;
3726}
3727
3728static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
3729 struct genl_info *info)
3730{
3731 struct devlink *devlink = info->user_ptr[0];
3732
3733 if (list_empty(&devlink->resource_list))
3734 return -EOPNOTSUPP;
3735
3736 return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
3737}
3738
2d8dc5bb
AS		 3739static int
3740devlink_resources_validate(struct devlink *devlink,
3741 struct devlink_resource *resource,
3742 struct genl_info *info)
3743{
3744 struct list_head *resource_list;
3745 int err = 0;
3746
3747 if (resource)
3748 resource_list = &resource->resource_list;
3749 else
3750 resource_list = &devlink->resource_list;
3751
3752 list_for_each_entry(resource, resource_list, list) {
3753 if (!resource->size_valid)
3754 return -EINVAL;
3755 err = devlink_resources_validate(devlink, resource, info);
3756 if (err)
3757 return err;
3758 }
3759 return err;
3760}
3761
070c63f2
JP		 3762static struct net *devlink_netns_get(struct sk_buff *skb,
3763 struct genl_info *info)
3764{
3765 struct nlattr *netns_pid_attr = info->attrs[DEVLINK_ATTR_NETNS_PID];
3766 struct nlattr *netns_fd_attr = info->attrs[DEVLINK_ATTR_NETNS_FD];
3767 struct nlattr *netns_id_attr = info->attrs[DEVLINK_ATTR_NETNS_ID];
3768 struct net *net;
3769
3770 if (!!netns_pid_attr + !!netns_fd_attr + !!netns_id_attr > 1) {
054eae82 3771 NL_SET_ERR_MSG_MOD(info->extack, "multiple netns identifying attributes specified");
070c63f2
JP		 3772 return ERR_PTR(-EINVAL);
3773 }
3774
3775 if (netns_pid_attr) {
3776 net = get_net_ns_by_pid(nla_get_u32(netns_pid_attr));
3777 } else if (netns_fd_attr) {
3778 net = get_net_ns_by_fd(nla_get_u32(netns_fd_attr));
3779 } else if (netns_id_attr) {
3780 net = get_net_ns_by_id(sock_net(skb->sk),
3781 nla_get_u32(netns_id_attr));
3782 if (!net)
3783 net = ERR_PTR(-EINVAL);
3784 } else {
3785 WARN_ON(1);
3786 net = ERR_PTR(-EINVAL);
3787 }
3788 if (IS_ERR(net)) {
054eae82 3789 NL_SET_ERR_MSG_MOD(info->extack, "Unknown network namespace");
070c63f2
JP		 3790 return ERR_PTR(-EINVAL);
3791 }
3792 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
3793 put_net(net);
3794 return ERR_PTR(-EPERM);
3795 }
3796 return net;
3797}
3798
3799static void devlink_param_notify(struct devlink *devlink,
3800 unsigned int port_index,
3801 struct devlink_param_item *param_item,
3802 enum devlink_command cmd);
3803
05a7f4a8
LR		 3804static void devlink_ns_change_notify(struct devlink *devlink,
3805 struct net *dest_net, struct net *curr_net,
3806 bool new)
070c63f2
JP		 3807{
3808 struct devlink_param_item *param_item;
05a7f4a8 3809 enum devlink_command cmd;
070c63f2
JP		 3810
3811 /* Userspace needs to be notified about devlink objects
3812 * removed from original and entering new network namespace.
3813 * The rest of the devlink objects are re-created during
3814 * reload process so the notifications are generated separatelly.
3815 */
3816
05a7f4a8
LR		 3817 if (!dest_net || net_eq(dest_net, curr_net))
3818 return;
070c63f2 3819
05a7f4a8
LR		 3820 if (new)
3821 devlink_notify(devlink, DEVLINK_CMD_NEW);
070c63f2 3822
05a7f4a8 3823 cmd = new ? DEVLINK_CMD_PARAM_NEW : DEVLINK_CMD_PARAM_DEL;
070c63f2 3824 list_for_each_entry(param_item, &devlink->param_list, list)
05a7f4a8
LR		 3825 devlink_param_notify(devlink, 0, param_item, cmd);
3826
3827 if (!new)
3828 devlink_notify(devlink, DEVLINK_CMD_DEL);
070c63f2
JP		 3829}
3830
69d56e0e 3831static bool devlink_reload_supported(const struct devlink_ops *ops)
97691069 3832{
69d56e0e 3833 return ops->reload_down && ops->reload_up;
97691069
JP		 3834}
3835
2670ac26
JP		 3836static void devlink_reload_failed_set(struct devlink *devlink,
3837 bool reload_failed)
3838{
3839 if (devlink->reload_failed == reload_failed)
3840 return;
3841 devlink->reload_failed = reload_failed;
3842 devlink_notify(devlink, DEVLINK_CMD_NEW);
3843}
3844
3845bool devlink_is_reload_failed(const struct devlink *devlink)
3846{
3847 return devlink->reload_failed;
3848}
3849EXPORT_SYMBOL_GPL(devlink_is_reload_failed);
3850
a254c264
MS		 3851static void
3852__devlink_reload_stats_update(struct devlink *devlink, u32 *reload_stats,
3853 enum devlink_reload_limit limit, u32 actions_performed)
3854{
3855 unsigned long actions = actions_performed;
3856 int stat_idx;
3857 int action;
3858
3859 for_each_set_bit(action, &actions, __DEVLINK_RELOAD_ACTION_MAX) {
3860 stat_idx = limit * __DEVLINK_RELOAD_ACTION_MAX + action;
3861 reload_stats[stat_idx]++;
3862 }
3863 devlink_notify(devlink, DEVLINK_CMD_NEW);
3864}
3865
3866static void
3867devlink_reload_stats_update(struct devlink *devlink, enum devlink_reload_limit limit,
3868 u32 actions_performed)
3869{
3870 __devlink_reload_stats_update(devlink, devlink->stats.reload_stats, limit,
3871 actions_performed);
3872}
3873
77069ba2
MS		 3874/**
3875 * devlink_remote_reload_actions_performed - Update devlink on reload actions
3876 * performed which are not a direct result of devlink reload call.
3877 *
3878 * This should be called by a driver after performing reload actions in case it was not
3879 * a result of devlink reload call. For example fw_activate was performed as a result
3880 * of devlink reload triggered fw_activate on another host.
3881 * The motivation for this function is to keep data on reload actions performed on this
3882 * function whether it was done due to direct devlink reload call or not.
3883 *
3884 * @devlink: devlink
3885 * @limit: reload limit
3886 * @actions_performed: bitmask of actions performed
3887 */
3888void devlink_remote_reload_actions_performed(struct devlink *devlink,
3889 enum devlink_reload_limit limit,
3890 u32 actions_performed)
3891{
3892 if (WARN_ON(!actions_performed ||
3893 actions_performed & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
3894 actions_performed >= BIT(__DEVLINK_RELOAD_ACTION_MAX) ||
3895 limit > DEVLINK_RELOAD_LIMIT_MAX))
3896 return;
3897
3898 __devlink_reload_stats_update(devlink, devlink->stats.remote_reload_stats, limit,
3899 actions_performed);
3900}
3901EXPORT_SYMBOL_GPL(devlink_remote_reload_actions_performed);
3902
070c63f2 3903static int devlink_reload(struct devlink *devlink, struct net *dest_net,
dc64cc7c
MS		 3904 enum devlink_reload_action action, enum devlink_reload_limit limit,
3905 u32 *actions_performed, struct netlink_ext_ack *extack)
070c63f2 3906{
77069ba2 3907 u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE];
05a7f4a8 3908 struct net *curr_net;
070c63f2
JP		 3909 int err;
3910
a0c76345
JP		 3911 if (!devlink->reload_enabled)
3912 return -EOPNOTSUPP;
3913
77069ba2
MS		 3914 memcpy(remote_reload_stats, devlink->stats.remote_reload_stats,
3915 sizeof(remote_reload_stats));
05a7f4a8
LR		 3916
3917 curr_net = devlink_net(devlink);
3918 devlink_ns_change_notify(devlink, dest_net, curr_net, false);
dc64cc7c 3919 err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack);
070c63f2
JP		 3920 if (err)
3921 return err;
3922
05a7f4a8
LR		 3923 if (dest_net && !net_eq(dest_net, curr_net))
3924 __devlink_net_set(devlink, dest_net);
070c63f2 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
05a7f4a8 3931 devlink_ns_change_notify(devlink, dest_net, curr_net, true);
ccdf0721 3932 WARN_ON(!(*actions_performed & BIT(action)));
77069ba2
MS		 3933 /* Catch driver on updating the remote action within devlink reload */
3934 WARN_ON(memcmp(remote_reload_stats, devlink->stats.remote_reload_stats,
3935 sizeof(remote_reload_stats)));
a254c264 3936 devlink_reload_stats_update(devlink, limit, *actions_performed);
ccdf0721
MS		 3937 return 0;
3938}
3939
3940static int
3941devlink_nl_reload_actions_performed_snd(struct devlink *devlink, u32 actions_performed,
3942 enum devlink_command cmd, struct genl_info *info)
3943{
3944 struct sk_buff *msg;
3945 void *hdr;
3946
3947 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3948 if (!msg)
3949 return -ENOMEM;
3950
3951 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &devlink_nl_family, 0, cmd);
3952 if (!hdr)
3953 goto free_msg;
3954
3955 if (devlink_nl_put_handle(msg, devlink))
3956 goto nla_put_failure;
3957
3958 if (nla_put_bitfield32(msg, DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED, actions_performed,
3959 actions_performed))
3960 goto nla_put_failure;
3961 genlmsg_end(msg, hdr);
3962
3963 return genlmsg_reply(msg, info);
3964
3965nla_put_failure:
3966 genlmsg_cancel(msg, hdr);
3967free_msg:
3968 nlmsg_free(msg);
3969 return -EMSGSIZE;
070c63f2
JP		 3970}
3971
2d8dc5bb
AS		 3972static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
3973{
3974 struct devlink *devlink = info->user_ptr[0];
ccdf0721 3975 enum devlink_reload_action action;
dc64cc7c 3976 enum devlink_reload_limit limit;
070c63f2 3977 struct net *dest_net = NULL;
ccdf0721 3978 u32 actions_performed;
2d8dc5bb
AS		 3979 int err;
3980
69d56e0e 3981 if (!devlink_reload_supported(devlink->ops))
2d8dc5bb
AS		 3982 return -EOPNOTSUPP;
3983
3984 err = devlink_resources_validate(devlink, NULL, info);
3985 if (err) {
3986 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
3987 return err;
3988 }
070c63f2
JP		 3989
3990 if (info->attrs[DEVLINK_ATTR_NETNS_PID] ||
3991 info->attrs[DEVLINK_ATTR_NETNS_FD] ||
3992 info->attrs[DEVLINK_ATTR_NETNS_ID]) {
3993 dest_net = devlink_netns_get(skb, info);
3994 if (IS_ERR(dest_net))
3995 return PTR_ERR(dest_net);
3996 }
3997
ccdf0721
MS		 3998 if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION])
3999 action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]);
4000 else
4001 action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT;
4002
4003 if (!devlink_reload_action_is_supported(devlink, action)) {
4004 NL_SET_ERR_MSG_MOD(info->extack,
4005 "Requested reload action is not supported by the driver");
4006 return -EOPNOTSUPP;
4007 }
4008
dc64cc7c
MS		 4009 limit = DEVLINK_RELOAD_LIMIT_UNSPEC;
4010 if (info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) {
4011 struct nla_bitfield32 limits;
4012 u32 limits_selected;
4013
4014 limits = nla_get_bitfield32(info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]);
4015 limits_selected = limits.value & limits.selector;
4016 if (!limits_selected) {
4017 NL_SET_ERR_MSG_MOD(info->extack, "Invalid limit selected");
4018 return -EINVAL;
4019 }
4020 for (limit = 0 ; limit <= DEVLINK_RELOAD_LIMIT_MAX ; limit++)
4021 if (limits_selected & BIT(limit))
4022 break;
4023 /* UAPI enables multiselection, but currently it is not used */
4024 if (limits_selected != BIT(limit)) {
4025 NL_SET_ERR_MSG_MOD(info->extack,
4026 "Multiselection of limit is not supported");
4027 return -EOPNOTSUPP;
4028 }
4029 if (!devlink_reload_limit_is_supported(devlink, limit)) {
4030 NL_SET_ERR_MSG_MOD(info->extack,
4031 "Requested limit is not supported by the driver");
4032 return -EOPNOTSUPP;
4033 }
4034 if (devlink_reload_combination_is_invalid(action, limit)) {
4035 NL_SET_ERR_MSG_MOD(info->extack,
4036 "Requested limit is invalid for this action");
4037 return -EINVAL;
4038 }
4039 }
4040 err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack);
070c63f2
JP		 4041
4042 if (dest_net)
4043 put_net(dest_net);
4044
ccdf0721
MS		 4045 if (err)
4046 return err;
4047 /* For backward compatibility generate reply only if attributes used by user */
dc64cc7c 4048 if (!info->attrs[DEVLINK_ATTR_RELOAD_ACTION] && !info->attrs[DEVLINK_ATTR_RELOAD_LIMITS])
ccdf0721
MS		 4049 return 0;
4050
4051 return devlink_nl_reload_actions_performed_snd(devlink, actions_performed,
4052 DEVLINK_CMD_RELOAD, info);
2d8dc5bb
AS		 4053}
4054
191ed202
JP		 4055static int devlink_nl_flash_update_fill(struct sk_buff *msg,
4056 struct devlink *devlink,
4057 enum devlink_command cmd,
6700acc5 4058 struct devlink_flash_notify *params)
191ed202
JP		 4059{
4060 void *hdr;
4061
4062 hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd);
4063 if (!hdr)
4064 return -EMSGSIZE;
4065
4066 if (devlink_nl_put_handle(msg, devlink))
4067 goto nla_put_failure;
4068
4069 if (cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS)
4070 goto out;
4071
6700acc5 4072 if (params->status_msg &&
191ed202 4073 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG,
6700acc5 4074 params->status_msg))
191ed202 4075 goto nla_put_failure;
6700acc5 4076 if (params->component &&
191ed202 4077 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT,
6700acc5 4078 params->component))
191ed202
JP		 4079 goto nla_put_failure;
4080 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE,
6700acc5 4081 params->done, DEVLINK_ATTR_PAD))
191ed202
JP		 4082 goto nla_put_failure;
4083 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL,
6700acc5 4084 params->total, DEVLINK_ATTR_PAD))
191ed202 4085 goto nla_put_failure;
f92970c6 4086 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT,
6700acc5 4087 params->timeout, DEVLINK_ATTR_PAD))
f92970c6 4088 goto nla_put_failure;
191ed202
JP		 4089
4090out:
4091 genlmsg_end(msg, hdr);
4092 return 0;
4093
4094nla_put_failure:
4095 genlmsg_cancel(msg, hdr);
4096 return -EMSGSIZE;
4097}
4098
4099static void __devlink_flash_update_notify(struct devlink *devlink,
4100 enum devlink_command cmd,
6700acc5 4101 struct devlink_flash_notify *params)
191ed202
JP		 4102{
4103 struct sk_buff *msg;
4104 int err;
4105
4106 WARN_ON(cmd != DEVLINK_CMD_FLASH_UPDATE &&
4107 cmd != DEVLINK_CMD_FLASH_UPDATE_END &&
4108 cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS);
4109
4110 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4111 if (!msg)
4112 return;
4113
6700acc5 4114 err = devlink_nl_flash_update_fill(msg, devlink, cmd, params);
191ed202
JP		 4115 if (err)
4116 goto out_free_msg;
4117
4118 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
4119 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
4120 return;
4121
4122out_free_msg:
4123 nlmsg_free(msg);
4124}
4125
52cc5f3a 4126static void devlink_flash_update_begin_notify(struct devlink *devlink)
191ed202 4127{
6700acc5
SN		 4128 struct devlink_flash_notify params = { 0 };
4129
191ed202
JP		 4130 __devlink_flash_update_notify(devlink,
4131 DEVLINK_CMD_FLASH_UPDATE,
6700acc5 4132 &params);
191ed202 4133}
191ed202 4134
52cc5f3a 4135static void devlink_flash_update_end_notify(struct devlink *devlink)
191ed202 4136{
6700acc5
SN		 4137 struct devlink_flash_notify params = { 0 };
4138
191ed202
JP		 4139 __devlink_flash_update_notify(devlink,
4140 DEVLINK_CMD_FLASH_UPDATE_END,
6700acc5 4141 &params);
191ed202 4142}
191ed202
JP		 4143
4144void devlink_flash_update_status_notify(struct devlink *devlink,
4145 const char *status_msg,
4146 const char *component,
4147 unsigned long done,
4148 unsigned long total)
4149{
6700acc5
SN		 4150 struct devlink_flash_notify params = {
4151 .status_msg = status_msg,
4152 .component = component,
4153 .done = done,
4154 .total = total,
4155 };
4156
191ed202
JP		 4157 __devlink_flash_update_notify(devlink,
4158 DEVLINK_CMD_FLASH_UPDATE_STATUS,
6700acc5 4159 &params);
191ed202
JP		 4160}
4161EXPORT_SYMBOL_GPL(devlink_flash_update_status_notify);
4162
f92970c6
SN		 4163void devlink_flash_update_timeout_notify(struct devlink *devlink,
4164 const char *status_msg,
4165 const char *component,
4166 unsigned long timeout)
4167{
6700acc5
SN		 4168 struct devlink_flash_notify params = {
4169 .status_msg = status_msg,
4170 .component = component,
4171 .timeout = timeout,
4172 };
4173
f92970c6
SN		 4174 __devlink_flash_update_notify(devlink,
4175 DEVLINK_CMD_FLASH_UPDATE_STATUS,
6700acc5 4176 &params);
f92970c6
SN		 4177}
4178EXPORT_SYMBOL_GPL(devlink_flash_update_timeout_notify);
4179
76726ccb
JK		 4180static int devlink_nl_cmd_flash_update(struct sk_buff *skb,
4181 struct genl_info *info)
4182{
b44cfd4f 4183 struct nlattr *nla_component, *nla_overwrite_mask, *nla_file_name;
bc75c054 4184 struct devlink_flash_update_params params = {};
76726ccb 4185 struct devlink *devlink = info->user_ptr[0];
b44cfd4f 4186 const char *file_name;
22ec3d23 4187 u32 supported_params;
b44cfd4f 4188 int ret;
76726ccb
JK		 4189
4190 if (!devlink->ops->flash_update)
4191 return -EOPNOTSUPP;
4192
4193 if (!info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME])
4194 return -EINVAL;
22ec3d23
JK		 4195
4196 supported_params = devlink->ops->supported_flash_update_params;
4197
76726ccb 4198 nla_component = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT];
22ec3d23
JK		 4199 if (nla_component) {
4200 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT)) {
4201 NL_SET_ERR_MSG_ATTR(info->extack, nla_component,
4202 "component update is not supported by this device");
4203 return -EOPNOTSUPP;
4204 }
bc75c054 4205 params.component = nla_data(nla_component);
22ec3d23 4206 }
76726ccb 4207
5d5b4128
JK		 4208 nla_overwrite_mask = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK];
4209 if (nla_overwrite_mask) {
4210 struct nla_bitfield32 sections;
4211
4212 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK)) {
4213 NL_SET_ERR_MSG_ATTR(info->extack, nla_overwrite_mask,
4214 "overwrite settings are not supported by this device");
4215 return -EOPNOTSUPP;
4216 }
4217 sections = nla_get_bitfield32(nla_overwrite_mask);
4218 params.overwrite_mask = sections.value & sections.selector;
4219 }
4220
b44cfd4f
JK		 4221 nla_file_name = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME];
4222 file_name = nla_data(nla_file_name);
4223 ret = request_firmware(&params.fw, file_name, devlink->dev);
4224 if (ret) {
4225 NL_SET_ERR_MSG_ATTR(info->extack, nla_file_name, "failed to locate the requested firmware file");
4226 return ret;
4227 }
4228
52cc5f3a 4229 devlink_flash_update_begin_notify(devlink);
b44cfd4f 4230 ret = devlink->ops->flash_update(devlink, &params, info->extack);
52cc5f3a 4231 devlink_flash_update_end_notify(devlink);
b44cfd4f
JK		 4232
4233 release_firmware(params.fw);
4234
4235 return ret;
76726ccb
JK		 4236}
4237
036467c3
MS		 4238static const struct devlink_param devlink_param_generic[] = {
4239 {
4240 .id = DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET,
4241 .name = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME,
4242 .type = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE,
4243 },
4244 {
4245 .id = DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
4246 .name = DEVLINK_PARAM_GENERIC_MAX_MACS_NAME,
4247 .type = DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE,
4248 },
f567bcda
VV		 4249 {
4250 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV,
4251 .name = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME,
4252 .type = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE,
4253 },
f6a69885
AV		 4254 {
4255 .id = DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT,
4256 .name = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME,
4257 .type = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE,
4258 },
e3b51061
VV		 4259 {
4260 .id = DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI,
4261 .name = DEVLINK_PARAM_GENERIC_IGNORE_ARI_NAME,
4262 .type = DEVLINK_PARAM_GENERIC_IGNORE_ARI_TYPE,
4263 },
f61cba42
VV		 4264 {
4265 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
4266 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_NAME,
4267 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_TYPE,
4268 },
16511789
VV		 4269 {
4270 .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
4271 .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_NAME,
4272 .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_TYPE,
4273 },
846e980a
ST		 4274 {
4275 .id = DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY,
4276 .name = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_NAME,
4277 .type = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_TYPE,
4278 },
5bbd21df
DM		 4279 {
4280 .id = DEVLINK_PARAM_GENERIC_ID_RESET_DEV_ON_DRV_PROBE,
4281 .name = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_NAME,
4282 .type = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_TYPE,
4283 },
6c7295e1
MG		 4284 {
4285 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
4286 .name = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_NAME,
4287 .type = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_TYPE,
4288 },
195d9dec
MS		 4289 {
4290 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_REMOTE_DEV_RESET,
4291 .name = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_NAME,
4292 .type = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_TYPE,
4293 },
036467c3 4294};
eabaef18
MS		 4295
4296static int devlink_param_generic_verify(const struct devlink_param *param)
4297{
4298 /* verify it match generic parameter by id and name */
4299 if (param->id > DEVLINK_PARAM_GENERIC_ID_MAX)
4300 return -EINVAL;
4301 if (strcmp(param->name, devlink_param_generic[param->id].name))
4302 return -ENOENT;
4303
4304 WARN_ON(param->type != devlink_param_generic[param->id].type);
4305
4306 return 0;
4307}
4308
4309static int devlink_param_driver_verify(const struct devlink_param *param)
4310{
4311 int i;
4312
4313 if (param->id <= DEVLINK_PARAM_GENERIC_ID_MAX)
4314 return -EINVAL;
4315 /* verify no such name in generic params */
4316 for (i = 0; i <= DEVLINK_PARAM_GENERIC_ID_MAX; i++)
4317 if (!strcmp(param->name, devlink_param_generic[i].name))
4318 return -EEXIST;
4319
4320 return 0;
4321}
4322
4323static struct devlink_param_item *
4324devlink_param_find_by_name(struct list_head *param_list,
4325 const char *param_name)
4326{
4327 struct devlink_param_item *param_item;
4328
4329 list_for_each_entry(param_item, param_list, list)
4330 if (!strcmp(param_item->param->name, param_name))
4331 return param_item;
4332 return NULL;
4333}
4334
ec01aeb1
MS		 4335static struct devlink_param_item *
4336devlink_param_find_by_id(struct list_head *param_list, u32 param_id)
4337{
4338 struct devlink_param_item *param_item;
4339
4340 list_for_each_entry(param_item, param_list, list)
4341 if (param_item->param->id == param_id)
4342 return param_item;
4343 return NULL;
4344}
4345
45f05def
MS		 4346static bool
4347devlink_param_cmode_is_supported(const struct devlink_param *param,
4348 enum devlink_param_cmode cmode)
4349{
4350 return test_bit(cmode, &param->supported_cmodes);
4351}
4352
4353static int devlink_param_get(struct devlink *devlink,
4354 const struct devlink_param *param,
4355 struct devlink_param_gset_ctx *ctx)
4356{
4357 if (!param->get)
4358 return -EOPNOTSUPP;
4359 return param->get(devlink, param->id, ctx);
4360}
4361
e3b7ca18
MS		 4362static int devlink_param_set(struct devlink *devlink,
4363 const struct devlink_param *param,
4364 struct devlink_param_gset_ctx *ctx)
4365{
4366 if (!param->set)
4367 return -EOPNOTSUPP;
4368 return param->set(devlink, param->id, ctx);
4369}
4370
45f05def
MS		 4371static int
4372devlink_param_type_to_nla_type(enum devlink_param_type param_type)
4373{
4374 switch (param_type) {
4375 case DEVLINK_PARAM_TYPE_U8:
4376 return NLA_U8;
4377 case DEVLINK_PARAM_TYPE_U16:
4378 return NLA_U16;
4379 case DEVLINK_PARAM_TYPE_U32:
4380 return NLA_U32;
4381 case DEVLINK_PARAM_TYPE_STRING:
4382 return NLA_STRING;
4383 case DEVLINK_PARAM_TYPE_BOOL:
4384 return NLA_FLAG;
4385 default:
4386 return -EINVAL;
4387 }
4388}
4389
4390static int
4391devlink_nl_param_value_fill_one(struct sk_buff *msg,
4392 enum devlink_param_type type,
4393 enum devlink_param_cmode cmode,
4394 union devlink_param_value val)
4395{
4396 struct nlattr *param_value_attr;
4397
ae0be8de
MK		 4398 param_value_attr = nla_nest_start_noflag(msg,
4399 DEVLINK_ATTR_PARAM_VALUE);
45f05def
MS		 4400 if (!param_value_attr)
4401 goto nla_put_failure;
4402
4403 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_CMODE, cmode))
4404 goto value_nest_cancel;
4405
4406 switch (type) {
4407 case DEVLINK_PARAM_TYPE_U8:
4408 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu8))
4409 goto value_nest_cancel;
4410 break;
4411 case DEVLINK_PARAM_TYPE_U16:
4412 if (nla_put_u16(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu16))
4413 goto value_nest_cancel;
4414 break;
4415 case DEVLINK_PARAM_TYPE_U32:
4416 if (nla_put_u32(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu32))
4417 goto value_nest_cancel;
4418 break;
4419 case DEVLINK_PARAM_TYPE_STRING:
4420 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_VALUE_DATA,
4421 val.vstr))
4422 goto value_nest_cancel;
4423 break;
4424 case DEVLINK_PARAM_TYPE_BOOL:
4425 if (val.vbool &&
4426 nla_put_flag(msg, DEVLINK_ATTR_PARAM_VALUE_DATA))
4427 goto value_nest_cancel;
4428 break;
4429 }
4430
4431 nla_nest_end(msg, param_value_attr);
4432 return 0;
4433
4434value_nest_cancel:
4435 nla_nest_cancel(msg, param_value_attr);
4436nla_put_failure:
4437 return -EMSGSIZE;
4438}
4439
4440static int devlink_nl_param_fill(struct sk_buff *msg, struct devlink *devlink,
f4601dee 4441 unsigned int port_index,
45f05def
MS		 4442 struct devlink_param_item *param_item,
4443 enum devlink_command cmd,
4444 u32 portid, u32 seq, int flags)
4445{
4446 union devlink_param_value param_value[DEVLINK_PARAM_CMODE_MAX + 1];
7c62cfb8 4447 bool param_value_set[DEVLINK_PARAM_CMODE_MAX + 1] = {};
45f05def
MS		 4448 const struct devlink_param *param = param_item->param;
4449 struct devlink_param_gset_ctx ctx;
4450 struct nlattr *param_values_list;
4451 struct nlattr *param_attr;
4452 int nla_type;
4453 void *hdr;
4454 int err;
4455 int i;
4456
4457 /* Get value from driver part to driverinit configuration mode */
4458 for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
4459 if (!devlink_param_cmode_is_supported(param, i))
4460 continue;
4461 if (i == DEVLINK_PARAM_CMODE_DRIVERINIT) {
4462 if (!param_item->driverinit_value_valid)
4463 return -EOPNOTSUPP;
4464 param_value[i] = param_item->driverinit_value;
4465 } else {
7c62cfb8
JP		 4466 if (!param_item->published)
4467 continue;
45f05def
MS		 4468 ctx.cmode = i;
4469 err = devlink_param_get(devlink, param, &ctx);
4470 if (err)
4471 return err;
4472 param_value[i] = ctx.val;
4473 }
7c62cfb8 4474 param_value_set[i] = true;
45f05def
MS		 4475 }
4476
4477 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4478 if (!hdr)
4479 return -EMSGSIZE;
4480
4481 if (devlink_nl_put_handle(msg, devlink))
4482 goto genlmsg_cancel;
f4601dee 4483
c1e5786d
VV		 4484 if (cmd == DEVLINK_CMD_PORT_PARAM_GET ||
4485 cmd == DEVLINK_CMD_PORT_PARAM_NEW ||
4486 cmd == DEVLINK_CMD_PORT_PARAM_DEL)
f4601dee
VV		 4487 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, port_index))
4488 goto genlmsg_cancel;
4489
ae0be8de 4490 param_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PARAM);
45f05def
MS		 4491 if (!param_attr)
4492 goto genlmsg_cancel;
4493 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_NAME, param->name))
4494 goto param_nest_cancel;
4495 if (param->generic && nla_put_flag(msg, DEVLINK_ATTR_PARAM_GENERIC))
4496 goto param_nest_cancel;
4497
4498 nla_type = devlink_param_type_to_nla_type(param->type);
4499 if (nla_type < 0)
4500 goto param_nest_cancel;
4501 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_TYPE, nla_type))
4502 goto param_nest_cancel;
4503
ae0be8de
MK		 4504 param_values_list = nla_nest_start_noflag(msg,
4505 DEVLINK_ATTR_PARAM_VALUES_LIST);
45f05def
MS		 4506 if (!param_values_list)
4507 goto param_nest_cancel;
4508
4509 for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
7c62cfb8 4510 if (!param_value_set[i])
45f05def
MS		 4511 continue;
4512 err = devlink_nl_param_value_fill_one(msg, param->type,
4513 i, param_value[i]);
4514 if (err)
4515 goto values_list_nest_cancel;
4516 }
4517
4518 nla_nest_end(msg, param_values_list);
4519 nla_nest_end(msg, param_attr);
4520 genlmsg_end(msg, hdr);
4521 return 0;
4522
4523values_list_nest_cancel:
4524 nla_nest_end(msg, param_values_list);
4525param_nest_cancel:
4526 nla_nest_cancel(msg, param_attr);
4527genlmsg_cancel:
4528 genlmsg_cancel(msg, hdr);
4529 return -EMSGSIZE;
4530}
4531
ea601e17 4532static void devlink_param_notify(struct devlink *devlink,
c1e5786d 4533 unsigned int port_index,
ea601e17
MS		 4534 struct devlink_param_item *param_item,
4535 enum devlink_command cmd)
4536{
4537 struct sk_buff *msg;
4538 int err;
4539
c1e5786d
VV		 4540 WARN_ON(cmd != DEVLINK_CMD_PARAM_NEW && cmd != DEVLINK_CMD_PARAM_DEL &&
4541 cmd != DEVLINK_CMD_PORT_PARAM_NEW &&
4542 cmd != DEVLINK_CMD_PORT_PARAM_DEL);
ea601e17
MS		 4543
4544 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4545 if (!msg)
4546 return;
c1e5786d
VV		 4547 err = devlink_nl_param_fill(msg, devlink, port_index, param_item, cmd,
4548 0, 0, 0);
ea601e17
MS		 4549 if (err) {
4550 nlmsg_free(msg);
4551 return;
4552 }
4553
4554 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
4555 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
4556}
4557
45f05def
MS		 4558static int devlink_nl_cmd_param_get_dumpit(struct sk_buff *msg,
4559 struct netlink_callback *cb)
4560{
4561 struct devlink_param_item *param_item;
4562 struct devlink *devlink;
4563 int start = cb->args[0];
4564 int idx = 0;
c62c2cfb 4565 int err = 0;
45f05def
MS		 4566
4567 mutex_lock(&devlink_mutex);
4568 list_for_each_entry(devlink, &devlink_list, list) {
4569 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4570 continue;
4571 mutex_lock(&devlink->lock);
4572 list_for_each_entry(param_item, &devlink->param_list, list) {
4573 if (idx < start) {
4574 idx++;
4575 continue;
4576 }
f4601dee 4577 err = devlink_nl_param_fill(msg, devlink, 0, param_item,
45f05def
MS		 4578 DEVLINK_CMD_PARAM_GET,
4579 NETLINK_CB(cb->skb).portid,
4580 cb->nlh->nlmsg_seq,
4581 NLM_F_MULTI);
82274d07
JK		 4582 if (err == -EOPNOTSUPP) {
4583 err = 0;
4584 } else if (err) {
45f05def
MS		 4585 mutex_unlock(&devlink->lock);
4586 goto out;
4587 }
4588 idx++;
4589 }
4590 mutex_unlock(&devlink->lock);
4591 }
4592out:
4593 mutex_unlock(&devlink_mutex);
4594
c62c2cfb
JP		 4595 if (err != -EMSGSIZE)
4596 return err;
4597
45f05def
MS		 4598 cb->args[0] = idx;
4599 return msg->len;
4600}
4601
e3b7ca18
MS		 4602static int
4603devlink_param_type_get_from_info(struct genl_info *info,
4604 enum devlink_param_type *param_type)
4605{
4606 if (!info->attrs[DEVLINK_ATTR_PARAM_TYPE])
4607 return -EINVAL;
4608
4609 switch (nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_TYPE])) {
4610 case NLA_U8:
4611 *param_type = DEVLINK_PARAM_TYPE_U8;
4612 break;
4613 case NLA_U16:
4614 *param_type = DEVLINK_PARAM_TYPE_U16;
4615 break;
4616 case NLA_U32:
4617 *param_type = DEVLINK_PARAM_TYPE_U32;
4618 break;
4619 case NLA_STRING:
4620 *param_type = DEVLINK_PARAM_TYPE_STRING;
4621 break;
4622 case NLA_FLAG:
4623 *param_type = DEVLINK_PARAM_TYPE_BOOL;
4624 break;
4625 default:
4626 return -EINVAL;
4627 }
4628
4629 return 0;
4630}
4631
4632static int
4633devlink_param_value_get_from_info(const struct devlink_param *param,
4634 struct genl_info *info,
4635 union devlink_param_value *value)
4636{
8750939b 4637 struct nlattr *param_data;
f355cfcd
MS		 4638 int len;
4639
8750939b
JK		 4640 param_data = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA];
4641
4642 if (param->type != DEVLINK_PARAM_TYPE_BOOL && !param_data)
e3b7ca18
MS		 4643 return -EINVAL;
4644
4645 switch (param->type) {
4646 case DEVLINK_PARAM_TYPE_U8:
8750939b
JK		 4647 if (nla_len(param_data) != sizeof(u8))
4648 return -EINVAL;
4649 value->vu8 = nla_get_u8(param_data);
e3b7ca18
MS		 4650 break;
4651 case DEVLINK_PARAM_TYPE_U16:
8750939b
JK		 4652 if (nla_len(param_data) != sizeof(u16))
4653 return -EINVAL;
4654 value->vu16 = nla_get_u16(param_data);
e3b7ca18
MS		 4655 break;
4656 case DEVLINK_PARAM_TYPE_U32:
8750939b
JK		 4657 if (nla_len(param_data) != sizeof(u32))
4658 return -EINVAL;
4659 value->vu32 = nla_get_u32(param_data);
e3b7ca18
MS		 4660 break;
4661 case DEVLINK_PARAM_TYPE_STRING:
8750939b
JK		 4662 len = strnlen(nla_data(param_data), nla_len(param_data));
4663 if (len == nla_len(param_data) ||
bde74ad1 4664 len >= __DEVLINK_PARAM_MAX_STRING_VALUE)
e3b7ca18 4665 return -EINVAL;
8750939b 4666 strcpy(value->vstr, nla_data(param_data));
e3b7ca18
MS		 4667 break;
4668 case DEVLINK_PARAM_TYPE_BOOL:
8750939b
JK		 4669 if (param_data && nla_len(param_data))
4670 return -EINVAL;
4671 value->vbool = nla_get_flag(param_data);
e3b7ca18
MS		 4672 break;
4673 }
4674 return 0;
4675}
4676
45f05def 4677static struct devlink_param_item *
f4601dee 4678devlink_param_get_from_info(struct list_head *param_list,
45f05def
MS		 4679 struct genl_info *info)
4680{
4681 char *param_name;
4682
4683 if (!info->attrs[DEVLINK_ATTR_PARAM_NAME])
4684 return NULL;
4685
4686 param_name = nla_data(info->attrs[DEVLINK_ATTR_PARAM_NAME]);
f4601dee 4687 return devlink_param_find_by_name(param_list, param_name);
45f05def
MS		 4688}
4689
4690static int devlink_nl_cmd_param_get_doit(struct sk_buff *skb,
4691 struct genl_info *info)
4692{
4693 struct devlink *devlink = info->user_ptr[0];
4694 struct devlink_param_item *param_item;
4695 struct sk_buff *msg;
4696 int err;
4697
f4601dee 4698 param_item = devlink_param_get_from_info(&devlink->param_list, info);
45f05def
MS		 4699 if (!param_item)
4700 return -EINVAL;
4701
4702 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4703 if (!msg)
4704 return -ENOMEM;
4705
f4601dee 4706 err = devlink_nl_param_fill(msg, devlink, 0, param_item,
45f05def
MS		 4707 DEVLINK_CMD_PARAM_GET,
4708 info->snd_portid, info->snd_seq, 0);
4709 if (err) {
4710 nlmsg_free(msg);
4711 return err;
4712 }
4713
4714 return genlmsg_reply(msg, info);
4715}
4716
9c54873b 4717static int __devlink_nl_cmd_param_set_doit(struct devlink *devlink,
c1e5786d 4718 unsigned int port_index,
9c54873b
VV		 4719 struct list_head *param_list,
4720 struct genl_info *info,
4721 enum devlink_command cmd)
e3b7ca18 4722{
e3b7ca18
MS		 4723 enum devlink_param_type param_type;
4724 struct devlink_param_gset_ctx ctx;
4725 enum devlink_param_cmode cmode;
4726 struct devlink_param_item *param_item;
4727 const struct devlink_param *param;
4728 union devlink_param_value value;
4729 int err = 0;
4730
9c54873b 4731 param_item = devlink_param_get_from_info(param_list, info);
e3b7ca18
MS		 4732 if (!param_item)
4733 return -EINVAL;
4734 param = param_item->param;
4735 err = devlink_param_type_get_from_info(info, &param_type);
4736 if (err)
4737 return err;
4738 if (param_type != param->type)
4739 return -EINVAL;
4740 err = devlink_param_value_get_from_info(param, info, &value);
4741 if (err)
4742 return err;
4743 if (param->validate) {
4744 err = param->validate(devlink, param->id, value, info->extack);
4745 if (err)
4746 return err;
4747 }
4748
4749 if (!info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE])
4750 return -EINVAL;
4751 cmode = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE]);
4752 if (!devlink_param_cmode_is_supported(param, cmode))
4753 return -EOPNOTSUPP;
4754
4755 if (cmode == DEVLINK_PARAM_CMODE_DRIVERINIT) {
1276534c
MS		 4756 if (param->type == DEVLINK_PARAM_TYPE_STRING)
4757 strcpy(param_item->driverinit_value.vstr, value.vstr);
4758 else
4759 param_item->driverinit_value = value;
e3b7ca18
MS		 4760 param_item->driverinit_value_valid = true;
4761 } else {
4762 if (!param->set)
4763 return -EOPNOTSUPP;
4764 ctx.val = value;
4765 ctx.cmode = cmode;
4766 err = devlink_param_set(devlink, param, &ctx);
4767 if (err)
4768 return err;
4769 }
4770
c1e5786d 4771 devlink_param_notify(devlink, port_index, param_item, cmd);
e3b7ca18
MS		 4772 return 0;
4773}
4774
9c54873b
VV		 4775static int devlink_nl_cmd_param_set_doit(struct sk_buff *skb,
4776 struct genl_info *info)
4777{
4778 struct devlink *devlink = info->user_ptr[0];
4779
c1e5786d 4780 return __devlink_nl_cmd_param_set_doit(devlink, 0, &devlink->param_list,
9c54873b
VV		 4781 info, DEVLINK_CMD_PARAM_NEW);
4782}
4783
eabaef18 4784static int devlink_param_register_one(struct devlink *devlink,
c1e5786d 4785 unsigned int port_index,
39e6160e 4786 struct list_head *param_list,
c1e5786d
VV		 4787 const struct devlink_param *param,
4788 enum devlink_command cmd)
eabaef18
MS		 4789{
4790 struct devlink_param_item *param_item;
4791
39e6160e 4792 if (devlink_param_find_by_name(param_list, param->name))
eabaef18
MS		 4793 return -EEXIST;
4794
4795 if (param->supported_cmodes == BIT(DEVLINK_PARAM_CMODE_DRIVERINIT))
4796 WARN_ON(param->get || param->set);
4797 else
4798 WARN_ON(!param->get || !param->set);
4799
4800 param_item = kzalloc(sizeof(*param_item), GFP_KERNEL);
4801 if (!param_item)
4802 return -ENOMEM;
4803 param_item->param = param;
4804
39e6160e 4805 list_add_tail(&param_item->list, param_list);
c1e5786d 4806 devlink_param_notify(devlink, port_index, param_item, cmd);
eabaef18
MS		 4807 return 0;
4808}
4809
4810static void devlink_param_unregister_one(struct devlink *devlink,
c1e5786d 4811 unsigned int port_index,
39e6160e 4812 struct list_head *param_list,
c1e5786d
VV		 4813 const struct devlink_param *param,
4814 enum devlink_command cmd)
eabaef18
MS		 4815{
4816 struct devlink_param_item *param_item;
4817
39e6160e 4818 param_item = devlink_param_find_by_name(param_list, param->name);
eabaef18 4819 WARN_ON(!param_item);
c1e5786d 4820 devlink_param_notify(devlink, port_index, param_item, cmd);
eabaef18
MS		 4821 list_del(&param_item->list);
4822 kfree(param_item);
4823}
4824
f4601dee
VV		 4825static int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg,
4826 struct netlink_callback *cb)
4827{
4828 struct devlink_param_item *param_item;
4829 struct devlink_port *devlink_port;
4830 struct devlink *devlink;
4831 int start = cb->args[0];
4832 int idx = 0;
c62c2cfb 4833 int err = 0;
f4601dee
VV		 4834
4835 mutex_lock(&devlink_mutex);
4836 list_for_each_entry(devlink, &devlink_list, list) {
4837 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
4838 continue;
4839 mutex_lock(&devlink->lock);
4840 list_for_each_entry(devlink_port, &devlink->port_list, list) {
4841 list_for_each_entry(param_item,
4842 &devlink_port->param_list, list) {
4843 if (idx < start) {
4844 idx++;
4845 continue;
4846 }
4847 err = devlink_nl_param_fill(msg,
4848 devlink_port->devlink,
4849 devlink_port->index, param_item,
4850 DEVLINK_CMD_PORT_PARAM_GET,
4851 NETLINK_CB(cb->skb).portid,
4852 cb->nlh->nlmsg_seq,
4853 NLM_F_MULTI);
82274d07
JK		 4854 if (err == -EOPNOTSUPP) {
4855 err = 0;
4856 } else if (err) {
f4601dee
VV		 4857 mutex_unlock(&devlink->lock);
4858 goto out;
4859 }
4860 idx++;
4861 }
4862 }
4863 mutex_unlock(&devlink->lock);
4864 }
4865out:
4866 mutex_unlock(&devlink_mutex);
4867
c62c2cfb
JP		 4868 if (err != -EMSGSIZE)
4869 return err;
4870
f4601dee
VV		 4871 cb->args[0] = idx;
4872 return msg->len;
4873}
4874
4875static int devlink_nl_cmd_port_param_get_doit(struct sk_buff *skb,
4876 struct genl_info *info)
4877{
7e238de8 4878 struct devlink_port *devlink_port = info->user_ptr[1];
f4601dee
VV		 4879 struct devlink_param_item *param_item;
4880 struct sk_buff *msg;
4881 int err;
4882
4883 param_item = devlink_param_get_from_info(&devlink_port->param_list,
4884 info);
4885 if (!param_item)
4886 return -EINVAL;
4887
4888 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4889 if (!msg)
4890 return -ENOMEM;
4891
4892 err = devlink_nl_param_fill(msg, devlink_port->devlink,
4893 devlink_port->index, param_item,
4894 DEVLINK_CMD_PORT_PARAM_GET,
4895 info->snd_portid, info->snd_seq, 0);
4896 if (err) {
4897 nlmsg_free(msg);
4898 return err;
4899 }
4900
4901 return genlmsg_reply(msg, info);
4902}
4903
9c54873b
VV		 4904static int devlink_nl_cmd_port_param_set_doit(struct sk_buff *skb,
4905 struct genl_info *info)
4906{
7e238de8 4907 struct devlink_port *devlink_port = info->user_ptr[1];
9c54873b
VV		 4908
4909 return __devlink_nl_cmd_param_set_doit(devlink_port->devlink,
c1e5786d
VV		 4910 devlink_port->index,
4911 &devlink_port->param_list, info,
4912 DEVLINK_CMD_PORT_PARAM_NEW);
9c54873b
VV		 4913}
4914
a006d467
AV		 4915static int devlink_nl_region_snapshot_id_put(struct sk_buff *msg,
4916 struct devlink *devlink,
4917 struct devlink_snapshot *snapshot)
4918{
4919 struct nlattr *snap_attr;
4920 int err;
4921
ae0be8de 4922 snap_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_SNAPSHOT);
a006d467
AV		 4923 if (!snap_attr)
4924 return -EINVAL;
4925
4926 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID, snapshot->id);
4927 if (err)
4928 goto nla_put_failure;
4929
4930 nla_nest_end(msg, snap_attr);
4931 return 0;
4932
4933nla_put_failure:
4934 nla_nest_cancel(msg, snap_attr);
4935 return err;
4936}
4937
4938static int devlink_nl_region_snapshots_id_put(struct sk_buff *msg,
4939 struct devlink *devlink,
4940 struct devlink_region *region)
4941{
4942 struct devlink_snapshot *snapshot;
4943 struct nlattr *snapshots_attr;
4944 int err;
4945
ae0be8de
MK		 4946 snapshots_attr = nla_nest_start_noflag(msg,
4947 DEVLINK_ATTR_REGION_SNAPSHOTS);
a006d467
AV		 4948 if (!snapshots_attr)
4949 return -EINVAL;
4950
4951 list_for_each_entry(snapshot, &region->snapshot_list, list) {
4952 err = devlink_nl_region_snapshot_id_put(msg, devlink, snapshot);
4953 if (err)
4954 goto nla_put_failure;
4955 }
4956
4957 nla_nest_end(msg, snapshots_attr);
4958 return 0;
4959
4960nla_put_failure:
4961 nla_nest_cancel(msg, snapshots_attr);
4962 return err;
4963}
4964
d8db7ea5
AV		 4965static int devlink_nl_region_fill(struct sk_buff *msg, struct devlink *devlink,
4966 enum devlink_command cmd, u32 portid,
4967 u32 seq, int flags,
4968 struct devlink_region *region)
4969{
4970 void *hdr;
4971 int err;
4972
4973 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
4974 if (!hdr)
4975 return -EMSGSIZE;
4976
4977 err = devlink_nl_put_handle(msg, devlink);
4978 if (err)
4979 goto nla_put_failure;
4980
6c211809
DC		 4981 if (region->port) {
4982 err = nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
4983 region->port->index);
4984 if (err)
544e7c33 4985 goto nla_put_failure;
6c211809 4986 }
544e7c33 4987
e8937681 4988 err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME, region->ops->name);
d8db7ea5
AV		 4989 if (err)
4990 goto nla_put_failure;
4991
4992 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
4993 region->size,
4994 DEVLINK_ATTR_PAD);
4995 if (err)
4996 goto nla_put_failure;
4997
a006d467
AV		 4998 err = devlink_nl_region_snapshots_id_put(msg, devlink, region);
4999 if (err)
5000 goto nla_put_failure;
5001
d8db7ea5
AV		 5002 genlmsg_end(msg, hdr);
5003 return 0;
5004
5005nla_put_failure:
5006 genlmsg_cancel(msg, hdr);
5007 return err;
5008}
5009
dd86fec7
JK		 5010static struct sk_buff *
5011devlink_nl_region_notify_build(struct devlink_region *region,
5012 struct devlink_snapshot *snapshot,
5013 enum devlink_command cmd, u32 portid, u32 seq)
866319bb
AV		 5014{
5015 struct devlink *devlink = region->devlink;
5016 struct sk_buff *msg;
5017 void *hdr;
5018 int err;
5019
866319bb
AV		 5020
5021 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5022 if (!msg)
dd86fec7 5023 return ERR_PTR(-ENOMEM);
866319bb 5024
dd86fec7
JK		 5025 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, 0, cmd);
5026 if (!hdr) {
5027 err = -EMSGSIZE;
866319bb 5028 goto out_free_msg;
dd86fec7 5029 }
866319bb
AV		 5030
5031 err = devlink_nl_put_handle(msg, devlink);
5032 if (err)
5033 goto out_cancel_msg;
5034
6c211809
DC		 5035 if (region->port) {
5036 err = nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX,
5037 region->port->index);
5038 if (err)
544e7c33 5039 goto out_cancel_msg;
6c211809 5040 }
544e7c33 5041
866319bb 5042 err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME,
e8937681 5043 region->ops->name);
866319bb
AV		 5044 if (err)
5045 goto out_cancel_msg;
5046
5047 if (snapshot) {
5048 err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID,
5049 snapshot->id);
5050 if (err)
5051 goto out_cancel_msg;
5052 } else {
5053 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
5054 region->size, DEVLINK_ATTR_PAD);
5055 if (err)
5056 goto out_cancel_msg;
5057 }
5058 genlmsg_end(msg, hdr);
5059
dd86fec7 5060 return msg;
866319bb
AV		 5061
5062out_cancel_msg:
5063 genlmsg_cancel(msg, hdr);
5064out_free_msg:
5065 nlmsg_free(msg);
dd86fec7
JK		 5066 return ERR_PTR(err);
5067}
5068
5069static void devlink_nl_region_notify(struct devlink_region *region,
5070 struct devlink_snapshot *snapshot,
5071 enum devlink_command cmd)
5072{
5073 struct devlink *devlink = region->devlink;
5074 struct sk_buff *msg;
5075
5076 WARN_ON(cmd != DEVLINK_CMD_REGION_NEW && cmd != DEVLINK_CMD_REGION_DEL);
5077
5078 msg = devlink_nl_region_notify_build(region, snapshot, cmd, 0, 0);
5079 if (IS_ERR(msg))
5080 return;
5081
5082 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
5083 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
866319bb
AV		 5084}
5085
12102436
JK		 5086/**
5087 * __devlink_snapshot_id_increment - Increment number of snapshots using an id
5088 * @devlink: devlink instance
5089 * @id: the snapshot id
5090 *
5091 * Track when a new snapshot begins using an id. Load the count for the
5092 * given id from the snapshot xarray, increment it, and store it back.
5093 *
5094 * Called when a new snapshot is created with the given id.
5095 *
5096 * The id *must* have been previously allocated by
5097 * devlink_region_snapshot_id_get().
5098 *
5099 * Returns 0 on success, or an error on failure.
5100 */
5101static int __devlink_snapshot_id_increment(struct devlink *devlink, u32 id)
5102{
5103 unsigned long count;
5104 void *p;
5105
5106 lockdep_assert_held(&devlink->lock);
5107
5108 p = xa_load(&devlink->snapshot_ids, id);
5109 if (WARN_ON(!p))
5110 return -EINVAL;
5111
5112 if (WARN_ON(!xa_is_value(p)))
5113 return -EINVAL;
5114
5115 count = xa_to_value(p);
5116 count++;
5117
5118 return xa_err(xa_store(&devlink->snapshot_ids, id, xa_mk_value(count),
5119 GFP_KERNEL));
5120}
5121
5122/**
5123 * __devlink_snapshot_id_decrement - Decrease number of snapshots using an id
5124 * @devlink: devlink instance
5125 * @id: the snapshot id
5126 *
5127 * Track when a snapshot is deleted and stops using an id. Load the count
5128 * for the given id from the snapshot xarray, decrement it, and store it
5129 * back.
5130 *
5131 * If the count reaches zero, erase this id from the xarray, freeing it
5132 * up for future re-use by devlink_region_snapshot_id_get().
5133 *
5134 * Called when a snapshot using the given id is deleted, and when the
5135 * initial allocator of the id is finished using it.
5136 */
5137static void __devlink_snapshot_id_decrement(struct devlink *devlink, u32 id)
5138{
5139 unsigned long count;
5140 void *p;
5141
5142 lockdep_assert_held(&devlink->lock);
5143
5144 p = xa_load(&devlink->snapshot_ids, id);
5145 if (WARN_ON(!p))
5146 return;
5147
5148 if (WARN_ON(!xa_is_value(p)))
5149 return;
5150
5151 count = xa_to_value(p);
5152
5153 if (count > 1) {
5154 count--;
5155 xa_store(&devlink->snapshot_ids, id, xa_mk_value(count),
5156 GFP_KERNEL);
5157 } else {
5158 /* If this was the last user, we can erase this id */
5159 xa_erase(&devlink->snapshot_ids, id);
5160 }
5161}
5162
b9a17abf
JK		 5163/**
5164 * __devlink_snapshot_id_insert - Insert a specific snapshot ID
5165 * @devlink: devlink instance
5166 * @id: the snapshot id
5167 *
5168 * Mark the given snapshot id as used by inserting a zero value into the
5169 * snapshot xarray.
5170 *
5171 * This must be called while holding the devlink instance lock. Unlike
5172 * devlink_snapshot_id_get, the initial reference count is zero, not one.
5173 * It is expected that the id will immediately be used before
5174 * releasing the devlink instance lock.
5175 *
5176 * Returns zero on success, or an error code if the snapshot id could not
5177 * be inserted.
5178 */
5179static int __devlink_snapshot_id_insert(struct devlink *devlink, u32 id)
5180{
5181 lockdep_assert_held(&devlink->lock);
5182
bd71ea60 5183 if (xa_load(&devlink->snapshot_ids, id))
b9a17abf
JK		 5184 return -EEXIST;
5185
5186 return xa_err(xa_store(&devlink->snapshot_ids, id, xa_mk_value(0),
5187 GFP_KERNEL));
5188}
5189
7000108f
JK		 5190/**
5191 * __devlink_region_snapshot_id_get - get snapshot ID
5192 * @devlink: devlink instance
7ef19d3b 5193 * @id: storage to return snapshot id
7000108f 5194 *
7ef19d3b
JK		 5195 * Allocates a new snapshot id. Returns zero on success, or a negative
5196 * error on failure. Must be called while holding the devlink instance
5197 * lock.
12102436
JK		 5198 *
5199 * Snapshot IDs are tracked using an xarray which stores the number of
5200 * users of the snapshot id.
5201 *
5202 * Note that the caller of this function counts as a 'user', in order to
5203 * avoid race conditions. The caller must release its hold on the
5204 * snapshot by using devlink_region_snapshot_id_put.
7000108f 5205 */
7ef19d3b 5206static int __devlink_region_snapshot_id_get(struct devlink *devlink, u32 *id)
7000108f
JK		 5207{
5208 lockdep_assert_held(&devlink->lock);
7ef19d3b 5209
12102436
JK		 5210 return xa_alloc(&devlink->snapshot_ids, id, xa_mk_value(1),
5211 xa_limit_32b, GFP_KERNEL);
7000108f
JK		 5212}
5213
cf80faee
JK		 5214/**
5215 * __devlink_region_snapshot_create - create a new snapshot
5216 * This will add a new snapshot of a region. The snapshot
5217 * will be stored on the region struct and can be accessed
5218 * from devlink. This is useful for future analyses of snapshots.
5219 * Multiple snapshots can be created on a region.
5220 * The @snapshot_id should be obtained using the getter function.
5221 *
5222 * Must be called only while holding the devlink instance lock.
5223 *
5224 * @region: devlink region of the snapshot
5225 * @data: snapshot data
5226 * @snapshot_id: snapshot id to be created
5227 */
5228static int
5229__devlink_region_snapshot_create(struct devlink_region *region,
5230 u8 *data, u32 snapshot_id)
5231{
5232 struct devlink *devlink = region->devlink;
5233 struct devlink_snapshot *snapshot;
12102436 5234 int err;
cf80faee
JK		 5235
5236 lockdep_assert_held(&devlink->lock);
5237
5238 /* check if region can hold one more snapshot */
5239 if (region->cur_snapshots == region->max_snapshots)
47a39f61 5240 return -ENOSPC;
cf80faee
JK		 5241
5242 if (devlink_region_snapshot_get_by_id(region, snapshot_id))
5243 return -EEXIST;
5244
5245 snapshot = kzalloc(sizeof(*snapshot), GFP_KERNEL);
5246 if (!snapshot)
5247 return -ENOMEM;
5248
12102436
JK		 5249 err = __devlink_snapshot_id_increment(devlink, snapshot_id);
5250 if (err)
5251 goto err_snapshot_id_increment;
5252
cf80faee
JK		 5253 snapshot->id = snapshot_id;
5254 snapshot->region = region;
5255 snapshot->data = data;
5256
5257 list_add_tail(&snapshot->list, &region->snapshot_list);
5258
5259 region->cur_snapshots++;
5260
5261 devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_NEW);
5262 return 0;
12102436
JK		 5263
5264err_snapshot_id_increment:
5265 kfree(snapshot);
5266 return err;
cf80faee
JK		 5267}
5268
92b49822
JP		 5269static void devlink_region_snapshot_del(struct devlink_region *region,
5270 struct devlink_snapshot *snapshot)
5271{
12102436
JK		 5272 struct devlink *devlink = region->devlink;
5273
5274 lockdep_assert_held(&devlink->lock);
5275
92b49822
JP		 5276 devlink_nl_region_notify(region, snapshot, DEVLINK_CMD_REGION_DEL);
5277 region->cur_snapshots--;
5278 list_del(&snapshot->list);
a0a09f6b 5279 region->ops->destructor(snapshot->data);
12102436 5280 __devlink_snapshot_id_decrement(devlink, snapshot->id);
92b49822
JP		 5281 kfree(snapshot);
5282}
5283
d8db7ea5
AV		 5284static int devlink_nl_cmd_region_get_doit(struct sk_buff *skb,
5285 struct genl_info *info)
5286{
5287 struct devlink *devlink = info->user_ptr[0];
544e7c33 5288 struct devlink_port *port = NULL;
d8db7ea5
AV		 5289 struct devlink_region *region;
5290 const char *region_name;
5291 struct sk_buff *msg;
544e7c33 5292 unsigned int index;
d8db7ea5
AV		 5293 int err;
5294
5295 if (!info->attrs[DEVLINK_ATTR_REGION_NAME])
5296 return -EINVAL;
5297
544e7c33
AL		 5298 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5299 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5300
5301 port = devlink_port_get_by_index(devlink, index);
5302 if (!port)
5303 return -ENODEV;
5304 }
5305
d8db7ea5 5306 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
544e7c33
AL		 5307 if (port)
5308 region = devlink_port_region_get_by_name(port, region_name);
5309 else
5310 region = devlink_region_get_by_name(devlink, region_name);
5311
d8db7ea5
AV		 5312 if (!region)
5313 return -EINVAL;
5314
5315 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5316 if (!msg)
5317 return -ENOMEM;
5318
5319 err = devlink_nl_region_fill(msg, devlink, DEVLINK_CMD_REGION_GET,
5320 info->snd_portid, info->snd_seq, 0,
5321 region);
5322 if (err) {
5323 nlmsg_free(msg);
5324 return err;
5325 }
5326
5327 return genlmsg_reply(msg, info);
5328}
5329
544e7c33
AL		 5330static int devlink_nl_cmd_region_get_port_dumpit(struct sk_buff *msg,
5331 struct netlink_callback *cb,
5332 struct devlink_port *port,
5333 int *idx,
5334 int start)
5335{
5336 struct devlink_region *region;
5337 int err = 0;
5338
5339 list_for_each_entry(region, &port->region_list, list) {
5340 if (*idx < start) {
5341 (*idx)++;
5342 continue;
5343 }
5344 err = devlink_nl_region_fill(msg, port->devlink,
5345 DEVLINK_CMD_REGION_GET,
5346 NETLINK_CB(cb->skb).portid,
5347 cb->nlh->nlmsg_seq,
5348 NLM_F_MULTI, region);
5349 if (err)
5350 goto out;
5351 (*idx)++;
5352 }
5353
5354out:
5355 return err;
5356}
5357
5358static int devlink_nl_cmd_region_get_devlink_dumpit(struct sk_buff *msg,
5359 struct netlink_callback *cb,
5360 struct devlink *devlink,
5361 int *idx,
5362 int start)
5363{
5364 struct devlink_region *region;
5365 struct devlink_port *port;
5366 int err = 0;
5367
5368 mutex_lock(&devlink->lock);
5369 list_for_each_entry(region, &devlink->region_list, list) {
5370 if (*idx < start) {
5371 (*idx)++;
5372 continue;
5373 }
5374 err = devlink_nl_region_fill(msg, devlink,
5375 DEVLINK_CMD_REGION_GET,
5376 NETLINK_CB(cb->skb).portid,
5377 cb->nlh->nlmsg_seq,
5378 NLM_F_MULTI, region);
5379 if (err)
5380 goto out;
5381 (*idx)++;
5382 }
5383
5384 list_for_each_entry(port, &devlink->port_list, list) {
5385 err = devlink_nl_cmd_region_get_port_dumpit(msg, cb, port, idx,
5386 start);
5387 if (err)
5388 goto out;
5389 }
5390
5391out:
5392 mutex_unlock(&devlink->lock);
5393 return err;
5394}
5395
d8db7ea5
AV		 5396static int devlink_nl_cmd_region_get_dumpit(struct sk_buff *msg,
5397 struct netlink_callback *cb)
5398{
d8db7ea5
AV		 5399 struct devlink *devlink;
5400 int start = cb->args[0];
5401 int idx = 0;
5402 int err;
5403
5404 mutex_lock(&devlink_mutex);
5405 list_for_each_entry(devlink, &devlink_list, list) {
5406 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5407 continue;
544e7c33
AL		 5408 err = devlink_nl_cmd_region_get_devlink_dumpit(msg, cb, devlink,
5409 &idx, start);
5410 if (err)
5411 goto out;
d8db7ea5
AV		 5412 }
5413out:
5414 mutex_unlock(&devlink_mutex);
5415 cb->args[0] = idx;
5416 return msg->len;
5417}
5418
866319bb
AV		 5419static int devlink_nl_cmd_region_del(struct sk_buff *skb,
5420 struct genl_info *info)
5421{
5422 struct devlink *devlink = info->user_ptr[0];
5423 struct devlink_snapshot *snapshot;
544e7c33 5424 struct devlink_port *port = NULL;
866319bb
AV		 5425 struct devlink_region *region;
5426 const char *region_name;
544e7c33 5427 unsigned int index;
866319bb
AV		 5428 u32 snapshot_id;
5429
5430 if (!info->attrs[DEVLINK_ATTR_REGION_NAME] ||
5431 !info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID])
5432 return -EINVAL;
5433
5434 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
5435 snapshot_id = nla_get_u32(info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
5436
544e7c33
AL		 5437 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5438 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5439
5440 port = devlink_port_get_by_index(devlink, index);
5441 if (!port)
5442 return -ENODEV;
5443 }
5444
5445 if (port)
5446 region = devlink_port_region_get_by_name(port, region_name);
5447 else
5448 region = devlink_region_get_by_name(devlink, region_name);
5449
866319bb
AV		 5450 if (!region)
5451 return -EINVAL;
5452
5453 snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
5454 if (!snapshot)
5455 return -EINVAL;
5456
92b49822 5457 devlink_region_snapshot_del(region, snapshot);
866319bb
AV		 5458 return 0;
5459}
5460
b9a17abf
JK		 5461static int
5462devlink_nl_cmd_region_new(struct sk_buff *skb, struct genl_info *info)
5463{
5464 struct devlink *devlink = info->user_ptr[0];
043b3e22 5465 struct devlink_snapshot *snapshot;
544e7c33 5466 struct devlink_port *port = NULL;
043b3e22 5467 struct nlattr *snapshot_id_attr;
b9a17abf
JK		 5468 struct devlink_region *region;
5469 const char *region_name;
544e7c33 5470 unsigned int index;
b9a17abf
JK		 5471 u32 snapshot_id;
5472 u8 *data;
5473 int err;
5474
5475 if (!info->attrs[DEVLINK_ATTR_REGION_NAME]) {
5476 NL_SET_ERR_MSG_MOD(info->extack, "No region name provided");
5477 return -EINVAL;
5478 }
5479
b9a17abf 5480 region_name = nla_data(info->attrs[DEVLINK_ATTR_REGION_NAME]);
544e7c33
AL		 5481
5482 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5483 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5484
5485 port = devlink_port_get_by_index(devlink, index);
5486 if (!port)
5487 return -ENODEV;
5488 }
5489
5490 if (port)
5491 region = devlink_port_region_get_by_name(port, region_name);
5492 else
5493 region = devlink_region_get_by_name(devlink, region_name);
5494
b9a17abf
JK		 5495 if (!region) {
5496 NL_SET_ERR_MSG_MOD(info->extack, "The requested region does not exist");
5497 return -EINVAL;
5498 }
5499
5500 if (!region->ops->snapshot) {
5501 NL_SET_ERR_MSG_MOD(info->extack, "The requested region does not support taking an immediate snapshot");
5502 return -EOPNOTSUPP;
5503 }
5504
5505 if (region->cur_snapshots == region->max_snapshots) {
5506 NL_SET_ERR_MSG_MOD(info->extack, "The region has reached the maximum number of stored snapshots");
5507 return -ENOSPC;
5508 }
5509
043b3e22
JK		 5510 snapshot_id_attr = info->attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID];
5511 if (snapshot_id_attr) {
5512 snapshot_id = nla_get_u32(snapshot_id_attr);
b9a17abf 5513
043b3e22
JK		 5514 if (devlink_region_snapshot_get_by_id(region, snapshot_id)) {
5515 NL_SET_ERR_MSG_MOD(info->extack, "The requested snapshot id is already in use");
5516 return -EEXIST;
5517 }
b9a17abf 5518
043b3e22
JK		 5519 err = __devlink_snapshot_id_insert(devlink, snapshot_id);
5520 if (err)
5521 return err;
5522 } else {
5523 err = __devlink_region_snapshot_id_get(devlink, &snapshot_id);
5524 if (err) {
5525 NL_SET_ERR_MSG_MOD(info->extack, "Failed to allocate a new snapshot id");
5526 return err;
5527 }
5528 }
b9a17abf 5529
544e7c33
AL		 5530 if (port)
5531 err = region->port_ops->snapshot(port, region->port_ops,
5532 info->extack, &data);
5533 else
5534 err = region->ops->snapshot(devlink, region->ops,
5535 info->extack, &data);
b9a17abf
JK		 5536 if (err)
5537 goto err_snapshot_capture;
5538
5539 err = __devlink_region_snapshot_create(region, data, snapshot_id);
5540 if (err)
5541 goto err_snapshot_create;
5542
043b3e22
JK		 5543 if (!snapshot_id_attr) {
5544 struct sk_buff *msg;
5545
5546 snapshot = devlink_region_snapshot_get_by_id(region,
5547 snapshot_id);
5548 if (WARN_ON(!snapshot))
5549 return -EINVAL;
5550
5551 msg = devlink_nl_region_notify_build(region, snapshot,
5552 DEVLINK_CMD_REGION_NEW,
5553 info->snd_portid,
5554 info->snd_seq);
5555 err = PTR_ERR_OR_ZERO(msg);
5556 if (err)
5557 goto err_notify;
5558
5559 err = genlmsg_reply(msg, info);
5560 if (err)
5561 goto err_notify;
5562 }
5563
b9a17abf
JK		 5564 return 0;
5565
5566err_snapshot_create:
5567 region->ops->destructor(data);
5568err_snapshot_capture:
5569 __devlink_snapshot_id_decrement(devlink, snapshot_id);
5570 return err;
043b3e22
JK		 5571
5572err_notify:
5573 devlink_region_snapshot_del(region, snapshot);
5574 return err;
b9a17abf
JK		 5575}
5576
4e54795a
AV		 5577static int devlink_nl_cmd_region_read_chunk_fill(struct sk_buff *msg,
5578 struct devlink *devlink,
5579 u8 *chunk, u32 chunk_size,
5580 u64 addr)
5581{
5582 struct nlattr *chunk_attr;
5583 int err;
5584
ae0be8de 5585 chunk_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_REGION_CHUNK);
4e54795a
AV		 5586 if (!chunk_attr)
5587 return -EINVAL;
5588
5589 err = nla_put(msg, DEVLINK_ATTR_REGION_CHUNK_DATA, chunk_size, chunk);
5590 if (err)
5591 goto nla_put_failure;
5592
5593 err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_CHUNK_ADDR, addr,
5594 DEVLINK_ATTR_PAD);
5595 if (err)
5596 goto nla_put_failure;
5597
5598 nla_nest_end(msg, chunk_attr);
5599 return 0;
5600
5601nla_put_failure:
5602 nla_nest_cancel(msg, chunk_attr);
5603 return err;
5604}
5605
5606#define DEVLINK_REGION_READ_CHUNK_SIZE 256
5607
5608static int devlink_nl_region_read_snapshot_fill(struct sk_buff *skb,
5609 struct devlink *devlink,
5610 struct devlink_region *region,
5611 struct nlattr **attrs,
5612 u64 start_offset,
5613 u64 end_offset,
4e54795a
AV		 5614 u64 *new_offset)
5615{
5616 struct devlink_snapshot *snapshot;
5617 u64 curr_offset = start_offset;
5618 u32 snapshot_id;
5619 int err = 0;
5620
5621 *new_offset = start_offset;
5622
5623 snapshot_id = nla_get_u32(attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
5624 snapshot = devlink_region_snapshot_get_by_id(region, snapshot_id);
5625 if (!snapshot)
5626 return -EINVAL;
5627
4e54795a
AV		 5628 while (curr_offset < end_offset) {
5629 u32 data_size;
5630 u8 *data;
5631
5632 if (end_offset - curr_offset < DEVLINK_REGION_READ_CHUNK_SIZE)
5633 data_size = end_offset - curr_offset;
5634 else
5635 data_size = DEVLINK_REGION_READ_CHUNK_SIZE;
5636
5637 data = &snapshot->data[curr_offset];
5638 err = devlink_nl_cmd_region_read_chunk_fill(skb, devlink,
5639 data, data_size,
5640 curr_offset);
5641 if (err)
5642 break;
5643
5644 curr_offset += data_size;
5645 }
5646 *new_offset = curr_offset;
5647
5648 return err;
5649}
5650
5651static int devlink_nl_cmd_region_read_dumpit(struct sk_buff *skb,
5652 struct netlink_callback *cb)
5653{
ee85da53 5654 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
5a46b062 5655 u64 ret_offset, start_offset, end_offset = U64_MAX;
ee85da53 5656 struct nlattr **attrs = info->attrs;
544e7c33 5657 struct devlink_port *port = NULL;
4e54795a
AV		 5658 struct devlink_region *region;
5659 struct nlattr *chunks_attr;
5660 const char *region_name;
5661 struct devlink *devlink;
544e7c33 5662 unsigned int index;
4e54795a
AV		 5663 void *hdr;
5664 int err;
5665
5666 start_offset = *((u64 *)&cb->args[0]);
5667
dac7c08f 5668 mutex_lock(&devlink_mutex);
4e54795a 5669 devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
fdd41ec2
PP		 5670 if (IS_ERR(devlink)) {
5671 err = PTR_ERR(devlink);
dac7c08f 5672 goto out_dev;
fdd41ec2 5673 }
4e54795a 5674
4e54795a
AV		 5675 mutex_lock(&devlink->lock);
5676
5677 if (!attrs[DEVLINK_ATTR_REGION_NAME] ||
fdd41ec2
PP		 5678 !attrs[DEVLINK_ATTR_REGION_SNAPSHOT_ID]) {
5679 err = -EINVAL;
4e54795a 5680 goto out_unlock;
fdd41ec2 5681 }
4e54795a 5682
544e7c33
AL		 5683 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
5684 index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
5685
5686 port = devlink_port_get_by_index(devlink, index);
0d8cb946
DC		 5687 if (!port) {
5688 err = -ENODEV;
5689 goto out_unlock;
5690 }
544e7c33
AL		 5691 }
5692
4e54795a 5693 region_name = nla_data(attrs[DEVLINK_ATTR_REGION_NAME]);
544e7c33
AL		 5694
5695 if (port)
5696 region = devlink_port_region_get_by_name(port, region_name);
5697 else
5698 region = devlink_region_get_by_name(devlink, region_name);
5699
fdd41ec2
PP		 5700 if (!region) {
5701 err = -EINVAL;
4e54795a 5702 goto out_unlock;
fdd41ec2 5703 }
4e54795a 5704
5a46b062
JK		 5705 if (attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR] &&
5706 attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]) {
5707 if (!start_offset)
5708 start_offset =
5709 nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
5710
5711 end_offset = nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_ADDR]);
5712 end_offset += nla_get_u64(attrs[DEVLINK_ATTR_REGION_CHUNK_LEN]);
5713 }
5714
5715 if (end_offset > region->size)
5716 end_offset = region->size;
5717
d5b90e99 5718 /* return 0 if there is no further data to read */
5a46b062 5719 if (start_offset == end_offset) {
d5b90e99
JK		 5720 err = 0;
5721 goto out_unlock;
5722 }
5723
4e54795a
AV		 5724 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
5725 &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI,
5726 DEVLINK_CMD_REGION_READ);
fdd41ec2
PP		 5727 if (!hdr) {
5728 err = -EMSGSIZE;
4e54795a 5729 goto out_unlock;
fdd41ec2 5730 }
4e54795a
AV		 5731
5732 err = devlink_nl_put_handle(skb, devlink);
5733 if (err)
5734 goto nla_put_failure;
5735
6c211809
DC		 5736 if (region->port) {
5737 err = nla_put_u32(skb, DEVLINK_ATTR_PORT_INDEX,
5738 region->port->index);
5739 if (err)
544e7c33 5740 goto nla_put_failure;
6c211809 5741 }
544e7c33 5742
4e54795a
AV		 5743 err = nla_put_string(skb, DEVLINK_ATTR_REGION_NAME, region_name);
5744 if (err)
5745 goto nla_put_failure;
5746
ae0be8de 5747 chunks_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_REGION_CHUNKS);
fdd41ec2
PP		 5748 if (!chunks_attr) {
5749 err = -EMSGSIZE;
4e54795a 5750 goto nla_put_failure;
fdd41ec2 5751 }
4e54795a 5752
4e54795a
AV		 5753 err = devlink_nl_region_read_snapshot_fill(skb, devlink,
5754 region, attrs,
5755 start_offset,
5a46b062 5756 end_offset, &ret_offset);
4e54795a
AV		 5757
5758 if (err && err != -EMSGSIZE)
5759 goto nla_put_failure;
5760
5761 /* Check if there was any progress done to prevent infinite loop */
fdd41ec2
PP		 5762 if (ret_offset == start_offset) {
5763 err = -EINVAL;
4e54795a 5764 goto nla_put_failure;
fdd41ec2 5765 }
4e54795a
AV		 5766
5767 *((u64 *)&cb->args[0]) = ret_offset;
5768
5769 nla_nest_end(skb, chunks_attr);
5770 genlmsg_end(skb, hdr);
5771 mutex_unlock(&devlink->lock);
5772 mutex_unlock(&devlink_mutex);
5773
5774 return skb->len;
5775
5776nla_put_failure:
5777 genlmsg_cancel(skb, hdr);
5778out_unlock:
5779 mutex_unlock(&devlink->lock);
dac7c08f 5780out_dev:
4e54795a 5781 mutex_unlock(&devlink_mutex);
fdd41ec2 5782 return err;
4e54795a
AV		 5783}
5784
f9cf2288
JK		 5785struct devlink_info_req {
5786 struct sk_buff *msg;
5787};
5788
5789int devlink_info_driver_name_put(struct devlink_info_req *req, const char *name)
5790{
5791 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME, name);
5792}
5793EXPORT_SYMBOL_GPL(devlink_info_driver_name_put);
5794
5795int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn)
5796{
5797 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn);
5798}
5799EXPORT_SYMBOL_GPL(devlink_info_serial_number_put);
5800
b5872cd0
VV		 5801int devlink_info_board_serial_number_put(struct devlink_info_req *req,
5802 const char *bsn)
5803{
5804 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER,
5805 bsn);
5806}
5807EXPORT_SYMBOL_GPL(devlink_info_board_serial_number_put);
5808
fc6fae7d
JK		 5809static int devlink_info_version_put(struct devlink_info_req *req, int attr,
5810 const char *version_name,
5811 const char *version_value)
5812{
5813 struct nlattr *nest;
5814 int err;
5815
ae0be8de 5816 nest = nla_nest_start_noflag(req->msg, attr);
fc6fae7d
JK		 5817 if (!nest)
5818 return -EMSGSIZE;
5819
5820 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME,
5821 version_name);
5822 if (err)
5823 goto nla_put_failure;
5824
5825 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE,
5826 version_value);
5827 if (err)
5828 goto nla_put_failure;
5829
5830 nla_nest_end(req->msg, nest);
5831
5832 return 0;
5833
5834nla_put_failure:
5835 nla_nest_cancel(req->msg, nest);
5836 return err;
5837}
5838
5839int devlink_info_version_fixed_put(struct devlink_info_req *req,
5840 const char *version_name,
5841 const char *version_value)
5842{
5843 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED,
5844 version_name, version_value);
5845}
5846EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put);
5847
5848int devlink_info_version_stored_put(struct devlink_info_req *req,
5849 const char *version_name,
5850 const char *version_value)
5851{
5852 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED,
5853 version_name, version_value);
5854}
5855EXPORT_SYMBOL_GPL(devlink_info_version_stored_put);
5856
5857int devlink_info_version_running_put(struct devlink_info_req *req,
5858 const char *version_name,
5859 const char *version_value)
5860{
5861 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING,
5862 version_name, version_value);
5863}
5864EXPORT_SYMBOL_GPL(devlink_info_version_running_put);
5865
f9cf2288
JK		 5866static int
5867devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink,
5868 enum devlink_command cmd, u32 portid,
5869 u32 seq, int flags, struct netlink_ext_ack *extack)
5870{
5871 struct devlink_info_req req;
5872 void *hdr;
5873 int err;
5874
5875 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
5876 if (!hdr)
5877 return -EMSGSIZE;
5878
5879 err = -EMSGSIZE;
5880 if (devlink_nl_put_handle(msg, devlink))
5881 goto err_cancel_msg;
5882
5883 req.msg = msg;
5884 err = devlink->ops->info_get(devlink, &req, extack);
5885 if (err)
5886 goto err_cancel_msg;
5887
5888 genlmsg_end(msg, hdr);
5889 return 0;
5890
5891err_cancel_msg:
5892 genlmsg_cancel(msg, hdr);
5893 return err;
5894}
5895
5896static int devlink_nl_cmd_info_get_doit(struct sk_buff *skb,
5897 struct genl_info *info)
5898{
5899 struct devlink *devlink = info->user_ptr[0];
5900 struct sk_buff *msg;
5901 int err;
5902
be6fe1d8 5903 if (!devlink->ops->info_get)
f9cf2288
JK		 5904 return -EOPNOTSUPP;
5905
5906 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5907 if (!msg)
5908 return -ENOMEM;
5909
5910 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
5911 info->snd_portid, info->snd_seq, 0,
5912 info->extack);
5913 if (err) {
5914 nlmsg_free(msg);
5915 return err;
5916 }
5917
5918 return genlmsg_reply(msg, info);
5919}
5920
5921static int devlink_nl_cmd_info_get_dumpit(struct sk_buff *msg,
5922 struct netlink_callback *cb)
5923{
5924 struct devlink *devlink;
5925 int start = cb->args[0];
5926 int idx = 0;
c62c2cfb 5927 int err = 0;
f9cf2288
JK		 5928
5929 mutex_lock(&devlink_mutex);
5930 list_for_each_entry(devlink, &devlink_list, list) {
5931 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
5932 continue;
5933 if (idx < start) {
5934 idx++;
5935 continue;
5936 }
5937
c493b09b
JP		 5938 if (!devlink->ops->info_get) {
5939 idx++;
5940 continue;
5941 }
5942
f9cf2288
JK		 5943 mutex_lock(&devlink->lock);
5944 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
5945 NETLINK_CB(cb->skb).portid,
5946 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5947 cb->extack);
5948 mutex_unlock(&devlink->lock);
82274d07
JK		 5949 if (err == -EOPNOTSUPP)
5950 err = 0;
5951 else if (err)
f9cf2288
JK		 5952 break;
5953 idx++;
5954 }
5955 mutex_unlock(&devlink_mutex);
5956
c62c2cfb
JP		 5957 if (err != -EMSGSIZE)
5958 return err;
5959
f9cf2288
JK		 5960 cb->args[0] = idx;
5961 return msg->len;
5962}
5963
1db64e87
EBE		 5964struct devlink_fmsg_item {
5965 struct list_head list;
5966 int attrtype;
5967 u8 nla_type;
5968 u16 len;
d2afb41a 5969 int value[];
1db64e87
EBE		 5970};
5971
5972struct devlink_fmsg {
5973 struct list_head item_list;
573ed90a
AL		 5974 bool putting_binary; /* This flag forces enclosing of binary data
5975 * in an array brackets. It forces using
5976 * of designated API:
5977 * devlink_fmsg_binary_pair_nest_start()
5978 * devlink_fmsg_binary_pair_nest_end()
5979 */
1db64e87
EBE		 5980};
5981
5982static struct devlink_fmsg *devlink_fmsg_alloc(void)
5983{
5984 struct devlink_fmsg *fmsg;
5985
5986 fmsg = kzalloc(sizeof(*fmsg), GFP_KERNEL);
5987 if (!fmsg)
5988 return NULL;
5989
5990 INIT_LIST_HEAD(&fmsg->item_list);
5991
5992 return fmsg;
5993}
5994
5995static void devlink_fmsg_free(struct devlink_fmsg *fmsg)
5996{
5997 struct devlink_fmsg_item *item, *tmp;
5998
5999 list_for_each_entry_safe(item, tmp, &fmsg->item_list, list) {
6000 list_del(&item->list);
6001 kfree(item);
6002 }
6003 kfree(fmsg);
6004}
6005
6006static int devlink_fmsg_nest_common(struct devlink_fmsg *fmsg,
6007 int attrtype)
6008{
6009 struct devlink_fmsg_item *item;
6010
6011 item = kzalloc(sizeof(*item), GFP_KERNEL);
6012 if (!item)
6013 return -ENOMEM;
6014
6015 item->attrtype = attrtype;
6016 list_add_tail(&item->list, &fmsg->item_list);
6017
6018 return 0;
6019}
6020
6021int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
6022{
573ed90a
AL		 6023 if (fmsg->putting_binary)
6024 return -EINVAL;
6025
1db64e87
EBE		 6026 return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
6027}
6028EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_start);
6029
6030static int devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
6031{
573ed90a
AL		 6032 if (fmsg->putting_binary)
6033 return -EINVAL;
6034
1db64e87
EBE		 6035 return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
6036}
6037
6038int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
6039{
573ed90a
AL		 6040 if (fmsg->putting_binary)
6041 return -EINVAL;
6042
1db64e87
EBE		 6043 return devlink_fmsg_nest_end(fmsg);
6044}
6045EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_end);
6046
6047#define DEVLINK_FMSG_MAX_SIZE (GENLMSG_DEFAULT_SIZE - GENL_HDRLEN - NLA_HDRLEN)
6048
6049static int devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
6050{
6051 struct devlink_fmsg_item *item;
6052
573ed90a
AL		 6053 if (fmsg->putting_binary)
6054 return -EINVAL;
6055
1db64e87
EBE		 6056 if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE)
6057 return -EMSGSIZE;
6058
6059 item = kzalloc(sizeof(*item) + strlen(name) + 1, GFP_KERNEL);
6060 if (!item)
6061 return -ENOMEM;
6062
6063 item->nla_type = NLA_NUL_STRING;
6064 item->len = strlen(name) + 1;
6065 item->attrtype = DEVLINK_ATTR_FMSG_OBJ_NAME;
6066 memcpy(&item->value, name, item->len);
6067 list_add_tail(&item->list, &fmsg->item_list);
6068
6069 return 0;
6070}
6071
6072int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
6073{
6074 int err;
6075
573ed90a
AL		 6076 if (fmsg->putting_binary)
6077 return -EINVAL;
6078
1db64e87
EBE		 6079 err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
6080 if (err)
6081 return err;
6082
6083 err = devlink_fmsg_put_name(fmsg, name);
6084 if (err)
6085 return err;
6086
6087 return 0;
6088}
6089EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_start);
6090
6091int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
6092{
573ed90a
AL		 6093 if (fmsg->putting_binary)
6094 return -EINVAL;
6095
1db64e87
EBE		 6096 return devlink_fmsg_nest_end(fmsg);
6097}
6098EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_end);
6099
6100int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
6101 const char *name)
6102{
6103 int err;
6104
573ed90a
AL		 6105 if (fmsg->putting_binary)
6106 return -EINVAL;
6107
1db64e87
EBE		 6108 err = devlink_fmsg_pair_nest_start(fmsg, name);
6109 if (err)
6110 return err;
6111
6112 err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
6113 if (err)
6114 return err;
6115
6116 return 0;
6117}
6118EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_start);
6119
6120int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
6121{
6122 int err;
6123
573ed90a
AL		 6124 if (fmsg->putting_binary)
6125 return -EINVAL;
6126
1db64e87
EBE		 6127 err = devlink_fmsg_nest_end(fmsg);
6128 if (err)
6129 return err;
6130
6131 err = devlink_fmsg_nest_end(fmsg);
6132 if (err)
6133 return err;
6134
6135 return 0;
6136}
6137EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_end);
6138
573ed90a
AL		 6139int devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
6140 const char *name)
6141{
6142 int err;
6143
6144 err = devlink_fmsg_arr_pair_nest_start(fmsg, name);
6145 if (err)
6146 return err;
6147
6148 fmsg->putting_binary = true;
6149 return err;
6150}
6151EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_start);
6152
6153int devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg)
6154{
6155 if (!fmsg->putting_binary)
6156 return -EINVAL;
6157
6158 fmsg->putting_binary = false;
6159 return devlink_fmsg_arr_pair_nest_end(fmsg);
6160}
6161EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_end);
6162
1db64e87
EBE		 6163static int devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
6164 const void *value, u16 value_len,
6165 u8 value_nla_type)
6166{
6167 struct devlink_fmsg_item *item;
6168
6169 if (value_len > DEVLINK_FMSG_MAX_SIZE)
6170 return -EMSGSIZE;
6171
6172 item = kzalloc(sizeof(*item) + value_len, GFP_KERNEL);
6173 if (!item)
6174 return -ENOMEM;
6175
6176 item->nla_type = value_nla_type;
6177 item->len = value_len;
6178 item->attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
6179 memcpy(&item->value, value, item->len);
6180 list_add_tail(&item->list, &fmsg->item_list);
6181
6182 return 0;
6183}
6184
6185int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
6186{
573ed90a
AL		 6187 if (fmsg->putting_binary)
6188 return -EINVAL;
6189
1db64e87
EBE		 6190 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
6191}
6192EXPORT_SYMBOL_GPL(devlink_fmsg_bool_put);
6193
6194int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
6195{
573ed90a
AL		 6196 if (fmsg->putting_binary)
6197 return -EINVAL;
6198
1db64e87
EBE		 6199 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
6200}
6201EXPORT_SYMBOL_GPL(devlink_fmsg_u8_put);
6202
6203int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
6204{
573ed90a
AL		 6205 if (fmsg->putting_binary)
6206 return -EINVAL;
6207
1db64e87
EBE		 6208 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
6209}
6210EXPORT_SYMBOL_GPL(devlink_fmsg_u32_put);
6211
6212int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
6213{
573ed90a
AL		 6214 if (fmsg->putting_binary)
6215 return -EINVAL;
6216
1db64e87
EBE		 6217 return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
6218}
6219EXPORT_SYMBOL_GPL(devlink_fmsg_u64_put);
6220
6221int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
6222{
573ed90a
AL		 6223 if (fmsg->putting_binary)
6224 return -EINVAL;
6225
1db64e87
EBE		 6226 return devlink_fmsg_put_value(fmsg, value, strlen(value) + 1,
6227 NLA_NUL_STRING);
6228}
6229EXPORT_SYMBOL_GPL(devlink_fmsg_string_put);
6230
573ed90a
AL		 6231int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
6232 u16 value_len)
1db64e87 6233{
573ed90a
AL		 6234 if (!fmsg->putting_binary)
6235 return -EINVAL;
6236
1db64e87
EBE		 6237 return devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
6238}
573ed90a 6239EXPORT_SYMBOL_GPL(devlink_fmsg_binary_put);
1db64e87
EBE		 6240
6241int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
6242 bool value)
6243{
6244 int err;
6245
6246 err = devlink_fmsg_pair_nest_start(fmsg, name);
6247 if (err)
6248 return err;
6249
6250 err = devlink_fmsg_bool_put(fmsg, value);
6251 if (err)
6252 return err;
6253
6254 err = devlink_fmsg_pair_nest_end(fmsg);
6255 if (err)
6256 return err;
6257
6258 return 0;
6259}
6260EXPORT_SYMBOL_GPL(devlink_fmsg_bool_pair_put);
6261
6262int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
6263 u8 value)
6264{
6265 int err;
6266
6267 err = devlink_fmsg_pair_nest_start(fmsg, name);
6268 if (err)
6269 return err;
6270
6271 err = devlink_fmsg_u8_put(fmsg, value);
6272 if (err)
6273 return err;
6274
6275 err = devlink_fmsg_pair_nest_end(fmsg);
6276 if (err)
6277 return err;
6278
6279 return 0;
6280}
6281EXPORT_SYMBOL_GPL(devlink_fmsg_u8_pair_put);
6282
6283int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
6284 u32 value)
6285{
6286 int err;
6287
6288 err = devlink_fmsg_pair_nest_start(fmsg, name);
6289 if (err)
6290 return err;
6291
6292 err = devlink_fmsg_u32_put(fmsg, value);
6293 if (err)
6294 return err;
6295
6296 err = devlink_fmsg_pair_nest_end(fmsg);
6297 if (err)
6298 return err;
6299
6300 return 0;
6301}
6302EXPORT_SYMBOL_GPL(devlink_fmsg_u32_pair_put);
6303
6304int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
6305 u64 value)
6306{
6307 int err;
6308
6309 err = devlink_fmsg_pair_nest_start(fmsg, name);
6310 if (err)
6311 return err;
6312
6313 err = devlink_fmsg_u64_put(fmsg, value);
6314 if (err)
6315 return err;
6316
6317 err = devlink_fmsg_pair_nest_end(fmsg);
6318 if (err)
6319 return err;
6320
6321 return 0;
6322}
6323EXPORT_SYMBOL_GPL(devlink_fmsg_u64_pair_put);
6324
6325int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
6326 const char *value)
6327{
6328 int err;
6329
6330 err = devlink_fmsg_pair_nest_start(fmsg, name);
6331 if (err)
6332 return err;
6333
6334 err = devlink_fmsg_string_put(fmsg, value);
6335 if (err)
6336 return err;
6337
6338 err = devlink_fmsg_pair_nest_end(fmsg);
6339 if (err)
6340 return err;
6341
6342 return 0;
6343}
6344EXPORT_SYMBOL_GPL(devlink_fmsg_string_pair_put);
6345
6346int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
e2cde864 6347 const void *value, u32 value_len)
1db64e87 6348{
e2cde864 6349 u32 data_size;
573ed90a 6350 int end_err;
e2cde864 6351 u32 offset;
1db64e87
EBE		 6352 int err;
6353
573ed90a 6354 err = devlink_fmsg_binary_pair_nest_start(fmsg, name);
1db64e87
EBE		 6355 if (err)
6356 return err;
6357
e2cde864
AL		 6358 for (offset = 0; offset < value_len; offset += data_size) {
6359 data_size = value_len - offset;
6360 if (data_size > DEVLINK_FMSG_MAX_SIZE)
6361 data_size = DEVLINK_FMSG_MAX_SIZE;
6362 err = devlink_fmsg_binary_put(fmsg, value + offset, data_size);
6363 if (err)
573ed90a
AL		 6364 break;
6365 /* Exit from loop with a break (instead of
6366 * return) to make sure putting_binary is turned off in
6367 * devlink_fmsg_binary_pair_nest_end
6368 */
e2cde864 6369 }
1db64e87 6370
573ed90a
AL		 6371 end_err = devlink_fmsg_binary_pair_nest_end(fmsg);
6372 if (end_err)
6373 err = end_err;
1db64e87 6374
573ed90a 6375 return err;
1db64e87
EBE		 6376}
6377EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_put);
6378
6379static int
6380devlink_fmsg_item_fill_type(struct devlink_fmsg_item *msg, struct sk_buff *skb)
6381{
6382 switch (msg->nla_type) {
6383 case NLA_FLAG:
6384 case NLA_U8:
6385 case NLA_U32:
6386 case NLA_U64:
6387 case NLA_NUL_STRING:
6388 case NLA_BINARY:
6389 return nla_put_u8(skb, DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE,
6390 msg->nla_type);
6391 default:
6392 return -EINVAL;
6393 }
6394}
6395
6396static int
6397devlink_fmsg_item_fill_data(struct devlink_fmsg_item *msg, struct sk_buff *skb)
6398{
6399 int attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
6400 u8 tmp;
6401
6402 switch (msg->nla_type) {
6403 case NLA_FLAG:
6404 /* Always provide flag data, regardless of its value */
6405 tmp = *(bool *) msg->value;
6406
6407 return nla_put_u8(skb, attrtype, tmp);
6408 case NLA_U8:
6409 return nla_put_u8(skb, attrtype, *(u8 *) msg->value);
6410 case NLA_U32:
6411 return nla_put_u32(skb, attrtype, *(u32 *) msg->value);
6412 case NLA_U64:
6413 return nla_put_u64_64bit(skb, attrtype, *(u64 *) msg->value,
6414 DEVLINK_ATTR_PAD);
6415 case NLA_NUL_STRING:
6416 return nla_put_string(skb, attrtype, (char *) &msg->value);
6417 case NLA_BINARY:
6418 return nla_put(skb, attrtype, msg->len, (void *) &msg->value);
6419 default:
6420 return -EINVAL;
6421 }
6422}
6423
6424static int
6425devlink_fmsg_prepare_skb(struct devlink_fmsg *fmsg, struct sk_buff *skb,
6426 int *start)
6427{
6428 struct devlink_fmsg_item *item;
6429 struct nlattr *fmsg_nlattr;
6430 int i = 0;
6431 int err;
6432
ae0be8de 6433 fmsg_nlattr = nla_nest_start_noflag(skb, DEVLINK_ATTR_FMSG);
1db64e87
EBE		 6434 if (!fmsg_nlattr)
6435 return -EMSGSIZE;
6436
6437 list_for_each_entry(item, &fmsg->item_list, list) {
6438 if (i < *start) {
6439 i++;
6440 continue;
6441 }
6442
6443 switch (item->attrtype) {
6444 case DEVLINK_ATTR_FMSG_OBJ_NEST_START:
6445 case DEVLINK_ATTR_FMSG_PAIR_NEST_START:
6446 case DEVLINK_ATTR_FMSG_ARR_NEST_START:
6447 case DEVLINK_ATTR_FMSG_NEST_END:
6448 err = nla_put_flag(skb, item->attrtype);
6449 break;
6450 case DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA:
6451 err = devlink_fmsg_item_fill_type(item, skb);
6452 if (err)
6453 break;
6454 err = devlink_fmsg_item_fill_data(item, skb);
6455 break;
6456 case DEVLINK_ATTR_FMSG_OBJ_NAME:
6457 err = nla_put_string(skb, item->attrtype,
6458 (char *) &item->value);
6459 break;
6460 default:
6461 err = -EINVAL;
6462 break;
6463 }
6464 if (!err)
6465 *start = ++i;
6466 else
6467 break;
6468 }
6469
6470 nla_nest_end(skb, fmsg_nlattr);
6471 return err;
6472}
6473
6474static int devlink_fmsg_snd(struct devlink_fmsg *fmsg,
6475 struct genl_info *info,
6476 enum devlink_command cmd, int flags)
6477{
6478 struct nlmsghdr *nlh;
6479 struct sk_buff *skb;
6480 bool last = false;
6481 int index = 0;
6482 void *hdr;
6483 int err;
6484
6485 while (!last) {
6486 int tmp_index = index;
6487
6488 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
6489 if (!skb)
6490 return -ENOMEM;
6491
6492 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
6493 &devlink_nl_family, flags | NLM_F_MULTI, cmd);
6494 if (!hdr) {
6495 err = -EMSGSIZE;
6496 goto nla_put_failure;
6497 }
6498
6499 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
6500 if (!err)
6501 last = true;
6502 else if (err != -EMSGSIZE || tmp_index == index)
6503 goto nla_put_failure;
6504
6505 genlmsg_end(skb, hdr);
6506 err = genlmsg_reply(skb, info);
6507 if (err)
6508 return err;
6509 }
6510
6511 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
6512 if (!skb)
6513 return -ENOMEM;
6514 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
6515 NLMSG_DONE, 0, flags | NLM_F_MULTI);
6516 if (!nlh) {
6517 err = -EMSGSIZE;
6518 goto nla_put_failure;
6519 }
1db64e87 6520
fde55ea7 6521 return genlmsg_reply(skb, info);
1db64e87
EBE		 6522
6523nla_put_failure:
6524 nlmsg_free(skb);
6525 return err;
6526}
6527
e44ef4e4
AL		 6528static int devlink_fmsg_dumpit(struct devlink_fmsg *fmsg, struct sk_buff *skb,
6529 struct netlink_callback *cb,
6530 enum devlink_command cmd)
6531{
6532 int index = cb->args[0];
6533 int tmp_index = index;
6534 void *hdr;
6535 int err;
6536
6537 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
6538 &devlink_nl_family, NLM_F_ACK | NLM_F_MULTI, cmd);
6539 if (!hdr) {
6540 err = -EMSGSIZE;
6541 goto nla_put_failure;
6542 }
6543
6544 err = devlink_fmsg_prepare_skb(fmsg, skb, &index);
6545 if ((err && err != -EMSGSIZE) || tmp_index == index)
6546 goto nla_put_failure;
6547
6548 cb->args[0] = index;
6549 genlmsg_end(skb, hdr);
6550 return skb->len;
6551
6552nla_put_failure:
6553 genlmsg_cancel(skb, hdr);
6554 return err;
6555}
6556
a0bdcc59
EBE		 6557struct devlink_health_reporter {
6558 struct list_head list;
6559 void *priv;
6560 const struct devlink_health_reporter_ops *ops;
6561 struct devlink *devlink;
f4f54166 6562 struct devlink_port *devlink_port;
c8e1da0b
EBE		 6563 struct devlink_fmsg *dump_fmsg;
6564 struct mutex dump_lock; /* lock parallel read/write from dump buffers */
a0bdcc59
EBE		 6565 u64 graceful_period;
6566 bool auto_recover;
48bb52c8 6567 bool auto_dump;
a0bdcc59 6568 u8 health_state;
c8e1da0b 6569 u64 dump_ts;
d279505b 6570 u64 dump_real_ts;
c8e1da0b
EBE		 6571 u64 error_count;
6572 u64 recovery_count;
6573 u64 last_recovery_ts;
b587bdaf 6574 refcount_t refcount;
c8e1da0b
EBE		 6575};
6576
a0bdcc59
EBE		 6577void *
6578devlink_health_reporter_priv(struct devlink_health_reporter *reporter)
6579{
6580 return reporter->priv;
6581}
6582EXPORT_SYMBOL_GPL(devlink_health_reporter_priv);
6583
6584static struct devlink_health_reporter *
bd821005
VT		 6585__devlink_health_reporter_find_by_name(struct list_head *reporter_list,
6586 struct mutex *list_lock,
6587 const char *reporter_name)
a0bdcc59
EBE		 6588{
6589 struct devlink_health_reporter *reporter;
6590
bd821005
VT		 6591 lockdep_assert_held(list_lock);
6592 list_for_each_entry(reporter, reporter_list, list)
a0bdcc59
EBE		 6593 if (!strcmp(reporter->ops->name, reporter_name))
6594 return reporter;
6595 return NULL;
6596}
6597
bd821005
VT		 6598static struct devlink_health_reporter *
6599devlink_health_reporter_find_by_name(struct devlink *devlink,
6600 const char *reporter_name)
6601{
6602 return __devlink_health_reporter_find_by_name(&devlink->reporter_list,
6603 &devlink->reporters_lock,
6604 reporter_name);
6605}
6606
f4f54166
VT		 6607static struct devlink_health_reporter *
6608devlink_port_health_reporter_find_by_name(struct devlink_port *devlink_port,
6609 const char *reporter_name)
6610{
6611 return __devlink_health_reporter_find_by_name(&devlink_port->reporter_list,
6612 &devlink_port->reporters_lock,
6613 reporter_name);
6614}
6615
c57544b3
VT		 6616static struct devlink_health_reporter *
6617__devlink_health_reporter_create(struct devlink *devlink,
6618 const struct devlink_health_reporter_ops *ops,
6619 u64 graceful_period, void *priv)
6620{
6621 struct devlink_health_reporter *reporter;
6622
6623 if (WARN_ON(graceful_period && !ops->recover))
6624 return ERR_PTR(-EINVAL);
6625
6626 reporter = kzalloc(sizeof(*reporter), GFP_KERNEL);
6627 if (!reporter)
6628 return ERR_PTR(-ENOMEM);
6629
6630 reporter->priv = priv;
6631 reporter->ops = ops;
6632 reporter->devlink = devlink;
6633 reporter->graceful_period = graceful_period;
6634 reporter->auto_recover = !!ops->recover;
6635 reporter->auto_dump = !!ops->dump;
6636 mutex_init(&reporter->dump_lock);
6637 refcount_set(&reporter->refcount, 1);
6638 return reporter;
6639}
6640
15c724b9
VT		 6641/**
6642 * devlink_port_health_reporter_create - create devlink health reporter for
6643 * specified port instance
6644 *
6645 * @port: devlink_port which should contain the new reporter
6646 * @ops: ops
6647 * @graceful_period: to avoid recovery loops, in msecs
6648 * @priv: priv
6649 */
6650struct devlink_health_reporter *
6651devlink_port_health_reporter_create(struct devlink_port *port,
6652 const struct devlink_health_reporter_ops *ops,
6653 u64 graceful_period, void *priv)
6654{
6655 struct devlink_health_reporter *reporter;
6656
6657 mutex_lock(&port->reporters_lock);
6658 if (__devlink_health_reporter_find_by_name(&port->reporter_list,
6659 &port->reporters_lock, ops->name)) {
6660 reporter = ERR_PTR(-EEXIST);
6661 goto unlock;
6662 }
6663
6664 reporter = __devlink_health_reporter_create(port->devlink, ops,
6665 graceful_period, priv);
6666 if (IS_ERR(reporter))
6667 goto unlock;
6668
6669 reporter->devlink_port = port;
6670 list_add_tail(&reporter->list, &port->reporter_list);
6671unlock:
6672 mutex_unlock(&port->reporters_lock);
6673 return reporter;
6674}
6675EXPORT_SYMBOL_GPL(devlink_port_health_reporter_create);
6676
a0bdcc59
EBE		 6677/**
6678 * devlink_health_reporter_create - create devlink health reporter
6679 *
6680 * @devlink: devlink
6681 * @ops: ops
6682 * @graceful_period: to avoid recovery loops, in msecs
a0bdcc59
EBE		 6683 * @priv: priv
6684 */
6685struct devlink_health_reporter *
6686devlink_health_reporter_create(struct devlink *devlink,
6687 const struct devlink_health_reporter_ops *ops,
ba7d16c7 6688 u64 graceful_period, void *priv)
a0bdcc59
EBE		 6689{
6690 struct devlink_health_reporter *reporter;
6691
b587bdaf 6692 mutex_lock(&devlink->reporters_lock);
a0bdcc59
EBE		 6693 if (devlink_health_reporter_find_by_name(devlink, ops->name)) {
6694 reporter = ERR_PTR(-EEXIST);
6695 goto unlock;
6696 }
6697
c57544b3
VT		 6698 reporter = __devlink_health_reporter_create(devlink, ops,
6699 graceful_period, priv);
6700 if (IS_ERR(reporter))
a0bdcc59 6701 goto unlock;
a0bdcc59 6702
a0bdcc59
EBE		 6703 list_add_tail(&reporter->list, &devlink->reporter_list);
6704unlock:
b587bdaf 6705 mutex_unlock(&devlink->reporters_lock);
a0bdcc59
EBE		 6706 return reporter;
6707}
6708EXPORT_SYMBOL_GPL(devlink_health_reporter_create);
6709
3c5584bf
VT		 6710static void
6711devlink_health_reporter_free(struct devlink_health_reporter *reporter)
6712{
6713 mutex_destroy(&reporter->dump_lock);
6714 if (reporter->dump_fmsg)
6715 devlink_fmsg_free(reporter->dump_fmsg);
6716 kfree(reporter);
6717}
6718
6719static void
6720devlink_health_reporter_put(struct devlink_health_reporter *reporter)
6721{
6722 if (refcount_dec_and_test(&reporter->refcount))
6723 devlink_health_reporter_free(reporter);
6724}
6725
6726static void
6727__devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
6728{
6729 list_del(&reporter->list);
6730 devlink_health_reporter_put(reporter);
6731}
6732
a0bdcc59
EBE		 6733/**
6734 * devlink_health_reporter_destroy - destroy devlink health reporter
6735 *
6736 * @reporter: devlink health reporter to destroy
6737 */
6738void
6739devlink_health_reporter_destroy(struct devlink_health_reporter *reporter)
6740{
5d037b4d
IS		 6741 struct mutex *lock = &reporter->devlink->reporters_lock;
6742
6743 mutex_lock(lock);
3c5584bf 6744 __devlink_health_reporter_destroy(reporter);
5d037b4d 6745 mutex_unlock(lock);
a0bdcc59
EBE		 6746}
6747EXPORT_SYMBOL_GPL(devlink_health_reporter_destroy);
6748
15c724b9
VT		 6749/**
6750 * devlink_port_health_reporter_destroy - destroy devlink port health reporter
6751 *
6752 * @reporter: devlink health reporter to destroy
6753 */
6754void
6755devlink_port_health_reporter_destroy(struct devlink_health_reporter *reporter)
6756{
5d037b4d
IS		 6757 struct mutex *lock = &reporter->devlink_port->reporters_lock;
6758
6759 mutex_lock(lock);
15c724b9 6760 __devlink_health_reporter_destroy(reporter);
5d037b4d 6761 mutex_unlock(lock);
15c724b9
VT		 6762}
6763EXPORT_SYMBOL_GPL(devlink_port_health_reporter_destroy);
6764
6ec8b6cd
MS		 6765static int
6766devlink_nl_health_reporter_fill(struct sk_buff *msg,
6767 struct devlink *devlink,
6768 struct devlink_health_reporter *reporter,
6769 enum devlink_command cmd, u32 portid,
6770 u32 seq, int flags)
6771{
6772 struct nlattr *reporter_attr;
6773 void *hdr;
6774
6775 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
6776 if (!hdr)
6777 return -EMSGSIZE;
6778
6779 if (devlink_nl_put_handle(msg, devlink))
6780 goto genlmsg_cancel;
6781
f4f54166
VT		 6782 if (reporter->devlink_port) {
6783 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, reporter->devlink_port->index))
6784 goto genlmsg_cancel;
6785 }
6ec8b6cd
MS		 6786 reporter_attr = nla_nest_start_noflag(msg,
6787 DEVLINK_ATTR_HEALTH_REPORTER);
6788 if (!reporter_attr)
6789 goto genlmsg_cancel;
6790 if (nla_put_string(msg, DEVLINK_ATTR_HEALTH_REPORTER_NAME,
6791 reporter->ops->name))
6792 goto reporter_nest_cancel;
6793 if (nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_STATE,
6794 reporter->health_state))
6795 goto reporter_nest_cancel;
6796 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT,
6797 reporter->error_count, DEVLINK_ATTR_PAD))
6798 goto reporter_nest_cancel;
6799 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT,
6800 reporter->recovery_count, DEVLINK_ATTR_PAD))
6801 goto reporter_nest_cancel;
6802 if (reporter->ops->recover &&
6803 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD,
6804 reporter->graceful_period,
6805 DEVLINK_ATTR_PAD))
6806 goto reporter_nest_cancel;
6807 if (reporter->ops->recover &&
6808 nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER,
6809 reporter->auto_recover))
6810 goto reporter_nest_cancel;
6811 if (reporter->dump_fmsg &&
6812 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS,
6813 jiffies_to_msecs(reporter->dump_ts),
6814 DEVLINK_ATTR_PAD))
6815 goto reporter_nest_cancel;
6816 if (reporter->dump_fmsg &&
6817 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS,
6818 reporter->dump_real_ts, DEVLINK_ATTR_PAD))
6819 goto reporter_nest_cancel;
48bb52c8
EBE		 6820 if (reporter->ops->dump &&
6821 nla_put_u8(msg, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP,
6822 reporter->auto_dump))
6823 goto reporter_nest_cancel;
6ec8b6cd
MS		 6824
6825 nla_nest_end(msg, reporter_attr);
6826 genlmsg_end(msg, hdr);
6827 return 0;
6828
6829reporter_nest_cancel:
6830 nla_nest_end(msg, reporter_attr);
6831genlmsg_cancel:
6832 genlmsg_cancel(msg, hdr);
6833 return -EMSGSIZE;
6834}
6835
6836static void devlink_recover_notify(struct devlink_health_reporter *reporter,
6837 enum devlink_command cmd)
6838{
6839 struct sk_buff *msg;
6840 int err;
6841
6842 WARN_ON(cmd != DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
6843
6844 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6845 if (!msg)
6846 return;
6847
6848 err = devlink_nl_health_reporter_fill(msg, reporter->devlink,
6849 reporter, cmd, 0, 0, 0);
6850 if (err) {
6851 nlmsg_free(msg);
6852 return;
6853 }
6854
6855 genlmsg_multicast_netns(&devlink_nl_family,
6856 devlink_net(reporter->devlink),
6857 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
6858}
6859
6181e5cb
VG		 6860void
6861devlink_health_reporter_recovery_done(struct devlink_health_reporter *reporter)
6862{
6863 reporter->recovery_count++;
6864 reporter->last_recovery_ts = jiffies;
6865}
6866EXPORT_SYMBOL_GPL(devlink_health_reporter_recovery_done);
6867
c8e1da0b
EBE		 6868static int
6869devlink_health_reporter_recover(struct devlink_health_reporter *reporter,
e7a98105 6870 void *priv_ctx, struct netlink_ext_ack *extack)
c8e1da0b
EBE		 6871{
6872 int err;
6873
40281820
JP		 6874 if (reporter->health_state == DEVLINK_HEALTH_REPORTER_STATE_HEALTHY)
6875 return 0;
6876
c8e1da0b
EBE		 6877 if (!reporter->ops->recover)
6878 return -EOPNOTSUPP;
6879
e7a98105 6880 err = reporter->ops->recover(reporter, priv_ctx, extack);
c8e1da0b
EBE		 6881 if (err)
6882 return err;
6883
6181e5cb 6884 devlink_health_reporter_recovery_done(reporter);
c8e1da0b 6885 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_HEALTHY;
6ec8b6cd 6886 devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
c8e1da0b
EBE		 6887
6888 return 0;
6889}
6890
6891static void
6892devlink_health_dump_clear(struct devlink_health_reporter *reporter)
6893{
6894 if (!reporter->dump_fmsg)
6895 return;
6896 devlink_fmsg_free(reporter->dump_fmsg);
6897 reporter->dump_fmsg = NULL;
6898}
6899
6900static int devlink_health_do_dump(struct devlink_health_reporter *reporter,
e7a98105
JP		 6901 void *priv_ctx,
6902 struct netlink_ext_ack *extack)
c8e1da0b
EBE		 6903{
6904 int err;
6905
6906 if (!reporter->ops->dump)
6907 return 0;
6908
6909 if (reporter->dump_fmsg)
6910 return 0;
6911
6912 reporter->dump_fmsg = devlink_fmsg_alloc();
6913 if (!reporter->dump_fmsg) {
6914 err = -ENOMEM;
6915 return err;
6916 }
6917
6918 err = devlink_fmsg_obj_nest_start(reporter->dump_fmsg);
6919 if (err)
6920 goto dump_err;
6921
6922 err = reporter->ops->dump(reporter, reporter->dump_fmsg,
e7a98105 6923 priv_ctx, extack);
c8e1da0b
EBE		 6924 if (err)
6925 goto dump_err;
6926
6927 err = devlink_fmsg_obj_nest_end(reporter->dump_fmsg);
6928 if (err)
6929 goto dump_err;
6930
6931 reporter->dump_ts = jiffies;
d279505b 6932 reporter->dump_real_ts = ktime_get_real_ns();
c8e1da0b
EBE		 6933
6934 return 0;
6935
6936dump_err:
6937 devlink_health_dump_clear(reporter);
6938 return err;
6939}
6940
6941int devlink_health_report(struct devlink_health_reporter *reporter,
6942 const char *msg, void *priv_ctx)
6943{
a0a21adb 6944 enum devlink_health_reporter_state prev_health_state;
c8e1da0b 6945 struct devlink *devlink = reporter->devlink;
bea0c5c9 6946 unsigned long recover_ts_threshold;
c8e1da0b
EBE		 6947
6948 /* write a log message of the current error */
6949 WARN_ON(!msg);
6950 trace_devlink_health_report(devlink, reporter->ops->name, msg);
6951 reporter->error_count++;
a0a21adb
EBE		 6952 prev_health_state = reporter->health_state;
6953 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
6ec8b6cd 6954 devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
c8e1da0b
EBE		 6955
6956 /* abort if the previous error wasn't recovered */
bea0c5c9
AL		 6957 recover_ts_threshold = reporter->last_recovery_ts +
6958 msecs_to_jiffies(reporter->graceful_period);
c8e1da0b 6959 if (reporter->auto_recover &&
a0a21adb 6960 (prev_health_state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY ||
bea0c5c9
AL		 6961 (reporter->last_recovery_ts && reporter->recovery_count &&
6962 time_is_after_jiffies(recover_ts_threshold)))) {
c8e1da0b
EBE		 6963 trace_devlink_health_recover_aborted(devlink,
6964 reporter->ops->name,
6965 reporter->health_state,
6966 jiffies -
6967 reporter->last_recovery_ts);
6968 return -ECANCELED;
6969 }
6970
6971 reporter->health_state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
6972
48bb52c8
EBE		 6973 if (reporter->auto_dump) {
6974 mutex_lock(&reporter->dump_lock);
6975 /* store current dump of current error, for later analysis */
6976 devlink_health_do_dump(reporter, priv_ctx, NULL);
6977 mutex_unlock(&reporter->dump_lock);
6978 }
c8e1da0b
EBE		 6979
6980 if (reporter->auto_recover)
e7a98105
JP		 6981 return devlink_health_reporter_recover(reporter,
6982 priv_ctx, NULL);
c8e1da0b
EBE		 6983
6984 return 0;
6985}
6986EXPORT_SYMBOL_GPL(devlink_health_report);
6987
7afe335a 6988static struct devlink_health_reporter *
e44ef4e4
AL		 6989devlink_health_reporter_get_from_attrs(struct devlink *devlink,
6990 struct nlattr **attrs)
7afe335a 6991{
b587bdaf 6992 struct devlink_health_reporter *reporter;
f4f54166 6993 struct devlink_port *devlink_port;
7afe335a
EBE		 6994 char *reporter_name;
6995
e44ef4e4 6996 if (!attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME])
7afe335a
EBE		 6997 return NULL;
6998
e44ef4e4 6999 reporter_name = nla_data(attrs[DEVLINK_ATTR_HEALTH_REPORTER_NAME]);
f4f54166
VT		 7000 devlink_port = devlink_port_get_from_attrs(devlink, attrs);
7001 if (IS_ERR(devlink_port)) {
7002 mutex_lock(&devlink->reporters_lock);
7003 reporter = devlink_health_reporter_find_by_name(devlink, reporter_name);
7004 if (reporter)
7005 refcount_inc(&reporter->refcount);
7006 mutex_unlock(&devlink->reporters_lock);
7007 } else {
7008 mutex_lock(&devlink_port->reporters_lock);
7009 reporter = devlink_port_health_reporter_find_by_name(devlink_port, reporter_name);
7010 if (reporter)
7011 refcount_inc(&reporter->refcount);
7012 mutex_unlock(&devlink_port->reporters_lock);
7013 }
7014
b587bdaf
MS		 7015 return reporter;
7016}
7017
e44ef4e4
AL		 7018static struct devlink_health_reporter *
7019devlink_health_reporter_get_from_info(struct devlink *devlink,
7020 struct genl_info *info)
7021{
7022 return devlink_health_reporter_get_from_attrs(devlink, info->attrs);
7023}
7024
7025static struct devlink_health_reporter *
7026devlink_health_reporter_get_from_cb(struct netlink_callback *cb)
7027{
ee85da53 7028 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
e44ef4e4 7029 struct devlink_health_reporter *reporter;
ee85da53 7030 struct nlattr **attrs = info->attrs;
e44ef4e4 7031 struct devlink *devlink;
e44ef4e4
AL		 7032
7033 mutex_lock(&devlink_mutex);
7034 devlink = devlink_get_from_attrs(sock_net(cb->skb->sk), attrs);
7035 if (IS_ERR(devlink))
7036 goto unlock;
7037
7038 reporter = devlink_health_reporter_get_from_attrs(devlink, attrs);
7039 mutex_unlock(&devlink_mutex);
e44ef4e4
AL		 7040 return reporter;
7041unlock:
7042 mutex_unlock(&devlink_mutex);
e44ef4e4
AL		 7043 return NULL;
7044}
7045
97ff3bd3
VG		 7046void
7047devlink_health_reporter_state_update(struct devlink_health_reporter *reporter,
7048 enum devlink_health_reporter_state state)
7049{
7050 if (WARN_ON(state != DEVLINK_HEALTH_REPORTER_STATE_HEALTHY &&
7051 state != DEVLINK_HEALTH_REPORTER_STATE_ERROR))
7052 return;
7053
7054 if (reporter->health_state == state)
7055 return;
7056
7057 reporter->health_state = state;
7058 trace_devlink_health_reporter_state_update(reporter->devlink,
7059 reporter->ops->name, state);
7060 devlink_recover_notify(reporter, DEVLINK_CMD_HEALTH_REPORTER_RECOVER);
7061}
7062EXPORT_SYMBOL_GPL(devlink_health_reporter_state_update);
7063
7afe335a
EBE		 7064static int devlink_nl_cmd_health_reporter_get_doit(struct sk_buff *skb,
7065 struct genl_info *info)
7066{
7067 struct devlink *devlink = info->user_ptr[0];
7068 struct devlink_health_reporter *reporter;
7069 struct sk_buff *msg;
7070 int err;
7071
7072 reporter = devlink_health_reporter_get_from_info(devlink, info);
7073 if (!reporter)
7074 return -EINVAL;
7075
7076 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
b587bdaf
MS		 7077 if (!msg) {
7078 err = -ENOMEM;
7079 goto out;
7080 }
7afe335a
EBE		 7081
7082 err = devlink_nl_health_reporter_fill(msg, devlink, reporter,
7083 DEVLINK_CMD_HEALTH_REPORTER_GET,
7084 info->snd_portid, info->snd_seq,
7085 0);
7086 if (err) {
7087 nlmsg_free(msg);
b587bdaf 7088 goto out;
7afe335a
EBE		 7089 }
7090
b587bdaf
MS		 7091 err = genlmsg_reply(msg, info);
7092out:
7093 devlink_health_reporter_put(reporter);
7094 return err;
7afe335a
EBE		 7095}
7096
7097static int
7098devlink_nl_cmd_health_reporter_get_dumpit(struct sk_buff *msg,
7099 struct netlink_callback *cb)
7100{
7101 struct devlink_health_reporter *reporter;
f4f54166 7102 struct devlink_port *port;
7afe335a
EBE		 7103 struct devlink *devlink;
7104 int start = cb->args[0];
7105 int idx = 0;
7106 int err;
7107
7108 mutex_lock(&devlink_mutex);
7109 list_for_each_entry(devlink, &devlink_list, list) {
7110 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7111 continue;
b587bdaf 7112 mutex_lock(&devlink->reporters_lock);
7afe335a
EBE		 7113 list_for_each_entry(reporter, &devlink->reporter_list,
7114 list) {
7115 if (idx < start) {
7116 idx++;
7117 continue;
7118 }
7119 err = devlink_nl_health_reporter_fill(msg, devlink,
7120 reporter,
7121 DEVLINK_CMD_HEALTH_REPORTER_GET,
7122 NETLINK_CB(cb->skb).portid,
7123 cb->nlh->nlmsg_seq,
7124 NLM_F_MULTI);
7125 if (err) {
b587bdaf 7126 mutex_unlock(&devlink->reporters_lock);
7afe335a
EBE		 7127 goto out;
7128 }
7129 idx++;
7130 }
b587bdaf 7131 mutex_unlock(&devlink->reporters_lock);
7afe335a 7132 }
f4f54166
VT		 7133
7134 list_for_each_entry(devlink, &devlink_list, list) {
7135 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7136 continue;
5d080b50 7137 mutex_lock(&devlink->lock);
f4f54166
VT		 7138 list_for_each_entry(port, &devlink->port_list, list) {
7139 mutex_lock(&port->reporters_lock);
7140 list_for_each_entry(reporter, &port->reporter_list, list) {
7141 if (idx < start) {
7142 idx++;
7143 continue;
7144 }
7145 err = devlink_nl_health_reporter_fill(msg, devlink, reporter,
7146 DEVLINK_CMD_HEALTH_REPORTER_GET,
7147 NETLINK_CB(cb->skb).portid,
7148 cb->nlh->nlmsg_seq,
7149 NLM_F_MULTI);
7150 if (err) {
7151 mutex_unlock(&port->reporters_lock);
5d080b50 7152 mutex_unlock(&devlink->lock);
f4f54166
VT		 7153 goto out;
7154 }
7155 idx++;
7156 }
7157 mutex_unlock(&port->reporters_lock);
7158 }
5d080b50 7159 mutex_unlock(&devlink->lock);
f4f54166 7160 }
7afe335a
EBE		 7161out:
7162 mutex_unlock(&devlink_mutex);
7163
7164 cb->args[0] = idx;
7165 return msg->len;
7166}
7167
a1e55ec0
EBE		 7168static int
7169devlink_nl_cmd_health_reporter_set_doit(struct sk_buff *skb,
7170 struct genl_info *info)
7171{
7172 struct devlink *devlink = info->user_ptr[0];
7173 struct devlink_health_reporter *reporter;
b587bdaf 7174 int err;
a1e55ec0
EBE		 7175
7176 reporter = devlink_health_reporter_get_from_info(devlink, info);
7177 if (!reporter)
7178 return -EINVAL;
7179
7180 if (!reporter->ops->recover &&
7181 (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] ||
b587bdaf
MS		 7182 info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])) {
7183 err = -EOPNOTSUPP;
7184 goto out;
7185 }
48bb52c8
EBE		 7186 if (!reporter->ops->dump &&
7187 info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP]) {
7188 err = -EOPNOTSUPP;
7189 goto out;
7190 }
a1e55ec0
EBE		 7191
7192 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD])
7193 reporter->graceful_period =
7194 nla_get_u64(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD]);
7195
7196 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])
7197 reporter->auto_recover =
7198 nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER]);
7199
48bb52c8
EBE		 7200 if (info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP])
7201 reporter->auto_dump =
7202 nla_get_u8(info->attrs[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP]);
7203
b587bdaf 7204 devlink_health_reporter_put(reporter);
a1e55ec0 7205 return 0;
b587bdaf
MS		 7206out:
7207 devlink_health_reporter_put(reporter);
7208 return err;
a1e55ec0
EBE		 7209}
7210
20a0943a
EBE		 7211static int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
7212 struct genl_info *info)
7213{
7214 struct devlink *devlink = info->user_ptr[0];
7215 struct devlink_health_reporter *reporter;
b587bdaf 7216 int err;
20a0943a
EBE		 7217
7218 reporter = devlink_health_reporter_get_from_info(devlink, info);
7219 if (!reporter)
7220 return -EINVAL;
7221
e7a98105 7222 err = devlink_health_reporter_recover(reporter, NULL, info->extack);
b587bdaf
MS		 7223
7224 devlink_health_reporter_put(reporter);
7225 return err;
20a0943a
EBE		 7226}
7227
fca42a27
EBE		 7228static int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
7229 struct genl_info *info)
7230{
7231 struct devlink *devlink = info->user_ptr[0];
7232 struct devlink_health_reporter *reporter;
7233 struct devlink_fmsg *fmsg;
7234 int err;
7235
7236 reporter = devlink_health_reporter_get_from_info(devlink, info);
7237 if (!reporter)
7238 return -EINVAL;
7239
b587bdaf
MS		 7240 if (!reporter->ops->diagnose) {
7241 devlink_health_reporter_put(reporter);
fca42a27 7242 return -EOPNOTSUPP;
b587bdaf 7243 }
fca42a27
EBE		 7244
7245 fmsg = devlink_fmsg_alloc();
b587bdaf
MS		 7246 if (!fmsg) {
7247 devlink_health_reporter_put(reporter);
fca42a27 7248 return -ENOMEM;
b587bdaf 7249 }
fca42a27
EBE		 7250
7251 err = devlink_fmsg_obj_nest_start(fmsg);
7252 if (err)
7253 goto out;
7254
e7a98105 7255 err = reporter->ops->diagnose(reporter, fmsg, info->extack);
fca42a27
EBE		 7256 if (err)
7257 goto out;
7258
7259 err = devlink_fmsg_obj_nest_end(fmsg);
7260 if (err)
7261 goto out;
7262
7263 err = devlink_fmsg_snd(fmsg, info,
7264 DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE, 0);
7265
7266out:
7267 devlink_fmsg_free(fmsg);
b587bdaf 7268 devlink_health_reporter_put(reporter);
fca42a27
EBE		 7269 return err;
7270}
7271
e44ef4e4
AL		 7272static int
7273devlink_nl_cmd_health_reporter_dump_get_dumpit(struct sk_buff *skb,
7274 struct netlink_callback *cb)
35455e23 7275{
35455e23 7276 struct devlink_health_reporter *reporter;
e44ef4e4 7277 u64 start = cb->args[0];
35455e23
EBE		 7278 int err;
7279
e44ef4e4 7280 reporter = devlink_health_reporter_get_from_cb(cb);
35455e23
EBE		 7281 if (!reporter)
7282 return -EINVAL;
7283
b587bdaf 7284 if (!reporter->ops->dump) {
e44ef4e4
AL		 7285 err = -EOPNOTSUPP;
7286 goto out;
b587bdaf 7287 }
35455e23 7288 mutex_lock(&reporter->dump_lock);
e44ef4e4 7289 if (!start) {
e7a98105 7290 err = devlink_health_do_dump(reporter, NULL, cb->extack);
e44ef4e4
AL		 7291 if (err)
7292 goto unlock;
7293 cb->args[1] = reporter->dump_ts;
7294 }
7295 if (!reporter->dump_fmsg || cb->args[1] != reporter->dump_ts) {
7296 NL_SET_ERR_MSG_MOD(cb->extack, "Dump trampled, please retry");
7297 err = -EAGAIN;
7298 goto unlock;
7299 }
35455e23 7300
e44ef4e4
AL		 7301 err = devlink_fmsg_dumpit(reporter->dump_fmsg, skb, cb,
7302 DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET);
7303unlock:
35455e23 7304 mutex_unlock(&reporter->dump_lock);
e44ef4e4 7305out:
b587bdaf 7306 devlink_health_reporter_put(reporter);
35455e23
EBE		 7307 return err;
7308}
7309
7310static int
7311devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
7312 struct genl_info *info)
7313{
7314 struct devlink *devlink = info->user_ptr[0];
7315 struct devlink_health_reporter *reporter;
7316
7317 reporter = devlink_health_reporter_get_from_info(devlink, info);
7318 if (!reporter)
7319 return -EINVAL;
7320
b587bdaf
MS		 7321 if (!reporter->ops->dump) {
7322 devlink_health_reporter_put(reporter);
35455e23 7323 return -EOPNOTSUPP;
b587bdaf 7324 }
35455e23
EBE		 7325
7326 mutex_lock(&reporter->dump_lock);
7327 devlink_health_dump_clear(reporter);
7328 mutex_unlock(&reporter->dump_lock);
b587bdaf 7329 devlink_health_reporter_put(reporter);
35455e23
EBE		 7330 return 0;
7331}
7332
e2ce94dc
JP		 7333static int devlink_nl_cmd_health_reporter_test_doit(struct sk_buff *skb,
7334 struct genl_info *info)
7335{
7336 struct devlink *devlink = info->user_ptr[0];
7337 struct devlink_health_reporter *reporter;
7338 int err;
7339
7340 reporter = devlink_health_reporter_get_from_info(devlink, info);
7341 if (!reporter)
7342 return -EINVAL;
7343
7344 if (!reporter->ops->test) {
7345 devlink_health_reporter_put(reporter);
7346 return -EOPNOTSUPP;
7347 }
7348
7349 err = reporter->ops->test(reporter, info->extack);
7350
7351 devlink_health_reporter_put(reporter);
7352 return err;
7353}
7354
0f420b6c
IS		 7355struct devlink_stats {
7356 u64 rx_bytes;
7357 u64 rx_packets;
7358 struct u64_stats_sync syncp;
7359};
7360
1e8c6619
IS		 7361/**
7362 * struct devlink_trap_policer_item - Packet trap policer attributes.
7363 * @policer: Immutable packet trap policer attributes.
7364 * @rate: Rate in packets / sec.
7365 * @burst: Burst size in packets.
7366 * @list: trap_policer_list member.
7367 *
7368 * Describes packet trap policer attributes. Created by devlink during trap
7369 * policer registration.
7370 */
7371struct devlink_trap_policer_item {
7372 const struct devlink_trap_policer *policer;
7373 u64 rate;
7374 u64 burst;
7375 struct list_head list;
7376};
7377
0f420b6c
IS		 7378/**
7379 * struct devlink_trap_group_item - Packet trap group attributes.
7380 * @group: Immutable packet trap group attributes.
f9f54392 7381 * @policer_item: Associated policer item. Can be NULL.
0f420b6c
IS		 7382 * @list: trap_group_list member.
7383 * @stats: Trap group statistics.
7384 *
7385 * Describes packet trap group attributes. Created by devlink during trap
a09b37fc 7386 * group registration.
0f420b6c
IS		 7387 */
7388struct devlink_trap_group_item {
7389 const struct devlink_trap_group *group;
f9f54392 7390 struct devlink_trap_policer_item *policer_item;
0f420b6c
IS		 7391 struct list_head list;
7392 struct devlink_stats __percpu *stats;
7393};
7394
7395/**
7396 * struct devlink_trap_item - Packet trap attributes.
7397 * @trap: Immutable packet trap attributes.
7398 * @group_item: Associated group item.
7399 * @list: trap_list member.
7400 * @action: Trap action.
7401 * @stats: Trap statistics.
7402 * @priv: Driver private information.
7403 *
7404 * Describes both mutable and immutable packet trap attributes. Created by
7405 * devlink during trap registration and used for all trap related operations.
7406 */
7407struct devlink_trap_item {
7408 const struct devlink_trap *trap;
7409 struct devlink_trap_group_item *group_item;
7410 struct list_head list;
7411 enum devlink_trap_action action;
7412 struct devlink_stats __percpu *stats;
7413 void *priv;
7414};
7415
1e8c6619
IS		 7416static struct devlink_trap_policer_item *
7417devlink_trap_policer_item_lookup(struct devlink *devlink, u32 id)
7418{
7419 struct devlink_trap_policer_item *policer_item;
7420
7421 list_for_each_entry(policer_item, &devlink->trap_policer_list, list) {
7422 if (policer_item->policer->id == id)
7423 return policer_item;
7424 }
7425
7426 return NULL;
7427}
7428
0f420b6c
IS		 7429static struct devlink_trap_item *
7430devlink_trap_item_lookup(struct devlink *devlink, const char *name)
7431{
7432 struct devlink_trap_item *trap_item;
7433
7434 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7435 if (!strcmp(trap_item->trap->name, name))
7436 return trap_item;
7437 }
7438
7439 return NULL;
7440}
7441
7442static struct devlink_trap_item *
7443devlink_trap_item_get_from_info(struct devlink *devlink,
7444 struct genl_info *info)
7445{
7446 struct nlattr *attr;
7447
7448 if (!info->attrs[DEVLINK_ATTR_TRAP_NAME])
7449 return NULL;
7450 attr = info->attrs[DEVLINK_ATTR_TRAP_NAME];
7451
7452 return devlink_trap_item_lookup(devlink, nla_data(attr));
7453}
7454
7455static int
7456devlink_trap_action_get_from_info(struct genl_info *info,
7457 enum devlink_trap_action *p_trap_action)
7458{
7459 u8 val;
7460
7461 val = nla_get_u8(info->attrs[DEVLINK_ATTR_TRAP_ACTION]);
7462 switch (val) {
df561f66
GS		 7463 case DEVLINK_TRAP_ACTION_DROP:
7464 case DEVLINK_TRAP_ACTION_TRAP:
9eefeabe 7465 case DEVLINK_TRAP_ACTION_MIRROR:
0f420b6c
IS		 7466 *p_trap_action = val;
7467 break;
7468 default:
7469 return -EINVAL;
7470 }
7471
7472 return 0;
7473}
7474
7475static int devlink_trap_metadata_put(struct sk_buff *msg,
7476 const struct devlink_trap *trap)
7477{
7478 struct nlattr *attr;
7479
7480 attr = nla_nest_start(msg, DEVLINK_ATTR_TRAP_METADATA);
7481 if (!attr)
7482 return -EMSGSIZE;
7483
7484 if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT) &&
7485 nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT))
7486 goto nla_put_failure;
85b0589e
JP		 7487 if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE) &&
7488 nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE))
7489 goto nla_put_failure;
0f420b6c
IS		 7490
7491 nla_nest_end(msg, attr);
7492
7493 return 0;
7494
7495nla_put_failure:
7496 nla_nest_cancel(msg, attr);
7497 return -EMSGSIZE;
7498}
7499
7500static void devlink_trap_stats_read(struct devlink_stats __percpu *trap_stats,
7501 struct devlink_stats *stats)
7502{
7503 int i;
7504
7505 memset(stats, 0, sizeof(*stats));
7506 for_each_possible_cpu(i) {
7507 struct devlink_stats *cpu_stats;
7508 u64 rx_packets, rx_bytes;
7509 unsigned int start;
7510
7511 cpu_stats = per_cpu_ptr(trap_stats, i);
7512 do {
7513 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
7514 rx_packets = cpu_stats->rx_packets;
7515 rx_bytes = cpu_stats->rx_bytes;
7516 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
7517
7518 stats->rx_packets += rx_packets;
7519 stats->rx_bytes += rx_bytes;
7520 }
7521}
7522
ddee9dbc
OM		 7523static int
7524devlink_trap_group_stats_put(struct sk_buff *msg,
7525 struct devlink_stats __percpu *trap_stats)
0f420b6c
IS		 7526{
7527 struct devlink_stats stats;
7528 struct nlattr *attr;
7529
7530 devlink_trap_stats_read(trap_stats, &stats);
7531
7532 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
7533 if (!attr)
7534 return -EMSGSIZE;
7535
7536 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
7537 stats.rx_packets, DEVLINK_ATTR_PAD))
7538 goto nla_put_failure;
7539
7540 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
7541 stats.rx_bytes, DEVLINK_ATTR_PAD))
7542 goto nla_put_failure;
7543
7544 nla_nest_end(msg, attr);
7545
7546 return 0;
7547
7548nla_put_failure:
7549 nla_nest_cancel(msg, attr);
7550 return -EMSGSIZE;
7551}
7552
ddee9dbc
OM		 7553static int devlink_trap_stats_put(struct sk_buff *msg, struct devlink *devlink,
7554 const struct devlink_trap_item *trap_item)
7555{
7556 struct devlink_stats stats;
7557 struct nlattr *attr;
7558 u64 drops = 0;
7559 int err;
7560
7561 if (devlink->ops->trap_drop_counter_get) {
7562 err = devlink->ops->trap_drop_counter_get(devlink,
7563 trap_item->trap,
7564 &drops);
7565 if (err)
7566 return err;
7567 }
7568
7569 devlink_trap_stats_read(trap_item->stats, &stats);
7570
7571 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
7572 if (!attr)
7573 return -EMSGSIZE;
7574
7575 if (devlink->ops->trap_drop_counter_get &&
7576 nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_DROPPED, drops,
7577 DEVLINK_ATTR_PAD))
7578 goto nla_put_failure;
7579
7580 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
7581 stats.rx_packets, DEVLINK_ATTR_PAD))
7582 goto nla_put_failure;
7583
7584 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
7585 stats.rx_bytes, DEVLINK_ATTR_PAD))
7586 goto nla_put_failure;
7587
7588 nla_nest_end(msg, attr);
7589
7590 return 0;
7591
7592nla_put_failure:
7593 nla_nest_cancel(msg, attr);
7594 return -EMSGSIZE;
7595}
7596
0f420b6c
IS		 7597static int devlink_nl_trap_fill(struct sk_buff *msg, struct devlink *devlink,
7598 const struct devlink_trap_item *trap_item,
7599 enum devlink_command cmd, u32 portid, u32 seq,
7600 int flags)
7601{
7602 struct devlink_trap_group_item *group_item = trap_item->group_item;
7603 void *hdr;
7604 int err;
7605
7606 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
7607 if (!hdr)
7608 return -EMSGSIZE;
7609
7610 if (devlink_nl_put_handle(msg, devlink))
7611 goto nla_put_failure;
7612
7613 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
7614 group_item->group->name))
7615 goto nla_put_failure;
7616
7617 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_NAME, trap_item->trap->name))
7618 goto nla_put_failure;
7619
7620 if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_TYPE, trap_item->trap->type))
7621 goto nla_put_failure;
7622
7623 if (trap_item->trap->generic &&
7624 nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
7625 goto nla_put_failure;
7626
7627 if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_ACTION, trap_item->action))
7628 goto nla_put_failure;
7629
7630 err = devlink_trap_metadata_put(msg, trap_item->trap);
7631 if (err)
7632 goto nla_put_failure;
7633
ddee9dbc 7634 err = devlink_trap_stats_put(msg, devlink, trap_item);
0f420b6c
IS		 7635 if (err)
7636 goto nla_put_failure;
7637
7638 genlmsg_end(msg, hdr);
7639
7640 return 0;
7641
7642nla_put_failure:
7643 genlmsg_cancel(msg, hdr);
7644 return -EMSGSIZE;
7645}
7646
7647static int devlink_nl_cmd_trap_get_doit(struct sk_buff *skb,
7648 struct genl_info *info)
7649{
7650 struct netlink_ext_ack *extack = info->extack;
7651 struct devlink *devlink = info->user_ptr[0];
7652 struct devlink_trap_item *trap_item;
7653 struct sk_buff *msg;
7654 int err;
7655
7656 if (list_empty(&devlink->trap_list))
7657 return -EOPNOTSUPP;
7658
7659 trap_item = devlink_trap_item_get_from_info(devlink, info);
7660 if (!trap_item) {
7661 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
7662 return -ENOENT;
7663 }
7664
7665 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7666 if (!msg)
7667 return -ENOMEM;
7668
7669 err = devlink_nl_trap_fill(msg, devlink, trap_item,
7670 DEVLINK_CMD_TRAP_NEW, info->snd_portid,
7671 info->snd_seq, 0);
7672 if (err)
7673 goto err_trap_fill;
7674
7675 return genlmsg_reply(msg, info);
7676
7677err_trap_fill:
7678 nlmsg_free(msg);
7679 return err;
7680}
7681
7682static int devlink_nl_cmd_trap_get_dumpit(struct sk_buff *msg,
7683 struct netlink_callback *cb)
7684{
7685 struct devlink_trap_item *trap_item;
7686 struct devlink *devlink;
7687 int start = cb->args[0];
7688 int idx = 0;
7689 int err;
7690
7691 mutex_lock(&devlink_mutex);
7692 list_for_each_entry(devlink, &devlink_list, list) {
7693 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7694 continue;
7695 mutex_lock(&devlink->lock);
7696 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7697 if (idx < start) {
7698 idx++;
7699 continue;
7700 }
7701 err = devlink_nl_trap_fill(msg, devlink, trap_item,
7702 DEVLINK_CMD_TRAP_NEW,
7703 NETLINK_CB(cb->skb).portid,
7704 cb->nlh->nlmsg_seq,
7705 NLM_F_MULTI);
7706 if (err) {
7707 mutex_unlock(&devlink->lock);
7708 goto out;
7709 }
7710 idx++;
7711 }
7712 mutex_unlock(&devlink->lock);
7713 }
7714out:
7715 mutex_unlock(&devlink_mutex);
7716
7717 cb->args[0] = idx;
7718 return msg->len;
7719}
7720
7721static int __devlink_trap_action_set(struct devlink *devlink,
7722 struct devlink_trap_item *trap_item,
7723 enum devlink_trap_action trap_action,
7724 struct netlink_ext_ack *extack)
7725{
7726 int err;
7727
7728 if (trap_item->action != trap_action &&
7729 trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP) {
7730 NL_SET_ERR_MSG_MOD(extack, "Cannot change action of non-drop traps. Skipping");
7731 return 0;
7732 }
7733
7734 err = devlink->ops->trap_action_set(devlink, trap_item->trap,
c88e11e0 7735 trap_action, extack);
0f420b6c
IS		 7736 if (err)
7737 return err;
7738
7739 trap_item->action = trap_action;
7740
7741 return 0;
7742}
7743
7744static int devlink_trap_action_set(struct devlink *devlink,
7745 struct devlink_trap_item *trap_item,
7746 struct genl_info *info)
7747{
7748 enum devlink_trap_action trap_action;
7749 int err;
7750
7751 if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
7752 return 0;
7753
7754 err = devlink_trap_action_get_from_info(info, &trap_action);
7755 if (err) {
7756 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
7757 return -EINVAL;
7758 }
7759
7760 return __devlink_trap_action_set(devlink, trap_item, trap_action,
7761 info->extack);
7762}
7763
7764static int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb,
7765 struct genl_info *info)
7766{
7767 struct netlink_ext_ack *extack = info->extack;
7768 struct devlink *devlink = info->user_ptr[0];
7769 struct devlink_trap_item *trap_item;
0f420b6c
IS		 7770
7771 if (list_empty(&devlink->trap_list))
7772 return -EOPNOTSUPP;
7773
7774 trap_item = devlink_trap_item_get_from_info(devlink, info);
7775 if (!trap_item) {
7776 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
7777 return -ENOENT;
7778 }
7779
8daa76a5 7780 return devlink_trap_action_set(devlink, trap_item, info);
0f420b6c
IS		 7781}
7782
7783static struct devlink_trap_group_item *
7784devlink_trap_group_item_lookup(struct devlink *devlink, const char *name)
7785{
7786 struct devlink_trap_group_item *group_item;
7787
7788 list_for_each_entry(group_item, &devlink->trap_group_list, list) {
7789 if (!strcmp(group_item->group->name, name))
7790 return group_item;
7791 }
7792
7793 return NULL;
7794}
7795
107f1678
IS		 7796static struct devlink_trap_group_item *
7797devlink_trap_group_item_lookup_by_id(struct devlink *devlink, u16 id)
7798{
7799 struct devlink_trap_group_item *group_item;
7800
7801 list_for_each_entry(group_item, &devlink->trap_group_list, list) {
7802 if (group_item->group->id == id)
7803 return group_item;
7804 }
7805
7806 return NULL;
7807}
7808
0f420b6c
IS		 7809static struct devlink_trap_group_item *
7810devlink_trap_group_item_get_from_info(struct devlink *devlink,
7811 struct genl_info *info)
7812{
7813 char *name;
7814
7815 if (!info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME])
7816 return NULL;
7817 name = nla_data(info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME]);
7818
7819 return devlink_trap_group_item_lookup(devlink, name);
7820}
7821
7822static int
7823devlink_nl_trap_group_fill(struct sk_buff *msg, struct devlink *devlink,
7824 const struct devlink_trap_group_item *group_item,
7825 enum devlink_command cmd, u32 portid, u32 seq,
7826 int flags)
7827{
7828 void *hdr;
7829 int err;
7830
7831 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
7832 if (!hdr)
7833 return -EMSGSIZE;
7834
7835 if (devlink_nl_put_handle(msg, devlink))
7836 goto nla_put_failure;
7837
7838 if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
7839 group_item->group->name))
7840 goto nla_put_failure;
7841
7842 if (group_item->group->generic &&
7843 nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
7844 goto nla_put_failure;
7845
f9f54392
IS		 7846 if (group_item->policer_item &&
7847 nla_put_u32(msg, DEVLINK_ATTR_TRAP_POLICER_ID,
7848 group_item->policer_item->policer->id))
7849 goto nla_put_failure;
7850
ddee9dbc 7851 err = devlink_trap_group_stats_put(msg, group_item->stats);
0f420b6c
IS		 7852 if (err)
7853 goto nla_put_failure;
7854
7855 genlmsg_end(msg, hdr);
7856
7857 return 0;
7858
7859nla_put_failure:
7860 genlmsg_cancel(msg, hdr);
7861 return -EMSGSIZE;
7862}
7863
7864static int devlink_nl_cmd_trap_group_get_doit(struct sk_buff *skb,
7865 struct genl_info *info)
7866{
7867 struct netlink_ext_ack *extack = info->extack;
7868 struct devlink *devlink = info->user_ptr[0];
7869 struct devlink_trap_group_item *group_item;
7870 struct sk_buff *msg;
7871 int err;
7872
7873 if (list_empty(&devlink->trap_group_list))
7874 return -EOPNOTSUPP;
7875
7876 group_item = devlink_trap_group_item_get_from_info(devlink, info);
7877 if (!group_item) {
7878 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
7879 return -ENOENT;
7880 }
7881
7882 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7883 if (!msg)
7884 return -ENOMEM;
7885
7886 err = devlink_nl_trap_group_fill(msg, devlink, group_item,
7887 DEVLINK_CMD_TRAP_GROUP_NEW,
7888 info->snd_portid, info->snd_seq, 0);
7889 if (err)
7890 goto err_trap_group_fill;
7891
7892 return genlmsg_reply(msg, info);
7893
7894err_trap_group_fill:
7895 nlmsg_free(msg);
7896 return err;
7897}
7898
7899static int devlink_nl_cmd_trap_group_get_dumpit(struct sk_buff *msg,
7900 struct netlink_callback *cb)
7901{
7902 enum devlink_command cmd = DEVLINK_CMD_TRAP_GROUP_NEW;
7903 struct devlink_trap_group_item *group_item;
7904 u32 portid = NETLINK_CB(cb->skb).portid;
7905 struct devlink *devlink;
7906 int start = cb->args[0];
7907 int idx = 0;
7908 int err;
7909
7910 mutex_lock(&devlink_mutex);
7911 list_for_each_entry(devlink, &devlink_list, list) {
7912 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
7913 continue;
7914 mutex_lock(&devlink->lock);
7915 list_for_each_entry(group_item, &devlink->trap_group_list,
7916 list) {
7917 if (idx < start) {
7918 idx++;
7919 continue;
7920 }
7921 err = devlink_nl_trap_group_fill(msg, devlink,
7922 group_item, cmd,
7923 portid,
7924 cb->nlh->nlmsg_seq,
7925 NLM_F_MULTI);
7926 if (err) {
7927 mutex_unlock(&devlink->lock);
7928 goto out;
7929 }
7930 idx++;
7931 }
7932 mutex_unlock(&devlink->lock);
7933 }
7934out:
7935 mutex_unlock(&devlink_mutex);
7936
7937 cb->args[0] = idx;
7938 return msg->len;
7939}
7940
7941static int
7942__devlink_trap_group_action_set(struct devlink *devlink,
7943 struct devlink_trap_group_item *group_item,
7944 enum devlink_trap_action trap_action,
7945 struct netlink_ext_ack *extack)
7946{
7947 const char *group_name = group_item->group->name;
7948 struct devlink_trap_item *trap_item;
7949 int err;
7950
c50bf2be
IC		 7951 if (devlink->ops->trap_group_action_set) {
7952 err = devlink->ops->trap_group_action_set(devlink, group_item->group,
7953 trap_action, extack);
7954 if (err)
7955 return err;
7956
7957 list_for_each_entry(trap_item, &devlink->trap_list, list) {
7958 if (strcmp(trap_item->group_item->group->name, group_name))
7959 continue;
7960 if (trap_item->action != trap_action &&
7961 trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP)
7962 continue;
7963 trap_item->action = trap_action;
7964 }
7965
7966 return 0;
7967 }
7968
0f420b6c 7969 list_for_each_entry(trap_item, &devlink->trap_list, list) {
107f1678 7970 if (strcmp(trap_item->group_item->group->name, group_name))
0f420b6c
IS		 7971 continue;
7972 err = __devlink_trap_action_set(devlink, trap_item,
7973 trap_action, extack);
7974 if (err)
7975 return err;
7976 }
7977
7978 return 0;
7979}
7980
7981static int
7982devlink_trap_group_action_set(struct devlink *devlink,
7983 struct devlink_trap_group_item *group_item,
c064875a 7984 struct genl_info *info, bool *p_modified)
0f420b6c
IS		 7985{
7986 enum devlink_trap_action trap_action;
7987 int err;
7988
7989 if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
7990 return 0;
7991
7992 err = devlink_trap_action_get_from_info(info, &trap_action);
7993 if (err) {
7994 NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
7995 return -EINVAL;
7996 }
7997
7998 err = __devlink_trap_group_action_set(devlink, group_item, trap_action,
7999 info->extack);
8000 if (err)
8001 return err;
8002
c064875a
IS		 8003 *p_modified = true;
8004
8005 return 0;
8006}
8007
8008static int devlink_trap_group_set(struct devlink *devlink,
8009 struct devlink_trap_group_item *group_item,
8010 struct genl_info *info)
8011{
8012 struct devlink_trap_policer_item *policer_item;
8013 struct netlink_ext_ack *extack = info->extack;
8014 const struct devlink_trap_policer *policer;
8015 struct nlattr **attrs = info->attrs;
8016 int err;
8017
8018 if (!attrs[DEVLINK_ATTR_TRAP_POLICER_ID])
8019 return 0;
8020
8021 if (!devlink->ops->trap_group_set)
8022 return -EOPNOTSUPP;
8023
8024 policer_item = group_item->policer_item;
8025 if (attrs[DEVLINK_ATTR_TRAP_POLICER_ID]) {
8026 u32 policer_id;
8027
8028 policer_id = nla_get_u32(attrs[DEVLINK_ATTR_TRAP_POLICER_ID]);
8029 policer_item = devlink_trap_policer_item_lookup(devlink,
8030 policer_id);
8031 if (policer_id && !policer_item) {
8032 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8033 return -ENOENT;
8034 }
8035 }
8036 policer = policer_item ? policer_item->policer : NULL;
8037
c88e11e0
IS		 8038 err = devlink->ops->trap_group_set(devlink, group_item->group, policer,
8039 extack);
c064875a
IS		 8040 if (err)
8041 return err;
8042
8043 group_item->policer_item = policer_item;
8044
0f420b6c
IS		 8045 return 0;
8046}
8047
8048static int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
8049 struct genl_info *info)
8050{
8051 struct netlink_ext_ack *extack = info->extack;
8052 struct devlink *devlink = info->user_ptr[0];
8053 struct devlink_trap_group_item *group_item;
c064875a 8054 bool modified = false;
0f420b6c
IS		 8055 int err;
8056
8057 if (list_empty(&devlink->trap_group_list))
8058 return -EOPNOTSUPP;
8059
8060 group_item = devlink_trap_group_item_get_from_info(devlink, info);
8061 if (!group_item) {
8062 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
8063 return -ENOENT;
8064 }
8065
c064875a
IS		 8066 err = devlink_trap_group_action_set(devlink, group_item, info,
8067 &modified);
0f420b6c
IS		 8068 if (err)
8069 return err;
8070
c064875a
IS		 8071 err = devlink_trap_group_set(devlink, group_item, info);
8072 if (err)
8073 goto err_trap_group_set;
8074
0f420b6c 8075 return 0;
c064875a
IS		 8076
8077err_trap_group_set:
8078 if (modified)
8079 NL_SET_ERR_MSG_MOD(extack, "Trap group set failed, but some changes were committed already");
8080 return err;
0f420b6c
IS		 8081}
8082
1e8c6619
IS		 8083static struct devlink_trap_policer_item *
8084devlink_trap_policer_item_get_from_info(struct devlink *devlink,
8085 struct genl_info *info)
8086{
8087 u32 id;
8088
8089 if (!info->attrs[DEVLINK_ATTR_TRAP_POLICER_ID])
8090 return NULL;
8091 id = nla_get_u32(info->attrs[DEVLINK_ATTR_TRAP_POLICER_ID]);
8092
8093 return devlink_trap_policer_item_lookup(devlink, id);
8094}
8095
8096static int
8097devlink_trap_policer_stats_put(struct sk_buff *msg, struct devlink *devlink,
8098 const struct devlink_trap_policer *policer)
8099{
8100 struct nlattr *attr;
8101 u64 drops;
8102 int err;
8103
8104 if (!devlink->ops->trap_policer_counter_get)
8105 return 0;
8106
8107 err = devlink->ops->trap_policer_counter_get(devlink, policer, &drops);
8108 if (err)
8109 return err;
8110
8111 attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
8112 if (!attr)
8113 return -EMSGSIZE;
8114
8115 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_DROPPED, drops,
8116 DEVLINK_ATTR_PAD))
8117 goto nla_put_failure;
8118
8119 nla_nest_end(msg, attr);
8120
8121 return 0;
8122
8123nla_put_failure:
8124 nla_nest_cancel(msg, attr);
8125 return -EMSGSIZE;
8126}
8127
8128static int
8129devlink_nl_trap_policer_fill(struct sk_buff *msg, struct devlink *devlink,
8130 const struct devlink_trap_policer_item *policer_item,
8131 enum devlink_command cmd, u32 portid, u32 seq,
8132 int flags)
8133{
8134 void *hdr;
8135 int err;
8136
8137 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
8138 if (!hdr)
8139 return -EMSGSIZE;
8140
8141 if (devlink_nl_put_handle(msg, devlink))
8142 goto nla_put_failure;
8143
8144 if (nla_put_u32(msg, DEVLINK_ATTR_TRAP_POLICER_ID,
8145 policer_item->policer->id))
8146 goto nla_put_failure;
8147
8148 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_TRAP_POLICER_RATE,
8149 policer_item->rate, DEVLINK_ATTR_PAD))
8150 goto nla_put_failure;
8151
8152 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_TRAP_POLICER_BURST,
8153 policer_item->burst, DEVLINK_ATTR_PAD))
8154 goto nla_put_failure;
8155
8156 err = devlink_trap_policer_stats_put(msg, devlink,
8157 policer_item->policer);
8158 if (err)
8159 goto nla_put_failure;
8160
8161 genlmsg_end(msg, hdr);
8162
8163 return 0;
8164
8165nla_put_failure:
8166 genlmsg_cancel(msg, hdr);
8167 return -EMSGSIZE;
8168}
8169
8170static int devlink_nl_cmd_trap_policer_get_doit(struct sk_buff *skb,
8171 struct genl_info *info)
8172{
8173 struct devlink_trap_policer_item *policer_item;
8174 struct netlink_ext_ack *extack = info->extack;
8175 struct devlink *devlink = info->user_ptr[0];
8176 struct sk_buff *msg;
8177 int err;
8178
8179 if (list_empty(&devlink->trap_policer_list))
8180 return -EOPNOTSUPP;
8181
8182 policer_item = devlink_trap_policer_item_get_from_info(devlink, info);
8183 if (!policer_item) {
8184 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8185 return -ENOENT;
8186 }
8187
8188 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8189 if (!msg)
8190 return -ENOMEM;
8191
8192 err = devlink_nl_trap_policer_fill(msg, devlink, policer_item,
8193 DEVLINK_CMD_TRAP_POLICER_NEW,
8194 info->snd_portid, info->snd_seq, 0);
8195 if (err)
8196 goto err_trap_policer_fill;
8197
8198 return genlmsg_reply(msg, info);
8199
8200err_trap_policer_fill:
8201 nlmsg_free(msg);
8202 return err;
8203}
8204
8205static int devlink_nl_cmd_trap_policer_get_dumpit(struct sk_buff *msg,
8206 struct netlink_callback *cb)
8207{
8208 enum devlink_command cmd = DEVLINK_CMD_TRAP_POLICER_NEW;
8209 struct devlink_trap_policer_item *policer_item;
8210 u32 portid = NETLINK_CB(cb->skb).portid;
8211 struct devlink *devlink;
8212 int start = cb->args[0];
8213 int idx = 0;
8214 int err;
8215
8216 mutex_lock(&devlink_mutex);
8217 list_for_each_entry(devlink, &devlink_list, list) {
8218 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
8219 continue;
8220 mutex_lock(&devlink->lock);
8221 list_for_each_entry(policer_item, &devlink->trap_policer_list,
8222 list) {
8223 if (idx < start) {
8224 idx++;
8225 continue;
8226 }
8227 err = devlink_nl_trap_policer_fill(msg, devlink,
8228 policer_item, cmd,
8229 portid,
8230 cb->nlh->nlmsg_seq,
8231 NLM_F_MULTI);
8232 if (err) {
8233 mutex_unlock(&devlink->lock);
8234 goto out;
8235 }
8236 idx++;
8237 }
8238 mutex_unlock(&devlink->lock);
8239 }
8240out:
8241 mutex_unlock(&devlink_mutex);
8242
8243 cb->args[0] = idx;
8244 return msg->len;
8245}
8246
8247static int
8248devlink_trap_policer_set(struct devlink *devlink,
8249 struct devlink_trap_policer_item *policer_item,
8250 struct genl_info *info)
8251{
8252 struct netlink_ext_ack *extack = info->extack;
8253 struct nlattr **attrs = info->attrs;
8254 u64 rate, burst;
8255 int err;
8256
8257 rate = policer_item->rate;
8258 burst = policer_item->burst;
8259
8260 if (attrs[DEVLINK_ATTR_TRAP_POLICER_RATE])
8261 rate = nla_get_u64(attrs[DEVLINK_ATTR_TRAP_POLICER_RATE]);
8262
8263 if (attrs[DEVLINK_ATTR_TRAP_POLICER_BURST])
8264 burst = nla_get_u64(attrs[DEVLINK_ATTR_TRAP_POLICER_BURST]);
8265
8266 if (rate < policer_item->policer->min_rate) {
8267 NL_SET_ERR_MSG_MOD(extack, "Policer rate lower than limit");
8268 return -EINVAL;
8269 }
8270
8271 if (rate > policer_item->policer->max_rate) {
8272 NL_SET_ERR_MSG_MOD(extack, "Policer rate higher than limit");
8273 return -EINVAL;
8274 }
8275
8276 if (burst < policer_item->policer->min_burst) {
8277 NL_SET_ERR_MSG_MOD(extack, "Policer burst size lower than limit");
8278 return -EINVAL;
8279 }
8280
8281 if (burst > policer_item->policer->max_burst) {
8282 NL_SET_ERR_MSG_MOD(extack, "Policer burst size higher than limit");
8283 return -EINVAL;
8284 }
8285
8286 err = devlink->ops->trap_policer_set(devlink, policer_item->policer,
8287 rate, burst, info->extack);
8288 if (err)
8289 return err;
8290
8291 policer_item->rate = rate;
8292 policer_item->burst = burst;
8293
8294 return 0;
8295}
8296
8297static int devlink_nl_cmd_trap_policer_set_doit(struct sk_buff *skb,
8298 struct genl_info *info)
8299{
8300 struct devlink_trap_policer_item *policer_item;
8301 struct netlink_ext_ack *extack = info->extack;
8302 struct devlink *devlink = info->user_ptr[0];
8303
8304 if (list_empty(&devlink->trap_policer_list))
8305 return -EOPNOTSUPP;
8306
8307 if (!devlink->ops->trap_policer_set)
8308 return -EOPNOTSUPP;
8309
8310 policer_item = devlink_trap_policer_item_get_from_info(devlink, info);
8311 if (!policer_item) {
8312 NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap policer");
8313 return -ENOENT;
8314 }
8315
8316 return devlink_trap_policer_set(devlink, policer_item, info);
8317}
8318
bfcd3a46 8319static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
1e8c6619
IS		 8320 [DEVLINK_ATTR_UNSPEC] = { .strict_start_type =
8321 DEVLINK_ATTR_TRAP_POLICER_ID },
bfcd3a46
JP		 8322 [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
8323 [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
8324 [DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
c49a9440
PP		 8325 [DEVLINK_ATTR_PORT_TYPE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_PORT_TYPE_AUTO,
8326 DEVLINK_PORT_TYPE_IB),
bfcd3a46 8327 [DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
bf797471
JP		 8328 [DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
8329 [DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
8330 [DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
8331 [DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
8332 [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
8333 [DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
8334 [DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
ba356c90
PP		 8335 [DEVLINK_ATTR_ESWITCH_MODE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_ESWITCH_MODE_LEGACY,
8336 DEVLINK_ESWITCH_MODE_SWITCHDEV),
59bfde01 8337 [DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
f43e9b06 8338 [DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
1555d204
AS		 8339 [DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
8340 [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
d9f9b9a4
AS		 8341 [DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
8342 [DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
e3b7ca18
MS		 8343 [DEVLINK_ATTR_PARAM_NAME] = { .type = NLA_NUL_STRING },
8344 [DEVLINK_ATTR_PARAM_TYPE] = { .type = NLA_U8 },
8345 [DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },
d8db7ea5 8346 [DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },
866319bb 8347 [DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },
ff3b63b8
JK		 8348 [DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .type = NLA_U64 },
8349 [DEVLINK_ATTR_REGION_CHUNK_LEN] = { .type = NLA_U64 },
7afe335a 8350 [DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },
a1e55ec0
EBE		 8351 [DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },
8352 [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },
76726ccb
JK		 8353 [DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING },
8354 [DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING },
5d5b4128
JK		 8355 [DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK] =
8356 NLA_POLICY_BITFIELD32(DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS),
0f420b6c
IS		 8357 [DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING },
8358 [DEVLINK_ATTR_TRAP_ACTION] = { .type = NLA_U8 },
8359 [DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING },
070c63f2
JP		 8360 [DEVLINK_ATTR_NETNS_PID] = { .type = NLA_U32 },
8361 [DEVLINK_ATTR_NETNS_FD] = { .type = NLA_U32 },
8362 [DEVLINK_ATTR_NETNS_ID] = { .type = NLA_U32 },
48bb52c8 8363 [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP] = { .type = NLA_U8 },
1e8c6619
IS		 8364 [DEVLINK_ATTR_TRAP_POLICER_ID] = { .type = NLA_U32 },
8365 [DEVLINK_ATTR_TRAP_POLICER_RATE] = { .type = NLA_U64 },
8366 [DEVLINK_ATTR_TRAP_POLICER_BURST] = { .type = NLA_U64 },
a1e8ae90 8367 [DEVLINK_ATTR_PORT_FUNCTION] = { .type = NLA_NESTED },
ccdf0721
MS		 8368 [DEVLINK_ATTR_RELOAD_ACTION] = NLA_POLICY_RANGE(NLA_U8, DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
8369 DEVLINK_RELOAD_ACTION_MAX),
dc64cc7c 8370 [DEVLINK_ATTR_RELOAD_LIMITS] = NLA_POLICY_BITFIELD32(DEVLINK_RELOAD_LIMITS_VALID_MASK),
cd76dcd6
PP		 8371 [DEVLINK_ATTR_PORT_FLAVOUR] = { .type = NLA_U16 },
8372 [DEVLINK_ATTR_PORT_PCI_PF_NUMBER] = { .type = NLA_U16 },
8373 [DEVLINK_ATTR_PORT_PCI_SF_NUMBER] = { .type = NLA_U32 },
8374 [DEVLINK_ATTR_PORT_CONTROLLER_NUMBER] = { .type = NLA_U32 },
4677efc4 8375 [DEVLINK_ATTR_RATE_TYPE] = { .type = NLA_U16 },
1897db2e
DL		 8376 [DEVLINK_ATTR_RATE_TX_SHARE] = { .type = NLA_U64 },
8377 [DEVLINK_ATTR_RATE_TX_MAX] = { .type = NLA_U64 },
a8ecb93e 8378 [DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING },
d7555984 8379 [DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .type = NLA_NUL_STRING },
bfcd3a46
JP		 8380};
8381
66a9b928 8382static const struct genl_small_ops devlink_nl_ops[] = {
bfcd3a46
JP		 8383 {
8384 .cmd = DEVLINK_CMD_GET,
ef6243ac 8385 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bfcd3a46
JP		 8386 .doit = devlink_nl_cmd_get_doit,
8387 .dumpit = devlink_nl_cmd_get_dumpit,
bfcd3a46
JP		 8388 /* can be retrieved by unprivileged users */
8389 },
8390 {
8391 .cmd = DEVLINK_CMD_PORT_GET,
ef6243ac 8392 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bfcd3a46
JP		 8393 .doit = devlink_nl_cmd_port_get_doit,
8394 .dumpit = devlink_nl_cmd_port_get_dumpit,
bfcd3a46
JP		 8395 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8396 /* can be retrieved by unprivileged users */
8397 },
8398 {
8399 .cmd = DEVLINK_CMD_PORT_SET,
ef6243ac 8400 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bfcd3a46 8401 .doit = devlink_nl_cmd_port_set_doit,
bfcd3a46
JP		 8402 .flags = GENL_ADMIN_PERM,
8403 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8404 },
4677efc4
DL		 8405 {
8406 .cmd = DEVLINK_CMD_RATE_GET,
8407 .doit = devlink_nl_cmd_rate_get_doit,
8408 .dumpit = devlink_nl_cmd_rate_get_dumpit,
8409 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE,
8410 /* can be retrieved by unprivileged users */
8411 },
1897db2e
DL		 8412 {
8413 .cmd = DEVLINK_CMD_RATE_SET,
8414 .doit = devlink_nl_cmd_rate_set_doit,
8415 .flags = GENL_ADMIN_PERM,
8416 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE,
8417 },
a8ecb93e
DL		 8418 {
8419 .cmd = DEVLINK_CMD_RATE_NEW,
8420 .doit = devlink_nl_cmd_rate_new_doit,
8421 .flags = GENL_ADMIN_PERM,
8422 },
8423 {
8424 .cmd = DEVLINK_CMD_RATE_DEL,
8425 .doit = devlink_nl_cmd_rate_del_doit,
8426 .flags = GENL_ADMIN_PERM,
8427 .internal_flags = DEVLINK_NL_FLAG_NEED_RATE_NODE,
8428 },
bfcd3a46
JP		 8429 {
8430 .cmd = DEVLINK_CMD_PORT_SPLIT,
ef6243ac 8431 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bfcd3a46 8432 .doit = devlink_nl_cmd_port_split_doit,
bfcd3a46 8433 .flags = GENL_ADMIN_PERM,
637989b5 8434 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
bfcd3a46
JP		 8435 },
8436 {
8437 .cmd = DEVLINK_CMD_PORT_UNSPLIT,
ef6243ac 8438 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bfcd3a46 8439 .doit = devlink_nl_cmd_port_unsplit_doit,
bfcd3a46 8440 .flags = GENL_ADMIN_PERM,
637989b5 8441 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
bfcd3a46 8442 },
cd76dcd6
PP		 8443 {
8444 .cmd = DEVLINK_CMD_PORT_NEW,
8445 .doit = devlink_nl_cmd_port_new_doit,
8446 .flags = GENL_ADMIN_PERM,
8447 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8448 },
8449 {
8450 .cmd = DEVLINK_CMD_PORT_DEL,
8451 .doit = devlink_nl_cmd_port_del_doit,
8452 .flags = GENL_ADMIN_PERM,
8453 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
8454 },
bf797471
JP		 8455 {
8456 .cmd = DEVLINK_CMD_SB_GET,
ef6243ac 8457 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471
JP		 8458 .doit = devlink_nl_cmd_sb_get_doit,
8459 .dumpit = devlink_nl_cmd_sb_get_dumpit,
bf797471
JP		 8460 /* can be retrieved by unprivileged users */
8461 },
8462 {
8463 .cmd = DEVLINK_CMD_SB_POOL_GET,
ef6243ac 8464 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471
JP		 8465 .doit = devlink_nl_cmd_sb_pool_get_doit,
8466 .dumpit = devlink_nl_cmd_sb_pool_get_dumpit,
bf797471
JP		 8467 /* can be retrieved by unprivileged users */
8468 },
8469 {
8470 .cmd = DEVLINK_CMD_SB_POOL_SET,
ef6243ac 8471 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471 8472 .doit = devlink_nl_cmd_sb_pool_set_doit,
bf797471 8473 .flags = GENL_ADMIN_PERM,
bf797471
JP		 8474 },
8475 {
8476 .cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
ef6243ac 8477 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471
JP		 8478 .doit = devlink_nl_cmd_sb_port_pool_get_doit,
8479 .dumpit = devlink_nl_cmd_sb_port_pool_get_dumpit,
637989b5 8480 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
bf797471
JP		 8481 /* can be retrieved by unprivileged users */
8482 },
8483 {
8484 .cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
ef6243ac 8485 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471 8486 .doit = devlink_nl_cmd_sb_port_pool_set_doit,
bf797471 8487 .flags = GENL_ADMIN_PERM,
637989b5 8488 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
bf797471
JP		 8489 },
8490 {
8491 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
ef6243ac 8492 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471
JP		 8493 .doit = devlink_nl_cmd_sb_tc_pool_bind_get_doit,
8494 .dumpit = devlink_nl_cmd_sb_tc_pool_bind_get_dumpit,
637989b5 8495 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
bf797471
JP		 8496 /* can be retrieved by unprivileged users */
8497 },
8498 {
8499 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
ef6243ac 8500 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
bf797471 8501 .doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
bf797471 8502 .flags = GENL_ADMIN_PERM,
637989b5 8503 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
bf797471 8504 },
df38dafd
JP		 8505 {
8506 .cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
ef6243ac 8507 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
df38dafd 8508 .doit = devlink_nl_cmd_sb_occ_snapshot_doit,
df38dafd 8509 .flags = GENL_ADMIN_PERM,
df38dafd
JP		 8510 },
8511 {
8512 .cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
ef6243ac 8513 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
df38dafd 8514 .doit = devlink_nl_cmd_sb_occ_max_clear_doit,
df38dafd 8515 .flags = GENL_ADMIN_PERM,
df38dafd 8516 },
08f4b591 8517 {
adf200f3 8518 .cmd = DEVLINK_CMD_ESWITCH_GET,
ef6243ac 8519 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
adf200f3 8520 .doit = devlink_nl_cmd_eswitch_get_doit,
08f4b591 8521 .flags = GENL_ADMIN_PERM,
637989b5 8522 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
08f4b591
OG		 8523 },
8524 {
adf200f3 8525 .cmd = DEVLINK_CMD_ESWITCH_SET,
ef6243ac 8526 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
adf200f3 8527 .doit = devlink_nl_cmd_eswitch_set_doit,
08f4b591 8528 .flags = GENL_ADMIN_PERM,
637989b5 8529 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
08f4b591 8530 },
1555d204
AS		 8531 {
8532 .cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
ef6243ac 8533 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1555d204 8534 .doit = devlink_nl_cmd_dpipe_table_get,
67ae686b 8535 /* can be retrieved by unprivileged users */
1555d204
AS		 8536 },
8537 {
8538 .cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
ef6243ac 8539 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1555d204 8540 .doit = devlink_nl_cmd_dpipe_entries_get,
67ae686b 8541 /* can be retrieved by unprivileged users */
1555d204
AS		 8542 },
8543 {
8544 .cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
ef6243ac 8545 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1555d204 8546 .doit = devlink_nl_cmd_dpipe_headers_get,
67ae686b 8547 /* can be retrieved by unprivileged users */
1555d204
AS		 8548 },
8549 {
8550 .cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
ef6243ac 8551 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1555d204 8552 .doit = devlink_nl_cmd_dpipe_table_counters_set,
1555d204 8553 .flags = GENL_ADMIN_PERM,
1555d204 8554 },
d9f9b9a4
AS		 8555 {
8556 .cmd = DEVLINK_CMD_RESOURCE_SET,
ef6243ac 8557 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
d9f9b9a4 8558 .doit = devlink_nl_cmd_resource_set,
d9f9b9a4 8559 .flags = GENL_ADMIN_PERM,
d9f9b9a4
AS		 8560 },
8561 {
8562 .cmd = DEVLINK_CMD_RESOURCE_DUMP,
ef6243ac 8563 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
d9f9b9a4 8564 .doit = devlink_nl_cmd_resource_dump,
67ae686b 8565 /* can be retrieved by unprivileged users */
d9f9b9a4 8566 },
2d8dc5bb
AS		 8567 {
8568 .cmd = DEVLINK_CMD_RELOAD,
ef6243ac 8569 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2d8dc5bb 8570 .doit = devlink_nl_cmd_reload,
2d8dc5bb 8571 .flags = GENL_ADMIN_PERM,
637989b5 8572 .internal_flags = DEVLINK_NL_FLAG_NO_LOCK,
2d8dc5bb 8573 },
45f05def
MS		 8574 {
8575 .cmd = DEVLINK_CMD_PARAM_GET,
ef6243ac 8576 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
45f05def
MS		 8577 .doit = devlink_nl_cmd_param_get_doit,
8578 .dumpit = devlink_nl_cmd_param_get_dumpit,
45f05def
MS		 8579 /* can be retrieved by unprivileged users */
8580 },
e3b7ca18
MS		 8581 {
8582 .cmd = DEVLINK_CMD_PARAM_SET,
ef6243ac 8583 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
e3b7ca18 8584 .doit = devlink_nl_cmd_param_set_doit,
e3b7ca18 8585 .flags = GENL_ADMIN_PERM,
e3b7ca18 8586 },
f4601dee
VV		 8587 {
8588 .cmd = DEVLINK_CMD_PORT_PARAM_GET,
ef6243ac 8589 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
f4601dee
VV		 8590 .doit = devlink_nl_cmd_port_param_get_doit,
8591 .dumpit = devlink_nl_cmd_port_param_get_dumpit,
f4601dee
VV		 8592 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8593 /* can be retrieved by unprivileged users */
8594 },
9c54873b
VV		 8595 {
8596 .cmd = DEVLINK_CMD_PORT_PARAM_SET,
ef6243ac 8597 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
9c54873b 8598 .doit = devlink_nl_cmd_port_param_set_doit,
9c54873b
VV		 8599 .flags = GENL_ADMIN_PERM,
8600 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
8601 },
d8db7ea5
AV		 8602 {
8603 .cmd = DEVLINK_CMD_REGION_GET,
ef6243ac 8604 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
d8db7ea5
AV		 8605 .doit = devlink_nl_cmd_region_get_doit,
8606 .dumpit = devlink_nl_cmd_region_get_dumpit,
d8db7ea5 8607 .flags = GENL_ADMIN_PERM,
d8db7ea5 8608 },
b9a17abf
JK		 8609 {
8610 .cmd = DEVLINK_CMD_REGION_NEW,
8611 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8612 .doit = devlink_nl_cmd_region_new,
8613 .flags = GENL_ADMIN_PERM,
b9a17abf 8614 },
866319bb
AV		 8615 {
8616 .cmd = DEVLINK_CMD_REGION_DEL,
ef6243ac 8617 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
866319bb 8618 .doit = devlink_nl_cmd_region_del,
866319bb 8619 .flags = GENL_ADMIN_PERM,
866319bb 8620 },
4e54795a
AV		 8621 {
8622 .cmd = DEVLINK_CMD_REGION_READ,
ee85da53
JP		 8623 .validate = GENL_DONT_VALIDATE_STRICT |
8624 GENL_DONT_VALIDATE_DUMP_STRICT,
4e54795a 8625 .dumpit = devlink_nl_cmd_region_read_dumpit,
4e54795a 8626 .flags = GENL_ADMIN_PERM,
4e54795a 8627 },
f9cf2288
JK		 8628 {
8629 .cmd = DEVLINK_CMD_INFO_GET,
ef6243ac 8630 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
f9cf2288
JK		 8631 .doit = devlink_nl_cmd_info_get_doit,
8632 .dumpit = devlink_nl_cmd_info_get_dumpit,
f9cf2288
JK		 8633 /* can be retrieved by unprivileged users */
8634 },
7afe335a
EBE		 8635 {
8636 .cmd = DEVLINK_CMD_HEALTH_REPORTER_GET,
ef6243ac 8637 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
7afe335a
EBE		 8638 .doit = devlink_nl_cmd_health_reporter_get_doit,
8639 .dumpit = devlink_nl_cmd_health_reporter_get_dumpit,
f4f54166 8640 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
b587bdaf 8641 DEVLINK_NL_FLAG_NO_LOCK,
7afe335a
EBE		 8642 /* can be retrieved by unprivileged users */
8643 },
a1e55ec0
EBE		 8644 {
8645 .cmd = DEVLINK_CMD_HEALTH_REPORTER_SET,
ef6243ac 8646 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
a1e55ec0 8647 .doit = devlink_nl_cmd_health_reporter_set_doit,
a1e55ec0 8648 .flags = GENL_ADMIN_PERM,
f4f54166 8649 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
b587bdaf 8650 DEVLINK_NL_FLAG_NO_LOCK,
a1e55ec0 8651 },
20a0943a
EBE		 8652 {
8653 .cmd = DEVLINK_CMD_HEALTH_REPORTER_RECOVER,
ef6243ac 8654 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
20a0943a 8655 .doit = devlink_nl_cmd_health_reporter_recover_doit,
20a0943a 8656 .flags = GENL_ADMIN_PERM,
f4f54166 8657 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
b587bdaf 8658 DEVLINK_NL_FLAG_NO_LOCK,
20a0943a 8659 },
fca42a27
EBE		 8660 {
8661 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE,
ef6243ac 8662 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
fca42a27 8663 .doit = devlink_nl_cmd_health_reporter_diagnose_doit,
fca42a27 8664 .flags = GENL_ADMIN_PERM,
f4f54166 8665 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
b587bdaf 8666 DEVLINK_NL_FLAG_NO_LOCK,
fca42a27 8667 },
35455e23
EBE		 8668 {
8669 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET,
82a843de
JP		 8670 .validate = GENL_DONT_VALIDATE_STRICT |
8671 GENL_DONT_VALIDATE_DUMP_STRICT,
e44ef4e4 8672 .dumpit = devlink_nl_cmd_health_reporter_dump_get_dumpit,
35455e23 8673 .flags = GENL_ADMIN_PERM,
f4f54166 8674 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
35455e23
EBE		 8675 DEVLINK_NL_FLAG_NO_LOCK,
8676 },
8677 {
8678 .cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR,
ef6243ac 8679 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
35455e23 8680 .doit = devlink_nl_cmd_health_reporter_dump_clear_doit,
35455e23 8681 .flags = GENL_ADMIN_PERM,
f4f54166 8682 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
35455e23
EBE		 8683 DEVLINK_NL_FLAG_NO_LOCK,
8684 },
e2ce94dc
JP		 8685 {
8686 .cmd = DEVLINK_CMD_HEALTH_REPORTER_TEST,
8687 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
8688 .doit = devlink_nl_cmd_health_reporter_test_doit,
8689 .flags = GENL_ADMIN_PERM,
8690 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT |
8691 DEVLINK_NL_FLAG_NO_LOCK,
8692 },
76726ccb
JK		 8693 {
8694 .cmd = DEVLINK_CMD_FLASH_UPDATE,
ef6243ac 8695 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
76726ccb 8696 .doit = devlink_nl_cmd_flash_update,
76726ccb 8697 .flags = GENL_ADMIN_PERM,
76726ccb 8698 },
0f420b6c
IS		 8699 {
8700 .cmd = DEVLINK_CMD_TRAP_GET,
8701 .doit = devlink_nl_cmd_trap_get_doit,
8702 .dumpit = devlink_nl_cmd_trap_get_dumpit,
0f420b6c
IS		 8703 /* can be retrieved by unprivileged users */
8704 },
8705 {
8706 .cmd = DEVLINK_CMD_TRAP_SET,
8707 .doit = devlink_nl_cmd_trap_set_doit,
8708 .flags = GENL_ADMIN_PERM,
0f420b6c
IS		 8709 },
8710 {
8711 .cmd = DEVLINK_CMD_TRAP_GROUP_GET,
8712 .doit = devlink_nl_cmd_trap_group_get_doit,
8713 .dumpit = devlink_nl_cmd_trap_group_get_dumpit,
0f420b6c
IS		 8714 /* can be retrieved by unprivileged users */
8715 },
8716 {
8717 .cmd = DEVLINK_CMD_TRAP_GROUP_SET,
8718 .doit = devlink_nl_cmd_trap_group_set_doit,
8719 .flags = GENL_ADMIN_PERM,
0f420b6c 8720 },
1e8c6619
IS		 8721 {
8722 .cmd = DEVLINK_CMD_TRAP_POLICER_GET,
8723 .doit = devlink_nl_cmd_trap_policer_get_doit,
8724 .dumpit = devlink_nl_cmd_trap_policer_get_dumpit,
1e8c6619
IS		 8725 /* can be retrieved by unprivileged users */
8726 },
8727 {
8728 .cmd = DEVLINK_CMD_TRAP_POLICER_SET,
8729 .doit = devlink_nl_cmd_trap_policer_set_doit,
8730 .flags = GENL_ADMIN_PERM,
1e8c6619 8731 },
bfcd3a46
JP		 8732};
8733
56989f6d 8734static struct genl_family devlink_nl_family __ro_after_init = {
489111e5
JB		 8735 .name = DEVLINK_GENL_NAME,
8736 .version = DEVLINK_GENL_VERSION,
8737 .maxattr = DEVLINK_ATTR_MAX,
3b0f31f2 8738 .policy = devlink_nl_policy,
489111e5
JB		 8739 .netnsok = true,
8740 .pre_doit = devlink_nl_pre_doit,
8741 .post_doit = devlink_nl_post_doit,
8742 .module = THIS_MODULE,
66a9b928
JK		 8743 .small_ops = devlink_nl_ops,
8744 .n_small_ops = ARRAY_SIZE(devlink_nl_ops),
489111e5
JB		 8745 .mcgrps = devlink_nl_mcgrps,
8746 .n_mcgrps = ARRAY_SIZE(devlink_nl_mcgrps),
8747};
8748
ccdf0721
MS		 8749static bool devlink_reload_actions_valid(const struct devlink_ops *ops)
8750{
dc64cc7c
MS		 8751 const struct devlink_reload_combination *comb;
8752 int i;
8753
ccdf0721
MS		 8754 if (!devlink_reload_supported(ops)) {
8755 if (WARN_ON(ops->reload_actions))
8756 return false;
8757 return true;
8758 }
8759
8760 if (WARN_ON(!ops->reload_actions ||
8761 ops->reload_actions & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
8762 ops->reload_actions >= BIT(__DEVLINK_RELOAD_ACTION_MAX)))
8763 return false;
dc64cc7c
MS		 8764
8765 if (WARN_ON(ops->reload_limits & BIT(DEVLINK_RELOAD_LIMIT_UNSPEC) ||
8766 ops->reload_limits >= BIT(__DEVLINK_RELOAD_LIMIT_MAX)))
8767 return false;
8768
8769 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++) {
8770 comb = &devlink_reload_invalid_combinations[i];
8771 if (ops->reload_actions == BIT(comb->action) &&
8772 ops->reload_limits == BIT(comb->limit))
8773 return false;
8774 }
ccdf0721
MS		 8775 return true;
8776}
8777
bfcd3a46
JP		 8778/**
8779 * devlink_alloc - Allocate new devlink instance resources
8780 *
8781 * @ops: ops
8782 * @priv_size: size of user private data
8783 *
8784 * Allocate new devlink instance resources, including devlink index
8785 * and name.
8786 */
8787struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size)
8788{
8789 struct devlink *devlink;
8790
be6fe1d8
JK		 8791 if (WARN_ON(!ops))
8792 return NULL;
8793
ccdf0721
MS		 8794 if (!devlink_reload_actions_valid(ops))
8795 return NULL;
8796
bfcd3a46
JP		 8797 devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
8798 if (!devlink)
8799 return NULL;
8800 devlink->ops = ops;
12102436 8801 xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
8273fd84 8802 __devlink_net_set(devlink, &init_net);
bfcd3a46 8803 INIT_LIST_HEAD(&devlink->port_list);
4677efc4 8804 INIT_LIST_HEAD(&devlink->rate_list);
bf797471 8805 INIT_LIST_HEAD(&devlink->sb_list);
1555d204 8806 INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
d9f9b9a4 8807 INIT_LIST_HEAD(&devlink->resource_list);
eabaef18 8808 INIT_LIST_HEAD(&devlink->param_list);
b16ebe92 8809 INIT_LIST_HEAD(&devlink->region_list);
a0bdcc59 8810 INIT_LIST_HEAD(&devlink->reporter_list);
0f420b6c
IS		 8811 INIT_LIST_HEAD(&devlink->trap_list);
8812 INIT_LIST_HEAD(&devlink->trap_group_list);
1e8c6619 8813 INIT_LIST_HEAD(&devlink->trap_policer_list);
2406e7e5 8814 mutex_init(&devlink->lock);
b587bdaf 8815 mutex_init(&devlink->reporters_lock);
bfcd3a46
JP		 8816 return devlink;
8817}
8818EXPORT_SYMBOL_GPL(devlink_alloc);
8819
8820/**
8821 * devlink_register - Register devlink instance
8822 *
8823 * @devlink: devlink
eeaadd82 8824 * @dev: parent device
bfcd3a46
JP		 8825 */
8826int devlink_register(struct devlink *devlink, struct device *dev)
8827{
d7907a2b 8828 WARN_ON(devlink->dev);
bfcd3a46 8829 devlink->dev = dev;
6553e561 8830 mutex_lock(&devlink_mutex);
bfcd3a46
JP		 8831 list_add_tail(&devlink->list, &devlink_list);
8832 devlink_notify(devlink, DEVLINK_CMD_NEW);
8833 mutex_unlock(&devlink_mutex);
8834 return 0;
8835}
8836EXPORT_SYMBOL_GPL(devlink_register);
8837
8838/**
8839 * devlink_unregister - Unregister devlink instance
8840 *
8841 * @devlink: devlink
8842 */
8843void devlink_unregister(struct devlink *devlink)
8844{
8845 mutex_lock(&devlink_mutex);
69d56e0e 8846 WARN_ON(devlink_reload_supported(devlink->ops) &&
a0c76345 8847 devlink->reload_enabled);
bfcd3a46
JP		 8848 devlink_notify(devlink, DEVLINK_CMD_DEL);
8849 list_del(&devlink->list);
8850 mutex_unlock(&devlink_mutex);
8851}
8852EXPORT_SYMBOL_GPL(devlink_unregister);
8853
a0c76345
JP		 8854/**
8855 * devlink_reload_enable - Enable reload of devlink instance
8856 *
8857 * @devlink: devlink
8858 *
8859 * Should be called at end of device initialization
8860 * process when reload operation is supported.
8861 */
8862void devlink_reload_enable(struct devlink *devlink)
8863{
8864 mutex_lock(&devlink_mutex);
8865 devlink->reload_enabled = true;
8866 mutex_unlock(&devlink_mutex);
8867}
8868EXPORT_SYMBOL_GPL(devlink_reload_enable);
8869
8870/**
8871 * devlink_reload_disable - Disable reload of devlink instance
8872 *
8873 * @devlink: devlink
8874 *
8875 * Should be called at the beginning of device cleanup
8876 * process when reload operation is supported.
8877 */
8878void devlink_reload_disable(struct devlink *devlink)
8879{
8880 mutex_lock(&devlink_mutex);
8881 /* Mutex is taken which ensures that no reload operation is in
8882 * progress while setting up forbidded flag.
8883 */
8884 devlink->reload_enabled = false;
8885 mutex_unlock(&devlink_mutex);
8886}
8887EXPORT_SYMBOL_GPL(devlink_reload_disable);
8888
bfcd3a46
JP		 8889/**
8890 * devlink_free - Free devlink instance resources
8891 *
8892 * @devlink: devlink
8893 */
8894void devlink_free(struct devlink *devlink)
8895{
b587bdaf 8896 mutex_destroy(&devlink->reporters_lock);
375cf8c6 8897 mutex_destroy(&devlink->lock);
1e8c6619 8898 WARN_ON(!list_empty(&devlink->trap_policer_list));
0f420b6c
IS		 8899 WARN_ON(!list_empty(&devlink->trap_group_list));
8900 WARN_ON(!list_empty(&devlink->trap_list));
b904aada
PP		 8901 WARN_ON(!list_empty(&devlink->reporter_list));
8902 WARN_ON(!list_empty(&devlink->region_list));
8903 WARN_ON(!list_empty(&devlink->param_list));
8904 WARN_ON(!list_empty(&devlink->resource_list));
8905 WARN_ON(!list_empty(&devlink->dpipe_table_list));
8906 WARN_ON(!list_empty(&devlink->sb_list));
4677efc4 8907 WARN_ON(!list_empty(&devlink->rate_list));
b904aada
PP		 8908 WARN_ON(!list_empty(&devlink->port_list));
8909
12102436
JK		 8910 xa_destroy(&devlink->snapshot_ids);
8911
bfcd3a46
JP		 8912 kfree(devlink);
8913}
8914EXPORT_SYMBOL_GPL(devlink_free);
8915
136bf27f
JP		 8916static void devlink_port_type_warn(struct work_struct *work)
8917{
8918 WARN(true, "Type was not set for devlink port.");
8919}
8920
8921static bool devlink_port_type_should_warn(struct devlink_port *devlink_port)
8922{
8923 /* Ignore CPU and DSA flavours. */
8924 return devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_CPU &&
cf116634
AL		 8925 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA &&
8926 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_UNUSED;
136bf27f
JP		 8927}
8928
4c582234 8929#define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600)
136bf27f
JP		 8930
8931static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
8932{
8933 if (!devlink_port_type_should_warn(devlink_port))
8934 return;
8935 /* Schedule a work to WARN in case driver does not set port
8936 * type within timeout.
8937 */
8938 schedule_delayed_work(&devlink_port->type_warn_dw,
8939 DEVLINK_PORT_TYPE_WARN_TIMEOUT);
8940}
8941
8942static void devlink_port_type_warn_cancel(struct devlink_port *devlink_port)
8943{
8944 if (!devlink_port_type_should_warn(devlink_port))
8945 return;
8946 cancel_delayed_work_sync(&devlink_port->type_warn_dw);
8947}
8948
bfcd3a46
JP		 8949/**
8950 * devlink_port_register - Register devlink port
8951 *
8952 * @devlink: devlink
8953 * @devlink_port: devlink port
eeaadd82 8954 * @port_index: driver-specific numerical identifier of the port
bfcd3a46
JP		 8955 *
8956 * Register devlink port with provided port index. User can use
8957 * any indexing, even hw-related one. devlink_port structure
8958 * is convenient to be embedded inside user driver private structure.
8959 * Note that the caller should take care of zeroing the devlink_port
8960 * structure.
8961 */
8962int devlink_port_register(struct devlink *devlink,
8963 struct devlink_port *devlink_port,
8964 unsigned int port_index)
8965{
2406e7e5 8966 mutex_lock(&devlink->lock);
bfcd3a46 8967 if (devlink_port_index_exists(devlink, port_index)) {
2406e7e5 8968 mutex_unlock(&devlink->lock);
bfcd3a46
JP		 8969 return -EEXIST;
8970 }
d7907a2b
LR		 8971
8972 WARN_ON(devlink_port->devlink);
bfcd3a46
JP		 8973 devlink_port->devlink = devlink;
8974 devlink_port->index = port_index;
b8f97554 8975 spin_lock_init(&devlink_port->type_lock);
79604c5d
PP		 8976 INIT_LIST_HEAD(&devlink_port->reporter_list);
8977 mutex_init(&devlink_port->reporters_lock);
bfcd3a46 8978 list_add_tail(&devlink_port->list, &devlink->port_list);
39e6160e 8979 INIT_LIST_HEAD(&devlink_port->param_list);
544e7c33 8980 INIT_LIST_HEAD(&devlink_port->region_list);
2406e7e5 8981 mutex_unlock(&devlink->lock);
136bf27f
JP		 8982 INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn);
8983 devlink_port_type_warn_schedule(devlink_port);
bfcd3a46
JP		 8984 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
8985 return 0;
8986}
8987EXPORT_SYMBOL_GPL(devlink_port_register);
8988
8989/**
8990 * devlink_port_unregister - Unregister devlink port
8991 *
8992 * @devlink_port: devlink port
8993 */
8994void devlink_port_unregister(struct devlink_port *devlink_port)
8995{
2406e7e5
AS		 8996 struct devlink *devlink = devlink_port->devlink;
8997
136bf27f 8998 devlink_port_type_warn_cancel(devlink_port);
bfcd3a46 8999 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
2406e7e5 9000 mutex_lock(&devlink->lock);
bfcd3a46 9001 list_del(&devlink_port->list);
2406e7e5 9002 mutex_unlock(&devlink->lock);
79604c5d 9003 WARN_ON(!list_empty(&devlink_port->reporter_list));
544e7c33 9004 WARN_ON(!list_empty(&devlink_port->region_list));
79604c5d 9005 mutex_destroy(&devlink_port->reporters_lock);
bfcd3a46
JP		 9006}
9007EXPORT_SYMBOL_GPL(devlink_port_unregister);
9008
9009static void __devlink_port_type_set(struct devlink_port *devlink_port,
9010 enum devlink_port_type type,
9011 void *type_dev)
9012{
d7907a2b 9013 if (WARN_ON(!devlink_port->devlink))
2b239e70 9014 return;
136bf27f 9015 devlink_port_type_warn_cancel(devlink_port);
0f420b6c 9016 spin_lock_bh(&devlink_port->type_lock);
bfcd3a46
JP		 9017 devlink_port->type = type;
9018 devlink_port->type_dev = type_dev;
0f420b6c 9019 spin_unlock_bh(&devlink_port->type_lock);
bfcd3a46
JP		 9020 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
9021}
9022
3ea87ca7
JK		 9023static void devlink_port_type_netdev_checks(struct devlink_port *devlink_port,
9024 struct net_device *netdev)
bfcd3a46 9025{
119c0b57
JP		 9026 const struct net_device_ops *ops = netdev->netdev_ops;
9027
746364f2
JP		 9028 /* If driver registers devlink port, it should set devlink port
9029 * attributes accordingly so the compat functions are called
9030 * and the original ops are not used.
9031 */
119c0b57 9032 if (ops->ndo_get_phys_port_name) {
746364f2
JP		 9033 /* Some drivers use the same set of ndos for netdevs
9034 * that have devlink_port registered and also for
9035 * those who don't. Make sure that ndo_get_phys_port_name
9036 * returns -EOPNOTSUPP here in case it is defined.
9037 * Warn if not.
9038 */
746364f2
JP		 9039 char name[IFNAMSIZ];
9040 int err;
9041
9042 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name));
9043 WARN_ON(err != -EOPNOTSUPP);
9044 }
119c0b57
JP		 9045 if (ops->ndo_get_port_parent_id) {
9046 /* Some drivers use the same set of ndos for netdevs
9047 * that have devlink_port registered and also for
9048 * those who don't. Make sure that ndo_get_port_parent_id
9049 * returns -EOPNOTSUPP here in case it is defined.
9050 * Warn if not.
9051 */
9052 struct netdev_phys_item_id ppid;
9053 int err;
9054
9055 err = ops->ndo_get_port_parent_id(netdev, &ppid);
9056 WARN_ON(err != -EOPNOTSUPP);
9057 }
3ea87ca7
JK		 9058}
9059
9060/**
9061 * devlink_port_type_eth_set - Set port type to Ethernet
9062 *
9063 * @devlink_port: devlink port
9064 * @netdev: related netdevice
9065 */
9066void devlink_port_type_eth_set(struct devlink_port *devlink_port,
9067 struct net_device *netdev)
9068{
9069 if (netdev)
9070 devlink_port_type_netdev_checks(devlink_port, netdev);
9071 else
9072 dev_warn(devlink_port->devlink->dev,
9073 "devlink port type for port %d set to Ethernet without a software interface reference, device type not supported by the kernel?\n",
9074 devlink_port->index);
9075
773b1f38 9076 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, netdev);
bfcd3a46
JP		 9077}
9078EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
9079
9080/**
9081 * devlink_port_type_ib_set - Set port type to InfiniBand
9082 *
9083 * @devlink_port: devlink port
9084 * @ibdev: related IB device
9085 */
9086void devlink_port_type_ib_set(struct devlink_port *devlink_port,
9087 struct ib_device *ibdev)
9088{
773b1f38 9089 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev);
bfcd3a46
JP		 9090}
9091EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
9092
9093/**
9094 * devlink_port_type_clear - Clear port type
9095 *
9096 * @devlink_port: devlink port
9097 */
9098void devlink_port_type_clear(struct devlink_port *devlink_port)
9099{
773b1f38 9100 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL);
136bf27f 9101 devlink_port_type_warn_schedule(devlink_port);
bfcd3a46
JP		 9102}
9103EXPORT_SYMBOL_GPL(devlink_port_type_clear);
9104
378ef01b 9105static int __devlink_port_attrs_set(struct devlink_port *devlink_port,
71ad8d55 9106 enum devlink_port_flavour flavour)
378ef01b
PP		 9107{
9108 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9109
10a429ba 9110 devlink_port->attrs_set = true;
378ef01b 9111 attrs->flavour = flavour;
71ad8d55 9112 if (attrs->switch_id.id_len) {
46737a19 9113 devlink_port->switch_port = true;
71ad8d55
DR		 9114 if (WARN_ON(attrs->switch_id.id_len > MAX_PHYS_ITEM_ID_LEN))
9115 attrs->switch_id.id_len = MAX_PHYS_ITEM_ID_LEN;
378ef01b 9116 } else {
46737a19 9117 devlink_port->switch_port = false;
378ef01b
PP		 9118 }
9119 return 0;
9120}
9121
bfcd3a46 9122/**
b9ffcbaf 9123 * devlink_port_attrs_set - Set port attributes
bfcd3a46
JP		 9124 *
9125 * @devlink_port: devlink port
71ad8d55 9126 * @attrs: devlink port attrs
bfcd3a46 9127 */
b9ffcbaf 9128void devlink_port_attrs_set(struct devlink_port *devlink_port,
71ad8d55 9129 struct devlink_port_attrs *attrs)
bfcd3a46 9130{
378ef01b 9131 int ret;
b9ffcbaf 9132
d7907a2b 9133 if (WARN_ON(devlink_port->devlink))
9f73bd1c 9134 return;
71ad8d55
DR		 9135 devlink_port->attrs = *attrs;
9136 ret = __devlink_port_attrs_set(devlink_port, attrs->flavour);
378ef01b 9137 if (ret)
45b86112 9138 return;
a0f49b54 9139 WARN_ON(attrs->splittable && attrs->split);
bfcd3a46 9140}
b9ffcbaf 9141EXPORT_SYMBOL_GPL(devlink_port_attrs_set);
bfcd3a46 9142
98fd2d65
PP		 9143/**
9144 * devlink_port_attrs_pci_pf_set - Set PCI PF port attributes
9145 *
9146 * @devlink_port: devlink port
3a2d9588 9147 * @controller: associated controller number for the devlink port instance
98fd2d65 9148 * @pf: associated PF for the devlink port instance
05b595e9 9149 * @external: indicates if the port is for an external controller
98fd2d65 9150 */
3a2d9588
PP		 9151void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller,
9152 u16 pf, bool external)
98fd2d65
PP		 9153{
9154 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9155 int ret;
9156
d7907a2b 9157 if (WARN_ON(devlink_port->devlink))
9f73bd1c 9158 return;
98fd2d65 9159 ret = __devlink_port_attrs_set(devlink_port,
71ad8d55 9160 DEVLINK_PORT_FLAVOUR_PCI_PF);
98fd2d65
PP		 9161 if (ret)
9162 return;
3a2d9588 9163 attrs->pci_pf.controller = controller;
98fd2d65 9164 attrs->pci_pf.pf = pf;
05b595e9 9165 attrs->pci_pf.external = external;
98fd2d65
PP		 9166}
9167EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set);
9168
e41b6bf3
PP		 9169/**
9170 * devlink_port_attrs_pci_vf_set - Set PCI VF port attributes
9171 *
9172 * @devlink_port: devlink port
3a2d9588 9173 * @controller: associated controller number for the devlink port instance
e41b6bf3
PP		 9174 * @pf: associated PF for the devlink port instance
9175 * @vf: associated VF of a PF for the devlink port instance
05b595e9 9176 * @external: indicates if the port is for an external controller
e41b6bf3 9177 */
3a2d9588 9178void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller,
05b595e9 9179 u16 pf, u16 vf, bool external)
e41b6bf3
PP		 9180{
9181 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9182 int ret;
9183
d7907a2b 9184 if (WARN_ON(devlink_port->devlink))
9f73bd1c 9185 return;
e41b6bf3 9186 ret = __devlink_port_attrs_set(devlink_port,
71ad8d55 9187 DEVLINK_PORT_FLAVOUR_PCI_VF);
e41b6bf3
PP		 9188 if (ret)
9189 return;
3a2d9588 9190 attrs->pci_vf.controller = controller;
e41b6bf3
PP		 9191 attrs->pci_vf.pf = pf;
9192 attrs->pci_vf.vf = vf;
05b595e9 9193 attrs->pci_vf.external = external;
e41b6bf3
PP		 9194}
9195EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set);
9196
b8288837
PP		 9197/**
9198 * devlink_port_attrs_pci_sf_set - Set PCI SF port attributes
9199 *
9200 * @devlink_port: devlink port
9201 * @controller: associated controller number for the devlink port instance
9202 * @pf: associated PF for the devlink port instance
9203 * @sf: associated SF of a PF for the devlink port instance
a1ab3e45 9204 * @external: indicates if the port is for an external controller
b8288837
PP		 9205 */
9206void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller,
a1ab3e45 9207 u16 pf, u32 sf, bool external)
b8288837
PP		 9208{
9209 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9210 int ret;
9211
d7907a2b 9212 if (WARN_ON(devlink_port->devlink))
b8288837
PP		 9213 return;
9214 ret = __devlink_port_attrs_set(devlink_port,
9215 DEVLINK_PORT_FLAVOUR_PCI_SF);
9216 if (ret)
9217 return;
9218 attrs->pci_sf.controller = controller;
9219 attrs->pci_sf.pf = pf;
9220 attrs->pci_sf.sf = sf;
a1ab3e45 9221 attrs->pci_sf.external = external;
b8288837
PP		 9222}
9223EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set);
9224
4677efc4
DL		 9225/**
9226 * devlink_rate_leaf_create - create devlink rate leaf
9227 *
9228 * @devlink_port: devlink port object to create rate object on
9229 * @priv: driver private data
9230 *
9231 * Create devlink rate object of type leaf on provided @devlink_port.
9232 * Throws call trace if @devlink_port already has a devlink rate object.
9233 *
9234 * Context: Takes and release devlink->lock <mutex>.
9235 *
9236 * Return: -ENOMEM if failed to allocate rate object, 0 otherwise.
9237 */
9238int
9239devlink_rate_leaf_create(struct devlink_port *devlink_port, void *priv)
9240{
9241 struct devlink *devlink = devlink_port->devlink;
9242 struct devlink_rate *devlink_rate;
9243
9244 devlink_rate = kzalloc(sizeof(*devlink_rate), GFP_KERNEL);
9245 if (!devlink_rate)
9246 return -ENOMEM;
9247
9248 mutex_lock(&devlink->lock);
9249 WARN_ON(devlink_port->devlink_rate);
9250 devlink_rate->type = DEVLINK_RATE_TYPE_LEAF;
9251 devlink_rate->devlink = devlink;
9252 devlink_rate->devlink_port = devlink_port;
9253 devlink_rate->priv = priv;
9254 list_add_tail(&devlink_rate->list, &devlink->rate_list);
9255 devlink_port->devlink_rate = devlink_rate;
9256 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_NEW);
9257 mutex_unlock(&devlink->lock);
9258
9259 return 0;
9260}
9261EXPORT_SYMBOL_GPL(devlink_rate_leaf_create);
9262
9263/**
9264 * devlink_rate_leaf_destroy - destroy devlink rate leaf
9265 *
9266 * @devlink_port: devlink port linked to the rate object
9267 *
9268 * Context: Takes and release devlink->lock <mutex>.
9269 */
9270void devlink_rate_leaf_destroy(struct devlink_port *devlink_port)
9271{
9272 struct devlink_rate *devlink_rate = devlink_port->devlink_rate;
9273 struct devlink *devlink = devlink_port->devlink;
9274
9275 if (!devlink_rate)
9276 return;
9277
9278 mutex_lock(&devlink->lock);
9279 devlink_rate_notify(devlink_rate, DEVLINK_CMD_RATE_DEL);
1321ed5e
DL		 9280 if (devlink_rate->parent)
9281 refcount_dec(&devlink_rate->parent->refcnt);
4677efc4
DL		 9282 list_del(&devlink_rate->list);
9283 devlink_port->devlink_rate = NULL;
9284 mutex_unlock(&devlink->lock);
9285 kfree(devlink_rate);
9286}
9287EXPORT_SYMBOL_GPL(devlink_rate_leaf_destroy);
9288
a8ecb93e
DL		 9289/**
9290 * devlink_rate_nodes_destroy - destroy all devlink rate nodes on device
9291 *
9292 * @devlink: devlink instance
9293 *
d7555984
DL		 9294 * Unset parent for all rate objects and destroy all rate nodes
9295 * on specified device.
a8ecb93e
DL		 9296 *
9297 * Context: Takes and release devlink->lock <mutex>.
9298 */
9299void devlink_rate_nodes_destroy(struct devlink *devlink)
9300{
9301 static struct devlink_rate *devlink_rate, *tmp;
9302 const struct devlink_ops *ops = devlink->ops;
9303
9304 mutex_lock(&devlink->lock);
d7555984
DL		 9305 list_for_each_entry(devlink_rate, &devlink->rate_list, list) {
9306 if (!devlink_rate->parent)
9307 continue;
9308
9309 refcount_dec(&devlink_rate->parent->refcnt);
9310 if (devlink_rate_is_leaf(devlink_rate))
9311 ops->rate_leaf_parent_set(devlink_rate, NULL, devlink_rate->priv,
9312 NULL, NULL);
9313 else if (devlink_rate_is_node(devlink_rate))
9314 ops->rate_node_parent_set(devlink_rate, NULL, devlink_rate->priv,
9315 NULL, NULL);
9316 }
a8ecb93e
DL		 9317 list_for_each_entry_safe(devlink_rate, tmp, &devlink->rate_list, list) {
9318 if (devlink_rate_is_node(devlink_rate)) {
9319 ops->rate_node_del(devlink_rate, devlink_rate->priv, NULL);
9320 list_del(&devlink_rate->list);
9321 kfree(devlink_rate->name);
9322 kfree(devlink_rate);
9323 }
9324 }
9325 mutex_unlock(&devlink->lock);
9326}
9327EXPORT_SYMBOL_GPL(devlink_rate_nodes_destroy);
9328
af3836df
JP		 9329static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port,
9330 char *name, size_t len)
08474c1a
JP		 9331{
9332 struct devlink_port_attrs *attrs = &devlink_port->attrs;
9333 int n = 0;
9334
10a429ba 9335 if (!devlink_port->attrs_set)
08474c1a
JP		 9336 return -EOPNOTSUPP;
9337
9338 switch (attrs->flavour) {
9339 case DEVLINK_PORT_FLAVOUR_PHYSICAL:
acf1ee44 9340 case DEVLINK_PORT_FLAVOUR_VIRTUAL:
f285f37c
JP		 9341 n = snprintf(name, len, "p%u", attrs->phys.port_number);
9342 if (n < len && attrs->split)
9343 n += snprintf(name + n, len - n, "s%u",
9344 attrs->phys.split_subport_number);
08474c1a 9345 if (!attrs->split)
378ef01b 9346 n = snprintf(name, len, "p%u", attrs->phys.port_number);
08474c1a 9347 else
378ef01b
PP		 9348 n = snprintf(name, len, "p%us%u",
9349 attrs->phys.port_number,
9350 attrs->phys.split_subport_number);
12628565 9351
08474c1a
JP		 9352 break;
9353 case DEVLINK_PORT_FLAVOUR_CPU:
9354 case DEVLINK_PORT_FLAVOUR_DSA:
cf116634 9355 case DEVLINK_PORT_FLAVOUR_UNUSED:
08474c1a
JP		 9356 /* As CPU and DSA ports do not have a netdevice associated
9357 * case should not ever happen.
9358 */
9359 WARN_ON(1);
9360 return -EINVAL;
98fd2d65 9361 case DEVLINK_PORT_FLAVOUR_PCI_PF:
66b17082
PP		 9362 if (attrs->pci_pf.external) {
9363 n = snprintf(name, len, "c%u", attrs->pci_pf.controller);
9364 if (n >= len)
9365 return -EINVAL;
9366 len -= n;
9367 name += n;
9368 }
98fd2d65
PP		 9369 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf);
9370 break;
e41b6bf3 9371 case DEVLINK_PORT_FLAVOUR_PCI_VF:
66b17082
PP		 9372 if (attrs->pci_vf.external) {
9373 n = snprintf(name, len, "c%u", attrs->pci_vf.controller);
9374 if (n >= len)
9375 return -EINVAL;
9376 len -= n;
9377 name += n;
9378 }
e41b6bf3
PP		 9379 n = snprintf(name, len, "pf%uvf%u",
9380 attrs->pci_vf.pf, attrs->pci_vf.vf);
9381 break;
b8288837 9382 case DEVLINK_PORT_FLAVOUR_PCI_SF:
a1ab3e45
PP		 9383 if (attrs->pci_sf.external) {
9384 n = snprintf(name, len, "c%u", attrs->pci_sf.controller);
9385 if (n >= len)
9386 return -EINVAL;
9387 len -= n;
9388 name += n;
9389 }
b8288837
PP		 9390 n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf,
9391 attrs->pci_sf.sf);
9392 break;
08474c1a
JP		 9393 }
9394
9395 if (n >= len)
9396 return -EINVAL;
9397
9398 return 0;
9399}
af3836df 9400
bf797471
JP		 9401int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
9402 u32 size, u16 ingress_pools_count,
9403 u16 egress_pools_count, u16 ingress_tc_count,
9404 u16 egress_tc_count)
9405{
9406 struct devlink_sb *devlink_sb;
9407 int err = 0;
9408
2406e7e5 9409 mutex_lock(&devlink->lock);
bf797471
JP		 9410 if (devlink_sb_index_exists(devlink, sb_index)) {
9411 err = -EEXIST;
9412 goto unlock;
9413 }
9414
9415 devlink_sb = kzalloc(sizeof(*devlink_sb), GFP_KERNEL);
9416 if (!devlink_sb) {
9417 err = -ENOMEM;
9418 goto unlock;
9419 }
9420 devlink_sb->index = sb_index;
9421 devlink_sb->size = size;
9422 devlink_sb->ingress_pools_count = ingress_pools_count;
9423 devlink_sb->egress_pools_count = egress_pools_count;
9424 devlink_sb->ingress_tc_count = ingress_tc_count;
9425 devlink_sb->egress_tc_count = egress_tc_count;
9426 list_add_tail(&devlink_sb->list, &devlink->sb_list);
9427unlock:
2406e7e5 9428 mutex_unlock(&devlink->lock);
bf797471
JP		 9429 return err;
9430}
9431EXPORT_SYMBOL_GPL(devlink_sb_register);
9432
9433void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index)
9434{
9435 struct devlink_sb *devlink_sb;
9436
2406e7e5 9437 mutex_lock(&devlink->lock);
bf797471
JP		 9438 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
9439 WARN_ON(!devlink_sb);
9440 list_del(&devlink_sb->list);
2406e7e5 9441 mutex_unlock(&devlink->lock);
bf797471
JP		 9442 kfree(devlink_sb);
9443}
9444EXPORT_SYMBOL_GPL(devlink_sb_unregister);
9445
1555d204
AS		 9446/**
9447 * devlink_dpipe_headers_register - register dpipe headers
9448 *
9449 * @devlink: devlink
9450 * @dpipe_headers: dpipe header array
9451 *
9452 * Register the headers supported by hardware.
9453 */
9454int devlink_dpipe_headers_register(struct devlink *devlink,
9455 struct devlink_dpipe_headers *dpipe_headers)
9456{
2406e7e5 9457 mutex_lock(&devlink->lock);
1555d204 9458 devlink->dpipe_headers = dpipe_headers;
2406e7e5 9459 mutex_unlock(&devlink->lock);
1555d204
AS		 9460 return 0;
9461}
9462EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register);
9463
9464/**
9465 * devlink_dpipe_headers_unregister - unregister dpipe headers
9466 *
9467 * @devlink: devlink
9468 *
9469 * Unregister the headers supported by hardware.
9470 */
9471void devlink_dpipe_headers_unregister(struct devlink *devlink)
9472{
2406e7e5 9473 mutex_lock(&devlink->lock);
1555d204 9474 devlink->dpipe_headers = NULL;
2406e7e5 9475 mutex_unlock(&devlink->lock);
1555d204
AS		 9476}
9477EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister);
9478
9479/**
9480 * devlink_dpipe_table_counter_enabled - check if counter allocation
9481 * required
9482 * @devlink: devlink
9483 * @table_name: tables name
9484 *
9485 * Used by driver to check if counter allocation is required.
9486 * After counter allocation is turned on the table entries
9487 * are updated to include counter statistics.
9488 *
9489 * After that point on the driver must respect the counter
9490 * state so that each entry added to the table is added
9491 * with a counter.
9492 */
9493bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
9494 const char *table_name)
9495{
9496 struct devlink_dpipe_table *table;
9497 bool enabled;
9498
9499 rcu_read_lock();
9500 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2eb51c75 9501 table_name, devlink);
1555d204
AS		 9502 enabled = false;
9503 if (table)
9504 enabled = table->counters_enabled;
9505 rcu_read_unlock();
9506 return enabled;
9507}
9508EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
9509
9510/**
9511 * devlink_dpipe_table_register - register dpipe table
9512 *
9513 * @devlink: devlink
9514 * @table_name: table name
9515 * @table_ops: table ops
9516 * @priv: priv
1555d204
AS		 9517 * @counter_control_extern: external control for counters
9518 */
9519int devlink_dpipe_table_register(struct devlink *devlink,
9520 const char *table_name,
9521 struct devlink_dpipe_table_ops *table_ops,
ffd3cdcc 9522 void *priv, bool counter_control_extern)
1555d204
AS		 9523{
9524 struct devlink_dpipe_table *table;
6132c1d9 9525 int err = 0;
1555d204 9526
ffd3cdcc
AS		 9527 if (WARN_ON(!table_ops->size_get))
9528 return -EINVAL;
9529
6132c1d9
MB		 9530 mutex_lock(&devlink->lock);
9531
2eb51c75
MB		 9532 if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name,
9533 devlink)) {
6132c1d9
MB		 9534 err = -EEXIST;
9535 goto unlock;
9536 }
9537
1555d204 9538 table = kzalloc(sizeof(*table), GFP_KERNEL);
6132c1d9
MB		 9539 if (!table) {
9540 err = -ENOMEM;
9541 goto unlock;
9542 }
1555d204
AS		 9543
9544 table->name = table_name;
9545 table->table_ops = table_ops;
9546 table->priv = priv;
1555d204
AS		 9547 table->counter_control_extern = counter_control_extern;
9548
1555d204 9549 list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
6132c1d9 9550unlock:
2406e7e5 9551 mutex_unlock(&devlink->lock);
6132c1d9 9552 return err;
1555d204
AS		 9553}
9554EXPORT_SYMBOL_GPL(devlink_dpipe_table_register);
9555
9556/**
9557 * devlink_dpipe_table_unregister - unregister dpipe table
9558 *
9559 * @devlink: devlink
9560 * @table_name: table name
9561 */
9562void devlink_dpipe_table_unregister(struct devlink *devlink,
9563 const char *table_name)
9564{
9565 struct devlink_dpipe_table *table;
9566
2406e7e5 9567 mutex_lock(&devlink->lock);
1555d204 9568 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2eb51c75 9569 table_name, devlink);
1555d204
AS		 9570 if (!table)
9571 goto unlock;
9572 list_del_rcu(&table->list);
2406e7e5 9573 mutex_unlock(&devlink->lock);
1555d204
AS		 9574 kfree_rcu(table, rcu);
9575 return;
9576unlock:
2406e7e5 9577 mutex_unlock(&devlink->lock);
1555d204
AS		 9578}
9579EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister);
9580
d9f9b9a4
AS		 9581/**
9582 * devlink_resource_register - devlink resource register
9583 *
9584 * @devlink: devlink
9585 * @resource_name: resource's name
d9f9b9a4
AS		 9586 * @resource_size: resource's size
9587 * @resource_id: resource's id
eeaadd82
JK		 9588 * @parent_resource_id: resource's parent id
9589 * @size_params: size parameters
321f7ab0
DR		 9590 *
9591 * Generic resources should reuse the same names across drivers.
9592 * Please see the generic resources list at:
9593 * Documentation/networking/devlink/devlink-resource.rst
d9f9b9a4
AS		 9594 */
9595int devlink_resource_register(struct devlink *devlink,
9596 const char *resource_name,
d9f9b9a4
AS		 9597 u64 resource_size,
9598 u64 resource_id,
9599 u64 parent_resource_id,
fc56be47 9600 const struct devlink_resource_size_params *size_params)
d9f9b9a4
AS		 9601{
9602 struct devlink_resource *resource;
9603 struct list_head *resource_list;
14530746 9604 bool top_hierarchy;
d9f9b9a4
AS		 9605 int err = 0;
9606
14530746
DA		 9607 top_hierarchy = parent_resource_id == DEVLINK_RESOURCE_ID_PARENT_TOP;
9608
d9f9b9a4
AS		 9609 mutex_lock(&devlink->lock);
9610 resource = devlink_resource_find(devlink, NULL, resource_id);
9611 if (resource) {
9612 err = -EINVAL;
9613 goto out;
9614 }
9615
9616 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
9617 if (!resource) {
9618 err = -ENOMEM;
9619 goto out;
9620 }
9621
9622 if (top_hierarchy) {
9623 resource_list = &devlink->resource_list;
9624 } else {
9625 struct devlink_resource *parent_resource;
9626
9627 parent_resource = devlink_resource_find(devlink, NULL,
9628 parent_resource_id);
9629 if (parent_resource) {
9630 resource_list = &parent_resource->resource_list;
9631 resource->parent = parent_resource;
9632 } else {
b75703de 9633 kfree(resource);
d9f9b9a4
AS		 9634 err = -EINVAL;
9635 goto out;
9636 }
9637 }
9638
9639 resource->name = resource_name;
9640 resource->size = resource_size;
9641 resource->size_new = resource_size;
9642 resource->id = resource_id;
d9f9b9a4 9643 resource->size_valid = true;
77d27096
JP		 9644 memcpy(&resource->size_params, size_params,
9645 sizeof(resource->size_params));
d9f9b9a4
AS		 9646 INIT_LIST_HEAD(&resource->resource_list);
9647 list_add_tail(&resource->list, resource_list);
9648out:
9649 mutex_unlock(&devlink->lock);
9650 return err;
9651}
9652EXPORT_SYMBOL_GPL(devlink_resource_register);
9653
9654/**
9655 * devlink_resources_unregister - free all resources
9656 *
9657 * @devlink: devlink
9658 * @resource: resource
9659 */
9660void devlink_resources_unregister(struct devlink *devlink,
9661 struct devlink_resource *resource)
9662{
9663 struct devlink_resource *tmp, *child_resource;
9664 struct list_head *resource_list;
9665
9666 if (resource)
9667 resource_list = &resource->resource_list;
9668 else
9669 resource_list = &devlink->resource_list;
9670
9671 if (!resource)
9672 mutex_lock(&devlink->lock);
9673
9674 list_for_each_entry_safe(child_resource, tmp, resource_list, list) {
9675 devlink_resources_unregister(devlink, child_resource);
9676 list_del(&child_resource->list);
9677 kfree(child_resource);
9678 }
9679
9680 if (!resource)
9681 mutex_unlock(&devlink->lock);
9682}
9683EXPORT_SYMBOL_GPL(devlink_resources_unregister);
9684
9685/**
9686 * devlink_resource_size_get - get and update size
9687 *
9688 * @devlink: devlink
9689 * @resource_id: the requested resource id
9690 * @p_resource_size: ptr to update
9691 */
9692int devlink_resource_size_get(struct devlink *devlink,
9693 u64 resource_id,
9694 u64 *p_resource_size)
9695{
9696 struct devlink_resource *resource;
9697 int err = 0;
9698
9699 mutex_lock(&devlink->lock);
9700 resource = devlink_resource_find(devlink, NULL, resource_id);
9701 if (!resource) {
9702 err = -EINVAL;
9703 goto out;
9704 }
9705 *p_resource_size = resource->size_new;
9706 resource->size = resource->size_new;
9707out:
9708 mutex_unlock(&devlink->lock);
9709 return err;
9710}
9711EXPORT_SYMBOL_GPL(devlink_resource_size_get);
9712
56dc7cd0
AS		 9713/**
9714 * devlink_dpipe_table_resource_set - set the resource id
9715 *
9716 * @devlink: devlink
9717 * @table_name: table name
9718 * @resource_id: resource id
9719 * @resource_units: number of resource's units consumed per table's entry
9720 */
9721int devlink_dpipe_table_resource_set(struct devlink *devlink,
9722 const char *table_name, u64 resource_id,
9723 u64 resource_units)
9724{
9725 struct devlink_dpipe_table *table;
9726 int err = 0;
9727
9728 mutex_lock(&devlink->lock);
9729 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2eb51c75 9730 table_name, devlink);
56dc7cd0
AS		 9731 if (!table) {
9732 err = -EINVAL;
9733 goto out;
9734 }
9735 table->resource_id = resource_id;
9736 table->resource_units = resource_units;
9737 table->resource_valid = true;
9738out:
9739 mutex_unlock(&devlink->lock);
9740 return err;
9741}
9742EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set);
9743
fc56be47
JP		 9744/**
9745 * devlink_resource_occ_get_register - register occupancy getter
9746 *
9747 * @devlink: devlink
9748 * @resource_id: resource id
9749 * @occ_get: occupancy getter callback
9750 * @occ_get_priv: occupancy getter callback priv
9751 */
9752void devlink_resource_occ_get_register(struct devlink *devlink,
9753 u64 resource_id,
9754 devlink_resource_occ_get_t *occ_get,
9755 void *occ_get_priv)
9756{
9757 struct devlink_resource *resource;
9758
9759 mutex_lock(&devlink->lock);
9760 resource = devlink_resource_find(devlink, NULL, resource_id);
9761 if (WARN_ON(!resource))
9762 goto out;
9763 WARN_ON(resource->occ_get);
9764
9765 resource->occ_get = occ_get;
9766 resource->occ_get_priv = occ_get_priv;
9767out:
9768 mutex_unlock(&devlink->lock);
9769}
9770EXPORT_SYMBOL_GPL(devlink_resource_occ_get_register);
9771
9772/**
9773 * devlink_resource_occ_get_unregister - unregister occupancy getter
9774 *
9775 * @devlink: devlink
9776 * @resource_id: resource id
9777 */
9778void devlink_resource_occ_get_unregister(struct devlink *devlink,
9779 u64 resource_id)
9780{
9781 struct devlink_resource *resource;
9782
9783 mutex_lock(&devlink->lock);
9784 resource = devlink_resource_find(devlink, NULL, resource_id);
9785 if (WARN_ON(!resource))
9786 goto out;
9787 WARN_ON(!resource->occ_get);
9788
9789 resource->occ_get = NULL;
9790 resource->occ_get_priv = NULL;
9791out:
9792 mutex_unlock(&devlink->lock);
9793}
9794EXPORT_SYMBOL_GPL(devlink_resource_occ_get_unregister);
9795
39e6160e
VV		 9796static int devlink_param_verify(const struct devlink_param *param)
9797{
9798 if (!param || !param->name || !param->supported_cmodes)
9799 return -EINVAL;
9800 if (param->generic)
9801 return devlink_param_generic_verify(param);
9802 else
9803 return devlink_param_driver_verify(param);
9804}
9805
9806static int __devlink_params_register(struct devlink *devlink,
c1e5786d 9807 unsigned int port_index,
39e6160e
VV		 9808 struct list_head *param_list,
9809 const struct devlink_param *params,
c1e5786d
VV		 9810 size_t params_count,
9811 enum devlink_command reg_cmd,
9812 enum devlink_command unreg_cmd)
eabaef18
MS		 9813{
9814 const struct devlink_param *param = params;
9815 int i;
9816 int err;
9817
9818 mutex_lock(&devlink->lock);
9819 for (i = 0; i < params_count; i++, param++) {
39e6160e
VV		 9820 err = devlink_param_verify(param);
9821 if (err)
eabaef18 9822 goto rollback;
39e6160e 9823
c1e5786d
VV		 9824 err = devlink_param_register_one(devlink, port_index,
9825 param_list, param, reg_cmd);
eabaef18
MS		 9826 if (err)
9827 goto rollback;
9828 }
9829
9830 mutex_unlock(&devlink->lock);
9831 return 0;
9832
9833rollback:
9834 if (!i)
9835 goto unlock;
9836 for (param--; i > 0; i--, param--)
c1e5786d
VV		 9837 devlink_param_unregister_one(devlink, port_index, param_list,
9838 param, unreg_cmd);
eabaef18
MS		 9839unlock:
9840 mutex_unlock(&devlink->lock);
9841 return err;
9842}
39e6160e
VV		 9843
9844static void __devlink_params_unregister(struct devlink *devlink,
c1e5786d 9845 unsigned int port_index,
39e6160e
VV		 9846 struct list_head *param_list,
9847 const struct devlink_param *params,
c1e5786d
VV		 9848 size_t params_count,
9849 enum devlink_command cmd)
39e6160e
VV		 9850{
9851 const struct devlink_param *param = params;
9852 int i;
9853
9854 mutex_lock(&devlink->lock);
9855 for (i = 0; i < params_count; i++, param++)
c1e5786d
VV		 9856 devlink_param_unregister_one(devlink, 0, param_list, param,
9857 cmd);
39e6160e
VV		 9858 mutex_unlock(&devlink->lock);
9859}
9860
9861/**
9862 * devlink_params_register - register configuration parameters
9863 *
9864 * @devlink: devlink
9865 * @params: configuration parameters array
9866 * @params_count: number of parameters provided
9867 *
9868 * Register the configuration parameters supported by the driver.
9869 */
9870int devlink_params_register(struct devlink *devlink,
9871 const struct devlink_param *params,
9872 size_t params_count)
9873{
c1e5786d
VV		 9874 return __devlink_params_register(devlink, 0, &devlink->param_list,
9875 params, params_count,
9876 DEVLINK_CMD_PARAM_NEW,
9877 DEVLINK_CMD_PARAM_DEL);
39e6160e 9878}
eabaef18
MS		 9879EXPORT_SYMBOL_GPL(devlink_params_register);
9880
9881/**
9882 * devlink_params_unregister - unregister configuration parameters
9883 * @devlink: devlink
9884 * @params: configuration parameters to unregister
9885 * @params_count: number of parameters provided
9886 */
9887void devlink_params_unregister(struct devlink *devlink,
9888 const struct devlink_param *params,
9889 size_t params_count)
9890{
c1e5786d
VV		 9891 return __devlink_params_unregister(devlink, 0, &devlink->param_list,
9892 params, params_count,
9893 DEVLINK_CMD_PARAM_DEL);
eabaef18
MS		 9894}
9895EXPORT_SYMBOL_GPL(devlink_params_unregister);
9896
7c62cfb8
JP		 9897/**
9898 * devlink_params_publish - publish configuration parameters
9899 *
9900 * @devlink: devlink
9901 *
9902 * Publish previously registered configuration parameters.
9903 */
9904void devlink_params_publish(struct devlink *devlink)
9905{
9906 struct devlink_param_item *param_item;
9907
9908 list_for_each_entry(param_item, &devlink->param_list, list) {
9909 if (param_item->published)
9910 continue;
9911 param_item->published = true;
9912 devlink_param_notify(devlink, 0, param_item,
9913 DEVLINK_CMD_PARAM_NEW);
9914 }
9915}
9916EXPORT_SYMBOL_GPL(devlink_params_publish);
9917
9918/**
9919 * devlink_params_unpublish - unpublish configuration parameters
9920 *
9921 * @devlink: devlink
9922 *
9923 * Unpublish previously registered configuration parameters.
9924 */
9925void devlink_params_unpublish(struct devlink *devlink)
9926{
9927 struct devlink_param_item *param_item;
9928
9929 list_for_each_entry(param_item, &devlink->param_list, list) {
9930 if (!param_item->published)
9931 continue;
9932 param_item->published = false;
9933 devlink_param_notify(devlink, 0, param_item,
9934 DEVLINK_CMD_PARAM_DEL);
9935 }
9936}
9937EXPORT_SYMBOL_GPL(devlink_params_unpublish);
9938
39e6160e
VV		 9939/**
9940 * devlink_port_params_register - register port configuration parameters
9941 *
9942 * @devlink_port: devlink port
9943 * @params: configuration parameters array
9944 * @params_count: number of parameters provided
9945 *
9946 * Register the configuration parameters supported by the port.
9947 */
9948int devlink_port_params_register(struct devlink_port *devlink_port,
9949 const struct devlink_param *params,
9950 size_t params_count)
9951{
9952 return __devlink_params_register(devlink_port->devlink,
c1e5786d 9953 devlink_port->index,
39e6160e 9954 &devlink_port->param_list, params,
c1e5786d
VV		 9955 params_count,
9956 DEVLINK_CMD_PORT_PARAM_NEW,
9957 DEVLINK_CMD_PORT_PARAM_DEL);
39e6160e
VV		 9958}
9959EXPORT_SYMBOL_GPL(devlink_port_params_register);
9960
9961/**
9962 * devlink_port_params_unregister - unregister port configuration
9963 * parameters
9964 *
9965 * @devlink_port: devlink port
9966 * @params: configuration parameters array
9967 * @params_count: number of parameters provided
9968 */
9969void devlink_port_params_unregister(struct devlink_port *devlink_port,
9970 const struct devlink_param *params,
9971 size_t params_count)
9972{
9973 return __devlink_params_unregister(devlink_port->devlink,
c1e5786d 9974 devlink_port->index,
39e6160e 9975 &devlink_port->param_list,
c1e5786d
VV		 9976 params, params_count,
9977 DEVLINK_CMD_PORT_PARAM_DEL);
39e6160e
VV		 9978}
9979EXPORT_SYMBOL_GPL(devlink_port_params_unregister);
9980
ffd19b9a
VV		 9981static int
9982__devlink_param_driverinit_value_get(struct list_head *param_list, u32 param_id,
9983 union devlink_param_value *init_val)
ec01aeb1
MS		 9984{
9985 struct devlink_param_item *param_item;
9986
ffd19b9a 9987 param_item = devlink_param_find_by_id(param_list, param_id);
ec01aeb1
MS		 9988 if (!param_item)
9989 return -EINVAL;
9990
9991 if (!param_item->driverinit_value_valid ||
9992 !devlink_param_cmode_is_supported(param_item->param,
9993 DEVLINK_PARAM_CMODE_DRIVERINIT))
9994 return -EOPNOTSUPP;
9995
1276534c
MS		 9996 if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
9997 strcpy(init_val->vstr, param_item->driverinit_value.vstr);
9998 else
9999 *init_val = param_item->driverinit_value;
ec01aeb1
MS		 10000
10001 return 0;
10002}
ffd19b9a 10003
5473a7bd
VV		 10004static int
10005__devlink_param_driverinit_value_set(struct devlink *devlink,
c1e5786d 10006 unsigned int port_index,
5473a7bd
VV		 10007 struct list_head *param_list, u32 param_id,
10008 union devlink_param_value init_val,
10009 enum devlink_command cmd)
10010{
10011 struct devlink_param_item *param_item;
10012
10013 param_item = devlink_param_find_by_id(param_list, param_id);
10014 if (!param_item)
10015 return -EINVAL;
10016
10017 if (!devlink_param_cmode_is_supported(param_item->param,
10018 DEVLINK_PARAM_CMODE_DRIVERINIT))
10019 return -EOPNOTSUPP;
10020
10021 if (param_item->param->type == DEVLINK_PARAM_TYPE_STRING)
10022 strcpy(param_item->driverinit_value.vstr, init_val.vstr);
10023 else
10024 param_item->driverinit_value = init_val;
10025 param_item->driverinit_value_valid = true;
10026
c1e5786d 10027 devlink_param_notify(devlink, port_index, param_item, cmd);
5473a7bd
VV		 10028 return 0;
10029}
10030
ffd19b9a
VV		 10031/**
10032 * devlink_param_driverinit_value_get - get configuration parameter
10033 * value for driver initializing
10034 *
10035 * @devlink: devlink
10036 * @param_id: parameter ID
10037 * @init_val: value of parameter in driverinit configuration mode
10038 *
10039 * This function should be used by the driver to get driverinit
10040 * configuration for initialization after reload command.
10041 */
10042int devlink_param_driverinit_value_get(struct devlink *devlink, u32 param_id,
10043 union devlink_param_value *init_val)
10044{
69d56e0e 10045 if (!devlink_reload_supported(devlink->ops))
ffd19b9a
VV		 10046 return -EOPNOTSUPP;
10047
10048 return __devlink_param_driverinit_value_get(&devlink->param_list,
10049 param_id, init_val);
10050}
ec01aeb1
MS		 10051EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_get);
10052
10053/**
10054 * devlink_param_driverinit_value_set - set value of configuration
10055 * parameter for driverinit
10056 * configuration mode
10057 *
10058 * @devlink: devlink
10059 * @param_id: parameter ID
10060 * @init_val: value of parameter to set for driverinit configuration mode
10061 *
10062 * This function should be used by the driver to set driverinit
10063 * configuration mode default value.
10064 */
10065int devlink_param_driverinit_value_set(struct devlink *devlink, u32 param_id,
10066 union devlink_param_value init_val)
10067{
c1e5786d 10068 return __devlink_param_driverinit_value_set(devlink, 0,
5473a7bd
VV		 10069 &devlink->param_list,
10070 param_id, init_val,
10071 DEVLINK_CMD_PARAM_NEW);
ec01aeb1
MS		 10072}
10073EXPORT_SYMBOL_GPL(devlink_param_driverinit_value_set);
10074
ffd19b9a
VV		 10075/**
10076 * devlink_port_param_driverinit_value_get - get configuration parameter
10077 * value for driver initializing
10078 *
10079 * @devlink_port: devlink_port
10080 * @param_id: parameter ID
10081 * @init_val: value of parameter in driverinit configuration mode
10082 *
10083 * This function should be used by the driver to get driverinit
10084 * configuration for initialization after reload command.
10085 */
10086int devlink_port_param_driverinit_value_get(struct devlink_port *devlink_port,
10087 u32 param_id,
10088 union devlink_param_value *init_val)
10089{
10090 struct devlink *devlink = devlink_port->devlink;
10091
69d56e0e 10092 if (!devlink_reload_supported(devlink->ops))
ffd19b9a
VV		 10093 return -EOPNOTSUPP;
10094
10095 return __devlink_param_driverinit_value_get(&devlink_port->param_list,
10096 param_id, init_val);
10097}
10098EXPORT_SYMBOL_GPL(devlink_port_param_driverinit_value_get);
10099
5473a7bd
VV		 10100/**
10101 * devlink_port_param_driverinit_value_set - set value of configuration
10102 * parameter for driverinit
10103 * configuration mode
10104 *
10105 * @devlink_port: devlink_port
10106 * @param_id: parameter ID
10107 * @init_val: value of parameter to set for driverinit configuration mode
10108 *
10109 * This function should be used by the driver to set driverinit
10110 * configuration mode default value.
10111 */
10112int devlink_port_param_driverinit_value_set(struct devlink_port *devlink_port,
10113 u32 param_id,
10114 union devlink_param_value init_val)
10115{
10116 return __devlink_param_driverinit_value_set(devlink_port->devlink,
c1e5786d 10117 devlink_port->index,
5473a7bd 10118 &devlink_port->param_list,
c1e5786d
VV		 10119 param_id, init_val,
10120 DEVLINK_CMD_PORT_PARAM_NEW);
5473a7bd
VV		 10121}
10122EXPORT_SYMBOL_GPL(devlink_port_param_driverinit_value_set);
10123
ea601e17
MS		 10124/**
10125 * devlink_param_value_changed - notify devlink on a parameter's value
10126 * change. Should be called by the driver
10127 * right after the change.
10128 *
10129 * @devlink: devlink
10130 * @param_id: parameter ID
10131 *
10132 * This function should be used by the driver to notify devlink on value
10133 * change, excluding driverinit configuration mode.
10134 * For driverinit configuration mode driver should use the function
ea601e17
MS		 10135 */
10136void devlink_param_value_changed(struct devlink *devlink, u32 param_id)
10137{
10138 struct devlink_param_item *param_item;
10139
10140 param_item = devlink_param_find_by_id(&devlink->param_list, param_id);
10141 WARN_ON(!param_item);
10142
c1e5786d 10143 devlink_param_notify(devlink, 0, param_item, DEVLINK_CMD_PARAM_NEW);
ea601e17
MS		 10144}
10145EXPORT_SYMBOL_GPL(devlink_param_value_changed);
10146
c1e5786d
VV		 10147/**
10148 * devlink_port_param_value_changed - notify devlink on a parameter's value
10149 * change. Should be called by the driver
10150 * right after the change.
10151 *
10152 * @devlink_port: devlink_port
10153 * @param_id: parameter ID
10154 *
10155 * This function should be used by the driver to notify devlink on value
10156 * change, excluding driverinit configuration mode.
10157 * For driverinit configuration mode driver should use the function
10158 * devlink_port_param_driverinit_value_set() instead.
10159 */
10160void devlink_port_param_value_changed(struct devlink_port *devlink_port,
10161 u32 param_id)
10162{
10163 struct devlink_param_item *param_item;
10164
10165 param_item = devlink_param_find_by_id(&devlink_port->param_list,
10166 param_id);
10167 WARN_ON(!param_item);
10168
10169 devlink_param_notify(devlink_port->devlink, devlink_port->index,
10170 param_item, DEVLINK_CMD_PORT_PARAM_NEW);
10171}
10172EXPORT_SYMBOL_GPL(devlink_port_param_value_changed);
10173
bde74ad1
MS		 10174/**
10175 * devlink_param_value_str_fill - Safely fill-up the string preventing
10176 * from overflow of the preallocated buffer
10177 *
10178 * @dst_val: destination devlink_param_value
10179 * @src: source buffer
10180 */
10181void devlink_param_value_str_fill(union devlink_param_value *dst_val,
10182 const char *src)
10183{
10184 size_t len;
10185
10186 len = strlcpy(dst_val->vstr, src, __DEVLINK_PARAM_MAX_STRING_VALUE);
10187 WARN_ON(len >= __DEVLINK_PARAM_MAX_STRING_VALUE);
10188}
10189EXPORT_SYMBOL_GPL(devlink_param_value_str_fill);
10190
b16ebe92
AV		 10191/**
10192 * devlink_region_create - create a new address region
10193 *
10194 * @devlink: devlink
e8937681 10195 * @ops: region operations and name
b16ebe92
AV		 10196 * @region_max_snapshots: Maximum supported number of snapshots for region
10197 * @region_size: size of region
10198 */
e8937681
JK		 10199struct devlink_region *
10200devlink_region_create(struct devlink *devlink,
10201 const struct devlink_region_ops *ops,
10202 u32 region_max_snapshots, u64 region_size)
b16ebe92
AV		 10203{
10204 struct devlink_region *region;
10205 int err = 0;
10206
a0a09f6b
JK		 10207 if (WARN_ON(!ops) || WARN_ON(!ops->destructor))
10208 return ERR_PTR(-EINVAL);
10209
b16ebe92
AV		 10210 mutex_lock(&devlink->lock);
10211
e8937681 10212 if (devlink_region_get_by_name(devlink, ops->name)) {
b16ebe92
AV		 10213 err = -EEXIST;
10214 goto unlock;
10215 }
10216
10217 region = kzalloc(sizeof(*region), GFP_KERNEL);
10218 if (!region) {
10219 err = -ENOMEM;
10220 goto unlock;
10221 }
10222
10223 region->devlink = devlink;
10224 region->max_snapshots = region_max_snapshots;
e8937681 10225 region->ops = ops;
b16ebe92
AV		 10226 region->size = region_size;
10227 INIT_LIST_HEAD(&region->snapshot_list);
10228 list_add_tail(&region->list, &devlink->region_list);
866319bb 10229 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
b16ebe92
AV		 10230
10231 mutex_unlock(&devlink->lock);
10232 return region;
10233
10234unlock:
10235 mutex_unlock(&devlink->lock);
10236 return ERR_PTR(err);
10237}
10238EXPORT_SYMBOL_GPL(devlink_region_create);
10239
544e7c33
AL		 10240/**
10241 * devlink_port_region_create - create a new address region for a port
10242 *
10243 * @port: devlink port
10244 * @ops: region operations and name
10245 * @region_max_snapshots: Maximum supported number of snapshots for region
10246 * @region_size: size of region
10247 */
10248struct devlink_region *
10249devlink_port_region_create(struct devlink_port *port,
10250 const struct devlink_port_region_ops *ops,
10251 u32 region_max_snapshots, u64 region_size)
10252{
10253 struct devlink *devlink = port->devlink;
10254 struct devlink_region *region;
10255 int err = 0;
10256
10257 if (WARN_ON(!ops) || WARN_ON(!ops->destructor))
10258 return ERR_PTR(-EINVAL);
10259
10260 mutex_lock(&devlink->lock);
10261
10262 if (devlink_port_region_get_by_name(port, ops->name)) {
10263 err = -EEXIST;
10264 goto unlock;
10265 }
10266
10267 region = kzalloc(sizeof(*region), GFP_KERNEL);
10268 if (!region) {
10269 err = -ENOMEM;
10270 goto unlock;
10271 }
10272
10273 region->devlink = devlink;
10274 region->port = port;
10275 region->max_snapshots = region_max_snapshots;
10276 region->port_ops = ops;
10277 region->size = region_size;
10278 INIT_LIST_HEAD(&region->snapshot_list);
10279 list_add_tail(&region->list, &port->region_list);
10280 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_NEW);
10281
10282 mutex_unlock(&devlink->lock);
10283 return region;
10284
10285unlock:
10286 mutex_unlock(&devlink->lock);
10287 return ERR_PTR(err);
10288}
10289EXPORT_SYMBOL_GPL(devlink_port_region_create);
10290
b16ebe92
AV		 10291/**
10292 * devlink_region_destroy - destroy address region
10293 *
10294 * @region: devlink region to destroy
10295 */
10296void devlink_region_destroy(struct devlink_region *region)
10297{
10298 struct devlink *devlink = region->devlink;
d7e52722 10299 struct devlink_snapshot *snapshot, *ts;
b16ebe92
AV		 10300
10301 mutex_lock(&devlink->lock);
d7e52722
AV		 10302
10303 /* Free all snapshots of region */
10304 list_for_each_entry_safe(snapshot, ts, &region->snapshot_list, list)
92b49822 10305 devlink_region_snapshot_del(region, snapshot);
d7e52722 10306
b16ebe92 10307 list_del(&region->list);
866319bb
AV		 10308
10309 devlink_nl_region_notify(region, NULL, DEVLINK_CMD_REGION_DEL);
b16ebe92
AV		 10310 mutex_unlock(&devlink->lock);
10311 kfree(region);
10312}
10313EXPORT_SYMBOL_GPL(devlink_region_destroy);
10314
ccadfa44 10315/**
b0efcae5 10316 * devlink_region_snapshot_id_get - get snapshot ID
ccadfa44
AV		 10317 *
10318 * This callback should be called when adding a new snapshot,
10319 * Driver should use the same id for multiple snapshots taken
10320 * on multiple regions at the same time/by the same trigger.
10321 *
12102436
JK		 10322 * The caller of this function must use devlink_region_snapshot_id_put
10323 * when finished creating regions using this id.
10324 *
7ef19d3b
JK		 10325 * Returns zero on success, or a negative error code on failure.
10326 *
ccadfa44 10327 * @devlink: devlink
7ef19d3b 10328 * @id: storage to return id
ccadfa44 10329 */
7ef19d3b 10330int devlink_region_snapshot_id_get(struct devlink *devlink, u32 *id)
ccadfa44 10331{
7ef19d3b 10332 int err;
ccadfa44
AV		 10333
10334 mutex_lock(&devlink->lock);
7ef19d3b 10335 err = __devlink_region_snapshot_id_get(devlink, id);
ccadfa44
AV		 10336 mutex_unlock(&devlink->lock);
10337
7ef19d3b 10338 return err;
ccadfa44 10339}
b0efcae5 10340EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_get);
ccadfa44 10341
12102436
JK		 10342/**
10343 * devlink_region_snapshot_id_put - put snapshot ID reference
10344 *
10345 * This should be called by a driver after finishing creating snapshots
10346 * with an id. Doing so ensures that the ID can later be released in the
10347 * event that all snapshots using it have been destroyed.
10348 *
10349 * @devlink: devlink
10350 * @id: id to release reference on
10351 */
10352void devlink_region_snapshot_id_put(struct devlink *devlink, u32 id)
10353{
10354 mutex_lock(&devlink->lock);
10355 __devlink_snapshot_id_decrement(devlink, id);
10356 mutex_unlock(&devlink->lock);
10357}
10358EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_put);
10359
d7e52722
AV		 10360/**
10361 * devlink_region_snapshot_create - create a new snapshot
10362 * This will add a new snapshot of a region. The snapshot
10363 * will be stored on the region struct and can be accessed
6d82f67e 10364 * from devlink. This is useful for future analyses of snapshots.
d7e52722
AV		 10365 * Multiple snapshots can be created on a region.
10366 * The @snapshot_id should be obtained using the getter function.
10367 *
eeaadd82 10368 * @region: devlink region of the snapshot
d7e52722
AV		 10369 * @data: snapshot data
10370 * @snapshot_id: snapshot id to be created
d7e52722 10371 */
3a5e5234 10372int devlink_region_snapshot_create(struct devlink_region *region,
a0a09f6b 10373 u8 *data, u32 snapshot_id)
d7e52722
AV		 10374{
10375 struct devlink *devlink = region->devlink;
d7e52722
AV		 10376 int err;
10377
10378 mutex_lock(&devlink->lock);
cf80faee 10379 err = __devlink_region_snapshot_create(region, data, snapshot_id);
d7e52722 10380 mutex_unlock(&devlink->lock);
d7e52722 10381
d7e52722
AV		 10382 return err;
10383}
10384EXPORT_SYMBOL_GPL(devlink_region_snapshot_create);
10385
0f420b6c
IS		 10386#define DEVLINK_TRAP(_id, _type) \
10387 { \
10388 .type = DEVLINK_TRAP_TYPE_##_type, \
10389 .id = DEVLINK_TRAP_GENERIC_ID_##_id, \
10390 .name = DEVLINK_TRAP_GENERIC_NAME_##_id, \
10391 }
10392
10393static const struct devlink_trap devlink_trap_generic[] = {
391203ab
IS		 10394 DEVLINK_TRAP(SMAC_MC, DROP),
10395 DEVLINK_TRAP(VLAN_TAG_MISMATCH, DROP),
10396 DEVLINK_TRAP(INGRESS_VLAN_FILTER, DROP),
10397 DEVLINK_TRAP(INGRESS_STP_FILTER, DROP),
10398 DEVLINK_TRAP(EMPTY_TX_LIST, DROP),
10399 DEVLINK_TRAP(PORT_LOOPBACK_FILTER, DROP),
10400 DEVLINK_TRAP(BLACKHOLE_ROUTE, DROP),
10401 DEVLINK_TRAP(TTL_ERROR, EXCEPTION),
10402 DEVLINK_TRAP(TAIL_DROP, DROP),
6896cc4d
AC		 10403 DEVLINK_TRAP(NON_IP_PACKET, DROP),
10404 DEVLINK_TRAP(UC_DIP_MC_DMAC, DROP),
10405 DEVLINK_TRAP(DIP_LB, DROP),
10406 DEVLINK_TRAP(SIP_MC, DROP),
10407 DEVLINK_TRAP(SIP_LB, DROP),
10408 DEVLINK_TRAP(CORRUPTED_IP_HDR, DROP),
10409 DEVLINK_TRAP(IPV4_SIP_BC, DROP),
10410 DEVLINK_TRAP(IPV6_MC_DIP_RESERVED_SCOPE, DROP),
10411 DEVLINK_TRAP(IPV6_MC_DIP_INTERFACE_LOCAL_SCOPE, DROP),
3b063ae5
AC		 10412 DEVLINK_TRAP(MTU_ERROR, EXCEPTION),
10413 DEVLINK_TRAP(UNRESOLVED_NEIGH, EXCEPTION),
10414 DEVLINK_TRAP(RPF, EXCEPTION),
10415 DEVLINK_TRAP(REJECT_ROUTE, EXCEPTION),
10416 DEVLINK_TRAP(IPV4_LPM_UNICAST_MISS, EXCEPTION),
10417 DEVLINK_TRAP(IPV6_LPM_UNICAST_MISS, EXCEPTION),
95f0ead8 10418 DEVLINK_TRAP(NON_ROUTABLE, DROP),
13c056ec 10419 DEVLINK_TRAP(DECAP_ERROR, EXCEPTION),
c3cae491 10420 DEVLINK_TRAP(OVERLAY_SMAC_MC, DROP),
ecd942a0
JP		 10421 DEVLINK_TRAP(INGRESS_FLOW_ACTION_DROP, DROP),
10422 DEVLINK_TRAP(EGRESS_FLOW_ACTION_DROP, DROP),
515eac67
IS		 10423 DEVLINK_TRAP(STP, CONTROL),
10424 DEVLINK_TRAP(LACP, CONTROL),
10425 DEVLINK_TRAP(LLDP, CONTROL),
10426 DEVLINK_TRAP(IGMP_QUERY, CONTROL),
10427 DEVLINK_TRAP(IGMP_V1_REPORT, CONTROL),
10428 DEVLINK_TRAP(IGMP_V2_REPORT, CONTROL),
10429 DEVLINK_TRAP(IGMP_V3_REPORT, CONTROL),
10430 DEVLINK_TRAP(IGMP_V2_LEAVE, CONTROL),
10431 DEVLINK_TRAP(MLD_QUERY, CONTROL),
10432 DEVLINK_TRAP(MLD_V1_REPORT, CONTROL),
10433 DEVLINK_TRAP(MLD_V2_REPORT, CONTROL),
10434 DEVLINK_TRAP(MLD_V1_DONE, CONTROL),
d77cfd16
IS		 10435 DEVLINK_TRAP(IPV4_DHCP, CONTROL),
10436 DEVLINK_TRAP(IPV6_DHCP, CONTROL),
10437 DEVLINK_TRAP(ARP_REQUEST, CONTROL),
10438 DEVLINK_TRAP(ARP_RESPONSE, CONTROL),
10439 DEVLINK_TRAP(ARP_OVERLAY, CONTROL),
10440 DEVLINK_TRAP(IPV6_NEIGH_SOLICIT, CONTROL),
10441 DEVLINK_TRAP(IPV6_NEIGH_ADVERT, CONTROL),
10442 DEVLINK_TRAP(IPV4_BFD, CONTROL),
10443 DEVLINK_TRAP(IPV6_BFD, CONTROL),
10444 DEVLINK_TRAP(IPV4_OSPF, CONTROL),
10445 DEVLINK_TRAP(IPV6_OSPF, CONTROL),
10446 DEVLINK_TRAP(IPV4_BGP, CONTROL),
10447 DEVLINK_TRAP(IPV6_BGP, CONTROL),
10448 DEVLINK_TRAP(IPV4_VRRP, CONTROL),
10449 DEVLINK_TRAP(IPV6_VRRP, CONTROL),
10450 DEVLINK_TRAP(IPV4_PIM, CONTROL),
10451 DEVLINK_TRAP(IPV6_PIM, CONTROL),
10452 DEVLINK_TRAP(UC_LB, CONTROL),
10453 DEVLINK_TRAP(LOCAL_ROUTE, CONTROL),
10454 DEVLINK_TRAP(EXTERNAL_ROUTE, CONTROL),
10455 DEVLINK_TRAP(IPV6_UC_DIP_LINK_LOCAL_SCOPE, CONTROL),
10456 DEVLINK_TRAP(IPV6_DIP_ALL_NODES, CONTROL),
10457 DEVLINK_TRAP(IPV6_DIP_ALL_ROUTERS, CONTROL),
10458 DEVLINK_TRAP(IPV6_ROUTER_SOLICIT, CONTROL),
10459 DEVLINK_TRAP(IPV6_ROUTER_ADVERT, CONTROL),
10460 DEVLINK_TRAP(IPV6_REDIRECT, CONTROL),
10461 DEVLINK_TRAP(IPV4_ROUTER_ALERT, CONTROL),
10462 DEVLINK_TRAP(IPV6_ROUTER_ALERT, CONTROL),
10463 DEVLINK_TRAP(PTP_EVENT, CONTROL),
10464 DEVLINK_TRAP(PTP_GENERAL, CONTROL),
5eb18a2b
IS		 10465 DEVLINK_TRAP(FLOW_ACTION_SAMPLE, CONTROL),
10466 DEVLINK_TRAP(FLOW_ACTION_TRAP, CONTROL),
08e335f6 10467 DEVLINK_TRAP(EARLY_DROP, DROP),
10c24eb2
IC		 10468 DEVLINK_TRAP(VXLAN_PARSING, DROP),
10469 DEVLINK_TRAP(LLC_SNAP_PARSING, DROP),
10470 DEVLINK_TRAP(VLAN_PARSING, DROP),
10471 DEVLINK_TRAP(PPPOE_PPP_PARSING, DROP),
10472 DEVLINK_TRAP(MPLS_PARSING, DROP),
10473 DEVLINK_TRAP(ARP_PARSING, DROP),
10474 DEVLINK_TRAP(IP_1_PARSING, DROP),
10475 DEVLINK_TRAP(IP_N_PARSING, DROP),
10476 DEVLINK_TRAP(GRE_PARSING, DROP),
10477 DEVLINK_TRAP(UDP_PARSING, DROP),
10478 DEVLINK_TRAP(TCP_PARSING, DROP),
10479 DEVLINK_TRAP(IPSEC_PARSING, DROP),
10480 DEVLINK_TRAP(SCTP_PARSING, DROP),
10481 DEVLINK_TRAP(DCCP_PARSING, DROP),
10482 DEVLINK_TRAP(GTP_PARSING, DROP),
10483 DEVLINK_TRAP(ESP_PARSING, DROP),
f0a5013e 10484 DEVLINK_TRAP(BLACKHOLE_NEXTHOP, DROP),
e78ab164 10485 DEVLINK_TRAP(DMAC_FILTER, DROP),
0f420b6c
IS		 10486};
10487
10488#define DEVLINK_TRAP_GROUP(_id) \
10489 { \
10490 .id = DEVLINK_TRAP_GROUP_GENERIC_ID_##_id, \
10491 .name = DEVLINK_TRAP_GROUP_GENERIC_NAME_##_id, \
10492 }
10493
10494static const struct devlink_trap_group devlink_trap_group_generic[] = {
391203ab
IS		 10495 DEVLINK_TRAP_GROUP(L2_DROPS),
10496 DEVLINK_TRAP_GROUP(L3_DROPS),
678eb199 10497 DEVLINK_TRAP_GROUP(L3_EXCEPTIONS),
391203ab 10498 DEVLINK_TRAP_GROUP(BUFFER_DROPS),
13c056ec 10499 DEVLINK_TRAP_GROUP(TUNNEL_DROPS),
ecd942a0 10500 DEVLINK_TRAP_GROUP(ACL_DROPS),
515eac67
IS		 10501 DEVLINK_TRAP_GROUP(STP),
10502 DEVLINK_TRAP_GROUP(LACP),
10503 DEVLINK_TRAP_GROUP(LLDP),
10504 DEVLINK_TRAP_GROUP(MC_SNOOPING),
d77cfd16
IS		 10505 DEVLINK_TRAP_GROUP(DHCP),
10506 DEVLINK_TRAP_GROUP(NEIGH_DISCOVERY),
10507 DEVLINK_TRAP_GROUP(BFD),
10508 DEVLINK_TRAP_GROUP(OSPF),
10509 DEVLINK_TRAP_GROUP(BGP),
10510 DEVLINK_TRAP_GROUP(VRRP),
10511 DEVLINK_TRAP_GROUP(PIM),
10512 DEVLINK_TRAP_GROUP(UC_LB),
10513 DEVLINK_TRAP_GROUP(LOCAL_DELIVERY),
ec4f5b36 10514 DEVLINK_TRAP_GROUP(EXTERNAL_DELIVERY),
d77cfd16
IS		 10515 DEVLINK_TRAP_GROUP(IPV6),
10516 DEVLINK_TRAP_GROUP(PTP_EVENT),
10517 DEVLINK_TRAP_GROUP(PTP_GENERAL),
5eb18a2b
IS		 10518 DEVLINK_TRAP_GROUP(ACL_SAMPLE),
10519 DEVLINK_TRAP_GROUP(ACL_TRAP),
10c24eb2 10520 DEVLINK_TRAP_GROUP(PARSER_ERROR_DROPS),
0f420b6c
IS		 10521};
10522
10523static int devlink_trap_generic_verify(const struct devlink_trap *trap)
10524{
10525 if (trap->id > DEVLINK_TRAP_GENERIC_ID_MAX)
10526 return -EINVAL;
10527
10528 if (strcmp(trap->name, devlink_trap_generic[trap->id].name))
10529 return -EINVAL;
10530
10531 if (trap->type != devlink_trap_generic[trap->id].type)
10532 return -EINVAL;
10533
10534 return 0;
10535}
10536
10537static int devlink_trap_driver_verify(const struct devlink_trap *trap)
10538{
10539 int i;
10540
10541 if (trap->id <= DEVLINK_TRAP_GENERIC_ID_MAX)
10542 return -EINVAL;
10543
10544 for (i = 0; i < ARRAY_SIZE(devlink_trap_generic); i++) {
10545 if (!strcmp(trap->name, devlink_trap_generic[i].name))
10546 return -EEXIST;
10547 }
10548
10549 return 0;
10550}
10551
10552static int devlink_trap_verify(const struct devlink_trap *trap)
10553{
107f1678 10554 if (!trap || !trap->name)
0f420b6c
IS		 10555 return -EINVAL;
10556
10557 if (trap->generic)
10558 return devlink_trap_generic_verify(trap);
10559 else
10560 return devlink_trap_driver_verify(trap);
10561}
10562
10563static int
10564devlink_trap_group_generic_verify(const struct devlink_trap_group *group)
10565{
10566 if (group->id > DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
10567 return -EINVAL;
10568
10569 if (strcmp(group->name, devlink_trap_group_generic[group->id].name))
10570 return -EINVAL;
10571
10572 return 0;
10573}
10574
10575static int
10576devlink_trap_group_driver_verify(const struct devlink_trap_group *group)
10577{
10578 int i;
10579
10580 if (group->id <= DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
10581 return -EINVAL;
10582
10583 for (i = 0; i < ARRAY_SIZE(devlink_trap_group_generic); i++) {
10584 if (!strcmp(group->name, devlink_trap_group_generic[i].name))
10585 return -EEXIST;
10586 }
10587
10588 return 0;
10589}
10590
10591static int devlink_trap_group_verify(const struct devlink_trap_group *group)
10592{
10593 if (group->generic)
10594 return devlink_trap_group_generic_verify(group);
10595 else
10596 return devlink_trap_group_driver_verify(group);
10597}
10598
10599static void
10600devlink_trap_group_notify(struct devlink *devlink,
10601 const struct devlink_trap_group_item *group_item,
10602 enum devlink_command cmd)
10603{
10604 struct sk_buff *msg;
10605 int err;
10606
10607 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_GROUP_NEW &&
10608 cmd != DEVLINK_CMD_TRAP_GROUP_DEL);
10609
10610 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10611 if (!msg)
10612 return;
10613
10614 err = devlink_nl_trap_group_fill(msg, devlink, group_item, cmd, 0, 0,
10615 0);
10616 if (err) {
10617 nlmsg_free(msg);
10618 return;
10619 }
10620
10621 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
10622 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
10623}
10624
0f420b6c
IS		 10625static int
10626devlink_trap_item_group_link(struct devlink *devlink,
10627 struct devlink_trap_item *trap_item)
10628{
107f1678 10629 u16 group_id = trap_item->trap->init_group_id;
0f420b6c
IS		 10630 struct devlink_trap_group_item *group_item;
10631
107f1678 10632 group_item = devlink_trap_group_item_lookup_by_id(devlink, group_id);
a09b37fc
IS		 10633 if (WARN_ON_ONCE(!group_item))
10634 return -EINVAL;
0f420b6c
IS		 10635
10636 trap_item->group_item = group_item;
10637
10638 return 0;
10639}
10640
0f420b6c
IS		 10641static void devlink_trap_notify(struct devlink *devlink,
10642 const struct devlink_trap_item *trap_item,
10643 enum devlink_command cmd)
10644{
10645 struct sk_buff *msg;
10646 int err;
10647
10648 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_NEW &&
10649 cmd != DEVLINK_CMD_TRAP_DEL);
10650
10651 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10652 if (!msg)
10653 return;
10654
10655 err = devlink_nl_trap_fill(msg, devlink, trap_item, cmd, 0, 0, 0);
10656 if (err) {
10657 nlmsg_free(msg);
10658 return;
10659 }
10660
10661 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
10662 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
10663}
10664
10665static int
10666devlink_trap_register(struct devlink *devlink,
10667 const struct devlink_trap *trap, void *priv)
10668{
10669 struct devlink_trap_item *trap_item;
10670 int err;
10671
10672 if (devlink_trap_item_lookup(devlink, trap->name))
10673 return -EEXIST;
10674
10675 trap_item = kzalloc(sizeof(*trap_item), GFP_KERNEL);
10676 if (!trap_item)
10677 return -ENOMEM;
10678
10679 trap_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
10680 if (!trap_item->stats) {
10681 err = -ENOMEM;
10682 goto err_stats_alloc;
10683 }
10684
10685 trap_item->trap = trap;
10686 trap_item->action = trap->init_action;
10687 trap_item->priv = priv;
10688
10689 err = devlink_trap_item_group_link(devlink, trap_item);
10690 if (err)
10691 goto err_group_link;
10692
10693 err = devlink->ops->trap_init(devlink, trap, trap_item);
10694 if (err)
10695 goto err_trap_init;
10696
10697 list_add_tail(&trap_item->list, &devlink->trap_list);
10698 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_NEW);
10699
10700 return 0;
10701
10702err_trap_init:
0f420b6c
IS		 10703err_group_link:
10704 free_percpu(trap_item->stats);
10705err_stats_alloc:
10706 kfree(trap_item);
10707 return err;
10708}
10709
10710static void devlink_trap_unregister(struct devlink *devlink,
10711 const struct devlink_trap *trap)
10712{
10713 struct devlink_trap_item *trap_item;
10714
10715 trap_item = devlink_trap_item_lookup(devlink, trap->name);
10716 if (WARN_ON_ONCE(!trap_item))
10717 return;
10718
10719 devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_DEL);
10720 list_del(&trap_item->list);
10721 if (devlink->ops->trap_fini)
10722 devlink->ops->trap_fini(devlink, trap, trap_item);
0f420b6c
IS		 10723 free_percpu(trap_item->stats);
10724 kfree(trap_item);
10725}
10726
10727static void devlink_trap_disable(struct devlink *devlink,
10728 const struct devlink_trap *trap)
10729{
10730 struct devlink_trap_item *trap_item;
10731
10732 trap_item = devlink_trap_item_lookup(devlink, trap->name);
10733 if (WARN_ON_ONCE(!trap_item))
10734 return;
10735
c88e11e0
IS		 10736 devlink->ops->trap_action_set(devlink, trap, DEVLINK_TRAP_ACTION_DROP,
10737 NULL);
0f420b6c
IS		 10738 trap_item->action = DEVLINK_TRAP_ACTION_DROP;
10739}
10740
10741/**
10742 * devlink_traps_register - Register packet traps with devlink.
10743 * @devlink: devlink.
10744 * @traps: Packet traps.
10745 * @traps_count: Count of provided packet traps.
10746 * @priv: Driver private information.
10747 *
10748 * Return: Non-zero value on failure.
10749 */
10750int devlink_traps_register(struct devlink *devlink,
10751 const struct devlink_trap *traps,
10752 size_t traps_count, void *priv)
10753{
10754 int i, err;
10755
10756 if (!devlink->ops->trap_init || !devlink->ops->trap_action_set)
10757 return -EINVAL;
10758
10759 mutex_lock(&devlink->lock);
10760 for (i = 0; i < traps_count; i++) {
10761 const struct devlink_trap *trap = &traps[i];
10762
10763 err = devlink_trap_verify(trap);
10764 if (err)
10765 goto err_trap_verify;
10766
10767 err = devlink_trap_register(devlink, trap, priv);
10768 if (err)
10769 goto err_trap_register;
10770 }
10771 mutex_unlock(&devlink->lock);
10772
10773 return 0;
10774
10775err_trap_register:
10776err_trap_verify:
10777 for (i--; i >= 0; i--)
10778 devlink_trap_unregister(devlink, &traps[i]);
10779 mutex_unlock(&devlink->lock);
10780 return err;
10781}
10782EXPORT_SYMBOL_GPL(devlink_traps_register);
10783
10784/**
10785 * devlink_traps_unregister - Unregister packet traps from devlink.
10786 * @devlink: devlink.
10787 * @traps: Packet traps.
10788 * @traps_count: Count of provided packet traps.
10789 */
10790void devlink_traps_unregister(struct devlink *devlink,
10791 const struct devlink_trap *traps,
10792 size_t traps_count)
10793{
10794 int i;
10795
10796 mutex_lock(&devlink->lock);
10797 /* Make sure we do not have any packets in-flight while unregistering
10798 * traps by disabling all of them and waiting for a grace period.
10799 */
10800 for (i = traps_count - 1; i >= 0; i--)
10801 devlink_trap_disable(devlink, &traps[i]);
10802 synchronize_rcu();
10803 for (i = traps_count - 1; i >= 0; i--)
10804 devlink_trap_unregister(devlink, &traps[i]);
10805 mutex_unlock(&devlink->lock);
10806}
10807EXPORT_SYMBOL_GPL(devlink_traps_unregister);
10808
10809static void
10810devlink_trap_stats_update(struct devlink_stats __percpu *trap_stats,
10811 size_t skb_len)
10812{
10813 struct devlink_stats *stats;
10814
10815 stats = this_cpu_ptr(trap_stats);
10816 u64_stats_update_begin(&stats->syncp);
10817 stats->rx_bytes += skb_len;
10818 stats->rx_packets++;
10819 u64_stats_update_end(&stats->syncp);
10820}
10821
5b88823b
IS		 10822static void
10823devlink_trap_report_metadata_set(struct devlink_trap_metadata *metadata,
10824 const struct devlink_trap_item *trap_item,
10825 struct devlink_port *in_devlink_port,
10826 const struct flow_action_cookie *fa_cookie)
10827{
10828 metadata->trap_name = trap_item->trap->name;
10829 metadata->trap_group_name = trap_item->group_item->group->name;
10830 metadata->fa_cookie = fa_cookie;
93e15596 10831 metadata->trap_type = trap_item->trap->type;
5b88823b
IS		 10832
10833 spin_lock(&in_devlink_port->type_lock);
10834 if (in_devlink_port->type == DEVLINK_PORT_TYPE_ETH)
10835 metadata->input_dev = in_devlink_port->type_dev;
10836 spin_unlock(&in_devlink_port->type_lock);
10837}
10838
0f420b6c
IS		 10839/**
10840 * devlink_trap_report - Report trapped packet to drop monitor.
10841 * @devlink: devlink.
10842 * @skb: Trapped packet.
10843 * @trap_ctx: Trap context.
10844 * @in_devlink_port: Input devlink port.
5a2e106c 10845 * @fa_cookie: Flow action cookie. Could be NULL.
0f420b6c
IS		 10846 */
10847void devlink_trap_report(struct devlink *devlink, struct sk_buff *skb,
5a2e106c
JP		 10848 void *trap_ctx, struct devlink_port *in_devlink_port,
10849 const struct flow_action_cookie *fa_cookie)
10850
0f420b6c
IS		 10851{
10852 struct devlink_trap_item *trap_item = trap_ctx;
0f420b6c
IS		 10853
10854 devlink_trap_stats_update(trap_item->stats, skb->len);
10855 devlink_trap_stats_update(trap_item->group_item->stats, skb->len);
10856
5b88823b
IS		 10857 if (trace_devlink_trap_report_enabled()) {
10858 struct devlink_trap_metadata metadata = {};
10859
10860 devlink_trap_report_metadata_set(&metadata, trap_item,
10861 in_devlink_port, fa_cookie);
10862 trace_devlink_trap_report(devlink, skb, &metadata);
10863 }
0f420b6c
IS		 10864}
10865EXPORT_SYMBOL_GPL(devlink_trap_report);
10866
10867/**
10868 * devlink_trap_ctx_priv - Trap context to driver private information.
10869 * @trap_ctx: Trap context.
10870 *
10871 * Return: Driver private information passed during registration.
10872 */
10873void *devlink_trap_ctx_priv(void *trap_ctx)
10874{
10875 struct devlink_trap_item *trap_item = trap_ctx;
10876
10877 return trap_item->priv;
10878}
10879EXPORT_SYMBOL_GPL(devlink_trap_ctx_priv);
10880
f9f54392
IS		 10881static int
10882devlink_trap_group_item_policer_link(struct devlink *devlink,
10883 struct devlink_trap_group_item *group_item)
10884{
10885 u32 policer_id = group_item->group->init_policer_id;
10886 struct devlink_trap_policer_item *policer_item;
10887
10888 if (policer_id == 0)
10889 return 0;
10890
10891 policer_item = devlink_trap_policer_item_lookup(devlink, policer_id);
10892 if (WARN_ON_ONCE(!policer_item))
10893 return -EINVAL;
10894
10895 group_item->policer_item = policer_item;
10896
10897 return 0;
10898}
10899
95ad9555
IS		 10900static int
10901devlink_trap_group_register(struct devlink *devlink,
10902 const struct devlink_trap_group *group)
10903{
10904 struct devlink_trap_group_item *group_item;
10905 int err;
10906
10907 if (devlink_trap_group_item_lookup(devlink, group->name))
10908 return -EEXIST;
10909
10910 group_item = kzalloc(sizeof(*group_item), GFP_KERNEL);
10911 if (!group_item)
10912 return -ENOMEM;
10913
10914 group_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
10915 if (!group_item->stats) {
10916 err = -ENOMEM;
10917 goto err_stats_alloc;
10918 }
10919
10920 group_item->group = group;
95ad9555 10921
f9f54392
IS		 10922 err = devlink_trap_group_item_policer_link(devlink, group_item);
10923 if (err)
10924 goto err_policer_link;
10925
95ad9555
IS		 10926 if (devlink->ops->trap_group_init) {
10927 err = devlink->ops->trap_group_init(devlink, group);
10928 if (err)
10929 goto err_group_init;
10930 }
10931
10932 list_add_tail(&group_item->list, &devlink->trap_group_list);
10933 devlink_trap_group_notify(devlink, group_item,
10934 DEVLINK_CMD_TRAP_GROUP_NEW);
10935
10936 return 0;
10937
10938err_group_init:
f9f54392 10939err_policer_link:
95ad9555
IS		 10940 free_percpu(group_item->stats);
10941err_stats_alloc:
10942 kfree(group_item);
10943 return err;
10944}
10945
10946static void
10947devlink_trap_group_unregister(struct devlink *devlink,
10948 const struct devlink_trap_group *group)
10949{
10950 struct devlink_trap_group_item *group_item;
10951
10952 group_item = devlink_trap_group_item_lookup(devlink, group->name);
10953 if (WARN_ON_ONCE(!group_item))
10954 return;
10955
10956 devlink_trap_group_notify(devlink, group_item,
10957 DEVLINK_CMD_TRAP_GROUP_DEL);
10958 list_del(&group_item->list);
10959 free_percpu(group_item->stats);
10960 kfree(group_item);
10961}
10962
10963/**
10964 * devlink_trap_groups_register - Register packet trap groups with devlink.
10965 * @devlink: devlink.
10966 * @groups: Packet trap groups.
10967 * @groups_count: Count of provided packet trap groups.
10968 *
10969 * Return: Non-zero value on failure.
10970 */
10971int devlink_trap_groups_register(struct devlink *devlink,
10972 const struct devlink_trap_group *groups,
10973 size_t groups_count)
10974{
10975 int i, err;
10976
10977 mutex_lock(&devlink->lock);
10978 for (i = 0; i < groups_count; i++) {
10979 const struct devlink_trap_group *group = &groups[i];
10980
10981 err = devlink_trap_group_verify(group);
10982 if (err)
10983 goto err_trap_group_verify;
10984
10985 err = devlink_trap_group_register(devlink, group);
10986 if (err)
10987 goto err_trap_group_register;
10988 }
10989 mutex_unlock(&devlink->lock);
10990
10991 return 0;
10992
10993err_trap_group_register:
10994err_trap_group_verify:
10995 for (i--; i >= 0; i--)
10996 devlink_trap_group_unregister(devlink, &groups[i]);
10997 mutex_unlock(&devlink->lock);
10998 return err;
10999}
11000EXPORT_SYMBOL_GPL(devlink_trap_groups_register);
11001
11002/**
11003 * devlink_trap_groups_unregister - Unregister packet trap groups from devlink.
11004 * @devlink: devlink.
11005 * @groups: Packet trap groups.
11006 * @groups_count: Count of provided packet trap groups.
11007 */
11008void devlink_trap_groups_unregister(struct devlink *devlink,
11009 const struct devlink_trap_group *groups,
11010 size_t groups_count)
11011{
11012 int i;
11013
11014 mutex_lock(&devlink->lock);
11015 for (i = groups_count - 1; i >= 0; i--)
11016 devlink_trap_group_unregister(devlink, &groups[i]);
11017 mutex_unlock(&devlink->lock);
11018}
11019EXPORT_SYMBOL_GPL(devlink_trap_groups_unregister);
11020
1e8c6619
IS		 11021static void
11022devlink_trap_policer_notify(struct devlink *devlink,
11023 const struct devlink_trap_policer_item *policer_item,
11024 enum devlink_command cmd)
11025{
11026 struct sk_buff *msg;
11027 int err;
11028
11029 WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_POLICER_NEW &&
11030 cmd != DEVLINK_CMD_TRAP_POLICER_DEL);
11031
11032 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11033 if (!msg)
11034 return;
11035
11036 err = devlink_nl_trap_policer_fill(msg, devlink, policer_item, cmd, 0,
11037 0, 0);
11038 if (err) {
11039 nlmsg_free(msg);
11040 return;
11041 }
11042
11043 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
11044 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
11045}
11046
11047static int
11048devlink_trap_policer_register(struct devlink *devlink,
11049 const struct devlink_trap_policer *policer)
11050{
11051 struct devlink_trap_policer_item *policer_item;
11052 int err;
11053
11054 if (devlink_trap_policer_item_lookup(devlink, policer->id))
11055 return -EEXIST;
11056
11057 policer_item = kzalloc(sizeof(*policer_item), GFP_KERNEL);
11058 if (!policer_item)
11059 return -ENOMEM;
11060
11061 policer_item->policer = policer;
11062 policer_item->rate = policer->init_rate;
11063 policer_item->burst = policer->init_burst;
11064
11065 if (devlink->ops->trap_policer_init) {
11066 err = devlink->ops->trap_policer_init(devlink, policer);
11067 if (err)
11068 goto err_policer_init;
11069 }
11070
11071 list_add_tail(&policer_item->list, &devlink->trap_policer_list);
11072 devlink_trap_policer_notify(devlink, policer_item,
11073 DEVLINK_CMD_TRAP_POLICER_NEW);
11074
11075 return 0;
11076
11077err_policer_init:
11078 kfree(policer_item);
11079 return err;
11080}
11081
11082static void
11083devlink_trap_policer_unregister(struct devlink *devlink,
11084 const struct devlink_trap_policer *policer)
11085{
11086 struct devlink_trap_policer_item *policer_item;
11087
11088 policer_item = devlink_trap_policer_item_lookup(devlink, policer->id);
11089 if (WARN_ON_ONCE(!policer_item))
11090 return;
11091
11092 devlink_trap_policer_notify(devlink, policer_item,
11093 DEVLINK_CMD_TRAP_POLICER_DEL);
11094 list_del(&policer_item->list);
11095 if (devlink->ops->trap_policer_fini)
11096 devlink->ops->trap_policer_fini(devlink, policer);
11097 kfree(policer_item);
11098}
11099
11100/**
11101 * devlink_trap_policers_register - Register packet trap policers with devlink.
11102 * @devlink: devlink.
11103 * @policers: Packet trap policers.
11104 * @policers_count: Count of provided packet trap policers.
11105 *
11106 * Return: Non-zero value on failure.
11107 */
11108int
11109devlink_trap_policers_register(struct devlink *devlink,
11110 const struct devlink_trap_policer *policers,
11111 size_t policers_count)
11112{
11113 int i, err;
11114
11115 mutex_lock(&devlink->lock);
11116 for (i = 0; i < policers_count; i++) {
11117 const struct devlink_trap_policer *policer = &policers[i];
11118
11119 if (WARN_ON(policer->id == 0 ||
11120 policer->max_rate < policer->min_rate ||
11121 policer->max_burst < policer->min_burst)) {
11122 err = -EINVAL;
11123 goto err_trap_policer_verify;
11124 }
11125
11126 err = devlink_trap_policer_register(devlink, policer);
11127 if (err)
11128 goto err_trap_policer_register;
11129 }
11130 mutex_unlock(&devlink->lock);
11131
11132 return 0;
11133
11134err_trap_policer_register:
11135err_trap_policer_verify:
11136 for (i--; i >= 0; i--)
11137 devlink_trap_policer_unregister(devlink, &policers[i]);
11138 mutex_unlock(&devlink->lock);
11139 return err;
11140}
11141EXPORT_SYMBOL_GPL(devlink_trap_policers_register);
11142
11143/**
11144 * devlink_trap_policers_unregister - Unregister packet trap policers from devlink.
11145 * @devlink: devlink.
11146 * @policers: Packet trap policers.
11147 * @policers_count: Count of provided packet trap policers.
11148 */
11149void
11150devlink_trap_policers_unregister(struct devlink *devlink,
11151 const struct devlink_trap_policer *policers,
11152 size_t policers_count)
11153{
11154 int i;
11155
11156 mutex_lock(&devlink->lock);
11157 for (i = policers_count - 1; i >= 0; i--)
11158 devlink_trap_policer_unregister(devlink, &policers[i]);
11159 mutex_unlock(&devlink->lock);
11160}
11161EXPORT_SYMBOL_GPL(devlink_trap_policers_unregister);
11162
ddb6e99e
JK		 11163static void __devlink_compat_running_version(struct devlink *devlink,
11164 char *buf, size_t len)
11165{
11166 const struct nlattr *nlattr;
11167 struct devlink_info_req req;
11168 struct sk_buff *msg;
11169 int rem, err;
11170
ddb6e99e
JK		 11171 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11172 if (!msg)
11173 return;
11174
11175 req.msg = msg;
11176 err = devlink->ops->info_get(devlink, &req, NULL);
11177 if (err)
11178 goto free_msg;
11179
11180 nla_for_each_attr(nlattr, (void *)msg->data, msg->len, rem) {
11181 const struct nlattr *kv;
11182 int rem_kv;
11183
11184 if (nla_type(nlattr) != DEVLINK_ATTR_INFO_VERSION_RUNNING)
11185 continue;
11186
11187 nla_for_each_nested(kv, nlattr, rem_kv) {
11188 if (nla_type(kv) != DEVLINK_ATTR_INFO_VERSION_VALUE)
11189 continue;
11190
11191 strlcat(buf, nla_data(kv), len);
11192 strlcat(buf, " ", len);
11193 }
11194 }
11195free_msg:
11196 nlmsg_free(msg);
11197}
11198
11199void devlink_compat_running_version(struct net_device *dev,
11200 char *buf, size_t len)
11201{
ddb6e99e
JK		 11202 struct devlink *devlink;
11203
1b45ff6c
JK		 11204 dev_hold(dev);
11205 rtnl_unlock();
11206
b473b0d2 11207 devlink = netdev_to_devlink(dev);
be6fe1d8 11208 if (!devlink || !devlink->ops->info_get)
e0dcd386 11209 goto out;
b473b0d2
JK		 11210
11211 mutex_lock(&devlink->lock);
11212 __devlink_compat_running_version(devlink, buf, len);
11213 mutex_unlock(&devlink->lock);
1b45ff6c 11214
e0dcd386 11215out:
1b45ff6c
JK		 11216 rtnl_lock();
11217 dev_put(dev);
ddb6e99e
JK		 11218}
11219
4eceba17
JK		 11220int devlink_compat_flash_update(struct net_device *dev, const char *file_name)
11221{
bc75c054 11222 struct devlink_flash_update_params params = {};
4eceba17 11223 struct devlink *devlink;
e0dcd386 11224 int ret;
4eceba17 11225
1b45ff6c
JK		 11226 dev_hold(dev);
11227 rtnl_unlock();
11228
b473b0d2 11229 devlink = netdev_to_devlink(dev);
e0dcd386
JP		 11230 if (!devlink || !devlink->ops->flash_update) {
11231 ret = -EOPNOTSUPP;
11232 goto out;
11233 }
4eceba17 11234
b44cfd4f
JK		 11235 ret = request_firmware(&params.fw, file_name, devlink->dev);
11236 if (ret)
11237 goto out;
bc75c054 11238
b473b0d2 11239 mutex_lock(&devlink->lock);
52cc5f3a 11240 devlink_flash_update_begin_notify(devlink);
bc75c054 11241 ret = devlink->ops->flash_update(devlink, &params, NULL);
52cc5f3a 11242 devlink_flash_update_end_notify(devlink);
b473b0d2 11243 mutex_unlock(&devlink->lock);
1b45ff6c 11244
b44cfd4f
JK		 11245 release_firmware(params.fw);
11246
e0dcd386 11247out:
1b45ff6c
JK		 11248 rtnl_lock();
11249 dev_put(dev);
11250
b473b0d2 11251 return ret;
4eceba17
JK		 11252}
11253
af3836df
JP		 11254int devlink_compat_phys_port_name_get(struct net_device *dev,
11255 char *name, size_t len)
11256{
11257 struct devlink_port *devlink_port;
11258
11259 /* RTNL mutex is held here which ensures that devlink_port
11260 * instance cannot disappear in the middle. No need to take
11261 * any devlink lock as only permanent values are accessed.
11262 */
11263 ASSERT_RTNL();
11264
11265 devlink_port = netdev_to_devlink_port(dev);
11266 if (!devlink_port)
11267 return -EOPNOTSUPP;
11268
11269 return __devlink_port_phys_port_name_get(devlink_port, name, len);
11270}
11271
7e1146e8
JP		 11272int devlink_compat_switch_id_get(struct net_device *dev,
11273 struct netdev_phys_item_id *ppid)
11274{
11275 struct devlink_port *devlink_port;
11276
043b8413
VB		 11277 /* Caller must hold RTNL mutex or reference to dev, which ensures that
11278 * devlink_port instance cannot disappear in the middle. No need to take
7e1146e8
JP		 11279 * any devlink lock as only permanent values are accessed.
11280 */
7e1146e8 11281 devlink_port = netdev_to_devlink_port(dev);
46737a19 11282 if (!devlink_port || !devlink_port->switch_port)
7e1146e8
JP		 11283 return -EOPNOTSUPP;
11284
11285 memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid));
11286
11287 return 0;
11288}
11289
070c63f2
JP		 11290static void __net_exit devlink_pernet_pre_exit(struct net *net)
11291{
11292 struct devlink *devlink;
ccdf0721 11293 u32 actions_performed;
070c63f2
JP		 11294 int err;
11295
11296 /* In case network namespace is getting destroyed, reload
11297 * all devlink instances from this namespace into init_net.
11298 */
11299 mutex_lock(&devlink_mutex);
11300 list_for_each_entry(devlink, &devlink_list, list) {
11301 if (net_eq(devlink_net(devlink), net)) {
69d56e0e 11302 if (WARN_ON(!devlink_reload_supported(devlink->ops)))
070c63f2 11303 continue;
ccdf0721
MS		 11304 err = devlink_reload(devlink, &init_net,
11305 DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
dc64cc7c 11306 DEVLINK_RELOAD_LIMIT_UNSPEC,
ccdf0721 11307 &actions_performed, NULL);
a0c76345 11308 if (err && err != -EOPNOTSUPP)
070c63f2
JP		 11309 pr_warn("Failed to reload devlink instance into init_net\n");
11310 }
11311 }
11312 mutex_unlock(&devlink_mutex);
11313}
11314
11315static struct pernet_operations devlink_pernet_ops __net_initdata = {
11316 .pre_exit = devlink_pernet_pre_exit,
11317};
11318
f4b6bcc7 11319static int __init devlink_init(void)
bfcd3a46 11320{
070c63f2
JP		 11321 int err;
11322
11323 err = genl_register_family(&devlink_nl_family);
11324 if (err)
11325 goto out;
11326 err = register_pernet_subsys(&devlink_pernet_ops);
11327
11328out:
11329 WARN_ON(err);
11330 return err;
bfcd3a46
JP		 11331}
11332
f4b6bcc7 11333subsys_initcall(devlink_init);
Linux 6.x block layer and io_uring tree(s)