网络子系统73_入口路由缓存查找

转：http://blog.csdn.net/nerdx/article/details/12911337

[cpp] view plaincopy

//  入口路由缓冲查找
//  返回值：
//      0，路由查找成功
//      -ENOBUFF，内存问题导致查找失败
//      -EINVAL，常规查找失败
//  hash值计算：
//      目的地址，源地址，入口设备index，tos进行hash
//  函数主要任务：
//      1.根据hash值遍历bucket
//      2.比较5元组
//      3.如果缓存命中，更新引用计数，绑定到skb->dst
//      4.否则，如果为本地多播地址，或者内核支持多播路由，多播路由中查找
//      5.否则，在路由表中查找

//  注：缓存确定5元组 = <目的地址，源地址，入口索引，出口索引=0，tos>
1.1 int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
           u8 tos, struct net_device *dev)
{
    struct rtable * rth;
    unsigned    hash;
    int iif = dev->ifindex;

    tos &= IPTOS_RT_MASK;
    hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos);

    rcu_read_lock();
    for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
         rth = rcu_dereference(rth->u.rt_next)) {
        if (rth->fl.fl4_dst == daddr &&
            rth->fl.fl4_src == saddr &&
            rth->fl.iif == iif &&
            //ofi=0，表示此路由为入口路由
            rth->fl.oif == 0 &&
            rth->fl.fl4_tos == tos) {
            rth->u.dst.lastuse = jiffies;
            dst_hold(&rth->u.dst);
            //引用计数
            rth->u.dst.__use++;
            //缓存命中次数
            RT_CACHE_STAT_INC(in_hit);
            rcu_read_unlock();
            //将路由缓存绑定到skb
            skb->dst = (struct dst_entry*)rth;
            return 0;
        }
        RT_CACHE_STAT_INC(in_hlist_search);
    }
    rcu_read_unlock();
    //目的地址为多播地址
    if (MULTICAST(daddr)) {
        struct in_device *in_dev;
        rcu_read_lock();
        //设备的ipv4配置信息
        if ((in_dev = __in_dev_get(dev)) != NULL) {
            int our = ip_check_mc(in_dev, daddr, saddr,
                skb->nh.iph->protocol);
            //本地配置的多播地址，或者内核支持多播路由
            if (our|| (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev)))
            {
                rcu_read_unlock();
                //多播路由
                return ip_route_input_mc(skb, daddr, saddr,
                             tos, dev, our);
            }
        }
        rcu_read_unlock();
        return -EINVAL;
    }
    //在路由表中查找
    return ip_route_input_slow(skb, daddr, saddr, tos, dev);
}

//  判断是否接收此ip多播
//      接收条件：
//          1.组播协议报文，接收
//          2.设备已加入此多播组
//              2.1 指定了源地址
//                  2.1.1 源地址在多播组的源地址链表
//                      2.1.1.1 源地址的包含计数!=0,或者源地址的排除计数!=多播组的排除计数，接收
//                  2.1.2 源地址不在多播组的源地址链表
//                      2.1.2.1 多播组的排斥计数!=0，接收
//              2.2 无源地址，默认接收
2.1 int ip_check_mc(struct in_device *in_dev, u32 mc_addr, u32 src_addr, u16 proto)
{
    struct ip_mc_list *im;
    struct ip_sf_list *psf;
    int rv = 0;

    read_lock(&in_dev->mc_list_lock);
    //设备的多播链表in_device->mc_list
    for (im=in_dev->mc_list; im; im=im->next) {
        if (im->multiaddr == mc_addr)
            break;
    }
    //组播协议，本地接收
    if (im && proto == IPPROTO_IGMP) {
        rv = 1;
    } else if (im) {
        //判断源地址是否在多播组中的源地址列表
        if (src_addr) {
            for (psf=im->sources; psf; psf=psf->sf_next) {
                if (psf->sf_inaddr == src_addr)
                    break;
            }
            //源地址在多播组源地址链表中
            if (psf)
            {
                //源地址接收计数>0，或者源地址排斥计数!=多播组排斥计数
                rv = psf->sf_count[MCAST_INCLUDE] ||
                    psf->sf_count[MCAST_EXCLUDE] !=
                    im->sfcount[MCAST_EXCLUDE];
            }
            else
            {
                //源地址不在多播组链表中，排斥计数!=0
                rv = im->sfcount[MCAST_EXCLUDE] != 0;
            }
        //没有指定源地址，默认接收
        } else
            rv = 1;
    }
    read_unlock(&in_dev->mc_list_lock);
    return rv;
}
//  路由入口多播地址
//      1.分配路由缓存
//      2.初始化路由缓存的ipv4搜索关键字
//      3.初始化路由缓存选项
//      4.初始化路由缓存输入，输出函数
//      5.插入到路由缓存hash表中

//  注：入口路由的出口设备索引=0，出口设备=回环设备
3.1 static int ip_route_input_mc(struct sk_buff *skb, u32 daddr, u32 saddr,
                u8 tos, struct net_device *dev, int our)
{
    unsigned hash;
    struct rtable *rth;
    u32 spec_dst;
    struct in_device *in_dev = in_dev_get(dev);
    u32 itag = 0;

    //分配路由缓存
    rth = dst_alloc(&ipv4_dst_ops);

    rth->u.dst.output = ip_rt_bug;//多播入口路由的输出函数
    atomic_set(&rth->u.dst.__refcnt, 1);//引用计数=1
    rth->u.dst.flags= DST_HOST;//DST_HOST，tcp使用标志，表示主机路由(即它不是到网络或到一个广播/多播地址的路由)
    if (in_dev->cnf.no_policy)
        rth->u.dst.flags |= DST_NOPOLICY;//DST_NOXFRM, DST_NOPOLICY, DST_NOHASH只用于IPsec

    rth->u.dst.dev   = &loopback_dev;//入口路由，使用回环设备作为其出口设备
    dev_hold(rth->u.dst.dev);//路由缓存关联到设备，增加设备的引用计数

    //路由项的搜索关键字
    rth->fl.fl4_dst  = daddr;
    rth->fl.fl4_tos  = tos;
    rth->fl.fl4_src  = saddr;
    rth->fl.iif  = dev->ifindex;
    rth->fl.oif  = 0;//入口路由的出口设备索引=0，表示为入口路由


    //目的，源ip地址
    rth->rt_dst  = daddr;
    rth->rt_src  = saddr;
    rth->rt_iif  = dev->ifindex;//入口设备索引
    rth->rt_gateway  = daddr;//下一跳网关初始化为目的地址
    rth->rt_spec_dst= spec_dst;//RFC 1122中指定的目的地址
    rth->rt_type = RTN_MULTICAST;//路由类型,间接定义了当路由查找匹配时应该采取的动作
    rth->rt_flags    = RTCF_MULTICAST;//表示路由的目的地址为多播地址
    rth->idev    = in_dev_get(rth->u.dst.dev);//使用入口设备的ipv4配置信息作为路由缓存的ipv4配置信息

    //本地配置的多播地址
    if (our) {
        rth->u.dst.input= ip_local_deliver;//向本地传递
        rth->rt_flags |= RTCF_LOCAL;//路由的目的地址为本地地址
    }

//内核支持多播路由
#ifdef CONFIG_IP_MROUTE
    //目标地址非组播地址
    //入口设备支持多播路由
    if (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
        rth->u.dst.input = ip_mr_input;
#endif

    in_dev_put(in_dev);
    hash = rt_hash_code(daddr, saddr ^ (dev->ifindex << 5), tos);
    //插入到路由缓存中
    return rt_intern_hash(hash, rth, (struct rtable**) &skb->dst);

}