blob: fda6feeb6c1f3fc3ae7c4929935901e31982166b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 */
14
David S. Miller1ef80192014-11-10 13:27:49 -050015#ifndef _NET_BONDING_H
16#define _NET_BONDING_H
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18#include <linux/timer.h>
19#include <linux/proc_fs.h>
20#include <linux/if_bonding.h>
Neil Hormane843fa52010-10-13 16:01:50 +000021#include <linux/cpumask.h>
Brian Haley305d5522008-11-04 17:51:14 -080022#include <linux/in6.h>
Amerigo Wang8a8efa22011-02-17 23:43:32 +000023#include <linux/netpoll.h>
Andy Gospodarekeaddcd72012-03-22 16:14:29 +000024#include <linux/inetdevice.h>
zheng.li567b8712012-11-27 23:57:04 +000025#include <linux/etherdevice.h>
Hannes Frederic Sowa809fa972014-01-22 02:29:41 +010026#include <linux/reciprocal_div.h>
Andy Gospodarek5f0c5f72014-09-28 22:34:37 -040027#include <linux/if_link.h>
Hannes Frederic Sowa809fa972014-01-22 02:29:41 +010028
David S. Miller1ef80192014-11-10 13:27:49 -050029#include <net/bond_3ad.h>
30#include <net/bond_alb.h>
31#include <net/bond_options.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Ben Hutchingsad246c92011-04-26 15:25:52 +000033#define DRV_VERSION "3.7.1"
34#define DRV_RELDATE "April 27, 2011"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define DRV_NAME "bonding"
36#define DRV_DESCRIPTION "Ethernet Channel Bonding Driver"
37
Amerigo Wangbd33acc2011-03-06 21:58:46 +000038#define bond_version DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n"
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#define BOND_MAX_ARP_TARGETS 16
41
dingtianhongfe9d04a2013-11-22 22:28:43 +080042#define BOND_DEFAULT_MIIMON 100
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * Less bad way to call ioctl from within the kernel; this needs to be
46 * done some other way to get the call out of interrupt context.
47 * Needs "ioctl" variable to be supplied by calling context.
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
Veaceslav Falico01844092014-05-15 21:39:55 +020057#define BOND_MODE(bond) ((bond)->params.mode)
58
nikolay@redhat.comdec1e902013-08-01 16:54:47 +020059/* slave list primitives */
Veaceslav Falico5a524052013-09-25 09:20:24 +020060#define bond_slave_list(bond) (&(bond)->dev->adj_list.lower)
61
62#define bond_has_slaves(bond) !list_empty(bond_slave_list(bond))
Veaceslav Falico0965a1f2013-09-25 09:20:21 +020063
nikolay@redhat.comdec1e902013-08-01 16:54:47 +020064/* IMPORTANT: bond_first/last_slave can return NULL in case of an empty list */
65#define bond_first_slave(bond) \
Veaceslav Falico5a524052013-09-25 09:20:24 +020066 (bond_has_slaves(bond) ? \
67 netdev_adjacent_get_private(bond_slave_list(bond)->next) : \
68 NULL)
nikolay@redhat.comdec1e902013-08-01 16:54:47 +020069#define bond_last_slave(bond) \
Veaceslav Falico5a524052013-09-25 09:20:24 +020070 (bond_has_slaves(bond) ? \
71 netdev_adjacent_get_private(bond_slave_list(bond)->prev) : \
72 NULL)
nikolay@redhat.comdec1e902013-08-01 16:54:47 +020073
dingtianhonge001bfa2013-12-13 10:19:55 +080074/* Caller must have rcu_read_lock */
75#define bond_first_slave_rcu(bond) \
76 netdev_lower_get_first_private_rcu(bond->dev)
77
Veaceslav Falico5a524052013-09-25 09:20:24 +020078#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))
nikolay@redhat.comdec1e902013-08-01 16:54:47 +020080
Linus Torvalds1da177e2005-04-16 15:20:36 -070081/**
nikolay@redhat.comdec1e902013-08-01 16:54:47 +020082 * bond_for_each_slave - iterate over all slaves
83 * @bond: the bond holding this list
84 * @pos: current slave
Veaceslav Falico9caff1e2013-09-25 09:20:14 +020085 * @iter: list_head * iterator
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 *
Nikolay Aleksandrov87163ef2014-09-09 23:17:03 +020087 * Caller must hold RTNL
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 */
Veaceslav Falico9caff1e2013-09-25 09:20:14 +020089#define bond_for_each_slave(bond, pos, iter) \
90 netdev_for_each_lower_private((bond)->dev, pos, iter)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
nikolay@redhat.com278b2082013-08-01 16:54:51 +020092/* Caller must have rcu_read_lock */
Veaceslav Falico9caff1e2013-09-25 09:20:14 +020093#define bond_for_each_slave_rcu(bond, pos, iter) \
94 netdev_for_each_lower_private_rcu((bond)->dev, pos, iter)
nikolay@redhat.com278b2082013-08-01 16:54:51 +020095
Neil Hormane843fa52010-10-13 16:01:50 +000096#ifdef CONFIG_NET_POLL_CONTROLLER
Neil Hormanfb4fa762010-12-06 09:05:50 +000097extern atomic_t netpoll_block_tx;
Neil Hormane843fa52010-10-13 16:01:50 +000098
99static inline void block_netpoll_tx(void)
100{
Neil Hormanfb4fa762010-12-06 09:05:50 +0000101 atomic_inc(&netpoll_block_tx);
Neil Hormane843fa52010-10-13 16:01:50 +0000102}
103
104static inline void unblock_netpoll_tx(void)
105{
Neil Hormanfb4fa762010-12-06 09:05:50 +0000106 atomic_dec(&netpoll_block_tx);
Neil Hormane843fa52010-10-13 16:01:50 +0000107}
108
109static inline int is_netpoll_tx_blocked(struct net_device *dev)
110{
Amerigo Wang080e4132011-02-17 23:43:33 +0000111 if (unlikely(netpoll_tx_running(dev)))
Neil Hormanfb4fa762010-12-06 09:05:50 +0000112 return atomic_read(&netpoll_block_tx);
Neil Hormane843fa52010-10-13 16:01:50 +0000113 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121struct bond_params {
122 int mode;
Jay Vosburgh169a3e62005-06-26 17:54:11 -0400123 int xmit_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 int miimon;
Ben Hutchingsad246c92011-04-26 15:25:52 +0000125 u8 num_peer_notif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 int arp_interval;
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700127 int arp_validate;
Veaceslav Falico8599b522013-06-24 11:49:34 +0200128 int arp_all_targets;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 int use_carrier;
Jay Vosburghdd957c52007-10-09 19:57:24 -0700130 int fail_over_mac;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 int updelay;
132 int downdelay;
133 int lacp_fast;
stephen hemminger655f8912011-06-22 09:54:39 +0000134 unsigned int min_links;
Jay Vosburghfd989c82008-11-04 17:51:16 -0800135 int ad_select;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 char primary[IFNAMSIZ];
Jiri Pirkoa5499522009-09-25 03:28:09 +0000137 int primary_reselect;
Al Virod3bb52b2007-08-22 20:06:58 -0400138 __be32 arp_targets[BOND_MAX_ARP_TARGETS];
Andy Gospodarekbb1d9122010-06-02 08:40:18 +0000139 int tx_queues;
Andy Gospodarekebd8e492010-06-02 08:39:21 +0000140 int all_slaves_active;
Flavio Leitnerc2952c32010-10-05 14:23:59 +0000141 int resend_igmp;
Neil Horman7eacd032013-09-13 11:05:33 -0400142 int lp_interval;
Nikolay Aleksandrov73958322013-11-05 13:51:41 +0100143 int packets_per_slave;
Mahesh Bandeware9f0fb82014-04-22 16:30:22 -0700144 int tlb_dynamic_lb;
Hannes Frederic Sowa809fa972014-01-22 02:29:41 +0100145 struct reciprocal_value reciprocal_packets_per_slave;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146};
147
Mitch Williams12479f92005-11-09 10:35:44 -0800148struct bond_parm_tbl {
149 char *modename;
150 int mode;
151};
152
Moni Shoua69e61132015-02-03 16:48:31 +0200153struct netdev_notify_work {
154 struct delayed_work work;
Moni Shoua69e61132015-02-03 16:48:31 +0200155 struct net_device *dev;
Moni Shoua92e584f2015-02-08 11:49:32 +0200156 struct netdev_bonding_info bonding_info;
Moni Shoua69e61132015-02-03 16:48:31 +0200157};
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159struct slave {
Mitch Williamse944ef72005-11-09 10:36:50 -0800160 struct net_device *dev; /* first - useful for panic debug */
Jiri Pirko35d48902011-03-22 02:38:12 +0000161 struct bonding *bond; /* our master */
Jay Vosburgh8bb5f962006-09-22 21:52:51 -0700162 int delay;
Veaceslav Falico8e603462014-02-18 07:48:46 +0100163 /* all three in jiffies */
164 unsigned long last_link_up;
Veaceslav Falico49f17de2014-02-18 07:48:47 +0100165 unsigned long last_rx;
Veaceslav Falico8599b522013-06-24 11:49:34 +0200166 unsigned long target_last_arp_rx[BOND_MAX_ARP_TARGETS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 s8 link; /* one of BOND_LINK_XXXX */
Jay Vosburghb2220ca2008-05-17 21:10:13 -0700168 s8 new_link;
Jiri Pirko2d7011c2011-03-16 08:46:43 +0000169 u8 backup:1, /* indicates backup slave. Value corresponds with
170 BOND_STATE_ACTIVE and BOND_STATE_BACKUP */
dingtianhong5e5b0662014-02-26 11:05:22 +0800171 inactive:1, /* indicates inactive slave */
172 should_notify:1; /* indicateds whether the state changed */
David Decotigny5d305302011-04-13 15:22:31 +0000173 u8 duplex;
Moni Shoua3158bf72007-10-09 19:43:41 -0700174 u32 original_mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 u32 link_failure_count;
David Decotigny5d305302011-04-13 15:22:31 +0000176 u32 speed;
Andy Gospodarekbb1d9122010-06-02 08:40:18 +0000177 u16 queue_id;
David Decotigny5d305302011-04-13 15:22:31 +0000178 u8 perm_hwaddr[ETH_ALEN];
dingtianhong3fdddd82014-05-12 15:08:43 +0800179 struct ad_slave_info *ad_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 struct tlb_slave_info tlb_info;
Amerigo Wang8a8efa22011-02-17 23:43:32 +0000181#ifdef CONFIG_NET_POLL_CONTROLLER
182 struct netpoll *np;
183#endif
sfeldma@cumulusnetworks.com07699f92014-01-16 22:57:49 -0800184 struct kobject kobj;
Andy Gospodarek5f0c5f72014-09-28 22:34:37 -0400185 struct rtnl_link_stats64 slave_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186};
187
Mahesh Bandewaree637712014-10-04 17:45:01 -0700188struct bond_up_slave {
189 unsigned int count;
190 struct rcu_head rcu;
191 struct slave *arr[0];
192};
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194/*
Jay Vosburghb2220ca2008-05-17 21:10:13 -0700195 * Link pseudo-state only used internally by monitors
196 */
197#define BOND_LINK_NOCHANGE -1
198
199/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 * Here are the locking policies for the two bonding locks:
Nikolay Aleksandrov1c72cfdc92014-09-11 22:49:24 +0200201 * Get rcu_read_lock when reading or RTNL when writing slave list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 */
203struct bonding {
Mitch Williamse944ef72005-11-09 10:36:50 -0800204 struct net_device *dev; /* first - useful for panic debug */
Eric Dumazet4740d632014-07-15 06:56:55 -0700205 struct slave __rcu *curr_active_slave;
Eric Dumazet857417182014-07-15 06:56:56 -0700206 struct slave __rcu *current_arp_slave;
Nikolay Aleksandrov059b47e2014-09-09 23:17:00 +0200207 struct slave __rcu *primary_slave;
Mahesh Bandewaree637712014-10-04 17:45:01 -0700208 struct bond_up_slave __rcu *slave_arr; /* Array of usable slaves */
Jiri Pirkoa5499522009-09-25 03:28:09 +0000209 bool force_primary;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 s32 slave_cnt; /* never change this value outside the attach/detach wrappers */
Eric Dumazetde063b72012-06-11 19:23:07 +0000211 int (*recv_probe)(const struct sk_buff *, struct bonding *,
212 struct slave *);
Nikolay Aleksandrov8c0bc552014-09-11 22:49:28 +0200213 /* mode_lock is used for mode-specific locking needs, currently used by:
214 * 3ad mode (4) - protect against running bond_3ad_unbind_slave() and
Nikolay Aleksandrov547942c2014-09-15 17:19:34 +0200215 * bond_3ad_state_machine_handler() concurrently and also
216 * the access to the state machine shared variables.
Nikolay Aleksandrov8c0bc552014-09-11 22:49:28 +0200217 * TLB mode (5) - to sync the use and modifications of its hash table
218 * ALB mode (6) - to sync the use and modifications of its hash table
219 */
Nikolay Aleksandrovb7435622014-09-11 22:49:25 +0200220 spinlock_t mode_lock;
Ben Hutchingsad246c92011-04-26 15:25:52 +0000221 u8 send_peer_notif;
Nikolay Aleksandrov4f5474e2013-06-12 00:07:02 +0200222 u8 igmp_retrans;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223#ifdef CONFIG_PROC_FS
224 struct proc_dir_entry *proc_entry;
225 char proc_file_name[IFNAMSIZ];
226#endif /* CONFIG_PROC_FS */
227 struct list_head bond_list;
Nikolay Aleksandrov73958322013-11-05 13:51:41 +0100228 u32 rr_tx_counter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 struct ad_bond_info ad_info;
230 struct alb_bond_info alb_info;
231 struct bond_params params;
Jay Vosburgh1b76b312007-10-17 17:37:45 -0700232 struct workqueue_struct *wq;
233 struct delayed_work mii_work;
234 struct delayed_work arp_work;
235 struct delayed_work alb_work;
236 struct delayed_work ad_work;
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000237 struct delayed_work mcast_work;
Mahesh Bandewaree637712014-10-04 17:45:01 -0700238 struct delayed_work slave_arr_work;
Taku Izumif073c7c2010-12-09 15:17:13 +0000239#ifdef CONFIG_DEBUG_FS
Masanari Iida02582e92012-08-22 19:11:26 +0900240 /* debugging support via debugfs */
Taku Izumif073c7c2010-12-09 15:17:13 +0000241 struct dentry *debug_dir;
242#endif /* CONFIG_DEBUG_FS */
Andy Gospodarek5f0c5f72014-09-28 22:34:37 -0400243 struct rtnl_link_stats64 bond_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244};
245
Jiri Pirkof1c17752011-03-12 03:14:35 +0000246#define bond_slave_get_rcu(dev) \
247 ((struct slave *) rcu_dereference(dev->rx_handler_data))
248
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000249#define bond_slave_get_rtnl(dev) \
250 ((struct slave *) rtnl_dereference(dev->rx_handler_data))
251
Moni Shoua69e61132015-02-03 16:48:31 +0200252void bond_queue_slave_event(struct slave *slave);
253
dingtianhongfbd929f2014-03-25 17:44:43 +0800254struct bond_vlan_tag {
255 __be16 vlan_proto;
256 unsigned short vlan_id;
257};
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259/**
260 * Returns NULL if the net_device does not belong to any of the bond's slaves
261 *
262 * Caller must hold bond lock for read
263 */
stephen hemminger4ec952b2011-02-23 07:40:33 +0000264static inline struct slave *bond_get_slave_by_dev(struct bonding *bond,
265 struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
Veaceslav Falico46bb4802013-09-25 09:20:11 +0200267 return netdev_lower_dev_get_private(bond->dev, slave_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
Adrian Bunkcceb9042006-01-05 22:45:42 -0800270static inline struct bonding *bond_get_bond_by_slave(struct slave *slave)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271{
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000272 return slave->bond;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
274
Veaceslav Falicod1e2e5c2014-05-15 21:39:52 +0200275static inline bool bond_should_override_tx_queue(struct bonding *bond)
276{
Veaceslav Falico01844092014-05-15 21:39:55 +0200277 return BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP ||
278 BOND_MODE(bond) == BOND_MODE_ROUNDROBIN;
Veaceslav Falicod1e2e5c2014-05-15 21:39:52 +0200279}
280
Holger Eitzenberger58402052008-12-09 23:07:13 -0800281static inline bool bond_is_lb(const struct bonding *bond)
282{
Veaceslav Falico01844092014-05-15 21:39:55 +0200283 return BOND_MODE(bond) == BOND_MODE_TLB ||
284 BOND_MODE(bond) == BOND_MODE_ALB;
Holger Eitzenberger58402052008-12-09 23:07:13 -0800285}
286
Mahesh Bandewar6b794c12014-07-16 11:10:36 -0700287static inline bool bond_is_nondyn_tlb(const struct bonding *bond)
288{
289 return (BOND_MODE(bond) == BOND_MODE_TLB) &&
290 (bond->params.tlb_dynamic_lb == 0);
291}
292
Mahesh Bandeward7021322014-10-04 17:44:44 -0700293static inline bool bond_mode_uses_xmit_hash(const struct bonding *bond)
294{
295 return (BOND_MODE(bond) == BOND_MODE_8023AD ||
296 BOND_MODE(bond) == BOND_MODE_XOR ||
297 bond_is_nondyn_tlb(bond));
298}
299
Veaceslav Falico267bed72014-05-15 21:39:53 +0200300static inline bool bond_mode_uses_arp(int mode)
301{
302 return mode != BOND_MODE_8023AD && mode != BOND_MODE_TLB &&
303 mode != BOND_MODE_ALB;
304}
305
Veaceslav Falicoec0865a2014-05-15 21:39:54 +0200306static inline bool bond_mode_uses_primary(int mode)
307{
308 return mode == BOND_MODE_ACTIVEBACKUP || mode == BOND_MODE_TLB ||
309 mode == BOND_MODE_ALB;
310}
311
312static inline bool bond_uses_primary(struct bonding *bond)
313{
Veaceslav Falico01844092014-05-15 21:39:55 +0200314 return bond_mode_uses_primary(BOND_MODE(bond));
Veaceslav Falicoec0865a2014-05-15 21:39:54 +0200315}
316
Veaceslav Falicob6adc612014-05-15 21:39:57 +0200317static inline bool bond_slave_is_up(struct slave *slave)
318{
319 return netif_running(slave->dev) && netif_carrier_ok(slave->dev);
320}
321
Jiri Pirkoe30bc062011-03-12 03:14:37 +0000322static inline void bond_set_active_slave(struct slave *slave)
323{
sfeldma@cumulusnetworks.com1d3ee882014-01-16 22:57:56 -0800324 if (slave->backup) {
325 slave->backup = 0;
Moni Shoua69e61132015-02-03 16:48:31 +0200326 bond_queue_slave_event(slave);
Veaceslav Falico072256d2014-03-06 15:33:22 +0100327 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
sfeldma@cumulusnetworks.com1d3ee882014-01-16 22:57:56 -0800328 }
Jiri Pirkoe30bc062011-03-12 03:14:37 +0000329}
330
331static inline void bond_set_backup_slave(struct slave *slave)
332{
sfeldma@cumulusnetworks.com1d3ee882014-01-16 22:57:56 -0800333 if (!slave->backup) {
334 slave->backup = 1;
Moni Shoua69e61132015-02-03 16:48:31 +0200335 bond_queue_slave_event(slave);
Veaceslav Falico072256d2014-03-06 15:33:22 +0100336 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
sfeldma@cumulusnetworks.com1d3ee882014-01-16 22:57:56 -0800337 }
Jiri Pirkoe30bc062011-03-12 03:14:37 +0000338}
339
dingtianhong5e5b0662014-02-26 11:05:22 +0800340static inline void bond_set_slave_state(struct slave *slave,
341 int slave_state, bool notify)
342{
343 if (slave->backup == slave_state)
344 return;
345
346 slave->backup = slave_state;
347 if (notify) {
Veaceslav Falico072256d2014-03-06 15:33:22 +0100348 rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_ATOMIC);
Moni Shoua69e61132015-02-03 16:48:31 +0200349 bond_queue_slave_event(slave);
dingtianhong5e5b0662014-02-26 11:05:22 +0800350 slave->should_notify = 0;
351 } else {
352 if (slave->should_notify)
353 slave->should_notify = 0;
354 else
355 slave->should_notify = 1;
356 }
357}
358
Ding Tianhong6fde8f02014-01-28 11:48:53 +0800359static inline void bond_slave_state_change(struct bonding *bond)
360{
361 struct list_head *iter;
362 struct slave *tmp;
363
364 bond_for_each_slave(bond, tmp, iter) {
365 if (tmp->link == BOND_LINK_UP)
366 bond_set_active_slave(tmp);
367 else if (tmp->link == BOND_LINK_DOWN)
368 bond_set_backup_slave(tmp);
369 }
370}
371
dingtianhongb0929912014-02-26 11:05:23 +0800372static inline void bond_slave_state_notify(struct bonding *bond)
373{
374 struct list_head *iter;
375 struct slave *tmp;
376
377 bond_for_each_slave(bond, tmp, iter) {
378 if (tmp->should_notify) {
Veaceslav Falico072256d2014-03-06 15:33:22 +0100379 rtmsg_ifinfo(RTM_NEWLINK, tmp->dev, 0, GFP_ATOMIC);
dingtianhongb0929912014-02-26 11:05:23 +0800380 tmp->should_notify = 0;
381 }
382 }
383}
384
Jiri Pirkoe30bc062011-03-12 03:14:37 +0000385static inline int bond_slave_state(struct slave *slave)
386{
387 return slave->backup;
388}
389
390static inline bool bond_is_active_slave(struct slave *slave)
391{
392 return !bond_slave_state(slave);
393}
394
Veaceslav Falico891ab542014-05-15 21:39:58 +0200395static inline bool bond_slave_can_tx(struct slave *slave)
396{
397 return bond_slave_is_up(slave) && slave->link == BOND_LINK_UP &&
398 bond_is_active_slave(slave);
399}
400
Jiri Pirkoa5499522009-09-25 03:28:09 +0000401#define BOND_PRI_RESELECT_ALWAYS 0
402#define BOND_PRI_RESELECT_BETTER 1
403#define BOND_PRI_RESELECT_FAILURE 2
404
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700405#define BOND_FOM_NONE 0
406#define BOND_FOM_ACTIVE 1
407#define BOND_FOM_FOLLOW 2
408
Veaceslav Falico8599b522013-06-24 11:49:34 +0200409#define BOND_ARP_TARGETS_ANY 0
410#define BOND_ARP_TARGETS_ALL 1
411
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700412#define BOND_ARP_VALIDATE_NONE 0
413#define BOND_ARP_VALIDATE_ACTIVE (1 << BOND_STATE_ACTIVE)
414#define BOND_ARP_VALIDATE_BACKUP (1 << BOND_STATE_BACKUP)
415#define BOND_ARP_VALIDATE_ALL (BOND_ARP_VALIDATE_ACTIVE | \
416 BOND_ARP_VALIDATE_BACKUP)
Veaceslav Falico896149f2014-02-18 07:48:40 +0100417#define BOND_ARP_FILTER (BOND_ARP_VALIDATE_ALL + 1)
418#define BOND_ARP_FILTER_ACTIVE (BOND_ARP_VALIDATE_ACTIVE | \
419 BOND_ARP_FILTER)
420#define BOND_ARP_FILTER_BACKUP (BOND_ARP_VALIDATE_BACKUP | \
421 BOND_ARP_FILTER)
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700422
dingtianhong5e5b0662014-02-26 11:05:22 +0800423#define BOND_SLAVE_NOTIFY_NOW true
424#define BOND_SLAVE_NOTIFY_LATER false
425
Adrian Bunk079ca7d2006-12-12 17:24:39 +0100426static inline int slave_do_arp_validate(struct bonding *bond,
427 struct slave *slave)
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700428{
Jiri Pirkoe30bc062011-03-12 03:14:37 +0000429 return bond->params.arp_validate & (1 << bond_slave_state(slave));
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700430}
431
dingtianhongbedabf92014-05-07 22:10:20 +0800432static inline int slave_do_arp_validate_only(struct bonding *bond)
Veaceslav Falico896149f2014-02-18 07:48:40 +0100433{
434 return bond->params.arp_validate & BOND_ARP_FILTER;
435}
436
Veaceslav Falico2807a9f2014-05-15 21:39:56 +0200437static inline int bond_is_ip_target_ok(__be32 addr)
438{
439 return !ipv4_is_lbcast(addr) && !ipv4_is_zeronet(addr);
440}
441
Veaceslav Falico8599b522013-06-24 11:49:34 +0200442/* Get the oldest arp which we've received on this slave for bond's
443 * arp_targets.
444 */
445static inline unsigned long slave_oldest_target_arp_rx(struct bonding *bond,
446 struct slave *slave)
447{
448 int i = 1;
449 unsigned long ret = slave->target_last_arp_rx[0];
450
451 for (; (i < BOND_MAX_ARP_TARGETS) && bond->params.arp_targets[i]; i++)
452 if (time_before(slave->target_last_arp_rx[i], ret))
453 ret = slave->target_last_arp_rx[i];
454
455 return ret;
456}
457
Adrian Bunk079ca7d2006-12-12 17:24:39 +0100458static inline unsigned long slave_last_rx(struct bonding *bond,
Andy Gospodarekf8a8ccd2007-01-29 12:08:38 -0800459 struct slave *slave)
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700460{
Veaceslav Falico9f242732014-02-18 07:48:43 +0100461 if (bond->params.arp_all_targets == BOND_ARP_TARGETS_ALL)
462 return slave_oldest_target_arp_rx(bond, slave);
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700463
Veaceslav Falico49f17de2014-02-18 07:48:47 +0100464 return slave->last_rx;
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700465}
466
Amerigo Wang8a8efa22011-02-17 23:43:32 +0000467#ifdef CONFIG_NET_POLL_CONTROLLER
468static inline void bond_netpoll_send_skb(const struct slave *slave,
469 struct sk_buff *skb)
470{
471 struct netpoll *np = slave->np;
472
473 if (np)
474 netpoll_send_skb(np, skb);
475}
476#else
477static inline void bond_netpoll_send_skb(const struct slave *slave,
478 struct sk_buff *skb)
479{
480}
481#endif
482
dingtianhong5e5b0662014-02-26 11:05:22 +0800483static inline void bond_set_slave_inactive_flags(struct slave *slave,
484 bool notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000486 if (!bond_is_lb(slave->bond))
dingtianhong5e5b0662014-02-26 11:05:22 +0800487 bond_set_slave_state(slave, BOND_STATE_BACKUP, notify);
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000488 if (!slave->bond->params.all_slaves_active)
Jiri Pirko2d7011c2011-03-16 08:46:43 +0000489 slave->inactive = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490}
491
dingtianhong5e5b0662014-02-26 11:05:22 +0800492static inline void bond_set_slave_active_flags(struct slave *slave,
493 bool notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494{
dingtianhong5e5b0662014-02-26 11:05:22 +0800495 bond_set_slave_state(slave, BOND_STATE_ACTIVE, notify);
Jiri Pirko2d7011c2011-03-16 08:46:43 +0000496 slave->inactive = 0;
497}
498
499static inline bool bond_is_slave_inactive(struct slave *slave)
500{
501 return slave->inactive;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
503
Moni Shoua69a23382015-02-03 16:48:30 +0200504static inline void bond_set_slave_link_state(struct slave *slave, int state)
505{
506 slave->link = state;
Moni Shoua69e61132015-02-03 16:48:31 +0200507 bond_queue_slave_event(slave);
Moni Shoua69a23382015-02-03 16:48:30 +0200508}
509
Andy Gospodarekeaddcd72012-03-22 16:14:29 +0000510static inline __be32 bond_confirm_addr(struct net_device *dev, __be32 dst, __be32 local)
511{
512 struct in_device *in_dev;
513 __be32 addr = 0;
514
515 rcu_read_lock();
516 in_dev = __in_dev_get_rcu(dev);
517
518 if (in_dev)
Nicolas Dichtelb601fa12013-12-10 15:02:40 +0100519 addr = inet_confirm_addr(dev_net(dev), in_dev, dst, local,
520 RT_SCOPE_HOST);
Andy Gospodarekeaddcd72012-03-22 16:14:29 +0000521 rcu_read_unlock();
522 return addr;
523}
524
dingtianhong31924322014-05-07 22:10:19 +0800525struct bond_net {
526 struct net *net; /* Associated network namespace */
527 struct list_head dev_list;
528#ifdef CONFIG_PROC_FS
529 struct proc_dir_entry *proc_dir;
530#endif
531 struct class_attribute class_attr_bonding_masters;
532};
Eric W. Biederman4c224002011-10-12 21:56:25 +0000533
nikolay@redhat.com5bb9e0b2013-09-07 00:00:26 +0200534int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond, struct slave *slave);
dingtianhongd316ded2014-01-02 09:13:09 +0800535void bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev);
Eric W. Biedermanec87fd32009-10-29 14:18:26 +0000536int bond_create(struct net *net, const char *name);
Eric W. Biederman4c224002011-10-12 21:56:25 +0000537int bond_create_sysfs(struct bond_net *net);
538void bond_destroy_sysfs(struct bond_net *net);
Eric W. Biederman6151b3d2009-10-29 14:18:22 +0000539void bond_prepare_sysfs_group(struct bonding *bond);
sfeldma@cumulusnetworks.com07699f92014-01-16 22:57:49 -0800540int bond_sysfs_slave_add(struct slave *slave);
541void bond_sysfs_slave_del(struct slave *slave);
Mitch Williamsa77b5322005-11-09 10:35:51 -0800542int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev);
543int bond_release(struct net_device *bond_dev, struct net_device *slave_dev);
Mahesh Bandewaree62e862014-04-22 16:30:15 -0700544u32 bond_xmit_hash(struct bonding *bond, struct sk_buff *skb);
Jonathan Toppins2477bc92015-01-26 01:16:57 -0500545int bond_set_carrier(struct bonding *bond);
Mitch Williamsa77b5322005-11-09 10:35:51 -0800546void bond_select_active_slave(struct bonding *bond);
547void bond_change_active_slave(struct bonding *bond, struct slave *new_active);
Taku Izumif073c7c2010-12-09 15:17:13 +0000548void bond_create_debugfs(void);
549void bond_destroy_debugfs(void);
550void bond_debug_register(struct bonding *bond);
551void bond_debug_unregister(struct bonding *bond);
552void bond_debug_reregister(struct bonding *bond);
David Decotignyd30ee672011-04-13 15:22:29 +0000553const char *bond_mode_name(int mode);
Jiri Pirko0a2a78c2013-10-18 17:43:33 +0200554void bond_setup(struct net_device *bond_dev);
555unsigned int bond_get_num_tx_queues(void);
556int bond_netlink_init(void);
557void bond_netlink_fini(void);
Jiri Pirko752d48b2013-10-18 17:43:37 +0200558struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond);
sfeldma@cumulusnetworks.com07699f92014-01-16 22:57:49 -0800559const char *bond_slave_link_status(s8 link);
Veaceslav Falico3e403a72014-07-17 17:02:23 +0200560struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev,
561 struct net_device *end_dev,
562 int level);
Mahesh Bandewaree637712014-10-04 17:45:01 -0700563int bond_update_slave_arr(struct bonding *bond, struct slave *skipslave);
564void bond_slave_arr_work_rearm(struct bonding *bond, unsigned long delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Amerigo Wangbd33acc2011-03-06 21:58:46 +0000566#ifdef CONFIG_PROC_FS
567void bond_create_proc_entry(struct bonding *bond);
568void bond_remove_proc_entry(struct bonding *bond);
569void bond_create_proc_dir(struct bond_net *bn);
570void bond_destroy_proc_dir(struct bond_net *bn);
571#else
572static inline void bond_create_proc_entry(struct bonding *bond)
573{
574}
575
576static inline void bond_remove_proc_entry(struct bonding *bond)
577{
578}
579
580static inline void bond_create_proc_dir(struct bond_net *bn)
581{
582}
583
584static inline void bond_destroy_proc_dir(struct bond_net *bn)
585{
586}
587#endif
588
zheng.li567b8712012-11-27 23:57:04 +0000589static inline struct slave *bond_slave_has_mac(struct bonding *bond,
590 const u8 *mac)
591{
Veaceslav Falico9caff1e2013-09-25 09:20:14 +0200592 struct list_head *iter;
zheng.li567b8712012-11-27 23:57:04 +0000593 struct slave *tmp;
594
Veaceslav Falico9caff1e2013-09-25 09:20:14 +0200595 bond_for_each_slave(bond, tmp, iter)
zheng.li567b8712012-11-27 23:57:04 +0000596 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
597 return tmp;
598
599 return NULL;
600}
Amerigo Wangbd33acc2011-03-06 21:58:46 +0000601
dingtianhong28c71922013-10-15 16:28:39 +0800602/* Caller must hold rcu_read_lock() for read */
603static inline struct slave *bond_slave_has_mac_rcu(struct bonding *bond,
604 const u8 *mac)
605{
606 struct list_head *iter;
607 struct slave *tmp;
608
609 bond_for_each_slave_rcu(bond, tmp, iter)
610 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
611 return tmp;
612
613 return NULL;
614}
615
Vlad Yasevich14af9962014-06-04 16:23:38 -0400616/* Caller must hold rcu_read_lock() for read */
617static inline bool bond_slave_has_mac_rx(struct bonding *bond, const u8 *mac)
618{
619 struct list_head *iter;
620 struct slave *tmp;
621 struct netdev_hw_addr *ha;
622
623 bond_for_each_slave_rcu(bond, tmp, iter)
624 if (ether_addr_equal_64bits(mac, tmp->dev->dev_addr))
625 return true;
626
627 if (netdev_uc_empty(bond->dev))
628 return false;
629
630 netdev_for_each_uc_addr(ha, bond->dev)
631 if (ether_addr_equal_64bits(mac, ha->addr))
632 return true;
633
634 return false;
635}
636
Veaceslav Falico87a7b842013-06-24 11:49:29 +0200637/* Check if the ip is present in arp ip list, or first free slot if ip == 0
638 * Returns -1 if not found, index if found
639 */
640static inline int bond_get_targets_ip(__be32 *targets, __be32 ip)
641{
642 int i;
643
644 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
645 if (targets[i] == ip)
646 return i;
647 else if (targets[i] == 0)
648 break;
649
650 return -1;
651}
652
Ben Dooksb2259672008-09-14 16:56:12 +0100653/* exported from bond_main.c */
Eric W. Biedermanec87fd32009-10-29 14:18:26 +0000654extern int bond_net_id;
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800655extern const struct bond_parm_tbl bond_lacp_tbl[];
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800656extern const struct bond_parm_tbl xmit_hashtype_tbl[];
657extern const struct bond_parm_tbl arp_validate_tbl[];
Veaceslav Falico8599b522013-06-24 11:49:34 +0200658extern const struct bond_parm_tbl arp_all_targets_tbl[];
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800659extern const struct bond_parm_tbl fail_over_mac_tbl[];
Jiri Pirkoa5499522009-09-25 03:28:09 +0000660extern const struct bond_parm_tbl pri_reselect_tbl[];
Hannes Ederb06715b2008-12-25 23:58:57 -0800661extern struct bond_parm_tbl ad_select_tbl[];
662
Jiri Pirko0a2a78c2013-10-18 17:43:33 +0200663/* exported from bond_netlink.c */
664extern struct rtnl_link_ops bond_link_ops;
665
Eric Dumazet31aa8602014-10-31 11:47:54 -0700666static inline void bond_tx_drop(struct net_device *dev, struct sk_buff *skb)
667{
668 atomic_long_inc(&dev->tx_dropped);
669 dev_kfree_skb_any(skb);
670}
671
David S. Miller1ef80192014-11-10 13:27:49 -0500672#endif /* _NET_BONDING_H */