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