免费注册 查看新帖 |

ChinaUnix.net

  平台 论坛 博客 文库
12345下一页
最近访问板块 发新帖
查看: 16477 | 回复: 47

Linux网桥源码框架分析初步 [复制链接]

论坛徽章:
0
发表于 2006-01-12 11:51 |显示全部楼层
[这篇贴子是边看代码边写的,其中有些比较凌乱,有些地方有错误,对于贴子的整理和改正,我会将其陆续贴于我的个人主页上边:http://www.skynet.org.cn/forumdisplay.php?fid=12&page=,希望大家指正。2006-2-12,大年十五]

今天处理网桥的STP的问题遇到了麻烦,对这个东东理论的倒是看了不少,没有真真学习到它的源理,来看Linux的实现,手头没有资料,看了两个钟头,只把网桥的框架结构看完,所以想先贴出来,希望有研究这块的大哥们讨论,继续把它写完,九贱好学习一下:

版本:Linux 2.4.18

一、调用
在src/net/core/dev.c的软中断函数static void net_rx_action(struct softirq_action *h)中:
line 1479

  1. #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
  2.                         if (skb->dev->br_port != NULL &&
  3.                             br_handle_frame_hook != NULL) {
  4.                                 handle_bridge(skb, pt_prev);
  5.                                 dev_put(rx_dev);
  6.                                 continue;
  7.                         }
  8. #endif
复制代码

如果定义了网桥或网桥模块,则由handle_bridge函数处理
skb->dev->br_port :接收该数据包的端口是网桥端口组的一员
br_handle_frame_hook :定义了网桥处理函数

二、初始化
src/net/bridge/br.c:

  1. static int __init br_init(void)
  2. {
  3.         printk(KERN_INFO "NET4: Ethernet Bridge 008 for NET4.0\n");

  4.         br_handle_frame_hook = br_handle_frame;
  5.         br_ioctl_hook = br_ioctl_deviceless_stub;
  6. #if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
  7.         br_fdb_get_hook = br_fdb_get;
  8.         br_fdb_put_hook = br_fdb_put;
  9. #endif
  10.         register_netdevice_notifier(&br_device_notifier);

  11.         return 0;
  12. }
复制代码

初始化函数指明了网桥的处理函数是br_handle_frame
ioctl处理函数是:br_ioctl_deviceless_stub

三、br_handle_frame(br_input.c)

  1. /*网桥处理函数*/
  2. void br_handle_frame(struct sk_buff *skb)
  3. {
  4.         struct net_bridge *br;
  5.         unsigned char *dest;
  6.         struct net_bridge_port *p;

  7.         /*获取目的MAC地址*/
  8.         dest = skb->mac.ethernet->h_dest;

  9.         /*skb->dev->br_port用于指定接收该数据包的端口,若不是属于网桥的端口,则为NULL*/
  10.         p = skb->dev->br_port;
  11.         if (p == NULL)                /*端口不是网桥组端口中*/
  12.                 goto err_nolock;

  13.         /*本端口所属的网桥组*/
  14.         br = p->br;
  15.        
  16.         /*加锁,因为在转发中需要读CAM表,所以必须加读锁,避免在这个过程中另外的内核控制路径(如多处理机上另外一个CPU上的系统调用)修改CAM表*/
  17.         read_lock(&br->lock);
  18.         if (skb->dev->br_port == NULL)                /*前面判断过的*/
  19.                 goto err;
  20.        
  21.         /*br->dev是网桥的虚拟网卡,如果它未UP,或网桥DISABLED,p->state实际上是桥的当前端口的STP计算判断后的状态*/
  22.         if (!(br->dev.flags & IFF_UP) ||
  23.             p->state == BR_STATE_DISABLED)
  24.                 goto err;
  25.        
  26.         /*源MAC地址为255.X.X.X,即源MAC是多播或广播,丢弃之*/
  27.         if (skb->mac.ethernet->h_source[0] & 1)
  28.                 goto err;

  29.         /*众所周之,网桥之所以是网桥,比HUB更智能,是因为它有一个MAC-PORT的表,这样转发数据就不用广播,而查表定端口就可以了
  30.         每次收到一个包,网桥都会学习其来源MAC,添加进这个表。Linux中这个表叫CAM表(这个名字是其它资料上看的)。
  31.         如果桥的状态是LEARNING或FORWARDING(学习或转发),则学习该包的源地址skb->mac.ethernet->h_source,
  32.         将其添加到CAM表中,如果已经存在于表中了,则更新定时器,br_fdb_insert完成了这一过程*/
  33.         if (p->state == BR_STATE_LEARNING ||
  34.             p->state == BR_STATE_FORWARDING)
  35.                 br_fdb_insert(br, p, skb->mac.ethernet->h_source, 0);
  36.        
  37.         /*STP协议的BPDU包的目的MAC采用的是多播目标MAC地址:从01-80-c2-00-00-00(Bridge_group_addr:网桥组多播地址)开始
  38.         所以这里是如果开启了STP,而当前数据包又是一个BPDU
  39.         (!memcmp(dest, bridge_ula, 5),        unsigned char bridge_ula[6] = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };),
  40.         则交由相应函数处理*/
  41.         if (br->stp_enabled &&
  42. /*这里只比较前5个字节,没有仔细研究过STP是使用了全部多播地址(从0 1 : 0 0 : 5 e : 0 0 : 0 0 : 0 0到0 1 : 0 0 : 5 e : 7 f : ff : ff。),还是只使用了一部份,这里看来似乎只是一部份,没去深究了*/
  43.             !memcmp(dest, bridge_ula, 5) &&
  44.             !(dest[5] & 0xF0))                /*01-80-c2-00-00-F0 是一个什么地址?为什么要判断呢?*/
  45.                 goto handle_special_frame;
  46.        
  47.         /*处理钩子函数,然后转交br_handle_frame_finish函数继续处理*/
  48.         if (p->state == BR_STATE_FORWARDING) {
  49.                 NF_HOOK(PF_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
  50.                         br_handle_frame_finish);
  51.                 read_unlock(&br->lock);
  52.                 return;
  53.         }

  54. err:
  55.         read_unlock(&br->lock);
  56. err_nolock:
  57.         kfree_skb(skb);
  58.         return;

  59. handle_special_frame:
  60.         if (!dest[5]) {
  61.                 br_stp_handle_bpdu(skb);
  62.                 return;
  63.         }

  64.         kfree_skb(skb);
  65. }
复制代码

四、br_handle_frame_finish

  1. static int br_handle_frame_finish(struct sk_buff *skb)
  2. {
  3.         struct net_bridge *br;
  4.         unsigned char *dest;
  5.         struct net_bridge_fdb_entry *dst;
  6.         struct net_bridge_port *p;
  7.         int passedup;

  8.         /*前面基本相同*/
  9.         dest = skb->mac.ethernet->h_dest;


  10.         p = skb->dev->br_port;
  11.         if (p == NULL)
  12.                 goto err_nolock;

  13.         br = p->br;
  14.         read_lock(&br->lock);
  15.         if (skb->dev->br_port == NULL)
  16.                 goto err;

  17.         passedup = 0;
  18.        
  19.         /*如果网桥的虚拟网卡处于混杂模式,那么每个接收到的数据包都需要克隆一份
  20.         送到AF_PACKET协议处理体(网络软中断函数net_rx_action中ptype_all链的处理)。*/
  21.         if (br->dev.flags & IFF_PROMISC) {
  22.                 struct sk_buff *skb2;

  23.                 skb2 = skb_clone(skb, GFP_ATOMIC);
  24.                 if (skb2 != NULL) {
  25.                         passedup = 1;
  26.                         br_pass_frame_up(br, skb2);
  27.                 }
  28.         }

  29.         /*目的MAC为广播或多播,则需要向本机的上层协议栈传送这个数据包,这里有一个标志变量passedup
  30.         用于表示是否传送过了,如果已传送过,那就算了*/
  31.         if (dest[0] & 1) {
  32.                 br_flood_forward(br, skb, !passedup);
  33.                 if (!passedup)
  34.                         br_pass_frame_up(br, skb);
  35.                 goto out;
  36.         }
  37.        
  38.         /*Linux中的MAC-PORT表是CAM表,这里根据目的地址来查表,以确定由哪个接口把包转发出去
  39.         每一个表项是通过结构struct net_bridge_fdb_entry来描述的:
  40.         struct net_bridge_fdb_entry
  41.         {
  42.                 struct net_bridge_fdb_entry        *next_hash;                //用于CAM表连接的链表指针
  43.                 struct net_bridge_fdb_entry        **pprev_hash;                //为什么是pprev不是prev呢?还没有仔细去研究
  44.                 atomic_t                        use_count;                //此项当前的引用计数器
  45.                 mac_addr                        addr;                        //MAC地址
  46.                 struct net_bridge_port                *dst;                        //此项所对应的物理端口
  47.                 unsigned long                        ageing_timer;                //处理MAC超时
  48.                 unsigned                        is_local:1;                //是否是本机的MAC地址
  49.                 unsigned                        is_static:1;                //是否是静态MAC地址
  50.         };*/
  51.         dst = br_fdb_get(br, dest);
  52.        
  53.         /*查询CAM表后,如果能够找到表项,并且目的MAC是到本机的虚拟网卡的,那么就需要把这个包提交给上层协议,
  54.         这样,我们就可以通过这个虚拟网卡的地址来远程管理网桥了*/
  55.         if (dst != NULL && dst->is_local) {
  56.                 if (!passedup)
  57.                         br_pass_frame_up(br, skb);
  58.                 else
  59.                         kfree_skb(skb);
  60.                 br_fdb_put(dst);
  61.                 goto out;
  62.         }
  63.        
  64.         /*查到表了,且不是本地虚拟网卡的,转发之*/
  65.         if (dst != NULL) {
  66.                 br_forward(dst->dst, skb);
  67.                 br_fdb_put(dst);
  68.                 goto out;
  69.         }

  70.         /*如果表里边查不到,那么只好学习学习HUB了……*/
  71.         br_flood_forward(br, skb, 0);

  72. out:
  73.         read_unlock(&br->lock);
  74.         return 0;

  75. err:
  76.         read_unlock(&br->lock);
  77. err_nolock:
  78.         kfree_skb(skb);
  79.         return 0;
  80. }
复制代码

基本框架就是这样了,与那些讲网桥原理的书上讲的基本差不多……
网桥之所以是网桥,主要靠这两个函数:
br_fdb_insert
br_fdb_get
一个学习,一个查表;
另外,支持STP,处理BPDU,需要用到函数br_stp_handle_bpdu
哪位有这三个函数的细节分析,可否送九贱一份,免得下午那么辛苦再去啃代码……

扫了一下 br_fdb_insert,结构还是很清析,如果当前项已存在于hash表项中,则更新它(__fdb_possibly_replace),如果是新项,则插入,实际是一个双向链表的维护过程(__hash_link):

  1. void br_fdb_insert(struct net_bridge *br,
  2.                    struct net_bridge_port *source,
  3.                    unsigned char *addr,
  4.                    int is_local)
  5. {
  6.         struct net_bridge_fdb_entry *fdb;
  7.         int hash;

  8.         hash = br_mac_hash(addr);

  9.         write_lock_bh(&br->hash_lock);
  10.         fdb = br->hash[hash];
  11.         while (fdb != NULL) {
  12.                 if (!fdb->is_local &&
  13.                     !memcmp(fdb->addr.addr, addr, ETH_ALEN)) {
  14.                         __fdb_possibly_replace(fdb, source, is_local);
  15.                         write_unlock_bh(&br->hash_lock);
  16.                         return;
  17.                 }

  18.                 fdb = fdb->next_hash;
  19.         }

  20.         fdb = kmalloc(sizeof(*fdb), GFP_ATOMIC);
  21.         if (fdb == NULL) {
  22.                 write_unlock_bh(&br->hash_lock);
  23.                 return;
  24.         }

  25.         memcpy(fdb->addr.addr, addr, ETH_ALEN);
  26.         atomic_set(&fdb->use_count, 1);
  27.         fdb->dst = source;
  28.         fdb->is_local = is_local;
  29.         fdb->is_static = is_local;
  30.         fdb->ageing_timer = jiffies;

  31.         __hash_link(br, fdb, hash);

  32.         write_unlock_bh(&br->hash_lock);
  33. }
复制代码

同样,查表也是一个遍历链表,进行地址匹配的过程:

  1. struct net_bridge_fdb_entry *br_fdb_get(struct net_bridge *br, unsigned char *addr)
  2. {
  3.         struct net_bridge_fdb_entry *fdb;

  4.         read_lock_bh(&br->hash_lock);
  5.         fdb = br->hash[br_mac_hash(addr)];
  6.         while (fdb != NULL) {
  7.                 if (!memcmp(fdb->addr.addr, addr, ETH_ALEN)) {
  8.                         if (!has_expired(br, fdb)) {
  9.                                 atomic_inc(&fdb->use_count);
  10.                                 read_unlock_bh(&br->hash_lock);
  11.                                 return fdb;
  12.                         }

  13.                         read_unlock_bh(&br->hash_lock);
  14.                         return NULL;
  15.                 }

  16.                 fdb = fdb->next_hash;
  17.         }

  18.         read_unlock_bh(&br->hash_lock);
  19.         return NULL;
  20. }
复制代码

[ 本帖最后由 platinum 于 2006-6-22 10:05 编辑 ]

论坛徽章:
0
发表于 2006-01-12 13:00 |显示全部楼层
继续,支持一把,大家看过以后,一定要顶一把,这样作者才可能把更精彩的内容给大家,否则,谁还愿意与大家分享知识,就这么一点要求,你们也不愿意????

论坛徽章:
0
发表于 2006-01-12 13:32 |显示全部楼层
原帖由 snow_insky 于 2006-1-12 13:00 发表
继续,支持一把,大家看过以后,一定要顶一把,这样作者才可能把更精彩的内容给大家,否则,谁还愿意与大家分享知识,就这么一点要求,你们也不愿意????


我没有更精彩的了内容了,只是本着处理我遇到问题的思路来看一个实现而已,发贴的目的是希望研究这块的牛人写出更精彩的文章,吾辈好学习一二……

又看了一个函数,继续发上来:
STP的处理函数

  1. /* called under bridge lock */
  2. void br_stp_handle_bpdu(struct sk_buff *skb)
  3. {
  4.         unsigned char *buf;
  5.         struct net_bridge_port *p;

  6.         /*跳过DLC首部*/
  7.         buf = skb->mac.raw + 14;
  8.         p = skb->dev->br_port;
  9.         /*再次做判断*/
  10.         if (!p->br->stp_enabled || memcmp(buf, header, 6)) {
  11.                 kfree_skb(skb);
  12.                 return;
  13.         }
  14.        
  15.         /*BPDU包有两类,由TYPE字段标志,分为配置和TCN(Topology Change Notification,拓朴改变通告)*/
  16.        
  17.         /*如果是配置类型*/
  18.         if (buf[6] == BPDU_TYPE_CONFIG) {
  19.                 /*内核中用struct br_config_bpdu描述一个BPDU包:
  20.                 struct br_config_bpdu
  21.                 {
  22.                         unsigned        topology_change:1;                //拓朴改变标志
  23.                         unsigned        topology_change_ack:1;                //拓朴改变回应标志
  24.                         bridge_id        root;                                //根ID,用于会聚后的网桥网络中,所有配置 BPDU 中的该字段都应该具有相同值(同VLAN),又可分为两个 BID 子字段:网桥优先级和网桥 MAC 地址
  25.                         int                root_path_cost;                        //路径开销,通向有根网桥(Root Bridge)的所有链路的积累资本
  26.                         bridge_id        bridge_id;                        //创建当前 BPDU 的网桥 BID。对于单交换机(单个 VLAN)发送的所有 BPDU 而言,该字段值都相同,而对于交换机与交换机之间发送的 BPDU 而言,该字段值不同)
  27.                         port_id                port_id;                        //端口ID,每个端口值都是唯一的。端口1/1值为0×8001,而端口1/2 值为0×8002。
  28.                         int                message_age;                        //记录 Root Bridge 生成当前 BPDU 起源信息的所消耗时间
  29.                         int                max_age;                        //保存 BPDU 的最长时间,也反映了拓朴变化通知(Topology Change Notification)过程中的网桥表生存时间情况
  30.                         int                hello_time;                        //指周期性配置 BPDU 间的时间
  31.                         int                forward_delay;                        //用于在 Listening 和 Learning 状态的时间,也反映了拓朴变化通知(Topology Change Notification)过程中的时间情况
  32.                 };
  33.                 在这个结构中,bpdu包的三个字段没有包含在内:
  34.                 Protocol ID ― 协议字段,恒为0。
  35.                 Version ― 版本字段,恒为0。
  36.                 Type ― 决定该帧中所包含的两种 BPDU 格式类型(配置 BPDU 或 TCN BPDU)。 上面用buf[6]直接访问了,这是
  37.                 因为bpdu之前,还有三个字节的LLC头,再加上ProtocolID(2字节),VersionID(1字节),3+2+1,所以是buf[6]
  38.                 这是标准的802.3封包方式,与以太网封包略有不同,参见《tcp/ip详解卷一》第二章的第二页的最上面那张图(记得是)
  39.                 */
  40.                
  41.                 struct br_config_bpdu bpdu;

  42.                 /*一个辛苦的解包过程……*/
  43.                 bpdu.topology_change = (buf[7] & 0x01) ? 1 : 0;
  44.                 bpdu.topology_change_ack = (buf[7] & 0x80) ? 1 : 0;
  45.                 bpdu.root.prio[0] = buf[8];
  46.                 bpdu.root.prio[1] = buf[9];
  47.                 bpdu.root.addr[0] = buf[10];
  48.                 bpdu.root.addr[1] = buf[11];
  49.                 bpdu.root.addr[2] = buf[12];
  50.                 bpdu.root.addr[3] = buf[13];
  51.                 bpdu.root.addr[4] = buf[14];
  52.                 bpdu.root.addr[5] = buf[15];
  53.                 bpdu.root_path_cost =
  54.                         (buf[16] << 24) |
  55.                         (buf[17] << 16) |
  56.                         (buf[18] << 8) |
  57.                         buf[19];
  58.                 bpdu.bridge_id.prio[0] = buf[20];
  59.                 bpdu.bridge_id.prio[1] = buf[21];
  60.                 bpdu.bridge_id.addr[0] = buf[22];
  61.                 bpdu.bridge_id.addr[1] = buf[23];
  62.                 bpdu.bridge_id.addr[2] = buf[24];
  63.                 bpdu.bridge_id.addr[3] = buf[25];
  64.                 bpdu.bridge_id.addr[4] = buf[26];
  65.                 bpdu.bridge_id.addr[5] = buf[27];
  66.                 bpdu.port_id = (buf[28] << 8) | buf[29];

  67.                 bpdu.message_age = br_get_ticks(buf+30);
  68.                 bpdu.max_age = br_get_ticks(buf+32);
  69.                 bpdu.hello_time = br_get_ticks(buf+34);
  70.                 bpdu.forward_delay = br_get_ticks(buf+36);

  71.                 kfree_skb(skb);
  72.                 br_received_config_bpdu(p, &bpdu);                /*调用配置函数*/
  73.                 return;
  74.         }

  75.         /*如果是TCN类型*/
  76.         if (buf[6] == BPDU_TYPE_TCN) {
  77.                 br_received_tcn_bpdu(p);                        /*调用TCN函数*/
  78.                 kfree_skb(skb);
  79.                 return;
  80.         }
  81.         kfree_skb(skb);
  82. }
复制代码

[ 本帖最后由 platinum 于 2006-6-22 10:06 编辑 ]

论坛徽章:
0
发表于 2006-01-12 13:59 |显示全部楼层
to独孤九贱:
请教个问题,有什么简单的方式可以获得当前系统的arp与ip地址的对应表和路由表?

论坛徽章:
0
发表于 2006-01-12 14:12 |显示全部楼层
原帖由 guotie 于 2006-1-12 13:59 发表
to独孤九贱:
请教个问题,有什么简单的方式可以获得当前系统的arp与ip地址的对应表和路由表?


我分析网桥中提到的MAC地址表与arp表是两个概念,完全不同。

“获得当前系统的arp与ip地址的对应表和路由表”读proc就OK了,参见nettools或busybox的源码……
不过最简单的方式还是system(……)

论坛徽章:
0
发表于 2006-01-12 14:32 |显示全部楼层
hehe,这是用户空间的工具,如果在内核里需要知道arp表呢

论坛徽章:
0
发表于 2006-01-12 14:41 |显示全部楼层
原帖由 guotie 于 2006-1-12 14:32 发表
hehe,这是用户空间的工具,如果在内核里需要知道arp表呢

sorry,我以为是用户空间……内核里我还没有仔细去看呢……

论坛徽章:
0
发表于 2006-01-12 15:08 |显示全部楼层
详细的STP协议就不在这里贴了,RFC有现成的。
继续来分析config BPDU:

还是先来大概说说STP的运作流程:
STP需要确定root bridge,root port,designate port,
所以,需要在确定之间进行判断,判断的原则是:
1. 最小的root BID(所有交换机中有最小BID的成为root bridge)
2. 最小的到root bridge路径开销(确定root port)
3. 最小的发送BID(确定指向端口)
4. 最小的端口ID(如果其他标准都相同,根据端口ID确定选择标准,较小的优先)
所以,网桥需要在每收到一个BPDU包的时候,将包中的这些值,与自己原先保存的值相对比,对应的函数是:
br_supersedes_port_info

在确定好这些值后,就需要根据这些值进行选举root bridge,root port,designate port,
运作流程是:
1. 选择root bridge,选举范围是整个网络,选择的流程是交换机相互交换BPDU,
        选择依据是根据BID判断谁的BID比较小(优先级小,桥MAC小)
2. 选择root port,选举范围是每个nonbridge的和其他交换机相连的端口之间(同一个交换机上的连接其他交换机的端口)
        选择依据是path cost较小,每个nonbridge一个root port,可以收发数据。
3. 选择designate port,选择范围是连接每个网段之间的端口(端口在不同交换机上)
        选择依据也是path cost较小,如果相同,进一步比较BID,designate port每个网段一个,可以收发数据。
4. 通过上述选择,没有成为任何角色的端口称作nondesignate port,端口设置为block状态,可以接收数据,但不转发数据。

前面三步是选择的过程,对应函数是br_configuration_update,
第四步是根据选举后的结果,决定端口的状态,对应的函数是:br_port_state_selection
开启STP的交换机端口可能处于5种状态:
1. Block:阻断状态,接收但不转发数据。
2. Listening:侦听状态,不转发数据,可以收发BPDU,执行选举root bridge,root port,designate port等动作。
3. Learning:学习状态,不转发数据,开始学习MAC,为数据转发作准备
4. Forward:转发状态,转发数据。
5. Disable:禁用状态,既不参与STP计算,也不转发数据。
在进行选举之前,需要先用传送过来的BPUD中的相关值,更新自己对应的相关值,对应的函数是:br_record_config_information

对应源码:
/* lock-safe */
void br_received_config_bpdu(struct net_bridge_port *p, struct br_config_bpdu *bpdu)
{
        struct net_bridge *br;
        int was_root;

        if (p->state == BR_STATE_DISABLED)
                return;

        br = p->br;
        read_lock(&br->lock);

        was_root = br_is_root_bridge(br);
        if (br_supersedes_port_info(p, bpdu)) {
                br_record_config_information(p, bpdu);
                br_configuration_update(br);
                br_port_state_selection(br);

                if (!br_is_root_bridge(br) && was_root) {
                        br_timer_clear(&br->hello_timer);
                        if (br->topology_change_detected) {
                                br_timer_clear(&br->topology_change_timer);
                                br_transmit_tcn(br);
                                br_timer_set(&br->tcn_timer, jiffies);
                        }
                }

                                /*这个判断的作用不是太明白,盼指点……*/
                if (p->port_no == br->root_port) {
                        br_record_config_timeout_values(br, bpdu);
                        br_config_bpdu_generation(br);
                        if (bpdu->topology_change_ack)
                                br_topology_change_acknowledged(br);
                }
        }
                /*如果当前端口是designate port,则根据当前配置信息,生成BPDU,发送出去*/
                else if (br_is_designated_port(p)) {               
                br_reply(p);               
        }

        read_unlock(&br->lock);
}
br_is_designated_port函数的是看当前桥是否就是指定的根桥,并且当前port 是否就是designate port:
/* called under bridge lock */
int br_is_designated_port(struct net_bridge_port *p)
{
        return !memcmp(&p->designated_bridge, &p->br->bridge_id, 8) &&
                (p->designated_port == p->port_id);
}
br_reply就是一个提取前前的信息,组包发包的过程。


br_supersedes_port_info这个判断,就是把包中的值,同先前指定的对应值进行判断和比较,经确定是否需要更新:
/* called under bridge lock */
static int br_supersedes_port_info(struct net_bridge_port *p, struct br_config_bpdu *bpdu)
{
        int t;

        t = memcmp(&bpdu->root, &p->designated_root, 8);
        if (t < 0)
                return 1;
        else if (t > 0)
                return 0;

        if (bpdu->root_path_cost < p->designated_cost)
                return 1;
        else if (bpdu->root_path_cost > p->designated_cost)
                return 0;

        t = memcmp(&bpdu->bridge_id, &p->designated_bridge, 8);
        if (t < 0)
                return 1;
        else if (t > 0)
                return 0;

        if (memcmp(&bpdu->bridge_id, &p->br->bridge_id, 8))
                return 1;

        if (bpdu->port_id <= p->designated_port)
                return 1;

        return 0;
}

在进行更新之前,先把包中对应的值拷过来:
/* called under bridge lock */
static void br_record_config_information(struct net_bridge_port *p, struct br_config_bpdu *bpdu)
{
        p->designated_root = bpdu->root;
        p->designated_cost = bpdu->root_path_cost;
        p->designated_bridge = bpdu->bridge_id;
        p->designated_port = bpdu->port_id;

        br_timer_set(&p->message_age_timer, jiffies - bpdu->message_age);
}

然后就是进行STP的选举,它们对应的协议的含义前面已经叙述了:
/* called under bridge lock */
void br_configuration_update(struct net_bridge *br)
{
        br_root_selection(br);
        br_designated_port_selection(br);
}

接着设置端口的状态:
/* called under bridge lock */
void br_port_state_selection(struct net_bridge *br)
{
        struct net_bridge_port *p;

        p = br->port_list;
        while (p != NULL) {
                if (p->state != BR_STATE_DISABLED) {
                        if (p->port_no == br->root_port) {
                                p->config_pending = 0;
                                p->topology_change_ack = 0;
                                br_make_forwarding(p);
                        } else if (br_is_designated_port(p)) {
                                br_timer_clear(&p->message_age_timer);
                                br_make_forwarding(p);
                        } else {
                                p->config_pending = 0;
                                p->topology_change_ack = 0;
                                br_make_blocking(p);
                        }
                }

                p = p->next;
        }
}

如果原来自己是根桥,现在不是了,即拓朴已改变,需要发送一个TCN类型的BPDU包,通告更新(另外有一种情况就是自己原来不是根,现在变成了根,在前面br_configuration_update函数调用中,会有类似的处理):
                if (!br_is_root_bridge(br) && was_root) {
                        br_timer_clear(&br->hello_timer);
                        if (br->topology_change_detected) {
                                br_timer_clear(&br->topology_change_timer);
                                br_transmit_tcn(br);
                                br_timer_set(&br->tcn_timer, jiffies);
                        }
                }

后面那个判断不是很明白,盼指点一下……

[ 本帖最后由 独孤九贱 于 2006-1-13 10:36 编辑 ]

论坛徽章:
0
发表于 2006-01-12 15:28 |显示全部楼层
九贱大侠,最近也在看这个,主要做的工作就是linux下的网桥,以前实现过一个没有生成树的也无操作系统的简单网桥。不过现在有几个弱智的问题,望解答一下:

/*获取目的MAC地址*/dest = skb->mac.ethernet->h_dest

这条语句,我判断skb应该是收到的帧,但是是放在缓冲区里的吗?

这句话应该是获取了帧的目的MAC地址,然后为什么会在生成树那条语句
if (br->stp_enabled &&
            !memcmp(dest, bridge_ula, 5) &&
            !(dest[5] & 0xF0))                /*01-80-c2-00-F0-00 是一个什么地址?为什么要判断呢?*/
                goto handle_special_frame;
就是目的MAC地址的高4位应该为0?为什么有这个要求?
还有01-80-c2-00-F0-00 是一个什么地址?这也是你没有找出答案的地方?
难道通过这个来判断是否是BPDU,不太明白

还有就是系统是如何调用网桥处理函数br_handle_frame(struct sk_buff *skb)的呢?

论坛徽章:
0
发表于 2006-01-12 15:35 |显示全部楼层
原帖由 Pagliuca 于 2006-1-12 15:28 发表
九贱大侠,最近也在看这个,主要做的工作就是linux下的网桥,以前实现过一个没有生成树的也无操作系统的简单网桥。不过现在有几个弱智的问题,望解答一下:

/*获取目的MAC地址*/dest = skb->mac.ethernet- ...

凑巧,因为处理一个工程问题,被STP难住了,今天上午才来看看这个协议的实现,也是初学者,不是大虾,以后大家一起讨论:

1、第一个问题,二层拆包后的结构是放在skb中的啊……
2、就是目的MAC地址的高4位应该为0?为什么有这个要求?
这个是什么意思?不明白你的意思,不过STP协议中,目的MAC,都是使用的多播目标MAC地址:01-80-c2-00-00-00(Bridge_group_addr:网桥组多播地址)
3、程序判断!(dest[5] & 0xF0)) ,我翻了RFC文档,google了一下,没有找到为何要做此判断,正在查资料中……
4、函数的调用,我一开始就说了吧……

[ 本帖最后由 独孤九贱 于 2006-1-12 15:37 编辑 ]
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

基于案例的 SQL 优化实战训练营

讲师:中电福富特级专家梁敬彬,参与本次课程培训,你将收获:
1. 能编写出较为高效的 SQL;
2. 能解决70%以上的数据库常见优化问题;
3. 能得到老师提供的高效的相关工具和解决方案;
4. 能举一反三,收获不仅仅是 SQL 优化。
现在购票享受8.8折优惠!
----------------------------------------
优惠时间:2019年3月20日前

大会官网>>
  

北京盛拓优讯信息技术有限公司. 版权所有 16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122
中国互联网协会会员  联系我们:huangweiwei@it168.com
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP