程序博客网 > png格式打开软件

Linux内核分析

来源：互联网 发布：png格式打开软件 编辑：程序博客网 时间：2024/06/14 16:39

网络收包流程从网卡驱动开始，一直往上，涉及NAPI、GRO、RPS等特性，但是一般最后都会调用__netif_receive_skb函数：

函数主要有几个处理：

1、vlan报文的处理，主要是循环把vlan头剥掉，如果qinq场景，两个vlan都会被剥掉；

2、交给rx_handler处理，例如OVS、linux bridge等；

3、ptype_all处理，例如抓包程序、raw socket等；

4、ptype_base处理，交给协议栈处理，例如ip、arp、rarp等；


  1. static int __netif_receive_skb(struct sk_buff *skb)
  2. {
  3.     struct packet_type *ptype, *pt_prev;
  4.     rx_handler_func_t *rx_handler;
  5.     struct net_device *orig_dev;
  6.     struct net_device *null_or_dev;
  7.     bool deliver_exact = false;
  8.     int ret = NET_RX_DROP;
  9.     __be16 type;

  11.     if (!netdev_tstamp_prequeue)
  12.         net_timestamp_check(skb);

  14.     trace_netif_receive_skb(skb);

  16.     if (netpoll_receive_skb(skb))
  17.         return NET_RX_DROP;

  19.     if (!skb->skb_iif)
  20.         skb->skb_iif = skb->dev->ifindex;
  21.     orig_dev = skb->dev;

  23.     skb_reset_network_header(skb);  //把L3、L4的头都指向data数据结构，到这里的时候skb已经处理完L2层的头了
  24.     skb_reset_transport_header(skb);
  25.     skb_reset_mac_len(skb);

  27.     pt_prev = NULL;

  29.     rcu_read_lock();

  31. another_round:

  33.     __this_cpu_inc(softnet_data.processed);

  35.     if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
  36.         skb = vlan_untag(skb);
  37.         if (unlikely(!skb))
  38.             goto out;
  39.     }

  41. #ifdef CONFIG_NET_CLS_ACT
  42.     if (skb->tc_verd & TC_NCLS) {
  43.         skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
  44.         goto ncls;
  45.     }
  46. #endif

  48.     list_for_each_entry_rcu(ptype, &ptype_all, list) {  //把包交给特定协议相关的处理函数前，先调用ptype_all中注册的函数
  49.         if (!ptype->dev || ptype->dev == skb->dev) {    //最常见的为tcpdump，该工具就是从这里拿到所有收到的包的
  50.             if (pt_prev)
  51.                 ret = deliver_skb(skb, pt_prev, orig_dev);
  52.             pt_prev = ptype;  //pt_prev的加入是为了优化，只有当找到下一个匹配的时候，才执行这一次的回调函数
  53.         }                     
  54.     }

  56. #ifdef CONFIG_NET_CLS_ACT
  57.     skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
  58.     if (!skb)
  59.         goto out;
  60. ncls:
  61. #endif
  62.     rx_handler = rcu_dereference(skb->dev->rx_handler);  //由具体驱动决定
  63.     if (rx_handler) {
  64.         if (pt_prev) {
  65.             ret = deliver_skb(skb, pt_prev, orig_dev);
  66.             pt_prev = NULL;
  67.         }
  68.         switch (rx_handler(&skb)) {
  69.         case RX_HANDLER_CONSUMED:
  70.             goto out;
  71.         case RX_HANDLER_ANOTHER:
  72.             goto another_round;
  73.         case RX_HANDLER_EXACT:
  74.             deliver_exact = true;
  75.         case RX_HANDLER_PASS:
  76.             break;
  77.         default:
  78.             BUG();
  79.         }
  80.     }

  82.     if (vlan_tx_tag_present(skb)) {
  83.         if (pt_prev) {
  84.             ret = deliver_skb(skb, pt_prev, orig_dev);
  85.             pt_prev = NULL;
  86.         }
  87.         if (vlan_do_receive(&skb)) {
  88.             ret = __netif_receive_skb(skb);
  89.             goto out;
  90.         } else if (unlikely(!skb))
  91.             goto out;
  92.     }

  94.     /* deliver only exact match when indicated */
  95.     null_or_dev = deliver_exact ? skb->dev : NULL;

  97.     type = skb->protocol;
  98.     list_for_each_entry_rcu(ptype,
  99.             &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
  100.         if (ptype->type == type &&
  101.             (ptype->dev == null_or_dev || ptype->dev == skb->dev ||
  102.              ptype->dev == orig_dev)) {
  103.             if (pt_prev)
  104.                 ret = deliver_skb(skb, pt_prev, orig_dev); //atomic_inc(&skb->users);
  105.             pt_prev = ptype;
  106.         }
  107.     }

  109.     if (pt_prev) {
  110.         ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);  //一般的最后这一次没有引用计数的增加，直接调用函数
  111.     } else {
  112.         atomic_long_inc(&skb->dev->rx_dropped);
  113.         kfree_skb(skb);
  114.         /* Jamal, now you will not able to escape explaining
  115.          * me how you were going to use this. :-)
  116.          */
  117.         ret = NET_RX_DROP;
  118.     }

  120. out:
  121.     rcu_read_unlock();
  122.     return ret;
  123. }
该函数涉及两个全局变量：
  1. static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
  2. static struct list_head ptype_all __read_mostly
看几个常见的packet_type，这些都在相应的协议初始化的时候调用dev_add_pack加入到特性的链表中：
  1. static struct packet_type ip_packet_type __read_mostly = {
  2.     .type = cpu_to_be16(ETH_P_IP),
  3.     .func = ip_rcv,
  4.     .gso_send_check = inet_gso_send_check,
  5.     .gso_segment = inet_gso_segment,
  6.     .gro_receive = inet_gro_receive,
  7.     .gro_complete = inet_gro_complete,
  8. };

  10. static struct packet_type arp_packet_type __read_mostly = {
  11.     .type = cpu_to_be16(ETH_P_ARP),
  12.     .func = arp_rcv,
  13. }
在ip_rcv函数中会对L3头做一些有效性检测:
  1. int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
  2. {
  3.     const struct iphdr *iph;
  4.     u32 len;

  6.     /* When the interface is in promisc. mode, drop all the crap
  7.      * that it receives, do not try to analyse it.
  8.      */
  9.     if (skb->pkt_type == PACKET_OTHERHOST)  //驱动根据MAC地址设置的，如果MAC地址不是本机的话，在这里丢弃。
  10.         goto drop;


  13.     IP_UPD_PO_STATS_BH(dev_net(dev), IPSTATS_MIB_IN, skb->len);

  15.     if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
  16.         IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INDISCARDS);
  17.         goto out;
  18.     }

  20.     if (!pskb_may_pull(skb, sizeof(struct iphdr)))
  21.         goto inhdr_error;

  23.     iph = ip_hdr(skb);

  25.     /*
  26.      * RFC1122: 3.2.1.2 MUST silently discard any IP frame that fails the checksum.
  27.      *
  28.      * Is the datagram acceptable?
  29.      *
  30.      * 1. Length at least the size of an ip header
  31.      * 2. Version of 4
  32.      * 3. Checksums correctly. [Speed optimisation for later, skip loopback checksums]
  33.      * 4. Doesn't have a bogus length
  34.      */

  36.     if (iph->ihl < 5 || iph->version != 4)
  37.         goto inhdr_error;

  39.     if (!pskb_may_pull(skb, iph->ihl*4))
  40.         goto inhdr_error;

  42.     iph = ip_hdr(skb);

  44.     if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))  //校验ip头是否正确
  45.         goto inhdr_error;
  46.     len = ntohs(iph->tot_len);  //iph中的大小是真正的大小，skb中len的大小是驱动中设置的，当包很小的时候，会进行填充，因此会比iph中的大
  47.     if (skb->len < len) {//以r8169为例，如果收到udp的包负载为1,则iph中的大小为20+8+1=29。但是此时skb->len=46=64(min)-14-4(vlan)
  48.         IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INTRUNCATEDPKTS);
  49.         goto drop;
  50.     } else if (len < (iph->ihl*4))
  51.         goto inhdr_error;

  53.     /* Our transport medium may have padded the buffer out. Now we know it
  54.      * is IP we can trim to the true length of the frame.
  55.      * Note this now means skb->len holds ntohs(iph->tot_len).
  56.      */
  57.     if (pskb_trim_rcsum(skb, len)) {  //去除填充的数据
  58.         IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INDISCARDS);
  59.         goto drop;
  60.     }

  62.     /* Remove any debris in the socket control block */
  63.     memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));

  65.     /* Must drop socket now because of tproxy. */
  66.     skb_orphan(skb);

  68.     return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL,
  69.                ip_rcv_finish);

  71. inhdr_error:
  72.     IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INHDRERRORS);
  73. drop:
  74.     kfree_skb(skb);
  75. out:
  76.     return NET_RX_DROP;
  77. }
然后调用ip_rcv_finish：

  1. static int ip_rcv_finish(struct sk_buff *skb)
  2. {
  3.     const struct iphdr *iph = ip_hdr(skb);
  4.     struct rtable *rt;

  6.     /* 
  7.      * Initialise the virtual path cache for the packet. It describes
  8.      * how the packet travels inside Linux networking.
  9.      */
  10.     if (skb_dst(skb) == NULL) {
  11.         int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,//路由寻找，根据目的地址判断是本地接收还是转发（使能forward的话）
  12.                            iph->tos, skb->dev);
  13.         if (unlikely(err)) {
  14.             if (err == -EHOSTUNREACH)
  15.                 IP_INC_STATS_BH(dev_net(skb->dev),
  16.                         IPSTATS_MIB_INADDRERRORS);
  17.             else if (err == -ENETUNREACH)
  18.                 IP_INC_STATS_BH(dev_net(skb->dev),
  19.                         IPSTATS_MIB_INNOROUTES);
  20.             else if (err == -EXDEV)
  21.                 NET_INC_STATS_BH(dev_net(skb->dev),
  22.                          LINUX_MIB_IPRPFILTER);
  23.             goto drop;
  24.         }
  25.     } 

  27. #ifdef CONFIG_IP_ROUTE_CLASSID
  28.     if (unlikely(skb_dst(skb)->tclassid)) {
  29.         struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
  30.         u32 idx = skb_dst(skb)->tclassid;
  31.         st[idx&0xFF].o_packets++;
  32.         st[idx&0xFF].o_bytes += skb->len;
  33.         st[(idx>>16)&0xFF].i_packets++;
  34.         st[(idx>>16)&0xFF].i_bytes += skb->len;
  35.     } 
  36. #endif

  38.     if (iph->ihl > 5 && ip_rcv_options(skb))
  39.         goto drop;

  41.     rt = skb_rtable(skb);
  42.     if (rt->rt_type == RTN_MULTICAST) {
  43.         IP_UPD_PO_STATS_BH(dev_net(rt->dst.dev), IPSTATS_MIB_INMCAST,
  44.                 skb->len);
  45.     } else if (rt->rt_type == RTN_BROADCAST)
  46.         IP_UPD_PO_STATS_BH(dev_net(rt->dst.dev), IPSTATS_MIB_INBCAST,
  47.                 skb->len);

  49.     return dst_input(skb);  //skb_dst(skb)->input(skb);路由寻找过程中赋值，本地接收的话为：ip_local_deliver

  51. drop:
  52.     kfree_skb(skb);
  53.     return NET_RX_DROP;
  54. }
  1. int ip_local_deliver(struct sk_buff *skb)
  2. {
  3.     /*
  4.      * Reassemble IP fragments.
  5.      */

  7.     if (ip_is_fragment(ip_hdr(skb))) {
  8.         if (ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER))
  9.             return 0;
  10.     }

  12.     return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN, skb, skb->dev, NULL,
  13.                ip_local_deliver_finish);
  14. }
略过ip defrag流程，直接调用ip_local_deliver_finish,该函数根据L3头指定的L4协议，调用特定的函数：
  1. static int ip_local_deliver_finish(struct sk_buff *skb)
  2. {
  3.     struct net *net = dev_net(skb->dev);

  5.     __skb_pull(skb, ip_hdrlen(skb)); //增加data，略过L3头，此时data指向L4头

  7.     /* Point into the IP datagram, just past the header. */
  8.     skb_reset_transport_header(skb);

  10.     rcu_read_lock();
  11.     {
  12.         int protocol = ip_hdr(skb)->protocol;  //L4类型，如TCP或者UDP
  13.         int hash, raw;
  14.         const struct net_protocol *ipprot;

  16.     resubmit:
  17.         raw = raw_local_deliver(skb, protocol); //

  19.         hash = protocol & (MAX_INET_PROTOS - 1);
  20.         ipprot = rcu_dereference(inet_protos[hash]);  //udp_protocol
  21.         if (ipprot != NULL) {
  22.             int ret;

  24.             if (!net_eq(net, &init_net) && !ipprot->netns_ok) {
  25.                 if (net_ratelimit())
  26.                     printk("%s: proto %d isn't netns-ready\n",
  27.                         __func__, protocol);
  28.                 kfree_skb(skb);
  29.                 goto out;
  30.             }

  32.             if (!ipprot->no_policy) {
  33.                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
  34.                     kfree_skb(skb);
  35.                     goto out;
  36.                 }
  37.                 nf_reset(skb);
  38.             }
  39.             ret = ipprot->handler(skb);  //udp_rcv
  40.             if (ret < 0) {
  41.                 protocol = -ret;
  42.                 goto resubmit;
  43.             }
  44.             IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
  45.         } else {
  46.             if (!raw) {
  47.                 if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
  48.                     IP_INC_STATS_BH(net, IPSTATS_MIB_INUNKNOWNPROTOS);
  49.                     icmp_send(skb, ICMP_DEST_UNREACH,
  50.                           ICMP_PROT_UNREACH, 0);
  51.                 }
  52.             } else
  53.                 IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
  54.             kfree_skb(skb);
  55.         }
  56.     }
  57.  out:
  58.     rcu_read_unlock();

  60.     return 0;
  61. }
udp调用udp_rcv，最后调用__udp4_lib_rcv：

  1. int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
  2.            int proto)
  3. {
  4.     struct sock *sk; 
  5.     struct udphdr *uh; 
  6.     unsigned short ulen;
  7.     struct rtable *rt = skb_rtable(skb);
  8.     __be32 saddr, daddr;
  9.     struct net *net = dev_net(skb->dev);

  11.     /* 
  12.      * Validate the packet.
  13.      */
  14.     if (!pskb_may_pull(skb, sizeof(struct udphdr)))
  15.         goto drop; /* No space for header. */

  17.     uh = udp_hdr(skb);
  18.     ulen = ntohs(uh->len);
  19.     saddr = ip_hdr(skb)->saddr;
  20.     daddr = ip_hdr(skb)->daddr;

  22.     if (ulen > skb->len)
  23.         goto short_packet;

  25.     if (proto == IPPROTO_UDP) {
  26.         /* UDP validates ulen. */
  27.         if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
  28.             goto short_packet;
  29.         uh = udp_hdr(skb);
  30.     } 

  32.     if (udp4_csum_init(skb, uh, proto))
  33.         goto csum_error;

  35.     if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
  36.         return __udp4_lib_mcast_deliver(net, skb, uh,
  37.                 saddr, daddr, udptable);

  39.     sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable); //根据ip地址以及端口号查找对应的sock数据结构
  40.                                                                      //接收进程在对应的链表中睡眠
  41.     if (sk != NULL) { //不为空说明有对应的进程在等待这数据
  42.         int ret = udp_queue_rcv_skb(sk, skb);
  43.         sock_put(sk);

  45.         /* a return value > 0 means to resubmit the input, but
  46.          * it wants the return to be -protocol, or 0
  47.          */
  48.         if (ret > 0)
  49.             return -ret;
  50.         return 0;
  51.     }

  53.     if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
  54.         goto drop;
  55.     nf_reset(skb);

  57.     /* No socket. Drop packet silently, if checksum is wrong */
  58.     if (udp_lib_checksum_complete(skb))
  59.         goto csum_error;

  61.     UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
  62.     icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);

  64.     /*
  65.      * Hmm. We got an UDP packet to a port to which we
  66.      * don't wanna listen.  Ignore it.
  67.      */
  68.     kfree_skb(skb);
  69.     return 0;
  70. }     
首先看一下sock的hash查找函数：__udp4_lib_lookup_skb，该函数涉及hash表的一些查找，主要看一下具体的匹配函数：
  1. static inline int compute_score(struct sock *sk, struct net *net, __be32 saddr,
  2.              unsigned short hnum,
  3.              __be16 sport, __be32 daddr, __be16 dport, int dif) 
  4. {
  5.     int score = -1;

  7.     if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
  8.             !ipv6_only_sock(sk)) {
  9.         struct inet_sock *inet = inet_sk(sk);

  11.         score = (sk->sk_family == PF_INET ? 1 : 0);  //一般为PF_INET
  12.         if (inet->inet_rcv_saddr) {   //bind指定地址的话有设置，否则为INADDR_ANY
  13.             if (inet->inet_rcv_saddr != daddr)
  14.                 return -1;
  15.             score += 2;
  16.         } 
  17.         if (inet->inet_daddr) {       //一般为0，参考inet_bind函数
  18.             if (inet->inet_daddr != saddr)
  19.                 return -1;
  20.             score += 2;
  21.         }
  22.         if (inet->inet_dport) {        //一般为0
  23.             if (inet->inet_dport != sport)
  24.                 return -1;
  25.             score += 2;
  26.         }
  27.         if (sk->sk_bound_dev_if) {    //一般为0
  28.             if (sk->sk_bound_dev_if != dif) 
  29.                 return -1;
  30.             score += 2;
  31.         }
  32.     } 
  33.     return score;
  34. }
该函数使用端口号寻找hash表中项，然后根据各个参数决定score，score大于-1表示找到对应的sock
找到sock后，去掉一些有效性检测，udp_queue_rcv_skb的逻辑如下：
  1. if (sk_rcvqueues_full(sk, skb))  //超过限值，sk->sk_rmem_alloc
  2.         goto drop;

  4.     rc = 0;

  6.     bh_lock_sock(sk);
  7.     if (!sock_owned_by_user(sk))
  8.         rc = __udp_queue_rcv_skb(sk, skb);  
  9.     else if (sk_add_backlog(sk, skb)) {
  10.         bh_unlock_sock(sk);
  11.         goto drop;
  12.     } 
  13.     bh_unlock_sock(sk)
分成两种情况：
1）sk没有被人占用，则把skb加入sk_receive_queue，然后唤醒等待的进程。
2）如果sk被人占用，则把skb加入backlog链表，释放sk的时候会处理这种流程
先看第一种情况：

  1. int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  2. {
  3.     int err;
  4.     int skb_len;
  5.     unsigned long flags;
  6.     struct sk_buff_head *list = &sk->sk_receive_queue; //获取链表头

  8.     /* Cast sk->rcvbuf to unsigned... It is pointless, but reduces
  9.        number of warnings when compiling with -W --ANK
  10.      */
  11.     if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
  12.         (unsigned)sk->sk_rcvbuf) {
  13.         atomic_inc(&sk->sk_drops);
  14.         trace_sock_rcvqueue_full(sk, skb);
  15.         return -ENOMEM;
  16.     }

  18.     err = sk_filter(sk, skb);
  19.     if (err)
  20.         return err;

  22.     if (!sk_rmem_schedule(sk, skb->truesize)) {
  23.         atomic_inc(&sk->sk_drops);
  24.         return -ENOBUFS;
  25.     }

  27.     skb->dev = NULL;
  28.     skb_set_owner_r(skb, sk);

  30.     /* Cache the SKB length before we tack it onto the receive
  31.      * queue. Once it is added it no longer belongs to us and
  32.      * may be freed by other threads of control pulling packets
  33.      * from the queue.
  34.      */
  35.     skb_len = skb->len;

  37.     /* we escape from rcu protected region, make sure we dont leak
  38.      * a norefcounted dst
  39.      */
  40.     skb_dst_force(skb);
  41.     spin_lock_irqsave(&list->lock, flags);
  42.     skb->dropcount = atomic_read(&sk->sk_drops);
  43.     __skb_queue_tail(list, skb);
  44.     spin_unlock_irqrestore(&list->lock, flags);

  46.     if (!sock_flag(sk, SOCK_DEAD))
  47.         sk->sk_data_ready(sk, skb_len); //sock_init_data初始化的时候赋值为：sock_def_readable
  48.     return 0;
  49. }
  1. static void sock_def_readable(struct sock *sk, int len)
  2. {
  3.     struct socket_wq *wq;

  5.     rcu_read_lock();
  6.     wq = rcu_dereference(sk->sk_wq);
  7.     if (wq_has_sleeper(wq))
  8.         wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
  9.                         POLLRDNORM | POLLRDBAND);
  10.     sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
  11.     rcu_read_unlock();
  12. }
再看第二种情况，加入到对应的链表：
  1. static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
  2. {
  3.     /* dont let skb dst not refcounted, we are going to leave rcu lock */
  4.     skb_dst_force(skb);

  6.     if (!sk->sk_backlog.tail)
  7.         sk->sk_backlog.head = skb;
  8.     else
  9.         sk->sk_backlog.tail->next = skb;

  11.     sk->sk_backlog.tail = skb;
  12.     skb->next = NULL;
  13. }
释放sock的时候会判断该链表：
  1. void release_sock(struct sock *sk)
  2. {
  3.     /*
  4.      * The sk_lock has mutex_unlock() semantics:
  5.      */
  6.     mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);

  8.     spin_lock_bh(&sk->sk_lock.slock);
  9.     if (sk->sk_backlog.tail)
  10.         __release_sock(sk);
  11.     sk->sk_lock.owned = 0;
  12.     if (waitqueue_active(&sk->sk_lock.wq))
  13.         wake_up(&sk->sk_lock.wq);
  14.     spin_unlock_bh(&sk->sk_lock.slock);
  15. }
__release_sock会遍历tail对应链表上的所有skb，分别调用sk_backlog_rcv函数：

  1. static void __release_sock(struct sock *sk)
  2.     __releases(&sk->sk_lock.slock)
  3.     __acquires(&sk->sk_lock.slock)
  4. {
  5.     struct sk_buff *skb = sk->sk_backlog.head;

  7.     do {
  8.         sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
  9.         bh_unlock_sock(sk);

  11.         do {
  12.             struct sk_buff *next = skb->next;

  14.             WARN_ON_ONCE(skb_dst_is_noref(skb));
  15.             skb->next = NULL;
  16.             sk_backlog_rcv(sk, skb); //sk->sk_backlog_rcv(sk, skb)=sk->sk_prot->backlog_rcv
  17.     
  18.             /*
  19.              * We are in process context here with softirqs
  20.              * disabled, use cond_resched_softirq() to preempt.
  21.              * This is safe to do because we've taken the backlog
  22.              * queue private:
  23.              */
  24.             cond_resched_softirq();

  26.             skb = next;
  27.         } while (skb != NULL);

  29.         bh_lock_sock(sk);
  30.     } while ((skb = sk->sk_backlog.head) != NULL);
  31.     
  32.     /*
  33.      * Doing the zeroing here guarantee we can not loop forever
  34.      * while a wild producer attempts to flood us.
  35.      */
  36.     sk->sk_backlog.len = 0;
  37. }
对于udp为__udp_queue_rcv_skb：
  1. static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  2. {
  3.     int rc;

  5.     if (inet_sk(sk)->inet_daddr)
  6.         sock_rps_save_rxhash(sk, skb->rxhash);

  8.     rc = ip_queue_rcv_skb(sk, skb); //调用sock_queue_rcv_skb，回到第一种处理情况
  9.     if (rc < 0) {
  10.         int is_udplite = IS_UDPLITE(sk);

  12.         /* Note that an ENOMEM error is charged twice */
  13.         if (rc == -ENOMEM)
  14.             UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
  15.                      is_udplite);
  16.         UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
  17.         kfree_skb(skb);
  18.         trace_udp_fail_queue_rcv_skb(rc, sk);
  19.         return -1;
  20.     }

  22.     return 0;
  23.     
  24. }

一句话总结，对应udp而言，__netif_receive_skb把底层传上来的skb放到sock对应的sk_receive_queue链表中，然后唤醒等待数据的进程。


ARP报文处理：

在netif_receive_skb()函数中，可以看出处理的是像ARP、IP这些链路层以上的协议，那么，链路层报头是在哪里去掉的呢？答案是网卡驱动中，在调用netif_receive_skb()前，

skb->protocol = eth_type_trans(skb, bp->dev);

该函数对处理后skb>data跳过以太网报头，由mac_header指示以太网报头：

进入netif_receive_skb()函数

list_for_each_entry_rcu(ptype,&ptype_base[ntohs(type) & PTYPE_HASH_MASK], list)

按照协议类型依次由相应的协议模块进行处理，而所以的协议模块处理都会注册在ptype_base中，实际是链表结构。

net/core/dev.c

static struct list_head ptype_base __read_mostly;   /* Taps */

 

而相应的协议模块是通过dev_add_pack()函数加入的：

void dev_add_pack(struct packet_type *pt)

{

     int hash;

 

     spin_lock_bh(&ptype_lock);

     if (pt->type == htons(ETH_P_ALL))

              list_add_rcu(&pt->list, &ptype_all);

     else {

              hash = ntohs(pt->type) & PTYPE_HASH_MASK;

              list_add_rcu(&pt->list, &ptype_base[hash]);

     }

     spin_unlock_bh(&ptype_lock);

}

 

以ARP处理为例

该模块的定义，它会在arp_init()中注册进ptype_base链表中：

static struct packet_type arp_packet_type __read_mostly = {

     .type =      cpu_to_be16(ETH_P_ARP),

     .func =      arp_rcv,

};

 

然后在根据报文的TYPE来在ptype_base中查找相应协议模块进行处理时，实际调用arp_rcv()进行接收

arp_rcv() --> arp_process()

arp = arp_hdr(skb);

……

arp_ptr= (unsigned char *)(arp+1);

sha= arp_ptr;

arp_ptr += dev->addr_len;

memcpy(&sip, arp_ptr, 4);

arp_ptr += 4;

arp_ptr += dev->addr_len;

memcpy(&tip, arp_ptr, 4);

操作后这指针位置：

然后判断是ARP请求报文，这时先查询路由表ip_route_input()

if (arp->ar_op == htons(ARPOP_REQUEST) &&

         ip_route_input(skb, tip, sip, 0, dev) == 0)

在ip_route_input()函数中，先在cache中查询是否存在相应的路由表项：

hash = rt_hash(daddr, saddr, iif, rt_genid(net));

缓存的路由项在内核中组织成hash表的形式，因此在查询时，先算出的hash值，再用该项- rt_hash_table[hash].chain即可。这里可以看到，缓存路由项包括了源IP地址、目的IP地址、网卡号。

 

如果在缓存中没有查到匹配项，或指定不查询cache，则查询路由表ip_route_input_slow()；

进入ip_route_input_slow()函数，最终调用fib_lookup()得到查询结果fib_result

if ((err = fib_lookup(net, &fl, &res)) != 0)

如果结果fib_result合法，则需要更新路由缓存，将此次查询结果写入缓存

hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));

err = rt_intern_hash(hash, rth, NULL, skb, fl.iif);

 

在查找完路由表后，回到arp_process()函数，如果路由项指向本地，则应由本机接收该报文：

if (addr_type == RTN_LOCAL) {

              ……

              if (!dont_send) {

                       n = neigh_event_ns(&arp_tbl, sha, &sip, dev);

                       if (n) {

                                 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);

                                 neigh_release(n);

                       }

              }

              goto out;

     }

首先更新邻居表neigh_event_ns()，然后发送ARP响应 – arp_send。

至此，大致的ARP流程完成。由于ARP部分涉及到路由表以及邻居表，这都是很大的概念。




阅读全文
0 0
png格式打开软件 png格式打开软件
原创粉丝点击
热门IT博客
sql语言培训中心sql语言培训中心
百鸡问题的最简单算法百鸡问题的最简单算法
suse linux 12 iso
美国税收数据
淘宝所有宝贝的链接
app图片编辑软件
网络拓扑图素材下载
网络安全教育考试
ccs软件功能
php上传图片自动压缩
阿里云服务器修改密码
褥子什么材质的好 知乎
mysql语句实例
守望先锋显示数据
帮别人开淘宝店安全吗
win7远程桌面连接端口
万历十五年读后感知乎
淘宝开店投资多少
华为软件市场7.2
java linkedlist sort
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 饺子导演 导演 总导演 攀登者导演 娱乐小导演 大导演系统 陈情令导演 好莱坞导演 张艺谋导演 田羽生导演 导演系统 导演巨星 导演之王 电竞导演见 我是大导演 我大导演 著名导演 导演英语 香港导演 导演英文 导演 英语 导演专业 执行导演 中国的导演 中国导演 副导演 导演图片 大导演 知名导演 导演张扬 胡枚导演 张导演 导演麦曦茵 黄巧玲导演 张扬导演 导演阐述 揭秘焰火总导演 导演吴贻弓逝世 天云山传奇导演 中国机长导演 国庆晚会导演

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里