20 #include <netlink-local.h> 21 #include <netlink/netlink.h> 22 #include <netlink/attr.h> 23 #include <netlink/utils.h> 24 #include <netlink/object.h> 25 #include <netlink/route/rtnl.h> 26 #include <netlink/route/link/info-api.h> 27 #include <netlink/route/link/vlan.h> 29 #include <linux/if_vlan.h> 32 #define VLAN_HAS_ID (1<<0) 33 #define VLAN_HAS_FLAGS (1<<1) 34 #define VLAN_HAS_INGRESS_QOS (1<<2) 35 #define VLAN_HAS_EGRESS_QOS (1<<3) 41 uint32_t vi_flags_mask;
42 uint32_t vi_ingress_qos[VLAN_PRIO_MAX+1];
44 uint32_t vi_egress_size;
50 static struct trans_tbl vlan_flags[] = {
51 __ADD(VLAN_FLAG_REORDER_HDR, reorder_hdr)
54 char *rtnl_link_vlan_flags2str(
int flags,
char *buf,
size_t len)
56 return __flags2str(flags, buf, len, vlan_flags, ARRAY_SIZE(vlan_flags));
59 int rtnl_link_vlan_str2flags(
const char *name)
61 return __str2flags(name, vlan_flags, ARRAY_SIZE(vlan_flags));
64 static struct nla_policy vlan_policy[IFLA_VLAN_MAX+1] = {
66 [IFLA_VLAN_FLAGS] = { .minlen =
sizeof(
struct ifla_vlan_flags) },
67 [IFLA_VLAN_INGRESS_QOS] = { .type =
NLA_NESTED },
68 [IFLA_VLAN_EGRESS_QOS] = { .type =
NLA_NESTED },
71 static int vlan_alloc(
struct rtnl_link *link)
75 if ((vi = calloc(1,
sizeof(*vi))) == NULL)
76 return nl_errno(ENOMEM);
83 static int vlan_parse(
struct rtnl_link *link,
struct nlattr *data,
84 struct nlattr *xstats)
86 struct nlattr *tb[IFLA_VLAN_MAX+1];
90 NL_DBG(3,
"Parsing VLAN link info");
95 if ((err = vlan_alloc(link)) < 0)
100 if (tb[IFLA_VLAN_ID]) {
102 vi->vi_mask |= VLAN_HAS_ID;
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))
122 return nl_error(EINVAL,
"Malformed mapping");
125 if (map->from < 0 || map->from > VLAN_PRIO_MAX) {
126 return nl_error(EINVAL,
"VLAN prio %d out of " 130 vi->vi_ingress_qos[map->from] = map->to;
133 vi->vi_mask |= VLAN_HAS_INGRESS_QOS;
136 if (tb[IFLA_VLAN_EGRESS_QOS]) {
137 struct ifla_vlan_qos_mapping *map;
139 int remaining, i = 0;
142 if (
nla_len(nla) <
sizeof(*map))
143 return nl_error(EINVAL,
"Malformed mapping");
148 vi->vi_egress_size = (i + 32) & ~31;
149 vi->vi_egress_qos = calloc(vi->vi_egress_size,
sizeof(*map));
150 if (vi->vi_egress_qos == NULL)
151 return nl_errno(ENOMEM);
156 NL_DBG(4,
"Assigning egress qos mapping %d\n", i);
157 vi->vi_egress_qos[i].vm_from = map->from;
158 vi->vi_egress_qos[i++].vm_to = map->to;
162 vi->vi_mask |= VLAN_HAS_EGRESS_QOS;
170 static void vlan_free(
struct rtnl_link *link)
172 struct vlan_info *vi = link->l_info;
175 free(vi->vi_egress_qos);
176 vi->vi_egress_qos = NULL;
183 static int vlan_dump_brief(
struct rtnl_link *link,
struct nl_dump_params *p,
186 struct vlan_info *vi = link->l_info;
188 dp_dump(p,
"vlan-id %d", vi->vi_vlan_id);
193 static int vlan_dump_full(
struct rtnl_link *link,
struct nl_dump_params *p,
196 struct vlan_info *vi = link->l_info;
200 rtnl_link_vlan_flags2str(vi->vi_flags, buf,
sizeof(buf));
201 dp_dump_line(p, line++,
" vlan-info id %d <%s>\n",
202 vi->vi_vlan_id, buf);
204 if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
205 dp_dump_line(p, line++,
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 dp_new_line(p, line);
213 dp_dump(p,
"%x -> %#08x, ",
214 i, vi->vi_ingress_qos[i]);
215 if (printed++ == 3) {
222 if (printed > 0 && printed != 4)
226 if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
227 dp_dump_line(p, line++,
228 " egress qos/socket prio -> vlan prio mapping:\n");
229 for (i = 0, printed = 0; i < vi->vi_negress; i++) {
231 dp_new_line(p, line);
234 dp_dump(p,
"%#08x -> %x, ",
235 vi->vi_egress_qos[i].vm_from,
236 vi->vi_egress_qos[i].vm_to);
237 if (printed++ == 3) {
243 if (printed > 0 && printed != 4)
250 static int vlan_clone(
struct rtnl_link *dst,
struct rtnl_link *src)
252 struct vlan_info *vdst, *vsrc = src->l_info;
260 vdst->vi_egress_qos = calloc(vsrc->vi_egress_size,
262 if (!vdst->vi_egress_qos)
263 return nl_errno(ENOMEM);
265 memcpy(vdst->vi_egress_qos, vsrc->vi_egress_qos,
266 vsrc->vi_egress_size *
sizeof(
struct vlan_map));
271 static int vlan_put_attrs(
struct nl_msg *msg,
struct rtnl_link *link)
273 struct vlan_info *vi = link->l_info;
277 return nl_errno(ENOBUFS);
279 if (vi->vi_mask & VLAN_HAS_ID)
282 if (vi->vi_mask & VLAN_HAS_FLAGS) {
283 struct ifla_vlan_flags flags = {
284 .flags = vi->vi_flags,
285 .mask = vi->vi_flags_mask,
288 NLA_PUT(msg, IFLA_VLAN_FLAGS,
sizeof(flags), &flags);
291 if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
292 struct ifla_vlan_qos_mapping map;
297 goto nla_put_failure;
299 for (i = 0; i <= VLAN_PRIO_MAX; i++) {
300 if (vi->vi_ingress_qos[i]) {
302 map.to = vi->vi_ingress_qos[i];
304 NLA_PUT(msg, i,
sizeof(map), &map);
311 if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
312 struct ifla_vlan_qos_mapping map;
317 goto nla_put_failure;
319 for (i = 0; i < vi->vi_negress; i++) {
320 map.from = vi->vi_egress_qos[i].vm_from;
321 map.to = vi->vi_egress_qos[i].vm_to;
323 NLA_PUT(msg, i,
sizeof(map), &map);
338 .io_alloc = vlan_alloc,
339 .io_parse = vlan_parse,
342 .io_clone = vlan_clone,
343 .io_put_attrs = vlan_put_attrs,
344 .io_free = vlan_free,
347 int rtnl_link_vlan_set_id(
struct rtnl_link *link,
int id)
349 struct vlan_info *vi = link->l_info;
351 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
352 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
355 vi->vi_mask |= VLAN_HAS_ID;
360 int rtnl_link_vlan_get_id(
struct rtnl_link *link)
362 struct vlan_info *vi = link->l_info;
364 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
365 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
367 if (vi->vi_mask & VLAN_HAS_ID)
368 return vi->vi_vlan_id;
373 int rtnl_link_vlan_set_flags(
struct rtnl_link *link,
unsigned int flags)
375 struct vlan_info *vi = link->l_info;
377 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
378 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
380 vi->vi_flags_mask |= flags;
381 vi->vi_flags |= flags;
382 vi->vi_mask |= VLAN_HAS_FLAGS;
387 int rtnl_link_vlan_unset_flags(
struct rtnl_link *link,
unsigned int flags)
389 struct vlan_info *vi = link->l_info;
391 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
392 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
394 vi->vi_flags_mask |= flags;
395 vi->vi_flags &= ~flags;
396 vi->vi_mask |= VLAN_HAS_FLAGS;
401 unsigned int rtnl_link_vlan_get_flags(
struct rtnl_link *link)
403 struct vlan_info *vi = link->l_info;
405 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
406 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
411 int rtnl_link_vlan_set_ingress_map(
struct rtnl_link *link,
int from,
414 struct vlan_info *vi = link->l_info;
416 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
417 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
419 if (from < 0 || from > VLAN_PRIO_MAX)
420 return nl_error(EINVAL,
"Invalid vlan prio 0..%d",
423 vi->vi_ingress_qos[from] = to;
424 vi->vi_mask |= VLAN_HAS_INGRESS_QOS;
429 uint32_t *rtnl_link_vlan_get_ingress_map(
struct rtnl_link *link)
431 struct vlan_info *vi = link->l_info;
433 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops) {
434 nl_error(EOPNOTSUPP,
"Not a VLAN link");
438 if (vi->vi_mask & VLAN_HAS_INGRESS_QOS)
439 return vi->vi_ingress_qos;
444 int rtnl_link_vlan_set_egress_map(
struct rtnl_link *link, uint32_t from,
int to)
446 struct vlan_info *vi = link->l_info;
448 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
449 return nl_error(EOPNOTSUPP,
"Not a VLAN link");
451 if (to < 0 || to > VLAN_PRIO_MAX)
452 return nl_error(EINVAL,
"Invalid vlan prio 0..%d",
455 if (vi->vi_negress >= vi->vi_egress_size) {
456 int new_size = vi->vi_egress_size + 32;
459 ptr = realloc(vi->vi_egress_qos, new_size);
461 return nl_errno(ENOMEM);
463 vi->vi_egress_qos = ptr;
464 vi->vi_egress_size = new_size;
467 vi->vi_egress_qos[vi->vi_negress].vm_from = from;
468 vi->vi_egress_qos[vi->vi_negress].vm_to = to;
470 vi->vi_mask |= VLAN_HAS_EGRESS_QOS;
475 struct vlan_map *rtnl_link_vlan_get_egress_map(
struct rtnl_link *link,
478 struct vlan_info *vi = link->l_info;
480 if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops) {
481 nl_error(EOPNOTSUPP,
"Not a VLAN link");
485 if (negress == NULL) {
486 nl_error(EINVAL,
"Require pointer to store negress");
490 if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
491 *negress = vi->vi_negress;
492 return vi->vi_egress_qos;
499 static void __init vlan_init(
void)
501 rtnl_link_register_info(&vlan_info_ops);
504 static void __exit vlan_exit(
void)
506 rtnl_link_unregister_info(&vlan_info_ops);
Dump object in a brief one-liner.
uint16_t nla_get_u16(struct nlattr *nla)
Return payload of u16 attribute.
int rtnl_link_set_info_type(struct rtnl_link *link, const char *type)
Specify the info type of a link.
attribute validation policy
int nla_nest_end(struct nl_msg *n, struct nlattr *start)
Finalize nesting of attributes.
#define NLA_PUT(n, attrtype, attrlen, data)
Add a netlink attribute to a netlink message.
int nla_memcpy(void *dest, struct nlattr *src, int count)
Copy a netlink attribute into another memory area.
#define NLA_PUT_U16(n, attrtype, value)
Add a u16 netlink attribute to a netlink message.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, struct nla_policy *policy)
parse nested attributes
void * nla_data(const struct nlattr *nla)
head of payload
int nla_len(const struct nlattr *nla)
length of payload
#define nla_for_each_nested(pos, nla, rem)
iterate over a stream of nested attributes
uint16_t type
Type of attribute or NLA_UNSPEC.
struct nlattr * nla_nest_start(struct nl_msg *n, int attrtype)
Start a new level of nested attributes.
char * io_name
Name of operations, must match name on kernel side.
Dump all attributes but no statistics.