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) {
116 d_vf->vf_lladdr = vf_addr;
119 if (s_vf->ce_mask & SRIOV_ATTR_VLAN) {
120 src_vlans = s_vf->vf_vlans;
121 src_vlan_info = src_vlans->
vlans;
129 dst_vlan_info = dst_vlans->vlans;
131 memcpy(dst_vlan_info, src_vlan_info,
132 dst_vlans->size *
sizeof(dst_vlan_info));
133 d_vf->vf_vlans = dst_vlans;
136 nl_list_add_head(&d_vf->vf_list, &dest_h->vf_list);
151 vlan_data = vlans->
vlans;
153 while (cur < vlans->size) {
154 nl_dump(p,
"\t vlan %u", vlan_data[cur].vf_vlan);
155 if (vlan_data[cur].vf_vlan_qos)
156 nl_dump(p,
" qos %u", vlan_data[cur].vf_vlan_qos);
157 if (vlan_data[cur].vf_vlan_proto) {
160 rtnl_link_vf_vlanproto2str(prot, buf,
171 static void dump_vf_details(
struct rtnl_link_vf *vf_data,
178 nl_dump(p,
"\tvf %u: ", vf_data->vf_index);
179 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
180 v = vf_data->vf_linkstate;
182 rtnl_link_vf_linkstate2str(v, buf,
sizeof(buf)));
184 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
186 nl_addr2str(vf_data->vf_lladdr, buf,
sizeof(buf)));
190 v = vf_data->vf_spoofchk;
191 nl_dump(p,
"\t spoofchk %s ", v ? SRIOVON : SRIOVOFF);
192 v = vf_data->vf_trust;
193 nl_dump(p,
"trust %s ", v ? SRIOVON : SRIOVOFF);
194 v = vf_data->vf_rss_query_en;
195 nl_dump(p,
"rss_query %s\n", v ? SRIOVON : SRIOVOFF);
200 nl_dump(p,
"\t rate_api old rate %u\n",
203 nl_dump(p,
"\t rate_api new min_rate %u " 204 "max_rate %u\n", vf_rate.min_tx_rate,
205 vf_rate.max_tx_rate);
207 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
208 dump_sriov_vlans(vf_data->vf_vlans, p);
214 void rtnl_link_sriov_dump_details(
struct rtnl_link *link,
219 if (!(err = rtnl_link_has_vf_list(link)))
222 nl_dump(p,
" SRIOV VF List\n");
223 list = link->l_vf_list;
224 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
225 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
226 dump_vf_details(vf_data, p);
238 nl_dump(p,
" VF %" PRIu64
" Stats:\n", vf_data->vf_index);
239 nl_dump_line(p,
"\tRX: %-14s %-10s %-10s %-10s\n",
240 "bytes",
"packets",
"multicast",
"broadcast");
246 "\t%10.2f %3s %10" PRIu64
" %10" PRIu64
" %10" PRIu64
"\n",
252 nl_dump_line(p,
"\tTX: %-14s %-10s\n",
"bytes",
"packets");
257 nl_dump_line(p,
"\t%10.2f %3s %10" PRIu64
"\n", res, unit,
264 void rtnl_link_sriov_dump_stats(
struct rtnl_link *link,
268 list = link->l_vf_list;
269 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
270 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
271 dump_vf_stats(vf_data, p);
279 void rtnl_link_sriov_free_data(
struct rtnl_link *link) {
283 if (!(err = rtnl_link_has_vf_list(link)))
286 list = link->l_vf_list;
287 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
288 nl_list_del(&vf->vf_list);
298 static int rtnl_link_vf_vlan_info(
int len,
struct ifla_vf_vlan_info **vi,
311 vlans->
vlans[cur].
vf_vlan = vi[cur]->vlan ? vi[cur]->vlan : 0;
313 if (vi[cur]->vlan_proto) {
328 struct ifla_vf_vlan vlan;
333 NLA_PUT(msg, IFLA_VF_VLAN,
sizeof(vlan), &vlan);
340 static int sriov_fill_vf_vlan_list(
struct nl_msg *msg,
nl_vf_vlans_t *vlans,
344 struct ifla_vf_vlan_info vlan;
351 while (cur < vlans->size) {
352 vlan.vlan = vlan_info[cur].
vf_vlan;
356 NLA_PUT(msg, IFLA_VF_VLAN_INFO,
sizeof(vlan), &vlan);
368 static int sriov_fill_vfinfo(
struct nl_msg *msg,
370 int err = 0, new_rate = 0;
373 struct ifla_vf_guid vf_node_guid;
374 struct ifla_vf_guid vf_port_guid;
375 struct ifla_vf_link_state vf_link_state;
376 struct ifla_vf_mac vf_mac;
377 struct ifla_vf_rate new_vf_rate;
378 struct ifla_vf_rss_query_en vf_rss_query_en;
379 struct ifla_vf_spoofchk vf_spoofchk;
380 struct ifla_vf_trust vf_trust;
381 struct ifla_vf_tx_rate vf_rate;
385 if (!(vf_data->ce_mask & SRIOV_ATTR_INDEX))
386 return -NLE_MISSING_ATTR;
392 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
393 vf_mac.vf = vf_data->vf_index;
394 memset(vf_mac.mac, 0,
sizeof(vf_mac.mac));
397 NLA_PUT(msg, IFLA_VF_MAC,
sizeof(vf_mac), &vf_mac);
401 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
402 vlan_list = vf_data->vf_vlans;
403 vlan_info = vlan_list->
vlans;
408 if ((vlan_list->
size == 1) && (proto == ETH_P_8021Q))
409 sriov_fill_vf_vlan(msg, vlan_info, vf_data->vf_index);
411 err = sriov_fill_vf_vlan_list(msg, vlan_list,
416 if (vf_data->ce_mask & SRIOV_ATTR_TX_RATE) {
417 vf_rate.vf = vf_data->vf_index;
418 vf_rate.rate = vf_data->vf_rate;
420 NLA_PUT(msg, IFLA_VF_TX_RATE,
sizeof(vf_rate), &vf_rate);
424 new_vf_rate.min_tx_rate = 0;
425 new_vf_rate.max_tx_rate = 0;
426 new_vf_rate.vf = vf_data->vf_index;
427 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
428 new_vf_rate.min_tx_rate = vf_data->vf_min_tx_rate;
431 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
432 new_vf_rate.max_tx_rate = vf_data->vf_max_tx_rate;
436 NLA_PUT(msg, IFLA_VF_RATE,
sizeof(new_vf_rate), &new_vf_rate);
439 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK) {
440 vf_spoofchk.vf = vf_data->vf_index;
441 vf_spoofchk.setting = vf_data->vf_spoofchk;
443 NLA_PUT(msg, IFLA_VF_SPOOFCHK,
sizeof(vf_spoofchk),
448 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
449 vf_link_state.vf = vf_data->vf_index;
450 vf_link_state.link_state = vf_data->vf_linkstate;
452 NLA_PUT(msg, IFLA_VF_LINK_STATE,
sizeof(vf_link_state),
457 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN) {
458 vf_rss_query_en.vf = vf_data->vf_index;
459 vf_rss_query_en.setting = vf_data->vf_rss_query_en;
461 NLA_PUT(msg, IFLA_VF_RSS_QUERY_EN,
sizeof(vf_rss_query_en),
466 if (vf_data->ce_mask & SRIOV_ATTR_TRUST) {
467 vf_trust.vf = vf_data->vf_index;
468 vf_trust.setting = vf_data->vf_trust;
470 NLA_PUT(msg, IFLA_VF_TRUST,
sizeof(vf_trust), &vf_trust);
474 if (vf_data->ce_mask & SRIOV_ATTR_IB_NODE_GUID) {
475 vf_node_guid.vf = vf_data->vf_index;
476 vf_node_guid.guid = vf_data->vf_guid_node;
478 NLA_PUT(msg, IFLA_VF_IB_NODE_GUID,
sizeof(vf_node_guid),
483 if (vf_data->ce_mask & SRIOV_ATTR_IB_PORT_GUID) {
484 vf_port_guid.vf = vf_data->vf_index;
485 vf_port_guid.guid = vf_data->vf_guid_port;
487 NLA_PUT(msg, IFLA_VF_IB_PORT_GUID,
sizeof(vf_port_guid),
498 int rtnl_link_sriov_fill_vflist(
struct nl_msg *msg,
struct rtnl_link *link) {
503 if (!(err = rtnl_link_has_vf_list(link)))
509 list = link->l_vf_list;
510 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
511 if (vf->ce_mask & SRIOV_ATTR_INDEX) {
512 if ((err = sriov_fill_vfinfo(msg, vf)) < 0)
513 goto nla_nest_list_failure;
517 nla_nest_list_failure:
524 int rtnl_link_sriov_parse_vflist(
struct rtnl_link *link,
struct nlattr **tb) {
525 int err, len, list_len, list_rem;
526 struct ifla_vf_mac *vf_lladdr;
527 struct ifla_vf_vlan *vf_vlan;
528 struct ifla_vf_vlan_info *vf_vlan_info[MAX_VLAN_LIST_LEN];
529 struct ifla_vf_tx_rate *vf_tx_rate;
530 struct ifla_vf_spoofchk *vf_spoofchk;
531 struct ifla_vf_link_state *vf_linkstate;
532 struct ifla_vf_rate *vf_rate;
533 struct ifla_vf_rss_query_en *vf_rss_query;
534 struct ifla_vf_trust *vf_trust;
535 struct nlattr *nla, *nla_list, *t[IFLA_VF_MAX+1],
536 *stb[RTNL_LINK_VF_STATS_MAX+1];
540 len =
nla_len(tb[IFLA_VFINFO_LIST]);
542 if (!link->l_vf_list)
544 vf_head = link->l_vf_list;
557 if (t[IFLA_VF_MAC]) {
558 vf_lladdr =
nla_data(t[IFLA_VF_MAC]);
560 vf_data->vf_index = vf_lladdr->vf;
561 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
565 if (vf_data->vf_lladdr == NULL) {
570 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
573 if (t[IFLA_VF_VLAN_LIST]) {
577 if (list_len >= MAX_VLAN_LIST_LEN)
579 vf_vlan_info[list_len] =
nla_data(nla_list);
583 err = rtnl_link_vf_vlan_info(list_len, vf_vlan_info,
590 vf_data->vf_vlans = vf_vlans;
591 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
592 }
else if (t[IFLA_VF_VLAN]) {
593 vf_vlan =
nla_data(t[IFLA_VF_VLAN]);
606 vf_data->vf_vlans = vf_vlans;
607 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
611 if (t[IFLA_VF_TX_RATE]) {
612 vf_tx_rate =
nla_data(t[IFLA_VF_TX_RATE]);
614 if (vf_tx_rate->rate) {
615 vf_data->vf_rate = vf_tx_rate->rate;
616 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
620 if (t[IFLA_VF_SPOOFCHK]) {
621 vf_spoofchk =
nla_data(t[IFLA_VF_SPOOFCHK]);
623 if (vf_spoofchk->setting != -1) {
624 vf_data->vf_spoofchk = vf_spoofchk->setting ? 1 : 0;
625 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
629 if (t[IFLA_VF_LINK_STATE]) {
630 vf_linkstate =
nla_data(t[IFLA_VF_LINK_STATE]);
632 vf_data->vf_linkstate = vf_linkstate->link_state;
633 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
636 if (t[IFLA_VF_RATE]) {
637 vf_rate =
nla_data(t[IFLA_VF_RATE]);
639 if (vf_rate->max_tx_rate) {
640 vf_data->vf_max_tx_rate = vf_rate->max_tx_rate;
641 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
643 if (vf_rate->min_tx_rate) {
644 vf_data->vf_min_tx_rate = vf_rate->min_tx_rate;
645 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
649 if (t[IFLA_VF_RSS_QUERY_EN]) {
650 vf_rss_query =
nla_data(t[IFLA_VF_RSS_QUERY_EN]);
652 if (vf_rss_query->setting != -1) {
653 vf_data->vf_rss_query_en = vf_rss_query->setting ? 1 : 0;
654 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
658 if (t[IFLA_VF_STATS]) {
667 SET_VF_STAT(link, cur, stb,
669 IFLA_VF_STATS_RX_PACKETS);
670 SET_VF_STAT(link, cur, stb,
672 IFLA_VF_STATS_TX_PACKETS);
673 SET_VF_STAT(link, cur, stb,
675 IFLA_VF_STATS_RX_BYTES);
676 SET_VF_STAT(link, cur, stb,
678 IFLA_VF_STATS_TX_BYTES);
679 SET_VF_STAT(link, cur, stb,
681 IFLA_VF_STATS_BROADCAST);
682 SET_VF_STAT(link, cur, stb,
684 IFLA_VF_STATS_MULTICAST);
686 vf_data->ce_mask |= IFLA_VF_STATS;
689 if (t[IFLA_VF_TRUST]) {
690 vf_trust =
nla_data(t[IFLA_VF_TRUST]);
692 if (vf_trust->setting != -1) {
693 vf_data->vf_trust = vf_trust->setting ? 1 : 0;
694 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
698 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
723 return -NLE_OBJ_NOTFOUND;
725 if (!link->l_vf_list) {
727 if (!link->l_vf_list)
732 vf_head->ce_refcnt++;
734 vf_head = link->l_vf_list;
735 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
736 link->l_vf_list = vf_head;
738 rtnl_link_set_vf_list(link);
757 if (!(vf = calloc(1,
sizeof(*vf))))
760 NL_INIT_LIST_HEAD(&vf->vf_list);
763 NL_DBG(4,
"Allocated new SRIOV VF object %p\n", vf);
776 if (vf_data->ce_refcnt > 0)
777 NL_DBG(1,
"Warning: Freeing SRIOV VF object in use...\n");
779 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
781 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
784 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_data);
804 list = link->l_vf_list;
805 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
806 if (vf->vf_index == vf_num) {
814 NL_DBG(4,
"New reference to SRIOV VF object %p, total %i\n",
815 ret, ret->ce_refcnt);
832 vf_data->ce_refcnt--;
833 NL_DBG(4,
"Returned SRIOV VF object reference %p, %i remaining\n",
834 vf_data, vf_data->ce_refcnt);
836 if (vf_data->ce_refcnt < 0)
839 if (vf_data->ce_refcnt <= 0)
861 return -NLE_OBJ_NOTFOUND;
863 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
864 *addr = vf_data->vf_lladdr;
882 if (vf_data->vf_lladdr)
886 vf_data->vf_lladdr = addr;
887 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
899 vf_data->vf_guid_node = guid;
900 vf_data->ce_mask |= SRIOV_ATTR_IB_NODE_GUID;
912 vf_data->vf_guid_port = guid;
913 vf_data->ce_mask |= SRIOV_ATTR_IB_PORT_GUID;
932 return -NLE_OBJ_NOTFOUND;
934 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
935 *vf_index = vf_data->vf_index;
951 vf_data->vf_index = vf_index;
952 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
970 uint32_t *vf_linkstate)
973 return -NLE_OBJ_NOTFOUND;
975 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE)
976 *vf_linkstate = vf_data->vf_linkstate;
994 uint32_t vf_linkstate) {
995 vf_data->vf_linkstate = vf_linkstate;
996 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
1031 return -NLE_OBJ_NOTFOUND;
1038 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
1039 if (vf_data->vf_max_tx_rate) {
1045 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
1046 if (vf_data->vf_min_tx_rate) {
1052 if ((!set) && (vf_data->ce_mask & SRIOV_ATTR_TX_RATE)) {
1053 if (vf_data->vf_rate) {
1055 vf_rate->
rate = vf_data->vf_rate;
1094 vf_data->vf_rate = vf_rate->
rate;
1095 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
1098 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
1101 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
1120 uint32_t *vf_rss_query_en)
1123 return -NLE_OBJ_NOTFOUND;
1125 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN)
1126 *vf_rss_query_en = vf_data->vf_rss_query_en;
1141 uint32_t vf_rss_query_en) {
1142 vf_data->vf_rss_query_en = vf_rss_query_en;
1143 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
1161 uint32_t *vf_spoofchk)
1164 return -NLE_OBJ_NOTFOUND;
1166 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK)
1167 *vf_spoofchk = vf_data->vf_spoofchk;
1182 uint32_t vf_spoofchk) {
1183 vf_data->vf_spoofchk = vf_spoofchk;
1184 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
1205 return -NLE_OBJ_NOTFOUND;
1207 if (vf_data->ce_mask & SRIOV_ATTR_STATS)
1208 *vf_stat = vf_data->vf_stats[stat];
1230 return -NLE_OBJ_NOTFOUND;
1232 if (vf_data->ce_mask & SRIOV_ATTR_TRUST)
1233 *vf_trust = vf_data->vf_trust;
1248 vf_data->vf_trust = vf_trust;
1249 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
1274 return -NLE_OBJ_NOTFOUND;
1276 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
1277 vf = vf_data->vf_vlans;
1300 if (!vf_data||!vf_vlans)
1303 vf_data->vf_vlans = vf_vlans;
1304 vf_data->vf_vlans->ce_refcnt++;
1305 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
1326 if (vlan_count > MAX_VLAN_LIST_LEN)
1329 vlans = calloc(1,
sizeof(*vlans));
1333 vlan_info = calloc(vlan_count+1,
sizeof(*vlan_info));
1339 NL_DBG(4,
"Allocated new SRIOV VF VLANs object %p\n", vlans);
1342 vlans->
size = vlan_count;
1343 vlans->
vlans = vlan_info;
1358 NL_DBG(1,
"Warning: Freeing SRIOV VF VLANs object in use...\n");
1360 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_vlans);
1361 free(vf_vlans->
vlans);
1376 NL_DBG(4,
"Returned SRIOV VF VLANs object reference %p, %i remaining\n",
1395 static const struct trans_tbl vf_link_states[] = {
1396 __ADD(IFLA_VF_LINK_STATE_AUTO, autodetect),
1397 __ADD(IFLA_VF_LINK_STATE_ENABLE, up),
1398 __ADD(IFLA_VF_LINK_STATE_DISABLE, down),
1401 char *rtnl_link_vf_linkstate2str(uint32_t ls,
char *buf,
size_t len)
1403 return __type2str(ls, buf, len, vf_link_states,
1404 ARRAY_SIZE(vf_link_states));
1407 int rtnl_link_vf_str2linkstate(
const char *name)
1409 return __str2type(name, vf_link_states, ARRAY_SIZE(vf_link_states));
1412 static const struct trans_tbl vf_vlan_proto[] = {
1413 __ADD(ETH_P_8021Q, 8021Q),
1414 __ADD(ETH_P_8021AD, 8021AD),
1417 char *rtnl_link_vf_vlanproto2str(uint16_t proto,
char *buf,
size_t len)
1419 return __type2str(proto, buf, len, vf_vlan_proto,
1420 ARRAY_SIZE(vf_vlan_proto));
1423 int rtnl_link_vf_str2vlanproto(
const char *name)
1425 return __str2type(name, vf_vlan_proto, ARRAY_SIZE(vf_vlan_proto));
1436 int rtnl_link_vf_str2guid(uint64_t *guid,
const char *guid_s) {
1437 unsigned long int tmp;
1441 if (strlen(guid_s) != RTNL_VF_GUID_STR_LEN)
1444 for (i = 0; i < 7; i++) {
1445 if (guid_s[2 + i * 3] !=
':')
1450 for (i = 0; i < 8; i++) {
1451 tmp = strtoul(guid_s + i * 3, &endptr, 16);
1452 if (endptr != guid_s + i * 3 + 2)
1458 *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 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 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.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, const struct nla_policy *policy)
Create attribute index based on nested attribute.
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.
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.
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.