22 #include <netlink-private/netlink.h>
23 #include <netlink-private/route/link/api.h>
24 #include <netlink/netlink.h>
25 #include <netlink/route/link.h>
27 #include <linux/if_ether.h>
28 #include <linux/if_link.h>
29 #include <netlink-private/route/link/sriov.h>
30 #include <netlink/route/link/sriov.h>
35 #define SRIOVOFF "off"
37 #define SET_VF_STAT(link, vf_num, stb, stat, attr) \
38 vf_data->vf_stats[stat] = nla_get_u64(stb[attr])
41 #define SRIOV_ATTR_INDEX (1 << 0)
42 #define SRIOV_ATTR_ADDR (1 << 1)
43 #define SRIOV_ATTR_VLAN (1 << 2)
44 #define SRIOV_ATTR_TX_RATE (1 << 3)
45 #define SRIOV_ATTR_SPOOFCHK (1 << 4)
46 #define SRIOV_ATTR_RATE_MAX (1 << 5)
47 #define SRIOV_ATTR_RATE_MIN (1 << 6)
48 #define SRIOV_ATTR_LINK_STATE (1 << 7)
49 #define SRIOV_ATTR_RSS_QUERY_EN (1 << 8)
50 #define SRIOV_ATTR_STATS (1 << 9)
51 #define SRIOV_ATTR_TRUST (1 << 10)
52 #define SRIOV_ATTR_IB_NODE_GUID (1 << 11)
53 #define SRIOV_ATTR_IB_PORT_GUID (1 << 12)
55 static struct nla_policy sriov_info_policy[IFLA_VF_MAX+1] = {
56 [IFLA_VF_MAC] = { .
minlen =
sizeof(
struct ifla_vf_mac) },
57 [IFLA_VF_VLAN] = { .minlen =
sizeof(
struct ifla_vf_vlan) },
59 [IFLA_VF_TX_RATE] = { .minlen =
sizeof(
struct ifla_vf_tx_rate) },
60 [IFLA_VF_SPOOFCHK] = { .minlen =
sizeof(
struct ifla_vf_spoofchk) },
61 [IFLA_VF_RATE] = { .minlen =
sizeof(
struct ifla_vf_rate) },
62 [IFLA_VF_LINK_STATE] = { .minlen =
sizeof(
struct ifla_vf_link_state) },
63 [IFLA_VF_RSS_QUERY_EN] = { .minlen =
sizeof(
struct ifla_vf_rss_query_en) },
65 [IFLA_VF_TRUST] = { .minlen =
sizeof(
struct ifla_vf_trust) },
66 [IFLA_VF_IB_NODE_GUID] = { .minlen =
sizeof(
struct ifla_vf_guid) },
67 [IFLA_VF_IB_PORT_GUID] = { .minlen =
sizeof(
struct ifla_vf_guid) },
70 static struct nla_policy sriov_stats_policy[IFLA_VF_STATS_MAX+1] = {
72 [IFLA_VF_STATS_TX_PACKETS] = { .type =
NLA_U64 },
73 [IFLA_VF_STATS_RX_BYTES] = { .type =
NLA_U64 },
74 [IFLA_VF_STATS_TX_BYTES] = { .type =
NLA_U64 },
75 [IFLA_VF_STATS_BROADCAST] = { .type =
NLA_U64 },
76 [IFLA_VF_STATS_MULTICAST] = { .type =
NLA_U64 },
84 struct nl_addr *vf_addr;
85 struct rtnl_link_vf *s_list, *d_vf, *s_vf, *next, *dest_h = NULL;
89 if (!(err = rtnl_link_has_vf_list(src)))
95 dest_h = dst->l_vf_list;
96 s_list = src->l_vf_list;
98 nl_list_for_each_entry_safe(s_vf, next, &s_list->vf_list, vf_list) {
102 memcpy(d_vf, s_vf,
sizeof(*s_vf));
104 if (s_vf->ce_mask & SRIOV_ATTR_ADDR) {
110 d_vf->vf_lladdr = vf_addr;
113 if (s_vf->ce_mask & SRIOV_ATTR_VLAN) {
114 src_vlans = s_vf->vf_vlans;
115 src_vlan_info = src_vlans->
vlans;
123 dst_vlan_info = dst_vlans->vlans;
125 memcpy(dst_vlan_info, src_vlan_info,
126 dst_vlans->size *
sizeof(dst_vlan_info));
127 d_vf->vf_vlans = dst_vlans;
130 nl_list_add_head(&d_vf->vf_list, &dest_h->vf_list);
145 vlan_data = vlans->
vlans;
147 while (cur < vlans->size) {
148 nl_dump(p,
"\t vlan %u", vlan_data[cur].vf_vlan);
149 if (vlan_data[cur].vf_vlan_qos)
150 nl_dump(p,
" qos %u", vlan_data[cur].vf_vlan_qos);
151 if (vlan_data[cur].vf_vlan_proto) {
154 rtnl_link_vf_vlanproto2str(prot, buf,
165 static void dump_vf_details(
struct rtnl_link_vf *vf_data,
172 nl_dump(p,
"\tvf %u: ", vf_data->vf_index);
173 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
174 v = vf_data->vf_linkstate;
176 rtnl_link_vf_linkstate2str(v, buf,
sizeof(buf)));
178 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
180 nl_addr2str(vf_data->vf_lladdr, buf,
sizeof(buf)));
184 v = vf_data->vf_spoofchk;
185 nl_dump(p,
"\t spoofchk %s ", v ? SRIOVON : SRIOVOFF);
186 v = vf_data->vf_trust;
187 nl_dump(p,
"trust %s ", v ? SRIOVON : SRIOVOFF);
188 v = vf_data->vf_rss_query_en;
189 nl_dump(p,
"rss_query %s\n", v ? SRIOVON : SRIOVOFF);
194 nl_dump(p,
"\t rate_api old rate %u\n",
197 nl_dump(p,
"\t rate_api new min_rate %u "
198 "max_rate %u\n", vf_rate.min_tx_rate,
199 vf_rate.max_tx_rate);
201 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
202 dump_sriov_vlans(vf_data->vf_vlans, p);
208 void rtnl_link_sriov_dump_details(
struct rtnl_link *link,
213 if (!(err = rtnl_link_has_vf_list(link)))
216 nl_dump(p,
" SRIOV VF List\n");
217 list = link->l_vf_list;
218 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
219 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
220 dump_vf_details(vf_data, p);
232 nl_dump(p,
" VF %" PRIu64
" Stats:\n", vf_data->vf_index);
233 nl_dump_line(p,
"\tRX: %-14s %-10s %-10s %-10s\n",
234 "bytes",
"packets",
"multicast",
"broadcast");
240 "\t%10.2f %3s %10" PRIu64
" %10" PRIu64
" %10" PRIu64
"\n",
246 nl_dump_line(p,
"\tTX: %-14s %-10s\n",
"bytes",
"packets");
251 nl_dump_line(p,
"\t%10.2f %3s %10" PRIu64
"\n", res, unit,
258 void rtnl_link_sriov_dump_stats(
struct rtnl_link *link,
262 list = link->l_vf_list;
263 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
264 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
265 dump_vf_stats(vf_data, p);
273 void rtnl_link_sriov_free_data(
struct rtnl_link *link) {
277 if (!(err = rtnl_link_has_vf_list(link)))
280 list = link->l_vf_list;
281 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
282 nl_list_del(&vf->vf_list);
292 static int rtnl_link_vf_vlan_info(
int len,
struct ifla_vf_vlan_info **vi,
305 vlans->
vlans[cur].
vf_vlan = vi[cur]->vlan ? vi[cur]->vlan : 0;
307 if (vi[cur]->vlan_proto) {
322 struct ifla_vf_vlan vlan;
327 NLA_PUT(msg, IFLA_VF_VLAN,
sizeof(vlan), &vlan);
334 static int sriov_fill_vf_vlan_list(
struct nl_msg *msg,
nl_vf_vlans_t *vlans,
338 struct ifla_vf_vlan_info vlan;
345 while (cur < vlans->size) {
346 vlan.vlan = vlan_info[cur].
vf_vlan;
350 NLA_PUT(msg, IFLA_VF_VLAN_INFO,
sizeof(vlan), &vlan);
362 static int sriov_fill_vfinfo(
struct nl_msg *msg,
364 int err = 0, new_rate = 0;
367 struct ifla_vf_guid vf_node_guid;
368 struct ifla_vf_guid vf_port_guid;
369 struct ifla_vf_link_state vf_link_state;
370 struct ifla_vf_mac vf_mac;
371 struct ifla_vf_rate new_vf_rate;
372 struct ifla_vf_rss_query_en vf_rss_query_en;
373 struct ifla_vf_spoofchk vf_spoofchk;
374 struct ifla_vf_trust vf_trust;
375 struct ifla_vf_tx_rate vf_rate;
379 if (!(vf_data->ce_mask & SRIOV_ATTR_INDEX))
380 return -NLE_MISSING_ATTR;
386 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
387 vf_mac.vf = vf_data->vf_index;
388 memset(vf_mac.mac, 0,
sizeof(vf_mac.mac));
391 NLA_PUT(msg, IFLA_VF_MAC,
sizeof(vf_mac), &vf_mac);
395 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
396 vlan_list = vf_data->vf_vlans;
397 vlan_info = vlan_list->
vlans;
402 if ((vlan_list->
size == 1) && (proto == ETH_P_8021Q))
403 sriov_fill_vf_vlan(msg, vlan_info, vf_data->vf_index);
405 err = sriov_fill_vf_vlan_list(msg, vlan_list,
410 if (vf_data->ce_mask & SRIOV_ATTR_TX_RATE) {
411 vf_rate.vf = vf_data->vf_index;
412 vf_rate.rate = vf_data->vf_rate;
414 NLA_PUT(msg, IFLA_VF_TX_RATE,
sizeof(vf_rate), &vf_rate);
418 new_vf_rate.min_tx_rate = 0;
419 new_vf_rate.max_tx_rate = 0;
420 new_vf_rate.vf = vf_data->vf_index;
421 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
422 new_vf_rate.min_tx_rate = vf_data->vf_min_tx_rate;
425 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
426 new_vf_rate.max_tx_rate = vf_data->vf_max_tx_rate;
430 NLA_PUT(msg, IFLA_VF_RATE,
sizeof(new_vf_rate), &new_vf_rate);
433 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK) {
434 vf_spoofchk.vf = vf_data->vf_index;
435 vf_spoofchk.setting = vf_data->vf_spoofchk;
437 NLA_PUT(msg, IFLA_VF_SPOOFCHK,
sizeof(vf_spoofchk),
442 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
443 vf_link_state.vf = vf_data->vf_index;
444 vf_link_state.link_state = vf_data->vf_linkstate;
446 NLA_PUT(msg, IFLA_VF_LINK_STATE,
sizeof(vf_link_state),
451 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN) {
452 vf_rss_query_en.vf = vf_data->vf_index;
453 vf_rss_query_en.setting = vf_data->vf_rss_query_en;
455 NLA_PUT(msg, IFLA_VF_RSS_QUERY_EN,
sizeof(vf_rss_query_en),
460 if (vf_data->ce_mask & SRIOV_ATTR_TRUST) {
461 vf_trust.vf = vf_data->vf_index;
462 vf_trust.setting = vf_data->vf_trust;
464 NLA_PUT(msg, IFLA_VF_TRUST,
sizeof(vf_trust), &vf_trust);
468 if (vf_data->ce_mask & SRIOV_ATTR_IB_NODE_GUID) {
469 vf_node_guid.vf = vf_data->vf_index;
470 vf_node_guid.guid = vf_data->vf_guid_node;
472 NLA_PUT(msg, IFLA_VF_IB_NODE_GUID,
sizeof(vf_node_guid),
477 if (vf_data->ce_mask & SRIOV_ATTR_IB_PORT_GUID) {
478 vf_port_guid.vf = vf_data->vf_index;
479 vf_port_guid.guid = vf_data->vf_guid_port;
481 NLA_PUT(msg, IFLA_VF_IB_PORT_GUID,
sizeof(vf_port_guid),
492 int rtnl_link_sriov_fill_vflist(
struct nl_msg *msg,
struct rtnl_link *link) {
497 if (!(err = rtnl_link_has_vf_list(link)))
503 list = link->l_vf_list;
504 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
505 if (vf->ce_mask & SRIOV_ATTR_INDEX) {
506 if ((err = sriov_fill_vfinfo(msg, vf)) < 0)
507 goto nla_nest_list_failure;
511 nla_nest_list_failure:
518 int rtnl_link_sriov_parse_vflist(
struct rtnl_link *link,
struct nlattr **tb) {
519 int err, len, list_len, list_rem;
520 struct ifla_vf_mac *vf_lladdr;
521 struct ifla_vf_vlan *vf_vlan;
522 struct ifla_vf_vlan_info *vf_vlan_info[MAX_VLAN_LIST_LEN];
523 struct ifla_vf_tx_rate *vf_tx_rate;
524 struct ifla_vf_spoofchk *vf_spoofchk;
525 struct ifla_vf_link_state *vf_linkstate;
526 struct ifla_vf_rate *vf_rate;
527 struct ifla_vf_rss_query_en *vf_rss_query;
528 struct ifla_vf_trust *vf_trust;
529 struct nlattr *nla, *nla_list, *t[IFLA_VF_MAX+1],
530 *stb[RTNL_LINK_VF_STATS_MAX+1];
534 len =
nla_len(tb[IFLA_VFINFO_LIST]);
536 if (!link->l_vf_list)
538 vf_head = link->l_vf_list;
551 if (t[IFLA_VF_MAC]) {
552 vf_lladdr =
nla_data(t[IFLA_VF_MAC]);
554 vf_data->vf_index = vf_lladdr->vf;
555 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
559 if (vf_data->vf_lladdr == NULL) {
564 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
567 if (t[IFLA_VF_VLAN_LIST]) {
571 if (list_len >= MAX_VLAN_LIST_LEN)
573 vf_vlan_info[list_len] =
nla_data(nla_list);
577 err = rtnl_link_vf_vlan_info(list_len, vf_vlan_info,
584 vf_data->vf_vlans = vf_vlans;
585 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
586 }
else if (t[IFLA_VF_VLAN]) {
587 vf_vlan =
nla_data(t[IFLA_VF_VLAN]);
600 vf_data->vf_vlans = vf_vlans;
601 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
605 if (t[IFLA_VF_TX_RATE]) {
606 vf_tx_rate =
nla_data(t[IFLA_VF_TX_RATE]);
608 if (vf_tx_rate->rate) {
609 vf_data->vf_rate = vf_tx_rate->rate;
610 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
614 if (t[IFLA_VF_SPOOFCHK]) {
615 vf_spoofchk =
nla_data(t[IFLA_VF_SPOOFCHK]);
617 if (vf_spoofchk->setting != -1) {
618 vf_data->vf_spoofchk = vf_spoofchk->setting ? 1 : 0;
619 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
623 if (t[IFLA_VF_LINK_STATE]) {
624 vf_linkstate =
nla_data(t[IFLA_VF_LINK_STATE]);
626 vf_data->vf_linkstate = vf_linkstate->link_state;
627 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
630 if (t[IFLA_VF_RATE]) {
631 vf_rate =
nla_data(t[IFLA_VF_RATE]);
633 if (vf_rate->max_tx_rate) {
634 vf_data->vf_max_tx_rate = vf_rate->max_tx_rate;
635 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
637 if (vf_rate->min_tx_rate) {
638 vf_data->vf_min_tx_rate = vf_rate->min_tx_rate;
639 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
643 if (t[IFLA_VF_RSS_QUERY_EN]) {
644 vf_rss_query =
nla_data(t[IFLA_VF_RSS_QUERY_EN]);
646 if (vf_rss_query->setting != -1) {
647 vf_data->vf_rss_query_en = vf_rss_query->setting ? 1 : 0;
648 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
652 if (t[IFLA_VF_STATS]) {
661 SET_VF_STAT(link, cur, stb,
663 IFLA_VF_STATS_RX_PACKETS);
664 SET_VF_STAT(link, cur, stb,
666 IFLA_VF_STATS_TX_PACKETS);
667 SET_VF_STAT(link, cur, stb,
669 IFLA_VF_STATS_RX_BYTES);
670 SET_VF_STAT(link, cur, stb,
672 IFLA_VF_STATS_TX_BYTES);
673 SET_VF_STAT(link, cur, stb,
675 IFLA_VF_STATS_BROADCAST);
676 SET_VF_STAT(link, cur, stb,
678 IFLA_VF_STATS_MULTICAST);
680 vf_data->ce_mask |= IFLA_VF_STATS;
683 if (t[IFLA_VF_TRUST]) {
684 vf_trust =
nla_data(t[IFLA_VF_TRUST]);
686 if (vf_trust->setting != -1) {
687 vf_data->vf_trust = vf_trust->setting ? 1 : 0;
688 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
692 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
717 return -NLE_OBJ_NOTFOUND;
719 if (!link->l_vf_list) {
721 if (!link->l_vf_list)
726 vf_head->ce_refcnt++;
728 vf_head = link->l_vf_list;
729 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
730 link->l_vf_list = vf_head;
732 rtnl_link_set_vf_list(link);
751 if (!(vf = calloc(1,
sizeof(*vf))))
754 NL_INIT_LIST_HEAD(&vf->vf_list);
757 NL_DBG(4,
"Allocated new SRIOV VF object %p\n", vf);
770 if (vf_data->ce_refcnt > 0)
771 NL_DBG(1,
"Warning: Freeing SRIOV VF object in use...\n");
773 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
775 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
778 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_data);
798 list = link->l_vf_list;
799 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
800 if (vf->vf_index == vf_num) {
808 NL_DBG(4,
"New reference to SRIOV VF object %p, total %i\n",
809 ret, ret->ce_refcnt);
826 vf_data->ce_refcnt--;
827 NL_DBG(4,
"Returned SRIOV VF object reference %p, %i remaining\n",
828 vf_data, vf_data->ce_refcnt);
830 if (vf_data->ce_refcnt < 0)
833 if (vf_data->ce_refcnt <= 0)
855 return -NLE_OBJ_NOTFOUND;
857 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
858 *addr = vf_data->vf_lladdr;
876 if (vf_data->vf_lladdr)
880 vf_data->vf_lladdr = addr;
881 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
893 vf_data->vf_guid_node = guid;
894 vf_data->ce_mask |= SRIOV_ATTR_IB_NODE_GUID;
906 vf_data->vf_guid_port = guid;
907 vf_data->ce_mask |= SRIOV_ATTR_IB_PORT_GUID;
926 return -NLE_OBJ_NOTFOUND;
928 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
929 *vf_index = vf_data->vf_index;
945 vf_data->vf_index = vf_index;
946 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
964 uint32_t *vf_linkstate)
967 return -NLE_OBJ_NOTFOUND;
969 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE)
970 *vf_linkstate = vf_data->vf_linkstate;
988 uint32_t vf_linkstate) {
989 vf_data->vf_linkstate = vf_linkstate;
990 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
1025 return -NLE_OBJ_NOTFOUND;
1032 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
1033 if (vf_data->vf_max_tx_rate) {
1039 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
1040 if (vf_data->vf_min_tx_rate) {
1046 if ((!set) && (vf_data->ce_mask & SRIOV_ATTR_TX_RATE)) {
1047 if (vf_data->vf_rate) {
1049 vf_rate->
rate = vf_data->vf_rate;
1088 vf_data->vf_rate = vf_rate->
rate;
1089 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
1092 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
1095 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
1114 uint32_t *vf_rss_query_en)
1117 return -NLE_OBJ_NOTFOUND;
1119 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN)
1120 *vf_rss_query_en = vf_data->vf_rss_query_en;
1135 uint32_t vf_rss_query_en) {
1136 vf_data->vf_rss_query_en = vf_rss_query_en;
1137 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
1155 uint32_t *vf_spoofchk)
1158 return -NLE_OBJ_NOTFOUND;
1160 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK)
1161 *vf_spoofchk = vf_data->vf_spoofchk;
1176 uint32_t vf_spoofchk) {
1177 vf_data->vf_spoofchk = vf_spoofchk;
1178 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
1199 return -NLE_OBJ_NOTFOUND;
1201 if (vf_data->ce_mask & SRIOV_ATTR_STATS)
1202 *vf_stat = vf_data->vf_stats[stat];
1224 return -NLE_OBJ_NOTFOUND;
1226 if (vf_data->ce_mask & SRIOV_ATTR_TRUST)
1227 *vf_trust = vf_data->vf_trust;
1242 vf_data->vf_trust = vf_trust;
1243 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
1268 return -NLE_OBJ_NOTFOUND;
1270 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
1271 vf = vf_data->vf_vlans;
1294 if (!vf_data||!vf_vlans)
1297 vf_data->vf_vlans = vf_vlans;
1298 vf_data->vf_vlans->ce_refcnt++;
1299 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
1320 if (vlan_count > MAX_VLAN_LIST_LEN)
1323 vlans = calloc(1,
sizeof(*vlans));
1327 vlan_info = calloc(vlan_count+1,
sizeof(*vlan_info));
1333 NL_DBG(4,
"Allocated new SRIOV VF VLANs object %p\n", vlans);
1336 vlans->
size = vlan_count;
1337 vlans->
vlans = vlan_info;
1352 NL_DBG(1,
"Warning: Freeing SRIOV VF VLANs object in use...\n");
1354 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_vlans);
1355 free(vf_vlans->
vlans);
1370 NL_DBG(4,
"Returned SRIOV VF VLANs object reference %p, %i remaining\n",
1389 static const struct trans_tbl vf_link_states[] = {
1390 __ADD(IFLA_VF_LINK_STATE_AUTO, autodetect),
1391 __ADD(IFLA_VF_LINK_STATE_ENABLE, up),
1392 __ADD(IFLA_VF_LINK_STATE_DISABLE, down),
1395 char *rtnl_link_vf_linkstate2str(uint32_t ls,
char *buf,
size_t len)
1397 return __type2str(ls, buf, len, vf_link_states,
1398 ARRAY_SIZE(vf_link_states));
1401 int rtnl_link_vf_str2linkstate(
const char *name)
1403 return __str2type(name, vf_link_states, ARRAY_SIZE(vf_link_states));
1406 static const struct trans_tbl vf_vlan_proto[] = {
1407 __ADD(ETH_P_8021Q, 8021Q),
1408 __ADD(ETH_P_8021AD, 8021AD),
1411 char *rtnl_link_vf_vlanproto2str(uint16_t proto,
char *buf,
size_t len)
1413 return __type2str(proto, buf, len, vf_vlan_proto,
1414 ARRAY_SIZE(vf_vlan_proto));
1417 int rtnl_link_vf_str2vlanproto(
const char *name)
1419 return __str2type(name, vf_vlan_proto, ARRAY_SIZE(vf_vlan_proto));
1430 int rtnl_link_vf_str2guid(uint64_t *guid,
const char *guid_s) {
1431 unsigned long int tmp;
1435 if (strlen(guid_s) != RTNL_VF_GUID_STR_LEN)
1438 for (i = 0; i < 7; i++) {
1439 if (guid_s[2 + i * 3] !=
':')
1444 for (i = 0; i < 8; i++) {
1445 tmp = strtoul(guid_s + i * 3, &endptr, 16);
1446 if (endptr != guid_s + i * 3 + 2)
1452 *guid |= tmp << (56 - 8 * i);
void * nl_addr_get_binary_addr(const struct nl_addr *addr)
Get binary address of abstract address object.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.
struct nl_addr * nl_addr_build(int family, const void *buf, size_t size)
Allocate abstract address based on a binary address.
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
struct nl_addr * nl_addr_get(struct nl_addr *addr)
Increase the reference counter of an abstract address.
unsigned int nl_addr_get_len(const struct nl_addr *addr)
Get length of binary address of abstract address object.
void nl_addr_put(struct nl_addr *addr)
Decrease the reference counter of an abstract address.
void nl_addr_set_family(struct nl_addr *addr, int family)
Set address family.
int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len, const struct nla_policy *policy)
Create attribute index based on a stream of attributes.
int nla_ok(const struct nlattr *nla, int remaining)
Check if the attribute header and payload can be accessed safely.
struct nlattr * nla_next(const struct nlattr *nla, int *remaining)
Return next attribute in a stream of attributes.
#define NLA_PUT(msg, attrtype, attrlen, data)
Add unspecific attribute to netlink message.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, const struct nla_policy *policy)
Create attribute index based on nested attribute.
#define nla_for_each_nested(pos, nla, rem)
Iterate over a stream of nested attributes.
int nla_len(const struct nlattr *nla)
Return length of the payload .
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
@ NLA_NESTED
Nested attributes.
int rtnl_link_vf_get_rss_query_en(struct rtnl_link_vf *vf_data, uint32_t *vf_rss_query_en)
Get RSS Query EN value of SRIOV Virtual Function.
int rtnl_link_vf_get_index(struct rtnl_link_vf *vf_data, uint32_t *vf_index)
Get index of SRIOV Virtual Function.
void rtnl_link_vf_set_addr(struct rtnl_link_vf *vf_data, struct nl_addr *addr)
Set link layer address of SRIOV Virtual Function object.
void rtnl_link_vf_set_vlans(struct rtnl_link_vf *vf_data, nl_vf_vlans_t *vf_vlans)
Add a SRIOV VF VLANs object to the SRIOV Virtual Function Object.
int rtnl_link_vf_vlan_alloc(nl_vf_vlans_t **vf_vlans, int vlan_count)
Allocate a SRIOV VF VLAN object.
void rtnl_link_vf_put(struct rtnl_link_vf *vf_data)
Return SRIOV VF object to the owning link object.
struct rtnl_link_vf * rtnl_link_vf_alloc(void)
Allocate a new SRIOV VF object.
struct rtnl_link_vf * rtnl_link_vf_get(struct rtnl_link *link, uint32_t vf_num)
Lookup SRIOV VF in link object by VF index.
void rtnl_link_vf_set_ib_node_guid(struct rtnl_link_vf *vf_data, uint64_t guid)
Set the Infiniband node GUID for the SRIOV Virtual Function object.
void rtnl_link_vf_set_trust(struct rtnl_link_vf *vf_data, uint32_t vf_trust)
Set user trust setting on SRIOV Virtual Function Object.
int rtnl_link_vf_get_addr(struct rtnl_link_vf *vf_data, struct nl_addr **addr)
Get link layer address of SRIOV Virtual Function.
void rtnl_link_vf_set_ib_port_guid(struct rtnl_link_vf *vf_data, uint64_t guid)
Set the Infiniband port GUID for the SRIOV Virtual Function object.
void rtnl_link_vf_set_rate(struct rtnl_link_vf *vf_data, struct nl_vf_rate *vf_rate)
Set TX Rate Limit of SRIOV Virtual Function object.
void rtnl_link_vf_set_linkstate(struct rtnl_link_vf *vf_data, uint32_t vf_linkstate)
Set link state of SRIOV Virtual Function object.
void rtnl_link_vf_set_rss_query_en(struct rtnl_link_vf *vf_data, uint32_t vf_rss_query_en)
Set RSS configuration querying of SRIOV Virtual Function Object.
int rtnl_link_vf_get_vlans(struct rtnl_link_vf *vf_data, nl_vf_vlans_t **vf_vlans)
Get an array of VLANS on SRIOV Virtual Function.
int rtnl_link_vf_get_stat(struct rtnl_link_vf *vf_data, rtnl_link_vf_stats_t stat, uint64_t *vf_stat)
Get value of stat counter for SRIOV Virtual Function.
void rtnl_link_vf_vlan_put(nl_vf_vlans_t *vf_vlans)
Return SRIOV VF VLANs object to the owning SRIOV VF object.
void rtnl_link_vf_set_spoofchk(struct rtnl_link_vf *vf_data, uint32_t vf_spoofchk)
Set spoof checking value of SRIOV Virtual Function Object.
int rtnl_link_vf_get_trust(struct rtnl_link_vf *vf_data, uint32_t *vf_trust)
Get trust setting of SRIOV Virtual Function.
void rtnl_link_vf_free(struct rtnl_link_vf *vf_data)
Free SRIOV VF object.
int rtnl_link_vf_get_spoofchk(struct rtnl_link_vf *vf_data, uint32_t *vf_spoofchk)
Get spoof checking value of SRIOV Virtual Function.
void rtnl_link_vf_set_index(struct rtnl_link_vf *vf_data, uint32_t vf_index)
Set index of SRIOV Virtual Function object.
void rtnl_link_vf_vlan_free(nl_vf_vlans_t *vf_vlans)
Free an allocated SRIOV VF VLANs object.
int rtnl_link_vf_get_linkstate(struct rtnl_link_vf *vf_data, uint32_t *vf_linkstate)
Get link state of SRIOV Virtual Function.
int rtnl_link_vf_get_rate(struct rtnl_link_vf *vf_data, struct nl_vf_rate *vf_rate)
Get TX Rate Limit of SRIOV Virtual Function.
int rtnl_link_vf_add(struct rtnl_link *link, struct rtnl_link_vf *vf_data)
Add a SRIOV VF object to a link object.
@ RTNL_LINK_VF_STATS_TX_BYTES
@ RTNL_LINK_VF_STATS_BROADCAST
@ RTNL_LINK_VF_STATS_RX_PACKETS
@ RTNL_LINK_VF_STATS_MULTICAST
@ RTNL_LINK_VF_STATS_RX_BYTES
@ RTNL_LINK_VF_STATS_TX_PACKETS
@ RTNL_LINK_VF_RATE_API_UNSPEC
@ RTNL_LINK_VF_RATE_API_NEW
@ RTNL_LINK_VF_RATE_API_OLD
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
VF Rate information structure.
SRIOV VF VLANs information.
nl_vf_vlan_info_t * vlans
Attribute validation policy.
uint16_t minlen
Minimal length of payload required.
uint16_t type
Type of attribute or NLA_UNSPEC.