ip_route_output_flow

[ip_route_output_flow]

struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4, struct sock *sk)
{
    struct rtable *rt = __ip_route_output_key(net, flp4);
    return rt;
}

[ip_route_output_flow->__ip_route_output_key]

struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
{
    __u8 tos = RT_FL_TOS(fl4);  // tos
    struct fib_result res;  // 查找结果
    int orig_oif;

    res.tclassid    = 0;
    res.fi      = NULL; // fib_info 
    res.table   = NULL; // fib_table 

    orig_oif = fl4->flowi4_oif; // 输出设备ID

    fl4->flowi4_iif = LOOPBACK_IFINDEX; // 输入设备ID设为环回接口
    fl4->flowi4_tos = tos & IPTOS_RT_MASK;
    fl4->flowi4_scope = ((tos & RTO_ONLINK) ?  RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);

在路由表中找查的结果会放在res当中，res.fi指向fib_info，res.table指向fib_table，保存fl4的输出设备ID，将fl4的输入设备设为环回接口，根据tos设置fls的scope，RT_SCOPE_LINK为局域网；RT_SCOPE_UNIVERSE表示没有直接相连的路由，使用下一站路由（next hop gateway）。下面看源地址不为0的情况：

    if (fl4->saddr) {
        if (ipv4_is_multicast(fl4->saddr) ||
            ipv4_is_lbcast(fl4->saddr) ||
             ipv4_is_zeronet(fl4->saddr))
            goto out;

当源地址为多播地址，广播地址，全0时，直接返回。

        if (fl4->flowi4_oif == 0 &&
            (ipv4_is_multicast(fl4->daddr) || ipv4_is_lbcast(fl4->daddr))) {
            dev_out = __ip_dev_find(net, fl4->saddr, false);
            if (dev_out == NULL)
                goto out;

当输出设备ID为0并且目标地址为多播地址或广播地址时，查找与源地址绑定的设备，如果没找到，返回
[ip_route_output_flow->__ip_route_output_key->__ip_dev_find]

struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
{
    u32 hash = inet_addr_hash(net, addr);   // 地址的哈希值
    hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
        if (ifa->ifa_local == addr) {
            struct net_device *dev = ifa->ifa_dev->dev;
             if (!net_eq(dev_net(dev), net))
                continue;
            result = dev;
            break;
        }
    }

inet_addr_lst是一个哈希表：static struct hlist_head inet_addr_lst[256]; 里面保存的列表项类型为in_ifaddr，表示一个地址。先计算地址的哈希值，然后开始查找。如果地址相同，并且设备的网络名字空间也相同，成功找到。

    if (!result) {
        struct flowi4 fl4 = { .daddr = addr };
        struct fib_table *local;
        local = fib_get_table(net, RT_TABLE_LOCAL); // 得到本地路由表
                if (local &&
            !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) && res.type == RTN_LOCAL)
            result = FIB_RES_DEV(res);
    }

    return result;
} 

如果没找到，在本地路由表中查找与addr匹配的项，结果放在res中。如果找到并且类型为RTN_LOCAL时，得到设备。
[ip_route_output_flow->__ip_route_output_key->__ip_dev_find->fib_table_lookup]

int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp, struct fib_result *res, int fib_flags)
{
    struct trie *t = (struct trie *) tb->tb_data;   // 根节点
    t_key key = ntohl(flp->daddr);  // 地址作为key
    struct rt_trie_node *n;
    n = rcu_dereference(t->trie);   // 字典树节点
    if (!n)
        goto failed;

路由表被组织为一棵树，tb->tb_data指向根节点，查找的key是地址，从第一个子节点开始查找：

    /* Just a leaf? */
    if (IS_LEAF(n)) {
        ret = check_leaf(tb, t, (struct leaf *)n, key, flp, res, fib_flags);
        goto found;
    }

如果第一个子节点是一个叶子，说明整个树只有一个叶子，只要查找它就可以了：
[ip_route_output_flow->__ip_route_output_key->__ip_dev_find->fib_table_lookup->check_leaf]

static int check_leaf(struct fib_table *tb, struct trie *t, struct leaf *l,
              t_key key,  const struct flowi4 *flp,
              struct fib_result *res, int fib_flags)
{
    struct leaf_info *li;
    struct hlist_head *hhead = &l->list;
    hlist_for_each_entry_rcu(li, hhead, hlist) {
        struct fib_alias *fa;

        if (l->key != (key & li->mask_plen))
            continue;

每个叶子中都有一个leaf_info列表。先找到key相同的项

        list_for_each_entry_rcu(fa, &li->falh, fa_list) {
            struct fib_info *fi = fa->fa_info;
            int nhsel, err;

            if (fa->fa_tos && fa->fa_tos != flp->flowi4_tos)
                continue;
            if (fi->fib_dead)
                continue;
            if (fa->fa_info->fib_scope < flp->flowi4_scope)
                continue;

            if (!(fa->fa_state & FA_S_ACCESSED))
                    fa->fa_state |= FA_S_ACCESSED;

一个地址有可能有多个路由，li->falh指向一个路由列表。要从中选出一个满足条件的。它们的tos要相同，fib_dead为false，路由的scope要匹配。这些条件都满足后，设置fa的状态为FA_S_ACCESSED

            err = fib_props[fa->fa_type].error;
            if (err) {
                return err;
            }
            if (fi->fib_flags & RTNH_F_DEAD)
                continue;

fib_props是一个全局数组，它对不同的路由类型定义了一个错误值，如：RTN_UNREACHABLE的error值为-EHOSTUNREACH。如果路由的状态不正确，直接返回。还要检查路由的flags不能为RTNH_F_DEAD（Nexthop is dead）

            for (nhsel = 0; nhsel < fi->fib_nhs; nhsel++) {
                const struct fib_nh *nh = &fi->fib_nh[nhsel];

                if (nh->nh_flags & RTNH_F_DEAD)
                    continue;
                if (flp->flowi4_oif && flp->flowi4_oif != nh->nh_oif)
                    continue;
                res->prefixlen = li->plen;
                res->nh_sel = nhsel;
                res->type = fa->fa_type;
                res->scope = fa->fa_info->fib_scope;
                res->fi = fi;
                res->table = tb;
                res->fa_head = &li->falh;
                if (!(fib_flags & FIB_LOOKUP_NOREF))
                    atomic_inc(&fi->fib_clntref);
                return 0;
            }
        }
    }

    return 1;
}

下一站路由地址会cache在fi->fib_nh中，此数组的大小为fi->fib_nhs。如果flp设置了输出设备，要与下一站地址的相同。然后设置返回值，返回0表示成功。
[ip_route_output_flow->__ip_route_output_key->__ip_dev_find->fib_table_lookup]

    // 是一个根节点
    pn = (struct tnode *) n;
    chopped_off = 0;

    while (pn) {
        pos = pn->pos;
        bits = pn->bits;

        if (!chopped_off)
            cindex = tkey_extract_bits(mask_pfx(key, current_prefix_length), pos, bits);

        n = tnode_get_child_rcu(pn, cindex);    // 得到子树
        if (n == NULL) {
            goto backtrace;
        }

如果有多个叶子，就要通过循环来查找了。通过计算key，得到子树索引，并得到子树

        if (IS_LEAF(n)) {
            ret = check_leaf(tb, t, (struct leaf *)n, key, flp, res, fib_flags);
            if (ret > 0)
                goto backtrace;
            goto found;
        }
        cn = (struct tnode *)n;

如果是叶子，在当中查找。

        if (current_prefix_length < pos+bits) {
            if (tkey_extract_bits(cn->key, current_prefix_length, 
                                cn->pos - current_prefix_length) || !(cn->child[0]))
                goto backtrace;
        }
        pref_mismatch = mask_pfx(cn->key ^ key, cn->pos);
        if (pref_mismatch) {
            /* fls(x) = __fls(x) + 1 */
            int mp = KEYLENGTH - __fls(pref_mismatch) - 1;

            if (tkey_extract_bits(cn->key, mp, cn->pos - mp) != 0)
                goto backtrace;

            if (current_prefix_length >= cn->pos)
                current_prefix_length = mp;
        }

        pn = (struct tnode *)n; /* Descend */
        chopped_off = 0;
        continue;
backtrace:
        chopped_off++;

        /* As zero don't change the child key (cindex) */
        while ((chopped_off <= pn->bits)
               && !(cindex & (1<<(chopped_off-1))))
            chopped_off++;

        /* Decrease current_... with bits chopped off */
        if (current_prefix_length > pn->pos + pn->bits - chopped_off)
            current_prefix_length = pn->pos + pn->bits
                - chopped_off;

        /*
         * Either we do the actual chop off according or if we have
         * chopped off all bits in this tnode walk up to our parent.
         */

        if (chopped_off <= pn->bits) {
            cindex &= ~(1 << (chopped_off-1));
        } else {
            struct tnode *parent = node_parent_rcu((struct rt_trie_node *) pn);
            if (!parent)
                goto failed;

            /* Get Child's index */
            cindex = tkey_extract_bits(pn->key, parent->pos, parent->bits);
            pn = parent;
            chopped_off = 0;
            goto backtrace;
        }
    }
failed:
    ret = 1;
found:
    return ret;
}

通过一系列计算得到下一个叶子。如果成功找到就返回0。
[ip_route_output_flow->__ip_route_output_key]

            if (dev_out == NULL)
                goto out;

            fl4->flowi4_oif = dev_out->ifindex; // 设置输出设备的ID
            goto make_route;
        }

如果输出设备没找到，出错返回。此时输出设备为与在路由表中与源地址对应的设备。转到make_route

        if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
            if (!__ip_dev_find(net, fl4->saddr, false))
                goto out;
        }
    }

总结下，当源地址不为0时，如果是多播地址或广播地址，直接返回。如果目标地址是多播地址或广播地址并且输出设备ID为0，通过源地址在路由表中去找设备，如果找到，转到make_route处。然后如果没有设置FLOWI_FLAG_ANYSRC，调用__ip_dev_find查找，如果没找到，出错返回。到这里，要么是源地址为0，要么源地址不为0并且通过源地址找到了输出设备。下面来看对目标地址的处理：

    if (fl4->flowi4_oif) {  // 输出设备ID不为0
        dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);   // 从ID得到设备
        if (dev_out == NULL)
            goto out;

        /* RACE: Check return value of inet_select_addr instead. 
         */
        if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
            goto out;
        }
        /* 本地多播
         * 广播
         */
        if (ipv4_is_local_multicast(fl4->daddr) ||
            ipv4_is_lbcast(fl4->daddr)) {
            if (!fl4->saddr)    // 源地址不为0
                fl4->saddr = inet_select_addr(dev_out, 0, RT_SCOPE_LINK); 
            goto make_route;
        }
        if (!fl4->saddr) {// 源地址为0
            if (ipv4_is_multicast(fl4->daddr)) // 多播
                fl4->saddr = inet_select_addr(dev_out, 0, fl4->flowi4_scope);
            else if (!fl4->daddr) // 目标地址为0
                fl4->saddr = inet_select_addr(dev_out, 0, RT_SCOPE_HOST);
        }
    }

如果输出设备不为0，先从ID得到设备，如果设备没有有被激活或因为竞争关系无法得到设备，出错。扣果目标地址为本地多播或广播，转到make_route，此时如果源地址不为0，将其设置为scope为RT_SCOPE_LINK的地址。再判断如果源地址为0，目的地址为多播，将其设置为scope为fl4->flowi4_scope的地址；目的地址为0，将其设置为scope为RT_SCOPE_HOST的地址。
[ip_route_output_flow->__ip_route_output_key->inet_select_addr]

__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
{
    __be32 addr = 0;
    struct in_device *in_dev;
    in_dev = __in_dev_get_rcu(dev); // 设备
    if (!in_dev)
        goto no_in_dev;

    for_primary_ifa(in_dev) {   // 设备的所有primary地址
        if (ifa->ifa_scope > scope) // 地址的范围大于参数传进来的
            continue;
        /* 目标地址为空
         * 与目标地址相同
         */
        if (!dst || inet_ifa_match(dst, ifa)) {
            addr = ifa->ifa_local;  // 得到地址
            break;
        }
        if (!addr)  // 如果没设地址初始化addr
            addr = ifa->ifa_local;
    } endfor_ifa(in_dev);
    if (addr)
        goto out_unlock;    

得到设备，在设备的primary地址列表中查找。地址的scope要大于要求的，如果目标地址为0或与列表中的地址匹配，就找到了。如果上面条件不符合，就选择列表中的第一个地址。如果找到，就返回了。

no_in_dev:
    /* Not loopback addresses on loopback should be preferred
       in this case. It is importnat that lo is the first interface
       in dev_base list.
     */
    for_each_netdev_rcu(net, dev) { // 所有网络设备
        in_dev = __in_dev_get_rcu(dev); // 设备
        if (!in_dev)
            continue;

        for_primary_ifa(in_dev) {   // 设备的所有primary地址
            if (ifa->ifa_scope != RT_SCOPE_LINK &&
                ifa->ifa_scope <= scope) {
                addr = ifa->ifa_local;  // 得到地址
                goto out_unlock;
            }
        } endfor_ifa(in_dev);
    }
out_unlock:
    return addr;
}

如果没找到，在同一个网络名字空间的所有设备上查找。设备不能为空，然后在每个设备的primary地址列表中查找scope不大于目标地址并不等于RT_SCOPE_LINK的地址。
[ip_route_output_flow->__ip_route_output_key]

    if (!fl4->daddr) {  
        fl4->daddr = fl4->saddr;    // 目标地址设为源地址
        if (!fl4->daddr)    // 目标地址为0
            fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
        dev_out = net->loopback_dev;    // 输出设备设为环回接口
        fl4->flowi4_oif = LOOPBACK_IFINDEX; // 输出设备ID设为环回接口
        res.type = RTN_LOCAL;   // 本机地址
        flags |= RTCF_LOCAL;    // 本机地址
        goto make_route;
    }

目标地址为0的情况。先把目标地址设为源地址，如果两者都为0，都设为环回地址。输出设备设为环回接口，地址类型设为本机地址。转到make_route。

    if (fib_lookup(net, fl4, &res)) {   // 路由表中查找

[ip_route_output_flow->__ip_route_output_key->fib_lookup]

static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
                 struct fib_result *res)
{
    struct fib_table *table;

    table = fib_get_table(net, RT_TABLE_LOCAL);
    if (!fib_table_lookup(table, flp, res, FIB_LOOKUP_NOREF))
        return 0;

    table = fib_get_table(net, RT_TABLE_MAIN);
    if (!fib_table_lookup(table, flp, res, FIB_LOOKUP_NOREF))
        return 0;
    return -ENETUNREACH;
}

在本地路由表和main路由表中分别查找。
[ip_route_output_flow->__ip_route_output_key]

        res.fi = NULL;
        res.table = NULL;
        if (fl4->flowi4_oif) {  // 输出设备ID不为0
            if (fl4->saddr == 0)    // 源地址为0
                fl4->saddr = inet_select_addr(dev_out, 0, RT_SCOPE_LINK);
            res.type = RTN_UNICAST; /* Gateway or direct route  */
            goto make_route;
        }
        goto out;
    }

没有找到的情况：如果输出设备不为0，结果设为前往默认路由，此时如果源地址为0，设为scope为RT_SCOPE_LINK的本机地址，然后转向make_route。如果输出设备为0，直接返回。

    if (res.type == RTN_LOCAL) {    // 本机地址
        if (!fl4->saddr) {  // 源地址为0
            if (res.fi->fib_prefsrc)
                fl4->saddr = res.fi->fib_prefsrc;// 源IP地址
            else
                fl4->saddr = fl4->daddr;    // 源地址设为目标地址
        }
        dev_out = net->loopback_dev;    // 环回接口
        fl4->flowi4_oif = dev_out->ifindex; // 输出设备 ID
        flags |= RTCF_LOCAL;    // 本机地址
        goto make_route;
    }

如果是本机地址，输出设备设为环回接口，fl4的输出设备号设为其输入设备号；此时如果源地址为0，如果结果设置了fib_prefsrc，将其设为源地址，否则设为目标地址。转到make_route。

    if (!res.prefixlen &&
        res.table->tb_num_default > 1 &&
        res.type == RTN_UNICAST && !fl4->flowi4_oif)
        fib_select_default(&res);   // 默认路由

如果路由表长度为0，并且路由表tb_num_default > 1并且路由指向gateway，并且输出设备为0，选择默认路由
[ip_route_output_flow->__ip_route_output_key->fib_select_default]

void fib_select_default(struct fib_result *res)
{
    struct fib_info *fi = NULL, *last_resort = NULL;
    struct list_head *fa_head = res->fa_head;
    struct fib_table *tb = res->table;
    int order = -1, last_idx = -1;
    struct fib_alias *fa;

有可能多个路由项指向同一个目标地址，而这些路由仅仅是因为TOS不同。这些不同的路由项放在fa_head中

    list_for_each_entry_rcu(fa, fa_head, fa_list) {
        struct fib_info *next_fi = fa->fa_info;

        if (next_fi->fib_scope != res->scope ||
            fa->fa_type != RTN_UNICAST)
            continue;

        if (next_fi->fib_priority > res->fi->fib_priority)
            break;
        if (!next_fi->fib_nh[0].nh_gw ||
            next_fi->fib_nh[0].nh_scope != RT_SCOPE_LINK)
            continue;

        fib_alias_accessed(fa);

在fa_head列表中查找，scope不同或类型不是RTN_UNICAST的跳过；优先级大的，结束查找，因为列表是按照优先级来排序的；下上站路由的gateway为0或scope不为RT_SCOPE_LINK的跳过。

    if (fi == NULL) {
            if (next_fi != res->fi)
                break;
        } else if (!fib_detect_death(fi, order, &last_resort,
                         &last_idx, tb->tb_default)) {
            fib_result_assign(res, fi);
            tb->tb_default = order;
            goto out;
        }
        fi = next_fi;
        order++;
    }

第一次循环时如果它们指向的fib_info不同（目标地址不同），结束查找。
[ip_route_output_flow->__ip_route_output_key->fib_select_default->fib_detect_death]

static int fib_detect_death(struct fib_info *fi, int order,
                struct fib_info **last_resort, int *last_idx,
                int dflt)
{
    struct neighbour *n;
    int state = NUD_NONE;

    n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
    if (n) {
        state = n->nud_state;
        neigh_release(n);
    }

arp_tbl主要用来缓冲ARP地址，这里来查找下一站地址。找到后，设备状态state
[ip_route_output_flow->__ip_route_output_key->fib_select_default->fib_detect_death->neigh_lookup]

struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
                   struct net_device *dev)
{
    struct neighbour *n;
    int key_len = tbl->key_len; // 地址长度
    u32 hash_val;
    struct neigh_hash_table *nht;

    NEIGH_CACHE_STAT_INC(tbl, lookups);

    rcu_read_lock_bh();
    nht = rcu_dereference_bh(tbl->nht); // neighbour对象的哈希表
    hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);

计算出pkey的哈希值，这里的tbl为arp_table

for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);   // 哈希表子表
         n != NULL;
         n = rcu_dereference_bh(n->next)) {
        if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {  // 设备和KEY都相同
            if (!atomic_inc_not_zero(&n->refcnt))   // 增加引用计数
                n = NULL;
            NEIGH_CACHE_STAT_INC(tbl, hits);    // 记录状态
            break;
        }
    }

    rcu_read_unlock_bh();
    return n;
}

在哈希表中查找。
[ip_route_output_flow->__ip_route_output_key->fib_select_default->fib_detect_death]

    if (state == NUD_REACHABLE)
        return 0;
    if ((state & NUD_VALID) && order != dflt)
        return 0;
    if ((state & NUD_VALID) ||
        (*last_idx < 0 && order > dflt)) {
        *last_resort = fi;
        *last_idx = order;
    }
    return 1;
}

NUD_REACHABLE表示处在连接状态；

    if (!fl4->saddr)    // 源地址为0
        fl4->saddr = FIB_RES_PREFSRC(net, res);

    dev_out = FIB_RES_DEV(res);
    fl4->flowi4_oif = dev_out->ifindex; // 输出设备ID

如果源地址为0，如果结果设置了fib_prefsrc，将其设为源地址，否则设为目标地址。

make_route:
    rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);    // 新增路由缓冲

out:
    rcu_read_unlock();
    return rth;
}

把结果放入缓冲中。