linux/net/core/rtnetlink.c
<<
>>
Prefs
   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, <kuznet@ms2.inr.ac.ru>
  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
  57#define RTNL_MAX_TYPE           50
  58#define RTNL_SLAVE_MAX_TYPE     40
  59
  60struct rtnl_link {
  61        rtnl_doit_func          doit;
  62        rtnl_dumpit_func        dumpit;
  63        struct module           *owner;
  64        unsigned int            flags;
  65        struct rcu_head         rcu;
  66};
  67
  68static DEFINE_MUTEX(rtnl_mutex);
  69
  70void rtnl_lock(void)
  71{
  72        mutex_lock(&rtnl_mutex);
  73}
  74EXPORT_SYMBOL(rtnl_lock);
  75
  76int rtnl_lock_killable(void)
  77{
  78        return mutex_lock_killable(&rtnl_mutex);
  79}
  80EXPORT_SYMBOL(rtnl_lock_killable);
  81
  82static struct sk_buff *defer_kfree_skb_list;
  83void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
  84{
  85        if (head && tail) {
  86                tail->next = defer_kfree_skb_list;
  87                defer_kfree_skb_list = head;
  88        }
  89}
  90EXPORT_SYMBOL(rtnl_kfree_skbs);
  91
  92void __rtnl_unlock(void)
  93{
  94        struct sk_buff *head = defer_kfree_skb_list;
  95
  96        defer_kfree_skb_list = NULL;
  97
  98        mutex_unlock(&rtnl_mutex);
  99
 100        while (head) {
 101                struct sk_buff *next = head->next;
 102
 103                kfree_skb(head);
 104                cond_resched();
 105                head = next;
 106        }
 107}
 108
 109void rtnl_unlock(void)
 110{
 111        /* This fellow will unlock it for us. */
 112        netdev_run_todo();
 113}
 114EXPORT_SYMBOL(rtnl_unlock);
 115
 116int rtnl_trylock(void)
 117{
 118        return mutex_trylock(&rtnl_mutex);
 119}
 120EXPORT_SYMBOL(rtnl_trylock);
 121
 122int rtnl_is_locked(void)
 123{
 124        return mutex_is_locked(&rtnl_mutex);
 125}
 126EXPORT_SYMBOL(rtnl_is_locked);
 127
 128bool refcount_dec_and_rtnl_lock(refcount_t *r)
 129{
 130        return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
 131}
 132EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
 133
 134#ifdef CONFIG_PROVE_LOCKING
 135bool lockdep_rtnl_is_held(void)
 136{
 137        return lockdep_is_held(&rtnl_mutex);
 138}
 139EXPORT_SYMBOL(lockdep_rtnl_is_held);
 140#endif /* #ifdef CONFIG_PROVE_LOCKING */
 141
 142static struct rtnl_link __rcu *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
 143
 144static inline int rtm_msgindex(int msgtype)
 145{
 146        int msgindex = msgtype - RTM_BASE;
 147
 148        /*
 149         * msgindex < 0 implies someone tried to register a netlink
 150         * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
 151         * the message type has not been added to linux/rtnetlink.h
 152         */
 153        BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
 154
 155        return msgindex;
 156}
 157
 158static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)
 159{
 160        struct rtnl_link __rcu **tab;
 161
 162        if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))
 163                protocol = PF_UNSPEC;
 164
 165        tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);
 166        if (!tab)
 167                tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);
 168
 169        return rcu_dereference_rtnl(tab[msgtype]);
 170}
 171
 172static int rtnl_register_internal(struct module *owner,
 173                                  int protocol, int msgtype,
 174                                  rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 175                                  unsigned int flags)
 176{
 177        struct rtnl_link *link, *old;
 178        struct rtnl_link __rcu **tab;
 179        int msgindex;
 180        int ret = -ENOBUFS;
 181
 182        BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 183        msgindex = rtm_msgindex(msgtype);
 184
 185        rtnl_lock();
 186        tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
 187        if (tab == NULL) {
 188                tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);
 189                if (!tab)
 190                        goto unlock;
 191
 192                /* ensures we see the 0 stores */
 193                rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);
 194        }
 195
 196        old = rtnl_dereference(tab[msgindex]);
 197        if (old) {
 198                link = kmemdup(old, sizeof(*old), GFP_KERNEL);
 199                if (!link)
 200                        goto unlock;
 201        } else {
 202                link = kzalloc(sizeof(*link), GFP_KERNEL);
 203                if (!link)
 204                        goto unlock;
 205        }
 206
 207        WARN_ON(link->owner && link->owner != owner);
 208        link->owner = owner;
 209
 210        WARN_ON(doit && link->doit && link->doit != doit);
 211        if (doit)
 212                link->doit = doit;
 213        WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
 214        if (dumpit)
 215                link->dumpit = dumpit;
 216
 217        link->flags |= flags;
 218
 219        /* publish protocol:msgtype */
 220        rcu_assign_pointer(tab[msgindex], link);
 221        ret = 0;
 222        if (old)
 223                kfree_rcu(old, rcu);
 224unlock:
 225        rtnl_unlock();
 226        return ret;
 227}
 228
 229/**
 230 * rtnl_register_module - Register a rtnetlink message type
 231 *
 232 * @owner: module registering the hook (THIS_MODULE)
 233 * @protocol: Protocol family or PF_UNSPEC
 234 * @msgtype: rtnetlink message type
 235 * @doit: Function pointer called for each request message
 236 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
 237 * @flags: rtnl_link_flags to modify behaviour of doit/dumpit functions
 238 *
 239 * Like rtnl_register, but for use by removable modules.
 240 */
 241int rtnl_register_module(struct module *owner,
 242                         int protocol, int msgtype,
 243                         rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 244                         unsigned int flags)
 245{
 246        return rtnl_register_internal(owner, protocol, msgtype,
 247                                      doit, dumpit, flags);
 248}
 249EXPORT_SYMBOL_GPL(rtnl_register_module);
 250
 251/**
 252 * rtnl_register - Register a rtnetlink message type
 253 * @protocol: Protocol family or PF_UNSPEC
 254 * @msgtype: rtnetlink message type
 255 * @doit: Function pointer called for each request message
 256 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
 257 * @flags: rtnl_link_flags to modify behaviour of doit/dumpit functions
 258 *
 259 * Registers the specified function pointers (at least one of them has
 260 * to be non-NULL) to be called whenever a request message for the
 261 * specified protocol family and message type is received.
 262 *
 263 * The special protocol family PF_UNSPEC may be used to define fallback
 264 * function pointers for the case when no entry for the specific protocol
 265 * family exists.
 266 */
 267void rtnl_register(int protocol, int msgtype,
 268                   rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 269                   unsigned int flags)
 270{
 271        int err;
 272
 273        err = rtnl_register_internal(NULL, protocol, msgtype, doit, dumpit,
 274                                     flags);
 275        if (err)
 276                pr_err("Unable to register rtnetlink message handler, "
 277                       "protocol = %d, message type = %d\n", protocol, msgtype);
 278}
 279
 280/**
 281 * rtnl_unregister - Unregister a rtnetlink message type
 282 * @protocol: Protocol family or PF_UNSPEC
 283 * @msgtype: rtnetlink message type
 284 *
 285 * Returns 0 on success or a negative error code.
 286 */
 287int rtnl_unregister(int protocol, int msgtype)
 288{
 289        struct rtnl_link __rcu **tab;
 290        struct rtnl_link *link;
 291        int msgindex;
 292
 293        BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 294        msgindex = rtm_msgindex(msgtype);
 295
 296        rtnl_lock();
 297        tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
 298        if (!tab) {
 299                rtnl_unlock();
 300                return -ENOENT;
 301        }
 302
 303        link = rtnl_dereference(tab[msgindex]);
 304        rcu_assign_pointer(tab[msgindex], NULL);
 305        rtnl_unlock();
 306
 307        kfree_rcu(link, rcu);
 308
 309        return 0;
 310}
 311EXPORT_SYMBOL_GPL(rtnl_unregister);
 312
 313/**
 314 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
 315 * @protocol : Protocol family or PF_UNSPEC
 316 *
 317 * Identical to calling rtnl_unregster() for all registered message types
 318 * of a certain protocol family.
 319 */
 320void rtnl_unregister_all(int protocol)
 321{
 322        struct rtnl_link __rcu **tab;
 323        struct rtnl_link *link;
 324        int msgindex;
 325
 326        BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 327
 328        rtnl_lock();
 329        tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
 330        if (!tab) {
 331                rtnl_unlock();
 332                return;
 333        }
 334        RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL);
 335        for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {
 336                link = rtnl_dereference(tab[msgindex]);
 337                if (!link)
 338                        continue;
 339
 340                rcu_assign_pointer(tab[msgindex], NULL);
 341                kfree_rcu(link, rcu);
 342        }
 343        rtnl_unlock();
 344
 345        synchronize_net();
 346
 347        kfree(tab);
 348}
 349EXPORT_SYMBOL_GPL(rtnl_unregister_all);
 350
 351static LIST_HEAD(link_ops);
 352
 353static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
 354{
 355        const struct rtnl_link_ops *ops;
 356
 357        list_for_each_entry(ops, &link_ops, list) {
 358                if (!strcmp(ops->kind, kind))
 359                        return ops;
 360        }
 361        return NULL;
 362}
 363
 364/**
 365 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 366 * @ops: struct rtnl_link_ops * to register
 367 *
 368 * The caller must hold the rtnl_mutex. This function should be used
 369 * by drivers that create devices during module initialization. It
 370 * must be called before registering the devices.
 371 *
 372 * Returns 0 on success or a negative error code.
 373 */
 374int __rtnl_link_register(struct rtnl_link_ops *ops)
 375{
 376        if (rtnl_link_ops_get(ops->kind))
 377                return -EEXIST;
 378
 379        /* The check for alloc/setup is here because if ops
 380         * does not have that filled up, it is not possible
 381         * to use the ops for creating device. So do not
 382         * fill up dellink as well. That disables rtnl_dellink.
 383         */
 384        if ((ops->alloc || ops->setup) && !ops->dellink)
 385                ops->dellink = unregister_netdevice_queue;
 386
 387        list_add_tail(&ops->list, &link_ops);
 388        return 0;
 389}
 390EXPORT_SYMBOL_GPL(__rtnl_link_register);
 391
 392/**
 393 * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 394 * @ops: struct rtnl_link_ops * to register
 395 *
 396 * Returns 0 on success or a negative error code.
 397 */
 398int rtnl_link_register(struct rtnl_link_ops *ops)
 399{
 400        int err;
 401
 402        /* Sanity-check max sizes to avoid stack buffer overflow. */
 403        if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||
 404                    ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))
 405                return -EINVAL;
 406
 407        rtnl_lock();
 408        err = __rtnl_link_register(ops);
 409        rtnl_unlock();
 410        return err;
 411}
 412EXPORT_SYMBOL_GPL(rtnl_link_register);
 413
 414static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
 415{
 416        struct net_device *dev;
 417        LIST_HEAD(list_kill);
 418
 419        for_each_netdev(net, dev) {
 420                if (dev->rtnl_link_ops == ops)
 421                        ops->dellink(dev, &list_kill);
 422        }
 423        unregister_netdevice_many(&list_kill);
 424}
 425
 426/**
 427 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 428 * @ops: struct rtnl_link_ops * to unregister
 429 *
 430 * The caller must hold the rtnl_mutex and guarantee net_namespace_list
 431 * integrity (hold pernet_ops_rwsem for writing to close the race
 432 * with setup_net() and cleanup_net()).
 433 */
 434void __rtnl_link_unregister(struct rtnl_link_ops *ops)
 435{
 436        struct net *net;
 437
 438        for_each_net(net) {
 439                __rtnl_kill_links(net, ops);
 440        }
 441        list_del(&ops->list);
 442}
 443EXPORT_SYMBOL_GPL(__rtnl_link_unregister);
 444
 445/* Return with the rtnl_lock held when there are no network
 446 * devices unregistering in any network namespace.
 447 */
 448static void rtnl_lock_unregistering_all(void)
 449{
 450        struct net *net;
 451        bool unregistering;
 452        DEFINE_WAIT_FUNC(wait, woken_wake_function);
 453
 454        add_wait_queue(&netdev_unregistering_wq, &wait);
 455        for (;;) {
 456                unregistering = false;
 457                rtnl_lock();
 458                /* We held write locked pernet_ops_rwsem, and parallel
 459                 * setup_net() and cleanup_net() are not possible.
 460                 */
 461                for_each_net(net) {
 462                        if (net->dev_unreg_count > 0) {
 463                                unregistering = true;
 464                                break;
 465                        }
 466                }
 467                if (!unregistering)
 468                        break;
 469                __rtnl_unlock();
 470
 471                wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 472        }
 473        remove_wait_queue(&netdev_unregistering_wq, &wait);
 474}
 475
 476/**
 477 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 478 * @ops: struct rtnl_link_ops * to unregister
 479 */
 480void rtnl_link_unregister(struct rtnl_link_ops *ops)
 481{
 482        /* Close the race with setup_net() and cleanup_net() */
 483        down_write(&pernet_ops_rwsem);
 484        rtnl_lock_unregistering_all();
 485        __rtnl_link_unregister(ops);
 486        rtnl_unlock();
 487        up_write(&pernet_ops_rwsem);
 488}
 489EXPORT_SYMBOL_GPL(rtnl_link_unregister);
 490
 491static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
 492{
 493        struct net_device *master_dev;
 494        const struct rtnl_link_ops *ops;
 495        size_t size = 0;
 496
 497        rcu_read_lock();
 498
 499        master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
 500        if (!master_dev)
 501                goto out;
 502
 503        ops = master_dev->rtnl_link_ops;
 504        if (!ops || !ops->get_slave_size)
 505                goto out;
 506        /* IFLA_INFO_SLAVE_DATA + nested data */
 507        size = nla_total_size(sizeof(struct nlattr)) +
 508               ops->get_slave_size(master_dev, dev);
 509
 510out:
 511        rcu_read_unlock();
 512        return size;
 513}
 514
 515static size_t rtnl_link_get_size(const struct net_device *dev)
 516{
 517        const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
 518        size_t size;
 519
 520        if (!ops)
 521                return 0;
 522
 523        size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
 524               nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
 525
 526        if (ops->get_size)
 527                /* IFLA_INFO_DATA + nested data */
 528                size += nla_total_size(sizeof(struct nlattr)) +
 529                        ops->get_size(dev);
 530
 531        if (ops->get_xstats_size)
 532                /* IFLA_INFO_XSTATS */
 533                size += nla_total_size(ops->get_xstats_size(dev));
 534
 535        size += rtnl_link_get_slave_info_data_size(dev);
 536
 537        return size;
 538}
 539
 540static LIST_HEAD(rtnl_af_ops);
 541
 542static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
 543{
 544        const struct rtnl_af_ops *ops;
 545
 546        ASSERT_RTNL();
 547
 548        list_for_each_entry(ops, &rtnl_af_ops, list) {
 549                if (ops->family == family)
 550                        return ops;
 551        }
 552
 553        return NULL;
 554}
 555
 556/**
 557 * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
 558 * @ops: struct rtnl_af_ops * to register
 559 *
 560 * Returns 0 on success or a negative error code.
 561 */
 562void rtnl_af_register(struct rtnl_af_ops *ops)
 563{
 564        rtnl_lock();
 565        list_add_tail_rcu(&ops->list, &rtnl_af_ops);
 566        rtnl_unlock();
 567}
 568EXPORT_SYMBOL_GPL(rtnl_af_register);
 569
 570/**
 571 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
 572 * @ops: struct rtnl_af_ops * to unregister
 573 */
 574void rtnl_af_unregister(struct rtnl_af_ops *ops)
 575{
 576        rtnl_lock();
 577        list_del_rcu(&ops->list);
 578        rtnl_unlock();
 579
 580        synchronize_rcu();
 581}
 582EXPORT_SYMBOL_GPL(rtnl_af_unregister);
 583
 584static size_t rtnl_link_get_af_size(const struct net_device *dev,
 585                                    u32 ext_filter_mask)
 586{
 587        struct rtnl_af_ops *af_ops;
 588        size_t size;
 589
 590        /* IFLA_AF_SPEC */
 591        size = nla_total_size(sizeof(struct nlattr));
 592
 593        rcu_read_lock();
 594        list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
 595                if (af_ops->get_link_af_size) {
 596                        /* AF_* + nested data */
 597                        size += nla_total_size(sizeof(struct nlattr)) +
 598                                af_ops->get_link_af_size(dev, ext_filter_mask);
 599                }
 600        }
 601        rcu_read_unlock();
 602
 603        return size;
 604}
 605
 606static bool rtnl_have_link_slave_info(const struct net_device *dev)
 607{
 608        struct net_device *master_dev;
 609        bool ret = false;
 610
 611        rcu_read_lock();
 612
 613        master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
 614        if (master_dev && master_dev->rtnl_link_ops)
 615                ret = true;
 616        rcu_read_unlock();
 617        return ret;
 618}
 619
 620static int rtnl_link_slave_info_fill(struct sk_buff *skb,
 621                                     const struct net_device *dev)
 622{
 623        struct net_device *master_dev;
 624        const struct rtnl_link_ops *ops;
 625        struct nlattr *slave_data;
 626        int err;
 627
 628        master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
 629        if (!master_dev)
 630                return 0;
 631        ops = master_dev->rtnl_link_ops;
 632        if (!ops)
 633                return 0;
 634        if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
 635                return -EMSGSIZE;
 636        if (ops->fill_slave_info) {
 637                slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);
 638                if (!slave_data)
 639                        return -EMSGSIZE;
 640                err = ops->fill_slave_info(skb, master_dev, dev);
 641                if (err < 0)
 642                        goto err_cancel_slave_data;
 643                nla_nest_end(skb, slave_data);
 644        }
 645        return 0;
 646
 647err_cancel_slave_data:
 648        nla_nest_cancel(skb, slave_data);
 649        return err;
 650}
 651
 652static int rtnl_link_info_fill(struct sk_buff *skb,
 653                               const struct net_device *dev)
 654{
 655        const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
 656        struct nlattr *data;
 657        int err;
 658
 659        if (!ops)
 660                return 0;
 661        if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
 662                return -EMSGSIZE;
 663        if (ops->fill_xstats) {
 664                err = ops->fill_xstats(skb, dev);
 665                if (err < 0)
 666                        return err;
 667        }
 668        if (ops->fill_info) {
 669                data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);
 670                if (data == NULL)
 671                        return -EMSGSIZE;
 672                err = ops->fill_info(skb, dev);
 673                if (err < 0)
 674                        goto err_cancel_data;
 675                nla_nest_end(skb, data);
 676        }
 677        return 0;
 678
 679err_cancel_data:
 680        nla_nest_cancel(skb, data);
 681        return err;
 682}
 683
 684static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
 685{
 686        struct nlattr *linkinfo;
 687        int err = -EMSGSIZE;
 688
 689        linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);
 690        if (linkinfo == NULL)
 691                goto out;
 692
 693        err = rtnl_link_info_fill(skb, dev);
 694        if (err < 0)
 695                goto err_cancel_link;
 696
 697        err = rtnl_link_slave_info_fill(skb, dev);
 698        if (err < 0)
 699                goto err_cancel_link;
 700
 701        nla_nest_end(skb, linkinfo);
 702        return 0;
 703
 704err_cancel_link:
 705        nla_nest_cancel(skb, linkinfo);
 706out:
 707        return err;
 708}
 709
 710int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
 711{
 712        struct sock *rtnl = net->rtnl;
 713        int err = 0;
 714
 715        NETLINK_CB(skb).dst_group = group;
 716        if (echo)
 717                refcount_inc(&skb->users);
 718        netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
 719        if (echo)
 720                err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
 721        return err;
 722}
 723
 724int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
 725{
 726        struct sock *rtnl = net->rtnl;
 727
 728        return nlmsg_unicast(rtnl, skb, pid);
 729}
 730EXPORT_SYMBOL(rtnl_unicast);
 731
 732void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
 733                 struct nlmsghdr *nlh, gfp_t flags)
 734{
 735        struct sock *rtnl = net->rtnl;
 736        int report = 0;
 737
 738        if (nlh)
 739                report = nlmsg_report(nlh);
 740
 741        nlmsg_notify(rtnl, skb, pid, group, report, flags);
 742}
 743EXPORT_SYMBOL(rtnl_notify);
 744
 745void rtnl_set_sk_err(struct net *net, u32 group, int error)
 746{
 747        struct sock *rtnl = net->rtnl;
 748
 749        netlink_set_err(rtnl, 0, group, error);
 750}
 751EXPORT_SYMBOL(rtnl_set_sk_err);
 752
 753int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
 754{
 755        struct nlattr *mx;
 756        int i, valid = 0;
 757
 758        /* nothing is dumped for dst_default_metrics, so just skip the loop */
 759        if (metrics == dst_default_metrics.metrics)
 760                return 0;
 761
 762        mx = nla_nest_start_noflag(skb, RTA_METRICS);
 763        if (mx == NULL)
 764                return -ENOBUFS;
 765
 766        for (i = 0; i < RTAX_MAX; i++) {
 767                if (metrics[i]) {
 768                        if (i == RTAX_CC_ALGO - 1) {
 769                                char tmp[TCP_CA_NAME_MAX], *name;
 770
 771                                name = tcp_ca_get_name_by_key(metrics[i], tmp);
 772                                if (!name)
 773                                        continue;
 774                                if (nla_put_string(skb, i + 1, name))
 775                                        goto nla_put_failure;
 776                        } else if (i == RTAX_FEATURES - 1) {
 777                                u32 user_features = metrics[i] & RTAX_FEATURE_MASK;
 778
 779                                if (!user_features)
 780                                        continue;
 781                                BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
 782                                if (nla_put_u32(skb, i + 1, user_features))
 783                                        goto nla_put_failure;
 784                        } else {
 785                                if (nla_put_u32(skb, i + 1, metrics[i]))
 786                                        goto nla_put_failure;
 787                        }
 788                        valid++;
 789                }
 790        }
 791
 792        if (!valid) {
 793                nla_nest_cancel(skb, mx);
 794                return 0;
 795        }
 796
 797        return nla_nest_end(skb, mx);
 798
 799nla_put_failure:
 800        nla_nest_cancel(skb, mx);
 801        return -EMSGSIZE;
 802}
 803EXPORT_SYMBOL(rtnetlink_put_metrics);
 804
 805int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
 806                       long expires, u32 error)
 807{
 808        struct rta_cacheinfo ci = {
 809                .rta_error = error,
 810                .rta_id =  id,
 811        };
 812
 813        if (dst) {
 814                ci.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse);
 815                ci.rta_used = dst->__use;
 816                ci.rta_clntref = atomic_read(&dst->__refcnt);
 817        }
 818        if (expires) {
 819                unsigned long clock;
 820
 821                clock = jiffies_to_clock_t(abs(expires));
 822                clock = min_t(unsigned long, clock, INT_MAX);
 823                ci.rta_expires = (expires > 0) ? clock : -clock;
 824        }
 825        return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
 826}
 827EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
 828
 829static void set_operstate(struct net_device *dev, unsigned char transition)
 830{
 831        unsigned char operstate = dev->operstate;
 832
 833        switch (transition) {
 834        case IF_OPER_UP:
 835                if ((operstate == IF_OPER_DORMANT ||
 836                     operstate == IF_OPER_TESTING ||
 837                     operstate == IF_OPER_UNKNOWN) &&
 838                    !netif_dormant(dev) && !netif_testing(dev))
 839                        operstate = IF_OPER_UP;
 840                break;
 841
 842        case IF_OPER_TESTING:
 843                if (operstate == IF_OPER_UP ||
 844                    operstate == IF_OPER_UNKNOWN)
 845                        operstate = IF_OPER_TESTING;
 846                break;
 847
 848        case IF_OPER_DORMANT:
 849                if (operstate == IF_OPER_UP ||
 850                    operstate == IF_OPER_UNKNOWN)
 851                        operstate = IF_OPER_DORMANT;
 852                break;
 853        }
 854
 855        if (dev->operstate != operstate) {
 856                write_lock_bh(&dev_base_lock);
 857                dev->operstate = operstate;
 858                write_unlock_bh(&dev_base_lock);
 859                netdev_state_change(dev);
 860        }
 861}
 862
 863static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
 864{
 865        return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
 866               (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
 867}
 868
 869static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
 870                                           const struct ifinfomsg *ifm)
 871{
 872        unsigned int flags = ifm->ifi_flags;
 873
 874        /* bugwards compatibility: ifi_change == 0 is treated as ~0 */
 875        if (ifm->ifi_change)
 876                flags = (flags & ifm->ifi_change) |
 877                        (rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
 878
 879        return flags;
 880}
 881
 882static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
 883                                 const struct rtnl_link_stats64 *b)
 884{
 885        a->rx_packets = b->rx_packets;
 886        a->tx_packets = b->tx_packets;
 887        a->rx_bytes = b->rx_bytes;
 888        a->tx_bytes = b->tx_bytes;
 889        a->rx_errors = b->rx_errors;
 890        a->tx_errors = b->tx_errors;
 891        a->rx_dropped = b->rx_dropped;
 892        a->tx_dropped = b->tx_dropped;
 893
 894        a->multicast = b->multicast;
 895        a->collisions = b->collisions;
 896
 897        a->rx_length_errors = b->rx_length_errors;
 898        a->rx_over_errors = b->rx_over_errors;
 899        a->rx_crc_errors = b->rx_crc_errors;
 900        a->rx_frame_errors = b->rx_frame_errors;
 901        a->rx_fifo_errors = b->rx_fifo_errors;
 902        a->rx_missed_errors = b->rx_missed_errors;
 903
 904        a->tx_aborted_errors = b->tx_aborted_errors;
 905        a->tx_carrier_errors = b->tx_carrier_errors;
 906        a->tx_fifo_errors = b->tx_fifo_errors;
 907        a->tx_heartbeat_errors = b->tx_heartbeat_errors;
 908        a->tx_window_errors = b->tx_window_errors;
 909
 910        a->rx_compressed = b->rx_compressed;
 911        a->tx_compressed = b->tx_compressed;
 912
 913        a->rx_nohandler = b->rx_nohandler;
 914}
 915
 916/* All VF info */
 917static inline int rtnl_vfinfo_size(const struct net_device *dev,
 918                                   u32 ext_filter_mask)
 919{
 920        if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
 921                int num_vfs = dev_num_vf(dev->dev.parent);
 922                size_t size = nla_total_size(0);
 923                size += num_vfs *
 924                        (nla_total_size(0) +
 925                         nla_total_size(sizeof(struct ifla_vf_mac)) +
 926                         nla_total_size(sizeof(struct ifla_vf_broadcast)) +
 927                         nla_total_size(sizeof(struct ifla_vf_vlan)) +
 928                         nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
 929                         nla_total_size(MAX_VLAN_LIST_LEN *
 930                                        sizeof(struct ifla_vf_vlan_info)) +
 931                         nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
 932                         nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
 933                         nla_total_size(sizeof(struct ifla_vf_rate)) +
 934                         nla_total_size(sizeof(struct ifla_vf_link_state)) +
 935                         nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
 936                         nla_total_size(0) + /* nest IFLA_VF_STATS */
 937                         /* IFLA_VF_STATS_RX_PACKETS */
 938                         nla_total_size_64bit(sizeof(__u64)) +
 939                         /* IFLA_VF_STATS_TX_PACKETS */
 940                         nla_total_size_64bit(sizeof(__u64)) +
 941                         /* IFLA_VF_STATS_RX_BYTES */
 942                         nla_total_size_64bit(sizeof(__u64)) +
 943                         /* IFLA_VF_STATS_TX_BYTES */
 944                         nla_total_size_64bit(sizeof(__u64)) +
 945                         /* IFLA_VF_STATS_BROADCAST */
 946                         nla_total_size_64bit(sizeof(__u64)) +
 947                         /* IFLA_VF_STATS_MULTICAST */
 948                         nla_total_size_64bit(sizeof(__u64)) +
 949                         /* IFLA_VF_STATS_RX_DROPPED */
 950                         nla_total_size_64bit(sizeof(__u64)) +
 951                         /* IFLA_VF_STATS_TX_DROPPED */
 952                         nla_total_size_64bit(sizeof(__u64)) +
 953                         nla_total_size(sizeof(struct ifla_vf_trust)));
 954                return size;
 955        } else
 956                return 0;
 957}
 958
 959static size_t rtnl_port_size(const struct net_device *dev,
 960                             u32 ext_filter_mask)
 961{
 962        size_t port_size = nla_total_size(4)            /* PORT_VF */
 963                + nla_total_size(PORT_PROFILE_MAX)      /* PORT_PROFILE */
 964                + nla_total_size(PORT_UUID_MAX)         /* PORT_INSTANCE_UUID */
 965                + nla_total_size(PORT_UUID_MAX)         /* PORT_HOST_UUID */
 966                + nla_total_size(1)                     /* PROT_VDP_REQUEST */
 967                + nla_total_size(2);                    /* PORT_VDP_RESPONSE */
 968        size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
 969        size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
 970                + port_size;
 971        size_t port_self_size = nla_total_size(sizeof(struct nlattr))
 972                + port_size;
 973
 974        if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
 975            !(ext_filter_mask & RTEXT_FILTER_VF))
 976                return 0;
 977        if (dev_num_vf(dev->dev.parent))
 978                return port_self_size + vf_ports_size +
 979                        vf_port_size * dev_num_vf(dev->dev.parent);
 980        else
 981                return port_self_size;
 982}
 983
 984static size_t rtnl_xdp_size(void)
 985{
 986        size_t xdp_size = nla_total_size(0) +   /* nest IFLA_XDP */
 987                          nla_total_size(1) +   /* XDP_ATTACHED */
 988                          nla_total_size(4) +   /* XDP_PROG_ID (or 1st mode) */
 989                          nla_total_size(4);    /* XDP_<mode>_PROG_ID */
 990
 991        return xdp_size;
 992}
 993
 994static size_t rtnl_prop_list_size(const struct net_device *dev)
 995{
 996        struct netdev_name_node *name_node;
 997        size_t size;
 998
 999        if (list_empty(&dev->name_node->list))
1000                return 0;
1001        size = nla_total_size(0);
1002        list_for_each_entry(name_node, &dev->name_node->list, list)
1003                size += nla_total_size(ALTIFNAMSIZ);
1004        return size;
1005}
1006
1007static size_t rtnl_proto_down_size(const struct net_device *dev)
1008{
1009        size_t size = nla_total_size(1);
1010
1011        if (dev->proto_down_reason)
1012                size += nla_total_size(0) + nla_total_size(4);
1013
1014        return size;
1015}
1016
1017static noinline size_t if_nlmsg_size(const struct net_device *dev,
1018                                     u32 ext_filter_mask)
1019{
1020        return NLMSG_ALIGN(sizeof(struct ifinfomsg))
1021               + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
1022               + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
1023               + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
1024               + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
1025               + nla_total_size(sizeof(struct rtnl_link_stats))
1026               + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))
1027               + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
1028               + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
1029               + nla_total_size(4) /* IFLA_TXQLEN */
1030               + nla_total_size(4) /* IFLA_WEIGHT */
1031               + nla_total_size(4) /* IFLA_MTU */
1032               + nla_total_size(4) /* IFLA_LINK */
1033               + nla_total_size(4) /* IFLA_MASTER */
1034               + nla_total_size(1) /* IFLA_CARRIER */
1035               + nla_total_size(4) /* IFLA_PROMISCUITY */
1036               + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
1037               + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
1038               + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
1039               + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */
1040               + nla_total_size(1) /* IFLA_OPERSTATE */
1041               + nla_total_size(1) /* IFLA_LINKMODE */
1042               + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
1043               + nla_total_size(4) /* IFLA_LINK_NETNSID */
1044               + nla_total_size(4) /* IFLA_GROUP */
1045               + nla_total_size(ext_filter_mask
1046                                & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
1047               + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
1048               + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
1049               + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
1050               + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */
1051               + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
1052               + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
1053               + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
1054               + rtnl_xdp_size() /* IFLA_XDP */
1055               + nla_total_size(4)  /* IFLA_EVENT */
1056               + nla_total_size(4)  /* IFLA_NEW_NETNSID */
1057               + nla_total_size(4)  /* IFLA_NEW_IFINDEX */
1058               + rtnl_proto_down_size(dev)  /* proto down */
1059               + nla_total_size(4)  /* IFLA_TARGET_NETNSID */
1060               + nla_total_size(4)  /* IFLA_CARRIER_UP_COUNT */
1061               + nla_total_size(4)  /* IFLA_CARRIER_DOWN_COUNT */
1062               + nla_total_size(4)  /* IFLA_MIN_MTU */
1063               + nla_total_size(4)  /* IFLA_MAX_MTU */
1064               + rtnl_prop_list_size(dev)
1065               + nla_total_size(MAX_ADDR_LEN) /* IFLA_PERM_ADDRESS */
1066               + 0;
1067}
1068
1069static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
1070{
1071        struct nlattr *vf_ports;
1072        struct nlattr *vf_port;
1073        int vf;
1074        int err;
1075
1076        vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS);
1077        if (!vf_ports)
1078                return -EMSGSIZE;
1079
1080        for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
1081                vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT);
1082                if (!vf_port)
1083                        goto nla_put_failure;
1084                if (nla_put_u32(skb, IFLA_PORT_VF, vf))
1085                        goto nla_put_failure;
1086                err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
1087                if (err == -EMSGSIZE)
1088                        goto nla_put_failure;
1089                if (err) {
1090                        nla_nest_cancel(skb, vf_port);
1091                        continue;
1092                }
1093                nla_nest_end(skb, vf_port);
1094        }
1095
1096        nla_nest_end(skb, vf_ports);
1097
1098        return 0;
1099
1100nla_put_failure:
1101        nla_nest_cancel(skb, vf_ports);
1102        return -EMSGSIZE;
1103}
1104
1105static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
1106{
1107        struct nlattr *port_self;
1108        int err;
1109
1110        port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF);
1111        if (!port_self)
1112                return -EMSGSIZE;
1113
1114        err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
1115        if (err) {
1116                nla_nest_cancel(skb, port_self);
1117                return (err == -EMSGSIZE) ? err : 0;
1118        }
1119
1120        nla_nest_end(skb, port_self);
1121
1122        return 0;
1123}
1124
1125static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
1126                          u32 ext_filter_mask)
1127{
1128        int err;
1129
1130        if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1131            !(ext_filter_mask & RTEXT_FILTER_VF))
1132                return 0;
1133
1134        err = rtnl_port_self_fill(skb, dev);
1135        if (err)
1136                return err;
1137
1138        if (dev_num_vf(dev->dev.parent)) {
1139                err = rtnl_vf_ports_fill(skb, dev);
1140                if (err)
1141                        return err;
1142        }
1143
1144        return 0;
1145}
1146
1147static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
1148{
1149        int err;
1150        struct netdev_phys_item_id ppid;
1151
1152        err = dev_get_phys_port_id(dev, &ppid);
1153        if (err) {
1154                if (err == -EOPNOTSUPP)
1155                        return 0;
1156                return err;
1157        }
1158
1159        if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
1160                return -EMSGSIZE;
1161
1162        return 0;
1163}
1164
1165static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
1166{
1167        char name[IFNAMSIZ];
1168        int err;
1169
1170        err = dev_get_phys_port_name(dev, name, sizeof(name));
1171        if (err) {
1172                if (err == -EOPNOTSUPP)
1173                        return 0;
1174                return err;
1175        }
1176
1177        if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))
1178                return -EMSGSIZE;
1179
1180        return 0;
1181}
1182
1183static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
1184{
1185        struct netdev_phys_item_id ppid = { };
1186        int err;
1187
1188        err = dev_get_port_parent_id(dev, &ppid, false);
1189        if (err) {
1190                if (err == -EOPNOTSUPP)
1191                        return 0;
1192                return err;
1193        }
1194
1195        if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id))
1196                return -EMSGSIZE;
1197
1198        return 0;
1199}
1200
1201static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
1202                                              struct net_device *dev)
1203{
1204        struct rtnl_link_stats64 *sp;
1205        struct nlattr *attr;
1206
1207        attr = nla_reserve_64bit(skb, IFLA_STATS64,
1208                                 sizeof(struct rtnl_link_stats64), IFLA_PAD);
1209        if (!attr)
1210                return -EMSGSIZE;
1211
1212        sp = nla_data(attr);
1213        dev_get_stats(dev, sp);
1214
1215        attr = nla_reserve(skb, IFLA_STATS,
1216                           sizeof(struct rtnl_link_stats));
1217        if (!attr)
1218                return -EMSGSIZE;
1219
1220        copy_rtnl_link_stats(nla_data(attr), sp);
1221
1222        return 0;
1223}
1224
1225static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
1226                                               struct net_device *dev,
1227                                               int vfs_num,
1228                                               struct nlattr *vfinfo)
1229{
1230        struct ifla_vf_rss_query_en vf_rss_query_en;
1231        struct nlattr *vf, *vfstats, *vfvlanlist;
1232        struct ifla_vf_link_state vf_linkstate;
1233        struct ifla_vf_vlan_info vf_vlan_info;
1234        struct ifla_vf_spoofchk vf_spoofchk;
1235        struct ifla_vf_tx_rate vf_tx_rate;
1236        struct ifla_vf_stats vf_stats;
1237        struct ifla_vf_trust vf_trust;
1238        struct ifla_vf_vlan vf_vlan;
1239        struct ifla_vf_rate vf_rate;
1240        struct ifla_vf_mac vf_mac;
1241        struct ifla_vf_broadcast vf_broadcast;
1242        struct ifla_vf_info ivi;
1243        struct ifla_vf_guid node_guid;
1244        struct ifla_vf_guid port_guid;
1245
1246        memset(&ivi, 0, sizeof(ivi));
1247
1248        /* Not all SR-IOV capable drivers support the
1249         * spoofcheck and "RSS query enable" query.  Preset to
1250         * -1 so the user space tool can detect that the driver
1251         * didn't report anything.
1252         */
1253        ivi.spoofchk = -1;
1254        ivi.rss_query_en = -1;
1255        ivi.trusted = -1;
1256        /* The default value for VF link state is "auto"
1257         * IFLA_VF_LINK_STATE_AUTO which equals zero
1258         */
1259        ivi.linkstate = 0;
1260        /* VLAN Protocol by default is 802.1Q */
1261        ivi.vlan_proto = htons(ETH_P_8021Q);
1262        if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
1263                return 0;
1264
1265        memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));
1266        memset(&node_guid, 0, sizeof(node_guid));
1267        memset(&port_guid, 0, sizeof(port_guid));
1268
1269        vf_mac.vf =
1270                vf_vlan.vf =
1271                vf_vlan_info.vf =
1272                vf_rate.vf =
1273                vf_tx_rate.vf =
1274                vf_spoofchk.vf =
1275                vf_linkstate.vf =
1276                vf_rss_query_en.vf =
1277                vf_trust.vf =
1278                node_guid.vf =
1279                port_guid.vf = ivi.vf;
1280
1281        memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
1282        memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len);
1283        vf_vlan.vlan = ivi.vlan;
1284        vf_vlan.qos = ivi.qos;
1285        vf_vlan_info.vlan = ivi.vlan;
1286        vf_vlan_info.qos = ivi.qos;
1287        vf_vlan_info.vlan_proto = ivi.vlan_proto;
1288        vf_tx_rate.rate = ivi.max_tx_rate;
1289        vf_rate.min_tx_rate = ivi.min_tx_rate;
1290        vf_rate.max_tx_rate = ivi.max_tx_rate;
1291        vf_spoofchk.setting = ivi.spoofchk;
1292        vf_linkstate.link_state = ivi.linkstate;
1293        vf_rss_query_en.setting = ivi.rss_query_en;
1294        vf_trust.setting = ivi.trusted;
1295        vf = nla_nest_start_noflag(skb, IFLA_VF_INFO);
1296        if (!vf)
1297                goto nla_put_vfinfo_failure;
1298        if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
1299            nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) ||
1300            nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1301            nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
1302                    &vf_rate) ||
1303            nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
1304                    &vf_tx_rate) ||
1305            nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1306                    &vf_spoofchk) ||
1307            nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
1308                    &vf_linkstate) ||
1309            nla_put(skb, IFLA_VF_RSS_QUERY_EN,
1310                    sizeof(vf_rss_query_en),
1311                    &vf_rss_query_en) ||
1312            nla_put(skb, IFLA_VF_TRUST,
1313                    sizeof(vf_trust), &vf_trust))
1314                goto nla_put_vf_failure;
1315
1316        if (dev->netdev_ops->ndo_get_vf_guid &&
1317            !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid,
1318                                              &port_guid)) {
1319                if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid),
1320                            &node_guid) ||
1321                    nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid),
1322                            &port_guid))
1323                        goto nla_put_vf_failure;
1324        }
1325        vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST);
1326        if (!vfvlanlist)
1327                goto nla_put_vf_failure;
1328        if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
1329                    &vf_vlan_info)) {
1330                nla_nest_cancel(skb, vfvlanlist);
1331                goto nla_put_vf_failure;
1332        }
1333        nla_nest_end(skb, vfvlanlist);
1334        memset(&vf_stats, 0, sizeof(vf_stats));
1335        if (dev->netdev_ops->ndo_get_vf_stats)
1336                dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
1337                                                &vf_stats);
1338        vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS);
1339        if (!vfstats)
1340                goto nla_put_vf_failure;
1341        if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
1342                              vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
1343            nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
1344                              vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
1345            nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
1346                              vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
1347            nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
1348                              vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
1349            nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
1350                              vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
1351            nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
1352                              vf_stats.multicast, IFLA_VF_STATS_PAD) ||
1353            nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED,
1354                              vf_stats.rx_dropped, IFLA_VF_STATS_PAD) ||
1355            nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED,
1356                              vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) {
1357                nla_nest_cancel(skb, vfstats);
1358                goto nla_put_vf_failure;
1359        }
1360        nla_nest_end(skb, vfstats);
1361        nla_nest_end(skb, vf);
1362        return 0;
1363
1364nla_put_vf_failure:
1365        nla_nest_cancel(skb, vf);
1366nla_put_vfinfo_failure:
1367        nla_nest_cancel(skb, vfinfo);
1368        return -EMSGSIZE;
1369}
1370
1371static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb,
1372                                           struct net_device *dev,
1373                                           u32 ext_filter_mask)
1374{
1375        struct nlattr *vfinfo;
1376        int i, num_vfs;
1377
1378        if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0))
1379                return 0;
1380
1381        num_vfs = dev_num_vf(dev->dev.parent);
1382        if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs))
1383                return -EMSGSIZE;
1384
1385        if (!dev->netdev_ops->ndo_get_vf_config)
1386                return 0;
1387
1388        vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST);
1389        if (!vfinfo)
1390                return -EMSGSIZE;
1391
1392        for (i = 0; i < num_vfs; i++) {
1393                if (rtnl_fill_vfinfo(skb, dev, i, vfinfo))
1394                        return -EMSGSIZE;
1395        }
1396
1397        nla_nest_end(skb, vfinfo);
1398        return 0;
1399}
1400
1401static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
1402{
1403        struct rtnl_link_ifmap map;
1404
1405        memset(&map, 0, sizeof(map));
1406        map.mem_start   = dev->mem_start;
1407        map.mem_end     = dev->mem_end;
1408        map.base_addr   = dev->base_addr;
1409        map.irq         = dev->irq;
1410        map.dma         = dev->dma;
1411        map.port        = dev->if_port;
1412
1413        if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
1414                return -EMSGSIZE;
1415
1416        return 0;
1417}
1418
1419static u32 rtnl_xdp_prog_skb(struct net_device *dev)
1420{
1421        const struct bpf_prog *generic_xdp_prog;
1422
1423        ASSERT_RTNL();
1424
1425        generic_xdp_prog = rtnl_dereference(dev->xdp_prog);
1426        if (!generic_xdp_prog)
1427                return 0;
1428        return generic_xdp_prog->aux->id;
1429}
1430
1431static u32 rtnl_xdp_prog_drv(struct net_device *dev)
1432{
1433        return dev_xdp_prog_id(dev, XDP_MODE_DRV);
1434}
1435
1436static u32 rtnl_xdp_prog_hw(struct net_device *dev)
1437{
1438        return dev_xdp_prog_id(dev, XDP_MODE_HW);
1439}
1440
1441static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev,
1442                               u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr,
1443                               u32 (*get_prog_id)(struct net_device *dev))
1444{
1445        u32 curr_id;
1446        int err;
1447
1448        curr_id = get_prog_id(dev);
1449        if (!curr_id)
1450                return 0;
1451
1452        *prog_id = curr_id;
1453        err = nla_put_u32(skb, attr, curr_id);
1454        if (err)
1455                return err;
1456
1457        if (*mode != XDP_ATTACHED_NONE)
1458                *mode = XDP_ATTACHED_MULTI;
1459        else
1460                *mode = tgt_mode;
1461
1462        return 0;
1463}
1464
1465static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
1466{
1467        struct nlattr *xdp;
1468        u32 prog_id;
1469        int err;
1470        u8 mode;
1471
1472        xdp = nla_nest_start_noflag(skb, IFLA_XDP);
1473        if (!xdp)
1474                return -EMSGSIZE;
1475
1476        prog_id = 0;
1477        mode = XDP_ATTACHED_NONE;
1478        err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB,
1479                                  IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb);
1480        if (err)
1481                goto err_cancel;
1482        err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV,
1483                                  IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv);
1484        if (err)
1485                goto err_cancel;
1486        err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW,
1487                                  IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw);
1488        if (err)
1489                goto err_cancel;
1490
1491        err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode);
1492        if (err)
1493                goto err_cancel;
1494
1495        if (prog_id && mode != XDP_ATTACHED_MULTI) {
1496                err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
1497                if (err)
1498                        goto err_cancel;
1499        }
1500
1501        nla_nest_end(skb, xdp);
1502        return 0;
1503
1504err_cancel:
1505        nla_nest_cancel(skb, xdp);
1506        return err;
1507}
1508
1509static u32 rtnl_get_event(unsigned long event)
1510{
1511        u32 rtnl_event_type = IFLA_EVENT_NONE;
1512
1513        switch (event) {
1514        case NETDEV_REBOOT:
1515                rtnl_event_type = IFLA_EVENT_REBOOT;
1516                break;
1517        case NETDEV_FEAT_CHANGE:
1518                rtnl_event_type = IFLA_EVENT_FEATURES;
1519                break;
1520        case NETDEV_BONDING_FAILOVER:
1521                rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
1522                break;
1523        case NETDEV_NOTIFY_PEERS:
1524                rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
1525                break;
1526        case NETDEV_RESEND_IGMP:
1527                rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
1528                break;
1529        case NETDEV_CHANGEINFODATA:
1530                rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
1531                break;
1532        default:
1533                break;
1534        }
1535
1536        return rtnl_event_type;
1537}
1538
1539static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev)
1540{
1541        const struct net_device *upper_dev;
1542        int ret = 0;
1543
1544        rcu_read_lock();
1545
1546        upper_dev = netdev_master_upper_dev_get_rcu(dev);
1547        if (upper_dev)
1548                ret = nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex);
1549
1550        rcu_read_unlock();
1551        return ret;
1552}
1553
1554static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev,
1555                          bool force)
1556{
1557        int ifindex = dev_get_iflink(dev);
1558
1559        if (force || dev->ifindex != ifindex)
1560                return nla_put_u32(skb, IFLA_LINK, ifindex);
1561
1562        return 0;
1563}
1564
1565static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb,
1566                                              struct net_device *dev)
1567{
1568        char buf[IFALIASZ];
1569        int ret;
1570
1571        ret = dev_get_alias(dev, buf, sizeof(buf));
1572        return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0;
1573}
1574
1575static int rtnl_fill_link_netnsid(struct sk_buff *skb,
1576                                  const struct net_device *dev,
1577                                  struct net *src_net, gfp_t gfp)
1578{
1579        bool put_iflink = false;
1580
1581        if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) {
1582                struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
1583
1584                if (!net_eq(dev_net(dev), link_net)) {
1585                        int id = peernet2id_alloc(src_net, link_net, gfp);
1586
1587                        if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
1588                                return -EMSGSIZE;
1589
1590                        put_iflink = true;
1591                }
1592        }
1593
1594        return nla_put_iflink(skb, dev, put_iflink);
1595}
1596
1597static int rtnl_fill_link_af(struct sk_buff *skb,
1598                             const struct net_device *dev,
1599                             u32 ext_filter_mask)
1600{
1601        const struct rtnl_af_ops *af_ops;
1602        struct nlattr *af_spec;
1603
1604        af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
1605        if (!af_spec)
1606                return -EMSGSIZE;
1607
1608        list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
1609                struct nlattr *af;
1610                int err;
1611
1612                if (!af_ops->fill_link_af)
1613                        continue;
1614
1615                af = nla_nest_start_noflag(skb, af_ops->family);
1616                if (!af)
1617                        return -EMSGSIZE;
1618
1619                err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
1620                /*
1621                 * Caller may return ENODATA to indicate that there
1622                 * was no data to be dumped. This is not an error, it
1623                 * means we should trim the attribute header and
1624                 * continue.
1625                 */
1626                if (err == -ENODATA)
1627                        nla_nest_cancel(skb, af);
1628                else if (err < 0)
1629                        return -EMSGSIZE;
1630
1631                nla_nest_end(skb, af);
1632        }
1633
1634        nla_nest_end(skb, af_spec);
1635        return 0;
1636}
1637
1638static int rtnl_fill_alt_ifnames(struct sk_buff *skb,
1639                                 const struct net_device *dev)
1640{
1641        struct netdev_name_node *name_node;
1642        int count = 0;
1643
1644        list_for_each_entry(name_node, &dev->name_node->list, list) {
1645                if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name))
1646                        return -EMSGSIZE;
1647                count++;
1648        }
1649        return count;
1650}
1651
1652static int rtnl_fill_prop_list(struct sk_buff *skb,
1653                               const struct net_device *dev)
1654{
1655        struct nlattr *prop_list;
1656        int ret;
1657
1658        prop_list = nla_nest_start(skb, IFLA_PROP_LIST);
1659        if (!prop_list)
1660                return -EMSGSIZE;
1661
1662        ret = rtnl_fill_alt_ifnames(skb, dev);
1663        if (ret <= 0)
1664                goto nest_cancel;
1665
1666        nla_nest_end(skb, prop_list);
1667        return 0;
1668
1669nest_cancel:
1670        nla_nest_cancel(skb, prop_list);
1671        return ret;
1672}
1673
1674static int rtnl_fill_proto_down(struct sk_buff *skb,
1675                                const struct net_device *dev)
1676{
1677        struct nlattr *pr;
1678        u32 preason;
1679
1680        if (nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))
1681                goto nla_put_failure;
1682
1683        preason = dev->proto_down_reason;
1684        if (!preason)
1685                return 0;
1686
1687        pr = nla_nest_start(skb, IFLA_PROTO_DOWN_REASON);
1688        if (!pr)
1689                return -EMSGSIZE;
1690
1691        if (nla_put_u32(skb, IFLA_PROTO_DOWN_REASON_VALUE, preason)) {
1692                nla_nest_cancel(skb, pr);
1693                goto nla_put_failure;
1694        }
1695
1696        nla_nest_end(skb, pr);
1697        return 0;
1698
1699nla_put_failure:
1700        return -EMSGSIZE;
1701}
1702
1703static int rtnl_fill_ifinfo(struct sk_buff *skb,
1704                            struct net_device *dev, struct net *src_net,
1705                            int type, u32 pid, u32 seq, u32 change,
1706                            unsigned int flags, u32 ext_filter_mask,
1707                            u32 event, int *new_nsid, int new_ifindex,
1708                            int tgt_netnsid, gfp_t gfp)
1709{
1710        struct ifinfomsg *ifm;
1711        struct nlmsghdr *nlh;
1712
1713        ASSERT_RTNL();
1714        nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
1715        if (nlh == NULL)
1716                return -EMSGSIZE;
1717
1718        ifm = nlmsg_data(nlh);
1719        ifm->ifi_family = AF_UNSPEC;
1720        ifm->__ifi_pad = 0;
1721        ifm->ifi_type = dev->type;
1722        ifm->ifi_index = dev->ifindex;
1723        ifm->ifi_flags = dev_get_flags(dev);
1724        ifm->ifi_change = change;
1725
1726        if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
1727                goto nla_put_failure;
1728
1729        if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
1730            nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
1731            nla_put_u8(skb, IFLA_OPERSTATE,
1732                       netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
1733            nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
1734            nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
1735            nla_put_u32(skb, IFLA_MIN_MTU, dev->min_mtu) ||
1736            nla_put_u32(skb, IFLA_MAX_MTU, dev->max_mtu) ||
1737            nla_put_u32(skb, IFLA_GROUP, dev->group) ||
1738            nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
1739            nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
1740            nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
1741            nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||
1742#ifdef CONFIG_RPS
1743            nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1744#endif
1745            put_master_ifindex(skb, dev) ||
1746            nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
1747            (dev->qdisc &&
1748             nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
1749            nla_put_ifalias(skb, dev) ||
1750            nla_put_u32(skb, IFLA_CARRIER_CHANGES,
1751                        atomic_read(&dev->carrier_up_count) +
1752                        atomic_read(&dev->carrier_down_count)) ||
1753            nla_put_u32(skb, IFLA_CARRIER_UP_COUNT,
1754                        atomic_read(&dev->carrier_up_count)) ||
1755            nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT,
1756                        atomic_read(&dev->carrier_down_count)))
1757                goto nla_put_failure;
1758
1759        if (rtnl_fill_proto_down(skb, dev))
1760                goto nla_put_failure;
1761
1762        if (event != IFLA_EVENT_NONE) {
1763                if (nla_put_u32(skb, IFLA_EVENT, event))
1764                        goto nla_put_failure;
1765        }
1766
1767        if (rtnl_fill_link_ifmap(skb, dev))
1768                goto nla_put_failure;
1769
1770        if (dev->addr_len) {
1771                if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
1772                    nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
1773                        goto nla_put_failure;
1774        }
1775
1776        if (rtnl_phys_port_id_fill(skb, dev))
1777                goto nla_put_failure;
1778
1779        if (rtnl_phys_port_name_fill(skb, dev))
1780                goto nla_put_failure;
1781
1782        if (rtnl_phys_switch_id_fill(skb, dev))
1783                goto nla_put_failure;
1784
1785        if (rtnl_fill_stats(skb, dev))
1786                goto nla_put_failure;
1787
1788        if (rtnl_fill_vf(skb, dev, ext_filter_mask))
1789                goto nla_put_failure;
1790
1791        if (rtnl_port_fill(skb, dev, ext_filter_mask))
1792                goto nla_put_failure;
1793
1794        if (rtnl_xdp_fill(skb, dev))
1795                goto nla_put_failure;
1796
1797        if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
1798                if (rtnl_link_fill(skb, dev) < 0)
1799                        goto nla_put_failure;
1800        }
1801
1802        if (rtnl_fill_link_netnsid(skb, dev, src_net, gfp))
1803                goto nla_put_failure;
1804
1805        if (new_nsid &&
1806            nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
1807                goto nla_put_failure;
1808        if (new_ifindex &&
1809            nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0)
1810                goto nla_put_failure;
1811
1812        if (memchr_inv(dev->perm_addr, '\0', dev->addr_len) &&
1813            nla_put(skb, IFLA_PERM_ADDRESS, dev->addr_len, dev->perm_addr))
1814                goto nla_put_failure;
1815
1816        rcu_read_lock();
1817        if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
1818                goto nla_put_failure_rcu;
1819        rcu_read_unlock();
1820
1821        if (rtnl_fill_prop_list(skb, dev))
1822                goto nla_put_failure;
1823
1824        if (dev->dev.parent &&
1825            nla_put_string(skb, IFLA_PARENT_DEV_NAME,
1826                           dev_name(dev->dev.parent)))
1827                goto nla_put_failure;
1828
1829        if (dev->dev.parent && dev->dev.parent->bus &&
1830            nla_put_string(skb, IFLA_PARENT_DEV_BUS_NAME,
1831                           dev->dev.parent->bus->name))
1832                goto nla_put_failure;
1833
1834        nlmsg_end(skb, nlh);
1835        return 0;
1836
1837nla_put_failure_rcu:
1838        rcu_read_unlock();
1839nla_put_failure:
1840        nlmsg_cancel(skb, nlh);
1841        return -EMSGSIZE;
1842}
1843
1844static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1845        [IFLA_IFNAME]           = { .type = NLA_STRING, .len = IFNAMSIZ-1 },
1846        [IFLA_ADDRESS]          = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1847        [IFLA_BROADCAST]        = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1848        [IFLA_MAP]              = { .len = sizeof(struct rtnl_link_ifmap) },
1849        [IFLA_MTU]              = { .type = NLA_U32 },
1850        [IFLA_LINK]             = { .type = NLA_U32 },
1851        [IFLA_MASTER]           = { .type = NLA_U32 },
1852        [IFLA_CARRIER]          = { .type = NLA_U8 },
1853        [IFLA_TXQLEN]           = { .type = NLA_U32 },
1854        [IFLA_WEIGHT]           = { .type = NLA_U32 },
1855        [IFLA_OPERSTATE]        = { .type = NLA_U8 },
1856        [IFLA_LINKMODE]         = { .type = NLA_U8 },
1857        [IFLA_LINKINFO]         = { .type = NLA_NESTED },
1858        [IFLA_NET_NS_PID]       = { .type = NLA_U32 },
1859        [IFLA_NET_NS_FD]        = { .type = NLA_U32 },
1860        /* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to
1861         * allow 0-length string (needed to remove an alias).
1862         */
1863        [IFLA_IFALIAS]          = { .type = NLA_BINARY, .len = IFALIASZ - 1 },
1864        [IFLA_VFINFO_LIST]      = {. type = NLA_NESTED },
1865        [IFLA_VF_PORTS]         = { .type = NLA_NESTED },
1866        [IFLA_PORT_SELF]        = { .type = NLA_NESTED },
1867        [IFLA_AF_SPEC]          = { .type = NLA_NESTED },
1868        [IFLA_EXT_MASK]         = { .type = NLA_U32 },
1869        [IFLA_PROMISCUITY]      = { .type = NLA_U32 },
1870        [IFLA_NUM_TX_QUEUES]    = { .type = NLA_U32 },
1871        [IFLA_NUM_RX_QUEUES]    = { .type = NLA_U32 },
1872        [IFLA_GSO_MAX_SEGS]     = { .type = NLA_U32 },
1873        [IFLA_GSO_MAX_SIZE]     = { .type = NLA_U32 },
1874        [IFLA_PHYS_PORT_ID]     = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1875        [IFLA_CARRIER_CHANGES]  = { .type = NLA_U32 },  /* ignored */
1876        [IFLA_PHYS_SWITCH_ID]   = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1877        [IFLA_LINK_NETNSID]     = { .type = NLA_S32 },
1878        [IFLA_PROTO_DOWN]       = { .type = NLA_U8 },
1879        [IFLA_XDP]              = { .type = NLA_NESTED },
1880        [IFLA_EVENT]            = { .type = NLA_U32 },
1881        [IFLA_GROUP]            = { .type = NLA_U32 },
1882        [IFLA_TARGET_NETNSID]   = { .type = NLA_S32 },
1883        [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 },
1884        [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
1885        [IFLA_MIN_MTU]          = { .type = NLA_U32 },
1886        [IFLA_MAX_MTU]          = { .type = NLA_U32 },
1887        [IFLA_PROP_LIST]        = { .type = NLA_NESTED },
1888        [IFLA_ALT_IFNAME]       = { .type = NLA_STRING,
1889                                    .len = ALTIFNAMSIZ - 1 },
1890        [IFLA_PERM_ADDRESS]     = { .type = NLA_REJECT },
1891        [IFLA_PROTO_DOWN_REASON] = { .type = NLA_NESTED },
1892        [IFLA_NEW_IFINDEX]      = NLA_POLICY_MIN(NLA_S32, 1),
1893        [IFLA_PARENT_DEV_NAME]  = { .type = NLA_NUL_STRING },
1894};
1895
1896static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1897        [IFLA_INFO_KIND]        = { .type = NLA_STRING },
1898        [IFLA_INFO_DATA]        = { .type = NLA_NESTED },
1899        [IFLA_INFO_SLAVE_KIND]  = { .type = NLA_STRING },
1900        [IFLA_INFO_SLAVE_DATA]  = { .type = NLA_NESTED },
1901};
1902
1903static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1904        [IFLA_VF_MAC]           = { .len = sizeof(struct ifla_vf_mac) },
1905        [IFLA_VF_BROADCAST]     = { .type = NLA_REJECT },
1906        [IFLA_VF_VLAN]          = { .len = sizeof(struct ifla_vf_vlan) },
1907        [IFLA_VF_VLAN_LIST]     = { .type = NLA_NESTED },
1908        [IFLA_VF_TX_RATE]       = { .len = sizeof(struct ifla_vf_tx_rate) },
1909        [IFLA_VF_SPOOFCHK]      = { .len = sizeof(struct ifla_vf_spoofchk) },
1910        [IFLA_VF_RATE]          = { .len = sizeof(struct ifla_vf_rate) },
1911        [IFLA_VF_LINK_STATE]    = { .len = sizeof(struct ifla_vf_link_state) },
1912        [IFLA_VF_RSS_QUERY_EN]  = { .len = sizeof(struct ifla_vf_rss_query_en) },
1913        [IFLA_VF_STATS]         = { .type = NLA_NESTED },
1914        [IFLA_VF_TRUST]         = { .len = sizeof(struct ifla_vf_trust) },
1915        [IFLA_VF_IB_NODE_GUID]  = { .len = sizeof(struct ifla_vf_guid) },
1916        [IFLA_VF_IB_PORT_GUID]  = { .len = sizeof(struct ifla_vf_guid) },
1917};
1918
1919static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
1920        [IFLA_PORT_VF]          = { .type = NLA_U32 },
1921        [IFLA_PORT_PROFILE]     = { .type = NLA_STRING,
1922                                    .len = PORT_PROFILE_MAX },
1923        [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
1924                                      .len = PORT_UUID_MAX },
1925        [IFLA_PORT_HOST_UUID]   = { .type = NLA_STRING,
1926                                    .len = PORT_UUID_MAX },
1927        [IFLA_PORT_REQUEST]     = { .type = NLA_U8, },
1928        [IFLA_PORT_RESPONSE]    = { .type = NLA_U16, },
1929
1930        /* Unused, but we need to keep it here since user space could
1931         * fill it. It's also broken with regard to NLA_BINARY use in
1932         * combination with structs.
1933         */
1934        [IFLA_PORT_VSI_TYPE]    = { .type = NLA_BINARY,
1935                                    .len = sizeof(struct ifla_port_vsi) },
1936};
1937
1938static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
1939        [IFLA_XDP_UNSPEC]       = { .strict_start_type = IFLA_XDP_EXPECTED_FD },
1940        [IFLA_XDP_FD]           = { .type = NLA_S32 },
1941        [IFLA_XDP_EXPECTED_FD]  = { .type = NLA_S32 },
1942        [IFLA_XDP_ATTACHED]     = { .type = NLA_U8 },
1943        [IFLA_XDP_FLAGS]        = { .type = NLA_U32 },
1944        [IFLA_XDP_PROG_ID]      = { .type = NLA_U32 },
1945};
1946
1947static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
1948{
1949        const struct rtnl_link_ops *ops = NULL;
1950        struct nlattr *linfo[IFLA_INFO_MAX + 1];
1951
1952        if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0)
1953                return NULL;
1954
1955        if (linfo[IFLA_INFO_KIND]) {
1956                char kind[MODULE_NAME_LEN];
1957
1958                nla_strscpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
1959                ops = rtnl_link_ops_get(kind);
1960        }
1961
1962        return ops;
1963}
1964
1965static bool link_master_filtered(struct net_device *dev, int master_idx)
1966{
1967        struct net_device *master;
1968
1969        if (!master_idx)
1970                return false;
1971
1972        master = netdev_master_upper_dev_get(dev);
1973        if (!master || master->ifindex != master_idx)
1974                return true;
1975
1976        return false;
1977}
1978
1979static bool link_kind_filtered(const struct net_device *dev,
1980                               const struct rtnl_link_ops *kind_ops)
1981{
1982        if (kind_ops && dev->rtnl_link_ops != kind_ops)
1983                return true;
1984
1985        return false;
1986}
1987
1988static bool link_dump_filtered(struct net_device *dev,
1989                               int master_idx,
1990                               const struct rtnl_link_ops *kind_ops)
1991{
1992        if (link_master_filtered(dev, master_idx) ||
1993            link_kind_filtered(dev, kind_ops))
1994                return true;
1995
1996        return false;
1997}
1998
1999/**
2000 * rtnl_get_net_ns_capable - Get netns if sufficiently privileged.
2001 * @sk: netlink socket
2002 * @netnsid: network namespace identifier
2003 *
2004 * Returns the network namespace identified by netnsid on success or an error
2005 * pointer on failure.
2006 */
2007struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
2008{
2009        struct net *net;
2010
2011        net = get_net_ns_by_id(sock_net(sk), netnsid);
2012        if (!net)
2013                return ERR_PTR(-EINVAL);
2014
2015        /* For now, the caller is required to have CAP_NET_ADMIN in
2016         * the user namespace owning the target net ns.
2017         */
2018        if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
2019                put_net(net);
2020                return ERR_PTR(-EACCES);
2021        }
2022        return net;
2023}
2024EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
2025
2026static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh,
2027                                      bool strict_check, struct nlattr **tb,
2028                                      struct netlink_ext_ack *extack)
2029{
2030        int hdrlen;
2031
2032        if (strict_check) {
2033                struct ifinfomsg *ifm;
2034
2035                if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
2036                        NL_SET_ERR_MSG(extack, "Invalid header for link dump");
2037                        return -EINVAL;
2038                }
2039
2040                ifm = nlmsg_data(nlh);
2041                if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
2042                    ifm->ifi_change) {
2043                        NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request");
2044                        return -EINVAL;
2045                }
2046                if (ifm->ifi_index) {
2047                        NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps");
2048                        return -EINVAL;
2049                }
2050
2051                return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb,
2052                                                     IFLA_MAX, ifla_policy,
2053                                                     extack);
2054        }
2055
2056        /* A hack to preserve kernel<->userspace interface.
2057         * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
2058         * However, before Linux v3.9 the code here assumed rtgenmsg and that's
2059         * what iproute2 < v3.9.0 used.
2060         * We can detect the old iproute2. Even including the IFLA_EXT_MASK
2061         * attribute, its netlink message is shorter than struct ifinfomsg.
2062         */
2063        hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
2064                 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
2065
2066        return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy,
2067                                      extack);
2068}
2069
2070static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
2071{
2072        struct netlink_ext_ack *extack = cb->extack;
2073        const struct nlmsghdr *nlh = cb->nlh;
2074        struct net *net = sock_net(skb->sk);
2075        struct net *tgt_net = net;
2076        int h, s_h;
2077        int idx = 0, s_idx;
2078        struct net_device *dev;
2079        struct hlist_head *head;
2080        struct nlattr *tb[IFLA_MAX+1];
2081        u32 ext_filter_mask = 0;
2082        const struct rtnl_link_ops *kind_ops = NULL;
2083        unsigned int flags = NLM_F_MULTI;
2084        int master_idx = 0;
2085        int netnsid = -1;
2086        int err, i;
2087
2088        s_h = cb->args[0];
2089        s_idx = cb->args[1];
2090
2091        err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
2092        if (err < 0) {
2093                if (cb->strict_check)
2094                        return err;
2095
2096                goto walk_entries;
2097        }
2098
2099        for (i = 0; i <= IFLA_MAX; ++i) {
2100                if (!tb[i])
2101                        continue;
2102
2103                /* new attributes should only be added with strict checking */
2104                switch (i) {
2105                case IFLA_TARGET_NETNSID:
2106                        netnsid = nla_get_s32(tb[i]);
2107                        tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
2108                        if (IS_ERR(tgt_net)) {
2109                                NL_SET_ERR_MSG(extack, "Invalid target network namespace id");
2110                                return PTR_ERR(tgt_net);
2111                        }
2112                        break;
2113                case IFLA_EXT_MASK:
2114                        ext_filter_mask = nla_get_u32(tb[i]);
2115                        break;
2116                case IFLA_MASTER:
2117                        master_idx = nla_get_u32(tb[i]);
2118                        break;
2119                case IFLA_LINKINFO:
2120                        kind_ops = linkinfo_to_kind_ops(tb[i]);
2121                        break;
2122                default:
2123                        if (cb->strict_check) {
2124                                NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request");
2125                                return -EINVAL;
2126                        }
2127                }
2128        }
2129
2130        if (master_idx || kind_ops)
2131                flags |= NLM_F_DUMP_FILTERED;
2132
2133walk_entries:
2134        for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2135                idx = 0;
2136                head = &tgt_net->dev_index_head[h];
2137                hlist_for_each_entry(dev, head, index_hlist) {
2138                        if (link_dump_filtered(dev, master_idx, kind_ops))
2139                                goto cont;
2140                        if (idx < s_idx)
2141                                goto cont;
2142                        err = rtnl_fill_ifinfo(skb, dev, net,
2143                                               RTM_NEWLINK,
2144                                               NETLINK_CB(cb->skb).portid,
2145                                               nlh->nlmsg_seq, 0, flags,
2146                                               ext_filter_mask, 0, NULL, 0,
2147                                               netnsid, GFP_KERNEL);
2148
2149                        if (err < 0) {
2150                                if (likely(skb->len))
2151                                        goto out;
2152
2153                                goto out_err;
2154                        }
2155cont:
2156                        idx++;
2157                }
2158        }
2159out:
2160        err = skb->len;
2161out_err:
2162        cb->args[1] = idx;
2163        cb->args[0] = h;
2164        cb->seq = tgt_net->dev_base_seq;
2165        nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2166        if (netnsid >= 0)
2167                put_net(tgt_net);
2168
2169        return err;
2170}
2171
2172int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
2173                        struct netlink_ext_ack *exterr)
2174{
2175        return nla_parse_deprecated(tb, IFLA_MAX, head, len, ifla_policy,
2176                                    exterr);
2177}
2178EXPORT_SYMBOL(rtnl_nla_parse_ifla);
2179
2180struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
2181{
2182        struct net *net;
2183        /* Examine the link attributes and figure out which
2184         * network namespace we are talking about.
2185         */
2186        if (tb[IFLA_NET_NS_PID])
2187                net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
2188        else if (tb[IFLA_NET_NS_FD])
2189                net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
2190        else
2191                net = get_net(src_net);
2192        return net;
2193}
2194EXPORT_SYMBOL(rtnl_link_get_net);
2195
2196/* Figure out which network namespace we are talking about by
2197 * examining the link attributes in the following order:
2198 *
2199 * 1. IFLA_NET_NS_PID
2200 * 2. IFLA_NET_NS_FD
2201 * 3. IFLA_TARGET_NETNSID
2202 */
2203static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
2204                                               struct nlattr *tb[])
2205{
2206        struct net *net;
2207
2208        if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
2209                return rtnl_link_get_net(src_net, tb);
2210
2211        if (!tb[IFLA_TARGET_NETNSID])
2212                return get_net(src_net);
2213
2214        net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
2215        if (!net)
2216                return ERR_PTR(-EINVAL);
2217
2218        return net;
2219}
2220
2221static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2222                                             struct net *src_net,
2223                                             struct nlattr *tb[], int cap)
2224{
2225        struct net *net;
2226
2227        net = rtnl_link_get_net_by_nlattr(src_net, tb);
2228        if (IS_ERR(net))
2229                return net;
2230
2231        if (!netlink_ns_capable(skb, net->user_ns, cap)) {
2232                put_net(net);
2233                return ERR_PTR(-EPERM);
2234        }
2235
2236        return net;
2237}
2238
2239/* Verify that rtnetlink requests do not pass additional properties
2240 * potentially referring to different network namespaces.
2241 */
2242static int rtnl_ensure_unique_netns(struct nlattr *tb[],
2243                                    struct netlink_ext_ack *extack,
2244                                    bool netns_id_only)
2245{
2246
2247        if (netns_id_only) {
2248                if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2249                        return 0;
2250
2251                NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2252                return -EOPNOTSUPP;
2253        }
2254
2255        if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
2256                goto invalid_attr;
2257
2258        if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
2259                goto invalid_attr;
2260
2261        if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
2262                goto invalid_attr;
2263
2264        return 0;
2265
2266invalid_attr:
2267        NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2268        return -EINVAL;
2269}
2270
2271static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
2272{
2273        if (dev) {
2274                if (tb[IFLA_ADDRESS] &&
2275                    nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
2276                        return -EINVAL;
2277
2278                if (tb[IFLA_BROADCAST] &&
2279                    nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
2280                        return -EINVAL;
2281        }
2282
2283        if (tb[IFLA_AF_SPEC]) {
2284                struct nlattr *af;
2285                int rem, err;
2286
2287                nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2288                        const struct rtnl_af_ops *af_ops;
2289
2290                        af_ops = rtnl_af_lookup(nla_type(af));
2291                        if (!af_ops)
2292                                return -EAFNOSUPPORT;
2293
2294                        if (!af_ops->set_link_af)
2295                                return -EOPNOTSUPP;
2296
2297                        if (af_ops->validate_link_af) {
2298                                err = af_ops->validate_link_af(dev, af);
2299                                if (err < 0)
2300                                        return err;
2301                        }
2302                }
2303        }
2304
2305        return 0;
2306}
2307
2308static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
2309                                  int guid_type)
2310{
2311        const struct net_device_ops *ops = dev->netdev_ops;
2312
2313        return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
2314}
2315
2316static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
2317{
2318        if (dev->type != ARPHRD_INFINIBAND)
2319                return -EOPNOTSUPP;
2320
2321        return handle_infiniband_guid(dev, ivt, guid_type);
2322}
2323
2324static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
2325{
2326        const struct net_device_ops *ops = dev->netdev_ops;
2327        int err = -EINVAL;
2328
2329        if (tb[IFLA_VF_MAC]) {
2330                struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
2331
2332                if (ivm->vf >= INT_MAX)
2333                        return -EINVAL;
2334                err = -EOPNOTSUPP;
2335                if (ops->ndo_set_vf_mac)
2336                        err = ops->ndo_set_vf_mac(dev, ivm->vf,
2337                                                  ivm->mac);
2338                if (err < 0)
2339                        return err;
2340        }
2341
2342        if (tb[IFLA_VF_VLAN]) {
2343                struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
2344
2345                if (ivv->vf >= INT_MAX)
2346                        return -EINVAL;
2347                err = -EOPNOTSUPP;
2348                if (ops->ndo_set_vf_vlan)
2349                        err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
2350                                                   ivv->qos,
2351                                                   htons(ETH_P_8021Q));
2352                if (err < 0)
2353                        return err;
2354        }
2355
2356        if (tb[IFLA_VF_VLAN_LIST]) {
2357                struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
2358                struct nlattr *attr;
2359                int rem, len = 0;
2360
2361                err = -EOPNOTSUPP;
2362                if (!ops->ndo_set_vf_vlan)
2363                        return err;
2364
2365                nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
2366                        if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
2367                            nla_len(attr) < NLA_HDRLEN) {
2368                                return -EINVAL;
2369                        }
2370                        if (len >= MAX_VLAN_LIST_LEN)
2371                                return -EOPNOTSUPP;
2372                        ivvl[len] = nla_data(attr);
2373
2374                        len++;
2375                }
2376                if (len == 0)
2377                        return -EINVAL;
2378
2379                if (ivvl[0]->vf >= INT_MAX)
2380                        return -EINVAL;
2381                err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
2382                                           ivvl[0]->qos, ivvl[0]->vlan_proto);
2383                if (err < 0)
2384                        return err;
2385        }
2386
2387        if (tb[IFLA_VF_TX_RATE]) {
2388                struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
2389                struct ifla_vf_info ivf;
2390
2391                if (ivt->vf >= INT_MAX)
2392                        return -EINVAL;
2393                err = -EOPNOTSUPP;
2394                if (ops->ndo_get_vf_config)
2395                        err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
2396                if (err < 0)
2397                        return err;
2398
2399                err = -EOPNOTSUPP;
2400                if (ops->ndo_set_vf_rate)
2401                        err = ops->ndo_set_vf_rate(dev, ivt->vf,
2402                                                   ivf.min_tx_rate,
2403                                                   ivt->rate);
2404                if (err < 0)
2405                        return err;
2406        }
2407
2408        if (tb[IFLA_VF_RATE]) {
2409                struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
2410
2411                if (ivt->vf >= INT_MAX)
2412                        return -EINVAL;
2413                err = -EOPNOTSUPP;
2414                if (ops->ndo_set_vf_rate)
2415                        err = ops->ndo_set_vf_rate(dev, ivt->vf,
2416                                                   ivt->min_tx_rate,
2417                                                   ivt->max_tx_rate);
2418                if (err < 0)
2419                        return err;
2420        }
2421
2422        if (tb[IFLA_VF_SPOOFCHK]) {
2423                struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
2424
2425                if (ivs->vf >= INT_MAX)
2426                        return -EINVAL;
2427                err = -EOPNOTSUPP;
2428                if (ops->ndo_set_vf_spoofchk)
2429                        err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
2430                                                       ivs->setting);
2431                if (err < 0)
2432                        return err;
2433        }
2434
2435        if (tb[IFLA_VF_LINK_STATE]) {
2436                struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
2437
2438                if (ivl->vf >= INT_MAX)
2439                        return -EINVAL;
2440                err = -EOPNOTSUPP;
2441                if (ops->ndo_set_vf_link_state)
2442                        err = ops->ndo_set_vf_link_state(dev, ivl->vf,
2443                                                         ivl->link_state);
2444                if (err < 0)
2445                        return err;
2446        }
2447
2448        if (tb[IFLA_VF_RSS_QUERY_EN]) {
2449                struct ifla_vf_rss_query_en *ivrssq_en;
2450
2451                err = -EOPNOTSUPP;
2452                ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
2453                if (ivrssq_en->vf >= INT_MAX)
2454                        return -EINVAL;
2455                if (ops->ndo_set_vf_rss_query_en)
2456                        err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
2457                                                           ivrssq_en->setting);
2458                if (err < 0)
2459                        return err;
2460        }
2461
2462        if (tb[IFLA_VF_TRUST]) {
2463                struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
2464
2465                if (ivt->vf >= INT_MAX)
2466                        return -EINVAL;
2467                err = -EOPNOTSUPP;
2468                if (ops->ndo_set_vf_trust)
2469                        err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
2470                if (err < 0)
2471                        return err;
2472        }
2473
2474        if (tb[IFLA_VF_IB_NODE_GUID]) {
2475                struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
2476
2477                if (ivt->vf >= INT_MAX)
2478                        return -EINVAL;
2479                if (!ops->ndo_set_vf_guid)
2480                        return -EOPNOTSUPP;
2481                return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
2482        }
2483
2484        if (tb[IFLA_VF_IB_PORT_GUID]) {
2485                struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
2486
2487                if (ivt->vf >= INT_MAX)
2488                        return -EINVAL;
2489                if (!ops->ndo_set_vf_guid)
2490                        return -EOPNOTSUPP;
2491
2492                return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
2493        }
2494
2495        return err;
2496}
2497
2498static int do_set_master(struct net_device *dev, int ifindex,
2499                         struct netlink_ext_ack *extack)
2500{
2501        struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
2502        const struct net_device_ops *ops;
2503        int err;
2504
2505        if (upper_dev) {
2506                if (upper_dev->ifindex == ifindex)
2507                        return 0;
2508                ops = upper_dev->netdev_ops;
2509                if (ops->ndo_del_slave) {
2510                        err = ops->ndo_del_slave(upper_dev, dev);
2511                        if (err)
2512                                return err;
2513                } else {
2514                        return -EOPNOTSUPP;
2515                }
2516        }
2517
2518        if (ifindex) {
2519                upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
2520                if (!upper_dev)
2521                        return -EINVAL;
2522                ops = upper_dev->netdev_ops;
2523                if (ops->ndo_add_slave) {
2524                        err = ops->ndo_add_slave(upper_dev, dev, extack);
2525                        if (err)
2526                                return err;
2527                } else {
2528                        return -EOPNOTSUPP;
2529                }
2530        }
2531        return 0;
2532}
2533
2534static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = {
2535        [IFLA_PROTO_DOWN_REASON_MASK]   = { .type = NLA_U32 },
2536        [IFLA_PROTO_DOWN_REASON_VALUE]  = { .type = NLA_U32 },
2537};
2538
2539static int do_set_proto_down(struct net_device *dev,
2540                             struct nlattr *nl_proto_down,
2541                             struct nlattr *nl_proto_down_reason,
2542                             struct netlink_ext_ack *extack)
2543{
2544        struct nlattr *pdreason[IFLA_PROTO_DOWN_REASON_MAX + 1];
2545        const struct net_device_ops *ops = dev->netdev_ops;
2546        unsigned long mask = 0;
2547        u32 value;
2548        bool proto_down;
2549        int err;
2550
2551        if (!ops->ndo_change_proto_down) {
2552                NL_SET_ERR_MSG(extack,  "Protodown not supported by device");
2553                return -EOPNOTSUPP;
2554        }
2555
2556        if (nl_proto_down_reason) {
2557                err = nla_parse_nested_deprecated(pdreason,
2558                                                  IFLA_PROTO_DOWN_REASON_MAX,
2559                                                  nl_proto_down_reason,
2560                                                  ifla_proto_down_reason_policy,
2561                                                  NULL);
2562                if (err < 0)
2563                        return err;
2564
2565                if (!pdreason[IFLA_PROTO_DOWN_REASON_VALUE]) {
2566                        NL_SET_ERR_MSG(extack, "Invalid protodown reason value");
2567                        return -EINVAL;
2568                }
2569
2570                value = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_VALUE]);
2571
2572                if (pdreason[IFLA_PROTO_DOWN_REASON_MASK])
2573                        mask = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_MASK]);
2574
2575                dev_change_proto_down_reason(dev, mask, value);
2576        }
2577
2578        if (nl_proto_down) {
2579                proto_down = nla_get_u8(nl_proto_down);
2580
2581                /* Don't turn off protodown if there are active reasons */
2582                if (!proto_down && dev->proto_down_reason) {
2583                        NL_SET_ERR_MSG(extack, "Cannot clear protodown, active reasons");
2584                        return -EBUSY;
2585                }
2586                err = dev_change_proto_down(dev,
2587                                            proto_down);
2588                if (err)
2589                        return err;
2590        }
2591
2592        return 0;
2593}
2594
2595#define DO_SETLINK_MODIFIED     0x01
2596/* notify flag means notify + modified. */
2597#define DO_SETLINK_NOTIFY       0x03
2598static int do_setlink(const struct sk_buff *skb,
2599                      struct net_device *dev, struct ifinfomsg *ifm,
2600                      struct netlink_ext_ack *extack,
2601                      struct nlattr **tb, char *ifname, int status)
2602{
2603        const struct net_device_ops *ops = dev->netdev_ops;
2604        int err;
2605
2606        err = validate_linkmsg(dev, tb);
2607        if (err < 0)
2608                return err;
2609
2610        if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
2611                const char *pat = ifname && ifname[0] ? ifname : NULL;
2612                struct net *net;
2613                int new_ifindex;
2614
2615                net = rtnl_link_get_net_capable(skb, dev_net(dev),
2616                                                tb, CAP_NET_ADMIN);
2617                if (IS_ERR(net)) {
2618                        err = PTR_ERR(net);
2619                        goto errout;
2620                }
2621
2622                if (tb[IFLA_NEW_IFINDEX])
2623                        new_ifindex = nla_get_s32(tb[IFLA_NEW_IFINDEX]);
2624                else
2625                        new_ifindex = 0;
2626
2627                err = __dev_change_net_namespace(dev, net, pat, new_ifindex);
2628                put_net(net);
2629                if (err)
2630                        goto errout;
2631                status |= DO_SETLINK_MODIFIED;
2632        }
2633
2634        if (tb[IFLA_MAP]) {
2635                struct rtnl_link_ifmap *u_map;
2636                struct ifmap k_map;
2637
2638                if (!ops->ndo_set_config) {
2639                        err = -EOPNOTSUPP;
2640                        goto errout;
2641                }
2642
2643                if (!netif_device_present(dev)) {
2644                        err = -ENODEV;
2645                        goto errout;
2646                }
2647
2648                u_map = nla_data(tb[IFLA_MAP]);
2649                k_map.mem_start = (unsigned long) u_map->mem_start;
2650                k_map.mem_end = (unsigned long) u_map->mem_end;
2651                k_map.base_addr = (unsigned short) u_map->base_addr;
2652                k_map.irq = (unsigned char) u_map->irq;
2653                k_map.dma = (unsigned char) u_map->dma;
2654                k_map.port = (unsigned char) u_map->port;
2655
2656                err = ops->ndo_set_config(dev, &k_map);
2657                if (err < 0)
2658                        goto errout;
2659
2660                status |= DO_SETLINK_NOTIFY;
2661        }
2662
2663        if (tb[IFLA_ADDRESS]) {
2664                struct sockaddr *sa;
2665                int len;
2666
2667                len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len,
2668                                                  sizeof(*sa));
2669                sa = kmalloc(len, GFP_KERNEL);
2670                if (!sa) {
2671                        err = -ENOMEM;
2672                        goto errout;
2673                }
2674                sa->sa_family = dev->type;
2675                memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
2676                       dev->addr_len);
2677                err = dev_set_mac_address_user(dev, sa, extack);
2678                kfree(sa);
2679                if (err)
2680                        goto errout;
2681                status |= DO_SETLINK_MODIFIED;
2682        }
2683
2684        if (tb[IFLA_MTU]) {
2685                err = dev_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack);
2686                if (err < 0)
2687                        goto errout;
2688                status |= DO_SETLINK_MODIFIED;
2689        }
2690
2691        if (tb[IFLA_GROUP]) {
2692                dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
2693                status |= DO_SETLINK_NOTIFY;
2694        }
2695
2696        /*
2697         * Interface selected by interface index but interface
2698         * name provided implies that a name change has been
2699         * requested.
2700         */
2701        if (ifm->ifi_index > 0 && ifname[0]) {
2702                err = dev_change_name(dev, ifname);
2703                if (err < 0)
2704                        goto errout;
2705                status |= DO_SETLINK_MODIFIED;
2706        }
2707
2708        if (tb[IFLA_IFALIAS]) {
2709                err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
2710                                    nla_len(tb[IFLA_IFALIAS]));
2711                if (err < 0)
2712                        goto errout;
2713                status |= DO_SETLINK_NOTIFY;
2714        }
2715
2716        if (tb[IFLA_BROADCAST]) {
2717                nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
2718                call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
2719        }
2720
2721        if (ifm->ifi_flags || ifm->ifi_change) {
2722                err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
2723                                       extack);
2724                if (err < 0)
2725                        goto errout;
2726        }
2727
2728        if (tb[IFLA_MASTER]) {
2729                err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
2730                if (err)
2731                        goto errout;
2732                status |= DO_SETLINK_MODIFIED;
2733        }
2734
2735        if (tb[IFLA_CARRIER]) {
2736                err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
2737                if (err)
2738                        goto errout;
2739                status |= DO_SETLINK_MODIFIED;
2740        }
2741
2742        if (tb[IFLA_TXQLEN]) {
2743                unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]);
2744
2745                err = dev_change_tx_queue_len(dev, value);
2746                if (err)
2747                        goto errout;
2748                status |= DO_SETLINK_MODIFIED;
2749        }
2750
2751        if (tb[IFLA_GSO_MAX_SIZE]) {
2752                u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]);
2753
2754                if (max_size > GSO_MAX_SIZE) {
2755                        err = -EINVAL;
2756                        goto errout;
2757                }
2758
2759                if (dev->gso_max_size ^ max_size) {
2760                        netif_set_gso_max_size(dev, max_size);
2761                        status |= DO_SETLINK_MODIFIED;
2762                }
2763        }
2764
2765        if (tb[IFLA_GSO_MAX_SEGS]) {
2766                u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
2767
2768                if (max_segs > GSO_MAX_SEGS) {
2769                        err = -EINVAL;
2770                        goto errout;
2771                }
2772
2773                if (dev->gso_max_segs ^ max_segs) {
2774                        dev->gso_max_segs = max_segs;
2775                        status |= DO_SETLINK_MODIFIED;
2776                }
2777        }
2778
2779        if (tb[IFLA_OPERSTATE])
2780                set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
2781
2782        if (tb[IFLA_LINKMODE]) {
2783                unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);
2784
2785                write_lock_bh(&dev_base_lock);
2786                if (dev->link_mode ^ value)
2787                        status |= DO_SETLINK_NOTIFY;
2788                dev->link_mode = value;
2789                write_unlock_bh(&dev_base_lock);
2790        }
2791
2792        if (tb[IFLA_VFINFO_LIST]) {
2793                struct nlattr *vfinfo[IFLA_VF_MAX + 1];
2794                struct nlattr *attr;
2795                int rem;
2796
2797                nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
2798                        if (nla_type(attr) != IFLA_VF_INFO ||
2799                            nla_len(attr) < NLA_HDRLEN) {
2800                                err = -EINVAL;
2801                                goto errout;
2802                        }
2803                        err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX,
2804                                                          attr,
2805                                                          ifla_vf_policy,
2806                                                          NULL);
2807                        if (err < 0)
2808                                goto errout;
2809                        err = do_setvfinfo(dev, vfinfo);
2810                        if (err < 0)
2811                                goto errout;
2812                        status |= DO_SETLINK_NOTIFY;
2813                }
2814        }
2815        err = 0;
2816
2817        if (tb[IFLA_VF_PORTS]) {
2818                struct nlattr *port[IFLA_PORT_MAX+1];
2819                struct nlattr *attr;
2820                int vf;
2821                int rem;
2822
2823                err = -EOPNOTSUPP;
2824                if (!ops->ndo_set_vf_port)
2825                        goto errout;
2826
2827                nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
2828                        if (nla_type(attr) != IFLA_VF_PORT ||
2829                            nla_len(attr) < NLA_HDRLEN) {
2830                                err = -EINVAL;
2831                                goto errout;
2832                        }
2833                        err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
2834                                                          attr,
2835                                                          ifla_port_policy,
2836                                                          NULL);
2837                        if (err < 0)
2838                                goto errout;
2839                        if (!port[IFLA_PORT_VF]) {
2840                                err = -EOPNOTSUPP;
2841                                goto errout;
2842                        }
2843                        vf = nla_get_u32(port[IFLA_PORT_VF]);
2844                        err = ops->ndo_set_vf_port(dev, vf, port);
2845                        if (err < 0)
2846                                goto errout;
2847                        status |= DO_SETLINK_NOTIFY;
2848                }
2849        }
2850        err = 0;
2851
2852        if (tb[IFLA_PORT_SELF]) {
2853                struct nlattr *port[IFLA_PORT_MAX+1];
2854
2855                err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
2856                                                  tb[IFLA_PORT_SELF],
2857                                                  ifla_port_policy, NULL);
2858                if (err < 0)
2859                        goto errout;
2860
2861                err = -EOPNOTSUPP;
2862                if (ops->ndo_set_vf_port)
2863                        err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
2864                if (err < 0)
2865                        goto errout;
2866                status |= DO_SETLINK_NOTIFY;
2867        }
2868
2869        if (tb[IFLA_AF_SPEC]) {
2870                struct nlattr *af;
2871                int rem;
2872
2873                nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2874                        const struct rtnl_af_ops *af_ops;
2875
2876                        BUG_ON(!(af_ops = rtnl_af_lookup(nla_type(af))));
2877
2878                        err = af_ops->set_link_af(dev, af, extack);
2879                        if (err < 0)
2880                                goto errout;
2881
2882                        status |= DO_SETLINK_NOTIFY;
2883                }
2884        }
2885        err = 0;
2886
2887        if (tb[IFLA_PROTO_DOWN] || tb[IFLA_PROTO_DOWN_REASON]) {
2888                err = do_set_proto_down(dev, tb[IFLA_PROTO_DOWN],
2889                                        tb[IFLA_PROTO_DOWN_REASON], extack);
2890                if (err)
2891                        goto errout;
2892                status |= DO_SETLINK_NOTIFY;
2893        }
2894
2895        if (tb[IFLA_XDP]) {
2896                struct nlattr *xdp[IFLA_XDP_MAX + 1];
2897                u32 xdp_flags = 0;
2898
2899                err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX,
2900                                                  tb[IFLA_XDP],
2901                                                  ifla_xdp_policy, NULL);
2902                if (err < 0)
2903                        goto errout;
2904
2905                if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) {
2906                        err = -EINVAL;
2907                        goto errout;
2908                }
2909
2910                if (xdp[IFLA_XDP_FLAGS]) {
2911                        xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
2912                        if (xdp_flags & ~XDP_FLAGS_MASK) {
2913                                err = -EINVAL;
2914                                goto errout;
2915                        }
2916                        if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) {
2917                                err = -EINVAL;
2918                                goto errout;
2919                        }
2920                }
2921
2922                if (xdp[IFLA_XDP_FD]) {
2923                        int expected_fd = -1;
2924
2925                        if (xdp_flags & XDP_FLAGS_REPLACE) {
2926                                if (!xdp[IFLA_XDP_EXPECTED_FD]) {
2927                                        err = -EINVAL;
2928                                        goto errout;
2929                                }
2930                                expected_fd =
2931                                        nla_get_s32(xdp[IFLA_XDP_EXPECTED_FD]);
2932                        }
2933
2934                        err = dev_change_xdp_fd(dev, extack,
2935                                                nla_get_s32(xdp[IFLA_XDP_FD]),
2936                                                expected_fd,
2937                                                xdp_flags);
2938                        if (err)
2939                                goto errout;
2940                        status |= DO_SETLINK_NOTIFY;
2941                }
2942        }
2943
2944errout:
2945        if (status & DO_SETLINK_MODIFIED) {
2946                if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)
2947                        netdev_state_change(dev);
2948
2949                if (err < 0)
2950                        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",
2951                                             dev->name);
2952        }
2953
2954        return err;
2955}
2956
2957static struct net_device *rtnl_dev_get(struct net *net,
2958                                       struct nlattr *ifname_attr,
2959                                       struct nlattr *altifname_attr,
2960                                       char *ifname)
2961{
2962        char buffer[ALTIFNAMSIZ];
2963
2964        if (!ifname) {
2965                ifname = buffer;
2966                if (ifname_attr)
2967                        nla_strscpy(ifname, ifname_attr, IFNAMSIZ);
2968                else if (altifname_attr)
2969                        nla_strscpy(ifname, altifname_attr, ALTIFNAMSIZ);
2970                else
2971                        return NULL;
2972        }
2973
2974        return __dev_get_by_name(net, ifname);
2975}
2976
2977static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
2978                        struct netlink_ext_ack *extack)
2979{
2980        struct net *net = sock_net(skb->sk);
2981        struct ifinfomsg *ifm;
2982        struct net_device *dev;
2983        int err;
2984        struct nlattr *tb[IFLA_MAX+1];
2985        char ifname[IFNAMSIZ];
2986
2987        err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
2988                                     ifla_policy, extack);
2989        if (err < 0)
2990                goto errout;
2991
2992        err = rtnl_ensure_unique_netns(tb, extack, false);
2993        if (err < 0)
2994                goto errout;
2995
2996        if (tb[IFLA_IFNAME])
2997                nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2998        else
2999                ifname[0] = '\0';
3000
3001        err = -EINVAL;
3002        ifm = nlmsg_data(nlh);
3003        if (ifm->ifi_index > 0)
3004                dev = __dev_get_by_index(net, ifm->ifi_index);
3005        else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3006                dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
3007        else
3008                goto errout;
3009
3010        if (dev == NULL) {
3011                err = -ENODEV;
3012                goto errout;
3013        }
3014
3015        err = do_setlink(skb, dev, ifm, extack, tb, ifname, 0);
3016errout:
3017        return err;
3018}
3019
3020static int rtnl_group_dellink(const struct net *net, int group)
3021{
3022        struct net_device *dev, *aux;
3023        LIST_HEAD(list_kill);
3024        bool found = false;
3025
3026        if (!group)
3027                return -EPERM;
3028
3029        for_each_netdev(net, dev) {
3030                if (dev->group == group) {
3031                        const struct rtnl_link_ops *ops;
3032
3033                        found = true;
3034                        ops = dev->rtnl_link_ops;
3035                        if (!ops || !ops->dellink)
3036                                return -EOPNOTSUPP;
3037                }
3038        }
3039
3040        if (!found)
3041                return -ENODEV;
3042
3043        for_each_netdev_safe(net, dev, aux) {
3044                if (dev->group == group) {
3045                        const struct rtnl_link_ops *ops;
3046
3047                        ops = dev->rtnl_link_ops;
3048                        ops->dellink(dev, &list_kill);
3049                }
3050        }
3051        unregister_netdevice_many(&list_kill);
3052
3053        return 0;
3054}
3055
3056int rtnl_delete_link(struct net_device *dev)
3057{
3058        const struct rtnl_link_ops *ops;
3059        LIST_HEAD(list_kill);
3060
3061        ops = dev->rtnl_link_ops;
3062        if (!ops || !ops->dellink)
3063                return -EOPNOTSUPP;
3064
3065        ops->dellink(dev, &list_kill);
3066        unregister_netdevice_many(&list_kill);
3067
3068        return 0;
3069}
3070EXPORT_SYMBOL_GPL(rtnl_delete_link);
3071
3072static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
3073                        struct netlink_ext_ack *extack)
3074{
3075        struct net *net = sock_net(skb->sk);
3076        struct net *tgt_net = net;
3077        struct net_device *dev = NULL;
3078        struct ifinfomsg *ifm;
3079        struct nlattr *tb[IFLA_MAX+1];
3080        int err;
3081        int netnsid = -1;
3082
3083        err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3084                                     ifla_policy, extack);
3085        if (err < 0)
3086                return err;
3087
3088        err = rtnl_ensure_unique_netns(tb, extack, true);
3089        if (err < 0)
3090                return err;
3091
3092        if (tb[IFLA_TARGET_NETNSID]) {
3093                netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3094                tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
3095                if (IS_ERR(tgt_net))
3096                        return PTR_ERR(tgt_net);
3097        }
3098
3099        err = -EINVAL;
3100        ifm = nlmsg_data(nlh);
3101        if (ifm->ifi_index > 0)
3102                dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3103        else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3104                dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3105                                   tb[IFLA_ALT_IFNAME], NULL);
3106        else if (tb[IFLA_GROUP])
3107                err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
3108        else
3109                goto out;
3110
3111        if (!dev) {
3112                if (tb[IFLA_IFNAME] || ifm->ifi_index > 0)
3113                        err = -ENODEV;
3114
3115                goto out;
3116        }
3117
3118        err = rtnl_delete_link(dev);
3119
3120out:
3121        if (netnsid >= 0)
3122                put_net(tgt_net);
3123
3124        return err;
3125}
3126
3127int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm)
3128{
3129        unsigned int old_flags;
3130        int err;
3131
3132        old_flags = dev->flags;
3133        if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
3134                err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
3135                                         NULL);
3136                if (err < 0)
3137                        return err;
3138        }
3139
3140        if (dev->rtnl_link_state == RTNL_LINK_INITIALIZED) {
3141                __dev_notify_flags(dev, old_flags, (old_flags ^ dev->flags));
3142        } else {
3143                dev->rtnl_link_state = RTNL_LINK_INITIALIZED;
3144                __dev_notify_flags(dev, old_flags, ~0U);
3145        }
3146        return 0;
3147}
3148EXPORT_SYMBOL(rtnl_configure_link);
3149
3150struct net_device *rtnl_create_link(struct net *net, const char *ifname,
3151                                    unsigned char name_assign_type,
3152                                    const struct rtnl_link_ops *ops,
3153                                    struct nlattr *tb[],
3154                                    struct netlink_ext_ack *extack)
3155{
3156        struct net_device *dev;
3157        unsigned int num_tx_queues = 1;
3158        unsigned int num_rx_queues = 1;
3159
3160        if (tb[IFLA_NUM_TX_QUEUES])
3161                num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
3162        else if (ops->get_num_tx_queues)
3163                num_tx_queues = ops->get_num_tx_queues();
3164
3165        if (tb[IFLA_NUM_RX_QUEUES])
3166                num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
3167        else if (ops->get_num_rx_queues)
3168                num_rx_queues = ops->get_num_rx_queues();
3169
3170        if (num_tx_queues < 1 || num_tx_queues > 4096) {
3171                NL_SET_ERR_MSG(extack, "Invalid number of transmit queues");
3172                return ERR_PTR(-EINVAL);
3173        }
3174
3175        if (num_rx_queues < 1 || num_rx_queues > 4096) {
3176                NL_SET_ERR_MSG(extack, "Invalid number of receive queues");
3177                return ERR_PTR(-EINVAL);
3178        }
3179
3180        if (ops->alloc) {
3181                dev = ops->alloc(tb, ifname, name_assign_type,
3182                                 num_tx_queues, num_rx_queues);
3183                if (IS_ERR(dev))
3184                        return dev;
3185        } else {
3186                dev = alloc_netdev_mqs(ops->priv_size, ifname,
3187                                       name_assign_type, ops->setup,
3188                                       num_tx_queues, num_rx_queues);
3189        }
3190
3191        if (!dev)
3192                return ERR_PTR(-ENOMEM);
3193
3194        dev_net_set(dev, net);
3195        dev->rtnl_link_ops = ops;
3196        dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
3197
3198        if (tb[IFLA_MTU]) {
3199                u32 mtu = nla_get_u32(tb[IFLA_MTU]);
3200                int err;
3201
3202                err = dev_validate_mtu(dev, mtu, extack);
3203                if (err) {
3204                        free_netdev(dev);
3205                        return ERR_PTR(err);
3206                }
3207                dev->mtu = mtu;
3208        }
3209        if (tb[IFLA_ADDRESS]) {
3210                memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
3211                                nla_len(tb[IFLA_ADDRESS]));
3212                dev->addr_assign_type = NET_ADDR_SET;
3213        }
3214        if (tb[IFLA_BROADCAST])
3215                memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
3216                                nla_len(tb[IFLA_BROADCAST]));
3217        if (tb[IFLA_TXQLEN])
3218                dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
3219        if (tb[IFLA_OPERSTATE])
3220                set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
3221        if (tb[IFLA_LINKMODE])
3222                dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
3223        if (tb[IFLA_GROUP])
3224                dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
3225        if (tb[IFLA_GSO_MAX_SIZE])
3226                netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE]));
3227        if (tb[IFLA_GSO_MAX_SEGS])
3228                dev->gso_max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
3229
3230        return dev;
3231}
3232EXPORT_SYMBOL(rtnl_create_link);
3233
3234static int rtnl_group_changelink(const struct sk_buff *skb,
3235                struct net *net, int group,
3236                struct ifinfomsg *ifm,
3237                struct netlink_ext_ack *extack,
3238                struct nlattr **tb)
3239{
3240        struct net_device *dev, *aux;
3241        int err;
3242
3243        for_each_netdev_safe(net, dev, aux) {
3244                if (dev->group == group) {
3245                        err = do_setlink(skb, dev, ifm, extack, tb, NULL, 0);
3246                        if (err < 0)
3247                                return err;
3248                }
3249        }
3250
3251        return 0;
3252}
3253
3254static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3255                          struct nlattr **attr, struct netlink_ext_ack *extack)
3256{
3257        struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3258        unsigned char name_assign_type = NET_NAME_USER;
3259        struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
3260        const struct rtnl_link_ops *m_ops = NULL;
3261        struct net_device *master_dev = NULL;
3262        struct net *net = sock_net(skb->sk);
3263        const struct rtnl_link_ops *ops;
3264        struct nlattr *tb[IFLA_MAX + 1];
3265        struct net *dest_net, *link_net;
3266        struct nlattr **slave_data;
3267        char kind[MODULE_NAME_LEN];
3268        struct net_device *dev;
3269        struct ifinfomsg *ifm;
3270        char ifname[IFNAMSIZ];
3271        struct nlattr **data;
3272        int err;
3273
3274#ifdef CONFIG_MODULES
3275replay:
3276#endif
3277        err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3278                                     ifla_policy, extack);
3279        if (err < 0)
3280                return err;
3281
3282        err = rtnl_ensure_unique_netns(tb, extack, false);
3283        if (err < 0)
3284                return err;
3285
3286        if (tb[IFLA_IFNAME])
3287                nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3288        else
3289                ifname[0] = '\0';
3290
3291        ifm = nlmsg_data(nlh);
3292        if (ifm->ifi_index > 0)
3293                dev = __dev_get_by_index(net, ifm->ifi_index);
3294        else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3295                dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
3296        else
3297                dev = NULL;
3298
3299        if (dev) {
3300                master_dev = netdev_master_upper_dev_get(dev);
3301                if (master_dev)
3302                        m_ops = master_dev->rtnl_link_ops;
3303        }
3304
3305        err = validate_linkmsg(dev, tb);
3306        if (err < 0)
3307                return err;
3308
3309        if (tb[IFLA_LINKINFO]) {
3310                err = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX,
3311                                                  tb[IFLA_LINKINFO],
3312                                                  ifla_info_policy, NULL);
3313                if (err < 0)
3314                        return err;
3315        } else
3316                memset(linkinfo, 0, sizeof(linkinfo));
3317
3318        if (linkinfo[IFLA_INFO_KIND]) {
3319                nla_strscpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
3320                ops = rtnl_link_ops_get(kind);
3321        } else {
3322                kind[0] = '\0';
3323                ops = NULL;
3324        }
3325
3326        data = NULL;
3327        if (ops) {
3328                if (ops->maxtype > RTNL_MAX_TYPE)
3329                        return -EINVAL;
3330
3331                if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
3332                        err = nla_parse_nested_deprecated(attr, ops->maxtype,
3333                                                          linkinfo[IFLA_INFO_DATA],
3334                                                          ops->policy, extack);
3335                        if (err < 0)
3336                                return err;
3337                        data = attr;
3338                }
3339                if (ops->validate) {
3340                        err = ops->validate(tb, data, extack);
3341                        if (err < 0)
3342                                return err;
3343                }
3344        }
3345
3346        slave_data = NULL;
3347        if (m_ops) {
3348                if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3349                        return -EINVAL;
3350
3351                if (m_ops->slave_maxtype &&
3352                    linkinfo[IFLA_INFO_SLAVE_DATA]) {
3353                        err = nla_parse_nested_deprecated(slave_attr,
3354                                                          m_ops->slave_maxtype,
3355                                                          linkinfo[IFLA_INFO_SLAVE_DATA],
3356                                                          m_ops->slave_policy,
3357                                                          extack);
3358                        if (err < 0)
3359                                return err;
3360                        slave_data = slave_attr;
3361                }
3362        }
3363
3364        if (dev) {
3365                int status = 0;
3366
3367                if (nlh->nlmsg_flags & NLM_F_EXCL)
3368                        return -EEXIST;
3369                if (nlh->nlmsg_flags & NLM_F_REPLACE)
3370                        return -EOPNOTSUPP;
3371
3372                if (linkinfo[IFLA_INFO_DATA]) {
3373                        if (!ops || ops != dev->rtnl_link_ops ||
3374                            !ops->changelink)
3375                                return -EOPNOTSUPP;
3376
3377                        err = ops->changelink(dev, tb, data, extack);
3378                        if (err < 0)
3379                                return err;
3380                        status |= DO_SETLINK_NOTIFY;
3381                }
3382
3383                if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
3384                        if (!m_ops || !m_ops->slave_changelink)
3385                                return -EOPNOTSUPP;
3386
3387                        err = m_ops->slave_changelink(master_dev, dev, tb,
3388                                                      slave_data, extack);
3389                        if (err < 0)
3390                                return err;
3391                        status |= DO_SETLINK_NOTIFY;
3392                }
3393
3394                return do_setlink(skb, dev, ifm, extack, tb, ifname, status);
3395        }
3396
3397        if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
3398                if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
3399                        return rtnl_group_changelink(skb, net,
3400                                                nla_get_u32(tb[IFLA_GROUP]),
3401                                                ifm, extack, tb);
3402                return -ENODEV;
3403        }
3404
3405        if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3406                return -EOPNOTSUPP;
3407
3408        if (!ops) {
3409#ifdef CONFIG_MODULES
3410                if (kind[0]) {
3411                        __rtnl_unlock();
3412                        request_module("rtnl-link-%s", kind);
3413                        rtnl_lock();
3414                        ops = rtnl_link_ops_get(kind);
3415                        if (ops)
3416                                goto replay;
3417                }
3418#endif
3419                NL_SET_ERR_MSG(extack, "Unknown device type");
3420                return -EOPNOTSUPP;
3421        }
3422
3423        if (!ops->alloc && !ops->setup)
3424                return -EOPNOTSUPP;
3425
3426        if (!ifname[0]) {
3427                snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3428                name_assign_type = NET_NAME_ENUM;
3429        }
3430
3431        dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3432        if (IS_ERR(dest_net))
3433                return PTR_ERR(dest_net);
3434
3435        if (tb[IFLA_LINK_NETNSID]) {
3436                int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
3437
3438                link_net = get_net_ns_by_id(dest_net, id);
3439                if (!link_net) {
3440                        NL_SET_ERR_MSG(extack, "Unknown network namespace id");
3441                        err =  -EINVAL;
3442                        goto out;
3443                }
3444                err = -EPERM;
3445                if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
3446                        goto out;
3447        } else {
3448                link_net = NULL;
3449        }
3450
3451        dev = rtnl_create_link(link_net ? : dest_net, ifname,
3452                               name_assign_type, ops, tb, extack);
3453        if (IS_ERR(dev)) {
3454                err = PTR_ERR(dev);
3455                goto out;
3456        }
3457
3458        dev->ifindex = ifm->ifi_index;
3459
3460        if (ops->newlink)
3461                err = ops->newlink(link_net ? : net, dev, tb, data, extack);
3462        else
3463                err = register_netdevice(dev);
3464        if (err < 0) {
3465                free_netdev(dev);
3466                goto out;
3467        }
3468
3469        err = rtnl_configure_link(dev, ifm);
3470        if (err < 0)
3471                goto out_unregister;
3472        if (link_net) {
3473                err = dev_change_net_namespace(dev, dest_net, ifname);
3474                if (err < 0)
3475                        goto out_unregister;
3476        }
3477        if (tb[IFLA_MASTER]) {
3478                err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3479                if (err)
3480                        goto out_unregister;
3481        }
3482out:
3483        if (link_net)
3484                put_net(link_net);
3485        put_net(dest_net);
3486        return err;
3487out_unregister:
3488        if (ops->newlink) {
3489                LIST_HEAD(list_kill);
3490
3491                ops->dellink(dev, &list_kill);
3492                unregister_netdevice_many(&list_kill);
3493        } else {
3494                unregister_netdevice(dev);
3495        }
3496        goto out;
3497}
3498
3499static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3500                        struct netlink_ext_ack *extack)
3501{
3502        struct nlattr **attr;
3503        int ret;
3504
3505        attr = kmalloc_array(RTNL_MAX_TYPE + 1, sizeof(*attr), GFP_KERNEL);
3506        if (!attr)
3507                return -ENOMEM;
3508
3509        ret = __rtnl_newlink(skb, nlh, attr, extack);
3510        kfree(attr);
3511        return ret;
3512}
3513
3514static int rtnl_valid_getlink_req(struct sk_buff *skb,
3515                                  const struct nlmsghdr *nlh,
3516                                  struct nlattr **tb,
3517                                  struct netlink_ext_ack *extack)
3518{
3519        struct ifinfomsg *ifm;
3520        int i, err;
3521
3522        if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
3523                NL_SET_ERR_MSG(extack, "Invalid header for get link");
3524                return -EINVAL;
3525        }
3526
3527        if (!netlink_strict_get_check(skb))
3528                return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3529                                              ifla_policy, extack);
3530
3531        ifm = nlmsg_data(nlh);
3532        if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
3533            ifm->ifi_change) {
3534                NL_SET_ERR_MSG(extack, "Invalid values in header for get link request");
3535                return -EINVAL;
3536        }
3537
3538        err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX,
3539                                            ifla_policy, extack);
3540        if (err)
3541                return err;
3542
3543        for (i = 0; i <= IFLA_MAX; i++) {
3544                if (!tb[i])
3545                        continue;
3546
3547                switch (i) {
3548                case IFLA_IFNAME:
3549                case IFLA_ALT_IFNAME:
3550                case IFLA_EXT_MASK:
3551                case IFLA_TARGET_NETNSID:
3552                        break;
3553                default:
3554                        NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request");
3555                        return -EINVAL;
3556                }
3557        }
3558
3559        return 0;
3560}
3561
3562static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3563                        struct netlink_ext_ack *extack)
3564{
3565        struct net *net = sock_net(skb->sk);
3566        struct net *tgt_net = net;
3567        struct ifinfomsg *ifm;
3568        struct nlattr *tb[IFLA_MAX+1];
3569        struct net_device *dev = NULL;
3570        struct sk_buff *nskb;
3571        int netnsid = -1;
3572        int err;
3573        u32 ext_filter_mask = 0;
3574
3575        err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
3576        if (err < 0)
3577                return err;
3578
3579        err = rtnl_ensure_unique_netns(tb, extack, true);
3580        if (err < 0)
3581                return err;
3582
3583        if (tb[IFLA_TARGET_NETNSID]) {
3584                netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3585                tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
3586                if (IS_ERR(tgt_net))
3587                        return PTR_ERR(tgt_net);
3588        }
3589
3590        if (tb[IFLA_EXT_MASK])
3591                ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3592
3593        err = -EINVAL;
3594        ifm = nlmsg_data(nlh);
3595        if (ifm->ifi_index > 0)
3596                dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3597        else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3598                dev = rtnl_dev_get(tgt_net, tb[IFLA_IFNAME],
3599                                   tb[IFLA_ALT_IFNAME], NULL);
3600        else
3601                goto out;
3602
3603        err = -ENODEV;
3604        if (dev == NULL)
3605                goto out;
3606
3607        err = -ENOBUFS;
3608        nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
3609        if (nskb == NULL)
3610                goto out;
3611
3612        err = rtnl_fill_ifinfo(nskb, dev, net,
3613                               RTM_NEWLINK, NETLINK_CB(skb).portid,
3614                               nlh->nlmsg_seq, 0, 0, ext_filter_mask,
3615                               0, NULL, 0, netnsid, GFP_KERNEL);
3616        if (err < 0) {
3617                /* -EMSGSIZE implies BUG in if_nlmsg_size */
3618                WARN_ON(err == -EMSGSIZE);
3619                kfree_skb(nskb);
3620        } else
3621                err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
3622out:
3623        if (netnsid >= 0)
3624                put_net(tgt_net);
3625
3626        return err;
3627}
3628
3629static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr,
3630                           bool *changed, struct netlink_ext_ack *extack)
3631{
3632        char *alt_ifname;
3633        int err;
3634
3635        err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack);
3636        if (err)
3637                return err;
3638
3639        alt_ifname = nla_strdup(attr, GFP_KERNEL);
3640        if (!alt_ifname)
3641                return -ENOMEM;
3642
3643        if (cmd == RTM_NEWLINKPROP) {
3644                err = netdev_name_node_alt_create(dev, alt_ifname);
3645                if (!err)
3646                        alt_ifname = NULL;
3647        } else if (cmd == RTM_DELLINKPROP) {
3648                err = netdev_name_node_alt_destroy(dev, alt_ifname);
3649        } else {
3650                WARN_ON_ONCE(1);
3651                err = -EINVAL;
3652        }
3653
3654        kfree(alt_ifname);
3655        if (!err)
3656                *changed = true;
3657        return err;
3658}
3659
3660static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,
3661                         struct netlink_ext_ack *extack)
3662{
3663        struct net *net = sock_net(skb->sk);
3664        struct nlattr *tb[IFLA_MAX + 1];
3665        struct net_device *dev;
3666        struct ifinfomsg *ifm;
3667        bool changed = false;
3668        struct nlattr *attr;
3669        int err, rem;
3670
3671        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
3672        if (err)
3673                return err;
3674
3675        err = rtnl_ensure_unique_netns(tb, extack, true);
3676        if (err)
3677                return err;
3678
3679        ifm = nlmsg_data(nlh);
3680        if (ifm->ifi_index > 0)
3681                dev = __dev_get_by_index(net, ifm->ifi_index);
3682        else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3683                dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3684                                   tb[IFLA_ALT_IFNAME], NULL);
3685        else
3686                return -EINVAL;
3687
3688        if (!dev)
3689                return -ENODEV;
3690
3691        if (!tb[IFLA_PROP_LIST])
3692                return 0;
3693
3694        nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) {
3695                switch (nla_type(attr)) {
3696                case IFLA_ALT_IFNAME:
3697                        err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack);
3698                        if (err)
3699                                return err;
3700                        break;
3701                }
3702        }
3703
3704        if (changed)
3705                netdev_state_change(dev);
3706        return 0;
3707}
3708
3709static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3710                            struct netlink_ext_ack *extack)
3711{
3712        return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack);
3713}
3714
3715static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3716                            struct netlink_ext_ack *extack)
3717{
3718        return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack);
3719}
3720
3721static u32 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
3722{
3723        struct net *net = sock_net(skb->sk);
3724        size_t min_ifinfo_dump_size = 0;
3725        struct nlattr *tb[IFLA_MAX+1];
3726        u32 ext_filter_mask = 0;
3727        struct net_device *dev;
3728        int hdrlen;
3729
3730        /* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
3731        hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
3732                 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
3733
3734        if (nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
3735                if (tb[IFLA_EXT_MASK])
3736                        ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3737        }
3738
3739        if (!ext_filter_mask)
3740                return NLMSG_GOODSIZE;
3741        /*
3742         * traverse the list of net devices and compute the minimum
3743         * buffer size based upon the filter mask.
3744         */
3745        rcu_read_lock();
3746        for_each_netdev_rcu(net, dev) {
3747                min_ifinfo_dump_size = max(min_ifinfo_dump_size,
3748                                           if_nlmsg_size(dev, ext_filter_mask));
3749        }
3750        rcu_read_unlock();
3751
3752        return nlmsg_total_size(min_ifinfo_dump_size);
3753}
3754
3755static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
3756{
3757        int idx;
3758        int s_idx = cb->family;
3759        int type = cb->nlh->nlmsg_type - RTM_BASE;
3760        int ret = 0;
3761
3762        if (s_idx == 0)
3763                s_idx = 1;
3764
3765        for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
3766                struct rtnl_link __rcu **tab;
3767                struct rtnl_link *link;
3768                rtnl_dumpit_func dumpit;
3769
3770                if (idx < s_idx || idx == PF_PACKET)
3771                        continue;
3772
3773                if (type < 0 || type >= RTM_NR_MSGTYPES)
3774                        continue;
3775
3776                tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]);
3777                if (!tab)
3778                        continue;
3779
3780                link = rcu_dereference_rtnl(tab[type]);
3781                if (!link)
3782                        continue;
3783
3784                dumpit = link->dumpit;
3785                if (!dumpit)
3786                        continue;
3787
3788                if (idx > s_idx) {
3789                        memset(&cb->args[0], 0, sizeof(cb->args));
3790                        cb->prev_seq = 0;
3791                        cb->seq = 0;
3792                }
3793                ret = dumpit(skb, cb);
3794                if (ret)
3795                        break;
3796        }
3797        cb->family = idx;
3798
3799        return skb->len ? : ret;
3800}
3801
3802struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
3803                                       unsigned int change,
3804                                       u32 event, gfp_t flags, int *new_nsid,
3805                                       int new_ifindex)
3806{
3807        struct net *net = dev_net(dev);
3808        struct sk_buff *skb;
3809        int err = -ENOBUFS;
3810        size_t if_info_size;
3811
3812        skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags);
3813        if (skb == NULL)
3814                goto errout;
3815
3816        err = rtnl_fill_ifinfo(skb, dev, dev_net(dev),
3817                               type, 0, 0, change, 0, 0, event,
3818                               new_nsid, new_ifindex, -1, flags);
3819        if (err < 0) {
3820                /* -EMSGSIZE implies BUG in if_nlmsg_size() */
3821                WARN_ON(err == -EMSGSIZE);
3822                kfree_skb(skb);
3823                goto errout;
3824        }
3825        return skb;
3826errout:
3827        if (err < 0)
3828                rtnl_set_sk_err(net, RTNLGRP_LINK, err);
3829        return NULL;
3830}
3831
3832void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags)
3833{
3834        struct net *net = dev_net(dev);
3835
3836        rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags);
3837}
3838
3839static void rtmsg_ifinfo_event(int type, struct net_device *dev,
3840                               unsigned int change, u32 event,
3841                               gfp_t flags, int *new_nsid, int new_ifindex)
3842{
3843        struct sk_buff *skb;
3844
3845        if (dev->reg_state != NETREG_REGISTERED)
3846                return;
3847
3848        skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid,
3849                                     new_ifindex);
3850        if (skb)
3851                rtmsg_ifinfo_send(skb, dev, flags);
3852}
3853
3854void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
3855                  gfp_t flags)
3856{
3857        rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
3858                           NULL, 0);
3859}
3860
3861void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
3862                         gfp_t flags, int *new_nsid, int new_ifindex)
3863{
3864        rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
3865                           new_nsid, new_ifindex);
3866}
3867
3868static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
3869                                   struct net_device *dev,
3870                                   u8 *addr, u16 vid, u32 pid, u32 seq,
3871                                   int type, unsigned int flags,
3872                                   int nlflags, u16 ndm_state)
3873{
3874        struct nlmsghdr *nlh;
3875        struct ndmsg *ndm;
3876
3877        nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
3878        if (!nlh)
3879                return -EMSGSIZE;
3880
3881        ndm = nlmsg_data(nlh);
3882        ndm->ndm_family  = AF_BRIDGE;
3883        ndm->ndm_pad1    = 0;
3884        ndm->ndm_pad2    = 0;
3885        ndm->ndm_flags   = flags;
3886        ndm->ndm_type    = 0;
3887        ndm->ndm_ifindex = dev->ifindex;
3888        ndm->ndm_state   = ndm_state;
3889
3890        if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
3891                goto nla_put_failure;
3892        if (vid)
3893                if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
3894                        goto nla_put_failure;
3895
3896        nlmsg_end(skb, nlh);
3897        return 0;
3898
3899nla_put_failure:
3900        nlmsg_cancel(skb, nlh);
3901        return -EMSGSIZE;
3902}
3903
3904static inline size_t rtnl_fdb_nlmsg_size(void)
3905{
3906        return NLMSG_ALIGN(sizeof(struct ndmsg)) +
3907               nla_total_size(ETH_ALEN) +       /* NDA_LLADDR */
3908               nla_total_size(sizeof(u16)) +    /* NDA_VLAN */
3909               0;
3910}
3911
3912static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
3913                            u16 ndm_state)
3914{
3915        struct net *net = dev_net(dev);
3916        struct sk_buff *skb;
3917        int err = -ENOBUFS;
3918
3919        skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC);
3920        if (!skb)
3921                goto errout;
3922
3923        err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
3924                                      0, 0, type, NTF_SELF, 0, ndm_state);
3925        if (err < 0) {
3926                kfree_skb(skb);
3927                goto errout;
3928        }
3929
3930        rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
3931        return;
3932errout:
3933        rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
3934}
3935
3936/*
3937 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
3938 */
3939int ndo_dflt_fdb_add(struct ndmsg *ndm,
3940                     struct nlattr *tb[],
3941                     struct net_device *dev,
3942                     const unsigned char *addr, u16 vid,
3943                     u16 flags)
3944{
3945        int err = -EINVAL;
3946
3947        /* If aging addresses are supported device will need to
3948         * implement its own handler for this.
3949         */
3950        if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
3951                netdev_info(dev, "default FDB implementation only supports local addresses\n");
3952                return err;
3953        }
3954
3955        if (vid) {
3956                netdev_info(dev, "vlans aren't supported yet for dev_uc|mc_add()\n");
3957                return err;
3958        }
3959
3960        if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
3961                err = dev_uc_add_excl(dev, addr);
3962        else if (is_multicast_ether_addr(addr))
3963                err = dev_mc_add_excl(dev, addr);
3964
3965        /* Only return duplicate errors if NLM_F_EXCL is set */
3966        if (err == -EEXIST && !(flags & NLM_F_EXCL))
3967                err = 0;
3968
3969        return err;
3970}
3971EXPORT_SYMBOL(ndo_dflt_fdb_add);
3972
3973static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid,
3974                         struct netlink_ext_ack *extack)
3975{
3976        u16 vid = 0;
3977
3978        if (vlan_attr) {
3979                if (nla_len(vlan_attr) != sizeof(u16)) {
3980                        NL_SET_ERR_MSG(extack, "invalid vlan attribute size");
3981                        return -EINVAL;
3982                }
3983
3984                vid = nla_get_u16(vlan_attr);
3985
3986                if (!vid || vid >= VLAN_VID_MASK) {
3987                        NL_SET_ERR_MSG(extack, "invalid vlan id");
3988                        return -EINVAL;
3989                }
3990        }
3991        *p_vid = vid;
3992        return 0;
3993}
3994
3995static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
3996                        struct netlink_ext_ack *extack)
3997{
3998        struct net *net = sock_net(skb->sk);
3999        struct ndmsg *ndm;
4000        struct nlattr *tb[NDA_MAX+1];
4001        struct net_device *dev;
4002        u8 *addr;
4003        u16 vid;
4004        int err;
4005
4006        err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
4007                                     extack);
4008        if (err < 0)
4009                return err;
4010
4011        ndm = nlmsg_data(nlh);
4012        if (ndm->ndm_ifindex == 0) {
4013                NL_SET_ERR_MSG(extack, "invalid ifindex");
4014                return -EINVAL;
4015        }
4016
4017        dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4018        if (dev == NULL) {
4019                NL_SET_ERR_MSG(extack, "unknown ifindex");
4020                return -ENODEV;
4021        }
4022
4023        if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4024                NL_SET_ERR_MSG(extack, "invalid address");
4025                return -EINVAL;
4026        }
4027
4028        if (dev->type != ARPHRD_ETHER) {
4029                NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices");
4030                return -EINVAL;
4031        }
4032
4033        addr = nla_data(tb[NDA_LLADDR]);
4034
4035        err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4036        if (err)
4037                return err;
4038
4039        err = -EOPNOTSUPP;
4040
4041        /* Support fdb on master device the net/bridge default case */
4042        if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4043            netif_is_bridge_port(dev)) {
4044                struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4045                const struct net_device_ops *ops = br_dev->netdev_ops;
4046
4047                err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
4048                                       nlh->nlmsg_flags, extack);
4049                if (err)
4050                        goto out;
4051                else
4052                        ndm->ndm_flags &= ~NTF_MASTER;
4053        }
4054
4055        /* Embedded bridge, macvlan, and any other device support */
4056        if ((ndm->ndm_flags & NTF_SELF)) {
4057                if (dev->netdev_ops->ndo_fdb_add)
4058                        err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
4059                                                           vid,
4060                                                           nlh->nlmsg_flags,
4061                                                           extack);
4062                else
4063                        err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
4064                                               nlh->nlmsg_flags);
4065
4066                if (!err) {
4067                        rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
4068                                        ndm->ndm_state);
4069                        ndm->ndm_flags &= ~NTF_SELF;
4070                }
4071        }
4072out:
4073        return err;
4074}
4075
4076/*
4077 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
4078 */
4079int ndo_dflt_fdb_del(struct ndmsg *ndm,
4080                     struct nlattr *tb[],
4081                     struct net_device *dev,
4082                     const unsigned char *addr, u16 vid)
4083{
4084        int err = -EINVAL;
4085
4086        /* If aging addresses are supported device will need to
4087         * implement its own handler for this.
4088         */
4089        if (!(ndm->ndm_state & NUD_PERMANENT)) {
4090                netdev_info(dev, "default FDB implementation only supports local addresses\n");
4091                return err;
4092        }
4093
4094        if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
4095                err = dev_uc_del(dev, addr);
4096        else if (is_multicast_ether_addr(addr))
4097                err = dev_mc_del(dev, addr);
4098
4099        return err;
4100}
4101EXPORT_SYMBOL(ndo_dflt_fdb_del);
4102
4103static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
4104                        struct netlink_ext_ack *extack)
4105{
4106        struct net *net = sock_net(skb->sk);
4107        struct ndmsg *ndm;
4108        struct nlattr *tb[NDA_MAX+1];
4109        struct net_device *dev;
4110        __u8 *addr;
4111        int err;
4112        u16 vid;
4113
4114        if (!netlink_capable(skb, CAP_NET_ADMIN))
4115                return -EPERM;
4116
4117        err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
4118                                     extack);
4119        if (err < 0)
4120                return err;
4121
4122        ndm = nlmsg_data(nlh);
4123        if (ndm->ndm_ifindex == 0) {
4124                NL_SET_ERR_MSG(extack, "invalid ifindex");
4125                return -EINVAL;
4126        }
4127
4128        dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4129        if (dev == NULL) {
4130                NL_SET_ERR_MSG(extack, "unknown ifindex");
4131                return -ENODEV;
4132        }
4133
4134        if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4135                NL_SET_ERR_MSG(extack, "invalid address");
4136                return -EINVAL;
4137        }
4138
4139        if (dev->type != ARPHRD_ETHER) {
4140                NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4141                return -EINVAL;
4142        }
4143
4144        addr = nla_data(tb[NDA_LLADDR]);
4145
4146        err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4147        if (err)
4148                return err;
4149
4150        err = -EOPNOTSUPP;
4151
4152        /* Support fdb on master device the net/bridge default case */
4153        if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4154            netif_is_bridge_port(dev)) {
4155                struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4156                const struct net_device_ops *ops = br_dev->netdev_ops;
4157
4158                if (ops->ndo_fdb_del)
4159                        err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
4160
4161                if (err)
4162                        goto out;
4163                else
4164                        ndm->ndm_flags &= ~NTF_MASTER;
4165        }
4166
4167        /* Embedded bridge, macvlan, and any other device support */
4168        if (ndm->ndm_flags & NTF_SELF) {
4169                if (dev->netdev_ops->ndo_fdb_del)
4170                        err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
4171                                                           vid);
4172                else
4173                        err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4174
4175                if (!err) {
4176                        rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4177                                        ndm->ndm_state);
4178                        ndm->ndm_flags &= ~NTF_SELF;
4179                }
4180        }
4181out:
4182        return err;
4183}
4184
4185static int nlmsg_populate_fdb(struct sk_buff *skb,
4186                              struct netlink_callback *cb,
4187                              struct net_device *dev,
4188                              int *idx,
4189                              struct netdev_hw_addr_list *list)
4190{
4191        struct netdev_hw_addr *ha;
4192        int err;
4193        u32 portid, seq;
4194
4195        portid = NETLINK_CB(cb->skb).portid;
4196        seq = cb->nlh->nlmsg_seq;
4197
4198        list_for_each_entry(ha, &list->list, list) {
4199                if (*idx < cb->args[2])
4200                        goto skip;
4201
4202                err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
4203                                              portid, seq,
4204                                              RTM_NEWNEIGH, NTF_SELF,
4205                                              NLM_F_MULTI, NUD_PERMANENT);
4206                if (err < 0)
4207                        return err;
4208skip:
4209                *idx += 1;
4210        }
4211        return 0;
4212}
4213
4214/**
4215 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
4216 * @skb: socket buffer to store message in
4217 * @cb: netlink callback
4218 * @dev: netdevice
4219 * @filter_dev: ignored
4220 * @idx: the number of FDB table entries dumped is added to *@idx
4221 *
4222 * Default netdevice operation to dump the existing unicast address list.
4223 * Returns number of addresses from list put in skb.
4224 */
4225int ndo_dflt_fdb_dump(struct sk_buff *skb,
4226                      struct netlink_callback *cb,
4227                      struct net_device *dev,
4228                      struct net_device *filter_dev,
4229                      int *idx)
4230{
4231        int err;
4232
4233        if (dev->type != ARPHRD_ETHER)
4234                return -EINVAL;
4235
4236        netif_addr_lock_bh(dev);
4237        err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
4238        if (err)
4239                goto out;
4240        err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
4241out:
4242        netif_addr_unlock_bh(dev);
4243        return err;
4244}
4245EXPORT_SYMBOL(ndo_dflt_fdb_dump);
4246
4247static int valid_fdb_dump_strict(const struct nlmsghdr *nlh,
4248                                 int *br_idx, int *brport_idx,
4249                                 struct netlink_ext_ack *extack)
4250{
4251        struct nlattr *tb[NDA_MAX + 1];
4252        struct ndmsg *ndm;
4253        int err, i;
4254
4255        if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4256                NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request");
4257                return -EINVAL;
4258        }
4259
4260        ndm = nlmsg_data(nlh);
4261        if (ndm->ndm_pad1  || ndm->ndm_pad2  || ndm->ndm_state ||
4262            ndm->ndm_flags || ndm->ndm_type) {
4263                NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request");
4264                return -EINVAL;
4265        }
4266
4267        err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4268                                            NDA_MAX, NULL, extack);
4269        if (err < 0)
4270                return err;
4271
4272        *brport_idx = ndm->ndm_ifindex;
4273        for (i = 0; i <= NDA_MAX; ++i) {
4274                if (!tb[i])
4275                        continue;
4276
4277                switch (i) {
4278                case NDA_IFINDEX:
4279                        if (nla_len(tb[i]) != sizeof(u32)) {
4280                                NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request");
4281                                return -EINVAL;
4282                        }
4283                        *brport_idx = nla_get_u32(tb[NDA_IFINDEX]);
4284                        break;
4285                case NDA_MASTER:
4286                        if (nla_len(tb[i]) != sizeof(u32)) {
4287                                NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request");
4288                                return -EINVAL;
4289                        }
4290                        *br_idx = nla_get_u32(tb[NDA_MASTER]);
4291                        break;
4292                default:
4293                        NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request");
4294                        return -EINVAL;
4295                }
4296        }
4297
4298        return 0;
4299}
4300
4301static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh,
4302                                 int *br_idx, int *brport_idx,
4303                                 struct netlink_ext_ack *extack)
4304{
4305        struct nlattr *tb[IFLA_MAX+1];
4306        int err;
4307
4308        /* A hack to preserve kernel<->userspace interface.
4309         * Before Linux v4.12 this code accepted ndmsg since iproute2 v3.3.0.
4310         * However, ndmsg is shorter than ifinfomsg thus nlmsg_parse() bails.
4311         * So, check for ndmsg with an optional u32 attribute (not used here).
4312         * Fortunately these sizes don't conflict with the size of ifinfomsg
4313         * with an optional attribute.
4314         */
4315        if (nlmsg_len(nlh) != sizeof(struct ndmsg) &&
4316            (nlmsg_len(nlh) != sizeof(struct ndmsg) +
4317             nla_attr_size(sizeof(u32)))) {
4318                struct ifinfomsg *ifm;
4319
4320                err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4321                                             tb, IFLA_MAX, ifla_policy,
4322                                             extack);
4323                if (err < 0) {
4324                        return -EINVAL;
4325                } else if (err == 0) {
4326                        if (tb[IFLA_MASTER])
4327                                *br_idx = nla_get_u32(tb[IFLA_MASTER]);
4328                }
4329
4330                ifm = nlmsg_data(nlh);
4331                *brport_idx = ifm->ifi_index;
4332        }
4333        return 0;
4334}
4335
4336static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
4337{
4338        struct net_device *dev;
4339        struct net_device *br_dev = NULL;
4340        const struct net_device_ops *ops = NULL;
4341        const struct net_device_ops *cops = NULL;
4342        struct net *net = sock_net(skb->sk);
4343        struct hlist_head *head;
4344        int brport_idx = 0;
4345        int br_idx = 0;
4346        int h, s_h;
4347        int idx = 0, s_idx;
4348        int err = 0;
4349        int fidx = 0;
4350
4351        if (cb->strict_check)
4352                err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx,
4353                                            cb->extack);
4354        else
4355                err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx,
4356                                            cb->extack);
4357        if (err < 0)
4358                return err;
4359
4360        if (br_idx) {
4361                br_dev = __dev_get_by_index(net, br_idx);
4362                if (!br_dev)
4363                        return -ENODEV;
4364
4365                ops = br_dev->netdev_ops;
4366        }
4367
4368        s_h = cb->args[0];
4369        s_idx = cb->args[1];
4370
4371        for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4372                idx = 0;
4373                head = &net->dev_index_head[h];
4374                hlist_for_each_entry(dev, head, index_hlist) {
4375
4376                        if (brport_idx && (dev->ifindex != brport_idx))
4377                                continue;
4378
4379                        if (!br_idx) { /* user did not specify a specific bridge */
4380                                if (netif_is_bridge_port(dev)) {
4381                                        br_dev = netdev_master_upper_dev_get(dev);
4382                                        cops = br_dev->netdev_ops;
4383                                }
4384                        } else {
4385                                if (dev != br_dev &&
4386                                    !netif_is_bridge_port(dev))
4387                                        continue;
4388
4389                                if (br_dev != netdev_master_upper_dev_get(dev) &&
4390                                    !(dev->priv_flags & IFF_EBRIDGE))
4391                                        continue;
4392                                cops = ops;
4393                        }
4394
4395                        if (idx < s_idx)
4396                                goto cont;
4397
4398                        if (netif_is_bridge_port(dev)) {
4399                                if (cops && cops->ndo_fdb_dump) {
4400                                        err = cops->ndo_fdb_dump(skb, cb,
4401                                                                br_dev, dev,
4402                                                                &fidx);
4403                                        if (err == -EMSGSIZE)
4404                                                goto out;
4405                                }
4406                        }
4407
4408                        if (dev->netdev_ops->ndo_fdb_dump)
4409                                err = dev->netdev_ops->ndo_fdb_dump(skb, cb,
4410                                                                    dev, NULL,
4411                                                                    &fidx);
4412                        else
4413                                err = ndo_dflt_fdb_dump(skb, cb, dev, NULL,
4414                                                        &fidx);
4415                        if (err == -EMSGSIZE)
4416                                goto out;
4417
4418                        cops = NULL;
4419
4420                        /* reset fdb offset to 0 for rest of the interfaces */
4421                        cb->args[2] = 0;
4422                        fidx = 0;
4423cont:
4424                        idx++;
4425                }
4426        }
4427
4428out:
4429        cb->args[0] = h;
4430        cb->args[1] = idx;
4431        cb->args[2] = fidx;
4432
4433        return skb->len;
4434}
4435
4436static int valid_fdb_get_strict(const struct nlmsghdr *nlh,
4437                                struct nlattr **tb, u8 *ndm_flags,
4438                                int *br_idx, int *brport_idx, u8 **addr,
4439                                u16 *vid, struct netlink_ext_ack *extack)
4440{
4441        struct ndmsg *ndm;
4442        int err, i;
4443
4444        if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4445                NL_SET_ERR_MSG(extack, "Invalid header for fdb get request");
4446                return -EINVAL;
4447        }
4448
4449        ndm = nlmsg_data(nlh);
4450        if (ndm->ndm_pad1  || ndm->ndm_pad2  || ndm->ndm_state ||
4451            ndm->ndm_type) {
4452                NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request");
4453                return -EINVAL;
4454        }
4455
4456        if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) {
4457                NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request");
4458                return -EINVAL;
4459        }
4460
4461        err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4462                                            NDA_MAX, nda_policy, extack);
4463        if (err < 0)
4464                return err;
4465
4466        *ndm_flags = ndm->ndm_flags;
4467        *brport_idx = ndm->ndm_ifindex;
4468        for (i = 0; i <= NDA_MAX; ++i) {
4469                if (!tb[i])
4470                        continue;
4471
4472                switch (i) {
4473                case NDA_MASTER:
4474                        *br_idx = nla_get_u32(tb[i]);
4475                        break;
4476                case NDA_LLADDR:
4477                        if (nla_len(tb[i]) != ETH_ALEN) {
4478                                NL_SET_ERR_MSG(extack, "Invalid address in fdb get request");
4479                                return -EINVAL;
4480                        }
4481                        *addr = nla_data(tb[i]);
4482                        break;
4483                case NDA_VLAN:
4484                        err = fdb_vid_parse(tb[i], vid, extack);
4485                        if (err)
4486                                return err;
4487                        break;
4488                case NDA_VNI:
4489                        break;
4490                default:
4491                        NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request");
4492                        return -EINVAL;
4493                }
4494        }
4495
4496        return 0;
4497}
4498
4499static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4500                        struct netlink_ext_ack *extack)
4501{
4502        struct net_device *dev = NULL, *br_dev = NULL;
4503        const struct net_device_ops *ops = NULL;
4504        struct net *net = sock_net(in_skb->sk);
4505        struct nlattr *tb[NDA_MAX + 1];
4506        struct sk_buff *skb;
4507        int brport_idx = 0;
4508        u8 ndm_flags = 0;
4509        int br_idx = 0;
4510        u8 *addr = NULL;
4511        u16 vid = 0;
4512        int err;
4513
4514        err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx,
4515                                   &brport_idx, &addr, &vid, extack);
4516        if (err < 0)
4517                return err;
4518
4519        if (!addr) {
4520                NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request");
4521                return -EINVAL;
4522        }
4523
4524        if (brport_idx) {
4525                dev = __dev_get_by_index(net, brport_idx);
4526                if (!dev) {
4527                        NL_SET_ERR_MSG(extack, "Unknown device ifindex");
4528                        return -ENODEV;
4529                }
4530        }
4531
4532        if (br_idx) {
4533                if (dev) {
4534                        NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive");
4535                        return -EINVAL;
4536                }
4537
4538                br_dev = __dev_get_by_index(net, br_idx);
4539                if (!br_dev) {
4540                        NL_SET_ERR_MSG(extack, "Invalid master ifindex");
4541                        return -EINVAL;
4542                }
4543                ops = br_dev->