devlink: Add extack for eswitch operations
[sfrench/cifs-2.6.git] / net / core / devlink.c
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 struct devlink_region {
330         struct devlink *devlink;
331         struct list_head list;
332         const char *name;
333         struct list_head snapshot_list;
334         u32 max_snapshots;
335         u32 cur_snapshots;
336         u64 size;
337 };
338
339 struct devlink_snapshot {
340         struct list_head list;
341         struct devlink_region *region;
342         devlink_snapshot_data_dest_t *data_destructor;
343         u64 data_len;
344         u8 *data;
345         u32 id;
346 };
347
348 static struct devlink_region *
349 devlink_region_get_by_name(struct devlink *devlink, const char *region_name)
350 {
351         struct devlink_region *region;
352
353         list_for_each_entry(region, &devlink->region_list, list)
354                 if (!strcmp(region->name, region_name))
355                         return region;
356
357         return NULL;
358 }
359
360 static struct devlink_snapshot *
361 devlink_region_snapshot_get_by_id(struct devlink_region *region, u32 id)
362 {
363         struct devlink_snapshot *snapshot;
364
365         list_for_each_entry(snapshot, &region->snapshot_list, list)
366                 if (snapshot->id == id)
367                         return snapshot;
368
369         return NULL;
370 }
371
372 static void devlink_region_snapshot_del(struct devlink_snapshot *snapshot)
373 {
374         snapshot->region->cur_snapshots--;
375         list_del(&snapshot->list);
376         (*snapshot->data_destructor)(snapshot->data);
377         kfree(snapshot);
378 }
379
380 #define DEVLINK_NL_FLAG_NEED_DEVLINK    BIT(0)
381 #define DEVLINK_NL_FLAG_NEED_PORT       BIT(1)
382 #define DEVLINK_NL_FLAG_NEED_SB         BIT(2)
383
384 /* The per devlink instance lock is taken by default in the pre-doit
385  * operation, yet several commands do not require this. The global
386  * devlink lock is taken and protects from disruption by user-calls.
387  */
388 #define DEVLINK_NL_FLAG_NO_LOCK         BIT(3)
389
390 static int devlink_nl_pre_doit(const struct genl_ops *ops,
391                                struct sk_buff *skb, struct genl_info *info)
392 {
393         struct devlink *devlink;
394         int err;
395
396         mutex_lock(&devlink_mutex);
397         devlink = devlink_get_from_info(info);
398         if (IS_ERR(devlink)) {
399                 mutex_unlock(&devlink_mutex);
400                 return PTR_ERR(devlink);
401         }
402         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
403                 mutex_lock(&devlink->lock);
404         if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_DEVLINK) {
405                 info->user_ptr[0] = devlink;
406         } else if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_PORT) {
407                 struct devlink_port *devlink_port;
408
409                 devlink_port = devlink_port_get_from_info(devlink, info);
410                 if (IS_ERR(devlink_port)) {
411                         err = PTR_ERR(devlink_port);
412                         goto unlock;
413                 }
414                 info->user_ptr[0] = devlink_port;
415         }
416         if (ops->internal_flags & DEVLINK_NL_FLAG_NEED_SB) {
417                 struct devlink_sb *devlink_sb;
418
419                 devlink_sb = devlink_sb_get_from_info(devlink, info);
420                 if (IS_ERR(devlink_sb)) {
421                         err = PTR_ERR(devlink_sb);
422                         goto unlock;
423                 }
424                 info->user_ptr[1] = devlink_sb;
425         }
426         return 0;
427
428 unlock:
429         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
430                 mutex_unlock(&devlink->lock);
431         mutex_unlock(&devlink_mutex);
432         return err;
433 }
434
435 static void devlink_nl_post_doit(const struct genl_ops *ops,
436                                  struct sk_buff *skb, struct genl_info *info)
437 {
438         struct devlink *devlink;
439
440         devlink = devlink_get_from_info(info);
441         if (~ops->internal_flags & DEVLINK_NL_FLAG_NO_LOCK)
442                 mutex_unlock(&devlink->lock);
443         mutex_unlock(&devlink_mutex);
444 }
445
446 static struct genl_family devlink_nl_family;
447
448 enum devlink_multicast_groups {
449         DEVLINK_MCGRP_CONFIG,
450 };
451
452 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
453         [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
454 };
455
456 static int devlink_nl_put_handle(struct sk_buff *msg, struct devlink *devlink)
457 {
458         if (nla_put_string(msg, DEVLINK_ATTR_BUS_NAME, devlink->dev->bus->name))
459                 return -EMSGSIZE;
460         if (nla_put_string(msg, DEVLINK_ATTR_DEV_NAME, dev_name(devlink->dev)))
461                 return -EMSGSIZE;
462         return 0;
463 }
464
465 static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
466                            enum devlink_command cmd, u32 portid,
467                            u32 seq, int flags)
468 {
469         void *hdr;
470
471         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
472         if (!hdr)
473                 return -EMSGSIZE;
474
475         if (devlink_nl_put_handle(msg, devlink))
476                 goto nla_put_failure;
477
478         genlmsg_end(msg, hdr);
479         return 0;
480
481 nla_put_failure:
482         genlmsg_cancel(msg, hdr);
483         return -EMSGSIZE;
484 }
485
486 static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
487 {
488         struct sk_buff *msg;
489         int err;
490
491         WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
492
493         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
494         if (!msg)
495                 return;
496
497         err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
498         if (err) {
499                 nlmsg_free(msg);
500                 return;
501         }
502
503         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
504                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
505 }
506
507 static int devlink_nl_port_attrs_put(struct sk_buff *msg,
508                                      struct devlink_port *devlink_port)
509 {
510         struct devlink_port_attrs *attrs = &devlink_port->attrs;
511
512         if (!attrs->set)
513                 return 0;
514         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_FLAVOUR, attrs->flavour))
515                 return -EMSGSIZE;
516         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER, attrs->port_number))
517                 return -EMSGSIZE;
518         if (!attrs->split)
519                 return 0;
520         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP, attrs->port_number))
521                 return -EMSGSIZE;
522         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER,
523                         attrs->split_subport_number))
524                 return -EMSGSIZE;
525         return 0;
526 }
527
528 static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
529                                 struct devlink_port *devlink_port,
530                                 enum devlink_command cmd, u32 portid,
531                                 u32 seq, int flags)
532 {
533         void *hdr;
534
535         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
536         if (!hdr)
537                 return -EMSGSIZE;
538
539         if (devlink_nl_put_handle(msg, devlink))
540                 goto nla_put_failure;
541         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
542                 goto nla_put_failure;
543         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
544                 goto nla_put_failure;
545         if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
546             nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
547                         devlink_port->desired_type))
548                 goto nla_put_failure;
549         if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
550                 struct net_device *netdev = devlink_port->type_dev;
551
552                 if (netdev &&
553                     (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
554                                  netdev->ifindex) ||
555                      nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
556                                     netdev->name)))
557                         goto nla_put_failure;
558         }
559         if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
560                 struct ib_device *ibdev = devlink_port->type_dev;
561
562                 if (ibdev &&
563                     nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
564                                    ibdev->name))
565                         goto nla_put_failure;
566         }
567         if (devlink_nl_port_attrs_put(msg, devlink_port))
568                 goto nla_put_failure;
569
570         genlmsg_end(msg, hdr);
571         return 0;
572
573 nla_put_failure:
574         genlmsg_cancel(msg, hdr);
575         return -EMSGSIZE;
576 }
577
578 static void devlink_port_notify(struct devlink_port *devlink_port,
579                                 enum devlink_command cmd)
580 {
581         struct devlink *devlink = devlink_port->devlink;
582         struct sk_buff *msg;
583         int err;
584
585         if (!devlink_port->registered)
586                 return;
587
588         WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
589
590         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
591         if (!msg)
592                 return;
593
594         err = devlink_nl_port_fill(msg, devlink, devlink_port, cmd, 0, 0, 0);
595         if (err) {
596                 nlmsg_free(msg);
597                 return;
598         }
599
600         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
601                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
602 }
603
604 static int devlink_nl_cmd_get_doit(struct sk_buff *skb, struct genl_info *info)
605 {
606         struct devlink *devlink = info->user_ptr[0];
607         struct sk_buff *msg;
608         int err;
609
610         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
611         if (!msg)
612                 return -ENOMEM;
613
614         err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
615                               info->snd_portid, info->snd_seq, 0);
616         if (err) {
617                 nlmsg_free(msg);
618                 return err;
619         }
620
621         return genlmsg_reply(msg, info);
622 }
623
624 static int devlink_nl_cmd_get_dumpit(struct sk_buff *msg,
625                                      struct netlink_callback *cb)
626 {
627         struct devlink *devlink;
628         int start = cb->args[0];
629         int idx = 0;
630         int err;
631
632         mutex_lock(&devlink_mutex);
633         list_for_each_entry(devlink, &devlink_list, list) {
634                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
635                         continue;
636                 if (idx < start) {
637                         idx++;
638                         continue;
639                 }
640                 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
641                                       NETLINK_CB(cb->skb).portid,
642                                       cb->nlh->nlmsg_seq, NLM_F_MULTI);
643                 if (err)
644                         goto out;
645                 idx++;
646         }
647 out:
648         mutex_unlock(&devlink_mutex);
649
650         cb->args[0] = idx;
651         return msg->len;
652 }
653
654 static int devlink_nl_cmd_port_get_doit(struct sk_buff *skb,
655                                         struct genl_info *info)
656 {
657         struct devlink_port *devlink_port = info->user_ptr[0];
658         struct devlink *devlink = devlink_port->devlink;
659         struct sk_buff *msg;
660         int err;
661
662         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
663         if (!msg)
664                 return -ENOMEM;
665
666         err = devlink_nl_port_fill(msg, devlink, devlink_port,
667                                    DEVLINK_CMD_PORT_NEW,
668                                    info->snd_portid, info->snd_seq, 0);
669         if (err) {
670                 nlmsg_free(msg);
671                 return err;
672         }
673
674         return genlmsg_reply(msg, info);
675 }
676
677 static int devlink_nl_cmd_port_get_dumpit(struct sk_buff *msg,
678                                           struct netlink_callback *cb)
679 {
680         struct devlink *devlink;
681         struct devlink_port *devlink_port;
682         int start = cb->args[0];
683         int idx = 0;
684         int err;
685
686         mutex_lock(&devlink_mutex);
687         list_for_each_entry(devlink, &devlink_list, list) {
688                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
689                         continue;
690                 mutex_lock(&devlink->lock);
691                 list_for_each_entry(devlink_port, &devlink->port_list, list) {
692                         if (idx < start) {
693                                 idx++;
694                                 continue;
695                         }
696                         err = devlink_nl_port_fill(msg, devlink, devlink_port,
697                                                    DEVLINK_CMD_NEW,
698                                                    NETLINK_CB(cb->skb).portid,
699                                                    cb->nlh->nlmsg_seq,
700                                                    NLM_F_MULTI);
701                         if (err) {
702                                 mutex_unlock(&devlink->lock);
703                                 goto out;
704                         }
705                         idx++;
706                 }
707                 mutex_unlock(&devlink->lock);
708         }
709 out:
710         mutex_unlock(&devlink_mutex);
711
712         cb->args[0] = idx;
713         return msg->len;
714 }
715
716 static int devlink_port_type_set(struct devlink *devlink,
717                                  struct devlink_port *devlink_port,
718                                  enum devlink_port_type port_type)
719
720 {
721         int err;
722
723         if (devlink->ops && devlink->ops->port_type_set) {
724                 if (port_type == DEVLINK_PORT_TYPE_NOTSET)
725                         return -EINVAL;
726                 if (port_type == devlink_port->type)
727                         return 0;
728                 err = devlink->ops->port_type_set(devlink_port, port_type);
729                 if (err)
730                         return err;
731                 devlink_port->desired_type = port_type;
732                 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
733                 return 0;
734         }
735         return -EOPNOTSUPP;
736 }
737
738 static int devlink_nl_cmd_port_set_doit(struct sk_buff *skb,
739                                         struct genl_info *info)
740 {
741         struct devlink_port *devlink_port = info->user_ptr[0];
742         struct devlink *devlink = devlink_port->devlink;
743         int err;
744
745         if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
746                 enum devlink_port_type port_type;
747
748                 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
749                 err = devlink_port_type_set(devlink, devlink_port, port_type);
750                 if (err)
751                         return err;
752         }
753         return 0;
754 }
755
756 static int devlink_port_split(struct devlink *devlink, u32 port_index,
757                               u32 count, struct netlink_ext_ack *extack)
758
759 {
760         if (devlink->ops && devlink->ops->port_split)
761                 return devlink->ops->port_split(devlink, port_index, count,
762                                                 extack);
763         return -EOPNOTSUPP;
764 }
765
766 static int devlink_nl_cmd_port_split_doit(struct sk_buff *skb,
767                                           struct genl_info *info)
768 {
769         struct devlink *devlink = info->user_ptr[0];
770         u32 port_index;
771         u32 count;
772
773         if (!info->attrs[DEVLINK_ATTR_PORT_INDEX] ||
774             !info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT])
775                 return -EINVAL;
776
777         port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
778         count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
779         return devlink_port_split(devlink, port_index, count, info->extack);
780 }
781
782 static int devlink_port_unsplit(struct devlink *devlink, u32 port_index,
783                                 struct netlink_ext_ack *extack)
784
785 {
786         if (devlink->ops && devlink->ops->port_unsplit)
787                 return devlink->ops->port_unsplit(devlink, port_index, extack);
788         return -EOPNOTSUPP;
789 }
790
791 static int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
792                                             struct genl_info *info)
793 {
794         struct devlink *devlink = info->user_ptr[0];
795         u32 port_index;
796
797         if (!info->attrs[DEVLINK_ATTR_PORT_INDEX])
798                 return -EINVAL;
799
800         port_index = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
801         return devlink_port_unsplit(devlink, port_index, info->extack);
802 }
803
804 static int devlink_nl_sb_fill(struct sk_buff *msg, struct devlink *devlink,
805                               struct devlink_sb *devlink_sb,
806                               enum devlink_command cmd, u32 portid,
807                               u32 seq, int flags)
808 {
809         void *hdr;
810
811         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
812         if (!hdr)
813                 return -EMSGSIZE;
814
815         if (devlink_nl_put_handle(msg, devlink))
816                 goto nla_put_failure;
817         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
818                 goto nla_put_failure;
819         if (nla_put_u32(msg, DEVLINK_ATTR_SB_SIZE, devlink_sb->size))
820                 goto nla_put_failure;
821         if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_POOL_COUNT,
822                         devlink_sb->ingress_pools_count))
823                 goto nla_put_failure;
824         if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_POOL_COUNT,
825                         devlink_sb->egress_pools_count))
826                 goto nla_put_failure;
827         if (nla_put_u16(msg, DEVLINK_ATTR_SB_INGRESS_TC_COUNT,
828                         devlink_sb->ingress_tc_count))
829                 goto nla_put_failure;
830         if (nla_put_u16(msg, DEVLINK_ATTR_SB_EGRESS_TC_COUNT,
831                         devlink_sb->egress_tc_count))
832                 goto nla_put_failure;
833
834         genlmsg_end(msg, hdr);
835         return 0;
836
837 nla_put_failure:
838         genlmsg_cancel(msg, hdr);
839         return -EMSGSIZE;
840 }
841
842 static int devlink_nl_cmd_sb_get_doit(struct sk_buff *skb,
843                                       struct genl_info *info)
844 {
845         struct devlink *devlink = info->user_ptr[0];
846         struct devlink_sb *devlink_sb = info->user_ptr[1];
847         struct sk_buff *msg;
848         int err;
849
850         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
851         if (!msg)
852                 return -ENOMEM;
853
854         err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
855                                  DEVLINK_CMD_SB_NEW,
856                                  info->snd_portid, info->snd_seq, 0);
857         if (err) {
858                 nlmsg_free(msg);
859                 return err;
860         }
861
862         return genlmsg_reply(msg, info);
863 }
864
865 static int devlink_nl_cmd_sb_get_dumpit(struct sk_buff *msg,
866                                         struct netlink_callback *cb)
867 {
868         struct devlink *devlink;
869         struct devlink_sb *devlink_sb;
870         int start = cb->args[0];
871         int idx = 0;
872         int err;
873
874         mutex_lock(&devlink_mutex);
875         list_for_each_entry(devlink, &devlink_list, list) {
876                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
877                         continue;
878                 mutex_lock(&devlink->lock);
879                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
880                         if (idx < start) {
881                                 idx++;
882                                 continue;
883                         }
884                         err = devlink_nl_sb_fill(msg, devlink, devlink_sb,
885                                                  DEVLINK_CMD_SB_NEW,
886                                                  NETLINK_CB(cb->skb).portid,
887                                                  cb->nlh->nlmsg_seq,
888                                                  NLM_F_MULTI);
889                         if (err) {
890                                 mutex_unlock(&devlink->lock);
891                                 goto out;
892                         }
893                         idx++;
894                 }
895                 mutex_unlock(&devlink->lock);
896         }
897 out:
898         mutex_unlock(&devlink_mutex);
899
900         cb->args[0] = idx;
901         return msg->len;
902 }
903
904 static int devlink_nl_sb_pool_fill(struct sk_buff *msg, struct devlink *devlink,
905                                    struct devlink_sb *devlink_sb,
906                                    u16 pool_index, enum devlink_command cmd,
907                                    u32 portid, u32 seq, int flags)
908 {
909         struct devlink_sb_pool_info pool_info;
910         void *hdr;
911         int err;
912
913         err = devlink->ops->sb_pool_get(devlink, devlink_sb->index,
914                                         pool_index, &pool_info);
915         if (err)
916                 return err;
917
918         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
919         if (!hdr)
920                 return -EMSGSIZE;
921
922         if (devlink_nl_put_handle(msg, devlink))
923                 goto nla_put_failure;
924         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
925                 goto nla_put_failure;
926         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
927                 goto nla_put_failure;
928         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_info.pool_type))
929                 goto nla_put_failure;
930         if (nla_put_u32(msg, DEVLINK_ATTR_SB_POOL_SIZE, pool_info.size))
931                 goto nla_put_failure;
932         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
933                        pool_info.threshold_type))
934                 goto nla_put_failure;
935
936         genlmsg_end(msg, hdr);
937         return 0;
938
939 nla_put_failure:
940         genlmsg_cancel(msg, hdr);
941         return -EMSGSIZE;
942 }
943
944 static int devlink_nl_cmd_sb_pool_get_doit(struct sk_buff *skb,
945                                            struct genl_info *info)
946 {
947         struct devlink *devlink = info->user_ptr[0];
948         struct devlink_sb *devlink_sb = info->user_ptr[1];
949         struct sk_buff *msg;
950         u16 pool_index;
951         int err;
952
953         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
954                                                   &pool_index);
955         if (err)
956                 return err;
957
958         if (!devlink->ops || !devlink->ops->sb_pool_get)
959                 return -EOPNOTSUPP;
960
961         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
962         if (!msg)
963                 return -ENOMEM;
964
965         err = devlink_nl_sb_pool_fill(msg, devlink, devlink_sb, pool_index,
966                                       DEVLINK_CMD_SB_POOL_NEW,
967                                       info->snd_portid, info->snd_seq, 0);
968         if (err) {
969                 nlmsg_free(msg);
970                 return err;
971         }
972
973         return genlmsg_reply(msg, info);
974 }
975
976 static int __sb_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
977                                 struct devlink *devlink,
978                                 struct devlink_sb *devlink_sb,
979                                 u32 portid, u32 seq)
980 {
981         u16 pool_count = devlink_sb_pool_count(devlink_sb);
982         u16 pool_index;
983         int err;
984
985         for (pool_index = 0; pool_index < pool_count; pool_index++) {
986                 if (*p_idx < start) {
987                         (*p_idx)++;
988                         continue;
989                 }
990                 err = devlink_nl_sb_pool_fill(msg, devlink,
991                                               devlink_sb,
992                                               pool_index,
993                                               DEVLINK_CMD_SB_POOL_NEW,
994                                               portid, seq, NLM_F_MULTI);
995                 if (err)
996                         return err;
997                 (*p_idx)++;
998         }
999         return 0;
1000 }
1001
1002 static int devlink_nl_cmd_sb_pool_get_dumpit(struct sk_buff *msg,
1003                                              struct netlink_callback *cb)
1004 {
1005         struct devlink *devlink;
1006         struct devlink_sb *devlink_sb;
1007         int start = cb->args[0];
1008         int idx = 0;
1009         int err;
1010
1011         mutex_lock(&devlink_mutex);
1012         list_for_each_entry(devlink, &devlink_list, list) {
1013                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1014                     !devlink->ops || !devlink->ops->sb_pool_get)
1015                         continue;
1016                 mutex_lock(&devlink->lock);
1017                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1018                         err = __sb_pool_get_dumpit(msg, start, &idx, devlink,
1019                                                    devlink_sb,
1020                                                    NETLINK_CB(cb->skb).portid,
1021                                                    cb->nlh->nlmsg_seq);
1022                         if (err && err != -EOPNOTSUPP) {
1023                                 mutex_unlock(&devlink->lock);
1024                                 goto out;
1025                         }
1026                 }
1027                 mutex_unlock(&devlink->lock);
1028         }
1029 out:
1030         mutex_unlock(&devlink_mutex);
1031
1032         cb->args[0] = idx;
1033         return msg->len;
1034 }
1035
1036 static int devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
1037                                u16 pool_index, u32 size,
1038                                enum devlink_sb_threshold_type threshold_type)
1039
1040 {
1041         const struct devlink_ops *ops = devlink->ops;
1042
1043         if (ops && ops->sb_pool_set)
1044                 return ops->sb_pool_set(devlink, sb_index, pool_index,
1045                                         size, threshold_type);
1046         return -EOPNOTSUPP;
1047 }
1048
1049 static int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb,
1050                                            struct genl_info *info)
1051 {
1052         struct devlink *devlink = info->user_ptr[0];
1053         struct devlink_sb *devlink_sb = info->user_ptr[1];
1054         enum devlink_sb_threshold_type threshold_type;
1055         u16 pool_index;
1056         u32 size;
1057         int err;
1058
1059         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1060                                                   &pool_index);
1061         if (err)
1062                 return err;
1063
1064         err = devlink_sb_th_type_get_from_info(info, &threshold_type);
1065         if (err)
1066                 return err;
1067
1068         if (!info->attrs[DEVLINK_ATTR_SB_POOL_SIZE])
1069                 return -EINVAL;
1070
1071         size = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_POOL_SIZE]);
1072         return devlink_sb_pool_set(devlink, devlink_sb->index,
1073                                    pool_index, size, threshold_type);
1074 }
1075
1076 static int devlink_nl_sb_port_pool_fill(struct sk_buff *msg,
1077                                         struct devlink *devlink,
1078                                         struct devlink_port *devlink_port,
1079                                         struct devlink_sb *devlink_sb,
1080                                         u16 pool_index,
1081                                         enum devlink_command cmd,
1082                                         u32 portid, u32 seq, int flags)
1083 {
1084         const struct devlink_ops *ops = devlink->ops;
1085         u32 threshold;
1086         void *hdr;
1087         int err;
1088
1089         err = ops->sb_port_pool_get(devlink_port, devlink_sb->index,
1090                                     pool_index, &threshold);
1091         if (err)
1092                 return err;
1093
1094         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1095         if (!hdr)
1096                 return -EMSGSIZE;
1097
1098         if (devlink_nl_put_handle(msg, devlink))
1099                 goto nla_put_failure;
1100         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1101                 goto nla_put_failure;
1102         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1103                 goto nla_put_failure;
1104         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1105                 goto nla_put_failure;
1106         if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1107                 goto nla_put_failure;
1108
1109         if (ops->sb_occ_port_pool_get) {
1110                 u32 cur;
1111                 u32 max;
1112
1113                 err = ops->sb_occ_port_pool_get(devlink_port, devlink_sb->index,
1114                                                 pool_index, &cur, &max);
1115                 if (err && err != -EOPNOTSUPP)
1116                         return err;
1117                 if (!err) {
1118                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1119                                 goto nla_put_failure;
1120                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1121                                 goto nla_put_failure;
1122                 }
1123         }
1124
1125         genlmsg_end(msg, hdr);
1126         return 0;
1127
1128 nla_put_failure:
1129         genlmsg_cancel(msg, hdr);
1130         return -EMSGSIZE;
1131 }
1132
1133 static int devlink_nl_cmd_sb_port_pool_get_doit(struct sk_buff *skb,
1134                                                 struct genl_info *info)
1135 {
1136         struct devlink_port *devlink_port = info->user_ptr[0];
1137         struct devlink *devlink = devlink_port->devlink;
1138         struct devlink_sb *devlink_sb = info->user_ptr[1];
1139         struct sk_buff *msg;
1140         u16 pool_index;
1141         int err;
1142
1143         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1144                                                   &pool_index);
1145         if (err)
1146                 return err;
1147
1148         if (!devlink->ops || !devlink->ops->sb_port_pool_get)
1149                 return -EOPNOTSUPP;
1150
1151         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1152         if (!msg)
1153                 return -ENOMEM;
1154
1155         err = devlink_nl_sb_port_pool_fill(msg, devlink, devlink_port,
1156                                            devlink_sb, pool_index,
1157                                            DEVLINK_CMD_SB_PORT_POOL_NEW,
1158                                            info->snd_portid, info->snd_seq, 0);
1159         if (err) {
1160                 nlmsg_free(msg);
1161                 return err;
1162         }
1163
1164         return genlmsg_reply(msg, info);
1165 }
1166
1167 static int __sb_port_pool_get_dumpit(struct sk_buff *msg, int start, int *p_idx,
1168                                      struct devlink *devlink,
1169                                      struct devlink_sb *devlink_sb,
1170                                      u32 portid, u32 seq)
1171 {
1172         struct devlink_port *devlink_port;
1173         u16 pool_count = devlink_sb_pool_count(devlink_sb);
1174         u16 pool_index;
1175         int err;
1176
1177         list_for_each_entry(devlink_port, &devlink->port_list, list) {
1178                 for (pool_index = 0; pool_index < pool_count; pool_index++) {
1179                         if (*p_idx < start) {
1180                                 (*p_idx)++;
1181                                 continue;
1182                         }
1183                         err = devlink_nl_sb_port_pool_fill(msg, devlink,
1184                                                            devlink_port,
1185                                                            devlink_sb,
1186                                                            pool_index,
1187                                                            DEVLINK_CMD_SB_PORT_POOL_NEW,
1188                                                            portid, seq,
1189                                                            NLM_F_MULTI);
1190                         if (err)
1191                                 return err;
1192                         (*p_idx)++;
1193                 }
1194         }
1195         return 0;
1196 }
1197
1198 static int devlink_nl_cmd_sb_port_pool_get_dumpit(struct sk_buff *msg,
1199                                                   struct netlink_callback *cb)
1200 {
1201         struct devlink *devlink;
1202         struct devlink_sb *devlink_sb;
1203         int start = cb->args[0];
1204         int idx = 0;
1205         int err;
1206
1207         mutex_lock(&devlink_mutex);
1208         list_for_each_entry(devlink, &devlink_list, list) {
1209                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1210                     !devlink->ops || !devlink->ops->sb_port_pool_get)
1211                         continue;
1212                 mutex_lock(&devlink->lock);
1213                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1214                         err = __sb_port_pool_get_dumpit(msg, start, &idx,
1215                                                         devlink, devlink_sb,
1216                                                         NETLINK_CB(cb->skb).portid,
1217                                                         cb->nlh->nlmsg_seq);
1218                         if (err && err != -EOPNOTSUPP) {
1219                                 mutex_unlock(&devlink->lock);
1220                                 goto out;
1221                         }
1222                 }
1223                 mutex_unlock(&devlink->lock);
1224         }
1225 out:
1226         mutex_unlock(&devlink_mutex);
1227
1228         cb->args[0] = idx;
1229         return msg->len;
1230 }
1231
1232 static int devlink_sb_port_pool_set(struct devlink_port *devlink_port,
1233                                     unsigned int sb_index, u16 pool_index,
1234                                     u32 threshold)
1235
1236 {
1237         const struct devlink_ops *ops = devlink_port->devlink->ops;
1238
1239         if (ops && ops->sb_port_pool_set)
1240                 return ops->sb_port_pool_set(devlink_port, sb_index,
1241                                              pool_index, threshold);
1242         return -EOPNOTSUPP;
1243 }
1244
1245 static int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
1246                                                 struct genl_info *info)
1247 {
1248         struct devlink_port *devlink_port = info->user_ptr[0];
1249         struct devlink_sb *devlink_sb = info->user_ptr[1];
1250         u16 pool_index;
1251         u32 threshold;
1252         int err;
1253
1254         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1255                                                   &pool_index);
1256         if (err)
1257                 return err;
1258
1259         if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1260                 return -EINVAL;
1261
1262         threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1263         return devlink_sb_port_pool_set(devlink_port, devlink_sb->index,
1264                                         pool_index, threshold);
1265 }
1266
1267 static int
1268 devlink_nl_sb_tc_pool_bind_fill(struct sk_buff *msg, struct devlink *devlink,
1269                                 struct devlink_port *devlink_port,
1270                                 struct devlink_sb *devlink_sb, u16 tc_index,
1271                                 enum devlink_sb_pool_type pool_type,
1272                                 enum devlink_command cmd,
1273                                 u32 portid, u32 seq, int flags)
1274 {
1275         const struct devlink_ops *ops = devlink->ops;
1276         u16 pool_index;
1277         u32 threshold;
1278         void *hdr;
1279         int err;
1280
1281         err = ops->sb_tc_pool_bind_get(devlink_port, devlink_sb->index,
1282                                        tc_index, pool_type,
1283                                        &pool_index, &threshold);
1284         if (err)
1285                 return err;
1286
1287         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1288         if (!hdr)
1289                 return -EMSGSIZE;
1290
1291         if (devlink_nl_put_handle(msg, devlink))
1292                 goto nla_put_failure;
1293         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
1294                 goto nla_put_failure;
1295         if (nla_put_u32(msg, DEVLINK_ATTR_SB_INDEX, devlink_sb->index))
1296                 goto nla_put_failure;
1297         if (nla_put_u16(msg, DEVLINK_ATTR_SB_TC_INDEX, tc_index))
1298                 goto nla_put_failure;
1299         if (nla_put_u8(msg, DEVLINK_ATTR_SB_POOL_TYPE, pool_type))
1300                 goto nla_put_failure;
1301         if (nla_put_u16(msg, DEVLINK_ATTR_SB_POOL_INDEX, pool_index))
1302                 goto nla_put_failure;
1303         if (nla_put_u32(msg, DEVLINK_ATTR_SB_THRESHOLD, threshold))
1304                 goto nla_put_failure;
1305
1306         if (ops->sb_occ_tc_port_bind_get) {
1307                 u32 cur;
1308                 u32 max;
1309
1310                 err = ops->sb_occ_tc_port_bind_get(devlink_port,
1311                                                    devlink_sb->index,
1312                                                    tc_index, pool_type,
1313                                                    &cur, &max);
1314                 if (err && err != -EOPNOTSUPP)
1315                         return err;
1316                 if (!err) {
1317                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_CUR, cur))
1318                                 goto nla_put_failure;
1319                         if (nla_put_u32(msg, DEVLINK_ATTR_SB_OCC_MAX, max))
1320                                 goto nla_put_failure;
1321                 }
1322         }
1323
1324         genlmsg_end(msg, hdr);
1325         return 0;
1326
1327 nla_put_failure:
1328         genlmsg_cancel(msg, hdr);
1329         return -EMSGSIZE;
1330 }
1331
1332 static int devlink_nl_cmd_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
1333                                                    struct genl_info *info)
1334 {
1335         struct devlink_port *devlink_port = info->user_ptr[0];
1336         struct devlink *devlink = devlink_port->devlink;
1337         struct devlink_sb *devlink_sb = info->user_ptr[1];
1338         struct sk_buff *msg;
1339         enum devlink_sb_pool_type pool_type;
1340         u16 tc_index;
1341         int err;
1342
1343         err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1344         if (err)
1345                 return err;
1346
1347         err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1348                                                 pool_type, &tc_index);
1349         if (err)
1350                 return err;
1351
1352         if (!devlink->ops || !devlink->ops->sb_tc_pool_bind_get)
1353                 return -EOPNOTSUPP;
1354
1355         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1356         if (!msg)
1357                 return -ENOMEM;
1358
1359         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink, devlink_port,
1360                                               devlink_sb, tc_index, pool_type,
1361                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1362                                               info->snd_portid,
1363                                               info->snd_seq, 0);
1364         if (err) {
1365                 nlmsg_free(msg);
1366                 return err;
1367         }
1368
1369         return genlmsg_reply(msg, info);
1370 }
1371
1372 static int __sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1373                                         int start, int *p_idx,
1374                                         struct devlink *devlink,
1375                                         struct devlink_sb *devlink_sb,
1376                                         u32 portid, u32 seq)
1377 {
1378         struct devlink_port *devlink_port;
1379         u16 tc_index;
1380         int err;
1381
1382         list_for_each_entry(devlink_port, &devlink->port_list, list) {
1383                 for (tc_index = 0;
1384                      tc_index < devlink_sb->ingress_tc_count; tc_index++) {
1385                         if (*p_idx < start) {
1386                                 (*p_idx)++;
1387                                 continue;
1388                         }
1389                         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1390                                                               devlink_port,
1391                                                               devlink_sb,
1392                                                               tc_index,
1393                                                               DEVLINK_SB_POOL_TYPE_INGRESS,
1394                                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1395                                                               portid, seq,
1396                                                               NLM_F_MULTI);
1397                         if (err)
1398                                 return err;
1399                         (*p_idx)++;
1400                 }
1401                 for (tc_index = 0;
1402                      tc_index < devlink_sb->egress_tc_count; tc_index++) {
1403                         if (*p_idx < start) {
1404                                 (*p_idx)++;
1405                                 continue;
1406                         }
1407                         err = devlink_nl_sb_tc_pool_bind_fill(msg, devlink,
1408                                                               devlink_port,
1409                                                               devlink_sb,
1410                                                               tc_index,
1411                                                               DEVLINK_SB_POOL_TYPE_EGRESS,
1412                                                               DEVLINK_CMD_SB_TC_POOL_BIND_NEW,
1413                                                               portid, seq,
1414                                                               NLM_F_MULTI);
1415                         if (err)
1416                                 return err;
1417                         (*p_idx)++;
1418                 }
1419         }
1420         return 0;
1421 }
1422
1423 static int
1424 devlink_nl_cmd_sb_tc_pool_bind_get_dumpit(struct sk_buff *msg,
1425                                           struct netlink_callback *cb)
1426 {
1427         struct devlink *devlink;
1428         struct devlink_sb *devlink_sb;
1429         int start = cb->args[0];
1430         int idx = 0;
1431         int err;
1432
1433         mutex_lock(&devlink_mutex);
1434         list_for_each_entry(devlink, &devlink_list, list) {
1435                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)) ||
1436                     !devlink->ops || !devlink->ops->sb_tc_pool_bind_get)
1437                         continue;
1438
1439                 mutex_lock(&devlink->lock);
1440                 list_for_each_entry(devlink_sb, &devlink->sb_list, list) {
1441                         err = __sb_tc_pool_bind_get_dumpit(msg, start, &idx,
1442                                                            devlink,
1443                                                            devlink_sb,
1444                                                            NETLINK_CB(cb->skb).portid,
1445                                                            cb->nlh->nlmsg_seq);
1446                         if (err && err != -EOPNOTSUPP) {
1447                                 mutex_unlock(&devlink->lock);
1448                                 goto out;
1449                         }
1450                 }
1451                 mutex_unlock(&devlink->lock);
1452         }
1453 out:
1454         mutex_unlock(&devlink_mutex);
1455
1456         cb->args[0] = idx;
1457         return msg->len;
1458 }
1459
1460 static int devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
1461                                        unsigned int sb_index, u16 tc_index,
1462                                        enum devlink_sb_pool_type pool_type,
1463                                        u16 pool_index, u32 threshold)
1464
1465 {
1466         const struct devlink_ops *ops = devlink_port->devlink->ops;
1467
1468         if (ops && ops->sb_tc_pool_bind_set)
1469                 return ops->sb_tc_pool_bind_set(devlink_port, sb_index,
1470                                                 tc_index, pool_type,
1471                                                 pool_index, threshold);
1472         return -EOPNOTSUPP;
1473 }
1474
1475 static int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
1476                                                    struct genl_info *info)
1477 {
1478         struct devlink_port *devlink_port = info->user_ptr[0];
1479         struct devlink_sb *devlink_sb = info->user_ptr[1];
1480         enum devlink_sb_pool_type pool_type;
1481         u16 tc_index;
1482         u16 pool_index;
1483         u32 threshold;
1484         int err;
1485
1486         err = devlink_sb_pool_type_get_from_info(info, &pool_type);
1487         if (err)
1488                 return err;
1489
1490         err = devlink_sb_tc_index_get_from_info(devlink_sb, info,
1491                                                 pool_type, &tc_index);
1492         if (err)
1493                 return err;
1494
1495         err = devlink_sb_pool_index_get_from_info(devlink_sb, info,
1496                                                   &pool_index);
1497         if (err)
1498                 return err;
1499
1500         if (!info->attrs[DEVLINK_ATTR_SB_THRESHOLD])
1501                 return -EINVAL;
1502
1503         threshold = nla_get_u32(info->attrs[DEVLINK_ATTR_SB_THRESHOLD]);
1504         return devlink_sb_tc_pool_bind_set(devlink_port, devlink_sb->index,
1505                                            tc_index, pool_type,
1506                                            pool_index, threshold);
1507 }
1508
1509 static int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
1510                                                struct genl_info *info)
1511 {
1512         struct devlink *devlink = info->user_ptr[0];
1513         struct devlink_sb *devlink_sb = info->user_ptr[1];
1514         const struct devlink_ops *ops = devlink->ops;
1515
1516         if (ops && ops->sb_occ_snapshot)
1517                 return ops->sb_occ_snapshot(devlink, devlink_sb->index);
1518         return -EOPNOTSUPP;
1519 }
1520
1521 static int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
1522                                                 struct genl_info *info)
1523 {
1524         struct devlink *devlink = info->user_ptr[0];
1525         struct devlink_sb *devlink_sb = info->user_ptr[1];
1526         const struct devlink_ops *ops = devlink->ops;
1527
1528         if (ops && ops->sb_occ_max_clear)
1529                 return ops->sb_occ_max_clear(devlink, devlink_sb->index);
1530         return -EOPNOTSUPP;
1531 }
1532
1533 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
1534                                    enum devlink_command cmd, u32 portid,
1535                                    u32 seq, int flags)
1536 {
1537         const struct devlink_ops *ops = devlink->ops;
1538         u8 inline_mode, encap_mode;
1539         void *hdr;
1540         int err = 0;
1541         u16 mode;
1542
1543         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
1544         if (!hdr)
1545                 return -EMSGSIZE;
1546
1547         err = devlink_nl_put_handle(msg, devlink);
1548         if (err)
1549                 goto nla_put_failure;
1550
1551         if (ops->eswitch_mode_get) {
1552                 err = ops->eswitch_mode_get(devlink, &mode);
1553                 if (err)
1554                         goto nla_put_failure;
1555                 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
1556                 if (err)
1557                         goto nla_put_failure;
1558         }
1559
1560         if (ops->eswitch_inline_mode_get) {
1561                 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
1562                 if (err)
1563                         goto nla_put_failure;
1564                 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
1565                                  inline_mode);
1566                 if (err)
1567                         goto nla_put_failure;
1568         }
1569
1570         if (ops->eswitch_encap_mode_get) {
1571                 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
1572                 if (err)
1573                         goto nla_put_failure;
1574                 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
1575                 if (err)
1576                         goto nla_put_failure;
1577         }
1578
1579         genlmsg_end(msg, hdr);
1580         return 0;
1581
1582 nla_put_failure:
1583         genlmsg_cancel(msg, hdr);
1584         return err;
1585 }
1586
1587 static int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb,
1588                                            struct genl_info *info)
1589 {
1590         struct devlink *devlink = info->user_ptr[0];
1591         const struct devlink_ops *ops = devlink->ops;
1592         struct sk_buff *msg;
1593         int err;
1594
1595         if (!ops)
1596                 return -EOPNOTSUPP;
1597
1598         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1599         if (!msg)
1600                 return -ENOMEM;
1601
1602         err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
1603                                       info->snd_portid, info->snd_seq, 0);
1604
1605         if (err) {
1606                 nlmsg_free(msg);
1607                 return err;
1608         }
1609
1610         return genlmsg_reply(msg, info);
1611 }
1612
1613 static int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb,
1614                                            struct genl_info *info)
1615 {
1616         struct devlink *devlink = info->user_ptr[0];
1617         const struct devlink_ops *ops = devlink->ops;
1618         u8 inline_mode, encap_mode;
1619         int err = 0;
1620         u16 mode;
1621
1622         if (!ops)
1623                 return -EOPNOTSUPP;
1624
1625         if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
1626                 if (!ops->eswitch_mode_set)
1627                         return -EOPNOTSUPP;
1628                 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
1629                 err = ops->eswitch_mode_set(devlink, mode, info->extack);
1630                 if (err)
1631                         return err;
1632         }
1633
1634         if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
1635                 if (!ops->eswitch_inline_mode_set)
1636                         return -EOPNOTSUPP;
1637                 inline_mode = nla_get_u8(
1638                                 info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
1639                 err = ops->eswitch_inline_mode_set(devlink, inline_mode,
1640                                                    info->extack);
1641                 if (err)
1642                         return err;
1643         }
1644
1645         if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
1646                 if (!ops->eswitch_encap_mode_set)
1647                         return -EOPNOTSUPP;
1648                 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
1649                 err = ops->eswitch_encap_mode_set(devlink, encap_mode,
1650                                                   info->extack);
1651                 if (err)
1652                         return err;
1653         }
1654
1655         return 0;
1656 }
1657
1658 int devlink_dpipe_match_put(struct sk_buff *skb,
1659                             struct devlink_dpipe_match *match)
1660 {
1661         struct devlink_dpipe_header *header = match->header;
1662         struct devlink_dpipe_field *field = &header->fields[match->field_id];
1663         struct nlattr *match_attr;
1664
1665         match_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_MATCH);
1666         if (!match_attr)
1667                 return -EMSGSIZE;
1668
1669         if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
1670             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
1671             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1672             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1673             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1674                 goto nla_put_failure;
1675
1676         nla_nest_end(skb, match_attr);
1677         return 0;
1678
1679 nla_put_failure:
1680         nla_nest_cancel(skb, match_attr);
1681         return -EMSGSIZE;
1682 }
1683 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
1684
1685 static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
1686                                      struct sk_buff *skb)
1687 {
1688         struct nlattr *matches_attr;
1689
1690         matches_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
1691         if (!matches_attr)
1692                 return -EMSGSIZE;
1693
1694         if (table->table_ops->matches_dump(table->priv, skb))
1695                 goto nla_put_failure;
1696
1697         nla_nest_end(skb, matches_attr);
1698         return 0;
1699
1700 nla_put_failure:
1701         nla_nest_cancel(skb, matches_attr);
1702         return -EMSGSIZE;
1703 }
1704
1705 int devlink_dpipe_action_put(struct sk_buff *skb,
1706                              struct devlink_dpipe_action *action)
1707 {
1708         struct devlink_dpipe_header *header = action->header;
1709         struct devlink_dpipe_field *field = &header->fields[action->field_id];
1710         struct nlattr *action_attr;
1711
1712         action_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_ACTION);
1713         if (!action_attr)
1714                 return -EMSGSIZE;
1715
1716         if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
1717             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
1718             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
1719             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
1720             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
1721                 goto nla_put_failure;
1722
1723         nla_nest_end(skb, action_attr);
1724         return 0;
1725
1726 nla_put_failure:
1727         nla_nest_cancel(skb, action_attr);
1728         return -EMSGSIZE;
1729 }
1730 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
1731
1732 static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
1733                                      struct sk_buff *skb)
1734 {
1735         struct nlattr *actions_attr;
1736
1737         actions_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
1738         if (!actions_attr)
1739                 return -EMSGSIZE;
1740
1741         if (table->table_ops->actions_dump(table->priv, skb))
1742                 goto nla_put_failure;
1743
1744         nla_nest_end(skb, actions_attr);
1745         return 0;
1746
1747 nla_put_failure:
1748         nla_nest_cancel(skb, actions_attr);
1749         return -EMSGSIZE;
1750 }
1751
1752 static int devlink_dpipe_table_put(struct sk_buff *skb,
1753                                    struct devlink_dpipe_table *table)
1754 {
1755         struct nlattr *table_attr;
1756         u64 table_size;
1757
1758         table_size = table->table_ops->size_get(table->priv);
1759         table_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLE);
1760         if (!table_attr)
1761                 return -EMSGSIZE;
1762
1763         if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
1764             nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
1765                               DEVLINK_ATTR_PAD))
1766                 goto nla_put_failure;
1767         if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
1768                        table->counters_enabled))
1769                 goto nla_put_failure;
1770
1771         if (table->resource_valid) {
1772                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
1773                                       table->resource_id, DEVLINK_ATTR_PAD) ||
1774                     nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
1775                                       table->resource_units, DEVLINK_ATTR_PAD))
1776                         goto nla_put_failure;
1777         }
1778         if (devlink_dpipe_matches_put(table, skb))
1779                 goto nla_put_failure;
1780
1781         if (devlink_dpipe_actions_put(table, skb))
1782                 goto nla_put_failure;
1783
1784         nla_nest_end(skb, table_attr);
1785         return 0;
1786
1787 nla_put_failure:
1788         nla_nest_cancel(skb, table_attr);
1789         return -EMSGSIZE;
1790 }
1791
1792 static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
1793                                             struct genl_info *info)
1794 {
1795         int err;
1796
1797         if (*pskb) {
1798                 err = genlmsg_reply(*pskb, info);
1799                 if (err)
1800                         return err;
1801         }
1802         *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
1803         if (!*pskb)
1804                 return -ENOMEM;
1805         return 0;
1806 }
1807
1808 static int devlink_dpipe_tables_fill(struct genl_info *info,
1809                                      enum devlink_command cmd, int flags,
1810                                      struct list_head *dpipe_tables,
1811                                      const char *table_name)
1812 {
1813         struct devlink *devlink = info->user_ptr[0];
1814         struct devlink_dpipe_table *table;
1815         struct nlattr *tables_attr;
1816         struct sk_buff *skb = NULL;
1817         struct nlmsghdr *nlh;
1818         bool incomplete;
1819         void *hdr;
1820         int i;
1821         int err;
1822
1823         table = list_first_entry(dpipe_tables,
1824                                  struct devlink_dpipe_table, list);
1825 start_again:
1826         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1827         if (err)
1828                 return err;
1829
1830         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
1831                           &devlink_nl_family, NLM_F_MULTI, cmd);
1832         if (!hdr) {
1833                 nlmsg_free(skb);
1834                 return -EMSGSIZE;
1835         }
1836
1837         if (devlink_nl_put_handle(skb, devlink))
1838                 goto nla_put_failure;
1839         tables_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_TABLES);
1840         if (!tables_attr)
1841                 goto nla_put_failure;
1842
1843         i = 0;
1844         incomplete = false;
1845         list_for_each_entry_from(table, dpipe_tables, list) {
1846                 if (!table_name) {
1847                         err = devlink_dpipe_table_put(skb, table);
1848                         if (err) {
1849                                 if (!i)
1850                                         goto err_table_put;
1851                                 incomplete = true;
1852                                 break;
1853                         }
1854                 } else {
1855                         if (!strcmp(table->name, table_name)) {
1856                                 err = devlink_dpipe_table_put(skb, table);
1857                                 if (err)
1858                                         break;
1859                         }
1860                 }
1861                 i++;
1862         }
1863
1864         nla_nest_end(skb, tables_attr);
1865         genlmsg_end(skb, hdr);
1866         if (incomplete)
1867                 goto start_again;
1868
1869 send_done:
1870         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
1871                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
1872         if (!nlh) {
1873                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
1874                 if (err)
1875                         return err;
1876                 goto send_done;
1877         }
1878
1879         return genlmsg_reply(skb, info);
1880
1881 nla_put_failure:
1882         err = -EMSGSIZE;
1883 err_table_put:
1884         nlmsg_free(skb);
1885         return err;
1886 }
1887
1888 static int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb,
1889                                           struct genl_info *info)
1890 {
1891         struct devlink *devlink = info->user_ptr[0];
1892         const char *table_name =  NULL;
1893
1894         if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
1895                 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
1896
1897         return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
1898                                          &devlink->dpipe_table_list,
1899                                          table_name);
1900 }
1901
1902 static int devlink_dpipe_value_put(struct sk_buff *skb,
1903                                    struct devlink_dpipe_value *value)
1904 {
1905         if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
1906                     value->value_size, value->value))
1907                 return -EMSGSIZE;
1908         if (value->mask)
1909                 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
1910                             value->value_size, value->mask))
1911                         return -EMSGSIZE;
1912         if (value->mapping_valid)
1913                 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
1914                                 value->mapping_value))
1915                         return -EMSGSIZE;
1916         return 0;
1917 }
1918
1919 static int devlink_dpipe_action_value_put(struct sk_buff *skb,
1920                                           struct devlink_dpipe_value *value)
1921 {
1922         if (!value->action)
1923                 return -EINVAL;
1924         if (devlink_dpipe_action_put(skb, value->action))
1925                 return -EMSGSIZE;
1926         if (devlink_dpipe_value_put(skb, value))
1927                 return -EMSGSIZE;
1928         return 0;
1929 }
1930
1931 static int devlink_dpipe_action_values_put(struct sk_buff *skb,
1932                                            struct devlink_dpipe_value *values,
1933                                            unsigned int values_count)
1934 {
1935         struct nlattr *action_attr;
1936         int i;
1937         int err;
1938
1939         for (i = 0; i < values_count; i++) {
1940                 action_attr = nla_nest_start(skb,
1941                                              DEVLINK_ATTR_DPIPE_ACTION_VALUE);
1942                 if (!action_attr)
1943                         return -EMSGSIZE;
1944                 err = devlink_dpipe_action_value_put(skb, &values[i]);
1945                 if (err)
1946                         goto err_action_value_put;
1947                 nla_nest_end(skb, action_attr);
1948         }
1949         return 0;
1950
1951 err_action_value_put:
1952         nla_nest_cancel(skb, action_attr);
1953         return err;
1954 }
1955
1956 static int devlink_dpipe_match_value_put(struct sk_buff *skb,
1957                                          struct devlink_dpipe_value *value)
1958 {
1959         if (!value->match)
1960                 return -EINVAL;
1961         if (devlink_dpipe_match_put(skb, value->match))
1962                 return -EMSGSIZE;
1963         if (devlink_dpipe_value_put(skb, value))
1964                 return -EMSGSIZE;
1965         return 0;
1966 }
1967
1968 static int devlink_dpipe_match_values_put(struct sk_buff *skb,
1969                                           struct devlink_dpipe_value *values,
1970                                           unsigned int values_count)
1971 {
1972         struct nlattr *match_attr;
1973         int i;
1974         int err;
1975
1976         for (i = 0; i < values_count; i++) {
1977                 match_attr = nla_nest_start(skb,
1978                                             DEVLINK_ATTR_DPIPE_MATCH_VALUE);
1979                 if (!match_attr)
1980                         return -EMSGSIZE;
1981                 err = devlink_dpipe_match_value_put(skb, &values[i]);
1982                 if (err)
1983                         goto err_match_value_put;
1984                 nla_nest_end(skb, match_attr);
1985         }
1986         return 0;
1987
1988 err_match_value_put:
1989         nla_nest_cancel(skb, match_attr);
1990         return err;
1991 }
1992
1993 static int devlink_dpipe_entry_put(struct sk_buff *skb,
1994                                    struct devlink_dpipe_entry *entry)
1995 {
1996         struct nlattr *entry_attr, *matches_attr, *actions_attr;
1997         int err;
1998
1999         entry_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_ENTRY);
2000         if (!entry_attr)
2001                 return  -EMSGSIZE;
2002
2003         if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
2004                               DEVLINK_ATTR_PAD))
2005                 goto nla_put_failure;
2006         if (entry->counter_valid)
2007                 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
2008                                       entry->counter, DEVLINK_ATTR_PAD))
2009                         goto nla_put_failure;
2010
2011         matches_attr = nla_nest_start(skb,
2012                                       DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
2013         if (!matches_attr)
2014                 goto nla_put_failure;
2015
2016         err = devlink_dpipe_match_values_put(skb, entry->match_values,
2017                                              entry->match_values_count);
2018         if (err) {
2019                 nla_nest_cancel(skb, matches_attr);
2020                 goto err_match_values_put;
2021         }
2022         nla_nest_end(skb, matches_attr);
2023
2024         actions_attr = nla_nest_start(skb,
2025                                       DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
2026         if (!actions_attr)
2027                 goto nla_put_failure;
2028
2029         err = devlink_dpipe_action_values_put(skb, entry->action_values,
2030                                               entry->action_values_count);
2031         if (err) {
2032                 nla_nest_cancel(skb, actions_attr);
2033                 goto err_action_values_put;
2034         }
2035         nla_nest_end(skb, actions_attr);
2036
2037         nla_nest_end(skb, entry_attr);
2038         return 0;
2039
2040 nla_put_failure:
2041         err = -EMSGSIZE;
2042 err_match_values_put:
2043 err_action_values_put:
2044         nla_nest_cancel(skb, entry_attr);
2045         return err;
2046 }
2047
2048 static struct devlink_dpipe_table *
2049 devlink_dpipe_table_find(struct list_head *dpipe_tables,
2050                          const char *table_name)
2051 {
2052         struct devlink_dpipe_table *table;
2053
2054         list_for_each_entry_rcu(table, dpipe_tables, list) {
2055                 if (!strcmp(table->name, table_name))
2056                         return table;
2057         }
2058         return NULL;
2059 }
2060
2061 int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
2062 {
2063         struct devlink *devlink;
2064         int err;
2065
2066         err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
2067                                                dump_ctx->info);
2068         if (err)
2069                 return err;
2070
2071         dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
2072                                     dump_ctx->info->snd_portid,
2073                                     dump_ctx->info->snd_seq,
2074                                     &devlink_nl_family, NLM_F_MULTI,
2075                                     dump_ctx->cmd);
2076         if (!dump_ctx->hdr)
2077                 goto nla_put_failure;
2078
2079         devlink = dump_ctx->info->user_ptr[0];
2080         if (devlink_nl_put_handle(dump_ctx->skb, devlink))
2081                 goto nla_put_failure;
2082         dump_ctx->nest = nla_nest_start(dump_ctx->skb,
2083                                         DEVLINK_ATTR_DPIPE_ENTRIES);
2084         if (!dump_ctx->nest)
2085                 goto nla_put_failure;
2086         return 0;
2087
2088 nla_put_failure:
2089         nlmsg_free(dump_ctx->skb);
2090         return -EMSGSIZE;
2091 }
2092 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
2093
2094 int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
2095                                    struct devlink_dpipe_entry *entry)
2096 {
2097         return devlink_dpipe_entry_put(dump_ctx->skb, entry);
2098 }
2099 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
2100
2101 int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
2102 {
2103         nla_nest_end(dump_ctx->skb, dump_ctx->nest);
2104         genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
2105         return 0;
2106 }
2107 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
2108
2109 void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
2110
2111 {
2112         unsigned int value_count, value_index;
2113         struct devlink_dpipe_value *value;
2114
2115         value = entry->action_values;
2116         value_count = entry->action_values_count;
2117         for (value_index = 0; value_index < value_count; value_index++) {
2118                 kfree(value[value_index].value);
2119                 kfree(value[value_index].mask);
2120         }
2121
2122         value = entry->match_values;
2123         value_count = entry->match_values_count;
2124         for (value_index = 0; value_index < value_count; value_index++) {
2125                 kfree(value[value_index].value);
2126                 kfree(value[value_index].mask);
2127         }
2128 }
2129 EXPORT_SYMBOL(devlink_dpipe_entry_clear);
2130
2131 static int devlink_dpipe_entries_fill(struct genl_info *info,
2132                                       enum devlink_command cmd, int flags,
2133                                       struct devlink_dpipe_table *table)
2134 {
2135         struct devlink_dpipe_dump_ctx dump_ctx;
2136         struct nlmsghdr *nlh;
2137         int err;
2138
2139         dump_ctx.skb = NULL;
2140         dump_ctx.cmd = cmd;
2141         dump_ctx.info = info;
2142
2143         err = table->table_ops->entries_dump(table->priv,
2144                                              table->counters_enabled,
2145                                              &dump_ctx);
2146         if (err)
2147                 return err;
2148
2149 send_done:
2150         nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
2151                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
2152         if (!nlh) {
2153                 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
2154                 if (err)
2155                         return err;
2156                 goto send_done;
2157         }
2158         return genlmsg_reply(dump_ctx.skb, info);
2159 }
2160
2161 static int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
2162                                             struct genl_info *info)
2163 {
2164         struct devlink *devlink = info->user_ptr[0];
2165         struct devlink_dpipe_table *table;
2166         const char *table_name;
2167
2168         if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
2169                 return -EINVAL;
2170
2171         table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2172         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2173                                          table_name);
2174         if (!table)
2175                 return -EINVAL;
2176
2177         if (!table->table_ops->entries_dump)
2178                 return -EINVAL;
2179
2180         return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
2181                                           0, table);
2182 }
2183
2184 static int devlink_dpipe_fields_put(struct sk_buff *skb,
2185                                     const struct devlink_dpipe_header *header)
2186 {
2187         struct devlink_dpipe_field *field;
2188         struct nlattr *field_attr;
2189         int i;
2190
2191         for (i = 0; i < header->fields_count; i++) {
2192                 field = &header->fields[i];
2193                 field_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_FIELD);
2194                 if (!field_attr)
2195                         return -EMSGSIZE;
2196                 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
2197                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
2198                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
2199                     nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
2200                         goto nla_put_failure;
2201                 nla_nest_end(skb, field_attr);
2202         }
2203         return 0;
2204
2205 nla_put_failure:
2206         nla_nest_cancel(skb, field_attr);
2207         return -EMSGSIZE;
2208 }
2209
2210 static int devlink_dpipe_header_put(struct sk_buff *skb,
2211                                     struct devlink_dpipe_header *header)
2212 {
2213         struct nlattr *fields_attr, *header_attr;
2214         int err;
2215
2216         header_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADER);
2217         if (!header_attr)
2218                 return -EMSGSIZE;
2219
2220         if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
2221             nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
2222             nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
2223                 goto nla_put_failure;
2224
2225         fields_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
2226         if (!fields_attr)
2227                 goto nla_put_failure;
2228
2229         err = devlink_dpipe_fields_put(skb, header);
2230         if (err) {
2231                 nla_nest_cancel(skb, fields_attr);
2232                 goto nla_put_failure;
2233         }
2234         nla_nest_end(skb, fields_attr);
2235         nla_nest_end(skb, header_attr);
2236         return 0;
2237
2238 nla_put_failure:
2239         err = -EMSGSIZE;
2240         nla_nest_cancel(skb, header_attr);
2241         return err;
2242 }
2243
2244 static int devlink_dpipe_headers_fill(struct genl_info *info,
2245                                       enum devlink_command cmd, int flags,
2246                                       struct devlink_dpipe_headers *
2247                                       dpipe_headers)
2248 {
2249         struct devlink *devlink = info->user_ptr[0];
2250         struct nlattr *headers_attr;
2251         struct sk_buff *skb = NULL;
2252         struct nlmsghdr *nlh;
2253         void *hdr;
2254         int i, j;
2255         int err;
2256
2257         i = 0;
2258 start_again:
2259         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2260         if (err)
2261                 return err;
2262
2263         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2264                           &devlink_nl_family, NLM_F_MULTI, cmd);
2265         if (!hdr) {
2266                 nlmsg_free(skb);
2267                 return -EMSGSIZE;
2268         }
2269
2270         if (devlink_nl_put_handle(skb, devlink))
2271                 goto nla_put_failure;
2272         headers_attr = nla_nest_start(skb, DEVLINK_ATTR_DPIPE_HEADERS);
2273         if (!headers_attr)
2274                 goto nla_put_failure;
2275
2276         j = 0;
2277         for (; i < dpipe_headers->headers_count; i++) {
2278                 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
2279                 if (err) {
2280                         if (!j)
2281                                 goto err_table_put;
2282                         break;
2283                 }
2284                 j++;
2285         }
2286         nla_nest_end(skb, headers_attr);
2287         genlmsg_end(skb, hdr);
2288         if (i != dpipe_headers->headers_count)
2289                 goto start_again;
2290
2291 send_done:
2292         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2293                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
2294         if (!nlh) {
2295                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2296                 if (err)
2297                         return err;
2298                 goto send_done;
2299         }
2300         return genlmsg_reply(skb, info);
2301
2302 nla_put_failure:
2303         err = -EMSGSIZE;
2304 err_table_put:
2305         nlmsg_free(skb);
2306         return err;
2307 }
2308
2309 static int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
2310                                             struct genl_info *info)
2311 {
2312         struct devlink *devlink = info->user_ptr[0];
2313
2314         if (!devlink->dpipe_headers)
2315                 return -EOPNOTSUPP;
2316         return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
2317                                           0, devlink->dpipe_headers);
2318 }
2319
2320 static int devlink_dpipe_table_counters_set(struct devlink *devlink,
2321                                             const char *table_name,
2322                                             bool enable)
2323 {
2324         struct devlink_dpipe_table *table;
2325
2326         table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
2327                                          table_name);
2328         if (!table)
2329                 return -EINVAL;
2330
2331         if (table->counter_control_extern)
2332                 return -EOPNOTSUPP;
2333
2334         if (!(table->counters_enabled ^ enable))
2335                 return 0;
2336
2337         table->counters_enabled = enable;
2338         if (table->table_ops->counters_set_update)
2339                 table->table_ops->counters_set_update(table->priv, enable);
2340         return 0;
2341 }
2342
2343 static int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
2344                                                    struct genl_info *info)
2345 {
2346         struct devlink *devlink = info->user_ptr[0];
2347         const char *table_name;
2348         bool counters_enable;
2349
2350         if (!info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME] ||
2351             !info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED])
2352                 return -EINVAL;
2353
2354         table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
2355         counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
2356
2357         return devlink_dpipe_table_counters_set(devlink, table_name,
2358                                                 counters_enable);
2359 }
2360
2361 static struct devlink_resource *
2362 devlink_resource_find(struct devlink *devlink,
2363                       struct devlink_resource *resource, u64 resource_id)
2364 {
2365         struct list_head *resource_list;
2366
2367         if (resource)
2368                 resource_list = &resource->resource_list;
2369         else
2370                 resource_list = &devlink->resource_list;
2371
2372         list_for_each_entry(resource, resource_list, list) {
2373                 struct devlink_resource *child_resource;
2374
2375                 if (resource->id == resource_id)
2376                         return resource;
2377
2378                 child_resource = devlink_resource_find(devlink, resource,
2379                                                        resource_id);
2380                 if (child_resource)
2381                         return child_resource;
2382         }
2383         return NULL;
2384 }
2385
2386 static void
2387 devlink_resource_validate_children(struct devlink_resource *resource)
2388 {
2389         struct devlink_resource *child_resource;
2390         bool size_valid = true;
2391         u64 parts_size = 0;
2392
2393         if (list_empty(&resource->resource_list))
2394                 goto out;
2395
2396         list_for_each_entry(child_resource, &resource->resource_list, list)
2397                 parts_size += child_resource->size_new;
2398
2399         if (parts_size > resource->size_new)
2400                 size_valid = false;
2401 out:
2402         resource->size_valid = size_valid;
2403 }
2404
2405 static int
2406 devlink_resource_validate_size(struct devlink_resource *resource, u64 size,
2407                                struct netlink_ext_ack *extack)
2408 {
2409         u64 reminder;
2410         int err = 0;
2411
2412         if (size > resource->size_params.size_max) {
2413                 NL_SET_ERR_MSG_MOD(extack, "Size larger than maximum");
2414                 err = -EINVAL;
2415         }
2416
2417         if (size < resource->size_params.size_min) {
2418                 NL_SET_ERR_MSG_MOD(extack, "Size smaller than minimum");
2419                 err = -EINVAL;
2420         }
2421
2422         div64_u64_rem(size, resource->size_params.size_granularity, &reminder);
2423         if (reminder) {
2424                 NL_SET_ERR_MSG_MOD(extack, "Wrong granularity");
2425                 err = -EINVAL;
2426         }
2427
2428         return err;
2429 }
2430
2431 static int devlink_nl_cmd_resource_set(struct sk_buff *skb,
2432                                        struct genl_info *info)
2433 {
2434         struct devlink *devlink = info->user_ptr[0];
2435         struct devlink_resource *resource;
2436         u64 resource_id;
2437         u64 size;
2438         int err;
2439
2440         if (!info->attrs[DEVLINK_ATTR_RESOURCE_ID] ||
2441             !info->attrs[DEVLINK_ATTR_RESOURCE_SIZE])
2442                 return -EINVAL;
2443         resource_id = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_ID]);
2444
2445         resource = devlink_resource_find(devlink, NULL, resource_id);
2446         if (!resource)
2447                 return -EINVAL;
2448
2449         size = nla_get_u64(info->attrs[DEVLINK_ATTR_RESOURCE_SIZE]);
2450         err = devlink_resource_validate_size(resource, size, info->extack);
2451         if (err)
2452                 return err;
2453
2454         resource->size_new = size;
2455         devlink_resource_validate_children(resource);
2456         if (resource->parent)
2457                 devlink_resource_validate_children(resource->parent);
2458         return 0;
2459 }
2460
2461 static int
2462 devlink_resource_size_params_put(struct devlink_resource *resource,
2463                                  struct sk_buff *skb)
2464 {
2465         struct devlink_resource_size_params *size_params;
2466
2467         size_params = &resource->size_params;
2468         if (nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_GRAN,
2469                               size_params->size_granularity, DEVLINK_ATTR_PAD) ||
2470             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MAX,
2471                               size_params->size_max, DEVLINK_ATTR_PAD) ||
2472             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_MIN,
2473                               size_params->size_min, DEVLINK_ATTR_PAD) ||
2474             nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_UNIT, size_params->unit))
2475                 return -EMSGSIZE;
2476         return 0;
2477 }
2478
2479 static int devlink_resource_occ_put(struct devlink_resource *resource,
2480                                     struct sk_buff *skb)
2481 {
2482         if (!resource->occ_get)
2483                 return 0;
2484         return nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_OCC,
2485                                  resource->occ_get(resource->occ_get_priv),
2486                                  DEVLINK_ATTR_PAD);
2487 }
2488
2489 static int devlink_resource_put(struct devlink *devlink, struct sk_buff *skb,
2490                                 struct devlink_resource *resource)
2491 {
2492         struct devlink_resource *child_resource;
2493         struct nlattr *child_resource_attr;
2494         struct nlattr *resource_attr;
2495
2496         resource_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE);
2497         if (!resource_attr)
2498                 return -EMSGSIZE;
2499
2500         if (nla_put_string(skb, DEVLINK_ATTR_RESOURCE_NAME, resource->name) ||
2501             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE, resource->size,
2502                               DEVLINK_ATTR_PAD) ||
2503             nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_ID, resource->id,
2504                               DEVLINK_ATTR_PAD))
2505                 goto nla_put_failure;
2506         if (resource->size != resource->size_new)
2507                 nla_put_u64_64bit(skb, DEVLINK_ATTR_RESOURCE_SIZE_NEW,
2508                                   resource->size_new, DEVLINK_ATTR_PAD);
2509         if (devlink_resource_occ_put(resource, skb))
2510                 goto nla_put_failure;
2511         if (devlink_resource_size_params_put(resource, skb))
2512                 goto nla_put_failure;
2513         if (list_empty(&resource->resource_list))
2514                 goto out;
2515
2516         if (nla_put_u8(skb, DEVLINK_ATTR_RESOURCE_SIZE_VALID,
2517                        resource->size_valid))
2518                 goto nla_put_failure;
2519
2520         child_resource_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE_LIST);
2521         if (!child_resource_attr)
2522                 goto nla_put_failure;
2523
2524         list_for_each_entry(child_resource, &resource->resource_list, list) {
2525                 if (devlink_resource_put(devlink, skb, child_resource))
2526                         goto resource_put_failure;
2527         }
2528
2529         nla_nest_end(skb, child_resource_attr);
2530 out:
2531         nla_nest_end(skb, resource_attr);
2532         return 0;
2533
2534 resource_put_failure:
2535         nla_nest_cancel(skb, child_resource_attr);
2536 nla_put_failure:
2537         nla_nest_cancel(skb, resource_attr);
2538         return -EMSGSIZE;
2539 }
2540
2541 static int devlink_resource_fill(struct genl_info *info,
2542                                  enum devlink_command cmd, int flags)
2543 {
2544         struct devlink *devlink = info->user_ptr[0];
2545         struct devlink_resource *resource;
2546         struct nlattr *resources_attr;
2547         struct sk_buff *skb = NULL;
2548         struct nlmsghdr *nlh;
2549         bool incomplete;
2550         void *hdr;
2551         int i;
2552         int err;
2553
2554         resource = list_first_entry(&devlink->resource_list,
2555                                     struct devlink_resource, list);
2556 start_again:
2557         err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2558         if (err)
2559                 return err;
2560
2561         hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
2562                           &devlink_nl_family, NLM_F_MULTI, cmd);
2563         if (!hdr) {
2564                 nlmsg_free(skb);
2565                 return -EMSGSIZE;
2566         }
2567
2568         if (devlink_nl_put_handle(skb, devlink))
2569                 goto nla_put_failure;
2570
2571         resources_attr = nla_nest_start(skb, DEVLINK_ATTR_RESOURCE_LIST);
2572         if (!resources_attr)
2573                 goto nla_put_failure;
2574
2575         incomplete = false;
2576         i = 0;
2577         list_for_each_entry_from(resource, &devlink->resource_list, list) {
2578                 err = devlink_resource_put(devlink, skb, resource);
2579                 if (err) {
2580                         if (!i)
2581                                 goto err_resource_put;
2582                         incomplete = true;
2583                         break;
2584                 }
2585                 i++;
2586         }
2587         nla_nest_end(skb, resources_attr);
2588         genlmsg_end(skb, hdr);
2589         if (incomplete)
2590                 goto start_again;
2591 send_done:
2592         nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
2593                         NLMSG_DONE, 0, flags | NLM_F_MULTI);
2594         if (!nlh) {
2595                 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
2596                 if (err)
2597                         return err;
2598                 goto send_done;
2599         }
2600         return genlmsg_reply(skb, info);
2601
2602 nla_put_failure:
2603         err = -EMSGSIZE;
2604 err_resource_put:
2605         nlmsg_free(skb);
2606         return err;
2607 }
2608
2609 static int devlink_nl_cmd_resource_dump(struct sk_buff *skb,
2610                                         struct genl_info *info)
2611 {
2612         struct devlink *devlink = info->user_ptr[0];
2613
2614         if (list_empty(&devlink->resource_list))
2615                 return -EOPNOTSUPP;
2616
2617         return devlink_resource_fill(info, DEVLINK_CMD_RESOURCE_DUMP, 0);
2618 }
2619
2620 static int
2621 devlink_resources_validate(struct devlink *devlink,
2622                            struct devlink_resource *resource,
2623                            struct genl_info *info)
2624 {
2625         struct list_head *resource_list;
2626         int err = 0;
2627
2628         if (resource)
2629                 resource_list = &resource->resource_list;
2630         else
2631                 resource_list = &devlink->resource_list;
2632
2633         list_for_each_entry(resource, resource_list, list) {
2634                 if (!resource->size_valid)
2635                         return -EINVAL;
2636                 err = devlink_resources_validate(devlink, resource, info);
2637                 if (err)
2638                         return err;
2639         }
2640         return err;
2641 }
2642
2643 static int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
2644 {
2645         struct devlink *devlink = info->user_ptr[0];
2646         int err;
2647
2648         if (!devlink->ops->reload)
2649                 return -EOPNOTSUPP;
2650
2651         err = devlink_resources_validate(devlink, NULL, info);
2652         if (err) {
2653                 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed");
2654                 return err;
2655         }
2656         return devlink->ops->reload(devlink, info->extack);
2657 }
2658
2659 static const struct devlink_param devlink_param_generic[] = {
2660         {
2661                 .id = DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET,
2662                 .name = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME,
2663                 .type = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE,
2664         },
2665         {
2666                 .id = DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
2667                 .name = DEVLINK_PARAM_GENERIC_MAX_MACS_NAME,
2668                 .type = DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE,
2669         },
2670         {
2671                 .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV,
2672                 .name = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME,
2673                 .type = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE,
2674         },
2675         {
2676                 .id = DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT,
2677                 .name = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME,
2678                 .type = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE,
2679         },
2680 };
2681
2682 static int devlink_param_generic_verify(const struct devlink_param *param)
2683 {
2684         /* verify it match generic parameter by id and name */
2685         if (param->id > DEVLINK_PARAM_GENERIC_ID_MAX)
2686                 return -EINVAL;
2687         if (strcmp(param->name, devlink_param_generic[param->id].name))
2688                 return -ENOENT;
2689
2690         WARN_ON(param->type != devlink_param_generic[param->id].type);
2691
2692         return 0;
2693 }
2694
2695 static int devlink_param_driver_verify(const struct devlink_param *param)
2696 {
2697         int i;
2698
2699         if (param->id <= DEVLINK_PARAM_GENERIC_ID_MAX)
2700                 return -EINVAL;
2701         /* verify no such name in generic params */
2702         for (i = 0; i <= DEVLINK_PARAM_GENERIC_ID_MAX; i++)
2703                 if (!strcmp(param->name, devlink_param_generic[i].name))
2704                         return -EEXIST;
2705
2706         return 0;
2707 }
2708
2709 static struct devlink_param_item *
2710 devlink_param_find_by_name(struct list_head *param_list,
2711                            const char *param_name)
2712 {
2713         struct devlink_param_item *param_item;
2714
2715         list_for_each_entry(param_item, param_list, list)
2716                 if (!strcmp(param_item->param->name, param_name))
2717                         return param_item;
2718         return NULL;
2719 }
2720
2721 static struct devlink_param_item *
2722 devlink_param_find_by_id(struct list_head *param_list, u32 param_id)
2723 {
2724         struct devlink_param_item *param_item;
2725
2726         list_for_each_entry(param_item, param_list, list)
2727                 if (param_item->param->id == param_id)
2728                         return param_item;
2729         return NULL;
2730 }
2731
2732 static bool
2733 devlink_param_cmode_is_supported(const struct devlink_param *param,
2734                                  enum devlink_param_cmode cmode)
2735 {
2736         return test_bit(cmode, &param->supported_cmodes);
2737 }
2738
2739 static int devlink_param_get(struct devlink *devlink,
2740                              const struct devlink_param *param,
2741                              struct devlink_param_gset_ctx *ctx)
2742 {
2743         if (!param->get)
2744                 return -EOPNOTSUPP;
2745         return param->get(devlink, param->id, ctx);
2746 }
2747
2748 static int devlink_param_set(struct devlink *devlink,
2749                              const struct devlink_param *param,
2750                              struct devlink_param_gset_ctx *ctx)
2751 {
2752         if (!param->set)
2753                 return -EOPNOTSUPP;
2754         return param->set(devlink, param->id, ctx);
2755 }
2756
2757 static int
2758 devlink_param_type_to_nla_type(enum devlink_param_type param_type)
2759 {
2760         switch (param_type) {
2761         case DEVLINK_PARAM_TYPE_U8:
2762                 return NLA_U8;
2763         case DEVLINK_PARAM_TYPE_U16:
2764                 return NLA_U16;
2765         case DEVLINK_PARAM_TYPE_U32:
2766                 return NLA_U32;
2767         case DEVLINK_PARAM_TYPE_STRING:
2768                 return NLA_STRING;
2769         case DEVLINK_PARAM_TYPE_BOOL:
2770                 return NLA_FLAG;
2771         default:
2772                 return -EINVAL;
2773         }
2774 }
2775
2776 static int
2777 devlink_nl_param_value_fill_one(struct sk_buff *msg,
2778                                 enum devlink_param_type type,
2779                                 enum devlink_param_cmode cmode,
2780                                 union devlink_param_value val)
2781 {
2782         struct nlattr *param_value_attr;
2783
2784         param_value_attr = nla_nest_start(msg, DEVLINK_ATTR_PARAM_VALUE);
2785         if (!param_value_attr)
2786                 goto nla_put_failure;
2787
2788         if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_CMODE, cmode))
2789                 goto value_nest_cancel;
2790
2791         switch (type) {
2792         case DEVLINK_PARAM_TYPE_U8:
2793                 if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu8))
2794                         goto value_nest_cancel;
2795                 break;
2796         case DEVLINK_PARAM_TYPE_U16:
2797                 if (nla_put_u16(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu16))
2798                         goto value_nest_cancel;
2799                 break;
2800         case DEVLINK_PARAM_TYPE_U32:
2801                 if (nla_put_u32(msg, DEVLINK_ATTR_PARAM_VALUE_DATA, val.vu32))
2802                         goto value_nest_cancel;
2803                 break;
2804         case DEVLINK_PARAM_TYPE_STRING:
2805                 if (nla_put_string(msg, DEVLINK_ATTR_PARAM_VALUE_DATA,
2806                                    val.vstr))
2807                         goto value_nest_cancel;
2808                 break;
2809         case DEVLINK_PARAM_TYPE_BOOL:
2810                 if (val.vbool &&
2811                     nla_put_flag(msg, DEVLINK_ATTR_PARAM_VALUE_DATA))
2812                         goto value_nest_cancel;
2813                 break;
2814         }
2815
2816         nla_nest_end(msg, param_value_attr);
2817         return 0;
2818
2819 value_nest_cancel:
2820         nla_nest_cancel(msg, param_value_attr);
2821 nla_put_failure:
2822         return -EMSGSIZE;
2823 }
2824
2825 static int devlink_nl_param_fill(struct sk_buff *msg, struct devlink *devlink,
2826                                  struct devlink_param_item *param_item,
2827                                  enum devlink_command cmd,
2828                                  u32 portid, u32 seq, int flags)
2829 {
2830         union devlink_param_value param_value[DEVLINK_PARAM_CMODE_MAX + 1];
2831         const struct devlink_param *param = param_item->param;
2832         struct devlink_param_gset_ctx ctx;
2833         struct nlattr *param_values_list;
2834         struct nlattr *param_attr;
2835         int nla_type;
2836         void *hdr;
2837         int err;
2838         int i;
2839
2840         /* Get value from driver part to driverinit configuration mode */
2841         for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
2842                 if (!devlink_param_cmode_is_supported(param, i))
2843                         continue;
2844                 if (i == DEVLINK_PARAM_CMODE_DRIVERINIT) {
2845                         if (!param_item->driverinit_value_valid)
2846                                 return -EOPNOTSUPP;
2847                         param_value[i] = param_item->driverinit_value;
2848                 } else {
2849                         ctx.cmode = i;
2850                         err = devlink_param_get(devlink, param, &ctx);
2851                         if (err)
2852                                 return err;
2853                         param_value[i] = ctx.val;
2854                 }
2855         }
2856
2857         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
2858         if (!hdr)
2859                 return -EMSGSIZE;
2860
2861         if (devlink_nl_put_handle(msg, devlink))
2862                 goto genlmsg_cancel;
2863         param_attr = nla_nest_start(msg, DEVLINK_ATTR_PARAM);
2864         if (!param_attr)
2865                 goto genlmsg_cancel;
2866         if (nla_put_string(msg, DEVLINK_ATTR_PARAM_NAME, param->name))
2867                 goto param_nest_cancel;
2868         if (param->generic && nla_put_flag(msg, DEVLINK_ATTR_PARAM_GENERIC))
2869                 goto param_nest_cancel;
2870
2871         nla_type = devlink_param_type_to_nla_type(param->type);
2872         if (nla_type < 0)
2873                 goto param_nest_cancel;
2874         if (nla_put_u8(msg, DEVLINK_ATTR_PARAM_TYPE, nla_type))
2875                 goto param_nest_cancel;
2876
2877         param_values_list = nla_nest_start(msg, DEVLINK_ATTR_PARAM_VALUES_LIST);
2878         if (!param_values_list)
2879                 goto param_nest_cancel;
2880
2881         for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) {
2882                 if (!devlink_param_cmode_is_supported(param, i))
2883                         continue;
2884                 err = devlink_nl_param_value_fill_one(msg, param->type,
2885                                                       i, param_value[i]);
2886                 if (err)
2887                         goto values_list_nest_cancel;
2888         }
2889
2890         nla_nest_end(msg, param_values_list);
2891         nla_nest_end(msg, param_attr);
2892         genlmsg_end(msg, hdr);
2893         return 0;
2894
2895 values_list_nest_cancel:
2896         nla_nest_end(msg, param_values_list);
2897 param_nest_cancel:
2898         nla_nest_cancel(msg, param_attr);
2899 genlmsg_cancel:
2900         genlmsg_cancel(msg, hdr);
2901         return -EMSGSIZE;
2902 }
2903
2904 static void devlink_param_notify(struct devlink *devlink,
2905                                  struct devlink_param_item *param_item,
2906                                  enum devlink_command cmd)
2907 {
2908         struct sk_buff *msg;
2909         int err;
2910
2911         WARN_ON(cmd != DEVLINK_CMD_PARAM_NEW && cmd != DEVLINK_CMD_PARAM_DEL);
2912
2913         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2914         if (!msg)
2915                 return;
2916         err = devlink_nl_param_fill(msg, devlink, param_item, cmd, 0, 0, 0);
2917         if (err) {
2918                 nlmsg_free(msg);
2919                 return;
2920         }
2921
2922         genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
2923                                 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
2924 }
2925
2926 static int devlink_nl_cmd_param_get_dumpit(struct sk_buff *msg,
2927                                            struct netlink_callback *cb)
2928 {
2929         struct devlink_param_item *param_item;
2930         struct devlink *devlink;
2931         int start = cb->args[0];
2932         int idx = 0;
2933         int err;
2934
2935         mutex_lock(&devlink_mutex);
2936         list_for_each_entry(devlink, &devlink_list, list) {
2937                 if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
2938                         continue;
2939                 mutex_lock(&devlink->lock);
2940                 list_for_each_entry(param_item, &devlink->param_list, list) {
2941                         if (idx < start) {
2942                                 idx++;
2943                                 continue;
2944                         }
2945                         err = devlink_nl_param_fill(msg, devlink, param_item,
2946                                                     DEVLINK_CMD_PARAM_GET,
2947                                                     NETLINK_CB(cb->skb).portid,
2948                                                     cb->nlh->nlmsg_seq,
2949                                                     NLM_F_MULTI);
2950                         if (err) {
2951                                 mutex_unlock(&devlink->lock);
2952                                 goto out;
2953                         }
2954                         idx++;
2955                 }
2956                 mutex_unlock(&devlink->lock);
2957         }
2958 out:
2959         mutex_unlock(&devlink_mutex);
2960
2961         cb->args[0] = idx;
2962         return msg->len;
2963 }
2964
2965 static int
2966 devlink_param_type_get_from_info(struct genl_info *info,
2967                                  enum devlink_param_type *param_type)
2968 {
2969         if (!info->attrs[DEVLINK_ATTR_PARAM_TYPE])
2970                 return -EINVAL;
2971
2972         switch (nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_TYPE])) {
2973         case NLA_U8:
2974                 *param_type = DEVLINK_PARAM_TYPE_U8;
2975                 break;
2976         case NLA_U16:
2977                 *param_type = DEVLINK_PARAM_TYPE_U16;
2978                 break;
2979         case NLA_U32:
2980                 *param_type = DEVLINK_PARAM_TYPE_U32;
2981                 break;
2982         case NLA_STRING:
2983                 *param_type = DEVLINK_PARAM_TYPE_STRING;
2984                 break;
2985         case NLA_FLAG:
2986                 *param_type = DEVLINK_PARAM_TYPE_BOOL;
2987                 break;
2988         default:
2989                 return -EINVAL;
2990         }
2991
2992         return 0;
2993 }
2994
2995 static int
2996 devlink_param_value_get_from_info(const struct devlink_param *param,
2997                                   struct genl_info *info,
2998                                   union devlink_param_value *value)
2999 {
3000         if (param->type != DEVLINK_PARAM_TYPE_BOOL &&
3001             !info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA])
3002                 return -EINVAL;
3003
3004         switch (param->type) {
3005         case DEVLINK_PARAM_TYPE_U8:
3006                 value->vu8 = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3007                 break;
3008         case DEVLINK_PARAM_TYPE_U16:
3009                 value->vu16 = nla_get_u16(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3010                 break;
3011         case DEVLINK_PARAM_TYPE_U32:
3012                 value->vu32 = nla_get_u32(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3013                 break;
3014         case DEVLINK_PARAM_TYPE_STRING:
3015                 if (nla_len(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]) >
3016                     DEVLINK_PARAM_MAX_STRING_VALUE)
3017                         return -EINVAL;
3018                 value->vstr = nla_data(info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]);
3019                 break;
3020         case DEVLINK_PARAM_TYPE_BOOL:
3021                 value->vbool = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA] ?
3022                                true : false;
3023                 break;
3024         }
3025         return 0;
3026 }
3027
3028 static struct devlink_param_item *
3029 devlink_param_get_from_info(struct devlink *devlink,
3030                             struct genl_info *info)
3031 {
3032         char *param_name;
3033
3034         if (!info->attrs[DEVLINK_ATTR_PARAM_NAME])
3035                 return NULL;
3036
3037         param_name = nla_data(info->attrs[DEVLINK_ATTR_PARAM_NAME]);
3038         return devlink_param_find_by_name(&devlink->param_list, param_name);
3039 }
3040
3041 static int devlink_nl_cmd_param_get_doit(struct sk_buff *skb,
3042                                          struct genl_info *info)
3043 {
3044         struct devlink *devlink = info->user_ptr[0];
3045         struct devlink_param_item *param_item;
3046         struct sk_buff *msg;
3047         int err;
3048
3049         param_item = devlink_param_get_from_info(devlink, info);
3050         if (!param_item)
3051                 return -EINVAL;
3052
3053         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3054         if (!msg)
3055                 return -ENOMEM;
3056
3057         err = devlink_nl_param_fill(msg, devlink, param_item,
3058                                     DEVLINK_CMD_PARAM_GET,
3059                                     info->snd_portid, info->snd_seq, 0);
3060         if (err) {
3061                 nlmsg_free(msg);
3062                 return err;
3063         }
3064
3065         return genlmsg_reply(msg, info);
3066 }
3067
3068 static int devlink_nl_cmd_param_set_doit(struct sk_buff *skb,
3069                                          struct genl_info *info)
3070 {
3071         struct devlink *devlink = info->user_ptr[0];
3072         enum devlink_param_type param_type;
3073         struct devlink_param_gset_ctx ctx;
3074         enum devlink_param_cmode cmode;
3075         struct devlink_param_item *param_item;
3076         const struct devlink_param *param;
3077         union devlink_param_value value;
3078         int err = 0;
3079
3080         param_item = devlink_param_get_from_info(devlink, info);
3081         if (!param_item)
3082                 return -EINVAL;
3083         param = param_item->param;
3084         err = devlink_param_type_get_from_info(info, &param_type);
3085         if (err)
3086                 return err;
3087         if (param_type != param->type)
3088                 return -EINVAL;
3089         err = devlink_param_value_get_from_info(param, info, &value);
3090         if (err)
3091                 return err;
3092         if (param->validate) {
3093                 err = param->validate(devlink, param->id, value, info->extack);
3094                 if (err)
3095                         return err;
3096         }
3097
3098         if (!info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE])
3099                 return -EINVAL;
3100         cmode = nla_get_u8(info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE]);
3101         if (!devlink_param_cmode_is_supported(param, cmode))
3102                 return -EOPNOTSUPP;
3103
3104         if (cmode == DEVLINK_PARAM_CMODE_DRIVERINIT) {
3105                 param_item->driverinit_value = value;
3106                 param_item->driverinit_value_valid = true;
3107         } else {
3108                 if (!param->set)
3109                         return -EOPNOTSUPP;
3110                 ctx.val = value;
3111                 ctx.cmode = cmode;
3112                 err = devlink_param_set(devlink, param, &ctx);
3113                 if (err)
3114                         return err;
3115         }
3116
3117         devlink_param_notify(devlink, param_item, DEVLINK_CMD_PARAM_NEW);
3118         return 0;
3119 }
3120
3121 static int devlink_param_register_one(struct devlink *devlink,
3122                                       const struct devlink_param *param)
3123 {
3124         struct devlink_param_item *param_item;
3125
3126         if (devlink_param_find_by_name(&devlink->param_list,
3127                                        param->name))
3128                 return -EEXIST;
3129
3130         if (param->supported_cmodes == BIT(DEVLINK_PARAM_CMODE_DRIVERINIT))
3131                 WARN_ON(param->get || param->set);
3132         else
3133                 WARN_ON(!param->get || !param->set);
3134
3135         param_item = kzalloc(sizeof(*param_item), GFP_KERNEL);
3136         if (!param_item)
3137                 return -ENOMEM;
3138         param_item->param = param;
3139
3140         list_add_tail(&param_item->list, &devlink->param_list);
3141         devlink_param_notify(devlink, param_item, DEVLINK_CMD_PARAM_NEW);
3142         return 0;
3143 }
3144
3145 static void devlink_param_unregister_one(struct devlink *devlink,
3146                                          const struct devlink_param *param)
3147 {
3148         struct devlink_param_item *param_item;
3149
3150         param_item = devlink_param_find_by_name(&devlink->param_list,
3151                                                 param->name);
3152         WARN_ON(!param_item);
3153         devlink_param_notify(devlink, param_item, DEVLINK_CMD_PARAM_DEL);
3154         list_del(&param_item->list);
3155         kfree(param_item);
3156 }
3157
3158 static int devlink_nl_region_snapshot_id_put(struct sk_buff *msg,
3159                                              struct devlink *devlink,
3160                                              struct devlink_snapshot *snapshot)
3161 {
3162         struct nlattr *snap_attr;
3163         int err;
3164
3165         snap_attr = nla_nest_start(msg, DEVLINK_ATTR_REGION_SNAPSHOT);
3166         if (!snap_attr)
3167                 return -EINVAL;
3168
3169         err = nla_put_u32(msg, DEVLINK_ATTR_REGION_SNAPSHOT_ID, snapshot->id);
3170         if (err)
3171                 goto nla_put_failure;
3172
3173         nla_nest_end(msg, snap_attr);
3174         return 0;
3175
3176 nla_put_failure:
3177         nla_nest_cancel(msg, snap_attr);
3178         return err;
3179 }
3180
3181 static int devlink_nl_region_snapshots_id_put(struct sk_buff *msg,
3182                                               struct devlink *devlink,
3183                                               struct devlink_region *region)
3184 {
3185         struct devlink_snapshot *snapshot;
3186         struct nlattr *snapshots_attr;
3187         int err;
3188
3189         snapshots_attr = nla_nest_start(msg, DEVLINK_ATTR_REGION_SNAPSHOTS);
3190         if (!snapshots_attr)
3191                 return -EINVAL;
3192
3193         list_for_each_entry(snapshot, &region->snapshot_list, list) {
3194                 err = devlink_nl_region_snapshot_id_put(msg, devlink, snapshot);
3195                 if (err)
3196                         goto nla_put_failure;
3197         }
3198
3199         nla_nest_end(msg, snapshots_attr);
3200         return 0;
3201
3202 nla_put_failure:
3203         nla_nest_cancel(msg, snapshots_attr);
3204         return err;
3205 }
3206
3207 static int devlink_nl_region_fill(struct sk_buff *msg, struct devlink *devlink,
3208                                   enum devlink_command cmd, u32 portid,
3209                                   u32 seq, int flags,
3210                                   struct devlink_region *region)
3211 {
3212         void *hdr;
3213         int err;
3214
3215         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
3216         if (!hdr)
3217                 return -EMSGSIZE;
3218
3219         err = devlink_nl_put_handle(msg, devlink);
3220         if (err)
3221                 goto nla_put_failure;
3222
3223         err = nla_put_string(msg, DEVLINK_ATTR_REGION_NAME, region->name);
3224         if (err)
3225                 goto nla_put_failure;
3226
3227         err = nla_put_u64_64bit(msg, DEVLINK_ATTR_REGION_SIZE,
3228                                 region->size,
3229                                 DEVLINK_ATTR_PAD);
3230         if (err)
3231                 goto nla_put_failure;
3232
3233         err = devlink_nl_region_snapshots_id_put(msg, devlink, region);
3234         if (err)
3235                 goto nla_put_failure;
3236
3237         genlmsg_end(msg, hdr);
3238         return 0;
3239
3240 nla_put_failure:
3241         genlmsg_cancel(msg, hdr);
3242         return err;
3243 }