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
9 static 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
17 struct 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 };
24 EXPORT_SYMBOL_GPL(devlink_dpipe_header_ethernet);
25
26 static 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
34 struct 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 };
41 EXPORT_SYMBOL_GPL(devlink_dpipe_header_ipv4);
42
43 static 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
51 struct 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 };
58 EXPORT_SYMBOL_GPL(devlink_dpipe_header_ipv6);
59
60 int 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
81 nla_put_failure:
82 nla_nest_cancel(skb, match_attr);
83 return -EMSGSIZE;
84 }
85 EXPORT_SYMBOL_GPL(devlink_dpipe_match_put);
86
87 static 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
103 nla_put_failure:
104 nla_nest_cancel(skb, matches_attr);
105 return -EMSGSIZE;
106 }
107
108 int 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
129 nla_put_failure:
130 nla_nest_cancel(skb, action_attr);
131 return -EMSGSIZE;
132 }
133 EXPORT_SYMBOL_GPL(devlink_dpipe_action_put);
134
135 static 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
151 nla_put_failure:
152 nla_nest_cancel(skb, actions_attr);
153 return -EMSGSIZE;
154 }
155
156 static 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
191 nla_put_failure:
192 nla_nest_cancel(skb, table_attr);
193 return -EMSGSIZE;
194 }
195
196 static 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
212 static 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);
229 start_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
273 send_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
285 nla_put_failure:
286 err = -EMSGSIZE;
287 err_table_put:
288 nlmsg_free(skb);
289 return err;
290 }
291
292 int 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
305 static 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
322 static 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
334 static 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
354 err_action_value_put:
355 nla_nest_cancel(skb, action_attr);
356 return err;
357 }
358
359 static 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
371 static 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
391 err_match_value_put:
392 nla_nest_cancel(skb, match_attr);
393 return err;
394 }
395
396 static 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
443 nla_put_failure:
444 err = -EMSGSIZE;
445 err_match_values_put:
446 err_action_values_put:
447 nla_nest_cancel(skb, entry_attr);
448 return err;
449 }
450
451 static struct devlink_dpipe_table *
452 devlink_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
465 int 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
492 nla_put_failure:
493 nlmsg_free(dump_ctx->skb);
494 return -EMSGSIZE;
495 }
496 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_prepare);
497
498 int 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 }
503 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_append);
504
505 int 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 }
511 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_ctx_close);
512
513 void 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 }
533 EXPORT_SYMBOL_GPL(devlink_dpipe_entry_clear);
534
535 static 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
553 send_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
565 int 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
588 static 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
610 nla_put_failure:
611 nla_nest_cancel(skb, field_attr);
612 return -EMSGSIZE;
613 }
614
615 static 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
644 nla_put_failure:
645 err = -EMSGSIZE;
646 nla_nest_cancel(skb, header_attr);
647 return err;
648 }
649
650 static 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;
664 start_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
697 send_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
708 nla_put_failure:
709 err = -EMSGSIZE;
710 err_table_put:
711 nlmsg_free(skb);
712 return err;
713 }
714
715 int 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
726 static 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
749 int 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 */
776 void 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 }
783 EXPORT_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 */
792 void devl_dpipe_headers_unregister(struct devlink *devlink)
793 {
794 lockdep_assert_held(&devlink->lock);
795
796 devlink->dpipe_headers = NULL;
797 }
798 EXPORT_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 */
814 bool 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 }
829 EXPORT_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 */
840 int devl_dpipe_table_register(struct devlink *devlink,
841 const char *table_name,
842 const 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 }
869 EXPORT_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 */
877 void 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 }
891 EXPORT_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 */
901 int 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 }
917 EXPORT_SYMBOL_GPL(devl_dpipe_table_resource_set);
918
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.