2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
6 * Routing netlink socket interface: protocol independent part.
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
16 * Vitaly E. Lavrov RTA_OK arithmetics was wrong.
19 #include <linux/errno.h>
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/socket.h>
23 #include <linux/kernel.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/fcntl.h>
30 #include <linux/slab.h>
31 #include <linux/interrupt.h>
32 #include <linux/capability.h>
33 #include <linux/skbuff.h>
34 #include <linux/init.h>
35 #include <linux/security.h>
36 #include <linux/mutex.h>
37 #include <linux/if_addr.h>
38 #include <linux/if_bridge.h>
39 #include <linux/if_vlan.h>
40 #include <linux/pci.h>
41 #include <linux/etherdevice.h>
43 #include <asm/uaccess.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <net/switchdev.h>
49 #include <net/protocol.h>
51 #include <net/route.h>
55 #include <net/pkt_sched.h>
56 #include <net/fib_rules.h>
57 #include <net/rtnetlink.h>
58 #include <net/net_namespace.h>
62 rtnl_dumpit_func dumpit
;
63 rtnl_calcit_func calcit
;
66 static DEFINE_MUTEX(rtnl_mutex
);
70 mutex_lock(&rtnl_mutex
);
72 EXPORT_SYMBOL(rtnl_lock
);
74 static struct sk_buff
*defer_kfree_skb_list
;
75 void rtnl_kfree_skbs(struct sk_buff
*head
, struct sk_buff
*tail
)
78 tail
->next
= defer_kfree_skb_list
;
79 defer_kfree_skb_list
= head
;
82 EXPORT_SYMBOL(rtnl_kfree_skbs
);
84 void __rtnl_unlock(void)
86 struct sk_buff
*head
= defer_kfree_skb_list
;
88 defer_kfree_skb_list
= NULL
;
90 mutex_unlock(&rtnl_mutex
);
93 struct sk_buff
*next
= head
->next
;
101 void rtnl_unlock(void)
103 /* This fellow will unlock it for us. */
106 EXPORT_SYMBOL(rtnl_unlock
);
108 int rtnl_trylock(void)
110 return mutex_trylock(&rtnl_mutex
);
112 EXPORT_SYMBOL(rtnl_trylock
);
114 int rtnl_is_locked(void)
116 return mutex_is_locked(&rtnl_mutex
);
118 EXPORT_SYMBOL(rtnl_is_locked
);
120 #ifdef CONFIG_PROVE_LOCKING
121 bool lockdep_rtnl_is_held(void)
123 return lockdep_is_held(&rtnl_mutex
);
125 EXPORT_SYMBOL(lockdep_rtnl_is_held
);
126 #endif /* #ifdef CONFIG_PROVE_LOCKING */
128 static struct rtnl_link
*rtnl_msg_handlers
[RTNL_FAMILY_MAX
+ 1];
130 static inline int rtm_msgindex(int msgtype
)
132 int msgindex
= msgtype
- RTM_BASE
;
135 * msgindex < 0 implies someone tried to register a netlink
136 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
137 * the message type has not been added to linux/rtnetlink.h
139 BUG_ON(msgindex
< 0 || msgindex
>= RTM_NR_MSGTYPES
);
144 static rtnl_doit_func
rtnl_get_doit(int protocol
, int msgindex
)
146 struct rtnl_link
*tab
;
148 if (protocol
<= RTNL_FAMILY_MAX
)
149 tab
= rtnl_msg_handlers
[protocol
];
153 if (tab
== NULL
|| tab
[msgindex
].doit
== NULL
)
154 tab
= rtnl_msg_handlers
[PF_UNSPEC
];
156 return tab
[msgindex
].doit
;
159 static rtnl_dumpit_func
rtnl_get_dumpit(int protocol
, int msgindex
)
161 struct rtnl_link
*tab
;
163 if (protocol
<= RTNL_FAMILY_MAX
)
164 tab
= rtnl_msg_handlers
[protocol
];
168 if (tab
== NULL
|| tab
[msgindex
].dumpit
== NULL
)
169 tab
= rtnl_msg_handlers
[PF_UNSPEC
];
171 return tab
[msgindex
].dumpit
;
174 static rtnl_calcit_func
rtnl_get_calcit(int protocol
, int msgindex
)
176 struct rtnl_link
*tab
;
178 if (protocol
<= RTNL_FAMILY_MAX
)
179 tab
= rtnl_msg_handlers
[protocol
];
183 if (tab
== NULL
|| tab
[msgindex
].calcit
== NULL
)
184 tab
= rtnl_msg_handlers
[PF_UNSPEC
];
186 return tab
[msgindex
].calcit
;
190 * __rtnl_register - Register a rtnetlink message type
191 * @protocol: Protocol family or PF_UNSPEC
192 * @msgtype: rtnetlink message type
193 * @doit: Function pointer called for each request message
194 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
195 * @calcit: Function pointer to calc size of dump message
197 * Registers the specified function pointers (at least one of them has
198 * to be non-NULL) to be called whenever a request message for the
199 * specified protocol family and message type is received.
201 * The special protocol family PF_UNSPEC may be used to define fallback
202 * function pointers for the case when no entry for the specific protocol
205 * Returns 0 on success or a negative error code.
207 int __rtnl_register(int protocol
, int msgtype
,
208 rtnl_doit_func doit
, rtnl_dumpit_func dumpit
,
209 rtnl_calcit_func calcit
)
211 struct rtnl_link
*tab
;
214 BUG_ON(protocol
< 0 || protocol
> RTNL_FAMILY_MAX
);
215 msgindex
= rtm_msgindex(msgtype
);
217 tab
= rtnl_msg_handlers
[protocol
];
219 tab
= kcalloc(RTM_NR_MSGTYPES
, sizeof(*tab
), GFP_KERNEL
);
223 rtnl_msg_handlers
[protocol
] = tab
;
227 tab
[msgindex
].doit
= doit
;
230 tab
[msgindex
].dumpit
= dumpit
;
233 tab
[msgindex
].calcit
= calcit
;
237 EXPORT_SYMBOL_GPL(__rtnl_register
);
240 * rtnl_register - Register a rtnetlink message type
242 * Identical to __rtnl_register() but panics on failure. This is useful
243 * as failure of this function is very unlikely, it can only happen due
244 * to lack of memory when allocating the chain to store all message
245 * handlers for a protocol. Meant for use in init functions where lack
246 * of memory implies no sense in continuing.
248 void rtnl_register(int protocol
, int msgtype
,
249 rtnl_doit_func doit
, rtnl_dumpit_func dumpit
,
250 rtnl_calcit_func calcit
)
252 if (__rtnl_register(protocol
, msgtype
, doit
, dumpit
, calcit
) < 0)
253 panic("Unable to register rtnetlink message handler, "
254 "protocol = %d, message type = %d\n",
257 EXPORT_SYMBOL_GPL(rtnl_register
);
260 * rtnl_unregister - Unregister a rtnetlink message type
261 * @protocol: Protocol family or PF_UNSPEC
262 * @msgtype: rtnetlink message type
264 * Returns 0 on success or a negative error code.
266 int rtnl_unregister(int protocol
, int msgtype
)
270 BUG_ON(protocol
< 0 || protocol
> RTNL_FAMILY_MAX
);
271 msgindex
= rtm_msgindex(msgtype
);
273 if (rtnl_msg_handlers
[protocol
] == NULL
)
276 rtnl_msg_handlers
[protocol
][msgindex
].doit
= NULL
;
277 rtnl_msg_handlers
[protocol
][msgindex
].dumpit
= NULL
;
281 EXPORT_SYMBOL_GPL(rtnl_unregister
);
284 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
285 * @protocol : Protocol family or PF_UNSPEC
287 * Identical to calling rtnl_unregster() for all registered message types
288 * of a certain protocol family.
290 void rtnl_unregister_all(int protocol
)
292 BUG_ON(protocol
< 0 || protocol
> RTNL_FAMILY_MAX
);
294 kfree(rtnl_msg_handlers
[protocol
]);
295 rtnl_msg_handlers
[protocol
] = NULL
;
297 EXPORT_SYMBOL_GPL(rtnl_unregister_all
);
299 static LIST_HEAD(link_ops
);
301 static const struct rtnl_link_ops
*rtnl_link_ops_get(const char *kind
)
303 const struct rtnl_link_ops
*ops
;
305 list_for_each_entry(ops
, &link_ops
, list
) {
306 if (!strcmp(ops
->kind
, kind
))
313 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink.
314 * @ops: struct rtnl_link_ops * to register
316 * The caller must hold the rtnl_mutex. This function should be used
317 * by drivers that create devices during module initialization. It
318 * must be called before registering the devices.
320 * Returns 0 on success or a negative error code.
322 int __rtnl_link_register(struct rtnl_link_ops
*ops
)
324 if (rtnl_link_ops_get(ops
->kind
))
327 /* The check for setup is here because if ops
328 * does not have that filled up, it is not possible
329 * to use the ops for creating device. So do not
330 * fill up dellink as well. That disables rtnl_dellink.
332 if (ops
->setup
&& !ops
->dellink
)
333 ops
->dellink
= unregister_netdevice_queue
;
335 list_add_tail(&ops
->list
, &link_ops
);
338 EXPORT_SYMBOL_GPL(__rtnl_link_register
);
341 * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
342 * @ops: struct rtnl_link_ops * to register
344 * Returns 0 on success or a negative error code.
346 int rtnl_link_register(struct rtnl_link_ops
*ops
)
351 err
= __rtnl_link_register(ops
);
355 EXPORT_SYMBOL_GPL(rtnl_link_register
);
357 static void __rtnl_kill_links(struct net
*net
, struct rtnl_link_ops
*ops
)
359 struct net_device
*dev
;
360 LIST_HEAD(list_kill
);
362 for_each_netdev(net
, dev
) {
363 if (dev
->rtnl_link_ops
== ops
)
364 ops
->dellink(dev
, &list_kill
);
366 unregister_netdevice_many(&list_kill
);
370 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
371 * @ops: struct rtnl_link_ops * to unregister
373 * The caller must hold the rtnl_mutex.
375 void __rtnl_link_unregister(struct rtnl_link_ops
*ops
)
380 __rtnl_kill_links(net
, ops
);
382 list_del(&ops
->list
);
384 EXPORT_SYMBOL_GPL(__rtnl_link_unregister
);
386 /* Return with the rtnl_lock held when there are no network
387 * devices unregistering in any network namespace.
389 static void rtnl_lock_unregistering_all(void)
393 DEFINE_WAIT_FUNC(wait
, woken_wake_function
);
395 add_wait_queue(&netdev_unregistering_wq
, &wait
);
397 unregistering
= false;
400 if (net
->dev_unreg_count
> 0) {
401 unregistering
= true;
409 wait_woken(&wait
, TASK_UNINTERRUPTIBLE
, MAX_SCHEDULE_TIMEOUT
);
411 remove_wait_queue(&netdev_unregistering_wq
, &wait
);
415 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
416 * @ops: struct rtnl_link_ops * to unregister
418 void rtnl_link_unregister(struct rtnl_link_ops
*ops
)
420 /* Close the race with cleanup_net() */
421 mutex_lock(&net_mutex
);
422 rtnl_lock_unregistering_all();
423 __rtnl_link_unregister(ops
);
425 mutex_unlock(&net_mutex
);
427 EXPORT_SYMBOL_GPL(rtnl_link_unregister
);
429 static size_t rtnl_link_get_slave_info_data_size(const struct net_device
*dev
)
431 struct net_device
*master_dev
;
432 const struct rtnl_link_ops
*ops
;
434 master_dev
= netdev_master_upper_dev_get((struct net_device
*) dev
);
437 ops
= master_dev
->rtnl_link_ops
;
438 if (!ops
|| !ops
->get_slave_size
)
440 /* IFLA_INFO_SLAVE_DATA + nested data */
441 return nla_total_size(sizeof(struct nlattr
)) +
442 ops
->get_slave_size(master_dev
, dev
);
445 static size_t rtnl_link_get_size(const struct net_device
*dev
)
447 const struct rtnl_link_ops
*ops
= dev
->rtnl_link_ops
;
453 size
= nla_total_size(sizeof(struct nlattr
)) + /* IFLA_LINKINFO */
454 nla_total_size(strlen(ops
->kind
) + 1); /* IFLA_INFO_KIND */
457 /* IFLA_INFO_DATA + nested data */
458 size
+= nla_total_size(sizeof(struct nlattr
)) +
461 if (ops
->get_xstats_size
)
462 /* IFLA_INFO_XSTATS */
463 size
+= nla_total_size(ops
->get_xstats_size(dev
));
465 size
+= rtnl_link_get_slave_info_data_size(dev
);
470 static LIST_HEAD(rtnl_af_ops
);
472 static const struct rtnl_af_ops
*rtnl_af_lookup(const int family
)
474 const struct rtnl_af_ops
*ops
;
476 list_for_each_entry(ops
, &rtnl_af_ops
, list
) {
477 if (ops
->family
== family
)
485 * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
486 * @ops: struct rtnl_af_ops * to register
488 * Returns 0 on success or a negative error code.
490 void rtnl_af_register(struct rtnl_af_ops
*ops
)
493 list_add_tail(&ops
->list
, &rtnl_af_ops
);
496 EXPORT_SYMBOL_GPL(rtnl_af_register
);
499 * __rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
500 * @ops: struct rtnl_af_ops * to unregister
502 * The caller must hold the rtnl_mutex.
504 void __rtnl_af_unregister(struct rtnl_af_ops
*ops
)
506 list_del(&ops
->list
);
508 EXPORT_SYMBOL_GPL(__rtnl_af_unregister
);
511 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
512 * @ops: struct rtnl_af_ops * to unregister
514 void rtnl_af_unregister(struct rtnl_af_ops
*ops
)
517 __rtnl_af_unregister(ops
);
520 EXPORT_SYMBOL_GPL(rtnl_af_unregister
);
522 static size_t rtnl_link_get_af_size(const struct net_device
*dev
,
525 struct rtnl_af_ops
*af_ops
;
529 size
= nla_total_size(sizeof(struct nlattr
));
531 list_for_each_entry(af_ops
, &rtnl_af_ops
, list
) {
532 if (af_ops
->get_link_af_size
) {
533 /* AF_* + nested data */
534 size
+= nla_total_size(sizeof(struct nlattr
)) +
535 af_ops
->get_link_af_size(dev
, ext_filter_mask
);
542 static bool rtnl_have_link_slave_info(const struct net_device
*dev
)
544 struct net_device
*master_dev
;
546 master_dev
= netdev_master_upper_dev_get((struct net_device
*) dev
);
547 if (master_dev
&& master_dev
->rtnl_link_ops
)
552 static int rtnl_link_slave_info_fill(struct sk_buff
*skb
,
553 const struct net_device
*dev
)
555 struct net_device
*master_dev
;
556 const struct rtnl_link_ops
*ops
;
557 struct nlattr
*slave_data
;
560 master_dev
= netdev_master_upper_dev_get((struct net_device
*) dev
);
563 ops
= master_dev
->rtnl_link_ops
;
566 if (nla_put_string(skb
, IFLA_INFO_SLAVE_KIND
, ops
->kind
) < 0)
568 if (ops
->fill_slave_info
) {
569 slave_data
= nla_nest_start(skb
, IFLA_INFO_SLAVE_DATA
);
572 err
= ops
->fill_slave_info(skb
, master_dev
, dev
);
574 goto err_cancel_slave_data
;
575 nla_nest_end(skb
, slave_data
);
579 err_cancel_slave_data
:
580 nla_nest_cancel(skb
, slave_data
);
584 static int rtnl_link_info_fill(struct sk_buff
*skb
,
585 const struct net_device
*dev
)
587 const struct rtnl_link_ops
*ops
= dev
->rtnl_link_ops
;
593 if (nla_put_string(skb
, IFLA_INFO_KIND
, ops
->kind
) < 0)
595 if (ops
->fill_xstats
) {
596 err
= ops
->fill_xstats(skb
, dev
);
600 if (ops
->fill_info
) {
601 data
= nla_nest_start(skb
, IFLA_INFO_DATA
);
604 err
= ops
->fill_info(skb
, dev
);
606 goto err_cancel_data
;
607 nla_nest_end(skb
, data
);
612 nla_nest_cancel(skb
, data
);
616 static int rtnl_link_fill(struct sk_buff
*skb
, const struct net_device
*dev
)
618 struct nlattr
*linkinfo
;
621 linkinfo
= nla_nest_start(skb
, IFLA_LINKINFO
);
622 if (linkinfo
== NULL
)
625 err
= rtnl_link_info_fill(skb
, dev
);
627 goto err_cancel_link
;
629 err
= rtnl_link_slave_info_fill(skb
, dev
);
631 goto err_cancel_link
;
633 nla_nest_end(skb
, linkinfo
);
637 nla_nest_cancel(skb
, linkinfo
);
642 int rtnetlink_send(struct sk_buff
*skb
, struct net
*net
, u32 pid
, unsigned int group
, int echo
)
644 struct sock
*rtnl
= net
->rtnl
;
647 NETLINK_CB(skb
).dst_group
= group
;
649 atomic_inc(&skb
->users
);
650 netlink_broadcast(rtnl
, skb
, pid
, group
, GFP_KERNEL
);
652 err
= netlink_unicast(rtnl
, skb
, pid
, MSG_DONTWAIT
);
656 int rtnl_unicast(struct sk_buff
*skb
, struct net
*net
, u32 pid
)
658 struct sock
*rtnl
= net
->rtnl
;
660 return nlmsg_unicast(rtnl
, skb
, pid
);
662 EXPORT_SYMBOL(rtnl_unicast
);
664 void rtnl_notify(struct sk_buff
*skb
, struct net
*net
, u32 pid
, u32 group
,
665 struct nlmsghdr
*nlh
, gfp_t flags
)
667 struct sock
*rtnl
= net
->rtnl
;
671 report
= nlmsg_report(nlh
);
673 nlmsg_notify(rtnl
, skb
, pid
, group
, report
, flags
);
675 EXPORT_SYMBOL(rtnl_notify
);
677 void rtnl_set_sk_err(struct net
*net
, u32 group
, int error
)
679 struct sock
*rtnl
= net
->rtnl
;
681 netlink_set_err(rtnl
, 0, group
, error
);
683 EXPORT_SYMBOL(rtnl_set_sk_err
);
685 int rtnetlink_put_metrics(struct sk_buff
*skb
, u32
*metrics
)
690 mx
= nla_nest_start(skb
, RTA_METRICS
);
694 for (i
= 0; i
< RTAX_MAX
; i
++) {
696 if (i
== RTAX_CC_ALGO
- 1) {
697 char tmp
[TCP_CA_NAME_MAX
], *name
;
699 name
= tcp_ca_get_name_by_key(metrics
[i
], tmp
);
702 if (nla_put_string(skb
, i
+ 1, name
))
703 goto nla_put_failure
;
704 } else if (i
== RTAX_FEATURES
- 1) {
705 u32 user_features
= metrics
[i
] & RTAX_FEATURE_MASK
;
709 BUILD_BUG_ON(RTAX_FEATURE_MASK
& DST_FEATURE_MASK
);
710 if (nla_put_u32(skb
, i
+ 1, user_features
))
711 goto nla_put_failure
;
713 if (nla_put_u32(skb
, i
+ 1, metrics
[i
]))
714 goto nla_put_failure
;
721 nla_nest_cancel(skb
, mx
);
725 return nla_nest_end(skb
, mx
);
728 nla_nest_cancel(skb
, mx
);
731 EXPORT_SYMBOL(rtnetlink_put_metrics
);
733 int rtnl_put_cacheinfo(struct sk_buff
*skb
, struct dst_entry
*dst
, u32 id
,
734 long expires
, u32 error
)
736 struct rta_cacheinfo ci
= {
737 .rta_lastuse
= jiffies_delta_to_clock_t(jiffies
- dst
->lastuse
),
738 .rta_used
= dst
->__use
,
739 .rta_clntref
= atomic_read(&(dst
->__refcnt
)),
747 clock
= jiffies_to_clock_t(abs(expires
));
748 clock
= min_t(unsigned long, clock
, INT_MAX
);
749 ci
.rta_expires
= (expires
> 0) ? clock
: -clock
;
751 return nla_put(skb
, RTA_CACHEINFO
, sizeof(ci
), &ci
);
753 EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo
);
755 static void set_operstate(struct net_device
*dev
, unsigned char transition
)
757 unsigned char operstate
= dev
->operstate
;
759 switch (transition
) {
761 if ((operstate
== IF_OPER_DORMANT
||
762 operstate
== IF_OPER_UNKNOWN
) &&
764 operstate
= IF_OPER_UP
;
767 case IF_OPER_DORMANT
:
768 if (operstate
== IF_OPER_UP
||
769 operstate
== IF_OPER_UNKNOWN
)
770 operstate
= IF_OPER_DORMANT
;
774 if (dev
->operstate
!= operstate
) {
775 write_lock_bh(&dev_base_lock
);
776 dev
->operstate
= operstate
;
777 write_unlock_bh(&dev_base_lock
);
778 netdev_state_change(dev
);
782 static unsigned int rtnl_dev_get_flags(const struct net_device
*dev
)
784 return (dev
->flags
& ~(IFF_PROMISC
| IFF_ALLMULTI
)) |
785 (dev
->gflags
& (IFF_PROMISC
| IFF_ALLMULTI
));
788 static unsigned int rtnl_dev_combine_flags(const struct net_device
*dev
,
789 const struct ifinfomsg
*ifm
)
791 unsigned int flags
= ifm
->ifi_flags
;
793 /* bugwards compatibility: ifi_change == 0 is treated as ~0 */
795 flags
= (flags
& ifm
->ifi_change
) |
796 (rtnl_dev_get_flags(dev
) & ~ifm
->ifi_change
);
801 static void copy_rtnl_link_stats(struct rtnl_link_stats
*a
,
802 const struct rtnl_link_stats64
*b
)
804 a
->rx_packets
= b
->rx_packets
;
805 a
->tx_packets
= b
->tx_packets
;
806 a
->rx_bytes
= b
->rx_bytes
;
807 a
->tx_bytes
= b
->tx_bytes
;
808 a
->rx_errors
= b
->rx_errors
;
809 a
->tx_errors
= b
->tx_errors
;
810 a
->rx_dropped
= b
->rx_dropped
;
811 a
->tx_dropped
= b
->tx_dropped
;
813 a
->multicast
= b
->multicast
;
814 a
->collisions
= b
->collisions
;
816 a
->rx_length_errors
= b
->rx_length_errors
;
817 a
->rx_over_errors
= b
->rx_over_errors
;
818 a
->rx_crc_errors
= b
->rx_crc_errors
;
819 a
->rx_frame_errors
= b
->rx_frame_errors
;
820 a
->rx_fifo_errors
= b
->rx_fifo_errors
;
821 a
->rx_missed_errors
= b
->rx_missed_errors
;
823 a
->tx_aborted_errors
= b
->tx_aborted_errors
;
824 a
->tx_carrier_errors
= b
->tx_carrier_errors
;
825 a
->tx_fifo_errors
= b
->tx_fifo_errors
;
826 a
->tx_heartbeat_errors
= b
->tx_heartbeat_errors
;
827 a
->tx_window_errors
= b
->tx_window_errors
;
829 a
->rx_compressed
= b
->rx_compressed
;
830 a
->tx_compressed
= b
->tx_compressed
;
832 a
->rx_nohandler
= b
->rx_nohandler
;
836 static inline int rtnl_vfinfo_size(const struct net_device
*dev
,
839 if (dev
->dev
.parent
&& dev_is_pci(dev
->dev
.parent
) &&
840 (ext_filter_mask
& RTEXT_FILTER_VF
)) {
841 int num_vfs
= dev_num_vf(dev
->dev
.parent
);
842 size_t size
= nla_total_size(sizeof(struct nlattr
));
843 size
+= nla_total_size(num_vfs
* sizeof(struct nlattr
));
845 (nla_total_size(sizeof(struct ifla_vf_mac
)) +
846 nla_total_size(MAX_VLAN_LIST_LEN
*
847 sizeof(struct nlattr
)) +
848 nla_total_size(MAX_VLAN_LIST_LEN
*
849 sizeof(struct ifla_vf_vlan_info
)) +
850 nla_total_size(sizeof(struct ifla_vf_spoofchk
)) +
851 nla_total_size(sizeof(struct ifla_vf_rate
)) +
852 nla_total_size(sizeof(struct ifla_vf_link_state
)) +
853 nla_total_size(sizeof(struct ifla_vf_rss_query_en
)) +
854 /* IFLA_VF_STATS_RX_PACKETS */
855 nla_total_size_64bit(sizeof(__u64
)) +
856 /* IFLA_VF_STATS_TX_PACKETS */
857 nla_total_size_64bit(sizeof(__u64
)) +
858 /* IFLA_VF_STATS_RX_BYTES */
859 nla_total_size_64bit(sizeof(__u64
)) +
860 /* IFLA_VF_STATS_TX_BYTES */
861 nla_total_size_64bit(sizeof(__u64
)) +
862 /* IFLA_VF_STATS_BROADCAST */
863 nla_total_size_64bit(sizeof(__u64
)) +
864 /* IFLA_VF_STATS_MULTICAST */
865 nla_total_size_64bit(sizeof(__u64
)) +
866 nla_total_size(sizeof(struct ifla_vf_trust
)));
872 static size_t rtnl_port_size(const struct net_device
*dev
,
875 size_t port_size
= nla_total_size(4) /* PORT_VF */
876 + nla_total_size(PORT_PROFILE_MAX
) /* PORT_PROFILE */
877 + nla_total_size(sizeof(struct ifla_port_vsi
))
879 + nla_total_size(PORT_UUID_MAX
) /* PORT_INSTANCE_UUID */
880 + nla_total_size(PORT_UUID_MAX
) /* PORT_HOST_UUID */
881 + nla_total_size(1) /* PROT_VDP_REQUEST */
882 + nla_total_size(2); /* PORT_VDP_RESPONSE */
883 size_t vf_ports_size
= nla_total_size(sizeof(struct nlattr
));
884 size_t vf_port_size
= nla_total_size(sizeof(struct nlattr
))
886 size_t port_self_size
= nla_total_size(sizeof(struct nlattr
))
889 if (!dev
->netdev_ops
->ndo_get_vf_port
|| !dev
->dev
.parent
||
890 !(ext_filter_mask
& RTEXT_FILTER_VF
))
892 if (dev_num_vf(dev
->dev
.parent
))
893 return port_self_size
+ vf_ports_size
+
894 vf_port_size
* dev_num_vf(dev
->dev
.parent
);
896 return port_self_size
;
899 static size_t rtnl_xdp_size(const struct net_device
*dev
)
901 size_t xdp_size
= nla_total_size(1); /* XDP_ATTACHED */
903 if (!dev
->netdev_ops
->ndo_xdp
)
909 static noinline
size_t if_nlmsg_size(const struct net_device
*dev
,
912 return NLMSG_ALIGN(sizeof(struct ifinfomsg
))
913 + nla_total_size(IFNAMSIZ
) /* IFLA_IFNAME */
914 + nla_total_size(IFALIASZ
) /* IFLA_IFALIAS */
915 + nla_total_size(IFNAMSIZ
) /* IFLA_QDISC */
916 + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap
))
917 + nla_total_size(sizeof(struct rtnl_link_stats
))
918 + nla_total_size_64bit(sizeof(struct rtnl_link_stats64
))
919 + nla_total_size(MAX_ADDR_LEN
) /* IFLA_ADDRESS */
920 + nla_total_size(MAX_ADDR_LEN
) /* IFLA_BROADCAST */
921 + nla_total_size(4) /* IFLA_TXQLEN */
922 + nla_total_size(4) /* IFLA_WEIGHT */
923 + nla_total_size(4) /* IFLA_MTU */
924 + nla_total_size(4) /* IFLA_LINK */
925 + nla_total_size(4) /* IFLA_MASTER */
926 + nla_total_size(1) /* IFLA_CARRIER */
927 + nla_total_size(4) /* IFLA_PROMISCUITY */
928 + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
929 + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
930 + nla_total_size(4) /* IFLA_MAX_GSO_SEGS */
931 + nla_total_size(4) /* IFLA_MAX_GSO_SIZE */
932 + nla_total_size(1) /* IFLA_OPERSTATE */
933 + nla_total_size(1) /* IFLA_LINKMODE */
934 + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
935 + nla_total_size(4) /* IFLA_LINK_NETNSID */
936 + nla_total_size(ext_filter_mask
937 & RTEXT_FILTER_VF
? 4 : 0) /* IFLA_NUM_VF */
938 + rtnl_vfinfo_size(dev
, ext_filter_mask
) /* IFLA_VFINFO_LIST */
939 + rtnl_port_size(dev
, ext_filter_mask
) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
940 + rtnl_link_get_size(dev
) /* IFLA_LINKINFO */
941 + rtnl_link_get_af_size(dev
, ext_filter_mask
) /* IFLA_AF_SPEC */
942 + nla_total_size(MAX_PHYS_ITEM_ID_LEN
) /* IFLA_PHYS_PORT_ID */
943 + nla_total_size(MAX_PHYS_ITEM_ID_LEN
) /* IFLA_PHYS_SWITCH_ID */
944 + nla_total_size(IFNAMSIZ
) /* IFLA_PHYS_PORT_NAME */
945 + rtnl_xdp_size(dev
) /* IFLA_XDP */
946 + nla_total_size(1); /* IFLA_PROTO_DOWN */
950 static int rtnl_vf_ports_fill(struct sk_buff
*skb
, struct net_device
*dev
)
952 struct nlattr
*vf_ports
;
953 struct nlattr
*vf_port
;
957 vf_ports
= nla_nest_start(skb
, IFLA_VF_PORTS
);
961 for (vf
= 0; vf
< dev_num_vf(dev
->dev
.parent
); vf
++) {
962 vf_port
= nla_nest_start(skb
, IFLA_VF_PORT
);
964 goto nla_put_failure
;
965 if (nla_put_u32(skb
, IFLA_PORT_VF
, vf
))
966 goto nla_put_failure
;
967 err
= dev
->netdev_ops
->ndo_get_vf_port(dev
, vf
, skb
);
968 if (err
== -EMSGSIZE
)
969 goto nla_put_failure
;
971 nla_nest_cancel(skb
, vf_port
);
974 nla_nest_end(skb
, vf_port
);
977 nla_nest_end(skb
, vf_ports
);
982 nla_nest_cancel(skb
, vf_ports
);
986 static int rtnl_port_self_fill(struct sk_buff
*skb
, struct net_device
*dev
)
988 struct nlattr
*port_self
;
991 port_self
= nla_nest_start(skb
, IFLA_PORT_SELF
);
995 err
= dev
->netdev_ops
->ndo_get_vf_port(dev
, PORT_SELF_VF
, skb
);
997 nla_nest_cancel(skb
, port_self
);
998 return (err
== -EMSGSIZE
) ? err
: 0;
1001 nla_nest_end(skb
, port_self
);
1006 static int rtnl_port_fill(struct sk_buff
*skb
, struct net_device
*dev
,
1007 u32 ext_filter_mask
)
1011 if (!dev
->netdev_ops
->ndo_get_vf_port
|| !dev
->dev
.parent
||
1012 !(ext_filter_mask
& RTEXT_FILTER_VF
))
1015 err
= rtnl_port_self_fill(skb
, dev
);
1019 if (dev_num_vf(dev
->dev
.parent
)) {
1020 err
= rtnl_vf_ports_fill(skb
, dev
);
1028 static int rtnl_phys_port_id_fill(struct sk_buff
*skb
, struct net_device
*dev
)
1031 struct netdev_phys_item_id ppid
;
1033 err
= dev_get_phys_port_id(dev
, &ppid
);
1035 if (err
== -EOPNOTSUPP
)
1040 if (nla_put(skb
, IFLA_PHYS_PORT_ID
, ppid
.id_len
, ppid
.id
))
1046 static int rtnl_phys_port_name_fill(struct sk_buff
*skb
, struct net_device
*dev
)
1048 char name
[IFNAMSIZ
];
1051 err
= dev_get_phys_port_name(dev
, name
, sizeof(name
));
1053 if (err
== -EOPNOTSUPP
)
1058 if (nla_put(skb
, IFLA_PHYS_PORT_NAME
, strlen(name
), name
))
1064 static int rtnl_phys_switch_id_fill(struct sk_buff
*skb
, struct net_device
*dev
)
1067 struct switchdev_attr attr
= {
1069 .id
= SWITCHDEV_ATTR_ID_PORT_PARENT_ID
,
1070 .flags
= SWITCHDEV_F_NO_RECURSE
,
1073 err
= switchdev_port_attr_get(dev
, &attr
);
1075 if (err
== -EOPNOTSUPP
)
1080 if (nla_put(skb
, IFLA_PHYS_SWITCH_ID
, attr
.u
.ppid
.id_len
,
1087 static noinline_for_stack
int rtnl_fill_stats(struct sk_buff
*skb
,
1088 struct net_device
*dev
)
1090 struct rtnl_link_stats64
*sp
;
1091 struct nlattr
*attr
;
1093 attr
= nla_reserve_64bit(skb
, IFLA_STATS64
,
1094 sizeof(struct rtnl_link_stats64
), IFLA_PAD
);
1098 sp
= nla_data(attr
);
1099 dev_get_stats(dev
, sp
);
1101 attr
= nla_reserve(skb
, IFLA_STATS
,
1102 sizeof(struct rtnl_link_stats
));
1106 copy_rtnl_link_stats(nla_data(attr
), sp
);
1111 static noinline_for_stack
int rtnl_fill_vfinfo(struct sk_buff
*skb
,
1112 struct net_device
*dev
,
1114 struct nlattr
*vfinfo
)
1116 struct ifla_vf_rss_query_en vf_rss_query_en
;
1117 struct nlattr
*vf
, *vfstats
, *vfvlanlist
;
1118 struct ifla_vf_link_state vf_linkstate
;
1119 struct ifla_vf_vlan_info vf_vlan_info
;
1120 struct ifla_vf_spoofchk vf_spoofchk
;
1121 struct ifla_vf_tx_rate vf_tx_rate
;
1122 struct ifla_vf_stats vf_stats
;
1123 struct ifla_vf_trust vf_trust
;
1124 struct ifla_vf_vlan vf_vlan
;
1125 struct ifla_vf_rate vf_rate
;
1126 struct ifla_vf_mac vf_mac
;
1127 struct ifla_vf_info ivi
;
1129 /* Not all SR-IOV capable drivers support the
1130 * spoofcheck and "RSS query enable" query. Preset to
1131 * -1 so the user space tool can detect that the driver
1132 * didn't report anything.
1135 ivi
.rss_query_en
= -1;
1137 memset(ivi
.mac
, 0, sizeof(ivi
.mac
));
1138 /* The default value for VF link state is "auto"
1139 * IFLA_VF_LINK_STATE_AUTO which equals zero
1142 /* VLAN Protocol by default is 802.1Q */
1143 ivi
.vlan_proto
= htons(ETH_P_8021Q
);
1144 if (dev
->netdev_ops
->ndo_get_vf_config(dev
, vfs_num
, &ivi
))
1154 vf_rss_query_en
.vf
=
1155 vf_trust
.vf
= ivi
.vf
;
1157 memcpy(vf_mac
.mac
, ivi
.mac
, sizeof(ivi
.mac
));
1158 vf_vlan
.vlan
= ivi
.vlan
;
1159 vf_vlan
.qos
= ivi
.qos
;
1160 vf_vlan_info
.vlan
= ivi
.vlan
;
1161 vf_vlan_info
.qos
= ivi
.qos
;
1162 vf_vlan_info
.vlan_proto
= ivi
.vlan_proto
;
1163 vf_tx_rate
.rate
= ivi
.max_tx_rate
;
1164 vf_rate
.min_tx_rate
= ivi
.min_tx_rate
;
1165 vf_rate
.max_tx_rate
= ivi
.max_tx_rate
;
1166 vf_spoofchk
.setting
= ivi
.spoofchk
;
1167 vf_linkstate
.link_state
= ivi
.linkstate
;
1168 vf_rss_query_en
.setting
= ivi
.rss_query_en
;
1169 vf_trust
.setting
= ivi
.trusted
;
1170 vf
= nla_nest_start(skb
, IFLA_VF_INFO
);
1172 goto nla_put_vfinfo_failure
;
1173 if (nla_put(skb
, IFLA_VF_MAC
, sizeof(vf_mac
), &vf_mac
) ||
1174 nla_put(skb
, IFLA_VF_VLAN
, sizeof(vf_vlan
), &vf_vlan
) ||
1175 nla_put(skb
, IFLA_VF_RATE
, sizeof(vf_rate
),
1177 nla_put(skb
, IFLA_VF_TX_RATE
, sizeof(vf_tx_rate
),
1179 nla_put(skb
, IFLA_VF_SPOOFCHK
, sizeof(vf_spoofchk
),
1181 nla_put(skb
, IFLA_VF_LINK_STATE
, sizeof(vf_linkstate
),
1183 nla_put(skb
, IFLA_VF_RSS_QUERY_EN
,
1184 sizeof(vf_rss_query_en
),
1185 &vf_rss_query_en
) ||
1186 nla_put(skb
, IFLA_VF_TRUST
,
1187 sizeof(vf_trust
), &vf_trust
))
1188 goto nla_put_vf_failure
;
1189 vfvlanlist
= nla_nest_start(skb
, IFLA_VF_VLAN_LIST
);
1191 goto nla_put_vf_failure
;
1192 if (nla_put(skb
, IFLA_VF_VLAN_INFO
, sizeof(vf_vlan_info
),
1194 nla_nest_cancel(skb
, vfvlanlist
);
1195 goto nla_put_vf_failure
;
1197 nla_nest_end(skb
, vfvlanlist
);
1198 memset(&vf_stats
, 0, sizeof(vf_stats
));
1199 if (dev
->netdev_ops
->ndo_get_vf_stats
)
1200 dev
->netdev_ops
->ndo_get_vf_stats(dev
, vfs_num
,
1202 vfstats
= nla_nest_start(skb
, IFLA_VF_STATS
);
1204 goto nla_put_vf_failure
;
1205 if (nla_put_u64_64bit(skb
, IFLA_VF_STATS_RX_PACKETS
,
1206 vf_stats
.rx_packets
, IFLA_VF_STATS_PAD
) ||
1207 nla_put_u64_64bit(skb
, IFLA_VF_STATS_TX_PACKETS
,
1208 vf_stats
.tx_packets
, IFLA_VF_STATS_PAD
) ||
1209 nla_put_u64_64bit(skb
, IFLA_VF_STATS_RX_BYTES
,
1210 vf_stats
.rx_bytes
, IFLA_VF_STATS_PAD
) ||
1211 nla_put_u64_64bit(skb
, IFLA_VF_STATS_TX_BYTES
,
1212 vf_stats
.tx_bytes
, IFLA_VF_STATS_PAD
) ||
1213 nla_put_u64_64bit(skb
, IFLA_VF_STATS_BROADCAST
,
1214 vf_stats
.broadcast
, IFLA_VF_STATS_PAD
) ||
1215 nla_put_u64_64bit(skb
, IFLA_VF_STATS_MULTICAST
,
1216 vf_stats
.multicast
, IFLA_VF_STATS_PAD
)) {
1217 nla_nest_cancel(skb
, vfstats
);
1218 goto nla_put_vf_failure
;
1220 nla_nest_end(skb
, vfstats
);
1221 nla_nest_end(skb
, vf
);
1225 nla_nest_cancel(skb
, vf
);
1226 nla_put_vfinfo_failure
:
1227 nla_nest_cancel(skb
, vfinfo
);
1231 static int rtnl_fill_link_ifmap(struct sk_buff
*skb
, struct net_device
*dev
)
1233 struct rtnl_link_ifmap map
;
1235 memset(&map
, 0, sizeof(map
));
1236 map
.mem_start
= dev
->mem_start
;
1237 map
.mem_end
= dev
->mem_end
;
1238 map
.base_addr
= dev
->base_addr
;
1241 map
.port
= dev
->if_port
;
1243 if (nla_put_64bit(skb
, IFLA_MAP
, sizeof(map
), &map
, IFLA_PAD
))
1249 static int rtnl_xdp_fill(struct sk_buff
*skb
, struct net_device
*dev
)
1251 struct netdev_xdp xdp_op
= {};
1255 if (!dev
->netdev_ops
->ndo_xdp
)
1257 xdp
= nla_nest_start(skb
, IFLA_XDP
);
1260 xdp_op
.command
= XDP_QUERY_PROG
;
1261 err
= dev
->netdev_ops
->ndo_xdp(dev
, &xdp_op
);
1264 err
= nla_put_u8(skb
, IFLA_XDP_ATTACHED
, xdp_op
.prog_attached
);
1268 nla_nest_end(skb
, xdp
);
1272 nla_nest_cancel(skb
, xdp
);
1276 static int rtnl_fill_ifinfo(struct sk_buff
*skb
, struct net_device
*dev
,
1277 int type
, u32 pid
, u32 seq
, u32 change
,
1278 unsigned int flags
, u32 ext_filter_mask
)
1280 struct ifinfomsg
*ifm
;
1281 struct nlmsghdr
*nlh
;
1282 struct nlattr
*af_spec
;
1283 struct rtnl_af_ops
*af_ops
;
1284 struct net_device
*upper_dev
= netdev_master_upper_dev_get(dev
);
1287 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ifm
), flags
);
1291 ifm
= nlmsg_data(nlh
);
1292 ifm
->ifi_family
= AF_UNSPEC
;
1294 ifm
->ifi_type
= dev
->type
;
1295 ifm
->ifi_index
= dev
->ifindex
;
1296 ifm
->ifi_flags
= dev_get_flags(dev
);
1297 ifm
->ifi_change
= change
;
1299 if (nla_put_string(skb
, IFLA_IFNAME
, dev
->name
) ||
1300 nla_put_u32(skb
, IFLA_TXQLEN
, dev
->tx_queue_len
) ||
1301 nla_put_u8(skb
, IFLA_OPERSTATE
,
1302 netif_running(dev
) ? dev
->operstate
: IF_OPER_DOWN
) ||
1303 nla_put_u8(skb
, IFLA_LINKMODE
, dev
->link_mode
) ||
1304 nla_put_u32(skb
, IFLA_MTU
, dev
->mtu
) ||
1305 nla_put_u32(skb
, IFLA_GROUP
, dev
->group
) ||
1306 nla_put_u32(skb
, IFLA_PROMISCUITY
, dev
->promiscuity
) ||
1307 nla_put_u32(skb
, IFLA_NUM_TX_QUEUES
, dev
->num_tx_queues
) ||
1308 nla_put_u32(skb
, IFLA_GSO_MAX_SEGS
, dev
->gso_max_segs
) ||
1309 nla_put_u32(skb
, IFLA_GSO_MAX_SIZE
, dev
->gso_max_size
) ||
1311 nla_put_u32(skb
, IFLA_NUM_RX_QUEUES
, dev
->num_rx_queues
) ||
1313 (dev
->ifindex
!= dev_get_iflink(dev
) &&
1314 nla_put_u32(skb
, IFLA_LINK
, dev_get_iflink(dev
))) ||
1316 nla_put_u32(skb
, IFLA_MASTER
, upper_dev
->ifindex
)) ||
1317 nla_put_u8(skb
, IFLA_CARRIER
, netif_carrier_ok(dev
)) ||
1319 nla_put_string(skb
, IFLA_QDISC
, dev
->qdisc
->ops
->id
)) ||
1321 nla_put_string(skb
, IFLA_IFALIAS
, dev
->ifalias
)) ||
1322 nla_put_u32(skb
, IFLA_CARRIER_CHANGES
,
1323 atomic_read(&dev
->carrier_changes
)) ||
1324 nla_put_u8(skb
, IFLA_PROTO_DOWN
, dev
->proto_down
))
1325 goto nla_put_failure
;
1327 if (rtnl_fill_link_ifmap(skb
, dev
))
1328 goto nla_put_failure
;
1330 if (dev
->addr_len
) {
1331 if (nla_put(skb
, IFLA_ADDRESS
, dev
->addr_len
, dev
->dev_addr
) ||
1332 nla_put(skb
, IFLA_BROADCAST
, dev
->addr_len
, dev
->broadcast
))
1333 goto nla_put_failure
;
1336 if (rtnl_phys_port_id_fill(skb
, dev
))
1337 goto nla_put_failure
;
1339 if (rtnl_phys_port_name_fill(skb
, dev
))
1340 goto nla_put_failure
;
1342 if (rtnl_phys_switch_id_fill(skb
, dev
))
1343 goto nla_put_failure
;
1345 if (rtnl_fill_stats(skb
, dev
))
1346 goto nla_put_failure
;
1348 if (dev
->dev
.parent
&& (ext_filter_mask
& RTEXT_FILTER_VF
) &&
1349 nla_put_u32(skb
, IFLA_NUM_VF
, dev_num_vf(dev
->dev
.parent
)))
1350 goto nla_put_failure
;
1352 if (dev
->netdev_ops
->ndo_get_vf_config
&& dev
->dev
.parent
&&
1353 ext_filter_mask
& RTEXT_FILTER_VF
) {
1355 struct nlattr
*vfinfo
;
1356 int num_vfs
= dev_num_vf(dev
->dev
.parent
);
1358 vfinfo
= nla_nest_start(skb
, IFLA_VFINFO_LIST
);
1360 goto nla_put_failure
;
1361 for (i
= 0; i
< num_vfs
; i
++) {
1362 if (rtnl_fill_vfinfo(skb
, dev
, i
, vfinfo
))
1363 goto nla_put_failure
;
1366 nla_nest_end(skb
, vfinfo
);
1369 if (rtnl_port_fill(skb
, dev
, ext_filter_mask
))
1370 goto nla_put_failure
;
1372 if (rtnl_xdp_fill(skb
, dev
))
1373 goto nla_put_failure
;
1375 if (dev
->rtnl_link_ops
|| rtnl_have_link_slave_info(dev
)) {
1376 if (rtnl_link_fill(skb
, dev
) < 0)
1377 goto nla_put_failure
;
1380 if (dev
->rtnl_link_ops
&&
1381 dev
->rtnl_link_ops
->get_link_net
) {
1382 struct net
*link_net
= dev
->rtnl_link_ops
->get_link_net(dev
);
1384 if (!net_eq(dev_net(dev
), link_net
)) {
1385 int id
= peernet2id_alloc(dev_net(dev
), link_net
);
1387 if (nla_put_s32(skb
, IFLA_LINK_NETNSID
, id
))
1388 goto nla_put_failure
;
1392 if (!(af_spec
= nla_nest_start(skb
, IFLA_AF_SPEC
)))
1393 goto nla_put_failure
;
1395 list_for_each_entry(af_ops
, &rtnl_af_ops
, list
) {
1396 if (af_ops
->fill_link_af
) {
1400 if (!(af
= nla_nest_start(skb
, af_ops
->family
)))
1401 goto nla_put_failure
;
1403 err
= af_ops
->fill_link_af(skb
, dev
, ext_filter_mask
);
1406 * Caller may return ENODATA to indicate that there
1407 * was no data to be dumped. This is not an error, it
1408 * means we should trim the attribute header and
1411 if (err
== -ENODATA
)
1412 nla_nest_cancel(skb
, af
);
1414 goto nla_put_failure
;
1416 nla_nest_end(skb
, af
);
1420 nla_nest_end(skb
, af_spec
);
1422 nlmsg_end(skb
, nlh
);
1426 nlmsg_cancel(skb
, nlh
);
1430 static const struct nla_policy ifla_policy
[IFLA_MAX
+1] = {
1431 [IFLA_IFNAME
] = { .type
= NLA_STRING
, .len
= IFNAMSIZ
-1 },
1432 [IFLA_ADDRESS
] = { .type
= NLA_BINARY
, .len
= MAX_ADDR_LEN
},
1433 [IFLA_BROADCAST
] = { .type
= NLA_BINARY
, .len
= MAX_ADDR_LEN
},
1434 [IFLA_MAP
] = { .len
= sizeof(struct rtnl_link_ifmap
) },
1435 [IFLA_MTU
] = { .type
= NLA_U32
},
1436 [IFLA_LINK
] = { .type
= NLA_U32
},
1437 [IFLA_MASTER
] = { .type
= NLA_U32
},
1438 [IFLA_CARRIER
] = { .type
= NLA_U8
},
1439 [IFLA_TXQLEN
] = { .type
= NLA_U32
},
1440 [IFLA_WEIGHT
] = { .type
= NLA_U32
},
1441 [IFLA_OPERSTATE
] = { .type
= NLA_U8
},
1442 [IFLA_LINKMODE
] = { .type
= NLA_U8
},
1443 [IFLA_LINKINFO
] = { .type
= NLA_NESTED
},
1444 [IFLA_NET_NS_PID
] = { .type
= NLA_U32
},
1445 [IFLA_NET_NS_FD
] = { .type
= NLA_U32
},
1446 [IFLA_IFALIAS
] = { .type
= NLA_STRING
, .len
= IFALIASZ
-1 },
1447 [IFLA_VFINFO_LIST
] = {. type
= NLA_NESTED
},
1448 [IFLA_VF_PORTS
] = { .type
= NLA_NESTED
},
1449 [IFLA_PORT_SELF
] = { .type
= NLA_NESTED
},
1450 [IFLA_AF_SPEC
] = { .type
= NLA_NESTED
},
1451 [IFLA_EXT_MASK
] = { .type
= NLA_U32
},
1452 [IFLA_PROMISCUITY
] = { .type
= NLA_U32
},
1453 [IFLA_NUM_TX_QUEUES
] = { .type
= NLA_U32
},
1454 [IFLA_NUM_RX_QUEUES
] = { .type
= NLA_U32
},
1455 [IFLA_PHYS_PORT_ID
] = { .type
= NLA_BINARY
, .len
= MAX_PHYS_ITEM_ID_LEN
},
1456 [IFLA_CARRIER_CHANGES
] = { .type
= NLA_U32
}, /* ignored */
1457 [IFLA_PHYS_SWITCH_ID
] = { .type
= NLA_BINARY
, .len
= MAX_PHYS_ITEM_ID_LEN
},
1458 [IFLA_LINK_NETNSID
] = { .type
= NLA_S32
},
1459 [IFLA_PROTO_DOWN
] = { .type
= NLA_U8
},
1460 [IFLA_XDP
] = { .type
= NLA_NESTED
},
1463 static const struct nla_policy ifla_info_policy
[IFLA_INFO_MAX
+1] = {
1464 [IFLA_INFO_KIND
] = { .type
= NLA_STRING
},
1465 [IFLA_INFO_DATA
] = { .type
= NLA_NESTED
},
1466 [IFLA_INFO_SLAVE_KIND
] = { .type
= NLA_STRING
},
1467 [IFLA_INFO_SLAVE_DATA
] = { .type
= NLA_NESTED
},
1470 static const struct nla_policy ifla_vf_policy
[IFLA_VF_MAX
+1] = {
1471 [IFLA_VF_MAC
] = { .len
= sizeof(struct ifla_vf_mac
) },
1472 [IFLA_VF_VLAN
] = { .len
= sizeof(struct ifla_vf_vlan
) },
1473 [IFLA_VF_VLAN_LIST
] = { .type
= NLA_NESTED
},
1474 [IFLA_VF_TX_RATE
] = { .len
= sizeof(struct ifla_vf_tx_rate
) },
1475 [IFLA_VF_SPOOFCHK
] = { .len
= sizeof(struct ifla_vf_spoofchk
) },
1476 [IFLA_VF_RATE
] = { .len
= sizeof(struct ifla_vf_rate
) },
1477 [IFLA_VF_LINK_STATE
] = { .len
= sizeof(struct ifla_vf_link_state
) },
1478 [IFLA_VF_RSS_QUERY_EN
] = { .len
= sizeof(struct ifla_vf_rss_query_en
) },
1479 [IFLA_VF_STATS
] = { .type
= NLA_NESTED
},
1480 [IFLA_VF_TRUST
] = { .len
= sizeof(struct ifla_vf_trust
) },
1481 [IFLA_VF_IB_NODE_GUID
] = { .len
= sizeof(struct ifla_vf_guid
) },
1482 [IFLA_VF_IB_PORT_GUID
] = { .len
= sizeof(struct ifla_vf_guid
) },
1485 static const struct nla_policy ifla_port_policy
[IFLA_PORT_MAX
+1] = {
1486 [IFLA_PORT_VF
] = { .type
= NLA_U32
},
1487 [IFLA_PORT_PROFILE
] = { .type
= NLA_STRING
,
1488 .len
= PORT_PROFILE_MAX
},
1489 [IFLA_PORT_VSI_TYPE
] = { .type
= NLA_BINARY
,
1490 .len
= sizeof(struct ifla_port_vsi
)},
1491 [IFLA_PORT_INSTANCE_UUID
] = { .type
= NLA_BINARY
,
1492 .len
= PORT_UUID_MAX
},
1493 [IFLA_PORT_HOST_UUID
] = { .type
= NLA_STRING
,
1494 .len
= PORT_UUID_MAX
},
1495 [IFLA_PORT_REQUEST
] = { .type
= NLA_U8
, },
1496 [IFLA_PORT_RESPONSE
] = { .type
= NLA_U16
, },
1499 static const struct nla_policy ifla_xdp_policy
[IFLA_XDP_MAX
+ 1] = {
1500 [IFLA_XDP_FD
] = { .type
= NLA_S32
},
1501 [IFLA_XDP_ATTACHED
] = { .type
= NLA_U8
},
1504 static const struct rtnl_link_ops
*linkinfo_to_kind_ops(const struct nlattr
*nla
)
1506 const struct rtnl_link_ops
*ops
= NULL
;
1507 struct nlattr
*linfo
[IFLA_INFO_MAX
+ 1];
1509 if (nla_parse_nested(linfo
, IFLA_INFO_MAX
, nla
, ifla_info_policy
) < 0)
1512 if (linfo
[IFLA_INFO_KIND
]) {
1513 char kind
[MODULE_NAME_LEN
];
1515 nla_strlcpy(kind
, linfo
[IFLA_INFO_KIND
], sizeof(kind
));
1516 ops
= rtnl_link_ops_get(kind
);
1522 static bool link_master_filtered(struct net_device
*dev
, int master_idx
)
1524 struct net_device
*master
;
1529 master
= netdev_master_upper_dev_get(dev
);
1530 if (!master
|| master
->ifindex
!= master_idx
)
1536 static bool link_kind_filtered(const struct net_device
*dev
,
1537 const struct rtnl_link_ops
*kind_ops
)
1539 if (kind_ops
&& dev
->rtnl_link_ops
!= kind_ops
)
1545 static bool link_dump_filtered(struct net_device
*dev
,
1547 const struct rtnl_link_ops
*kind_ops
)
1549 if (link_master_filtered(dev
, master_idx
) ||
1550 link_kind_filtered(dev
, kind_ops
))
1556 static int rtnl_dump_ifinfo(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1558 struct net
*net
= sock_net(skb
->sk
);
1561 struct net_device
*dev
;
1562 struct hlist_head
*head
;
1563 struct nlattr
*tb
[IFLA_MAX
+1];
1564 u32 ext_filter_mask
= 0;
1565 const struct rtnl_link_ops
*kind_ops
= NULL
;
1566 unsigned int flags
= NLM_F_MULTI
;
1572 s_idx
= cb
->args
[1];
1574 cb
->seq
= net
->dev_base_seq
;
1576 /* A hack to preserve kernel<->userspace interface.
1577 * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
1578 * However, before Linux v3.9 the code here assumed rtgenmsg and that's
1579 * what iproute2 < v3.9.0 used.
1580 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
1581 * attribute, its netlink message is shorter than struct ifinfomsg.
1583 hdrlen
= nlmsg_len(cb
->nlh
) < sizeof(struct ifinfomsg
) ?
1584 sizeof(struct rtgenmsg
) : sizeof(struct ifinfomsg
);
1586 if (nlmsg_parse(cb
->nlh
, hdrlen
, tb
, IFLA_MAX
, ifla_policy
) >= 0) {
1588 if (tb
[IFLA_EXT_MASK
])
1589 ext_filter_mask
= nla_get_u32(tb
[IFLA_EXT_MASK
]);
1591 if (tb
[IFLA_MASTER
])
1592 master_idx
= nla_get_u32(tb
[IFLA_MASTER
]);
1594 if (tb
[IFLA_LINKINFO
])
1595 kind_ops
= linkinfo_to_kind_ops(tb
[IFLA_LINKINFO
]);
1597 if (master_idx
|| kind_ops
)
1598 flags
|= NLM_F_DUMP_FILTERED
;
1601 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1603 head
= &net
->dev_index_head
[h
];
1604 hlist_for_each_entry(dev
, head
, index_hlist
) {
1605 if (link_dump_filtered(dev
, master_idx
, kind_ops
))
1609 err
= rtnl_fill_ifinfo(skb
, dev
, RTM_NEWLINK
,
1610 NETLINK_CB(cb
->skb
).portid
,
1611 cb
->nlh
->nlmsg_seq
, 0,
1614 /* If we ran out of room on the first message,
1617 WARN_ON((err
== -EMSGSIZE
) && (skb
->len
== 0));
1622 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1634 int rtnl_nla_parse_ifla(struct nlattr
**tb
, const struct nlattr
*head
, int len
)
1636 return nla_parse(tb
, IFLA_MAX
, head
, len
, ifla_policy
);
1638 EXPORT_SYMBOL(rtnl_nla_parse_ifla
);
1640 struct net
*rtnl_link_get_net(struct net
*src_net
, struct nlattr
*tb
[])
1643 /* Examine the link attributes and figure out which
1644 * network namespace we are talking about.
1646 if (tb
[IFLA_NET_NS_PID
])
1647 net
= get_net_ns_by_pid(nla_get_u32(tb
[IFLA_NET_NS_PID
]));
1648 else if (tb
[IFLA_NET_NS_FD
])
1649 net
= get_net_ns_by_fd(nla_get_u32(tb
[IFLA_NET_NS_FD
]));
1651 net
= get_net(src_net
);
1654 EXPORT_SYMBOL(rtnl_link_get_net
);
1656 static int validate_linkmsg(struct net_device
*dev
, struct nlattr
*tb
[])
1659 if (tb
[IFLA_ADDRESS
] &&
1660 nla_len(tb
[IFLA_ADDRESS
]) < dev
->addr_len
)
1663 if (tb
[IFLA_BROADCAST
] &&
1664 nla_len(tb
[IFLA_BROADCAST
]) < dev
->addr_len
)
1668 if (tb
[IFLA_AF_SPEC
]) {
1672 nla_for_each_nested(af
, tb
[IFLA_AF_SPEC
], rem
) {
1673 const struct rtnl_af_ops
*af_ops
;
1675 if (!(af_ops
= rtnl_af_lookup(nla_type(af
))))
1676 return -EAFNOSUPPORT
;
1678 if (!af_ops
->set_link_af
)
1681 if (af_ops
->validate_link_af
) {
1682 err
= af_ops
->validate_link_af(dev
, af
);
1692 static int handle_infiniband_guid(struct net_device
*dev
, struct ifla_vf_guid
*ivt
,
1695 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1697 return ops
->ndo_set_vf_guid(dev
, ivt
->vf
, ivt
->guid
, guid_type
);
1700 static int handle_vf_guid(struct net_device
*dev
, struct ifla_vf_guid
*ivt
, int guid_type
)
1702 if (dev
->type
!= ARPHRD_INFINIBAND
)
1705 return handle_infiniband_guid(dev
, ivt
, guid_type
);
1708 static int do_setvfinfo(struct net_device
*dev
, struct nlattr
**tb
)
1710 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1713 if (tb
[IFLA_VF_MAC
]) {
1714 struct ifla_vf_mac
*ivm
= nla_data(tb
[IFLA_VF_MAC
]);
1717 if (ops
->ndo_set_vf_mac
)
1718 err
= ops
->ndo_set_vf_mac(dev
, ivm
->vf
,
1724 if (tb
[IFLA_VF_VLAN
]) {
1725 struct ifla_vf_vlan
*ivv
= nla_data(tb
[IFLA_VF_VLAN
]);
1728 if (ops
->ndo_set_vf_vlan
)
1729 err
= ops
->ndo_set_vf_vlan(dev
, ivv
->vf
, ivv
->vlan
,
1731 htons(ETH_P_8021Q
));
1736 if (tb
[IFLA_VF_VLAN_LIST
]) {
1737 struct ifla_vf_vlan_info
*ivvl
[MAX_VLAN_LIST_LEN
];
1738 struct nlattr
*attr
;
1742 if (!ops
->ndo_set_vf_vlan
)
1745 nla_for_each_nested(attr
, tb
[IFLA_VF_VLAN_LIST
], rem
) {
1746 if (nla_type(attr
) != IFLA_VF_VLAN_INFO
||
1747 nla_len(attr
) < NLA_HDRLEN
) {
1750 if (len
>= MAX_VLAN_LIST_LEN
)
1752 ivvl
[len
] = nla_data(attr
);
1759 err
= ops
->ndo_set_vf_vlan(dev
, ivvl
[0]->vf
, ivvl
[0]->vlan
,
1760 ivvl
[0]->qos
, ivvl
[0]->vlan_proto
);
1765 if (tb
[IFLA_VF_TX_RATE
]) {
1766 struct ifla_vf_tx_rate
*ivt
= nla_data(tb
[IFLA_VF_TX_RATE
]);
1767 struct ifla_vf_info ivf
;
1770 if (ops
->ndo_get_vf_config
)
1771 err
= ops
->ndo_get_vf_config(dev
, ivt
->vf
, &ivf
);
1776 if (ops
->ndo_set_vf_rate
)
1777 err
= ops
->ndo_set_vf_rate(dev
, ivt
->vf
,
1784 if (tb
[IFLA_VF_RATE
]) {
1785 struct ifla_vf_rate
*ivt
= nla_data(tb
[IFLA_VF_RATE
]);
1788 if (ops
->ndo_set_vf_rate
)
1789 err
= ops
->ndo_set_vf_rate(dev
, ivt
->vf
,
1796 if (tb
[IFLA_VF_SPOOFCHK
]) {
1797 struct ifla_vf_spoofchk
*ivs
= nla_data(tb
[IFLA_VF_SPOOFCHK
]);
1800 if (ops
->ndo_set_vf_spoofchk
)
1801 err
= ops
->ndo_set_vf_spoofchk(dev
, ivs
->vf
,
1807 if (tb
[IFLA_VF_LINK_STATE
]) {
1808 struct ifla_vf_link_state
*ivl
= nla_data(tb
[IFLA_VF_LINK_STATE
]);
1811 if (ops
->ndo_set_vf_link_state
)
1812 err
= ops
->ndo_set_vf_link_state(dev
, ivl
->vf
,
1818 if (tb
[IFLA_VF_RSS_QUERY_EN
]) {
1819 struct ifla_vf_rss_query_en
*ivrssq_en
;
1822 ivrssq_en
= nla_data(tb
[IFLA_VF_RSS_QUERY_EN
]);
1823 if (ops
->ndo_set_vf_rss_query_en
)
1824 err
= ops
->ndo_set_vf_rss_query_en(dev
, ivrssq_en
->vf
,
1825 ivrssq_en
->setting
);
1830 if (tb
[IFLA_VF_TRUST
]) {
1831 struct ifla_vf_trust
*ivt
= nla_data(tb
[IFLA_VF_TRUST
]);
1834 if (ops
->ndo_set_vf_trust
)
1835 err
= ops
->ndo_set_vf_trust(dev
, ivt
->vf
, ivt
->setting
);
1840 if (tb
[IFLA_VF_IB_NODE_GUID
]) {
1841 struct ifla_vf_guid
*ivt
= nla_data(tb
[IFLA_VF_IB_NODE_GUID
]);
1843 if (!ops
->ndo_set_vf_guid
)
1846 return handle_vf_guid(dev
, ivt
, IFLA_VF_IB_NODE_GUID
);
1849 if (tb
[IFLA_VF_IB_PORT_GUID
]) {
1850 struct ifla_vf_guid
*ivt
= nla_data(tb
[IFLA_VF_IB_PORT_GUID
]);
1852 if (!ops
->ndo_set_vf_guid
)
1855 return handle_vf_guid(dev
, ivt
, IFLA_VF_IB_PORT_GUID
);
1861 static int do_set_master(struct net_device
*dev
, int ifindex
)
1863 struct net_device
*upper_dev
= netdev_master_upper_dev_get(dev
);
1864 const struct net_device_ops
*ops
;
1868 if (upper_dev
->ifindex
== ifindex
)
1870 ops
= upper_dev
->netdev_ops
;
1871 if (ops
->ndo_del_slave
) {
1872 err
= ops
->ndo_del_slave(upper_dev
, dev
);
1881 upper_dev
= __dev_get_by_index(dev_net(dev
), ifindex
);
1884 ops
= upper_dev
->netdev_ops
;
1885 if (ops
->ndo_add_slave
) {
1886 err
= ops
->ndo_add_slave(upper_dev
, dev
);
1896 #define DO_SETLINK_MODIFIED 0x01
1897 /* notify flag means notify + modified. */
1898 #define DO_SETLINK_NOTIFY 0x03
1899 static int do_setlink(const struct sk_buff
*skb
,
1900 struct net_device
*dev
, struct ifinfomsg
*ifm
,
1901 struct nlattr
**tb
, char *ifname
, int status
)
1903 const struct net_device_ops
*ops
= dev
->netdev_ops
;
1906 if (tb
[IFLA_NET_NS_PID
] || tb
[IFLA_NET_NS_FD
]) {
1907 struct net
*net
= rtnl_link_get_net(dev_net(dev
), tb
);
1912 if (!netlink_ns_capable(skb
, net
->user_ns
, CAP_NET_ADMIN
)) {
1917 err
= dev_change_net_namespace(dev
, net
, ifname
);
1921 status
|= DO_SETLINK_MODIFIED
;
1925 struct rtnl_link_ifmap
*u_map
;
1928 if (!ops
->ndo_set_config
) {
1933 if (!netif_device_present(dev
)) {
1938 u_map
= nla_data(tb
[IFLA_MAP
]);
1939 k_map
.mem_start
= (unsigned long) u_map
->mem_start
;
1940 k_map
.mem_end
= (unsigned long) u_map
->mem_end
;
1941 k_map
.base_addr
= (unsigned short) u_map
->base_addr
;
1942 k_map
.irq
= (unsigned char) u_map
->irq
;
1943 k_map
.dma
= (unsigned char) u_map
->dma
;
1944 k_map
.port
= (unsigned char) u_map
->port
;
1946 err
= ops
->ndo_set_config(dev
, &k_map
);
1950 status
|= DO_SETLINK_NOTIFY
;
1953 if (tb
[IFLA_ADDRESS
]) {
1954 struct sockaddr
*sa
;
1957 len
= sizeof(sa_family_t
) + dev
->addr_len
;
1958 sa
= kmalloc(len
, GFP_KERNEL
);
1963 sa
->sa_family
= dev
->type
;
1964 memcpy(sa
->sa_data
, nla_data(tb
[IFLA_ADDRESS
]),
1966 err
= dev_set_mac_address(dev
, sa
);
1970 status
|= DO_SETLINK_MODIFIED
;
1974 err
= dev_set_mtu(dev
, nla_get_u32(tb
[IFLA_MTU
]));
1977 status
|= DO_SETLINK_MODIFIED
;
1980 if (tb
[IFLA_GROUP
]) {
1981 dev_set_group(dev
, nla_get_u32(tb
[IFLA_GROUP
]));
1982 status
|= DO_SETLINK_NOTIFY
;
1986 * Interface selected by interface index but interface
1987 * name provided implies that a name change has been
1990 if (ifm
->ifi_index
> 0 && ifname
[0]) {
1991 err
= dev_change_name(dev
, ifname
);
1994 status
|= DO_SETLINK_MODIFIED
;
1997 if (tb
[IFLA_IFALIAS
]) {
1998 err
= dev_set_alias(dev
, nla_data(tb
[IFLA_IFALIAS
]),
1999 nla_len(tb
[IFLA_IFALIAS
]));
2002 status
|= DO_SETLINK_NOTIFY
;
2005 if (tb
[IFLA_BROADCAST
]) {
2006 nla_memcpy(dev
->broadcast
, tb
[IFLA_BROADCAST
], dev
->addr_len
);
2007 call_netdevice_notifiers(NETDEV_CHANGEADDR
, dev
);
2010 if (ifm
->ifi_flags
|| ifm
->ifi_change
) {
2011 err
= dev_change_flags(dev
, rtnl_dev_combine_flags(dev
, ifm
));
2016 if (tb
[IFLA_MASTER
]) {
2017 err
= do_set_master(dev
, nla_get_u32(tb
[IFLA_MASTER
]));
2020 status
|= DO_SETLINK_MODIFIED
;
2023 if (tb
[IFLA_CARRIER
]) {
2024 err
= dev_change_carrier(dev
, nla_get_u8(tb
[IFLA_CARRIER
]));
2027 status
|= DO_SETLINK_MODIFIED
;
2030 if (tb
[IFLA_TXQLEN
]) {
2031 unsigned long value
= nla_get_u32(tb
[IFLA_TXQLEN
]);
2032 unsigned long orig_len
= dev
->tx_queue_len
;
2034 if (dev
->tx_queue_len
^ value
) {
2035 dev
->tx_queue_len
= value
;
2036 err
= call_netdevice_notifiers(
2037 NETDEV_CHANGE_TX_QUEUE_LEN
, dev
);
2038 err
= notifier_to_errno(err
);
2040 dev
->tx_queue_len
= orig_len
;
2043 status
|= DO_SETLINK_NOTIFY
;
2047 if (tb
[IFLA_OPERSTATE
])
2048 set_operstate(dev
, nla_get_u8(tb
[IFLA_OPERSTATE
]));
2050 if (tb
[IFLA_LINKMODE
]) {
2051 unsigned char value
= nla_get_u8(tb
[IFLA_LINKMODE
]);
2053 write_lock_bh(&dev_base_lock
);
2054 if (dev
->link_mode
^ value
)
2055 status
|= DO_SETLINK_NOTIFY
;
2056 dev
->link_mode
= value
;
2057 write_unlock_bh(&dev_base_lock
);
2060 if (tb
[IFLA_VFINFO_LIST
]) {
2061 struct nlattr
*vfinfo
[IFLA_VF_MAX
+ 1];
2062 struct nlattr
*attr
;
2065 nla_for_each_nested(attr
, tb
[IFLA_VFINFO_LIST
], rem
) {
2066 if (nla_type(attr
) != IFLA_VF_INFO
||
2067 nla_len(attr
) < NLA_HDRLEN
) {
2071 err
= nla_parse_nested(vfinfo
, IFLA_VF_MAX
, attr
,
2075 err
= do_setvfinfo(dev
, vfinfo
);
2078 status
|= DO_SETLINK_NOTIFY
;
2083 if (tb
[IFLA_VF_PORTS
]) {
2084 struct nlattr
*port
[IFLA_PORT_MAX
+1];
2085 struct nlattr
*attr
;
2090 if (!ops
->ndo_set_vf_port
)
2093 nla_for_each_nested(attr
, tb
[IFLA_VF_PORTS
], rem
) {
2094 if (nla_type(attr
) != IFLA_VF_PORT
||
2095 nla_len(attr
) < NLA_HDRLEN
) {
2099 err
= nla_parse_nested(port
, IFLA_PORT_MAX
, attr
,
2103 if (!port
[IFLA_PORT_VF
]) {
2107 vf
= nla_get_u32(port
[IFLA_PORT_VF
]);
2108 err
= ops
->ndo_set_vf_port(dev
, vf
, port
);
2111 status
|= DO_SETLINK_NOTIFY
;
2116 if (tb
[IFLA_PORT_SELF
]) {
2117 struct nlattr
*port
[IFLA_PORT_MAX
+1];
2119 err
= nla_parse_nested(port
, IFLA_PORT_MAX
,
2120 tb
[IFLA_PORT_SELF
], ifla_port_policy
);
2125 if (ops
->ndo_set_vf_port
)
2126 err
= ops
->ndo_set_vf_port(dev
, PORT_SELF_VF
, port
);
2129 status
|= DO_SETLINK_NOTIFY
;
2132 if (tb
[IFLA_AF_SPEC
]) {
2136 nla_for_each_nested(af
, tb
[IFLA_AF_SPEC
], rem
) {
2137 const struct rtnl_af_ops
*af_ops
;
2139 if (!(af_ops
= rtnl_af_lookup(nla_type(af
))))
2142 err
= af_ops
->set_link_af(dev
, af
);
2146 status
|= DO_SETLINK_NOTIFY
;
2151 if (tb
[IFLA_PROTO_DOWN
]) {
2152 err
= dev_change_proto_down(dev
,
2153 nla_get_u8(tb
[IFLA_PROTO_DOWN
]));
2156 status
|= DO_SETLINK_NOTIFY
;
2160 struct nlattr
*xdp
[IFLA_XDP_MAX
+ 1];
2162 err
= nla_parse_nested(xdp
, IFLA_XDP_MAX
, tb
[IFLA_XDP
],
2167 if (xdp
[IFLA_XDP_ATTACHED
]) {
2171 if (xdp
[IFLA_XDP_FD
]) {
2172 err
= dev_change_xdp_fd(dev
,
2173 nla_get_s32(xdp
[IFLA_XDP_FD
]));
2176 status
|= DO_SETLINK_NOTIFY
;
2181 if (status
& DO_SETLINK_MODIFIED
) {
2182 if (status
& DO_SETLINK_NOTIFY
)
2183 netdev_state_change(dev
);
2186 net_warn_ratelimited("A link change request failed with some changes committed already. Interface %s may have been left with an inconsistent configuration, please check.\n",
2193 static int rtnl_setlink(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
2195 struct net
*net
= sock_net(skb
->sk
);
2196 struct ifinfomsg
*ifm
;
2197 struct net_device
*dev
;
2199 struct nlattr
*tb
[IFLA_MAX
+1];
2200 char ifname
[IFNAMSIZ
];
2202 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFLA_MAX
, ifla_policy
);
2206 if (tb
[IFLA_IFNAME
])
2207 nla_strlcpy(ifname
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
2212 ifm
= nlmsg_data(nlh
);
2213 if (ifm
->ifi_index
> 0)
2214 dev
= __dev_get_by_index(net
, ifm
->ifi_index
);
2215 else if (tb
[IFLA_IFNAME
])
2216 dev
= __dev_get_by_name(net
, ifname
);
2225 err
= validate_linkmsg(dev
, tb
);
2229 err
= do_setlink(skb
, dev
, ifm
, tb
, ifname
, 0);
2234 static int rtnl_group_dellink(const struct net
*net
, int group
)
2236 struct net_device
*dev
, *aux
;
2237 LIST_HEAD(list_kill
);
2243 for_each_netdev(net
, dev
) {
2244 if (dev
->group
== group
) {
2245 const struct rtnl_link_ops
*ops
;
2248 ops
= dev
->rtnl_link_ops
;
2249 if (!ops
|| !ops
->dellink
)
2257 for_each_netdev_safe(net
, dev
, aux
) {
2258 if (dev
->group
== group
) {
2259 const struct rtnl_link_ops
*ops
;
2261 ops
= dev
->rtnl_link_ops
;
2262 ops
->dellink(dev
, &list_kill
);
2265 unregister_netdevice_many(&list_kill
);
2270 int rtnl_delete_link(struct net_device
*dev
)
2272 const struct rtnl_link_ops
*ops
;
2273 LIST_HEAD(list_kill
);
2275 ops
= dev
->rtnl_link_ops
;
2276 if (!ops
|| !ops
->dellink
)
2279 ops
->dellink(dev
, &list_kill
);
2280 unregister_netdevice_many(&list_kill
);
2284 EXPORT_SYMBOL_GPL(rtnl_delete_link
);
2286 static int rtnl_dellink(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
2288 struct net
*net
= sock_net(skb
->sk
);
2289 struct net_device
*dev
;
2290 struct ifinfomsg
*ifm
;
2291 char ifname
[IFNAMSIZ
];
2292 struct nlattr
*tb
[IFLA_MAX
+1];
2295 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFLA_MAX
, ifla_policy
);
2299 if (tb
[IFLA_IFNAME
])
2300 nla_strlcpy(ifname
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
2302 ifm
= nlmsg_data(nlh
);
2303 if (ifm
->ifi_index
> 0)
2304 dev
= __dev_get_by_index(net
, ifm
->ifi_index
);
2305 else if (tb
[IFLA_IFNAME
])
2306 dev
= __dev_get_by_name(net
, ifname
);
2307 else if (tb
[IFLA_GROUP
])
2308 return rtnl_group_dellink(net
, nla_get_u32(tb
[IFLA_GROUP
]));
2315 return rtnl_delete_link(dev
);
2318 int rtnl_configure_link(struct net_device
*dev
, const struct ifinfomsg
*ifm
)
2320 unsigned int old_flags
;
2323 old_flags
= dev
->flags
;
2324 if (ifm
&& (ifm
->ifi_flags
|| ifm
->ifi_change
)) {
2325 err
= __dev_change_flags(dev
, rtnl_dev_combine_flags(dev
, ifm
));
2330 dev
->rtnl_link_state
= RTNL_LINK_INITIALIZED
;
2332 __dev_notify_flags(dev
, old_flags
, ~0U);
2335 EXPORT_SYMBOL(rtnl_configure_link
);
2337 struct net_device
*rtnl_create_link(struct net
*net
,
2338 const char *ifname
, unsigned char name_assign_type
,
2339 const struct rtnl_link_ops
*ops
, struct nlattr
*tb
[])
2342 struct net_device
*dev
;
2343 unsigned int num_tx_queues
= 1;
2344 unsigned int num_rx_queues
= 1;
2346 if (tb
[IFLA_NUM_TX_QUEUES
])
2347 num_tx_queues
= nla_get_u32(tb
[IFLA_NUM_TX_QUEUES
]);
2348 else if (ops
->get_num_tx_queues
)
2349 num_tx_queues
= ops
->get_num_tx_queues();
2351 if (tb
[IFLA_NUM_RX_QUEUES
])
2352 num_rx_queues
= nla_get_u32(tb
[IFLA_NUM_RX_QUEUES
]);
2353 else if (ops
->get_num_rx_queues
)
2354 num_rx_queues
= ops
->get_num_rx_queues();
2357 dev
= alloc_netdev_mqs(ops
->priv_size
, ifname
, name_assign_type
,
2358 ops
->setup
, num_tx_queues
, num_rx_queues
);
2362 dev_net_set(dev
, net
);
2363 dev
->rtnl_link_ops
= ops
;
2364 dev
->rtnl_link_state
= RTNL_LINK_INITIALIZING
;
2367 dev
->mtu
= nla_get_u32(tb
[IFLA_MTU
]);
2368 if (tb
[IFLA_ADDRESS
]) {
2369 memcpy(dev
->dev_addr
, nla_data(tb
[IFLA_ADDRESS
]),
2370 nla_len(tb
[IFLA_ADDRESS
]));
2371 dev
->addr_assign_type
= NET_ADDR_SET
;
2373 if (tb
[IFLA_BROADCAST
])
2374 memcpy(dev
->broadcast
, nla_data(tb
[IFLA_BROADCAST
]),
2375 nla_len(tb
[IFLA_BROADCAST
]));
2376 if (tb
[IFLA_TXQLEN
])
2377 dev
->tx_queue_len
= nla_get_u32(tb
[IFLA_TXQLEN
]);
2378 if (tb
[IFLA_OPERSTATE
])
2379 set_operstate(dev
, nla_get_u8(tb
[IFLA_OPERSTATE
]));
2380 if (tb
[IFLA_LINKMODE
])
2381 dev
->link_mode
= nla_get_u8(tb
[IFLA_LINKMODE
]);
2383 dev_set_group(dev
, nla_get_u32(tb
[IFLA_GROUP
]));
2388 return ERR_PTR(err
);
2390 EXPORT_SYMBOL(rtnl_create_link
);
2392 static int rtnl_group_changelink(const struct sk_buff
*skb
,
2393 struct net
*net
, int group
,
2394 struct ifinfomsg
*ifm
,
2397 struct net_device
*dev
, *aux
;
2400 for_each_netdev_safe(net
, dev
, aux
) {
2401 if (dev
->group
== group
) {
2402 err
= do_setlink(skb
, dev
, ifm
, tb
, NULL
, 0);
2411 static int rtnl_newlink(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
2413 struct net
*net
= sock_net(skb
->sk
);
2414 const struct rtnl_link_ops
*ops
;
2415 const struct rtnl_link_ops
*m_ops
= NULL
;
2416 struct net_device
*dev
;
2417 struct net_device
*master_dev
= NULL
;
2418 struct ifinfomsg
*ifm
;
2419 char kind
[MODULE_NAME_LEN
];
2420 char ifname
[IFNAMSIZ
];
2421 struct nlattr
*tb
[IFLA_MAX
+1];
2422 struct nlattr
*linkinfo
[IFLA_INFO_MAX
+1];
2423 unsigned char name_assign_type
= NET_NAME_USER
;
2426 #ifdef CONFIG_MODULES
2429 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFLA_MAX
, ifla_policy
);
2433 if (tb
[IFLA_IFNAME
])
2434 nla_strlcpy(ifname
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
2438 ifm
= nlmsg_data(nlh
);
2439 if (ifm
->ifi_index
> 0)
2440 dev
= __dev_get_by_index(net
, ifm
->ifi_index
);
2443 dev
= __dev_get_by_name(net
, ifname
);
2449 master_dev
= netdev_master_upper_dev_get(dev
);
2451 m_ops
= master_dev
->rtnl_link_ops
;
2454 err
= validate_linkmsg(dev
, tb
);
2458 if (tb
[IFLA_LINKINFO
]) {
2459 err
= nla_parse_nested(linkinfo
, IFLA_INFO_MAX
,
2460 tb
[IFLA_LINKINFO
], ifla_info_policy
);
2464 memset(linkinfo
, 0, sizeof(linkinfo
));
2466 if (linkinfo
[IFLA_INFO_KIND
]) {
2467 nla_strlcpy(kind
, linkinfo
[IFLA_INFO_KIND
], sizeof(kind
));
2468 ops
= rtnl_link_ops_get(kind
);
2475 struct nlattr
*attr
[ops
? ops
->maxtype
+ 1 : 1];
2476 struct nlattr
*slave_attr
[m_ops
? m_ops
->slave_maxtype
+ 1 : 1];
2477 struct nlattr
**data
= NULL
;
2478 struct nlattr
**slave_data
= NULL
;
2479 struct net
*dest_net
, *link_net
= NULL
;
2482 if (ops
->maxtype
&& linkinfo
[IFLA_INFO_DATA
]) {
2483 err
= nla_parse_nested(attr
, ops
->maxtype
,
2484 linkinfo
[IFLA_INFO_DATA
],
2490 if (ops
->validate
) {
2491 err
= ops
->validate(tb
, data
);
2498 if (m_ops
->slave_maxtype
&&
2499 linkinfo
[IFLA_INFO_SLAVE_DATA
]) {
2500 err
= nla_parse_nested(slave_attr
,
2501 m_ops
->slave_maxtype
,
2502 linkinfo
[IFLA_INFO_SLAVE_DATA
],
2503 m_ops
->slave_policy
);
2506 slave_data
= slave_attr
;
2508 if (m_ops
->slave_validate
) {
2509 err
= m_ops
->slave_validate(tb
, slave_data
);
2518 if (nlh
->nlmsg_flags
& NLM_F_EXCL
)
2520 if (nlh
->nlmsg_flags
& NLM_F_REPLACE
)
2523 if (linkinfo
[IFLA_INFO_DATA
]) {
2524 if (!ops
|| ops
!= dev
->rtnl_link_ops
||
2528 err
= ops
->changelink(dev
, tb
, data
);
2531 status
|= DO_SETLINK_NOTIFY
;
2534 if (linkinfo
[IFLA_INFO_SLAVE_DATA
]) {
2535 if (!m_ops
|| !m_ops
->slave_changelink
)
2538 err
= m_ops
->slave_changelink(master_dev
, dev
,
2542 status
|= DO_SETLINK_NOTIFY
;
2545 return do_setlink(skb
, dev
, ifm
, tb
, ifname
, status
);
2548 if (!(nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
2549 if (ifm
->ifi_index
== 0 && tb
[IFLA_GROUP
])
2550 return rtnl_group_changelink(skb
, net
,
2551 nla_get_u32(tb
[IFLA_GROUP
]),
2556 if (tb
[IFLA_MAP
] || tb
[IFLA_MASTER
] || tb
[IFLA_PROTINFO
])
2560 #ifdef CONFIG_MODULES
2563 request_module("rtnl-link-%s", kind
);
2565 ops
= rtnl_link_ops_get(kind
);
2577 snprintf(ifname
, IFNAMSIZ
, "%s%%d", ops
->kind
);
2578 name_assign_type
= NET_NAME_ENUM
;
2581 dest_net
= rtnl_link_get_net(net
, tb
);
2582 if (IS_ERR(dest_net
))
2583 return PTR_ERR(dest_net
);
2586 if (!netlink_ns_capable(skb
, dest_net
->user_ns
, CAP_NET_ADMIN
))
2589 if (tb
[IFLA_LINK_NETNSID
]) {
2590 int id
= nla_get_s32(tb
[IFLA_LINK_NETNSID
]);
2592 link_net
= get_net_ns_by_id(dest_net
, id
);
2598 if (!netlink_ns_capable(skb
, link_net
->user_ns
, CAP_NET_ADMIN
))
2602 dev
= rtnl_create_link(link_net
? : dest_net
, ifname
,
2603 name_assign_type
, ops
, tb
);
2609 dev
->ifindex
= ifm
->ifi_index
;
2612 err
= ops
->newlink(link_net
? : net
, dev
, tb
, data
);
2613 /* Drivers should call free_netdev() in ->destructor
2614 * and unregister it on failure after registration
2615 * so that device could be finally freed in rtnl_unlock.
2618 /* If device is not registered at all, free it now */
2619 if (dev
->reg_state
== NETREG_UNINITIALIZED
)
2624 err
= register_netdevice(dev
);
2630 err
= rtnl_configure_link(dev
, ifm
);
2632 goto out_unregister
;
2634 err
= dev_change_net_namespace(dev
, dest_net
, ifname
);
2636 goto out_unregister
;
2645 LIST_HEAD(list_kill
);
2647 ops
->dellink(dev
, &list_kill
);
2648 unregister_netdevice_many(&list_kill
);
2650 unregister_netdevice(dev
);
2656 static int rtnl_getlink(struct sk_buff
*skb
, struct nlmsghdr
* nlh
)
2658 struct net
*net
= sock_net(skb
->sk
);
2659 struct ifinfomsg
*ifm
;
2660 char ifname
[IFNAMSIZ
];
2661 struct nlattr
*tb
[IFLA_MAX
+1];
2662 struct net_device
*dev
= NULL
;
2663 struct sk_buff
*nskb
;
2665 u32 ext_filter_mask
= 0;
2667 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFLA_MAX
, ifla_policy
);
2671 if (tb
[IFLA_IFNAME
])
2672 nla_strlcpy(ifname
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
2674 if (tb
[IFLA_EXT_MASK
])
2675 ext_filter_mask
= nla_get_u32(tb
[IFLA_EXT_MASK
]);
2677 ifm
= nlmsg_data(nlh
);
2678 if (ifm
->ifi_index
> 0)
2679 dev
= __dev_get_by_index(net
, ifm
->ifi_index
);
2680 else if (tb
[IFLA_IFNAME
])
2681 dev
= __dev_get_by_name(net
, ifname
);
2688 nskb
= nlmsg_new(if_nlmsg_size(dev
, ext_filter_mask
), GFP_KERNEL
);
2692 err
= rtnl_fill_ifinfo(nskb
, dev
, RTM_NEWLINK
, NETLINK_CB(skb
).portid
,
2693 nlh
->nlmsg_seq
, 0, 0, ext_filter_mask
);
2695 /* -EMSGSIZE implies BUG in if_nlmsg_size */
2696 WARN_ON(err
== -EMSGSIZE
);
2699 err
= rtnl_unicast(nskb
, net
, NETLINK_CB(skb
).portid
);
2704 static u16
rtnl_calcit(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
2706 struct net
*net
= sock_net(skb
->sk
);
2707 struct net_device
*dev
;
2708 struct nlattr
*tb
[IFLA_MAX
+1];
2709 u32 ext_filter_mask
= 0;
2710 u16 min_ifinfo_dump_size
= 0;
2713 /* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
2714 hdrlen
= nlmsg_len(nlh
) < sizeof(struct ifinfomsg
) ?
2715 sizeof(struct rtgenmsg
) : sizeof(struct ifinfomsg
);
2717 if (nlmsg_parse(nlh
, hdrlen
, tb
, IFLA_MAX
, ifla_policy
) >= 0) {
2718 if (tb
[IFLA_EXT_MASK
])
2719 ext_filter_mask
= nla_get_u32(tb
[IFLA_EXT_MASK
]);
2722 if (!ext_filter_mask
)
2723 return NLMSG_GOODSIZE
;
2725 * traverse the list of net devices and compute the minimum
2726 * buffer size based upon the filter mask.
2728 list_for_each_entry(dev
, &net
->dev_base_head
, dev_list
) {
2729 min_ifinfo_dump_size
= max_t(u16
, min_ifinfo_dump_size
,
2734 return min_ifinfo_dump_size
;
2737 static int rtnl_dump_all(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2740 int s_idx
= cb
->family
;
2744 for (idx
= 1; idx
<= RTNL_FAMILY_MAX
; idx
++) {
2745 int type
= cb
->nlh
->nlmsg_type
-RTM_BASE
;
2746 if (idx
< s_idx
|| idx
== PF_PACKET
)
2748 if (rtnl_msg_handlers
[idx
] == NULL
||
2749 rtnl_msg_handlers
[idx
][type
].dumpit
== NULL
)
2752 memset(&cb
->args
[0], 0, sizeof(cb
->args
));
2756 if (rtnl_msg_handlers
[idx
][type
].dumpit(skb
, cb
))
2764 struct sk_buff
*rtmsg_ifinfo_build_skb(int type
, struct net_device
*dev
,
2765 unsigned int change
, gfp_t flags
)
2767 struct net
*net
= dev_net(dev
);
2768 struct sk_buff
*skb
;
2770 size_t if_info_size
;
2772 skb
= nlmsg_new((if_info_size
= if_nlmsg_size(dev
, 0)), flags
);
2776 err
= rtnl_fill_ifinfo(skb
, dev
, type
, 0, 0, change
, 0, 0);
2778 /* -EMSGSIZE implies BUG in if_nlmsg_size() */
2779 WARN_ON(err
== -EMSGSIZE
);
2786 rtnl_set_sk_err(net
, RTNLGRP_LINK
, err
);
2790 void rtmsg_ifinfo_send(struct sk_buff
*skb
, struct net_device
*dev
, gfp_t flags
)
2792 struct net
*net
= dev_net(dev
);
2794 rtnl_notify(skb
, net
, 0, RTNLGRP_LINK
, NULL
, flags
);
2797 void rtmsg_ifinfo(int type
, struct net_device
*dev
, unsigned int change
,
2800 struct sk_buff
*skb
;
2802 if (dev
->reg_state
!= NETREG_REGISTERED
)
2805 skb
= rtmsg_ifinfo_build_skb(type
, dev
, change
, flags
);
2807 rtmsg_ifinfo_send(skb
, dev
, flags
);
2809 EXPORT_SYMBOL(rtmsg_ifinfo
);
2811 static int nlmsg_populate_fdb_fill(struct sk_buff
*skb
,
2812 struct net_device
*dev
,
2813 u8
*addr
, u16 vid
, u32 pid
, u32 seq
,
2814 int type
, unsigned int flags
,
2815 int nlflags
, u16 ndm_state
)
2817 struct nlmsghdr
*nlh
;
2820 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ndm
), nlflags
);
2824 ndm
= nlmsg_data(nlh
);
2825 ndm
->ndm_family
= AF_BRIDGE
;
2828 ndm
->ndm_flags
= flags
;
2830 ndm
->ndm_ifindex
= dev
->ifindex
;
2831 ndm
->ndm_state
= ndm_state
;
2833 if (nla_put(skb
, NDA_LLADDR
, ETH_ALEN
, addr
))
2834 goto nla_put_failure
;
2836 if (nla_put(skb
, NDA_VLAN
, sizeof(u16
), &vid
))
2837 goto nla_put_failure
;
2839 nlmsg_end(skb
, nlh
);
2843 nlmsg_cancel(skb
, nlh
);
2847 static inline size_t rtnl_fdb_nlmsg_size(void)
2849 return NLMSG_ALIGN(sizeof(struct ndmsg
)) + nla_total_size(ETH_ALEN
);
2852 static void rtnl_fdb_notify(struct net_device
*dev
, u8
*addr
, u16 vid
, int type
,
2855 struct net
*net
= dev_net(dev
);
2856 struct sk_buff
*skb
;
2859 skb
= nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC
);
2863 err
= nlmsg_populate_fdb_fill(skb
, dev
, addr
, vid
,
2864 0, 0, type
, NTF_SELF
, 0, ndm_state
);
2870 rtnl_notify(skb
, net
, 0, RTNLGRP_NEIGH
, NULL
, GFP_ATOMIC
);
2873 rtnl_set_sk_err(net
, RTNLGRP_NEIGH
, err
);
2877 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
2879 int ndo_dflt_fdb_add(struct ndmsg
*ndm
,
2880 struct nlattr
*tb
[],
2881 struct net_device
*dev
,
2882 const unsigned char *addr
, u16 vid
,
2887 /* If aging addresses are supported device will need to
2888 * implement its own handler for this.
2890 if (ndm
->ndm_state
&& !(ndm
->ndm_state
& NUD_PERMANENT
)) {
2891 pr_info("%s: FDB only supports static addresses\n", dev
->name
);
2896 pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev
->name
);
2900 if (is_unicast_ether_addr(addr
) || is_link_local_ether_addr(addr
))
2901 err
= dev_uc_add_excl(dev
, addr
);
2902 else if (is_multicast_ether_addr(addr
))
2903 err
= dev_mc_add_excl(dev
, addr
);
2905 /* Only return duplicate errors if NLM_F_EXCL is set */
2906 if (err
== -EEXIST
&& !(flags
& NLM_F_EXCL
))
2911 EXPORT_SYMBOL(ndo_dflt_fdb_add
);
2913 static int fdb_vid_parse(struct nlattr
*vlan_attr
, u16
*p_vid
)
2918 if (nla_len(vlan_attr
) != sizeof(u16
)) {
2919 pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid vlan\n");
2923 vid
= nla_get_u16(vlan_attr
);
2925 if (!vid
|| vid
>= VLAN_VID_MASK
) {
2926 pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid vlan id %d\n",
2935 static int rtnl_fdb_add(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
2937 struct net
*net
= sock_net(skb
->sk
);
2939 struct nlattr
*tb
[NDA_MAX
+1];
2940 struct net_device
*dev
;
2945 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
2949 ndm
= nlmsg_data(nlh
);
2950 if (ndm
->ndm_ifindex
== 0) {
2951 pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid ifindex\n");
2955 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
2957 pr_info("PF_BRIDGE: RTM_NEWNEIGH with unknown ifindex\n");
2961 if (!tb
[NDA_LLADDR
] || nla_len(tb
[NDA_LLADDR
]) != ETH_ALEN
) {
2962 pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid address\n");
2966 addr
= nla_data(tb
[NDA_LLADDR
]);
2968 err
= fdb_vid_parse(tb
[NDA_VLAN
], &vid
);
2974 /* Support fdb on master device the net/bridge default case */
2975 if ((!ndm
->ndm_flags
|| ndm
->ndm_flags
& NTF_MASTER
) &&
2976 (dev
->priv_flags
& IFF_BRIDGE_PORT
)) {
2977 struct net_device
*br_dev
= netdev_master_upper_dev_get(dev
);
2978 const struct net_device_ops
*ops
= br_dev
->netdev_ops
;
2980 err
= ops
->ndo_fdb_add(ndm
, tb
, dev
, addr
, vid
,
2985 ndm
->ndm_flags
&= ~NTF_MASTER
;
2988 /* Embedded bridge, macvlan, and any other device support */
2989 if ((ndm
->ndm_flags
& NTF_SELF
)) {
2990 if (dev
->netdev_ops
->ndo_fdb_add
)
2991 err
= dev
->netdev_ops
->ndo_fdb_add(ndm
, tb
, dev
, addr
,
2995 err
= ndo_dflt_fdb_add(ndm
, tb
, dev
, addr
, vid
,
2999 rtnl_fdb_notify(dev
, addr
, vid
, RTM_NEWNEIGH
,
3001 ndm
->ndm_flags
&= ~NTF_SELF
;
3009 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
3011 int ndo_dflt_fdb_del(struct ndmsg
*ndm
,
3012 struct nlattr
*tb
[],
3013 struct net_device
*dev
,
3014 const unsigned char *addr
, u16 vid
)
3018 /* If aging addresses are supported device will need to
3019 * implement its own handler for this.
3021 if (!(ndm
->ndm_state
& NUD_PERMANENT
)) {
3022 pr_info("%s: FDB only supports static addresses\n", dev
->name
);
3026 if (is_unicast_ether_addr(addr
) || is_link_local_ether_addr(addr
))
3027 err
= dev_uc_del(dev
, addr
);
3028 else if (is_multicast_ether_addr(addr
))
3029 err
= dev_mc_del(dev
, addr
);
3033 EXPORT_SYMBOL(ndo_dflt_fdb_del
);
3035 static int rtnl_fdb_del(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
3037 struct net
*net
= sock_net(skb
->sk
);
3039 struct nlattr
*tb
[NDA_MAX
+1];
3040 struct net_device
*dev
;
3045 if (!netlink_capable(skb
, CAP_NET_ADMIN
))
3048 err
= nlmsg_parse(nlh
, sizeof(*ndm
), tb
, NDA_MAX
, NULL
);
3052 ndm
= nlmsg_data(nlh
);
3053 if (ndm
->ndm_ifindex
== 0) {
3054 pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid ifindex\n");
3058 dev
= __dev_get_by_index(net
, ndm
->ndm_ifindex
);
3060 pr_info("PF_BRIDGE: RTM_DELNEIGH with unknown ifindex\n");
3064 if (!tb
[NDA_LLADDR
] || nla_len(tb
[NDA_LLADDR
]) != ETH_ALEN
) {
3065 pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid address\n");
3069 addr
= nla_data(tb
[NDA_LLADDR
]);
3071 err
= fdb_vid_parse(tb
[NDA_VLAN
], &vid
);
3077 /* Support fdb on master device the net/bridge default case */
3078 if ((!ndm
->ndm_flags
|| ndm
->ndm_flags
& NTF_MASTER
) &&
3079 (dev
->priv_flags
& IFF_BRIDGE_PORT
)) {
3080 struct net_device
*br_dev
= netdev_master_upper_dev_get(dev
);
3081 const struct net_device_ops
*ops
= br_dev
->netdev_ops
;
3083 if (ops
->ndo_fdb_del
)
3084 err
= ops
->ndo_fdb_del(ndm
, tb
, dev
, addr
, vid
);
3089 ndm
->ndm_flags
&= ~NTF_MASTER
;
3092 /* Embedded bridge, macvlan, and any other device support */
3093 if (ndm
->ndm_flags
& NTF_SELF
) {
3094 if (dev
->netdev_ops
->ndo_fdb_del
)
3095 err
= dev
->netdev_ops
->ndo_fdb_del(ndm
, tb
, dev
, addr
,
3098 err
= ndo_dflt_fdb_del(ndm
, tb
, dev
, addr
, vid
);
3101 rtnl_fdb_notify(dev
, addr
, vid
, RTM_DELNEIGH
,
3103 ndm
->ndm_flags
&= ~NTF_SELF
;
3110 static int nlmsg_populate_fdb(struct sk_buff
*skb
,
3111 struct netlink_callback
*cb
,
3112 struct net_device
*dev
,
3114 struct netdev_hw_addr_list
*list
)
3116 struct netdev_hw_addr
*ha
;
3120 portid
= NETLINK_CB(cb
->skb
).portid
;
3121 seq
= cb
->nlh
->nlmsg_seq
;
3123 list_for_each_entry(ha
, &list
->list
, list
) {
3124 if (*idx
< cb
->args
[2])
3127 err
= nlmsg_populate_fdb_fill(skb
, dev
, ha
->addr
, 0,
3129 RTM_NEWNEIGH
, NTF_SELF
,
3130 NLM_F_MULTI
, NUD_PERMANENT
);
3140 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
3141 * @nlh: netlink message header
3144 * Default netdevice operation to dump the existing unicast address list.
3145 * Returns number of addresses from list put in skb.
3147 int ndo_dflt_fdb_dump(struct sk_buff
*skb
,
3148 struct netlink_callback
*cb
,
3149 struct net_device
*dev
,
3150 struct net_device
*filter_dev
,
3155 netif_addr_lock_bh(dev
);
3156 err
= nlmsg_populate_fdb(skb
, cb
, dev
, idx
, &dev
->uc
);
3159 nlmsg_populate_fdb(skb
, cb
, dev
, idx
, &dev
->mc
);
3161 netif_addr_unlock_bh(dev
);
3164 EXPORT_SYMBOL(ndo_dflt_fdb_dump
);
3166 static int rtnl_fdb_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
3168 struct net_device
*dev
;
3169 struct nlattr
*tb
[IFLA_MAX
+1];
3170 struct net_device
*br_dev
= NULL
;
3171 const struct net_device_ops
*ops
= NULL
;
3172 const struct net_device_ops
*cops
= NULL
;
3173 struct ifinfomsg
*ifm
= nlmsg_data(cb
->nlh
);
3174 struct net
*net
= sock_net(skb
->sk
);
3175 struct hlist_head
*head
;
3183 if (nlmsg_parse(cb
->nlh
, sizeof(struct ifinfomsg
), tb
, IFLA_MAX
,
3184 ifla_policy
) == 0) {
3185 if (tb
[IFLA_MASTER
])
3186 br_idx
= nla_get_u32(tb
[IFLA_MASTER
]);
3189 brport_idx
= ifm
->ifi_index
;
3192 br_dev
= __dev_get_by_index(net
, br_idx
);
3196 ops
= br_dev
->netdev_ops
;
3200 s_idx
= cb
->args
[1];
3202 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
3204 head
= &net
->dev_index_head
[h
];
3205 hlist_for_each_entry(dev
, head
, index_hlist
) {
3207 if (brport_idx
&& (dev
->ifindex
!= brport_idx
))
3210 if (!br_idx
) { /* user did not specify a specific bridge */
3211 if (dev
->priv_flags
& IFF_BRIDGE_PORT
) {
3212 br_dev
= netdev_master_upper_dev_get(dev
);
3213 cops
= br_dev
->netdev_ops
;
3216 if (dev
!= br_dev
&&
3217 !(dev
->priv_flags
& IFF_BRIDGE_PORT
))
3220 if (br_dev
!= netdev_master_upper_dev_get(dev
) &&
3221 !(dev
->priv_flags
& IFF_EBRIDGE
))
3229 if (dev
->priv_flags
& IFF_BRIDGE_PORT
) {
3230 if (cops
&& cops
->ndo_fdb_dump
) {
3231 err
= cops
->ndo_fdb_dump(skb
, cb
,
3234 if (err
== -EMSGSIZE
)
3239 if (dev
->netdev_ops
->ndo_fdb_dump
)
3240 err
= dev
->netdev_ops
->ndo_fdb_dump(skb
, cb
,
3244 err
= ndo_dflt_fdb_dump(skb
, cb
, dev
, NULL
,
3246 if (err
== -EMSGSIZE
)
3251 /* reset fdb offset to 0 for rest of the interfaces */
3267 static int brport_nla_put_flag(struct sk_buff
*skb
, u32 flags
, u32 mask
,
3268 unsigned int attrnum
, unsigned int flag
)
3271 return nla_put_u8(skb
, attrnum
, !!(flags
& flag
));
3275 int ndo_dflt_bridge_getlink(struct sk_buff
*skb
, u32 pid
, u32 seq
,
3276 struct net_device
*dev
, u16 mode
,
3277 u32 flags
, u32 mask
, int nlflags
,
3279 int (*vlan_fill
)(struct sk_buff
*skb
,
3280 struct net_device
*dev
,
3283 struct nlmsghdr
*nlh
;
3284 struct ifinfomsg
*ifm
;
3285 struct nlattr
*br_afspec
;
3286 struct nlattr
*protinfo
;
3287 u8 operstate
= netif_running(dev
) ? dev
->operstate
: IF_OPER_DOWN
;
3288 struct net_device
*br_dev
= netdev_master_upper_dev_get(dev
);
3291 nlh
= nlmsg_put(skb
, pid
, seq
, RTM_NEWLINK
, sizeof(*ifm
), nlflags
);
3295 ifm
= nlmsg_data(nlh
);
3296 ifm
->ifi_family
= AF_BRIDGE
;
3298 ifm
->ifi_type
= dev
->type
;
3299 ifm
->ifi_index
= dev
->ifindex
;
3300 ifm
->ifi_flags
= dev_get_flags(dev
);
3301 ifm
->ifi_change
= 0;
3304 if (nla_put_string(skb
, IFLA_IFNAME
, dev
->name
) ||
3305 nla_put_u32(skb
, IFLA_MTU
, dev
->mtu
) ||
3306 nla_put_u8(skb
, IFLA_OPERSTATE
, operstate
) ||
3308 nla_put_u32(skb
, IFLA_MASTER
, br_dev
->ifindex
)) ||
3310 nla_put(skb
, IFLA_ADDRESS
, dev
->addr_len
, dev
->dev_addr
)) ||
3311 (dev
->ifindex
!= dev_get_iflink(dev
) &&
3312 nla_put_u32(skb
, IFLA_LINK
, dev_get_iflink(dev
))))
3313 goto nla_put_failure
;
3315 br_afspec
= nla_nest_start(skb
, IFLA_AF_SPEC
);
3317 goto nla_put_failure
;
3319 if (nla_put_u16(skb
, IFLA_BRIDGE_FLAGS
, BRIDGE_FLAGS_SELF
)) {
3320 nla_nest_cancel(skb
, br_afspec
);
3321 goto nla_put_failure
;
3324 if (mode
!= BRIDGE_MODE_UNDEF
) {
3325 if (nla_put_u16(skb
, IFLA_BRIDGE_MODE
, mode
)) {
3326 nla_nest_cancel(skb
, br_afspec
);
3327 goto nla_put_failure
;
3331 err
= vlan_fill(skb
, dev
, filter_mask
);
3333 nla_nest_cancel(skb
, br_afspec
);
3334 goto nla_put_failure
;
3337 nla_nest_end(skb
, br_afspec
);
3339 protinfo
= nla_nest_start(skb
, IFLA_PROTINFO
| NLA_F_NESTED
);
3341 goto nla_put_failure
;
3343 if (brport_nla_put_flag(skb
, flags
, mask
,
3344 IFLA_BRPORT_MODE
, BR_HAIRPIN_MODE
) ||
3345 brport_nla_put_flag(skb
, flags
, mask
,
3346 IFLA_BRPORT_GUARD
, BR_BPDU_GUARD
) ||
3347 brport_nla_put_flag(skb
, flags
, mask
,
3348 IFLA_BRPORT_FAST_LEAVE
,
3349 BR_MULTICAST_FAST_LEAVE
) ||
3350 brport_nla_put_flag(skb
, flags
, mask
,
3351 IFLA_BRPORT_PROTECT
, BR_ROOT_BLOCK
) ||
3352 brport_nla_put_flag(skb
, flags
, mask
,
3353 IFLA_BRPORT_LEARNING
, BR_LEARNING
) ||
3354 brport_nla_put_flag(skb
, flags
, mask
,
3355 IFLA_BRPORT_LEARNING_SYNC
, BR_LEARNING_SYNC
) ||
3356 brport_nla_put_flag(skb
, flags
, mask
,
3357 IFLA_BRPORT_UNICAST_FLOOD
, BR_FLOOD
) ||
3358 brport_nla_put_flag(skb
, flags
, mask
,
3359 IFLA_BRPORT_PROXYARP
, BR_PROXYARP
)) {
3360 nla_nest_cancel(skb
, protinfo
);
3361 goto nla_put_failure
;
3364 nla_nest_end(skb
, protinfo
);
3366 nlmsg_end(skb
, nlh
);
3369 nlmsg_cancel(skb
, nlh
);
3370 return err
? err
: -EMSGSIZE
;
3372 EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink
);
3374 static int rtnl_bridge_getlink(struct sk_buff
*skb
, struct netlink_callback
*cb
)
3376 struct net
*net
= sock_net(skb
->sk
);
3377 struct net_device
*dev
;
3379 u32 portid
= NETLINK_CB(cb
->skb
).portid
;
3380 u32 seq
= cb
->nlh
->nlmsg_seq
;
3381 u32 filter_mask
= 0;
3384 if (nlmsg_len(cb
->nlh
) > sizeof(struct ifinfomsg
)) {
3385 struct nlattr
*extfilt
;
3387 extfilt
= nlmsg_find_attr(cb
->nlh
, sizeof(struct ifinfomsg
),
3390 if (nla_len(extfilt
) < sizeof(filter_mask
))
3393 filter_mask
= nla_get_u32(extfilt
);
3398 for_each_netdev_rcu(net
, dev
) {
3399 const struct net_device_ops
*ops
= dev
->netdev_ops
;
3400 struct net_device
*br_dev
= netdev_master_upper_dev_get(dev
);
3402 if (br_dev
&& br_dev
->netdev_ops
->ndo_bridge_getlink
) {
3403 if (idx
>= cb
->args
[0]) {
3404 err
= br_dev
->netdev_ops
->ndo_bridge_getlink(
3405 skb
, portid
, seq
, dev
,
3406 filter_mask
, NLM_F_MULTI
);
3407 if (err
< 0 && err
!= -EOPNOTSUPP
)
3413 if (ops
->ndo_bridge_getlink
) {
3414 if (idx
>= cb
->args
[0]) {
3415 err
= ops
->ndo_bridge_getlink(skb
, portid
,
3419 if (err
< 0 && err
!= -EOPNOTSUPP
)
3431 static inline size_t bridge_nlmsg_size(void)
3433 return NLMSG_ALIGN(sizeof(struct ifinfomsg
))
3434 + nla_total_size(IFNAMSIZ
) /* IFLA_IFNAME */
3435 + nla_total_size(MAX_ADDR_LEN
) /* IFLA_ADDRESS */
3436 + nla_total_size(sizeof(u32
)) /* IFLA_MASTER */
3437 + nla_total_size(sizeof(u32
)) /* IFLA_MTU */
3438 + nla_total_size(sizeof(u32
)) /* IFLA_LINK */
3439 + nla_total_size(sizeof(u32
)) /* IFLA_OPERSTATE */
3440 + nla_total_size(sizeof(u8
)) /* IFLA_PROTINFO */
3441 + nla_total_size(sizeof(struct nlattr
)) /* IFLA_AF_SPEC */
3442 + nla_total_size(sizeof(u16
)) /* IFLA_BRIDGE_FLAGS */
3443 + nla_total_size(sizeof(u16
)); /* IFLA_BRIDGE_MODE */
3446 static int rtnl_bridge_notify(struct net_device
*dev
)
3448 struct net
*net
= dev_net(dev
);
3449 struct sk_buff
*skb
;
3450 int err
= -EOPNOTSUPP
;
3452 if (!dev
->netdev_ops
->ndo_bridge_getlink
)
3455 skb
= nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC
);
3461 err
= dev
->netdev_ops
->ndo_bridge_getlink(skb
, 0, 0, dev
, 0, 0);
3468 rtnl_notify(skb
, net
, 0, RTNLGRP_LINK
, NULL
, GFP_ATOMIC
);
3471 WARN_ON(err
== -EMSGSIZE
);
3474 rtnl_set_sk_err(net
, RTNLGRP_LINK
, err
);
3478 static int rtnl_bridge_setlink(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
3480 struct net
*net
= sock_net(skb
->sk
);
3481 struct ifinfomsg
*ifm
;
3482 struct net_device
*dev
;
3483 struct nlattr
*br_spec
, *attr
= NULL
;
3484 int rem
, err
= -EOPNOTSUPP
;
3486 bool have_flags
= false;
3488 if (nlmsg_len(nlh
) < sizeof(*ifm
))
3491 ifm
= nlmsg_data(nlh
);
3492 if (ifm
->ifi_family
!= AF_BRIDGE
)
3493 return -EPFNOSUPPORT
;
3495 dev
= __dev_get_by_index(net
, ifm
->ifi_index
);
3497 pr_info("PF_BRIDGE: RTM_SETLINK with unknown ifindex\n");
3501 br_spec
= nlmsg_find_attr(nlh
, sizeof(struct ifinfomsg
), IFLA_AF_SPEC
);
3503 nla_for_each_nested(attr
, br_spec
, rem
) {
3504 if (nla_type(attr
) == IFLA_BRIDGE_FLAGS
) {
3505 if (nla_len(attr
) < sizeof(flags
))
3509 flags
= nla_get_u16(attr
);
3515 if (!flags
|| (flags
& BRIDGE_FLAGS_MASTER
)) {
3516 struct net_device
*br_dev
= netdev_master_upper_dev_get(dev
);
3518 if (!br_dev
|| !br_dev
->netdev_ops
->ndo_bridge_setlink
) {
3523 err
= br_dev
->netdev_ops
->ndo_bridge_setlink(dev
, nlh
, flags
);
3527 flags
&= ~BRIDGE_FLAGS_MASTER
;
3530 if ((flags
& BRIDGE_FLAGS_SELF
)) {
3531 if (!dev
->netdev_ops
->ndo_bridge_setlink
)
3534 err
= dev
->netdev_ops
->ndo_bridge_setlink(dev
, nlh
,
3537 flags
&= ~BRIDGE_FLAGS_SELF
;
3539 /* Generate event to notify upper layer of bridge
3542 err
= rtnl_bridge_notify(dev
);
3547 memcpy(nla_data(attr
), &flags
, sizeof(flags
));
3552 static int rtnl_bridge_dellink(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
3554 struct net
*net
= sock_net(skb
->sk
);
3555 struct ifinfomsg
*ifm
;
3556 struct net_device
*dev
;
3557 struct nlattr
*br_spec
, *attr
= NULL
;
3558 int rem
, err
= -EOPNOTSUPP
;
3560 bool have_flags
= false;
3562 if (nlmsg_len(nlh
) < sizeof(*ifm
))
3565 ifm
= nlmsg_data(nlh
);
3566 if (ifm
->ifi_family
!= AF_BRIDGE
)
3567 return -EPFNOSUPPORT
;
3569 dev
= __dev_get_by_index(net
, ifm
->ifi_index
);
3571 pr_info("PF_BRIDGE: RTM_SETLINK with unknown ifindex\n");
3575 br_spec
= nlmsg_find_attr(nlh
, sizeof(struct ifinfomsg
), IFLA_AF_SPEC
);
3577 nla_for_each_nested(attr
, br_spec
, rem
) {
3578 if (nla_type(attr
) == IFLA_BRIDGE_FLAGS
) {
3579 if (nla_len(attr
) < sizeof(flags
))
3583 flags
= nla_get_u16(attr
);
3589 if (!flags
|| (flags
& BRIDGE_FLAGS_MASTER
)) {
3590 struct net_device
*br_dev
= netdev_master_upper_dev_get(dev
);
3592 if (!br_dev
|| !br_dev
->netdev_ops
->ndo_bridge_dellink
) {
3597 err
= br_dev
->netdev_ops
->ndo_bridge_dellink(dev
, nlh
, flags
);
3601 flags
&= ~BRIDGE_FLAGS_MASTER
;
3604 if ((flags
& BRIDGE_FLAGS_SELF
)) {
3605 if (!dev
->netdev_ops
->ndo_bridge_dellink
)
3608 err
= dev
->netdev_ops
->ndo_bridge_dellink(dev
, nlh
,
3612 flags
&= ~BRIDGE_FLAGS_SELF
;
3614 /* Generate event to notify upper layer of bridge
3617 err
= rtnl_bridge_notify(dev
);
3622 memcpy(nla_data(attr
), &flags
, sizeof(flags
));
3627 static bool stats_attr_valid(unsigned int mask
, int attrid
, int idxattr
)
3629 return (mask
& IFLA_STATS_FILTER_BIT(attrid
)) &&
3630 (!idxattr
|| idxattr
== attrid
);
3633 #define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1)
3634 static int rtnl_get_offload_stats_attr_size(int attr_id
)
3637 case IFLA_OFFLOAD_XSTATS_CPU_HIT
:
3638 return sizeof(struct rtnl_link_stats64
);
3644 static int rtnl_get_offload_stats(struct sk_buff
*skb
, struct net_device
*dev
,
3647 struct nlattr
*attr
= NULL
;
3652 if (!(dev
->netdev_ops
&& dev
->netdev_ops
->ndo_has_offload_stats
&&
3653 dev
->netdev_ops
->ndo_get_offload_stats
))
3656 for (attr_id
= IFLA_OFFLOAD_XSTATS_FIRST
;
3657 attr_id
<= IFLA_OFFLOAD_XSTATS_MAX
; attr_id
++) {
3658 if (attr_id
< *prividx
)
3661 size
= rtnl_get_offload_stats_attr_size(attr_id
);
3665 if (!dev
->netdev_ops
->ndo_has_offload_stats(attr_id
))
3668 attr
= nla_reserve_64bit(skb
, attr_id
, size
,
3669 IFLA_OFFLOAD_XSTATS_UNSPEC
);
3671 goto nla_put_failure
;
3673 attr_data
= nla_data(attr
);
3674 memset(attr_data
, 0, size
);
3675 err
= dev
->netdev_ops
->ndo_get_offload_stats(attr_id
, dev
,
3678 goto get_offload_stats_failure
;
3689 get_offload_stats_failure
:
3694 static int rtnl_get_offload_stats_size(const struct net_device
*dev
)
3700 if (!(dev
->netdev_ops
&& dev
->netdev_ops
->ndo_has_offload_stats
&&
3701 dev
->netdev_ops
->ndo_get_offload_stats
))
3704 for (attr_id
= IFLA_OFFLOAD_XSTATS_FIRST
;
3705 attr_id
<= IFLA_OFFLOAD_XSTATS_MAX
; attr_id
++) {
3706 if (!dev
->netdev_ops
->ndo_has_offload_stats(attr_id
))
3708 size
= rtnl_get_offload_stats_attr_size(attr_id
);
3709 nla_size
+= nla_total_size_64bit(size
);
3713 nla_size
+= nla_total_size(0);
3718 static int rtnl_fill_statsinfo(struct sk_buff
*skb
, struct net_device
*dev
,
3719 int type
, u32 pid
, u32 seq
, u32 change
,
3720 unsigned int flags
, unsigned int filter_mask
,
3721 int *idxattr
, int *prividx
)
3723 struct if_stats_msg
*ifsm
;
3724 struct nlmsghdr
*nlh
;
3725 struct nlattr
*attr
;
3726 int s_prividx
= *prividx
;
3731 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*ifsm
), flags
);
3735 ifsm
= nlmsg_data(nlh
);
3736 ifsm
->ifindex
= dev
->ifindex
;
3737 ifsm
->filter_mask
= filter_mask
;
3739 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_64
, *idxattr
)) {
3740 struct rtnl_link_stats64
*sp
;
3742 attr
= nla_reserve_64bit(skb
, IFLA_STATS_LINK_64
,
3743 sizeof(struct rtnl_link_stats64
),
3746 goto nla_put_failure
;
3748 sp
= nla_data(attr
);
3749 dev_get_stats(dev
, sp
);
3752 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_XSTATS
, *idxattr
)) {
3753 const struct rtnl_link_ops
*ops
= dev
->rtnl_link_ops
;
3755 if (ops
&& ops
->fill_linkxstats
) {
3756 *idxattr
= IFLA_STATS_LINK_XSTATS
;
3757 attr
= nla_nest_start(skb
,
3758 IFLA_STATS_LINK_XSTATS
);
3760 goto nla_put_failure
;
3762 err
= ops
->fill_linkxstats(skb
, dev
, prividx
, *idxattr
);
3763 nla_nest_end(skb
, attr
);
3765 goto nla_put_failure
;
3770 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_XSTATS_SLAVE
,
3772 const struct rtnl_link_ops
*ops
= NULL
;
3773 const struct net_device
*master
;
3775 master
= netdev_master_upper_dev_get(dev
);
3777 ops
= master
->rtnl_link_ops
;
3778 if (ops
&& ops
->fill_linkxstats
) {
3779 *idxattr
= IFLA_STATS_LINK_XSTATS_SLAVE
;
3780 attr
= nla_nest_start(skb
,
3781 IFLA_STATS_LINK_XSTATS_SLAVE
);
3783 goto nla_put_failure
;
3785 err
= ops
->fill_linkxstats(skb
, dev
, prividx
, *idxattr
);
3786 nla_nest_end(skb
, attr
);
3788 goto nla_put_failure
;
3793 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_OFFLOAD_XSTATS
,
3795 *idxattr
= IFLA_STATS_LINK_OFFLOAD_XSTATS
;
3796 attr
= nla_nest_start(skb
, IFLA_STATS_LINK_OFFLOAD_XSTATS
);
3798 goto nla_put_failure
;
3800 err
= rtnl_get_offload_stats(skb
, dev
, prividx
);
3801 if (err
== -ENODATA
)
3802 nla_nest_cancel(skb
, attr
);
3804 nla_nest_end(skb
, attr
);
3806 if (err
&& err
!= -ENODATA
)
3807 goto nla_put_failure
;
3811 nlmsg_end(skb
, nlh
);
3816 /* not a multi message or no progress mean a real error */
3817 if (!(flags
& NLM_F_MULTI
) || s_prividx
== *prividx
)
3818 nlmsg_cancel(skb
, nlh
);
3820 nlmsg_end(skb
, nlh
);
3825 static size_t if_nlmsg_stats_size(const struct net_device
*dev
,
3830 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_64
, 0))
3831 size
+= nla_total_size_64bit(sizeof(struct rtnl_link_stats64
));
3833 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_XSTATS
, 0)) {
3834 const struct rtnl_link_ops
*ops
= dev
->rtnl_link_ops
;
3835 int attr
= IFLA_STATS_LINK_XSTATS
;
3837 if (ops
&& ops
->get_linkxstats_size
) {
3838 size
+= nla_total_size(ops
->get_linkxstats_size(dev
,
3840 /* for IFLA_STATS_LINK_XSTATS */
3841 size
+= nla_total_size(0);
3845 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_XSTATS_SLAVE
, 0)) {
3846 struct net_device
*_dev
= (struct net_device
*)dev
;
3847 const struct rtnl_link_ops
*ops
= NULL
;
3848 const struct net_device
*master
;
3850 /* netdev_master_upper_dev_get can't take const */
3851 master
= netdev_master_upper_dev_get(_dev
);
3853 ops
= master
->rtnl_link_ops
;
3854 if (ops
&& ops
->get_linkxstats_size
) {
3855 int attr
= IFLA_STATS_LINK_XSTATS_SLAVE
;
3857 size
+= nla_total_size(ops
->get_linkxstats_size(dev
,
3859 /* for IFLA_STATS_LINK_XSTATS_SLAVE */
3860 size
+= nla_total_size(0);
3864 if (stats_attr_valid(filter_mask
, IFLA_STATS_LINK_OFFLOAD_XSTATS
, 0))
3865 size
+= rtnl_get_offload_stats_size(dev
);
3870 static int rtnl_stats_get(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
3872 struct net
*net
= sock_net(skb
->sk
);
3873 struct net_device
*dev
= NULL
;
3874 int idxattr
= 0, prividx
= 0;
3875 struct if_stats_msg
*ifsm
;
3876 struct sk_buff
*nskb
;
3880 ifsm
= nlmsg_data(nlh
);
3881 if (ifsm
->ifindex
> 0)
3882 dev
= __dev_get_by_index(net
, ifsm
->ifindex
);
3889 filter_mask
= ifsm
->filter_mask
;
3893 nskb
= nlmsg_new(if_nlmsg_stats_size(dev
, filter_mask
), GFP_KERNEL
);
3897 err
= rtnl_fill_statsinfo(nskb
, dev
, RTM_NEWSTATS
,
3898 NETLINK_CB(skb
).portid
, nlh
->nlmsg_seq
, 0,
3899 0, filter_mask
, &idxattr
, &prividx
);
3901 /* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
3902 WARN_ON(err
== -EMSGSIZE
);
3905 err
= rtnl_unicast(nskb
, net
, NETLINK_CB(skb
).portid
);
3911 static int rtnl_stats_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
3913 int h
, s_h
, err
, s_idx
, s_idxattr
, s_prividx
;
3914 struct net
*net
= sock_net(skb
->sk
);
3915 unsigned int flags
= NLM_F_MULTI
;
3916 struct if_stats_msg
*ifsm
;
3917 struct hlist_head
*head
;
3918 struct net_device
*dev
;
3919 u32 filter_mask
= 0;
3923 s_idx
= cb
->args
[1];
3924 s_idxattr
= cb
->args
[2];
3925 s_prividx
= cb
->args
[3];
3927 cb
->seq
= net
->dev_base_seq
;
3929 ifsm
= nlmsg_data(cb
->nlh
);
3930 filter_mask
= ifsm
->filter_mask
;
3934 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
3936 head
= &net
->dev_index_head
[h
];
3937 hlist_for_each_entry(dev
, head
, index_hlist
) {
3940 err
= rtnl_fill_statsinfo(skb
, dev
, RTM_NEWSTATS
,
3941 NETLINK_CB(cb
->skb
).portid
,
3942 cb
->nlh
->nlmsg_seq
, 0,
3944 &s_idxattr
, &s_prividx
);
3945 /* If we ran out of room on the first message,
3948 WARN_ON((err
== -EMSGSIZE
) && (skb
->len
== 0));
3954 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
3960 cb
->args
[3] = s_prividx
;
3961 cb
->args
[2] = s_idxattr
;
3968 /* Process one rtnetlink message. */
3970 static int rtnetlink_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
3972 struct net
*net
= sock_net(skb
->sk
);
3973 rtnl_doit_func doit
;
3979 type
= nlh
->nlmsg_type
;
3985 /* All the messages must have at least 1 byte length */
3986 if (nlmsg_len(nlh
) < sizeof(struct rtgenmsg
))
3989 family
= ((struct rtgenmsg
*)nlmsg_data(nlh
))->rtgen_family
;
3992 if (kind
!= 2 && !netlink_net_capable(skb
, CAP_NET_ADMIN
))
3995 if (kind
== 2 && nlh
->nlmsg_flags
&NLM_F_DUMP
) {
3997 rtnl_dumpit_func dumpit
;
3998 rtnl_calcit_func calcit
;
3999 u16 min_dump_alloc
= 0;
4001 dumpit
= rtnl_get_dumpit(family
, type
);
4004 calcit
= rtnl_get_calcit(family
, type
);
4006 min_dump_alloc
= calcit(skb
, nlh
);
4011 struct netlink_dump_control c
= {
4013 .min_dump_alloc
= min_dump_alloc
,
4015 err
= netlink_dump_start(rtnl
, skb
, nlh
, &c
);
4021 doit
= rtnl_get_doit(family
, type
);
4025 return doit(skb
, nlh
);
4028 static void rtnetlink_rcv(struct sk_buff
*skb
)
4031 netlink_rcv_skb(skb
, &rtnetlink_rcv_msg
);
4035 static int rtnetlink_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
4037 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
4043 case NETDEV_POST_INIT
:
4044 case NETDEV_REGISTER
:
4046 case NETDEV_PRE_TYPE_CHANGE
:
4047 case NETDEV_GOING_DOWN
:
4048 case NETDEV_UNREGISTER
:
4049 case NETDEV_UNREGISTER_FINAL
:
4050 case NETDEV_RELEASE
:
4052 case NETDEV_BONDING_INFO
:
4055 rtmsg_ifinfo(RTM_NEWLINK
, dev
, 0, GFP_KERNEL
);
4061 static struct notifier_block rtnetlink_dev_notifier
= {
4062 .notifier_call
= rtnetlink_event
,
4066 static int __net_init
rtnetlink_net_init(struct net
*net
)
4069 struct netlink_kernel_cfg cfg
= {
4070 .groups
= RTNLGRP_MAX
,
4071 .input
= rtnetlink_rcv
,
4072 .cb_mutex
= &rtnl_mutex
,
4073 .flags
= NL_CFG_F_NONROOT_RECV
,
4076 sk
= netlink_kernel_create(net
, NETLINK_ROUTE
, &cfg
);
4083 static void __net_exit
rtnetlink_net_exit(struct net
*net
)
4085 netlink_kernel_release(net
->rtnl
);
4089 static struct pernet_operations rtnetlink_net_ops
= {
4090 .init
= rtnetlink_net_init
,
4091 .exit
= rtnetlink_net_exit
,
4094 void __init
rtnetlink_init(void)
4096 if (register_pernet_subsys(&rtnetlink_net_ops
))
4097 panic("rtnetlink_init: cannot initialize rtnetlink\n");
4099 register_netdevice_notifier(&rtnetlink_dev_notifier
);
4101 rtnl_register(PF_UNSPEC
, RTM_GETLINK
, rtnl_getlink
,
4102 rtnl_dump_ifinfo
, rtnl_calcit
);
4103 rtnl_register(PF_UNSPEC
, RTM_SETLINK
, rtnl_setlink
, NULL
, NULL
);
4104 rtnl_register(PF_UNSPEC
, RTM_NEWLINK
, rtnl_newlink
, NULL
, NULL
);
4105 rtnl_register(PF_UNSPEC
, RTM_DELLINK
, rtnl_dellink
, NULL
, NULL
);
4107 rtnl_register(PF_UNSPEC
, RTM_GETADDR
, NULL
, rtnl_dump_all
, NULL
);
4108 rtnl_register(PF_UNSPEC
, RTM_GETROUTE
, NULL
, rtnl_dump_all
, NULL
);
4110 rtnl_register(PF_BRIDGE
, RTM_NEWNEIGH
, rtnl_fdb_add
, NULL
, NULL
);
4111 rtnl_register(PF_BRIDGE
, RTM_DELNEIGH
, rtnl_fdb_del
, NULL
, NULL
);
4112 rtnl_register(PF_BRIDGE
, RTM_GETNEIGH
, NULL
, rtnl_fdb_dump
, NULL
);
4114 rtnl_register(PF_BRIDGE
, RTM_GETLINK
, NULL
, rtnl_bridge_getlink
, NULL
);
4115 rtnl_register(PF_BRIDGE
, RTM_DELLINK
, rtnl_bridge_dellink
, NULL
, NULL
);
4116 rtnl_register(PF_BRIDGE
, RTM_SETLINK
, rtnl_bridge_setlink
, NULL
, NULL
);
4118 rtnl_register(PF_UNSPEC
, RTM_GETSTATS
, rtnl_stats_get
, rtnl_stats_dump
,