22#include "nl-default.h"
24#include <linux/if_ether.h>
25#include <linux/if_link.h>
27#include <netlink/netlink.h>
28#include <netlink/route/link.h>
29#include <netlink/route/link/sriov.h>
32#include "link-sriov.h"
41 uint64_t vf_guid_node;
42 uint64_t vf_guid_port;
43 uint32_t vf_linkstate;
44 struct nl_addr *vf_lladdr;
45 uint32_t vf_max_tx_rate;
46 uint32_t vf_min_tx_rate;
48 uint32_t vf_rss_query_en;
50 uint64_t vf_stats[RTNL_LINK_VF_STATS_MAX + 1];
58#define SET_VF_STAT(link, vf_num, stb, stat, attr) \
59 vf_data->vf_stats[stat] = nla_get_u64(stb[attr])
62#define SRIOV_ATTR_INDEX (1 << 0)
63#define SRIOV_ATTR_ADDR (1 << 1)
64#define SRIOV_ATTR_VLAN (1 << 2)
65#define SRIOV_ATTR_TX_RATE (1 << 3)
66#define SRIOV_ATTR_SPOOFCHK (1 << 4)
67#define SRIOV_ATTR_RATE_MAX (1 << 5)
68#define SRIOV_ATTR_RATE_MIN (1 << 6)
69#define SRIOV_ATTR_LINK_STATE (1 << 7)
70#define SRIOV_ATTR_RSS_QUERY_EN (1 << 8)
71#define SRIOV_ATTR_STATS (1 << 9)
72#define SRIOV_ATTR_TRUST (1 << 10)
73#define SRIOV_ATTR_IB_NODE_GUID (1 << 11)
74#define SRIOV_ATTR_IB_PORT_GUID (1 << 12)
78 [IFLA_VF_VLAN] = { .minlen =
sizeof(
struct ifla_vf_vlan) },
80 [IFLA_VF_TX_RATE] = { .minlen =
sizeof(
struct ifla_vf_tx_rate) },
81 [IFLA_VF_SPOOFCHK] = { .minlen =
sizeof(
struct ifla_vf_spoofchk) },
82 [IFLA_VF_RATE] = { .minlen =
sizeof(
struct ifla_vf_rate) },
83 [IFLA_VF_LINK_STATE] = { .minlen =
sizeof(
struct ifla_vf_link_state) },
84 [IFLA_VF_RSS_QUERY_EN] = { .minlen =
sizeof(
struct ifla_vf_rss_query_en) },
86 [IFLA_VF_TRUST] = { .minlen =
sizeof(
struct ifla_vf_trust) },
87 [IFLA_VF_IB_NODE_GUID] = { .minlen =
sizeof(
struct ifla_vf_guid) },
88 [IFLA_VF_IB_PORT_GUID] = { .minlen =
sizeof(
struct ifla_vf_guid) },
105 struct nl_addr *vf_addr;
106 struct rtnl_link_vf *s_list, *d_vf, *s_vf, *next, *dest_h = NULL;
110 if (!rtnl_link_has_vf_list(src))
116 dest_h = dst->l_vf_list;
117 s_list = src->l_vf_list;
119 nl_list_for_each_entry_safe(s_vf, next, &s_list->vf_list, vf_list) {
123 memcpy(d_vf, s_vf,
sizeof(*s_vf));
125 if (s_vf->ce_mask & SRIOV_ATTR_ADDR) {
131 d_vf->vf_lladdr = vf_addr;
134 if (s_vf->ce_mask & SRIOV_ATTR_VLAN) {
135 src_vlans = s_vf->vf_vlans;
136 src_vlan_info = src_vlans->
vlans;
144 dst_vlan_info = dst_vlans->vlans;
146 memcpy(dst_vlan_info, src_vlan_info,
147 dst_vlans->size *
sizeof(*dst_vlan_info));
148 d_vf->vf_vlans = dst_vlans;
151 nl_list_add_head(&d_vf->vf_list, &dest_h->vf_list);
166 vlan_data = vlans->
vlans;
168 while (cur < vlans->size) {
169 nl_dump(p,
"\t vlan %u", vlan_data[cur].vf_vlan);
170 if (vlan_data[cur].vf_vlan_qos)
171 nl_dump(p,
" qos %u", vlan_data[cur].vf_vlan_qos);
172 if (vlan_data[cur].vf_vlan_proto) {
175 rtnl_link_vf_vlanproto2str(prot, buf,
186static void dump_vf_details(
struct rtnl_link_vf *vf_data,
193 nl_dump(p,
"\tvf %u: ", vf_data->vf_index);
194 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
195 v = vf_data->vf_linkstate;
197 rtnl_link_vf_linkstate2str(v, buf,
sizeof(buf)));
199 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
201 nl_addr2str(vf_data->vf_lladdr, buf,
sizeof(buf)));
205 v = vf_data->vf_spoofchk;
206 nl_dump(p,
"\t spoofchk %s ", v ? SRIOVON : SRIOVOFF);
207 v = vf_data->vf_trust;
208 nl_dump(p,
"trust %s ", v ? SRIOVON : SRIOVOFF);
209 v = vf_data->vf_rss_query_en;
210 nl_dump(p,
"rss_query %s\n", v ? SRIOVON : SRIOVOFF);
215 nl_dump(p,
"\t rate_api old rate %u\n",
218 nl_dump(p,
"\t rate_api new min_rate %u "
219 "max_rate %u\n", vf_rate.min_tx_rate,
220 vf_rate.max_tx_rate);
222 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
223 dump_sriov_vlans(vf_data->vf_vlans, p);
229void rtnl_link_sriov_dump_details(
struct rtnl_link *link,
233 if (!rtnl_link_has_vf_list(link))
236 nl_dump(p,
" SRIOV VF List\n");
237 list = link->l_vf_list;
238 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
239 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
240 dump_vf_details(vf_data, p);
252 nl_dump(p,
" VF %u Stats:\n", vf_data->vf_index);
253 nl_dump_line(p,
"\tRX: %-14s %-10s %-10s %-10s\n",
254 "bytes",
"packets",
"multicast",
"broadcast");
260 "\t%10.2f %3s %10" PRIu64
" %10" PRIu64
" %10" PRIu64
"\n",
266 nl_dump_line(p,
"\tTX: %-14s %-10s\n",
"bytes",
"packets");
271 nl_dump_line(p,
"\t%10.2f %3s %10" PRIu64
"\n", res, unit,
278void rtnl_link_sriov_dump_stats(
struct rtnl_link *link,
282 list = link->l_vf_list;
283 nl_list_for_each_entry_safe(vf_data, next, &list->vf_list, vf_list) {
284 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
285 dump_vf_stats(vf_data, p);
293void rtnl_link_sriov_free_data(
struct rtnl_link *link) {
296 if (!rtnl_link_has_vf_list(link))
299 list = link->l_vf_list;
300 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
301 nl_list_del(&vf->vf_list);
311static int rtnl_link_vf_vlan_info(
int len,
struct ifla_vf_vlan_info **vi,
324 vlans->
vlans[cur].
vf_vlan = vi[cur]->vlan ? vi[cur]->vlan : 0;
326 if (vi[cur]->vlan_proto) {
341 struct ifla_vf_vlan vlan;
346 NLA_PUT(msg, IFLA_VF_VLAN,
sizeof(vlan), &vlan);
353static int sriov_fill_vf_vlan_list(
struct nl_msg *msg,
nl_vf_vlans_t *vlans,
357 struct ifla_vf_vlan_info vlan;
364 while (cur < vlans->size) {
365 vlan.vlan = vlan_info[cur].
vf_vlan;
369 NLA_PUT(msg, IFLA_VF_VLAN_INFO,
sizeof(vlan), &vlan);
381static int sriov_fill_vfinfo(
struct nl_msg *msg,
383 int err = 0, new_rate = 0;
386 struct ifla_vf_guid vf_node_guid;
387 struct ifla_vf_guid vf_port_guid;
388 struct ifla_vf_link_state vf_link_state;
389 struct ifla_vf_mac vf_mac;
390 struct ifla_vf_rate new_vf_rate;
391 struct ifla_vf_rss_query_en vf_rss_query_en;
392 struct ifla_vf_spoofchk vf_spoofchk;
393 struct ifla_vf_trust vf_trust;
394 struct ifla_vf_tx_rate vf_rate;
398 if (!(vf_data->ce_mask & SRIOV_ATTR_INDEX))
399 return -NLE_MISSING_ATTR;
405 if (vf_data->ce_mask & SRIOV_ATTR_ADDR) {
406 vf_mac.vf = vf_data->vf_index;
407 memset(vf_mac.mac, 0,
sizeof(vf_mac.mac));
410 NLA_PUT(msg, IFLA_VF_MAC,
sizeof(vf_mac), &vf_mac);
414 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
415 vlan_list = vf_data->vf_vlans;
416 vlan_info = vlan_list->
vlans;
421 if ((vlan_list->
size == 1) && (proto == ETH_P_8021Q))
422 sriov_fill_vf_vlan(msg, vlan_info, vf_data->vf_index);
424 err = sriov_fill_vf_vlan_list(msg, vlan_list,
429 if (vf_data->ce_mask & SRIOV_ATTR_TX_RATE) {
430 vf_rate.vf = vf_data->vf_index;
431 vf_rate.rate = vf_data->vf_rate;
433 NLA_PUT(msg, IFLA_VF_TX_RATE,
sizeof(vf_rate), &vf_rate);
437 new_vf_rate.min_tx_rate = 0;
438 new_vf_rate.max_tx_rate = 0;
439 new_vf_rate.vf = vf_data->vf_index;
440 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
441 new_vf_rate.min_tx_rate = vf_data->vf_min_tx_rate;
444 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
445 new_vf_rate.max_tx_rate = vf_data->vf_max_tx_rate;
449 NLA_PUT(msg, IFLA_VF_RATE,
sizeof(new_vf_rate), &new_vf_rate);
452 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK) {
453 vf_spoofchk.vf = vf_data->vf_index;
454 vf_spoofchk.setting = vf_data->vf_spoofchk;
456 NLA_PUT(msg, IFLA_VF_SPOOFCHK,
sizeof(vf_spoofchk),
461 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE) {
462 vf_link_state.vf = vf_data->vf_index;
463 vf_link_state.link_state = vf_data->vf_linkstate;
465 NLA_PUT(msg, IFLA_VF_LINK_STATE,
sizeof(vf_link_state),
470 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN) {
471 vf_rss_query_en.vf = vf_data->vf_index;
472 vf_rss_query_en.setting = vf_data->vf_rss_query_en;
474 NLA_PUT(msg, IFLA_VF_RSS_QUERY_EN,
sizeof(vf_rss_query_en),
479 if (vf_data->ce_mask & SRIOV_ATTR_TRUST) {
480 vf_trust.vf = vf_data->vf_index;
481 vf_trust.setting = vf_data->vf_trust;
483 NLA_PUT(msg, IFLA_VF_TRUST,
sizeof(vf_trust), &vf_trust);
487 if (vf_data->ce_mask & SRIOV_ATTR_IB_NODE_GUID) {
488 vf_node_guid.vf = vf_data->vf_index;
489 vf_node_guid.guid = vf_data->vf_guid_node;
491 NLA_PUT(msg, IFLA_VF_IB_NODE_GUID,
sizeof(vf_node_guid),
496 if (vf_data->ce_mask & SRIOV_ATTR_IB_PORT_GUID) {
497 vf_port_guid.vf = vf_data->vf_index;
498 vf_port_guid.guid = vf_data->vf_guid_port;
500 NLA_PUT(msg, IFLA_VF_IB_PORT_GUID,
sizeof(vf_port_guid),
511int rtnl_link_sriov_fill_vflist(
struct nl_msg *msg,
struct rtnl_link *link) {
516 if (!(err = rtnl_link_has_vf_list(link)))
522 list = link->l_vf_list;
523 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
524 if (vf->ce_mask & SRIOV_ATTR_INDEX) {
525 if ((err = sriov_fill_vfinfo(msg, vf)) < 0)
526 goto nla_nest_list_failure;
530nla_nest_list_failure:
537int rtnl_link_sriov_parse_vflist(
struct rtnl_link *link,
struct nlattr **tb) {
538 int err, len, list_len, list_rem;
539 struct ifla_vf_mac *vf_lladdr;
540 struct ifla_vf_vlan *vf_vlan;
541 struct ifla_vf_vlan_info *vf_vlan_info[MAX_VLAN_LIST_LEN];
542 struct ifla_vf_tx_rate *vf_tx_rate;
543 struct ifla_vf_spoofchk *vf_spoofchk;
544 struct ifla_vf_link_state *vf_linkstate;
545 struct ifla_vf_rate *vf_rate;
546 struct ifla_vf_rss_query_en *vf_rss_query;
547 struct ifla_vf_trust *vf_trust;
548 struct nlattr *nla, *nla_list, *t[IFLA_VF_MAX+1],
549 *stb[RTNL_LINK_VF_STATS_MAX+1];
553 len =
nla_len(tb[IFLA_VFINFO_LIST]);
555 if (!link->l_vf_list)
557 vf_head = link->l_vf_list;
570 if (t[IFLA_VF_MAC]) {
571 vf_lladdr =
nla_data(t[IFLA_VF_MAC]);
573 vf_data->vf_index = vf_lladdr->vf;
574 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
578 if (vf_data->vf_lladdr == NULL) {
583 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
586 if (t[IFLA_VF_VLAN_LIST]) {
590 if (list_len >= MAX_VLAN_LIST_LEN)
592 vf_vlan_info[list_len] =
nla_data(nla_list);
596 err = rtnl_link_vf_vlan_info(list_len, vf_vlan_info,
603 vf_data->vf_vlans = vf_vlans;
604 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
605 }
else if (t[IFLA_VF_VLAN]) {
606 vf_vlan =
nla_data(t[IFLA_VF_VLAN]);
619 vf_data->vf_vlans = vf_vlans;
620 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
624 if (t[IFLA_VF_TX_RATE]) {
625 vf_tx_rate =
nla_data(t[IFLA_VF_TX_RATE]);
627 if (vf_tx_rate->rate) {
628 vf_data->vf_rate = vf_tx_rate->rate;
629 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
633 if (t[IFLA_VF_SPOOFCHK]) {
634 vf_spoofchk =
nla_data(t[IFLA_VF_SPOOFCHK]);
636 if (vf_spoofchk->setting != ((uint32_t)-1)) {
637 vf_data->vf_spoofchk = vf_spoofchk->setting ? 1 : 0;
638 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
642 if (t[IFLA_VF_LINK_STATE]) {
643 vf_linkstate =
nla_data(t[IFLA_VF_LINK_STATE]);
645 vf_data->vf_linkstate = vf_linkstate->link_state;
646 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
649 if (t[IFLA_VF_RATE]) {
650 vf_rate =
nla_data(t[IFLA_VF_RATE]);
652 if (vf_rate->max_tx_rate) {
653 vf_data->vf_max_tx_rate = vf_rate->max_tx_rate;
654 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
656 if (vf_rate->min_tx_rate) {
657 vf_data->vf_min_tx_rate = vf_rate->min_tx_rate;
658 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
662 if (t[IFLA_VF_RSS_QUERY_EN]) {
663 vf_rss_query =
nla_data(t[IFLA_VF_RSS_QUERY_EN]);
665 if (vf_rss_query->setting != ((uint32_t)-1)) {
666 vf_data->vf_rss_query_en = vf_rss_query->setting ? 1 : 0;
667 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
671 if (t[IFLA_VF_STATS]) {
680 SET_VF_STAT(link, cur, stb,
682 IFLA_VF_STATS_RX_PACKETS);
683 SET_VF_STAT(link, cur, stb,
685 IFLA_VF_STATS_TX_PACKETS);
686 SET_VF_STAT(link, cur, stb,
688 IFLA_VF_STATS_RX_BYTES);
689 SET_VF_STAT(link, cur, stb,
691 IFLA_VF_STATS_TX_BYTES);
692 SET_VF_STAT(link, cur, stb,
694 IFLA_VF_STATS_BROADCAST);
695 SET_VF_STAT(link, cur, stb,
697 IFLA_VF_STATS_MULTICAST);
699 vf_data->ce_mask |= SRIOV_ATTR_STATS;
702 if (t[IFLA_VF_TRUST]) {
703 vf_trust =
nla_data(t[IFLA_VF_TRUST]);
705 if (vf_trust->setting != ((uint32_t)-1)) {
706 vf_data->vf_trust = vf_trust->setting ? 1 : 0;
707 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
711 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
736 return -NLE_OBJ_NOTFOUND;
738 if (!link->l_vf_list) {
740 if (!link->l_vf_list)
745 vf_head->ce_refcnt++;
747 vf_head = link->l_vf_list;
748 nl_list_add_head(&vf_data->vf_list, &vf_head->vf_list);
749 link->l_vf_list = vf_head;
751 rtnl_link_set_vf_list(link);
770 if (!(vf = calloc(1,
sizeof(*vf))))
773 NL_INIT_LIST_HEAD(&vf->vf_list);
776 NL_DBG(4,
"Allocated new SRIOV VF object %p\n", vf);
789 if (vf_data->ce_refcnt > 0)
790 NL_DBG(1,
"Warning: Freeing SRIOV VF object in use...\n");
792 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
794 if (vf_data->ce_mask & SRIOV_ATTR_VLAN)
797 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_data);
817 list = link->l_vf_list;
818 nl_list_for_each_entry_safe(vf, next, &list->vf_list, vf_list) {
819 if (vf->vf_index == vf_num) {
827 NL_DBG(4,
"New reference to SRIOV VF object %p, total %i\n",
828 ret, ret->ce_refcnt);
845 vf_data->ce_refcnt--;
846 NL_DBG(4,
"Returned SRIOV VF object reference %p, %i remaining\n",
847 vf_data, vf_data->ce_refcnt);
849 if (vf_data->ce_refcnt < 0)
852 if (vf_data->ce_refcnt <= 0)
874 return -NLE_OBJ_NOTFOUND;
876 if (vf_data->ce_mask & SRIOV_ATTR_ADDR)
877 *addr = vf_data->vf_lladdr;
895 if (vf_data->vf_lladdr)
899 vf_data->vf_lladdr = addr;
900 vf_data->ce_mask |= SRIOV_ATTR_ADDR;
912 vf_data->vf_guid_node = guid;
913 vf_data->ce_mask |= SRIOV_ATTR_IB_NODE_GUID;
925 vf_data->vf_guid_port = guid;
926 vf_data->ce_mask |= SRIOV_ATTR_IB_PORT_GUID;
945 return -NLE_OBJ_NOTFOUND;
947 if (vf_data->ce_mask & SRIOV_ATTR_INDEX)
948 *vf_index = vf_data->vf_index;
964 vf_data->vf_index = vf_index;
965 vf_data->ce_mask |= SRIOV_ATTR_INDEX;
983 uint32_t *vf_linkstate)
986 return -NLE_OBJ_NOTFOUND;
988 if (vf_data->ce_mask & SRIOV_ATTR_LINK_STATE)
989 *vf_linkstate = vf_data->vf_linkstate;
1007 uint32_t vf_linkstate) {
1008 vf_data->vf_linkstate = vf_linkstate;
1009 vf_data->ce_mask |= SRIOV_ATTR_LINK_STATE;
1044 return -NLE_OBJ_NOTFOUND;
1051 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MAX) {
1052 if (vf_data->vf_max_tx_rate) {
1058 if (vf_data->ce_mask & SRIOV_ATTR_RATE_MIN) {
1059 if (vf_data->vf_min_tx_rate) {
1065 if ((!set) && (vf_data->ce_mask & SRIOV_ATTR_TX_RATE)) {
1066 if (vf_data->vf_rate) {
1068 vf_rate->
rate = vf_data->vf_rate;
1107 vf_data->vf_rate = vf_rate->
rate;
1108 vf_data->ce_mask |= SRIOV_ATTR_TX_RATE;
1111 vf_data->ce_mask |= SRIOV_ATTR_RATE_MAX;
1114 vf_data->ce_mask |= SRIOV_ATTR_RATE_MIN;
1133 uint32_t *vf_rss_query_en)
1136 return -NLE_OBJ_NOTFOUND;
1138 if (vf_data->ce_mask & SRIOV_ATTR_RSS_QUERY_EN)
1139 *vf_rss_query_en = vf_data->vf_rss_query_en;
1154 uint32_t vf_rss_query_en) {
1155 vf_data->vf_rss_query_en = vf_rss_query_en;
1156 vf_data->ce_mask |= SRIOV_ATTR_RSS_QUERY_EN;
1174 uint32_t *vf_spoofchk)
1177 return -NLE_OBJ_NOTFOUND;
1179 if (vf_data->ce_mask & SRIOV_ATTR_SPOOFCHK)
1180 *vf_spoofchk = vf_data->vf_spoofchk;
1195 uint32_t vf_spoofchk) {
1196 vf_data->vf_spoofchk = vf_spoofchk;
1197 vf_data->ce_mask |= SRIOV_ATTR_SPOOFCHK;
1218 return -NLE_OBJ_NOTFOUND;
1220 if (vf_data->ce_mask & SRIOV_ATTR_STATS)
1221 *vf_stat = vf_data->vf_stats[stat];
1243 return -NLE_OBJ_NOTFOUND;
1245 if (vf_data->ce_mask & SRIOV_ATTR_TRUST)
1246 *vf_trust = vf_data->vf_trust;
1261 vf_data->vf_trust = vf_trust;
1262 vf_data->ce_mask |= SRIOV_ATTR_TRUST;
1287 return -NLE_OBJ_NOTFOUND;
1289 if (vf_data->ce_mask & SRIOV_ATTR_VLAN) {
1290 vf = vf_data->vf_vlans;
1313 if (!vf_data||!vf_vlans)
1316 vf_data->vf_vlans = vf_vlans;
1317 vf_data->vf_vlans->ce_refcnt++;
1318 vf_data->ce_mask |= SRIOV_ATTR_VLAN;
1339 if (vlan_count > MAX_VLAN_LIST_LEN)
1342 vlans = calloc(1,
sizeof(*vlans));
1346 vlan_info = calloc(vlan_count+1,
sizeof(*vlan_info));
1352 NL_DBG(4,
"Allocated new SRIOV VF VLANs object %p\n", vlans);
1355 vlans->
size = vlan_count;
1356 vlans->
vlans = vlan_info;
1371 NL_DBG(1,
"Warning: Freeing SRIOV VF VLANs object in use...\n");
1373 NL_DBG(4,
"Freed SRIOV VF object %p\n", vf_vlans);
1374 free(vf_vlans->
vlans);
1389 NL_DBG(4,
"Returned SRIOV VF VLANs object reference %p, %i remaining\n",
1408static const struct trans_tbl vf_link_states[] = {
1409 __ADD(IFLA_VF_LINK_STATE_AUTO, autodetect),
1410 __ADD(IFLA_VF_LINK_STATE_ENABLE, up),
1411 __ADD(IFLA_VF_LINK_STATE_DISABLE, down),
1414char *rtnl_link_vf_linkstate2str(uint32_t ls,
char *buf,
size_t len)
1416 return __type2str(ls, buf, len, vf_link_states,
1417 ARRAY_SIZE(vf_link_states));
1420int rtnl_link_vf_str2linkstate(
const char *name)
1422 return __str2type(name, vf_link_states, ARRAY_SIZE(vf_link_states));
1425static const struct trans_tbl vf_vlan_proto[] = {
1426 __ADD(ETH_P_8021Q, 8021Q),
1427 __ADD(ETH_P_8021AD, 8021AD),
1430char *rtnl_link_vf_vlanproto2str(uint16_t proto,
char *buf,
size_t len)
1432 return __type2str(proto, buf, len, vf_vlan_proto,
1433 ARRAY_SIZE(vf_vlan_proto));
1436int rtnl_link_vf_str2vlanproto(
const char *name)
1438 return __str2type(name, vf_vlan_proto, ARRAY_SIZE(vf_vlan_proto));
1449int rtnl_link_vf_str2guid(uint64_t *guid,
const char *guid_s) {
1450 unsigned long int tmp;
1454 if (strlen(guid_s) != RTNL_VF_GUID_STR_LEN)
1457 for (i = 0; i < 7; i++) {
1458 if (guid_s[2 + i * 3] !=
':')
1463 for (i = 0; i < 8; i++) {
1464 tmp = strtoul(guid_s + i * 3, &endptr, 16);
1465 if (endptr != guid_s + i * 3 + 2)
1471 *guid |= tmp << (56 - 8 * i);
struct nl_addr * nl_addr_get(struct nl_addr *addr)
Increase the reference counter of an abstract address.
struct nl_addr * nl_addr_build(int family, const void *buf, size_t size)
Allocate abstract address based on a binary address.
void * nl_addr_get_binary_addr(const struct nl_addr *addr)
Get binary address of abstract address object.
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.
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.
struct nlattr * nla_next(const struct nlattr *nla, int *remaining)
Return next attribute in a stream of attributes.
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.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
#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.
@ 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_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.
struct rtnl_link_vf * rtnl_link_vf_alloc(void)
Allocate a new 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.