1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
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. |
8 | */ |
9 | |
10 | #include <linux/netdevice.h> |
11 | #include <linux/rtnetlink.h> |
12 | #include <linux/export.h> |
13 | #include <linux/list.h> |
14 | |
15 | #include "dev.h" |
16 | |
17 | /* |
18 | * General list handling functions |
19 | */ |
20 | |
21 | static int __hw_addr_insert(struct netdev_hw_addr_list *list, |
22 | struct netdev_hw_addr *new, int addr_len) |
23 | { |
24 | struct rb_node **ins_point = &list->tree.rb_node, *parent = NULL; |
25 | struct netdev_hw_addr *ha; |
26 | |
27 | while (*ins_point) { |
28 | int diff; |
29 | |
30 | ha = rb_entry(*ins_point, struct netdev_hw_addr, node); |
31 | diff = memcmp(p: new->addr, q: ha->addr, size: addr_len); |
32 | if (diff == 0) |
33 | diff = memcmp(p: &new->type, q: &ha->type, size: sizeof(new->type)); |
34 | |
35 | parent = *ins_point; |
36 | if (diff < 0) |
37 | ins_point = &parent->rb_left; |
38 | else if (diff > 0) |
39 | ins_point = &parent->rb_right; |
40 | else |
41 | return -EEXIST; |
42 | } |
43 | |
44 | rb_link_node_rcu(node: &new->node, parent, rb_link: ins_point); |
45 | rb_insert_color(&new->node, &list->tree); |
46 | |
47 | return 0; |
48 | } |
49 | |
50 | static struct netdev_hw_addr* |
51 | __hw_addr_create(const unsigned char *addr, int addr_len, |
52 | unsigned char addr_type, bool global, bool sync) |
53 | { |
54 | struct netdev_hw_addr *ha; |
55 | int alloc_size; |
56 | |
57 | alloc_size = sizeof(*ha); |
58 | if (alloc_size < L1_CACHE_BYTES) |
59 | alloc_size = L1_CACHE_BYTES; |
60 | ha = kmalloc(size: alloc_size, GFP_ATOMIC); |
61 | if (!ha) |
62 | return NULL; |
63 | memcpy(ha->addr, addr, addr_len); |
64 | ha->type = addr_type; |
65 | ha->refcount = 1; |
66 | ha->global_use = global; |
67 | ha->synced = sync ? 1 : 0; |
68 | ha->sync_cnt = 0; |
69 | |
70 | return ha; |
71 | } |
72 | |
73 | static int __hw_addr_add_ex(struct netdev_hw_addr_list *list, |
74 | const unsigned char *addr, int addr_len, |
75 | unsigned char addr_type, bool global, bool sync, |
76 | int sync_count, bool exclusive) |
77 | { |
78 | struct rb_node **ins_point = &list->tree.rb_node, *parent = NULL; |
79 | struct netdev_hw_addr *ha; |
80 | |
81 | if (addr_len > MAX_ADDR_LEN) |
82 | return -EINVAL; |
83 | |
84 | while (*ins_point) { |
85 | int diff; |
86 | |
87 | ha = rb_entry(*ins_point, struct netdev_hw_addr, node); |
88 | diff = memcmp(p: addr, q: ha->addr, size: addr_len); |
89 | if (diff == 0) |
90 | diff = memcmp(p: &addr_type, q: &ha->type, size: sizeof(addr_type)); |
91 | |
92 | parent = *ins_point; |
93 | if (diff < 0) { |
94 | ins_point = &parent->rb_left; |
95 | } else if (diff > 0) { |
96 | ins_point = &parent->rb_right; |
97 | } else { |
98 | if (exclusive) |
99 | return -EEXIST; |
100 | if (global) { |
101 | /* check if addr is already used as global */ |
102 | if (ha->global_use) |
103 | return 0; |
104 | else |
105 | ha->global_use = true; |
106 | } |
107 | if (sync) { |
108 | if (ha->synced && sync_count) |
109 | return -EEXIST; |
110 | else |
111 | ha->synced++; |
112 | } |
113 | ha->refcount++; |
114 | return 0; |
115 | } |
116 | } |
117 | |
118 | ha = __hw_addr_create(addr, addr_len, addr_type, global, sync); |
119 | if (!ha) |
120 | return -ENOMEM; |
121 | |
122 | rb_link_node(node: &ha->node, parent, rb_link: ins_point); |
123 | rb_insert_color(&ha->node, &list->tree); |
124 | |
125 | list_add_tail_rcu(new: &ha->list, head: &list->list); |
126 | list->count++; |
127 | |
128 | return 0; |
129 | } |
130 | |
131 | static int __hw_addr_add(struct netdev_hw_addr_list *list, |
132 | const unsigned char *addr, int addr_len, |
133 | unsigned char addr_type) |
134 | { |
135 | return __hw_addr_add_ex(list, addr, addr_len, addr_type, global: false, sync: false, |
136 | sync_count: 0, exclusive: false); |
137 | } |
138 | |
139 | static int __hw_addr_del_entry(struct netdev_hw_addr_list *list, |
140 | struct netdev_hw_addr *ha, bool global, |
141 | bool sync) |
142 | { |
143 | if (global && !ha->global_use) |
144 | return -ENOENT; |
145 | |
146 | if (sync && !ha->synced) |
147 | return -ENOENT; |
148 | |
149 | if (global) |
150 | ha->global_use = false; |
151 | |
152 | if (sync) |
153 | ha->synced--; |
154 | |
155 | if (--ha->refcount) |
156 | return 0; |
157 | |
158 | rb_erase(&ha->node, &list->tree); |
159 | |
160 | list_del_rcu(entry: &ha->list); |
161 | kfree_rcu(ha, rcu_head); |
162 | list->count--; |
163 | return 0; |
164 | } |
165 | |
166 | static struct netdev_hw_addr *__hw_addr_lookup(struct netdev_hw_addr_list *list, |
167 | const unsigned char *addr, int addr_len, |
168 | unsigned char addr_type) |
169 | { |
170 | struct rb_node *node; |
171 | |
172 | node = list->tree.rb_node; |
173 | |
174 | while (node) { |
175 | struct netdev_hw_addr *ha = rb_entry(node, struct netdev_hw_addr, node); |
176 | int diff = memcmp(p: addr, q: ha->addr, size: addr_len); |
177 | |
178 | if (diff == 0 && addr_type) |
179 | diff = memcmp(p: &addr_type, q: &ha->type, size: sizeof(addr_type)); |
180 | |
181 | if (diff < 0) |
182 | node = node->rb_left; |
183 | else if (diff > 0) |
184 | node = node->rb_right; |
185 | else |
186 | return ha; |
187 | } |
188 | |
189 | return NULL; |
190 | } |
191 | |
192 | static int __hw_addr_del_ex(struct netdev_hw_addr_list *list, |
193 | const unsigned char *addr, int addr_len, |
194 | unsigned char addr_type, bool global, bool sync) |
195 | { |
196 | struct netdev_hw_addr *ha = __hw_addr_lookup(list, addr, addr_len, addr_type); |
197 | |
198 | if (!ha) |
199 | return -ENOENT; |
200 | return __hw_addr_del_entry(list, ha, global, sync); |
201 | } |
202 | |
203 | static int __hw_addr_del(struct netdev_hw_addr_list *list, |
204 | const unsigned char *addr, int addr_len, |
205 | unsigned char addr_type) |
206 | { |
207 | return __hw_addr_del_ex(list, addr, addr_len, addr_type, global: false, sync: false); |
208 | } |
209 | |
210 | static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list, |
211 | struct netdev_hw_addr *ha, |
212 | int addr_len) |
213 | { |
214 | int err; |
215 | |
216 | err = __hw_addr_add_ex(list: to_list, addr: ha->addr, addr_len, addr_type: ha->type, |
217 | global: false, sync: true, sync_count: ha->sync_cnt, exclusive: false); |
218 | if (err && err != -EEXIST) |
219 | return err; |
220 | |
221 | if (!err) { |
222 | ha->sync_cnt++; |
223 | ha->refcount++; |
224 | } |
225 | |
226 | return 0; |
227 | } |
228 | |
229 | static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list, |
230 | struct netdev_hw_addr_list *from_list, |
231 | struct netdev_hw_addr *ha, |
232 | int addr_len) |
233 | { |
234 | int err; |
235 | |
236 | err = __hw_addr_del_ex(list: to_list, addr: ha->addr, addr_len, addr_type: ha->type, |
237 | global: false, sync: true); |
238 | if (err) |
239 | return; |
240 | ha->sync_cnt--; |
241 | /* address on from list is not marked synced */ |
242 | __hw_addr_del_entry(list: from_list, ha, global: false, sync: false); |
243 | } |
244 | |
245 | static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list, |
246 | struct netdev_hw_addr_list *from_list, |
247 | int addr_len) |
248 | { |
249 | int err = 0; |
250 | struct netdev_hw_addr *ha, *tmp; |
251 | |
252 | list_for_each_entry_safe(ha, tmp, &from_list->list, list) { |
253 | if (ha->sync_cnt == ha->refcount) { |
254 | __hw_addr_unsync_one(to_list, from_list, ha, addr_len); |
255 | } else { |
256 | err = __hw_addr_sync_one(to_list, ha, addr_len); |
257 | if (err) |
258 | break; |
259 | } |
260 | } |
261 | return err; |
262 | } |
263 | |
264 | /* This function only works where there is a strict 1-1 relationship |
265 | * between source and destionation of they synch. If you ever need to |
266 | * sync addresses to more then 1 destination, you need to use |
267 | * __hw_addr_sync_multiple(). |
268 | */ |
269 | int __hw_addr_sync(struct netdev_hw_addr_list *to_list, |
270 | struct netdev_hw_addr_list *from_list, |
271 | int addr_len) |
272 | { |
273 | int err = 0; |
274 | struct netdev_hw_addr *ha, *tmp; |
275 | |
276 | list_for_each_entry_safe(ha, tmp, &from_list->list, list) { |
277 | if (!ha->sync_cnt) { |
278 | err = __hw_addr_sync_one(to_list, ha, addr_len); |
279 | if (err) |
280 | break; |
281 | } else if (ha->refcount == 1) |
282 | __hw_addr_unsync_one(to_list, from_list, ha, addr_len); |
283 | } |
284 | return err; |
285 | } |
286 | EXPORT_SYMBOL(__hw_addr_sync); |
287 | |
288 | void __hw_addr_unsync(struct netdev_hw_addr_list *to_list, |
289 | struct netdev_hw_addr_list *from_list, |
290 | int addr_len) |
291 | { |
292 | struct netdev_hw_addr *ha, *tmp; |
293 | |
294 | list_for_each_entry_safe(ha, tmp, &from_list->list, list) { |
295 | if (ha->sync_cnt) |
296 | __hw_addr_unsync_one(to_list, from_list, ha, addr_len); |
297 | } |
298 | } |
299 | EXPORT_SYMBOL(__hw_addr_unsync); |
300 | |
301 | /** |
302 | * __hw_addr_sync_dev - Synchonize device's multicast list |
303 | * @list: address list to syncronize |
304 | * @dev: device to sync |
305 | * @sync: function to call if address should be added |
306 | * @unsync: function to call if address should be removed |
307 | * |
308 | * This function is intended to be called from the ndo_set_rx_mode |
309 | * function of devices that require explicit address add/remove |
310 | * notifications. The unsync function may be NULL in which case |
311 | * the addresses requiring removal will simply be removed without |
312 | * any notification to the device. |
313 | **/ |
314 | int __hw_addr_sync_dev(struct netdev_hw_addr_list *list, |
315 | struct net_device *dev, |
316 | int (*sync)(struct net_device *, const unsigned char *), |
317 | int (*unsync)(struct net_device *, |
318 | const unsigned char *)) |
319 | { |
320 | struct netdev_hw_addr *ha, *tmp; |
321 | int err; |
322 | |
323 | /* first go through and flush out any stale entries */ |
324 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
325 | if (!ha->sync_cnt || ha->refcount != 1) |
326 | continue; |
327 | |
328 | /* if unsync is defined and fails defer unsyncing address */ |
329 | if (unsync && unsync(dev, ha->addr)) |
330 | continue; |
331 | |
332 | ha->sync_cnt--; |
333 | __hw_addr_del_entry(list, ha, global: false, sync: false); |
334 | } |
335 | |
336 | /* go through and sync new entries to the list */ |
337 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
338 | if (ha->sync_cnt) |
339 | continue; |
340 | |
341 | err = sync(dev, ha->addr); |
342 | if (err) |
343 | return err; |
344 | |
345 | ha->sync_cnt++; |
346 | ha->refcount++; |
347 | } |
348 | |
349 | return 0; |
350 | } |
351 | EXPORT_SYMBOL(__hw_addr_sync_dev); |
352 | |
353 | /** |
354 | * __hw_addr_ref_sync_dev - Synchronize device's multicast address list taking |
355 | * into account references |
356 | * @list: address list to synchronize |
357 | * @dev: device to sync |
358 | * @sync: function to call if address or reference on it should be added |
359 | * @unsync: function to call if address or some reference on it should removed |
360 | * |
361 | * This function is intended to be called from the ndo_set_rx_mode |
362 | * function of devices that require explicit address or references on it |
363 | * add/remove notifications. The unsync function may be NULL in which case |
364 | * the addresses or references on it requiring removal will simply be |
365 | * removed without any notification to the device. That is responsibility of |
366 | * the driver to identify and distribute address or references on it between |
367 | * internal address tables. |
368 | **/ |
369 | int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list, |
370 | struct net_device *dev, |
371 | int (*sync)(struct net_device *, |
372 | const unsigned char *, int), |
373 | int (*unsync)(struct net_device *, |
374 | const unsigned char *, int)) |
375 | { |
376 | struct netdev_hw_addr *ha, *tmp; |
377 | int err, ref_cnt; |
378 | |
379 | /* first go through and flush out any unsynced/stale entries */ |
380 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
381 | /* sync if address is not used */ |
382 | if ((ha->sync_cnt << 1) <= ha->refcount) |
383 | continue; |
384 | |
385 | /* if fails defer unsyncing address */ |
386 | ref_cnt = ha->refcount - ha->sync_cnt; |
387 | if (unsync && unsync(dev, ha->addr, ref_cnt)) |
388 | continue; |
389 | |
390 | ha->refcount = (ref_cnt << 1) + 1; |
391 | ha->sync_cnt = ref_cnt; |
392 | __hw_addr_del_entry(list, ha, global: false, sync: false); |
393 | } |
394 | |
395 | /* go through and sync updated/new entries to the list */ |
396 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
397 | /* sync if address added or reused */ |
398 | if ((ha->sync_cnt << 1) >= ha->refcount) |
399 | continue; |
400 | |
401 | ref_cnt = ha->refcount - ha->sync_cnt; |
402 | err = sync(dev, ha->addr, ref_cnt); |
403 | if (err) |
404 | return err; |
405 | |
406 | ha->refcount = ref_cnt << 1; |
407 | ha->sync_cnt = ref_cnt; |
408 | } |
409 | |
410 | return 0; |
411 | } |
412 | EXPORT_SYMBOL(__hw_addr_ref_sync_dev); |
413 | |
414 | /** |
415 | * __hw_addr_ref_unsync_dev - Remove synchronized addresses and references on |
416 | * it from device |
417 | * @list: address list to remove synchronized addresses (references on it) from |
418 | * @dev: device to sync |
419 | * @unsync: function to call if address and references on it should be removed |
420 | * |
421 | * Remove all addresses that were added to the device by |
422 | * __hw_addr_ref_sync_dev(). This function is intended to be called from the |
423 | * ndo_stop or ndo_open functions on devices that require explicit address (or |
424 | * references on it) add/remove notifications. If the unsync function pointer |
425 | * is NULL then this function can be used to just reset the sync_cnt for the |
426 | * addresses in the list. |
427 | **/ |
428 | void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list, |
429 | struct net_device *dev, |
430 | int (*unsync)(struct net_device *, |
431 | const unsigned char *, int)) |
432 | { |
433 | struct netdev_hw_addr *ha, *tmp; |
434 | |
435 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
436 | if (!ha->sync_cnt) |
437 | continue; |
438 | |
439 | /* if fails defer unsyncing address */ |
440 | if (unsync && unsync(dev, ha->addr, ha->sync_cnt)) |
441 | continue; |
442 | |
443 | ha->refcount -= ha->sync_cnt - 1; |
444 | ha->sync_cnt = 0; |
445 | __hw_addr_del_entry(list, ha, global: false, sync: false); |
446 | } |
447 | } |
448 | EXPORT_SYMBOL(__hw_addr_ref_unsync_dev); |
449 | |
450 | /** |
451 | * __hw_addr_unsync_dev - Remove synchronized addresses from device |
452 | * @list: address list to remove synchronized addresses from |
453 | * @dev: device to sync |
454 | * @unsync: function to call if address should be removed |
455 | * |
456 | * Remove all addresses that were added to the device by __hw_addr_sync_dev(). |
457 | * This function is intended to be called from the ndo_stop or ndo_open |
458 | * functions on devices that require explicit address add/remove |
459 | * notifications. If the unsync function pointer is NULL then this function |
460 | * can be used to just reset the sync_cnt for the addresses in the list. |
461 | **/ |
462 | void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list, |
463 | struct net_device *dev, |
464 | int (*unsync)(struct net_device *, |
465 | const unsigned char *)) |
466 | { |
467 | struct netdev_hw_addr *ha, *tmp; |
468 | |
469 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
470 | if (!ha->sync_cnt) |
471 | continue; |
472 | |
473 | /* if unsync is defined and fails defer unsyncing address */ |
474 | if (unsync && unsync(dev, ha->addr)) |
475 | continue; |
476 | |
477 | ha->sync_cnt--; |
478 | __hw_addr_del_entry(list, ha, global: false, sync: false); |
479 | } |
480 | } |
481 | EXPORT_SYMBOL(__hw_addr_unsync_dev); |
482 | |
483 | static void __hw_addr_flush(struct netdev_hw_addr_list *list) |
484 | { |
485 | struct netdev_hw_addr *ha, *tmp; |
486 | |
487 | list->tree = RB_ROOT; |
488 | list_for_each_entry_safe(ha, tmp, &list->list, list) { |
489 | list_del_rcu(entry: &ha->list); |
490 | kfree_rcu(ha, rcu_head); |
491 | } |
492 | list->count = 0; |
493 | } |
494 | |
495 | void __hw_addr_init(struct netdev_hw_addr_list *list) |
496 | { |
497 | INIT_LIST_HEAD(list: &list->list); |
498 | list->count = 0; |
499 | list->tree = RB_ROOT; |
500 | } |
501 | EXPORT_SYMBOL(__hw_addr_init); |
502 | |
503 | /* |
504 | * Device addresses handling functions |
505 | */ |
506 | |
507 | /* Check that netdev->dev_addr is not written to directly as this would |
508 | * break the rbtree layout. All changes should go thru dev_addr_set() and co. |
509 | * Remove this check in mid-2024. |
510 | */ |
511 | void dev_addr_check(struct net_device *dev) |
512 | { |
513 | if (!memcmp(p: dev->dev_addr, q: dev->dev_addr_shadow, MAX_ADDR_LEN)) |
514 | return; |
515 | |
516 | netdev_warn(dev, format: "Current addr: %*ph\n" , MAX_ADDR_LEN, dev->dev_addr); |
517 | netdev_warn(dev, format: "Expected addr: %*ph\n" , |
518 | MAX_ADDR_LEN, dev->dev_addr_shadow); |
519 | netdev_WARN(dev, "Incorrect netdev->dev_addr\n" ); |
520 | } |
521 | |
522 | /** |
523 | * dev_addr_flush - Flush device address list |
524 | * @dev: device |
525 | * |
526 | * Flush device address list and reset ->dev_addr. |
527 | * |
528 | * The caller must hold the rtnl_mutex. |
529 | */ |
530 | void dev_addr_flush(struct net_device *dev) |
531 | { |
532 | /* rtnl_mutex must be held here */ |
533 | dev_addr_check(dev); |
534 | |
535 | __hw_addr_flush(list: &dev->dev_addrs); |
536 | dev->dev_addr = NULL; |
537 | } |
538 | |
539 | /** |
540 | * dev_addr_init - Init device address list |
541 | * @dev: device |
542 | * |
543 | * Init device address list and create the first element, |
544 | * used by ->dev_addr. |
545 | * |
546 | * The caller must hold the rtnl_mutex. |
547 | */ |
548 | int dev_addr_init(struct net_device *dev) |
549 | { |
550 | unsigned char addr[MAX_ADDR_LEN]; |
551 | struct netdev_hw_addr *ha; |
552 | int err; |
553 | |
554 | /* rtnl_mutex must be held here */ |
555 | |
556 | __hw_addr_init(&dev->dev_addrs); |
557 | memset(addr, 0, sizeof(addr)); |
558 | err = __hw_addr_add(list: &dev->dev_addrs, addr, addr_len: sizeof(addr), |
559 | NETDEV_HW_ADDR_T_LAN); |
560 | if (!err) { |
561 | /* |
562 | * Get the first (previously created) address from the list |
563 | * and set dev_addr pointer to this location. |
564 | */ |
565 | ha = list_first_entry(&dev->dev_addrs.list, |
566 | struct netdev_hw_addr, list); |
567 | dev->dev_addr = ha->addr; |
568 | } |
569 | return err; |
570 | } |
571 | |
572 | void dev_addr_mod(struct net_device *dev, unsigned int offset, |
573 | const void *addr, size_t len) |
574 | { |
575 | struct netdev_hw_addr *ha; |
576 | |
577 | dev_addr_check(dev); |
578 | |
579 | ha = container_of(dev->dev_addr, struct netdev_hw_addr, addr[0]); |
580 | rb_erase(&ha->node, &dev->dev_addrs.tree); |
581 | memcpy(&ha->addr[offset], addr, len); |
582 | memcpy(&dev->dev_addr_shadow[offset], addr, len); |
583 | WARN_ON(__hw_addr_insert(&dev->dev_addrs, ha, dev->addr_len)); |
584 | } |
585 | EXPORT_SYMBOL(dev_addr_mod); |
586 | |
587 | /** |
588 | * dev_addr_add - Add a device address |
589 | * @dev: device |
590 | * @addr: address to add |
591 | * @addr_type: address type |
592 | * |
593 | * Add a device address to the device or increase the reference count if |
594 | * it already exists. |
595 | * |
596 | * The caller must hold the rtnl_mutex. |
597 | */ |
598 | int dev_addr_add(struct net_device *dev, const unsigned char *addr, |
599 | unsigned char addr_type) |
600 | { |
601 | int err; |
602 | |
603 | ASSERT_RTNL(); |
604 | |
605 | err = dev_pre_changeaddr_notify(dev, addr, NULL); |
606 | if (err) |
607 | return err; |
608 | err = __hw_addr_add(list: &dev->dev_addrs, addr, addr_len: dev->addr_len, addr_type); |
609 | if (!err) |
610 | call_netdevice_notifiers(val: NETDEV_CHANGEADDR, dev); |
611 | return err; |
612 | } |
613 | EXPORT_SYMBOL(dev_addr_add); |
614 | |
615 | /** |
616 | * dev_addr_del - Release a device address. |
617 | * @dev: device |
618 | * @addr: address to delete |
619 | * @addr_type: address type |
620 | * |
621 | * Release reference to a device address and remove it from the device |
622 | * if the reference count drops to zero. |
623 | * |
624 | * The caller must hold the rtnl_mutex. |
625 | */ |
626 | int dev_addr_del(struct net_device *dev, const unsigned char *addr, |
627 | unsigned char addr_type) |
628 | { |
629 | int err; |
630 | struct netdev_hw_addr *ha; |
631 | |
632 | ASSERT_RTNL(); |
633 | |
634 | /* |
635 | * We can not remove the first address from the list because |
636 | * dev->dev_addr points to that. |
637 | */ |
638 | ha = list_first_entry(&dev->dev_addrs.list, |
639 | struct netdev_hw_addr, list); |
640 | if (!memcmp(p: ha->addr, q: addr, size: dev->addr_len) && |
641 | ha->type == addr_type && ha->refcount == 1) |
642 | return -ENOENT; |
643 | |
644 | err = __hw_addr_del(list: &dev->dev_addrs, addr, addr_len: dev->addr_len, |
645 | addr_type); |
646 | if (!err) |
647 | call_netdevice_notifiers(val: NETDEV_CHANGEADDR, dev); |
648 | return err; |
649 | } |
650 | EXPORT_SYMBOL(dev_addr_del); |
651 | |
652 | /* |
653 | * Unicast list handling functions |
654 | */ |
655 | |
656 | /** |
657 | * dev_uc_add_excl - Add a global secondary unicast address |
658 | * @dev: device |
659 | * @addr: address to add |
660 | */ |
661 | int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr) |
662 | { |
663 | int err; |
664 | |
665 | netif_addr_lock_bh(dev); |
666 | err = __hw_addr_add_ex(list: &dev->uc, addr, addr_len: dev->addr_len, |
667 | NETDEV_HW_ADDR_T_UNICAST, global: true, sync: false, |
668 | sync_count: 0, exclusive: true); |
669 | if (!err) |
670 | __dev_set_rx_mode(dev); |
671 | netif_addr_unlock_bh(dev); |
672 | return err; |
673 | } |
674 | EXPORT_SYMBOL(dev_uc_add_excl); |
675 | |
676 | /** |
677 | * dev_uc_add - Add a secondary unicast address |
678 | * @dev: device |
679 | * @addr: address to add |
680 | * |
681 | * Add a secondary unicast address to the device or increase |
682 | * the reference count if it already exists. |
683 | */ |
684 | int dev_uc_add(struct net_device *dev, const unsigned char *addr) |
685 | { |
686 | int err; |
687 | |
688 | netif_addr_lock_bh(dev); |
689 | err = __hw_addr_add(list: &dev->uc, addr, addr_len: dev->addr_len, |
690 | NETDEV_HW_ADDR_T_UNICAST); |
691 | if (!err) |
692 | __dev_set_rx_mode(dev); |
693 | netif_addr_unlock_bh(dev); |
694 | return err; |
695 | } |
696 | EXPORT_SYMBOL(dev_uc_add); |
697 | |
698 | /** |
699 | * dev_uc_del - Release secondary unicast address. |
700 | * @dev: device |
701 | * @addr: address to delete |
702 | * |
703 | * Release reference to a secondary unicast address and remove it |
704 | * from the device if the reference count drops to zero. |
705 | */ |
706 | int dev_uc_del(struct net_device *dev, const unsigned char *addr) |
707 | { |
708 | int err; |
709 | |
710 | netif_addr_lock_bh(dev); |
711 | err = __hw_addr_del(list: &dev->uc, addr, addr_len: dev->addr_len, |
712 | NETDEV_HW_ADDR_T_UNICAST); |
713 | if (!err) |
714 | __dev_set_rx_mode(dev); |
715 | netif_addr_unlock_bh(dev); |
716 | return err; |
717 | } |
718 | EXPORT_SYMBOL(dev_uc_del); |
719 | |
720 | /** |
721 | * dev_uc_sync - Synchronize device's unicast list to another device |
722 | * @to: destination device |
723 | * @from: source device |
724 | * |
725 | * Add newly added addresses to the destination device and release |
726 | * addresses that have no users left. The source device must be |
727 | * locked by netif_addr_lock_bh. |
728 | * |
729 | * This function is intended to be called from the dev->set_rx_mode |
730 | * function of layered software devices. This function assumes that |
731 | * addresses will only ever be synced to the @to devices and no other. |
732 | */ |
733 | int dev_uc_sync(struct net_device *to, struct net_device *from) |
734 | { |
735 | int err = 0; |
736 | |
737 | if (to->addr_len != from->addr_len) |
738 | return -EINVAL; |
739 | |
740 | netif_addr_lock(dev: to); |
741 | err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len); |
742 | if (!err) |
743 | __dev_set_rx_mode(dev: to); |
744 | netif_addr_unlock(dev: to); |
745 | return err; |
746 | } |
747 | EXPORT_SYMBOL(dev_uc_sync); |
748 | |
749 | /** |
750 | * dev_uc_sync_multiple - Synchronize device's unicast list to another |
751 | * device, but allow for multiple calls to sync to multiple devices. |
752 | * @to: destination device |
753 | * @from: source device |
754 | * |
755 | * Add newly added addresses to the destination device and release |
756 | * addresses that have been deleted from the source. The source device |
757 | * must be locked by netif_addr_lock_bh. |
758 | * |
759 | * This function is intended to be called from the dev->set_rx_mode |
760 | * function of layered software devices. It allows for a single source |
761 | * device to be synced to multiple destination devices. |
762 | */ |
763 | int dev_uc_sync_multiple(struct net_device *to, struct net_device *from) |
764 | { |
765 | int err = 0; |
766 | |
767 | if (to->addr_len != from->addr_len) |
768 | return -EINVAL; |
769 | |
770 | netif_addr_lock(dev: to); |
771 | err = __hw_addr_sync_multiple(to_list: &to->uc, from_list: &from->uc, addr_len: to->addr_len); |
772 | if (!err) |
773 | __dev_set_rx_mode(dev: to); |
774 | netif_addr_unlock(dev: to); |
775 | return err; |
776 | } |
777 | EXPORT_SYMBOL(dev_uc_sync_multiple); |
778 | |
779 | /** |
780 | * dev_uc_unsync - Remove synchronized addresses from the destination device |
781 | * @to: destination device |
782 | * @from: source device |
783 | * |
784 | * Remove all addresses that were added to the destination device by |
785 | * dev_uc_sync(). This function is intended to be called from the |
786 | * dev->stop function of layered software devices. |
787 | */ |
788 | void dev_uc_unsync(struct net_device *to, struct net_device *from) |
789 | { |
790 | if (to->addr_len != from->addr_len) |
791 | return; |
792 | |
793 | /* netif_addr_lock_bh() uses lockdep subclass 0, this is okay for two |
794 | * reasons: |
795 | * 1) This is always called without any addr_list_lock, so as the |
796 | * outermost one here, it must be 0. |
797 | * 2) This is called by some callers after unlinking the upper device, |
798 | * so the dev->lower_level becomes 1 again. |
799 | * Therefore, the subclass for 'from' is 0, for 'to' is either 1 or |
800 | * larger. |
801 | */ |
802 | netif_addr_lock_bh(dev: from); |
803 | netif_addr_lock(dev: to); |
804 | __hw_addr_unsync(&to->uc, &from->uc, to->addr_len); |
805 | __dev_set_rx_mode(dev: to); |
806 | netif_addr_unlock(dev: to); |
807 | netif_addr_unlock_bh(dev: from); |
808 | } |
809 | EXPORT_SYMBOL(dev_uc_unsync); |
810 | |
811 | /** |
812 | * dev_uc_flush - Flush unicast addresses |
813 | * @dev: device |
814 | * |
815 | * Flush unicast addresses. |
816 | */ |
817 | void dev_uc_flush(struct net_device *dev) |
818 | { |
819 | netif_addr_lock_bh(dev); |
820 | __hw_addr_flush(list: &dev->uc); |
821 | netif_addr_unlock_bh(dev); |
822 | } |
823 | EXPORT_SYMBOL(dev_uc_flush); |
824 | |
825 | /** |
826 | * dev_uc_init - Init unicast address list |
827 | * @dev: device |
828 | * |
829 | * Init unicast address list. |
830 | */ |
831 | void dev_uc_init(struct net_device *dev) |
832 | { |
833 | __hw_addr_init(&dev->uc); |
834 | } |
835 | EXPORT_SYMBOL(dev_uc_init); |
836 | |
837 | /* |
838 | * Multicast list handling functions |
839 | */ |
840 | |
841 | /** |
842 | * dev_mc_add_excl - Add a global secondary multicast address |
843 | * @dev: device |
844 | * @addr: address to add |
845 | */ |
846 | int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr) |
847 | { |
848 | int err; |
849 | |
850 | netif_addr_lock_bh(dev); |
851 | err = __hw_addr_add_ex(list: &dev->mc, addr, addr_len: dev->addr_len, |
852 | NETDEV_HW_ADDR_T_MULTICAST, global: true, sync: false, |
853 | sync_count: 0, exclusive: true); |
854 | if (!err) |
855 | __dev_set_rx_mode(dev); |
856 | netif_addr_unlock_bh(dev); |
857 | return err; |
858 | } |
859 | EXPORT_SYMBOL(dev_mc_add_excl); |
860 | |
861 | static int __dev_mc_add(struct net_device *dev, const unsigned char *addr, |
862 | bool global) |
863 | { |
864 | int err; |
865 | |
866 | netif_addr_lock_bh(dev); |
867 | err = __hw_addr_add_ex(list: &dev->mc, addr, addr_len: dev->addr_len, |
868 | NETDEV_HW_ADDR_T_MULTICAST, global, sync: false, |
869 | sync_count: 0, exclusive: false); |
870 | if (!err) |
871 | __dev_set_rx_mode(dev); |
872 | netif_addr_unlock_bh(dev); |
873 | return err; |
874 | } |
875 | /** |
876 | * dev_mc_add - Add a multicast address |
877 | * @dev: device |
878 | * @addr: address to add |
879 | * |
880 | * Add a multicast address to the device or increase |
881 | * the reference count if it already exists. |
882 | */ |
883 | int dev_mc_add(struct net_device *dev, const unsigned char *addr) |
884 | { |
885 | return __dev_mc_add(dev, addr, global: false); |
886 | } |
887 | EXPORT_SYMBOL(dev_mc_add); |
888 | |
889 | /** |
890 | * dev_mc_add_global - Add a global multicast address |
891 | * @dev: device |
892 | * @addr: address to add |
893 | * |
894 | * Add a global multicast address to the device. |
895 | */ |
896 | int dev_mc_add_global(struct net_device *dev, const unsigned char *addr) |
897 | { |
898 | return __dev_mc_add(dev, addr, global: true); |
899 | } |
900 | EXPORT_SYMBOL(dev_mc_add_global); |
901 | |
902 | static int __dev_mc_del(struct net_device *dev, const unsigned char *addr, |
903 | bool global) |
904 | { |
905 | int err; |
906 | |
907 | netif_addr_lock_bh(dev); |
908 | err = __hw_addr_del_ex(list: &dev->mc, addr, addr_len: dev->addr_len, |
909 | NETDEV_HW_ADDR_T_MULTICAST, global, sync: false); |
910 | if (!err) |
911 | __dev_set_rx_mode(dev); |
912 | netif_addr_unlock_bh(dev); |
913 | return err; |
914 | } |
915 | |
916 | /** |
917 | * dev_mc_del - Delete a multicast address. |
918 | * @dev: device |
919 | * @addr: address to delete |
920 | * |
921 | * Release reference to a multicast address and remove it |
922 | * from the device if the reference count drops to zero. |
923 | */ |
924 | int dev_mc_del(struct net_device *dev, const unsigned char *addr) |
925 | { |
926 | return __dev_mc_del(dev, addr, global: false); |
927 | } |
928 | EXPORT_SYMBOL(dev_mc_del); |
929 | |
930 | /** |
931 | * dev_mc_del_global - Delete a global multicast address. |
932 | * @dev: device |
933 | * @addr: address to delete |
934 | * |
935 | * Release reference to a multicast address and remove it |
936 | * from the device if the reference count drops to zero. |
937 | */ |
938 | int dev_mc_del_global(struct net_device *dev, const unsigned char *addr) |
939 | { |
940 | return __dev_mc_del(dev, addr, global: true); |
941 | } |
942 | EXPORT_SYMBOL(dev_mc_del_global); |
943 | |
944 | /** |
945 | * dev_mc_sync - Synchronize device's multicast list to another device |
946 | * @to: destination device |
947 | * @from: source device |
948 | * |
949 | * Add newly added addresses to the destination device and release |
950 | * addresses that have no users left. The source device must be |
951 | * locked by netif_addr_lock_bh. |
952 | * |
953 | * This function is intended to be called from the ndo_set_rx_mode |
954 | * function of layered software devices. |
955 | */ |
956 | int dev_mc_sync(struct net_device *to, struct net_device *from) |
957 | { |
958 | int err = 0; |
959 | |
960 | if (to->addr_len != from->addr_len) |
961 | return -EINVAL; |
962 | |
963 | netif_addr_lock(dev: to); |
964 | err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len); |
965 | if (!err) |
966 | __dev_set_rx_mode(dev: to); |
967 | netif_addr_unlock(dev: to); |
968 | return err; |
969 | } |
970 | EXPORT_SYMBOL(dev_mc_sync); |
971 | |
972 | /** |
973 | * dev_mc_sync_multiple - Synchronize device's multicast list to another |
974 | * device, but allow for multiple calls to sync to multiple devices. |
975 | * @to: destination device |
976 | * @from: source device |
977 | * |
978 | * Add newly added addresses to the destination device and release |
979 | * addresses that have no users left. The source device must be |
980 | * locked by netif_addr_lock_bh. |
981 | * |
982 | * This function is intended to be called from the ndo_set_rx_mode |
983 | * function of layered software devices. It allows for a single |
984 | * source device to be synced to multiple destination devices. |
985 | */ |
986 | int dev_mc_sync_multiple(struct net_device *to, struct net_device *from) |
987 | { |
988 | int err = 0; |
989 | |
990 | if (to->addr_len != from->addr_len) |
991 | return -EINVAL; |
992 | |
993 | netif_addr_lock(dev: to); |
994 | err = __hw_addr_sync_multiple(to_list: &to->mc, from_list: &from->mc, addr_len: to->addr_len); |
995 | if (!err) |
996 | __dev_set_rx_mode(dev: to); |
997 | netif_addr_unlock(dev: to); |
998 | return err; |
999 | } |
1000 | EXPORT_SYMBOL(dev_mc_sync_multiple); |
1001 | |
1002 | /** |
1003 | * dev_mc_unsync - Remove synchronized addresses from the destination device |
1004 | * @to: destination device |
1005 | * @from: source device |
1006 | * |
1007 | * Remove all addresses that were added to the destination device by |
1008 | * dev_mc_sync(). This function is intended to be called from the |
1009 | * dev->stop function of layered software devices. |
1010 | */ |
1011 | void dev_mc_unsync(struct net_device *to, struct net_device *from) |
1012 | { |
1013 | if (to->addr_len != from->addr_len) |
1014 | return; |
1015 | |
1016 | /* See the above comments inside dev_uc_unsync(). */ |
1017 | netif_addr_lock_bh(dev: from); |
1018 | netif_addr_lock(dev: to); |
1019 | __hw_addr_unsync(&to->mc, &from->mc, to->addr_len); |
1020 | __dev_set_rx_mode(dev: to); |
1021 | netif_addr_unlock(dev: to); |
1022 | netif_addr_unlock_bh(dev: from); |
1023 | } |
1024 | EXPORT_SYMBOL(dev_mc_unsync); |
1025 | |
1026 | /** |
1027 | * dev_mc_flush - Flush multicast addresses |
1028 | * @dev: device |
1029 | * |
1030 | * Flush multicast addresses. |
1031 | */ |
1032 | void dev_mc_flush(struct net_device *dev) |
1033 | { |
1034 | netif_addr_lock_bh(dev); |
1035 | __hw_addr_flush(list: &dev->mc); |
1036 | netif_addr_unlock_bh(dev); |
1037 | } |
1038 | EXPORT_SYMBOL(dev_mc_flush); |
1039 | |
1040 | /** |
1041 | * dev_mc_init - Init multicast address list |
1042 | * @dev: device |
1043 | * |
1044 | * Init multicast address list. |
1045 | */ |
1046 | void dev_mc_init(struct net_device *dev) |
1047 | { |
1048 | __hw_addr_init(&dev->mc); |
1049 | } |
1050 | EXPORT_SYMBOL(dev_mc_init); |
1051 | |