static int __init br_init(void)
{
    br_fdb_init(); //网桥数据库初始化，分配slab缓冲区

#ifdef CONFIG_BRIDGE_NETFILTER
    if (br_netfilter_init()) //netfilter钩子初始化
        return 1;
#endif


    brioctl_set(br_ioctl_deviceless_stub); //设置ioctl钩子函数:br_ioctl_hook
    br_handle_frame_hook = br_handle_frame;//设置报文处理钩子:br_ioctl_hook

    //网桥数据库处理钩子
    br_fdb_get_hook = br_fdb_get;
    br_fdb_put_hook = br_fdb_put;

    //在netdev_chain通知链表上注册
    register_netdevice_notifier(&br_device_notifier);

    return 0;
}

int br_ioctl_deviceless_stub(unsigned int cmd, void __user *uarg)
{
    switch (cmd) {
    case SIOCGIFBR:
    case SIOCSIFBR:
        return old_deviceless(uarg);
        
    case SIOCBRADDBR: //新建网桥
    case SIOCBRDELBR: //删除网桥
    {
        char buf[IFNAMSIZ];

        if (!capable(CAP_NET_ADMIN))
            return -EPERM;
            
        //copy_from_user:把用户空间的数据拷入内核空间
        if (copy_from_user(buf, uarg, IFNAMSIZ))
            return -EFAULT;

        buf[IFNAMSIZ-1] = 0;
        if (cmd == SIOCBRADDBR)
            return br_add_bridge(buf);

        return br_del_bridge(buf);
    }
    }
    return -EOPNOTSUPP;
}

int br_add_bridge(const char *name)
{
    struct net_device *dev;
    int ret;
    
    //为虚拟桥新建一个net_device
    dev = new_bridge_dev(name);
    if (!dev)
        return -ENOMEM;

    rtnl_lock();
    //由内核确定接口名字，例如eth0 eth1等
    if (strchr(dev->name, '%')) {
        ret = dev_alloc_name(dev, dev->name);
        if (ret < 0)
            goto err1;
    }

    //向内核注册此网络设备
    ret = register_netdevice(dev);
    if (ret)
        goto err2;

    /* network device kobject is not setup until
     * after rtnl_unlock does it's hotplug magic.
     * so hold reference to avoid race.
     */
    dev_hold(dev);
    rtnl_unlock();
    
    //在sysfs中建立相关信息
    ret = br_sysfs_addbr(dev);
    dev_put(dev);
    if (ret)
        unregister_netdev(dev);

 out:
    return ret;

 err2:
    free_netdev(dev);
 err1:
    rtnl_unlock();
    goto out;
}

static struct net_device *new_bridge_dev(const char *name)
{
    struct net_bridge *br;
    struct net_device *dev;

    //分配net_device
    dev = alloc_netdev(sizeof(struct net_bridge), name,
             br_dev_setup);  
    if (!dev)
        return NULL;

    //网桥的私区结构为net_bridge
    br = netdev_priv(dev);

    //私区结构中的dev字段指向设备本身
    br->dev = dev;

    //队列初始化。在port_list中保存了这个桥上的端口列表
    spin_lock_init(&br->lock); 
    INIT_LIST_HEAD(&br->port_list);
    spin_lock_init(&br->hash_lock);

    //下面这部份代码跟stp协议相关,我们暂不关心

    br->bridge_id.prio[0] = 0x80;
    br->bridge_id.prio[1] = 0x00;
    memset(br->bridge_id.addr, 0, ETH_ALEN);

    br->stp_enabled = 0;
    br->designated_root = br->bridge_id;
    br->root_path_cost = 0;
    br->root_port = 0;
    br->bridge_max_age = br->max_age = 20 * HZ;
    br->bridge_hello_time = br->hello_time = 2 * HZ;
    br->bridge_forward_delay = br->forward_delay = 15 * HZ;
    br->topology_change = 0;
    br->topology_change_detected = 0;
    br->ageing_time = 300 * HZ;
    INIT_LIST_HEAD(&br->age_list);

    br_stp_timer_init(br);

    return dev;
}

void br_dev_setup(struct net_device *dev)
{
    //将桥的MAC地址设为零
    memset(dev->dev_addr, 0, ETH_ALEN);

    //初始化dev的部分函数指针，因为目前网桥设备主适用于以及网,
    //以太网的部分功能对它也适用
    ether_setup(dev);
    
    //设置设备的ioctl函数为br_dev_ioctl
    dev->do_ioctl = br_dev_ioctl;

    //网桥与一般网卡不同，网桥统一统计它的数据包和字节数等信息
    dev->get_stats = br_dev_get_stats;

    // 网桥接口的数据包发送函数,真实设备要向外发送数据时,是通过网卡向外发送数据 
    // 而该网桥设备要向外发送数据时，它的处理逻辑与网桥其它接口的基本一致。 
    dev->hard_start_xmit = br_dev_xmit;
    dev->open = br_dev_open;
    dev->set_multicast_list = br_dev_set_multicast_list;
    dev->change_mtu = br_change_mtu;
    dev->destructor = free_netdev;
    SET_MODULE_OWNER(dev);
    dev->stop = br_dev_stop;
    dev->tx_queue_len = 0;
    dev->set_mac_address = NULL;
    dev->priv_flags = IFF_EBRIDGE;
}

int br_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
    struct net_bridge *br = netdev_priv(dev);

    switch(cmd) {
    case SIOCDEVPRIVATE:
        return old_dev_ioctl(dev, rq, cmd);

    case SIOCBRADDIF: //添加
    case SIOCBRDELIF: //删除

        //同一处理函数，默认为添加
        return add_del_if(br, rq->ifr_ifindex, cmd == SIOCBRADDIF);
    }

    pr_debug("Bridge does not support ioctl 0x%x\n", cmd);
    return -EOPNOTSUPP;
}

static int add_del_if(struct net_bridge *br, int ifindex, int isadd)
{
    struct net_device *dev;
    int ret;

    if (!capable(CAP_NET_ADMIN))
        return -EPERM;

    dev = dev_get_by_index(ifindex);
    if (dev == NULL)
        return -EINVAL;
    
    if (isadd)
        ret = br_add_if(br, dev);
    else
        ret = br_del_if(br, dev);

    dev_put(dev);
    return ret;
}

int br_add_if(struct net_bridge *br, struct net_device *dev)
{
    struct net_bridge_port *p;
    int err = 0;

    /*--Kernel仅支持以太网网桥--*/
    if (dev->flags & IFF_LOOPBACK || dev->type != ARPHRD_ETHER)
        return -EINVAL;

    /*--把网桥接口当作物理接口加入到另一个网桥中，是不行的,逻辑和代码上都会出现 loop--*/
    if (dev->hard_start_xmit == br_dev_xmit)
        return -ELOOP;

    /*--该物理接口已经绑定到另一个网桥了--*/
    if (dev->br_port != NULL)
        return -EBUSY;

    /*--为该接口创建一个网桥端口数据，并初始化好该端口的相关数据--*/
    if (IS_ERR(p = new_nbp(br, dev, br_initial_port_cost(dev))))
        return PTR_ERR(p);
        
    /*--将该接口的物理地址写入到 MAC-端口映射表中，该MAC是属于网桥内部端口的固定MAC地址，
        它在fdb中的记录是固定的，不会失效（agged）--*/
     if ((err = br_fdb_insert(br, p, dev->dev_addr)))
        destroy_nbp(p);


     /*--添加相应的系统文件信息--*/
    else if ((err = br_sysfs_addif(p)))
        del_nbp(p);
    else {
        /*--打开该接口的混杂模式，网桥中的各个端口必须处于混杂模式，网桥才能正确工作--*/
        dev_set_promiscuity(dev, 1);
        
        /*--加到端口列表--*/
        list_add_rcu(&p->list, &br->port_list);

        /*--STP相关设置-*/
        spin_lock_bh(&br->lock);
        br_stp_recalculate_bridge_id(br);
        br_features_recompute(br);
        if ((br->dev->flags & IFF_UP)
         && (dev->flags & IFF_UP) && netif_carrier_ok(dev))
            br_stp_enable_port(p);
        spin_unlock_bh(&br->lock);
        
        /*--设置设备的mtu--*/
        dev_set_mtu(br->dev, br_min_mtu(br));
    }

    return err;
}

int br_del_if(struct net_bridge *br, struct net_device *dev)
{
    struct net_bridge_port *p = dev->br_port;
    
    if (!p || p->br != br)
        return -EINVAL;

    br_sysfs_removeif(p);
    del_nbp(p);

    spin_lock_bh(&br->lock);
    br_stp_recalculate_bridge_id(br);
    br_features_recompute(br);
    spin_unlock_bh(&br->lock);

    return 0;
}

struct net_bridge
{
    spinlock_t            lock; //读写锁

    //网桥所有端口的链表,其中每个元素都是一个net_bridge_port结构
    struct list_head        port_list;
    struct net_device        *dev; //网桥对应的设备

    struct net_device_stats        statistics; //网桥对应的虚拟网卡的统计数据

    spinlock_t            hash_lock; //hash表的锁

    /*--CAM: 保存forwarding database的一个hash链表(这个也就是地址学习的东东,
    所以通过hash能 快速定位),这里每个元素都是一个net_bridge_fsb_entry结构--*/
    struct hlist_head        hash[BR_HASH_SIZE];
    struct list_head        age_list;

    /* STP */ //与stp 协议对应的数据
    bridge_id            designated_root;
    bridge_id            bridge_id;
    u32                  root_path_cost;
    unsigned long            max_age;
    unsigned long            hello_time;
    unsigned long            forward_delay;
    unsigned long            bridge_max_age;
    unsigned long            ageing_time;
    unsigned long            bridge_hello_time;
    unsigned long            bridge_forward_delay;

    u16                root_port;
    unsigned char            stp_enabled;
    unsigned char            topology_change;
    unsigned char            topology_change_detected;


    //stp要用的一些定时器列表。
    struct timer_list        hello_timer;
    struct timer_list        tcn_timer;
    struct timer_list        topology_change_timer;
    struct timer_list        gc_timer;
    struct kobject            ifobj;
}

struct net_bridge_port
{
    struct net_bridge        *br; //从属于的网桥设备

    struct net_device        *dev;//表示链接到这个端口的物理设备

    struct list_head        list;

    /* STP */ //stp相关的一些参数。
    u8                priority;
    u8                state;
    u16                port_no; //本端口在网桥中的编号

    unsigned char            topology_change_ack;
    unsigned char            config_pending;
    port_id                port_id;
    port_id                designated_port;
    bridge_id            designated_root;
    bridge_id            designated_bridge;
    u32                path_cost;
    u32                designated_cost;


    //端口定时器，也就是stp控制超时的一些定时器列表
    struct timer_list        forward_delay_timer;
    struct timer_list        hold_timer;
    struct timer_list        message_age_timer;
    struct kobject            kobj;
    struct rcu_head            rcu;
}

struct net_bridge_fdb_entry
{
    struct hlist_node        hlist;
    //桥的端口(最主要的两个域就是这个域和下面的mac地址域) 
    struct net_bridge_port *dst;
    
    struct rcu_head            rcu; //当使用RCU策略，才用到
   
    atomic_t                use_count; //引用计数

    unsigned long            ageing_timer; //MAC超时时间

    mac_addr                addr; //mac地址。    
 
    unsigned char            is_local; //是否为本机的MAC地址

    unsigned char            is_static; //是否为静态MAC地址

}

void __init br_fdb_init(void)
{
    br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
                     sizeof(struct net_bridge_fdb_entry),
                     0,
                     SLAB_HWCACHE_ALIGN, NULL, NULL);
}

void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
         const unsigned char *addr)
{
    /*--br_mac_hash函数是hash表中的hash函数，具体算法过程可参阅该函数代码;
        br->hash就是数据库的hash表，每个hash值对应一个链表;
        数据库的每项为net_bridge_fdb_entry结构--*/
    struct hlist_head *head = &br->hash[br_mac_hash(addr)];
    struct net_bridge_fdb_entry *fdb;

    /* some users want to always flood. */
    if (hold_time(br) == 0)
        return;

    rcu_read_lock();
    fdb = fdb_find(head, addr);


    /*--如果找到对应的fdb，更新fdb->dst，fdb->ageing_timer--*/
    if (likely(fdb)) {
        /* attempt to update an entry for a local interface */
        if (unlikely(fdb->is_local)) {
            if (net_ratelimit())
                printk(KERN_WARNING "%s: received packet with "
                 " own address as source address\n",
                 source->dev->name);
        } else {
            /* fastpath: update of existing entry */
            fdb->dst = source;
            fdb->ageing_timer = jiffies;
        }
    } else { /*--没有找到，则新建一个fdb--*/
        spin_lock_bh(&br->hash_lock);
        if (!fdb_find(head, addr))
            fdb_create(head, source, addr, 0);
        /* else we lose race and someone else inserts
         * it first, don't bother updating
         */
        spin_unlock_bh(&br->hash_lock);
    }
    rcu_read_unlock();
}

static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
                     struct net_bridge_port *source,
                     const unsigned char *addr,
                     int is_local)
{
    struct net_bridge_fdb_entry *fdb;

    /*--申请数据区--*/
    fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
    if (fdb) {
        memcpy(fdb->addr.addr, addr, ETH_ALEN);
        atomic_set(&fdb->use_count, 1);
        hlist_add_head_rcu(&fdb->hlist, head); /*--添加到链表--*/

        fdb->dst = source;
        fdb->is_local = is_local;
        fdb->is_static = is_local;
        fdb->ageing_timer = jiffies; //MAC年龄
    }
    return fdb;
}

static inline struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
                         const unsigned char *addr)
{
    struct hlist_node *h;
    struct net_bridge_fdb_entry *fdb;

    /*--遍历链表比较地址--*/
    hlist_for_each_entry_rcu(fdb, h, head, hlist) {
        if (!compare_ether_addr(fdb->addr.addr, addr))
            return fdb;
    }
    return NULL;
}

struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
                     const unsigned char *addr)
{
    struct hlist_node *h;
    struct net_bridge_fdb_entry *fdb;

    /*--遍历链表比较地址--*/
    hlist_for_each_entry_rcu(fdb, h, &br->hash[br_mac_hash(addr)], hlist) {
        if (!compare_ether_addr(fdb->addr.addr, addr)) {
            /*--判断是否过期--*/
            if (unlikely(has_expired(br, fdb)))
                break;
            return fdb;
        }
    }

    return NULL;
}

/*--数据项的可保留时间根据拓扑结构是否改变来决定，改变则为forward_delay，否则为ageing_time--*/
/* if topology_changing then use forward_delay (default 15 sec)
 * otherwise keep longer (default 5 minutes)
 */
static __inline__ unsigned long hold_time(const struct net_bridge *br)
{
    return br->topology_change ? br->forward_delay : br->ageing_time;
}

static __inline__ int has_expired(const struct net_bridge *br,
                 const struct net_bridge_fdb_entry *fdb)
{
    /*--1. 如果该数据项是静态的，即不是学习过来的，它永远不会过期。
         因为它就是网桥自己端口的地址
        2. 如果最近更新时间加上可保留时间大于当前时间，即老化时间还在以后，
         表示尚未过期，time_before_eq返回真，否则返回假
    --*/
    return !fdb->is_static
        && time_before_eq(fdb->ageing_timer + hold_time(br), jiffies);
}

/*--定时器循环检查MAC地址是否过期,定时器在桥初始化中定义开启--*/
void br_fdb_cleanup(unsigned long _data)
{
    struct net_bridge *br = (struct net_bridge *)_data;
    unsigned long delay = hold_time(br);/*--获取MAC地址可保留时间--*/
    int i;

    spin_lock_bh(&br->hash_lock);
    for (i = 0; i < BR_HASH_SIZE; i++) {
        struct net_bridge_fdb_entry *f;
        struct hlist_node *h, *n;

        /*--如果该地址不是静态的，并且已经过期，则从数据库中清除该MAC映射--*/
        hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) {
            if (!f->is_static &&
             time_before_eq(f->ageing_timer + delay, jiffies))
                fdb_delete(f);
        }
    }
    spin_unlock_bh(&br->hash_lock);
    
    /*--更新检查定时器--*/
    mod_timer(&br->gc_timer, jiffies + HZ/10);
}