rtnetlink.c (9e6a90790357e8b468445f5c549c498126cedefb) rtnetlink.c (c92bf26ccebc8501863b38c4a4f65b8fef28ce5e)
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 *

--- 40 unchanged lines hidden (view full) ---

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
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 *

--- 40 unchanged lines hidden (view full) ---

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#include "dev.h"
58
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;

--- 25 unchanged lines hidden (view full) ---

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
59#define RTNL_MAX_TYPE 50
60#define RTNL_SLAVE_MAX_TYPE 40
61
62struct rtnl_link {
63 rtnl_doit_func doit;
64 rtnl_dumpit_func dumpit;
65 struct module *owner;
66 unsigned int flags;

--- 25 unchanged lines hidden (view full) ---

92EXPORT_SYMBOL(rtnl_kfree_skbs);
93
94void __rtnl_unlock(void)
95{
96 struct sk_buff *head = defer_kfree_skb_list;
97
98 defer_kfree_skb_list = NULL;
99
100 /* Ensure that we didn't actually add any TODO item when __rtnl_unlock()
101 * is used. In some places, e.g. in cfg80211, we have code that will do
102 * something like
103 * rtnl_lock()
104 * wiphy_lock()
105 * ...
106 * rtnl_unlock()
107 *
108 * and because netdev_run_todo() acquires the RTNL for items on the list
109 * we could cause a situation such as this:
110 * Thread 1 Thread 2
111 * rtnl_lock()
112 * unregister_netdevice()
113 * __rtnl_unlock()
114 * rtnl_lock()
115 * wiphy_lock()
116 * rtnl_unlock()
117 * netdev_run_todo()
118 * __rtnl_unlock()
119 *
120 * // list not empty now
121 * // because of thread 2
122 * rtnl_lock()
123 * while (!list_empty(...))
124 * rtnl_lock()
125 * wiphy_lock()
126 * **** DEADLOCK ****
127 *
128 * However, usage of __rtnl_unlock() is rare, and so we can ensure that
129 * it's not used in cases where something is added to do the list.
130 */
131 WARN_ON(!list_empty(&net_todo_list));
132
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;

--- 103 unchanged lines hidden (view full) ---

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
133 mutex_unlock(&rtnl_mutex);
134
135 while (head) {
136 struct sk_buff *next = head->next;
137
138 kfree_skb(head);
139 cond_resched();
140 head = next;

--- 103 unchanged lines hidden (view full) ---

244
245 WARN_ON(doit && link->doit && link->doit != doit);
246 if (doit)
247 link->doit = doit;
248 WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
249 if (dumpit)
250 link->dumpit = dumpit;
251
252 WARN_ON(rtnl_msgtype_kind(msgtype) != RTNL_KIND_DEL &&
253 (flags & RTNL_FLAG_BULK_DEL_SUPPORTED));
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:

--- 2377 unchanged lines hidden (view full) ---

2602}
2603
2604#define DO_SETLINK_MODIFIED 0x01
2605/* notify flag means notify + modified. */
2606#define DO_SETLINK_NOTIFY 0x03
2607static int do_setlink(const struct sk_buff *skb,
2608 struct net_device *dev, struct ifinfomsg *ifm,
2609 struct netlink_ext_ack *extack,
254 link->flags |= flags;
255
256 /* publish protocol:msgtype */
257 rcu_assign_pointer(tab[msgindex], link);
258 ret = 0;
259 if (old)
260 kfree_rcu(old, rcu);
261unlock:

--- 2377 unchanged lines hidden (view full) ---

2639}
2640
2641#define DO_SETLINK_MODIFIED 0x01
2642/* notify flag means notify + modified. */
2643#define DO_SETLINK_NOTIFY 0x03
2644static int do_setlink(const struct sk_buff *skb,
2645 struct net_device *dev, struct ifinfomsg *ifm,
2646 struct netlink_ext_ack *extack,
2610 struct nlattr **tb, char *ifname, int status)
2647 struct nlattr **tb, int status)
2611{
2612 const struct net_device_ops *ops = dev->netdev_ops;
2648{
2649 const struct net_device_ops *ops = dev->netdev_ops;
2650 char ifname[IFNAMSIZ];
2613 int err;
2614
2615 err = validate_linkmsg(dev, tb, extack);
2616 if (err < 0)
2617 return err;
2618
2651 int err;
2652
2653 err = validate_linkmsg(dev, tb, extack);
2654 if (err < 0)
2655 return err;
2656
2657 if (tb[IFLA_IFNAME])
2658 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2659 else
2660 ifname[0] = '\0';
2661
2619 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
2662 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
2620 const char *pat = ifname && ifname[0] ? ifname : NULL;
2663 const char *pat = ifname[0] ? ifname : NULL;
2621 struct net *net;
2622 int new_ifindex;
2623
2624 net = rtnl_link_get_net_capable(skb, dev_net(dev),
2625 tb, CAP_NET_ADMIN);
2626 if (IS_ERR(net)) {
2627 err = PTR_ERR(net);
2628 goto errout;

--- 339 unchanged lines hidden (view full) ---

2968 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",
2969 dev->name);
2970 }
2971
2972 return err;
2973}
2974
2975static struct net_device *rtnl_dev_get(struct net *net,
2664 struct net *net;
2665 int new_ifindex;
2666
2667 net = rtnl_link_get_net_capable(skb, dev_net(dev),
2668 tb, CAP_NET_ADMIN);
2669 if (IS_ERR(net)) {
2670 err = PTR_ERR(net);
2671 goto errout;

--- 339 unchanged lines hidden (view full) ---

3011 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",
3012 dev->name);
3013 }
3014
3015 return err;
3016}
3017
3018static struct net_device *rtnl_dev_get(struct net *net,
2976 struct nlattr *ifname_attr,
2977 struct nlattr *altifname_attr,
2978 char *ifname)
3019 struct nlattr *tb[])
2979{
3020{
2980 char buffer[ALTIFNAMSIZ];
3021 char ifname[ALTIFNAMSIZ];
2981
3022
2982 if (!ifname) {
2983 ifname = buffer;
2984 if (ifname_attr)
2985 nla_strscpy(ifname, ifname_attr, IFNAMSIZ);
2986 else if (altifname_attr)
2987 nla_strscpy(ifname, altifname_attr, ALTIFNAMSIZ);
2988 else
2989 return NULL;
2990 }
3023 if (tb[IFLA_IFNAME])
3024 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3025 else if (tb[IFLA_ALT_IFNAME])
3026 nla_strscpy(ifname, tb[IFLA_ALT_IFNAME], ALTIFNAMSIZ);
3027 else
3028 return NULL;
2991
2992 return __dev_get_by_name(net, ifname);
2993}
2994
2995static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
2996 struct netlink_ext_ack *extack)
2997{
2998 struct net *net = sock_net(skb->sk);
2999 struct ifinfomsg *ifm;
3000 struct net_device *dev;
3001 int err;
3002 struct nlattr *tb[IFLA_MAX+1];
3029
3030 return __dev_get_by_name(net, ifname);
3031}
3032
3033static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3034 struct netlink_ext_ack *extack)
3035{
3036 struct net *net = sock_net(skb->sk);
3037 struct ifinfomsg *ifm;
3038 struct net_device *dev;
3039 int err;
3040 struct nlattr *tb[IFLA_MAX+1];
3003 char ifname[IFNAMSIZ];
3004
3005 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3006 ifla_policy, extack);
3007 if (err < 0)
3008 goto errout;
3009
3010 err = rtnl_ensure_unique_netns(tb, extack, false);
3011 if (err < 0)
3012 goto errout;
3013
3041
3042 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3043 ifla_policy, extack);
3044 if (err < 0)
3045 goto errout;
3046
3047 err = rtnl_ensure_unique_netns(tb, extack, false);
3048 if (err < 0)
3049 goto errout;
3050
3014 if (tb[IFLA_IFNAME])
3015 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3016 else
3017 ifname[0] = '\0';
3018
3019 err = -EINVAL;
3020 ifm = nlmsg_data(nlh);
3021 if (ifm->ifi_index > 0)
3022 dev = __dev_get_by_index(net, ifm->ifi_index);
3023 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3051 err = -EINVAL;
3052 ifm = nlmsg_data(nlh);
3053 if (ifm->ifi_index > 0)
3054 dev = __dev_get_by_index(net, ifm->ifi_index);
3055 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3024 dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
3056 dev = rtnl_dev_get(net, tb);
3025 else
3026 goto errout;
3027
3028 if (dev == NULL) {
3029 err = -ENODEV;
3030 goto errout;
3031 }
3032
3057 else
3058 goto errout;
3059
3060 if (dev == NULL) {
3061 err = -ENODEV;
3062 goto errout;
3063 }
3064
3033 err = do_setlink(skb, dev, ifm, extack, tb, ifname, 0);
3065 err = do_setlink(skb, dev, ifm, extack, tb, 0);
3034errout:
3035 return err;
3036}
3037
3038static int rtnl_group_dellink(const struct net *net, int group)
3039{
3040 struct net_device *dev, *aux;
3041 LIST_HEAD(list_kill);

--- 72 unchanged lines hidden (view full) ---

3114 return PTR_ERR(tgt_net);
3115 }
3116
3117 err = -EINVAL;
3118 ifm = nlmsg_data(nlh);
3119 if (ifm->ifi_index > 0)
3120 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3121 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3066errout:
3067 return err;
3068}
3069
3070static int rtnl_group_dellink(const struct net *net, int group)
3071{
3072 struct net_device *dev, *aux;
3073 LIST_HEAD(list_kill);

--- 72 unchanged lines hidden (view full) ---

3146 return PTR_ERR(tgt_net);
3147 }
3148
3149 err = -EINVAL;
3150 ifm = nlmsg_data(nlh);
3151 if (ifm->ifi_index > 0)
3152 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3153 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3122 dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3123 tb[IFLA_ALT_IFNAME], NULL);
3154 dev = rtnl_dev_get(net, tb);
3124 else if (tb[IFLA_GROUP])
3125 err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
3126 else
3127 goto out;
3128
3129 if (!dev) {
3155 else if (tb[IFLA_GROUP])
3156 err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
3157 else
3158 goto out;
3159
3160 if (!dev) {
3130 if (tb[IFLA_IFNAME] || ifm->ifi_index > 0)
3161 if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME] || ifm->ifi_index > 0)
3131 err = -ENODEV;
3132
3133 goto out;
3134 }
3135
3136 err = rtnl_delete_link(dev);
3137
3138out:

--- 118 unchanged lines hidden (view full) ---

3257 struct netlink_ext_ack *extack,
3258 struct nlattr **tb)
3259{
3260 struct net_device *dev, *aux;
3261 int err;
3262
3263 for_each_netdev_safe(net, dev, aux) {
3264 if (dev->group == group) {
3162 err = -ENODEV;
3163
3164 goto out;
3165 }
3166
3167 err = rtnl_delete_link(dev);
3168
3169out:

--- 118 unchanged lines hidden (view full) ---

3288 struct netlink_ext_ack *extack,
3289 struct nlattr **tb)
3290{
3291 struct net_device *dev, *aux;
3292 int err;
3293
3294 for_each_netdev_safe(net, dev, aux) {
3295 if (dev->group == group) {
3265 err = do_setlink(skb, dev, ifm, extack, tb, NULL, 0);
3296 err = do_setlink(skb, dev, ifm, extack, tb, 0);
3266 if (err < 0)
3267 return err;
3268 }
3269 }
3270
3271 return 0;
3272}
3273
3297 if (err < 0)
3298 return err;
3299 }
3300 }
3301
3302 return 0;
3303}
3304
3305struct rtnl_newlink_tbs {
3306 struct nlattr *tb[IFLA_MAX + 1];
3307 struct nlattr *attr[RTNL_MAX_TYPE + 1];
3308 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3309};
3310
3274static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3311static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3275 struct nlattr **attr, struct netlink_ext_ack *extack)
3312 struct rtnl_newlink_tbs *tbs,
3313 struct netlink_ext_ack *extack)
3276{
3314{
3277 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3278 unsigned char name_assign_type = NET_NAME_USER;
3279 struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
3315 unsigned char name_assign_type = NET_NAME_USER;
3316 struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
3317 struct nlattr ** const tb = tbs->tb;
3280 const struct rtnl_link_ops *m_ops;
3281 struct net_device *master_dev;
3282 struct net *net = sock_net(skb->sk);
3283 const struct rtnl_link_ops *ops;
3318 const struct rtnl_link_ops *m_ops;
3319 struct net_device *master_dev;
3320 struct net *net = sock_net(skb->sk);
3321 const struct rtnl_link_ops *ops;
3284 struct nlattr *tb[IFLA_MAX + 1];
3285 struct net *dest_net, *link_net;
3286 struct nlattr **slave_data;
3287 char kind[MODULE_NAME_LEN];
3288 struct net_device *dev;
3289 struct ifinfomsg *ifm;
3290 char ifname[IFNAMSIZ];
3291 struct nlattr **data;
3322 struct net *dest_net, *link_net;
3323 struct nlattr **slave_data;
3324 char kind[MODULE_NAME_LEN];
3325 struct net_device *dev;
3326 struct ifinfomsg *ifm;
3327 char ifname[IFNAMSIZ];
3328 struct nlattr **data;
3329 bool link_specified;
3292 int err;
3293
3294#ifdef CONFIG_MODULES
3295replay:
3296#endif
3297 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3298 ifla_policy, extack);
3299 if (err < 0)
3300 return err;
3301
3302 err = rtnl_ensure_unique_netns(tb, extack, false);
3303 if (err < 0)
3304 return err;
3305
3330 int err;
3331
3332#ifdef CONFIG_MODULES
3333replay:
3334#endif
3335 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3336 ifla_policy, extack);
3337 if (err < 0)
3338 return err;
3339
3340 err = rtnl_ensure_unique_netns(tb, extack, false);
3341 if (err < 0)
3342 return err;
3343
3306 if (tb[IFLA_IFNAME])
3307 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3308 else
3309 ifname[0] = '\0';
3310
3311 ifm = nlmsg_data(nlh);
3344 ifm = nlmsg_data(nlh);
3312 if (ifm->ifi_index > 0)
3345 if (ifm->ifi_index > 0) {
3346 link_specified = true;
3313 dev = __dev_get_by_index(net, ifm->ifi_index);
3347 dev = __dev_get_by_index(net, ifm->ifi_index);
3314 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3315 dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
3316 else
3348 } else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) {
3349 link_specified = true;
3350 dev = rtnl_dev_get(net, tb);
3351 } else {
3352 link_specified = false;
3317 dev = NULL;
3353 dev = NULL;
3354 }
3318
3319 master_dev = NULL;
3320 m_ops = NULL;
3321 if (dev) {
3322 master_dev = netdev_master_upper_dev_get(dev);
3323 if (master_dev)
3324 m_ops = master_dev->rtnl_link_ops;
3325 }

--- 20 unchanged lines hidden (view full) ---

3346 }
3347
3348 data = NULL;
3349 if (ops) {
3350 if (ops->maxtype > RTNL_MAX_TYPE)
3351 return -EINVAL;
3352
3353 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
3355
3356 master_dev = NULL;
3357 m_ops = NULL;
3358 if (dev) {
3359 master_dev = netdev_master_upper_dev_get(dev);
3360 if (master_dev)
3361 m_ops = master_dev->rtnl_link_ops;
3362 }

--- 20 unchanged lines hidden (view full) ---

3383 }
3384
3385 data = NULL;
3386 if (ops) {
3387 if (ops->maxtype > RTNL_MAX_TYPE)
3388 return -EINVAL;
3389
3390 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
3354 err = nla_parse_nested_deprecated(attr, ops->maxtype,
3391 err = nla_parse_nested_deprecated(tbs->attr, ops->maxtype,
3355 linkinfo[IFLA_INFO_DATA],
3356 ops->policy, extack);
3357 if (err < 0)
3358 return err;
3392 linkinfo[IFLA_INFO_DATA],
3393 ops->policy, extack);
3394 if (err < 0)
3395 return err;
3359 data = attr;
3396 data = tbs->attr;
3360 }
3361 if (ops->validate) {
3362 err = ops->validate(tb, data, extack);
3363 if (err < 0)
3364 return err;
3365 }
3366 }
3367
3368 slave_data = NULL;
3369 if (m_ops) {
3370 if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3371 return -EINVAL;
3372
3373 if (m_ops->slave_maxtype &&
3374 linkinfo[IFLA_INFO_SLAVE_DATA]) {
3397 }
3398 if (ops->validate) {
3399 err = ops->validate(tb, data, extack);
3400 if (err < 0)
3401 return err;
3402 }
3403 }
3404
3405 slave_data = NULL;
3406 if (m_ops) {
3407 if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3408 return -EINVAL;
3409
3410 if (m_ops->slave_maxtype &&
3411 linkinfo[IFLA_INFO_SLAVE_DATA]) {
3375 err = nla_parse_nested_deprecated(slave_attr,
3412 err = nla_parse_nested_deprecated(tbs->slave_attr,
3376 m_ops->slave_maxtype,
3377 linkinfo[IFLA_INFO_SLAVE_DATA],
3378 m_ops->slave_policy,
3379 extack);
3380 if (err < 0)
3381 return err;
3413 m_ops->slave_maxtype,
3414 linkinfo[IFLA_INFO_SLAVE_DATA],
3415 m_ops->slave_policy,
3416 extack);
3417 if (err < 0)
3418 return err;
3382 slave_data = slave_attr;
3419 slave_data = tbs->slave_attr;
3383 }
3384 }
3385
3386 if (dev) {
3387 int status = 0;
3388
3389 if (nlh->nlmsg_flags & NLM_F_EXCL)
3390 return -EEXIST;

--- 17 unchanged lines hidden (view full) ---

3408
3409 err = m_ops->slave_changelink(master_dev, dev, tb,
3410 slave_data, extack);
3411 if (err < 0)
3412 return err;
3413 status |= DO_SETLINK_NOTIFY;
3414 }
3415
3420 }
3421 }
3422
3423 if (dev) {
3424 int status = 0;
3425
3426 if (nlh->nlmsg_flags & NLM_F_EXCL)
3427 return -EEXIST;

--- 17 unchanged lines hidden (view full) ---

3445
3446 err = m_ops->slave_changelink(master_dev, dev, tb,
3447 slave_data, extack);
3448 if (err < 0)
3449 return err;
3450 status |= DO_SETLINK_NOTIFY;
3451 }
3452
3416 return do_setlink(skb, dev, ifm, extack, tb, ifname, status);
3453 return do_setlink(skb, dev, ifm, extack, tb, status);
3417 }
3418
3419 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
3454 }
3455
3456 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
3420 if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
3457 /* No dev found and NLM_F_CREATE not set. Requested dev does not exist,
3458 * or it's for a group
3459 */
3460 if (link_specified)
3461 return -ENODEV;
3462 if (tb[IFLA_GROUP])
3421 return rtnl_group_changelink(skb, net,
3422 nla_get_u32(tb[IFLA_GROUP]),
3423 ifm, extack, tb);
3424 return -ENODEV;
3425 }
3426
3427 if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3428 return -EOPNOTSUPP;

--- 11 unchanged lines hidden (view full) ---

3440#endif
3441 NL_SET_ERR_MSG(extack, "Unknown device type");
3442 return -EOPNOTSUPP;
3443 }
3444
3445 if (!ops->alloc && !ops->setup)
3446 return -EOPNOTSUPP;
3447
3463 return rtnl_group_changelink(skb, net,
3464 nla_get_u32(tb[IFLA_GROUP]),
3465 ifm, extack, tb);
3466 return -ENODEV;
3467 }
3468
3469 if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3470 return -EOPNOTSUPP;

--- 11 unchanged lines hidden (view full) ---

3482#endif
3483 NL_SET_ERR_MSG(extack, "Unknown device type");
3484 return -EOPNOTSUPP;
3485 }
3486
3487 if (!ops->alloc && !ops->setup)
3488 return -EOPNOTSUPP;
3489
3448 if (!ifname[0]) {
3490 if (tb[IFLA_IFNAME]) {
3491 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3492 } else {
3449 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3450 name_assign_type = NET_NAME_ENUM;
3451 }
3452
3453 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3454 if (IS_ERR(dest_net))
3455 return PTR_ERR(dest_net);
3456

--- 59 unchanged lines hidden (view full) ---

3516 unregister_netdevice(dev);
3517 }
3518 goto out;
3519}
3520
3521static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3522 struct netlink_ext_ack *extack)
3523{
3493 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3494 name_assign_type = NET_NAME_ENUM;
3495 }
3496
3497 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3498 if (IS_ERR(dest_net))
3499 return PTR_ERR(dest_net);
3500

--- 59 unchanged lines hidden (view full) ---

3560 unregister_netdevice(dev);
3561 }
3562 goto out;
3563}
3564
3565static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3566 struct netlink_ext_ack *extack)
3567{
3524 struct nlattr **attr;
3568 struct rtnl_newlink_tbs *tbs;
3525 int ret;
3526
3569 int ret;
3570
3527 attr = kmalloc_array(RTNL_MAX_TYPE + 1, sizeof(*attr), GFP_KERNEL);
3528 if (!attr)
3571 tbs = kmalloc(sizeof(*tbs), GFP_KERNEL);
3572 if (!tbs)
3529 return -ENOMEM;
3530
3573 return -ENOMEM;
3574
3531 ret = __rtnl_newlink(skb, nlh, attr, extack);
3532 kfree(attr);
3575 ret = __rtnl_newlink(skb, nlh, tbs, extack);
3576 kfree(tbs);
3533 return ret;
3534}
3535
3536static int rtnl_valid_getlink_req(struct sk_buff *skb,
3537 const struct nlmsghdr *nlh,
3538 struct nlattr **tb,
3539 struct netlink_ext_ack *extack)
3540{

--- 71 unchanged lines hidden (view full) ---

3612 if (tb[IFLA_EXT_MASK])
3613 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3614
3615 err = -EINVAL;
3616 ifm = nlmsg_data(nlh);
3617 if (ifm->ifi_index > 0)
3618 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3619 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3577 return ret;
3578}
3579
3580static int rtnl_valid_getlink_req(struct sk_buff *skb,
3581 const struct nlmsghdr *nlh,
3582 struct nlattr **tb,
3583 struct netlink_ext_ack *extack)
3584{

--- 71 unchanged lines hidden (view full) ---

3656 if (tb[IFLA_EXT_MASK])
3657 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3658
3659 err = -EINVAL;
3660 ifm = nlmsg_data(nlh);
3661 if (ifm->ifi_index > 0)
3662 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3663 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3620 dev = rtnl_dev_get(tgt_net, tb[IFLA_IFNAME],
3621 tb[IFLA_ALT_IFNAME], NULL);
3664 dev = rtnl_dev_get(tgt_net, tb);
3622 else
3623 goto out;
3624
3625 err = -ENODEV;
3626 if (dev == NULL)
3627 goto out;
3628
3629 err = -ENOBUFS;

--- 78 unchanged lines hidden (view full) ---

3708 err = rtnl_ensure_unique_netns(tb, extack, true);
3709 if (err)
3710 return err;
3711
3712 ifm = nlmsg_data(nlh);
3713 if (ifm->ifi_index > 0)
3714 dev = __dev_get_by_index(net, ifm->ifi_index);
3715 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3665 else
3666 goto out;
3667
3668 err = -ENODEV;
3669 if (dev == NULL)
3670 goto out;
3671
3672 err = -ENOBUFS;

--- 78 unchanged lines hidden (view full) ---

3751 err = rtnl_ensure_unique_netns(tb, extack, true);
3752 if (err)
3753 return err;
3754
3755 ifm = nlmsg_data(nlh);
3756 if (ifm->ifi_index > 0)
3757 dev = __dev_get_by_index(net, ifm->ifi_index);
3758 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3716 dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3717 tb[IFLA_ALT_IFNAME], NULL);
3759 dev = rtnl_dev_get(net, tb);
3718 else
3719 return -EINVAL;
3720
3721 if (!dev)
3722 return -ENODEV;
3723
3724 if (!tb[IFLA_PROP_LIST])
3725 return 0;

--- 401 unchanged lines hidden (view full) ---

4127 err = dev_uc_del(dev, addr);
4128 else if (is_multicast_ether_addr(addr))
4129 err = dev_mc_del(dev, addr);
4130
4131 return err;
4132}
4133EXPORT_SYMBOL(ndo_dflt_fdb_del);
4134
3760 else
3761 return -EINVAL;
3762
3763 if (!dev)
3764 return -ENODEV;
3765
3766 if (!tb[IFLA_PROP_LIST])
3767 return 0;

--- 401 unchanged lines hidden (view full) ---

4169 err = dev_uc_del(dev, addr);
4170 else if (is_multicast_ether_addr(addr))
4171 err = dev_mc_del(dev, addr);
4172
4173 return err;
4174}
4175EXPORT_SYMBOL(ndo_dflt_fdb_del);
4176
4177static const struct nla_policy fdb_del_bulk_policy[NDA_MAX + 1] = {
4178 [NDA_VLAN] = { .type = NLA_U16 },
4179 [NDA_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
4180 [NDA_NDM_STATE_MASK] = { .type = NLA_U16 },
4181 [NDA_NDM_FLAGS_MASK] = { .type = NLA_U8 },
4182};
4183
4135static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
4136 struct netlink_ext_ack *extack)
4137{
4184static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
4185 struct netlink_ext_ack *extack)
4186{
4187 bool del_bulk = !!(nlh->nlmsg_flags & NLM_F_BULK);
4138 struct net *net = sock_net(skb->sk);
4188 struct net *net = sock_net(skb->sk);
4189 const struct net_device_ops *ops;
4139 struct ndmsg *ndm;
4140 struct nlattr *tb[NDA_MAX+1];
4141 struct net_device *dev;
4190 struct ndmsg *ndm;
4191 struct nlattr *tb[NDA_MAX+1];
4192 struct net_device *dev;
4142 __u8 *addr;
4193 __u8 *addr = NULL;
4143 int err;
4144 u16 vid;
4145
4146 if (!netlink_capable(skb, CAP_NET_ADMIN))
4147 return -EPERM;
4148
4194 int err;
4195 u16 vid;
4196
4197 if (!netlink_capable(skb, CAP_NET_ADMIN))
4198 return -EPERM;
4199
4149 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
4150 extack);
4200 if (!del_bulk) {
4201 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX,
4202 NULL, extack);
4203 } else {
4204 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX,
4205 fdb_del_bulk_policy, extack);
4206 }
4151 if (err < 0)
4152 return err;
4153
4154 ndm = nlmsg_data(nlh);
4155 if (ndm->ndm_ifindex == 0) {
4156 NL_SET_ERR_MSG(extack, "invalid ifindex");
4157 return -EINVAL;
4158 }
4159
4160 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4161 if (dev == NULL) {
4162 NL_SET_ERR_MSG(extack, "unknown ifindex");
4163 return -ENODEV;
4164 }
4165
4207 if (err < 0)
4208 return err;
4209
4210 ndm = nlmsg_data(nlh);
4211 if (ndm->ndm_ifindex == 0) {
4212 NL_SET_ERR_MSG(extack, "invalid ifindex");
4213 return -EINVAL;
4214 }
4215
4216 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4217 if (dev == NULL) {
4218 NL_SET_ERR_MSG(extack, "unknown ifindex");
4219 return -ENODEV;
4220 }
4221
4166 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4167 NL_SET_ERR_MSG(extack, "invalid address");
4168 return -EINVAL;
4222 if (!del_bulk) {
4223 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4224 NL_SET_ERR_MSG(extack, "invalid address");
4225 return -EINVAL;
4226 }
4227 addr = nla_data(tb[NDA_LLADDR]);
4169 }
4170
4171 if (dev->type != ARPHRD_ETHER) {
4172 NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4173 return -EINVAL;
4174 }
4175
4228 }
4229
4230 if (dev->type != ARPHRD_ETHER) {
4231 NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4232 return -EINVAL;
4233 }
4234
4176 addr = nla_data(tb[NDA_LLADDR]);
4177
4178 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4179 if (err)
4180 return err;
4181
4182 err = -EOPNOTSUPP;
4183
4184 /* Support fdb on master device the net/bridge default case */
4185 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4186 netif_is_bridge_port(dev)) {
4187 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4235 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4236 if (err)
4237 return err;
4238
4239 err = -EOPNOTSUPP;
4240
4241 /* Support fdb on master device the net/bridge default case */
4242 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4243 netif_is_bridge_port(dev)) {
4244 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4188 const struct net_device_ops *ops = br_dev->netdev_ops;
4189
4245
4190 if (ops->ndo_fdb_del)
4191 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
4246 ops = br_dev->netdev_ops;
4247 if (!del_bulk) {
4248 if (ops->ndo_fdb_del)
4249 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
4250 } else {
4251 if (ops->ndo_fdb_del_bulk)
4252 err = ops->ndo_fdb_del_bulk(ndm, tb, dev, vid,
4253 extack);
4254 }
4192
4193 if (err)
4194 goto out;
4195 else
4196 ndm->ndm_flags &= ~NTF_MASTER;
4197 }
4198
4199 /* Embedded bridge, macvlan, and any other device support */
4200 if (ndm->ndm_flags & NTF_SELF) {
4255
4256 if (err)
4257 goto out;
4258 else
4259 ndm->ndm_flags &= ~NTF_MASTER;
4260 }
4261
4262 /* Embedded bridge, macvlan, and any other device support */
4263 if (ndm->ndm_flags & NTF_SELF) {
4201 if (dev->netdev_ops->ndo_fdb_del)
4202 err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
4203 vid);
4204 else
4205 err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4264 ops = dev->netdev_ops;
4265 if (!del_bulk) {
4266 if (ops->ndo_fdb_del)
4267 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
4268 else
4269 err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4270 } else {
4271 /* in case err was cleared by NTF_MASTER call */
4272 err = -EOPNOTSUPP;
4273 if (ops->ndo_fdb_del_bulk)
4274 err = ops->ndo_fdb_del_bulk(ndm, tb, dev, vid,
4275 extack);
4276 }
4206
4207 if (!err) {
4277
4278 if (!err) {
4208 rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4209 ndm->ndm_state);
4279 if (!del_bulk)
4280 rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4281 ndm->ndm_state);
4210 ndm->ndm_flags &= ~NTF_SELF;
4211 }
4212 }
4213out:
4214 return err;
4215}
4216
4217static int nlmsg_populate_fdb(struct sk_buff *skb,

--- 1673 unchanged lines hidden (view full) ---

5891
5892/* Process one rtnetlink message. */
5893
5894static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
5895 struct netlink_ext_ack *extack)
5896{
5897 struct net *net = sock_net(skb->sk);
5898 struct rtnl_link *link;
4282 ndm->ndm_flags &= ~NTF_SELF;
4283 }
4284 }
4285out:
4286 return err;
4287}
4288
4289static int nlmsg_populate_fdb(struct sk_buff *skb,

--- 1673 unchanged lines hidden (view full) ---

5963
5964/* Process one rtnetlink message. */
5965
5966static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
5967 struct netlink_ext_ack *extack)
5968{
5969 struct net *net = sock_net(skb->sk);
5970 struct rtnl_link *link;
5971 enum rtnl_kinds kind;
5899 struct module *owner;
5900 int err = -EOPNOTSUPP;
5901 rtnl_doit_func doit;
5902 unsigned int flags;
5972 struct module *owner;
5973 int err = -EOPNOTSUPP;
5974 rtnl_doit_func doit;
5975 unsigned int flags;
5903 int kind;
5904 int family;
5905 int type;
5906
5907 type = nlh->nlmsg_type;
5908 if (type > RTM_MAX)
5909 return -EOPNOTSUPP;
5910
5911 type -= RTM_BASE;
5912
5913 /* All the messages must have at least 1 byte length */
5914 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
5915 return 0;
5916
5917 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
5976 int family;
5977 int type;
5978
5979 type = nlh->nlmsg_type;
5980 if (type > RTM_MAX)
5981 return -EOPNOTSUPP;
5982
5983 type -= RTM_BASE;
5984
5985 /* All the messages must have at least 1 byte length */
5986 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
5987 return 0;
5988
5989 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
5918 kind = type&3;
5990 kind = rtnl_msgtype_kind(type);
5919
5991
5920 if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN))
5992 if (kind != RTNL_KIND_GET && !netlink_net_capable(skb, CAP_NET_ADMIN))
5921 return -EPERM;
5922
5923 rcu_read_lock();
5993 return -EPERM;
5994
5995 rcu_read_lock();
5924 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
5996 if (kind == RTNL_KIND_GET && (nlh->nlmsg_flags & NLM_F_DUMP)) {
5925 struct sock *rtnl;
5926 rtnl_dumpit_func dumpit;
5927 u32 min_dump_alloc = 0;
5928
5929 link = rtnl_get_link(family, type);
5930 if (!link || !link->dumpit) {
5931 family = PF_UNSPEC;
5932 link = rtnl_get_link(family, type);

--- 39 unchanged lines hidden (view full) ---

5972
5973 owner = link->owner;
5974 if (!try_module_get(owner)) {
5975 err = -EPROTONOSUPPORT;
5976 goto out_unlock;
5977 }
5978
5979 flags = link->flags;
5997 struct sock *rtnl;
5998 rtnl_dumpit_func dumpit;
5999 u32 min_dump_alloc = 0;
6000
6001 link = rtnl_get_link(family, type);
6002 if (!link || !link->dumpit) {
6003 family = PF_UNSPEC;
6004 link = rtnl_get_link(family, type);

--- 39 unchanged lines hidden (view full) ---

6044
6045 owner = link->owner;
6046 if (!try_module_get(owner)) {
6047 err = -EPROTONOSUPPORT;
6048 goto out_unlock;
6049 }
6050
6051 flags = link->flags;
6052 if (kind == RTNL_KIND_DEL && (nlh->nlmsg_flags & NLM_F_BULK) &&
6053 !(flags & RTNL_FLAG_BULK_DEL_SUPPORTED)) {
6054 NL_SET_ERR_MSG(extack, "Bulk delete is not supported");
6055 goto err_unlock;
6056 }
6057
5980 if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
5981 doit = link->doit;
5982 rcu_read_unlock();
5983 if (doit)
5984 err = doit(skb, nlh, extack);
5985 module_put(owner);
5986 return err;
5987 }

--- 112 unchanged lines hidden (view full) ---

6100 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0);
6101 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0);
6102 rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0);
6103
6104 rtnl_register(PF_UNSPEC, RTM_NEWLINKPROP, rtnl_newlinkprop, NULL, 0);
6105 rtnl_register(PF_UNSPEC, RTM_DELLINKPROP, rtnl_dellinkprop, NULL, 0);
6106
6107 rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0);
6058 if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
6059 doit = link->doit;
6060 rcu_read_unlock();
6061 if (doit)
6062 err = doit(skb, nlh, extack);
6063 module_put(owner);
6064 return err;
6065 }

--- 112 unchanged lines hidden (view full) ---

6178 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0);
6179 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0);
6180 rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0);
6181
6182 rtnl_register(PF_UNSPEC, RTM_NEWLINKPROP, rtnl_newlinkprop, NULL, 0);
6183 rtnl_register(PF_UNSPEC, RTM_DELLINKPROP, rtnl_dellinkprop, NULL, 0);
6184
6185 rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0);
6108 rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, 0);
6186 rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL,
6187 RTNL_FLAG_BULK_DEL_SUPPORTED);
6109 rtnl_register(PF_BRIDGE, RTM_GETNEIGH, rtnl_fdb_get, rtnl_fdb_dump, 0);
6110
6111 rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0);
6112 rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0);
6113 rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0);
6114
6115 rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
6116 0);
6117 rtnl_register(PF_UNSPEC, RTM_SETSTATS, rtnl_stats_set, NULL, 0);
6118}
6188 rtnl_register(PF_BRIDGE, RTM_GETNEIGH, rtnl_fdb_get, rtnl_fdb_dump, 0);
6189
6190 rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0);
6191 rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0);
6192 rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0);
6193
6194 rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
6195 0);
6196 rtnl_register(PF_UNSPEC, RTM_SETSTATS, rtnl_stats_set, NULL, 0);
6197}