blob: 2f949b5a1eb9cd9a65e0c0a6d089032a92e100e2 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Jiri Pirkoa748ee22010-04-01 21:22:09 +00002/*
3 * net/core/dev_addr_lists.c - Functions for handling net device lists
4 * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
5 *
6 * This file contains functions for working with unicast, multicast and device
7 * addresses lists.
Jiri Pirkoa748ee22010-04-01 21:22:09 +00008 */
9
10#include <linux/netdevice.h>
11#include <linux/rtnetlink.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040012#include <linux/export.h>
Jiri Pirkoa748ee22010-04-01 21:22:09 +000013#include <linux/list.h>
14
15/*
16 * General list handling functions
17 */
18
John Fastabend12a94632012-04-15 06:44:02 +000019static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
stephen hemminger6b6e2722012-09-17 10:03:26 +000020 const unsigned char *addr, int addr_len,
Vlad Yasevich4cd729b02013-04-15 09:54:25 +000021 unsigned char addr_type, bool global,
22 bool sync)
John Fastabend12a94632012-04-15 06:44:02 +000023{
24 struct netdev_hw_addr *ha;
25 int alloc_size;
26
27 alloc_size = sizeof(*ha);
28 if (alloc_size < L1_CACHE_BYTES)
29 alloc_size = L1_CACHE_BYTES;
30 ha = kmalloc(alloc_size, GFP_ATOMIC);
31 if (!ha)
32 return -ENOMEM;
33 memcpy(ha->addr, addr, addr_len);
34 ha->type = addr_type;
35 ha->refcount = 1;
36 ha->global_use = global;
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -050037 ha->synced = sync ? 1 : 0;
Jay Vosburgh9747ba62013-05-31 11:57:26 +000038 ha->sync_cnt = 0;
John Fastabend12a94632012-04-15 06:44:02 +000039 list_add_tail_rcu(&ha->list, &list->list);
40 list->count++;
41
42 return 0;
43}
44
Jiri Pirko22bedad32010-04-01 21:22:57 +000045static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
stephen hemminger6b6e2722012-09-17 10:03:26 +000046 const unsigned char *addr, int addr_len,
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -050047 unsigned char addr_type, bool global, bool sync,
48 int sync_count)
Jiri Pirkoa748ee22010-04-01 21:22:09 +000049{
50 struct netdev_hw_addr *ha;
Jiri Pirkoa748ee22010-04-01 21:22:09 +000051
52 if (addr_len > MAX_ADDR_LEN)
53 return -EINVAL;
54
55 list_for_each_entry(ha, &list->list, list) {
Eric Dumazet77d36392018-04-07 13:42:40 -070056 if (ha->type == addr_type &&
57 !memcmp(ha->addr, addr, addr_len)) {
Jiri Pirko22bedad32010-04-01 21:22:57 +000058 if (global) {
59 /* check if addr is already used as global */
60 if (ha->global_use)
61 return 0;
62 else
63 ha->global_use = true;
64 }
Vlad Yasevich4cd729b02013-04-15 09:54:25 +000065 if (sync) {
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -050066 if (ha->synced && sync_count)
Jay Vosburgh29ca2f82013-05-31 11:57:28 +000067 return -EEXIST;
Vlad Yasevich4cd729b02013-04-15 09:54:25 +000068 else
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -050069 ha->synced++;
Vlad Yasevich4cd729b02013-04-15 09:54:25 +000070 }
Jiri Pirkoa748ee22010-04-01 21:22:09 +000071 ha->refcount++;
72 return 0;
73 }
74 }
75
Vlad Yasevich4cd729b02013-04-15 09:54:25 +000076 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
77 sync);
Jiri Pirkoa748ee22010-04-01 21:22:09 +000078}
79
stephen hemminger6b6e2722012-09-17 10:03:26 +000080static int __hw_addr_add(struct netdev_hw_addr_list *list,
81 const unsigned char *addr, int addr_len,
82 unsigned char addr_type)
Jiri Pirko22bedad32010-04-01 21:22:57 +000083{
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -050084 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
85 0);
Vlad Yasevich4cd729b02013-04-15 09:54:25 +000086}
87
88static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
89 struct netdev_hw_addr *ha, bool global,
90 bool sync)
91{
92 if (global && !ha->global_use)
93 return -ENOENT;
94
95 if (sync && !ha->synced)
96 return -ENOENT;
97
98 if (global)
99 ha->global_use = false;
100
101 if (sync)
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -0500102 ha->synced--;
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000103
104 if (--ha->refcount)
105 return 0;
106 list_del_rcu(&ha->list);
107 kfree_rcu(ha, rcu_head);
108 list->count--;
109 return 0;
Jiri Pirko22bedad32010-04-01 21:22:57 +0000110}
111
Jiri Pirko22bedad32010-04-01 21:22:57 +0000112static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
stephen hemminger6b6e2722012-09-17 10:03:26 +0000113 const unsigned char *addr, int addr_len,
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000114 unsigned char addr_type, bool global, bool sync)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000115{
116 struct netdev_hw_addr *ha;
117
118 list_for_each_entry(ha, &list->list, list) {
119 if (!memcmp(ha->addr, addr, addr_len) &&
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000120 (ha->type == addr_type || !addr_type))
121 return __hw_addr_del_entry(list, ha, global, sync);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000122 }
123 return -ENOENT;
124}
125
stephen hemminger6b6e2722012-09-17 10:03:26 +0000126static int __hw_addr_del(struct netdev_hw_addr_list *list,
127 const unsigned char *addr, int addr_len,
128 unsigned char addr_type)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000129{
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000130 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
131}
132
133static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
134 struct netdev_hw_addr *ha,
135 int addr_len)
136{
137 int err;
138
139 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -0500140 false, true, ha->sync_cnt);
Jay Vosburgh29ca2f82013-05-31 11:57:28 +0000141 if (err && err != -EEXIST)
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000142 return err;
Jay Vosburgh29ca2f82013-05-31 11:57:28 +0000143
144 if (!err) {
145 ha->sync_cnt++;
146 ha->refcount++;
147 }
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000148
149 return 0;
150}
151
152static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
153 struct netdev_hw_addr_list *from_list,
154 struct netdev_hw_addr *ha,
155 int addr_len)
156{
157 int err;
158
159 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
160 false, true);
161 if (err)
162 return;
163 ha->sync_cnt--;
Jay Vosburgh60ba8342013-05-31 11:57:27 +0000164 /* address on from list is not marked synced */
165 __hw_addr_del_entry(from_list, ha, false, false);
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000166}
167
168static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
169 struct netdev_hw_addr_list *from_list,
170 int addr_len)
171{
172 int err = 0;
173 struct netdev_hw_addr *ha, *tmp;
174
175 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
176 if (ha->sync_cnt == ha->refcount) {
177 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
178 } else {
179 err = __hw_addr_sync_one(to_list, ha, addr_len);
180 if (err)
181 break;
182 }
183 }
184 return err;
Jiri Pirko22bedad32010-04-01 21:22:57 +0000185}
186
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000187/* This function only works where there is a strict 1-1 relationship
188 * between source and destionation of they synch. If you ever need to
189 * sync addresses to more then 1 destination, you need to use
190 * __hw_addr_sync_multiple().
191 */
Jiri Pirko22bedad32010-04-01 21:22:57 +0000192int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
193 struct netdev_hw_addr_list *from_list,
194 int addr_len)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000195{
196 int err = 0;
197 struct netdev_hw_addr *ha, *tmp;
198
199 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000200 if (!ha->sync_cnt) {
201 err = __hw_addr_sync_one(to_list, ha, addr_len);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000202 if (err)
203 break;
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000204 } else if (ha->refcount == 1)
205 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000206 }
207 return err;
208}
Jiri Pirko22bedad32010-04-01 21:22:57 +0000209EXPORT_SYMBOL(__hw_addr_sync);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000210
Jiri Pirko22bedad32010-04-01 21:22:57 +0000211void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
212 struct netdev_hw_addr_list *from_list,
213 int addr_len)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000214{
215 struct netdev_hw_addr *ha, *tmp;
216
217 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000218 if (ha->sync_cnt)
219 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000220 }
221}
Jiri Pirko22bedad32010-04-01 21:22:57 +0000222EXPORT_SYMBOL(__hw_addr_unsync);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000223
Alexander Duyck670e5b82014-05-28 18:44:46 -0700224/**
225 * __hw_addr_sync_dev - Synchonize device's multicast list
226 * @list: address list to syncronize
227 * @dev: device to sync
228 * @sync: function to call if address should be added
229 * @unsync: function to call if address should be removed
230 *
231 * This funciton is intended to be called from the ndo_set_rx_mode
232 * function of devices that require explicit address add/remove
233 * notifications. The unsync function may be NULL in which case
234 * the addresses requiring removal will simply be removed without
235 * any notification to the device.
236 **/
237int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
238 struct net_device *dev,
239 int (*sync)(struct net_device *, const unsigned char *),
240 int (*unsync)(struct net_device *,
241 const unsigned char *))
242{
243 struct netdev_hw_addr *ha, *tmp;
244 int err;
245
246 /* first go through and flush out any stale entries */
247 list_for_each_entry_safe(ha, tmp, &list->list, list) {
248 if (!ha->sync_cnt || ha->refcount != 1)
249 continue;
250
251 /* if unsync is defined and fails defer unsyncing address */
252 if (unsync && unsync(dev, ha->addr))
253 continue;
254
255 ha->sync_cnt--;
256 __hw_addr_del_entry(list, ha, false, false);
257 }
258
259 /* go through and sync new entries to the list */
260 list_for_each_entry_safe(ha, tmp, &list->list, list) {
261 if (ha->sync_cnt)
262 continue;
263
264 err = sync(dev, ha->addr);
265 if (err)
266 return err;
267
268 ha->sync_cnt++;
269 ha->refcount++;
270 }
271
272 return 0;
273}
274EXPORT_SYMBOL(__hw_addr_sync_dev);
275
276/**
Ivan Khoronzhuke7946762018-11-08 22:27:54 +0200277 * __hw_addr_ref_sync_dev - Synchronize device's multicast address list taking
278 * into account references
279 * @list: address list to synchronize
280 * @dev: device to sync
281 * @sync: function to call if address or reference on it should be added
282 * @unsync: function to call if address or some reference on it should removed
283 *
284 * This function is intended to be called from the ndo_set_rx_mode
285 * function of devices that require explicit address or references on it
286 * add/remove notifications. The unsync function may be NULL in which case
287 * the addresses or references on it requiring removal will simply be
288 * removed without any notification to the device. That is responsibility of
289 * the driver to identify and distribute address or references on it between
290 * internal address tables.
291 **/
292int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
293 struct net_device *dev,
294 int (*sync)(struct net_device *,
295 const unsigned char *, int),
296 int (*unsync)(struct net_device *,
297 const unsigned char *, int))
298{
299 struct netdev_hw_addr *ha, *tmp;
300 int err, ref_cnt;
301
302 /* first go through and flush out any unsynced/stale entries */
303 list_for_each_entry_safe(ha, tmp, &list->list, list) {
304 /* sync if address is not used */
305 if ((ha->sync_cnt << 1) <= ha->refcount)
306 continue;
307
308 /* if fails defer unsyncing address */
309 ref_cnt = ha->refcount - ha->sync_cnt;
310 if (unsync && unsync(dev, ha->addr, ref_cnt))
311 continue;
312
313 ha->refcount = (ref_cnt << 1) + 1;
314 ha->sync_cnt = ref_cnt;
315 __hw_addr_del_entry(list, ha, false, false);
316 }
317
318 /* go through and sync updated/new entries to the list */
319 list_for_each_entry_safe(ha, tmp, &list->list, list) {
320 /* sync if address added or reused */
321 if ((ha->sync_cnt << 1) >= ha->refcount)
322 continue;
323
324 ref_cnt = ha->refcount - ha->sync_cnt;
325 err = sync(dev, ha->addr, ref_cnt);
326 if (err)
327 return err;
328
329 ha->refcount = ref_cnt << 1;
330 ha->sync_cnt = ref_cnt;
331 }
332
333 return 0;
334}
335EXPORT_SYMBOL(__hw_addr_ref_sync_dev);
336
337/**
338 * __hw_addr_ref_unsync_dev - Remove synchronized addresses and references on
339 * it from device
340 * @list: address list to remove synchronized addresses (references on it) from
341 * @dev: device to sync
342 * @unsync: function to call if address and references on it should be removed
343 *
344 * Remove all addresses that were added to the device by
345 * __hw_addr_ref_sync_dev(). This function is intended to be called from the
346 * ndo_stop or ndo_open functions on devices that require explicit address (or
347 * references on it) add/remove notifications. If the unsync function pointer
348 * is NULL then this function can be used to just reset the sync_cnt for the
349 * addresses in the list.
350 **/
351void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
352 struct net_device *dev,
353 int (*unsync)(struct net_device *,
354 const unsigned char *, int))
355{
356 struct netdev_hw_addr *ha, *tmp;
357
358 list_for_each_entry_safe(ha, tmp, &list->list, list) {
359 if (!ha->sync_cnt)
360 continue;
361
362 /* if fails defer unsyncing address */
363 if (unsync && unsync(dev, ha->addr, ha->sync_cnt))
364 continue;
365
366 ha->refcount -= ha->sync_cnt - 1;
367 ha->sync_cnt = 0;
368 __hw_addr_del_entry(list, ha, false, false);
369 }
370}
371EXPORT_SYMBOL(__hw_addr_ref_unsync_dev);
372
373/**
Fabian Frederick1d2398d2014-11-17 22:04:03 +0100374 * __hw_addr_unsync_dev - Remove synchronized addresses from device
375 * @list: address list to remove synchronized addresses from
Alexander Duyck670e5b82014-05-28 18:44:46 -0700376 * @dev: device to sync
377 * @unsync: function to call if address should be removed
378 *
379 * Remove all addresses that were added to the device by __hw_addr_sync_dev().
380 * This function is intended to be called from the ndo_stop or ndo_open
381 * functions on devices that require explicit address add/remove
382 * notifications. If the unsync function pointer is NULL then this function
383 * can be used to just reset the sync_cnt for the addresses in the list.
384 **/
385void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
386 struct net_device *dev,
387 int (*unsync)(struct net_device *,
388 const unsigned char *))
389{
390 struct netdev_hw_addr *ha, *tmp;
391
392 list_for_each_entry_safe(ha, tmp, &list->list, list) {
393 if (!ha->sync_cnt)
394 continue;
395
396 /* if unsync is defined and fails defer unsyncing address */
397 if (unsync && unsync(dev, ha->addr))
398 continue;
399
400 ha->sync_cnt--;
401 __hw_addr_del_entry(list, ha, false, false);
402 }
403}
404EXPORT_SYMBOL(__hw_addr_unsync_dev);
405
stephen hemminger477bb932013-12-13 12:35:56 -0800406static void __hw_addr_flush(struct netdev_hw_addr_list *list)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000407{
408 struct netdev_hw_addr *ha, *tmp;
409
410 list_for_each_entry_safe(ha, tmp, &list->list, list) {
411 list_del_rcu(&ha->list);
Lai Jiangshan217f1862011-03-15 18:08:58 +0800412 kfree_rcu(ha, rcu_head);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000413 }
414 list->count = 0;
415}
416
Jiri Pirko22bedad32010-04-01 21:22:57 +0000417void __hw_addr_init(struct netdev_hw_addr_list *list)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000418{
419 INIT_LIST_HEAD(&list->list);
420 list->count = 0;
421}
Jiri Pirko22bedad32010-04-01 21:22:57 +0000422EXPORT_SYMBOL(__hw_addr_init);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000423
424/*
425 * Device addresses handling functions
426 */
427
428/**
429 * dev_addr_flush - Flush device address list
430 * @dev: device
431 *
432 * Flush device address list and reset ->dev_addr.
433 *
434 * The caller must hold the rtnl_mutex.
435 */
436void dev_addr_flush(struct net_device *dev)
437{
438 /* rtnl_mutex must be held here */
439
440 __hw_addr_flush(&dev->dev_addrs);
441 dev->dev_addr = NULL;
442}
443EXPORT_SYMBOL(dev_addr_flush);
444
445/**
446 * dev_addr_init - Init device address list
447 * @dev: device
448 *
449 * Init device address list and create the first element,
450 * used by ->dev_addr.
451 *
452 * The caller must hold the rtnl_mutex.
453 */
454int dev_addr_init(struct net_device *dev)
455{
456 unsigned char addr[MAX_ADDR_LEN];
457 struct netdev_hw_addr *ha;
458 int err;
459
460 /* rtnl_mutex must be held here */
461
462 __hw_addr_init(&dev->dev_addrs);
463 memset(addr, 0, sizeof(addr));
464 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
465 NETDEV_HW_ADDR_T_LAN);
466 if (!err) {
467 /*
468 * Get the first (previously created) address from the list
469 * and set dev_addr pointer to this location.
470 */
471 ha = list_first_entry(&dev->dev_addrs.list,
472 struct netdev_hw_addr, list);
473 dev->dev_addr = ha->addr;
474 }
475 return err;
476}
477EXPORT_SYMBOL(dev_addr_init);
478
479/**
480 * dev_addr_add - Add a device address
481 * @dev: device
482 * @addr: address to add
483 * @addr_type: address type
484 *
485 * Add a device address to the device or increase the reference count if
486 * it already exists.
487 *
488 * The caller must hold the rtnl_mutex.
489 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000490int dev_addr_add(struct net_device *dev, const unsigned char *addr,
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000491 unsigned char addr_type)
492{
493 int err;
494
495 ASSERT_RTNL();
496
Petr Machatad59cdf92018-12-13 11:54:35 +0000497 err = dev_pre_changeaddr_notify(dev, addr, NULL);
498 if (err)
499 return err;
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000500 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
501 if (!err)
502 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
503 return err;
504}
505EXPORT_SYMBOL(dev_addr_add);
506
507/**
508 * dev_addr_del - Release a device address.
509 * @dev: device
510 * @addr: address to delete
511 * @addr_type: address type
512 *
513 * Release reference to a device address and remove it from the device
514 * if the reference count drops to zero.
515 *
516 * The caller must hold the rtnl_mutex.
517 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000518int dev_addr_del(struct net_device *dev, const unsigned char *addr,
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000519 unsigned char addr_type)
520{
521 int err;
522 struct netdev_hw_addr *ha;
523
524 ASSERT_RTNL();
525
526 /*
527 * We can not remove the first address from the list because
528 * dev->dev_addr points to that.
529 */
530 ha = list_first_entry(&dev->dev_addrs.list,
531 struct netdev_hw_addr, list);
Jiri Pirkoa6522082012-11-14 02:51:04 +0000532 if (!memcmp(ha->addr, addr, dev->addr_len) &&
533 ha->type == addr_type && ha->refcount == 1)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000534 return -ENOENT;
535
536 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
537 addr_type);
538 if (!err)
539 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
540 return err;
541}
542EXPORT_SYMBOL(dev_addr_del);
543
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000544/*
545 * Unicast list handling functions
546 */
547
548/**
John Fastabend12a94632012-04-15 06:44:02 +0000549 * dev_uc_add_excl - Add a global secondary unicast address
550 * @dev: device
551 * @addr: address to add
552 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000553int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
John Fastabend12a94632012-04-15 06:44:02 +0000554{
555 struct netdev_hw_addr *ha;
556 int err;
557
558 netif_addr_lock_bh(dev);
559 list_for_each_entry(ha, &dev->uc.list, list) {
560 if (!memcmp(ha->addr, addr, dev->addr_len) &&
561 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
562 err = -EEXIST;
563 goto out;
564 }
565 }
566 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000567 NETDEV_HW_ADDR_T_UNICAST, true, false);
John Fastabend12a94632012-04-15 06:44:02 +0000568 if (!err)
569 __dev_set_rx_mode(dev);
570out:
571 netif_addr_unlock_bh(dev);
572 return err;
573}
574EXPORT_SYMBOL(dev_uc_add_excl);
575
576/**
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000577 * dev_uc_add - Add a secondary unicast address
578 * @dev: device
579 * @addr: address to add
580 *
581 * Add a secondary unicast address to the device or increase
582 * the reference count if it already exists.
583 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000584int dev_uc_add(struct net_device *dev, const unsigned char *addr)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000585{
586 int err;
587
588 netif_addr_lock_bh(dev);
589 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
590 NETDEV_HW_ADDR_T_UNICAST);
591 if (!err)
592 __dev_set_rx_mode(dev);
593 netif_addr_unlock_bh(dev);
594 return err;
595}
596EXPORT_SYMBOL(dev_uc_add);
597
598/**
599 * dev_uc_del - Release secondary unicast address.
600 * @dev: device
601 * @addr: address to delete
602 *
603 * Release reference to a secondary unicast address and remove it
604 * from the device if the reference count drops to zero.
605 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000606int dev_uc_del(struct net_device *dev, const unsigned char *addr)
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000607{
608 int err;
609
610 netif_addr_lock_bh(dev);
611 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
612 NETDEV_HW_ADDR_T_UNICAST);
613 if (!err)
614 __dev_set_rx_mode(dev);
615 netif_addr_unlock_bh(dev);
616 return err;
617}
618EXPORT_SYMBOL(dev_uc_del);
619
620/**
621 * dev_uc_sync - Synchronize device's unicast list to another device
622 * @to: destination device
623 * @from: source device
624 *
625 * Add newly added addresses to the destination device and release
626 * addresses that have no users left. The source device must be
Jiri Pirkoab16ebf2012-01-09 06:18:34 +0000627 * locked by netif_addr_lock_bh.
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000628 *
629 * This function is intended to be called from the dev->set_rx_mode
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000630 * function of layered software devices. This function assumes that
631 * addresses will only ever be synced to the @to devices and no other.
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000632 */
633int dev_uc_sync(struct net_device *to, struct net_device *from)
634{
635 int err = 0;
636
637 if (to->addr_len != from->addr_len)
638 return -EINVAL;
639
Taehee Yoof3b0a182019-10-21 18:47:58 +0000640 netif_addr_lock(to);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000641 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
642 if (!err)
643 __dev_set_rx_mode(to);
Jiri Pirko2429f7a2012-01-09 06:36:54 +0000644 netif_addr_unlock(to);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000645 return err;
646}
647EXPORT_SYMBOL(dev_uc_sync);
648
649/**
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000650 * dev_uc_sync_multiple - Synchronize device's unicast list to another
651 * device, but allow for multiple calls to sync to multiple devices.
652 * @to: destination device
653 * @from: source device
654 *
655 * Add newly added addresses to the destination device and release
656 * addresses that have been deleted from the source. The source device
657 * must be locked by netif_addr_lock_bh.
658 *
659 * This function is intended to be called from the dev->set_rx_mode
660 * function of layered software devices. It allows for a single source
661 * device to be synced to multiple destination devices.
662 */
663int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
664{
665 int err = 0;
666
667 if (to->addr_len != from->addr_len)
668 return -EINVAL;
669
Taehee Yoof3b0a182019-10-21 18:47:58 +0000670 netif_addr_lock(to);
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000671 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
672 if (!err)
673 __dev_set_rx_mode(to);
674 netif_addr_unlock(to);
675 return err;
676}
677EXPORT_SYMBOL(dev_uc_sync_multiple);
678
679/**
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000680 * dev_uc_unsync - Remove synchronized addresses from the destination device
681 * @to: destination device
682 * @from: source device
683 *
684 * Remove all addresses that were added to the destination device by
685 * dev_uc_sync(). This function is intended to be called from the
686 * dev->stop function of layered software devices.
687 */
688void dev_uc_unsync(struct net_device *to, struct net_device *from)
689{
690 if (to->addr_len != from->addr_len)
691 return;
692
693 netif_addr_lock_bh(from);
Taehee Yoof3b0a182019-10-21 18:47:58 +0000694 netif_addr_lock(to);
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000695 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
696 __dev_set_rx_mode(to);
697 netif_addr_unlock(to);
698 netif_addr_unlock_bh(from);
699}
700EXPORT_SYMBOL(dev_uc_unsync);
701
702/**
703 * dev_uc_flush - Flush unicast addresses
704 * @dev: device
705 *
706 * Flush unicast addresses.
707 */
708void dev_uc_flush(struct net_device *dev)
709{
710 netif_addr_lock_bh(dev);
711 __hw_addr_flush(&dev->uc);
712 netif_addr_unlock_bh(dev);
713}
714EXPORT_SYMBOL(dev_uc_flush);
715
716/**
717 * dev_uc_flush - Init unicast address list
718 * @dev: device
719 *
720 * Init unicast address list.
721 */
722void dev_uc_init(struct net_device *dev)
723{
724 __hw_addr_init(&dev->uc);
725}
726EXPORT_SYMBOL(dev_uc_init);
727
728/*
729 * Multicast list handling functions
730 */
731
John Fastabend12a94632012-04-15 06:44:02 +0000732/**
733 * dev_mc_add_excl - Add a global secondary multicast address
734 * @dev: device
735 * @addr: address to add
736 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000737int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
John Fastabend12a94632012-04-15 06:44:02 +0000738{
739 struct netdev_hw_addr *ha;
740 int err;
741
742 netif_addr_lock_bh(dev);
743 list_for_each_entry(ha, &dev->mc.list, list) {
744 if (!memcmp(ha->addr, addr, dev->addr_len) &&
745 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
746 err = -EEXIST;
747 goto out;
748 }
749 }
750 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000751 NETDEV_HW_ADDR_T_MULTICAST, true, false);
John Fastabend12a94632012-04-15 06:44:02 +0000752 if (!err)
753 __dev_set_rx_mode(dev);
754out:
755 netif_addr_unlock_bh(dev);
756 return err;
757}
758EXPORT_SYMBOL(dev_mc_add_excl);
759
stephen hemminger6b6e2722012-09-17 10:03:26 +0000760static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
Jiri Pirko22bedad32010-04-01 21:22:57 +0000761 bool global)
762{
763 int err;
764
765 netif_addr_lock_bh(dev);
766 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
Vlad Yasevich6ef7b8a2014-01-22 12:54:15 -0500767 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000768 if (!err)
769 __dev_set_rx_mode(dev);
770 netif_addr_unlock_bh(dev);
771 return err;
772}
773/**
774 * dev_mc_add - Add a multicast address
775 * @dev: device
776 * @addr: address to add
777 *
778 * Add a multicast address to the device or increase
779 * the reference count if it already exists.
780 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000781int dev_mc_add(struct net_device *dev, const unsigned char *addr)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000782{
783 return __dev_mc_add(dev, addr, false);
784}
785EXPORT_SYMBOL(dev_mc_add);
786
787/**
788 * dev_mc_add_global - Add a global multicast address
789 * @dev: device
790 * @addr: address to add
791 *
792 * Add a global multicast address to the device.
793 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000794int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000795{
796 return __dev_mc_add(dev, addr, true);
797}
798EXPORT_SYMBOL(dev_mc_add_global);
799
stephen hemminger6b6e2722012-09-17 10:03:26 +0000800static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
Jiri Pirko22bedad32010-04-01 21:22:57 +0000801 bool global)
802{
803 int err;
804
805 netif_addr_lock_bh(dev);
806 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000807 NETDEV_HW_ADDR_T_MULTICAST, global, false);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000808 if (!err)
809 __dev_set_rx_mode(dev);
810 netif_addr_unlock_bh(dev);
811 return err;
812}
813
814/**
815 * dev_mc_del - Delete a multicast address.
816 * @dev: device
817 * @addr: address to delete
818 *
819 * Release reference to a multicast address and remove it
820 * from the device if the reference count drops to zero.
821 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000822int dev_mc_del(struct net_device *dev, const unsigned char *addr)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000823{
824 return __dev_mc_del(dev, addr, false);
825}
826EXPORT_SYMBOL(dev_mc_del);
827
828/**
829 * dev_mc_del_global - Delete a global multicast address.
830 * @dev: device
831 * @addr: address to delete
832 *
833 * Release reference to a multicast address and remove it
834 * from the device if the reference count drops to zero.
835 */
stephen hemminger6b6e2722012-09-17 10:03:26 +0000836int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000837{
838 return __dev_mc_del(dev, addr, true);
839}
840EXPORT_SYMBOL(dev_mc_del_global);
841
842/**
Zhi Yong Wucdfb97b2013-10-28 16:15:50 +0800843 * dev_mc_sync - Synchronize device's multicast list to another device
Jiri Pirko22bedad32010-04-01 21:22:57 +0000844 * @to: destination device
845 * @from: source device
846 *
847 * Add newly added addresses to the destination device and release
848 * addresses that have no users left. The source device must be
Jiri Pirkoab16ebf2012-01-09 06:18:34 +0000849 * locked by netif_addr_lock_bh.
Jiri Pirko22bedad32010-04-01 21:22:57 +0000850 *
Jiri Pirkob81693d2011-08-16 06:29:02 +0000851 * This function is intended to be called from the ndo_set_rx_mode
852 * function of layered software devices.
Jiri Pirko22bedad32010-04-01 21:22:57 +0000853 */
854int dev_mc_sync(struct net_device *to, struct net_device *from)
855{
856 int err = 0;
857
858 if (to->addr_len != from->addr_len)
859 return -EINVAL;
860
Taehee Yoof3b0a182019-10-21 18:47:58 +0000861 netif_addr_lock(to);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000862 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
863 if (!err)
864 __dev_set_rx_mode(to);
Jiri Pirko2429f7a2012-01-09 06:36:54 +0000865 netif_addr_unlock(to);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000866 return err;
867}
868EXPORT_SYMBOL(dev_mc_sync);
869
870/**
Zhi Yong Wucdfb97b2013-10-28 16:15:50 +0800871 * dev_mc_sync_multiple - Synchronize device's multicast list to another
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000872 * device, but allow for multiple calls to sync to multiple devices.
873 * @to: destination device
874 * @from: source device
875 *
876 * Add newly added addresses to the destination device and release
877 * addresses that have no users left. The source device must be
878 * locked by netif_addr_lock_bh.
879 *
880 * This function is intended to be called from the ndo_set_rx_mode
881 * function of layered software devices. It allows for a single
882 * source device to be synced to multiple destination devices.
883 */
884int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
885{
886 int err = 0;
887
888 if (to->addr_len != from->addr_len)
889 return -EINVAL;
890
Taehee Yoof3b0a182019-10-21 18:47:58 +0000891 netif_addr_lock(to);
Jay Vosburghb190a502013-05-31 11:57:29 +0000892 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
Vlad Yasevich4cd729b02013-04-15 09:54:25 +0000893 if (!err)
894 __dev_set_rx_mode(to);
895 netif_addr_unlock(to);
896 return err;
897}
898EXPORT_SYMBOL(dev_mc_sync_multiple);
899
900/**
Jiri Pirko22bedad32010-04-01 21:22:57 +0000901 * dev_mc_unsync - Remove synchronized addresses from the destination device
902 * @to: destination device
903 * @from: source device
904 *
905 * Remove all addresses that were added to the destination device by
906 * dev_mc_sync(). This function is intended to be called from the
907 * dev->stop function of layered software devices.
908 */
909void dev_mc_unsync(struct net_device *to, struct net_device *from)
910{
911 if (to->addr_len != from->addr_len)
912 return;
913
914 netif_addr_lock_bh(from);
Taehee Yoof3b0a182019-10-21 18:47:58 +0000915 netif_addr_lock(to);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000916 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
917 __dev_set_rx_mode(to);
918 netif_addr_unlock(to);
919 netif_addr_unlock_bh(from);
920}
921EXPORT_SYMBOL(dev_mc_unsync);
922
923/**
924 * dev_mc_flush - Flush multicast addresses
925 * @dev: device
926 *
927 * Flush multicast addresses.
928 */
929void dev_mc_flush(struct net_device *dev)
930{
931 netif_addr_lock_bh(dev);
932 __hw_addr_flush(&dev->mc);
933 netif_addr_unlock_bh(dev);
934}
935EXPORT_SYMBOL(dev_mc_flush);
936
937/**
sunlianwenbb9aaaa2018-04-18 09:22:39 +0800938 * dev_mc_init - Init multicast address list
Jiri Pirko22bedad32010-04-01 21:22:57 +0000939 * @dev: device
940 *
941 * Init multicast address list.
942 */
943void dev_mc_init(struct net_device *dev)
944{
945 __hw_addr_init(&dev->mc);
946}
947EXPORT_SYMBOL(dev_mc_init);