1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#ifndef _LINUX_BONDING_H
16#define _LINUX_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 "bond_3ad.h"
30#include "bond_alb.h"
31#include "bond_options.h"
32
33#define DRV_VERSION "3.7.1"
34#define DRV_RELDATE "April 27, 2011"
35#define DRV_NAME "bonding"
36#define DRV_DESCRIPTION "Ethernet Channel Bonding Driver"
37
38#define bond_version DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n"
39
40#define BOND_MAX_ARP_TARGETS 16
41
42#define BOND_DEFAULT_MIIMON 100
43
44
45
46
47
48
49#define IOCTL(dev, arg, cmd) ({ \
50 int res = 0; \
51 mm_segment_t fs = get_fs(); \
52 set_fs(get_ds()); \
53 res = ioctl(dev, arg, cmd); \
54 set_fs(fs); \
55 res; })
56
57#define BOND_MODE(bond) ((bond)->params.mode)
58
59
60#define bond_slave_list(bond) (&(bond)->dev->adj_list.lower)
61
62#define bond_has_slaves(bond) !list_empty(bond_slave_list(bond))
63
64
65#define bond_first_slave(bond) \
66 (bond_has_slaves(bond) ? \
67 netdev_adjacent_get_private(bond_slave_list(bond)->next) : \
68 NULL)
69#define bond_last_slave(bond) \
70 (bond_has_slaves(bond) ? \
71 netdev_adjacent_get_private(bond_slave_list(bond)->prev) : \
72 NULL)
73
74
75#define bond_first_slave_rcu(bond) \
76 netdev_lower_get_first_private_rcu(bond->dev)
77
78#define bond_is_first_slave(bond, pos) (pos == bond_first_slave(bond))
79#define bond_is_last_slave(bond, pos) (pos == bond_last_slave(bond))
80
81
82
83
84
85
86
87
88
89#define bond_for_each_slave(bond, pos, iter) \
90 netdev_for_each_lower_private((bond)->dev, pos, iter)
91
92
93#define bond_for_each_slave_rcu(bond, pos, iter) \
94 netdev_for_each_lower_private_rcu((bond)->dev, pos, iter)
95
96#ifdef CONFIG_NET_POLL_CONTROLLER
97extern atomic_t netpoll_block_tx;
98
99static inline void block_netpoll_tx(void)
100{
101 atomic_inc(&netpoll_block_tx);
102}
103
104static inline void unblock_netpoll_tx(void)
105{
106 atomic_dec(&netpoll_block_tx);
107}
108
109static inline int is_netpoll_tx_blocked(struct net_device *dev)
110{
111 if (unlikely(netpoll_tx_running(dev)))
112 return atomic_read(&netpoll_block_tx);
113 return 0;
114}
115#else
116#define block_netpoll_tx()
117#define unblock_netpoll_tx()
118#define is_netpoll_tx_blocked(dev) (0)
119#endif
120
121struct bond_params {
122 int mode;
123 int xmit_policy;
124 int miimon;
125 u8 num_peer_notif;
126 int arp_interval;
127 int arp_validate;
128 int arp_all_targets;
129 int use_carrier;
130 int fail_over_mac;
131 int updelay;
132 int downdelay;
133 int lacp_fast;
134 unsigned int min_links;
135 int ad_select;
136 char primary[IFNAMSIZ];
137 int primary_reselect;
138 __be32 arp_targets[BOND_MAX_ARP_TARGETS];
139 int tx_queues;
140 int all_slaves_active;
141 int resend_igmp;
142 int lp_interval;
143 int packets_per_slave;
144 int tlb_dynamic_lb;
145 struct reciprocal_value reciprocal_packets_per_slave;
146};
147
148struct bond_parm_tbl {
149 char *modename;
150 int mode;
151};
152
153struct slave {
154 struct net_device *dev;
155 struct bonding *bond;
156 int delay;
157
158 unsigned long last_link_up;
159 unsigned long last_rx;
160 unsigned long target_last_arp_rx[BOND_MAX_ARP_TARGETS];
161 s8 link;
162 s8 new_link;
163 u8 backup:1,
164
165 inactive:1,
166 should_notify:1;
167 u8 duplex;
168 u32 original_mtu;
169 u32 link_failure_count;
170 u32 speed;
171 u16 queue_id;
172 u8 perm_hwaddr[ETH_ALEN];
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 kobject kobj;
179 struct rtnl_link_stats64 slave_stats;
180};
181
182struct bond_up_slave {
183 unsigned int count;
184 struct rcu_head rcu;
185 struct slave *arr[0];
186};
187
188
189
190
191#define BOND_LINK_NOCHANGE -1
192
193
194
195
196
197struct bonding {
198 struct net_device *dev;
199 struct slave __rcu *curr_active_slave;
200 struct slave __rcu *current_arp_slave;
201 struct slave __rcu *primary_slave;
202 struct bond_up_slave __rcu *slave_arr;
203 bool force_primary;
204 s32 slave_cnt;
205 int (*recv_probe)(const struct sk_buff *, struct bonding *,
206 struct slave *);
207
208
209
210
211
212
213
214 spinlock_t mode_lock;
215 u8 send_peer_notif;
216 u8 igmp_retrans;
217#ifdef CONFIG_PROC_FS
218 struct proc_dir_entry *proc_entry;
219 char proc_file_name[IFNAMSIZ];
220#endif
221 struct list_head bond_list;
222 u32 rr_tx_counter;
223 struct ad_bond_info ad_info;
224 struct alb_bond_info alb_info;
225 struct bond_params params;
226 struct workqueue_struct *wq;
227 struct delayed_work mii_work;
228 struct delayed_work arp_work;
229 struct delayed_work alb_work;
230 struct delayed_work ad_work;
231 struct delayed_work mcast_work;
232 struct delayed_work slave_arr_work;
233#ifdef CONFIG_DEBUG_FS
234
235 struct dentry *debug_dir;
236#endif
237 struct rtnl_link_stats64 bond_stats;
238};
239
240#define bond_slave_get_rcu(dev) \
241 ((struct slave *) rcu_dereference(dev->rx_handler_data))
242
243#define bond_slave_get_rtnl(dev) \
244 ((struct slave *) rtnl_dereference(dev->rx_handler_data))
245
246struct bond_vlan_tag {
247 __be16 vlan_proto;
248 unsigned short vlan_id;
249};
250
251
252
253
254
255
256static inline struct slave *bond_get_slave_by_dev(struct bonding *bond,
257 struct net_device *slave_dev)
258{
259 return netdev_lower_dev_get_private(bond->dev, slave_dev);
260}
261
262static inline struct bonding *bond_get_bond_by_slave(struct slave *slave)
263{
264 return slave->bond;
265}
266
267static inline bool bond_should_override_tx_queue(struct bonding *bond)
268{
269 return BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP ||
270 BOND_MODE(bond) == BOND_MODE_ROUNDROBIN;
271}
272
273static inline bool bond_is_lb(const struct bonding *bond)
274{
275 return BOND_MODE(bond) == BOND_MODE_TLB ||
276 BOND_MODE(bond) == BOND_MODE_ALB;
277}
278
279static inline bool bond_is_nondyn_tlb(const struct bonding *bond)
280{
281 return (BOND_MODE(bond) == BOND_MODE_TLB) &&
282 (bond->params.tlb_dynamic_lb == 0);
283}
284
285static inline bool bond_mode_uses_xmit_hash(const struct bonding *bond)
286{
287 return (BOND_MODE(bond) == BOND_MODE_8023AD ||
288 BOND_MODE(bond) == BOND_MODE_XOR ||
289 bond_is_nondyn_tlb(bond));
290}
291
292static inline bool bond_mode_uses_arp(int mode)
293{
294 return mode != BOND_MODE_8023AD && mode != BOND_MODE_TLB &&
295 mode != BOND_MODE_ALB;
296}
297
298static inline bool bond_mode_uses_primary(int mode)
299{
300 return mode == BOND_MODE_ACTIVEBACKUP || mode == BOND_MODE_TLB ||
301 mode == BOND_MODE_ALB;
302}
303
304static inline bool bond_uses_primary(struct bonding *bond)
305{
306 return bond_mode_uses_primary(BOND_MODE(bond));
307}
308
309static inline bool bond_slave_is_up(struct slave *slave)
310{
311 return netif_running(slave->dev) && netif_carrier_ok(slave->dev);
312}
313
314static inline void bond_set_active_slave(struct slave *slave)
315{
316 if (slave->backup) {
317 slave->backup = 0;
318 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
319 }
320}
321
322static inline void bond_set_backup_slave(struct slave *slave)
323{
324 if (!slave->backup) {
325 slave->backup = 1;
326 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
327 }
328}
329
330static inline void bond_set_slave_state(struct slave *slave,
331 int slave_state, bool notify)
332{
333 if (slave->backup == slave_state)
334 return;
335
336 slave->backup = slave_state;
337 if (notify) {
338 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
339 slave->should_notify = 0;
340 } else {
341 if (slave->should_notify)
342 slave->should_notify = 0;
343 else
344 slave->should_notify = 1;
345 }
346}
347
348static inline void bond_slave_state_change(struct bonding *bond)
349{
350 struct list_head *iter;
351 struct slave *tmp;
352
353 bond_for_each_slave(bond, tmp, iter) {
354 if (tmp->link == BOND_LINK_UP)
355 bond_set_active_slave(tmp);
356 else if (tmp->link == BOND_LINK_DOWN)
357 bond_set_backup_slave(tmp);
358 }
359}
360
361static inline void bond_slave_state_notify(struct bonding *bond)
362{
363 struct list_head *iter;
364 struct slave *tmp;
365
366 bond_for_each_slave(bond, tmp, iter) {
367 if (tmp->should_notify) {
368 rtmsg_ifinfo(RTM_NEWLINK, tmp->dev, 0, GFP_ATOMIC);
369 tmp->should_notify = 0;
370 }
371 }
372}
373
374static inline int bond_slave_state(struct slave *slave)
375{
376 return slave->backup;
377}
378
379static inline bool bond_is_active_slave(struct slave *slave)
380{
381 return !bond_slave_state(slave);
382}
383
384static inline bool bond_slave_can_tx(struct slave *slave)
385{
386 return bond_slave_is_up(slave) && slave->link == BOND_LINK_UP &&
387 bond_is_active_slave(slave);
388}
389
390#define BOND_PRI_RESELECT_ALWAYS 0
391#define BOND_PRI_RESELECT_BETTER 1
392#define BOND_PRI_RESELECT_FAILURE 2
393
394#define BOND_FOM_NONE 0
395#define BOND_FOM_ACTIVE 1
396#define BOND_FOM_FOLLOW 2
397
398#define BOND_ARP_TARGETS_ANY 0
399#define BOND_ARP_TARGETS_ALL 1
400
401#define BOND_ARP_VALIDATE_NONE 0
402#define BOND_ARP_VALIDATE_ACTIVE (1 << BOND_STATE_ACTIVE)
403#define BOND_ARP_VALIDATE_BACKUP (1 << BOND_STATE_BACKUP)
404#define BOND_ARP_VALIDATE_ALL (BOND_ARP_VALIDATE_ACTIVE | \
405 BOND_ARP_VALIDATE_BACKUP)
406#define BOND_ARP_FILTER (BOND_ARP_VALIDATE_ALL + 1)
407#define BOND_ARP_FILTER_ACTIVE (BOND_ARP_VALIDATE_ACTIVE | \
408 BOND_ARP_FILTER)
409#define BOND_ARP_FILTER_BACKUP (BOND_ARP_VALIDATE_BACKUP | \
410 BOND_ARP_FILTER)
411
412#define BOND_SLAVE_NOTIFY_NOW true
413#define BOND_SLAVE_NOTIFY_LATER false
414
415static inline int slave_do_arp_validate(struct bonding *bond,
416 struct slave *slave)
417{
418 return bond->params.arp_validate & (1 << bond_slave_state(slave));
419}
420
421static inline int slave_do_arp_validate_only(struct bonding *bond)
422{
423 return bond->params.arp_validate & BOND_ARP_FILTER;
424}
425
426static inline int bond_is_ip_target_ok(__be32 addr)
427{
428 return !ipv4_is_lbcast(addr) && !ipv4_is_zeronet(addr);
429}
430
431
432
433
434static inline unsigned long slave_oldest_target_arp_rx(struct bonding *bond,
435 struct slave *slave)
436{
437 int i = 1;
438 unsigned long ret = slave->target_last_arp_rx[0];
439
440 for (; (i < BOND_MAX_ARP_TARGETS) && bond->params.arp_targets[i]; i++)
441 if (time_before(slave->target_last_arp_rx[i], ret))
442 ret = slave->target_last_arp_rx[i];
443
444 return ret;
445}
446
447static inline unsigned long slave_last_rx(struct bonding *bond,
448 struct slave *slave)
449{
450 if (bond->params.arp_all_targets == BOND_ARP_TARGETS_ALL)
451 return slave_oldest_target_arp_rx(bond, slave);
452
453 return slave->last_rx;
454}
455
456#ifdef CONFIG_NET_POLL_CONTROLLER
457static inline void bond_netpoll_send_skb(const struct slave *slave,
458 struct sk_buff *skb)
459{
460 struct netpoll *np = slave->np;
461
462 if (np)
463 netpoll_send_skb(np, skb);
464}
465#else
466static inline void bond_netpoll_send_skb(const struct slave *slave,
467 struct sk_buff *skb)
468{
469}
470#endif
471
472static inline void bond_set_slave_inactive_flags(struct slave *slave,
473 bool notify)
474{
475 if (!bond_is_lb(slave->bond))
476 bond_set_slave_state(slave, BOND_STATE_BACKUP, notify);
477 if (!slave->bond->params.all_slaves_active)
478 slave->inactive = 1;
479}
480
481static inline void bond_set_slave_active_flags(struct slave *slave,
482 bool notify)
483{
484 bond_set_slave_state(slave, BOND_STATE_ACTIVE, notify);
485 slave->inactive = 0;
486}
487
488static inline bool bond_is_slave_inactive(struct slave *slave)
489{
490 return slave->inactive;
491}
492
493static inline __be32 bond_confirm_addr(struct net_device *dev, __be32 dst, __be32 local)
494{
495 struct in_device *in_dev;
496 __be32 addr = 0;
497
498 rcu_read_lock();
499 in_dev = __in_dev_get_rcu(dev);
500
501 if (in_dev)
502 addr = inet_confirm_addr(dev_net(dev), in_dev, dst, local,
503 RT_SCOPE_HOST);
504 rcu_read_unlock();
505 return addr;
506}
507
508struct bond_net {
509 struct net *net;
510 struct list_head dev_list;
511#ifdef CONFIG_PROC_FS
512 struct proc_dir_entry *proc_dir;
513#endif
514 struct class_attribute class_attr_bonding_masters;
515};
516
517int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond, struct slave *slave);
518void bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev);
519int bond_create(struct net *net, const char *name);
520int bond_create_sysfs(struct bond_net *net);
521void bond_destroy_sysfs(struct bond_net *net);
522void bond_prepare_sysfs_group(struct bonding *bond);
523int bond_sysfs_slave_add(struct slave *slave);
524void bond_sysfs_slave_del(struct slave *slave);
525int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev);
526int bond_release(struct net_device *bond_dev, struct net_device *slave_dev);
527u32 bond_xmit_hash(struct bonding *bond, struct sk_buff *skb);
528void bond_select_active_slave(struct bonding *bond);
529void bond_change_active_slave(struct bonding *bond, struct slave *new_active);
530void bond_create_debugfs(void);
531void bond_destroy_debugfs(void);
532void bond_debug_register(struct bonding *bond);
533void bond_debug_unregister(struct bonding *bond);
534void bond_debug_reregister(struct bonding *bond);
535const char *bond_mode_name(int mode);
536void bond_setup(struct net_device *bond_dev);
537unsigned int bond_get_num_tx_queues(void);
538int bond_netlink_init(void);
539void bond_netlink_fini(void);
540struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond);
541const char *bond_slave_link_status(s8 link);
542struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev,
543 struct net_device *end_dev,
544 int level);
545int bond_update_slave_arr(struct bonding *bond, struct slave *skipslave);
546void bond_slave_arr_work_rearm(struct bonding *bond, unsigned long delay);
547
548#ifdef CONFIG_PROC_FS
549void bond_create_proc_entry(struct bonding *bond);
550void bond_remove_proc_entry(struct bonding *bond);
551void bond_create_proc_dir(struct bond_net *bn);
552void bond_destroy_proc_dir(struct bond_net *bn);
553#else
554static inline void bond_create_proc_entry(struct bonding *bond)
555{
556}
557
558static inline void bond_remove_proc_entry(struct bonding *bond)
559{
560}
561
562static inline void bond_create_proc_dir(struct bond_net *bn)
563{
564}
565
566static inline void bond_destroy_proc_dir(struct bond_net *bn)
567{
568}
569#endif
570
571static inline struct slave *bond_slave_has_mac(struct bonding *bond,
572 const u8 *mac)
573{
574 struct list_head *iter;
575 struct slave *tmp;
576
577 bond_for_each_slave(bond, tmp, iter)
578 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
579 return tmp;
580
581 return NULL;
582}
583
584
585static inline struct slave *bond_slave_has_mac_rcu(struct bonding *bond,
586 const u8 *mac)
587{
588 struct list_head *iter;
589 struct slave *tmp;
590
591 bond_for_each_slave_rcu(bond, tmp, iter)
592 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
593 return tmp;
594
595 return NULL;
596}
597
598
599static inline bool bond_slave_has_mac_rx(struct bonding *bond, const u8 *mac)
600{
601 struct list_head *iter;
602 struct slave *tmp;
603 struct netdev_hw_addr *ha;
604
605 bond_for_each_slave_rcu(bond, tmp, iter)
606 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
607 return true;
608
609 if (netdev_uc_empty(bond->dev))
610 return false;
611
612 netdev_for_each_uc_addr(ha, bond->dev)
613 if (ether_addr_equal_64bits(mac, ha->addr))
614 return true;
615
616 return false;
617}
618
619
620
621
622static inline int bond_get_targets_ip(__be32 *targets, __be32 ip)
623{
624 int i;
625
626 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
627 if (targets[i] == ip)
628 return i;
629 else if (targets[i] == 0)
630 break;
631
632 return -1;
633}
634
635
636extern int bond_net_id;
637extern const struct bond_parm_tbl bond_lacp_tbl[];
638extern const struct bond_parm_tbl xmit_hashtype_tbl[];
639extern const struct bond_parm_tbl arp_validate_tbl[];
640extern const struct bond_parm_tbl arp_all_targets_tbl[];
641extern const struct bond_parm_tbl fail_over_mac_tbl[];
642extern const struct bond_parm_tbl pri_reselect_tbl[];
643extern struct bond_parm_tbl ad_select_tbl[];
644
645
646extern struct rtnl_link_ops bond_link_ops;
647
648#endif
649