Lines Matching refs:link
2 * lib/route/link.c Links (Interfaces)
14 * @defgroup link Links (Interfaces)
17 * @route_doc{route_link, Link Documentation}
29 #include <netlink/route/link.h>
30 #include <netlink-private/route/link/api.h>
69 static struct rtnl_link_af_ops *af_lookup_and_alloc(struct rtnl_link *link,
79 if (!(data = rtnl_link_af_alloc(link, af_ops))) {
87 static int af_free(struct rtnl_link *link, struct rtnl_link_af_ops *ops,
91 ops->ao_free(link, data);
98 static int af_clone(struct rtnl_link *link, struct rtnl_link_af_ops *ops,
110 static int af_fill(struct rtnl_link *link, struct rtnl_link_af_ops *ops,
123 if ((err = ops->ao_fill_af(link, arg, data)) < 0)
131 static int af_dump_line(struct rtnl_link *link, struct rtnl_link_af_ops *ops,
137 ops->ao_dump[NL_DUMP_LINE](link, p, data);
142 static int af_dump_details(struct rtnl_link *link, struct rtnl_link_af_ops *ops,
148 ops->ao_dump[NL_DUMP_DETAILS](link, p, data);
153 static int af_dump_stats(struct rtnl_link *link, struct rtnl_link_af_ops *ops,
159 ops->ao_dump[NL_DUMP_STATS](link, p, data);
164 static int do_foreach_af(struct rtnl_link *link,
172 if (link->l_af_data[i]) {
178 err = cb(link, ops, link->l_af_data[i], arg);
190 static void release_link_info(struct rtnl_link *link)
192 struct rtnl_link_info_ops *io = link->l_info_ops;
196 io->io_free(link);
199 BUG_ON(link->l_info);
202 link->l_info_ops = NULL;
208 struct rtnl_link *link = nl_object_priv(c);
210 if (link) {
213 if ((io = link->l_info_ops) != NULL)
214 release_link_info(link);
217 rtnl_link_af_ops_put(link->l_af_ops);
219 nl_addr_put(link->l_addr);
220 nl_addr_put(link->l_bcast);
222 free(link->l_ifalias);
223 free(link->l_info_kind);
225 do_foreach_af(link, af_free, NULL);
227 nl_data_free(link->l_phys_port_id);
304 int rtnl_link_info_parse(struct rtnl_link *link, struct nlattr **tb)
309 nla_strlcpy(link->l_name, tb[IFLA_IFNAME], IFNAMSIZ);
315 link->l_stats[RTNL_LINK_RX_PACKETS] = st->rx_packets;
316 link->l_stats[RTNL_LINK_TX_PACKETS] = st->tx_packets;
317 link->l_stats[RTNL_LINK_RX_BYTES] = st->rx_bytes;
318 link->l_stats[RTNL_LINK_TX_BYTES] = st->tx_bytes;
319 link->l_stats[RTNL_LINK_RX_ERRORS] = st->rx_errors;
320 link->l_stats[RTNL_LINK_TX_ERRORS] = st->tx_errors;
321 link->l_stats[RTNL_LINK_RX_DROPPED] = st->rx_dropped;
322 link->l_stats[RTNL_LINK_TX_DROPPED] = st->tx_dropped;
323 link->l_stats[RTNL_LINK_MULTICAST] = st->multicast;
324 link->l_stats[RTNL_LINK_COLLISIONS] = st->collisions;
326 link->l_stats[RTNL_LINK_RX_LEN_ERR] = st->rx_length_errors;
327 link->l_stats[RTNL_LINK_RX_OVER_ERR] = st->rx_over_errors;
328 link->l_stats[RTNL_LINK_RX_CRC_ERR] = st->rx_crc_errors;
329 link->l_stats[RTNL_LINK_RX_FRAME_ERR] = st->rx_frame_errors;
330 link->l_stats[RTNL_LINK_RX_FIFO_ERR] = st->rx_fifo_errors;
331 link->l_stats[RTNL_LINK_RX_MISSED_ERR] = st->rx_missed_errors;
333 link->l_stats[RTNL_LINK_TX_ABORT_ERR] = st->tx_aborted_errors;
334 link->l_stats[RTNL_LINK_TX_CARRIER_ERR] = st->tx_carrier_errors;
335 link->l_stats[RTNL_LINK_TX_FIFO_ERR] = st->tx_fifo_errors;
336 link->l_stats[RTNL_LINK_TX_HBEAT_ERR] = st->tx_heartbeat_errors;
337 link->l_stats[RTNL_LINK_TX_WIN_ERR] = st->tx_window_errors;
339 link->l_stats[RTNL_LINK_RX_COMPRESSED] = st->rx_compressed;
340 link->l_stats[RTNL_LINK_TX_COMPRESSED] = st->tx_compressed;
342 link->ce_mask |= LINK_ATTR_STATS;
358 link->l_stats[RTNL_LINK_RX_PACKETS] = st.rx_packets;
359 link->l_stats[RTNL_LINK_TX_PACKETS] = st.tx_packets;
360 link->l_stats[RTNL_LINK_RX_BYTES] = st.rx_bytes;
361 link->l_stats[RTNL_LINK_TX_BYTES] = st.tx_bytes;
362 link->l_stats[RTNL_LINK_RX_ERRORS] = st.rx_errors;
363 link->l_stats[RTNL_LINK_TX_ERRORS] = st.tx_errors;
364 link->l_stats[RTNL_LINK_RX_DROPPED] = st.rx_dropped;
365 link->l_stats[RTNL_LINK_TX_DROPPED] = st.tx_dropped;
366 link->l_stats[RTNL_LINK_MULTICAST] = st.multicast;
367 link->l_stats[RTNL_LINK_COLLISIONS] = st.collisions;
369 link->l_stats[RTNL_LINK_RX_LEN_ERR] = st.rx_length_errors;
370 link->l_stats[RTNL_LINK_RX_OVER_ERR] = st.rx_over_errors;
371 link->l_stats[RTNL_LINK_RX_CRC_ERR] = st.rx_crc_errors;
372 link->l_stats[RTNL_LINK_RX_FRAME_ERR] = st.rx_frame_errors;
373 link->l_stats[RTNL_LINK_RX_FIFO_ERR] = st.rx_fifo_errors;
374 link->l_stats[RTNL_LINK_RX_MISSED_ERR] = st.rx_missed_errors;
376 link->l_stats[RTNL_LINK_TX_ABORT_ERR] = st.tx_aborted_errors;
377 link->l_stats[RTNL_LINK_TX_CARRIER_ERR] = st.tx_carrier_errors;
378 link->l_stats[RTNL_LINK_TX_FIFO_ERR] = st.tx_fifo_errors;
379 link->l_stats[RTNL_LINK_TX_HBEAT_ERR] = st.tx_heartbeat_errors;
380 link->l_stats[RTNL_LINK_TX_WIN_ERR] = st.tx_window_errors;
382 link->l_stats[RTNL_LINK_RX_COMPRESSED] = st.rx_compressed;
383 link->l_stats[RTNL_LINK_TX_COMPRESSED] = st.tx_compressed;
385 link->ce_mask |= LINK_ATTR_STATS;
389 link->l_txqlen = nla_get_u32(tb[IFLA_TXQLEN]);
390 link->ce_mask |= LINK_ATTR_TXQLEN;
394 link->l_mtu = nla_get_u32(tb[IFLA_MTU]);
395 link->ce_mask |= LINK_ATTR_MTU;
399 link->l_addr = nl_addr_alloc_attr(tb[IFLA_ADDRESS], AF_UNSPEC);
400 if (link->l_addr == NULL)
402 nl_addr_set_family(link->l_addr,
403 nl_addr_guess_family(link->l_addr));
404 link->ce_mask |= LINK_ATTR_ADDR;
408 link->l_bcast = nl_addr_alloc_attr(tb[IFLA_BROADCAST],
410 if (link->l_bcast == NULL)
412 nl_addr_set_family(link->l_bcast,
413 nl_addr_guess_family(link->l_bcast));
414 link->ce_mask |= LINK_ATTR_BRD;
418 link->l_link = nla_get_u32(tb[IFLA_LINK]);
419 link->ce_mask |= LINK_ATTR_LINK;
423 link->l_weight = nla_get_u32(tb[IFLA_WEIGHT]);
424 link->ce_mask |= LINK_ATTR_WEIGHT;
428 nla_strlcpy(link->l_qdisc, tb[IFLA_QDISC], IFQDISCSIZ);
429 link->ce_mask |= LINK_ATTR_QDISC;
433 nla_memcpy(&link->l_map, tb[IFLA_MAP],
435 link->ce_mask |= LINK_ATTR_MAP;
439 link->l_master = nla_get_u32(tb[IFLA_MASTER]);
440 link->ce_mask |= LINK_ATTR_MASTER;
444 link->l_carrier = nla_get_u8(tb[IFLA_CARRIER]);
445 link->ce_mask |= LINK_ATTR_CARRIER;
449 link->l_operstate = nla_get_u8(tb[IFLA_OPERSTATE]);
450 link->ce_mask |= LINK_ATTR_OPERSTATE;
454 link->l_linkmode = nla_get_u8(tb[IFLA_LINKMODE]);
455 link->ce_mask |= LINK_ATTR_LINKMODE;
459 link->l_ifalias = nla_strdup(tb[IFLA_IFALIAS]);
460 if (link->l_ifalias == NULL)
462 link->ce_mask |= LINK_ATTR_IFALIAS;
466 link->l_ns_fd = nla_get_u32(tb[IFLA_NET_NS_FD]);
467 link->ce_mask |= LINK_ATTR_NS_FD;
471 link->l_ns_pid = nla_get_u32(tb[IFLA_NET_NS_PID]);
472 link->ce_mask |= LINK_ATTR_NS_PID;
481 struct rtnl_link *link;
490 link = rtnl_link_alloc();
491 if (link == NULL) {
496 link->ce_msgtype = n->nlmsg_type;
502 link->l_family = family = ifi->ifi_family;
503 link->l_arptype = ifi->ifi_type;
504 link->l_index = ifi->ifi_index;
505 link->l_flags = ifi->ifi_flags;
506 link->l_change = ifi->ifi_change;
507 link->ce_mask = (LINK_ATTR_IFNAME | LINK_ATTR_FAMILY |
511 if ((af_ops = af_lookup_and_alloc(link, family))) {
518 link->l_af_ops = af_ops;
525 err = rtnl_link_info_parse(link, tb);
530 link->l_num_vf = nla_get_u32(tb[IFLA_NUM_VF]);
531 link->ce_mask |= LINK_ATTR_NUM_VF;
547 err = rtnl_link_set_type(link, kind);
552 !af_ops && (af_ops = af_lookup_and_alloc(link, af))) {
557 link->l_family = family = af;
558 link->l_af_ops = af_ops;
562 link->l_info_ops = ops;
567 err = ops->io_parse(link, li[IFLA_INFO_DATA],
576 link->ce_mask |= LINK_ATTR_LINKINFO;
580 err = af_ops->ao_parse_protinfo(link, tb[IFLA_PROTINFO],
581 link->l_af_data[link->l_family]);
584 link->ce_mask |= LINK_ATTR_PROTINFO;
592 af_ops = af_lookup_and_alloc(link, nla_type(af_attr));
594 char *af_data = link->l_af_data[nla_type(af_attr)];
596 err = af_ops->ao_parse_af(link, af_attr, af_data);
602 link->ce_mask |= LINK_ATTR_AF_SPEC;
606 link->l_promiscuity = nla_get_u32(tb[IFLA_PROMISCUITY]);
607 link->ce_mask |= LINK_ATTR_PROMISCUITY;
611 link->l_num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
612 link->ce_mask |= LINK_ATTR_NUM_TX_QUEUES;
616 link->l_num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
617 link->ce_mask |= LINK_ATTR_NUM_RX_QUEUES;
621 link->l_group = nla_get_u32(tb[IFLA_GROUP]);
622 link->ce_mask |= LINK_ATTR_GROUP;
626 link->l_phys_port_id = nl_data_alloc_attr(tb[IFLA_PHYS_PORT_ID]);
627 if (link->l_phys_port_id == NULL) {
631 link->ce_mask |= LINK_ATTR_PHYS_PORT_ID;
634 err = pp->pp_cb((struct nl_object *) link, pp);
637 rtnl_link_put(link);
652 struct rtnl_link *link = (struct rtnl_link *) obj;
656 cache = nl_cache_mngt_require_safe("route/link");
660 nl_dump_line(p, "%s %s ", link->l_name,
661 nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
663 if (link->l_addr && !nl_addr_iszero(link->l_addr))
664 nl_dump(p, "%s ", nl_addr2str(link->l_addr, buf, sizeof(buf)));
666 if (link->ce_mask & LINK_ATTR_MASTER) {
668 struct rtnl_link *master = rtnl_link_get(cache, link->l_master);
673 nl_dump(p, "master %d ", link->l_master);
676 rtnl_link_flags2str(link->l_flags, buf, sizeof(buf));
680 if (link->ce_mask & LINK_ATTR_LINK) {
682 struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
687 nl_dump(p, "slave-of %d ", link->l_link);
690 if (link->ce_mask & LINK_ATTR_GROUP)
691 nl_dump(p, "group %u ", link->l_group);
693 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_LINE])
694 link->l_info_ops->io_dump[NL_DUMP_LINE](link, p);
696 do_foreach_af(link, af_dump_line, p);
706 struct rtnl_link *link = (struct rtnl_link *) obj;
711 nl_dump_line(p, " mtu %u ", link->l_mtu);
712 nl_dump(p, "txqlen %u weight %u ", link->l_txqlen, link->l_weight);
714 if (link->ce_mask & LINK_ATTR_QDISC)
715 nl_dump(p, "qdisc %s ", link->l_qdisc);
717 if (link->ce_mask & LINK_ATTR_MAP && link->l_map.lm_irq)
718 nl_dump(p, "irq %u ", link->l_map.lm_irq);
720 if (link->ce_mask & LINK_ATTR_IFINDEX)
721 nl_dump(p, "index %u ", link->l_index);
723 if (link->ce_mask & LINK_ATTR_PROMISCUITY && link->l_promiscuity > 0)
724 nl_dump(p, "promisc-mode (%u users) ", link->l_promiscuity);
728 if (link->ce_mask & LINK_ATTR_IFALIAS)
729 nl_dump_line(p, " alias %s\n", link->l_ifalias);
733 if (link->ce_mask & LINK_ATTR_NUM_TX_QUEUES)
734 nl_dump(p, "txq %u ", link->l_num_tx_queues);
736 if (link->ce_mask & LINK_ATTR_NUM_RX_QUEUES)
737 nl_dump(p, "rxq %u ", link->l_num_rx_queues);
739 if (link->ce_mask & LINK_ATTR_BRD)
740 nl_dump(p, "brd %s ", nl_addr2str(link->l_bcast, buf,
743 if ((link->ce_mask & LINK_ATTR_OPERSTATE) &&
744 link->l_operstate != IF_OPER_UNKNOWN) {
745 rtnl_link_operstate2str(link->l_operstate, buf, sizeof(buf));
749 if (link->ce_mask & LINK_ATTR_NUM_VF)
750 nl_dump(p, "num-vf %u ", link->l_num_vf);
753 rtnl_link_mode2str(link->l_linkmode, buf, sizeof(buf)));
756 rtnl_link_carrier2str(link->l_carrier, buf, sizeof(buf)));
760 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_DETAILS])
761 link->l_info_ops->io_dump[NL_DUMP_DETAILS](link, p);
763 do_foreach_af(link, af_dump_details, p);
768 struct rtnl_link *link = (struct rtnl_link *) obj;
777 res = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_RX_BYTES], &unit);
783 link->l_stats[RTNL_LINK_RX_PACKETS],
784 link->l_stats[RTNL_LINK_RX_ERRORS],
785 link->l_stats[RTNL_LINK_RX_DROPPED],
786 link->l_stats[RTNL_LINK_RX_FIFO_ERR],
787 link->l_stats[RTNL_LINK_RX_COMPRESSED]);
789 res = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_TX_BYTES], &unit);
795 link->l_stats[RTNL_LINK_TX_PACKETS],
796 link->l_stats[RTNL_LINK_TX_ERRORS],
797 link->l_stats[RTNL_LINK_TX_DROPPED],
798 link->l_stats[RTNL_LINK_TX_FIFO_ERR],
799 link->l_stats[RTNL_LINK_TX_COMPRESSED]);
807 link->l_stats[RTNL_LINK_RX_LEN_ERR],
808 link->l_stats[RTNL_LINK_RX_OVER_ERR],
809 link->l_stats[RTNL_LINK_RX_CRC_ERR],
810 link->l_stats[RTNL_LINK_RX_FRAME_ERR],
811 link->l_stats[RTNL_LINK_RX_MISSED_ERR],
812 link->l_stats[RTNL_LINK_MULTICAST]);
819 link->l_stats[RTNL_LINK_TX_ABORT_ERR],
820 link->l_stats[RTNL_LINK_TX_CARRIER_ERR],
821 link->l_stats[RTNL_LINK_TX_HBEAT_ERR],
822 link->l_stats[RTNL_LINK_TX_WIN_ERR],
823 link->l_stats[RTNL_LINK_COLLISIONS]);
825 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_STATS])
826 link->l_info_ops->io_dump[NL_DUMP_STATS](link, p);
828 do_foreach_af(link, af_dump_stats, p);
859 dp_dump_line(p, line++, "link %s changed state to %s.\n",
864 dp_dump(p, "link %s %s promiscuous mode.\n",
869 dp_dump_line(p, line++, "link %s sent unknown event.\n",
881 struct rtnl_link *link = (struct rtnl_link *) obj;
889 lkey.l_index = link->l_index;
890 lkey.l_family = link->l_family;
894 NL_DBG(5, "link %p key (dev %d fam %d) keysz %d, hash 0x%x\n",
895 link, lkey.l_index, lkey.l_family, lkey_sz, *hashkey);
911 diff |= LINK_DIFF(LINK, a->l_link != b->l_link);
955 __ADD(LINK_ATTR_LINK, link)
995 * Allocate link cache and fill in all configured links.
997 * @arg family Link address family or AF_UNSPEC
1000 * Allocates and initializes a new link cache. If \c sk is valid, a netlink
1003 * the operation succeeds, the resulting cache will contain a link object for
1004 * each link configured in the kernel. If \c sk is NULL, returns 0 but the
1039 * Lookup link in cache by interface index
1040 * @arg cache Link cache
1043 * Searches through the provided cache looking for a link with matching
1046 * @attention The reference counter of the returned link object will be
1051 * @return Link object or NULL if no match was found.
1055 struct rtnl_link *link;
1060 nl_list_for_each_entry(link, &cache->c_items, ce_list) {
1061 if (link->l_index == ifindex) {
1062 nl_object_get((struct nl_object *) link);
1063 return link;
1071 * Lookup link in cache by link name
1072 * @arg cache Link cache
1073 * @arg name Name of link
1075 * Searches through the provided cache looking for a link with matching
1076 * link name
1078 * @attention The reference counter of the returned link object will be
1083 * @return Link object or NULL if no match was found.
1088 struct rtnl_link *link;
1093 nl_list_for_each_entry(link, &cache->c_items, ce_list) {
1094 if (!strcmp(name, link->l_name)) {
1095 nl_object_get((struct nl_object *) link);
1096 return link;
1106 * @arg name Name of link
1151 * Get a link object directly from kernel
1154 * @arg name Name of link
1155 * @arg result Pointer to store resulting link object
1158 * a specific link directly from the kernel. The returned answer is
1160 * pointer or -NLE_OBJ_NOTFOUND is returned if no matching link was
1163 * @route_doc{link_direct_lookup, Lookup Single Link (Direct Lookup)}
1184 /* We have used link_msg_parser(), object is definitely a link */
1195 * Translate interface index to corresponding link name
1196 * @arg cache Link cache
1202 * link name and stores the name in the destination string.
1204 * @route_doc{link_translate_ifindex, Translating interface index to link name}
1206 * @return Name of link or NULL if no match was found.
1211 struct rtnl_link *link = rtnl_link_get(cache, ifindex);
1213 if (link) {
1214 strncpy(dst, link->l_name, len - 1);
1215 rtnl_link_put(link);
1223 * Translate link name to corresponding interface index
1224 * @arg cache Link cache
1225 * @arg name Name of link
1227 * @route_doc{link_translate_ifindex, Translating interface index to link name}
1234 struct rtnl_link *link;
1236 link = rtnl_link_get_by_name(cache, name);
1237 if (link) {
1238 ifindex = link->l_index;
1239 rtnl_link_put(link);
1247 int rtnl_link_fill_info(struct nl_msg *msg, struct rtnl_link *link)
1249 if (link->ce_mask & LINK_ATTR_ADDR)
1250 NLA_PUT_ADDR(msg, IFLA_ADDRESS, link->l_addr);
1252 if (link->ce_mask & LINK_ATTR_BRD)
1253 NLA_PUT_ADDR(msg, IFLA_BROADCAST, link->l_bcast);
1255 if (link->ce_mask & LINK_ATTR_MTU)
1256 NLA_PUT_U32(msg, IFLA_MTU, link->l_mtu);
1258 if (link->ce_mask & LINK_ATTR_TXQLEN)
1259 NLA_PUT_U32(msg, IFLA_TXQLEN, link->l_txqlen);
1261 if (link->ce_mask & LINK_ATTR_WEIGHT)
1262 NLA_PUT_U32(msg, IFLA_WEIGHT, link->l_weight);
1264 if (link->ce_mask & LINK_ATTR_IFNAME)
1265 NLA_PUT_STRING(msg, IFLA_IFNAME, link->l_name);
1267 if (link->ce_mask & LINK_ATTR_OPERSTATE)
1268 NLA_PUT_U8(msg, IFLA_OPERSTATE, link->l_operstate);
1270 if (link->ce_mask & LINK_ATTR_CARRIER)
1271 NLA_PUT_U8(msg, IFLA_CARRIER, link->l_carrier);
1273 if (link->ce_mask & LINK_ATTR_LINKMODE)
1274 NLA_PUT_U8(msg, IFLA_LINKMODE, link->l_linkmode);
1276 if (link->ce_mask & LINK_ATTR_IFALIAS)
1277 NLA_PUT_STRING(msg, IFLA_IFALIAS, link->l_ifalias);
1279 if (link->ce_mask & LINK_ATTR_LINK)
1280 NLA_PUT_U32(msg, IFLA_LINK, link->l_link);
1282 if (link->ce_mask & LINK_ATTR_MASTER)
1283 NLA_PUT_U32(msg, IFLA_MASTER, link->l_master);
1285 if (link->ce_mask & LINK_ATTR_NUM_TX_QUEUES)
1286 NLA_PUT_U32(msg, IFLA_NUM_TX_QUEUES, link->l_num_tx_queues);
1288 if (link->ce_mask & LINK_ATTR_NUM_RX_QUEUES)
1289 NLA_PUT_U32(msg, IFLA_NUM_RX_QUEUES, link->l_num_rx_queues);
1291 if (link->ce_mask & LINK_ATTR_NS_FD)
1292 NLA_PUT_U32(msg, IFLA_NET_NS_FD, link->l_ns_fd);
1294 if (link->ce_mask & LINK_ATTR_NS_PID)
1295 NLA_PUT_U32(msg, IFLA_NET_NS_PID, link->l_ns_pid);
1304 struct rtnl_link *link, int flags, struct nl_msg **result)
1316 if (rtnl_link_fill_info(msg, link))
1319 if (link->ce_mask & LINK_ATTR_GROUP)
1320 NLA_PUT_U32(msg, IFLA_GROUP, link->l_group);
1322 if (link->ce_mask & LINK_ATTR_LINKINFO) {
1328 NLA_PUT_STRING(msg, IFLA_INFO_KIND, link->l_info_kind);
1330 if (link->l_info_ops) {
1331 if (link->l_info_ops->io_put_attrs &&
1332 link->l_info_ops->io_put_attrs(msg, link) < 0)
1342 if (do_foreach_af(link, af_fill, msg) < 0)
1361 * Build a netlink message requesting the addition of new virtual link
1362 * @arg link new link to add
1376 int rtnl_link_build_add_request(struct rtnl_link *link, int flags,
1380 .ifi_family = link->l_family,
1381 .ifi_index = link->l_index,
1382 .ifi_flags = link->l_flags,
1385 return build_link_msg(RTM_NEWLINK, &ifi, link, flags, result);
1389 * Add virtual link
1391 * @arg link new link to add
1395 * a new virtual link.
1405 int rtnl_link_add(struct nl_sock *sk, struct rtnl_link *link, int flags)
1410 err = rtnl_link_build_add_request(link, flags, &msg);
1418 * Build a netlink message requesting the modification of link
1419 * @arg orig original link to change
1420 * @arg changes link containing the changes to be made
1432 * to RTM_SETLINK (does not allow changing link info attributes) to
1453 APPBUG("link change: family is immutable");
1474 * Change link
1476 * @arg orig original link to be changed
1477 * @arg changes link containing the changes to be made
1481 * a network link. If -EOPNOTSUPP is returned by the kernel, the
1485 * The link to be changed is looked up based on the interface index
1486 * supplied in the \p orig link. Optionaly the link name is used but
1488 * link name will result in the link name being changed.
1490 * If no matching link exists, the function will return
1499 * @note The link name can only be changed if the link has been put
1538 * Build a netlink message requesting the deletion of a link
1539 * @arg link Link to delete
1550 int rtnl_link_build_delete_request(const struct rtnl_link *link,
1555 .ifi_index = link->l_index,
1558 if (!(link->ce_mask & (LINK_ATTR_IFINDEX | LINK_ATTR_IFNAME))) {
1569 if (link->ce_mask & LINK_ATTR_IFNAME)
1570 NLA_PUT_STRING(msg, IFLA_IFNAME, link->l_name);
1581 * Delete link
1583 * @arg link Link to delete
1586 * a network link which has been previously added to the kernel and
1589 * If no matching link exists, the function will return
1604 int rtnl_link_delete(struct nl_sock *sk, const struct rtnl_link *link)
1609 if ((err = rtnl_link_build_delete_request(link, &msg)) < 0)
1618 * @name Link Object
1623 * Allocate link object
1626 * @return New link object or NULL if allocation failed
1634 * Return a link object reference
1635 * @arg link Link object
1637 void rtnl_link_put(struct rtnl_link *link)
1639 nl_object_put((struct nl_object *) link);
1643 * Set name of link object
1644 * @arg link Link object
1647 * @note To change the name of a link in the kernel, set the interface
1648 * index to the link you wish to change, modify the link name using
1649 * this function and pass the link object to rtnl_link_change() or
1652 * @route_doc{link_attr_name, Link Name}
1656 void rtnl_link_set_name(struct rtnl_link *link, const char *name)
1658 strncpy(link->l_name, name, sizeof(link->l_name) - 1);
1659 link->ce_mask |= LINK_ATTR_IFNAME;
1663 * Return name of link object
1664 * @arg link Link object
1666 * @route_doc{link_attr_name, Link Name}
1668 * @return Link name or NULL if name is not specified
1670 char *rtnl_link_get_name(struct rtnl_link *link)
1672 return link->ce_mask & LINK_ATTR_IFNAME ? link->l_name : NULL;
1676 * Set the group identifier of a link object
1677 * @arg link Link object
1680 void rtnl_link_set_group(struct rtnl_link *link, uint32_t group)
1682 link->l_group = group;
1683 link->ce_mask |= LINK_ATTR_GROUP;
1687 * Return the group identifier of link object
1688 * @arg link Link object
1692 uint32_t rtnl_link_get_group(struct rtnl_link *link)
1694 return link->l_group;
1697 static inline void __assign_addr(struct rtnl_link *link, struct nl_addr **pos,
1706 link->ce_mask |= flag;
1710 * Set link layer address of link object
1711 * @arg link Link object
1712 * @arg addr New link layer address
1715 * and overwrites any existing link layer address previously assigned.
1717 * @route_doc{link_attr_address, Link layer address}
1720 void rtnl_link_set_addr(struct rtnl_link *link, struct nl_addr *addr)
1722 __assign_addr(link, &link->l_addr, addr, LINK_ATTR_ADDR);
1726 * Return link layer address of link object
1727 * @arg link Link object
1730 * @route_doc{link_attr_address, Link Layer Address}
1732 * @return Link layer address or NULL if not set.
1734 struct nl_addr *rtnl_link_get_addr(struct rtnl_link *link)
1736 return link->ce_mask & LINK_ATTR_ADDR ? link->l_addr : NULL;
1740 * Set link layer broadcast address of link object
1741 * @arg link Link object
1745 * and overwrites any existing link layer broadcast address previously
1748 * @route_doc{link_attr_broadcast, Link Layer Broadcast Address}
1751 void rtnl_link_set_broadcast(struct rtnl_link *link, struct nl_addr *addr)
1753 __assign_addr(link, &link->l_bcast, addr, LINK_ATTR_BRD);
1757 * Return link layer broadcast address of link object
1758 * @arg link Link object
1761 * @route_doc{link_attr_address, Link Layer Address}
1763 * @return Link layer address or NULL if not set.
1765 struct nl_addr *rtnl_link_get_broadcast(struct rtnl_link *link)
1767 return link->ce_mask & LINK_ATTR_BRD ? link->l_bcast : NULL;
1771 * Set flags of link object
1772 * @arg link Link object
1778 void rtnl_link_set_flags(struct rtnl_link *link, unsigned int flags)
1780 link->l_flag_mask |= flags;
1781 link->l_flags |= flags;
1782 link->ce_mask |= LINK_ATTR_FLAGS;
1786 * Unset flags of link object
1787 * @arg link Link object
1793 void rtnl_link_unset_flags(struct rtnl_link *link, unsigned int flags)
1795 link->l_flag_mask |= flags;
1796 link->l_flags &= ~flags;
1797 link->ce_mask |= LINK_ATTR_FLAGS;
1801 * Return flags of link object
1802 * @arg link Link object
1804 * @route_doc{link_attr_flags, Link Flags}
1807 * @return Link flags or 0 if none have been set.
1809 unsigned int rtnl_link_get_flags(struct rtnl_link *link)
1811 return link->l_flags;
1815 * Set address family of link object
1819 void rtnl_link_set_family(struct rtnl_link *link, int family)
1821 link->l_family = family;
1822 link->ce_mask |= LINK_ATTR_FAMILY;
1824 if (link->l_af_ops) {
1825 af_free(link, link->l_af_ops,
1826 link->l_af_data[link->l_af_ops->ao_family], NULL);
1827 link->l_af_data[link->l_af_ops->ao_family] = NULL;
1830 link->l_af_ops = af_lookup_and_alloc(link, family);
1834 * Return address family of link object
1835 * @arg link Link object
1840 int rtnl_link_get_family(struct rtnl_link *link)
1842 link->ce_mask & LINK_ATTR_FAMILY ? link->l_family : AF_UNSPEC;
1846 * Set hardware type of link object
1847 * @arg link Link object
1854 void rtnl_link_set_arptype(struct rtnl_link *link, unsigned int arptype)
1856 link->l_arptype = arptype;
1857 link->ce_mask |= LINK_ATTR_ARPTYPE;
1861 * Get hardware type of link object
1862 * @arg link Link object
1868 unsigned int rtnl_link_get_arptype(struct rtnl_link *link)
1870 if (link->ce_mask & LINK_ATTR_ARPTYPE)
1871 return link->l_arptype;
1877 * Set interface index of link object
1878 * @arg link Link object
1884 void rtnl_link_set_ifindex(struct rtnl_link *link, int ifindex)
1886 link->l_index = ifindex;
1887 link->ce_mask |= LINK_ATTR_IFINDEX;
1892 * Return interface index of link object
1893 * @arg link Link object
1899 int rtnl_link_get_ifindex(struct rtnl_link *link)
1901 return link->l_index;
1905 * Set Maximum Transmission Unit of link object
1906 * @arg link Link object
1912 void rtnl_link_set_mtu(struct rtnl_link *link, unsigned int mtu)
1914 link->l_mtu = mtu;
1915 link->ce_mask |= LINK_ATTR_MTU;
1919 * Return maximum transmission unit of link object
1920 * @arg link Link object
1926 unsigned int rtnl_link_get_mtu(struct rtnl_link *link)
1928 return link->l_mtu;
1933 * @arg link Link object
1936 * The unit is dependant on the link type. The most common units is number
1941 void rtnl_link_set_txqlen(struct rtnl_link *link, unsigned int txqlen)
1943 link->l_txqlen = txqlen;
1944 link->ce_mask |= LINK_ATTR_TXQLEN;
1949 * @arg link Link object
1951 * The unit is dependant on the link type. The most common units is number
1957 unsigned int rtnl_link_get_txqlen(struct rtnl_link *link)
1959 return link->ce_mask & LINK_ATTR_TXQLEN ? link->l_txqlen : 0;
1962 void rtnl_link_set_link(struct rtnl_link *link, int ifindex)
1964 link->l_link = ifindex;
1965 link->ce_mask |= LINK_ATTR_LINK;
1968 int rtnl_link_get_link(struct rtnl_link *link)
1970 return link->l_link;
1974 * Set master link of link object
1975 * @arg link Link object
1976 * @arg ifindex Interface index of master link
1980 void rtnl_link_set_master(struct rtnl_link *link, int ifindex)
1982 link->l_master = ifindex;
1983 link->ce_mask |= LINK_ATTR_MASTER;
1987 * Return master link of link object
1988 * @arg link Link object
1991 * @return Interface index of master link or 0 if not specified
1993 int rtnl_link_get_master(struct rtnl_link *link)
1995 return link->l_master;
1999 * Set carrier of link object
2000 * @arg link Link object
2005 void rtnl_link_set_carrier(struct rtnl_link *link, uint8_t status)
2007 link->l_carrier = status;
2008 link->ce_mask |= LINK_ATTR_CARRIER;
2012 * Return carrier status of link object
2013 * @arg link Link object
2018 uint8_t rtnl_link_get_carrier(struct rtnl_link *link)
2020 return link->l_carrier;
2024 * Set operational status of link object
2025 * @arg link Link object
2031 void rtnl_link_set_operstate(struct rtnl_link *link, uint8_t status)
2033 link->l_operstate = status;
2034 link->ce_mask |= LINK_ATTR_OPERSTATE;
2038 * Return operational status of link object
2039 * @arg link Link object
2045 uint8_t rtnl_link_get_operstate(struct rtnl_link *link)
2047 return link->l_operstate;
2051 * Set link mode of link object
2052 * @arg link Link object
2053 * @arg mode New link mode
2058 void rtnl_link_set_linkmode(struct rtnl_link *link, uint8_t mode)
2060 link->l_linkmode = mode;
2061 link->ce_mask |= LINK_ATTR_LINKMODE;
2065 * Return link mode of link object
2066 * @arg link Link object
2070 * @return Link mode or \c IF_LINK_MODE_DEFAULT
2072 uint8_t rtnl_link_get_linkmode(struct rtnl_link *link)
2074 return link->l_linkmode;
2078 * Return alias name of link object (SNMP IfAlias)
2079 * @arg link Link object
2085 const char *rtnl_link_get_ifalias(struct rtnl_link *link)
2087 return link->l_ifalias;
2091 * Set alias name of link object (SNMP IfAlias)
2092 * @arg link Link object
2095 * Sets the alias name of the link to the specified name. The alias
2102 void rtnl_link_set_ifalias(struct rtnl_link *link, const char *alias)
2104 free(link->l_ifalias);
2107 link->l_ifalias = strdup(alias);
2108 link->ce_mask |= LINK_ATTR_IFALIAS;
2110 link->l_ifalias = NULL;
2111 link->ce_mask &= ~LINK_ATTR_IFALIAS;
2116 * Set queueing discipline name of link object
2117 * @arg link Link object
2122 * For more information on how to modify the qdisc of a link, see section
2128 void rtnl_link_set_qdisc(struct rtnl_link *link, const char *name)
2130 strncpy(link->l_qdisc, name, sizeof(link->l_qdisc) - 1);
2131 link->ce_mask |= LINK_ATTR_QDISC;
2135 * Return name of queueing discipline of link object
2136 * @arg link Link object
2142 char *rtnl_link_get_qdisc(struct rtnl_link *link)
2144 return link->ce_mask & LINK_ATTR_QDISC ? link->l_qdisc : NULL;
2149 * Return number of PCI virtual functions of link object
2150 * @arg link Link object
2155 int rtnl_link_get_num_vf(struct rtnl_link *link, uint32_t *num_vf)
2157 if (link->ce_mask & LINK_ATTR_NUM_VF) {
2158 *num_vf = link->l_num_vf;
2165 * Return value of link statistics counter
2166 * @arg link Link object
2171 uint64_t rtnl_link_get_stat(struct rtnl_link *link, rtnl_link_stat_id_t id)
2176 return link->l_stats[id];
2180 * Set value of link statistics counter
2181 * @arg link Link object
2190 int rtnl_link_set_stat(struct rtnl_link *link, rtnl_link_stat_id_t id,
2196 link->l_stats[id] = value;
2202 * Set type of link object
2203 * @arg link Link object
2204 * @arg type Name of link type
2206 * Looks up the link type module and prepares the link to store type
2208 * be released with all link type specific attributes lost.
2210 * @route_doc{link_modules, Link Modules}
2213 int rtnl_link_set_type(struct rtnl_link *link, const char *type)
2219 free(link->l_info_kind);
2220 link->ce_mask &= ~LINK_ATTR_LINKINFO;
2221 if (link->l_info_ops)
2222 release_link_info(link);
2233 if (io->io_alloc && (err = io->io_alloc(link)) < 0)
2236 link->l_info_ops = io;
2239 link->l_info_kind = kind;
2240 link->ce_mask |= LINK_ATTR_LINKINFO;
2250 * Return type of link
2251 * @arg link Link object
2253 * @route_doc{link_modules, Link Modules}
2254 * @return Name of link type or NULL if not specified.
2256 char *rtnl_link_get_type(struct rtnl_link *link)
2258 return link->l_info_kind;
2262 * Set link promiscuity count
2263 * @arg link Link object
2270 void rtnl_link_set_promiscuity(struct rtnl_link *link, uint32_t count)
2272 link->l_promiscuity = count;
2273 link->ce_mask |= LINK_ATTR_PROMISCUITY;
2277 * Return link promiscuity count
2278 * @arg link Link object
2281 * @return Link promiscuity count or 0
2283 uint32_t rtnl_link_get_promiscuity(struct rtnl_link *link)
2285 return link->l_promiscuity;
2290 * @arg link Link object
2293 * Sets the number of TX queues of the link object. The value is considered
2298 * combination with rtnl_link_add() or if the link object is used as a filter.
2302 void rtnl_link_set_num_tx_queues(struct rtnl_link *link, uint32_t nqueues)
2304 link->l_num_tx_queues = nqueues;
2305 link->ce_mask |= LINK_ATTR_NUM_TX_QUEUES;
2310 * @arg link Link object
2314 uint32_t rtnl_link_get_num_tx_queues(struct rtnl_link *link)
2316 return link->l_num_tx_queues;
2321 * @arg link Link object
2324 * Sets the number of RX queues of the link object. The value is considered
2329 * combination with rtnl_link_add() or if the link object is used as a filter.
2333 void rtnl_link_set_num_rx_queues(struct rtnl_link *link, uint32_t nqueues)
2335 link->l_num_rx_queues = nqueues;
2336 link->ce_mask |= LINK_ATTR_NUM_RX_QUEUES;
2341 * @arg link Link object
2345 uint32_t rtnl_link_get_num_rx_queues(struct rtnl_link *link)
2347 return link->l_num_rx_queues;
2351 * Return physical port id of link object
2352 * @arg link Link object
2356 struct nl_data *rtnl_link_get_phys_port_id(struct rtnl_link *link)
2358 return link->l_phys_port_id;
2361 void rtnl_link_set_ns_fd(struct rtnl_link *link, int fd)
2363 link->l_ns_fd = fd;
2364 link->ce_mask |= LINK_ATTR_NS_FD;
2367 int rtnl_link_get_ns_fd(struct rtnl_link *link)
2369 return link->l_ns_fd;
2372 void rtnl_link_set_ns_pid(struct rtnl_link *link, pid_t pid)
2374 link->l_ns_pid = pid;
2375 link->ce_mask |= LINK_ATTR_NS_PID;
2378 pid_t rtnl_link_get_ns_pid(struct rtnl_link *link)
2380 return link->l_ns_pid;
2391 * Enslave slave link to master link
2393 * @arg master ifindex of master link
2394 * @arg slave ifindex of slave link
2405 struct rtnl_link *link;
2408 if (!(link = rtnl_link_alloc()))
2411 rtnl_link_set_ifindex(link, slave);
2412 rtnl_link_set_master(link, master);
2414 if ((err = rtnl_link_change(sock, link, link, 0)) < 0)
2417 rtnl_link_put(link);
2426 if ((err = rtnl_link_get_kernel(sock, slave, NULL, &link)) < 0)
2429 if (rtnl_link_get_master(link) != master)
2433 rtnl_link_put(link);
2439 * Enslave slave link to master link
2441 * @arg master master link
2442 * @arg slave slave link
2466 * Release slave link from its master
2468 * @arg slave slave link
2483 * Release slave link from its master
2485 * @arg slave slave link
2684 int rtnl_link_set_info_type(struct rtnl_link *link, const char *type)
2686 return rtnl_link_set_type(link, type);
2692 char *rtnl_link_get_info_type(struct rtnl_link *link)
2694 return rtnl_link_get_type(link);
2700 void rtnl_link_set_weight(struct rtnl_link *link, unsigned int weight)
2702 link->l_weight = weight;
2703 link->ce_mask |= LINK_ATTR_WEIGHT;
2709 unsigned int rtnl_link_get_weight(struct rtnl_link *link)
2711 return link->l_weight;
2717 .oo_name = "route/link",
2739 .co_name = "route/link",
