Linux协议栈网桥部分之CAM表操作

网桥之cam表的操作
http://blog.sina.com.cn/s/blog_52355d840100arv8.html
http://blog.sina.com.cn/s/blog_52355d840100arv9.html
http://blog.csdn.net/linyt/article/details/5191512
http://blog.chinaunix.net/space.php?uid=24836818&do=blog&id=2562048
http://blog.chinaunix.net/space.php?uid=20543183&do=blog&frmd=29887&view=me

网桥之所以是网桥，主要靠这两个函数：
br_fdb_insert //学习，插入
br_fdb_get //查表

/*
* Forwarding database
* Linux ethernet bridge
*
* Authors:
* Lennert Buytenhek <buytenh@gnu.org>
*
* $Id: br_fdb.c,v 1.6 2002/01/17 00:57:07 davem Exp $
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/times.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/jhash.h>
#include <linux/random.h>
#include <asm/atomic.h>
#include <asm/unaligned.h>
#include "br_private.h"

//__read_mostly具体是一个宏，#define __read_mostly __attribute__((__section__(".data.read_mostly")))
//http://hi.baidu.com/xucha00/blog/item/e4b5c1245c75613bd5074246.html

static struct kmem_cache *br_fdb_cache __read_mostly;

static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
const unsigned char *addr);

static u32 fdb_salt __read_mostly;

//初始化，创建后备高速缓存
int __init br_fdb_init(void) 
{ 
//使用kmem_cache_create函数进行创建
br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
sizeof(struct net_bridge_fdb_entry),
0,
SLAB_HWCACHE_ALIGN, NULL);
if (!br_fdb_cache)
return -ENOMEM;
//随机数，调用了一个高强度的随机数发生器
get_random_bytes(&fdb_salt, sizeof(fdb_salt)); 
return 0;
}

//销毁，释放后备高速缓存
void br_fdb_fini(void)
{ 
//使用kmem_cache_destroy进行销毁
kmem_cache_destroy(br_fdb_cache);
}


/* 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;
}

//MAC 地址表项老化，返回1；否则返回0
static inline int has_expired(const struct net_bridge *br,
const struct net_bridge_fdb_entry *fdb)
{
return !fdb->is_static
&& time_before_eq(fdb->ageing_timer + hold_time(br), jiffies);
}

//算出mac的hash值,返回 MAC 地址的 Hash 值，用于随意对应的链表头
static inline int br_mac_hash(const unsigned char *mac)
{
/* use 1 byte of OUI cnd 3 bytes of NIC */
u32 key = get_unaligned((u32 *)(mac + 2));
return jhash_1word(key, fdb_salt) & (BR_HASH_SIZE - 1);
}

//删除某个对应值
static inline void fdb_delete(struct net_bridge_fdb_entry *f)
{
hlist_del_rcu(&f->hlist);
br_fdb_put(f);
}

/* 桥端口的 MAC 地址改变时，此函数被触发，br_notify.c: br_device_event()。
* 此函数插入新的 MAC 地址表项，删除或修改原 MAC 地址对应的表项。
* 此函数遍历整个 MAC 地址表，寻找桥端口对应的本地 MAC 地址表项。
* 如果存在该表项，当桥上还有其它端口具有原 MAC 地址，则更新表项，使此
* 表项属于其它端口（表项的 dst）。如果没有其它端口具有原 MAC
* 地址，则调用 fdb_delete() 删除该表项。
* br_fdb_put() 通过钩子调用相应的函数删除设备的硬件表项。
* 之后调用 fdb_insert() 插入新的本地静态 MAC 地址表项。
********************************************************************
* fdb_insert() 首先在 MAC 地址表中查找新 MAC 地址对应的表项。
* 如果存在对应的本地表项，什么也不做，函数返回。
* 如果存在非本地表项，则调用 fdb_delete() 删除该表项，并打印
* 错误信息（网络上可能有设备的 MAC 地址与新设定的
* 桥端口 MAC 地址相同，MAC地址表中存在非本地表项，
* 表示这可能是从收到的数据包中学习到的）。

br_fdb_put() 通过钩子删除设备的硬件表项。
* 之后调用 fdb_create() 创建并插入新的 MAC 地址表项，注意新表项
* 被设为本地静态表项。
* 同样，fdb_create() 此时通过钩子调用相应的函数创建设备的硬件表项。
********************************************************************
* /
//修改相关的mac地址
void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
{
struct net_bridge *br = p->br;
int i;

spin_lock_bh(&br->hash_lock);

/* Search all chains since old address/hash is unknown */
for (i = 0; i < BR_HASH_SIZE; i++) {
struct hlist_node *h;
hlist_for_each(h, &br->hash[i]) {
struct net_bridge_fdb_entry *f;

f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
if (f->dst == p && f->is_local) {
/* maybe another port has same hw addr? */
struct net_bridge_port *op;
list_for_each_entry(op, &br->port_list, list) {
if (op != p &&
!compare_ether_addr(op->dev->dev_addr,
f->addr.addr)) {
f->dst = op;
goto insert;
}
}

/* delete old one */
fdb_delete(f);
goto insert;
}
}
}
insert:
/* insert new address, may fail if invalid address or dup. */
fdb_insert(br, p, newaddr);

spin_unlock_bh(&br->hash_lock);
}


/* 此函数清理 MAC 地址表中的过时表项，重置有效表项。
* 此函数由内核定时器驱动，创建桥时将创建此定时器，net_bridge.gc_timer。
* 此函数被 EXPORT_SYMBOL(br_fdb_cleanup)。
* 此函数遍历整个 MAC 地址表，检查每个表项是否过期（静态表项永不过期）。
* 对于没有过期的表项，此函数不做任何处理。
* 对于过期表项，此函数通过钩子调用相应函数检查设备中的硬件表项是否有效。
* 如果有效，则重置该表项的老化时间（ageing_timer）。
* 如果无效，则调用 fdb_delete() 删除该表项。
* fdb_delete() 又调用 br_fdb_put() 做进一步处理。
* br_fdb_put() 通过钩子调用相应的函数删除设备的硬件表项。
* 并且检查该表项的引用计数，决定是否释放该表项。
* /
void br_fdb_cleanup(unsigned long _data)
{
struct net_bridge *br = (struct net_bridge *)_data;
unsigned long delay = hold_time(br);
unsigned long next_timer = jiffies + br->forward_delay;
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;

hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) {
unsigned long this_timer;
if (f->is_static)
continue;
this_timer = f->ageing_timer + delay;
if (time_before_eq(this_timer, jiffies))
fdb_delete(f);
else if (this_timer < next_timer)
next_timer = this_timer;
}
}
spin_unlock_bh(&br->hash_lock);

/* Add HZ/4 to ensure we round the jiffies upwards to be after the next
* timer, otherwise we might round down and will have no-op run. */
mod_timer(&br->gc_timer, round_jiffies(next_timer + HZ/4));
}

/* Completely flush all dynamic entries in forwarding database.*/
void br_fdb_flush(struct net_bridge *br)
{
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;
hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) {
if (!f->is_static)
fdb_delete(f);
}
}
spin_unlock_bh(&br->hash_lock);
}

/* Flush all entries refering to a specific port.
* if do_all is set also flush static entries
*/
void br_fdb_delete_by_port(struct net_bridge *br,
const struct net_bridge_port *p,
int do_all)
{
int i;

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

hlist_for_each_safe(h, g, &br->hash[i]) {
struct net_bridge_fdb_entry *f
= hlist_entry(h, struct net_bridge_fdb_entry, hlist);
if (f->dst != p)
continue;

if (f->is_static && !do_all)
continue;
/*
* if multiple ports all have the same device address
* then when one port is deleted, assign
* the local entry to other port
*/
if (f->is_local) {
struct net_bridge_port *op;
list_for_each_entry(op, &br->port_list, list) {
if (op != p &&
!compare_ether_addr(op->dev->dev_addr,
f->addr.addr)) {
f->dst = op;
goto skip_delete;
}
}
}

fdb_delete(f);
skip_delete: ;
}
}
spin_unlock_bh(&br->hash_lock);
}

/* No locking or refcounting, assumes caller has no preempt (rcu_read_lock) */
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;
//遍历net_bridge->hash
hlist_for_each_entry_rcu(fdb, h, &br->hash[br_mac_hash(addr)], hlist) {
//如果MAC地址和fdb中的地址相同并且fdb没有超时，
//就说明找到了相应的fdb
if (!compare_ether_addr(fdb->addr.addr, addr)) {
if (unlikely(has_expired(br, fdb)))
break;
return fdb;
}
}

return NULL;
}

/* Interface used by ATM hook that keeps a ref count */
struct net_bridge_fdb_entry *br_fdb_get(struct net_bridge *br,
unsigned char *addr)
{
struct net_bridge_fdb_entry *fdb;

rcu_read_lock();
fdb = __br_fdb_get(br, addr);
if (fdb && !atomic_inc_not_zero(&fdb->use_count))
fdb = NULL;
rcu_read_unlock();
return fdb;
}

//释放 MAC 地址表项，br.c: br_deinit() 中调用。
static void fdb_rcu_free(struct rcu_head *head)
{
struct net_bridge_fdb_entry *ent
= container_of(head, struct net_bridge_fdb_entry, rcu);
kmem_cache_free(br_fdb_cache, ent);
}

/* Set entry up for deletion with RCU */
void br_fdb_put(struct net_bridge_fdb_entry *ent)
{
if (atomic_dec_and_test(&ent->use_count))
call_rcu(&ent->rcu, fdb_rcu_free);
}

/*
* Fill buffer with forwarding table records in
* the API format.
*/
int br_fdb_fillbuf(struct net_bridge *br, void *buf,
unsigned long maxnum, unsigned long skip)
{
struct __fdb_entry *fe = buf;
int i, num = 0;
struct hlist_node *h;
struct net_bridge_fdb_entry *f;

memset(buf, 0, maxnum*sizeof(struct __fdb_entry));

rcu_read_lock();
for (i = 0; i < BR_HASH_SIZE; i++) {
hlist_for_each_entry_rcu(f, h, &br->hash[i], hlist) {
if (num >= maxnum)
goto out;

if (has_expired(br, f))
continue;

if (skip) {
--skip;
continue;
}

/* convert from internal format to API */
memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
fe->port_no = f->dst->port_no;
fe->is_local = f->is_local;
if (!f->is_static)
fe->ageing_timer_value = jiffies_to_clock_t(jiffies - f->ageing_timer);
++fe;
++num;
}
}

out:
rcu_read_unlock();

return num;
}

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;
}

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;
}
return fdb;
}

static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
const unsigned char *addr)
{
struct hlist_head *head = &br->hash[br_mac_hash(addr)];
struct net_bridge_fdb_entry *fdb;

//检查地址的有效性，这个地址不能是广播地址，也不能是
//为0的地址
if (!is_valid_ether_addr(addr))
return -EINVAL;
//从链表头开始查找需要插入的fdb已经存在
fdb = fdb_find(head, addr);
if (fdb) {
/* it is okay to have multiple ports with same
* address, just use the first one.
*/
//如果需要插入的是本机的MAC地址，则不需要更新
if (fdb->is_local)
return 0;

printk(KERN_WARNING "%s adding interface with same address "
"as a received packet\n",
source->dev->name);
//删除已经存在的表项，后面会创建新的表项用以替代
fdb_delete(fdb);
}
//创建新的fdb
if (!fdb_create(head, source, addr, 1))
return -ENOMEM;

return 0;
}

//实现插入CAM表的功能
int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
const unsigned char *addr)
{
int ret;

spin_lock_bh(&br->hash_lock); //该宏在得到自旋锁的同时失效本地软中断。http://www.ibm.com/developerworks/cn/linux/l-synch/part1/index.html
ret = fdb_insert(br, source, addr);
spin_unlock_bh(&br->hash_lock);
return ret;
}

/**
此函数首先调用 fdb_find() 在 MAC 地址表中查找对应的表项。
如已存在该表项，如果该表项为本地 MAC 地址表项，则打印警告信息，
"%s: received packet with own address as source address\n"
如前所述，桥不可能通过学习得到本地 MAC 地址（收到源 MAC 地址等于设
备自己的 MAC 地址的包是一个错误）。否则，刷新该表项，设置该表项中
的端口为本次接收到数据包的端口，重置老化时间（ageing_timer）。
对于我们的设备，此时通过钩子调用相应的函数刷新设备的硬件表项。
如不存在该表项，则调用 fdb_create() 创建并插入新的 MAC 地址表项，注意
新表项被设为非本地非静态表项。
同样，fdb_create() 此时通过钩子调用相应的函数创建设备的硬件表项。
**/

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;

/* ignore packets unless we are using this port */
if (!(source->state == BR_STATE_LEARNING ||
source->state == BR_STATE_FORWARDING))
return;

fdb = fdb_find(head, addr);
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 {
spin_lock(&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(&br->hash_lock);
}
}