net/core/rtnetlink.c

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