linux网络协议栈源码分析 - 网络层IP网际协议
Posted arm7star
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了linux网络协议栈源码分析 - 网络层IP网际协议相关的知识，希望对你有一定的参考价值。
1、IP报文
1.1、IP报文格式
更详细的介绍参考《TCP/IP详解卷 1：协议》第3章 IP：网际协议。
1.2、IP首部结构体
struct iphdr
#if defined(__LITTLE_ENDIAN_BITFIELD)
__u8 ihl:4,
version:4;
#elif defined (__BIG_ENDIAN_BITFIELD)
__u8 version:4,
ihl:4;
#else
#error "Please fix <asm/byteorder.h>"
#endif
__u8 tos;
__be16 tot_len;
__be16 id;
__be16 frag_off;
__u8 ttl;
__u8 protocol;
__sum16 check;
__be32 saddr;
__be32 daddr;
/*The options start here. */
;
3位标志位:
/* IP flags. */
#define IP_CE 0x8000 /* Flag: "Congestion" */
#define IP_DF 0x4000 /* Flag: "Don't Fragment" */
#define IP_MF 0x2000 /* Flag: "More Fragments" */
#define IP_OFFSET 0x1FFF /* "Fragment Offset" part */
2、IP路由缓存查找
(参考资料《Linux Kernel Networking - Implementation and Theory》、机械工业出版社《Linux内核源码剖析：TCP/IP实现(上册)》)
2.1、输出路由缓存查询(ip_route_output_key)
__ip_route_output_key_hash返回路由rtable，rtable里面包含路由缓存项dst_entry，对于输出路由，主要用到了路由及路由缓存项的输出函数指针output、网卡设备net_device、网关rt_gateway，__ip_route_output_key_hash调用栈:
dst_output调用路由缓存的输出函数指针output，然后调用ip_output、ip_finish_output、ip_finish_output2，ip_finish_output2找到路由缓的下一跳(网关或者局域网内的其他主机)，然后调用邻居子系统的dst_neigh_output发送报文，ip_finish_output2邻居查找及报文发送代码实现如下:
ip_finish_output2函数调用栈如下:
2.2、输入路由缓存查询(ip_route_input/ip_route_input_noref)
ip_route_input_slow调用skb_dst_set_noref设置skb的路由缓存，路由缓存dst包含一个输入函数指针，最终调用该输入函数处理输入报文:
ip_route_input_slow调用栈:
查找到路由缓存之后，调用dst_input函数，dst_input函数调用路由缓存的input函数处理报文，dst_input调用栈:
3、IP报文输出
3.1、IP报文发送(ip_queue_xmit)
ip_queue_xmit主要检查skb是否已经设置路由，如果没有就查找路由，如果找不到路由就丢弃报文；有路由就设置IP首部(IP首部的16位总长度、16位首部检验和在下一级函数设置)，调用ip_local_out、rt->dst.output输出IP报文。
ip_queue_xmit代码实现如下:
int ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
struct inet_sock *inet = inet_sk(sk);
struct net *net = sock_net(sk);
struct ip_options_rcu *inet_opt;
struct flowi4 *fl4;
struct rtable *rt;
struct iphdr *iph;
int res;
/* Skip all of this if the packet is already routed,
* f.e. by something like SCTP.
*/
rcu_read_lock();
inet_opt = rcu_dereference(inet->inet_opt);
fl4 = &fl->u.ip4;
rt = skb_rtable(skb); // skb路由项(输出网卡设备、下一跳地址等)
if (rt)
goto packet_routed; // 如果已经有路由，那么跳转到packet_routed，使用已经设置好的路由
/* Make sure we can route this packet. */
rt = (struct rtable *)__sk_dst_check(sk, 0); // 获取路由项缓存sk_dst_cache
if (!rt)
__be32 daddr;
/* Use correct destination address if we have options. */
daddr = inet->inet_daddr;
if (inet_opt && inet_opt->opt.srr)
daddr = inet_opt->opt.faddr;
/* If this fails, retransmit mechanism of transport layer will
* keep trying until route appears or the connection times
* itself out.
*/
rt = ip_route_output_ports(net, fl4, sk,
daddr, inet->inet_saddr,
inet->inet_dport,
inet->inet_sport,
sk->sk_protocol,
RT_CONN_FLAGS(sk),
sk->sk_bound_dev_if); // 调用ip_route_output_ports、ip_route_output_flow查询输出路由缓存；参考机械工业出版社《Linux内核源码剖析：TCP IP实现(下册)》"第20章 路由缓存"
if (IS_ERR(rt))
goto no_route; // 没有路由则跳转到no_route，丢弃报文
sk_setup_caps(sk, &rt->dst);
skb_dst_set_noref(skb, &rt->dst); // 设置skb->_skb_refdst
packet_routed:
if (inet_opt && inet_opt->opt.is_strictroute && rt->rt_uses_gateway)
goto no_route;
/* OK, we know where to send it, allocate and build IP header. */
skb_push(skb, sizeof(struct iphdr) + (inet_opt ? inet_opt->opt.optlen : 0)); // 获取IP首部在skb里面的地址(如果有选项，需要计算选项的长度，否则为0；从传输层数据之前预留的就是IP首部地址空间)
skb_reset_network_header(skb);
iph = ip_hdr(skb); // 获取IP首部地址
*((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff)); // IP首部前16位为: 4位版本号、4位首部长度、8位服务类型(TOS)；(4 << 12)为4位版本号，IPv4，(5 << 8)为4位首部长度，5*4共20字节(此次没加上选项长度), (inet->tos & 0xff)为8位服务类型(TOS)
if (ip_dont_fragment(sk, &rt->dst) && !skb->ignore_df)
iph->frag_off = htons(IP_DF); // IP不分片(Don’t Fragment)
else
iph->frag_off = 0;
iph->ttl = ip_select_ttl(inet, &rt->dst); // 8位生存时间(TTL)
iph->protocol = sk->sk_protocol; // 8位协议(IPPROTO_TCP/IPPROTO_UDP)
ip_copy_addrs(iph, fl4); // 32位源IP地址
/* Transport layer set skb->h.foo itself. */
if (inet_opt && inet_opt->opt.optlen) // 选项(如果有)
iph->ihl += inet_opt->opt.optlen >> 2; // 修正4位首部长度
ip_options_build(skb, &inet_opt->opt, inet->inet_daddr, rt, 0); // 拷贝选项
ip_select_ident_segs(net, skb, sk,
skb_shinfo(skb)->gso_segs ?: 1); // 16位标识(每个IP报文有唯一的标识，通过16位标识区分是否是一个IP报文的分片)
/* TODO : should we use skb->sk here instead of sk ? */
skb->priority = sk->sk_priority;
skb->mark = sk->sk_mark;
res = ip_local_out(net, sk, skb); // 调用ip_local_out发送IP报文(IP首部的16位总长度在函数__ip_local_out里面设置，16位首部检验和在函数ip_send_check设置)
rcu_read_unlock();
return res;
no_route:
rcu_read_unlock();
IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
kfree_skb(skb);
return -EHOSTUNREACH;
3.2、ip_queue_xmit调用栈
ip_queue_xmit调用栈如下:
4、IP报文输入
4.1、IP报文输入流程
ip_packet_type定义ETH_P_IP报文输入函数:
static struct packet_type ip_packet_type __read_mostly =
.type = cpu_to_be16(ETH_P_IP),
.func = ip_rcv,
;
以太网首部:
struct ethhdr
unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
unsigned char h_source[ETH_ALEN]; /* source ether addr */
__be16 h_proto; /* packet type ID field */
__attribute__((packed));
smsc911x_poll调用eth_type_trans读取以太网首部类型字段并设置接收报文类型skb->protocol:
__netif_receive_skb_core找到ip_packet_type，并调用输入函数ip_rcv处理输入报文:
ip_rcv函数调用栈:
4.2、IP报文校验(ip_rcv)
ip_rcv校验IP首部各字段、校验和、总长度等，校验通过之后调用ip_rcv_finish继续处理IP报文。
ip_rcv函数代码实现:
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
const struct iphdr *iph;
struct net *net;
u32 len;
/* When the interface is in promisc. mode, drop all the crap
* that it receives, do not try to analyse it.
*/
if (skb->pkt_type == PACKET_OTHERHOST) // eth_type_trans比较以太网首部的目的地址是否是输入网卡的地址，如果不是，设置skb->pkt_type为PACKET_OTHERHOST
goto drop; // 丢弃发往其他主机的IP报文
net = dev_net(dev);
IP_UPD_PO_STATS_BH(net, IPSTATS_MIB_IN, skb->len);
skb = skb_share_check(skb, GFP_ATOMIC);
if (!skb)
IP_INC_STATS_BH(net, IPSTATS_MIB_INDISCARDS);
goto out;
if (!pskb_may_pull(skb, sizeof(struct iphdr))) // 报文长度检查(IP首部的长度)
goto inhdr_error; // 报文的长度小于IP首部的长度(不包含选项)，也就是不完整的IP报文，或者有其他错误，跳转到inhdr_error
iph = ip_hdr(skb); // 获取IP首部地址
/*
* RFC1122: 3.2.1.2 MUST silently discard any IP frame that fails the checksum.
*
* Is the datagram acceptable?
*
* 1. Length at least the size of an ip header
* 2. Version of 4
* 3. Checksums correctly. [Speed optimisation for later, skip loopback checksums]
* 4. Doesn't have a bogus length
*/
if (iph->ihl < 5 || iph->version != 4) // 如果IP首部4位首部长度小于5(IP首部不包含选项至少有5*4个字节数据)，那么4位首部长度错误，跳转到inhdr_error；如果IP首部4位版本不是4(不是IPv4)，那么跳转到inhdr_error
goto inhdr_error;
BUILD_BUG_ON(IPSTATS_MIB_ECT1PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_1);
BUILD_BUG_ON(IPSTATS_MIB_ECT0PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_0);
BUILD_BUG_ON(IPSTATS_MIB_CEPKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_CE);
IP_ADD_STATS_BH(net,
IPSTATS_MIB_NOECTPKTS + (iph->tos & INET_ECN_MASK),
max_t(unsigned short, 1, skb_shinfo(skb)->gso_segs));
if (!pskb_may_pull(skb, iph->ihl*4)) // 报文长度检查(IP首部长度(包含选项))
goto inhdr_error; // 报文长度不够IP首部长度(包含选项)或者其他错误，跳转到inhdr_error
iph = ip_hdr(skb); // 获取IP首部地址
if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl))) // 16位首部检验和校验(包含选项)
goto csum_error; // 16位首部检验和校验失败，跳转到csum_error
len = ntohs(iph->tot_len); // 16位总长度(字节数)
if (skb->len < len) // 报文总长度小于16位总长度
IP_INC_STATS_BH(net, IPSTATS_MIB_INTRUNCATEDPKTS);
goto drop; // 跳转到drop，丢弃报文
else if (len < (iph->ihl*4)) // 报文长度检查(IP首部长度(包含选项))
goto inhdr_error; // 报文长度不够IP首部长度(包含选项)或者其他错误，跳转到inhdr_error
/* Our transport medium may have padded the buffer out. Now we know it
* is IP we can trim to the true length of the frame.
* Note this now means skb->len holds ntohs(iph->tot_len).
*/
if (pskb_trim_rcsum(skb, len)) // 删除SKB尾部的数据(len之后的数据)
IP_INC_STATS_BH(net, IPSTATS_MIB_INDISCARDS);
goto drop;
skb->transport_header = skb->network_header + iph->ihl*4; // 获取传输层首部
/* Remove any debris in the socket control block */
memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
/* Must drop socket now because of tproxy. */
skb_orphan(skb);
return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
net, NULL, skb, dev, NULL,
ip_rcv_finish); // 调用ip_rcv_finish
csum_error:
IP_INC_STATS_BH(net, IPSTATS_MIB_CSUMERRORS);
inhdr_error:
IP_INC_STATS_BH(net, IPSTATS_MIB_INHDRERRORS);
drop:
kfree_skb(skb);
out:
return NET_RX_DROP;
4.3、输入路由查找(ip_rcv_finish)
物理层只管物理地址不管IP地址，IP报文校验完整之后还得调用ip_route_input_noref查找输入路由，看看是否有输入路由(发往本地或者转发)，如果没有输入路由则丢弃报文，否则调用dst_input根据路由处理报文(发往本地或者转发)。
ip_rcv_finish函数实现代码如下:
static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
const struct iphdr *iph = ip_hdr(skb);
struct rtable *rt;
if (sysctl_ip_early_demux &&
!skb_dst(skb) &&
!skb->sk &&
!ip_is_fragment(iph))
const struct net_protocol *ipprot;
int protocol = iph->protocol;
ipprot = rcu_dereference(inet_protos[protocol]);
if (ipprot && ipprot->early_demux)
ipprot->early_demux(skb);
/* must reload iph, skb->head might have changed */
iph = ip_hdr(skb);
/*
* Initialise the virtual path cache for the packet. It describes
* how the packet travels inside Linux networking.
*/
if (!skb_valid_dst(skb)) // 没有输入路由缓存
int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
iph->tos, skb->dev); // 查找输入路由
if (unlikely(err)) // 没有输入路由
if (err == -EXDEV)
NET_INC_STATS_BH(net, LINUX_MIB_IPRPFILTER);
goto drop; // 跳转到drop，丢弃报文
#ifdef CONFIG_IP_ROUTE_CLASSID
if (unlikely(skb_dst(skb)->tclassid))
struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
u32 idx = skb_dst(skb)->tclassid;
st[idx&0xFF].o_packets++;
st[idx&0xFF].o_bytes += skb->len;
st[(idx>>16)&0xFF].i_packets++;
st[(idx>>16)&0xFF].i_bytes += skb->len;
#endif
if (iph->ihl > 5 && ip_rcv_options(skb)) // 4位首部长度大于5(包含选项)，处理选项
goto drop; // 选项处理失败，跳转到drop，丢弃报文
rt = skb_rtable(skb);
if (rt->rt_type == RTN_MULTICAST)
IP_UPD_PO_STATS_BH(net, IPSTATS_MIB_INMCAST, skb->len);
else if (rt->rt_type == RTN_BROADCAST)
IP_UPD_PO_STATS_BH(net, IPSTATS_MIB_INBCAST, skb->len);
return dst_input(skb); // 调用dst_input处理输入报文
drop:
kfree_skb(skb);
return NET_RX_DROP;
ip_local_deliver调用栈:
4.4、报文发送到传输层(ip_local_deliver_finish)
对于发送本地的报文，调用ip_local_deliver、ip_local_deliver_finish，ip_local_deliver_finish根据IP首部的8位协议找到传输层对应协议的输入处理函数，调用传输层的处理函数处理传输层报文，对于IPv4的TCP协议就是tcp_v4_rcv。
ip_local_deliver_finish函数代码实现如下:
static int ip_local_deliver_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
__skb_pull(skb, skb_network_header_len(skb));
rcu_read_lock();
int protocol = ip_hdr(skb)->protocol; // 8位协议(IPPROTO_TCP/IPPROTO_UDP/IPPROTO_RAW...)
const struct net_protocol *ipprot;
int raw;
resubmit:
raw = raw_local_deliver(skb, protocol);
ipprot = rcu_dereference(inet_protos[protocol]); // 获取传输层的net_protocol(tcp_protocol/udp_protocol...)
if (ipprot)
int ret;
if (!ipprot->no_policy)
if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
kfree_skb(skb);
goto out;
nf_reset(skb);
ret = ipprot->handler(skb); // 调用传输层的处理函数(tcp_v4_rcv/udp_rcv...)
if (ret < 0)
protocol = -ret;
goto resubmit;
IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
else
if (!raw)
if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
IP_INC_STATS_BH(net, IPSTATS_MIB_INUNKNOWNPROTOS);
icmp_send(skb, ICMP_DEST_UNREACH,
ICMP_PROT_UNREACH, 0);
kfree_skb(skb);
else
IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
consume_skb(skb);
out:
rcu_read_unlock();
return 0;
ip_local_deliver_finish调用栈:
以上是关于linux网络协议栈源码分析 - 网络层IP网际协议的主要内容，如果未能解决你的问题，请参考以下文章