开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
bonding.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：57k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

bonding.c：源码内容
  1. /*
  2.  * originally based on the dummy device.
  3.  *
  4.  * Copyright 1999, Thomas Davis, tadavis@lbl.gov.  
  5.  * Licensed under the GPL. Based on dummy.c, and eql.c devices.
  6.  *
  7.  * bonding.c: an Ethernet Bonding driver
  8.  *
  9.  * This is useful to talk to a Cisco EtherChannel compatible equipment:
  10.  * Cisco 5500
  11.  * Sun Trunking (Solaris)
  12.  * Alteon AceDirector Trunks
  13.  * Linux Bonding
  14.  * and probably many L2 switches ...
  15.  *
  16.  * How it works:
  17.  *    ifconfig bond0 ipaddress netmask up
  18.  *      will setup a network device, with an ip address.  No mac address 
  19.  * will be assigned at this time.  The hw mac address will come from 
  20.  * the first slave bonded to the channel.  All slaves will then use 
  21.  * this hw mac address.
  22.  *
  23.  *    ifconfig bond0 down
  24.  *         will release all slaves, marking them as down.
  25.  *
  26.  *    ifenslave bond0 eth0
  27.  * will attach eth0 to bond0 as a slave.  eth0 hw mac address will either
  28.  * a: be used as initial mac address
  29.  * b: if a hw mac address already is there, eth0's hw mac address 
  30.  *    will then be set from bond0.
  31.  *
  32.  * v0.1 - first working version.
  33.  * v0.2 - changed stats to be calculated by summing slaves stats.
  34.  *
  35.  * Changes:
  36.  * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  37.  * - fix leaks on failure at bond_init
  38.  *
  39.  * 2000/09/30 - Willy Tarreau <willy at meta-x.org>
  40.  *     - added trivial code to release a slave device.
  41.  *     - fixed security bug (CAP_NET_ADMIN not checked)
  42.  *     - implemented MII link monitoring to disable dead links :
  43.  *       All MII capable slaves are checked every <miimon> milliseconds
  44.  *       (100 ms seems good). This value can be changed by passing it to
  45.  *       insmod. A value of zero disables the monitoring (default).
  46.  *     - fixed an infinite loop in bond_xmit_roundrobin() when there's no
  47.  *       good slave.
  48.  *     - made the code hopefully SMP safe
  49.  *
  50.  * 2000/10/03 - Willy Tarreau <willy at meta-x.org>
  51.  *     - optimized slave lists based on relevant suggestions from Thomas Davis
  52.  *     - implemented active-backup method to obtain HA with two switches:
  53.  *       stay as long as possible on the same active interface, while we
  54.  *       also monitor the backup one (MII link status) because we want to know
  55.  *       if we are able to switch at any time. ( pass "mode=1" to insmod )
  56.  *     - lots of stress testings because we need it to be more robust than the
  57.  *       wires ! :->
  58.  *
  59.  * 2000/10/09 - Willy Tarreau <willy at meta-x.org>
  60.  *     - added up and down delays after link state change.
  61.  *     - optimized the slaves chaining so that when we run forward, we never
  62.  *       repass through the bond itself, but we can find it by searching
  63.  *       backwards. Renders the deletion more difficult, but accelerates the
  64.  *       scan.
  65.  *     - smarter enslaving and releasing.
  66.  *     - finer and more robust SMP locking
  67.  *
  68.  * 2000/10/17 - Willy Tarreau <willy at meta-x.org>
  69.  *     - fixed two potential SMP race conditions
  70.  *
  71.  * 2000/10/18 - Willy Tarreau <willy at meta-x.org>
  72.  *     - small fixes to the monitoring FSM in case of zero delays
  73.  * 2000/11/01 - Willy Tarreau <willy at meta-x.org>
  74.  *     - fixed first slave not automatically used in trunk mode.
  75.  * 2000/11/10 : spelling of "EtherChannel" corrected.
  76.  * 2000/11/13 : fixed a race condition in case of concurrent accesses to ioctl().
  77.  * 2000/12/16 : fixed improper usage of rtnl_exlock_nowait().
  78.  *
  79.  * 2001/1/3 - Chad N. Tindel <ctindel at ieee dot org>
  80.  *     - The bonding driver now simulates MII status monitoring, just like
  81.  *       a normal network device.  It will show that the link is down iff
  82.  *       every slave in the bond shows that their links are down.  If at least
  83.  *       one slave is up, the bond's MII status will appear as up.
  84.  *
  85.  * 2001/2/7 - Chad N. Tindel <ctindel at ieee dot org>
  86.  *     - Applications can now query the bond from user space to get
  87.  *       information which may be useful.  They do this by calling
  88.  *       the BOND_INFO_QUERY ioctl.  Once the app knows how many slaves
  89.  *       are in the bond, it can call the BOND_SLAVE_INFO_QUERY ioctl to
  90.  *       get slave specific information (# link failures, etc).  See
  91.  *       <linux/if_bonding.h> for more details.  The structs of interest
  92.  *       are ifbond and ifslave.
  93.  *
  94.  * 2001/4/5 - Chad N. Tindel <ctindel at ieee dot org>
  95.  *     - Ported to 2.4 Kernel
  96.  * 
  97.  * 2001/5/2 - Jeffrey E. Mast <jeff at mastfamily dot com>
  98.  *     - When a device is detached from a bond, the slave device is no longer
  99.  *       left thinking that is has a master.
  100.  *
  101.  * 2001/5/16 - Jeffrey E. Mast <jeff at mastfamily dot com>
  102.  *     - memset did not appropriately initialized the bond rw_locks. Used 
  103.  *       rwlock_init to initialize to unlocked state to prevent deadlock when 
  104.  *       first attempting a lock
  105.  *     - Called SET_MODULE_OWNER for bond device
  106.  *
  107.  * 2001/5/17 - Tim Anderson <tsa at mvista.com>
  108.  *     - 2 paths for releasing for slave release; 1 through ioctl
  109.  *       and 2) through close. Both paths need to release the same way.
  110.  *     - the free slave in bond release is changing slave status before
  111.  *       the free. The netdev_set_master() is intended to change slave state
  112.  *       so it should not be done as part of the release process.
  113.  *     - Simple rule for slave state at release: only the active in A/B and
  114.  *       only one in the trunked case.
  115.  *
  116.  * 2001/6/01 - Tim Anderson <tsa at mvista.com>
  117.  *     - Now call dev_close when releasing a slave so it doesn't screw up
  118.  *       out routing table.
  119.  *
  120.  * 2001/6/01 - Chad N. Tindel <ctindel at ieee dot org>
  121.  *     - Added /proc support for getting bond and slave information.
  122.  *       Information is in /proc/net/<bond device>/info. 
  123.  *     - Changed the locking when calling bond_close to prevent deadlock.
  124.  *
  125.  * 2001/8/05 - Janice Girouard <girouard at us.ibm.com>
  126.  *     - correct problem where refcnt of slave is not incremented in bond_ioctl
  127.  *       so the system hangs when halting.
  128.  *     - correct locking problem when unable to malloc in bond_enslave.
  129.  *     - adding bond_xmit_xor logic.
  130.  *     - adding multiple bond device support.
  131.  *
  132.  * 2001/8/13 - Erik Habbinga <erik_habbinga at hp dot com>
  133.  *     - correct locking problem with rtnl_exlock_nowait
  134.  *
  135.  * 2001/8/23 - Janice Girouard <girouard at us.ibm.com>
  136.  *     - bzero initial dev_bonds, to correct oops
  137.  *     - convert SIOCDEVPRIVATE to new MII ioctl calls
  138.  *
  139.  * 2001/9/13 - Takao Indoh <indou dot takao at jp dot fujitsu dot com>
  140.  *     - Add the BOND_CHANGE_ACTIVE ioctl implementation
  141.  *
  142.  * 2001/9/14 - Mark Huth <mhuth at mvista dot com>
  143.  *     - Change MII_LINK_READY to not check for end of auto-negotiation,
  144.  *       but only for an up link.
  145.  *
  146.  * 2001/9/20 - Chad N. Tindel <ctindel at ieee dot org>
  147.  *     - Add the device field to bonding_t.  Previously the net_device 
  148.  *       corresponding to a bond wasn't available from the bonding_t 
  149.  *       structure.
  150.  *
  151.  * 2001/9/25 - Janice Girouard <girouard at us.ibm.com>
  152.  *     - add arp_monitor for active backup mode
  153.  *
  154.  * 2001/10/23 - Takao Indoh <indou dot takao at jp dot fujitsu dot com>
  155.  *     - Various memory leak fixes
  156.  *
  157.  * 2001/11/5 - Mark Huth <mark dot huth at mvista dot com>
  158.  *     - Don't take rtnl lock in bond_mii_monitor as it deadlocks under 
  159.  *       certain hotswap conditions.  
  160.  *       Note:  this same change may be required in bond_arp_monitor ???
  161.  *     - Remove possibility of calling bond_sethwaddr with NULL slave_dev ptr 
  162.  *     - Handle hot swap ethernet interface deregistration events to remove
  163.  *       kernel oops following hot swap of enslaved interface
  164.  */
  166. #include <linux/config.h>
  167. #include <linux/kernel.h>
  168. #include <linux/module.h>
  169. #include <linux/sched.h>
  170. #include <linux/types.h>
  171. #include <linux/fcntl.h>
  172. #include <linux/interrupt.h>
  173. #include <linux/ptrace.h>
  174. #include <linux/ioport.h>
  175. #include <linux/in.h>
  176. #include <linux/slab.h>
  177. #include <linux/string.h>
  178. #include <linux/init.h>
  179. #include <linux/timer.h>
  180. #include <linux/socket.h>
  181. #include <asm/system.h>
  182. #include <asm/bitops.h>
  183. #include <asm/io.h>
  184. #include <asm/dma.h>
  185. #include <asm/uaccess.h>
  186. #include <linux/errno.h>
  188. #include <linux/netdevice.h>
  189. #include <linux/etherdevice.h>
  190. #include <linux/skbuff.h>
  191. #include <net/sock.h>
  192. #include <linux/rtnetlink.h>
  194. #include <linux/if_bonding.h>
  195. #include <linux/smp.h>
  196. #include <linux/if_ether.h>
  197. #include <linux/if_arp.h>
  199. /* monitor all links that often (in milliseconds). <=0 disables monitoring */
  200. #ifndef BOND_LINK_MON_INTERV
  201. #define BOND_LINK_MON_INTERV 0
  202. #endif
  204. #undef  MII_LINK_UP
  205. #define MII_LINK_UP 0x04
  207. #undef  MII_ENDOF_NWAY
  208. #define MII_ENDOF_NWAY 0x20
  210. #undef  MII_LINK_READY
  211. /*#define MII_LINK_READY (MII_LINK_UP | MII_ENDOF_NWAY)*/
  212. #define MII_LINK_READY (MII_LINK_UP)
  214. #define MAX_BOND_ADDR 256
  216. #ifndef BOND_LINK_ARP_INTERV
  217. #define BOND_LINK_ARP_INTERV 0
  218. #endif
  220. static int arp_interval = BOND_LINK_ARP_INTERV;
  221. static char *arp_ip_target = NULL;
  222. static unsigned long arp_target = 0;
  223. static u32 my_ip = 0;
  224. char *arp_target_hw_addr = NULL;
  226. static int max_bonds = MAX_BONDS;
  227. static int miimon = BOND_LINK_MON_INTERV;
  228. static int mode = BOND_MODE_ROUNDROBIN;
  229. static int updelay = 0;
  230. static int downdelay = 0;
  232. static int first_pass = 1;
  233. int bond_cnt;
  234. static struct bonding *these_bonds =  NULL;
  235. static struct net_device *dev_bonds = NULL;
  237. MODULE_PARM(max_bonds, "1-" __MODULE_STRING(INT_MAX) "i");
  238. MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
  239. MODULE_PARM(miimon, "i");
  240. MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
  241. MODULE_PARM(mode, "i");
  242. MODULE_PARM(arp_interval, "i");
  243. MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
  244. MODULE_PARM(arp_ip_target, "1-12s");
  245. MODULE_PARM_DESC(arp_ip_target, "arp target in n.n.n.n form");
  246. MODULE_PARM_DESC(mode, "Mode of operation : 0 for round robin, 1 for active-backup, 2 for xor");
  247. MODULE_PARM(updelay, "i");
  248. MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
  249. MODULE_PARM(downdelay, "i");
  250. MODULE_PARM_DESC(downdelay, "Delay before considering link down, in milliseconds");
  252. extern void arp_send( int type, int ptype, u32 dest_ip, struct net_device *dev,
  253. u32 src_ip, unsigned char *dest_hw, unsigned char *src_hw, 
  254. unsigned char *target_hw);
  256. static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *dev);
  257. static int bond_xmit_xor(struct sk_buff *skb, struct net_device *dev);
  258. static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *dev);
  259. static struct net_device_stats *bond_get_stats(struct net_device *dev);
  260. static void bond_mii_monitor(struct net_device *dev);
  261. static void bond_arp_monitor(struct net_device *dev);
  262. static int bond_event(struct notifier_block *this, unsigned long event, void *ptr);
  263. static void bond_set_slave_inactive_flags(slave_t *slave);
  264. static void bond_set_slave_active_flags(slave_t *slave);
  265. static int bond_enslave(struct net_device *master, struct net_device *slave);
  266. static int bond_release(struct net_device *master, struct net_device *slave);
  267. static int bond_release_all(struct net_device *master);
  268. static int bond_sethwaddr(struct net_device *master, struct net_device *slave);
  270. /*
  271.  * bond_get_info is the interface into the /proc filesystem.  This is
  272.  * a different interface than the BOND_INFO_QUERY ioctl.  That is done
  273.  * through the generic networking ioctl interface, and bond_info_query
  274.  * is the internal function which provides that information.
  275.  */
  276. static int bond_get_info(char *buf, char **start, off_t offset, int length);
  278. /* #define BONDING_DEBUG 1 */
  280. /* several macros */
  282. #define IS_UP(dev) ((((dev)->flags & (IFF_UP)) == (IFF_UP)) && 
  283. (netif_running(dev) && netif_carrier_ok(dev)))
  285. static void bond_set_slave_inactive_flags(slave_t *slave)
  286. {
  287. slave->state = BOND_STATE_BACKUP;
  288. slave->dev->flags |= IFF_NOARP;
  289. }
  291. static void bond_set_slave_active_flags(slave_t *slave)
  292. {
  293. slave->state = BOND_STATE_ACTIVE;
  294. slave->dev->flags &= ~IFF_NOARP;
  295. }
  297. /* 
  298.  * This function detaches the slave <slave> from the list <bond>.
  299.  * WARNING: no check is made to verify if the slave effectively
  300.  * belongs to <bond>. It returns <slave> in case it's needed.
  301.  * Nothing is freed on return, structures are just unchained.
  302.  * If the bond->current_slave pointer was pointing to <slave>,
  303.  * it's replaced with slave->next, or <bond> if not applicable.
  304.  */
  305. static slave_t *bond_detach_slave(bonding_t *bond, slave_t *slave)
  306. {
  307. if ((bond == NULL) || (slave == NULL) ||
  308.    ((void *)bond == (void *)slave)) {
  309. printk(KERN_ERR
  310. "bond_detach_slave(): trying to detach "
  311. "slave %p from bond %pn", bond, slave);
  312. return slave;
  313. }
  315. if (bond->next == slave) {  /* is the slave at the head ? */
  316. if (bond->prev == slave) {  /* is the slave alone ? */
  317. write_lock(&bond->ptrlock);
  318. bond->current_slave = NULL; /* no slave anymore */
  319. write_unlock(&bond->ptrlock);
  320. bond->prev = bond->next = (slave_t *)bond;
  321. } else { /* not alone */
  322. bond->next        = slave->next;
  323. slave->next->prev = (slave_t *)bond;
  324. bond->prev->next  = slave->next;
  326. write_lock(&bond->ptrlock);
  327. if (bond->current_slave == slave) {
  328. bond->current_slave = slave->next;
  329. }
  330. write_unlock(&bond->ptrlock);
  331. }
  332. }
  333. else {
  334. slave->prev->next = slave->next;
  335. if (bond->prev == slave) {  /* is this slave the last one ? */
  336. bond->prev = slave->prev;
  337. } else {
  338. slave->next->prev = slave->prev;
  339. }
  341. write_lock(&bond->ptrlock);
  342. if (bond->current_slave == slave) {
  343. bond->current_slave = slave->next;
  344. }
  345. write_unlock(&bond->ptrlock);
  346. }
  348. return slave;
  349. }
  351. /* 
  352.  * if <dev> supports MII link status reporting, check its link
  353.  * and report it as a bit field in a short int :
  354.  *   - 0x04 means link is up,
  355.  *   - 0x20 means end of autonegociation
  356.  * If the device doesn't support MII, then we only report 0x24,
  357.  * meaning that the link is up and running since we can't check it.
  358.  */
  359. static u16 bond_check_dev_link(struct net_device *dev)
  360. {
  361. static int (* ioctl)(struct net_device *, struct ifreq *, int);
  362. struct ifreq ifr;
  363. u16 *data = (u16 *)&ifr.ifr_data;
  365. /* data[0] automagically filled by the ioctl */
  366. data[1] = 1; /* MII location 1 reports Link Status */
  368. if (((ioctl = dev->do_ioctl) != NULL) &&  /* ioctl to access MII */
  369.     (ioctl(dev, &ifr, SIOCGMIIPHY) == 0)) {
  370. /* now, data[3] contains info about link status :
  371.    - data[3] & 0x04 means link up
  372.    - data[3] & 0x20 means end of auto-negociation
  373. */
  374. return data[3];
  375. } else {
  376. return MII_LINK_READY;  /* spoof link up ( we can't check it) */
  377. }
  378. }
  380. static u16 bond_check_mii_link(bonding_t *bond)
  381. {
  382. int has_active_interface = 0;
  383. unsigned long flags;
  385. read_lock_irqsave(&bond->lock, flags);
  386. read_lock(&bond->ptrlock);
  387. has_active_interface = (bond->current_slave != NULL);
  388. read_unlock(&bond->ptrlock);
  389. read_unlock_irqrestore(&bond->lock, flags);
  391. return (has_active_interface ? MII_LINK_READY : 0);
  392. }
  394. static int bond_open(struct net_device *dev)
  395. {
  396. struct timer_list *timer = &((struct bonding *)(dev->priv))->mii_timer;
  397. struct timer_list *arp_timer = &((struct bonding *)(dev->priv))->arp_timer;
  398. MOD_INC_USE_COUNT;
  400. if (miimon > 0) {  /* link check interval, in milliseconds. */
  401. init_timer(timer);
  402. timer->expires  = jiffies + (miimon * HZ / 1000);
  403. timer->data     = (unsigned long)dev;
  404. timer->function = (void *)&bond_mii_monitor;
  405. add_timer(timer);
  406. }
  408. if (arp_interval> 0) {  /* arp interval, in milliseconds. */
  409. init_timer(arp_timer);
  410. arp_timer->expires  = jiffies + (arp_interval * HZ / 1000);
  411. arp_timer->data     = (unsigned long)dev;
  412. arp_timer->function = (void *)&bond_arp_monitor;
  413. add_timer(arp_timer);
  414. }
  415. return 0;
  416. }
  418. static int bond_close(struct net_device *master)
  419. {
  420. bonding_t *bond = (struct bonding *) master->priv;
  421. unsigned long flags;
  423. write_lock_irqsave(&bond->lock, flags);
  425. if (miimon > 0) {  /* link check interval, in milliseconds. */
  426. del_timer(&bond->mii_timer);
  427. }
  428. if (arp_interval> 0) {  /* arp interval, in milliseconds. */
  429. del_timer(&bond->arp_timer);
  430. }
  432. /* Release the bonded slaves */
  433. bond_release_all(master);
  435. write_unlock_irqrestore(&bond->lock, flags);
  437. MOD_DEC_USE_COUNT;
  438. return 0;
  439. }
  441. static void set_multicast_list(struct net_device *master)
  442. {
  443. /*
  444. bonding_t *bond = master->priv;
  445. slave_t *slave;
  447. for (slave = bond->next; slave != (slave_t*)bond; slave = slave->next) {
  448. slave->dev->mc_list = master->mc_list;
  449. slave->dev->mc_count = master->mc_count;
  450. slave->dev->flags = master->flags;
  451. slave->dev->set_multicast_list(slave->dev);
  452. }
  453.  */
  454. }
  456. /*
  457.  * This function counts the the number of attached 
  458.  * slaves for use by bond_xmit_xor.
  459.  */
  460. static void update_slave_cnt(bonding_t *bond)
  461. {
  462. slave_t *slave = NULL;
  464. bond->slave_cnt = 0;
  465. for (slave = bond->prev; slave != (slave_t*)bond; slave = slave->prev) {
  466. bond->slave_cnt++;
  467. }
  468. }
  470. /* enslave device <slave> to bond device <master> */
  471. static int bond_enslave(struct net_device *master_dev, 
  472.                         struct net_device *slave_dev)
  473. {
  474. bonding_t *bond = NULL;
  475. slave_t *new_slave = NULL;
  476. unsigned long flags = 0;
  477. int ndx = 0;
  478. int err = 0;
  480. if (master_dev == NULL || slave_dev == NULL) {
  481. return -ENODEV;
  482. }
  483. bond = (struct bonding *) master_dev->priv;
  485. if (slave_dev->do_ioctl == NULL) {
  486. printk(KERN_DEBUG
  487. "Warning : no link monitoring support for %sn",
  488. slave_dev->name);
  489. }
  490. write_lock_irqsave(&bond->lock, flags);
  492. /* not running. */
  493. if ((slave_dev->flags & IFF_UP) != IFF_UP) {
  494. #ifdef BONDING_DEBUG
  495. printk(KERN_CRIT "Error, slave_dev is not runningn");
  496. #endif
  497. write_unlock_irqrestore(&bond->lock, flags);
  498. return -EINVAL;
  499. }
  501. /* already enslaved */
  502. if (master_dev->flags & IFF_SLAVE || slave_dev->flags & IFF_SLAVE) {
  503. #ifdef BONDING_DEBUG
  504. printk(KERN_CRIT "Error, Device was already enslavedn");
  505. #endif
  506. write_unlock_irqrestore(&bond->lock, flags);
  507. return -EBUSY;
  508. }
  509.    
  510. if ((new_slave = kmalloc(sizeof(slave_t), GFP_KERNEL)) == NULL) {
  511. write_unlock_irqrestore(&bond->lock, flags);
  512. return -ENOMEM;
  513. }
  514. memset(new_slave, 0, sizeof(slave_t));
  516. err = netdev_set_master(slave_dev, master_dev);
  518. if (err) {
  519. #ifdef BONDING_DEBUG
  520. printk(KERN_CRIT "Error %d calling netdev_set_mastern", err);
  521. #endif
  522. kfree(new_slave);
  523. write_unlock_irqrestore(&bond->lock, flags);
  524. return err;      
  525. }
  527. new_slave->dev = slave_dev;
  529. /* 
  530.  * queue to the end of the slaves list, make the first element its
  531.  * successor, the last one its predecessor, and make it the bond's
  532.  * predecessor. 
  533.  */
  534. new_slave->prev       = bond->prev;
  535. new_slave->prev->next = new_slave;
  536. bond->prev            = new_slave;
  537. new_slave->next       = bond->next;
  539. new_slave->delay = 0;
  540. new_slave->link_failure_count = 0;
  542. /* check for initial state */
  543. if ((miimon <= 0) || ((bond_check_dev_link(slave_dev) & MII_LINK_READY)
  544.  == MII_LINK_READY)) {
  545. #ifdef BONDING_DEBUG
  546. printk(KERN_CRIT "Initial state of slave_dev is BOND_LINK_UPn");
  547. #endif
  548. new_slave->link  = BOND_LINK_UP;
  549. }
  550. else {
  551. #ifdef BONDING_DEBUG
  552. printk(KERN_CRIT "Initial state of slave_dev is BOND_LINK_DOWNn");
  553. #endif
  554. new_slave->link  = BOND_LINK_DOWN;
  555. }
  557. /* if we're in active-backup mode, we need one and only one active
  558.  * interface. The backup interfaces will have their NOARP flag set
  559.  * because we need them to be completely deaf and not to respond to
  560.  * any ARP request on the network to avoid fooling a switch. Thus,
  561.  * since we guarantee that current_slave always point to the last
  562.  * usable interface, we just have to verify this interface's flag.
  563.  */
  564. if (mode == BOND_MODE_ACTIVEBACKUP) {
  565. if (((bond->current_slave == NULL)
  566. || (bond->current_slave->dev->flags & IFF_NOARP))
  567. && (new_slave->link == BOND_LINK_UP)) {
  568. #ifdef BONDING_DEBUG
  569. printk(KERN_CRIT "This is the first active slaven");
  570. #endif
  571. /* first slave or no active slave yet, and this link
  572.    is OK, so make this interface the active one */
  573. bond->current_slave = new_slave;
  574. bond_set_slave_active_flags(new_slave);
  575. }
  576. else {
  577. #ifdef BONDING_DEBUG
  578. printk(KERN_CRIT "This is just a backup slaven");
  579. #endif
  580. bond_set_slave_inactive_flags(new_slave);
  581. }
  582. } else {
  583. #ifdef BONDING_DEBUG
  584. printk(KERN_CRIT "This slave is always active in trunk moden");
  585. #endif
  586. /* always active in trunk mode */
  587. new_slave->state = BOND_STATE_ACTIVE;
  588. if (bond->current_slave == NULL) {
  589. bond->current_slave = new_slave;
  590. }
  591. }
  593. update_slave_cnt(bond);
  595. write_unlock_irqrestore(&bond->lock, flags);
  597. /*
  598.  * !!! This is to support old versions of ifenslave.  We can remove
  599.  * this in 2.5 because our ifenslave takes care of this for us.
  600.  * We check to see if the master has a mac address yet.  If not,
  601.  * we'll give it the mac address of our slave device.
  602.  */
  603. for (ndx = 0; ndx < slave_dev->addr_len; ndx++) {
  604. #ifdef BONDING_DEBUG
  605. printk(KERN_CRIT "Checking ndx=%d of master_dev->dev_addrn",
  606.        ndx);
  607. #endif
  608. if (master_dev->dev_addr[ndx] != 0) {
  609. #ifdef BONDING_DEBUG
  610. printk(KERN_CRIT "Found non-zero byte at ndx=%dn",
  611.        ndx);
  612. #endif
  613. break;
  614. }
  615. }
  616. if (ndx == slave_dev->addr_len) {
  617. /*
  618.  * We got all the way through the address and it was
  619.  * all 0's.
  620.  */
  621. #ifdef BONDING_DEBUG
  622. printk(KERN_CRIT "%s doesn't have a MAC address yet.  ",
  623.        master_dev->name);
  624. printk(KERN_CRIT "Going to give assign it from %s.n",
  625.        slave_dev->name);
  626. #endif
  627. bond_sethwaddr(master_dev, slave_dev);
  628. }
  630. printk (KERN_INFO "%s: enslaving %s as a%s interface with a%s link.n",
  631. master_dev->name, slave_dev->name,
  632. new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup",
  633. new_slave->link == BOND_LINK_UP ? "n up" : " down");
  635. return 0;
  636. }
  638. /* 
  639.  * This function changes the active slave to slave <slave_dev>.
  640.  * It returns -EINVAL in the following cases.
  641.  *  - <slave_dev> is not found in the list.
  642.  *  - There is not active slave now.
  643.  *  - <slave_dev> is already active.
  644.  *  - The link state of <slave_dev> is not BOND_LINK_UP.
  645.  *  - <slave_dev> is not running.
  646.  * In these cases, this fuction does nothing.
  647.  * In the other cases, currnt_slave pointer is changed and 0 is returned.
  648.  */
  649. static int bond_change_active(struct net_device *master_dev, struct net_device *slave_dev)
  650. {
  651. bonding_t *bond;
  652. slave_t *slave;
  653. slave_t *oldactive = NULL;
  654. slave_t *newactive = NULL;
  655. unsigned long flags;
  656. int ret = 0;
  658. if (master_dev == NULL || slave_dev == NULL) {
  659. return -ENODEV;
  660. }
  662. bond = (struct bonding *) master_dev->priv;
  663. write_lock_irqsave(&bond->lock, flags);
  664. slave = (slave_t *)bond;
  665. oldactive = bond->current_slave;
  667. while ((slave = slave->prev) != (slave_t *)bond) {
  668. if(slave_dev == slave->dev) {
  669. newactive = slave;
  670. break;
  671. }
  672. }
  674. if ((newactive != NULL)&&
  675.     (oldactive != NULL)&&
  676.     (newactive != oldactive)&&
  677.     (newactive->link == BOND_LINK_UP)&&
  678.     IS_UP(newactive->dev)) {
  679. bond_set_slave_inactive_flags(oldactive);
  680. bond_set_slave_active_flags(newactive);
  681. bond->current_slave = newactive;
  682. printk("%s : activate %s(old : %s)n",
  683. master_dev->name, newactive->dev->name, 
  684. oldactive->dev->name);
  685. }
  686. else {
  687. ret = -EINVAL;
  688. }
  689. write_unlock_irqrestore(&bond->lock, flags);
  690. return ret;
  691. }
  693. /* Choose a new valid interface from the pool, set it active
  694.  * and make it the current slave. If no valid interface is
  695.  * found, the oldest slave in BACK state is choosen and
  696.  * activated. If none is found, it's considered as no
  697.  * interfaces left so the current slave is set to NULL.
  698.  * The result is a pointer to the current slave.
  699.  *
  700.  * Since this function sends messages tails through printk, the caller
  701.  * must have started something like `printk(KERN_INFO "xxxx ");'.
  702.  *
  703.  * Warning: must put locks around the call to this function if needed.
  704.  */
  705. slave_t *change_active_interface(bonding_t *bond)
  706. {
  707. slave_t *newslave, *oldslave;
  708. slave_t *bestslave = NULL;
  709. int mintime;
  711. read_lock(&bond->ptrlock);
  712. newslave = oldslave = bond->current_slave;
  713. read_unlock(&bond->ptrlock);
  715. if (newslave == NULL) { /* there were no active slaves left */
  716. if (bond->next != (slave_t *)bond) {  /* found one slave */
  717. write_lock(&bond->ptrlock);
  718. newslave = bond->current_slave = bond->next;
  719. write_unlock(&bond->ptrlock);
  720. } else {
  721. printk (" but could not find any %s interface.n",
  722. (mode == BOND_MODE_ACTIVEBACKUP) ? "backup":"other");
  723. write_lock(&bond->ptrlock);
  724. bond->current_slave = (slave_t *)NULL;
  725. write_unlock(&bond->ptrlock);
  726. return NULL; /* still no slave, return NULL */
  727. }
  728. }
  730. mintime = updelay;
  732. do {
  733. if (IS_UP(newslave->dev)) {
  734. if (newslave->link == BOND_LINK_UP) {
  735. /* this one is immediately usable */
  736. if (mode == BOND_MODE_ACTIVEBACKUP) {
  737. bond_set_slave_active_flags(newslave);
  738. printk (" and making interface %s the active one.n",
  739. newslave->dev->name);
  740. }
  741. else {
  742. printk (" and setting pointer to interface %s.n",
  743. newslave->dev->name);
  744. }
  746. write_lock(&bond->ptrlock);
  747. bond->current_slave = newslave;
  748. write_unlock(&bond->ptrlock);
  749. return newslave;
  750. }
  751. else if (newslave->link == BOND_LINK_BACK) {
  752. /* link up, but waiting for stabilization */
  753. if (newslave->delay < mintime) {
  754. mintime = newslave->delay;
  755. bestslave = newslave;
  756. }
  757. }
  758. }
  759. } while ((newslave = newslave->next) != oldslave);
  761. /* no usable backup found, we'll see if we at least got a link that was
  762.    coming back for a long time, and could possibly already be usable.
  763. */
  765. if (bestslave != NULL) {
  766. /* early take-over. */
  767. printk (" and making interface %s the active one %d ms earlier.n",
  768. bestslave->dev->name,
  769. (updelay - bestslave->delay)*miimon);
  771. bestslave->delay = 0;
  772. bestslave->link = BOND_LINK_UP;
  773. bond_set_slave_active_flags(bestslave);
  775. write_lock(&bond->ptrlock);
  776. bond->current_slave = bestslave;
  777. write_unlock(&bond->ptrlock);
  778. return bestslave;
  779. }
  781. printk (" but could not find any %s interface.n",
  782. (mode == BOND_MODE_ACTIVEBACKUP) ? "backup":"other");
  784. /* absolutely nothing found. let's return NULL */
  785. write_lock(&bond->ptrlock);
  786. bond->current_slave = (slave_t *)NULL;
  787. write_unlock(&bond->ptrlock);
  788. return NULL;
  789. }
  791. /*
  792.  * Try to release the slave device <slave> from the bond device <master>
  793.  * It is legal to access current_slave without a lock because all the function
  794.  * is write-locked.
  795.  *
  796.  * The rules for slave state should be:
  797.  *   for Active/Backup:
  798.  *     Active stays on all backups go down
  799.  *   for Bonded connections:
  800.  *     The first up interface should be left on and all others downed.
  801.  */
  802. static int bond_release(struct net_device *master, struct net_device *slave)
  803. {
  804. bonding_t *bond;
  805. slave_t *our_slave, *old_current;
  806. unsigned long flags;
  808. if (master == NULL || slave == NULL)  {
  809. return -ENODEV;
  810. }
  812. bond = (struct bonding *) master->priv;
  814. write_lock_irqsave(&bond->lock, flags);
  816. /* master already enslaved, or slave not enslaved,
  817.    or no slave for this master */
  818. if ((master->flags & IFF_SLAVE) || !(slave->flags & IFF_SLAVE)) {
  819. printk (KERN_DEBUG "%s: cannot release %s.n", master->name, slave->name);
  820. write_unlock_irqrestore(&bond->lock, flags);
  821. return -EINVAL;
  822. }
  824. our_slave = (slave_t *)bond;
  825. old_current = bond->current_slave;
  826. while ((our_slave = our_slave->prev) != (slave_t *)bond) {
  827. if (our_slave->dev == slave) {
  828. bond_detach_slave(bond, our_slave);
  830. printk (KERN_INFO "%s: releasing %s interface %s",
  831. master->name,
  832. (our_slave->state == BOND_STATE_ACTIVE) ? "active" : "backup",
  833. slave->name);
  835. if (our_slave == old_current) {
  836. /* find a new interface and be verbose */
  837. change_active_interface(bond); 
  838. } else {
  839. printk(".n");
  840. }
  841. kfree(our_slave);
  843. /* release the slave from its bond */
  844.  
  845. netdev_set_master(slave, NULL);
  847. /* only restore its RUNNING flag if monitoring set it down */
  848. if (slave->flags & IFF_UP) {
  849. slave->flags |= IFF_RUNNING;
  850. }
  852. if (slave->flags & IFF_NOARP || 
  853. bond->current_slave != NULL) {
  854. dev_close(slave);
  855. }
  857. if (bond->current_slave == NULL) {
  858. printk(KERN_INFO
  859. "%s: now running without any active interface !n",
  860. master->name);
  861. }
  863. update_slave_cnt(bond);
  865. write_unlock_irqrestore(&bond->lock, flags);
  866. return 0;  /* deletion OK */
  867. }
  868. }
  870. /* if we get here, it's because the device was not found */
  871. write_unlock_irqrestore(&bond->lock, flags);
  873. printk (KERN_INFO "%s: %s not enslavedn", master->name, slave->name);
  874. return -EINVAL;
  875. }
  877. /* 
  878.  * This function releases all slaves.
  879.  * Warning: must put write-locks around the call to this function.
  880.  */
  881. static int bond_release_all(struct net_device *master)
  882. {
  883. bonding_t *bond;
  884. slave_t *our_slave;
  885. struct net_device *slave_dev;
  887. if (master == NULL)  {
  888. return -ENODEV;
  889. }
  891. if (master->flags & IFF_SLAVE) {
  892. return -EINVAL;
  893. }
  895. bond = (struct bonding *) master->priv;
  896. bond->current_slave = NULL;
  898. while ((our_slave = bond->prev) != (slave_t *)bond) {
  899. slave_dev = our_slave->dev;
  900. bond->prev = our_slave->prev;
  902. kfree(our_slave);
  904. netdev_set_master(slave_dev, NULL);
  906. /* only restore its RUNNING flag if monitoring set it down */
  907. if (slave_dev->flags & IFF_UP)
  908. slave_dev->flags |= IFF_RUNNING;
  910. if (slave_dev->flags & IFF_NOARP)
  911. dev_close(slave_dev);
  912. }
  913. bond->next = (slave_t *)bond;
  914. bond->slave_cnt = 0;
  915. printk (KERN_INFO "%s: releases all slavesn", master->name);
  917. return 0;
  918. }
  920. /* this function is called regularly to monitor each slave's link. */
  921. static void bond_mii_monitor(struct net_device *master)
  922. {
  923. bonding_t *bond = (struct bonding *) master->priv;
  924. slave_t *slave, *bestslave, *oldcurrent;
  925. unsigned long flags;
  926. int slave_died = 0;
  928. read_lock_irqsave(&bond->lock, flags);
  930. /* we will try to read the link status of each of our slaves, and
  931.  * set their IFF_RUNNING flag appropriately. For each slave not
  932.  * supporting MII status, we won't do anything so that a user-space
  933.  * program could monitor the link itself if needed.
  934.  */
  936. bestslave = NULL;
  937. slave = (slave_t *)bond;
  939. read_lock(&bond->ptrlock);
  940. oldcurrent = bond->current_slave;
  941. read_unlock(&bond->ptrlock);
  943. while ((slave = slave->prev) != (slave_t *)bond) {
  944. /* use updelay+1 to match an UP slave even when updelay is 0 */
  945. int mindelay = updelay + 1;
  946. struct net_device *dev = slave->dev;
  947. u16 link_state;
  949. link_state = bond_check_dev_link(dev);
  951. switch (slave->link) {
  952. case BOND_LINK_UP: /* the link was up */
  953. if ((link_state & MII_LINK_UP) == MII_LINK_UP) {
  954. /* link stays up, tell that this one
  955.    is immediately available */
  956. if (IS_UP(dev) && (mindelay > -2)) {
  957. /* -2 is the best case :
  958.    this slave was already up */
  959. mindelay = -2;
  960. bestslave = slave;
  961. }
  962. break;
  963. }
  964. else { /* link going down */
  965. slave->link  = BOND_LINK_FAIL;
  966. slave->delay = downdelay;
  967. if (slave->link_failure_count < UINT_MAX) {
  968. slave->link_failure_count++;
  969. }
  970. if (downdelay > 0) {
  971. printk (KERN_INFO
  972. "%s: link status down for %sinterface "
  973. "%s, disabling it in %d ms.n",
  974. master->name,
  975. IS_UP(dev)
  976. ? ((mode == BOND_MODE_ACTIVEBACKUP)
  977.    ? ((slave == oldcurrent)
  978.       ? "active " : "backup ")
  979.    : "")
  980. : "idle ",
  981. dev->name,
  982. downdelay * miimon);
  983. }
  984. }
  985. /* no break ! fall through the BOND_LINK_FAIL test to
  986.    ensure proper action to be taken
  987. */
  988. case BOND_LINK_FAIL: /* the link has just gone down */
  989. if ((link_state & MII_LINK_UP) == 0) {
  990. /* link stays down */
  991. if (slave->delay <= 0) {
  992. /* link down for too long time */
  993. slave->link = BOND_LINK_DOWN;
  994. /* in active/backup mode, we must
  995.    completely disable this interface */
  996. if (mode == BOND_MODE_ACTIVEBACKUP) {
  997. bond_set_slave_inactive_flags(slave);
  998. }
  999. printk(KERN_INFO
  1000. "%s: link status definitely down "
  1001. "for interface %s, disabling it",
  1002. master->name,
  1003. dev->name);
  1005. read_lock(&bond->ptrlock);
  1006. if (slave == bond->current_slave) {
  1007. read_unlock(&bond->ptrlock);
  1008. /* find a new interface and be verbose */
  1009. change_active_interface(bond);
  1010. } else {
  1011. read_unlock(&bond->ptrlock);
  1012. printk(".n");
  1013. }
  1014. slave_died = 1;
  1015. } else {
  1016. slave->delay--;
  1017. }
  1018. } else if ((link_state & MII_LINK_READY) == MII_LINK_READY) {
  1019. /* link up again */
  1020. slave->link  = BOND_LINK_UP;
  1021. printk(KERN_INFO
  1022. "%s: link status up again after %d ms "
  1023. "for interface %s.n",
  1024. master->name,
  1025. (downdelay - slave->delay) * miimon,
  1026. dev->name);
  1028. if (IS_UP(dev) && (mindelay > -1)) {
  1029. /* -1 is a good case : this slave went
  1030.    down only for a short time */
  1031. mindelay = -1;
  1032. bestslave = slave;
  1033. }
  1034. }
  1035. break;
  1036. case BOND_LINK_DOWN: /* the link was down */
  1037. if ((link_state & MII_LINK_READY) != MII_LINK_READY) {
  1038. /* the link stays down, nothing more to do */
  1039. break;
  1040. } else { /* link going up */
  1041. slave->link  = BOND_LINK_BACK;
  1042. slave->delay = updelay;
  1044. if (updelay > 0) {
  1045. /* if updelay == 0, no need to
  1046.    advertise about a 0 ms delay */
  1047. printk (KERN_INFO
  1048. "%s: link status up for interface"
  1049. " %s, enabling it in %d ms.n",
  1050. master->name,
  1051. dev->name,
  1052. updelay * miimon);
  1053. }
  1054. }
  1055. /* no break ! fall through the BOND_LINK_BACK state in
  1056.    case there's something to do.
  1057. */
  1058. case BOND_LINK_BACK: /* the link has just come back */
  1059. if ((link_state & MII_LINK_UP) == 0) {
  1060. /* link down again */
  1061. slave->link  = BOND_LINK_DOWN;
  1062. printk(KERN_INFO
  1063. "%s: link status down again after %d ms "
  1064. "for interface %s.n",
  1065. master->name,
  1066. (updelay - slave->delay) * miimon,
  1067. dev->name);
  1068. }
  1069. else if ((link_state & MII_LINK_READY) == MII_LINK_READY) {
  1070. /* link stays up */
  1071. if (slave->delay == 0) {
  1072. /* now the link has been up for long time enough */
  1073. slave->link = BOND_LINK_UP;
  1075. if (mode == BOND_MODE_ACTIVEBACKUP) {
  1076. /* prevent it from being the active one */
  1077. slave->state = BOND_STATE_BACKUP;
  1078. }
  1079. else {
  1080. /* make it immediately active */
  1081. slave->state = BOND_STATE_ACTIVE;
  1082. }
  1084. printk(KERN_INFO
  1085. "%s: link status definitely up "
  1086. "for interface %s.n",
  1087. master->name,
  1088. dev->name);
  1089. }
  1090. else
  1091. slave->delay--;
  1093. /* we'll also look for the mostly eligible slave */
  1094. if (IS_UP(dev) && (slave->delay < mindelay)) {
  1095. mindelay = slave->delay;
  1096. bestslave = slave;
  1097. } 
  1098. }
  1099. break;
  1100. } /* end of switch */
  1101. } /* end of while */
  1103. /* 
  1104.  * if there's no active interface and we discovered that one
  1105.  * of the slaves could be activated earlier, so we do it.
  1106.  */
  1107. read_lock(&bond->ptrlock);
  1108. oldcurrent = bond->current_slave;
  1109. read_unlock(&bond->ptrlock);
  1111. if (oldcurrent == NULL) {  /* no active interface at the moment */
  1112. if (bestslave != NULL) { /* last chance to find one ? */
  1113. if (bestslave->link == BOND_LINK_UP) {
  1114. printk (KERN_INFO
  1115. "%s: making interface %s the new active one.n",
  1116. master->name, bestslave->dev->name);
  1117. } else {
  1118. printk (KERN_INFO
  1119. "%s: making interface %s the new "
  1120. "active one %d ms earlier.n",
  1121. master->name, bestslave->dev->name,
  1122. (updelay - bestslave->delay) * miimon);
  1124. bestslave->delay= 0;
  1125. bestslave->link = BOND_LINK_UP;
  1126. }
  1128. if (mode == BOND_MODE_ACTIVEBACKUP) {
  1129. bond_set_slave_active_flags(bestslave);
  1130. } else {
  1131. bestslave->state = BOND_STATE_ACTIVE;
  1132. }
  1133. write_lock(&bond->ptrlock);
  1134. bond->current_slave = bestslave;
  1135. write_unlock(&bond->ptrlock);
  1136. } else if (slave_died) {
  1137. /* print this message only once a slave has just died */
  1138. printk(KERN_INFO
  1139. "%s: now running without any active interface !n",
  1140. master->name);
  1141. }
  1142. }
  1144. read_unlock_irqrestore(&bond->lock, flags);
  1145. /* re-arm the timer */
  1146. mod_timer(&bond->mii_timer, jiffies + (miimon * HZ / 1000));
  1147. }
  1149. /* 
  1150.  * this function is called regularly to monitor each slave's link 
  1151.  * insuring that traffic is being sent and received.  If the adapter
  1152.  * has been dormant, then an arp is transmitted to generate traffic 
  1153.  */
  1154. static void bond_arp_monitor(struct net_device *master)
  1155. {
  1156. bonding_t *bond;
  1157. unsigned long flags;
  1158. slave_t *slave;
  1159. int the_delta_in_ticks =  arp_interval * HZ / 1000;
  1160. int next_timer = jiffies + (arp_interval * HZ / 1000);
  1162. bond = (struct bonding *) master->priv; 
  1163. if (master->priv == NULL) {
  1164. mod_timer(&bond->arp_timer, next_timer);
  1165. return;
  1166. }
  1168. read_lock_irqsave(&bond->lock, flags);
  1170. if (!IS_UP(master)) {
  1171. mod_timer(&bond->arp_timer, next_timer);
  1172. goto arp_monitor_out;
  1173. }
  1176. if (rtnl_shlock_nowait()) {
  1177. goto arp_monitor_out;
  1178. }
  1180. if (rtnl_exlock_nowait()) {
  1181. rtnl_shunlock();
  1182. goto arp_monitor_out;
  1183. }
  1185. /* see if any of the previous devices are up now (i.e. they have seen a 
  1186.  * response from an arp request sent by another adapter, since they 
  1187.  * have the same hardware address).
  1188.  */
  1190. slave = (slave_t *)bond;
  1191. while ((slave = slave->prev) != (slave_t *)bond)  {
  1193. read_lock(&bond->ptrlock);
  1194.    if ( (!(slave->link == BOND_LINK_UP))  
  1195. && (slave!= bond->current_slave) ) {
  1197. read_unlock(&bond->ptrlock);
  1199.    if ( ((jiffies - slave->dev->trans_start) <= 
  1200. the_delta_in_ticks) &&  
  1201.      ((jiffies - slave->dev->last_rx) <= 
  1202. the_delta_in_ticks) ) {
  1204. slave->link  = BOND_LINK_UP;
  1205. write_lock(&bond->ptrlock);
  1206. if (bond->current_slave == NULL) {
  1207. slave->state = BOND_STATE_ACTIVE;
  1208. bond->current_slave = slave;
  1209. }
  1210. if (slave!=bond->current_slave) {
  1211. slave->dev->flags |= IFF_NOARP;
  1212. }
  1213. write_unlock(&bond->ptrlock);
  1214. } else {
  1215. if ((jiffies - slave->dev->last_rx) <= 
  1216. the_delta_in_ticks)  {
  1217. arp_send(ARPOP_REQUEST, ETH_P_ARP, 
  1218. arp_target, slave->dev, 
  1219. my_ip, arp_target_hw_addr, 
  1220. slave->dev->dev_addr, 
  1221.    arp_target_hw_addr); 
  1222. }
  1223. }
  1224. } else 
  1225. read_unlock(&bond->ptrlock);
  1226. }
  1228. read_lock(&bond->ptrlock);
  1229. slave = bond->current_slave;
  1230. read_unlock(&bond->ptrlock);
  1232. if (slave != 0) {
  1234.   /* see if you need to take down the current_slave, since
  1235.    * you haven't seen an arp in 2*arp_intervals
  1236.    */
  1238. if ( ((jiffies - slave->dev->trans_start) >= 
  1239.       (2*the_delta_in_ticks)) ||
  1240.      ((jiffies - slave->dev->last_rx) >= 
  1241.       (2*the_delta_in_ticks)) ) {
  1243. if (slave->link == BOND_LINK_UP) {
  1244. slave->link  = BOND_LINK_DOWN;
  1245. slave->state = BOND_STATE_BACKUP;
  1246. /* 
  1247.  * we want to see arps, otherwise we couldn't 
  1248.  * bring the adapter back online...  
  1249.  */
  1250. printk(KERN_INFO "%s: link status definitely "
  1251.  "down for interface %s, "
  1252.  "disabling it",
  1253.        slave->dev->master->name,
  1254.        slave->dev->name);
  1255. /* find a new interface and be verbose */
  1256. change_active_interface(bond);
  1257. read_lock(&bond->ptrlock);
  1258. slave = bond->current_slave;
  1259. read_unlock(&bond->ptrlock);
  1260. }
  1261. } 
  1263. /* 
  1264.  * ok, we know up/down, so just send a arp out if there has
  1265.  * been no activity for a while 
  1266.  */
  1268. if (slave != NULL ) {
  1269. if ( ((jiffies - slave->dev->trans_start) >= 
  1270.        the_delta_in_ticks) || 
  1271.      ((jiffies - slave->dev->last_rx) >= 
  1272.        the_delta_in_ticks) ) {
  1273. arp_send(ARPOP_REQUEST, ETH_P_ARP, 
  1274.  arp_target, slave->dev,
  1275.  my_ip, arp_target_hw_addr, 
  1276.  slave->dev->dev_addr, 
  1277.  arp_target_hw_addr); 
  1278. }
  1279. } 
  1281. }
  1283. /* if we have no current slave.. try sending 
  1284.  * an arp on all of the interfaces 
  1285.  */
  1287. read_lock(&bond->ptrlock);
  1288. if (bond->current_slave == NULL) { 
  1289. read_unlock(&bond->ptrlock);
  1290. slave = (slave_t *)bond;
  1291. while ((slave = slave->prev) != (slave_t *)bond)   {
  1292. arp_send(ARPOP_REQUEST, ETH_P_ARP, arp_target, 
  1293.  slave->dev, my_ip, arp_target_hw_addr, 
  1294.  slave->dev->dev_addr, arp_target_hw_addr); 
  1295. }
  1296. }
  1297. else {
  1298. read_unlock(&bond->ptrlock);
  1299. }
  1301. rtnl_exunlock();
  1302. rtnl_shunlock();
  1304. arp_monitor_out:
  1305. read_unlock_irqrestore(&bond->lock, flags);
  1307. /* re-arm the timer */
  1308. mod_timer(&bond->arp_timer, next_timer);
  1309. }
  1311. #define isdigit(c) (c >= '0' && c <= '9')
  1312. __inline static int atoi( char **s) 
  1313. {
  1314. int i=0;
  1315. while (isdigit(**s))
  1316.   i = i*20 + *((*s)++) - '0';
  1317. return i;
  1318. }
  1320. #define isascii(c) (((unsigned char)(c))<=0x7f)
  1321. #define LF 0xA
  1322. #define isspace(c) (c==' ' || c==' '|| c==LF)   
  1323. typedef uint32_t in_addr_t;
  1325. int
  1326. my_inet_aton(char *cp, unsigned long *the_addr) {
  1327. static const in_addr_t max[4] = { 0xffffffff, 0xffffff, 0xffff, 0xff };
  1328. in_addr_t val;
  1329. char c;
  1330. union iaddr {
  1331.   uint8_t bytes[4];
  1332.   uint32_t word;
  1333. } res;
  1334. uint8_t *pp = res.bytes;
  1335. int digit,base;
  1337. res.word = 0;
  1339. c = *cp;
  1340. for (;;) {
  1341. /*
  1342.  * Collect number up to ``.''.
  1343.  * Values are specified as for C:
  1344.  * 0x=hex, 0=octal, isdigit=decimal.
  1345.  */
  1346. if (!isdigit(c)) goto ret_0;
  1347. val = 0; base = 10; digit = 0;
  1348. for (;;) {
  1349. if (isdigit(c)) {
  1350. val = (val * base) + (c - '0');
  1351. c = *++cp;
  1352. digit = 1;
  1353. } else {
  1354. break;
  1355. }
  1356. }
  1357. if (c == '.') {
  1358. /*
  1359.  * Internet format:
  1360.  * a.b.c.d
  1361.  * a.b.c (with c treated as 16 bits)
  1362.  * a.b (with b treated as 24 bits)
  1363.  */
  1364. if (pp > res.bytes + 2 || val > 0xff) {
  1365. goto ret_0;
  1366. }
  1367. *pp++ = val;
  1368. c = *++cp;
  1369. } else
  1370. break;
  1371. }
  1372. /*
  1373.  * Check for trailing characters.
  1374.  */
  1375. if (c != '' && (!isascii(c) || !isspace(c))) {
  1376. goto ret_0;
  1377. }
  1378. /*
  1379.  * Did we get a valid digit?
  1380.  */
  1381. if (!digit) {
  1382. goto ret_0;
  1383. }
  1385. /* Check whether the last part is in its limits depending on
  1386.    the number of parts in total.  */
  1387. if (val > max[pp - res.bytes]) {
  1388. goto ret_0;
  1389. }
  1391. if (the_addr!= NULL) {
  1392. *the_addr = res.word | htonl (val);
  1393. }
  1395. return (1);
  1397. ret_0:
  1398. return (0);
  1399. }
  1401. static int bond_sethwaddr(struct net_device *master, struct net_device *slave)
  1402. {
  1403. #ifdef BONDING_DEBUG
  1404. printk(KERN_CRIT "bond_sethwaddr: master=%xn", (unsigned int)master);
  1405. printk(KERN_CRIT "bond_sethwaddr: slave=%xn", (unsigned int)slave);
  1406. printk(KERN_CRIT "bond_sethwaddr: slave->addr_len=%dn", slave->addr_len);
  1407. #endif
  1408. memcpy(master->dev_addr, slave->dev_addr, slave->addr_len);
  1409. return 0;
  1410. }
  1412. static int bond_info_query(struct net_device *master, struct ifbond *info)
  1413. {
  1414. bonding_t *bond = (struct bonding *) master->priv;
  1415. slave_t *slave;
  1416. unsigned long flags;
  1418. info->bond_mode = mode;
  1419. info->num_slaves = 0;
  1420. info->miimon = miimon;
  1422. read_lock_irqsave(&bond->lock, flags);
  1423. for (slave = bond->prev; slave!=(slave_t *)bond; slave = slave->prev) {
  1424. info->num_slaves++;
  1425. }
  1426. read_unlock_irqrestore(&bond->lock, flags);
  1428. return 0;
  1429. }
  1431. static int bond_slave_info_query(struct net_device *master, 
  1432. struct ifslave *info)
  1433. {
  1434. bonding_t *bond = (struct bonding *) master->priv;
  1435. slave_t *slave;
  1436. int cur_ndx = 0;
  1437. unsigned long flags;
  1439. if (info->slave_id < 0) {
  1440. return -ENODEV;
  1441. }
  1443. read_lock_irqsave(&bond->lock, flags);
  1444. for (slave = bond->prev; 
  1445.  slave != (slave_t *)bond && cur_ndx < info->slave_id; 
  1446.  slave = slave->prev) {
  1447. cur_ndx++;
  1448. }
  1449. read_unlock_irqrestore(&bond->lock, flags);
  1451. if (cur_ndx == info->slave_id) {
  1452. strcpy(info->slave_name, slave->dev->name);
  1453. info->link = slave->link;
  1454. info->state = slave->state;
  1455. info->link_failure_count = slave->link_failure_count;
  1456. } else {
  1457. return -ENODEV;
  1458. }
  1460. return 0;
  1461. }
  1463. static int bond_ioctl(struct net_device *master_dev, struct ifreq *ifr, int cmd)
  1464. {
  1465. struct net_device *slave_dev = NULL;
  1466. struct ifbond *u_binfo = NULL, k_binfo;
  1467. struct ifslave *u_sinfo = NULL, k_sinfo;
  1468. u16 *data = NULL;
  1469. int ret = 0;
  1471. #ifdef BONDING_DEBUG
  1472. printk(KERN_INFO "bond_ioctl: master=%s, cmd=%dn", 
  1473. master_dev->name, cmd);
  1474. #endif
  1476. switch (cmd) {
  1477. case SIOCGMIIPHY:
  1478. data = (u16 *)&ifr->ifr_data;
  1479. if (data == NULL) {
  1480. return -EINVAL;
  1481. }
  1482. data[0] = 0;
  1483. /* Fall Through */
  1484. case SIOCGMIIREG:
  1485. /* 
  1486.  * We do this again just in case we were called by SIOCGMIIREG
  1487.  * instead of SIOCGMIIPHY.
  1488.  */
  1489. data = (u16 *)&ifr->ifr_data;
  1490. if (data == NULL) {
  1491. return -EINVAL;
  1492. }
  1493. if (data[1] == 1) {
  1494. data[3] = bond_check_mii_link(
  1495. (struct bonding *)master_dev->priv);
  1496. }
  1497. return 0;
  1498. case BOND_INFO_QUERY_OLD:
  1499. case SIOCBONDINFOQUERY:
  1500. u_binfo = (struct ifbond *)ifr->ifr_data;
  1501. if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) {
  1502. return -EFAULT;
  1503. }
  1504. ret = bond_info_query(master_dev, &k_binfo);
  1505. if (ret == 0) {
  1506. if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) {
  1507. return -EFAULT;
  1508. }
  1509. }
  1510. return ret;
  1511. case BOND_SLAVE_INFO_QUERY_OLD:
  1512. case SIOCBONDSLAVEINFOQUERY:
  1513. u_sinfo = (struct ifslave *)ifr->ifr_data;
  1514. if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) {
  1515. return -EFAULT;
  1516. }
  1517. ret = bond_slave_info_query(master_dev, &k_sinfo);
  1518. if (ret == 0) {
  1519. if (copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) {
  1520. return -EFAULT;
  1521. }
  1522. }
  1523. return ret;
  1524. }
  1526. if (!capable(CAP_NET_ADMIN)) {
  1527. return -EPERM;
  1528. }
  1530. slave_dev = dev_get_by_name(ifr->ifr_slave);
  1532. #ifdef BONDING_DEBUG
  1533. printk(KERN_INFO "slave_dev=%x: n", (unsigned int)slave_dev);
  1534. printk(KERN_INFO "slave_dev->name=%s: n", slave_dev->name);
  1535. #endif
  1537. if (slave_dev == NULL) {
  1538. ret = -ENODEV;
  1539. } else {
  1540. switch (cmd) {
  1541. case BOND_ENSLAVE_OLD:
  1542. case SIOCBONDENSLAVE:
  1543. ret = bond_enslave(master_dev, slave_dev);
  1544. break;
  1545. case BOND_RELEASE_OLD:
  1546. case SIOCBONDRELEASE:
  1547. ret = bond_release(master_dev, slave_dev); 
  1548. break;
  1549. case BOND_SETHWADDR_OLD:
  1550. case SIOCBONDSETHWADDR:
  1551. ret = bond_sethwaddr(master_dev, slave_dev);
  1552. break;
  1553. case BOND_CHANGE_ACTIVE_OLD:
  1554. case SIOCBONDCHANGEACTIVE:
  1555. if (mode == BOND_MODE_ACTIVEBACKUP) {
  1556. ret = bond_change_active(master_dev, slave_dev);
  1557. }
  1558. else {
  1559. ret = -EINVAL;
  1560. }
  1561. break;
  1562. default:
  1563. ret = -EOPNOTSUPP;
  1564. }
  1565. dev_put(slave_dev);
  1566. }
  1567. return ret;
  1568. }
  1570. #ifdef CONFIG_NET_FASTROUTE
  1571. static int bond_accept_fastpath(struct net_device *dev, struct dst_entry *dst)
  1572. {
  1573. return -1;
  1574. }
  1575. #endif
  1577. static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *dev)
  1578. {
  1579. slave_t *slave, *start_at;
  1580. struct bonding *bond = (struct bonding *) dev->priv;
  1581. unsigned long flags;
  1583. if (!IS_UP(dev)) { /* bond down */
  1584. dev_kfree_skb(skb);
  1585. return 0;
  1586. }
  1588. read_lock_irqsave(&bond->lock, flags);
  1590. read_lock(&bond->ptrlock);
  1591. slave = start_at = bond->current_slave;
  1592. read_unlock(&bond->ptrlock);
  1594. if (slave == NULL) { /* we're at the root, get the first slave */
  1595. /* no suitable interface, frame not sent */
  1596. dev_kfree_skb(skb);
  1597. read_unlock_irqrestore(&bond->lock, flags);
  1598. return 0;
  1599. }
  1601. do {
  1602. if (IS_UP(slave->dev)
  1603.     && (slave->link == BOND_LINK_UP)
  1604.     && (slave->state == BOND_STATE_ACTIVE)) {
  1606. skb->dev = slave->dev;
  1607. skb->priority = 1;
  1608. dev_queue_xmit(skb);
  1610. write_lock(&bond->ptrlock);
  1611. bond->current_slave = slave->next;
  1612. write_unlock(&bond->ptrlock);
  1614. read_unlock_irqrestore(&bond->lock, flags);
  1615. return 0;
  1616. }
  1617. } while ((slave = slave->next) != start_at);
  1619. /* no suitable interface, frame not sent */
  1620. dev_kfree_skb(skb);
  1621. read_unlock_irqrestore(&bond->lock, flags);
  1622. return 0;
  1623. }
  1625. /* 
  1626.  * in XOR mode, we determine the output device by performing xor on
  1627.  * the source and destination hw adresses.  If this device is not 
  1628.  * enabled, find the next slave following this xor slave. 
  1629.  */
  1630. static int bond_xmit_xor(struct sk_buff *skb, struct net_device *dev)
  1631. {
  1632. slave_t *slave, *start_at;
  1633. struct bonding *bond = (struct bonding *) dev->priv;
  1634. unsigned long flags;
  1635. struct ethhdr *data = (struct ethhdr *)skb->data;
  1636. int slave_no;
  1638. if (!IS_UP(dev)) { /* bond down */
  1639. dev_kfree_skb(skb);
  1640. return 0;
  1641. }
  1643. read_lock_irqsave(&bond->lock, flags);
  1644. slave = bond->prev;
  1646. /* we're at the root, get the first slave */
  1647. if ((slave == NULL) || (slave->dev == NULL)) { 
  1648. /* no suitable interface, frame not sent */
  1649. dev_kfree_skb(skb);
  1650. read_unlock_irqrestore(&bond->lock, flags);
  1651. return 0;
  1652. }
  1654. slave_no = (data->h_dest[5]^slave->dev->dev_addr[5]) % bond->slave_cnt;
  1656. while ( (slave_no > 0) && (slave != (slave_t *)bond) ) {
  1657. slave = slave->prev;
  1658. slave_no--;
  1659. } 
  1660. start_at = slave;
  1662. do {
  1663. if (IS_UP(slave->dev)
  1664.     && (slave->link == BOND_LINK_UP)
  1665.     && (slave->state == BOND_STATE_ACTIVE)) {
  1667. skb->dev = slave->dev;
  1668. skb->priority = 1;
  1669. dev_queue_xmit(skb);
  1671. read_unlock_irqrestore(&bond->lock, flags);
  1672. return 0;
  1673. }
  1674. } while ((slave = slave->next) != start_at);
  1676. /* no suitable interface, frame not sent */
  1677. dev_kfree_skb(skb);
  1678. read_unlock_irqrestore(&bond->lock, flags);
  1679. return 0;
  1680. }
  1682. /* 
  1683.  * in active-backup mode, we know that bond->current_slave is always valid if
  1684.  * the bond has a usable interface.
  1685.  */
  1686. static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *dev)
  1687. {
  1688. struct bonding *bond = (struct bonding *) dev->priv;
  1689. unsigned long flags;
  1690. int ret;
  1692. if (!IS_UP(dev)) { /* bond down */
  1693. dev_kfree_skb(skb);
  1694. return 0;
  1695. }
  1697. /* if we are sending arp packets, try to at least 
  1698.    identify our own ip address */
  1699. if ( (arp_interval > 0) && (my_ip==0) &&
  1700. (skb->protocol == __constant_htons(ETH_P_ARP) ) ) {
  1701. char *the_ip = (((char *)skb->data)) 
  1702. + sizeof(struct ethhdr)  
  1703. + sizeof(struct arphdr) + 
  1704. ETH_ALEN;
  1705. memcpy(&my_ip, the_ip, 4);
  1706. }
  1708. /* if we are sending arp packets and don't know 
  1709.    the target hw address, save it so we don't need 
  1710.    to use a broadcast address */
  1711. if ( (arp_interval > 0) && (arp_target_hw_addr==NULL) &&
  1712.      (skb->protocol == __constant_htons(ETH_P_IP) ) ) {
  1713. struct ethhdr *eth_hdr = 
  1714. (struct ethhdr *) (((char *)skb->data));
  1715. arp_target_hw_addr = kmalloc(ETH_ALEN, GFP_KERNEL);
  1716. memcpy(arp_target_hw_addr, eth_hdr->h_dest, ETH_ALEN);
  1717. }
  1719. read_lock_irqsave(&bond->lock, flags);
  1721. read_lock(&bond->ptrlock);
  1722. if (bond->current_slave != NULL) { /* one usable interface */
  1723. skb->dev = bond->current_slave->dev;
  1724. read_unlock(&bond->ptrlock);
  1725. skb->priority = 1;
  1726. ret = dev_queue_xmit(skb);
  1727. read_unlock_irqrestore(&bond->lock, flags);
  1728. return 0;
  1729. }
  1730. else {
  1731. read_unlock(&bond->ptrlock);
  1732. }
  1734. /* no suitable interface, frame not sent */
  1735. #ifdef BONDING_DEBUG
  1736. printk(KERN_INFO "There was no suitable interface, so we don't transmitn");
  1737. #endif
  1738. dev_kfree_skb(skb);
  1739. read_unlock_irqrestore(&bond->lock, flags);
  1740. return 0;
  1741. }
  1743. static struct net_device_stats *bond_get_stats(struct net_device *dev)
  1744. {
  1745. bonding_t *bond = dev->priv;
  1746. struct net_device_stats *stats = bond->stats, *sstats;
  1747. slave_t *slave;
  1748. unsigned long flags;
  1750. memset(bond->stats, 0, sizeof(struct net_device_stats));
  1752. read_lock_irqsave(&bond->lock, flags);
  1754. for (slave = bond->prev; slave!=(slave_t *)bond; slave = slave->prev) {
  1755. sstats = slave->dev->get_stats(slave->dev);
  1756.  
  1757. stats->rx_packets += sstats->rx_packets;
  1758. stats->rx_bytes += sstats->rx_bytes;
  1759. stats->rx_errors += sstats->rx_errors;
  1760. stats->rx_dropped += sstats->rx_dropped;
  1762. stats->tx_packets += sstats->tx_packets;
  1763. stats->tx_bytes += sstats->tx_bytes;
  1764. stats->tx_errors += sstats->tx_errors;
  1765. stats->tx_dropped += sstats->tx_dropped;
  1767. stats->multicast += sstats->multicast;
  1768. stats->collisions += sstats->collisions;
  1770. stats->rx_length_errors += sstats->rx_length_errors;
  1771. stats->rx_over_errors += sstats->rx_over_errors;
  1772. stats->rx_crc_errors += sstats->rx_crc_errors;
  1773. stats->rx_frame_errors += sstats->rx_frame_errors;
  1774. stats->rx_fifo_errors += sstats->rx_fifo_errors;
  1775. stats->rx_missed_errors += sstats->rx_missed_errors;
  1777. stats->tx_aborted_errors += sstats->tx_aborted_errors;
  1778. stats->tx_carrier_errors += sstats->tx_carrier_errors;
  1779. stats->tx_fifo_errors += sstats->tx_fifo_errors;
  1780. stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
  1781. stats->tx_window_errors += sstats->tx_window_errors;
  1783. }
  1785. read_unlock_irqrestore(&bond->lock, flags);
  1786. return stats;
  1787. }
  1789. static int bond_get_info(char *buf, char **start, off_t offset, int length)
  1790. {
  1791. bonding_t *bond = these_bonds;
  1792. int len = 0;
  1793. off_t begin = 0;
  1794. u16 link;
  1795. slave_t *slave = NULL;
  1796. unsigned long flags;
  1798. while (bond != NULL) {
  1799. /*
  1800.  * This function locks the mutex, so we can't lock it until 
  1801.  * afterwards
  1802.  */
  1803. link = bond_check_mii_link(bond);
  1805. len += sprintf(buf + len, "Bonding Mode: ");
  1806. len += sprintf(buf + len, "%sn", mode ? "active-backup" : "load balancing");
  1808. if (mode == BOND_MODE_ACTIVEBACKUP) {
  1809. read_lock_irqsave(&bond->lock, flags);
  1810. read_lock(&bond->ptrlock);
  1811. if (bond->current_slave != NULL) {
  1812. len += sprintf(buf + len, 
  1813. "Currently Active Slave: %sn", 
  1814. bond->current_slave->dev->name);
  1815. }
  1816. read_unlock(&bond->ptrlock);
  1817. read_unlock_irqrestore(&bond->lock, flags);
  1818. }
  1820. len += sprintf(buf + len, "MII Status: ");
  1821. len += sprintf(buf + len, 
  1822. link == MII_LINK_READY ? "upn" : "downn");
  1823. len += sprintf(buf + len, "MII Polling Interval (ms): %dn", 
  1824. miimon);
  1825. len += sprintf(buf + len, "Up Delay (ms): %dn", updelay);
  1826. len += sprintf(buf + len, "Down Delay (ms): %dn", downdelay);
  1828. read_lock_irqsave(&bond->lock, flags);
  1829. for (slave = bond->prev; slave != (slave_t *)bond; 
  1830.      slave = slave->prev) {
  1831. len += sprintf(buf + len, "nSlave Interface: %sn", slave->dev->name);
  1833. len += sprintf(buf + len, "MII Status: ");
  1835. len += sprintf(buf + len, 
  1836. slave->link == BOND_LINK_UP ? 
  1837. "upn" : "downn");
  1838. len += sprintf(buf + len, "Link Failure Count: %dn", 
  1839. slave->link_failure_count);
  1840. }
  1841. read_unlock_irqrestore(&bond->lock, flags);
  1843. /*
  1844.  * Figure out the calcs for the /proc/net interface
  1845.  */
  1846. *start = buf + (offset - begin);
  1847. len -= (offset - begin);
  1848. if (len > length) {
  1849. len = length;
  1850. }
  1851. if (len < 0) {
  1852. len = 0;
  1853. }
  1856. bond = bond->next_bond;
  1857. }
  1858. return len;
  1859. }
  1861. static int bond_event(struct notifier_block *this, unsigned long event, 
  1862. void *ptr)
  1863. {
  1864. struct bonding *this_bond=(struct bonding *)these_bonds;
  1865. struct bonding *last_bond;
  1866. struct net_device *event_dev = (struct net_device *)ptr;
  1868. /* while there are bonds configured */
  1869. while (this_bond != NULL) {
  1870. if (this_bond == event_dev->priv ) {
  1871. switch (event) {
  1872. case NETDEV_UNREGISTER:
  1873. /* 
  1874.  * remove this bond from a linked list of 
  1875.  * bonds 
  1876.  */
  1877. if (this_bond == these_bonds) {
  1878. these_bonds = this_bond->next_bond;
  1879. } else {
  1880. for (last_bond = these_bonds; 
  1881.      last_bond != NULL; 
  1882.      last_bond = last_bond->next_bond) {
  1883. if (last_bond->next_bond == 
  1884.     this_bond) {
  1885. last_bond->next_bond = 
  1886. this_bond->next_bond;
  1887. }
  1888. }
  1889. }
  1890. return NOTIFY_DONE;
  1892. default:
  1893. return NOTIFY_DONE;
  1894. }
  1895. } else if (this_bond->device == event_dev->master) {
  1896. switch (event) {
  1897. case NETDEV_UNREGISTER:
  1898. bond_release(this_bond->device, event_dev);
  1899. break;
  1900. }
  1901. return NOTIFY_DONE;
  1902. }
  1903. this_bond = this_bond->next_bond;
  1904. }
  1905. return NOTIFY_DONE;
  1906. }
  1908. static struct notifier_block bond_netdev_notifier={
  1909. bond_event,
  1910. NULL,
  1911. 0
  1912. };
  1914. static int __init bond_init(struct net_device *dev)
  1915. {
  1916. bonding_t *bond, *this_bond, *last_bond;
  1918. #ifdef BONDING_DEBUG
  1919. printk (KERN_INFO "Begin bond_init for %sn", dev->name);
  1920. #endif
  1921. bond = kmalloc(sizeof(struct bonding), GFP_KERNEL);
  1922. if (bond == NULL) {
  1923. return -ENOMEM;
  1924. }
  1925. memset(bond, 0, sizeof(struct bonding));
  1927. /* initialize rwlocks */
  1928. rwlock_init(&bond->lock);
  1929. rwlock_init(&bond->ptrlock);
  1931. bond->stats = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
  1932. if (bond->stats == NULL) {
  1933. kfree(bond);
  1934. return -ENOMEM;
  1935. }
  1936. memset(bond->stats, 0, sizeof(struct net_device_stats));
  1938. bond->next = bond->prev = (slave_t *)bond;
  1939. bond->current_slave = NULL;
  1940. bond->device = dev;
  1941. dev->priv = bond;
  1943. /* Initialize the device structure. */
  1944. if (mode == BOND_MODE_ACTIVEBACKUP) {
  1945. dev->hard_start_xmit = bond_xmit_activebackup;
  1946. } else if (mode == BOND_MODE_ROUNDROBIN) {
  1947. dev->hard_start_xmit = bond_xmit_roundrobin;
  1948. } else if (mode == BOND_MODE_XOR) {
  1949. dev->hard_start_xmit = bond_xmit_xor;
  1950. } else {
  1951. printk(KERN_ERR "Unknown bonding mode %dn", mode);
  1952. kfree(bond->stats);
  1953. kfree(bond);
  1954. return -EINVAL;
  1955. }
  1957. dev->get_stats = bond_get_stats;
  1958. dev->open = bond_open;
  1959. dev->stop = bond_close;
  1960. dev->set_multicast_list = set_multicast_list;
  1961. dev->do_ioctl = bond_ioctl;
  1963. /* 
  1964.  * Fill in the fields of the device structure with ethernet-generic 
  1965.  * values. 
  1966.  */
  1968. ether_setup(dev);
  1970. dev->tx_queue_len = 0;
  1971. dev->flags |= IFF_MASTER|IFF_MULTICAST;
  1972. #ifdef CONFIG_NET_FASTROUTE
  1973. dev->accept_fastpath = bond_accept_fastpath;
  1974. #endif
  1976. printk(KERN_INFO "%s registered with", dev->name);
  1977. if (miimon > 0) {
  1978. printk(" MII link monitoring set to %d ms", miimon);
  1979. updelay /= miimon;
  1980. downdelay /= miimon;
  1981. } else {
  1982. printk("out MII link monitoring");
  1983. }
  1984. printk(", in %s mode.n",mode?"active-backup":"bonding");
  1986. #ifdef CONFIG_PROC_FS
  1987. bond->bond_proc_dir = proc_mkdir(dev->name, proc_net);
  1988. if (bond->bond_proc_dir == NULL) {
  1989. printk(KERN_ERR "%s: Cannot init /proc/net/%s/n", 
  1990. dev->name, dev->name);
  1991. kfree(bond->stats);
  1992. kfree(bond);
  1993. return -ENOMEM;
  1994. }
  1995. bond->bond_proc_info_file = 
  1996. create_proc_info_entry("info", 0, bond->bond_proc_dir, 
  1997. bond_get_info);
  1998. if (bond->bond_proc_info_file == NULL) {
  1999. printk(KERN_ERR "%s: Cannot init /proc/net/%s/infon", 
  2000. dev->name, dev->name);
  2001. remove_proc_entry(dev->name, proc_net);
  2002. kfree(bond->stats);
  2003. kfree(bond);
  2004. return -ENOMEM;
  2005. }
  2006. #endif /* CONFIG_PROC_FS */
  2008. if (first_pass == 1) {
  2009. these_bonds = bond;
  2010. register_netdevice_notifier(&bond_netdev_notifier);
  2011. first_pass = 0;
  2012. } else {
  2013. last_bond = these_bonds;
  2014. this_bond = these_bonds->next_bond;
  2015. while (this_bond != NULL) {
  2016. last_bond = this_bond;
  2017. this_bond = this_bond->next_bond;
  2018. }
  2019. last_bond->next_bond = bond;
  2020. } 
  2022. return 0;
  2023. }
  2025. /*
  2026. static int __init bond_probe(struct net_device *dev)
  2027. {
  2028. bond_init(dev);
  2029. return 0;
  2030. }
  2031.  */
  2033. static int __init bonding_init(void)
  2034. {
  2035. int no;
  2036. int err;
  2038. /* Find a name for this unit */
  2039. static struct net_device *dev_bond = NULL;
  2041. dev_bond = dev_bonds = kmalloc(max_bonds*sizeof(struct net_device), 
  2042. GFP_KERNEL);
  2043. if (dev_bond == NULL) {
  2044. return -ENOMEM;
  2045. }
  2046. memset(dev_bonds, 0, max_bonds*sizeof(struct net_device));
  2048. if (arp_ip_target) {
  2049. if (my_inet_aton(arp_ip_target, &arp_target) == 0)  {
  2050. arp_interval = 0;
  2051. }
  2052. }
  2054. for (no = 0; no < max_bonds; no++) {
  2055. dev_bond->init = bond_init;
  2057. err = dev_alloc_name(dev_bond,"bond%d");
  2058. if (err < 0) {
  2059. kfree(dev_bonds);
  2060. return err;
  2061. }
  2062. SET_MODULE_OWNER(dev_bond);
  2063. if (register_netdev(dev_bond) != 0) {
  2064. kfree(dev_bonds);
  2065. return -EIO;
  2066. }
  2067. dev_bond++;
  2068. }
  2069. return 0;
  2070. }
  2072. static void __exit bonding_exit(void)
  2073. {
  2074. struct net_device *dev_bond = dev_bonds;
  2075. struct bonding *bond;
  2076. int no;
  2078. unregister_netdevice_notifier(&bond_netdev_notifier);
  2079.  
  2080. for (no = 0; no < max_bonds; no++) {
  2082. #ifdef CONFIG_PROC_FS
  2083. bond = (struct bonding *) dev_bond->priv;
  2084. remove_proc_entry("info", bond->bond_proc_dir);
  2085. remove_proc_entry(dev_bond->name, proc_net);
  2086. #endif
  2087. unregister_netdev(dev_bond);
  2088. kfree(bond->stats);
  2089. kfree(dev_bond->priv);
  2091. dev_bond->priv = NULL;
  2092. dev_bond++;
  2093. }
  2094. kfree(dev_bonds);
  2095. }
  2097. module_init(bonding_init);
  2098. module_exit(bonding_exit);
  2099. MODULE_LICENSE("GPL");
  2101. /*
  2102.  * Local variables:
  2103.  *  c-indent-level: 8
  2104.  *  c-basic-offset: 8
  2105.  *  tab-width: 8
  2106.  * End:
  2107.  */