网络配置过程分析(linux网络协议栈笔记)

网络配置过程分析

#ifconfig –a
eth0        Link encap:Ethernet HWaddr 00:80:C8:EB:2A:39
BROADCAST MULTICAST MTU:1500 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:0 ( 0.0 b) Interrupt:5
lo         Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:6 errors:0 dropped:0 overruns:0 frame:0
TX packets:6 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)

#strace ifconfig eth0 192.168.18.2 netmask 255.255.255.0

main(int argc, char **argv )
1. {
2. struct sockaddr sa;
3. struct sockaddr_in sin;
4. char host[128];
5. struct aftype *ap;
6. struct hwtype *hw;
7. struct ifreq ifr;
8. char **spp;
9. int fd;
10.
11. fd = socket
12. ifr.ifr_name = “eth0”; (PF_INET, SOCK_DGRAM, IPPROTO_IP);
13. ap = inet_aftype =
14. {
15. "inet", NULL, /*"DARPA Internet", */ AF_INET, sizeof(unsigned long),
16. INET_print, INET_sprint, INET_input, INET_reserror,
17. NULL /*INET_rprint */ , NULL /*INET_rinput */ ,
18. INET_getnetmask,
19. -1, /* 这个值会被赋成fd，即刚才打开的socket */
20. NULL
21. };
22. host = “192.168.18.2”;
23. ap->input(0, host, &sa);  /* 在此sa->sa_family=AF_INET，af->sa_data已经被设置成192.168.1.1 */
24. memcpy((char *) &ifr.ifr_addr, (char *) &sa, sizeof(struct sockaddr));
25. ioctl (fd, SIOCSIFADDR, &ifr);
26. ioctl (skfd, SIOCGIFFLAGS, &ifr);
27. ioctl
28. /* 开始第二次遍历命令行*/ (skfd, SIOCSIFFLAGS, &ifr);
29. host = “255.255.255.0”;
30. ioctl
31. (skfd, SIOCSIFNETMASK, ifr);
32. }

socket系统调用

struct socket {
struct proto_ops *ops;
struct file *file;
struct sock *sk;
wait_queue_head_t wait;
short type;
……
};

socket{ }

msghdr{ }

sock{ }

sk_buff{ }

sys_soceket

sock_mnt

sock_mnt

file->f_dentry

int 0x80

sys_socket

int family

int type

int protocol

security_socket_create

sock_alloc

struct socket{}

mnt_sb->s_op->alloc_inode

super_operations sockfs_ops

sock_alloc_inode

kmem_cache_alloc

socket_alloc{}

alloc_inode

sock_alloc( )

socket_alloc

socket_alloc

socket{ }

sock_alloc

inode slab cache

SOCKET_I

SOCK_INODE

file_operations

socket_file_ops

1. /*
2. Socket类型的文件系统和其他文件系统一样有一个特别的操作集合， 但是有相当一部分操作是经过直接调用系统接口而不是通过这个操作集合来完成。
3. */
4.
5. static struct file_operations socket_file_ops = {
6.       .owner = THIS_MODULE,
7.      .llseek = no_llseek,
8.      ......
9.      .poll = sock_poll,
10.     .unlocked_ioctl = sock_ioctl,
11.     .open = sock_no_open, /* 这个open操作明显是socket系统不支持的*/
12.     .release = sock_close,
13.     ......
14.     .readv = sock_readv,
15.     .writev = sock_writev,
16.     .......
17. };

super_operations

sockfs_ops

file_operations

socket_file_ops

write( )

read( )

send( )

recv( )

PF_INET

socket_create

net_families[family]->create(sock, protocol)

net_families[PF_INET]

inet_create

sock->type

inetsw[]

inet_create

static int inet_create(struct net *net, struct socket *sock, int protocol,
int kern)
{
struct sock *sk;
struct inet_protosw *answer;
struct inet_sock *inet;
struct proto *answer_prot;
unsigned char answer_flags;
char answer_no_check;
int try_loading_module = 0;
int err;

sock->state = SS_UNCONNECTED;

/* Look for the requested type/protocol pair. */
lookup_protocol:
err = -ESOCKTNOSUPPORT;
rcu_read_lock();
/*  从inetsw中根据类型、协议查找相应的socket interface也就是 inet_protosw */
list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {

err = 0;
/* Check the non-wild match. */
if (protocol == answer->protocol) {
if (protocol != IPPROTO_IP)
break;
} else {
/* Check for the two wild cases. */
if (IPPROTO_IP == protocol) {
protocol = answer->protocol;
break;
}
if (IPPROTO_IP == answer->protocol)
break;
}
err = -EPROTONOSUPPORT;
}
/*如果没有找到，尝试加载模块*/
if (unlikely(err)) {
if (try_loading_module < 2) {
rcu_read_unlock();
/*
* Be more specific, e.g. net-pf-2-proto-132-type-1
* (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
*/
if (++try_loading_module == 1)
request_module("net-pf-%d-proto-%d-type-%d",
PF_INET, protocol, sock->type);
/*
* Fall back to generic, e.g. net-pf-2-proto-132
* (net-pf-PF_INET-proto-IPPROTO_SCTP)
*/
else
request_module("net-pf-%d-proto-%d",
PF_INET, protocol);
goto lookup_protocol;
} else
goto out_rcu_unlock;
}

err = -EPERM;
if (sock->type == SOCK_RAW && !kern &&
!ns_capable(net->user_ns, CAP_NET_RAW))
goto out_rcu_unlock;

sock->ops = answer->ops;
answer_prot = answer->prot;
answer_no_check = answer->no_check;
answer_flags = answer->flags;
rcu_read_unlock();

WARN_ON(answer_prot->slab == NULL);
/* sk_alloc表面上是生成一个sock的结构体，但是实际上对于tcp来说是一个tcp_sock的大小的结构体，这样就可以使用inet_sk(sk);进行强制的类型转换，具体是怎么分配的是tcp_sock大小的，在后续进行分析*/
err = -ENOBUFS;
sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);
if (sk == NULL)
goto out;

err = 0;
sk->sk_no_check = answer_no_check;
if (INET_PROTOSW_REUSE & answer_flags)
sk->sk_reuse = SK_CAN_REUSE;

inet = inet_sk(sk);
inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;

inet->nodefrag = 0;

if (SOCK_RAW == sock->type) {
inet->inet_num = protocol;
if (IPPROTO_RAW == protocol)
inet->hdrincl = 1;
}

if (net->ipv4.sysctl_ip_no_pmtu_disc)
inet->pmtudisc = IP_PMTUDISC_DONT;
else
inet->pmtudisc = IP_PMTUDISC_WANT;

inet->inet_id = 0;
/*对sk结构体中的变量进行初始化操作，*/
sock_init_data(sock, sk);------------------（1）

sk->sk_destruct          = inet_sock_destruct;
sk->sk_protocol           = protocol;
sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;

inet->uc_ttl      = -1;
inet->mc_loop = 1;
inet->mc_ttl     = 1;
inet->mc_all     = 1;
inet->mc_index        = 0;
inet->mc_list   = NULL;
inet->rcv_tos   = 0;

sk_refcnt_debug_inc(sk);

if (inet->inet_num) {
/* It assumes that any protocol which allows
* the user to assign a number at socket
* creation time automatically
* shares.
*/
inet->inet_sport = htons(inet->inet_num);
/* Add to protocol hash chains. */
sk->sk_prot->hash(sk);
}

if (sk->sk_prot->init) {
err = sk->sk_prot->init(sk);//如果是tcp的话，这里就是tcp_v4_init_sock--------（2）
if (err)
sk_common_release(sk);
}
out:
return err;
out_rcu_unlock:
rcu_read_unlock();
goto out;
}

sock{ }

socket{ }

socket{}

sock{ }

sk->sk_protocol

backlog_rcv

tcp_v4_do_rcv

udp_queue_rcv_skb

raw_rcv_skb

sys_socket

file{ }

socket{ }

sock{ }

sock_map_fd

<file, socket，sock>

inet_create

sock{}

sk_alloc

sock{}

raw_sock

tcp_sock

proto_ops

sock{}

inet_sk

sock{}

inet_sock{}

udp_sk

sock{}

udp_sock{}

tcp_sk

sock{}

tcp_sock{}

raw_sk

sock{}

raw_sock{}

ioctl代码的实现

sys_ioctl

socket_file_ops

struct ifreq {
#define IFHWADDRLEN 6
union
{
char    ifrn_name[IFNAMSIZ];        /* if name, e.g. "en0" */
} ifr_ifrn;

union {
struct  sockaddr ifru_addr;
struct  sockaddr ifru_dstaddr;
struct  sockaddr ifru_broadaddr;
struct  sockaddr ifru_netmask;
struct  sockaddr ifru_hwaddr;
short   ifru_flags;
int ifru_ivalue;
int ifru_mtu;
struct  ifmap ifru_map;
char    ifru_slave[IFNAMSIZ];   /* Just fits the size */
char    ifru_newname[IFNAMSIZ];
void __user *   ifru_data;
struct  if_settings ifru_settings;
} ifr_ifru;
};

devinet_ioctl

copy_from_user(&ifr, arg, sizeof(struct ifreq))

unsigned long

SIOCSIFADDR

SIOCSIFFLAGS

SIOCSIFNETMASK

devinet_ioctl

int devinet_ioctl(unsigned int cmd, void *arg)
{
struct ifreq ifr;
struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
struct in_device *in_dev;
struct in_ifaddr **ifap = NULL;
struct in_ifaddr *ifa = NULL;
struct net_device *dev;
char *colon;
int ret = 0;

/*
*    Fetch the caller's info block into kernel space
*/

if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
return -EFAULT;
ifr.ifr_name[IFNAMSIZ-1] = 0;

colon = strchr(ifr.ifr_name, ':');
if (colon)
*colon = 0;

#ifdef CONFIG_KMOD
dev_load(ifr.ifr_name);
#endif

switch(cmd) {        //根據cmd對參數進行檢查
case SIOCGIFADDR:    /* Get interface address */
case SIOCGIFBRDADDR:    /* Get the broadcast address */
case SIOCGIFDSTADDR:    /* Get the destination address */
case SIOCGIFNETMASK:    /* Get the netmask for the interface */
/* Note that this ioctls will not sleep,
so that we do not impose a lock.
One day we will be forced to put shlock here (I mean SMP)
*/
memset(sin, 0, sizeof(*sin));
sin->sin_family = AF_INET;
break;

case SIOCSIFFLAGS:
if (!capable(CAP_NET_ADMIN))
return -EACCES;
break;
case SIOCSIFADDR:    /* Set interface address (and family) */
case SIOCSIFBRDADDR:    /* Set the broadcast address */
case SIOCSIFDSTADDR:    /* Set the destination address */
case SIOCSIFNETMASK:     /* Set the netmask for the interface */
if (!capable(CAP_NET_ADMIN))
return -EACCES;
if (sin->sin_family != AF_INET)
return -EINVAL;
break;
default:
return -EINVAL;
}
//鎖
dev_probe_lock();
rtnl_lock();
//獲取設備名對應的設備的數據結構（描述一個設備）
if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL) {
ret = -ENODEV;
goto done;
}

if (colon)
*colon = ':';

if ((in_dev=__in_dev_get(dev)) != NULL) {                //查找對應的設備名
for (ifap=&in_dev->ifa_list; (ifa=*ifap) != NULL; ifap=&ifa->ifa_next)
if (strcmp(ifr.ifr_name, ifa->ifa_label) == 0)
break;
}

if (ifa == NULL && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) {
ret = -EADDRNOTAVAIL;
goto done;
}

switch(cmd) {                                            //在對應的設備上進行操作
case SIOCGIFADDR:    /* Get interface address */        //獲取IP
sin->sin_addr.s_addr = ifa->ifa_local;
goto rarok;

case SIOCGIFBRDADDR:    /* Get the broadcast address */
sin->sin_addr.s_addr = ifa->ifa_broadcast;
goto rarok;

case SIOCGIFDSTADDR:    /* Get the destination address */
sin->sin_addr.s_addr = ifa->ifa_address;
goto rarok;

case SIOCGIFNETMASK:    /* Get the netmask for the interface */
sin->sin_addr.s_addr = ifa->ifa_mask;
goto rarok;

case SIOCSIFFLAGS:
if (colon) {
if (ifa == NULL) {
ret = -EADDRNOTAVAIL;
break;
}
if (!(ifr.ifr_flags&IFF_UP))
inet_del_ifa(in_dev, ifap, 1);
break;
}
ret = dev_change_flags(dev, ifr.ifr_flags);
break;

case SIOCSIFADDR:    /* Set interface address (and family) */
if (inet_abc_len(sin->sin_addr.s_addr) < 0) {
ret = -EINVAL;
break;
}

if (!ifa) {
if ((ifa = inet_alloc_ifa()) == NULL) {
ret = -ENOBUFS;
break;
}
if (colon)
memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
else
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
} else {
ret = 0;
if (ifa->ifa_local == sin->sin_addr.s_addr)
break;
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_broadcast = 0;
ifa->ifa_anycast = 0;
}

ifa->ifa_address =
ifa->ifa_local = sin->sin_addr.s_addr;            //設置IP

if (!(dev->flags&IFF_POINTOPOINT)) {
ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
if ((dev->flags&IFF_BROADCAST) && ifa->ifa_prefixlen < 31)
ifa->ifa_broadcast = ifa->ifa_address|~ifa->ifa_mask;
} else {
ifa->ifa_prefixlen = 32;
ifa->ifa_mask = inet_make_mask(32);
}
ret = inet_set_ifa(dev, ifa);
break;

case SIOCSIFBRDADDR:    /* Set the broadcast address */
if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_broadcast = sin->sin_addr.s_addr;
inet_insert_ifa(ifa);
}
break;

case SIOCSIFDSTADDR:    /* Set the destination address */
if (ifa->ifa_address != sin->sin_addr.s_addr) {
if (inet_abc_len(sin->sin_addr.s_addr) < 0) {
ret = -EINVAL;
break;
}
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_address = sin->sin_addr.s_addr;
inet_insert_ifa(ifa);
}
break;

case SIOCSIFNETMASK:     /* Set the netmask for the interface */

/*
*    The mask we set must be legal.
*/
if (bad_mask(sin->sin_addr.s_addr, 0)) {
ret = -EINVAL;
break;
}

if (ifa->ifa_mask != sin->sin_addr.s_addr) {
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_mask = sin->sin_addr.s_addr;
ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
inet_insert_ifa(ifa);
}
break;
}
done:
rtnl_unlock();
dev_probe_unlock();
return ret;

rarok:
rtnl_unlock();
dev_probe_unlock();
if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
return -EFAULT;
return 0;
}

SIOCSIFADDR

in_ifaddr{}

inet_set_ifa

in_dev{}

static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
{
struct in_device *in_dev = __in_dev_get(dev);

if (!in_dev) {
in_dev = inetdev_init(dev);
．．．．．．
}
if (ifa->ifa_dev != in_dev) {
ifa->ifa_dev = in_dev;
}
/**如果是loopback地址，那么该地址的scope是本机范围，否则还是初始值0，即UNIVERSE。**/
if (LOOPBACK(ifa->ifa_local))
ifa->ifa_scope = RT_SCOPE_HOST;
return inet_insert_ifa(ifa);
}

in_device

static struct in_device *inetdev_init(struct net_device *dev)
{
struct in_device *in_dev;
ASSERT_RTNL();

in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
if (!in_dev)
goto out;
memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
sizeof(in_dev->cnf));//这里对in_dev->cnt进行初始化操作，
in_dev->cnf.sysctl = NULL;
in_dev->dev = dev;
if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
goto out_kfree;
if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
dev_disable_lro(dev);
/* Reference in_dev->dev */
dev_hold(dev);
/* Account for reference dev->ip_ptr (below) */
in_dev_hold(in_dev);

devinet_sysctl_register(in_dev);
ip_mc_init_dev(in_dev);
if (dev->flags & IFF_UP)
ip_mc_up(in_dev);

/* we can receive as soon as ip_ptr is set -- do this last */
rcu_assign_pointer(dev->ip_ptr, in_dev);//使用RCU保护锁机制对dev->ip_ptr进行赋值
out:
return in_dev;
out_kfree:
kfree(in_dev);
in_dev = NULL;
goto out;
}

in_ifaddr{}

net_device{}

in_device{}

in_ifaddr{}

rtmsg_ifa

blocking_notifier_call_chain

inetaddr_chain

netlink和rtnetlink接口

netlink_broadcast

fib_convert_rtentry（int cmd, struct nlmsghdr *nl, struct rtmsg *rtm, struct kern_rta *rta, struct rtentry *r)

nlmsghdr{}

rtmmsg{}

kern_rta{}

AF_NETLINK

fd ＝ socket(PF_NETLINK, socket_type, netlink_family);

socket_type

SOCK_RAW

SOCK_DGRAM

netlink_family

NETLINK_ROUTE

NETLINK_ARPD

NETLINK_USERSOCK

PF_NETLINK

netlink_family

NETLINK_ROUTE

netlink_broadcast

rtnetlink_rcv

inet_insert_ifa

inet_fill_ifaddr

netlink_broadcast

static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
{
int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);

if (inet_fill_ifaddr(skb, ifa, current->pid, 0, event, 0) < 0) {
//错误处理
} else {
//下面这个函数会通知阻塞在某个netlink下的回调函数，然后让它们进行处理。不过要注意，rtnl是一个sock{}结构的全局变量
netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL);
}
}

rtnetlink_rcv

inet_rtm_newaddr

inet_rtm_newroute

inet_rtm_delroute

struct rtmsg
{
unsigned char         rtm_family;           /*路由地址族*/
unsigned char         rtm_dst_len;          /*length of destination*/
unsigned char         rtm_src_len;          /*length of source*/
unsigned char         rtm_tos;                /*TOS filter*/

unsigned char         rtm_table;             /*Routing table id*/
unsigned char         rtm_protocol;               /*路由协议*/
unsigned char         rtm_scope;
unsigned char         rtm_type;

unsigned int           rtm_flags;
}

RTPROT_STATIC