25 #include <netlink-private/netlink.h>
26 #include <netlink/netlink.h>
27 #include <netlink/attr.h>
28 #include <netlink/utils.h>
29 #include <netlink/object.h>
30 #include <netlink/route/rtnl.h>
31 #include <netlink-private/route/link/api.h>
32 #include <netlink/route/link/vlan.h>
34 #include <linux/if_vlan.h>
37 #define VLAN_HAS_ID (1<<0)
38 #define VLAN_HAS_FLAGS (1<<1)
39 #define VLAN_HAS_INGRESS_QOS (1<<2)
40 #define VLAN_HAS_EGRESS_QOS (1<<3)
41 #define VLAN_HAS_PROTOCOL (1<<4)
48 uint32_t vi_flags_mask;
49 uint32_t vi_ingress_qos[VLAN_PRIO_MAX+1];
51 uint32_t vi_egress_size;
58 static struct nla_policy vlan_policy[IFLA_VLAN_MAX+1] = {
60 [IFLA_VLAN_FLAGS] = { .minlen =
sizeof(
struct ifla_vlan_flags) },
61 [IFLA_VLAN_INGRESS_QOS] = { .type =
NLA_NESTED },
62 [IFLA_VLAN_EGRESS_QOS] = { .type =
NLA_NESTED },
63 [IFLA_VLAN_PROTOCOL] = { .type =
NLA_U16 },
66 static int vlan_alloc(
struct rtnl_link *link)
70 if ((vi = calloc(1,
sizeof(*vi))) == NULL)
78 static int vlan_parse(
struct rtnl_link *link,
struct nlattr *data,
79 struct nlattr *xstats)
81 struct nlattr *tb[IFLA_VLAN_MAX+1];
85 NL_DBG(3,
"Parsing VLAN link info");
90 if ((err = vlan_alloc(link)) < 0)
95 if (tb[IFLA_VLAN_ID]) {
97 vi->vi_mask |= VLAN_HAS_ID;
100 if (tb[IFLA_VLAN_PROTOCOL]) {
101 vi->vi_protocol =
nla_get_u16(tb[IFLA_VLAN_PROTOCOL]);
102 vi->vi_mask |= VLAN_HAS_PROTOCOL;
105 if (tb[IFLA_VLAN_FLAGS]) {
106 struct ifla_vlan_flags flags;
107 nla_memcpy(&flags, tb[IFLA_VLAN_FLAGS],
sizeof(flags));
109 vi->vi_flags = flags.flags;
110 vi->vi_mask |= VLAN_HAS_FLAGS;
113 if (tb[IFLA_VLAN_INGRESS_QOS]) {
114 struct ifla_vlan_qos_mapping *map;
118 memset(vi->vi_ingress_qos, 0,
sizeof(vi->vi_ingress_qos));
121 if (
nla_len(nla) <
sizeof(*map))
125 if (map->from > VLAN_PRIO_MAX) {
129 vi->vi_ingress_qos[map->from] = map->to;
132 vi->vi_mask |= VLAN_HAS_INGRESS_QOS;
135 if (tb[IFLA_VLAN_EGRESS_QOS]) {
136 struct ifla_vlan_qos_mapping *map;
138 int remaining, i = 0;
141 if (
nla_len(nla) <
sizeof(*map))
147 vi->vi_egress_size = (i + 32) & ~31;
148 vi->vi_egress_qos = calloc(vi->vi_egress_size,
sizeof(*vi->vi_egress_qos));
149 if (vi->vi_egress_qos == NULL)
155 NL_DBG(4,
"Assigning egress qos mapping %d\n", i);
156 vi->vi_egress_qos[i].vm_from = map->from;
157 vi->vi_egress_qos[i++].vm_to = map->to;
161 vi->vi_mask |= VLAN_HAS_EGRESS_QOS;
169 static void vlan_free(
struct rtnl_link *link)
171 struct vlan_info *vi = link->l_info;
174 free(vi->vi_egress_qos);
175 vi->vi_egress_qos = NULL;
184 struct vlan_info *vi = link->l_info;
186 nl_dump(p,
"vlan-id %d", vi->vi_vlan_id);
191 struct vlan_info *vi = link->l_info;
196 rtnl_link_vlan_flags2str(vi->vi_flags, buf,
sizeof(buf));
197 nl_dump_line(p,
" vlan-info id %d <%s>", vi->vi_vlan_id, buf);
199 if (vi->vi_mask & VLAN_HAS_PROTOCOL)
200 nl_dump_line(p,
" vlan protocol <%d>", vi->vi_protocol);
204 if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
206 " ingress vlan prio -> qos/socket prio mapping:\n");
207 for (i = 0, printed = 0; i <= VLAN_PRIO_MAX; i++) {
208 if (vi->vi_ingress_qos[i]) {
210 nl_dump_line(p,
" ");
212 i, vi->vi_ingress_qos[i]);
213 if (printed++ == 3) {
220 if (printed > 0 && printed != 4)
224 if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
226 " egress qos/socket prio -> vlan prio mapping:\n");
227 for (i = 0, printed = 0; i < vi->vi_negress; i++) {
229 nl_dump_line(p,
" ");
231 vi->vi_egress_qos[i].vm_from,
232 vi->vi_egress_qos[i].vm_to);
233 if (printed++ == 3) {
239 if (printed > 0 && printed != 4)
246 struct vlan_info *vdst, *vsrc = src->l_info;
254 vdst->vi_egress_qos = calloc(vsrc->vi_egress_size,
256 if (!vdst->vi_egress_qos)
259 memcpy(vdst->vi_egress_qos, vsrc->vi_egress_qos,
260 vsrc->vi_egress_size *
sizeof(
struct vlan_map));
265 static int vlan_put_attrs(
struct nl_msg *msg,
struct rtnl_link *link)
267 struct vlan_info *vi = link->l_info;
273 if (vi->vi_mask & VLAN_HAS_ID)
276 if (vi->vi_mask & VLAN_HAS_FLAGS) {
277 struct ifla_vlan_flags flags = {
278 .flags = vi->vi_flags,
279 .mask = vi->vi_flags_mask,
282 NLA_PUT(msg, IFLA_VLAN_FLAGS,
sizeof(flags), &flags);
285 if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
286 struct ifla_vlan_qos_mapping map;
291 goto nla_put_failure;
293 for (i = 0; i <= VLAN_PRIO_MAX; i++) {
294 if (vi->vi_ingress_qos[i]) {
296 map.to = vi->vi_ingress_qos[i];
298 NLA_PUT(msg, i,
sizeof(map), &map);
305 if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
306 struct ifla_vlan_qos_mapping map;
311 goto nla_put_failure;
313 for (i = 0; i < vi->vi_negress; i++) {
314 map.from = vi->vi_egress_qos[i].vm_from;
315 map.to = vi->vi_egress_qos[i].vm_to;
317 NLA_PUT(msg, i,
sizeof(map), &map);
330 static struct rtnl_link_info_ops vlan_info_ops = {
332 .io_alloc = vlan_alloc,
333 .io_parse = vlan_parse,
338 .io_clone = vlan_clone,
339 .io_put_attrs = vlan_put_attrs,
340 .io_free = vlan_free,
344 #define IS_VLAN_LINK_ASSERT(link) \
345 if ((link)->l_info_ops != &vlan_info_ops) { \
346 APPBUG("Link is not a vlan link. set type \"vlan\" first."); \
347 return -NLE_OPNOTSUPP; \
385 return link->l_info_ops && !strcmp(link->l_info_ops->io_name,
"vlan");
397 struct vlan_info *vi = link->l_info;
399 IS_VLAN_LINK_ASSERT(link);
402 vi->vi_mask |= VLAN_HAS_ID;
415 struct vlan_info *vi = link->l_info;
417 IS_VLAN_LINK_ASSERT(link);
419 if (vi->vi_mask & VLAN_HAS_ID)
420 return vi->vi_vlan_id;
434 struct vlan_info *vi = link->l_info;
436 IS_VLAN_LINK_ASSERT(link);
438 vi->vi_protocol = protocol;
439 vi->vi_mask |= VLAN_HAS_PROTOCOL;
452 struct vlan_info *vi = link->l_info;
454 IS_VLAN_LINK_ASSERT(link);
456 if (vi->vi_mask & VLAN_HAS_PROTOCOL)
457 return vi->vi_protocol;
471 struct vlan_info *vi = link->l_info;
473 IS_VLAN_LINK_ASSERT(link);
475 vi->vi_flags_mask |= flags;
476 vi->vi_flags |= flags;
477 vi->vi_mask |= VLAN_HAS_FLAGS;
491 struct vlan_info *vi = link->l_info;
493 IS_VLAN_LINK_ASSERT(link);
495 vi->vi_flags_mask |= flags;
496 vi->vi_flags &= ~flags;
497 vi->vi_mask |= VLAN_HAS_FLAGS;
510 struct vlan_info *vi = link->l_info;
512 IS_VLAN_LINK_ASSERT(link);
524 int rtnl_link_vlan_set_ingress_map(
struct rtnl_link *link,
int from,
527 struct vlan_info *vi = link->l_info;
529 IS_VLAN_LINK_ASSERT(link);
531 if (from < 0 || from > VLAN_PRIO_MAX)
534 vi->vi_ingress_qos[from] = to;
535 vi->vi_mask |= VLAN_HAS_INGRESS_QOS;
540 uint32_t *rtnl_link_vlan_get_ingress_map(
struct rtnl_link *link)
542 struct vlan_info *vi = link->l_info;
544 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
547 if (vi->vi_mask & VLAN_HAS_INGRESS_QOS)
548 return vi->vi_ingress_qos;
553 int rtnl_link_vlan_set_egress_map(
struct rtnl_link *link, uint32_t from,
int to)
555 struct vlan_info *vi = link->l_info;
557 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
558 return -NLE_OPNOTSUPP;
560 if (to < 0 || to > VLAN_PRIO_MAX)
563 if (vi->vi_negress >= vi->vi_egress_size) {
564 int new_size = vi->vi_egress_size + 32;
567 ptr = realloc(vi->vi_egress_qos, new_size);
571 vi->vi_egress_qos = ptr;
572 vi->vi_egress_size = new_size;
575 vi->vi_egress_qos[vi->vi_negress].vm_from = from;
576 vi->vi_egress_qos[vi->vi_negress].vm_to = to;
578 vi->vi_mask |= VLAN_HAS_EGRESS_QOS;
586 struct vlan_info *vi = link->l_info;
588 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
594 if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
595 *negress = vi->vi_negress;
596 return vi->vi_egress_qos;
605 static const struct trans_tbl vlan_flags[] = {
606 __ADD(VLAN_FLAG_REORDER_HDR, reorder_hdr)
614 char *rtnl_link_vlan_flags2str(
int flags,
char *buf,
size_t len)
616 return __flags2str(flags, buf, len, vlan_flags, ARRAY_SIZE(vlan_flags));
619 int rtnl_link_vlan_str2flags(
const char *name)
621 return __str2flags(name, vlan_flags, ARRAY_SIZE(vlan_flags));
627 static void __init vlan_init(
void)
632 static void __exit vlan_exit(
void)
Dump object briefly on one line.
uint16_t nla_get_u16(struct nlattr *nla)
Return payload of 16 bit integer attribute.
int rtnl_link_vlan_set_flags(struct rtnl_link *link, unsigned int flags)
Set VLAN flags.
struct rtnl_link * rtnl_link_vlan_alloc(void)
Allocate link object of type VLAN.
int rtnl_link_register_info(struct rtnl_link_info_ops *ops)
Register operations for a link info type.
int rtnl_link_vlan_get_flags(struct rtnl_link *link)
Get VLAN flags.
Attribute validation policy.
struct rtnl_link * rtnl_link_alloc(void)
Allocate link object.
Dump all attributes but no statistics.
int nla_memcpy(void *dest, struct nlattr *src, int count)
Copy attribute payload to another memory area.
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
#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 rtnl_link_vlan_get_id(struct rtnl_link *link)
Get VLAN Id.
int rtnl_link_set_type(struct rtnl_link *link, const char *type)
Set type of link object.
int nla_len(const struct nlattr *nla)
Return length of the payload .
#define nla_for_each_nested(pos, nla, rem)
Iterate over a stream of nested attributes.
int rtnl_link_vlan_get_protocol(struct rtnl_link *link)
Get VLAN protocol.
int rtnl_link_vlan_unset_flags(struct rtnl_link *link, unsigned int flags)
Unset VLAN flags.
int rtnl_link_unregister_info(struct rtnl_link_info_ops *ops)
Unregister operations for a link info type.
uint16_t type
Type of attribute or NLA_UNSPEC.
#define NLA_PUT_U16(msg, attrtype, value)
Add 16 bit integer attribute to netlink message.
int rtnl_link_vlan_set_protocol(struct rtnl_link *link, uint16_t protocol)
Set VLAN protocol.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
void rtnl_link_put(struct rtnl_link *link)
Return a link object reference.
int rtnl_link_is_vlan(struct rtnl_link *link)
Check if link is a VLAN link.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
int rtnl_link_vlan_set_id(struct rtnl_link *link, uint16_t id)
Set VLAN ID.