28 #include <netlink-private/netlink.h> 29 #include <netlink-private/route/link/api.h> 30 #include <netlink/netlink.h> 31 #include <netlink/route/link.h> 33 #include <linux/if_ether.h> 34 #include <linux/if_link.h> 35 #include <netlink-private/route/link/sriov.h> 36 #include <netlink/route/link/sriov.h> 41 #define SRIOVOFF "off" 43 #define SET_VF_STAT(link, vf_num, stb, stat, attr) \ 44 vf_data->vf_stats[stat] = nla_get_u64(stb[attr]) 47 #define SRIOV_ATTR_INDEX (1 << 0) 48 #define SRIOV_ATTR_ADDR (1 << 1) 49 #define SRIOV_ATTR_VLAN (1 << 2) 50 #define SRIOV_ATTR_TX_RATE (1 << 3) 51 #define SRIOV_ATTR_SPOOFCHK (1 << 4) 52 #define SRIOV_ATTR_RATE_MAX (1 << 5) 53 #define SRIOV_ATTR_RATE_MIN (1 << 6) 54 #define SRIOV_ATTR_LINK_STATE (1 << 7) 55 #define SRIOV_ATTR_RSS_QUERY_EN (1 << 8) 56 #define SRIOV_ATTR_STATS (1 << 9) 57 #define SRIOV_ATTR_TRUST (1 << 10) 58 #define SRIOV_ATTR_IB_NODE_GUID (1 << 11) 59 #define SRIOV_ATTR_IB_PORT_GUID (1 << 12) 61 static struct nla_policy sriov_info_policy[IFLA_VF_MAX+1] = {
62 [IFLA_VF_MAC] = { .
minlen =
sizeof(
struct ifla_vf_mac) },
63 [IFLA_VF_VLAN] = { .minlen =
sizeof(
struct ifla_vf_vlan) },
65 [IFLA_VF_TX_RATE] = { .minlen =
sizeof(
struct ifla_vf_tx_rate) },
66 [IFLA_VF_SPOOFCHK] = { .minlen =
sizeof(
struct ifla_vf_spoofchk) },
67 [IFLA_VF_RATE] = { .minlen =
sizeof(
struct ifla_vf_rate) },
68 [IFLA_VF_LINK_STATE] = { .minlen =
sizeof(
struct ifla_vf_link_state) },
69 [IFLA_VF_RSS_QUERY_EN] = { .minlen =
sizeof(
struct ifla_vf_rss_query_en) },
71 [IFLA_VF_TRUST] = { .minlen =
sizeof(
struct ifla_vf_trust) },
72 [IFLA_VF_IB_NODE_GUID] = { .minlen =
sizeof(
struct ifla_vf_guid) },
73 [IFLA_VF_IB_PORT_GUID] = { .minlen =
sizeof(
struct ifla_vf_guid) },
76 static struct nla_policy sriov_stats_policy[IFLA_VF_STATS_MAX+1] = {
78 [IFLA_VF_STATS_TX_PACKETS] = { .type =
NLA_U64 },
79 [IFLA_VF_STATS_RX_BYTES] = { .type =
NLA_U64 },
80 [IFLA_VF_STATS_TX_BYTES] = { .type =
NLA_U64 },
81 [IFLA_VF_STATS_BROADCAST] = { .type =
NLA_U64 },
82 [IFLA_VF_STATS_MULTICAST] = { .type =
NLA_U64 },
90 struct nl_addr *vf_addr;
91 struct rtnl_link_vf *s_list, *d_vf, *s_vf, *next, *dest_h = NULL;
95 if (!(err = rtnl_link_has_vf_list(src)))
101 dest_h = dst->l_vf_list;
102 s_list = src->l_vf_list;
104 nl_list_for_each_entry_safe(s_vf, next, &s_list->vf_list, vf_list) {
108 memcpy(d_vf, s_vf,
sizeof(*s_vf));
110 if (s_vf->ce_mask & SRIOV_ATTR_ADDR) {
114 d_vf->vf_lladdr = vf_addr;
117 if (s_vf->ce_mask & SRIOV_ATTR_VLAN) {
118 src_vlans = s_vf->vf_vlans;
119 src_vlan_info = src_vlans->
vlans;
125 dst_vlan_info = dst_vlans->vlans;
127 memcpy(dst_vlan_info, src_vlan_info,
128 dst_vlans->size *
sizeof(dst_vlan_info));
129 d_vf->vf_vlans = dst_vlans;
132 nl_list_add_head(&d_vf->vf_list, &dest_h->vf_list);
147 vlan_data = vlans->
vlans;
149 while (cur < vlans->size) {
150 nl_dump(p,
"\t vlan %u", vlan_data[cur].vf_vlan);
151 if (vlan_data[cur].vf_vlan_qos)
152 nl_dump(p,
" qos %u", vlan_data[cur].vf_vlan_qos);
153 if (vlan_data[cur].vf_vlan_proto) {
156 rtnl_link_vf_vlanproto2str(prot, buf,
167 static void dump_vf_details(
struct rtnl_link_vf *vf_data,
174 nl_dump(p,
"\tvf %u: ", vf_data->vf_index);
175 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
176 v = vf_data->vf_linkstate;
178 rtnl_link_vf_linkstate2str(v, buf,
sizeof(buf)));
180 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
182 nl_addr2str(vf_data->vf_lladdr, buf,
sizeof(buf)));
186 v = vf_data->vf_spoofchk;
187 nl_dump(p,
"\t spoofchk %s ", v ? SRIOVON : SRIOVOFF);
188 v = vf_data->vf_trust;
189 nl_dump(p,
"trust %s ", v ? SRIOVON : SRIOVOFF);
190 v = vf_data->vf_rss_query_en;
191 nl_dump(p,
"rss_query %s\n", v ? SRIOVON : SRIOVOFF);
196 nl_dump(p,
"\t rate_api old rate %u\n",
199 nl_dump(p,
"\t rate_api new min_rate %u " 200 "max_rate %u\n", vf_rate.min_tx_rate,
201 vf_rate.max_tx_rate);
203 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
204 dump_sriov_vlans(vf_data->vf_vlans, p);
210 void rtnl_link_sriov_dump_details(
struct rtnl_link *link,
215 if (!(err = rtnl_link_has_vf_list(link)))
218 nl_dump(p,
" SRIOV VF List\n");
219 list = link->l_vf_list;
220 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
221 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
222 dump_vf_details(vf_data, p);
234 nl_dump(p,
" VF %" PRIu64
" Stats:\n", vf_data->vf_index);
235 nl_dump_line(p,
"\tRX: %-14s %-10s %-10s %-10s\n",
236 "bytes",
"packets",
"multicast",
"broadcast");
242 "\t%10.2f %3s %10" PRIu64
" %10" PRIu64
" %10" PRIu64
"\n",
248 nl_dump_line(p,
"\tTX: %-14s %-10s\n",
"bytes",
"packets");
253 nl_dump_line(p,
"\t%10.2f %3s %10" PRIu64
"\n", res, unit,
260 void rtnl_link_sriov_dump_stats(
struct rtnl_link *link,
264 list = link->l_vf_list;
265 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
266 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
267 dump_vf_stats(vf_data, p);
275 void rtnl_link_sriov_free_data(
struct rtnl_link *link) {
279 if (!(err = rtnl_link_has_vf_list(link)))
282 list = link->l_vf_list;
283 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
284 nl_list_del(&vf->vf_list);
294 static int rtnl_link_vf_vlan_info(
int len,
struct ifla_vf_vlan_info **vi,
307 vlans->
vlans[cur].
vf_vlan = vi[cur]->vlan ? vi[cur]->vlan : 0;
309 if (vi[cur]->vlan_proto) {
324 struct ifla_vf_vlan vlan;
329 NLA_PUT(msg, IFLA_VF_VLAN,
sizeof(vlan), &vlan);
336 static int sriov_fill_vf_vlan_list(
struct nl_msg *msg,
nl_vf_vlans_t *vlans,
340 struct ifla_vf_vlan_info vlan;
347 while (cur < vlans->size) {
348 vlan.vlan = vlan_info[cur].
vf_vlan;
352 NLA_PUT(msg, IFLA_VF_VLAN_INFO,
sizeof(vlan), &vlan);
364 static int sriov_fill_vfinfo(
struct nl_msg *msg,
366 int err = 0, new_rate = 0;
369 struct ifla_vf_guid vf_node_guid;
370 struct ifla_vf_guid vf_port_guid;
371 struct ifla_vf_link_state vf_link_state;
372 struct ifla_vf_mac vf_mac;
373 struct ifla_vf_rate new_vf_rate;
374 struct ifla_vf_rss_query_en vf_rss_query_en;
375 struct ifla_vf_spoofchk vf_spoofchk;
376 struct ifla_vf_trust vf_trust;
377 struct ifla_vf_tx_rate vf_rate;
381 if (!(vf_data->ce_mask & SRIOV_ATTR_INDEX))
382 return -NLE_MISSING_ATTR;
388 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
389 vf_mac.vf = vf_data->vf_index;
390 memset(vf_mac.mac, 0,
sizeof(vf_mac.mac));
393 NLA_PUT(msg, IFLA_VF_MAC,
sizeof(vf_mac), &vf_mac);
397 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
398 vlan_list = vf_data->vf_vlans;
399 vlan_info = vlan_list->
vlans;
404 if ((vlan_list->
size == 1) && (proto == ETH_P_8021Q))
405 sriov_fill_vf_vlan(msg, vlan_info, vf_data->vf_index);
407 err = sriov_fill_vf_vlan_list(msg, vlan_list,
412 if (vf_data->ce_mask & SRIOV_ATTR_TX_RATE) {
413 vf_rate.vf = vf_data->vf_index;
414 vf_rate.rate = vf_data->vf_rate;
416 NLA_PUT(msg, IFLA_VF_TX_RATE,
sizeof(vf_rate), &vf_rate);
420 new_vf_rate.min_tx_rate = 0;
421 new_vf_rate.max_tx_rate = 0;
422 new_vf_rate.vf = vf_data->vf_index;
423 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
424 new_vf_rate.min_tx_rate = vf_data->vf_min_tx_rate;
427 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
428 new_vf_rate.max_tx_rate = vf_data->vf_max_tx_rate;
432 NLA_PUT(msg, IFLA_VF_RATE,
sizeof(new_vf_rate), &new_vf_rate);
435 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK) {
436 vf_spoofchk.vf = vf_data->vf_index;
437 vf_spoofchk.setting = vf_data->vf_spoofchk;
439 NLA_PUT(msg, IFLA_VF_SPOOFCHK,
sizeof(vf_spoofchk),
444 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
445 vf_link_state.vf = vf_data->vf_index;
446 vf_link_state.link_state = vf_data->vf_linkstate;
448 NLA_PUT(msg, IFLA_VF_LINK_STATE,
sizeof(vf_link_state),
453 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN) {
454 vf_rss_query_en.vf = vf_data->vf_index;
455 vf_rss_query_en.setting = vf_data->vf_rss_query_en;
457 NLA_PUT(msg, IFLA_VF_RSS_QUERY_EN,
sizeof(vf_rss_query_en),
462 if (vf_data->ce_mask & SRIOV_ATTR_TRUST) {
463 vf_trust.vf = vf_data->vf_index;
464 vf_trust.setting = vf_data->vf_trust;
466 NLA_PUT(msg, IFLA_VF_TRUST,
sizeof(vf_trust), &vf_trust);
470 if (vf_data->ce_mask & SRIOV_ATTR_IB_NODE_GUID) {
471 vf_node_guid.vf = vf_data->vf_index;
472 vf_node_guid.guid = vf_data->vf_guid_node;
474 NLA_PUT(msg, IFLA_VF_IB_NODE_GUID,
sizeof(vf_node_guid),
479 if (vf_data->ce_mask & SRIOV_ATTR_IB_PORT_GUID) {
480 vf_port_guid.vf = vf_data->vf_index;
481 vf_port_guid.guid = vf_data->vf_guid_port;
483 NLA_PUT(msg, IFLA_VF_IB_PORT_GUID,
sizeof(vf_port_guid),
494 int rtnl_link_sriov_fill_vflist(
struct nl_msg *msg,
struct rtnl_link *link) {
499 if (!(err = rtnl_link_has_vf_list(link)))
505 list = link->l_vf_list;
506 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
507 if (vf->ce_mask & SRIOV_ATTR_INDEX) {
508 if ((err = sriov_fill_vfinfo(msg, vf)) < 0)
509 goto nla_nest_list_failure;
513 nla_nest_list_failure:
520 int rtnl_link_sriov_parse_vflist(
struct rtnl_link *link,
struct nlattr **tb) {
521 int err, len, list_len, list_rem;
522 struct ifla_vf_mac *vf_lladdr;
523 struct ifla_vf_vlan *vf_vlan;
524 struct ifla_vf_vlan_info *vf_vlan_info[MAX_VLAN_LIST_LEN];
525 struct ifla_vf_tx_rate *vf_tx_rate;
526 struct ifla_vf_spoofchk *vf_spoofchk;
527 struct ifla_vf_link_state *vf_linkstate;
528 struct ifla_vf_rate *vf_rate;
529 struct ifla_vf_rss_query_en *vf_rss_query;
530 struct ifla_vf_trust *vf_trust;
531 struct nlattr *nla, *nla_list, *t[IFLA_VF_MAX+1],
532 *stb[RTNL_LINK_VF_STATS_MAX+1];
536 len =
nla_len(tb[IFLA_VFINFO_LIST]);
538 if (!link->l_vf_list)
540 vf_head = link->l_vf_list;
553 if (t[IFLA_VF_MAC]) {
554 vf_lladdr =
nla_data(t[IFLA_VF_MAC]);
556 vf_data->vf_index = vf_lladdr->vf;
557 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
561 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,
582 vf_data->vf_vlans = vf_vlans;
583 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
584 }
else if (t[IFLA_VF_VLAN]) {
585 vf_vlan =
nla_data(t[IFLA_VF_VLAN]);
596 vf_data->vf_vlans = vf_vlans;
597 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
601 if (t[IFLA_VF_TX_RATE]) {
602 vf_tx_rate =
nla_data(t[IFLA_VF_TX_RATE]);
604 if (vf_tx_rate->rate) {
605 vf_data->vf_rate = vf_tx_rate->rate;
606 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
610 if (t[IFLA_VF_SPOOFCHK]) {
611 vf_spoofchk =
nla_data(t[IFLA_VF_SPOOFCHK]);
613 if (vf_spoofchk->setting != -1) {
614 vf_data->vf_spoofchk = vf_spoofchk->setting ? 1 : 0;
615 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
619 if (t[IFLA_VF_LINK_STATE]) {
620 vf_linkstate =
nla_data(t[IFLA_VF_LINK_STATE]);
622 vf_data->vf_linkstate = vf_linkstate->link_state;
623 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
626 if (t[IFLA_VF_RATE]) {
627 vf_rate =
nla_data(t[IFLA_VF_RATE]);
629 if (vf_rate->max_tx_rate) {
630 vf_data->vf_max_tx_rate = vf_rate->max_tx_rate;
631 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
633 if (vf_rate->min_tx_rate) {
634 vf_data->vf_min_tx_rate = vf_rate->min_tx_rate;
635 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
639 if (t[IFLA_VF_RSS_QUERY_EN]) {
640 vf_rss_query =
nla_data(t[IFLA_VF_RSS_QUERY_EN]);
642 if (vf_rss_query->setting != -1) {
643 vf_data->vf_rss_query_en = vf_rss_query->setting ? 1 : 0;
644 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
648 if (t[IFLA_VF_STATS]) {
655 SET_VF_STAT(link, cur, stb,
657 IFLA_VF_STATS_RX_PACKETS);
658 SET_VF_STAT(link, cur, stb,
660 IFLA_VF_STATS_TX_PACKETS);
661 SET_VF_STAT(link, cur, stb,
663 IFLA_VF_STATS_RX_BYTES);
664 SET_VF_STAT(link, cur, stb,
666 IFLA_VF_STATS_TX_BYTES);
667 SET_VF_STAT(link, cur, stb,
669 IFLA_VF_STATS_BROADCAST);
670 SET_VF_STAT(link, cur, stb,
672 IFLA_VF_STATS_MULTICAST);
674 vf_data->ce_mask |= IFLA_VF_STATS;
677 if (t[IFLA_VF_TRUST]) {
678 vf_trust =
nla_data(t[IFLA_VF_TRUST]);
680 if (vf_trust->setting != -1) {
681 vf_data->vf_trust = vf_trust->setting ? 1 : 0;
682 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
686 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
711 return -NLE_OBJ_NOTFOUND;
713 if (!link->l_vf_list) {
715 if (!link->l_vf_list)
720 vf_head->ce_refcnt++;
722 vf_head = link->l_vf_list;
723 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
724 link->l_vf_list = vf_head;
726 rtnl_link_set_vf_list(link);
745 if (!(vf = calloc(1,
sizeof(*vf))))
748 NL_INIT_LIST_HEAD(&vf->vf_list);
751 NL_DBG(4,
"Allocated new SRIOV VF object %p\n", vf);
764 if (vf_data->ce_refcnt > 0)
765 NL_DBG(1,
"Warning: Freeing SRIOV VF object in use...\n");
767 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
769 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
772 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_data);
792 list = link->l_vf_list;
793 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
794 if (vf->vf_index == vf_num) {
802 NL_DBG(4,
"New reference to SRIOV VF object %p, total %i\n",
803 ret, ret->ce_refcnt);
820 vf_data->ce_refcnt--;
821 NL_DBG(4,
"Returned SRIOV VF object reference %p, %i remaining\n",
822 vf_data, vf_data->ce_refcnt);
824 if (vf_data->ce_refcnt < 0)
827 if (vf_data->ce_refcnt <= 0)
849 return -NLE_OBJ_NOTFOUND;
851 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
852 *addr = vf_data->vf_lladdr;
870 if (vf_data->vf_lladdr)
874 vf_data->vf_lladdr = addr;
875 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
887 vf_data->vf_guid_node = guid;
888 vf_data->ce_mask |= SRIOV_ATTR_IB_NODE_GUID;
900 vf_data->vf_guid_port = guid;
901 vf_data->ce_mask |= SRIOV_ATTR_IB_PORT_GUID;
920 return -NLE_OBJ_NOTFOUND;
922 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
923 *vf_index = vf_data->vf_index;
939 vf_data->vf_index = vf_index;
940 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
958 uint32_t *vf_linkstate)
961 return -NLE_OBJ_NOTFOUND;
963 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE)
964 *vf_linkstate = vf_data->vf_linkstate;
982 uint32_t vf_linkstate) {
983 vf_data->vf_linkstate = vf_linkstate;
984 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
1019 return -NLE_OBJ_NOTFOUND;
1026 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
1027 if (vf_data->vf_max_tx_rate) {
1033 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
1034 if (vf_data->vf_min_tx_rate) {
1040 if ((!
set) && (vf_data->ce_mask & SRIOV_ATTR_TX_RATE)) {
1041 if (vf_data->vf_rate) {
1043 vf_rate->
rate = vf_data->vf_rate;
1082 vf_data->vf_rate = vf_rate->
rate;
1083 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
1086 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
1089 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
1108 uint32_t *vf_rss_query_en)
1111 return -NLE_OBJ_NOTFOUND;
1113 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN)
1114 *vf_rss_query_en = vf_data->vf_rss_query_en;
1129 uint32_t vf_rss_query_en) {
1130 vf_data->vf_rss_query_en = vf_rss_query_en;
1131 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
1149 uint32_t *vf_spoofchk)
1152 return -NLE_OBJ_NOTFOUND;
1154 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK)
1155 *vf_spoofchk = vf_data->vf_spoofchk;
1170 uint32_t vf_spoofchk) {
1171 vf_data->vf_spoofchk = vf_spoofchk;
1172 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
1193 return -NLE_OBJ_NOTFOUND;
1195 if (vf_data->ce_mask & SRIOV_ATTR_STATS)
1196 *vf_stat = vf_data->vf_stats[stat];
1218 return -NLE_OBJ_NOTFOUND;
1220 if (vf_data->ce_mask & SRIOV_ATTR_TRUST)
1221 *vf_trust = vf_data->vf_trust;
1236 vf_data->vf_trust = vf_trust;
1237 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
1262 return -NLE_OBJ_NOTFOUND;
1264 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
1265 vf = vf_data->vf_vlans;
1288 if (!vf_data||!vf_vlans)
1291 vf_data->vf_vlans = vf_vlans;
1292 vf_data->vf_vlans->ce_refcnt++;
1293 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
1314 if (vlan_count > MAX_VLAN_LIST_LEN)
1317 vlans = calloc(1,
sizeof(*vlans));
1321 vlan_info = calloc(vlan_count+1,
sizeof(*vlan_info));
1327 NL_DBG(4,
"Allocated new SRIOV VF VLANs object %p\n", vlans);
1330 vlans->
size = vlan_count;
1331 vlans->
vlans = vlan_info;
1346 NL_DBG(1,
"Warning: Freeing SRIOV VF VLANs object in use...\n");
1348 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_vlans);
1349 free(vf_vlans->
vlans);
1364 NL_DBG(4,
"Returned SRIOV VF VLANs object reference %p, %i remaining\n",
1383 static const struct trans_tbl vf_link_states[] = {
1384 __ADD(IFLA_VF_LINK_STATE_AUTO, autodetect),
1385 __ADD(IFLA_VF_LINK_STATE_ENABLE, up),
1386 __ADD(IFLA_VF_LINK_STATE_DISABLE, down),
1389 char *rtnl_link_vf_linkstate2str(uint32_t ls,
char *buf,
size_t len)
1391 return __type2str(ls, buf, len, vf_link_states,
1392 ARRAY_SIZE(vf_link_states));
1395 int rtnl_link_vf_str2linkstate(
const char *name)
1397 return __str2type(name, vf_link_states, ARRAY_SIZE(vf_link_states));
1400 static const struct trans_tbl vf_vlan_proto[] = {
1401 __ADD(ETH_P_8021Q, 8021Q),
1402 __ADD(ETH_P_8021AD, 8021AD),
1405 char *rtnl_link_vf_vlanproto2str(uint16_t proto,
char *buf,
size_t len)
1407 return __type2str(proto, buf, len, vf_vlan_proto,
1408 ARRAY_SIZE(vf_vlan_proto));
1411 int rtnl_link_vf_str2vlanproto(
const char *name)
1413 return __str2type(name, vf_vlan_proto, ARRAY_SIZE(vf_vlan_proto));
1424 int rtnl_link_vf_str2guid(uint64_t *guid,
const char *guid_s) {
1425 unsigned long int tmp;
1429 if (strlen(guid_s) != RTNL_VF_GUID_STR_LEN)
1432 for (i = 0; i < 7; i++) {
1433 if (guid_s[2 + i * 3] !=
':')
1438 for (i = 0; i < 8; i++) {
1439 tmp = strtoul(guid_s + i * 3, &endptr, 16);
1440 if (endptr != guid_s + i * 3 + 2)
1446 *guid |= tmp << (56 - 8 * i);
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
int rtnl_link_vf_get_trust(struct rtnl_link_vf *vf_data, uint32_t *vf_trust)
Get trust setting of SRIOV Virtual Function.
SRIOV VF VLANs information.
int nla_ok(const struct nlattr *nla, int remaining)
Check if the attribute header and payload can be accessed safely.
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.
Attribute validation policy.
struct nl_addr * nl_addr_build(int family, const void *buf, size_t size)
Allocate abstract address based on a binary address.
struct rtnl_link_vf * rtnl_link_vf_alloc(void)
Allocate a new SRIOV VF object.
void rtnl_link_vf_put(struct rtnl_link_vf *vf_data)
Return SRIOV VF object to the owning link object.
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_set_spoofchk(struct rtnl_link_vf *vf_data, uint32_t vf_spoofchk)
Set spoof checking value of SRIOV Virtual Function Object.
struct nl_addr * nl_addr_get(struct nl_addr *addr)
Increase the reference counter of an abstract address.
void nl_addr_set_family(struct nl_addr *addr, int family)
Set address family.
void rtnl_link_vf_set_linkstate(struct rtnl_link_vf *vf_data, uint32_t vf_linkstate)
Set link state 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.
void rtnl_link_vf_vlan_put(nl_vf_vlans_t *vf_vlans)
Return SRIOV VF VLANs object to the owning SRIOV VF object.
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
struct nlattr * nla_next(const struct nlattr *nla, int *remaining)
Return next attribute in a stream of attributes.
nl_vf_vlan_info_t * vlans
int rtnl_link_vf_get_addr(struct rtnl_link_vf *vf_data, struct nl_addr **addr)
Get link layer address of SRIOV Virtual Function.
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
#define NLA_PUT(msg, attrtype, attrlen, data)
Add unspecific attribute to netlink message.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, struct nla_policy *policy)
Create attribute index based on nested attribute.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
int nla_len(const struct nlattr *nla)
Return length of the payload .
int rtnl_link_vf_get_index(struct rtnl_link_vf *vf_data, uint32_t *vf_index)
Get index of SRIOV Virtual Function.
int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len, struct nla_policy *policy)
Create attribute index based on a stream of attributes.
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.
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_addr(struct rtnl_link_vf *vf_data, struct nl_addr *addr)
Set link layer address of SRIOV Virtual Function object.
uint16_t minlen
Minimal length of payload required.
#define nla_for_each_nested(pos, nla, rem)
Iterate over a stream of nested attributes.
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.
int rtnl_link_vf_add(struct rtnl_link *link, struct rtnl_link_vf *vf_data)
Add a SRIOV VF object to a link object.
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_rate(struct rtnl_link_vf *vf_data, struct nl_vf_rate *vf_rate)
Get TX Rate Limit of SRIOV Virtual Function.
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 nl_addr_put(struct nl_addr *addr)
Decrease the reference counter of an abstract address.
uint16_t type
Type of attribute or NLA_UNSPEC.
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_set_rate(struct rtnl_link_vf *vf_data, struct nl_vf_rate *vf_rate)
Set TX Rate Limit of SRIOV Virtual Function 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 nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
void rtnl_link_vf_free(struct rtnl_link_vf *vf_data)
Free SRIOV VF object.
VF Rate information structure.
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.
unsigned int nl_addr_get_len(const struct nl_addr *addr)
Get length of binary address of abstract address 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.
void * nl_addr_get_binary_addr(const struct nl_addr *addr)
Get binary address of abstract address object.
void rtnl_link_vf_vlan_free(nl_vf_vlans_t *vf_vlans)
Free an allocated SRIOV VF VLANs object.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
int rtnl_link_vf_get_linkstate(struct rtnl_link_vf *vf_data, uint32_t *vf_linkstate)
Get link state of SRIOV Virtual Function.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.