FreeBSD/Linux Kernel Cross Reference
sys/drivers/net/bonding/bonding.h

     /*
      * Bond several ethernet interfaces into a Cisco, running 'Etherchannel'.
      *
      * Portions are (c) Copyright 1995 Simon "Guru Aleph-Null" Janes
      * NCM: Network and Communications Management, Inc.
      *
      * BUT, I'm the one who modified it for ethernet, so:
      * (c) Copyright 1999, Thomas Davis, tadavis@lbl.gov
      *
     *      This software may be used and distributed according to the terms
     *      of the GNU Public License, incorporated herein by reference.
     * 
     *
     * 2003/03/18 - Amir Noam <amir.noam at intel dot com>,
     *              Tsippy Mendelson <tsippy.mendelson at intel dot com> and
     *              Shmulik Hen <shmulik.hen at intel dot com>
     *      - Added support for IEEE 802.3ad Dynamic link aggregation mode.
     *
     * 2003/05/01 - Tsippy Mendelson <tsippy.mendelson at intel dot com> and
     *              Amir Noam <amir.noam at intel dot com>
     *      - Code beautification and style changes (mainly in comments).
     *
     * 2003/05/01 - Shmulik Hen <shmulik.hen at intel dot com>
     *      - Added support for Transmit load balancing mode.
     */
     
    #ifndef _LINUX_BONDING_H
    #define _LINUX_BONDING_H
    
    #include <linux/timer.h>
    #include <linux/proc_fs.h>
    #include "bond_3ad.h"
    #include "bond_alb.h"
    
    #ifdef BONDING_DEBUG
    
    // use this like so: BOND_PRINT_DBG(("foo = %d, bar = %d", foo, bar));
    #define BOND_PRINT_DBG(X)                                     \
    do {                                                          \
            printk(KERN_DEBUG "%s (%d)", __FUNCTION__, __LINE__); \
            printk X;                                             \
            printk("\n");                                         \
    } while(0)
    
    #else
    #define BOND_PRINT_DBG(X)
    #endif /* BONDING_DEBUG */
    
    #define IS_UP(dev)  ((((dev)->flags & (IFF_UP)) == (IFF_UP)) && \
                         (netif_running(dev) && netif_carrier_ok(dev)))
    
    /* Checks whether the dev is ready for transmit. We do not check netif_running
     * since a device can be stopped by the driver for short periods of time for
     * maintainance. dev_queue_xmit() handles this by queing the packet until the
     * the dev is running again. Keeping packets ordering requires sticking the
     * same dev as much as possible
     */
    #define SLAVE_IS_OK(slave) \
                         ((((slave)->dev->flags & (IFF_UP)) == (IFF_UP)) && \
                         netif_carrier_ok((slave)->dev) && \
                         ((slave)->link == BOND_LINK_UP) && \
                         ((slave)->state == BOND_STATE_ACTIVE))
    
    
    typedef struct slave {
            struct slave *next;
            struct slave *prev;
            struct net_device *dev;
            short  delay;
            unsigned long jiffies;
            char   link;    /* one of BOND_LINK_XXXX */
            char   state;   /* one of BOND_STATE_XXXX */
            unsigned short original_flags;
            u32 link_failure_count;
            u16    speed;
            u8     duplex;
            u8     perm_hwaddr[ETH_ALEN];
            struct ad_slave_info ad_info; /* HUGE - better to dynamically alloc */
            struct tlb_slave_info tlb_info;
    } slave_t;
    
    /*
     * Here are the locking policies for the two bonding locks:
     *
     * 1) Get bond->lock when reading/writing slave list.
     * 2) Get bond->ptrlock when reading/writing bond->current_slave.
     *    (It is unnecessary when the write-lock is put with bond->lock.)
     * 3) When we lock with bond->ptrlock, we must lock with bond->lock
     *    beforehand.
     */
    typedef struct bonding {
            slave_t *next;
            slave_t *prev;
            slave_t *current_slave;
            slave_t *primary_slave;
            slave_t *current_arp_slave;
            __s32 slave_cnt;
            rwlock_t lock;
            rwlock_t ptrlock;
           struct timer_list mii_timer;
           struct timer_list arp_timer;
           struct net_device_stats *stats;
   #ifdef CONFIG_PROC_FS
           struct proc_dir_entry *bond_proc_dir;
           struct proc_dir_entry *bond_proc_info_file;
   #endif /* CONFIG_PROC_FS */
           struct bonding *next_bond;
           struct net_device *device;
           struct dev_mc_list *mc_list;
           unsigned short flags;
           struct ad_bond_info ad_info;
           struct alb_bond_info alb_info;
   } bonding_t;
   
   /* Forward declarations */
   void bond_set_slave_active_flags(slave_t *slave);
   void bond_set_slave_inactive_flags(slave_t *slave);
   
   /**
    * These functions can be used for iterating the slave list
    * (which is circular)
    * Caller must hold bond lock for read
    */
   extern inline struct slave*
   bond_get_first_slave(struct bonding *bond)
   {
           /* if there are no slaves return NULL */
           if (bond->next == (slave_t *)bond) {
                   return NULL;
           }
           return bond->next;
   }
   
   /**
    * Caller must hold bond lock for read
    */
   extern inline struct slave*
   bond_get_next_slave(struct bonding *bond, struct slave *slave)
   {
           /* If we have reached the last slave return NULL */
           if (slave->next == bond->next) {
                   return NULL;
           }
           return slave->next;
   }
   
   /**
    * Returns NULL if the net_device does not belong to any of the bond's slaves
    *
    * Caller must hold bond lock for read
    */
   extern inline struct slave*
   bond_get_slave_by_dev(struct bonding *bond, struct net_device *slave_dev)
   {
           struct slave *our_slave = bond->next;
   
           /* check if the list of slaves is empty */
           if (our_slave == (slave_t *)bond) {
                   return NULL;
           }
   
           for (; our_slave; our_slave = bond_get_next_slave(bond, our_slave)) {
                   if (our_slave->dev == slave_dev) {
                           break;
                   }
           }
           return our_slave;
   }
   
   extern inline struct bonding*
   bond_get_bond_by_slave(struct slave *slave)
   {
           if (!slave || !slave->dev->master) {
                   return NULL;
           }
   
           return (struct bonding *)(slave->dev->master->priv);
   }
   
   #endif /* _LINUX_BONDING_H */
   

Cache object: 9245570fa2dece02bff3d90d22c0fb02