]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - net/core/rtnetlink.c
projects / thirdparty / kernel / stable.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'kvm-x86-mmu-6.7' of https://github.com/kvm-x86/linux into HEAD
[thirdparty/kernel/stable.git] / net / core / rtnetlink.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4
LT		 2/*
3 * INET An implementation of the TCP/IP protocol suite for the LINUX
4 * operating system. INET is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
6 *
7 * Routing netlink socket interface: protocol independent part.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
1da177e4 11 * Fixes:
d467d0bc 12 * Vitaly E. Lavrov RTA_OK arithmetic was wrong.
1da177e4
LT		 13 */
14
ee5d032f 15#include <linux/bitops.h>
1da177e4
LT		 16#include <linux/errno.h>
17#include <linux/module.h>
18#include <linux/types.h>
19#include <linux/socket.h>
20#include <linux/kernel.h>
1da177e4
LT		 21#include <linux/timer.h>
22#include <linux/string.h>
23#include <linux/sockios.h>
24#include <linux/net.h>
25#include <linux/fcntl.h>
26#include <linux/mm.h>
27#include <linux/slab.h>
28#include <linux/interrupt.h>
29#include <linux/capability.h>
30#include <linux/skbuff.h>
31#include <linux/init.h>
32#include <linux/security.h>
6756ae4b 33#include <linux/mutex.h>
1823730f 34#include <linux/if_addr.h>
77162022 35#include <linux/if_bridge.h>
f6f6424b 36#include <linux/if_vlan.h>
ebc08a6f 37#include <linux/pci.h>
77162022 38#include <linux/etherdevice.h>
58038695 39#include <linux/bpf.h>
1da177e4 40
7c0f6ba6 41#include <linux/uaccess.h>
1da177e4
LT		 42
43#include <linux/inet.h>
44#include <linux/netdevice.h>
45#include <net/ip.h>
46#include <net/protocol.h>
47#include <net/arp.h>
48#include <net/route.h>
49#include <net/udp.h>
ea697639 50#include <net/tcp.h>
1da177e4
LT		 51#include <net/sock.h>
52#include <net/pkt_sched.h>
14c0b97d 53#include <net/fib_rules.h>
e2849863 54#include <net/rtnetlink.h>
30ffee84 55#include <net/net_namespace.h>
dca56c30 56#include <net/devlink.h>
cc7f5022
IS		 57#if IS_ENABLED(CONFIG_IPV6)
58#include <net/addrconf.h>
59#endif
1da177e4 60
6264f58c
JK		 61#include "dev.h"
62
a428afe8 63#define RTNL_MAX_TYPE 50
29cfb2aa 64#define RTNL_SLAVE_MAX_TYPE 44
ccf8dbcd 65
e0d087af 66struct rtnl_link {
e2849863
TG		 67 rtnl_doit_func doit;
68 rtnl_dumpit_func dumpit;
e4202511 69 struct module *owner;
62256f98 70 unsigned int flags;
addf9b90 71 struct rcu_head rcu;
e2849863
TG		 72};
73
6756ae4b 74static DEFINE_MUTEX(rtnl_mutex);
1da177e4
LT		 75
76void rtnl_lock(void)
77{
6756ae4b 78 mutex_lock(&rtnl_mutex);
1da177e4 79}
e0d087af 80EXPORT_SYMBOL(rtnl_lock);
1da177e4 81
79ffdfc6
KT		 82int rtnl_lock_killable(void)
83{
84 return mutex_lock_killable(&rtnl_mutex);
85}
86EXPORT_SYMBOL(rtnl_lock_killable);
87
1b5c5493
ED		 88static struct sk_buff *defer_kfree_skb_list;
89void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
90{
91 if (head && tail) {
92 tail->next = defer_kfree_skb_list;
93 defer_kfree_skb_list = head;
94 }
95}
96EXPORT_SYMBOL(rtnl_kfree_skbs);
97
6756ae4b 98void __rtnl_unlock(void)
1da177e4 99{
1b5c5493
ED		 100 struct sk_buff *head = defer_kfree_skb_list;
101
102 defer_kfree_skb_list = NULL;
103
0b5c21bb
JB		 104 /* Ensure that we didn't actually add any TODO item when __rtnl_unlock()
105 * is used. In some places, e.g. in cfg80211, we have code that will do
106 * something like
107 * rtnl_lock()
108 * wiphy_lock()
109 * ...
110 * rtnl_unlock()
111 *
112 * and because netdev_run_todo() acquires the RTNL for items on the list
113 * we could cause a situation such as this:
114 * Thread 1 Thread 2
115 * rtnl_lock()
116 * unregister_netdevice()
117 * __rtnl_unlock()
118 * rtnl_lock()
119 * wiphy_lock()
120 * rtnl_unlock()
121 * netdev_run_todo()
122 * __rtnl_unlock()
123 *
124 * // list not empty now
125 * // because of thread 2
126 * rtnl_lock()
127 * while (!list_empty(...))
128 * rtnl_lock()
129 * wiphy_lock()
130 * **** DEADLOCK ****
131 *
132 * However, usage of __rtnl_unlock() is rare, and so we can ensure that
133 * it's not used in cases where something is added to do the list.
134 */
135 WARN_ON(!list_empty(&net_todo_list));
136
6756ae4b 137 mutex_unlock(&rtnl_mutex);
1b5c5493
ED		 138
139 while (head) {
140 struct sk_buff *next = head->next;
141
142 kfree_skb(head);
143 cond_resched();
144 head = next;
145 }
1da177e4 146}
6756ae4b 147
1da177e4
LT		 148void rtnl_unlock(void)
149{
58ec3b4d 150 /* This fellow will unlock it for us. */
1da177e4
LT		 151 netdev_run_todo();
152}
e0d087af 153EXPORT_SYMBOL(rtnl_unlock);
1da177e4 154
6756ae4b
SH		 155int rtnl_trylock(void)
156{
157 return mutex_trylock(&rtnl_mutex);
158}
e0d087af 159EXPORT_SYMBOL(rtnl_trylock);
6756ae4b 160
c9c1014b
PM		 161int rtnl_is_locked(void)
162{
163 return mutex_is_locked(&rtnl_mutex);
164}
e0d087af 165EXPORT_SYMBOL(rtnl_is_locked);
c9c1014b 166
6f99528e
VB		 167bool refcount_dec_and_rtnl_lock(refcount_t *r)
168{
169 return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
170}
171EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
172
a898def2 173#ifdef CONFIG_PROVE_LOCKING
0cbf3343 174bool lockdep_rtnl_is_held(void)
a898def2
PM		 175{
176 return lockdep_is_held(&rtnl_mutex);
177}
178EXPORT_SYMBOL(lockdep_rtnl_is_held);
179#endif /* #ifdef CONFIG_PROVE_LOCKING */
180
51e13685 181static struct rtnl_link __rcu *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
e2849863
TG		 182
183static inline int rtm_msgindex(int msgtype)
184{
185 int msgindex = msgtype - RTM_BASE;
186
187 /*
188 * msgindex < 0 implies someone tried to register a netlink
189 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
190 * the message type has not been added to linux/rtnetlink.h
191 */
192 BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
193
194 return msgindex;
195}
196
addf9b90
FW		 197static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)
198{
51e13685 199 struct rtnl_link __rcu **tab;
addf9b90
FW		 200
201 if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))
202 protocol = PF_UNSPEC;
203
204 tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);
205 if (!tab)
206 tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);
207
51e13685 208 return rcu_dereference_rtnl(tab[msgtype]);
addf9b90
FW		 209}
210
e4202511
FW		 211static int rtnl_register_internal(struct module *owner,
212 int protocol, int msgtype,
213 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
214 unsigned int flags)
e2849863 215{
b0e9fe1b
FW		 216 struct rtnl_link *link, *old;
217 struct rtnl_link __rcu **tab;
e2849863 218 int msgindex;
addf9b90 219 int ret = -ENOBUFS;
e2849863 220
25239cee 221 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
e2849863
TG		 222 msgindex = rtm_msgindex(msgtype);
223
addf9b90 224 rtnl_lock();
51e13685 225 tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
e2849863 226 if (tab == NULL) {
addf9b90
FW		 227 tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);
228 if (!tab)
229 goto unlock;
e2849863 230
addf9b90 231 /* ensures we see the 0 stores */
6853dd48 232 rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);
e2849863
TG		 233 }
234
addf9b90
FW		 235 old = rtnl_dereference(tab[msgindex]);
236 if (old) {
237 link = kmemdup(old, sizeof(*old), GFP_KERNEL);
238 if (!link)
239 goto unlock;
240 } else {
241 link = kzalloc(sizeof(*link), GFP_KERNEL);
242 if (!link)
243 goto unlock;
244 }
245
e4202511
FW		 246 WARN_ON(link->owner && link->owner != owner);
247 link->owner = owner;
248
addf9b90 249 WARN_ON(doit && link->doit && link->doit != doit);
e2849863 250 if (doit)
addf9b90
FW		 251 link->doit = doit;
252 WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
e2849863 253 if (dumpit)
addf9b90 254 link->dumpit = dumpit;
e2849863 255
a6cec0bc
NA		 256 WARN_ON(rtnl_msgtype_kind(msgtype) != RTNL_KIND_DEL &&
257 (flags & RTNL_FLAG_BULK_DEL_SUPPORTED));
addf9b90
FW		 258 link->flags |= flags;
259
260 /* publish protocol:msgtype */
261 rcu_assign_pointer(tab[msgindex], link);
262 ret = 0;
263 if (old)
264 kfree_rcu(old, rcu);
265unlock:
266 rtnl_unlock();
267 return ret;
e2849863 268}
e4202511
FW		 269
270/**
271 * rtnl_register_module - Register a rtnetlink message type
272 *
273 * @owner: module registering the hook (THIS_MODULE)
274 * @protocol: Protocol family or PF_UNSPEC
275 * @msgtype: rtnetlink message type
276 * @doit: Function pointer called for each request message
277 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
d467d0bc 278 * @flags: rtnl_link_flags to modify behaviour of doit/dumpit functions
e4202511
FW		 279 *
280 * Like rtnl_register, but for use by removable modules.
281 */
282int rtnl_register_module(struct module *owner,
283 int protocol, int msgtype,
284 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
285 unsigned int flags)
286{
287 return rtnl_register_internal(owner, protocol, msgtype,
288 doit, dumpit, flags);
289}
290EXPORT_SYMBOL_GPL(rtnl_register_module);
291
292/**
16feebcf 293 * rtnl_register - Register a rtnetlink message type
e4202511
FW		 294 * @protocol: Protocol family or PF_UNSPEC
295 * @msgtype: rtnetlink message type
296 * @doit: Function pointer called for each request message
297 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
d467d0bc 298 * @flags: rtnl_link_flags to modify behaviour of doit/dumpit functions
e4202511
FW		 299 *
300 * Registers the specified function pointers (at least one of them has
301 * to be non-NULL) to be called whenever a request message for the
302 * specified protocol family and message type is received.
303 *
304 * The special protocol family PF_UNSPEC may be used to define fallback
305 * function pointers for the case when no entry for the specific protocol
306 * family exists.
e2849863
TG		 307 */
308void rtnl_register(int protocol, int msgtype,
c7ac8679 309 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
b97bac64 310 unsigned int flags)
e2849863 311{
16feebcf
FW		 312 int err;
313
314 err = rtnl_register_internal(NULL, protocol, msgtype, doit, dumpit,
315 flags);
316 if (err)
317 pr_err("Unable to register rtnetlink message handler, "
318 "protocol = %d, message type = %d\n", protocol, msgtype);
e2849863 319}
e2849863
TG		 320
321/**
322 * rtnl_unregister - Unregister a rtnetlink message type
323 * @protocol: Protocol family or PF_UNSPEC
324 * @msgtype: rtnetlink message type
325 *
326 * Returns 0 on success or a negative error code.
327 */
328int rtnl_unregister(int protocol, int msgtype)
329{
51e13685
JK		 330 struct rtnl_link __rcu **tab;
331 struct rtnl_link *link;
e2849863
TG		 332 int msgindex;
333
25239cee 334 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
e2849863
TG		 335 msgindex = rtm_msgindex(msgtype);
336
6853dd48 337 rtnl_lock();
addf9b90
FW		 338 tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
339 if (!tab) {
6853dd48 340 rtnl_unlock();
e2849863 341 return -ENOENT;
6853dd48 342 }
e2849863 343
51e13685 344 link = rtnl_dereference(tab[msgindex]);
4fc29989 345 RCU_INIT_POINTER(tab[msgindex], NULL);
6853dd48 346 rtnl_unlock();
e2849863 347
addf9b90
FW		 348 kfree_rcu(link, rcu);
349
e2849863
TG		 350 return 0;
351}
e2849863
TG		 352EXPORT_SYMBOL_GPL(rtnl_unregister);
353
354/**
355 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
356 * @protocol : Protocol family or PF_UNSPEC
357 *
358 * Identical to calling rtnl_unregster() for all registered message types
359 * of a certain protocol family.
360 */
361void rtnl_unregister_all(int protocol)
362{
51e13685
JK		 363 struct rtnl_link __rcu **tab;
364 struct rtnl_link *link;
addf9b90 365 int msgindex;
019a3169 366
25239cee 367 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
e2849863 368
019a3169 369 rtnl_lock();
51e13685 370 tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
f707ef61
SD		 371 if (!tab) {
372 rtnl_unlock();
373 return;
374 }
6853dd48 375 RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL);
addf9b90 376 for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {
51e13685 377 link = rtnl_dereference(tab[msgindex]);
addf9b90
FW		 378 if (!link)
379 continue;
380
4fc29989 381 RCU_INIT_POINTER(tab[msgindex], NULL);
addf9b90
FW		 382 kfree_rcu(link, rcu);
383 }
019a3169
FW		 384 rtnl_unlock();
385
6853dd48
FW		 386 synchronize_net();
387
addf9b90 388 kfree(tab);
e2849863 389}
e2849863 390EXPORT_SYMBOL_GPL(rtnl_unregister_all);
1da177e4 391
38f7b870
PM		 392static LIST_HEAD(link_ops);
393
c63044f0
ED		 394static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
395{
396 const struct rtnl_link_ops *ops;
397
398 list_for_each_entry(ops, &link_ops, list) {
399 if (!strcmp(ops->kind, kind))
400 return ops;
401 }
402 return NULL;
403}
404
38f7b870
PM		 405/**
406 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink.
407 * @ops: struct rtnl_link_ops * to register
408 *
409 * The caller must hold the rtnl_mutex. This function should be used
410 * by drivers that create devices during module initialization. It
411 * must be called before registering the devices.
412 *
413 * Returns 0 on success or a negative error code.
414 */
415int __rtnl_link_register(struct rtnl_link_ops *ops)
416{
c63044f0
ED		 417 if (rtnl_link_ops_get(ops->kind))
418 return -EEXIST;
419
8c713dc9 420 /* The check for alloc/setup is here because if ops
b0ab2fab
JP		 421 * does not have that filled up, it is not possible
422 * to use the ops for creating device. So do not
423 * fill up dellink as well. That disables rtnl_dellink.
424 */
8c713dc9 425 if ((ops->alloc || ops->setup) && !ops->dellink)
23289a37 426 ops->dellink = unregister_netdevice_queue;
2d85cba2 427
38f7b870
PM		 428 list_add_tail(&ops->list, &link_ops);
429 return 0;
430}
38f7b870
PM		 431EXPORT_SYMBOL_GPL(__rtnl_link_register);
432
433/**
434 * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
435 * @ops: struct rtnl_link_ops * to register
436 *
437 * Returns 0 on success or a negative error code.
438 */
439int rtnl_link_register(struct rtnl_link_ops *ops)
440{
441 int err;
442
ccf8dbcd
KC		 443 /* Sanity-check max sizes to avoid stack buffer overflow. */
444 if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||
445 ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))
446 return -EINVAL;
447
38f7b870
PM		 448 rtnl_lock();
449 err = __rtnl_link_register(ops);
450 rtnl_unlock();
451 return err;
452}
38f7b870
PM		 453EXPORT_SYMBOL_GPL(rtnl_link_register);
454
669f87ba
PE		 455static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
456{
457 struct net_device *dev;
23289a37
ED		 458 LIST_HEAD(list_kill);
459
669f87ba 460 for_each_netdev(net, dev) {
23289a37
ED		 461 if (dev->rtnl_link_ops == ops)
462 ops->dellink(dev, &list_kill);
669f87ba 463 }
23289a37 464 unregister_netdevice_many(&list_kill);
669f87ba
PE		 465}
466
38f7b870
PM		 467/**
468 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
469 * @ops: struct rtnl_link_ops * to unregister
470 *
554873e5
KT		 471 * The caller must hold the rtnl_mutex and guarantee net_namespace_list
472 * integrity (hold pernet_ops_rwsem for writing to close the race
473 * with setup_net() and cleanup_net()).
38f7b870
PM		 474 */
475void __rtnl_link_unregister(struct rtnl_link_ops *ops)
476{
881d966b 477 struct net *net;
2d85cba2 478
881d966b 479 for_each_net(net) {
669f87ba 480 __rtnl_kill_links(net, ops);
2d85cba2 481 }
38f7b870
PM		 482 list_del(&ops->list);
483}
38f7b870
PM		 484EXPORT_SYMBOL_GPL(__rtnl_link_unregister);
485
200b916f
CW		 486/* Return with the rtnl_lock held when there are no network
487 * devices unregistering in any network namespace.
488 */
489static void rtnl_lock_unregistering_all(void)
490{
491 struct net *net;
492 bool unregistering;
ff960a73 493 DEFINE_WAIT_FUNC(wait, woken_wake_function);
200b916f 494
ff960a73 495 add_wait_queue(&netdev_unregistering_wq, &wait);
200b916f 496 for (;;) {
200b916f
CW		 497 unregistering = false;
498 rtnl_lock();
f0b07bb1
KT		 499 /* We held write locked pernet_ops_rwsem, and parallel
500 * setup_net() and cleanup_net() are not possible.
501 */
200b916f 502 for_each_net(net) {
ede6c39c 503 if (atomic_read(&net->dev_unreg_count) > 0) {
200b916f
CW		 504 unregistering = true;
505 break;
506 }
507 }
508 if (!unregistering)
509 break;
510 __rtnl_unlock();
ff960a73
PZ		 511
512 wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
200b916f 513 }
ff960a73 514 remove_wait_queue(&netdev_unregistering_wq, &wait);
200b916f
CW		 515}
516
38f7b870
PM		 517/**
518 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
519 * @ops: struct rtnl_link_ops * to unregister
520 */
521void rtnl_link_unregister(struct rtnl_link_ops *ops)
522{
8518e9bb 523 /* Close the race with setup_net() and cleanup_net() */
4420bf21 524 down_write(&pernet_ops_rwsem);
200b916f 525 rtnl_lock_unregistering_all();
38f7b870
PM		 526 __rtnl_link_unregister(ops);
527 rtnl_unlock();
4420bf21 528 up_write(&pernet_ops_rwsem);
38f7b870 529}
38f7b870
PM		 530EXPORT_SYMBOL_GPL(rtnl_link_unregister);
531
ba7d49b1
JP		 532static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
533{
534 struct net_device *master_dev;
535 const struct rtnl_link_ops *ops;
8515ae38 536 size_t size = 0;
ba7d49b1 537
8515ae38
FW		 538 rcu_read_lock();
539
540 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
ba7d49b1 541 if (!master_dev)
8515ae38
FW		 542 goto out;
543
ba7d49b1 544 ops = master_dev->rtnl_link_ops;
6049f253 545 if (!ops || !ops->get_slave_size)
8515ae38 546 goto out;
ba7d49b1 547 /* IFLA_INFO_SLAVE_DATA + nested data */
8515ae38 548 size = nla_total_size(sizeof(struct nlattr)) +
ba7d49b1 549 ops->get_slave_size(master_dev, dev);
8515ae38
FW		 550
551out:
552 rcu_read_unlock();
553 return size;
ba7d49b1
JP		 554}
555
38f7b870
PM		 556static size_t rtnl_link_get_size(const struct net_device *dev)
557{
558 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
559 size_t size;
560
561 if (!ops)
562 return 0;
563
369cf77a
TG		 564 size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
565 nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */
38f7b870
PM		 566
567 if (ops->get_size)
568 /* IFLA_INFO_DATA + nested data */
369cf77a 569 size += nla_total_size(sizeof(struct nlattr)) +
38f7b870
PM		 570 ops->get_size(dev);
571
572 if (ops->get_xstats_size)
369cf77a
TG		 573 /* IFLA_INFO_XSTATS */
574 size += nla_total_size(ops->get_xstats_size(dev));
38f7b870 575
ba7d49b1
JP		 576 size += rtnl_link_get_slave_info_data_size(dev);
577
38f7b870
PM		 578 return size;
579}
580
f8ff182c
TG		 581static LIST_HEAD(rtnl_af_ops);
582
583static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
584{
585 const struct rtnl_af_ops *ops;
586
a100243d
CW		 587 ASSERT_RTNL();
588
589 list_for_each_entry(ops, &rtnl_af_ops, list) {
f8ff182c
TG		 590 if (ops->family == family)
591 return ops;
592 }
593
594 return NULL;
595}
596
f8ff182c
TG		 597/**
598 * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
599 * @ops: struct rtnl_af_ops * to register
600 *
601 * Returns 0 on success or a negative error code.
602 */
3678a9d8 603void rtnl_af_register(struct rtnl_af_ops *ops)
f8ff182c 604{
f8ff182c 605 rtnl_lock();
5fa85a09 606 list_add_tail_rcu(&ops->list, &rtnl_af_ops);
f8ff182c 607 rtnl_unlock();
f8ff182c
TG		 608}
609EXPORT_SYMBOL_GPL(rtnl_af_register);
610
f8ff182c
TG		 611/**
612 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
613 * @ops: struct rtnl_af_ops * to unregister
614 */
615void rtnl_af_unregister(struct rtnl_af_ops *ops)
616{
617 rtnl_lock();
5fa85a09 618 list_del_rcu(&ops->list);
f8ff182c 619 rtnl_unlock();
5fa85a09
FW		 620
621 synchronize_rcu();
f8ff182c
TG		 622}
623EXPORT_SYMBOL_GPL(rtnl_af_unregister);
624
b1974ed0
AR		 625static size_t rtnl_link_get_af_size(const struct net_device *dev,
626 u32 ext_filter_mask)
f8ff182c
TG		 627{
628 struct rtnl_af_ops *af_ops;
629 size_t size;
630
631 /* IFLA_AF_SPEC */
632 size = nla_total_size(sizeof(struct nlattr));
633
5fa85a09
FW		 634 rcu_read_lock();
635 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
f8ff182c
TG		 636 if (af_ops->get_link_af_size) {
637 /* AF_* + nested data */
638 size += nla_total_size(sizeof(struct nlattr)) +
b1974ed0 639 af_ops->get_link_af_size(dev, ext_filter_mask);
f8ff182c
TG		 640 }
641 }
5fa85a09 642 rcu_read_unlock();
f8ff182c
TG		 643
644 return size;
645}
646
ba7d49b1 647static bool rtnl_have_link_slave_info(const struct net_device *dev)
38f7b870 648{
ba7d49b1 649 struct net_device *master_dev;
4c82a95e 650 bool ret = false;
38f7b870 651
4c82a95e
FW		 652 rcu_read_lock();
653
654 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
813f020c 655 if (master_dev && master_dev->rtnl_link_ops)
4c82a95e
FW		 656 ret = true;
657 rcu_read_unlock();
658 return ret;
ba7d49b1
JP		 659}
660
661static int rtnl_link_slave_info_fill(struct sk_buff *skb,
662 const struct net_device *dev)
663{
664 struct net_device *master_dev;
665 const struct rtnl_link_ops *ops;
666 struct nlattr *slave_data;
667 int err;
38f7b870 668
ba7d49b1
JP		 669 master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
670 if (!master_dev)
671 return 0;
672 ops = master_dev->rtnl_link_ops;
673 if (!ops)
674 return 0;
675 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
676 return -EMSGSIZE;
677 if (ops->fill_slave_info) {
ae0be8de 678 slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);
ba7d49b1
JP		 679 if (!slave_data)
680 return -EMSGSIZE;
681 err = ops->fill_slave_info(skb, master_dev, dev);
682 if (err < 0)
683 goto err_cancel_slave_data;
684 nla_nest_end(skb, slave_data);
685 }
686 return 0;
687
688err_cancel_slave_data:
689 nla_nest_cancel(skb, slave_data);
690 return err;
691}
692
693static int rtnl_link_info_fill(struct sk_buff *skb,
694 const struct net_device *dev)
695{
696 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
697 struct nlattr *data;
698 int err;
699
700 if (!ops)
701 return 0;
38f7b870 702 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
ba7d49b1 703 return -EMSGSIZE;
38f7b870
PM		 704 if (ops->fill_xstats) {
705 err = ops->fill_xstats(skb, dev);
706 if (err < 0)
ba7d49b1 707 return err;
38f7b870
PM		 708 }
709 if (ops->fill_info) {
ae0be8de 710 data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);
ba7d49b1
JP		 711 if (data == NULL)
712 return -EMSGSIZE;
38f7b870
PM		 713 err = ops->fill_info(skb, dev);
714 if (err < 0)
715 goto err_cancel_data;
716 nla_nest_end(skb, data);
717 }
38f7b870
PM		 718 return 0;
719
720err_cancel_data:
721 nla_nest_cancel(skb, data);
ba7d49b1
JP		 722 return err;
723}
724
725static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
726{
727 struct nlattr *linkinfo;
728 int err = -EMSGSIZE;
729
ae0be8de 730 linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);
ba7d49b1
JP		 731 if (linkinfo == NULL)
732 goto out;
733
734 err = rtnl_link_info_fill(skb, dev);
735 if (err < 0)
736 goto err_cancel_link;
737
738 err = rtnl_link_slave_info_fill(skb, dev);
739 if (err < 0)
740 goto err_cancel_link;
741
742 nla_nest_end(skb, linkinfo);
743 return 0;
744
38f7b870
PM		 745err_cancel_link:
746 nla_nest_cancel(skb, linkinfo);
747out:
748 return err;
749}
750
95c96174 751int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
1da177e4 752{
97c53cac 753 struct sock *rtnl = net->rtnl;
cfdf0d9a
YD		 754
755 return nlmsg_notify(rtnl, skb, pid, group, echo, GFP_KERNEL);
1da177e4
LT		 756}
757
97c53cac 758int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
2942e900 759{
97c53cac
DL		 760 struct sock *rtnl = net->rtnl;
761
2942e900
TG		 762 return nlmsg_unicast(rtnl, skb, pid);
763}
e0d087af 764EXPORT_SYMBOL(rtnl_unicast);
2942e900 765
1ce85fe4 766void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
1d997f10 767 const struct nlmsghdr *nlh, gfp_t flags)
97676b6b 768{
97c53cac 769 struct sock *rtnl = net->rtnl;
97676b6b 770
f9b282b3 771 nlmsg_notify(rtnl, skb, pid, group, nlmsg_report(nlh), flags);
97676b6b 772}
e0d087af 773EXPORT_SYMBOL(rtnl_notify);
97676b6b 774
97c53cac 775void rtnl_set_sk_err(struct net *net, u32 group, int error)
97676b6b 776{
97c53cac
DL		 777 struct sock *rtnl = net->rtnl;
778
97676b6b
TG		 779 netlink_set_err(rtnl, 0, group, error);
780}
e0d087af 781EXPORT_SYMBOL(rtnl_set_sk_err);
97676b6b 782
1da177e4
LT		 783int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
784{
2d7202bf
TG		 785 struct nlattr *mx;
786 int i, valid = 0;
787
c22a133a
DA		 788 /* nothing is dumped for dst_default_metrics, so just skip the loop */
789 if (metrics == dst_default_metrics.metrics)
790 return 0;
791
ae0be8de 792 mx = nla_nest_start_noflag(skb, RTA_METRICS);
2d7202bf
TG		 793 if (mx == NULL)
794 return -ENOBUFS;
795
796 for (i = 0; i < RTAX_MAX; i++) {
797 if (metrics[i]) {
ea697639
DB		 798 if (i == RTAX_CC_ALGO - 1) {
799 char tmp[TCP_CA_NAME_MAX], *name;
800
801 name = tcp_ca_get_name_by_key(metrics[i], tmp);
802 if (!name)
803 continue;
804 if (nla_put_string(skb, i + 1, name))
805 goto nla_put_failure;
c3a8d947
DB		 806 } else if (i == RTAX_FEATURES - 1) {
807 u32 user_features = metrics[i] & RTAX_FEATURE_MASK;
808
f8edcd12
PS		 809 if (!user_features)
810 continue;
c3a8d947
DB		 811 BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
812 if (nla_put_u32(skb, i + 1, user_features))
813 goto nla_put_failure;
ea697639
DB		 814 } else {
815 if (nla_put_u32(skb, i + 1, metrics[i]))
816 goto nla_put_failure;
817 }
2d7202bf 818 valid++;
2d7202bf 819 }
1da177e4 820 }
1da177e4 821
a57d27fc
DM		 822 if (!valid) {
823 nla_nest_cancel(skb, mx);
824 return 0;
825 }
2d7202bf
TG		 826
827 return nla_nest_end(skb, mx);
828
829nla_put_failure:
bc3ed28c
TG		 830 nla_nest_cancel(skb, mx);
831 return -EMSGSIZE;
1da177e4 832}
e0d087af 833EXPORT_SYMBOL(rtnetlink_put_metrics);
1da177e4 834
e3703b3d 835int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
87a50699 836 long expires, u32 error)
e3703b3d
TG		 837{
838 struct rta_cacheinfo ci = {
e3703b3d
TG		 839 .rta_error = error,
840 .rta_id = id,
e3703b3d
TG		 841 };
842
3940746d
DA		 843 if (dst) {
844 ci.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse);
845 ci.rta_used = dst->__use;
bc9d3a9f 846 ci.rta_clntref = rcuref_read(&dst->__rcuref);
3940746d 847 }
8253947e
LW		 848 if (expires) {
849 unsigned long clock;
e3703b3d 850
8253947e
LW		 851 clock = jiffies_to_clock_t(abs(expires));
852 clock = min_t(unsigned long, clock, INT_MAX);
853 ci.rta_expires = (expires > 0) ? clock : -clock;
854 }
e3703b3d
TG		 855 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
856}
e3703b3d 857EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
1da177e4 858
93b2d4a2 859static void set_operstate(struct net_device *dev, unsigned char transition)
b00055aa
SR		 860{
861 unsigned char operstate = dev->operstate;
862
e0d087af 863 switch (transition) {
b00055aa
SR		 864 case IF_OPER_UP:
865 if ((operstate == IF_OPER_DORMANT ||
eec517cd 866 operstate == IF_OPER_TESTING ||
b00055aa 867 operstate == IF_OPER_UNKNOWN) &&
eec517cd 868 !netif_dormant(dev) && !netif_testing(dev))
b00055aa
SR		 869 operstate = IF_OPER_UP;
870 break;
871
eec517cd 872 case IF_OPER_TESTING:
abbc7928 873 if (netif_oper_up(dev))
eec517cd
AL		 874 operstate = IF_OPER_TESTING;
875 break;
876
b00055aa 877 case IF_OPER_DORMANT:
abbc7928 878 if (netif_oper_up(dev))
b00055aa
SR		 879 operstate = IF_OPER_DORMANT;
880 break;
3ff50b79 881 }
b00055aa
SR		 882
883 if (dev->operstate != operstate) {
fd888e85 884 write_lock(&dev_base_lock);
b00055aa 885 dev->operstate = operstate;
fd888e85 886 write_unlock(&dev_base_lock);
93b2d4a2
DM		 887 netdev_state_change(dev);
888 }
b00055aa
SR		 889}
890
b1beb681
JB		 891static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
892{
893 return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
894 (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
895}
896
3729d502
PM		 897static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
898 const struct ifinfomsg *ifm)
899{
900 unsigned int flags = ifm->ifi_flags;
901
902 /* bugwards compatibility: ifi_change == 0 is treated as ~0 */
903 if (ifm->ifi_change)
904 flags = (flags & ifm->ifi_change) |
b1beb681 905 (rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
3729d502
PM		 906
907 return flags;
908}
909
b60c5115 910static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
be1f3c2c 911 const struct rtnl_link_stats64 *b)
1da177e4 912{
b60c5115
TG		 913 a->rx_packets = b->rx_packets;
914 a->tx_packets = b->tx_packets;
915 a->rx_bytes = b->rx_bytes;
916 a->tx_bytes = b->tx_bytes;
917 a->rx_errors = b->rx_errors;
918 a->tx_errors = b->tx_errors;
919 a->rx_dropped = b->rx_dropped;
920 a->tx_dropped = b->tx_dropped;
921
922 a->multicast = b->multicast;
923 a->collisions = b->collisions;
924
925 a->rx_length_errors = b->rx_length_errors;
926 a->rx_over_errors = b->rx_over_errors;
927 a->rx_crc_errors = b->rx_crc_errors;
928 a->rx_frame_errors = b->rx_frame_errors;
929 a->rx_fifo_errors = b->rx_fifo_errors;
930 a->rx_missed_errors = b->rx_missed_errors;
931
932 a->tx_aborted_errors = b->tx_aborted_errors;
933 a->tx_carrier_errors = b->tx_carrier_errors;
934 a->tx_fifo_errors = b->tx_fifo_errors;
935 a->tx_heartbeat_errors = b->tx_heartbeat_errors;
936 a->tx_window_errors = b->tx_window_errors;
937
938 a->rx_compressed = b->rx_compressed;
939 a->tx_compressed = b->tx_compressed;
6e7333d3
JW		 940
941 a->rx_nohandler = b->rx_nohandler;
10708f37
JE		 942}
943
c02db8c6 944/* All VF info */
115c9b81
GR		 945static inline int rtnl_vfinfo_size(const struct net_device *dev,
946 u32 ext_filter_mask)
ebc08a6f 947{
9af15c38 948 if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
c02db8c6 949 int num_vfs = dev_num_vf(dev->dev.parent);
7e75f74a 950 size_t size = nla_total_size(0);
045de01a 951 size += num_vfs *
7e75f74a
SD		 952 (nla_total_size(0) +
953 nla_total_size(sizeof(struct ifla_vf_mac)) +
75345f88 954 nla_total_size(sizeof(struct ifla_vf_broadcast)) +
7e75f74a
SD		 955 nla_total_size(sizeof(struct ifla_vf_vlan)) +
956 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
79aab093
MS		 957 nla_total_size(MAX_VLAN_LIST_LEN *
958 sizeof(struct ifla_vf_vlan_info)) +
ed616689 959 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
7e75f74a 960 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
945a3676 961 nla_total_size(sizeof(struct ifla_vf_rate)) +
01a3d796 962 nla_total_size(sizeof(struct ifla_vf_link_state)) +
3b766cd8 963 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
dd461d6a 964 nla_total_size(sizeof(struct ifla_vf_trust)));
fa0e21fa
EP		 965 if (~ext_filter_mask & RTEXT_FILTER_SKIP_STATS) {
966 size += num_vfs *
967 (nla_total_size(0) + /* nest IFLA_VF_STATS */
968 /* IFLA_VF_STATS_RX_PACKETS */
969 nla_total_size_64bit(sizeof(__u64)) +
970 /* IFLA_VF_STATS_TX_PACKETS */
971 nla_total_size_64bit(sizeof(__u64)) +
972 /* IFLA_VF_STATS_RX_BYTES */
973 nla_total_size_64bit(sizeof(__u64)) +
974 /* IFLA_VF_STATS_TX_BYTES */
975 nla_total_size_64bit(sizeof(__u64)) +
976 /* IFLA_VF_STATS_BROADCAST */
977 nla_total_size_64bit(sizeof(__u64)) +
978 /* IFLA_VF_STATS_MULTICAST */
979 nla_total_size_64bit(sizeof(__u64)) +
980 /* IFLA_VF_STATS_RX_DROPPED */
981 nla_total_size_64bit(sizeof(__u64)) +
982 /* IFLA_VF_STATS_TX_DROPPED */
983 nla_total_size_64bit(sizeof(__u64)));
984 }
c02db8c6
CW		 985 return size;
986 } else
ebc08a6f
WM		 987 return 0;
988}
989
c53864fd
DG		 990static size_t rtnl_port_size(const struct net_device *dev,
991 u32 ext_filter_mask)
57b61080
SF		 992{
993 size_t port_size = nla_total_size(4) /* PORT_VF */
994 + nla_total_size(PORT_PROFILE_MAX) /* PORT_PROFILE */
57b61080
SF		 995 + nla_total_size(PORT_UUID_MAX) /* PORT_INSTANCE_UUID */
996 + nla_total_size(PORT_UUID_MAX) /* PORT_HOST_UUID */
997 + nla_total_size(1) /* PROT_VDP_REQUEST */
998 + nla_total_size(2); /* PORT_VDP_RESPONSE */
999 size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
1000 size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
1001 + port_size;
1002 size_t port_self_size = nla_total_size(sizeof(struct nlattr))
1003 + port_size;
1004
c53864fd
DG		 1005 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1006 !(ext_filter_mask & RTEXT_FILTER_VF))
57b61080
SF		 1007 return 0;
1008 if (dev_num_vf(dev->dev.parent))
1009 return port_self_size + vf_ports_size +
1010 vf_port_size * dev_num_vf(dev->dev.parent);
1011 else
1012 return port_self_size;
1013}
1014
b5cdae32 1015static size_t rtnl_xdp_size(void)
d1fdd913 1016{
b3cfaa31 1017 size_t xdp_size = nla_total_size(0) + /* nest IFLA_XDP */
58038695 1018 nla_total_size(1) + /* XDP_ATTACHED */
a25717d2 1019 nla_total_size(4) + /* XDP_PROG_ID (or 1st mode) */
4f91da26 1020 nla_total_size(4); /* XDP_<mode>_PROG_ID */
d1fdd913 1021
b5cdae32 1022 return xdp_size;
d1fdd913
BB		 1023}
1024
88f4fb0c
JP		 1025static size_t rtnl_prop_list_size(const struct net_device *dev)
1026{
1027 struct netdev_name_node *name_node;
1028 size_t size;
1029
1030 if (list_empty(&dev->name_node->list))
1031 return 0;
1032 size = nla_total_size(0);
1033 list_for_each_entry(name_node, &dev->name_node->list, list)
1034 size += nla_total_size(ALTIFNAMSIZ);
1035 return size;
1036}
1037
829eb208
RP		 1038static size_t rtnl_proto_down_size(const struct net_device *dev)
1039{
1040 size_t size = nla_total_size(1);
1041
1042 if (dev->proto_down_reason)
1043 size += nla_total_size(0) + nla_total_size(4);
1044
1045 return size;
1046}
1047
dca56c30
JP		 1048static size_t rtnl_devlink_port_size(const struct net_device *dev)
1049{
1050 size_t size = nla_total_size(0); /* nest IFLA_DEVLINK_PORT */
1051
1052 if (dev->devlink_port)
1053 size += devlink_nl_port_handle_size(dev->devlink_port);
1054
1055 return size;
1056}
1057
115c9b81
GR		 1058static noinline size_t if_nlmsg_size(const struct net_device *dev,
1059 u32 ext_filter_mask)
339bf98f
TG		 1060{
1061 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
1062 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
0b815a1a 1063 + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
339bf98f 1064 + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
270cb4d0 1065 + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
339bf98f 1066 + nla_total_size(sizeof(struct rtnl_link_stats))
35c58459 1067 + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))
339bf98f
TG		 1068 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
1069 + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
1070 + nla_total_size(4) /* IFLA_TXQLEN */
1071 + nla_total_size(4) /* IFLA_WEIGHT */
1072 + nla_total_size(4) /* IFLA_MTU */
1073 + nla_total_size(4) /* IFLA_LINK */
1074 + nla_total_size(4) /* IFLA_MASTER */
9a57247f 1075 + nla_total_size(1) /* IFLA_CARRIER */
edbc0bb3 1076 + nla_total_size(4) /* IFLA_PROMISCUITY */
7e6e1b57 1077 + nla_total_size(4) /* IFLA_ALLMULTI */
76ff5cc9
JP		 1078 + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
1079 + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
6919756c
TK		 1080 + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
1081 + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */
eac1b93c 1082 + nla_total_size(4) /* IFLA_GRO_MAX_SIZE */
9eefedd5
XL		 1083 + nla_total_size(4) /* IFLA_GSO_IPV4_MAX_SIZE */
1084 + nla_total_size(4) /* IFLA_GRO_IPV4_MAX_SIZE */
89527be8
ED		 1085 + nla_total_size(4) /* IFLA_TSO_MAX_SIZE */
1086 + nla_total_size(4) /* IFLA_TSO_MAX_SEGS */
339bf98f 1087 + nla_total_size(1) /* IFLA_OPERSTATE */
38f7b870 1088 + nla_total_size(1) /* IFLA_LINKMODE */
2d3b479d 1089 + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
d37512a2 1090 + nla_total_size(4) /* IFLA_LINK_NETNSID */
db833d40 1091 + nla_total_size(4) /* IFLA_GROUP */
115c9b81
GR		 1092 + nla_total_size(ext_filter_mask
1093 & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
1094 + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
c53864fd 1095 + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
f8ff182c 1096 + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
b1974ed0 1097 + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */
82f28412 1098 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
88d6378b 1099 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
c57c7a95 1100 + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
b5cdae32 1101 + rtnl_xdp_size() /* IFLA_XDP */
3d3ea5af 1102 + nla_total_size(4) /* IFLA_EVENT */
6621dd29 1103 + nla_total_size(4) /* IFLA_NEW_NETNSID */
38e01b30 1104 + nla_total_size(4) /* IFLA_NEW_IFINDEX */
829eb208 1105 + rtnl_proto_down_size(dev) /* proto down */
7e4a8d5a 1106 + nla_total_size(4) /* IFLA_TARGET_NETNSID */
b2d3bcfa
DD		 1107 + nla_total_size(4) /* IFLA_CARRIER_UP_COUNT */
1108 + nla_total_size(4) /* IFLA_CARRIER_DOWN_COUNT */
3e7a50ce
SH		 1109 + nla_total_size(4) /* IFLA_MIN_MTU */
1110 + nla_total_size(4) /* IFLA_MAX_MTU */
88f4fb0c 1111 + rtnl_prop_list_size(dev)
f74877a5 1112 + nla_total_size(MAX_ADDR_LEN) /* IFLA_PERM_ADDRESS */
dca56c30 1113 + rtnl_devlink_port_size(dev)
79e1ad14 1114 + 0;
339bf98f
TG		 1115}
1116
57b61080
SF		 1117static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
1118{
1119 struct nlattr *vf_ports;
1120 struct nlattr *vf_port;
1121 int vf;
1122 int err;
1123
ae0be8de 1124 vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS);
57b61080
SF		 1125 if (!vf_ports)
1126 return -EMSGSIZE;
1127
1128 for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
ae0be8de 1129 vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT);
8ca94183
SF		 1130 if (!vf_port)
1131 goto nla_put_failure;
a6574349
DM		 1132 if (nla_put_u32(skb, IFLA_PORT_VF, vf))
1133 goto nla_put_failure;
57b61080 1134 err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
8ca94183
SF		 1135 if (err == -EMSGSIZE)
1136 goto nla_put_failure;
57b61080 1137 if (err) {
57b61080
SF		 1138 nla_nest_cancel(skb, vf_port);
1139 continue;
1140 }
1141 nla_nest_end(skb, vf_port);
1142 }
1143
1144 nla_nest_end(skb, vf_ports);
1145
1146 return 0;
8ca94183
SF		 1147
1148nla_put_failure:
1149 nla_nest_cancel(skb, vf_ports);
1150 return -EMSGSIZE;
57b61080
SF		 1151}
1152
1153static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
1154{
1155 struct nlattr *port_self;
1156 int err;
1157
ae0be8de 1158 port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF);
57b61080
SF		 1159 if (!port_self)
1160 return -EMSGSIZE;
1161
1162 err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
1163 if (err) {
1164 nla_nest_cancel(skb, port_self);
8ca94183 1165 return (err == -EMSGSIZE) ? err : 0;
57b61080
SF		 1166 }
1167
1168 nla_nest_end(skb, port_self);
1169
1170 return 0;
1171}
1172
c53864fd
DG		 1173static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
1174 u32 ext_filter_mask)
57b61080
SF		 1175{
1176 int err;
1177
c53864fd
DG		 1178 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1179 !(ext_filter_mask & RTEXT_FILTER_VF))
57b61080
SF		 1180 return 0;
1181
1182 err = rtnl_port_self_fill(skb, dev);
1183 if (err)
1184 return err;
1185
1186 if (dev_num_vf(dev->dev.parent)) {
1187 err = rtnl_vf_ports_fill(skb, dev);
1188 if (err)
1189 return err;
1190 }
1191
1192 return 0;
1193}
1194
66cae9ed
JP		 1195static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
1196{
1197 int err;
02637fce 1198 struct netdev_phys_item_id ppid;
66cae9ed
JP		 1199
1200 err = dev_get_phys_port_id(dev, &ppid);
1201 if (err) {
1202 if (err == -EOPNOTSUPP)
1203 return 0;
1204 return err;
1205 }
1206
1207 if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
1208 return -EMSGSIZE;
1209
1210 return 0;
1211}
1212
db24a904
DA		 1213static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
1214{
1215 char name[IFNAMSIZ];
1216 int err;
1217
1218 err = dev_get_phys_port_name(dev, name, sizeof(name));
1219 if (err) {
1220 if (err == -EOPNOTSUPP)
1221 return 0;
1222 return err;
1223 }
1224
77ef033b 1225 if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))
db24a904
DA		 1226 return -EMSGSIZE;
1227
1228 return 0;
1229}
1230
82f28412
JP		 1231static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
1232{
bccb3025 1233 struct netdev_phys_item_id ppid = { };
82f28412 1234 int err;
82f28412 1235
bccb3025 1236 err = dev_get_port_parent_id(dev, &ppid, false);
82f28412
JP		 1237 if (err) {
1238 if (err == -EOPNOTSUPP)
1239 return 0;
1240 return err;
1241 }
1242
bccb3025 1243 if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id))
82f28412
JP		 1244 return -EMSGSIZE;
1245
1246 return 0;
1247}
1248
b22b941b
HFS		 1249static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
1250 struct net_device *dev)
1251{
550bce59 1252 struct rtnl_link_stats64 *sp;
b22b941b 1253 struct nlattr *attr;
18402843 1254
58414d32
ND		 1255 attr = nla_reserve_64bit(skb, IFLA_STATS64,
1256 sizeof(struct rtnl_link_stats64), IFLA_PAD);
b22b941b
HFS		 1257 if (!attr)
1258 return -EMSGSIZE;
1259
550bce59
RP		 1260 sp = nla_data(attr);
1261 dev_get_stats(dev, sp);
b22b941b 1262
550bce59
RP		 1263 attr = nla_reserve(skb, IFLA_STATS,
1264 sizeof(struct rtnl_link_stats));
b22b941b
HFS		 1265 if (!attr)
1266 return -EMSGSIZE;
1267
550bce59 1268 copy_rtnl_link_stats(nla_data(attr), sp);
b22b941b
HFS		 1269
1270 return 0;
1271}
1272
1273static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
1274 struct net_device *dev,
1275 int vfs_num,
fa0e21fa 1276 u32 ext_filter_mask)
b22b941b
HFS		 1277{
1278 struct ifla_vf_rss_query_en vf_rss_query_en;
79aab093 1279 struct nlattr *vf, *vfstats, *vfvlanlist;
b22b941b 1280 struct ifla_vf_link_state vf_linkstate;
79aab093 1281 struct ifla_vf_vlan_info vf_vlan_info;
b22b941b
HFS		 1282 struct ifla_vf_spoofchk vf_spoofchk;
1283 struct ifla_vf_tx_rate vf_tx_rate;
1284 struct ifla_vf_stats vf_stats;
1285 struct ifla_vf_trust vf_trust;
1286 struct ifla_vf_vlan vf_vlan;
1287 struct ifla_vf_rate vf_rate;
b22b941b 1288 struct ifla_vf_mac vf_mac;
75345f88 1289 struct ifla_vf_broadcast vf_broadcast;
b22b941b 1290 struct ifla_vf_info ivi;
30aad417
DG		 1291 struct ifla_vf_guid node_guid;
1292 struct ifla_vf_guid port_guid;
b22b941b 1293
0eed9cf5
MY		 1294 memset(&ivi, 0, sizeof(ivi));
1295
b22b941b
HFS		 1296 /* Not all SR-IOV capable drivers support the
1297 * spoofcheck and "RSS query enable" query. Preset to
1298 * -1 so the user space tool can detect that the driver
1299 * didn't report anything.
1300 */
1301 ivi.spoofchk = -1;
1302 ivi.rss_query_en = -1;
1303 ivi.trusted = -1;
b22b941b
HFS		 1304 /* The default value for VF link state is "auto"
1305 * IFLA_VF_LINK_STATE_AUTO which equals zero
1306 */
1307 ivi.linkstate = 0;
79aab093
MS		 1308 /* VLAN Protocol by default is 802.1Q */
1309 ivi.vlan_proto = htons(ETH_P_8021Q);
b22b941b
HFS		 1310 if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
1311 return 0;
1312
775f4f05 1313 memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));
9fbf082f
LR		 1314 memset(&node_guid, 0, sizeof(node_guid));
1315 memset(&port_guid, 0, sizeof(port_guid));
775f4f05 1316
b22b941b
HFS		 1317 vf_mac.vf =
1318 vf_vlan.vf =
79aab093 1319 vf_vlan_info.vf =
b22b941b
HFS		 1320 vf_rate.vf =
1321 vf_tx_rate.vf =
1322 vf_spoofchk.vf =
1323 vf_linkstate.vf =
1324 vf_rss_query_en.vf =
9aed6ae0
DG		 1325 vf_trust.vf =
1326 node_guid.vf =
1327 port_guid.vf = ivi.vf;
b22b941b
HFS		 1328
1329 memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
75345f88 1330 memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len);
b22b941b
HFS		 1331 vf_vlan.vlan = ivi.vlan;
1332 vf_vlan.qos = ivi.qos;
79aab093
MS		 1333 vf_vlan_info.vlan = ivi.vlan;
1334 vf_vlan_info.qos = ivi.qos;
1335 vf_vlan_info.vlan_proto = ivi.vlan_proto;
b22b941b
HFS		 1336 vf_tx_rate.rate = ivi.max_tx_rate;
1337 vf_rate.min_tx_rate = ivi.min_tx_rate;
1338 vf_rate.max_tx_rate = ivi.max_tx_rate;
1339 vf_spoofchk.setting = ivi.spoofchk;
1340 vf_linkstate.link_state = ivi.linkstate;
1341 vf_rss_query_en.setting = ivi.rss_query_en;
1342 vf_trust.setting = ivi.trusted;
ae0be8de 1343 vf = nla_nest_start_noflag(skb, IFLA_VF_INFO);
79aab093 1344 if (!vf)
4a59cdfd 1345 return -EMSGSIZE;
b22b941b 1346 if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
75345f88 1347 nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) ||
b22b941b
HFS		 1348 nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1349 nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
1350 &vf_rate) ||
1351 nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
1352 &vf_tx_rate) ||
1353 nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1354 &vf_spoofchk) ||
1355 nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
1356 &vf_linkstate) ||
1357 nla_put(skb, IFLA_VF_RSS_QUERY_EN,
1358 sizeof(vf_rss_query_en),
1359 &vf_rss_query_en) ||
1360 nla_put(skb, IFLA_VF_TRUST,
1361 sizeof(vf_trust), &vf_trust))
79aab093 1362 goto nla_put_vf_failure;
30aad417 1363
30aad417
DG		 1364 if (dev->netdev_ops->ndo_get_vf_guid &&
1365 !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid,
1366 &port_guid)) {
1367 if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid),
1368 &node_guid) ||
1369 nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid),
1370 &port_guid))
1371 goto nla_put_vf_failure;
1372 }
ae0be8de 1373 vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST);
79aab093
MS		 1374 if (!vfvlanlist)
1375 goto nla_put_vf_failure;
1376 if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
1377 &vf_vlan_info)) {
1378 nla_nest_cancel(skb, vfvlanlist);
1379 goto nla_put_vf_failure;
1380 }
1381 nla_nest_end(skb, vfvlanlist);
fa0e21fa
EP		 1382 if (~ext_filter_mask & RTEXT_FILTER_SKIP_STATS) {
1383 memset(&vf_stats, 0, sizeof(vf_stats));
1384 if (dev->netdev_ops->ndo_get_vf_stats)
1385 dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
1386 &vf_stats);
1387 vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS);
1388 if (!vfstats)
1389 goto nla_put_vf_failure;
1390 if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
1391 vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
1392 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
1393 vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
1394 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
1395 vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
1396 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
1397 vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
1398 nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
1399 vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
1400 nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
1401 vf_stats.multicast, IFLA_VF_STATS_PAD) ||
1402 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED,
1403 vf_stats.rx_dropped, IFLA_VF_STATS_PAD) ||
1404 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED,
1405 vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) {
1406 nla_nest_cancel(skb, vfstats);
1407 goto nla_put_vf_failure;
1408 }
1409 nla_nest_end(skb, vfstats);
79aab093 1410 }
b22b941b
HFS		 1411 nla_nest_end(skb, vf);
1412 return 0;
79aab093
MS		 1413
1414nla_put_vf_failure:
1415 nla_nest_cancel(skb, vf);
79aab093 1416 return -EMSGSIZE;
b22b941b
HFS		 1417}
1418
250fc3df
FW		 1419static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb,
1420 struct net_device *dev,
1421 u32 ext_filter_mask)
1422{
1423 struct nlattr *vfinfo;
1424 int i, num_vfs;
1425
1426 if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0))
1427 return 0;
1428
1429 num_vfs = dev_num_vf(dev->dev.parent);
1430 if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs))
1431 return -EMSGSIZE;
1432
1433 if (!dev->netdev_ops->ndo_get_vf_config)
1434 return 0;
1435
ae0be8de 1436 vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST);
250fc3df
FW		 1437 if (!vfinfo)
1438 return -EMSGSIZE;
1439
1440 for (i = 0; i < num_vfs; i++) {
4a59cdfd
GP		 1441 if (rtnl_fill_vfinfo(skb, dev, i, ext_filter_mask)) {
1442 nla_nest_cancel(skb, vfinfo);
250fc3df 1443 return -EMSGSIZE;
4a59cdfd 1444 }
250fc3df
FW		 1445 }
1446
1447 nla_nest_end(skb, vfinfo);
1448 return 0;
1449}
1450
b22b941b
HFS		 1451static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
1452{
5f8e4474
KL		 1453 struct rtnl_link_ifmap map;
1454
1455 memset(&map, 0, sizeof(map));
1456 map.mem_start = dev->mem_start;
1457 map.mem_end = dev->mem_end;
1458 map.base_addr = dev->base_addr;
1459 map.irq = dev->irq;
1460 map.dma = dev->dma;
1461 map.port = dev->if_port;
1462
270cb4d0 1463 if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
b22b941b
HFS		 1464 return -EMSGSIZE;
1465
1466 return 0;
1467}
1468
a25717d2 1469static u32 rtnl_xdp_prog_skb(struct net_device *dev)
d67b9cd2 1470{
58038695 1471 const struct bpf_prog *generic_xdp_prog;
d67b9cd2
DB		 1472
1473 ASSERT_RTNL();
1474
58038695 1475 generic_xdp_prog = rtnl_dereference(dev->xdp_prog);
a25717d2
JK		 1476 if (!generic_xdp_prog)
1477 return 0;
1478 return generic_xdp_prog->aux->id;
1479}
d67b9cd2 1480
a25717d2
JK		 1481static u32 rtnl_xdp_prog_drv(struct net_device *dev)
1482{
7f0a8382 1483 return dev_xdp_prog_id(dev, XDP_MODE_DRV);
a25717d2 1484}
118b4aa2 1485
a25717d2
JK		 1486static u32 rtnl_xdp_prog_hw(struct net_device *dev)
1487{
7f0a8382 1488 return dev_xdp_prog_id(dev, XDP_MODE_HW);
a25717d2
JK		 1489}
1490
1491static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev,
1492 u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr,
1493 u32 (*get_prog_id)(struct net_device *dev))
1494{
1495 u32 curr_id;
1496 int err;
1497
1498 curr_id = get_prog_id(dev);
1499 if (!curr_id)
1500 return 0;
1501
1502 *prog_id = curr_id;
1503 err = nla_put_u32(skb, attr, curr_id);
1504 if (err)
1505 return err;
d67b9cd2 1506
a25717d2
JK		 1507 if (*mode != XDP_ATTACHED_NONE)
1508 *mode = XDP_ATTACHED_MULTI;
1509 else
1510 *mode = tgt_mode;
118b4aa2 1511
a25717d2 1512 return 0;
d67b9cd2
DB		 1513}
1514
d1fdd913
BB		 1515static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
1516{
d1fdd913 1517 struct nlattr *xdp;
58038695 1518 u32 prog_id;
d1fdd913 1519 int err;
4f91da26 1520 u8 mode;
d1fdd913 1521
ae0be8de 1522 xdp = nla_nest_start_noflag(skb, IFLA_XDP);
d1fdd913
BB		 1523 if (!xdp)
1524 return -EMSGSIZE;
d67b9cd2 1525
a25717d2
JK		 1526 prog_id = 0;
1527 mode = XDP_ATTACHED_NONE;
202aabe8
JK		 1528 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB,
1529 IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb);
1530 if (err)
a25717d2 1531 goto err_cancel;
202aabe8
JK		 1532 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV,
1533 IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv);
1534 if (err)
a25717d2 1535 goto err_cancel;
202aabe8
JK		 1536 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW,
1537 IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw);
1538 if (err)
a25717d2
JK		 1539 goto err_cancel;
1540
4f91da26 1541 err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode);
d1fdd913
BB		 1542 if (err)
1543 goto err_cancel;
1544
a25717d2 1545 if (prog_id && mode != XDP_ATTACHED_MULTI) {
58038695
MKL		 1546 err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
1547 if (err)
1548 goto err_cancel;
1549 }
1550
d1fdd913
BB		 1551 nla_nest_end(skb, xdp);
1552 return 0;
1553
1554err_cancel:
1555 nla_nest_cancel(skb, xdp);
1556 return err;
1557}
1558
3d3ea5af
VY		 1559static u32 rtnl_get_event(unsigned long event)
1560{
1561 u32 rtnl_event_type = IFLA_EVENT_NONE;
1562
1563 switch (event) {
1564 case NETDEV_REBOOT:
1565 rtnl_event_type = IFLA_EVENT_REBOOT;
1566 break;
1567 case NETDEV_FEAT_CHANGE:
1568 rtnl_event_type = IFLA_EVENT_FEATURES;
1569 break;
1570 case NETDEV_BONDING_FAILOVER:
1571 rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
1572 break;
1573 case NETDEV_NOTIFY_PEERS:
1574 rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
1575 break;
1576 case NETDEV_RESEND_IGMP:
1577 rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
1578 break;
1579 case NETDEV_CHANGEINFODATA:
1580 rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
1581 break;
1582 default:
1583 break;
1584 }
1585
1586 return rtnl_event_type;
1587}
1588
79110a04
FW		 1589static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev)
1590{
1591 const struct net_device *upper_dev;
1592 int ret = 0;
1593
1594 rcu_read_lock();
1595
1596 upper_dev = netdev_master_upper_dev_get_rcu(dev);
1597 if (upper_dev)
1598 ret = nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex);
1599
1600 rcu_read_unlock();
1601 return ret;
1602}
1603
feadc4b6
SD		 1604static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev,
1605 bool force)
79110a04
FW		 1606{
1607 int ifindex = dev_get_iflink(dev);
1608
feadc4b6
SD		 1609 if (force || dev->ifindex != ifindex)
1610 return nla_put_u32(skb, IFLA_LINK, ifindex);
79110a04 1611
feadc4b6 1612 return 0;
79110a04
FW		 1613}
1614
6c557001
FW		 1615static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb,
1616 struct net_device *dev)
1617{
1618 char buf[IFALIASZ];
1619 int ret;
1620
1621 ret = dev_get_alias(dev, buf, sizeof(buf));
1622 return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0;
1623}
1624
b1e66b9a 1625static int rtnl_fill_link_netnsid(struct sk_buff *skb,
79e1ad14 1626 const struct net_device *dev,
d4e4fdf9 1627 struct net *src_net, gfp_t gfp)
b1e66b9a 1628{
feadc4b6
SD		 1629 bool put_iflink = false;
1630
b1e66b9a
FW		 1631 if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) {
1632 struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
1633
1634 if (!net_eq(dev_net(dev), link_net)) {
d4e4fdf9 1635 int id = peernet2id_alloc(src_net, link_net, gfp);
b1e66b9a
FW		 1636
1637 if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
1638 return -EMSGSIZE;
feadc4b6
SD		 1639
1640 put_iflink = true;
b1e66b9a
FW		 1641 }
1642 }
1643
feadc4b6 1644 return nla_put_iflink(skb, dev, put_iflink);
b1e66b9a
FW		 1645}
1646
070cbf5b
FW		 1647static int rtnl_fill_link_af(struct sk_buff *skb,
1648 const struct net_device *dev,
1649 u32 ext_filter_mask)
1650{
1651 const struct rtnl_af_ops *af_ops;
1652 struct nlattr *af_spec;
1653
ae0be8de 1654 af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
070cbf5b
FW		 1655 if (!af_spec)
1656 return -EMSGSIZE;
1657
5fa85a09 1658 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
070cbf5b
FW		 1659 struct nlattr *af;
1660 int err;
1661
1662 if (!af_ops->fill_link_af)
1663 continue;
1664
ae0be8de 1665 af = nla_nest_start_noflag(skb, af_ops->family);
070cbf5b
FW		 1666 if (!af)
1667 return -EMSGSIZE;
1668
1669 err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
1670 /*
1671 * Caller may return ENODATA to indicate that there
1672 * was no data to be dumped. This is not an error, it
1673 * means we should trim the attribute header and
1674 * continue.
1675 */
1676 if (err == -ENODATA)
1677 nla_nest_cancel(skb, af);
1678 else if (err < 0)
1679 return -EMSGSIZE;
1680
1681 nla_nest_end(skb, af);
1682 }
1683
1684 nla_nest_end(skb, af_spec);
1685 return 0;
1686}
1687
88f4fb0c
JP		 1688static int rtnl_fill_alt_ifnames(struct sk_buff *skb,
1689 const struct net_device *dev)
1690{
1691 struct netdev_name_node *name_node;
1692 int count = 0;
1693
1694 list_for_each_entry(name_node, &dev->name_node->list, list) {
1695 if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name))
1696 return -EMSGSIZE;
1697 count++;
1698 }
1699 return count;
1700}
1701
1702static int rtnl_fill_prop_list(struct sk_buff *skb,
1703 const struct net_device *dev)
1704{
1705 struct nlattr *prop_list;
1706 int ret;
1707
1708 prop_list = nla_nest_start(skb, IFLA_PROP_LIST);
1709 if (!prop_list)
1710 return -EMSGSIZE;
1711
1712 ret = rtnl_fill_alt_ifnames(skb, dev);
1713 if (ret <= 0)
1714 goto nest_cancel;
1715
1716 nla_nest_end(skb, prop_list);
1717 return 0;
1718
1719nest_cancel:
1720 nla_nest_cancel(skb, prop_list);
1721 return ret;
1722}
1723
829eb208
RP		 1724static int rtnl_fill_proto_down(struct sk_buff *skb,
1725 const struct net_device *dev)
1726{
1727 struct nlattr *pr;
1728 u32 preason;
1729
1730 if (nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))
1731 goto nla_put_failure;
1732
1733 preason = dev->proto_down_reason;
1734 if (!preason)
1735 return 0;
1736
1737 pr = nla_nest_start(skb, IFLA_PROTO_DOWN_REASON);
1738 if (!pr)
1739 return -EMSGSIZE;
1740
1741 if (nla_put_u32(skb, IFLA_PROTO_DOWN_REASON_VALUE, preason)) {
1742 nla_nest_cancel(skb, pr);
1743 goto nla_put_failure;
1744 }
1745
1746 nla_nest_end(skb, pr);
1747 return 0;
1748
1749nla_put_failure:
1750 return -EMSGSIZE;
1751}
1752
dca56c30
JP		 1753static int rtnl_fill_devlink_port(struct sk_buff *skb,
1754 const struct net_device *dev)
1755{
1756 struct nlattr *devlink_port_nest;
1757 int ret;
1758
1759 devlink_port_nest = nla_nest_start(skb, IFLA_DEVLINK_PORT);
1760 if (!devlink_port_nest)
1761 return -EMSGSIZE;
1762
1763 if (dev->devlink_port) {
1764 ret = devlink_nl_port_handle_fill(skb, dev->devlink_port);
1765 if (ret < 0)
1766 goto nest_cancel;
1767 }
1768
1769 nla_nest_end(skb, devlink_port_nest);
1770 return 0;
1771
1772nest_cancel:
1773 nla_nest_cancel(skb, devlink_port_nest);
1774 return ret;
1775}
1776
79e1ad14
JB		 1777static int rtnl_fill_ifinfo(struct sk_buff *skb,
1778 struct net_device *dev, struct net *src_net,
575c3e2a 1779 int type, u32 pid, u32 seq, u32 change,
3d3ea5af 1780 unsigned int flags, u32 ext_filter_mask,
38e01b30 1781 u32 event, int *new_nsid, int new_ifindex,
d4e4fdf9 1782 int tgt_netnsid, gfp_t gfp)
b60c5115
TG		 1783{
1784 struct ifinfomsg *ifm;
1785 struct nlmsghdr *nlh;
5891cd5e 1786 struct Qdisc *qdisc;
1da177e4 1787
2907c35f 1788 ASSERT_RTNL();
b60c5115
TG		 1789 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
1790 if (nlh == NULL)
26932566 1791 return -EMSGSIZE;
1da177e4 1792
b60c5115
TG		 1793 ifm = nlmsg_data(nlh);
1794 ifm->ifi_family = AF_UNSPEC;
1795 ifm->__ifi_pad = 0;
1796 ifm->ifi_type = dev->type;
1797 ifm->ifi_index = dev->ifindex;
1798 ifm->ifi_flags = dev_get_flags(dev);
1799 ifm->ifi_change = change;
1800
7e4a8d5a 1801 if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
79e1ad14
JB		 1802 goto nla_put_failure;
1803
5891cd5e 1804 qdisc = rtnl_dereference(dev->qdisc);
a6574349
DM		 1805 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
1806 nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
1807 nla_put_u8(skb, IFLA_OPERSTATE,
1808 netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
1809 nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
1810 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
3e7a50ce
SH		 1811 nla_put_u32(skb, IFLA_MIN_MTU, dev->min_mtu) ||
1812 nla_put_u32(skb, IFLA_MAX_MTU, dev->max_mtu) ||
a6574349 1813 nla_put_u32(skb, IFLA_GROUP, dev->group) ||
edbc0bb3 1814 nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
7e6e1b57 1815 nla_put_u32(skb, IFLA_ALLMULTI, dev->allmulti) ||
76ff5cc9 1816 nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
c70ce028
ED		 1817 nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
1818 nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||
eac1b93c 1819 nla_put_u32(skb, IFLA_GRO_MAX_SIZE, dev->gro_max_size) ||
9eefedd5
XL		 1820 nla_put_u32(skb, IFLA_GSO_IPV4_MAX_SIZE, dev->gso_ipv4_max_size) ||
1821 nla_put_u32(skb, IFLA_GRO_IPV4_MAX_SIZE, dev->gro_ipv4_max_size) ||
89527be8
ED		 1822 nla_put_u32(skb, IFLA_TSO_MAX_SIZE, dev->tso_max_size) ||
1823 nla_put_u32(skb, IFLA_TSO_MAX_SEGS, dev->tso_max_segs) ||
1d69c2b3 1824#ifdef CONFIG_RPS
76ff5cc9 1825 nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1d69c2b3 1826#endif
79110a04 1827 put_master_ifindex(skb, dev) ||
9a57247f 1828 nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
5891cd5e
ED		 1829 (qdisc &&
1830 nla_put_string(skb, IFLA_QDISC, qdisc->ops->id)) ||
6c557001 1831 nla_put_ifalias(skb, dev) ||
2d3b479d 1832 nla_put_u32(skb, IFLA_CARRIER_CHANGES,
b2d3bcfa
DD		 1833 atomic_read(&dev->carrier_up_count) +
1834 atomic_read(&dev->carrier_down_count)) ||
b2d3bcfa
DD		 1835 nla_put_u32(skb, IFLA_CARRIER_UP_COUNT,
1836 atomic_read(&dev->carrier_up_count)) ||
1837 nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT,
1838 atomic_read(&dev->carrier_down_count)))
a6574349 1839 goto nla_put_failure;
0b815a1a 1840
829eb208
RP		 1841 if (rtnl_fill_proto_down(skb, dev))
1842 goto nla_put_failure;
1843
3d3ea5af
VY		 1844 if (event != IFLA_EVENT_NONE) {
1845 if (nla_put_u32(skb, IFLA_EVENT, event))
1846 goto nla_put_failure;
1847 }
1848
b22b941b
HFS		 1849 if (rtnl_fill_link_ifmap(skb, dev))
1850 goto nla_put_failure;
1da177e4
LT		 1851
1852 if (dev->addr_len) {
a6574349
DM		 1853 if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
1854 nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
1855 goto nla_put_failure;
1da177e4
LT		 1856 }
1857
66cae9ed
JP		 1858 if (rtnl_phys_port_id_fill(skb, dev))
1859 goto nla_put_failure;
1860
db24a904
DA		 1861 if (rtnl_phys_port_name_fill(skb, dev))
1862 goto nla_put_failure;
1863
82f28412
JP		 1864 if (rtnl_phys_switch_id_fill(skb, dev))
1865 goto nla_put_failure;
1866
b22b941b 1867 if (rtnl_fill_stats(skb, dev))
10708f37 1868 goto nla_put_failure;
10708f37 1869
250fc3df 1870 if (rtnl_fill_vf(skb, dev, ext_filter_mask))
a6574349 1871 goto nla_put_failure;
57b61080 1872
c53864fd 1873 if (rtnl_port_fill(skb, dev, ext_filter_mask))
57b61080
SF		 1874 goto nla_put_failure;
1875
d1fdd913
BB		 1876 if (rtnl_xdp_fill(skb, dev))
1877 goto nla_put_failure;
1878
ba7d49b1 1879 if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
38f7b870
PM		 1880 if (rtnl_link_fill(skb, dev) < 0)
1881 goto nla_put_failure;
1882 }
1883
d4e4fdf9 1884 if (rtnl_fill_link_netnsid(skb, dev, src_net, gfp))
b1e66b9a 1885 goto nla_put_failure;
d37512a2 1886
6621dd29
ND		 1887 if (new_nsid &&
1888 nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
1889 goto nla_put_failure;
38e01b30
ND		 1890 if (new_ifindex &&
1891 nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0)
1892 goto nla_put_failure;
1893
f74877a5
MK		 1894 if (memchr_inv(dev->perm_addr, '\0', dev->addr_len) &&
1895 nla_put(skb, IFLA_PERM_ADDRESS, dev->addr_len, dev->perm_addr))
1896 goto nla_put_failure;
6621dd29 1897
5fa85a09 1898 rcu_read_lock();
070cbf5b 1899 if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
5fa85a09
FW		 1900 goto nla_put_failure_rcu;
1901 rcu_read_unlock();
f8ff182c 1902
88f4fb0c
JP		 1903 if (rtnl_fill_prop_list(skb, dev))
1904 goto nla_put_failure;
1905
00e77ed8
JB		 1906 if (dev->dev.parent &&
1907 nla_put_string(skb, IFLA_PARENT_DEV_NAME,
1908 dev_name(dev->dev.parent)))
1909 goto nla_put_failure;
1910
1911 if (dev->dev.parent && dev->dev.parent->bus &&
1912 nla_put_string(skb, IFLA_PARENT_DEV_BUS_NAME,
1913 dev->dev.parent->bus->name))
1914 goto nla_put_failure;
1915
dca56c30
JP		 1916 if (rtnl_fill_devlink_port(skb, dev))
1917 goto nla_put_failure;
1918
053c095a
JB		 1919 nlmsg_end(skb, nlh);
1920 return 0;
b60c5115 1921
5fa85a09
FW		 1922nla_put_failure_rcu:
1923 rcu_read_unlock();
b60c5115 1924nla_put_failure:
26932566
PM		 1925 nlmsg_cancel(skb, nlh);
1926 return -EMSGSIZE;
1da177e4
LT		 1927}
1928
f7b12606 1929static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
5176f91e 1930 [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 },
38f7b870
PM		 1931 [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1932 [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
5176f91e 1933 [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) },
da5e0494 1934 [IFLA_MTU] = { .type = NLA_U32 },
76e87306 1935 [IFLA_LINK] = { .type = NLA_U32 },
fbaec0ea 1936 [IFLA_MASTER] = { .type = NLA_U32 },
9a57247f 1937 [IFLA_CARRIER] = { .type = NLA_U8 },
da5e0494
TG		 1938 [IFLA_TXQLEN] = { .type = NLA_U32 },
1939 [IFLA_WEIGHT] = { .type = NLA_U32 },
1940 [IFLA_OPERSTATE] = { .type = NLA_U8 },
1941 [IFLA_LINKMODE] = { .type = NLA_U8 },
76e87306 1942 [IFLA_LINKINFO] = { .type = NLA_NESTED },
d8a5ec67 1943 [IFLA_NET_NS_PID] = { .type = NLA_U32 },
f0630529 1944 [IFLA_NET_NS_FD] = { .type = NLA_U32 },
2459b4c6
ND		 1945 /* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to
1946 * allow 0-length string (needed to remove an alias).
1947 */
1948 [IFLA_IFALIAS] = { .type = NLA_BINARY, .len = IFALIASZ - 1 },
c02db8c6 1949 [IFLA_VFINFO_LIST] = {. type = NLA_NESTED },
57b61080
SF		 1950 [IFLA_VF_PORTS] = { .type = NLA_NESTED },
1951 [IFLA_PORT_SELF] = { .type = NLA_NESTED },
f8ff182c 1952 [IFLA_AF_SPEC] = { .type = NLA_NESTED },
115c9b81 1953 [IFLA_EXT_MASK] = { .type = NLA_U32 },
edbc0bb3 1954 [IFLA_PROMISCUITY] = { .type = NLA_U32 },
76ff5cc9
JP		 1955 [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 },
1956 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
46e6b992
SH		 1957 [IFLA_GSO_MAX_SEGS] = { .type = NLA_U32 },
1958 [IFLA_GSO_MAX_SIZE] = { .type = NLA_U32 },
02637fce 1959 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
2d3b479d 1960 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */
82f28412 1961 [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
317f4810 1962 [IFLA_LINK_NETNSID] = { .type = NLA_S32 },
88d6378b 1963 [IFLA_PROTO_DOWN] = { .type = NLA_U8 },
d1fdd913 1964 [IFLA_XDP] = { .type = NLA_NESTED },
3d3ea5af 1965 [IFLA_EVENT] = { .type = NLA_U32 },
db833d40 1966 [IFLA_GROUP] = { .type = NLA_U32 },
7e4a8d5a 1967 [IFLA_TARGET_NETNSID] = { .type = NLA_S32 },
b2d3bcfa
DD		 1968 [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 },
1969 [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
3e7a50ce
SH		 1970 [IFLA_MIN_MTU] = { .type = NLA_U32 },
1971 [IFLA_MAX_MTU] = { .type = NLA_U32 },
36fbf1e5
JP		 1972 [IFLA_PROP_LIST] = { .type = NLA_NESTED },
1973 [IFLA_ALT_IFNAME] = { .type = NLA_STRING,
1974 .len = ALTIFNAMSIZ - 1 },
f74877a5 1975 [IFLA_PERM_ADDRESS] = { .type = NLA_REJECT },
829eb208 1976 [IFLA_PROTO_DOWN_REASON] = { .type = NLA_NESTED },
7e4a5131 1977 [IFLA_NEW_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
88b71053 1978 [IFLA_PARENT_DEV_NAME] = { .type = NLA_NUL_STRING },
eac1b93c 1979 [IFLA_GRO_MAX_SIZE] = { .type = NLA_U32 },
89527be8
ED		 1980 [IFLA_TSO_MAX_SIZE] = { .type = NLA_REJECT },
1981 [IFLA_TSO_MAX_SEGS] = { .type = NLA_REJECT },
7e6e1b57 1982 [IFLA_ALLMULTI] = { .type = NLA_REJECT },
9eefedd5
XL		 1983 [IFLA_GSO_IPV4_MAX_SIZE] = { .type = NLA_U32 },
1984 [IFLA_GRO_IPV4_MAX_SIZE] = { .type = NLA_U32 },
da5e0494
TG		 1985};
1986
38f7b870
PM		 1987static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1988 [IFLA_INFO_KIND] = { .type = NLA_STRING },
1989 [IFLA_INFO_DATA] = { .type = NLA_NESTED },
ba7d49b1
JP		 1990 [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING },
1991 [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED },
38f7b870
PM		 1992};
1993
c02db8c6 1994static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
364d5716 1995 [IFLA_VF_MAC] = { .len = sizeof(struct ifla_vf_mac) },
75345f88 1996 [IFLA_VF_BROADCAST] = { .type = NLA_REJECT },
364d5716 1997 [IFLA_VF_VLAN] = { .len = sizeof(struct ifla_vf_vlan) },
79aab093 1998 [IFLA_VF_VLAN_LIST] = { .type = NLA_NESTED },
364d5716
DB		 1999 [IFLA_VF_TX_RATE] = { .len = sizeof(struct ifla_vf_tx_rate) },
2000 [IFLA_VF_SPOOFCHK] = { .len = sizeof(struct ifla_vf_spoofchk) },
2001 [IFLA_VF_RATE] = { .len = sizeof(struct ifla_vf_rate) },
2002 [IFLA_VF_LINK_STATE] = { .len = sizeof(struct ifla_vf_link_state) },
01a3d796 2003 [IFLA_VF_RSS_QUERY_EN] = { .len = sizeof(struct ifla_vf_rss_query_en) },
3b766cd8 2004 [IFLA_VF_STATS] = { .type = NLA_NESTED },
dd461d6a 2005 [IFLA_VF_TRUST] = { .len = sizeof(struct ifla_vf_trust) },
cc8e27cc
EC		 2006 [IFLA_VF_IB_NODE_GUID] = { .len = sizeof(struct ifla_vf_guid) },
2007 [IFLA_VF_IB_PORT_GUID] = { .len = sizeof(struct ifla_vf_guid) },
3b766cd8
EBE		 2008};
2009
57b61080
SF		 2010static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
2011 [IFLA_PORT_VF] = { .type = NLA_U32 },
2012 [IFLA_PORT_PROFILE] = { .type = NLA_STRING,
2013 .len = PORT_PROFILE_MAX },
57b61080
SF		 2014 [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
2015 .len = PORT_UUID_MAX },
2016 [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING,
2017 .len = PORT_UUID_MAX },
2018 [IFLA_PORT_REQUEST] = { .type = NLA_U8, },
2019 [IFLA_PORT_RESPONSE] = { .type = NLA_U16, },
025331df
DB		 2020
2021 /* Unused, but we need to keep it here since user space could
2022 * fill it. It's also broken with regard to NLA_BINARY use in
2023 * combination with structs.
2024 */
2025 [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY,
2026 .len = sizeof(struct ifla_port_vsi) },
57b61080
SF		 2027};
2028
d1fdd913 2029static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
92234c8f 2030 [IFLA_XDP_UNSPEC] = { .strict_start_type = IFLA_XDP_EXPECTED_FD },
d1fdd913 2031 [IFLA_XDP_FD] = { .type = NLA_S32 },
92234c8f 2032 [IFLA_XDP_EXPECTED_FD] = { .type = NLA_S32 },
d1fdd913 2033 [IFLA_XDP_ATTACHED] = { .type = NLA_U8 },
85de8576 2034 [IFLA_XDP_FLAGS] = { .type = NLA_U32 },
58038695 2035 [IFLA_XDP_PROG_ID] = { .type = NLA_U32 },
d1fdd913
BB		 2036};
2037
dc599f76
DA		 2038static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
2039{
2040 const struct rtnl_link_ops *ops = NULL;
2041 struct nlattr *linfo[IFLA_INFO_MAX + 1];
2042
8cb08174 2043 if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0)
dc599f76
DA		 2044 return NULL;
2045
2046 if (linfo[IFLA_INFO_KIND]) {
2047 char kind[MODULE_NAME_LEN];
2048
872f6903 2049 nla_strscpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
dc599f76
DA		 2050 ops = rtnl_link_ops_get(kind);
2051 }
2052
2053 return ops;
2054}
2055
2056static bool link_master_filtered(struct net_device *dev, int master_idx)
2057{
2058 struct net_device *master;
2059
2060 if (!master_idx)
2061 return false;
2062
2063 master = netdev_master_upper_dev_get(dev);
d3432bf1
LS		 2064
2065 /* 0 is already used to denote IFLA_MASTER wasn't passed, therefore need
2066 * another invalid value for ifindex to denote "no master".
2067 */
2068 if (master_idx == -1)
2069 return !!master;
2070
dc599f76
DA		 2071 if (!master || master->ifindex != master_idx)
2072 return true;
2073
2074 return false;
2075}
2076
2077static bool link_kind_filtered(const struct net_device *dev,
2078 const struct rtnl_link_ops *kind_ops)
2079{
2080 if (kind_ops && dev->rtnl_link_ops != kind_ops)
2081 return true;
2082
2083 return false;
2084}
2085
2086static bool link_dump_filtered(struct net_device *dev,
2087 int master_idx,
2088 const struct rtnl_link_ops *kind_ops)
2089{
2090 if (link_master_filtered(dev, master_idx) ||
2091 link_kind_filtered(dev, kind_ops))
2092 return true;
2093
2094 return false;
2095}
2096
c383edc4
CB		 2097/**
2098 * rtnl_get_net_ns_capable - Get netns if sufficiently privileged.
2099 * @sk: netlink socket
2100 * @netnsid: network namespace identifier
2101 *
2102 * Returns the network namespace identified by netnsid on success or an error
2103 * pointer on failure.
2104 */
2105struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
79e1ad14
JB		 2106{
2107 struct net *net;
2108
f428fe4a 2109 net = get_net_ns_by_id(sock_net(sk), netnsid);
79e1ad14
JB		 2110 if (!net)
2111 return ERR_PTR(-EINVAL);
2112
2113 /* For now, the caller is required to have CAP_NET_ADMIN in
2114 * the user namespace owning the target net ns.
2115 */
f428fe4a 2116 if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
79e1ad14
JB		 2117 put_net(net);
2118 return ERR_PTR(-EACCES);
2119 }
2120 return net;
2121}
c383edc4 2122EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
79e1ad14 2123
905cf0ab
DA		 2124static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh,
2125 bool strict_check, struct nlattr **tb,
2126 struct netlink_ext_ack *extack)
2127{
2128 int hdrlen;
2129
2130 if (strict_check) {
2131 struct ifinfomsg *ifm;
2132
2133 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
2134 NL_SET_ERR_MSG(extack, "Invalid header for link dump");
2135 return -EINVAL;
2136 }
2137
2138 ifm = nlmsg_data(nlh);
2139 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
2140 ifm->ifi_change) {
2141 NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request");
2142 return -EINVAL;
2143 }
2144 if (ifm->ifi_index) {
2145 NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps");
2146 return -EINVAL;
2147 }
2148
8cb08174
JB		 2149 return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb,
2150 IFLA_MAX, ifla_policy,
2151 extack);
905cf0ab
DA		 2152 }
2153
2154 /* A hack to preserve kernel<->userspace interface.
2155 * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
2156 * However, before Linux v3.9 the code here assumed rtgenmsg and that's
2157 * what iproute2 < v3.9.0 used.
2158 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
2159 * attribute, its netlink message is shorter than struct ifinfomsg.
2160 */
2161 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
2162 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
2163
8cb08174
JB		 2164 return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy,
2165 extack);
905cf0ab
DA		 2166}
2167
f7b12606
JP		 2168static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
2169{
905cf0ab
DA		 2170 struct netlink_ext_ack *extack = cb->extack;
2171 const struct nlmsghdr *nlh = cb->nlh;
f7b12606 2172 struct net *net = sock_net(skb->sk);
79e1ad14 2173 struct net *tgt_net = net;
f7b12606
JP		 2174 int h, s_h;
2175 int idx = 0, s_idx;
2176 struct net_device *dev;
2177 struct hlist_head *head;
2178 struct nlattr *tb[IFLA_MAX+1];
2179 u32 ext_filter_mask = 0;
dc599f76
DA		 2180 const struct rtnl_link_ops *kind_ops = NULL;
2181 unsigned int flags = NLM_F_MULTI;
2182 int master_idx = 0;
79e1ad14 2183 int netnsid = -1;
905cf0ab 2184 int err, i;
f7b12606
JP		 2185
2186 s_h = cb->args[0];
2187 s_idx = cb->args[1];
2188
905cf0ab
DA		 2189 err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
2190 if (err < 0) {
2191 if (cb->strict_check)
2192 return err;
2193
2194 goto walk_entries;
2195 }
2196
2197 for (i = 0; i <= IFLA_MAX; ++i) {
2198 if (!tb[i])
2199 continue;
e5eca6d4 2200
905cf0ab
DA		 2201 /* new attributes should only be added with strict checking */
2202 switch (i) {
2203 case IFLA_TARGET_NETNSID:
2204 netnsid = nla_get_s32(tb[i]);
c383edc4 2205 tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
905cf0ab
DA		 2206 if (IS_ERR(tgt_net)) {
2207 NL_SET_ERR_MSG(extack, "Invalid target network namespace id");
893626d6 2208 return PTR_ERR(tgt_net);
905cf0ab
DA		 2209 }
2210 break;
2211 case IFLA_EXT_MASK:
2212 ext_filter_mask = nla_get_u32(tb[i]);
2213 break;
2214 case IFLA_MASTER:
2215 master_idx = nla_get_u32(tb[i]);
2216 break;
2217 case IFLA_LINKINFO:
2218 kind_ops = linkinfo_to_kind_ops(tb[i]);
2219 break;
2220 default:
2221 if (cb->strict_check) {
2222 NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request");
2223 return -EINVAL;
2224 }
79e1ad14 2225 }
f7b12606
JP		 2226 }
2227
905cf0ab
DA		 2228 if (master_idx || kind_ops)
2229 flags |= NLM_F_DUMP_FILTERED;
2230
2231walk_entries:
f7b12606
JP		 2232 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2233 idx = 0;
79e1ad14 2234 head = &tgt_net->dev_index_head[h];
cac5e65e 2235 hlist_for_each_entry(dev, head, index_hlist) {
dc599f76 2236 if (link_dump_filtered(dev, master_idx, kind_ops))
3f0ae05d 2237 goto cont;
f7b12606
JP		 2238 if (idx < s_idx)
2239 goto cont;
79e1ad14
JB		 2240 err = rtnl_fill_ifinfo(skb, dev, net,
2241 RTM_NEWLINK,
973462bb 2242 NETLINK_CB(cb->skb).portid,
905cf0ab 2243 nlh->nlmsg_seq, 0, flags,
38e01b30 2244 ext_filter_mask, 0, NULL, 0,
d4e4fdf9 2245 netnsid, GFP_KERNEL);
973462bb 2246
f6c5775f
DA		 2247 if (err < 0) {
2248 if (likely(skb->len))
2249 goto out;
2250
2251 goto out_err;
2252 }
f7b12606
JP		 2253cont:
2254 idx++;
2255 }
2256 }
2257out:
f6c5775f
DA		 2258 err = skb->len;
2259out_err:
f7b12606
JP		 2260 cb->args[1] = idx;
2261 cb->args[0] = h;
a9ecb0cb 2262 cb->seq = tgt_net->dev_base_seq;
d0225784 2263 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
79e1ad14
JB		 2264 if (netnsid >= 0)
2265 put_net(tgt_net);
f7b12606 2266
f6c5775f 2267 return err;
f7b12606
JP		 2268}
2269
f534f658
JK		 2270int rtnl_nla_parse_ifinfomsg(struct nlattr **tb, const struct nlattr *nla_peer,
2271 struct netlink_ext_ack *exterr)
f7b12606 2272{
f534f658
JK		 2273 const struct ifinfomsg *ifmp;
2274 const struct nlattr *attrs;
2275 size_t len;
2276
2277 ifmp = nla_data(nla_peer);
2278 attrs = nla_data(nla_peer) + sizeof(struct ifinfomsg);
2279 len = nla_len(nla_peer) - sizeof(struct ifinfomsg);
2280
2281 if (ifmp->ifi_index < 0) {
2282 NL_SET_ERR_MSG_ATTR(exterr, nla_peer,
2283 "ifindex can't be negative");
2284 return -EINVAL;
2285 }
2286
2287 return nla_parse_deprecated(tb, IFLA_MAX, attrs, len, ifla_policy,
8cb08174 2288 exterr);
f7b12606 2289}
f534f658 2290EXPORT_SYMBOL(rtnl_nla_parse_ifinfomsg);
f7b12606 2291
81adee47
EB		 2292struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
2293{
2294 struct net *net;
2295 /* Examine the link attributes and figure out which
2296 * network namespace we are talking about.
2297 */
2298 if (tb[IFLA_NET_NS_PID])
2299 net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
f0630529
EB		 2300 else if (tb[IFLA_NET_NS_FD])
2301 net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
81adee47
EB		 2302 else
2303 net = get_net(src_net);
2304 return net;
2305}
2306EXPORT_SYMBOL(rtnl_link_get_net);
2307
7c4f63ba
CB		 2308/* Figure out which network namespace we are talking about by
2309 * examining the link attributes in the following order:
2310 *
2311 * 1. IFLA_NET_NS_PID
2312 * 2. IFLA_NET_NS_FD
7e4a8d5a 2313 * 3. IFLA_TARGET_NETNSID
7c4f63ba
CB		 2314 */
2315static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
2316 struct nlattr *tb[])
2317{
2318 struct net *net;
2319
2320 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
2321 return rtnl_link_get_net(src_net, tb);
2322
7e4a8d5a 2323 if (!tb[IFLA_TARGET_NETNSID])
7c4f63ba
CB		 2324 return get_net(src_net);
2325
7e4a8d5a 2326 net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
7c4f63ba
CB		 2327 if (!net)
2328 return ERR_PTR(-EINVAL);
2329
2330 return net;
2331}
2332
2333static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2334 struct net *src_net,
2335 struct nlattr *tb[], int cap)
2336{
2337 struct net *net;
2338
2339 net = rtnl_link_get_net_by_nlattr(src_net, tb);
2340 if (IS_ERR(net))
2341 return net;
2342
2343 if (!netlink_ns_capable(skb, net->user_ns, cap)) {
2344 put_net(net);
2345 return ERR_PTR(-EPERM);
2346 }
2347
2348 return net;
2349}
2350
4ff66cae
CB		 2351/* Verify that rtnetlink requests do not pass additional properties
2352 * potentially referring to different network namespaces.
2353 */
2354static int rtnl_ensure_unique_netns(struct nlattr *tb[],
2355 struct netlink_ext_ack *extack,
2356 bool netns_id_only)
2357{
2358
2359 if (netns_id_only) {
2360 if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2361 return 0;
2362
2363 NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2364 return -EOPNOTSUPP;
2365 }
2366
7e4a8d5a 2367 if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
4ff66cae
CB		 2368 goto invalid_attr;
2369
7e4a8d5a 2370 if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
4ff66cae
CB		 2371 goto invalid_attr;
2372
7e4a8d5a 2373 if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
4ff66cae
CB		 2374 goto invalid_attr;
2375
2376 return 0;
2377
2378invalid_attr:
2379 NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2380 return -EINVAL;
2381}
2382
a14857c2
BC		 2383static int rtnl_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
2384 int max_tx_rate)
2385{
2386 const struct net_device_ops *ops = dev->netdev_ops;
2387
2388 if (!ops->ndo_set_vf_rate)
2389 return -EOPNOTSUPP;
2390 if (max_tx_rate && max_tx_rate < min_tx_rate)
2391 return -EINVAL;
2392
2393 return ops->ndo_set_vf_rate(dev, vf, min_tx_rate, max_tx_rate);
2394}
2395
8679c31e
RY		 2396static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[],
2397 struct netlink_ext_ack *extack)
1840bb13 2398{
89da780a
XL		 2399 if (tb[IFLA_ADDRESS] &&
2400 nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
2401 return -EINVAL;
1840bb13 2402
89da780a
XL		 2403 if (tb[IFLA_BROADCAST] &&
2404 nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
2405 return -EINVAL;
fef5b228 2406
89da780a
XL		 2407 if (tb[IFLA_GSO_MAX_SIZE] &&
2408 nla_get_u32(tb[IFLA_GSO_MAX_SIZE]) > dev->tso_max_size) {
2409 NL_SET_ERR_MSG(extack, "too big gso_max_size");
2410 return -EINVAL;
2411 }
fef5b228 2412
89da780a
XL		 2413 if (tb[IFLA_GSO_MAX_SEGS] &&
2414 (nla_get_u32(tb[IFLA_GSO_MAX_SEGS]) > GSO_MAX_SEGS ||
2415 nla_get_u32(tb[IFLA_GSO_MAX_SEGS]) > dev->tso_max_segs)) {
2416 NL_SET_ERR_MSG(extack, "too big gso_max_segs");
2417 return -EINVAL;
2418 }
fef5b228 2419
89da780a
XL		 2420 if (tb[IFLA_GRO_MAX_SIZE] &&
2421 nla_get_u32(tb[IFLA_GRO_MAX_SIZE]) > GRO_MAX_SIZE) {
2422 NL_SET_ERR_MSG(extack, "too big gro_max_size");
2423 return -EINVAL;
2424 }
65d6914e 2425
89da780a
XL		 2426 if (tb[IFLA_GSO_IPV4_MAX_SIZE] &&
2427 nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]) > dev->tso_max_size) {
2428 NL_SET_ERR_MSG(extack, "too big gso_ipv4_max_size");
2429 return -EINVAL;
2430 }
65d6914e 2431
89da780a
XL		 2432 if (tb[IFLA_GRO_IPV4_MAX_SIZE] &&
2433 nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]) > GRO_MAX_SIZE) {
2434 NL_SET_ERR_MSG(extack, "too big gro_ipv4_max_size");
2435 return -EINVAL;
1840bb13
TG		 2436 }
2437
cf7afbfe
TG		 2438 if (tb[IFLA_AF_SPEC]) {
2439 struct nlattr *af;
2440 int rem, err;
2441
2442 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2443 const struct rtnl_af_ops *af_ops;
2444
5fa85a09 2445 af_ops = rtnl_af_lookup(nla_type(af));
a100243d 2446 if (!af_ops)
cf7afbfe
TG		 2447 return -EAFNOSUPPORT;
2448
a100243d 2449 if (!af_ops->set_link_af)
cf7afbfe
TG		 2450 return -EOPNOTSUPP;
2451
2452 if (af_ops->validate_link_af) {
8679c31e 2453 err = af_ops->validate_link_af(dev, af, extack);
a100243d 2454 if (err < 0)
cf7afbfe
TG		 2455 return err;
2456 }
2457 }
2458 }
2459
1840bb13
TG		 2460 return 0;
2461}
2462
cc8e27cc
EC		 2463static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
2464 int guid_type)
2465{
2466 const struct net_device_ops *ops = dev->netdev_ops;
2467
2468 return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
2469}
2470
2471static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
2472{
2473 if (dev->type != ARPHRD_INFINIBAND)
2474 return -EOPNOTSUPP;
2475
2476 return handle_infiniband_guid(dev, ivt, guid_type);
2477}
2478
4f7d2cdf 2479static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
c02db8c6 2480{
c02db8c6 2481 const struct net_device_ops *ops = dev->netdev_ops;
4f7d2cdf 2482 int err = -EINVAL;
c02db8c6 2483
4f7d2cdf
DB		 2484 if (tb[IFLA_VF_MAC]) {
2485 struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
01a3d796 2486
ff08ddba
DC		 2487 if (ivm->vf >= INT_MAX)
2488 return -EINVAL;
4f7d2cdf
DB		 2489 err = -EOPNOTSUPP;
2490 if (ops->ndo_set_vf_mac)
2491 err = ops->ndo_set_vf_mac(dev, ivm->vf,
2492 ivm->mac);
2493 if (err < 0)
2494 return err;
2495 }
2496
2497 if (tb[IFLA_VF_VLAN]) {
2498 struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
2499
ff08ddba
DC		 2500 if (ivv->vf >= INT_MAX)
2501 return -EINVAL;
4f7d2cdf
DB		 2502 err = -EOPNOTSUPP;
2503 if (ops->ndo_set_vf_vlan)
2504 err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
79aab093
MS		 2505 ivv->qos,
2506 htons(ETH_P_8021Q));
2507 if (err < 0)
2508 return err;
2509 }
2510
2511 if (tb[IFLA_VF_VLAN_LIST]) {
2512 struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
2513 struct nlattr *attr;
2514 int rem, len = 0;
2515
2516 err = -EOPNOTSUPP;
2517 if (!ops->ndo_set_vf_vlan)
2518 return err;
2519
2520 nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
2521 if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
2522 nla_len(attr) < NLA_HDRLEN) {
2523 return -EINVAL;
2524 }
2525 if (len >= MAX_VLAN_LIST_LEN)
2526 return -EOPNOTSUPP;
2527 ivvl[len] = nla_data(attr);
2528
2529 len++;
2530 }
fa34cd94
AB		 2531 if (len == 0)
2532 return -EINVAL;
2533
ff08ddba
DC		 2534 if (ivvl[0]->vf >= INT_MAX)
2535 return -EINVAL;
79aab093
MS		 2536 err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
2537 ivvl[0]->qos, ivvl[0]->vlan_proto);
4f7d2cdf
DB		 2538 if (err < 0)
2539 return err;
c02db8c6 2540 }
4f7d2cdf
DB		 2541
2542 if (tb[IFLA_VF_TX_RATE]) {
2543 struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
2544 struct ifla_vf_info ivf;
2545
ff08ddba
DC		 2546 if (ivt->vf >= INT_MAX)
2547 return -EINVAL;
4f7d2cdf
DB		 2548 err = -EOPNOTSUPP;
2549 if (ops->ndo_get_vf_config)
2550 err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
2551 if (err < 0)
2552 return err;
2553
a14857c2
BC		 2554 err = rtnl_set_vf_rate(dev, ivt->vf,
2555 ivf.min_tx_rate, ivt->rate);
4f7d2cdf
DB		 2556 if (err < 0)
2557 return err;
2558 }
2559
2560 if (tb[IFLA_VF_RATE]) {
2561 struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
2562
ff08ddba
DC		 2563 if (ivt->vf >= INT_MAX)
2564 return -EINVAL;
a14857c2
BC		 2565
2566 err = rtnl_set_vf_rate(dev, ivt->vf,
2567 ivt->min_tx_rate, ivt->max_tx_rate);
4f7d2cdf
DB		 2568 if (err < 0)
2569 return err;
2570 }
2571
2572 if (tb[IFLA_VF_SPOOFCHK]) {
2573 struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
2574
ff08ddba
DC		 2575 if (ivs->vf >= INT_MAX)
2576 return -EINVAL;
4f7d2cdf
DB		 2577 err = -EOPNOTSUPP;
2578 if (ops->ndo_set_vf_spoofchk)
2579 err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
2580 ivs->setting);
2581 if (err < 0)
2582 return err;
2583 }
2584
2585 if (tb[IFLA_VF_LINK_STATE]) {
2586 struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
2587
ff08ddba
DC		 2588 if (ivl->vf >= INT_MAX)
2589 return -EINVAL;
4f7d2cdf
DB		 2590 err = -EOPNOTSUPP;
2591 if (ops->ndo_set_vf_link_state)
2592 err = ops->ndo_set_vf_link_state(dev, ivl->vf,
2593 ivl->link_state);
2594 if (err < 0)
2595 return err;
2596 }
2597
2598 if (tb[IFLA_VF_RSS_QUERY_EN]) {
2599 struct ifla_vf_rss_query_en *ivrssq_en;
2600
2601 err = -EOPNOTSUPP;
2602 ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
ff08ddba
DC		 2603 if (ivrssq_en->vf >= INT_MAX)
2604 return -EINVAL;
4f7d2cdf
DB		 2605 if (ops->ndo_set_vf_rss_query_en)
2606 err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
2607 ivrssq_en->setting);
2608 if (err < 0)
2609 return err;
2610 }
2611
dd461d6a
HS		 2612 if (tb[IFLA_VF_TRUST]) {
2613 struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
2614
ff08ddba
DC		 2615 if (ivt->vf >= INT_MAX)
2616 return -EINVAL;
dd461d6a
HS		 2617 err = -EOPNOTSUPP;
2618 if (ops->ndo_set_vf_trust)
2619 err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
2620 if (err < 0)
2621 return err;
2622 }
2623
cc8e27cc
EC		 2624 if (tb[IFLA_VF_IB_NODE_GUID]) {
2625 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
2626
ff08ddba
DC		 2627 if (ivt->vf >= INT_MAX)
2628 return -EINVAL;
cc8e27cc
EC		 2629 if (!ops->ndo_set_vf_guid)
2630 return -EOPNOTSUPP;
cc8e27cc
EC		 2631 return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
2632 }
2633
2634 if (tb[IFLA_VF_IB_PORT_GUID]) {
2635 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
2636
ff08ddba
DC		 2637 if (ivt->vf >= INT_MAX)
2638 return -EINVAL;
cc8e27cc
EC		 2639 if (!ops->ndo_set_vf_guid)
2640 return -EOPNOTSUPP;
2641
2642 return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
2643 }
2644
c02db8c6
CW		 2645 return err;
2646}
2647
33eaf2a6
DA		 2648static int do_set_master(struct net_device *dev, int ifindex,
2649 struct netlink_ext_ack *extack)
fbaec0ea 2650{
898e5061 2651 struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
fbaec0ea
JP		 2652 const struct net_device_ops *ops;
2653 int err;
2654
898e5061
JP		 2655 if (upper_dev) {
2656 if (upper_dev->ifindex == ifindex)
fbaec0ea 2657 return 0;
898e5061 2658 ops = upper_dev->netdev_ops;
fbaec0ea 2659 if (ops->ndo_del_slave) {
898e5061 2660 err = ops->ndo_del_slave(upper_dev, dev);
fbaec0ea
JP		 2661 if (err)
2662 return err;
2663 } else {
2664 return -EOPNOTSUPP;
2665 }
2666 }
2667
2668 if (ifindex) {
898e5061
JP		 2669 upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
2670 if (!upper_dev)
fbaec0ea 2671 return -EINVAL;
898e5061 2672 ops = upper_dev->netdev_ops;
fbaec0ea 2673 if (ops->ndo_add_slave) {
33eaf2a6 2674 err = ops->ndo_add_slave(upper_dev, dev, extack);
fbaec0ea
JP		 2675 if (err)
2676 return err;
2677 } else {
2678 return -EOPNOTSUPP;
2679 }
2680 }
2681 return 0;
2682}
2683
829eb208
RP		 2684static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = {
2685 [IFLA_PROTO_DOWN_REASON_MASK] = { .type = NLA_U32 },
2686 [IFLA_PROTO_DOWN_REASON_VALUE] = { .type = NLA_U32 },
2687};
2688
2689static int do_set_proto_down(struct net_device *dev,
2690 struct nlattr *nl_proto_down,
2691 struct nlattr *nl_proto_down_reason,
2692 struct netlink_ext_ack *extack)
2693{
2694 struct nlattr *pdreason[IFLA_PROTO_DOWN_REASON_MAX + 1];
829eb208
RP		 2695 unsigned long mask = 0;
2696 u32 value;
2697 bool proto_down;
2698 int err;
2699
2106efda 2700 if (!(dev->priv_flags & IFF_CHANGE_PROTO_DOWN)) {
829eb208
RP		 2701 NL_SET_ERR_MSG(extack, "Protodown not supported by device");
2702 return -EOPNOTSUPP;
2703 }
2704
2705 if (nl_proto_down_reason) {
2706 err = nla_parse_nested_deprecated(pdreason,
2707 IFLA_PROTO_DOWN_REASON_MAX,
2708 nl_proto_down_reason,
2709 ifla_proto_down_reason_policy,
2710 NULL);
2711 if (err < 0)
2712 return err;
2713
2714 if (!pdreason[IFLA_PROTO_DOWN_REASON_VALUE]) {
2715 NL_SET_ERR_MSG(extack, "Invalid protodown reason value");
2716 return -EINVAL;
2717 }
2718
2719 value = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_VALUE]);
2720
2721 if (pdreason[IFLA_PROTO_DOWN_REASON_MASK])
2722 mask = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_MASK]);
2723
2724 dev_change_proto_down_reason(dev, mask, value);
2725 }
2726
2727 if (nl_proto_down) {
2728 proto_down = nla_get_u8(nl_proto_down);
2729
d467d0bc 2730 /* Don't turn off protodown if there are active reasons */
829eb208
RP		 2731 if (!proto_down && dev->proto_down_reason) {
2732 NL_SET_ERR_MSG(extack, "Cannot clear protodown, active reasons");
2733 return -EBUSY;
2734 }
2735 err = dev_change_proto_down(dev,
2736 proto_down);
2737 if (err)
2738 return err;
2739 }
2740
2741 return 0;
2742}
2743
90c325e3 2744#define DO_SETLINK_MODIFIED 0x01
ba998906
ND		 2745/* notify flag means notify + modified. */
2746#define DO_SETLINK_NOTIFY 0x03
90f62cf3
EB		 2747static int do_setlink(const struct sk_buff *skb,
2748 struct net_device *dev, struct ifinfomsg *ifm,
ddf9f970 2749 struct netlink_ext_ack *extack,
5ea08b52 2750 struct nlattr **tb, int status)
1da177e4 2751{
d314774c 2752 const struct net_device_ops *ops = dev->netdev_ops;
5ea08b52 2753 char ifname[IFNAMSIZ];
0157f60c 2754 int err;
1da177e4 2755
5ea08b52
FF		 2756 if (tb[IFLA_IFNAME])
2757 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2758 else
2759 ifname[0] = '\0';
2760
7e4a8d5a 2761 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
5ea08b52 2762 const char *pat = ifname[0] ? ifname : NULL;
eeb85a14
AV		 2763 struct net *net;
2764 int new_ifindex;
2765
2766 net = rtnl_link_get_net_capable(skb, dev_net(dev),
2767 tb, CAP_NET_ADMIN);
d8a5ec67
EB		 2768 if (IS_ERR(net)) {
2769 err = PTR_ERR(net);
2770 goto errout;
2771 }
7c4f63ba 2772
eeb85a14
AV		 2773 if (tb[IFLA_NEW_IFINDEX])
2774 new_ifindex = nla_get_s32(tb[IFLA_NEW_IFINDEX]);
2775 else
2776 new_ifindex = 0;
2777
96a6b93b 2778 err = __dev_change_net_namespace(dev, net, pat, new_ifindex);
d8a5ec67
EB		 2779 put_net(net);
2780 if (err)
2781 goto errout;
90c325e3 2782 status |= DO_SETLINK_MODIFIED;
d8a5ec67
EB		 2783 }
2784
da5e0494 2785 if (tb[IFLA_MAP]) {
1da177e4
LT		 2786 struct rtnl_link_ifmap *u_map;
2787 struct ifmap k_map;
2788
d314774c 2789 if (!ops->ndo_set_config) {
1da177e4 2790 err = -EOPNOTSUPP;
0157f60c 2791 goto errout;
1da177e4
LT		 2792 }
2793
2794 if (!netif_device_present(dev)) {
2795 err = -ENODEV;
0157f60c 2796 goto errout;
1da177e4 2797 }
1da177e4 2798
da5e0494 2799 u_map = nla_data(tb[IFLA_MAP]);
1da177e4
LT		 2800 k_map.mem_start = (unsigned long) u_map->mem_start;
2801 k_map.mem_end = (unsigned long) u_map->mem_end;
2802 k_map.base_addr = (unsigned short) u_map->base_addr;
2803 k_map.irq = (unsigned char) u_map->irq;
2804 k_map.dma = (unsigned char) u_map->dma;
2805 k_map.port = (unsigned char) u_map->port;
2806
d314774c 2807 err = ops->ndo_set_config(dev, &k_map);
da5e0494 2808 if (err < 0)
0157f60c 2809 goto errout;
1da177e4 2810
ba998906 2811 status |= DO_SETLINK_NOTIFY;
1da177e4
LT		 2812 }
2813
da5e0494 2814 if (tb[IFLA_ADDRESS]) {
70f8e78e
DM		 2815 struct sockaddr *sa;
2816 int len;
2817
153711f9
WC		 2818 len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len,
2819 sizeof(*sa));
70f8e78e
DM		 2820 sa = kmalloc(len, GFP_KERNEL);
2821 if (!sa) {
2822 err = -ENOMEM;
0157f60c 2823 goto errout;
70f8e78e
DM		 2824 }
2825 sa->sa_family = dev->type;
da5e0494 2826 memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
70f8e78e 2827 dev->addr_len);
3b23a32a 2828 err = dev_set_mac_address_user(dev, sa, extack);
70f8e78e 2829 kfree(sa);
1da177e4 2830 if (err)
0157f60c 2831 goto errout;
90c325e3 2832 status |= DO_SETLINK_MODIFIED;
1da177e4
LT		 2833 }
2834
da5e0494 2835 if (tb[IFLA_MTU]) {
7a4c53be 2836 err = dev_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack);
da5e0494 2837 if (err < 0)
0157f60c 2838 goto errout;
90c325e3 2839 status |= DO_SETLINK_MODIFIED;
1da177e4
LT		 2840 }
2841
cbda10fa
VD		 2842 if (tb[IFLA_GROUP]) {
2843 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
ba998906 2844 status |= DO_SETLINK_NOTIFY;
cbda10fa
VD		 2845 }
2846
da5e0494
TG		 2847 /*
2848 * Interface selected by interface index but interface
2849 * name provided implies that a name change has been
2850 * requested.
2851 */
51055be8 2852 if (ifm->ifi_index > 0 && ifname[0]) {
da5e0494
TG		 2853 err = dev_change_name(dev, ifname);
2854 if (err < 0)
0157f60c 2855 goto errout;
90c325e3 2856 status |= DO_SETLINK_MODIFIED;
1da177e4
LT		 2857 }
2858
0b815a1a
SH		 2859 if (tb[IFLA_IFALIAS]) {
2860 err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
2861 nla_len(tb[IFLA_IFALIAS]));
2862 if (err < 0)
2863 goto errout;
ba998906 2864 status |= DO_SETLINK_NOTIFY;
0b815a1a
SH		 2865 }
2866
da5e0494
TG		 2867 if (tb[IFLA_BROADCAST]) {
2868 nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
e7c3273e 2869 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
1da177e4
LT		 2870 }
2871
fbaec0ea 2872 if (tb[IFLA_MASTER]) {
33eaf2a6 2873 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
fbaec0ea
JP		 2874 if (err)
2875 goto errout;
90c325e3 2876 status |= DO_SETLINK_MODIFIED;
fbaec0ea
JP		 2877 }
2878
a4abfa62
PS		 2879 if (ifm->ifi_flags || ifm->ifi_change) {
2880 err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
2881 extack);
2882 if (err < 0)
2883 goto errout;
2884 }
2885
9a57247f
JP		 2886 if (tb[IFLA_CARRIER]) {
2887 err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
2888 if (err)
2889 goto errout;
90c325e3 2890 status |= DO_SETLINK_MODIFIED;
9a57247f
JP		 2891 }
2892
5d1180fc 2893 if (tb[IFLA_TXQLEN]) {
0cd29503 2894 unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]);
6a643ddb
CW		 2895
2896 err = dev_change_tx_queue_len(dev, value);
2897 if (err)
2898 goto errout;
2899 status |= DO_SETLINK_MODIFIED;
5d1180fc 2900 }
b00055aa 2901
46e6b992
SH		 2902 if (tb[IFLA_GSO_MAX_SIZE]) {
2903 u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]);
2904
46e6b992
SH		 2905 if (dev->gso_max_size ^ max_size) {
2906 netif_set_gso_max_size(dev, max_size);
2907 status |= DO_SETLINK_MODIFIED;
2908 }
2909 }
2910
2911 if (tb[IFLA_GSO_MAX_SEGS]) {
2912 u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
2913
46e6b992 2914 if (dev->gso_max_segs ^ max_segs) {
6d872df3 2915 netif_set_gso_max_segs(dev, max_segs);
46e6b992
SH		 2916 status |= DO_SETLINK_MODIFIED;
2917 }
2918 }
2919
eac1b93c
CL		 2920 if (tb[IFLA_GRO_MAX_SIZE]) {
2921 u32 gro_max_size = nla_get_u32(tb[IFLA_GRO_MAX_SIZE]);
2922
2923 if (dev->gro_max_size ^ gro_max_size) {
2924 netif_set_gro_max_size(dev, gro_max_size);
2925 status |= DO_SETLINK_MODIFIED;
2926 }
2927 }
2928
9eefedd5
XL		 2929 if (tb[IFLA_GSO_IPV4_MAX_SIZE]) {
2930 u32 max_size = nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]);
2931
9eefedd5
XL		 2932 if (dev->gso_ipv4_max_size ^ max_size) {
2933 netif_set_gso_ipv4_max_size(dev, max_size);
2934 status |= DO_SETLINK_MODIFIED;
2935 }
2936 }
2937
2938 if (tb[IFLA_GRO_IPV4_MAX_SIZE]) {
2939 u32 gro_max_size = nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]);
2940
2941 if (dev->gro_ipv4_max_size ^ gro_max_size) {
2942 netif_set_gro_ipv4_max_size(dev, gro_max_size);
2943 status |= DO_SETLINK_MODIFIED;
2944 }
2945 }
2946
da5e0494 2947 if (tb[IFLA_OPERSTATE])
93b2d4a2 2948 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
b00055aa 2949
da5e0494 2950 if (tb[IFLA_LINKMODE]) {
1889b0e7
ND		 2951 unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);
2952
fd888e85 2953 write_lock(&dev_base_lock);
1889b0e7 2954 if (dev->link_mode ^ value)
ba998906 2955 status |= DO_SETLINK_NOTIFY;
1889b0e7 2956 dev->link_mode = value;
fd888e85 2957 write_unlock(&dev_base_lock);
b00055aa
SR		 2958 }
2959
c02db8c6 2960 if (tb[IFLA_VFINFO_LIST]) {
4f7d2cdf 2961 struct nlattr *vfinfo[IFLA_VF_MAX + 1];
c02db8c6
CW		 2962 struct nlattr *attr;
2963 int rem;
4f7d2cdf 2964
c02db8c6 2965 nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
4f7d2cdf
DB		 2966 if (nla_type(attr) != IFLA_VF_INFO ||
2967 nla_len(attr) < NLA_HDRLEN) {
253683bb 2968 err = -EINVAL;
c02db8c6 2969 goto errout;
253683bb 2970 }
8cb08174
JB		 2971 err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX,
2972 attr,
2973 ifla_vf_policy,
2974 NULL);
4f7d2cdf
DB		 2975 if (err < 0)
2976 goto errout;
2977 err = do_setvfinfo(dev, vfinfo);
c02db8c6
CW		 2978 if (err < 0)
2979 goto errout;
ba998906 2980 status |= DO_SETLINK_NOTIFY;
c02db8c6 2981 }
ebc08a6f 2982 }
1da177e4
LT		 2983 err = 0;
2984
57b61080
SF		 2985 if (tb[IFLA_VF_PORTS]) {
2986 struct nlattr *port[IFLA_PORT_MAX+1];
2987 struct nlattr *attr;
2988 int vf;
2989 int rem;
2990
2991 err = -EOPNOTSUPP;
2992 if (!ops->ndo_set_vf_port)
2993 goto errout;
2994
2995 nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
035d210f
DB		 2996 if (nla_type(attr) != IFLA_VF_PORT ||
2997 nla_len(attr) < NLA_HDRLEN) {
2998 err = -EINVAL;
2999 goto errout;
3000 }
8cb08174
JB		 3001 err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
3002 attr,
3003 ifla_port_policy,
3004 NULL);
57b61080
SF		 3005 if (err < 0)
3006 goto errout;
3007 if (!port[IFLA_PORT_VF]) {
3008 err = -EOPNOTSUPP;
3009 goto errout;
3010 }
3011 vf = nla_get_u32(port[IFLA_PORT_VF]);
3012 err = ops->ndo_set_vf_port(dev, vf, port);
3013 if (err < 0)
3014 goto errout;
ba998906 3015 status |= DO_SETLINK_NOTIFY;
57b61080
SF		 3016 }
3017 }
3018 err = 0;
3019
3020 if (tb[IFLA_PORT_SELF]) {
3021 struct nlattr *port[IFLA_PORT_MAX+1];
3022
8cb08174
JB		 3023 err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
3024 tb[IFLA_PORT_SELF],
3025 ifla_port_policy, NULL);
57b61080
SF		 3026 if (err < 0)
3027 goto errout;
3028
3029 err = -EOPNOTSUPP;
3030 if (ops->ndo_set_vf_port)
3031 err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
3032 if (err < 0)
3033 goto errout;
ba998906 3034 status |= DO_SETLINK_NOTIFY;
57b61080 3035 }
f8ff182c
TG		 3036
3037 if (tb[IFLA_AF_SPEC]) {
3038 struct nlattr *af;
3039 int rem;
3040
3041 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
3042 const struct rtnl_af_ops *af_ops;
3043
058c8d59 3044 BUG_ON(!(af_ops = rtnl_af_lookup(nla_type(af))));
f8ff182c 3045
3583a4e8 3046 err = af_ops->set_link_af(dev, af, extack);
a100243d 3047 if (err < 0)
f8ff182c
TG		 3048 goto errout;
3049
ba998906 3050 status |= DO_SETLINK_NOTIFY;
f8ff182c
TG		 3051 }
3052 }
57b61080
SF		 3053 err = 0;
3054
829eb208
RP		 3055 if (tb[IFLA_PROTO_DOWN] || tb[IFLA_PROTO_DOWN_REASON]) {
3056 err = do_set_proto_down(dev, tb[IFLA_PROTO_DOWN],
3057 tb[IFLA_PROTO_DOWN_REASON], extack);
88d6378b
AK		 3058 if (err)
3059 goto errout;
3060 status |= DO_SETLINK_NOTIFY;
3061 }
3062
d1fdd913
BB		 3063 if (tb[IFLA_XDP]) {
3064 struct nlattr *xdp[IFLA_XDP_MAX + 1];
85de8576 3065 u32 xdp_flags = 0;
d1fdd913 3066
8cb08174
JB		 3067 err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX,
3068 tb[IFLA_XDP],
3069 ifla_xdp_policy, NULL);
d1fdd913
BB		 3070 if (err < 0)
3071 goto errout;
3072
58038695 3073 if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) {
262d8625
BB		 3074 err = -EINVAL;
3075 goto errout;
3076 }
85de8576
DB		 3077
3078 if (xdp[IFLA_XDP_FLAGS]) {
3079 xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
3080 if (xdp_flags & ~XDP_FLAGS_MASK) {
3081 err = -EINVAL;
3082 goto errout;
3083 }
ee5d032f 3084 if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) {
0489df9a
DB		 3085 err = -EINVAL;
3086 goto errout;
3087 }
85de8576
DB		 3088 }
3089
d1fdd913 3090 if (xdp[IFLA_XDP_FD]) {
92234c8f
THJ		 3091 int expected_fd = -1;
3092
3093 if (xdp_flags & XDP_FLAGS_REPLACE) {
3094 if (!xdp[IFLA_XDP_EXPECTED_FD]) {
3095 err = -EINVAL;
3096 goto errout;
3097 }
3098 expected_fd =
3099 nla_get_s32(xdp[IFLA_XDP_EXPECTED_FD]);
3100 }
3101
ddf9f970 3102 err = dev_change_xdp_fd(dev, extack,
85de8576 3103 nla_get_s32(xdp[IFLA_XDP_FD]),
92234c8f 3104 expected_fd,
85de8576 3105 xdp_flags);
d1fdd913
BB		 3106 if (err)
3107 goto errout;
3108 status |= DO_SETLINK_NOTIFY;
3109 }
3110 }
3111
0157f60c 3112errout:
ba998906 3113 if (status & DO_SETLINK_MODIFIED) {
64ff90cc 3114 if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)
ba998906
ND		 3115 netdev_state_change(dev);
3116
3117 if (err < 0)
3118 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",
3119 dev->name);
3120 }
da5e0494 3121
0157f60c
PM		 3122 return err;
3123}
1da177e4 3124
cc6090e9 3125static struct net_device *rtnl_dev_get(struct net *net,
5ea08b52
FF		 3126 struct nlattr *tb[])
3127{
3128 char ifname[ALTIFNAMSIZ];
3129
3130 if (tb[IFLA_IFNAME])
3131 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3132 else if (tb[IFLA_ALT_IFNAME])
3133 nla_strscpy(ifname, tb[IFLA_ALT_IFNAME], ALTIFNAMSIZ);
3134 else
3135 return NULL;
cc6090e9
JP		 3136
3137 return __dev_get_by_name(net, ifname);
3138}
3139
c21ef3e3
DA		 3140static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3141 struct netlink_ext_ack *extack)
0157f60c 3142{
3b1e0a65 3143 struct net *net = sock_net(skb->sk);
0157f60c
PM		 3144 struct ifinfomsg *ifm;
3145 struct net_device *dev;
3146 int err;
3147 struct nlattr *tb[IFLA_MAX+1];
0157f60c 3148
8cb08174
JB		 3149 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3150 ifla_policy, extack);
0157f60c
PM		 3151 if (err < 0)
3152 goto errout;
3153
4ff66cae
CB		 3154 err = rtnl_ensure_unique_netns(tb, extack, false);
3155 if (err < 0)
3156 goto errout;
3157
0157f60c
PM		 3158 err = -EINVAL;
3159 ifm = nlmsg_data(nlh);
3160 if (ifm->ifi_index > 0)
a3d12891 3161 dev = __dev_get_by_index(net, ifm->ifi_index);
76c9ac0e 3162 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
5ea08b52 3163 dev = rtnl_dev_get(net, tb);
0157f60c
PM		 3164 else
3165 goto errout;
3166
3167 if (dev == NULL) {
3168 err = -ENODEV;
3169 goto errout;
3170 }
3171
89da780a
XL		 3172 err = validate_linkmsg(dev, tb, extack);
3173 if (err < 0)
3174 goto errout;
3175
5ea08b52 3176 err = do_setlink(skb, dev, ifm, extack, tb, 0);
da5e0494 3177errout:
1da177e4
LT		 3178 return err;
3179}
3180
66400d54
WC		 3181static int rtnl_group_dellink(const struct net *net, int group)
3182{
3183 struct net_device *dev, *aux;
3184 LIST_HEAD(list_kill);
3185 bool found = false;
3186
3187 if (!group)
3188 return -EPERM;
3189
3190 for_each_netdev(net, dev) {
3191 if (dev->group == group) {
3192 const struct rtnl_link_ops *ops;
3193
3194 found = true;
3195 ops = dev->rtnl_link_ops;
3196 if (!ops || !ops->dellink)
3197 return -EOPNOTSUPP;
3198 }
3199 }
3200
3201 if (!found)
3202 return -ENODEV;
3203
3204 for_each_netdev_safe(net, dev, aux) {
3205 if (dev->group == group) {
3206 const struct rtnl_link_ops *ops;
3207
3208 ops = dev->rtnl_link_ops;
3209 ops->dellink(dev, &list_kill);
3210 }
3211 }
3212 unregister_netdevice_many(&list_kill);
3213
3214 return 0;
3215}
3216
f3a63cce 3217int rtnl_delete_link(struct net_device *dev, u32 portid, const struct nlmsghdr *nlh)
614732ea
TG		 3218{
3219 const struct rtnl_link_ops *ops;
3220 LIST_HEAD(list_kill);
3221
3222 ops = dev->rtnl_link_ops;
3223 if (!ops || !ops->dellink)
3224 return -EOPNOTSUPP;
3225
3226 ops->dellink(dev, &list_kill);
f3a63cce 3227 unregister_netdevice_many_notify(&list_kill, portid, nlh);
614732ea
TG		 3228
3229 return 0;
3230}
3231EXPORT_SYMBOL_GPL(rtnl_delete_link);
3232
c21ef3e3
DA		 3233static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
3234 struct netlink_ext_ack *extack)
38f7b870 3235{
3b1e0a65 3236 struct net *net = sock_net(skb->sk);
f3a63cce 3237 u32 portid = NETLINK_CB(skb).portid;
b61ad68a
CB		 3238 struct net *tgt_net = net;
3239 struct net_device *dev = NULL;
38f7b870 3240 struct ifinfomsg *ifm;
38f7b870
PM		 3241 struct nlattr *tb[IFLA_MAX+1];
3242 int err;
b61ad68a 3243 int netnsid = -1;
38f7b870 3244
8cb08174
JB		 3245 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3246 ifla_policy, extack);
38f7b870
PM		 3247 if (err < 0)
3248 return err;
3249
4ff66cae
CB		 3250 err = rtnl_ensure_unique_netns(tb, extack, true);
3251 if (err < 0)
3252 return err;
3253
7e4a8d5a
CB		 3254 if (tb[IFLA_TARGET_NETNSID]) {
3255 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
c383edc4 3256 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
b61ad68a
CB		 3257 if (IS_ERR(tgt_net))
3258 return PTR_ERR(tgt_net);
3259 }
3260
3261 err = -EINVAL;
38f7b870
PM		 3262 ifm = nlmsg_data(nlh);
3263 if (ifm->ifi_index > 0)
b61ad68a 3264 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
76c9ac0e 3265 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
5ea08b52 3266 dev = rtnl_dev_get(net, tb);
66400d54 3267 else if (tb[IFLA_GROUP])
b61ad68a 3268 err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
38f7b870 3269 else
b61ad68a 3270 goto out;
38f7b870 3271
b61ad68a 3272 if (!dev) {
dee04163 3273 if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME] || ifm->ifi_index > 0)
b61ad68a
CB		 3274 err = -ENODEV;
3275
3276 goto out;
3277 }
3278
f3a63cce 3279 err = rtnl_delete_link(dev, portid, nlh);
38f7b870 3280
b61ad68a
CB		 3281out:
3282 if (netnsid >= 0)
3283 put_net(tgt_net);
3284
3285 return err;
38f7b870
PM		 3286}
3287
1d997f10
HL		 3288int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm,
3289 u32 portid, const struct nlmsghdr *nlh)
3729d502
PM		 3290{
3291 unsigned int old_flags;
3292 int err;
3293
3294 old_flags = dev->flags;
3295 if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
6d040321
PM		 3296 err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
3297 NULL);
3729d502
PM		 3298 if (err < 0)
3299 return err;
3300 }
3301
8d356b89 3302 if (dev->rtnl_link_state == RTNL_LINK_INITIALIZED) {
1d997f10 3303 __dev_notify_flags(dev, old_flags, (old_flags ^ dev->flags), portid, nlh);
8d356b89
RP		 3304 } else {
3305 dev->rtnl_link_state = RTNL_LINK_INITIALIZED;
1d997f10 3306 __dev_notify_flags(dev, old_flags, ~0U, portid, nlh);
8d356b89 3307 }
3729d502
PM		 3308 return 0;
3309}
3310EXPORT_SYMBOL(rtnl_configure_link);
3311
d0522f1c
DA		 3312struct net_device *rtnl_create_link(struct net *net, const char *ifname,
3313 unsigned char name_assign_type,
3314 const struct rtnl_link_ops *ops,
3315 struct nlattr *tb[],
3316 struct netlink_ext_ack *extack)
e7199288 3317{
e7199288 3318 struct net_device *dev;
d40156aa
JP		 3319 unsigned int num_tx_queues = 1;
3320 unsigned int num_rx_queues = 1;
b0ad3c17 3321 int err;
e7199288 3322
76ff5cc9
JP		 3323 if (tb[IFLA_NUM_TX_QUEUES])
3324 num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
3325 else if (ops->get_num_tx_queues)
d40156aa 3326 num_tx_queues = ops->get_num_tx_queues();
76ff5cc9
JP		 3327
3328 if (tb[IFLA_NUM_RX_QUEUES])
3329 num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
3330 else if (ops->get_num_rx_queues)
d40156aa 3331 num_rx_queues = ops->get_num_rx_queues();
efacb309 3332
d0522f1c
DA		 3333 if (num_tx_queues < 1 || num_tx_queues > 4096) {
3334 NL_SET_ERR_MSG(extack, "Invalid number of transmit queues");
0e1d6eca 3335 return ERR_PTR(-EINVAL);
d0522f1c 3336 }
0e1d6eca 3337
d0522f1c
DA		 3338 if (num_rx_queues < 1 || num_rx_queues > 4096) {
3339 NL_SET_ERR_MSG(extack, "Invalid number of receive queues");
0e1d6eca 3340 return ERR_PTR(-EINVAL);
d0522f1c 3341 }
0e1d6eca 3342
8c713dc9
JB		 3343 if (ops->alloc) {
3344 dev = ops->alloc(tb, ifname, name_assign_type,
3345 num_tx_queues, num_rx_queues);
3346 if (IS_ERR(dev))
3347 return dev;
3348 } else {
3349 dev = alloc_netdev_mqs(ops->priv_size, ifname,
3350 name_assign_type, ops->setup,
3351 num_tx_queues, num_rx_queues);
3352 }
3353
e7199288 3354 if (!dev)
d1892e4e 3355 return ERR_PTR(-ENOMEM);
e7199288 3356
b0ad3c17
XL		 3357 err = validate_linkmsg(dev, tb, extack);
3358 if (err < 0) {
3359 free_netdev(dev);
3360 return ERR_PTR(err);
3361 }
3362
81adee47
EB		 3363 dev_net_set(dev, net);
3364 dev->rtnl_link_ops = ops;
3729d502 3365 dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
81adee47 3366
d836f5c6
ED		 3367 if (tb[IFLA_MTU]) {
3368 u32 mtu = nla_get_u32(tb[IFLA_MTU]);
d836f5c6
ED		 3369
3370 err = dev_validate_mtu(dev, mtu, extack);
3371 if (err) {
3372 free_netdev(dev);
3373 return ERR_PTR(err);
3374 }
3375 dev->mtu = mtu;
3376 }
2afb9b53 3377 if (tb[IFLA_ADDRESS]) {
efd38f75
JK		 3378 __dev_addr_set(dev, nla_data(tb[IFLA_ADDRESS]),
3379 nla_len(tb[IFLA_ADDRESS]));
2afb9b53
JP		 3380 dev->addr_assign_type = NET_ADDR_SET;
3381 }
e7199288
PE		 3382 if (tb[IFLA_BROADCAST])
3383 memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
3384 nla_len(tb[IFLA_BROADCAST]));
3385 if (tb[IFLA_TXQLEN])
3386 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
3387 if (tb[IFLA_OPERSTATE])
93b2d4a2 3388 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
e7199288
PE		 3389 if (tb[IFLA_LINKMODE])
3390 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
ffa934f1
PM		 3391 if (tb[IFLA_GROUP])
3392 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
46e6b992
SH		 3393 if (tb[IFLA_GSO_MAX_SIZE])
3394 netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE]));
3395 if (tb[IFLA_GSO_MAX_SEGS])
6d872df3 3396 netif_set_gso_max_segs(dev, nla_get_u32(tb[IFLA_GSO_MAX_SEGS]));
eac1b93c
CL		 3397 if (tb[IFLA_GRO_MAX_SIZE])
3398 netif_set_gro_max_size(dev, nla_get_u32(tb[IFLA_GRO_MAX_SIZE]));
9eefedd5
XL		 3399 if (tb[IFLA_GSO_IPV4_MAX_SIZE])
3400 netif_set_gso_ipv4_max_size(dev, nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]));
3401 if (tb[IFLA_GRO_IPV4_MAX_SIZE])
3402 netif_set_gro_ipv4_max_size(dev, nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]));
e7199288
PE		 3403
3404 return dev;
e7199288 3405}
e0d087af 3406EXPORT_SYMBOL(rtnl_create_link);
e7199288 3407
90f62cf3
EB		 3408static int rtnl_group_changelink(const struct sk_buff *skb,
3409 struct net *net, int group,
e7ed828f 3410 struct ifinfomsg *ifm,
ddf9f970 3411 struct netlink_ext_ack *extack,
e7ed828f
VD		 3412 struct nlattr **tb)
3413{
d079535d 3414 struct net_device *dev, *aux;
e7ed828f
VD		 3415 int err;
3416
d079535d 3417 for_each_netdev_safe(net, dev, aux) {
e7ed828f 3418 if (dev->group == group) {
89da780a
XL		 3419 err = validate_linkmsg(dev, tb, extack);
3420 if (err < 0)
3421 return err;
5ea08b52 3422 err = do_setlink(skb, dev, ifm, extack, tb, 0);
e7ed828f
VD		 3423 if (err < 0)
3424 return err;
3425 }
3426 }
3427
3428 return 0;
3429}
3430
63105e83
JK		 3431static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm,
3432 const struct rtnl_link_ops *ops,
d88e136c 3433 const struct nlmsghdr *nlh,
63105e83 3434 struct nlattr **tb, struct nlattr **data,
02839cc8
JK		 3435 struct netlink_ext_ack *extack)
3436{
3437 unsigned char name_assign_type = NET_NAME_USER;
3438 struct net *net = sock_net(skb->sk);
d88e136c 3439 u32 portid = NETLINK_CB(skb).portid;
02839cc8
JK		 3440 struct net *dest_net, *link_net;
3441 struct net_device *dev;
3442 char ifname[IFNAMSIZ];
3443 int err;
3444
3445 if (!ops->alloc && !ops->setup)
3446 return -EOPNOTSUPP;
3447
3448 if (tb[IFLA_IFNAME]) {
3449 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3450 } else {
3451 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3452 name_assign_type = NET_NAME_ENUM;
3453 }
3454
3455 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3456 if (IS_ERR(dest_net))
3457 return PTR_ERR(dest_net);
3458
3459 if (tb[IFLA_LINK_NETNSID]) {
3460 int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
3461
3462 link_net = get_net_ns_by_id(dest_net, id);
3463 if (!link_net) {
3464 NL_SET_ERR_MSG(extack, "Unknown network namespace id");
3465 err = -EINVAL;
3466 goto out;
3467 }
3468 err = -EPERM;
3469 if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
3470 goto out;
3471 } else {
3472 link_net = NULL;
3473 }
3474
3475 dev = rtnl_create_link(link_net ? : dest_net, ifname,
3476 name_assign_type, ops, tb, extack);
3477 if (IS_ERR(dev)) {
3478 err = PTR_ERR(dev);
3479 goto out;
3480 }
3481
3482 dev->ifindex = ifm->ifi_index;
3483
3484 if (ops->newlink)
3485 err = ops->newlink(link_net ? : net, dev, tb, data, extack);
3486 else
3487 err = register_netdevice(dev);
3488 if (err < 0) {
3489 free_netdev(dev);
3490 goto out;
3491 }
3492
d88e136c 3493 err = rtnl_configure_link(dev, ifm, portid, nlh);
02839cc8
JK		 3494 if (err < 0)
3495 goto out_unregister;
3496 if (link_net) {
3497 err = dev_change_net_namespace(dev, dest_net, ifname);
3498 if (err < 0)
3499 goto out_unregister;
3500 }
3501 if (tb[IFLA_MASTER]) {
3502 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3503 if (err)
3504 goto out_unregister;
3505 }
3506out:
3507 if (link_net)
3508 put_net(link_net);
3509 put_net(dest_net);
3510 return err;
3511out_unregister:
3512 if (ops->newlink) {
3513 LIST_HEAD(list_kill);
3514
3515 ops->dellink(dev, &list_kill);
3516 unregister_netdevice_many(&list_kill);
3517 } else {
3518 unregister_netdevice(dev);
3519 }
3520 goto out;
3521}
63105e83 3522
c92bf26c
JK		 3523struct rtnl_newlink_tbs {
3524 struct nlattr *tb[IFLA_MAX + 1];
3525 struct nlattr *attr[RTNL_MAX_TYPE + 1];
3526 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3527};
3528
a2939745 3529static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
c92bf26c
JK		 3530 struct rtnl_newlink_tbs *tbs,
3531 struct netlink_ext_ack *extack)
38f7b870 3532{
420d0318 3533 struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
c92bf26c 3534 struct nlattr ** const tb = tbs->tb;
c6f6f244
ED		 3535 const struct rtnl_link_ops *m_ops;
3536 struct net_device *master_dev;
3b1e0a65 3537 struct net *net = sock_net(skb->sk);
38f7b870 3538 const struct rtnl_link_ops *ops;
420d0318
JK		 3539 struct nlattr **slave_data;
3540 char kind[MODULE_NAME_LEN];
38f7b870
PM		 3541 struct net_device *dev;
3542 struct ifinfomsg *ifm;
420d0318 3543 struct nlattr **data;
ef2a7c90 3544 bool link_specified;
38f7b870
PM		 3545 int err;
3546
95a5afca 3547#ifdef CONFIG_MODULES
38f7b870 3548replay:
8072f085 3549#endif
8cb08174
JB		 3550 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3551 ifla_policy, extack);
38f7b870
PM		 3552 if (err < 0)
3553 return err;
3554
4ff66cae
CB		 3555 err = rtnl_ensure_unique_netns(tb, extack, false);
3556 if (err < 0)
3557 return err;
3558
38f7b870 3559 ifm = nlmsg_data(nlh);
ef2a7c90
FF		 3560 if (ifm->ifi_index > 0) {
3561 link_specified = true;
881d966b 3562 dev = __dev_get_by_index(net, ifm->ifi_index);
30188bd7
IS		 3563 } else if (ifm->ifi_index < 0) {
3564 NL_SET_ERR_MSG(extack, "ifindex can't be negative");
3565 return -EINVAL;
ef2a7c90
FF		 3566 } else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) {
3567 link_specified = true;
5ea08b52 3568 dev = rtnl_dev_get(net, tb);
ef2a7c90
FF		 3569 } else {
3570 link_specified = false;
7af12cba 3571 dev = NULL;
ef2a7c90 3572 }
38f7b870 3573
c6f6f244
ED		 3574 master_dev = NULL;
3575 m_ops = NULL;
ba7d49b1
JP		 3576 if (dev) {
3577 master_dev = netdev_master_upper_dev_get(dev);
3578 if (master_dev)
3579 m_ops = master_dev->rtnl_link_ops;
3580 }
3581
38f7b870 3582 if (tb[IFLA_LINKINFO]) {
8cb08174
JB		 3583 err = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX,
3584 tb[IFLA_LINKINFO],
3585 ifla_info_policy, NULL);
38f7b870
PM		 3586 if (err < 0)
3587 return err;
3588 } else
3589 memset(linkinfo, 0, sizeof(linkinfo));
3590
3591 if (linkinfo[IFLA_INFO_KIND]) {
872f6903 3592 nla_strscpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
38f7b870
PM		 3593 ops = rtnl_link_ops_get(kind);
3594 } else {
3595 kind[0] = '\0';
3596 ops = NULL;
3597 }
3598
420d0318
JK		 3599 data = NULL;
3600 if (ops) {
3601 if (ops->maxtype > RTNL_MAX_TYPE)
3602 return -EINVAL;
ccf8dbcd 3603
420d0318 3604 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
c92bf26c 3605 err = nla_parse_nested_deprecated(tbs->attr, ops->maxtype,
8cb08174
JB		 3606 linkinfo[IFLA_INFO_DATA],
3607 ops->policy, extack);
420d0318
JK		 3608 if (err < 0)
3609 return err;
c92bf26c 3610 data = tbs->attr;
38f7b870 3611 }
420d0318
JK		 3612 if (ops->validate) {
3613 err = ops->validate(tb, data, extack);
3614 if (err < 0)
3615 return err;
3616 }
3617 }
38f7b870 3618
420d0318
JK		 3619 slave_data = NULL;
3620 if (m_ops) {
3621 if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3622 return -EINVAL;
ccf8dbcd 3623
420d0318
JK		 3624 if (m_ops->slave_maxtype &&
3625 linkinfo[IFLA_INFO_SLAVE_DATA]) {
c92bf26c 3626 err = nla_parse_nested_deprecated(tbs->slave_attr,
8cb08174
JB		 3627 m_ops->slave_maxtype,
3628 linkinfo[IFLA_INFO_SLAVE_DATA],
3629 m_ops->slave_policy,
3630 extack);
420d0318
JK		 3631 if (err < 0)
3632 return err;
c92bf26c 3633 slave_data = tbs->slave_attr;
ba7d49b1 3634 }
420d0318 3635 }
ba7d49b1 3636
420d0318
JK		 3637 if (dev) {
3638 int status = 0;
38f7b870 3639
420d0318
JK		 3640 if (nlh->nlmsg_flags & NLM_F_EXCL)
3641 return -EEXIST;
3642 if (nlh->nlmsg_flags & NLM_F_REPLACE)
3643 return -EOPNOTSUPP;
38f7b870 3644
89da780a
XL		 3645 err = validate_linkmsg(dev, tb, extack);
3646 if (err < 0)
3647 return err;
3648
420d0318
JK		 3649 if (linkinfo[IFLA_INFO_DATA]) {
3650 if (!ops || ops != dev->rtnl_link_ops ||
3651 !ops->changelink)
3652 return -EOPNOTSUPP;
38f7b870 3653
420d0318
JK		 3654 err = ops->changelink(dev, tb, data, extack);
3655 if (err < 0)
3656 return err;
3657 status |= DO_SETLINK_NOTIFY;
3658 }
ba7d49b1 3659
420d0318
JK		 3660 if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
3661 if (!m_ops || !m_ops->slave_changelink)
3662 return -EOPNOTSUPP;
ba7d49b1 3663
420d0318
JK		 3664 err = m_ops->slave_changelink(master_dev, dev, tb,
3665 slave_data, extack);
3666 if (err < 0)
3667 return err;
3668 status |= DO_SETLINK_NOTIFY;
38f7b870
PM		 3669 }
3670
5ea08b52 3671 return do_setlink(skb, dev, ifm, extack, tb, status);
420d0318
JK		 3672 }
3673
3674 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
ef2a7c90
FF		 3675 /* No dev found and NLM_F_CREATE not set. Requested dev does not exist,
3676 * or it's for a group
3677 */
3678 if (link_specified)
3679 return -ENODEV;
3680 if (tb[IFLA_GROUP])
420d0318 3681 return rtnl_group_changelink(skb, net,
ffa934f1 3682 nla_get_u32(tb[IFLA_GROUP]),
ddf9f970 3683 ifm, extack, tb);
6f37c9f9 3684 return -ENODEV;
420d0318 3685 }
38f7b870 3686
420d0318
JK		 3687 if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3688 return -EOPNOTSUPP;
38f7b870 3689
420d0318 3690 if (!ops) {
95a5afca 3691#ifdef CONFIG_MODULES
420d0318
JK		 3692 if (kind[0]) {
3693 __rtnl_unlock();
3694 request_module("rtnl-link-%s", kind);
3695 rtnl_lock();
3696 ops = rtnl_link_ops_get(kind);
3697 if (ops)
3698 goto replay;
38f7b870 3699 }
420d0318
JK		 3700#endif
3701 NL_SET_ERR_MSG(extack, "Unknown device type");
3702 return -EOPNOTSUPP;
3703 }
38f7b870 3704
d88e136c 3705 return rtnl_newlink_create(skb, ifm, ops, nlh, tb, data, extack);
63105e83
JK		 3706}
3707
a2939745
JK		 3708static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3709 struct netlink_ext_ack *extack)
3710{
c92bf26c 3711 struct rtnl_newlink_tbs *tbs;
a2939745
JK		 3712 int ret;
3713
c92bf26c
JK		 3714 tbs = kmalloc(sizeof(*tbs), GFP_KERNEL);
3715 if (!tbs)
a2939745
JK		 3716 return -ENOMEM;
3717
c92bf26c
JK		 3718 ret = __rtnl_newlink(skb, nlh, tbs, extack);
3719 kfree(tbs);
a2939745
JK		 3720 return ret;
3721}
3722
9b3757b0
JK		 3723static int rtnl_valid_getlink_req(struct sk_buff *skb,
3724 const struct nlmsghdr *nlh,
3725 struct nlattr **tb,
3726 struct netlink_ext_ack *extack)
3727{
3728 struct ifinfomsg *ifm;
3729 int i, err;
3730
3731 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
3732 NL_SET_ERR_MSG(extack, "Invalid header for get link");
3733 return -EINVAL;
3734 }
3735
3736 if (!netlink_strict_get_check(skb))
8cb08174
JB		 3737 return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3738 ifla_policy, extack);
9b3757b0
JK		 3739
3740 ifm = nlmsg_data(nlh);
3741 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
3742 ifm->ifi_change) {
3743 NL_SET_ERR_MSG(extack, "Invalid values in header for get link request");
3744 return -EINVAL;
3745 }
3746
8cb08174
JB		 3747 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX,
3748 ifla_policy, extack);
9b3757b0
JK		 3749 if (err)
3750 return err;
3751
3752 for (i = 0; i <= IFLA_MAX; i++) {
3753 if (!tb[i])
3754 continue;
3755
3756 switch (i) {
3757 case IFLA_IFNAME:
76c9ac0e 3758 case IFLA_ALT_IFNAME:
9b3757b0
JK		 3759 case IFLA_EXT_MASK:
3760 case IFLA_TARGET_NETNSID:
3761 break;
3762 default:
3763 NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request");
3764 return -EINVAL;
3765 }
3766 }
3767
3768 return 0;
3769}
3770
c21ef3e3
DA		 3771static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3772 struct netlink_ext_ack *extack)
711e2c33 3773{
3b1e0a65 3774 struct net *net = sock_net(skb->sk);
79e1ad14 3775 struct net *tgt_net = net;
b60c5115
TG		 3776 struct ifinfomsg *ifm;
3777 struct nlattr *tb[IFLA_MAX+1];
3778 struct net_device *dev = NULL;
3779 struct sk_buff *nskb;
79e1ad14 3780 int netnsid = -1;
339bf98f 3781 int err;
115c9b81 3782 u32 ext_filter_mask = 0;
711e2c33 3783
9b3757b0 3784 err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
b60c5115 3785 if (err < 0)
9918f230 3786 return err;
b60c5115 3787
4ff66cae
CB		 3788 err = rtnl_ensure_unique_netns(tb, extack, true);
3789 if (err < 0)
3790 return err;
3791
7e4a8d5a
CB		 3792 if (tb[IFLA_TARGET_NETNSID]) {
3793 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
c383edc4 3794 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
79e1ad14
JB		 3795 if (IS_ERR(tgt_net))
3796 return PTR_ERR(tgt_net);
3797 }
3798
115c9b81
GR		 3799 if (tb[IFLA_EXT_MASK])
3800 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3801
79e1ad14 3802 err = -EINVAL;
b60c5115 3803 ifm = nlmsg_data(nlh);
a3d12891 3804 if (ifm->ifi_index > 0)
79e1ad14 3805 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
76c9ac0e 3806 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
5ea08b52 3807 dev = rtnl_dev_get(tgt_net, tb);
a3d12891 3808 else
79e1ad14 3809 goto out;
711e2c33 3810
79e1ad14 3811 err = -ENODEV;
a3d12891 3812 if (dev == NULL)
79e1ad14 3813 goto out;
a3d12891 3814
79e1ad14 3815 err = -ENOBUFS;
115c9b81 3816 nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
a3d12891 3817 if (nskb == NULL)
79e1ad14 3818 goto out;
b60c5115 3819
79e1ad14
JB		 3820 err = rtnl_fill_ifinfo(nskb, dev, net,
3821 RTM_NEWLINK, NETLINK_CB(skb).portid,
3822 nlh->nlmsg_seq, 0, 0, ext_filter_mask,
d4e4fdf9 3823 0, NULL, 0, netnsid, GFP_KERNEL);
26932566
PM		 3824 if (err < 0) {
3825 /* -EMSGSIZE implies BUG in if_nlmsg_size */
3826 WARN_ON(err == -EMSGSIZE);
3827 kfree_skb(nskb);
a3d12891 3828 } else
15e47304 3829 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
79e1ad14
JB		 3830out:
3831 if (netnsid >= 0)
3832 put_net(tgt_net);
711e2c33 3833
b60c5115 3834 return err;
711e2c33 3835}
711e2c33 3836
36fbf1e5
JP		 3837static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr,
3838 bool *changed, struct netlink_ext_ack *extack)
3839{
3840 char *alt_ifname;
155fb43b 3841 size_t size;
36fbf1e5
JP		 3842 int err;
3843
3844 err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack);
3845 if (err)
3846 return err;
3847
155fb43b
JK		 3848 if (cmd == RTM_NEWLINKPROP) {
3849 size = rtnl_prop_list_size(dev);
3850 size += nla_total_size(ALTIFNAMSIZ);
3851 if (size >= U16_MAX) {
3852 NL_SET_ERR_MSG(extack,
3853 "effective property list too long");
3854 return -EINVAL;
3855 }
3856 }
3857
5d26cff5 3858 alt_ifname = nla_strdup(attr, GFP_KERNEL_ACCOUNT);
44bfa9c5
ED		 3859 if (!alt_ifname)
3860 return -ENOMEM;
3861
36fbf1e5 3862 if (cmd == RTM_NEWLINKPROP) {
36fbf1e5 3863 err = netdev_name_node_alt_create(dev, alt_ifname);
44bfa9c5
ED		 3864 if (!err)
3865 alt_ifname = NULL;
36fbf1e5
JP		 3866 } else if (cmd == RTM_DELLINKPROP) {
3867 err = netdev_name_node_alt_destroy(dev, alt_ifname);
36fbf1e5 3868 } else {
44bfa9c5
ED		 3869 WARN_ON_ONCE(1);
3870 err = -EINVAL;
36fbf1e5
JP		 3871 }
3872
44bfa9c5
ED		 3873 kfree(alt_ifname);
3874 if (!err)
3875 *changed = true;
3876 return err;
36fbf1e5
JP		 3877}
3878
3879static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,
3880 struct netlink_ext_ack *extack)
3881{
3882 struct net *net = sock_net(skb->sk);
3883 struct nlattr *tb[IFLA_MAX + 1];
3884 struct net_device *dev;
3885 struct ifinfomsg *ifm;
3886 bool changed = false;
3887 struct nlattr *attr;
3888 int err, rem;
3889
3890 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
3891 if (err)
3892 return err;
3893
3894 err = rtnl_ensure_unique_netns(tb, extack, true);
3895 if (err)
3896 return err;
3897
3898 ifm = nlmsg_data(nlh);
cc6090e9 3899 if (ifm->ifi_index > 0)
36fbf1e5 3900 dev = __dev_get_by_index(net, ifm->ifi_index);
76c9ac0e 3901 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
5ea08b52 3902 dev = rtnl_dev_get(net, tb);
cc6090e9 3903 else
36fbf1e5 3904 return -EINVAL;
36fbf1e5
JP		 3905
3906 if (!dev)
3907 return -ENODEV;
3908
3909 if (!tb[IFLA_PROP_LIST])
3910 return 0;
3911
3912 nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) {
3913 switch (nla_type(attr)) {
3914 case IFLA_ALT_IFNAME:
3915 err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack);
3916 if (err)
3917 return err;
3918 break;
3919 }
3920 }
3921
3922 if (changed)
3923 netdev_state_change(dev);
3924 return 0;
3925}
3926
3927static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3928 struct netlink_ext_ack *extack)
3929{
3930 return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack);
3931}
3932
3933static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3934 struct netlink_ext_ack *extack)
3935{
3936 return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack);
3937}
3938
ebfe3c51 3939static u32 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
c7ac8679 3940{
115c9b81 3941 struct net *net = sock_net(skb->sk);
ebfe3c51 3942 size_t min_ifinfo_dump_size = 0;
115c9b81
GR		 3943 struct nlattr *tb[IFLA_MAX+1];
3944 u32 ext_filter_mask = 0;
ebfe3c51 3945 struct net_device *dev;
e5eca6d4
MS		 3946 int hdrlen;
3947
3948 /* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
3949 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
3950 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
115c9b81 3951
8cb08174 3952 if (nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
a4b64fbe
ED		 3953 if (tb[IFLA_EXT_MASK])
3954 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3955 }
115c9b81
GR		 3956
3957 if (!ext_filter_mask)
3958 return NLMSG_GOODSIZE;
3959 /*
3960 * traverse the list of net devices and compute the minimum
3961 * buffer size based upon the filter mask.
3962 */
6853dd48
FW		 3963 rcu_read_lock();
3964 for_each_netdev_rcu(net, dev) {
ebfe3c51
DZ		 3965 min_ifinfo_dump_size = max(min_ifinfo_dump_size,
3966 if_nlmsg_size(dev, ext_filter_mask));
115c9b81 3967 }
6853dd48 3968 rcu_read_unlock();
115c9b81 3969
93af2056 3970 return nlmsg_total_size(min_ifinfo_dump_size);
c7ac8679
GR		 3971}
3972
42bad1da 3973static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
1da177e4
LT		 3974{
3975 int idx;
3976 int s_idx = cb->family;
87ccbb1f 3977 int type = cb->nlh->nlmsg_type - RTM_BASE;
c63586dc 3978 int ret = 0;
1da177e4
LT		 3979
3980 if (s_idx == 0)
3981 s_idx = 1;
6853dd48 3982
25239cee 3983 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
51e13685 3984 struct rtnl_link __rcu **tab;
addf9b90 3985 struct rtnl_link *link;
6853dd48
FW		 3986 rtnl_dumpit_func dumpit;
3987
1da177e4
LT		 3988 if (idx < s_idx || idx == PF_PACKET)
3989 continue;
6853dd48 3990
addf9b90 3991 if (type < 0 || type >= RTM_NR_MSGTYPES)
1da177e4 3992 continue;
6853dd48 3993
addf9b90
FW		 3994 tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]);
3995 if (!tab)
3996 continue;
3997
51e13685 3998 link = rcu_dereference_rtnl(tab[type]);
addf9b90
FW		 3999 if (!link)
4000 continue;
4001
4002 dumpit = link->dumpit;
6853dd48
FW		 4003 if (!dumpit)
4004 continue;
4005
0465277f 4006 if (idx > s_idx) {
1da177e4 4007 memset(&cb->args[0], 0, sizeof(cb->args));
0465277f
ND		 4008 cb->prev_seq = 0;
4009 cb->seq = 0;
4010 }
c63586dc 4011 ret = dumpit(skb, cb);
5e1acb4a 4012 if (ret)
1da177e4
LT		 4013 break;
4014 }
4015 cb->family = idx;
4016
c63586dc 4017 return skb->len ? : ret;
1da177e4
LT		 4018}
4019
395eea6c 4020struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
3d3ea5af 4021 unsigned int change,
38e01b30 4022 u32 event, gfp_t flags, int *new_nsid,
59d3efd2
MW		 4023 int new_ifindex, u32 portid,
4024 const struct nlmsghdr *nlh)
1da177e4 4025{
c346dca1 4026 struct net *net = dev_net(dev);
1da177e4 4027 struct sk_buff *skb;
0ec6d3f4 4028 int err = -ENOBUFS;
59d3efd2 4029 u32 seq = 0;
1da177e4 4030
50af5969 4031 skb = nlmsg_new(if_nlmsg_size(dev, 0), flags);
0ec6d3f4
TG		 4032 if (skb == NULL)
4033 goto errout;
1da177e4 4034
59d3efd2
MW		 4035 if (nlmsg_report(nlh))
4036 seq = nlmsg_seq(nlh);
4037 else
4038 portid = 0;
4039
79e1ad14 4040 err = rtnl_fill_ifinfo(skb, dev, dev_net(dev),
1d997f10 4041 type, portid, seq, change, 0, 0, event,
d4e4fdf9 4042 new_nsid, new_ifindex, -1, flags);
26932566
PM		 4043 if (err < 0) {
4044 /* -EMSGSIZE implies BUG in if_nlmsg_size() */
4045 WARN_ON(err == -EMSGSIZE);
4046 kfree_skb(skb);
4047 goto errout;
4048 }
395eea6c 4049 return skb;
0ec6d3f4
TG		 4050errout:
4051 if (err < 0)
4b3da706 4052 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
395eea6c
MB		 4053 return NULL;
4054}
4055
1d997f10
HL		 4056void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags,
4057 u32 portid, const struct nlmsghdr *nlh)
395eea6c
MB		 4058{
4059 struct net *net = dev_net(dev);
4060
1d997f10 4061 rtnl_notify(skb, net, portid, RTNLGRP_LINK, nlh, flags);
395eea6c
MB		 4062}
4063
3d3ea5af
VY		 4064static void rtmsg_ifinfo_event(int type, struct net_device *dev,
4065 unsigned int change, u32 event,
1d997f10
HL		 4066 gfp_t flags, int *new_nsid, int new_ifindex,
4067 u32 portid, const struct nlmsghdr *nlh)
395eea6c
MB		 4068{
4069 struct sk_buff *skb;
4070
ed2a80ab
ND		 4071 if (dev->reg_state != NETREG_REGISTERED)
4072 return;
4073
38e01b30 4074 skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid,
59d3efd2 4075 new_ifindex, portid, nlh);
395eea6c 4076 if (skb)
1d997f10 4077 rtmsg_ifinfo_send(skb, dev, flags, portid, nlh);
1da177e4 4078}
3d3ea5af
VY		 4079
4080void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
1d997f10 4081 gfp_t flags, u32 portid, const struct nlmsghdr *nlh)
3d3ea5af 4082{
38e01b30 4083 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
1d997f10 4084 NULL, 0, portid, nlh);
3d3ea5af 4085}
1da177e4 4086
6621dd29 4087void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
38e01b30 4088 gfp_t flags, int *new_nsid, int new_ifindex)
6621dd29
ND		 4089{
4090 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
1d997f10 4091 new_nsid, new_ifindex, 0, NULL);
6621dd29
ND		 4092}
4093
d83b0603
JF		 4094static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
4095 struct net_device *dev,
1e53d5bb 4096 u8 *addr, u16 vid, u32 pid, u32 seq,
1c104a6b 4097 int type, unsigned int flags,
b3379041 4098 int nlflags, u16 ndm_state)
d83b0603
JF		 4099{
4100 struct nlmsghdr *nlh;
4101 struct ndmsg *ndm;
4102
1c104a6b 4103 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
d83b0603
JF		 4104 if (!nlh)
4105 return -EMSGSIZE;
4106
4107 ndm = nlmsg_data(nlh);
4108 ndm->ndm_family = AF_BRIDGE;
4109 ndm->ndm_pad1 = 0;
4110 ndm->ndm_pad2 = 0;
4111 ndm->ndm_flags = flags;
4112 ndm->ndm_type = 0;
4113 ndm->ndm_ifindex = dev->ifindex;
b3379041 4114 ndm->ndm_state = ndm_state;
d83b0603 4115
aa540695 4116 if (nla_put(skb, NDA_LLADDR, dev->addr_len, addr))
d83b0603 4117 goto nla_put_failure;
1e53d5bb
HS		 4118 if (vid)
4119 if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
4120 goto nla_put_failure;
d83b0603 4121
053c095a
JB		 4122 nlmsg_end(skb, nlh);
4123 return 0;
d83b0603
JF		 4124
4125nla_put_failure:
4126 nlmsg_cancel(skb, nlh);
4127 return -EMSGSIZE;
4128}
4129
aa540695 4130static inline size_t rtnl_fdb_nlmsg_size(const struct net_device *dev)
3ff661c3 4131{
f82ef3e1 4132 return NLMSG_ALIGN(sizeof(struct ndmsg)) +
aa540695 4133 nla_total_size(dev->addr_len) + /* NDA_LLADDR */
f82ef3e1
SD		 4134 nla_total_size(sizeof(u16)) + /* NDA_VLAN */
4135 0;
3ff661c3
JF		 4136}
4137
b3379041
HS		 4138static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
4139 u16 ndm_state)
3ff661c3
JF		 4140{
4141 struct net *net = dev_net(dev);
4142 struct sk_buff *skb;
4143 int err = -ENOBUFS;
4144
aa540695 4145 skb = nlmsg_new(rtnl_fdb_nlmsg_size(dev), GFP_ATOMIC);
3ff661c3
JF		 4146 if (!skb)
4147 goto errout;
4148
1e53d5bb 4149 err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
b3379041 4150 0, 0, type, NTF_SELF, 0, ndm_state);
3ff661c3
JF		 4151 if (err < 0) {
4152 kfree_skb(skb);
4153 goto errout;
4154 }
4155
4156 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
4157 return;
4158errout:
4159 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
4160}
4161
a986967e 4162/*
090096bf
VY		 4163 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
4164 */
4165int ndo_dflt_fdb_add(struct ndmsg *ndm,
4166 struct nlattr *tb[],
4167 struct net_device *dev,
f6f6424b 4168 const unsigned char *addr, u16 vid,
090096bf
VY		 4169 u16 flags)
4170{
4171 int err = -EINVAL;
4172
4173 /* If aging addresses are supported device will need to
4174 * implement its own handler for this.
4175 */
4176 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
78ecc890 4177 netdev_info(dev, "default FDB implementation only supports local addresses\n");
090096bf
VY		 4178 return err;
4179 }
4180
a35ec8e3
HS		 4181 if (tb[NDA_FLAGS_EXT]) {
4182 netdev_info(dev, "invalid flags given to default FDB implementation\n");
4183 return err;
4184 }
4185
65891fea 4186 if (vid) {
23ac0b42 4187 netdev_info(dev, "vlans aren't supported yet for dev_uc|mc_add()\n");
65891fea
OG		 4188 return err;
4189 }
4190
090096bf
VY		 4191 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
4192 err = dev_uc_add_excl(dev, addr);
4193 else if (is_multicast_ether_addr(addr))
4194 err = dev_mc_add_excl(dev, addr);
4195
4196 /* Only return duplicate errors if NLM_F_EXCL is set */
4197 if (err == -EEXIST && !(flags & NLM_F_EXCL))
4198 err = 0;
4199
4200 return err;
4201}
4202EXPORT_SYMBOL(ndo_dflt_fdb_add);
4203
b88d12e4
FW		 4204static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid,
4205 struct netlink_ext_ack *extack)
f6f6424b
JP		 4206{
4207 u16 vid = 0;
4208
4209 if (vlan_attr) {
4210 if (nla_len(vlan_attr) != sizeof(u16)) {
b88d12e4 4211 NL_SET_ERR_MSG(extack, "invalid vlan attribute size");
f6f6424b
JP		 4212 return -EINVAL;
4213 }
4214
4215 vid = nla_get_u16(vlan_attr);
4216
4217 if (!vid || vid >= VLAN_VID_MASK) {
b88d12e4 4218 NL_SET_ERR_MSG(extack, "invalid vlan id");
f6f6424b
JP		 4219 return -EINVAL;
4220 }
4221 }
4222 *p_vid = vid;
4223 return 0;
4224}
4225
c21ef3e3
DA		 4226static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
4227 struct netlink_ext_ack *extack)
77162022
JF		 4228{
4229 struct net *net = sock_net(skb->sk);
77162022
JF		 4230 struct ndmsg *ndm;
4231 struct nlattr *tb[NDA_MAX+1];
4232 struct net_device *dev;
4233 u8 *addr;
f6f6424b 4234 u16 vid;
77162022
JF		 4235 int err;
4236
8cb08174
JB		 4237 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
4238 extack);
77162022
JF		 4239 if (err < 0)
4240 return err;
4241
4242 ndm = nlmsg_data(nlh);
4243 if (ndm->ndm_ifindex == 0) {
b88d12e4 4244 NL_SET_ERR_MSG(extack, "invalid ifindex");
77162022
JF		 4245 return -EINVAL;
4246 }
4247
4248 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4249 if (dev == NULL) {
b88d12e4 4250 NL_SET_ERR_MSG(extack, "unknown ifindex");
77162022
JF		 4251 return -ENODEV;
4252 }
4253
4254 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
b88d12e4 4255 NL_SET_ERR_MSG(extack, "invalid address");
77162022
JF		 4256 return -EINVAL;
4257 }
4258
da715775
IS		 4259 if (dev->type != ARPHRD_ETHER) {
4260 NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices");
4261 return -EINVAL;
4262 }
4263
77162022 4264 addr = nla_data(tb[NDA_LLADDR]);
77162022 4265
b88d12e4 4266 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
f6f6424b
JP		 4267 if (err)
4268 return err;
4269
77162022
JF		 4270 err = -EOPNOTSUPP;
4271
4272 /* Support fdb on master device the net/bridge default case */
4273 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
2e92a2d0 4274 netif_is_bridge_port(dev)) {
898e5061
JP		 4275 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4276 const struct net_device_ops *ops = br_dev->netdev_ops;
4277
f6f6424b 4278 err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
87b0984e 4279 nlh->nlmsg_flags, extack);
77162022
JF		 4280 if (err)
4281 goto out;
4282 else
4283 ndm->ndm_flags &= ~NTF_MASTER;
4284 }
4285
4286 /* Embedded bridge, macvlan, and any other device support */
090096bf
VY		 4287 if ((ndm->ndm_flags & NTF_SELF)) {
4288 if (dev->netdev_ops->ndo_fdb_add)
4289 err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
f6f6424b 4290 vid,
87b0984e
PM		 4291 nlh->nlmsg_flags,
4292 extack);
090096bf 4293 else
f6f6424b 4294 err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
090096bf 4295 nlh->nlmsg_flags);
77162022 4296
3ff661c3 4297 if (!err) {
b3379041
HS		 4298 rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
4299 ndm->ndm_state);
77162022 4300 ndm->ndm_flags &= ~NTF_SELF;
3ff661c3 4301 }
77162022
JF		 4302 }
4303out:
4304 return err;
4305}
4306
a986967e 4307/*
090096bf
VY		 4308 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
4309 */
4310int ndo_dflt_fdb_del(struct ndmsg *ndm,
4311 struct nlattr *tb[],
4312 struct net_device *dev,
f6f6424b 4313 const unsigned char *addr, u16 vid)
090096bf 4314{
c8a89c4a 4315 int err = -EINVAL;
090096bf
VY		 4316
4317 /* If aging addresses are supported device will need to
4318 * implement its own handler for this.
4319 */
64535993 4320 if (!(ndm->ndm_state & NUD_PERMANENT)) {
78ecc890 4321 netdev_info(dev, "default FDB implementation only supports local addresses\n");
c8a89c4a 4322 return err;
090096bf
VY		 4323 }
4324
4325 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
4326 err = dev_uc_del(dev, addr);
4327 else if (is_multicast_ether_addr(addr))
4328 err = dev_mc_del(dev, addr);
090096bf
VY		 4329
4330 return err;
4331}
4332EXPORT_SYMBOL(ndo_dflt_fdb_del);
4333
9e834259
NA		 4334static const struct nla_policy fdb_del_bulk_policy[NDA_MAX + 1] = {
4335 [NDA_VLAN] = { .type = NLA_U16 },
4336 [NDA_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
ea2c0f9e
NA		 4337 [NDA_NDM_STATE_MASK] = { .type = NLA_U16 },
4338 [NDA_NDM_FLAGS_MASK] = { .type = NLA_U8 },
9e834259
NA		 4339};
4340
c21ef3e3
DA		 4341static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
4342 struct netlink_ext_ack *extack)
77162022 4343{
9e834259 4344 bool del_bulk = !!(nlh->nlmsg_flags & NLM_F_BULK);
77162022 4345 struct net *net = sock_net(skb->sk);
9e834259 4346 const struct net_device_ops *ops;
77162022 4347 struct ndmsg *ndm;
1690be63 4348 struct nlattr *tb[NDA_MAX+1];
77162022 4349 struct net_device *dev;
9e834259 4350 __u8 *addr = NULL;
7d311801 4351 int err;
f6f6424b 4352 u16 vid;
77162022 4353
90f62cf3 4354 if (!netlink_capable(skb, CAP_NET_ADMIN))
1690be63
VY		 4355 return -EPERM;
4356
9e834259
NA		 4357 if (!del_bulk) {
4358 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX,
4359 NULL, extack);
4360 } else {
4361 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX,
4362 fdb_del_bulk_policy, extack);
4363 }
1690be63
VY		 4364 if (err < 0)
4365 return err;
77162022
JF		 4366
4367 ndm = nlmsg_data(nlh);
4368 if (ndm->ndm_ifindex == 0) {
b88d12e4 4369 NL_SET_ERR_MSG(extack, "invalid ifindex");
77162022
JF		 4370 return -EINVAL;
4371 }
4372
4373 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4374 if (dev == NULL) {
b88d12e4 4375 NL_SET_ERR_MSG(extack, "unknown ifindex");
77162022
JF		 4376 return -ENODEV;
4377 }
4378
9e834259
NA		 4379 if (!del_bulk) {
4380 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4381 NL_SET_ERR_MSG(extack, "invalid address");
4382 return -EINVAL;
4383 }
4384 addr = nla_data(tb[NDA_LLADDR]);
1690be63
VY		 4385 }
4386
da715775
IS		 4387 if (dev->type != ARPHRD_ETHER) {
4388 NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4389 return -EINVAL;
4390 }
4391
b88d12e4 4392 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
f6f6424b
JP		 4393 if (err)
4394 return err;
4395
77162022
JF		 4396 err = -EOPNOTSUPP;
4397
4398 /* Support fdb on master device the net/bridge default case */
4399 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
2e92a2d0 4400 netif_is_bridge_port(dev)) {
898e5061 4401 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
77162022 4402
9e834259
NA		 4403 ops = br_dev->netdev_ops;
4404 if (!del_bulk) {
4405 if (ops->ndo_fdb_del)
ca4567f1 4406 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid, extack);
9e834259
NA		 4407 } else {
4408 if (ops->ndo_fdb_del_bulk)
4409 err = ops->ndo_fdb_del_bulk(ndm, tb, dev, vid,
4410 extack);
4411 }
77162022
JF		 4412
4413 if (err)
4414 goto out;
4415 else
4416 ndm->ndm_flags &= ~NTF_MASTER;
4417 }
4418
4419 /* Embedded bridge, macvlan, and any other device support */
090096bf 4420 if (ndm->ndm_flags & NTF_SELF) {
9e834259
NA		 4421 ops = dev->netdev_ops;
4422 if (!del_bulk) {
4423 if (ops->ndo_fdb_del)
ca4567f1 4424 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid, extack);
9e834259
NA		 4425 else
4426 err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4427 } else {
4428 /* in case err was cleared by NTF_MASTER call */
4429 err = -EOPNOTSUPP;
4430 if (ops->ndo_fdb_del_bulk)
4431 err = ops->ndo_fdb_del_bulk(ndm, tb, dev, vid,
4432 extack);
4433 }
77162022 4434
3ff661c3 4435 if (!err) {
9e834259
NA		 4436 if (!del_bulk)
4437 rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4438 ndm->ndm_state);
77162022 4439 ndm->ndm_flags &= ~NTF_SELF;
3ff661c3 4440 }
77162022
JF		 4441 }
4442out:
4443 return err;
4444}
4445
d83b0603
JF		 4446static int nlmsg_populate_fdb(struct sk_buff *skb,
4447 struct netlink_callback *cb,
4448 struct net_device *dev,
4449 int *idx,
4450 struct netdev_hw_addr_list *list)
4451{
4452 struct netdev_hw_addr *ha;
4453 int err;
15e47304 4454 u32 portid, seq;
d83b0603 4455
15e47304 4456 portid = NETLINK_CB(cb->skb).portid;
d83b0603
JF		 4457 seq = cb->nlh->nlmsg_seq;
4458
4459 list_for_each_entry(ha, &list->list, list) {
d297653d 4460 if (*idx < cb->args[2])
d83b0603
JF		 4461 goto skip;
4462
1e53d5bb 4463 err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
a7a558fe 4464 portid, seq,
1c104a6b 4465 RTM_NEWNEIGH, NTF_SELF,
b3379041 4466 NLM_F_MULTI, NUD_PERMANENT);
d83b0603
JF		 4467 if (err < 0)
4468 return err;
4469skip:
4470 *idx += 1;
4471 }
4472 return 0;
4473}
4474
4475/**
2c53040f 4476 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
a986967e
BVA		 4477 * @skb: socket buffer to store message in
4478 * @cb: netlink callback
d83b0603 4479 * @dev: netdevice
a986967e
BVA		 4480 * @filter_dev: ignored
4481 * @idx: the number of FDB table entries dumped is added to *@idx
d83b0603
JF		 4482 *
4483 * Default netdevice operation to dump the existing unicast address list.
91f3e7b1 4484 * Returns number of addresses from list put in skb.
d83b0603
JF		 4485 */
4486int ndo_dflt_fdb_dump(struct sk_buff *skb,
4487 struct netlink_callback *cb,
4488 struct net_device *dev,
5d5eacb3 4489 struct net_device *filter_dev,
d297653d 4490 int *idx)
d83b0603
JF		 4491{
4492 int err;
4493
68883893
ED		 4494 if (dev->type != ARPHRD_ETHER)
4495 return -EINVAL;
4496
d83b0603 4497 netif_addr_lock_bh(dev);
d297653d 4498 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
d83b0603
JF		 4499 if (err)
4500 goto out;
2934c9db 4501 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
d83b0603
JF		 4502out:
4503 netif_addr_unlock_bh(dev);
d297653d 4504 return err;
d83b0603
JF		 4505}
4506EXPORT_SYMBOL(ndo_dflt_fdb_dump);
4507
8c6e137f
DA		 4508static int valid_fdb_dump_strict(const struct nlmsghdr *nlh,
4509 int *br_idx, int *brport_idx,
4510 struct netlink_ext_ack *extack)
4511{
4512 struct nlattr *tb[NDA_MAX + 1];
4513 struct ndmsg *ndm;
4514 int err, i;
4515
4516 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4517 NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request");
4518 return -EINVAL;
4519 }
4520
4521 ndm = nlmsg_data(nlh);
4522 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
4523 ndm->ndm_flags || ndm->ndm_type) {
8b73018f 4524 NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request");
8c6e137f
DA		 4525 return -EINVAL;
4526 }
4527
8cb08174
JB		 4528 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4529 NDA_MAX, NULL, extack);
8c6e137f
DA		 4530 if (err < 0)
4531 return err;
4532
4533 *brport_idx = ndm->ndm_ifindex;
4534 for (i = 0; i <= NDA_MAX; ++i) {
4535 if (!tb[i])
4536 continue;
4537
4538 switch (i) {
4539 case NDA_IFINDEX:
4540 if (nla_len(tb[i]) != sizeof(u32)) {
4541 NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request");
4542 return -EINVAL;
4543 }
4544 *brport_idx = nla_get_u32(tb[NDA_IFINDEX]);
4545 break;
4546 case NDA_MASTER:
4547 if (nla_len(tb[i]) != sizeof(u32)) {
4548 NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request");
4549 return -EINVAL;
4550 }
4551 *br_idx = nla_get_u32(tb[NDA_MASTER]);
4552 break;
4553 default:
4554 NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request");
4555 return -EINVAL;
4556 }
4557 }
4558
4559 return 0;
4560}
4561
8dfbda19
DA		 4562static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh,
4563 int *br_idx, int *brport_idx,
4564 struct netlink_ext_ack *extack)
77162022 4565{
5e6d2435 4566 struct nlattr *tb[IFLA_MAX+1];
8dfbda19 4567 int err;
5e6d2435 4568
bd961c9b
MFO		 4569 /* A hack to preserve kernel<->userspace interface.
4570 * Before Linux v4.12 this code accepted ndmsg since iproute2 v3.3.0.
4571 * However, ndmsg is shorter than ifinfomsg thus nlmsg_parse() bails.
4572 * So, check for ndmsg with an optional u32 attribute (not used here).
4573 * Fortunately these sizes don't conflict with the size of ifinfomsg
4574 * with an optional attribute.
4575 */
8dfbda19
DA		 4576 if (nlmsg_len(nlh) != sizeof(struct ndmsg) &&
4577 (nlmsg_len(nlh) != sizeof(struct ndmsg) +
bd961c9b 4578 nla_attr_size(sizeof(u32)))) {
4565d7e5
DA		 4579 struct ifinfomsg *ifm;
4580
8cb08174
JB		 4581 err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4582 tb, IFLA_MAX, ifla_policy,
4583 extack);
bd961c9b
MFO		 4584 if (err < 0) {
4585 return -EINVAL;
4586 } else if (err == 0) {
4587 if (tb[IFLA_MASTER])
8dfbda19 4588 *br_idx = nla_get_u32(tb[IFLA_MASTER]);
bd961c9b 4589 }
5e6d2435 4590
4565d7e5 4591 ifm = nlmsg_data(nlh);
8dfbda19 4592 *brport_idx = ifm->ifi_index;
bd961c9b 4593 }
8dfbda19
DA		 4594 return 0;
4595}
4596
4597static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
4598{
4599 struct net_device *dev;
4600 struct net_device *br_dev = NULL;
4601 const struct net_device_ops *ops = NULL;
4602 const struct net_device_ops *cops = NULL;
4603 struct net *net = sock_net(skb->sk);
4604 struct hlist_head *head;
4605 int brport_idx = 0;
4606 int br_idx = 0;
4607 int h, s_h;
4608 int idx = 0, s_idx;
4609 int err = 0;
4610 int fidx = 0;
4611
8c6e137f
DA		 4612 if (cb->strict_check)
4613 err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx,
4614 cb->extack);
4615 else
4616 err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx,
4617 cb->extack);
8dfbda19
DA		 4618 if (err < 0)
4619 return err;
5e6d2435
JHS		 4620
4621 if (br_idx) {
4622 br_dev = __dev_get_by_index(net, br_idx);
4623 if (!br_dev)
4624 return -ENODEV;
4625
4626 ops = br_dev->netdev_ops;
5e6d2435
JHS		 4627 }
4628
d297653d
RP		 4629 s_h = cb->args[0];
4630 s_idx = cb->args[1];
5e6d2435 4631
d297653d
RP		 4632 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4633 idx = 0;
4634 head = &net->dev_index_head[h];
4635 hlist_for_each_entry(dev, head, index_hlist) {
5e6d2435 4636
d297653d 4637 if (brport_idx && (dev->ifindex != brport_idx))
5e6d2435
JHS		 4638 continue;
4639
d297653d 4640 if (!br_idx) { /* user did not specify a specific bridge */
2e92a2d0 4641 if (netif_is_bridge_port(dev)) {
d297653d
RP		 4642 br_dev = netdev_master_upper_dev_get(dev);
4643 cops = br_dev->netdev_ops;
4644 }
4645 } else {
4646 if (dev != br_dev &&
2e92a2d0 4647 !netif_is_bridge_port(dev))
d297653d 4648 continue;
5e6d2435 4649
d297653d 4650 if (br_dev != netdev_master_upper_dev_get(dev) &&
254ec036 4651 !netif_is_bridge_master(dev))
d297653d
RP		 4652 continue;
4653 cops = ops;
4654 }
77162022 4655
d297653d
RP		 4656 if (idx < s_idx)
4657 goto cont;
77162022 4658
2e92a2d0 4659 if (netif_is_bridge_port(dev)) {
d297653d
RP		 4660 if (cops && cops->ndo_fdb_dump) {
4661 err = cops->ndo_fdb_dump(skb, cb,
4662 br_dev, dev,
4663 &fidx);
4664 if (err == -EMSGSIZE)
4665 goto out;
4666 }
4667 }
5e6d2435 4668
d297653d
RP		 4669 if (dev->netdev_ops->ndo_fdb_dump)
4670 err = dev->netdev_ops->ndo_fdb_dump(skb, cb,
4671 dev, NULL,
4672 &fidx);
4673 else
4674 err = ndo_dflt_fdb_dump(skb, cb, dev, NULL,
4675 &fidx);
4676 if (err == -EMSGSIZE)
4677 goto out;
4678
4679 cops = NULL;
4680
4681 /* reset fdb offset to 0 for rest of the interfaces */
4682 cb->args[2] = 0;
4683 fidx = 0;
4684cont:
4685 idx++;
4686 }
77162022 4687 }
77162022 4688
d297653d
RP		 4689out:
4690 cb->args[0] = h;
4691 cb->args[1] = idx;
4692 cb->args[2] = fidx;
4693
77162022
JF		 4694 return skb->len;
4695}
4696
5b2f94b2
RP		 4697static int valid_fdb_get_strict(const struct nlmsghdr *nlh,
4698 struct nlattr **tb, u8 *ndm_flags,
4699 int *br_idx, int *brport_idx, u8 **addr,
4700 u16 *vid, struct netlink_ext_ack *extack)
4701{
4702 struct ndmsg *ndm;
4703 int err, i;
4704
4705 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4706 NL_SET_ERR_MSG(extack, "Invalid header for fdb get request");
4707 return -EINVAL;
4708 }
4709
4710 ndm = nlmsg_data(nlh);
4711 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
4712 ndm->ndm_type) {
4713 NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request");
4714 return -EINVAL;
4715 }
4716
4717 if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) {
4718 NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request");
4719 return -EINVAL;
4720 }
4721
8cb08174
JB		 4722 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4723 NDA_MAX, nda_policy, extack);
5b2f94b2
RP		 4724 if (err < 0)
4725 return err;
4726
4727 *ndm_flags = ndm->ndm_flags;
4728 *brport_idx = ndm->ndm_ifindex;
4729 for (i = 0; i <= NDA_MAX; ++i) {
4730 if (!tb[i])
4731 continue;
4732
4733 switch (i) {
4734 case NDA_MASTER:
4735 *br_idx = nla_get_u32(tb[i]);
4736 break;
4737 case NDA_LLADDR:
4738 if (nla_len(tb[i]) != ETH_ALEN) {
4739 NL_SET_ERR_MSG(extack, "Invalid address in fdb get request");
4740 return -EINVAL;
4741 }
4742 *addr = nla_data(tb[i]);
4743 break;
4744 case NDA_VLAN:
4745 err = fdb_vid_parse(tb[i], vid, extack);
4746 if (err)
4747 return err;
4748 break;
4749 case NDA_VNI:
4750 break;
4751 default:
4752 NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request");
4753 return -EINVAL;
4754 }
4755 }
4756
4757 return 0;
4758}
4759
4760static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4761 struct netlink_ext_ack *extack)
4762{
4763 struct net_device *dev = NULL, *br_dev = NULL;
4764 const struct net_device_ops *ops = NULL;
4765 struct net *net = sock_net(in_skb->sk);
4766 struct nlattr *tb[NDA_MAX + 1];
4767 struct sk_buff *skb;
4768 int brport_idx = 0;
4769 u8 ndm_flags = 0;
4770 int br_idx = 0;
4771 u8 *addr = NULL;
4772 u16 vid = 0;
4773 int err;
4774
4775 err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx,
4776 &brport_idx, &addr, &vid, extack);
4777 if (err < 0)
4778 return err;
4779
f989d03e
NA		 4780 if (!addr) {
4781 NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request");
4782 return -EINVAL;
4783 }
4784
5b2f94b2
RP		 4785 if (brport_idx) {
4786 dev = __dev_get_by_index(net, brport_idx);
4787 if (!dev) {
4788 NL_SET_ERR_MSG(extack, "Unknown device ifindex");
4789 return -ENODEV;
4790 }
4791 }
4792
4793 if (br_idx) {
4794 if (dev) {
4795 NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive");
4796 return -EINVAL;
4797 }
4798
4799 br_dev = __dev_get_by_index(net, br_idx);
4800 if (!br_dev) {
4801 NL_SET_ERR_MSG(extack, "Invalid master ifindex");
4802 return -EINVAL;
4803 }
4804 ops = br_dev->netdev_ops;
4805 }
4806
4807 if (dev) {
4808 if (!ndm_flags || (ndm_flags & NTF_MASTER)) {
2e92a2d0 4809 if (!netif_is_bridge_port(dev)) {
5b2f94b2
RP		 4810 NL_SET_ERR_MSG(extack, "Device is not a bridge port");
4811 return -EINVAL;
4812 }
4813 br_dev = netdev_master_upper_dev_get(dev);
4814 if (!br_dev) {
4815 NL_SET_ERR_MSG(extack, "Master of device not found");
4816 return -EINVAL;
4817 }
4818 ops = br_dev->netdev_ops;
4819 } else {
4820 if (!(ndm_flags & NTF_SELF)) {
4821 NL_SET_ERR_MSG(extack, "Missing NTF_SELF");
4822 return -EINVAL;
4823 }
4824 ops = dev->netdev_ops;
4825 }
4826 }
4827
4828 if (!br_dev && !dev) {
4829 NL_SET_ERR_MSG(extack, "No device specified");
4830 return -ENODEV;
4831 }
4832
4833 if (!ops || !ops->ndo_fdb_get) {
4834 NL_SET_ERR_MSG(extack, "Fdb get operation not supported by device");
4835 return -EOPNOTSUPP;
4836 }
4837
4838 skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4839 if (!skb)
4840 return -ENOBUFS;
4841
4842 if (br_dev)
4843 dev = br_dev;
4844 err = ops->ndo_fdb_get(skb, tb, dev, addr, vid,
4845 NETLINK_CB(in_skb).portid,
4846 nlh->nlmsg_seq, extack);
4847 if (err)
4848 goto out;
4849
4850 return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4851out:
4852 kfree_skb(skb);
4853 return err;
4854}
4855
2c3c031c
SF		 4856static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask,
4857 unsigned int attrnum, unsigned int flag)
4858{
4859 if (mask & flag)
4860 return nla_put_u8(skb, attrnum, !!(flags & flag));
4861 return 0;
4862}
4863
815cccbf 4864int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
2c3c031c 4865 struct net_device *dev, u16 mode,
7d4f8d87
SF		 4866 u32 flags, u32 mask, int nlflags,
4867 u32 filter_mask,
4868 int (*vlan_fill)(struct sk_buff *skb,
4869 struct net_device *dev,
4870 u32 filter_mask))
815cccbf
JF		 4871{
4872 struct nlmsghdr *nlh;
4873 struct ifinfomsg *ifm;
4874 struct nlattr *br_afspec;
2c3c031c 4875 struct nlattr *protinfo;
815cccbf 4876 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
898e5061 4877 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
7d4f8d87 4878 int err = 0;
815cccbf 4879
46c264da 4880 nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
815cccbf
JF		 4881 if (nlh == NULL)
4882 return -EMSGSIZE;
4883
4884 ifm = nlmsg_data(nlh);
4885 ifm->ifi_family = AF_BRIDGE;
4886 ifm->__ifi_pad = 0;
4887 ifm->ifi_type = dev->type;
4888 ifm->ifi_index = dev->ifindex;
4889 ifm->ifi_flags = dev_get_flags(dev);
4890 ifm->ifi_change = 0;
4891
4892
4893 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
4894 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
4895 nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
898e5061
JP		 4896 (br_dev &&
4897 nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
815cccbf
JF		 4898 (dev->addr_len &&
4899 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
a54acb3a
ND		 4900 (dev->ifindex != dev_get_iflink(dev) &&
4901 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
815cccbf
JF		 4902 goto nla_put_failure;
4903
ae0be8de 4904 br_afspec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
815cccbf
JF		 4905 if (!br_afspec)
4906 goto nla_put_failure;
4907
1d460b98 4908 if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
815cccbf
JF		 4909 nla_nest_cancel(skb, br_afspec);
4910 goto nla_put_failure;
4911 }
1d460b98
RP		 4912
4913 if (mode != BRIDGE_MODE_UNDEF) {
4914 if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
4915 nla_nest_cancel(skb, br_afspec);
4916 goto nla_put_failure;
4917 }
4918 }
7d4f8d87
SF		 4919 if (vlan_fill) {
4920 err = vlan_fill(skb, dev, filter_mask);
4921 if (err) {
4922 nla_nest_cancel(skb, br_afspec);
4923 goto nla_put_failure;
4924 }
4925 }
815cccbf
JF		 4926 nla_nest_end(skb, br_afspec);
4927
ae0be8de 4928 protinfo = nla_nest_start(skb, IFLA_PROTINFO);
2c3c031c
SF		 4929 if (!protinfo)
4930 goto nla_put_failure;
4931
4932 if (brport_nla_put_flag(skb, flags, mask,
4933 IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) ||
4934 brport_nla_put_flag(skb, flags, mask,
4935 IFLA_BRPORT_GUARD, BR_BPDU_GUARD) ||
4936 brport_nla_put_flag(skb, flags, mask,
4937 IFLA_BRPORT_FAST_LEAVE,
4938 BR_MULTICAST_FAST_LEAVE) ||
4939 brport_nla_put_flag(skb, flags, mask,
4940 IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) ||
4941 brport_nla_put_flag(skb, flags, mask,
4942 IFLA_BRPORT_LEARNING, BR_LEARNING) ||
4943 brport_nla_put_flag(skb, flags, mask,
4944 IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) ||
4945 brport_nla_put_flag(skb, flags, mask,
4946 IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) ||
4947 brport_nla_put_flag(skb, flags, mask,
583cb0b4
JW		 4948 IFLA_BRPORT_PROXYARP, BR_PROXYARP) ||
4949 brport_nla_put_flag(skb, flags, mask,
4950 IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD) ||
4951 brport_nla_put_flag(skb, flags, mask,
4952 IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD)) {
2c3c031c
SF		 4953 nla_nest_cancel(skb, protinfo);
4954 goto nla_put_failure;
4955 }
4956
4957 nla_nest_end(skb, protinfo);
4958
053c095a
JB		 4959 nlmsg_end(skb, nlh);
4960 return 0;
815cccbf
JF		 4961nla_put_failure:
4962 nlmsg_cancel(skb, nlh);
7d4f8d87 4963 return err ? err : -EMSGSIZE;
815cccbf 4964}
7d4f8d87 4965EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
815cccbf 4966
2d011be8
DA		 4967static int valid_bridge_getlink_req(const struct nlmsghdr *nlh,
4968 bool strict_check, u32 *filter_mask,
4969 struct netlink_ext_ack *extack)
4970{
4971 struct nlattr *tb[IFLA_MAX+1];
4972 int err, i;
4973
4974 if (strict_check) {
4975 struct ifinfomsg *ifm;
4976
4977 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
4978 NL_SET_ERR_MSG(extack, "Invalid header for bridge link dump");
4979 return -EINVAL;
4980 }
4981
4982 ifm = nlmsg_data(nlh);
4983 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
4984 ifm->ifi_change || ifm->ifi_index) {
4985 NL_SET_ERR_MSG(extack, "Invalid values in header for bridge link dump request");
4986 return -EINVAL;
4987 }
4988
8cb08174
JB		 4989 err = nlmsg_parse_deprecated_strict(nlh,
4990 sizeof(struct ifinfomsg),
4991 tb, IFLA_MAX, ifla_policy,
4992 extack);
2d011be8 4993 } else {
8cb08174
JB		 4994 err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4995 tb, IFLA_MAX, ifla_policy,
4996 extack);
2d011be8
DA		 4997 }
4998 if (err < 0)
4999 return err;
5000
5001 /* new attributes should only be added with strict checking */
5002 for (i = 0; i <= IFLA_MAX; ++i) {
5003 if (!tb[i])
5004 continue;
5005
5006 switch (i) {
5007 case IFLA_EXT_MASK:
5008 *filter_mask = nla_get_u32(tb[i]);
5009 break;
5010 default:
5011 if (strict_check) {
5012 NL_SET_ERR_MSG(extack, "Unsupported attribute in bridge link dump request");
5013 return -EINVAL;
5014 }
5015 }
5016 }
5017
5018 return 0;
5019}
5020
e5a55a89
JF		 5021static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb)
5022{
2d011be8 5023 const struct nlmsghdr *nlh = cb->nlh;
e5a55a89
JF		 5024 struct net *net = sock_net(skb->sk);
5025 struct net_device *dev;
5026 int idx = 0;
5027 u32 portid = NETLINK_CB(cb->skb).portid;
2d011be8 5028 u32 seq = nlh->nlmsg_seq;
6cbdceeb 5029 u32 filter_mask = 0;
d64f69b0 5030 int err;
6cbdceeb 5031
2d011be8
DA		 5032 err = valid_bridge_getlink_req(nlh, cb->strict_check, &filter_mask,
5033 cb->extack);
5034 if (err < 0 && cb->strict_check)
5035 return err;
e5a55a89
JF		 5036
5037 rcu_read_lock();
5038 for_each_netdev_rcu(net, dev) {
5039 const struct net_device_ops *ops = dev->netdev_ops;
898e5061 5040 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
e5a55a89 5041
898e5061 5042 if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
d64f69b0
RP		 5043 if (idx >= cb->args[0]) {
5044 err = br_dev->netdev_ops->ndo_bridge_getlink(
5045 skb, portid, seq, dev,
5046 filter_mask, NLM_F_MULTI);
f6c5775f
DA		 5047 if (err < 0 && err != -EOPNOTSUPP) {
5048 if (likely(skb->len))
5049 break;
5050
5051 goto out_err;
5052 }
d64f69b0 5053 }
25b1e679 5054 idx++;
e5a55a89
JF		 5055 }
5056
5057 if (ops->ndo_bridge_getlink) {
d64f69b0
RP		 5058 if (idx >= cb->args[0]) {
5059 err = ops->ndo_bridge_getlink(skb, portid,
5060 seq, dev,
5061 filter_mask,
5062 NLM_F_MULTI);
f6c5775f
DA		 5063 if (err < 0 && err != -EOPNOTSUPP) {
5064 if (likely(skb->len))
5065 break;
5066
5067 goto out_err;
5068 }
d64f69b0 5069 }
25b1e679 5070 idx++;
e5a55a89
JF		 5071 }
5072 }
f6c5775f
DA		 5073 err = skb->len;
5074out_err:
e5a55a89
JF		 5075 rcu_read_unlock();
5076 cb->args[0] = idx;
5077
f6c5775f 5078 return err;
e5a55a89
JF		 5079}
5080
2469ffd7
JF		 5081static inline size_t bridge_nlmsg_size(void)
5082{
5083 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
5084 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
5085 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
5086 + nla_total_size(sizeof(u32)) /* IFLA_MASTER */
5087 + nla_total_size(sizeof(u32)) /* IFLA_MTU */
5088 + nla_total_size(sizeof(u32)) /* IFLA_LINK */
5089 + nla_total_size(sizeof(u32)) /* IFLA_OPERSTATE */
5090 + nla_total_size(sizeof(u8)) /* IFLA_PROTINFO */
5091 + nla_total_size(sizeof(struct nlattr)) /* IFLA_AF_SPEC */
5092 + nla_total_size(sizeof(u16)) /* IFLA_BRIDGE_FLAGS */
5093 + nla_total_size(sizeof(u16)); /* IFLA_BRIDGE_MODE */
5094}
5095
02dba438 5096static int rtnl_bridge_notify(struct net_device *dev)
2469ffd7
JF		 5097{
5098 struct net *net = dev_net(dev);
2469ffd7
JF		 5099 struct sk_buff *skb;
5100 int err = -EOPNOTSUPP;
5101
02dba438
RP		 5102 if (!dev->netdev_ops->ndo_bridge_getlink)
5103 return 0;
5104
2469ffd7
JF		 5105 skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
5106 if (!skb) {
5107 err = -ENOMEM;
5108 goto errout;
5109 }
5110
46c264da 5111 err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
02dba438
RP		 5112 if (err < 0)
5113 goto errout;
2469ffd7 5114
d2e381c4
IS		 5115 /* Notification info is only filled for bridge ports, not the bridge
5116 * device itself. Therefore, a zero notification length is valid and
5117 * should not result in an error.
5118 */
5119 if (!skb->len)
59ccaaaa
RP		 5120 goto errout;
5121
2469ffd7
JF		 5122 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
5123 return 0;
5124errout:
5125 WARN_ON(err == -EMSGSIZE);
5126 kfree_skb(skb);
59ccaaaa
RP		 5127 if (err)
5128 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
2469ffd7
JF		 5129 return err;
5130}
5131
c21ef3e3
DA		 5132static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
5133 struct netlink_ext_ack *extack)
e5a55a89
JF		 5134{
5135 struct net *net = sock_net(skb->sk);
5136 struct ifinfomsg *ifm;
5137 struct net_device *dev;
2469ffd7
JF		 5138 struct nlattr *br_spec, *attr = NULL;
5139 int rem, err = -EOPNOTSUPP;
4de8b413 5140 u16 flags = 0;
c38e01b8 5141 bool have_flags = false;
e5a55a89
JF		 5142
5143 if (nlmsg_len(nlh) < sizeof(*ifm))
5144 return -EINVAL;
5145
5146 ifm = nlmsg_data(nlh);
5147 if (ifm->ifi_family != AF_BRIDGE)
5148 return -EPFNOSUPPORT;
5149
5150 dev = __dev_get_by_index(net, ifm->ifi_index);
5151 if (!dev) {
b88d12e4 5152 NL_SET_ERR_MSG(extack, "unknown ifindex");
e5a55a89
JF		 5153 return -ENODEV;
5154 }
5155
2469ffd7
JF		 5156 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5157 if (br_spec) {
5158 nla_for_each_nested(attr, br_spec, rem) {
d73ef2d6 5159 if (nla_type(attr) == IFLA_BRIDGE_FLAGS && !have_flags) {
6e8d1c55
TG		 5160 if (nla_len(attr) < sizeof(flags))
5161 return -EINVAL;
5162
c38e01b8 5163 have_flags = true;
2469ffd7 5164 flags = nla_get_u16(attr);
d73ef2d6
LM		 5165 }
5166
5167 if (nla_type(attr) == IFLA_BRIDGE_MODE) {
5168 if (nla_len(attr) < sizeof(u16))
5169 return -EINVAL;
2469ffd7
JF		 5170 }
5171 }
5172 }
5173
5174 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
898e5061
JP		 5175 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
5176
5177 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
2469ffd7
JF		 5178 err = -EOPNOTSUPP;
5179 goto out;
5180 }
5181
2fd527b7
PM		 5182 err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags,
5183 extack);
e5a55a89
JF		 5184 if (err)
5185 goto out;
2469ffd7
JF		 5186
5187 flags &= ~BRIDGE_FLAGS_MASTER;
e5a55a89
JF		 5188 }
5189
2469ffd7
JF		 5190 if ((flags & BRIDGE_FLAGS_SELF)) {
5191 if (!dev->netdev_ops->ndo_bridge_setlink)
5192 err = -EOPNOTSUPP;
5193 else
add511b3 5194 err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
2fd527b7
PM		 5195 flags,
5196 extack);
02dba438 5197 if (!err) {
2469ffd7 5198 flags &= ~BRIDGE_FLAGS_SELF;
02dba438
RP		 5199
5200 /* Generate event to notify upper layer of bridge
5201 * change
5202 */
5203 err = rtnl_bridge_notify(dev);
5204 }
2469ffd7 5205 }
e5a55a89 5206
c38e01b8 5207 if (have_flags)
2469ffd7 5208 memcpy(nla_data(attr), &flags, sizeof(flags));
e5a55a89
JF		 5209out:
5210 return err;
5211}
5212
c21ef3e3
DA		 5213static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
5214 struct netlink_ext_ack *extack)
407af329
VY		 5215{
5216 struct net *net = sock_net(skb->sk);
5217 struct ifinfomsg *ifm;
5218 struct net_device *dev;
5219 struct nlattr *br_spec, *attr = NULL;
5220 int rem, err = -EOPNOTSUPP;
4de8b413 5221 u16 flags = 0;
407af329
VY		 5222 bool have_flags = false;
5223
5224 if (nlmsg_len(nlh) < sizeof(*ifm))
5225 return -EINVAL;
5226
5227 ifm = nlmsg_data(nlh);
5228 if (ifm->ifi_family != AF_BRIDGE)
5229 return -EPFNOSUPPORT;
5230
5231 dev = __dev_get_by_index(net, ifm->ifi_index);
5232 if (!dev) {
b88d12e4 5233 NL_SET_ERR_MSG(extack, "unknown ifindex");
407af329
VY		 5234 return -ENODEV;
5235 }
5236
5237 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5238 if (br_spec) {
5239 nla_for_each_nested(attr, br_spec, rem) {
5240 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
6e8d1c55
TG		 5241 if (nla_len(attr) < sizeof(flags))
5242 return -EINVAL;
5243
407af329
VY		 5244 have_flags = true;
5245 flags = nla_get_u16(attr);
5246 break;
5247 }
5248 }
5249 }
5250
407af329
VY		 5251 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
5252 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
5253
5254 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) {
5255 err = -EOPNOTSUPP;
5256 goto out;
5257 }
5258
add511b3 5259 err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
407af329
VY		 5260 if (err)
5261 goto out;
5262
5263 flags &= ~BRIDGE_FLAGS_MASTER;
5264 }
5265
5266 if ((flags & BRIDGE_FLAGS_SELF)) {
5267 if (!dev->netdev_ops->ndo_bridge_dellink)
5268 err = -EOPNOTSUPP;
5269 else
add511b3
RP		 5270 err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
5271 flags);
407af329 5272
02dba438 5273 if (!err) {
407af329 5274 flags &= ~BRIDGE_FLAGS_SELF;
02dba438
RP		 5275
5276 /* Generate event to notify upper layer of bridge
5277 * change
5278 */
5279 err = rtnl_bridge_notify(dev);
5280 }
407af329
VY		 5281 }
5282
5283 if (have_flags)
5284 memcpy(nla_data(attr), &flags, sizeof(flags));
407af329
VY		 5285out:
5286 return err;
5287}
5288
e8872a25
NA		 5289static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
5290{
5291 return (mask & IFLA_STATS_FILTER_BIT(attrid)) &&
5292 (!idxattr || idxattr == attrid);
5293}
5294
f6e0fb81
PM		 5295static bool
5296rtnl_offload_xstats_have_ndo(const struct net_device *dev, int attr_id)
69ae6ad2 5297{
f6e0fb81
PM		 5298 return dev->netdev_ops &&
5299 dev->netdev_ops->ndo_has_offload_stats &&
5300 dev->netdev_ops->ndo_get_offload_stats &&
5301 dev->netdev_ops->ndo_has_offload_stats(dev, attr_id);
5302}
69ae6ad2 5303
f6e0fb81
PM		 5304static unsigned int
5305rtnl_offload_xstats_get_size_ndo(const struct net_device *dev, int attr_id)
5306{
5307 return rtnl_offload_xstats_have_ndo(dev, attr_id) ?
5308 sizeof(struct rtnl_link_stats64) : 0;
69ae6ad2
NF		 5309}
5310
f6e0fb81
PM		 5311static int
5312rtnl_offload_xstats_fill_ndo(struct net_device *dev, int attr_id,
5313 struct sk_buff *skb)
69ae6ad2 5314{
f6e0fb81 5315 unsigned int size = rtnl_offload_xstats_get_size_ndo(dev, attr_id);
69ae6ad2 5316 struct nlattr *attr = NULL;
69ae6ad2
NF		 5317 void *attr_data;
5318 int err;
5319
f6e0fb81 5320 if (!size)
69ae6ad2
NF		 5321 return -ENODATA;
5322
f6e0fb81
PM		 5323 attr = nla_reserve_64bit(skb, attr_id, size,
5324 IFLA_OFFLOAD_XSTATS_UNSPEC);
5325 if (!attr)
5326 return -EMSGSIZE;
69ae6ad2 5327
f6e0fb81
PM		 5328 attr_data = nla_data(attr);
5329 memset(attr_data, 0, size);
69ae6ad2 5330
f6e0fb81
PM		 5331 err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev, attr_data);
5332 if (err)
5333 return err;
69ae6ad2 5334
f6e0fb81
PM		 5335 return 0;
5336}
69ae6ad2 5337
0e7788fd
PM		 5338static unsigned int
5339rtnl_offload_xstats_get_size_stats(const struct net_device *dev,
5340 enum netdev_offload_xstats_type type)
5341{
5342 bool enabled = netdev_offload_xstats_enabled(dev, type);
5343
5344 return enabled ? sizeof(struct rtnl_hw_stats64) : 0;
5345}
5346
5347struct rtnl_offload_xstats_request_used {
5348 bool request;
5349 bool used;
5350};
5351
5352static int
5353rtnl_offload_xstats_get_stats(struct net_device *dev,
5354 enum netdev_offload_xstats_type type,
5355 struct rtnl_offload_xstats_request_used *ru,
5356 struct rtnl_hw_stats64 *stats,
5357 struct netlink_ext_ack *extack)
5358{
5359 bool request;
5360 bool used;
5361 int err;
5362
5363 request = netdev_offload_xstats_enabled(dev, type);
5364 if (!request) {
5365 used = false;
5366 goto out;
5367 }
5368
5369 err = netdev_offload_xstats_get(dev, type, stats, &used, extack);
5370 if (err)
5371 return err;
5372
5373out:
5374 if (ru) {
5375 ru->request = request;
5376 ru->used = used;
5377 }
5378 return 0;
5379}
5380
5381static int
5382rtnl_offload_xstats_fill_hw_s_info_one(struct sk_buff *skb, int attr_id,
5383 struct rtnl_offload_xstats_request_used *ru)
5384{
5385 struct nlattr *nest;
5386
5387 nest = nla_nest_start(skb, attr_id);
5388 if (!nest)
5389 return -EMSGSIZE;
5390
5391 if (nla_put_u8(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST, ru->request))
5392 goto nla_put_failure;
5393
5394 if (nla_put_u8(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED, ru->used))
5395 goto nla_put_failure;
5396
5397 nla_nest_end(skb, nest);
5398 return 0;
5399
5400nla_put_failure:
5401 nla_nest_cancel(skb, nest);
5402 return -EMSGSIZE;
5403}
5404
5405static int
5406rtnl_offload_xstats_fill_hw_s_info(struct sk_buff *skb, struct net_device *dev,
5407 struct netlink_ext_ack *extack)
5408{
5409 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5410 struct rtnl_offload_xstats_request_used ru_l3;
5411 struct nlattr *nest;
5412 int err;
5413
5414 err = rtnl_offload_xstats_get_stats(dev, t_l3, &ru_l3, NULL, extack);
5415 if (err)
5416 return err;
5417
5418 nest = nla_nest_start(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO);
5419 if (!nest)
5420 return -EMSGSIZE;
5421
5422 if (rtnl_offload_xstats_fill_hw_s_info_one(skb,
5423 IFLA_OFFLOAD_XSTATS_L3_STATS,
5424 &ru_l3))
5425 goto nla_put_failure;
5426
5427 nla_nest_end(skb, nest);
5428 return 0;
5429
5430nla_put_failure:
5431 nla_nest_cancel(skb, nest);
5432 return -EMSGSIZE;
5433}
5434
f6e0fb81 5435static int rtnl_offload_xstats_fill(struct sk_buff *skb, struct net_device *dev,
05415bcc
PM		 5436 int *prividx, u32 off_filter_mask,
5437 struct netlink_ext_ack *extack)
f6e0fb81 5438{
0e7788fd
PM		 5439 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5440 int attr_id_hw_s_info = IFLA_OFFLOAD_XSTATS_HW_S_INFO;
5441 int attr_id_l3_stats = IFLA_OFFLOAD_XSTATS_L3_STATS;
f6e0fb81
PM		 5442 int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT;
5443 bool have_data = false;
5444 int err;
5445
46efc97b
PM		 5446 if (*prividx <= attr_id_cpu_hit &&
5447 (off_filter_mask &
5448 IFLA_STATS_FILTER_BIT(attr_id_cpu_hit))) {
f6e0fb81
PM		 5449 err = rtnl_offload_xstats_fill_ndo(dev, attr_id_cpu_hit, skb);
5450 if (!err) {
5451 have_data = true;
5452 } else if (err != -ENODATA) {
5453 *prividx = attr_id_cpu_hit;
5454 return err;
5455 }
69ae6ad2
NF		 5456 }
5457
0e7788fd
PM		 5458 if (*prividx <= attr_id_hw_s_info &&
5459 (off_filter_mask & IFLA_STATS_FILTER_BIT(attr_id_hw_s_info))) {
5460 *prividx = attr_id_hw_s_info;
5461
5462 err = rtnl_offload_xstats_fill_hw_s_info(skb, dev, extack);
5463 if (err)
5464 return err;
5465
5466 have_data = true;
5467 *prividx = 0;
5468 }
5469
5470 if (*prividx <= attr_id_l3_stats &&
5471 (off_filter_mask & IFLA_STATS_FILTER_BIT(attr_id_l3_stats))) {
5472 unsigned int size_l3;
5473 struct nlattr *attr;
5474
5475 *prividx = attr_id_l3_stats;
5476
5477 size_l3 = rtnl_offload_xstats_get_size_stats(dev, t_l3);
23cfe941
PM		 5478 if (!size_l3)
5479 goto skip_l3_stats;
0e7788fd
PM		 5480 attr = nla_reserve_64bit(skb, attr_id_l3_stats, size_l3,
5481 IFLA_OFFLOAD_XSTATS_UNSPEC);
5482 if (!attr)
5483 return -EMSGSIZE;
5484
5485 err = rtnl_offload_xstats_get_stats(dev, t_l3, NULL,
5486 nla_data(attr), extack);
5487 if (err)
5488 return err;
5489
5490 have_data = true;
23cfe941 5491skip_l3_stats:
0e7788fd
PM		 5492 *prividx = 0;
5493 }
5494
f6e0fb81 5495 if (!have_data)
69ae6ad2
NF		 5496 return -ENODATA;
5497
5498 *prividx = 0;
5499 return 0;
69ae6ad2
NF		 5500}
5501
0e7788fd
PM		 5502static unsigned int
5503rtnl_offload_xstats_get_size_hw_s_info_one(const struct net_device *dev,
5504 enum netdev_offload_xstats_type type)
5505{
0e7788fd
PM		 5506 return nla_total_size(0) +
5507 /* IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST */
5508 nla_total_size(sizeof(u8)) +
5509 /* IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED */
503930f8 5510 nla_total_size(sizeof(u8)) +
0e7788fd
PM		 5511 0;
5512}
5513
5514static unsigned int
5515rtnl_offload_xstats_get_size_hw_s_info(const struct net_device *dev)
5516{
5517 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5518
5519 return nla_total_size(0) +
5520 /* IFLA_OFFLOAD_XSTATS_L3_STATS */
5521 rtnl_offload_xstats_get_size_hw_s_info_one(dev, t_l3) +
5522 0;
5523}
5524
46efc97b
PM		 5525static int rtnl_offload_xstats_get_size(const struct net_device *dev,
5526 u32 off_filter_mask)
69ae6ad2 5527{
0e7788fd 5528 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
f6e0fb81 5529 int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT;
69ae6ad2 5530 int nla_size = 0;
69ae6ad2
NF		 5531 int size;
5532
46efc97b
PM		 5533 if (off_filter_mask &
5534 IFLA_STATS_FILTER_BIT(attr_id_cpu_hit)) {
5535 size = rtnl_offload_xstats_get_size_ndo(dev, attr_id_cpu_hit);
5536 nla_size += nla_total_size_64bit(size);
5537 }
69ae6ad2 5538
0e7788fd
PM		 5539 if (off_filter_mask &
5540 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO))
5541 nla_size += rtnl_offload_xstats_get_size_hw_s_info(dev);
5542
5543 if (off_filter_mask &
5544 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_L3_STATS)) {
5545 size = rtnl_offload_xstats_get_size_stats(dev, t_l3);
5546 nla_size += nla_total_size_64bit(size);
5547 }
5548
69ae6ad2
NF		 5549 if (nla_size != 0)
5550 nla_size += nla_total_size(0);
5551
5552 return nla_size;
5553}
5554
46efc97b
PM		 5555struct rtnl_stats_dump_filters {
5556 /* mask[0] filters outer attributes. Then individual nests have their
5557 * filtering mask at the index of the nested attribute.
5558 */
5559 u32 mask[IFLA_STATS_MAX + 1];
5560};
5561
10c9ead9
RP		 5562static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
5563 int type, u32 pid, u32 seq, u32 change,
46efc97b
PM		 5564 unsigned int flags,
5565 const struct rtnl_stats_dump_filters *filters,
05415bcc
PM		 5566 int *idxattr, int *prividx,
5567 struct netlink_ext_ack *extack)
10c9ead9 5568{
46efc97b 5569 unsigned int filter_mask = filters->mask[0];
10c9ead9
RP		 5570 struct if_stats_msg *ifsm;
5571 struct nlmsghdr *nlh;
5572 struct nlattr *attr;
e8872a25 5573 int s_prividx = *prividx;
69ae6ad2 5574 int err;
10c9ead9
RP		 5575
5576 ASSERT_RTNL();
5577
5578 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
5579 if (!nlh)
5580 return -EMSGSIZE;
5581
5582 ifsm = nlmsg_data(nlh);
ce024f42
NA		 5583 ifsm->family = PF_UNSPEC;
5584 ifsm->pad1 = 0;
5585 ifsm->pad2 = 0;
10c9ead9
RP		 5586 ifsm->ifindex = dev->ifindex;
5587 ifsm->filter_mask = filter_mask;
5588
e8872a25 5589 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) {
10c9ead9 5590 struct rtnl_link_stats64 *sp;
10c9ead9 5591
58414d32
ND		 5592 attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64,
5593 sizeof(struct rtnl_link_stats64),
5594 IFLA_STATS_UNSPEC);
216e6906
PM		 5595 if (!attr) {
5596 err = -EMSGSIZE;
10c9ead9 5597 goto nla_put_failure;
216e6906 5598 }
10c9ead9
RP		 5599
5600 sp = nla_data(attr);
5601 dev_get_stats(dev, sp);
5602 }
5603
97a47fac
NA		 5604 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) {
5605 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
5606
5607 if (ops && ops->fill_linkxstats) {
97a47fac 5608 *idxattr = IFLA_STATS_LINK_XSTATS;
ae0be8de
MK		 5609 attr = nla_nest_start_noflag(skb,
5610 IFLA_STATS_LINK_XSTATS);
216e6906
PM		 5611 if (!attr) {
5612 err = -EMSGSIZE;
97a47fac 5613 goto nla_put_failure;
216e6906 5614 }
97a47fac 5615
80e73cc5
NA		 5616 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
5617 nla_nest_end(skb, attr);
5618 if (err)
5619 goto nla_put_failure;
5620 *idxattr = 0;
5621 }
5622 }
5623
5624 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE,
5625 *idxattr)) {
5626 const struct rtnl_link_ops *ops = NULL;
5627 const struct net_device *master;
5628
5629 master = netdev_master_upper_dev_get(dev);
5630 if (master)
5631 ops = master->rtnl_link_ops;
5632 if (ops && ops->fill_linkxstats) {
80e73cc5 5633 *idxattr = IFLA_STATS_LINK_XSTATS_SLAVE;
ae0be8de
MK		 5634 attr = nla_nest_start_noflag(skb,
5635 IFLA_STATS_LINK_XSTATS_SLAVE);
216e6906
PM		 5636 if (!attr) {
5637 err = -EMSGSIZE;
80e73cc5 5638 goto nla_put_failure;
216e6906 5639 }
80e73cc5
NA		 5640
5641 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
97a47fac
NA		 5642 nla_nest_end(skb, attr);
5643 if (err)
5644 goto nla_put_failure;
5645 *idxattr = 0;
5646 }
5647 }
5648
69ae6ad2
NF		 5649 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS,
5650 *idxattr)) {
46efc97b
PM		 5651 u32 off_filter_mask;
5652
5653 off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS];
69ae6ad2 5654 *idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS;
ae0be8de
MK		 5655 attr = nla_nest_start_noflag(skb,
5656 IFLA_STATS_LINK_OFFLOAD_XSTATS);
216e6906
PM		 5657 if (!attr) {
5658 err = -EMSGSIZE;
69ae6ad2 5659 goto nla_put_failure;
216e6906 5660 }
69ae6ad2 5661
46efc97b 5662 err = rtnl_offload_xstats_fill(skb, dev, prividx,
05415bcc 5663 off_filter_mask, extack);
69ae6ad2
NF		 5664 if (err == -ENODATA)
5665 nla_nest_cancel(skb, attr);
5666 else
5667 nla_nest_end(skb, attr);
5668
5669 if (err && err != -ENODATA)
5670 goto nla_put_failure;
5671 *idxattr = 0;
5672 }
5673
aefb4d4a
RS		 5674 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) {
5675 struct rtnl_af_ops *af_ops;
5676
5677 *idxattr = IFLA_STATS_AF_SPEC;
ae0be8de 5678 attr = nla_nest_start_noflag(skb, IFLA_STATS_AF_SPEC);
216e6906
PM		 5679 if (!attr) {
5680 err = -EMSGSIZE;
aefb4d4a 5681 goto nla_put_failure;
216e6906 5682 }
aefb4d4a 5683
5fa85a09
FW		 5684 rcu_read_lock();
5685 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
aefb4d4a
RS		 5686 if (af_ops->fill_stats_af) {
5687 struct nlattr *af;
aefb4d4a 5688
ae0be8de
MK		 5689 af = nla_nest_start_noflag(skb,
5690 af_ops->family);
5fa85a09
FW		 5691 if (!af) {
5692 rcu_read_unlock();
57d29a29 5693 err = -EMSGSIZE;
aefb4d4a 5694 goto nla_put_failure;
5fa85a09 5695 }
aefb4d4a
RS		 5696 err = af_ops->fill_stats_af(skb, dev);
5697
5fa85a09 5698 if (err == -ENODATA) {
aefb4d4a 5699 nla_nest_cancel(skb, af);
5fa85a09
FW		 5700 } else if (err < 0) {
5701 rcu_read_unlock();
aefb4d4a 5702 goto nla_put_failure;
5fa85a09 5703 }
aefb4d4a
RS		 5704
5705 nla_nest_end(skb, af);
5706 }
5707 }
5fa85a09 5708 rcu_read_unlock();
aefb4d4a
RS		 5709
5710 nla_nest_end(skb, attr);
5711
5712 *idxattr = 0;
5713 }
5714
10c9ead9
RP		 5715 nlmsg_end(skb, nlh);
5716
5717 return 0;
5718
5719nla_put_failure:
e8872a25
NA		 5720 /* not a multi message or no progress mean a real error */
5721 if (!(flags & NLM_F_MULTI) || s_prividx == *prividx)
5722 nlmsg_cancel(skb, nlh);
5723 else
5724 nlmsg_end(skb, nlh);
10c9ead9 5725
216e6906 5726 return err;
10c9ead9
RP		 5727}
5728
10c9ead9 5729static size_t if_nlmsg_stats_size(const struct net_device *dev,
46efc97b 5730 const struct rtnl_stats_dump_filters *filters)
10c9ead9 5731{
d3436799 5732 size_t size = NLMSG_ALIGN(sizeof(struct if_stats_msg));
46efc97b 5733 unsigned int filter_mask = filters->mask[0];
10c9ead9 5734
e8872a25 5735 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0))
10c9ead9
RP		 5736 size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
5737
97a47fac
NA		 5738 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) {
5739 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
80e73cc5 5740 int attr = IFLA_STATS_LINK_XSTATS;
97a47fac
NA		 5741
5742 if (ops && ops->get_linkxstats_size) {
80e73cc5
NA		 5743 size += nla_total_size(ops->get_linkxstats_size(dev,
5744 attr));
97a47fac
NA		 5745 /* for IFLA_STATS_LINK_XSTATS */
5746 size += nla_total_size(0);
5747 }
5748 }
5749
80e73cc5
NA		 5750 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) {
5751 struct net_device *_dev = (struct net_device *)dev;
5752 const struct rtnl_link_ops *ops = NULL;
5753 const struct net_device *master;
5754
5755 /* netdev_master_upper_dev_get can't take const */
5756 master = netdev_master_upper_dev_get(_dev);
5757 if (master)
5758 ops = master->rtnl_link_ops;
5759 if (ops && ops->get_linkxstats_size) {
5760 int attr = IFLA_STATS_LINK_XSTATS_SLAVE;
5761
5762 size += nla_total_size(ops->get_linkxstats_size(dev,
5763 attr));
5764 /* for IFLA_STATS_LINK_XSTATS_SLAVE */
5765 size += nla_total_size(0);
5766 }
5767 }
5768
46efc97b
PM		 5769 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0)) {
5770 u32 off_filter_mask;
5771
5772 off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS];
5773 size += rtnl_offload_xstats_get_size(dev, off_filter_mask);
5774 }
69ae6ad2 5775
aefb4d4a
RS		 5776 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) {
5777 struct rtnl_af_ops *af_ops;
5778
5779 /* for IFLA_STATS_AF_SPEC */
5780 size += nla_total_size(0);
5781
5fa85a09
FW		 5782 rcu_read_lock();
5783 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
aefb4d4a
RS		 5784 if (af_ops->get_stats_af_size) {
5785 size += nla_total_size(
5786 af_ops->get_stats_af_size(dev));
5787
5788 /* for AF_* */
5789 size += nla_total_size(0);
5790 }
5791 }
5fa85a09 5792 rcu_read_unlock();
aefb4d4a
RS		 5793 }
5794
10c9ead9
RP		 5795 return size;
5796}
5797
46efc97b
PM		 5798#define RTNL_STATS_OFFLOAD_XSTATS_VALID ((1 << __IFLA_OFFLOAD_XSTATS_MAX) - 1)
5799
5800static const struct nla_policy
5801rtnl_stats_get_policy_filters[IFLA_STATS_MAX + 1] = {
5802 [IFLA_STATS_LINK_OFFLOAD_XSTATS] =
5803 NLA_POLICY_MASK(NLA_U32, RTNL_STATS_OFFLOAD_XSTATS_VALID),
5804};
5805
5806static const struct nla_policy
5807rtnl_stats_get_policy[IFLA_STATS_GETSET_MAX + 1] = {
5808 [IFLA_STATS_GET_FILTERS] =
5809 NLA_POLICY_NESTED(rtnl_stats_get_policy_filters),
5810};
5811
03ba3566
PM		 5812static const struct nla_policy
5813ifla_stats_set_policy[IFLA_STATS_GETSET_MAX + 1] = {
5fd0b838 5814 [IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS] = NLA_POLICY_MAX(NLA_U8, 1),
03ba3566
PM		 5815};
5816
46efc97b
PM		 5817static int rtnl_stats_get_parse_filters(struct nlattr *ifla_filters,
5818 struct rtnl_stats_dump_filters *filters,
5819 struct netlink_ext_ack *extack)
5820{
5821 struct nlattr *tb[IFLA_STATS_MAX + 1];
5822 int err;
5823 int at;
5824
5825 err = nla_parse_nested(tb, IFLA_STATS_MAX, ifla_filters,
5826 rtnl_stats_get_policy_filters, extack);
5827 if (err < 0)
5828 return err;
5829
5830 for (at = 1; at <= IFLA_STATS_MAX; at++) {
5831 if (tb[at]) {
5832 if (!(filters->mask[0] & IFLA_STATS_FILTER_BIT(at))) {
5833 NL_SET_ERR_MSG(extack, "Filtered attribute not enabled in filter_mask");
5834 return -EINVAL;
5835 }
5836 filters->mask[at] = nla_get_u32(tb[at]);
5837 }
5838 }
5839
5840 return 0;
5841}
5842
5843static int rtnl_stats_get_parse(const struct nlmsghdr *nlh,
5844 u32 filter_mask,
5845 struct rtnl_stats_dump_filters *filters,
5846 struct netlink_ext_ack *extack)
5847{
5848 struct nlattr *tb[IFLA_STATS_GETSET_MAX + 1];
5849 int err;
5850 int i;
5851
5852 filters->mask[0] = filter_mask;
5853 for (i = 1; i < ARRAY_SIZE(filters->mask); i++)
5854 filters->mask[i] = -1U;
5855
5856 err = nlmsg_parse(nlh, sizeof(struct if_stats_msg), tb,
5857 IFLA_STATS_GETSET_MAX, rtnl_stats_get_policy, extack);
5858 if (err < 0)
5859 return err;
5860
5861 if (tb[IFLA_STATS_GET_FILTERS]) {
5862 err = rtnl_stats_get_parse_filters(tb[IFLA_STATS_GET_FILTERS],
5863 filters, extack);
5864 if (err)
5865 return err;
5866 }
5867
5868 return 0;
5869}
5870
51bc860d
JK		 5871static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check,
5872 bool is_dump, struct netlink_ext_ack *extack)
5873{
5874 struct if_stats_msg *ifsm;
5875
69f23a09 5876 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifsm))) {
51bc860d
JK		 5877 NL_SET_ERR_MSG(extack, "Invalid header for stats dump");
5878 return -EINVAL;
5879 }
5880
5881 if (!strict_check)
5882 return 0;
5883
5884 ifsm = nlmsg_data(nlh);
5885
5886 /* only requests using strict checks can pass data to influence
5887 * the dump. The legacy exception is filter_mask.
5888 */
5889 if (ifsm->pad1 || ifsm->pad2 || (is_dump && ifsm->ifindex)) {
5890 NL_SET_ERR_MSG(extack, "Invalid values in header for stats dump request");
5891 return -EINVAL;
5892 }
6300acb2
JK		 5893 if (ifsm->filter_mask >= IFLA_STATS_FILTER_BIT(IFLA_STATS_MAX + 1)) {
5894 NL_SET_ERR_MSG(extack, "Invalid stats requested through filter mask");
5895 return -EINVAL;
5896 }
51bc860d
JK		 5897
5898 return 0;
5899}
5900
c21ef3e3
DA		 5901static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh,
5902 struct netlink_ext_ack *extack)
10c9ead9 5903{
46efc97b 5904 struct rtnl_stats_dump_filters filters;
10c9ead9 5905 struct net *net = sock_net(skb->sk);
10c9ead9 5906 struct net_device *dev = NULL;
e8872a25
NA		 5907 int idxattr = 0, prividx = 0;
5908 struct if_stats_msg *ifsm;
10c9ead9 5909 struct sk_buff *nskb;
10c9ead9
RP		 5910 int err;
5911
51bc860d
JK		 5912 err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
5913 false, extack);
5914 if (err)
5915 return err;
4775cc1f 5916
10c9ead9
RP		 5917 ifsm = nlmsg_data(nlh);
5918 if (ifsm->ifindex > 0)
5919 dev = __dev_get_by_index(net, ifsm->ifindex);
5920 else
5921 return -EINVAL;
5922
5923 if (!dev)
5924 return -ENODEV;
5925
46efc97b 5926 if (!ifsm->filter_mask) {
22b67d17 5927 NL_SET_ERR_MSG(extack, "Filter mask must be set for stats get");
10c9ead9 5928 return -EINVAL;
22b67d17 5929 }
10c9ead9 5930
46efc97b
PM		 5931 err = rtnl_stats_get_parse(nlh, ifsm->filter_mask, &filters, extack);
5932 if (err)
5933 return err;
5934
5935 nskb = nlmsg_new(if_nlmsg_stats_size(dev, &filters), GFP_KERNEL);
10c9ead9
RP		 5936 if (!nskb)
5937 return -ENOBUFS;
5938
5939 err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
5940 NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
05415bcc 5941 0, &filters, &idxattr, &prividx, extack);
10c9ead9
RP		 5942 if (err < 0) {
5943 /* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
5944 WARN_ON(err == -EMSGSIZE);
5945 kfree_skb(nskb);
5946 } else {
5947 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
5948 }
5949
5950 return err;
5951}
5952
5953static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
5954{
841891ec 5955 struct netlink_ext_ack *extack = cb->extack;
e8872a25 5956 int h, s_h, err, s_idx, s_idxattr, s_prividx;
46efc97b 5957 struct rtnl_stats_dump_filters filters;
10c9ead9 5958 struct net *net = sock_net(skb->sk);
e8872a25 5959 unsigned int flags = NLM_F_MULTI;
10c9ead9 5960 struct if_stats_msg *ifsm;
10c9ead9 5961 struct hlist_head *head;
e8872a25 5962 struct net_device *dev;
e8872a25 5963 int idx = 0;
10c9ead9
RP		 5964
5965 s_h = cb->args[0];
5966 s_idx = cb->args[1];
e8872a25
NA		 5967 s_idxattr = cb->args[2];
5968 s_prividx = cb->args[3];
10c9ead9
RP		 5969
5970 cb->seq = net->dev_base_seq;
5971
51bc860d
JK		 5972 err = rtnl_valid_stats_req(cb->nlh, cb->strict_check, true, extack);
5973 if (err)
5974 return err;
4775cc1f 5975
10c9ead9 5976 ifsm = nlmsg_data(cb->nlh);
46efc97b 5977 if (!ifsm->filter_mask) {
841891ec 5978 NL_SET_ERR_MSG(extack, "Filter mask must be set for stats dump");
10c9ead9 5979 return -EINVAL;
841891ec 5980 }
10c9ead9 5981
46efc97b
PM		 5982 err = rtnl_stats_get_parse(cb->nlh, ifsm->filter_mask, &filters,
5983 extack);
5984 if (err)
5985 return err;
5986
10c9ead9
RP		 5987 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5988 idx = 0;
5989 head = &net->dev_index_head[h];
5990 hlist_for_each_entry(dev, head, index_hlist) {
5991 if (idx < s_idx)
5992 goto cont;
5993 err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
5994 NETLINK_CB(cb->skb).portid,
5995 cb->nlh->nlmsg_seq, 0,
46efc97b 5996 flags, &filters,
05415bcc
PM		 5997 &s_idxattr, &s_prividx,
5998 extack);
10c9ead9
RP		 5999 /* If we ran out of room on the first message,
6000 * we're in trouble
6001 */
6002 WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
6003
6004 if (err < 0)
6005 goto out;
e8872a25
NA		 6006 s_prividx = 0;
6007 s_idxattr = 0;
10c9ead9
RP		 6008 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
6009cont:
6010 idx++;
6011 }
6012 }
6013out:
e8872a25
NA		 6014 cb->args[3] = s_prividx;
6015 cb->args[2] = s_idxattr;
10c9ead9
RP		 6016 cb->args[1] = idx;
6017 cb->args[0] = h;
6018
6019 return skb->len;
6020}
6021
5fd0b838
PM		 6022void rtnl_offload_xstats_notify(struct net_device *dev)
6023{
6024 struct rtnl_stats_dump_filters response_filters = {};
6025 struct net *net = dev_net(dev);
6026 int idxattr = 0, prividx = 0;
6027 struct sk_buff *skb;
6028 int err = -ENOBUFS;
6029
6030 ASSERT_RTNL();
6031
6032 response_filters.mask[0] |=
6033 IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_OFFLOAD_XSTATS);
6034 response_filters.mask[IFLA_STATS_LINK_OFFLOAD_XSTATS] |=
6035 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO);
6036
6037 skb = nlmsg_new(if_nlmsg_stats_size(dev, &response_filters),
6038 GFP_KERNEL);
6039 if (!skb)
6040 goto errout;
6041
6042 err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS, 0, 0, 0, 0,
6043 &response_filters, &idxattr, &prividx, NULL);
6044 if (err < 0) {
6045 kfree_skb(skb);
6046 goto errout;
6047 }
6048
6049 rtnl_notify(skb, net, 0, RTNLGRP_STATS, NULL, GFP_KERNEL);
6050 return;
6051
6052errout:
6053 rtnl_set_sk_err(net, RTNLGRP_STATS, err);
6054}
6055EXPORT_SYMBOL(rtnl_offload_xstats_notify);
6056
03ba3566
PM		 6057static int rtnl_stats_set(struct sk_buff *skb, struct nlmsghdr *nlh,
6058 struct netlink_ext_ack *extack)
6059{
5fd0b838 6060 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
03ba3566
PM		 6061 struct rtnl_stats_dump_filters response_filters = {};
6062 struct nlattr *tb[IFLA_STATS_GETSET_MAX + 1];
6063 struct net *net = sock_net(skb->sk);
6064 struct net_device *dev = NULL;
03ba3566 6065 struct if_stats_msg *ifsm;
5fd0b838 6066 bool notify = false;
03ba3566
PM		 6067 int err;
6068
6069 err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
6070 false, extack);
6071 if (err)
6072 return err;
6073
6074 ifsm = nlmsg_data(nlh);
6075 if (ifsm->family != AF_UNSPEC) {
6076 NL_SET_ERR_MSG(extack, "Address family should be AF_UNSPEC");
6077 return -EINVAL;
6078 }
6079
6080 if (ifsm->ifindex > 0)
6081 dev = __dev_get_by_index(net, ifsm->ifindex);
6082 else
6083 return -EINVAL;
6084
6085 if (!dev)
6086 return -ENODEV;
6087
6088 if (ifsm->filter_mask) {
6089 NL_SET_ERR_MSG(extack, "Filter mask must be 0 for stats set");
6090 return -EINVAL;
6091 }
6092
6093 err = nlmsg_parse(nlh, sizeof(*ifsm), tb, IFLA_STATS_GETSET_MAX,
6094 ifla_stats_set_policy, extack);
6095 if (err < 0)
6096 return err;
6097
5fd0b838
PM		 6098 if (tb[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS]) {
6099 u8 req = nla_get_u8(tb[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS]);
03ba3566 6100
5fd0b838
PM		 6101 if (req)
6102 err = netdev_offload_xstats_enable(dev, t_l3, extack);
6103 else
6104 err = netdev_offload_xstats_disable(dev, t_l3);
6105
6106 if (!err)
6107 notify = true;
6108 else if (err != -EALREADY)
6109 return err;
6110
6111 response_filters.mask[0] |=
6112 IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_OFFLOAD_XSTATS);
6113 response_filters.mask[IFLA_STATS_LINK_OFFLOAD_XSTATS] |=
6114 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO);
03ba3566
PM		 6115 }
6116
5fd0b838
PM		 6117 if (notify)
6118 rtnl_offload_xstats_notify(dev);
6119
6120 return 0;
03ba3566
PM		 6121}
6122
cc7f5022
IS		 6123static int rtnl_mdb_valid_dump_req(const struct nlmsghdr *nlh,
6124 struct netlink_ext_ack *extack)
6125{
6126 struct br_port_msg *bpm;
6127
6128 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*bpm))) {
6129 NL_SET_ERR_MSG(extack, "Invalid header for mdb dump request");
6130 return -EINVAL;
6131 }
6132
6133 bpm = nlmsg_data(nlh);
6134 if (bpm->ifindex) {
6135 NL_SET_ERR_MSG(extack, "Filtering by device index is not supported for mdb dump request");
6136 return -EINVAL;
6137 }
6138 if (nlmsg_attrlen(nlh, sizeof(*bpm))) {
6139 NL_SET_ERR_MSG(extack, "Invalid data after header in mdb dump request");
6140 return -EINVAL;
6141 }
6142
6143 return 0;
6144}
6145
6146struct rtnl_mdb_dump_ctx {
6147 long idx;
6148};
6149
6150static int rtnl_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
6151{
6152 struct rtnl_mdb_dump_ctx *ctx = (void *)cb->ctx;
6153 struct net *net = sock_net(skb->sk);
6154 struct net_device *dev;
6155 int idx, s_idx;
6156 int err;
6157
6158 NL_ASSERT_DUMP_CTX_FITS(struct rtnl_mdb_dump_ctx);
6159
6160 if (cb->strict_check) {
6161 err = rtnl_mdb_valid_dump_req(cb->nlh, cb->extack);
6162 if (err)
6163 return err;
6164 }
6165
6166 s_idx = ctx->idx;
6167 idx = 0;
6168
6169 for_each_netdev(net, dev) {
6170 if (idx < s_idx)
6171 goto skip;
6172 if (!dev->netdev_ops->ndo_mdb_dump)
6173 goto skip;
6174
6175 err = dev->netdev_ops->ndo_mdb_dump(dev, skb, cb);
6176 if (err == -EMSGSIZE)
6177 goto out;
6178 /* Moving on to next device, reset markers and sequence
6179 * counters since they are all maintained per-device.
6180 */
6181 memset(cb->ctx, 0, sizeof(cb->ctx));
6182 cb->prev_seq = 0;
6183 cb->seq = 0;
6184skip:
6185 idx++;
6186 }
6187
6188out:
6189 ctx->idx = idx;
6190 return skb->len;
6191}
6192
6193static int rtnl_validate_mdb_entry(const struct nlattr *attr,
6194 struct netlink_ext_ack *extack)
6195{
6196 struct br_mdb_entry *entry = nla_data(attr);
6197
6198 if (nla_len(attr) != sizeof(struct br_mdb_entry)) {
6199 NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length");
6200 return -EINVAL;
6201 }
6202
6203 if (entry->ifindex == 0) {
6204 NL_SET_ERR_MSG(extack, "Zero entry ifindex is not allowed");
6205 return -EINVAL;
6206 }
6207
6208 if (entry->addr.proto == htons(ETH_P_IP)) {
da654c80
IS		 6209 if (!ipv4_is_multicast(entry->addr.u.ip4) &&
6210 !ipv4_is_zeronet(entry->addr.u.ip4)) {
6211 NL_SET_ERR_MSG(extack, "IPv4 entry group address is not multicast or 0.0.0.0");
cc7f5022
IS		 6212 return -EINVAL;
6213 }
6214 if (ipv4_is_local_multicast(entry->addr.u.ip4)) {
6215 NL_SET_ERR_MSG(extack, "IPv4 entry group address is local multicast");
6216 return -EINVAL;
6217 }
6218#if IS_ENABLED(CONFIG_IPV6)
6219 } else if (entry->addr.proto == htons(ETH_P_IPV6)) {
6220 if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6)) {
6221 NL_SET_ERR_MSG(extack, "IPv6 entry group address is link-local all nodes");
6222 return -EINVAL;
6223 }
6224#endif
6225 } else if (entry->addr.proto == 0) {
6226 /* L2 mdb */
6227 if (!is_multicast_ether_addr(entry->addr.u.mac_addr)) {
6228 NL_SET_ERR_MSG(extack, "L2 entry group is not multicast");
6229 return -EINVAL;
6230 }
6231 } else {
6232 NL_SET_ERR_MSG(extack, "Unknown entry protocol");
6233 return -EINVAL;
6234 }
6235
6236 if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) {
6237 NL_SET_ERR_MSG(extack, "Unknown entry state");
6238 return -EINVAL;
6239 }
6240 if (entry->vid >= VLAN_VID_MASK) {
6241 NL_SET_ERR_MSG(extack, "Invalid entry VLAN id");
6242 return -EINVAL;
6243 }
6244
6245 return 0;
6246}
6247
6248static const struct nla_policy mdba_policy[MDBA_SET_ENTRY_MAX + 1] = {
6249 [MDBA_SET_ENTRY_UNSPEC] = { .strict_start_type = MDBA_SET_ENTRY_ATTRS + 1 },
6250 [MDBA_SET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
6251 rtnl_validate_mdb_entry,
6252 sizeof(struct br_mdb_entry)),
6253 [MDBA_SET_ENTRY_ATTRS] = { .type = NLA_NESTED },
6254};
6255
6256static int rtnl_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
6257 struct netlink_ext_ack *extack)
6258{
6259 struct nlattr *tb[MDBA_SET_ENTRY_MAX + 1];
6260 struct net *net = sock_net(skb->sk);
6261 struct br_port_msg *bpm;
6262 struct net_device *dev;
6263 int err;
6264
6265 err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb,
6266 MDBA_SET_ENTRY_MAX, mdba_policy, extack);
6267 if (err)
6268 return err;
6269
6270 bpm = nlmsg_data(nlh);
6271 if (!bpm->ifindex) {
6272 NL_SET_ERR_MSG(extack, "Invalid ifindex");
6273 return -EINVAL;
6274 }
6275
6276 dev = __dev_get_by_index(net, bpm->ifindex);
6277 if (!dev) {
6278 NL_SET_ERR_MSG(extack, "Device doesn't exist");
6279 return -ENODEV;
6280 }
6281
6282 if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY)) {
6283 NL_SET_ERR_MSG(extack, "Missing MDBA_SET_ENTRY attribute");
6284 return -EINVAL;
6285 }
6286
6287 if (!dev->netdev_ops->ndo_mdb_add) {
6288 NL_SET_ERR_MSG(extack, "Device does not support MDB operations");
6289 return -EOPNOTSUPP;
6290 }
6291
6292 return dev->netdev_ops->ndo_mdb_add(dev, tb, nlh->nlmsg_flags, extack);
6293}
6294
6295static int rtnl_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
6296 struct netlink_ext_ack *extack)
6297{
6298 struct nlattr *tb[MDBA_SET_ENTRY_MAX + 1];
6299 struct net *net = sock_net(skb->sk);
6300 struct br_port_msg *bpm;
6301 struct net_device *dev;
6302 int err;
6303
6304 err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb,
6305 MDBA_SET_ENTRY_MAX, mdba_policy, extack);
6306 if (err)
6307 return err;
6308
6309 bpm = nlmsg_data(nlh);
6310 if (!bpm->ifindex) {
6311 NL_SET_ERR_MSG(extack, "Invalid ifindex");
6312 return -EINVAL;
6313 }
6314
6315 dev = __dev_get_by_index(net, bpm->ifindex);
6316 if (!dev) {
6317 NL_SET_ERR_MSG(extack, "Device doesn't exist");
6318 return -ENODEV;
6319 }
6320
6321 if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY)) {
6322 NL_SET_ERR_MSG(extack, "Missing MDBA_SET_ENTRY attribute");
6323 return -EINVAL;
6324 }
6325
6326 if (!dev->netdev_ops->ndo_mdb_del) {
6327 NL_SET_ERR_MSG(extack, "Device does not support MDB operations");
6328 return -EOPNOTSUPP;
6329 }
6330
6331 return dev->netdev_ops->ndo_mdb_del(dev, tb, extack);
6332}
6333
1da177e4
LT		 6334/* Process one rtnetlink message. */
6335
2d4bc933
JB		 6336static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
6337 struct netlink_ext_ack *extack)
1da177e4 6338{
3b1e0a65 6339 struct net *net = sock_net(skb->sk);
addf9b90 6340 struct rtnl_link *link;
12dc5c2c 6341 enum rtnl_kinds kind;
e4202511 6342 struct module *owner;
6853dd48 6343 int err = -EOPNOTSUPP;
e2849863 6344 rtnl_doit_func doit;
62256f98 6345 unsigned int flags;
1da177e4
LT		 6346 int family;
6347 int type;
1da177e4 6348
1da177e4 6349 type = nlh->nlmsg_type;
1da177e4 6350 if (type > RTM_MAX)
038890fe 6351 return -EOPNOTSUPP;
1da177e4
LT		 6352
6353 type -= RTM_BASE;
6354
6355 /* All the messages must have at least 1 byte length */
573ce260 6356 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
1da177e4
LT		 6357 return 0;
6358
573ce260 6359 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
2e9ea3e3 6360 kind = rtnl_msgtype_kind(type);
1da177e4 6361
12dc5c2c 6362 if (kind != RTNL_KIND_GET && !netlink_net_capable(skb, CAP_NET_ADMIN))
1d00a4eb 6363 return -EPERM;
1da177e4 6364
6853dd48 6365 rcu_read_lock();
12dc5c2c 6366 if (kind == RTNL_KIND_GET && (nlh->nlmsg_flags & NLM_F_DUMP)) {
97c53cac 6367 struct sock *rtnl;
e2849863 6368 rtnl_dumpit_func dumpit;
ebfe3c51 6369 u32 min_dump_alloc = 0;
1da177e4 6370
addf9b90
FW		 6371 link = rtnl_get_link(family, type);
6372 if (!link || !link->dumpit) {
6853dd48 6373 family = PF_UNSPEC;
addf9b90
FW		 6374 link = rtnl_get_link(family, type);
6375 if (!link || !link->dumpit)
6853dd48
FW		 6376 goto err_unlock;
6377 }
e4202511 6378 owner = link->owner;
addf9b90 6379 dumpit = link->dumpit;
e1fa6d21 6380
5c2bb9b6 6381 if (type == RTM_GETLINK - RTM_BASE)
e1fa6d21 6382 min_dump_alloc = rtnl_calcit(skb, nlh);
9ac4a169 6383
e4202511
FW		 6384 err = 0;
6385 /* need to do this before rcu_read_unlock() */
6386 if (!try_module_get(owner))
6387 err = -EPROTONOSUPPORT;
6388
6853dd48
FW		 6389 rcu_read_unlock();
6390
97c53cac 6391 rtnl = net->rtnl;
e4202511 6392 if (err == 0) {
80d326fa
PNA		 6393 struct netlink_dump_control c = {
6394 .dump = dumpit,
6395 .min_dump_alloc = min_dump_alloc,
e4202511 6396 .module = owner,
80d326fa
PNA		 6397 };
6398 err = netlink_dump_start(rtnl, skb, nlh, &c);
e4202511
FW		 6399 /* netlink_dump_start() will keep a reference on
6400 * module if dump is still in progress.
6401 */
6402 module_put(owner);
80d326fa 6403 }
2907c35f 6404 return err;
1da177e4
LT		 6405 }
6406
addf9b90
FW		 6407 link = rtnl_get_link(family, type);
6408 if (!link || !link->doit) {
8caa38b5 6409 family = PF_UNSPEC;
addf9b90
FW		 6410 link = rtnl_get_link(PF_UNSPEC, type);
6411 if (!link || !link->doit)
6412 goto out_unlock;
8caa38b5
FW		 6413 }
6414
e4202511
FW		 6415 owner = link->owner;
6416 if (!try_module_get(owner)) {
6417 err = -EPROTONOSUPPORT;
6418 goto out_unlock;
6419 }
6420
addf9b90 6421 flags = link->flags;
a6cec0bc
NA		 6422 if (kind == RTNL_KIND_DEL && (nlh->nlmsg_flags & NLM_F_BULK) &&
6423 !(flags & RTNL_FLAG_BULK_DEL_SUPPORTED)) {
6424 NL_SET_ERR_MSG(extack, "Bulk delete is not supported");
5b22f627 6425 module_put(owner);
a6cec0bc
NA		 6426 goto err_unlock;
6427 }
6428
62256f98 6429 if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
addf9b90 6430 doit = link->doit;
62256f98
FW		 6431 rcu_read_unlock();
6432 if (doit)
6433 err = doit(skb, nlh, extack);
e4202511 6434 module_put(owner);
62256f98
FW		 6435 return err;
6436 }
6853dd48 6437 rcu_read_unlock();
1da177e4 6438
6853dd48 6439 rtnl_lock();
addf9b90
FW		 6440 link = rtnl_get_link(family, type);
6441 if (link && link->doit)
6442 err = link->doit(skb, nlh, extack);
0cc09020 6443 rtnl_unlock();
addf9b90 6444
e4202511
FW		 6445 module_put(owner);
6446
addf9b90
FW		 6447 return err;
6448
6449out_unlock:
6450 rcu_read_unlock();
0cc09020
FW		 6451 return err;
6452
6453err_unlock:
6853dd48 6454 rcu_read_unlock();
0cc09020 6455 return -EOPNOTSUPP;
1da177e4
LT		 6456}
6457
cd40b7d3 6458static void rtnetlink_rcv(struct sk_buff *skb)
1da177e4 6459{
cd40b7d3 6460 netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
1da177e4
LT		 6461}
6462
5f729eaa
JG		 6463static int rtnetlink_bind(struct net *net, int group)
6464{
6465 switch (group) {
6466 case RTNLGRP_IPV4_MROUTE_R:
6467 case RTNLGRP_IPV6_MROUTE_R:
6468 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
6469 return -EPERM;
6470 break;
6471 }
6472 return 0;
6473}
6474
1da177e4
LT		 6475static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
6476{
351638e7 6477 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
e9dc8653 6478
1da177e4 6479 switch (event) {
5138e86f 6480 case NETDEV_REBOOT:
8a212589 6481 case NETDEV_CHANGEMTU:
3753654e 6482 case NETDEV_CHANGEADDR:
5138e86f
VY		 6483 case NETDEV_CHANGENAME:
6484 case NETDEV_FEAT_CHANGE:
6485 case NETDEV_BONDING_FAILOVER:
e6e66594 6486 case NETDEV_POST_TYPE_CHANGE:
5138e86f 6487 case NETDEV_NOTIFY_PEERS:
dc709f37 6488 case NETDEV_CHANGEUPPER:
5138e86f 6489 case NETDEV_RESEND_IGMP:
5138e86f 6490 case NETDEV_CHANGEINFODATA:
eeda3fb9 6491 case NETDEV_CHANGELOWERSTATE:
ebdcf045 6492 case NETDEV_CHANGE_TX_QUEUE_LEN:
3d3ea5af 6493 rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event),
1d997f10 6494 GFP_KERNEL, NULL, 0, 0, NULL);
1da177e4
LT		 6495 break;
6496 default:
1da177e4
LT		 6497 break;
6498 }
6499 return NOTIFY_DONE;
6500}
6501
6502static struct notifier_block rtnetlink_dev_notifier = {
6503 .notifier_call = rtnetlink_event,
6504};
6505
97c53cac 6506
2c8c1e72 6507static int __net_init rtnetlink_net_init(struct net *net)
97c53cac
DL		 6508{
6509 struct sock *sk;
a31f2d17
PNA		 6510 struct netlink_kernel_cfg cfg = {
6511 .groups = RTNLGRP_MAX,
6512 .input = rtnetlink_rcv,
6513 .cb_mutex = &rtnl_mutex,
9785e10a 6514 .flags = NL_CFG_F_NONROOT_RECV,
5f729eaa 6515 .bind = rtnetlink_bind,
a31f2d17
PNA		 6516 };
6517
9f00d977 6518 sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
97c53cac
DL		 6519 if (!sk)
6520 return -ENOMEM;
97c53cac
DL		 6521 net->rtnl = sk;
6522 return 0;
6523}
6524
2c8c1e72 6525static void __net_exit rtnetlink_net_exit(struct net *net)
97c53cac 6526{
775516bf
DL		 6527 netlink_kernel_release(net->rtnl);
6528 net->rtnl = NULL;
97c53cac
DL		 6529}
6530
6531static struct pernet_operations rtnetlink_net_ops = {
6532 .init = rtnetlink_net_init,
6533 .exit = rtnetlink_net_exit,
6534};
6535
1da177e4
LT		 6536void __init rtnetlink_init(void)
6537{
97c53cac 6538 if (register_pernet_subsys(&rtnetlink_net_ops))
1da177e4 6539 panic("rtnetlink_init: cannot initialize rtnetlink\n");
97c53cac 6540
1da177e4 6541 register_netdevice_notifier(&rtnetlink_dev_notifier);
340d17fc 6542
c7ac8679 6543 rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink,
b97bac64
FW		 6544 rtnl_dump_ifinfo, 0);
6545 rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, 0);
6546 rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, 0);
6547 rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, 0);
687ad8cc 6548
b97bac64
FW		 6549 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0);
6550 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0);
6551 rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0);
77162022 6552
36fbf1e5
JP		 6553 rtnl_register(PF_UNSPEC, RTM_NEWLINKPROP, rtnl_newlinkprop, NULL, 0);
6554 rtnl_register(PF_UNSPEC, RTM_DELLINKPROP, rtnl_dellinkprop, NULL, 0);
6555
b97bac64 6556 rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0);
9e834259
NA		 6557 rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL,
6558 RTNL_FLAG_BULK_DEL_SUPPORTED);
5b2f94b2 6559 rtnl_register(PF_BRIDGE, RTM_GETNEIGH, rtnl_fdb_get, rtnl_fdb_dump, 0);
e5a55a89 6560
b97bac64
FW		 6561 rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0);
6562 rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0);
6563 rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0);
10c9ead9
RP		 6564
6565 rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
b97bac64 6566 0);
03ba3566 6567 rtnl_register(PF_UNSPEC, RTM_SETSTATS, rtnl_stats_set, NULL, 0);
cc7f5022
IS		 6568
6569 rtnl_register(PF_BRIDGE, RTM_GETMDB, NULL, rtnl_mdb_dump, 0);
6570 rtnl_register(PF_BRIDGE, RTM_NEWMDB, rtnl_mdb_add, NULL, 0);
6571 rtnl_register(PF_BRIDGE, RTM_DELMDB, rtnl_mdb_del, NULL, 0);
1da177e4 6572}
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git