Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 */
6
7#include "devl_internal.h"
8
9static struct devlink_dpipe_field devlink_dpipe_fields_ethernet[] = {
10 {
11 .name = "destination mac",
12 .id = DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC,
13 .bitwidth = 48,
14 },
15};
16
17struct devlink_dpipe_header devlink_dpipe_header_ethernet = {
18 .name = "ethernet",
19 .id = DEVLINK_DPIPE_HEADER_ETHERNET,
20 .fields = devlink_dpipe_fields_ethernet,
21 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ethernet),
22 .global = true,
23};
24EXPORT_SYMBOL_GPL(devlink_dpipe_header_ethernet);
25
26static struct devlink_dpipe_field devlink_dpipe_fields_ipv4[] = {
27 {
28 .name = "destination ip",
29 .id = DEVLINK_DPIPE_FIELD_IPV4_DST_IP,
30 .bitwidth = 32,
31 },
32};
33
34struct devlink_dpipe_header devlink_dpipe_header_ipv4 = {
35 .name = "ipv4",
36 .id = DEVLINK_DPIPE_HEADER_IPV4,
37 .fields = devlink_dpipe_fields_ipv4,
38 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv4),
39 .global = true,
40};
41EXPORT_SYMBOL_GPL(devlink_dpipe_header_ipv4);
42
43static struct devlink_dpipe_field devlink_dpipe_fields_ipv6[] = {
44 {
45 .name = "destination ip",
46 .id = DEVLINK_DPIPE_FIELD_IPV6_DST_IP,
47 .bitwidth = 128,
48 },
49};
50
51struct devlink_dpipe_header devlink_dpipe_header_ipv6 = {
52 .name = "ipv6",
53 .id = DEVLINK_DPIPE_HEADER_IPV6,
54 .fields = devlink_dpipe_fields_ipv6,
55 .fields_count = ARRAY_SIZE(devlink_dpipe_fields_ipv6),
56 .global = true,
57};
58EXPORT_SYMBOL_GPL(devlink_dpipe_header_ipv6);
59
60int devlink_dpipe_match_put(struct sk_buff *skb,
61 struct devlink_dpipe_match *match)
62{
63 struct devlink_dpipe_header *header = match->header;
64 struct devlink_dpipe_field *field = &header->fields[match->field_id];
65 struct nlattr *match_attr;
66
67 match_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_MATCH);
68 if (!match_attr)
69 return -EMSGSIZE;
70
71 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_MATCH_TYPE, match->type) ||
72 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, match->header_index) ||
73 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
74 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
75 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
76 goto nla_put_failure;
77
78 nla_nest_end(skb, match_attr);
79 return 0;
80
81nla_put_failure:
82 nla_nest_cancel(skb, match_attr);
83 return -EMSGSIZE;
84}
85EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
86
87static int devlink_dpipe_matches_put(struct devlink_dpipe_table *table,
88 struct sk_buff *skb)
89{
90 struct nlattr *matches_attr;
91
92 matches_attr = nla_nest_start_noflag(skb,
93 DEVLINK_ATTR_DPIPE_TABLE_MATCHES);
94 if (!matches_attr)
95 return -EMSGSIZE;
96
97 if (table->table_ops->matches_dump(table->priv, skb))
98 goto nla_put_failure;
99
100 nla_nest_end(skb, matches_attr);
101 return 0;
102
103nla_put_failure:
104 nla_nest_cancel(skb, matches_attr);
105 return -EMSGSIZE;
106}
107
108int devlink_dpipe_action_put(struct sk_buff *skb,
109 struct devlink_dpipe_action *action)
110{
111 struct devlink_dpipe_header *header = action->header;
112 struct devlink_dpipe_field *field = &header->fields[action->field_id];
113 struct nlattr *action_attr;
114
115 action_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ACTION);
116 if (!action_attr)
117 return -EMSGSIZE;
118
119 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_ACTION_TYPE, action->type) ||
120 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_INDEX, action->header_index) ||
121 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
122 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
123 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
124 goto nla_put_failure;
125
126 nla_nest_end(skb, action_attr);
127 return 0;
128
129nla_put_failure:
130 nla_nest_cancel(skb, action_attr);
131 return -EMSGSIZE;
132}
133EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
134
135static int devlink_dpipe_actions_put(struct devlink_dpipe_table *table,
136 struct sk_buff *skb)
137{
138 struct nlattr *actions_attr;
139
140 actions_attr = nla_nest_start_noflag(skb,
141 DEVLINK_ATTR_DPIPE_TABLE_ACTIONS);
142 if (!actions_attr)
143 return -EMSGSIZE;
144
145 if (table->table_ops->actions_dump(table->priv, skb))
146 goto nla_put_failure;
147
148 nla_nest_end(skb, actions_attr);
149 return 0;
150
151nla_put_failure:
152 nla_nest_cancel(skb, actions_attr);
153 return -EMSGSIZE;
154}
155
156static int devlink_dpipe_table_put(struct sk_buff *skb,
157 struct devlink_dpipe_table *table)
158{
159 struct nlattr *table_attr;
160 u64 table_size;
161
162 table_size = table->table_ops->size_get(table->priv);
163 table_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLE);
164 if (!table_attr)
165 return -EMSGSIZE;
166
167 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_TABLE_NAME, table->name) ||
168 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_SIZE, table_size,
169 DEVLINK_ATTR_PAD))
170 goto nla_put_failure;
171 if (nla_put_u8(skb, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
172 table->counters_enabled))
173 goto nla_put_failure;
174
175 if (table->resource_valid) {
176 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,
177 table->resource_id, DEVLINK_ATTR_PAD) ||
178 nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,
179 table->resource_units, DEVLINK_ATTR_PAD))
180 goto nla_put_failure;
181 }
182 if (devlink_dpipe_matches_put(table, skb))
183 goto nla_put_failure;
184
185 if (devlink_dpipe_actions_put(table, skb))
186 goto nla_put_failure;
187
188 nla_nest_end(skb, table_attr);
189 return 0;
190
191nla_put_failure:
192 nla_nest_cancel(skb, table_attr);
193 return -EMSGSIZE;
194}
195
196static int devlink_dpipe_send_and_alloc_skb(struct sk_buff **pskb,
197 struct genl_info *info)
198{
199 int err;
200
201 if (*pskb) {
202 err = genlmsg_reply(*pskb, info);
203 if (err)
204 return err;
205 }
206 *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
207 if (!*pskb)
208 return -ENOMEM;
209 return 0;
210}
211
212static int devlink_dpipe_tables_fill(struct genl_info *info,
213 enum devlink_command cmd, int flags,
214 struct list_head *dpipe_tables,
215 const char *table_name)
216{
217 struct devlink *devlink = info->user_ptr[0];
218 struct devlink_dpipe_table *table;
219 struct nlattr *tables_attr;
220 struct sk_buff *skb = NULL;
221 struct nlmsghdr *nlh;
222 bool incomplete;
223 void *hdr;
224 int i;
225 int err;
226
227 table = list_first_entry(dpipe_tables,
228 struct devlink_dpipe_table, list);
229start_again:
230 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
231 if (err)
232 return err;
233
234 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
235 &devlink_nl_family, NLM_F_MULTI, cmd);
236 if (!hdr) {
237 nlmsg_free(skb);
238 return -EMSGSIZE;
239 }
240
241 if (devlink_nl_put_handle(skb, devlink))
242 goto nla_put_failure;
243 tables_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_TABLES);
244 if (!tables_attr)
245 goto nla_put_failure;
246
247 i = 0;
248 incomplete = false;
249 list_for_each_entry_from(table, dpipe_tables, list) {
250 if (!table_name) {
251 err = devlink_dpipe_table_put(skb, table);
252 if (err) {
253 if (!i)
254 goto err_table_put;
255 incomplete = true;
256 break;
257 }
258 } else {
259 if (!strcmp(table->name, table_name)) {
260 err = devlink_dpipe_table_put(skb, table);
261 if (err)
262 break;
263 }
264 }
265 i++;
266 }
267
268 nla_nest_end(skb, tables_attr);
269 genlmsg_end(skb, hdr);
270 if (incomplete)
271 goto start_again;
272
273send_done:
274 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
275 NLMSG_DONE, 0, flags | NLM_F_MULTI);
276 if (!nlh) {
277 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
278 if (err)
279 return err;
280 goto send_done;
281 }
282
283 return genlmsg_reply(skb, info);
284
285nla_put_failure:
286 err = -EMSGSIZE;
287err_table_put:
288 nlmsg_free(skb);
289 return err;
290}
291
292int devlink_nl_dpipe_table_get_doit(struct sk_buff *skb, struct genl_info *info)
293{
294 struct devlink *devlink = info->user_ptr[0];
295 const char *table_name = NULL;
296
297 if (info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME])
298 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
299
300 return devlink_dpipe_tables_fill(info, DEVLINK_CMD_DPIPE_TABLE_GET, 0,
301 &devlink->dpipe_table_list,
302 table_name);
303}
304
305static int devlink_dpipe_value_put(struct sk_buff *skb,
306 struct devlink_dpipe_value *value)
307{
308 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE,
309 value->value_size, value->value))
310 return -EMSGSIZE;
311 if (value->mask)
312 if (nla_put(skb, DEVLINK_ATTR_DPIPE_VALUE_MASK,
313 value->value_size, value->mask))
314 return -EMSGSIZE;
315 if (value->mapping_valid)
316 if (nla_put_u32(skb, DEVLINK_ATTR_DPIPE_VALUE_MAPPING,
317 value->mapping_value))
318 return -EMSGSIZE;
319 return 0;
320}
321
322static int devlink_dpipe_action_value_put(struct sk_buff *skb,
323 struct devlink_dpipe_value *value)
324{
325 if (!value->action)
326 return -EINVAL;
327 if (devlink_dpipe_action_put(skb, value->action))
328 return -EMSGSIZE;
329 if (devlink_dpipe_value_put(skb, value))
330 return -EMSGSIZE;
331 return 0;
332}
333
334static int devlink_dpipe_action_values_put(struct sk_buff *skb,
335 struct devlink_dpipe_value *values,
336 unsigned int values_count)
337{
338 struct nlattr *action_attr;
339 int i;
340 int err;
341
342 for (i = 0; i < values_count; i++) {
343 action_attr = nla_nest_start_noflag(skb,
344 DEVLINK_ATTR_DPIPE_ACTION_VALUE);
345 if (!action_attr)
346 return -EMSGSIZE;
347 err = devlink_dpipe_action_value_put(skb, &values[i]);
348 if (err)
349 goto err_action_value_put;
350 nla_nest_end(skb, action_attr);
351 }
352 return 0;
353
354err_action_value_put:
355 nla_nest_cancel(skb, action_attr);
356 return err;
357}
358
359static int devlink_dpipe_match_value_put(struct sk_buff *skb,
360 struct devlink_dpipe_value *value)
361{
362 if (!value->match)
363 return -EINVAL;
364 if (devlink_dpipe_match_put(skb, value->match))
365 return -EMSGSIZE;
366 if (devlink_dpipe_value_put(skb, value))
367 return -EMSGSIZE;
368 return 0;
369}
370
371static int devlink_dpipe_match_values_put(struct sk_buff *skb,
372 struct devlink_dpipe_value *values,
373 unsigned int values_count)
374{
375 struct nlattr *match_attr;
376 int i;
377 int err;
378
379 for (i = 0; i < values_count; i++) {
380 match_attr = nla_nest_start_noflag(skb,
381 DEVLINK_ATTR_DPIPE_MATCH_VALUE);
382 if (!match_attr)
383 return -EMSGSIZE;
384 err = devlink_dpipe_match_value_put(skb, &values[i]);
385 if (err)
386 goto err_match_value_put;
387 nla_nest_end(skb, match_attr);
388 }
389 return 0;
390
391err_match_value_put:
392 nla_nest_cancel(skb, match_attr);
393 return err;
394}
395
396static int devlink_dpipe_entry_put(struct sk_buff *skb,
397 struct devlink_dpipe_entry *entry)
398{
399 struct nlattr *entry_attr, *matches_attr, *actions_attr;
400 int err;
401
402 entry_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_ENTRY);
403 if (!entry_attr)
404 return -EMSGSIZE;
405
406 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_INDEX, entry->index,
407 DEVLINK_ATTR_PAD))
408 goto nla_put_failure;
409 if (entry->counter_valid)
410 if (nla_put_u64_64bit(skb, DEVLINK_ATTR_DPIPE_ENTRY_COUNTER,
411 entry->counter, DEVLINK_ATTR_PAD))
412 goto nla_put_failure;
413
414 matches_attr = nla_nest_start_noflag(skb,
415 DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES);
416 if (!matches_attr)
417 goto nla_put_failure;
418
419 err = devlink_dpipe_match_values_put(skb, entry->match_values,
420 entry->match_values_count);
421 if (err) {
422 nla_nest_cancel(skb, matches_attr);
423 goto err_match_values_put;
424 }
425 nla_nest_end(skb, matches_attr);
426
427 actions_attr = nla_nest_start_noflag(skb,
428 DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES);
429 if (!actions_attr)
430 goto nla_put_failure;
431
432 err = devlink_dpipe_action_values_put(skb, entry->action_values,
433 entry->action_values_count);
434 if (err) {
435 nla_nest_cancel(skb, actions_attr);
436 goto err_action_values_put;
437 }
438 nla_nest_end(skb, actions_attr);
439
440 nla_nest_end(skb, entry_attr);
441 return 0;
442
443nla_put_failure:
444 err = -EMSGSIZE;
445err_match_values_put:
446err_action_values_put:
447 nla_nest_cancel(skb, entry_attr);
448 return err;
449}
450
451static struct devlink_dpipe_table *
452devlink_dpipe_table_find(struct list_head *dpipe_tables,
453 const char *table_name, struct devlink *devlink)
454{
455 struct devlink_dpipe_table *table;
456
457 list_for_each_entry_rcu(table, dpipe_tables, list,
458 lockdep_is_held(&devlink->lock)) {
459 if (!strcmp(table->name, table_name))
460 return table;
461 }
462 return NULL;
463}
464
465int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
466{
467 struct devlink *devlink;
468 int err;
469
470 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx->skb,
471 dump_ctx->info);
472 if (err)
473 return err;
474
475 dump_ctx->hdr = genlmsg_put(dump_ctx->skb,
476 dump_ctx->info->snd_portid,
477 dump_ctx->info->snd_seq,
478 &devlink_nl_family, NLM_F_MULTI,
479 dump_ctx->cmd);
480 if (!dump_ctx->hdr)
481 goto nla_put_failure;
482
483 devlink = dump_ctx->info->user_ptr[0];
484 if (devlink_nl_put_handle(dump_ctx->skb, devlink))
485 goto nla_put_failure;
486 dump_ctx->nest = nla_nest_start_noflag(dump_ctx->skb,
487 DEVLINK_ATTR_DPIPE_ENTRIES);
488 if (!dump_ctx->nest)
489 goto nla_put_failure;
490 return 0;
491
492nla_put_failure:
493 nlmsg_free(dump_ctx->skb);
494 return -EMSGSIZE;
495}
496EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
497
498int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
499 struct devlink_dpipe_entry *entry)
500{
501 return devlink_dpipe_entry_put(dump_ctx->skb, entry);
502}
503EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
504
505int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
506{
507 nla_nest_end(dump_ctx->skb, dump_ctx->nest);
508 genlmsg_end(dump_ctx->skb, dump_ctx->hdr);
509 return 0;
510}
511EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
512
513void devlink_dpipe_entry_clear(struct devlink_dpipe_entry *entry)
514
515{
516 unsigned int value_count, value_index;
517 struct devlink_dpipe_value *value;
518
519 value = entry->action_values;
520 value_count = entry->action_values_count;
521 for (value_index = 0; value_index < value_count; value_index++) {
522 kfree(value[value_index].value);
523 kfree(value[value_index].mask);
524 }
525
526 value = entry->match_values;
527 value_count = entry->match_values_count;
528 for (value_index = 0; value_index < value_count; value_index++) {
529 kfree(value[value_index].value);
530 kfree(value[value_index].mask);
531 }
532}
533EXPORT_SYMBOL_GPL(devlink_dpipe_entry_clear);
534
535static int devlink_dpipe_entries_fill(struct genl_info *info,
536 enum devlink_command cmd, int flags,
537 struct devlink_dpipe_table *table)
538{
539 struct devlink_dpipe_dump_ctx dump_ctx;
540 struct nlmsghdr *nlh;
541 int err;
542
543 dump_ctx.skb = NULL;
544 dump_ctx.cmd = cmd;
545 dump_ctx.info = info;
546
547 err = table->table_ops->entries_dump(table->priv,
548 table->counters_enabled,
549 &dump_ctx);
550 if (err)
551 return err;
552
553send_done:
554 nlh = nlmsg_put(dump_ctx.skb, info->snd_portid, info->snd_seq,
555 NLMSG_DONE, 0, flags | NLM_F_MULTI);
556 if (!nlh) {
557 err = devlink_dpipe_send_and_alloc_skb(&dump_ctx.skb, info);
558 if (err)
559 return err;
560 goto send_done;
561 }
562 return genlmsg_reply(dump_ctx.skb, info);
563}
564
565int devlink_nl_dpipe_entries_get_doit(struct sk_buff *skb,
566 struct genl_info *info)
567{
568 struct devlink *devlink = info->user_ptr[0];
569 struct devlink_dpipe_table *table;
570 const char *table_name;
571
572 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_DPIPE_TABLE_NAME))
573 return -EINVAL;
574
575 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
576 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
577 table_name, devlink);
578 if (!table)
579 return -EINVAL;
580
581 if (!table->table_ops->entries_dump)
582 return -EINVAL;
583
584 return devlink_dpipe_entries_fill(info, DEVLINK_CMD_DPIPE_ENTRIES_GET,
585 0, table);
586}
587
588static int devlink_dpipe_fields_put(struct sk_buff *skb,
589 const struct devlink_dpipe_header *header)
590{
591 struct devlink_dpipe_field *field;
592 struct nlattr *field_attr;
593 int i;
594
595 for (i = 0; i < header->fields_count; i++) {
596 field = &header->fields[i];
597 field_attr = nla_nest_start_noflag(skb,
598 DEVLINK_ATTR_DPIPE_FIELD);
599 if (!field_attr)
600 return -EMSGSIZE;
601 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_FIELD_NAME, field->name) ||
602 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_ID, field->id) ||
603 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH, field->bitwidth) ||
604 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE, field->mapping_type))
605 goto nla_put_failure;
606 nla_nest_end(skb, field_attr);
607 }
608 return 0;
609
610nla_put_failure:
611 nla_nest_cancel(skb, field_attr);
612 return -EMSGSIZE;
613}
614
615static int devlink_dpipe_header_put(struct sk_buff *skb,
616 struct devlink_dpipe_header *header)
617{
618 struct nlattr *fields_attr, *header_attr;
619 int err;
620
621 header_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADER);
622 if (!header_attr)
623 return -EMSGSIZE;
624
625 if (nla_put_string(skb, DEVLINK_ATTR_DPIPE_HEADER_NAME, header->name) ||
626 nla_put_u32(skb, DEVLINK_ATTR_DPIPE_HEADER_ID, header->id) ||
627 nla_put_u8(skb, DEVLINK_ATTR_DPIPE_HEADER_GLOBAL, header->global))
628 goto nla_put_failure;
629
630 fields_attr = nla_nest_start_noflag(skb,
631 DEVLINK_ATTR_DPIPE_HEADER_FIELDS);
632 if (!fields_attr)
633 goto nla_put_failure;
634
635 err = devlink_dpipe_fields_put(skb, header);
636 if (err) {
637 nla_nest_cancel(skb, fields_attr);
638 goto nla_put_failure;
639 }
640 nla_nest_end(skb, fields_attr);
641 nla_nest_end(skb, header_attr);
642 return 0;
643
644nla_put_failure:
645 err = -EMSGSIZE;
646 nla_nest_cancel(skb, header_attr);
647 return err;
648}
649
650static int devlink_dpipe_headers_fill(struct genl_info *info,
651 enum devlink_command cmd, int flags,
652 struct devlink_dpipe_headers *
653 dpipe_headers)
654{
655 struct devlink *devlink = info->user_ptr[0];
656 struct nlattr *headers_attr;
657 struct sk_buff *skb = NULL;
658 struct nlmsghdr *nlh;
659 void *hdr;
660 int i, j;
661 int err;
662
663 i = 0;
664start_again:
665 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
666 if (err)
667 return err;
668
669 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
670 &devlink_nl_family, NLM_F_MULTI, cmd);
671 if (!hdr) {
672 nlmsg_free(skb);
673 return -EMSGSIZE;
674 }
675
676 if (devlink_nl_put_handle(skb, devlink))
677 goto nla_put_failure;
678 headers_attr = nla_nest_start_noflag(skb, DEVLINK_ATTR_DPIPE_HEADERS);
679 if (!headers_attr)
680 goto nla_put_failure;
681
682 j = 0;
683 for (; i < dpipe_headers->headers_count; i++) {
684 err = devlink_dpipe_header_put(skb, dpipe_headers->headers[i]);
685 if (err) {
686 if (!j)
687 goto err_table_put;
688 break;
689 }
690 j++;
691 }
692 nla_nest_end(skb, headers_attr);
693 genlmsg_end(skb, hdr);
694 if (i != dpipe_headers->headers_count)
695 goto start_again;
696
697send_done:
698 nlh = nlmsg_put(skb, info->snd_portid, info->snd_seq,
699 NLMSG_DONE, 0, flags | NLM_F_MULTI);
700 if (!nlh) {
701 err = devlink_dpipe_send_and_alloc_skb(&skb, info);
702 if (err)
703 return err;
704 goto send_done;
705 }
706 return genlmsg_reply(skb, info);
707
708nla_put_failure:
709 err = -EMSGSIZE;
710err_table_put:
711 nlmsg_free(skb);
712 return err;
713}
714
715int devlink_nl_dpipe_headers_get_doit(struct sk_buff *skb,
716 struct genl_info *info)
717{
718 struct devlink *devlink = info->user_ptr[0];
719
720 if (!devlink->dpipe_headers)
721 return -EOPNOTSUPP;
722 return devlink_dpipe_headers_fill(info, DEVLINK_CMD_DPIPE_HEADERS_GET,
723 0, devlink->dpipe_headers);
724}
725
726static int devlink_dpipe_table_counters_set(struct devlink *devlink,
727 const char *table_name,
728 bool enable)
729{
730 struct devlink_dpipe_table *table;
731
732 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
733 table_name, devlink);
734 if (!table)
735 return -EINVAL;
736
737 if (table->counter_control_extern)
738 return -EOPNOTSUPP;
739
740 if (!(table->counters_enabled ^ enable))
741 return 0;
742
743 table->counters_enabled = enable;
744 if (table->table_ops->counters_set_update)
745 table->table_ops->counters_set_update(table->priv, enable);
746 return 0;
747}
748
749int devlink_nl_dpipe_table_counters_set_doit(struct sk_buff *skb,
750 struct genl_info *info)
751{
752 struct devlink *devlink = info->user_ptr[0];
753 const char *table_name;
754 bool counters_enable;
755
756 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_DPIPE_TABLE_NAME) ||
757 GENL_REQ_ATTR_CHECK(info,
758 DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED))
759 return -EINVAL;
760
761 table_name = nla_data(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_NAME]);
762 counters_enable = !!nla_get_u8(info->attrs[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED]);
763
764 return devlink_dpipe_table_counters_set(devlink, table_name,
765 counters_enable);
766}
767
768/**
769 * devl_dpipe_headers_register - register dpipe headers
770 *
771 * @devlink: devlink
772 * @dpipe_headers: dpipe header array
773 *
774 * Register the headers supported by hardware.
775 */
776void devl_dpipe_headers_register(struct devlink *devlink,
777 struct devlink_dpipe_headers *dpipe_headers)
778{
779 lockdep_assert_held(&devlink->lock);
780
781 devlink->dpipe_headers = dpipe_headers;
782}
783EXPORT_SYMBOL_GPL(devl_dpipe_headers_register);
784
785/**
786 * devl_dpipe_headers_unregister - unregister dpipe headers
787 *
788 * @devlink: devlink
789 *
790 * Unregister the headers supported by hardware.
791 */
792void devl_dpipe_headers_unregister(struct devlink *devlink)
793{
794 lockdep_assert_held(&devlink->lock);
795
796 devlink->dpipe_headers = NULL;
797}
798EXPORT_SYMBOL_GPL(devl_dpipe_headers_unregister);
799
800/**
801 * devlink_dpipe_table_counter_enabled - check if counter allocation
802 * required
803 * @devlink: devlink
804 * @table_name: tables name
805 *
806 * Used by driver to check if counter allocation is required.
807 * After counter allocation is turned on the table entries
808 * are updated to include counter statistics.
809 *
810 * After that point on the driver must respect the counter
811 * state so that each entry added to the table is added
812 * with a counter.
813 */
814bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
815 const char *table_name)
816{
817 struct devlink_dpipe_table *table;
818 bool enabled;
819
820 rcu_read_lock();
821 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
822 table_name, devlink);
823 enabled = false;
824 if (table)
825 enabled = table->counters_enabled;
826 rcu_read_unlock();
827 return enabled;
828}
829EXPORT_SYMBOL_GPL(devlink_dpipe_table_counter_enabled);
830
831/**
832 * devl_dpipe_table_register - register dpipe table
833 *
834 * @devlink: devlink
835 * @table_name: table name
836 * @table_ops: table ops
837 * @priv: priv
838 * @counter_control_extern: external control for counters
839 */
840int devl_dpipe_table_register(struct devlink *devlink,
841 const char *table_name,
842 struct devlink_dpipe_table_ops *table_ops,
843 void *priv, bool counter_control_extern)
844{
845 struct devlink_dpipe_table *table;
846
847 lockdep_assert_held(&devlink->lock);
848
849 if (WARN_ON(!table_ops->size_get))
850 return -EINVAL;
851
852 if (devlink_dpipe_table_find(&devlink->dpipe_table_list, table_name,
853 devlink))
854 return -EEXIST;
855
856 table = kzalloc(sizeof(*table), GFP_KERNEL);
857 if (!table)
858 return -ENOMEM;
859
860 table->name = table_name;
861 table->table_ops = table_ops;
862 table->priv = priv;
863 table->counter_control_extern = counter_control_extern;
864
865 list_add_tail_rcu(&table->list, &devlink->dpipe_table_list);
866
867 return 0;
868}
869EXPORT_SYMBOL_GPL(devl_dpipe_table_register);
870
871/**
872 * devl_dpipe_table_unregister - unregister dpipe table
873 *
874 * @devlink: devlink
875 * @table_name: table name
876 */
877void devl_dpipe_table_unregister(struct devlink *devlink,
878 const char *table_name)
879{
880 struct devlink_dpipe_table *table;
881
882 lockdep_assert_held(&devlink->lock);
883
884 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
885 table_name, devlink);
886 if (!table)
887 return;
888 list_del_rcu(&table->list);
889 kfree_rcu(table, rcu);
890}
891EXPORT_SYMBOL_GPL(devl_dpipe_table_unregister);
892
893/**
894 * devl_dpipe_table_resource_set - set the resource id
895 *
896 * @devlink: devlink
897 * @table_name: table name
898 * @resource_id: resource id
899 * @resource_units: number of resource's units consumed per table's entry
900 */
901int devl_dpipe_table_resource_set(struct devlink *devlink,
902 const char *table_name, u64 resource_id,
903 u64 resource_units)
904{
905 struct devlink_dpipe_table *table;
906
907 table = devlink_dpipe_table_find(&devlink->dpipe_table_list,
908 table_name, devlink);
909 if (!table)
910 return -EINVAL;
911
912 table->resource_id = resource_id;
913 table->resource_units = resource_units;
914 table->resource_valid = true;
915 return 0;
916}
917EXPORT_SYMBOL_GPL(devl_dpipe_table_resource_set);