?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'locking-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[cris-mirror.git] / net / core / devlink.c
blob18d385ed82370a7b6a9a2e31023b785a054e9e9f
1 /*
2 * net/core/devlink.c - Network physical/parent device Netlink interface
3 *
4 * Heavily inspired by net/wireless/
5 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
6 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/slab.h>
18 #include <linux/gfp.h>
19 #include <linux/device.h>
20 #include <linux/list.h>
21 #include <linux/netdevice.h>
22 #include <rdma/ib_verbs.h>
23 #include <net/netlink.h>
24 #include <net/genetlink.h>
25 #include <net/rtnetlink.h>
26 #include <net/net_namespace.h>
27 #include <net/sock.h>
28 #include <net/devlink.h>
29 #define CREATE_TRACE_POINTS
30 #include <trace/events/devlink.h>
31
32 static struct devlink_dpipe_field devlink_dpipe_fields_ethernet[] = {
33 {
34 .name = "destination mac",
35 .id = DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC,
36 .bitwidth = 48,
37 },
38 };
39
40 struct devlink_dpipe_header devlink_dpipe_header_ethernet = {
41 .name = "ethernet",
42 .id = DEVLINK_DPIPE_HEADER_ETHERNET,
43 .fields = devlink_dpipe_fields_ethernet,
44 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ethernet),
45 .global = true,
46 };
47 EXPORT_SYMBOL(devlink_dpipe_header_ethernet);
48
49 static struct devlink_dpipe_field devlink_dpipe_fields_ipv4[] = {
50 {
51 .name = "destination ip",
52 .id = DEVLINK_DPIPE_FIELD_IPV4_DST_IP,
53 .bitwidth = 32,
54 },
55 };
56
57 struct devlink_dpipe_header devlink_dpipe_header_ipv4 = {
58 .name = "ipv4",
59 .id = DEVLINK_DPIPE_HEADER_IPV4,
60 .fields = devlink_dpipe_fields_ipv4,
61 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv4),
62 .global = true,
63 };
64 EXPORT_SYMBOL(devlink_dpipe_header_ipv4);
65
66 static struct devlink_dpipe_field devlink_dpipe_fields_ipv6[] = {
67 {
68 .name = "destination ip",
69 .id = DEVLINK_DPIPE_FIELD_IPV6_DST_IP,
70 .bitwidth = 128,
71 },
72 };
73
74 struct devlink_dpipe_header devlink_dpipe_header_ipv6 = {
75 .name = "ipv6",
76 .id = DEVLINK_DPIPE_HEADER_IPV6,
77 .fields = devlink_dpipe_fields_ipv6,
78 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv6),
79 .global = true,
80 };
81 EXPORT_SYMBOL(devlink_dpipe_header_ipv6);
82
83 EXPORT_TRACEPOINT_SYMBOL_GPL(devlink_hwmsg);
84
85 static LIST_HEAD(devlink_list);
86
87 /* devlink_mutex
88 *
89 * An overall lock guarding every operation coming from userspace.
90 * It also guards devlink devices list and it is taken when
91 * driver registers/unregisters it.
92 */
93 static DEFINE_MUTEX(devlink_mutex);
94
95 static struct net *devlink_net(const struct devlink *devlink)
96 {
97 return read_pnet(&devlink->_net);
98 }
99
100 static void devlink_net_set(struct devlink *devlink, struct net *net)
101 {
102 write_pnet(&devlink->_net, net);
103 }
104
105 static struct devlink *devlink_get_from_attrs(struct net *net,
106 struct nlattr **attrs)
107 {
108 struct devlink *devlink;
109 char *busname;
110 char *devname;
111
112 if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
113 return ERR_PTR(-EINVAL);
114
115 busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
116 devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
117
118 list_for_each_entry(devlink, &devlink_list, list) {
119 if (strcmp(devlink->dev->bus->name, busname) == 0 &&
120 strcmp(dev_name(devlink->dev), devname) == 0 &&
121 net_eq(devlink_net(devlink), net))
122 return devlink;
123 }
124
125 return ERR_PTR(-ENODEV);
126 }
127
128 static struct devlink *devlink_get_from_info(struct genl_info *info)
129 {
130 return devlink_get_from_attrs(genl_info_net(info), info->attrs);
131 }
132
133 static struct devlink_port *devlink_port_get_by_index(struct devlink *devlink,
134 int port_index)
135 {
136 struct devlink_port *devlink_port;
137
138 list_for_each_entry(devlink_port, &devlink->port_list, list) {
139 if (devlink_port->index == port_index)
140 return devlink_port;
141 }
142 return NULL;
143 }
144
145 static bool devlink_port_index_exists(struct devlink *devlink, int port_index)
146 {
147 return devlink_port_get_by_index(devlink, port_index);
148 }
149
150 static struct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink,
151 struct nlattr **attrs)
152 {
153 if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
154 u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
155 struct devlink_port *devlink_port;
156
157 devlink_port = devlink_port_get_by_index(devlink, port_index);
158 if (!devlink_port)
159 return ERR_PTR(-ENODEV);
160 return devlink_port;
161 }
162 return ERR_PTR(-EINVAL);
163 }
164
165 static struct devlink_port *devlink_port_get_from_info(struct devlink *devlink,
166 struct genl_info *info)
167 {
168 return devlink_port_get_from_attrs(devlink, info->attrs);
169 }
170
171 struct devlink_sb {
172 struct list_head list;
173 unsigned int index;
174 u32 size;
175 u16 ingress_pools_count;
176 u16 egress_pools_count;
177 u16 ingress_tc_count;
178 u16 egress_tc_count;
179 };
180
181 static u16 devlink_sb_pool_count(struct devlink_sb *devlink_sb)
182 {
183 return devlink_sb->ingress_pools_count + devlink_sb->egress_pools_count;
184 }
185
186 static struct devlink_sb *devlink_sb_get_by_index(struct devlink *devlink,
187 unsigned int sb_index)
188 {
189 struct devlink_sb *devlink_sb;
190
191 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
192 if (devlink_sb->index == sb_index)
193 return devlink_sb;
194 }
195 return NULL;
196 }
197
198 static bool devlink_sb_index_exists(struct devlink *devlink,
199 unsigned int sb_index)
200 {
201 return devlink_sb_get_by_index(devlink, sb_index);
202 }
203
204 static struct devlink_sb *devlink_sb_get_from_attrs(struct devlink *devlink,
205 struct nlattr **attrs)
206 {
207 if (attrs[DEVLINK_ATTR_SB_INDEX]) {
208 u32 sb_index = nla_get_u32(attrs[DEVLINK_ATTR_SB_INDEX]);
209 struct devlink_sb *devlink_sb;
210
211 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
212 if (!devlink_sb)
213 return ERR_PTR(-ENODEV);
214 return devlink_sb;
215 }
216 return ERR_PTR(-EINVAL);
217 }
218
219 static struct devlink_sb *devlink_sb_get_from_info(struct devlink *devlink,
220 struct genl_info *info)
221 {
222 return devlink_sb_get_from_attrs(devlink, info->attrs);
223 }
224
225 static int devlink_sb_pool_index_get_from_attrs(struct devlink_sb *devlink_sb,
226 struct nlattr **attrs,
227 u16 *p_pool_index)
228 {
229 u16 val;
230
231 if (!attrs[DEVLINK_ATTR_SB_POOL_INDEX])
232 return -EINVAL;
233
234 val = nla_get_u16(attrs[DEVLINK_ATTR_SB_POOL_INDEX]);
235 if (val >= devlink_sb_pool_count(devlink_sb))
236 return -EINVAL;
237 *p_pool_index = val;
238 return 0;
239 }
240
241 static int devlink_sb_pool_index_get_from_info(struct devlink_sb *devlink_sb,
242 struct genl_info *info,
243 u16 *p_pool_index)
244 {
245 return devlink_sb_pool_index_get_from_attrs(devlink_sb, info->attrs,
246 p_pool_index);
247 }
248
249 static int
250 devlink_sb_pool_type_get_from_attrs(struct nlattr **attrs,
251 enum devlink_sb_pool_type *p_pool_type)
252 {
253 u8 val;
254
255 if (!attrs[DEVLINK_ATTR_SB_POOL_TYPE])
256 return -EINVAL;
257
258 val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_TYPE]);
259 if (val != DEVLINK_SB_POOL_TYPE_INGRESS &&
260 val != DEVLINK_SB_POOL_TYPE_EGRESS)
261 return -EINVAL;
262 *p_pool_type = val;
263 return 0;
264 }
265
266 static int
267 devlink_sb_pool_type_get_from_info(struct genl_info *info,
268 enum devlink_sb_pool_type *p_pool_type)
269 {
270 return devlink_sb_pool_type_get_from_attrs(info->attrs, p_pool_type);
271 }
272
273 static int
274 devlink_sb_th_type_get_from_attrs(struct nlattr **attrs,
275 enum devlink_sb_threshold_type *p_th_type)
276 {
277 u8 val;
278
279 if (!attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])
280 return -EINVAL;
281
282 val = nla_get_u8(attrs[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE]);
283 if (val != DEVLINK_SB_THRESHOLD_TYPE_STATIC &&
284 val != DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC)
285 return -EINVAL;
286 *p_th_type = val;
287 return 0;
288 }
289
290 static int
291 devlink_sb_th_type_get_from_info(struct genl_info *info,
292 enum devlink_sb_threshold_type *p_th_type)
293 {
294 return devlink_sb_th_type_get_from_attrs(info->attrs, p_th_type);
295 }
296
297 static int
298 devlink_sb_tc_index_get_from_attrs(struct devlink_sb *devlink_sb,
299 struct nlattr **attrs,
300 enum devlink_sb_pool_type pool_type,
301 u16 *p_tc_index)
302 {
303 u16 val;
304
305 if (!attrs[DEVLINK_ATTR_SB_TC_INDEX])
306 return -EINVAL;
307
308 val = nla_get_u16(attrs[DEVLINK_ATTR_SB_TC_INDEX]);
309 if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS &&
310 val >= devlink_sb->ingress_tc_count)
311 return -EINVAL;
312 if (pool_type == DEVLINK_SB_POOL_TYPE_EGRESS &&
313 val >= devlink_sb->egress_tc_count)
314 return -EINVAL;
315 *p_tc_index = val;
316 return 0;
317 }
318
319 static int
320 devlink_sb_tc_index_get_from_info(struct devlink_sb *devlink_sb,
321 struct genl_info *info,
322 enum devlink_sb_pool_type pool_type,
323 u16 *p_tc_index)
324 {
325 return devlink_sb_tc_index_get_from_attrs(devlink_sb, info->attrs,
326 pool_type, p_tc_index);
327 }
328
329 #define DEVLINK_NL_FLAG_NEED_DEVLINK BIT(0)
330 #define DEVLINK_NL_FLAG_NEED_PORT BIT(1)
331 #define DEVLINK_NL_FLAG_NEED_SB BIT(2)
332
333 /* The per devlink instance lock is taken by default in the pre-doit
334 * operation, yet several commands do not require this. The global
335 * devlink lock is taken and protects from disruption by user-calls.
336 */
337 #define DEVLINK_NL_FLAG_NO_LOCK BIT(3)
338
339 static int devlink_nl_pre_doit(const struct genl_ops *ops,
340 struct sk_buff *skb, struct genl_info *info)
341 {
342 struct devlink *devlink;
343 int err;
344
345 mutex_lock(&devlink_mutex);
346 devlink = devlink_get_from_info(info);
347 if (IS_ERR(devlink)) {
348 mutex_unlock(&devlink_mutex);
349 return PTR_ERR(devlink);
350 }
351 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
352 mutex_lock(&devlink->lock);
353 if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_DEVLINK) {
354 info->user_ptr[0] = devlink;
355 } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_PORT) {
356 struct devlink_port *devlink_port;
357
358 devlink_port = devlink_port_get_from_info(devlink, info);
359 if (IS_ERR(devlink_port)) {
360 err = PTR_ERR(devlink_port);
361 goto unlock;
362 }
363 info->user_ptr[0] = devlink_port;
364 }
365 if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_SB) {
366 struct devlink_sb *devlink_sb;
367
368 devlink_sb = devlink_sb_get_from_info(devlink, info);
369 if (IS_ERR(devlink_sb)) {
370 err = PTR_ERR(devlink_sb);
371 goto unlock;
372 }
373 info->user_ptr[1] = devlink_sb;
374 }
375 return 0;
376
377 unlock:
378 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
379 mutex_unlock(&devlink->lock);
380 mutex_unlock(&devlink_mutex);
381 return err;
382 }
383
384 static void devlink_nl_post_doit(const struct genl_ops *ops,
385 struct sk_buff *skb, struct genl_info *info)
386 {
387 struct devlink *devlink;
388
389 devlink = devlink_get_from_info(info);
390 if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
391 mutex_unlock(&devlink->lock);
392 mutex_unlock(&devlink_mutex);
393 }
394
395 static struct genl_family devlink_nl_family;
396
397 enum devlink_multicast_groups {
398 DEVLINK_MCGRP_CONFIG,
399 };
400
401 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
402 [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
403 };
404
405 static int devlink_nl_put_handle(struct sk_buff *msg, struct devlink *devlink)
406 {
407 if (nla_put_string(msg, DEVLINK_ATTR_BUS_NAME, devlink->dev->bus->name))
408 return -EMSGSIZE;
409 if (nla_put_string(msg, DEVLINK_ATTR_DEV_NAME, dev_name(devlink->dev)))
410 return -EMSGSIZE;
411 return 0;
412 }
413
414 static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
415 enum devlink_command cmd, u32 portid,
416 u32 seq, int flags)
417 {
418 void *hdr;
419
420 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
421 if (!hdr)
422 return -EMSGSIZE;
423
424 if (devlink_nl_put_handle(msg, devlink))
425 goto nla_put_failure;
426
427 genlmsg_end(msg, hdr);
428 return 0;
429
430 nla_put_failure:
431 genlmsg_cancel(msg, hdr);
432 return -EMSGSIZE;
433 }
434
435 static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
436 {
437 struct sk_buff *msg;
438 int err;
439
440 WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
441
442 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
443 if (!msg)
444 return;
445
446 err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
447 if (err) {
448 nlmsg_free(msg);
449 return;
450 }
451
452 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
453 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
454 }
455
456 static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
457 struct devlink_port *devlink_port,
458 enum devlink_command cmd, u32 portid,
459 u32 seq, int flags)
460 {
461 void *hdr;
462
463 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
464 if (!hdr)
465 return -EMSGSIZE;
466
467 if (devlink_nl_put_handle(msg, devlink))
468 goto nla_put_failure;
469 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
470 goto nla_put_failure;
471 if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
472 goto nla_put_failure;
473 if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
474 nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
475 devlink_port->desired_type))
476 goto nla_put_failure;
477 if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
478 struct net_device *netdev = devlink_port->type_dev;
479
480 if (netdev &&
481 (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
482 netdev->ifindex) ||
483 nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
484 netdev->name)))
485 goto nla_put_failure;
486 }
487 if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
488 struct ib_device *ibdev = devlink_port->type_dev;
489
490 if (ibdev &&
491 nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
492 ibdev->name))
493 goto nla_put_failure;
494 }
495 if (devlink_port->split &&
496 nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP,
497 devlink_port->split_group))
498 goto nla_put_failure;
499
500 genlmsg_end(msg, hdr);
501 return 0;
502
503 nla_put_failure:
504 genlmsg_cancel(msg, hdr);
505 return -EMSGSIZE;
506 }
507
508 static void devlink_port_notify(struct devlink_port *devlink_port,
509 enum devlink_command cmd)
510 {
511 struct devlink *devlink = devlink_port->devlink;
512 struct sk_buff *msg;
513 int err;
514
515 if (!devlink_port->registered)
516 return;
517
518 WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
519
520 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
521 if (!msg)
522 return;
523
524 err = devlink_nl_port_fill(msg, devlink, devlink_port, cmd, 0, 0, 0);
525 if (err) {
526 nlmsg_free(msg);
527 return;
528 }
529
530 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
531 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
532 }
533
534 static int devlink_nl_cmd_get_doit(struct sk_buff *skb, struct genl_info *info)
535 {
536 struct devlink *devlink = info->user_ptr[0];
537 struct sk_buff *msg;
538 int err;
539
540 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
541 if (!msg)
542 return -ENOMEM;
543
544 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
545 info->snd_portid, info->snd_seq, 0);
546 if (err) {
547 nlmsg_free(msg);
548 return err;
549 }
550
551 return genlmsg_reply(msg, info);
552 }
553
554 static int devlink_nl_cmd_get_dumpit(struct sk_buff *msg,
555 struct netlink_callback *cb)
556 {
557 struct devlink *devlink;
558 int start = cb->args[0];
559 int idx = 0;
560 int err;
561
562 mutex_lock(&devlink_mutex);
563 list_for_each_entry(devlink, &devlink_list, list) {
564 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
565 continue;
566 if (idx < start) {
567 idx++;
568 continue;
569 }
570 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
571 NETLINK_CB(cb->skb).portid,
572 cb->nlh->nlmsg_seq, NLM_F_MULTI);
573 if (err)
574 goto out;
575 idx++;
576 }
577 out:
578 mutex_unlock(&devlink_mutex);
579
580 cb->args[0] = idx;
581 return msg->len;
582 }
583
584 static int devlink_nl_cmd_port_get_doit(struct sk_buff *skb,
585 struct genl_info *info)
586 {
587 struct devlink_port *devlink_port = info->user_ptr[0];
588 struct devlink *devlink = devlink_port->devlink;
589 struct sk_buff *msg;
590 int err;
591
592 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
593 if (!msg)
594 return -ENOMEM;
595
596 err = devlink_nl_port_fill(msg, devlink, devlink_port,
597 DEVLINK_CMD_PORT_NEW,
598 info->snd_portid, info->snd_seq, 0);
599 if (err) {
600 nlmsg_free(msg);
601 return err;
602 }
603
604 return genlmsg_reply(msg, info);
605 }
606
607 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff *msg,
608 struct netlink_callback *cb)
609 {
610 struct devlink *devlink;
611 struct devlink_port *devlink_port;
612 int start = cb->args[0];
613 int idx = 0;
614 int err;
615
616 mutex_lock(&devlink_mutex);
617 list_for_each_entry(devlink, &devlink_list, list) {
618 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
619 continue;
620 mutex_lock(&devlink->lock);
621 list_for_each_entry(devlink_port, &devlink->port_list, list) {
622 if (idx < start) {
623 idx++;
624 continue;
625 }
626 err = devlink_nl_port_fill(msg, devlink, devlink_port,
627 DEVLINK_CMD_NEW,
628 NETLINK_CB(cb->skb).portid,
629 cb->nlh->nlmsg_seq,
630 NLM_F_MULTI);
631 if (err) {
632 mutex_unlock(&devlink->lock);
633 goto out;
634 }
635 idx++;
636 }
637 mutex_unlock(&devlink->lock);
638 }
639 out:
640 mutex_unlock(&devlink_mutex);
641
642 cb->args[0] = idx;
643 return msg->len;
644 }
645
646 static int devlink_port_type_set(struct devlink *devlink,
647 struct devlink_port *devlink_port,
648 enum devlink_port_type port_type)
649
650 {
651 int err;
652
653 if (devlink->ops && devlink->ops->port_type_set) {
654 if (port_type == DEVLINK_PORT_TYPE_NOTSET)
655 return -EINVAL;
656 if (port_type == devlink_port->type)
657 return 0;
658 err = devlink->ops->port_type_set(devlink_port, port_type);
659 if (err)
660 return err;
661 devlink_port->desired_type = port_type;
662 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
663 return 0;
664 }
665 return -EOPNOTSUPP;
666 }
667
668 static int devlink_nl_cmd_port_set_doit(struct sk_buff *skb,
669 struct genl_info *info)
670 {
671 struct devlink_port *devlink_port = info->user_ptr[0];
672 struct devlink *devlink = devlink_port->devlink;
673 int err;
674
675 if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
676 enum devlink_port_type port_type;
677
678 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
679 err = devlink_port_type_set(devlink, devlink_port, port_type);
680 if (err)
681 return err;
682 }
683 return 0;
684 }
685
686 static int devlink_port_split(struct devlink *devlink,
687 u32 port_index, u32 count)
688
689 {
690 if (devlink->ops && devlink->ops->port_split)
691 return devlink->ops->port_split(devlink, port_index, count);
692 return -EOPNOTSUPP;
693 }
694
695 static int devlink_nl_cmd_port_split_doit(struct sk_buff *skb,
696 struct genl_info *info)
697 {
698 struct devlink *devlink = info->user_ptr[0];
699 u32 port_index;
700 u32 count;
701
702 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX] ||
703 !info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT])
704 return -EINVAL;
705
706 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
707 count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
708 return devlink_port_split(devlink, port_index, count);
709 }
710
711 static int devlink_port_unsplit(struct devlink *devlink, u32 port_index)
712
713 {
714 if (devlink->ops && devlink->ops->port_unsplit)
715 return devlink->ops->port_unsplit(devlink, port_index);
716 return -EOPNOTSUPP;
717 }
718
719 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
720 struct genl_info *info)
721 {
722 struct devlink *devlink = info->user_ptr[0];
723 u32 port_index;
724
725 if (!info->attrs[DEVLINK_ATTR_PORT_INDEX])
726 return -EINVAL;
727
728 port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
729 return devlink_port_unsplit(devlink, port_index);
730 }
731
732 static int devlink_nl_sb_fill(struct sk_buff *msg, struct devlink *devlink,
733 struct devlink_sb *devlink_sb,
734 enum devlink_command cmd, u32 portid,
735 u32 seq, int flags)
736 {
737 void *hdr;
738
739 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
740 if (!hdr)
741 return -EMSGSIZE;
742
743 if (devlink_nl_put_handle(msg, devlink))
744 goto nla_put_failure;
745 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
746 goto nla_put_failure;
747 if (nla_put_u32(msg, DEVLINK_ATTR_SB_SIZE, devlink_sb->size))
748 goto nla_put_failure;
749 if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT,
750 devlink_sb->ingress_pools_count))
751 goto nla_put_failure;
752 if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT,
753 devlink_sb->egress_pools_count))
754 goto nla_put_failure;
755 if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_TC_COUNT,
756 devlink_sb->ingress_tc_count))
757 goto nla_put_failure;
758 if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_TC_COUNT,
759 devlink_sb->egress_tc_count))
760 goto nla_put_failure;
761
762 genlmsg_end(msg, hdr);
763 return 0;
764
765 nla_put_failure:
766 genlmsg_cancel(msg, hdr);
767 return -EMSGSIZE;
768 }
769
770 static int devlink_nl_cmd_sb_get_doit(struct sk_buff *skb,
771 struct genl_info *info)
772 {
773 struct devlink *devlink = info->user_ptr[0];
774 struct devlink_sb *devlink_sb = info->user_ptr[1];
775 struct sk_buff *msg;
776 int err;
777
778 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
779 if (!msg)
780 return -ENOMEM;
781
782 err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
783 DEVLINK_CMD_SB_NEW,
784 info->snd_portid, info->snd_seq, 0);
785 if (err) {
786 nlmsg_free(msg);
787 return err;
788 }
789
790 return genlmsg_reply(msg, info);
791 }
792
793 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff *msg,
794 struct netlink_callback *cb)
795 {
796 struct devlink *devlink;
797 struct devlink_sb *devlink_sb;
798 int start = cb->args[0];
799 int idx = 0;
800 int err;
801
802 mutex_lock(&devlink_mutex);
803 list_for_each_entry(devlink, &devlink_list, list) {
804 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
805 continue;
806 mutex_lock(&devlink->lock);
807 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
808 if (idx < start) {
809 idx++;
810 continue;
811 }
812 err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
813 DEVLINK_CMD_SB_NEW,
814 NETLINK_CB(cb->skb).portid,
815 cb->nlh->nlmsg_seq,
816 NLM_F_MULTI);
817 if (err) {
818 mutex_unlock(&devlink->lock);
819 goto out;
820 }
821 idx++;
822 }
823 mutex_unlock(&devlink->lock);
824 }
825 out:
826 mutex_unlock(&devlink_mutex);
827
828 cb->args[0] = idx;
829 return msg->len;
830 }
831
832 static int devlink_nl_sb_pool_fill(struct sk_buff *msg, struct devlink *devlink,
833 struct devlink_sb *devlink_sb,
834 u16 pool_index, enum devlink_command cmd,
835 u32 portid, u32 seq, int flags)
836 {
837 struct devlink_sb_pool_info pool_info;
838 void *hdr;
839 int err;
840
841 err = devlink->ops->sb_pool_get(devlink, devlink_sb->index,
842 pool_index, &pool_info);
843 if (err)
844 return err;
845
846 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
847 if (!hdr)
848 return -EMSGSIZE;
849
850 if (devlink_nl_put_handle(msg, devlink))
851 goto nla_put_failure;
852 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
853 goto nla_put_failure;
854 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
855 goto nla_put_failure;
856 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_info.pool_type))
857 goto nla_put_failure;
858 if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_SIZE, pool_info.size))
859 goto nla_put_failure;
860 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
861 pool_info.threshold_type))
862 goto nla_put_failure;
863
864 genlmsg_end(msg, hdr);
865 return 0;
866
867 nla_put_failure:
868 genlmsg_cancel(msg, hdr);
869 return -EMSGSIZE;
870 }
871
872 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff *skb,
873 struct genl_info *info)
874 {
875 struct devlink *devlink = info->user_ptr[0];
876 struct devlink_sb *devlink_sb = info->user_ptr[1];
877 struct sk_buff *msg;
878 u16 pool_index;
879 int err;
880
881 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
882 &pool_index);
883 if (err)
884 return err;
885
886 if (!devlink->ops || !devlink->ops->sb_pool_get)
887 return -EOPNOTSUPP;
888
889 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
890 if (!msg)
891 return -ENOMEM;
892
893 err = devlink_nl_sb_pool_fill(msg, devlink, devlink_sb, pool_index,
894 DEVLINK_CMD_SB_POOL_NEW,
895 info->snd_portid, info->snd_seq, 0);
896 if (err) {
897 nlmsg_free(msg);
898 return err;
899 }
900
901 return genlmsg_reply(msg, info);
902 }
903
904 static int __sb_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
905 struct devlink *devlink,
906 struct devlink_sb *devlink_sb,
907 u32 portid, u32 seq)
908 {
909 u16 pool_count = devlink_sb_pool_count(devlink_sb);
910 u16 pool_index;
911 int err;
912
913 for (pool_index = 0; pool_index < pool_count; pool_index++) {
914 if (*p_idx < start) {
915 (*p_idx)++;
916 continue;
917 }
918 err = devlink_nl_sb_pool_fill(msg, devlink,
919 devlink_sb,
920 pool_index,
921 DEVLINK_CMD_SB_POOL_NEW,
922 portid, seq, NLM_F_MULTI);
923 if (err)
924 return err;
925 (*p_idx)++;
926 }
927 return 0;
928 }
929
930 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff *msg,
931 struct netlink_callback *cb)
932 {
933 struct devlink *devlink;
934 struct devlink_sb *devlink_sb;
935 int start = cb->args[0];
936 int idx = 0;
937 int err;
938
939 mutex_lock(&devlink_mutex);
940 list_for_each_entry(devlink, &devlink_list, list) {
941 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
942 !devlink->ops || !devlink->ops->sb_pool_get)
943 continue;
944 mutex_lock(&devlink->lock);
945 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
946 err = __sb_pool_get_dumpit(msg, start, &idx, devlink,
947 devlink_sb,
948 NETLINK_CB(cb->skb).portid,
949 cb->nlh->nlmsg_seq);
950 if (err && err != -EOPNOTSUPP) {
951 mutex_unlock(&devlink->lock);
952 goto out;
953 }
954 }
955 mutex_unlock(&devlink->lock);
956 }
957 out:
958 mutex_unlock(&devlink_mutex);
959
960 cb->args[0] = idx;
961 return msg->len;
962 }
963
964 static int devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
965 u16 pool_index, u32 size,
966 enum devlink_sb_threshold_type threshold_type)
967
968 {
969 const struct devlink_ops *ops = devlink->ops;
970
971 if (ops && ops->sb_pool_set)
972 return ops->sb_pool_set(devlink, sb_index, pool_index,
973 size, threshold_type);
974 return -EOPNOTSUPP;
975 }
976
977 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb,
978 struct genl_info *info)
979 {
980 struct devlink *devlink = info->user_ptr[0];
981 struct devlink_sb *devlink_sb = info->user_ptr[1];
982 enum devlink_sb_threshold_type threshold_type;
983 u16 pool_index;
984 u32 size;
985 int err;
986
987 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
988 &pool_index);
989 if (err)
990 return err;
991
992 err = devlink_sb_th_type_get_from_info(info, &threshold_type);
993 if (err)
994 return err;
995
996 if (!info->attrs[DEVLINK_ATTR_SB_POOL_SIZE])
997 return -EINVAL;
998
999 size = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_POOL_SIZE]);
1000 return devlink_sb_pool_set(devlink, devlink_sb->index,
1001 pool_index, size, threshold_type);
1002 }
1003
1004 static int devlink_nl_sb_port_pool_fill(struct sk_buff *msg,
1005 struct devlink *devlink,
1006 struct devlink_port *devlink_port,
1007 struct devlink_sb *devlink_sb,
1008 u16 pool_index,
1009 enum devlink_command cmd,
1010 u32 portid, u32 seq, int flags)
1011 {
1012 const struct devlink_ops *ops = devlink->ops;
1013 u32 threshold;
1014 void *hdr;
1015 int err;
1016
1017 err = ops->sb_port_pool_get(devlink_port, devlink_sb->index,
1018 pool_index, &threshold);
1019 if (err)
1020 return err;
1021
1022 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1023 if (!hdr)
1024 return -EMSGSIZE;
1025
1026 if (devlink_nl_put_handle(msg, devlink))
1027 goto nla_put_failure;
1028 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1029 goto nla_put_failure;
1030 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1031 goto nla_put_failure;
1032 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1033 goto nla_put_failure;
1034 if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1035 goto nla_put_failure;
1036
1037 if (ops->sb_occ_port_pool_get) {
1038 u32 cur;
1039 u32 max;
1040
1041 err = ops->sb_occ_port_pool_get(devlink_port, devlink_sb->index,
1042 pool_index, &cur, &max);
1043 if (err && err != -EOPNOTSUPP)
1044 return err;
1045 if (!err) {
1046 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1047 goto nla_put_failure;
1048 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1049 goto nla_put_failure;
1050 }
1051 }
1052
1053 genlmsg_end(msg, hdr);
1054 return 0;
1055
1056 nla_put_failure:
1057 genlmsg_cancel(msg, hdr);
1058 return -EMSGSIZE;
1059 }
1060
1061 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff *skb,
1062 struct genl_info *info)
1063 {
1064 struct devlink_port *devlink_port = info->user_ptr[0];
1065 struct devlink *devlink = devlink_port->devlink;
1066 struct devlink_sb *devlink_sb = info->user_ptr[1];
1067 struct sk_buff *msg;
1068 u16 pool_index;
1069 int err;
1070
1071 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1072 &pool_index);
1073 if (err)
1074 return err;
1075
1076 if (!devlink->ops || !devlink->ops->sb_port_pool_get)
1077 return -EOPNOTSUPP;
1078
1079 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1080 if (!msg)
1081 return -ENOMEM;
1082
1083 err = devlink_nl_sb_port_pool_fill(msg, devlink, devlink_port,
1084 devlink_sb, pool_index,
1085 DEVLINK_CMD_SB_PORT_POOL_NEW,
1086 info->snd_portid, info->snd_seq, 0);
1087 if (err) {
1088 nlmsg_free(msg);
1089 return err;
1090 }
1091
1092 return genlmsg_reply(msg, info);
1093 }
1094
1095 static int __sb_port_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
1096 struct devlink *devlink,
1097 struct devlink_sb *devlink_sb,
1098 u32 portid, u32 seq)
1099 {
1100 struct devlink_port *devlink_port;
1101 u16 pool_count = devlink_sb_pool_count(devlink_sb);
1102 u16 pool_index;
1103 int err;
1104
1105 list_for_each_entry(devlink_port, &devlink->port_list, list) {
1106 for (pool_index = 0; pool_index < pool_count; pool_index++) {
1107 if (*p_idx < start) {
1108 (*p_idx)++;
1109 continue;
1110 }
1111 err = devlink_nl_sb_port_pool_fill(msg, devlink,
1112 devlink_port,
1113 devlink_sb,
1114 pool_index,
1115 DEVLINK_CMD_SB_PORT_POOL_NEW,
1116 portid, seq,
1117 NLM_F_MULTI);
1118 if (err)
1119 return err;
1120 (*p_idx)++;
1121 }
1122 }
1123 return 0;
1124 }
1125
1126 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff *msg,
1127 struct netlink_callback *cb)
1128 {
1129 struct devlink *devlink;
1130 struct devlink_sb *devlink_sb;
1131 int start = cb->args[0];
1132 int idx = 0;
1133 int err;
1134
1135 mutex_lock(&devlink_mutex);
1136 list_for_each_entry(devlink, &devlink_list, list) {
1137 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1138 !devlink->ops || !devlink->ops->sb_port_pool_get)
1139 continue;
1140 mutex_lock(&devlink->lock);
1141 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1142 err = __sb_port_pool_get_dumpit(msg, start, &idx,
1143 devlink, devlink_sb,
1144 NETLINK_CB(cb->skb).portid,
1145 cb->nlh->nlmsg_seq);
1146 if (err && err != -EOPNOTSUPP) {
1147 mutex_unlock(&devlink->lock);
1148 goto out;
1149 }
1150 }
1151 mutex_unlock(&devlink->lock);
1152 }
1153 out:
1154 mutex_unlock(&devlink_mutex);
1155
1156 cb->args[0] = idx;
1157 return msg->len;
1158 }
1159
1160 static int devlink_sb_port_pool_set(struct devlink_port *devlink_port,
1161 unsigned int sb_index, u16 pool_index,
1162 u32 threshold)
1163
1164 {
1165 const struct devlink_ops *ops = devlink_port->devlink->ops;
1166
1167 if (ops && ops->sb_port_pool_set)
1168 return ops->sb_port_pool_set(devlink_port, sb_index,
1169 pool_index, threshold);
1170 return -EOPNOTSUPP;
1171 }
1172
1173 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
1174 struct genl_info *info)
1175 {
1176 struct devlink_port *devlink_port = info->user_ptr[0];
1177 struct devlink_sb *devlink_sb = info->user_ptr[1];
1178 u16 pool_index;
1179 u32 threshold;
1180 int err;
1181
1182 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1183 &pool_index);
1184 if (err)
1185 return err;
1186
1187 if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1188 return -EINVAL;
1189
1190 threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1191 return devlink_sb_port_pool_set(devlink_port, devlink_sb->index,
1192 pool_index, threshold);
1193 }
1194
1195 static int
1196 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff *msg, struct devlink *devlink,
1197 struct devlink_port *devlink_port,
1198 struct devlink_sb *devlink_sb, u16 tc_index,
1199 enum devlink_sb_pool_type pool_type,
1200 enum devlink_command cmd,
1201 u32 portid, u32 seq, int flags)
1202 {
1203 const struct devlink_ops *ops = devlink->ops;
1204 u16 pool_index;
1205 u32 threshold;
1206 void *hdr;
1207 int err;
1208
1209 err = ops->sb_tc_pool_bind_get(devlink_port, devlink_sb->index,
1210 tc_index, pool_type,
1211 &pool_index, &threshold);
1212 if (err)
1213 return err;
1214
1215 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1216 if (!hdr)
1217 return -EMSGSIZE;
1218
1219 if (devlink_nl_put_handle(msg, devlink))
1220 goto nla_put_failure;
1221 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1222 goto nla_put_failure;
1223 if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1224 goto nla_put_failure;
1225 if (nla_put_u16(msg, DEVLINK_ATTR_SB_TC_INDEX, tc_index))
1226 goto nla_put_failure;
1227 if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_type))
1228 goto nla_put_failure;
1229 if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1230 goto nla_put_failure;
1231 if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1232 goto nla_put_failure;
1233
1234 if (ops->sb_occ_tc_port_bind_get) {
1235 u32 cur;
1236 u32 max;
1237
1238 err = ops->sb_occ_tc_port_bind_get(devlink_port,
1239 devlink_sb->index,
1240 tc_index, pool_type,
1241 &cur, &max);
1242 if (err && err != -EOPNOTSUPP)
1243 return err;
1244 if (!err) {
1245 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1246 goto nla_put_failure;
1247 if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1248 goto nla_put_failure;
1249 }
1250 }
1251
1252 genlmsg_end(msg, hdr);
1253 return 0;
1254
1255 nla_put_failure:
1256 genlmsg_cancel(msg, hdr);
1257 return -EMSGSIZE;
1258 }
1259
1260 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
1261 struct genl_info *info)
1262 {
1263 struct devlink_port *devlink_port = info->user_ptr[0];
1264 struct devlink *devlink = devlink_port->devlink;
1265 struct devlink_sb *devlink_sb = info->user_ptr[1];
1266 struct sk_buff *msg;
1267 enum devlink_sb_pool_type pool_type;
1268 u16 tc_index;
1269 int err;
1270
1271 err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1272 if (err)
1273 return err;
1274
1275 err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1276 pool_type, &tc_index);
1277 if (err)
1278 return err;
1279
1280 if (!devlink->ops || !devlink->ops->sb_tc_pool_bind_get)
1281 return -EOPNOTSUPP;
1282
1283 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1284 if (!msg)
1285 return -ENOMEM;
1286
1287 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink, devlink_port,
1288 devlink_sb, tc_index, pool_type,
1289 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1290 info->snd_portid,
1291 info->snd_seq, 0);
1292 if (err) {
1293 nlmsg_free(msg);
1294 return err;
1295 }
1296
1297 return genlmsg_reply(msg, info);
1298 }
1299
1300 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1301 int start, int *p_idx,
1302 struct devlink *devlink,
1303 struct devlink_sb *devlink_sb,
1304 u32 portid, u32 seq)
1305 {
1306 struct devlink_port *devlink_port;
1307 u16 tc_index;
1308 int err;
1309
1310 list_for_each_entry(devlink_port, &devlink->port_list, list) {
1311 for (tc_index = 0;
1312 tc_index < devlink_sb->ingress_tc_count; tc_index++) {
1313 if (*p_idx < start) {
1314 (*p_idx)++;
1315 continue;
1316 }
1317 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1318 devlink_port,
1319 devlink_sb,
1320 tc_index,
1321 DEVLINK_SB_POOL_TYPE_INGRESS,
1322 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1323 portid, seq,
1324 NLM_F_MULTI);
1325 if (err)
1326 return err;
1327 (*p_idx)++;
1328 }
1329 for (tc_index = 0;
1330 tc_index < devlink_sb->egress_tc_count; tc_index++) {
1331 if (*p_idx < start) {
1332 (*p_idx)++;
1333 continue;
1334 }
1335 err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1336 devlink_port,
1337 devlink_sb,
1338 tc_index,
1339 DEVLINK_SB_POOL_TYPE_EGRESS,
1340 DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1341 portid, seq,
1342 NLM_F_MULTI);
1343 if (err)
1344 return err;
1345 (*p_idx)++;
1346 }
1347 }
1348 return 0;
1349 }
1350
1351 static int
1352 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1353 struct netlink_callback *cb)
1354 {
1355 struct devlink *devlink;
1356 struct devlink_sb *devlink_sb;
1357 int start = cb->args[0];
1358 int idx = 0;
1359 int err;
1360
1361 mutex_lock(&devlink_mutex);
1362 list_for_each_entry(devlink, &devlink_list, list) {
1363 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1364 !devlink->ops || !devlink->ops->sb_tc_pool_bind_get)
1365 continue;
1366
1367 mutex_lock(&devlink->lock);
1368 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1369 err = __sb_tc_pool_bind_get_dumpit(msg, start, &idx,
1370 devlink,
1371 devlink_sb,
1372 NETLINK_CB(cb->skb).portid,
1373 cb->nlh->nlmsg_seq);
1374 if (err && err != -EOPNOTSUPP) {
1375 mutex_unlock(&devlink->lock);
1376 goto out;
1377 }
1378 }
1379 mutex_unlock(&devlink->lock);
1380 }
1381 out:
1382 mutex_unlock(&devlink_mutex);
1383
1384 cb->args[0] = idx;
1385 return msg->len;
1386 }
1387
1388 static int devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
1389 unsigned int sb_index, u16 tc_index,
1390 enum devlink_sb_pool_type pool_type,
1391 u16 pool_index, u32 threshold)
1392
1393 {
1394 const struct devlink_ops *ops = devlink_port->devlink->ops;
1395
1396 if (ops && ops->sb_tc_pool_bind_set)
1397 return ops->sb_tc_pool_bind_set(devlink_port, sb_index,
1398 tc_index, pool_type,
1399 pool_index, threshold);
1400 return -EOPNOTSUPP;
1401 }
1402
1403 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
1404 struct genl_info *info)
1405 {
1406 struct devlink_port *devlink_port = info->user_ptr[0];
1407 struct devlink_sb *devlink_sb = info->user_ptr[1];
1408 enum devlink_sb_pool_type pool_type;
1409 u16 tc_index;
1410 u16 pool_index;
1411 u32 threshold;
1412 int err;
1413
1414 err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1415 if (err)
1416 return err;
1417
1418 err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1419 pool_type, &tc_index);
1420 if (err)
1421 return err;
1422
1423 err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1424 &pool_index);
1425 if (err)
1426 return err;
1427
1428 if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1429 return -EINVAL;
1430
1431 threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1432 return devlink_sb_tc_pool_bind_set(devlink_port, devlink_sb->index,
1433 tc_index, pool_type,
1434 pool_index, threshold);
1435 }
1436
1437 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
1438 struct genl_info *info)
1439 {
1440 struct devlink *devlink = info->user_ptr[0];
1441 struct devlink_sb *devlink_sb = info->user_ptr[1];
1442 const struct devlink_ops *ops = devlink->ops;
1443
1444 if (ops && ops->sb_occ_snapshot)
1445 return ops->sb_occ_snapshot(devlink, devlink_sb->index);
1446 return -EOPNOTSUPP;
1447 }
1448
1449 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
1450 struct genl_info *info)
1451 {
1452 struct devlink *devlink = info->user_ptr[0];
1453 struct devlink_sb *devlink_sb = info->user_ptr[1];
1454 const struct devlink_ops *ops = devlink->ops;
1455
1456 if (ops && ops->sb_occ_max_clear)
1457 return ops->sb_occ_max_clear(devlink, devlink_sb->index);
1458 return -EOPNOTSUPP;
1459 }
1460
1461 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
1462 enum devlink_command cmd, u32 portid,
1463 u32 seq, int flags)
1464 {
1465 const struct devlink_ops *ops = devlink->ops;
1466 u8 inline_mode, encap_mode;
1467 void *hdr;
1468 int err = 0;
1469 u16 mode;
1470
1471 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1472 if (!hdr)
1473 return -EMSGSIZE;
1474
1475 err = devlink_nl_put_handle(msg, devlink);
1476 if (err)
1477 goto nla_put_failure;
1478
1479 if (ops->eswitch_mode_get) {
1480 err = ops->eswitch_mode_get(devlink, &mode);
1481 if (err)
1482 goto nla_put_failure;
1483 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
1484 if (err)
1485 goto nla_put_failure;
1486 }
1487
1488 if (ops->eswitch_inline_mode_get) {
1489 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
1490 if (err)
1491 goto nla_put_failure;
1492 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
1493 inline_mode);
1494 if (err)
1495 goto nla_put_failure;
1496 }
1497
1498 if (ops->eswitch_encap_mode_get) {
1499 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
1500 if (err)
1501 goto nla_put_failure;
1502 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
1503 if (err)
1504 goto nla_put_failure;
1505 }
1506
1507 genlmsg_end(msg, hdr);
1508 return 0;
1509
1510 nla_put_failure:
1511 genlmsg_cancel(msg, hdr);
1512 return err;
1513 }
1514
1515 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb,
1516 struct genl_info *info)
1517 {
1518 struct devlink *devlink = info->user_ptr[0];
1519 const struct devlink_ops *ops = devlink->ops;
1520 struct sk_buff *msg;
1521 int err;
1522
1523 if (!ops)
1524 return -EOPNOTSUPP;
1525
1526 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1527 if (!msg)
1528 return -ENOMEM;
1529
1530 err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
1531 info->snd_portid, info->snd_seq, 0);
1532
1533 if (err) {
1534 nlmsg_free(msg);
1535 return err;
1536 }
1537
1538 return genlmsg_reply(msg, info);
1539 }
1540
1541 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
1542 struct genl_info *info)
1543 {
1544 struct devlink *devlink = info->user_ptr[0];
1545 const struct devlink_ops *ops = devlink->ops;
1546 u8 inline_mode, encap_mode;
1547 int err = 0;
1548 u16 mode;
1549
1550 if (!ops)
1551 return -EOPNOTSUPP;
1552
1553 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
1554 if (!ops->eswitch_mode_set)
1555 return -EOPNOTSUPP;
1556 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
1557 err = ops->eswitch_mode_set(devlink, mode);
1558 if (err)
1559 return err;
1560 }
1561
1562 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
1563 if (!ops->eswitch_inline_mode_set)
1564 return -EOPNOTSUPP;
1565 inline_mode = nla_get_u8(
1566 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
1567 err = ops->eswitch_inline_mode_set(devlink, inline_mode);
1568 if (err)
1569 return err;
1570 }
1571
1572 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
1573 if (!ops->eswitch_encap_mode_set)
1574 return -EOPNOTSUPP;
1575 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
1576 err = ops->eswitch_encap_mode_set(devlink, encap_mode);
1577 if (err)
1578 return err;
1579 }
1580
1581 return 0;
1582 }
1583
1584 int devlink_dpipe_match_put(struct sk_buff *skb,
1585 struct devlink_dpipe_match *match)
1586 {
1587 struct devlink_dpipe_header *header = match->header;
1588 struct devlink_dpipe_field *field = &header->fields[match->field_id];
1589 struct nlattr *match_attr;
1590
1591 match_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_MATCH);
1592 if (!match_attr)
1593 return -EMSGSIZE;
1594
1595 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
1596 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
1597 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1598 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1599 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1600 goto nla_put_failure;
1601
1602 nla_nest_end(skb, match_attr);
1603 return 0;
1604
1605 nla_put_failure:
1606 nla_nest_cancel(skb, match_attr);
1607 return -EMSGSIZE;
1608 }
1609 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
1610
1611 static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
1612 struct sk_buff *skb)
1613 {
1614 struct nlattr *matches_attr;
1615
1616 matches_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
1617 if (!matches_attr)
1618 return -EMSGSIZE;
1619
1620 if (table->table_ops->matches_dump(table->priv, skb))
1621 goto nla_put_failure;
1622
1623 nla_nest_end(skb, matches_attr);
1624 return 0;
1625
1626 nla_put_failure:
1627 nla_nest_cancel(skb, matches_attr);
1628 return -EMSGSIZE;
1629 }
1630
1631 int devlink_dpipe_action_put(struct sk_buff *skb,
1632 struct devlink_dpipe_action *action)
1633 {
1634 struct devlink_dpipe_header *header = action->header;
1635 struct devlink_dpipe_field *field = &header->fields[action->field_id];
1636 struct nlattr *action_attr;
1637
1638 action_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_ACTION);
1639 if (!action_attr)
1640 return -EMSGSIZE;
1641
1642 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
1643 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
1644 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1645 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1646 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1647 goto nla_put_failure;
1648
1649 nla_nest_end(skb, action_attr);
1650 return 0;
1651
1652 nla_put_failure:
1653 nla_nest_cancel(skb, action_attr);
1654 return -EMSGSIZE;
1655 }
1656 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
1657
1658 static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
1659 struct sk_buff *skb)
1660 {
1661 struct nlattr *actions_attr;
1662
1663 actions_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
1664 if (!actions_attr)
1665 return -EMSGSIZE;
1666
1667 if (table->table_ops->actions_dump(table->priv, skb))
1668 goto nla_put_failure;
1669
1670 nla_nest_end(skb, actions_attr);
1671 return 0;
1672
1673 nla_put_failure:
1674 nla_nest_cancel(skb, actions_attr);
1675 return -EMSGSIZE;
1676 }
1677
1678 static int devlink_dpipe_table_put(struct sk_buff *skb,
1679 struct devlink_dpipe_table *table)
1680 {
1681 struct nlattr *table_attr;
1682 u64 table_size;
1683
1684 table_size = table->table_ops->size_get(table->priv);
1685 table_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE);
1686 if (!table_attr)
1687 return -EMSGSIZE;
1688
1689 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
1690 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
1691 DEVLINK_ATTR_PAD))
1692 goto nla_put_failure;
1693 if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
1694 table->counters_enabled))
1695 goto nla_put_failure;
1696
1697 if (table->resource_valid) {
1698 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
1699 table->resource_id, DEVLINK_ATTR_PAD);
1700 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
1701 table->resource_units, DEVLINK_ATTR_PAD);
1702 }
1703 if (devlink_dpipe_matches_put(table, skb))
1704 goto nla_put_failure;
1705
1706 if (devlink_dpipe_actions_put(table, skb))
1707 goto nla_put_failure;
1708
1709 nla_nest_end(skb, table_attr);
1710 return 0;
1711
1712 nla_put_failure:
1713 nla_nest_cancel(skb, table_attr);
1714 return -EMSGSIZE;
1715 }
1716
1717 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
1718 struct genl_info *info)
1719 {
1720 int err;
1721
1722 if (*pskb) {
1723 err = genlmsg_reply(*pskb, info);
1724 if (err)
1725 return err;
1726 }
1727 *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
1728 if (!*pskb)
1729 return -ENOMEM;
1730 return 0;
1731 }
1732
1733 static int devlink_dpipe_tables_fill(struct genl_info *info,
1734 enum devlink_command cmd, int flags,
1735 struct list_head *dpipe_tables,
1736 const char *table_name)
1737 {
1738 struct devlink *devlink = info->user_ptr[0];
1739 struct devlink_dpipe_table *table;
1740 struct nlattr *tables_attr;
1741 struct sk_buff *skb = NULL;
1742 struct nlmsghdr *nlh;
1743 bool incomplete;
1744 void *hdr;
1745 int i;
1746 int err;
1747
1748 table = list_first_entry(dpipe_tables,
1749 struct devlink_dpipe_table, list);
1750 start_again:
1751 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1752 if (err)
1753 return err;
1754
1755 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
1756 &devlink_nl_family, NLM_F_MULTI, cmd);
1757 if (!hdr) {
1758 nlmsg_free(skb);
1759 return -EMSGSIZE;
1760 }
1761
1762 if (devlink_nl_put_handle(skb, devlink))
1763 goto nla_put_failure;
1764 tables_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLES);
1765 if (!tables_attr)
1766 goto nla_put_failure;
1767
1768 i = 0;
1769 incomplete = false;
1770 list_for_each_entry_from(table, dpipe_tables, list) {
1771 if (!table_name) {
1772 err = devlink_dpipe_table_put(skb, table);
1773 if (err) {
1774 if (!i)
1775 goto err_table_put;
1776 incomplete = true;
1777 break;
1778 }
1779 } else {
1780 if (!strcmp(table->name, table_name)) {
1781 err = devlink_dpipe_table_put(skb, table);
1782 if (err)
1783 break;
1784 }
1785 }
1786 i++;
1787 }
1788
1789 nla_nest_end(skb, tables_attr);
1790 genlmsg_end(skb, hdr);
1791 if (incomplete)
1792 goto start_again;
1793
1794 send_done:
1795 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
1796 NLMSG_DONE, 0, flags | NLM_F_MULTI);
1797 if (!nlh) {
1798 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1799 if (err)
1800 goto err_skb_send_alloc;
1801 goto send_done;
1802 }
1803
1804 return genlmsg_reply(skb, info);
1805
1806 nla_put_failure:
1807 err = -EMSGSIZE;
1808 err_table_put:
1809 err_skb_send_alloc:
1810 genlmsg_cancel(skb, hdr);
1811 nlmsg_free(skb);
1812 return err;
1813 }
1814
1815 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
1816 struct genl_info *info)
1817 {
1818 struct devlink *devlink = info->user_ptr[0];
1819 const char *table_name = NULL;
1820
1821 if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
1822 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
1823
1824 return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
1825 &devlink->dpipe_table_list,
1826 table_name);
1827 }
1828
1829 static int devlink_dpipe_value_put(struct sk_buff *skb,
1830 struct devlink_dpipe_value *value)
1831 {
1832 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
1833 value->value_size, value->value))
1834 return -EMSGSIZE;
1835 if (value->mask)
1836 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
1837 value->value_size, value->mask))
1838 return -EMSGSIZE;
1839 if (value->mapping_valid)
1840 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
1841 value->mapping_value))
1842 return -EMSGSIZE;
1843 return 0;
1844 }
1845
1846 static int devlink_dpipe_action_value_put(struct sk_buff *skb,
1847 struct devlink_dpipe_value *value)
1848 {
1849 if (!value->action)
1850 return -EINVAL;
1851 if (devlink_dpipe_action_put(skb, value->action))
1852 return -EMSGSIZE;
1853 if (devlink_dpipe_value_put(skb, value))
1854 return -EMSGSIZE;
1855 return 0;
1856 }
1857
1858 static int devlink_dpipe_action_values_put(struct sk_buff *skb,
1859 struct devlink_dpipe_value *values,
1860 unsigned int values_count)
1861 {
1862 struct nlattr *action_attr;
1863 int i;
1864 int err;
1865
1866 for (i = 0; i < values_count; i++) {
1867 action_attr = nla_nest_start(skb,
1868 DEVLINK_ATTR_DPIPE_ACTION_VALUE);
1869 if (!action_attr)
1870 return -EMSGSIZE;
1871 err = devlink_dpipe_action_value_put(skb, &values[i]);
1872 if (err)
1873 goto err_action_value_put;
1874 nla_nest_end(skb, action_attr);
1875 }
1876 return 0;
1877
1878 err_action_value_put:
1879 nla_nest_cancel(skb, action_attr);
1880 return err;
1881 }
1882
1883 static int devlink_dpipe_match_value_put(struct sk_buff *skb,
1884 struct devlink_dpipe_value *value)
1885 {
1886 if (!value->match)
1887 return -EINVAL;
1888 if (devlink_dpipe_match_put(skb, value->match))
1889 return -EMSGSIZE;
1890 if (devlink_dpipe_value_put(skb, value))
1891 return -EMSGSIZE;
1892 return 0;
1893 }
1894
1895 static int devlink_dpipe_match_values_put(struct sk_buff *skb,
1896 struct devlink_dpipe_value *values,
1897 unsigned int values_count)
1898 {
1899 struct nlattr *match_attr;
1900 int i;
1901 int err;
1902
1903 for (i = 0; i < values_count; i++) {
1904 match_attr = nla_nest_start(skb,
1905 DEVLINK_ATTR_DPIPE_MATCH_VALUE);
1906 if (!match_attr)
1907 return -EMSGSIZE;
1908 err = devlink_dpipe_match_value_put(skb, &values[i]);
1909 if (err)
1910 goto err_match_value_put;
1911 nla_nest_end(skb, match_attr);
1912 }
1913 return 0;
1914
1915 err_match_value_put:
1916 nla_nest_cancel(skb, match_attr);
1917 return err;
1918 }
1919
1920 static int devlink_dpipe_entry_put(struct sk_buff *skb,
1921 struct devlink_dpipe_entry *entry)
1922 {
1923 struct nlattr *entry_attr, *matches_attr, *actions_attr;
1924 int err;
1925
1926 entry_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_ENTRY);
1927 if (!entry_attr)
1928 return -EMSGSIZE;
1929
1930 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
1931 DEVLINK_ATTR_PAD))
1932 goto nla_put_failure;
1933 if (entry->counter_valid)
1934 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
1935 entry->counter, DEVLINK_ATTR_PAD))
1936 goto nla_put_failure;
1937
1938 matches_attr = nla_nest_start(skb,
1939 DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
1940 if (!matches_attr)
1941 goto nla_put_failure;
1942
1943 err = devlink_dpipe_match_values_put(skb, entry->match_values,
1944 entry->match_values_count);
1945 if (err) {
1946 nla_nest_cancel(skb, matches_attr);
1947 goto err_match_values_put;
1948 }
1949 nla_nest_end(skb, matches_attr);
1950
1951 actions_attr = nla_nest_start(skb,
1952 DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
1953 if (!actions_attr)
1954 goto nla_put_failure;
1955
1956 err = devlink_dpipe_action_values_put(skb, entry->action_values,
1957 entry->action_values_count);
1958 if (err) {
1959 nla_nest_cancel(skb, actions_attr);
1960 goto err_action_values_put;
1961 }
1962 nla_nest_end(skb, actions_attr);
1963
1964 nla_nest_end(skb, entry_attr);
1965 return 0;
1966
1967 nla_put_failure:
1968 err = -EMSGSIZE;
1969 err_match_values_put:
1970 err_action_values_put:
1971 nla_nest_cancel(skb, entry_attr);
1972 return err;
1973 }
1974
1975 static struct devlink_dpipe_table *
1976 devlink_dpipe_table_find(struct list_head *dpipe_tables,
1977 const char *table_name)
1978 {
1979 struct devlink_dpipe_table *table;
1980
1981 list_for_each_entry_rcu(table, dpipe_tables, list) {
1982 if (!strcmp(table->name, table_name))
1983 return table;
1984 }
1985 return NULL;
1986 }
1987
1988 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
1989 {
1990 struct devlink *devlink;
1991 int err;
1992
1993 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
1994 dump_ctx->info);
1995 if (err)
1996 return err;
1997
1998 dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
1999 dump_ctx->info->snd_portid,
2000 dump_ctx->info->snd_seq,
2001 &devlink_nl_family, NLM_F_MULTI,
2002 dump_ctx->cmd);
2003 if (!dump_ctx->hdr)
2004 goto nla_put_failure;
2005
2006 devlink = dump_ctx->info->user_ptr[0];
2007 if (devlink_nl_put_handle(dump_ctx->skb, devlink))
2008 goto nla_put_failure;
2009 dump_ctx->nest = nla_nest_start(dump_ctx->skb,
2010 DEVLINK_ATTR_DPIPE_ENTRIES);
2011 if (!dump_ctx->nest)
2012 goto nla_put_failure;
2013 return 0;
2014
2015 nla_put_failure:
2016 genlmsg_cancel(dump_ctx->skb, dump_ctx->hdr);
2017 nlmsg_free(dump_ctx->skb);
2018 return -EMSGSIZE;
2019 }
2020 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
2021
2022 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
2023 struct devlink_dpipe_entry *entry)
2024 {
2025 return devlink_dpipe_entry_put(dump_ctx->skb, entry);
2026 }
2027 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
2028
2029 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
2030 {
2031 nla_nest_end(dump_ctx->skb, dump_ctx->nest);
2032 genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
2033 return 0;
2034 }
2035 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
2036
2037 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
2038
2039 {
2040 unsigned int value_count, value_index;
2041 struct devlink_dpipe_value *value;
2042
2043 value = entry->action_values;
2044 value_count = entry->action_values_count;
2045 for (value_index = 0; value_index < value_count; value_index++) {
2046 kfree(value[value_index].value);
2047 kfree(value[value_index].mask);
2048 }
2049
2050 value = entry->match_values;
2051 value_count = entry->match_values_count;
2052 for (value_index = 0; value_index < value_count; value_index++) {
2053 kfree(value[value_index].value);
2054 kfree(value[value_index].mask);
2055 }
2056 }
2057 EXPORT_SYMBOL(devlink_dpipe_entry_clear);
2058
2059 static int devlink_dpipe_entries_fill(struct genl_info *info,
2060 enum devlink_command cmd, int flags,
2061 struct devlink_dpipe_table *table)
2062 {
2063 struct devlink_dpipe_dump_ctx dump_ctx;
2064 struct nlmsghdr *nlh;
2065 int err;
2066
2067 dump_ctx.skb = NULL;
2068 dump_ctx.cmd = cmd;
2069 dump_ctx.info = info;
2070
2071 err = table->table_ops->entries_dump(table->priv,
2072 table->counters_enabled,
2073 &dump_ctx);
2074 if (err)
2075 goto err_entries_dump;
2076
2077 send_done:
2078 nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
2079 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2080 if (!nlh) {
2081 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
2082 if (err)
2083 goto err_skb_send_alloc;
2084 goto send_done;
2085 }
2086 return genlmsg_reply(dump_ctx.skb, info);
2087
2088 err_entries_dump:
2089 err_skb_send_alloc:
2090 genlmsg_cancel(dump_ctx.skb, dump_ctx.hdr);
2091 nlmsg_free(dump_ctx.skb);
2092 return err;
2093 }
2094
2095 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
2096 struct genl_info *info)
2097 {
2098 struct devlink *devlink = info->user_ptr[0];
2099 struct devlink_dpipe_table *table;
2100 const char *table_name;
2101
2102 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
2103 return -EINVAL;
2104
2105 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2106 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2107 table_name);
2108 if (!table)
2109 return -EINVAL;
2110
2111 if (!table->table_ops->entries_dump)
2112 return -EINVAL;
2113
2114 return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
2115 0, table);
2116 }
2117
2118 static int devlink_dpipe_fields_put(struct sk_buff *skb,
2119 const struct devlink_dpipe_header *header)
2120 {
2121 struct devlink_dpipe_field *field;
2122 struct nlattr *field_attr;
2123 int i;
2124
2125 for (i = 0; i < header->fields_count; i++) {
2126 field = &header->fields[i];
2127 field_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_FIELD);
2128 if (!field_attr)
2129 return -EMSGSIZE;
2130 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
2131 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2132 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
2133 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
2134 goto nla_put_failure;
2135 nla_nest_end(skb, field_attr);
2136 }
2137 return 0;
2138
2139 nla_put_failure:
2140 nla_nest_cancel(skb, field_attr);
2141 return -EMSGSIZE;
2142 }
2143
2144 static int devlink_dpipe_header_put(struct sk_buff *skb,
2145 struct devlink_dpipe_header *header)
2146 {
2147 struct nlattr *fields_attr, *header_attr;
2148 int err;
2149
2150 header_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADER);
2151 if (!header_attr)
2152 return -EMSGSIZE;
2153
2154 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
2155 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2156 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2157 goto nla_put_failure;
2158
2159 fields_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
2160 if (!fields_attr)
2161 goto nla_put_failure;
2162
2163 err = devlink_dpipe_fields_put(skb, header);
2164 if (err) {
2165 nla_nest_cancel(skb, fields_attr);
2166 goto nla_put_failure;
2167 }
2168 nla_nest_end(skb, fields_attr);
2169 nla_nest_end(skb, header_attr);
2170 return 0;
2171
2172 nla_put_failure:
2173 err = -EMSGSIZE;
2174 nla_nest_cancel(skb, header_attr);
2175 return err;
2176 }
2177
2178 static int devlink_dpipe_headers_fill(struct genl_info *info,
2179 enum devlink_command cmd, int flags,
2180 struct devlink_dpipe_headers *
2181 dpipe_headers)
2182 {
2183 struct devlink *devlink = info->user_ptr[0];
2184 struct nlattr *headers_attr;
2185 struct sk_buff *skb = NULL;
2186 struct nlmsghdr *nlh;
2187 void *hdr;
2188 int i, j;
2189 int err;
2190
2191 i = 0;
2192 start_again:
2193 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2194 if (err)
2195 return err;
2196
2197 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2198 &devlink_nl_family, NLM_F_MULTI, cmd);
2199 if (!hdr) {
2200 nlmsg_free(skb);
2201 return -EMSGSIZE;
2202 }
2203
2204 if (devlink_nl_put_handle(skb, devlink))
2205 goto nla_put_failure;
2206 headers_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADERS);
2207 if (!headers_attr)
2208 goto nla_put_failure;
2209
2210 j = 0;
2211 for (; i < dpipe_headers->headers_count; i++) {
2212 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
2213 if (err) {
2214 if (!j)
2215 goto err_table_put;
2216 break;
2217 }
2218 j++;
2219 }
2220 nla_nest_end(skb, headers_attr);
2221 genlmsg_end(skb, hdr);
2222 if (i != dpipe_headers->headers_count)
2223 goto start_again;
2224
2225 send_done:
2226 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2227 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2228 if (!nlh) {
2229 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2230 if (err)
2231 goto err_skb_send_alloc;
2232 goto send_done;
2233 }
2234 return genlmsg_reply(skb, info);
2235
2236 nla_put_failure:
2237 err = -EMSGSIZE;
2238 err_table_put:
2239 err_skb_send_alloc:
2240 genlmsg_cancel(skb, hdr);
2241 nlmsg_free(skb);
2242 return err;
2243 }
2244
2245 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
2246 struct genl_info *info)
2247 {
2248 struct devlink *devlink = info->user_ptr[0];
2249
2250 if (!devlink->dpipe_headers)
2251 return -EOPNOTSUPP;
2252 return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
2253 0, devlink->dpipe_headers);
2254 }
2255
2256 static int devlink_dpipe_table_counters_set(struct devlink *devlink,
2257 const char *table_name,
2258 bool enable)
2259 {
2260 struct devlink_dpipe_table *table;
2261
2262 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2263 table_name);
2264 if (!table)
2265 return -EINVAL;
2266
2267 if (table->counter_control_extern)
2268 return -EOPNOTSUPP;
2269
2270 if (!(table->counters_enabled ^ enable))
2271 return 0;
2272
2273 table->counters_enabled = enable;
2274 if (table->table_ops->counters_set_update)
2275 table->table_ops->counters_set_update(table->priv, enable);
2276 return 0;
2277 }
2278
2279 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
2280 struct genl_info *info)
2281 {
2282 struct devlink *devlink = info->user_ptr[0];
2283 const char *table_name;
2284 bool counters_enable;
2285
2286 if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
2287 !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
2288 return -EINVAL;
2289
2290 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2291 counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
2292
2293 return devlink_dpipe_table_counters_set(devlink, table_name,
2294 counters_enable);
2295 }
2296
2297 static struct devlink_resource *
2298 devlink_resource_find(struct devlink *devlink,
2299 struct devlink_resource *resource, u64 resource_id)
2300 {
2301 struct list_head *resource_list;
2302
2303 if (resource)
2304 resource_list = &resource->resource_list;
2305 else
2306 resource_list = &devlink->resource_list;
2307
2308 list_for_each_entry(resource, resource_list, list) {
2309 struct devlink_resource *child_resource;
2310
2311 if (resource->id == resource_id)
2312 return resource;
2313
2314 child_resource = devlink_resource_find(devlink, resource,
2315 resource_id);
2316 if (child_resource)
2317 return child_resource;
2318 }
2319 return NULL;
2320 }
2321
2322 static void
2323 devlink_resource_validate_children(struct devlink_resource *resource)
2324 {
2325 struct devlink_resource *child_resource;
2326 bool size_valid = true;
2327 u64 parts_size = 0;
2328
2329 if (list_empty(&resource->resource_list))
2330 goto out;
2331
2332 list_for_each_entry(child_resource, &resource->resource_list, list)
2333 parts_size += child_resource->size_new;
2334
2335 if (parts_size > resource->size)
2336 size_valid = false;
2337 out:
2338 resource->size_valid = size_valid;
2339 }
2340
2341 static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
2342 struct genl_info *info)
2343 {
2344 struct devlink *devlink = info->user_ptr[0];
2345 struct devlink_resource *resource;
2346 u64 resource_id;
2347 u64 size;
2348 int err;
2349
2350 if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
2351 !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
2352 return -EINVAL;
2353 resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
2354
2355 resource = devlink_resource_find(devlink, NULL, resource_id);
2356 if (!resource)
2357 return -EINVAL;
2358
2359 if (!resource->resource_ops->size_validate)
2360 return -EINVAL;
2361
2362 size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
2363 err = resource->resource_ops->size_validate(devlink, size,
2364 info->extack);
2365 if (err)
2366 return err;
2367
2368 resource->size_new = size;
2369 devlink_resource_validate_children(resource);
2370 if (resource->parent)
2371 devlink_resource_validate_children(resource->parent);
2372 return 0;
2373 }
2374
2375 static void
2376 devlink_resource_size_params_put(struct devlink_resource *resource,
2377 struct sk_buff *skb)
2378 {
2379 struct devlink_resource_size_params *size_params;
2380
2381 size_params = resource->size_params;
2382 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
2383 size_params->size_granularity, DEVLINK_ATTR_PAD);
2384 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
2385 size_params->size_max, DEVLINK_ATTR_PAD);
2386 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
2387 size_params->size_min, DEVLINK_ATTR_PAD);
2388 nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit);
2389 }
2390
2391 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
2392 struct devlink_resource *resource)
2393 {
2394 struct devlink_resource *child_resource;
2395 struct nlattr *child_resource_attr;
2396 struct nlattr *resource_attr;
2397
2398 resource_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE);
2399 if (!resource_attr)
2400 return -EMSGSIZE;
2401
2402 if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
2403 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
2404 DEVLINK_ATTR_PAD) ||
2405 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
2406 DEVLINK_ATTR_PAD))
2407 goto nla_put_failure;
2408 if (resource->size != resource->size_new)
2409 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
2410 resource->size_new, DEVLINK_ATTR_PAD);
2411 if (resource->resource_ops && resource->resource_ops->occ_get)
2412 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
2413 resource->resource_ops->occ_get(devlink),
2414 DEVLINK_ATTR_PAD);
2415 devlink_resource_size_params_put(resource, skb);
2416 if (list_empty(&resource->resource_list))
2417 goto out;
2418
2419 if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
2420 resource->size_valid))
2421 goto nla_put_failure;
2422
2423 child_resource_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE_LIST);
2424 if (!child_resource_attr)
2425 goto nla_put_failure;
2426
2427 list_for_each_entry(child_resource, &resource->resource_list, list) {
2428 if (devlink_resource_put(devlink, skb, child_resource))
2429 goto resource_put_failure;
2430 }
2431
2432 nla_nest_end(skb, child_resource_attr);
2433 out:
2434 nla_nest_end(skb, resource_attr);
2435 return 0;
2436
2437 resource_put_failure:
2438 nla_nest_cancel(skb, child_resource_attr);
2439 nla_put_failure:
2440 nla_nest_cancel(skb, resource_attr);
2441 return -EMSGSIZE;
2442 }
2443
2444 static int devlink_resource_fill(struct genl_info *info,
2445 enum devlink_command cmd, int flags)
2446 {
2447 struct devlink *devlink = info->user_ptr[0];
2448 struct devlink_resource *resource;
2449 struct nlattr *resources_attr;
2450 struct sk_buff *skb = NULL;
2451 struct nlmsghdr *nlh;
2452 bool incomplete;
2453 void *hdr;
2454 int i;
2455 int err;
2456
2457 resource = list_first_entry(&devlink->resource_list,
2458 struct devlink_resource, list);
2459 start_again:
2460 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2461 if (err)
2462 return err;
2463
2464 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2465 &devlink_nl_family, NLM_F_MULTI, cmd);
2466 if (!hdr) {
2467 nlmsg_free(skb);
2468 return -EMSGSIZE;
2469 }
2470
2471 if (devlink_nl_put_handle(skb, devlink))
2472 goto nla_put_failure;
2473
2474 resources_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE_LIST);
2475 if (!resources_attr)
2476 goto nla_put_failure;
2477
2478 incomplete = false;
2479 i = 0;
2480 list_for_each_entry_from(resource, &devlink->resource_list, list) {
2481 err = devlink_resource_put(devlink, skb, resource);
2482 if (err) {
2483 if (!i)
2484 goto err_resource_put;
2485 incomplete = true;
2486 break;
2487 }
2488 i++;
2489 }
2490 nla_nest_end(skb, resources_attr);
2491 genlmsg_end(skb, hdr);
2492 if (incomplete)
2493 goto start_again;
2494 send_done:
2495 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2496 NLMSG_DONE, 0, flags | NLM_F_MULTI);
2497 if (!nlh) {
2498 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2499 if (err)
2500 goto err_skb_send_alloc;
2501 goto send_done;
2502 }
2503 return genlmsg_reply(skb, info);
2504
2505 nla_put_failure:
2506 err = -EMSGSIZE;
2507 err_resource_put:
2508 err_skb_send_alloc:
2509 genlmsg_cancel(skb, hdr);
2510 nlmsg_free(skb);
2511 return err;
2512 }
2513
2514 static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
2515 struct genl_info *info)
2516 {
2517 struct devlink *devlink = info->user_ptr[0];
2518
2519 if (list_empty(&devlink->resource_list))
2520 return -EOPNOTSUPP;
2521
2522 return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
2523 }
2524
2525 static int
2526 devlink_resources_validate(struct devlink *devlink,
2527 struct devlink_resource *resource,
2528 struct genl_info *info)
2529 {
2530 struct list_head *resource_list;
2531 int err = 0;
2532
2533 if (resource)
2534 resource_list = &resource->resource_list;
2535 else
2536 resource_list = &devlink->resource_list;
2537
2538 list_for_each_entry(resource, resource_list, list) {
2539 if (!resource->size_valid)
2540 return -EINVAL;
2541 err = devlink_resources_validate(devlink, resource, info);
2542 if (err)
2543 return err;
2544 }
2545 return err;
2546 }
2547
2548 static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
2549 {
2550 struct devlink *devlink = info->user_ptr[0];
2551 int err;
2552
2553 if (!devlink->ops->reload)
2554 return -EOPNOTSUPP;
2555
2556 err = devlink_resources_validate(devlink, NULL, info);
2557 if (err) {
2558 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
2559 return err;
2560 }
2561 return devlink->ops->reload(devlink);
2562 }
2563
2564 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
2565 [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
2566 [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
2567 [DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
2568 [DEVLINK_ATTR_PORT_TYPE] = { .type = NLA_U16 },
2569 [DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
2570 [DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
2571 [DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
2572 [DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
2573 [DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
2574 [DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
2575 [DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
2576 [DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
2577 [DEVLINK_ATTR_ESWITCH_MODE] = { .type = NLA_U16 },
2578 [DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
2579 [DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
2580 [DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
2581 [DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
2582 [DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
2583 [DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
2584 };
2585
2586 static const struct genl_ops devlink_nl_ops[] = {
2587 {
2588 .cmd = DEVLINK_CMD_GET,
2589 .doit = devlink_nl_cmd_get_doit,
2590 .dumpit = devlink_nl_cmd_get_dumpit,
2591 .policy = devlink_nl_policy,
2592 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2593 /* can be retrieved by unprivileged users */
2594 },
2595 {
2596 .cmd = DEVLINK_CMD_PORT_GET,
2597 .doit = devlink_nl_cmd_port_get_doit,
2598 .dumpit = devlink_nl_cmd_port_get_dumpit,
2599 .policy = devlink_nl_policy,
2600 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
2601 /* can be retrieved by unprivileged users */
2602 },
2603 {
2604 .cmd = DEVLINK_CMD_PORT_SET,
2605 .doit = devlink_nl_cmd_port_set_doit,
2606 .policy = devlink_nl_policy,
2607 .flags = GENL_ADMIN_PERM,
2608 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
2609 },
2610 {
2611 .cmd = DEVLINK_CMD_PORT_SPLIT,
2612 .doit = devlink_nl_cmd_port_split_doit,
2613 .policy = devlink_nl_policy,
2614 .flags = GENL_ADMIN_PERM,
2615 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2616 DEVLINK_NL_FLAG_NO_LOCK,
2617 },
2618 {
2619 .cmd = DEVLINK_CMD_PORT_UNSPLIT,
2620 .doit = devlink_nl_cmd_port_unsplit_doit,
2621 .policy = devlink_nl_policy,
2622 .flags = GENL_ADMIN_PERM,
2623 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2624 DEVLINK_NL_FLAG_NO_LOCK,
2625 },
2626 {
2627 .cmd = DEVLINK_CMD_SB_GET,
2628 .doit = devlink_nl_cmd_sb_get_doit,
2629 .dumpit = devlink_nl_cmd_sb_get_dumpit,
2630 .policy = devlink_nl_policy,
2631 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2632 DEVLINK_NL_FLAG_NEED_SB,
2633 /* can be retrieved by unprivileged users */
2634 },
2635 {
2636 .cmd = DEVLINK_CMD_SB_POOL_GET,
2637 .doit = devlink_nl_cmd_sb_pool_get_doit,
2638 .dumpit = devlink_nl_cmd_sb_pool_get_dumpit,
2639 .policy = devlink_nl_policy,
2640 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2641 DEVLINK_NL_FLAG_NEED_SB,
2642 /* can be retrieved by unprivileged users */
2643 },
2644 {
2645 .cmd = DEVLINK_CMD_SB_POOL_SET,
2646 .doit = devlink_nl_cmd_sb_pool_set_doit,
2647 .policy = devlink_nl_policy,
2648 .flags = GENL_ADMIN_PERM,
2649 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2650 DEVLINK_NL_FLAG_NEED_SB,
2651 },
2652 {
2653 .cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
2654 .doit = devlink_nl_cmd_sb_port_pool_get_doit,
2655 .dumpit = devlink_nl_cmd_sb_port_pool_get_dumpit,
2656 .policy = devlink_nl_policy,
2657 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2658 DEVLINK_NL_FLAG_NEED_SB,
2659 /* can be retrieved by unprivileged users */
2660 },
2661 {
2662 .cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
2663 .doit = devlink_nl_cmd_sb_port_pool_set_doit,
2664 .policy = devlink_nl_policy,
2665 .flags = GENL_ADMIN_PERM,
2666 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2667 DEVLINK_NL_FLAG_NEED_SB,
2668 },
2669 {
2670 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
2671 .doit = devlink_nl_cmd_sb_tc_pool_bind_get_doit,
2672 .dumpit = devlink_nl_cmd_sb_tc_pool_bind_get_dumpit,
2673 .policy = devlink_nl_policy,
2674 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2675 DEVLINK_NL_FLAG_NEED_SB,
2676 /* can be retrieved by unprivileged users */
2677 },
2678 {
2679 .cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
2680 .doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
2681 .policy = devlink_nl_policy,
2682 .flags = GENL_ADMIN_PERM,
2683 .internal_flags = DEVLINK_NL_FLAG_NEED_PORT |
2684 DEVLINK_NL_FLAG_NEED_SB,
2685 },
2686 {
2687 .cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
2688 .doit = devlink_nl_cmd_sb_occ_snapshot_doit,
2689 .policy = devlink_nl_policy,
2690 .flags = GENL_ADMIN_PERM,
2691 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2692 DEVLINK_NL_FLAG_NEED_SB,
2693 },
2694 {
2695 .cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
2696 .doit = devlink_nl_cmd_sb_occ_max_clear_doit,
2697 .policy = devlink_nl_policy,
2698 .flags = GENL_ADMIN_PERM,
2699 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2700 DEVLINK_NL_FLAG_NEED_SB,
2701 },
2702 {
2703 .cmd = DEVLINK_CMD_ESWITCH_GET,
2704 .doit = devlink_nl_cmd_eswitch_get_doit,
2705 .policy = devlink_nl_policy,
2706 .flags = GENL_ADMIN_PERM,
2707 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2708 },
2709 {
2710 .cmd = DEVLINK_CMD_ESWITCH_SET,
2711 .doit = devlink_nl_cmd_eswitch_set_doit,
2712 .policy = devlink_nl_policy,
2713 .flags = GENL_ADMIN_PERM,
2714 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2715 },
2716 {
2717 .cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
2718 .doit = devlink_nl_cmd_dpipe_table_get,
2719 .policy = devlink_nl_policy,
2720 .flags = GENL_ADMIN_PERM,
2721 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2722 },
2723 {
2724 .cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
2725 .doit = devlink_nl_cmd_dpipe_entries_get,
2726 .policy = devlink_nl_policy,
2727 .flags = GENL_ADMIN_PERM,
2728 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2729 },
2730 {
2731 .cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
2732 .doit = devlink_nl_cmd_dpipe_headers_get,
2733 .policy = devlink_nl_policy,
2734 .flags = GENL_ADMIN_PERM,
2735 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2736 },
2737 {
2738 .cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
2739 .doit = devlink_nl_cmd_dpipe_table_counters_set,
2740 .policy = devlink_nl_policy,
2741 .flags = GENL_ADMIN_PERM,
2742 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2743 },
2744 {
2745 .cmd = DEVLINK_CMD_RESOURCE_SET,
2746 .doit = devlink_nl_cmd_resource_set,
2747 .policy = devlink_nl_policy,
2748 .flags = GENL_ADMIN_PERM,
2749 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2750 },
2751 {
2752 .cmd = DEVLINK_CMD_RESOURCE_DUMP,
2753 .doit = devlink_nl_cmd_resource_dump,
2754 .policy = devlink_nl_policy,
2755 .flags = GENL_ADMIN_PERM,
2756 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
2757 },
2758 {
2759 .cmd = DEVLINK_CMD_RELOAD,
2760 .doit = devlink_nl_cmd_reload,
2761 .policy = devlink_nl_policy,
2762 .flags = GENL_ADMIN_PERM,
2763 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK |
2764 DEVLINK_NL_FLAG_NO_LOCK,
2765 },
2766 };
2767
2768 static struct genl_family devlink_nl_family __ro_after_init = {
2769 .name = DEVLINK_GENL_NAME,
2770 .version = DEVLINK_GENL_VERSION,
2771 .maxattr = DEVLINK_ATTR_MAX,
2772 .netnsok = true,
2773 .pre_doit = devlink_nl_pre_doit,
2774 .post_doit = devlink_nl_post_doit,
2775 .module = THIS_MODULE,
2776 .ops = devlink_nl_ops,
2777 .n_ops = ARRAY_SIZE(devlink_nl_ops),
2778 .mcgrps = devlink_nl_mcgrps,
2779 .n_mcgrps = ARRAY_SIZE(devlink_nl_mcgrps),
2780 };
2781
2782 /**
2783 * devlink_alloc - Allocate new devlink instance resources
2784 *
2785 * @ops: ops
2786 * @priv_size: size of user private data
2787 *
2788 * Allocate new devlink instance resources, including devlink index
2789 * and name.
2790 */
2791 struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size)
2792 {
2793 struct devlink *devlink;
2794
2795 devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
2796 if (!devlink)
2797 return NULL;
2798 devlink->ops = ops;
2799 devlink_net_set(devlink, &init_net);
2800 INIT_LIST_HEAD(&devlink->port_list);
2801 INIT_LIST_HEAD(&devlink->sb_list);
2802 INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
2803 INIT_LIST_HEAD(&devlink->resource_list);
2804 mutex_init(&devlink->lock);
2805 return devlink;
2806 }
2807 EXPORT_SYMBOL_GPL(devlink_alloc);
2808
2809 /**
2810 * devlink_register - Register devlink instance
2811 *
2812 * @devlink: devlink
2813 */
2814 int devlink_register(struct devlink *devlink, struct device *dev)
2815 {
2816 mutex_lock(&devlink_mutex);
2817 devlink->dev = dev;
2818 list_add_tail(&devlink->list, &devlink_list);
2819 devlink_notify(devlink, DEVLINK_CMD_NEW);
2820 mutex_unlock(&devlink_mutex);
2821 return 0;
2822 }
2823 EXPORT_SYMBOL_GPL(devlink_register);
2824
2825 /**
2826 * devlink_unregister - Unregister devlink instance
2827 *
2828 * @devlink: devlink
2829 */
2830 void devlink_unregister(struct devlink *devlink)
2831 {
2832 mutex_lock(&devlink_mutex);
2833 devlink_notify(devlink, DEVLINK_CMD_DEL);
2834 list_del(&devlink->list);
2835 mutex_unlock(&devlink_mutex);
2836 }
2837 EXPORT_SYMBOL_GPL(devlink_unregister);
2838
2839 /**
2840 * devlink_free - Free devlink instance resources
2841 *
2842 * @devlink: devlink
2843 */
2844 void devlink_free(struct devlink *devlink)
2845 {
2846 kfree(devlink);
2847 }
2848 EXPORT_SYMBOL_GPL(devlink_free);
2849
2850 /**
2851 * devlink_port_register - Register devlink port
2852 *
2853 * @devlink: devlink
2854 * @devlink_port: devlink port
2855 * @port_index
2856 *
2857 * Register devlink port with provided port index. User can use
2858 * any indexing, even hw-related one. devlink_port structure
2859 * is convenient to be embedded inside user driver private structure.
2860 * Note that the caller should take care of zeroing the devlink_port
2861 * structure.
2862 */
2863 int devlink_port_register(struct devlink *devlink,
2864 struct devlink_port *devlink_port,
2865 unsigned int port_index)
2866 {
2867 mutex_lock(&devlink->lock);
2868 if (devlink_port_index_exists(devlink, port_index)) {
2869 mutex_unlock(&devlink->lock);
2870 return -EEXIST;
2871 }
2872 devlink_port->devlink = devlink;
2873 devlink_port->index = port_index;
2874 devlink_port->registered = true;
2875 list_add_tail(&devlink_port->list, &devlink->port_list);
2876 mutex_unlock(&devlink->lock);
2877 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
2878 return 0;
2879 }
2880 EXPORT_SYMBOL_GPL(devlink_port_register);
2881
2882 /**
2883 * devlink_port_unregister - Unregister devlink port
2884 *
2885 * @devlink_port: devlink port
2886 */
2887 void devlink_port_unregister(struct devlink_port *devlink_port)
2888 {
2889 struct devlink *devlink = devlink_port->devlink;
2890
2891 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
2892 mutex_lock(&devlink->lock);
2893 list_del(&devlink_port->list);
2894 mutex_unlock(&devlink->lock);
2895 }
2896 EXPORT_SYMBOL_GPL(devlink_port_unregister);
2897
2898 static void __devlink_port_type_set(struct devlink_port *devlink_port,
2899 enum devlink_port_type type,
2900 void *type_dev)
2901 {
2902 devlink_port->type = type;
2903 devlink_port->type_dev = type_dev;
2904 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
2905 }
2906
2907 /**
2908 * devlink_port_type_eth_set - Set port type to Ethernet
2909 *
2910 * @devlink_port: devlink port
2911 * @netdev: related netdevice
2912 */
2913 void devlink_port_type_eth_set(struct devlink_port *devlink_port,
2914 struct net_device *netdev)
2915 {
2916 return __devlink_port_type_set(devlink_port,
2917 DEVLINK_PORT_TYPE_ETH, netdev);
2918 }
2919 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
2920
2921 /**
2922 * devlink_port_type_ib_set - Set port type to InfiniBand
2923 *
2924 * @devlink_port: devlink port
2925 * @ibdev: related IB device
2926 */
2927 void devlink_port_type_ib_set(struct devlink_port *devlink_port,
2928 struct ib_device *ibdev)
2929 {
2930 return __devlink_port_type_set(devlink_port,
2931 DEVLINK_PORT_TYPE_IB, ibdev);
2932 }
2933 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
2934
2935 /**
2936 * devlink_port_type_clear - Clear port type
2937 *
2938 * @devlink_port: devlink port
2939 */
2940 void devlink_port_type_clear(struct devlink_port *devlink_port)
2941 {
2942 return __devlink_port_type_set(devlink_port,
2943 DEVLINK_PORT_TYPE_NOTSET, NULL);
2944 }
2945 EXPORT_SYMBOL_GPL(devlink_port_type_clear);
2946
2947 /**
2948 * devlink_port_split_set - Set port is split
2949 *
2950 * @devlink_port: devlink port
2951 * @split_group: split group - identifies group split port is part of
2952 */
2953 void devlink_port_split_set(struct devlink_port *devlink_port,
2954 u32 split_group)
2955 {
2956 devlink_port->split = true;
2957 devlink_port->split_group = split_group;
2958 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
2959 }
2960 EXPORT_SYMBOL_GPL(devlink_port_split_set);
2961
2962 int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
2963 u32 size, u16 ingress_pools_count,
2964 u16 egress_pools_count, u16 ingress_tc_count,
2965 u16 egress_tc_count)
2966 {
2967 struct devlink_sb *devlink_sb;
2968 int err = 0;
2969
2970 mutex_lock(&devlink->lock);
2971 if (devlink_sb_index_exists(devlink, sb_index)) {
2972 err = -EEXIST;
2973 goto unlock;
2974 }
2975
2976 devlink_sb = kzalloc(sizeof(*devlink_sb), GFP_KERNEL);
2977 if (!devlink_sb) {
2978 err = -ENOMEM;
2979 goto unlock;
2980 }
2981 devlink_sb->index = sb_index;
2982 devlink_sb->size = size;
2983 devlink_sb->ingress_pools_count = ingress_pools_count;
2984 devlink_sb->egress_pools_count = egress_pools_count;
2985 devlink_sb->ingress_tc_count = ingress_tc_count;
2986 devlink_sb->egress_tc_count = egress_tc_count;
2987 list_add_tail(&devlink_sb->list, &devlink->sb_list);
2988 unlock:
2989 mutex_unlock(&devlink->lock);
2990 return err;
2991 }
2992 EXPORT_SYMBOL_GPL(devlink_sb_register);
2993
2994 void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index)
2995 {
2996 struct devlink_sb *devlink_sb;
2997
2998 mutex_lock(&devlink->lock);
2999 devlink_sb = devlink_sb_get_by_index(devlink, sb_index);
3000 WARN_ON(!devlink_sb);
3001 list_del(&devlink_sb->list);
3002 mutex_unlock(&devlink->lock);
3003 kfree(devlink_sb);
3004 }
3005 EXPORT_SYMBOL_GPL(devlink_sb_unregister);
3006
3007 /**
3008 * devlink_dpipe_headers_register - register dpipe headers
3009 *
3010 * @devlink: devlink
3011 * @dpipe_headers: dpipe header array
3012 *
3013 * Register the headers supported by hardware.
3014 */
3015 int devlink_dpipe_headers_register(struct devlink *devlink,
3016 struct devlink_dpipe_headers *dpipe_headers)
3017 {
3018 mutex_lock(&devlink->lock);
3019 devlink->dpipe_headers = dpipe_headers;
3020 mutex_unlock(&devlink->lock);
3021 return 0;
3022 }
3023 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_register);
3024
3025 /**
3026 * devlink_dpipe_headers_unregister - unregister dpipe headers
3027 *
3028 * @devlink: devlink
3029 *
3030 * Unregister the headers supported by hardware.
3031 */
3032 void devlink_dpipe_headers_unregister(struct devlink *devlink)
3033 {
3034 mutex_lock(&devlink->lock);
3035 devlink->dpipe_headers = NULL;
3036 mutex_unlock(&devlink->lock);
3037 }
3038 EXPORT_SYMBOL_GPL(devlink_dpipe_headers_unregister);
3039
3040 /**
3041 * devlink_dpipe_table_counter_enabled - check if counter allocation
3042 * required
3043 * @devlink: devlink
3044 * @table_name: tables name
3045 *
3046 * Used by driver to check if counter allocation is required.
3047 * After counter allocation is turned on the table entries
3048 * are updated to include counter statistics.
3049 *
3050 * After that point on the driver must respect the counter
3051 * state so that each entry added to the table is added
3052 * with a counter.
3053 */
3054 bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
3055 const char *table_name)
3056 {
3057 struct devlink_dpipe_table *table;
3058 bool enabled;
3059
3060 rcu_read_lock();
3061 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3062 table_name);
3063 enabled = false;
3064 if (table)
3065 enabled = table->counters_enabled;
3066 rcu_read_unlock();
3067 return enabled;
3068 }
3069 EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
3070
3071 /**
3072 * devlink_dpipe_table_register - register dpipe table
3073 *
3074 * @devlink: devlink
3075 * @table_name: table name
3076 * @table_ops: table ops
3077 * @priv: priv
3078 * @counter_control_extern: external control for counters
3079 */
3080 int devlink_dpipe_table_register(struct devlink *devlink,
3081 const char *table_name,
3082 struct devlink_dpipe_table_ops *table_ops,
3083 void *priv, bool counter_control_extern)
3084 {
3085 struct devlink_dpipe_table *table;
3086
3087 if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name))
3088 return -EEXIST;
3089
3090 if (WARN_ON(!table_ops->size_get))
3091 return -EINVAL;
3092
3093 table = kzalloc(sizeof(*table), GFP_KERNEL);
3094 if (!table)
3095 return -ENOMEM;
3096
3097 table->name = table_name;
3098 table->table_ops = table_ops;
3099 table->priv = priv;
3100 table->counter_control_extern = counter_control_extern;
3101
3102 mutex_lock(&devlink->lock);
3103 list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
3104 mutex_unlock(&devlink->lock);
3105 return 0;
3106 }
3107 EXPORT_SYMBOL_GPL(devlink_dpipe_table_register);
3108
3109 /**
3110 * devlink_dpipe_table_unregister - unregister dpipe table
3111 *
3112 * @devlink: devlink
3113 * @table_name: table name
3114 */
3115 void devlink_dpipe_table_unregister(struct devlink *devlink,
3116 const char *table_name)
3117 {
3118 struct devlink_dpipe_table *table;
3119
3120 mutex_lock(&devlink->lock);
3121 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3122 table_name);
3123 if (!table)
3124 goto unlock;
3125 list_del_rcu(&table->list);
3126 mutex_unlock(&devlink->lock);
3127 kfree_rcu(table, rcu);
3128 return;
3129 unlock:
3130 mutex_unlock(&devlink->lock);
3131 }
3132 EXPORT_SYMBOL_GPL(devlink_dpipe_table_unregister);
3133
3134 /**
3135 * devlink_resource_register - devlink resource register
3136 *
3137 * @devlink: devlink
3138 * @resource_name: resource's name
3139 * @top_hierarchy: top hierarchy
3140 * @reload_required: reload is required for new configuration to
3141 * apply
3142 * @resource_size: resource's size
3143 * @resource_id: resource's id
3144 * @parent_reosurce_id: resource's parent id
3145 * @size params: size parameters
3146 * @resource_ops: resource ops
3147 */
3148 int devlink_resource_register(struct devlink *devlink,
3149 const char *resource_name,
3150 bool top_hierarchy,
3151 u64 resource_size,
3152 u64 resource_id,
3153 u64 parent_resource_id,
3154 struct devlink_resource_size_params *size_params,
3155 const struct devlink_resource_ops *resource_ops)
3156 {
3157 struct devlink_resource *resource;
3158 struct list_head *resource_list;
3159 int err = 0;
3160
3161 mutex_lock(&devlink->lock);
3162 resource = devlink_resource_find(devlink, NULL, resource_id);
3163 if (resource) {
3164 err = -EINVAL;
3165 goto out;
3166 }
3167
3168 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
3169 if (!resource) {
3170 err = -ENOMEM;
3171 goto out;
3172 }
3173
3174 if (top_hierarchy) {
3175 resource_list = &devlink->resource_list;
3176 } else {
3177 struct devlink_resource *parent_resource;
3178
3179 parent_resource = devlink_resource_find(devlink, NULL,
3180 parent_resource_id);
3181 if (parent_resource) {
3182 resource_list = &parent_resource->resource_list;
3183 resource->parent = parent_resource;
3184 } else {
3185 kfree(resource);
3186 err = -EINVAL;
3187 goto out;
3188 }
3189 }
3190
3191 resource->name = resource_name;
3192 resource->size = resource_size;
3193 resource->size_new = resource_size;
3194 resource->id = resource_id;
3195 resource->resource_ops = resource_ops;
3196 resource->size_valid = true;
3197 resource->size_params = size_params;
3198 INIT_LIST_HEAD(&resource->resource_list);
3199 list_add_tail(&resource->list, resource_list);
3200 out:
3201 mutex_unlock(&devlink->lock);
3202 return err;
3203 }
3204 EXPORT_SYMBOL_GPL(devlink_resource_register);
3205
3206 /**
3207 * devlink_resources_unregister - free all resources
3208 *
3209 * @devlink: devlink
3210 * @resource: resource
3211 */
3212 void devlink_resources_unregister(struct devlink *devlink,
3213 struct devlink_resource *resource)
3214 {
3215 struct devlink_resource *tmp, *child_resource;
3216 struct list_head *resource_list;
3217
3218 if (resource)
3219 resource_list = &resource->resource_list;
3220 else
3221 resource_list = &devlink->resource_list;
3222
3223 if (!resource)
3224 mutex_lock(&devlink->lock);
3225
3226 list_for_each_entry_safe(child_resource, tmp, resource_list, list) {
3227 devlink_resources_unregister(devlink, child_resource);
3228 list_del(&child_resource->list);
3229 kfree(child_resource);
3230 }
3231
3232 if (!resource)
3233 mutex_unlock(&devlink->lock);
3234 }
3235 EXPORT_SYMBOL_GPL(devlink_resources_unregister);
3236
3237 /**
3238 * devlink_resource_size_get - get and update size
3239 *
3240 * @devlink: devlink
3241 * @resource_id: the requested resource id
3242 * @p_resource_size: ptr to update
3243 */
3244 int devlink_resource_size_get(struct devlink *devlink,
3245 u64 resource_id,
3246 u64 *p_resource_size)
3247 {
3248 struct devlink_resource *resource;
3249 int err = 0;
3250
3251 mutex_lock(&devlink->lock);
3252 resource = devlink_resource_find(devlink, NULL, resource_id);
3253 if (!resource) {
3254 err = -EINVAL;
3255 goto out;
3256 }
3257 *p_resource_size = resource->size_new;
3258 resource->size = resource->size_new;
3259 out:
3260 mutex_unlock(&devlink->lock);
3261 return err;
3262 }
3263 EXPORT_SYMBOL_GPL(devlink_resource_size_get);
3264
3265 /**
3266 * devlink_dpipe_table_resource_set - set the resource id
3267 *
3268 * @devlink: devlink
3269 * @table_name: table name
3270 * @resource_id: resource id
3271 * @resource_units: number of resource's units consumed per table's entry
3272 */
3273 int devlink_dpipe_table_resource_set(struct devlink *devlink,
3274 const char *table_name, u64 resource_id,
3275 u64 resource_units)
3276 {
3277 struct devlink_dpipe_table *table;
3278 int err = 0;
3279
3280 mutex_lock(&devlink->lock);
3281 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
3282 table_name);
3283 if (!table) {
3284 err = -EINVAL;
3285 goto out;
3286 }
3287 table->resource_id = resource_id;
3288 table->resource_units = resource_units;
3289 table->resource_valid = true;
3290 out:
3291 mutex_unlock(&devlink->lock);
3292 return err;
3293 }
3294 EXPORT_SYMBOL_GPL(devlink_dpipe_table_resource_set);
3295
3296 static int __init devlink_module_init(void)
3297 {
3298 return genl_register_family(&devlink_nl_family);
3299 }
3300
3301 static void __exit devlink_module_exit(void)
3302 {
3303 genl_unregister_family(&devlink_nl_family);
3304 }
3305
3306 module_init(devlink_module_init);
3307 module_exit(devlink_module_exit);
3308
3309 MODULE_LICENSE("GPL v2");
3310 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
3311 MODULE_DESCRIPTION("Network physical device Netlink interface");
3312 MODULE_ALIAS_GENL_FAMILY(DEVLINK_GENL_NAME);
CRIS linux kernel tree