~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/bonding.h

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Bond several ethernet interfaces into a Cisco, running 'Etherchannel'.
  3  *
  4  * Portions are (c) Copyright 1995 Simon "Guru Aleph-Null" Janes
  5  * NCM: Network and Communications Management, Inc.
  6  *
  7  * BUT, I'm the one who modified it for ethernet, so:
  8  * (c) Copyright 1999, Thomas Davis, tadavis@lbl.gov
  9  *
 10  *      This software may be used and distributed according to the terms
 11  *      of the GNU Public License, incorporated herein by reference.
 12  *
 13  */
 14 
 15 #ifndef _NET_BONDING_H
 16 #define _NET_BONDING_H
 17 
 18 #include <linux/timer.h>
 19 #include <linux/proc_fs.h>
 20 #include <linux/if_bonding.h>
 21 #include <linux/cpumask.h>
 22 #include <linux/in6.h>
 23 #include <linux/netpoll.h>
 24 #include <linux/inetdevice.h>
 25 #include <linux/etherdevice.h>
 26 #include <linux/reciprocal_div.h>
 27 #include <linux/if_link.h>
 28 
 29 #include <net/bond_3ad.h>
 30 #include <net/bond_alb.h>
 31 #include <net/bond_options.h>
 32 
 33 #define BOND_MAX_ARP_TARGETS    16
 34 
 35 #define BOND_DEFAULT_MIIMON     100
 36 
 37 #ifndef __long_aligned
 38 #define __long_aligned __attribute__((aligned((sizeof(long)))))
 39 #endif
 40 
 41 #define slave_info(bond_dev, slave_dev, fmt, ...) \
 42         netdev_info(bond_dev, "(slave %s): " fmt, (slave_dev)->name, ##__VA_ARGS__)
 43 #define slave_warn(bond_dev, slave_dev, fmt, ...) \
 44         netdev_warn(bond_dev, "(slave %s): " fmt, (slave_dev)->name, ##__VA_ARGS__)
 45 #define slave_dbg(bond_dev, slave_dev, fmt, ...) \
 46         netdev_dbg(bond_dev, "(slave %s): " fmt, (slave_dev)->name, ##__VA_ARGS__)
 47 #define slave_err(bond_dev, slave_dev, fmt, ...) \
 48         netdev_err(bond_dev, "(slave %s): " fmt, (slave_dev)->name, ##__VA_ARGS__)
 49 
 50 #define BOND_MODE(bond) ((bond)->params.mode)
 51 
 52 /* slave list primitives */
 53 #define bond_slave_list(bond) (&(bond)->dev->adj_list.lower)
 54 
 55 #define bond_has_slaves(bond) !list_empty(bond_slave_list(bond))
 56 
 57 /* IMPORTANT: bond_first/last_slave can return NULL in case of an empty list */
 58 #define bond_first_slave(bond) \
 59         (bond_has_slaves(bond) ? \
 60                 netdev_adjacent_get_private(bond_slave_list(bond)->next) : \
 61                 NULL)
 62 #define bond_last_slave(bond) \
 63         (bond_has_slaves(bond) ? \
 64                 netdev_adjacent_get_private(bond_slave_list(bond)->prev) : \
 65                 NULL)
 66 
 67 /* Caller must have rcu_read_lock */
 68 #define bond_first_slave_rcu(bond) \
 69         netdev_lower_get_first_private_rcu(bond->dev)
 70 
 71 #define bond_is_first_slave(bond, pos) (pos == bond_first_slave(bond))
 72 #define bond_is_last_slave(bond, pos) (pos == bond_last_slave(bond))
 73 
 74 /**
 75  * bond_for_each_slave - iterate over all slaves
 76  * @bond:       the bond holding this list
 77  * @pos:        current slave
 78  * @iter:       list_head * iterator
 79  *
 80  * Caller must hold RTNL
 81  */
 82 #define bond_for_each_slave(bond, pos, iter) \
 83         netdev_for_each_lower_private((bond)->dev, pos, iter)
 84 
 85 /* Caller must have rcu_read_lock */
 86 #define bond_for_each_slave_rcu(bond, pos, iter) \
 87         netdev_for_each_lower_private_rcu((bond)->dev, pos, iter)
 88 
 89 #ifdef CONFIG_NET_POLL_CONTROLLER
 90 extern atomic_t netpoll_block_tx;
 91 
 92 static inline void block_netpoll_tx(void)
 93 {
 94         atomic_inc(&netpoll_block_tx);
 95 }
 96 
 97 static inline void unblock_netpoll_tx(void)
 98 {
 99         atomic_dec(&netpoll_block_tx);
100 }
101 
102 static inline int is_netpoll_tx_blocked(struct net_device *dev)
103 {
104         if (unlikely(netpoll_tx_running(dev)))
105                 return atomic_read(&netpoll_block_tx);
106         return 0;
107 }
108 #else
109 #define block_netpoll_tx()
110 #define unblock_netpoll_tx()
111 #define is_netpoll_tx_blocked(dev) (0)
112 #endif
113 
114 struct bond_params {
115         int mode;
116         int xmit_policy;
117         int miimon;
118         u8 num_peer_notif;
119         int arp_interval;
120         int arp_validate;
121         int arp_all_targets;
122         int use_carrier;
123         int fail_over_mac;
124         int updelay;
125         int downdelay;
126         int peer_notif_delay;
127         int lacp_fast;
128         unsigned int min_links;
129         int ad_select;
130         char primary[IFNAMSIZ];
131         int primary_reselect;
132         __be32 arp_targets[BOND_MAX_ARP_TARGETS];
133         int tx_queues;
134         int all_slaves_active;
135         int resend_igmp;
136         int lp_interval;
137         int packets_per_slave;
138         int tlb_dynamic_lb;
139         struct reciprocal_value reciprocal_packets_per_slave;
140         u16 ad_actor_sys_prio;
141         u16 ad_user_port_key;
142 
143         /* 2 bytes of padding : see ether_addr_equal_64bits() */
144         u8 ad_actor_system[ETH_ALEN + 2];
145 };
146 
147 struct bond_parm_tbl {
148         char *modename;
149         int mode;
150 };
151 
152 struct slave {
153         struct net_device *dev; /* first - useful for panic debug */
154         struct bonding *bond; /* our master */
155         int    delay;
156         /* all three in jiffies */
157         unsigned long last_link_up;
158         unsigned long last_rx;
159         unsigned long target_last_arp_rx[BOND_MAX_ARP_TARGETS];
160         s8     link;            /* one of BOND_LINK_XXXX */
161         s8     link_new_state;  /* one of BOND_LINK_XXXX */
162         u8     backup:1,   /* indicates backup slave. Value corresponds with
163                               BOND_STATE_ACTIVE and BOND_STATE_BACKUP */
164                inactive:1, /* indicates inactive slave */
165                should_notify:1, /* indicates whether the state changed */
166                should_notify_link:1; /* indicates whether the link changed */
167         u8     duplex;
168         u32    original_mtu;
169         u32    link_failure_count;
170         u32    speed;
171         u16    queue_id;
172         u8     perm_hwaddr[MAX_ADDR_LEN];
173         struct ad_slave_info *ad_info;
174         struct tlb_slave_info tlb_info;
175 #ifdef CONFIG_NET_POLL_CONTROLLER
176         struct netpoll *np;
177 #endif
178         struct delayed_work notify_work;
179         struct kobject kobj;
180         struct rtnl_link_stats64 slave_stats;
181 };
182 
183 struct bond_up_slave {
184         unsigned int    count;
185         struct rcu_head rcu;
186         struct slave    *arr[];
187 };
188 
189 /*
190  * Link pseudo-state only used internally by monitors
191  */
192 #define BOND_LINK_NOCHANGE -1
193 
194 /*
195  * Here are the locking policies for the two bonding locks:
196  * Get rcu_read_lock when reading or RTNL when writing slave list.
197  */
198 struct bonding {
199         struct   net_device *dev; /* first - useful for panic debug */
200         struct   slave __rcu *curr_active_slave;
201         struct   slave __rcu *current_arp_slave;
202         struct   slave __rcu *primary_slave;
203         struct   bond_up_slave __rcu *slave_arr; /* Array of usable slaves */
204         bool     force_primary;
205         s32      slave_cnt; /* never change this value outside the attach/detach wrappers */
206         int     (*recv_probe)(const struct sk_buff *, struct bonding *,
207                               struct slave *);
208         /* mode_lock is used for mode-specific locking needs, currently used by:
209          * 3ad mode (4) - protect against running bond_3ad_unbind_slave() and
210          *                bond_3ad_state_machine_handler() concurrently and also
211          *                the access to the state machine shared variables.
212          * TLB mode (5) - to sync the use and modifications of its hash table
213          * ALB mode (6) - to sync the use and modifications of its hash table
214          */
215         spinlock_t mode_lock;
216         spinlock_t stats_lock;
217         u8       send_peer_notif;
218         u8       igmp_retrans;
219 #ifdef CONFIG_PROC_FS
220         struct   proc_dir_entry *proc_entry;
221         char     proc_file_name[IFNAMSIZ];
222 #endif /* CONFIG_PROC_FS */
223         struct   list_head bond_list;
224         u32      rr_tx_counter;
225         struct   ad_bond_info ad_info;
226         struct   alb_bond_info alb_info;
227         struct   bond_params params;
228         struct   workqueue_struct *wq;
229         struct   delayed_work mii_work;
230         struct   delayed_work arp_work;
231         struct   delayed_work alb_work;
232         struct   delayed_work ad_work;
233         struct   delayed_work mcast_work;
234         struct   delayed_work slave_arr_work;
235 #ifdef CONFIG_DEBUG_FS
236         /* debugging support via debugfs */
237         struct   dentry *debug_dir;
238 #endif /* CONFIG_DEBUG_FS */
239         struct rtnl_link_stats64 bond_stats;
240         struct lock_class_key stats_lock_key;
241 };
242 
243 #define bond_slave_get_rcu(dev) \
244         ((struct slave *) rcu_dereference(dev->rx_handler_data))
245 
246 #define bond_slave_get_rtnl(dev) \
247         ((struct slave *) rtnl_dereference(dev->rx_handler_data))
248 
249 void bond_queue_slave_event(struct slave *slave);
250 void bond_lower_state_changed(struct slave *slave);
251 
252 struct bond_vlan_tag {
253         __be16          vlan_proto;
254         unsigned short  vlan_id;
255 };
256 
257 /**
258  * Returns NULL if the net_device does not belong to any of the bond's slaves
259  *
260  * Caller must hold bond lock for read
261  */
262 static inline struct slave *bond_get_slave_by_dev(struct bonding *bond,
263                                                   struct net_device *slave_dev)
264 {
265         return netdev_lower_dev_get_private(bond->dev, slave_dev);
266 }
267 
268 static inline struct bonding *bond_get_bond_by_slave(struct slave *slave)
269 {
270         return slave->bond;
271 }
272 
273 static inline bool bond_should_override_tx_queue(struct bonding *bond)
274 {
275         return BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP ||
276                BOND_MODE(bond) == BOND_MODE_ROUNDROBIN;
277 }
278 
279 static inline bool bond_is_lb(const struct bonding *bond)
280 {
281         return BOND_MODE(bond) == BOND_MODE_TLB ||
282                BOND_MODE(bond) == BOND_MODE_ALB;
283 }
284 
285 static inline bool bond_needs_speed_duplex(const struct bonding *bond)
286 {
287         return BOND_MODE(bond) == BOND_MODE_8023AD || bond_is_lb(bond);
288 }
289 
290 static inline bool bond_is_nondyn_tlb(const struct bonding *bond)
291 {
292         return (bond_is_lb(bond) && bond->params.tlb_dynamic_lb == 0);
293 }
294 
295 static inline bool bond_mode_can_use_xmit_hash(const struct bonding *bond)
296 {
297         return (BOND_MODE(bond) == BOND_MODE_8023AD ||
298                 BOND_MODE(bond) == BOND_MODE_XOR ||
299                 BOND_MODE(bond) == BOND_MODE_TLB ||
300                 BOND_MODE(bond) == BOND_MODE_ALB);
301 }
302 
303 static inline bool bond_mode_uses_xmit_hash(const struct bonding *bond)
304 {
305         return (BOND_MODE(bond) == BOND_MODE_8023AD ||
306                 BOND_MODE(bond) == BOND_MODE_XOR ||
307                 bond_is_nondyn_tlb(bond));
308 }
309 
310 static inline bool bond_mode_uses_arp(int mode)
311 {
312         return mode != BOND_MODE_8023AD && mode != BOND_MODE_TLB &&
313                mode != BOND_MODE_ALB;
314 }
315 
316 static inline bool bond_mode_uses_primary(int mode)
317 {
318         return mode == BOND_MODE_ACTIVEBACKUP || mode == BOND_MODE_TLB ||
319                mode == BOND_MODE_ALB;
320 }
321 
322 static inline bool bond_uses_primary(struct bonding *bond)
323 {
324         return bond_mode_uses_primary(BOND_MODE(bond));
325 }
326 
327 static inline struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond)
328 {
329         struct slave *slave = rcu_dereference(bond->curr_active_slave);
330 
331         return bond_uses_primary(bond) && slave ? slave->dev : NULL;
332 }
333 
334 static inline bool bond_slave_is_up(struct slave *slave)
335 {
336         return netif_running(slave->dev) && netif_carrier_ok(slave->dev);
337 }
338 
339 static inline void bond_set_active_slave(struct slave *slave)
340 {
341         if (slave->backup) {
342                 slave->backup = 0;
343                 bond_queue_slave_event(slave);
344                 bond_lower_state_changed(slave);
345         }
346 }
347 
348 static inline void bond_set_backup_slave(struct slave *slave)
349 {
350         if (!slave->backup) {
351                 slave->backup = 1;
352                 bond_queue_slave_event(slave);
353                 bond_lower_state_changed(slave);
354         }
355 }
356 
357 static inline void bond_set_slave_state(struct slave *slave,
358                                         int slave_state, bool notify)
359 {
360         if (slave->backup == slave_state)
361                 return;
362 
363         slave->backup = slave_state;
364         if (notify) {
365                 bond_lower_state_changed(slave);
366                 bond_queue_slave_event(slave);
367                 slave->should_notify = 0;
368         } else {
369                 if (slave->should_notify)
370                         slave->should_notify = 0;
371                 else
372                         slave->should_notify = 1;
373         }
374 }
375 
376 static inline void bond_slave_state_change(struct bonding *bond)
377 {
378         struct list_head *iter;
379         struct slave *tmp;
380 
381         bond_for_each_slave(bond, tmp, iter) {
382                 if (tmp->link == BOND_LINK_UP)
383                         bond_set_active_slave(tmp);
384                 else if (tmp->link == BOND_LINK_DOWN)
385                         bond_set_backup_slave(tmp);
386         }
387 }
388 
389 static inline void bond_slave_state_notify(struct bonding *bond)
390 {
391         struct list_head *iter;
392         struct slave *tmp;
393 
394         bond_for_each_slave(bond, tmp, iter) {
395                 if (tmp->should_notify) {
396                         bond_lower_state_changed(tmp);
397                         tmp->should_notify = 0;
398                 }
399         }
400 }
401 
402 static inline int bond_slave_state(struct slave *slave)
403 {
404         return slave->backup;
405 }
406 
407 static inline bool bond_is_active_slave(struct slave *slave)
408 {
409         return !bond_slave_state(slave);
410 }
411 
412 static inline bool bond_slave_can_tx(struct slave *slave)
413 {
414         return bond_slave_is_up(slave) && slave->link == BOND_LINK_UP &&
415                bond_is_active_slave(slave);
416 }
417 
418 static inline bool bond_is_active_slave_dev(const struct net_device *slave_dev)
419 {
420         struct slave *slave;
421         bool active;
422 
423         rcu_read_lock();
424         slave = bond_slave_get_rcu(slave_dev);
425         active = bond_is_active_slave(slave);
426         rcu_read_unlock();
427 
428         return active;
429 }
430 
431 static inline void bond_hw_addr_copy(u8 *dst, const u8 *src, unsigned int len)
432 {
433         if (len == ETH_ALEN) {
434                 ether_addr_copy(dst, src);
435                 return;
436         }
437 
438         memcpy(dst, src, len);
439 }
440 
441 #define BOND_PRI_RESELECT_ALWAYS        0
442 #define BOND_PRI_RESELECT_BETTER        1
443 #define BOND_PRI_RESELECT_FAILURE       2
444 
445 #define BOND_FOM_NONE                   0
446 #define BOND_FOM_ACTIVE                 1
447 #define BOND_FOM_FOLLOW                 2
448 
449 #define BOND_ARP_TARGETS_ANY            0
450 #define BOND_ARP_TARGETS_ALL            1
451 
452 #define BOND_ARP_VALIDATE_NONE          0
453 #define BOND_ARP_VALIDATE_ACTIVE        (1 << BOND_STATE_ACTIVE)
454 #define BOND_ARP_VALIDATE_BACKUP        (1 << BOND_STATE_BACKUP)
455 #define BOND_ARP_VALIDATE_ALL           (BOND_ARP_VALIDATE_ACTIVE | \
456                                          BOND_ARP_VALIDATE_BACKUP)
457 #define BOND_ARP_FILTER                 (BOND_ARP_VALIDATE_ALL + 1)
458 #define BOND_ARP_FILTER_ACTIVE          (BOND_ARP_VALIDATE_ACTIVE | \
459                                          BOND_ARP_FILTER)
460 #define BOND_ARP_FILTER_BACKUP          (BOND_ARP_VALIDATE_BACKUP | \
461                                          BOND_ARP_FILTER)
462 
463 #define BOND_SLAVE_NOTIFY_NOW           true
464 #define BOND_SLAVE_NOTIFY_LATER         false
465 
466 static inline int slave_do_arp_validate(struct bonding *bond,
467                                         struct slave *slave)
468 {
469         return bond->params.arp_validate & (1 << bond_slave_state(slave));
470 }
471 
472 static inline int slave_do_arp_validate_only(struct bonding *bond)
473 {
474         return bond->params.arp_validate & BOND_ARP_FILTER;
475 }
476 
477 static inline int bond_is_ip_target_ok(__be32 addr)
478 {
479         return !ipv4_is_lbcast(addr) && !ipv4_is_zeronet(addr);
480 }
481 
482 /* Get the oldest arp which we've received on this slave for bond's
483  * arp_targets.
484  */
485 static inline unsigned long slave_oldest_target_arp_rx(struct bonding *bond,
486                                                        struct slave *slave)
487 {
488         int i = 1;
489         unsigned long ret = slave->target_last_arp_rx[0];
490 
491         for (; (i < BOND_MAX_ARP_TARGETS) && bond->params.arp_targets[i]; i++)
492                 if (time_before(slave->target_last_arp_rx[i], ret))
493                         ret = slave->target_last_arp_rx[i];
494 
495         return ret;
496 }
497 
498 static inline unsigned long slave_last_rx(struct bonding *bond,
499                                         struct slave *slave)
500 {
501         if (bond->params.arp_all_targets == BOND_ARP_TARGETS_ALL)
502                 return slave_oldest_target_arp_rx(bond, slave);
503 
504         return slave->last_rx;
505 }
506 
507 #ifdef CONFIG_NET_POLL_CONTROLLER
508 static inline void bond_netpoll_send_skb(const struct slave *slave,
509                                          struct sk_buff *skb)
510 {
511         struct netpoll *np = slave->np;
512 
513         if (np)
514                 netpoll_send_skb(np, skb);
515 }
516 #else
517 static inline void bond_netpoll_send_skb(const struct slave *slave,
518                                          struct sk_buff *skb)
519 {
520 }
521 #endif
522 
523 static inline void bond_set_slave_inactive_flags(struct slave *slave,
524                                                  bool notify)
525 {
526         if (!bond_is_lb(slave->bond))
527                 bond_set_slave_state(slave, BOND_STATE_BACKUP, notify);
528         if (!slave->bond->params.all_slaves_active)
529                 slave->inactive = 1;
530 }
531 
532 static inline void bond_set_slave_active_flags(struct slave *slave,
533                                                bool notify)
534 {
535         bond_set_slave_state(slave, BOND_STATE_ACTIVE, notify);
536         slave->inactive = 0;
537 }
538 
539 static inline bool bond_is_slave_inactive(struct slave *slave)
540 {
541         return slave->inactive;
542 }
543 
544 static inline void bond_propose_link_state(struct slave *slave, int state)
545 {
546         slave->link_new_state = state;
547 }
548 
549 static inline void bond_commit_link_state(struct slave *slave, bool notify)
550 {
551         if (slave->link_new_state == BOND_LINK_NOCHANGE)
552                 return;
553 
554         slave->link = slave->link_new_state;
555         if (notify) {
556                 bond_queue_slave_event(slave);
557                 bond_lower_state_changed(slave);
558                 slave->should_notify_link = 0;
559         } else {
560                 if (slave->should_notify_link)
561                         slave->should_notify_link = 0;
562                 else
563                         slave->should_notify_link = 1;
564         }
565 }
566 
567 static inline void bond_set_slave_link_state(struct slave *slave, int state,
568                                              bool notify)
569 {
570         bond_propose_link_state(slave, state);
571         bond_commit_link_state(slave, notify);
572 }
573 
574 static inline void bond_slave_link_notify(struct bonding *bond)
575 {
576         struct list_head *iter;
577         struct slave *tmp;
578 
579         bond_for_each_slave(bond, tmp, iter) {
580                 if (tmp->should_notify_link) {
581                         bond_queue_slave_event(tmp);
582                         bond_lower_state_changed(tmp);
583                         tmp->should_notify_link = 0;
584                 }
585         }
586 }
587 
588 static inline __be32 bond_confirm_addr(struct net_device *dev, __be32 dst, __be32 local)
589 {
590         struct in_device *in_dev;
591         __be32 addr = 0;
592 
593         rcu_read_lock();
594         in_dev = __in_dev_get_rcu(dev);
595 
596         if (in_dev)
597                 addr = inet_confirm_addr(dev_net(dev), in_dev, dst, local,
598                                          RT_SCOPE_HOST);
599         rcu_read_unlock();
600         return addr;
601 }
602 
603 struct bond_net {
604         struct net              *net;   /* Associated network namespace */
605         struct list_head        dev_list;
606 #ifdef CONFIG_PROC_FS
607         struct proc_dir_entry   *proc_dir;
608 #endif
609         struct class_attribute  class_attr_bonding_masters;
610 };
611 
612 int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond, struct slave *slave);
613 void bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev);
614 int bond_create(struct net *net, const char *name);
615 int bond_create_sysfs(struct bond_net *net);
616 void bond_destroy_sysfs(struct bond_net *net);
617 void bond_prepare_sysfs_group(struct bonding *bond);
618 int bond_sysfs_slave_add(struct slave *slave);
619 void bond_sysfs_slave_del(struct slave *slave);
620 int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev,
621                  struct netlink_ext_ack *extack);
622 int bond_release(struct net_device *bond_dev, struct net_device *slave_dev);
623 u32 bond_xmit_hash(struct bonding *bond, struct sk_buff *skb);
624 int bond_set_carrier(struct bonding *bond);
625 void bond_select_active_slave(struct bonding *bond);
626 void bond_change_active_slave(struct bonding *bond, struct slave *new_active);
627 void bond_create_debugfs(void);
628 void bond_destroy_debugfs(void);
629 void bond_debug_register(struct bonding *bond);
630 void bond_debug_unregister(struct bonding *bond);
631 void bond_debug_reregister(struct bonding *bond);
632 const char *bond_mode_name(int mode);
633 void bond_setup(struct net_device *bond_dev);
634 unsigned int bond_get_num_tx_queues(void);
635 int bond_netlink_init(void);
636 void bond_netlink_fini(void);
637 struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond);
638 const char *bond_slave_link_status(s8 link);
639 struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev,
640                                               struct net_device *end_dev,
641                                               int level);
642 int bond_update_slave_arr(struct bonding *bond, struct slave *skipslave);
643 void bond_slave_arr_work_rearm(struct bonding *bond, unsigned long delay);
644 void bond_work_init_all(struct bonding *bond);
645 
646 #ifdef CONFIG_PROC_FS
647 void bond_create_proc_entry(struct bonding *bond);
648 void bond_remove_proc_entry(struct bonding *bond);
649 void bond_create_proc_dir(struct bond_net *bn);
650 void bond_destroy_proc_dir(struct bond_net *bn);
651 #else
652 static inline void bond_create_proc_entry(struct bonding *bond)
653 {
654 }
655 
656 static inline void bond_remove_proc_entry(struct bonding *bond)
657 {
658 }
659 
660 static inline void bond_create_proc_dir(struct bond_net *bn)
661 {
662 }
663 
664 static inline void bond_destroy_proc_dir(struct bond_net *bn)
665 {
666 }
667 #endif
668 
669 static inline struct slave *bond_slave_has_mac(struct bonding *bond,
670                                                const u8 *mac)
671 {
672         struct list_head *iter;
673         struct slave *tmp;
674 
675         bond_for_each_slave(bond, tmp, iter)
676                 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
677                         return tmp;
678 
679         return NULL;
680 }
681 
682 /* Caller must hold rcu_read_lock() for read */
683 static inline struct slave *bond_slave_has_mac_rcu(struct bonding *bond,
684                                                const u8 *mac)
685 {
686         struct list_head *iter;
687         struct slave *tmp;
688 
689         bond_for_each_slave_rcu(bond, tmp, iter)
690                 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
691                         return tmp;
692 
693         return NULL;
694 }
695 
696 /* Caller must hold rcu_read_lock() for read */
697 static inline bool bond_slave_has_mac_rx(struct bonding *bond, const u8 *mac)
698 {
699         struct list_head *iter;
700         struct slave *tmp;
701         struct netdev_hw_addr *ha;
702 
703         bond_for_each_slave_rcu(bond, tmp, iter)
704                 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
705                         return true;
706 
707         if (netdev_uc_empty(bond->dev))
708                 return false;
709 
710         netdev_for_each_uc_addr(ha, bond->dev)
711                 if (ether_addr_equal_64bits(mac, ha->addr))
712                         return true;
713 
714         return false;
715 }
716 
717 /* Check if the ip is present in arp ip list, or first free slot if ip == 0
718  * Returns -1 if not found, index if found
719  */
720 static inline int bond_get_targets_ip(__be32 *targets, __be32 ip)
721 {
722         int i;
723 
724         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
725                 if (targets[i] == ip)
726                         return i;
727                 else if (targets[i] == 0)
728                         break;
729 
730         return -1;
731 }
732 
733 /* exported from bond_main.c */
734 extern unsigned int bond_net_id;
735 extern const struct bond_parm_tbl bond_lacp_tbl[];
736 extern const struct bond_parm_tbl xmit_hashtype_tbl[];
737 extern const struct bond_parm_tbl arp_validate_tbl[];
738 extern const struct bond_parm_tbl arp_all_targets_tbl[];
739 extern const struct bond_parm_tbl fail_over_mac_tbl[];
740 extern const struct bond_parm_tbl pri_reselect_tbl[];
741 extern struct bond_parm_tbl ad_select_tbl[];
742 
743 /* exported from bond_netlink.c */
744 extern struct rtnl_link_ops bond_link_ops;
745 
746 static inline void bond_tx_drop(struct net_device *dev, struct sk_buff *skb)
747 {
748         atomic_long_inc(&dev->tx_dropped);
749         dev_kfree_skb_any(skb);
750 }
751 
752 #endif /* _NET_BONDING_H */
753 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp