协议栈（Internet协议族）

net_proto_family

// net_families数组，NPROTO为37，表示最多支持37种协议族
static const struct net_proto_family *net_families[NPROTO] __read_mostly;
 
// Internet协议族
#define AF_INET    2  /* Internet IP Protocol    */
 
// PF_INET和AF_INET相同
#define PF_INET    AF_INET
 
struct net_proto_family {
   int       family;
   int       (*create)(struct net *net, struct socket *sock, int protocol); // 套接口层到传输层的创建接口
   struct module  *owner;
};
 
// Internet协议族的net_proto_family
static struct net_proto_family inet_family_ops = {
   .family = PF_INET,
   .create = inet_create,
   .owner = THIS_MODULE,
};

inet_protosw

// inetsws数组，SOCK_MAX为11，表示最多支持11种套接口类型
static struct list_head inetsw[SOCK_MAX];
 
struct inet_protosw {
   struct list_head list; // 链入inetsw数组
 
        /* These two fields form the lookup key.  */
   unsigned short  type;    /* This is the 2nd argument to socket(2). */
   unsigned short  protocol; /* This is the L4 protocol number.  */
 
   struct proto    *prot;
   const struct proto_ops *ops;
   
   int              capability; /* Which (if any) capability do
                  * we need to use this socket
                  * interface?
                                      */
   char             no_check;   /* checksum on rcv/xmit/none? */
   unsigned char   flags;      /* See INET_PROTOSW_* below.  */
};
 
// inetsw_array数组
static struct inet_protosw inetsw_array[] =
{
   {
      .type =       SOCK_STREAM,
      .protocol =   IPPROTO_TCP,
      .prot =       &tcp_prot,
      .ops =        &inet_stream_ops,
      .capability = -1,
      .no_check =   0,
      .flags =      INET_PROTOSW_PERMANENT |
               INET_PROTOSW_ICSK,
   },
 
   {
      .type =       SOCK_DGRAM,
      .protocol =   IPPROTO_UDP,
      .prot =       &udp_prot,
      .ops =        &inet_dgram_ops,
      .capability = -1,
      .no_check =   UDP_CSUM_DEFAULT,
      .flags =      INET_PROTOSW_PERMANENT,
   },
 
   {
      .type =       SOCK_RAW,
      .protocol =   IPPROTO_IP,   /* wild card */
      .prot =       &raw_prot,
      .ops =        &inet_sockraw_ops,
      .capability = CAP_NET_RAW,
      .no_check =   UDP_CSUM_DEFAULT,
      .flags =      INET_PROTOSW_REUSE,
   }
};

net_protocol

// inet_protos数组，MAX_INET_PROTOS为256，表示最多支持256种传输层协议
const struct net_protocol *inet_protos[MAX_INET_PROTOS] ____cacheline_aligned_in_smp;
 
IPPROTO_ICMP = 1,
IPPROTO_IGMP = 2,
IPPROTO_TCP = 6,
IPPROTO_UDP = 17,
 
struct net_protocol {
   int          (*handler)(struct sk_buff *skb); // 网络层到传输层的接收接口
   void         (*err_handler)(struct sk_buff *skb, u32 info);
   int          (*gso_send_check)(struct sk_buff *skb);
   struct sk_buff        *(*gso_segment)(struct sk_buff *skb,
                      int features);
   struct sk_buff       **(*gro_receive)(struct sk_buff **head,
                      struct sk_buff *skb);
   int          (*gro_complete)(struct sk_buff *skb);
   unsigned int      no_policy:1,
            netns_ok:1;
};
 
// ICMP
static const struct net_protocol icmp_protocol = {
   .handler = icmp_rcv,
   .no_policy =   1,
   .netns_ok =    1,
};
 
// IGMP
static const struct net_protocol igmp_protocol = {
   .handler = igmp_rcv,
   .netns_ok =    1,
};
 
// TCP
static const struct net_protocol tcp_protocol = {
   .handler = tcp_v4_rcv,
   .err_handler = tcp_v4_err,
   .gso_send_check = tcp_v4_gso_send_check,
   .gso_segment = tcp_tso_segment,
   .gro_receive = tcp4_gro_receive,
   .gro_complete =    tcp4_gro_complete,
   .no_policy =   1,
   .netns_ok =    1,
};
 
// UDP
static const struct net_protocol udp_protocol = {
   .handler = udp_rcv,
   .err_handler = udp_err,
   .gso_send_check = udp4_ufo_send_check,
   .gso_segment = udp4_ufo_fragment,
   .no_policy =   1,
   .netns_ok =    1,
};

proto_ops

套接口层到传输层的接口

// TCP
const struct proto_ops inet_stream_ops = {
   .family          = PF_INET,
   .owner       = THIS_MODULE,
   .release      = inet_release,
   .bind        = inet_bind,
   .connect      = inet_stream_connect,
   .socketpair       = sock_no_socketpair,
   .accept          = inet_accept,
   .getname      = inet_getname,
   .poll        = tcp_poll,
   .ioctl       = inet_ioctl,
   .listen          = inet_listen,
   .shutdown     = inet_shutdown,
   .setsockopt       = sock_common_setsockopt,
   .getsockopt       = sock_common_getsockopt,
   .sendmsg      = tcp_sendmsg,
   .recvmsg      = sock_common_recvmsg,
   .mmap        = sock_no_mmap,
   .sendpage     = tcp_sendpage,
   .splice_read      = tcp_splice_read,
#ifdef CONFIG_COMPAT
   .compat_setsockopt = compat_sock_common_setsockopt,
   .compat_getsockopt = compat_sock_common_getsockopt,
#endif
};
 
// UDP
const struct proto_ops inet_dgram_ops = {
   .family          = PF_INET,
   .owner       = THIS_MODULE,
   .release      = inet_release,
   .bind        = inet_bind,
   .connect      = inet_dgram_connect,
   .socketpair       = sock_no_socketpair,
   .accept          = sock_no_accept,
   .getname      = inet_getname,
   .poll        = udp_poll,
   .ioctl       = inet_ioctl,
   .listen          = sock_no_listen,
   .shutdown     = inet_shutdown,
   .setsockopt       = sock_common_setsockopt,
   .getsockopt       = sock_common_getsockopt,
   .sendmsg      = inet_sendmsg,
   .recvmsg      = sock_common_recvmsg,
   .mmap        = sock_no_mmap,
   .sendpage     = inet_sendpage,
#ifdef CONFIG_COMPAT
   .compat_setsockopt = compat_sock_common_setsockopt,
   .compat_getsockopt = compat_sock_common_getsockopt,
#endif
};
 
// RAW
static const struct proto_ops inet_sockraw_ops = {
   .family          = PF_INET,
   .owner       = THIS_MODULE,
   .release      = inet_release,
   .bind        = inet_bind,
   .connect      = inet_dgram_connect,
   .socketpair       = sock_no_socketpair,
   .accept          = sock_no_accept,
   .getname      = inet_getname,
   .poll        = datagram_poll,
   .ioctl       = inet_ioctl,
   .listen          = sock_no_listen,
   .shutdown     = inet_shutdown,
   .setsockopt       = sock_common_setsockopt,
   .getsockopt       = sock_common_getsockopt,
   .sendmsg      = inet_sendmsg,
   .recvmsg      = sock_common_recvmsg,
   .mmap        = sock_no_mmap,
   .sendpage     = inet_sendpage,
#ifdef CONFIG_COMPAT
   .compat_setsockopt = compat_sock_common_setsockopt,
   .compat_getsockopt = compat_sock_common_getsockopt,
#endif
};

proto

传输层到网络层的接口

// TCP
struct proto tcp_prot = {
   .name        = "TCP",
   .owner       = THIS_MODULE,
   .close       = tcp_close,
   .connect      = tcp_v4_connect,
   .disconnect       = tcp_disconnect,
   .accept          = inet_csk_accept,
   .ioctl       = tcp_ioctl,
   .init        = tcp_v4_init_sock,
   .destroy      = tcp_v4_destroy_sock,
   .shutdown     = tcp_shutdown,
   .setsockopt       = tcp_setsockopt,
   .getsockopt       = tcp_getsockopt,
   .recvmsg      = tcp_recvmsg,
   .backlog_rcv      = tcp_v4_do_rcv,
   .hash        = inet_hash,
   .unhash          = inet_unhash,
   .get_port     = inet_csk_get_port,
   .enter_memory_pressure = tcp_enter_memory_pressure,
   .sockets_allocated = &tcp_sockets_allocated,
   .orphan_count     = &tcp_orphan_count,
   .memory_allocated  = &tcp_memory_allocated,
   .memory_pressure   = &tcp_memory_pressure,
   .sysctl_mem       = sysctl_tcp_mem,
   .sysctl_wmem      = sysctl_tcp_wmem,
   .sysctl_rmem      = sysctl_tcp_rmem,
   .max_header       = MAX_TCP_HEADER,
   .obj_size     = sizeof(struct tcp_sock),
   .slab_flags       = SLAB_DESTROY_BY_RCU,
   .twsk_prot    = &tcp_timewait_sock_ops,
   .rsk_prot     = &tcp_request_sock_ops,
   .h.hashinfo       = &tcp_hashinfo,
#ifdef CONFIG_COMPAT
   .compat_setsockopt = compat_tcp_setsockopt,
   .compat_getsockopt = compat_tcp_getsockopt,
#endif
};
 
// UDP
struct proto udp_prot = {
   .name        = "UDP",
   .owner       = THIS_MODULE,
   .close       = udp_lib_close,
   .connect      = ip4_datagram_connect,
   .disconnect       = udp_disconnect,
   .ioctl       = udp_ioctl,
   .destroy      = udp_destroy_sock,
   .setsockopt       = udp_setsockopt,
   .getsockopt       = udp_getsockopt,
   .sendmsg      = udp_sendmsg,
   .recvmsg      = udp_recvmsg,
   .sendpage     = udp_sendpage,
   .backlog_rcv      = __udp_queue_rcv_skb,
   .hash        = udp_lib_hash,
   .unhash          = udp_lib_unhash,
   .get_port     = udp_v4_get_port,
   .memory_allocated  = &udp_memory_allocated,
   .sysctl_mem       = sysctl_udp_mem,
   .sysctl_wmem      = &sysctl_udp_wmem_min,
   .sysctl_rmem      = &sysctl_udp_rmem_min,
   .obj_size     = sizeof(struct udp_sock),
   .slab_flags       = SLAB_DESTROY_BY_RCU,
   .h.udp_table      = &udp_table,
#ifdef CONFIG_COMPAT
   .compat_setsockopt = compat_udp_setsockopt,
   .compat_getsockopt = compat_udp_getsockopt,
#endif
};
 
// RAW
struct proto raw_prot = {
   .name        = "RAW",
   .owner       = THIS_MODULE,
   .close       = raw_close,
   .destroy      = raw_destroy,
   .connect      = ip4_datagram_connect,
   .disconnect       = udp_disconnect,
   .ioctl       = raw_ioctl,
   .init        = raw_init,
   .setsockopt       = raw_setsockopt,
   .getsockopt       = raw_getsockopt,
   .sendmsg      = raw_sendmsg,
   .recvmsg      = raw_recvmsg,
   .bind        = raw_bind,
   .backlog_rcv      = raw_rcv_skb,
   .hash        = raw_hash_sk,
   .unhash          = raw_unhash_sk,
   .obj_size     = sizeof(struct raw_sock),
   .h.raw_hash       = &raw_v4_hashinfo,
#ifdef CONFIG_COMPAT
   .compat_setsockopt = compat_raw_setsockopt,
   .compat_getsockopt = compat_raw_getsockopt,
#endif
};