此网络协议栈源码分析是基于linux 1.2.13版本的内核源码进行分析的；在分析此代码的过程中，同时深入阅读了linux网络驱动和TCP-IP详解，先理解整体的网络概念和内核网络模块代码齐头并进，梳理出了如下的代码调用流程。如下的代码流程是从内核网络模块初始化，到插口层如何调用到内核的处理过程，针对流程和主要的数据体进行分析展示：
start_kernel
sock_init
proto_init
inet_proto_init
static struct proto_ops inet_proto_ops = {
AF_INET,
inet_create,
inet_dup,
inet_release,
inet_bind,
inet_connect,
inet_socketpair,
inet_accept,
inet_getname,
inet_read,
inet_write,
inet_select,
inet_ioctl,
inet_listen,
inet_send,
inet_recv,
inet_sendto,
inet_recvfrom,
inet_shutdown,
inet_setsockopt,
inet_getsockopt,
inet_fcntl,
};
sock_register(inet_proto_ops.family, &inet_proto_ops);
pops[i] = ops; //pops指向inet_proto_ops结构体
pops[i]->family = family;
tcp_prot.sock_array
udp_prot.sock_array
raw_prot.sock_array
tcp_prot.inuse = 0;
tcp_prot.highestinuse = 0;
udp_prot.inuse = 0;
udp_prot.highestinuse = 0;
raw_prot.inuse = 0;
raw_prot.highestinuse = 0;
inet_add_protocol(p);
inet_protos[hash] = prot;
arp_init();
ip_init();
dev_init
ethif_probe
ne_probe(dev)
ne_probe1(dev, base_addr);
request_irq (dev->irq, ei_interrupt, 0, wordlength==2 ? "ne2000":"ne1000");
ei_receive(dev);
ei_block_input(dev, pkt_len, (char *) skb->data,current_offset + sizeof(rx_frame));
netif_rx(skb);
mark_bh(NET_BH);
ethdev_init(dev);
dev->hard_start_xmit = &ei_start_xmit;
dev->get_stats = get_stats;
dev->hard_header = eth_header;
dev->rebuild_header = eth_rebuild_header;
dev->type_trans = eth_type_trans;
dev->type = ARPHRD_ETHER;
dev->hard_header_len = ETH_HLEN;
dev->mtu = 1500; /* eth_mtu */
dev->addr_len = ETH_ALEN;
/* New-style flags. */
dev->flags = IFF_BROADCAST|IFF_MULTICAST;
dev->family = AF_INET;
dev->pa_addr = 0;
dev->pa_brdaddr = 0;
dev->pa_mask = 0;
dev->pa_alen = sizeof(unsigned long);
ei_status.reset_8390 = &ne_reset_8390;
ei_status.block_input = &ne_block_input;
ei_status.block_output = &ne_block_output;
bh_base[NET_BH].routine= net_bh;
enable_bh(NET_BH);
net_bh
dev_transmit
//ptype_base->func = ip_rcv
pt_prev->func(skb, skb->dev, pt_prev);
ip_rcv(skb, skb->dev, pt_prev);
ip_fw_chk
ip_forward(skb, dev, is_frag);
ip_acct_cnt(iph,dev, ip_acct_chain);
ip_defrag(iph,skb,dev);//处理分片数据包
ip_find
ip_create(skb, iph, dev)
ipqueue//IP fragment queue 全局队列
ip_frag_create(offset, end, skb, ptr);
ip_done(qp) //检测分片包是否接收完成
ip_glue(qp); //将分片的数据包组装起来
raw_rcv //原始套接字
ipprot->handler //网络层向传输层传输数据包
tcp_rcv
udp_rcv
ip_chk_addr(daddr);
udp_check(uh, len, saddr, daddr)
udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
sock_queue_rcv_skb(sk,skb). //将数据包挂接到sk变量表示的套接字的接收队列中
//将数据包插入到接收队列尾部，并通知可能等待读取数据被置于睡眠的进程进行数据包的读取 sk->data_ready = def_callback2
//def_callback2(sk,skb->len);
sk->data_ready(sk,skb->len); //Now tell the user we may have some data.
release_sock(sk);
sk->prot->icv
icmp_rcv
dev_transmit
sys_socketcall
sock_socket
ops = pops[i];
sock = sock_alloc（）；
inode = get_empty_inode(); //申请一个文件节点
sock = &inode->u.socket_i;
sock->type = type;
sock->ops = ops;
sock->ops->create(sock, protocol)
inet_create(sock, protocol)
sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
sk->num = 0;
sk->reuse = 0;
switch(sock->type)
case SOCK_STREAM:
case SOCK_SEQPACKET:
protocol = IPPROTO_TCP;
sk->no_check = TCP_NO_CHECK;
prot = &tcp_prot;
case SOCK_DGRAM:
protocol = IPPROTO_UDP;
sk->no_check = UDP_NO_CHECK;
prot=&udp_prot;
case SOCK_RAW:
Sk->reuse = 1;
sk->no_check = 0;
prot=&raw_prot;
sk->num = protocol;
case SOCK_PACKET:
Sk->reuse = 1;
sk->no_check = 0;
prot=&packet_prot;
sk->num = protocol;
sk->socket = sock;
sk->nonagle = 1;
sk->nonagle = 0;
sk->type = sock->type;
sk->stamp.tv_sec=0;
sk->protocol = protocol;
sk->wmem_alloc = 0;
sk->rmem_alloc = 0;
sk->sndbuf = SK_WMEM_MAX;
sk->rcvbuf = SK_RMEM_MAX;
sk->pair = NULL;
sk->opt = NULL;
sk->write_seq = 0;
sk->acked_seq = 0;
sk->copied_seq = 0;
sk->fin_seq = 0;
sk->urg_seq = 0;
sk->urg_data = 0;
sk->proc = 0;
sk->rtt = 0; /*TCP_WRITE_TIME << 3;*/
sk->rto = TCP_TIMEOUT_INIT; /*TCP_WRITE_TIME*/
sk->mdev = 0;
sk->backoff = 0;
sk->packets_out = 0;
sk->cong_window = 1; /* start with only sending one packet at a time. */
sk->cong_count = 0;
sk->ssthresh = 0;
sk->max_window = 0;
sk->urginline = 0;
sk->intr = 0;
sk->linger = 0;
sk->destroy = 0;
sk->priority = 1;
sk->shutdown = 0;
sk->keepopen = 0;
sk->zapped = 0;
sk->done = 0;
sk->ack_backlog = 0;
sk->window = 0;
sk->bytes_rcv = 0;
sk->state = TCP_CLOSE;
sk->dead = 0;
sk->ack_timed = 0;
sk->partial = NULL;
sk->user_mss = 0;
sk->debug = 0;
sk->max_unacked = 2048;
sk->max_ack_backlog = 0;
sk->inuse = 0;
sk->delay_acks = 0;
skb_queue_head_init(&sk->write_queue);
skb_queue_head_init(&sk->receive_queue);
sk->mtu = 576;
sk->prot = prot;
sk->sleep = sock->wait;
sk->daddr = 0;
sk->saddr = 0 /* ip_my_addr() */;
sk->err = 0;
sk->next = NULL;
sk->pair = NULL;
sk->send_tail = NULL;
sk->send_head = NULL;
sk->timeout = 0;
sk->broadcast = 0;
sk->localroute = 0;
init_timer(&sk->timer);
init_timer(&sk->retransmit_timer);
sk->timer.data = (unsigned long)sk;
sk->timer.function = &net_timer;
sk->timer.expires = 10;
add_timer(&sk->timer);
skb_queue_head_init(&sk->back_log);
sk->blog = 0;
sock->data =(void *) sk;
sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
sk->dummy_th.res1=0;
sk->dummy_th.res2=0;
sk->dummy_th.res2=0;
sk->dummy_th.urg_ptr = 0;
sk->dummy_th.fin = 0;
sk->dummy_th.syn = 0;
sk->dummy_th.rst = 0;
sk->dummy_th.psh = 0;
sk->dummy_th.ack = 0;
sk->dummy_th.urg = 0;
sk->dummy_th.dest = 0;
sk->ip_tos=0;
sk->ip_ttl=64;
sk->ip_mc_loop=1;
sk->ip_mc_ttl=1;
*sk->ip_mc_name=0;
sk->ip_mc_list=NULL;
sk->state_change = def_callback1;
sk->data_ready = def_callback2;
wake_up_interruptible(sk->sleep);
sock_wake_async(sk->socket, 1);
sk->write_space = def_callback3;
sk->error_report = def_callback1;
//Add a socket into the socket tables by number.
put_sock(sk->num, sk);
sk->dummy_th.source = ntohs(sk->num);
err = sk->prot->init(sk);
fd = get_fd(SOCK_INODE(sock); //fd = get_fd(sock->node);
file = get_empty_filp();
static struct file_operations socket_file_ops = {
sock_lseek,
sock_read,
sock_write,
sock_readdir,
sock_select,
sock_ioctl,
NULL, /* mmap */
NULL, /* no special open code... */
sock_close,
NULL, /* no fsync */
sock_fasync
};
file->f_op = &socket_file_ops;
file->f_mode = 3;
file->f_flags = O_RDWR;
file->f_count = 1;
file->f_inode = inode;
inode->i_count++;
file->f_pos = 0;
recvfrom
sys_socketcall
sock_recvfrom
inet_recvfrom
udp_recvfrom
skb_recv_datagram
interruptible_sleep_on(sk->sleep); //阻塞进程进入睡眠
skb_copy_datagram(skb,sizeof(struct udphdr),to,copied);
skb_free_datagram(skb);
sendto
sys_socketcall
sock_sendto
udp_sendto(sk, &sin, from, len, flags);
udp_send(sk, &sin, from, len, flags);
//ip_queue_xmit(sk, dev, skb, 1);
sk->prot->queue_xmit(sk, dev, skb, 1); //queue_xmit = ip_queue_xmit
ip_fw_chk
ip_loopback(dev,skb);
ip_queue_xmit(NULL, dev, newskb, 1);
dev_queue_xmit(skb, dev, SOPRI_NORMAL)
//ei_start_xmit(skb, dev)
dev->hard_start_xmit(skb, dev) //dev->hard_start_xmit = &ei_start_xmit;
ei_start_xmit(skb, dev)
read
sock_read
inet_read
sk->prot->read //udp_read
udp_read
udp_recvfrom
大家结合linux 1.2.13的源码，上面的函数调用流程可以让大家清晰对网络协议栈有一个比较通透的认知。