从udp_sendmsg到ip_output发包过程

从udp_sendmsg到ip_output发包过程：

udp_sendmsg->udp_send_skb->ip_send_skb->ip_local_out->ip_local_out_sk->__ip_local_out->__ip_local_out_sk->dst_output_sk->ip_output；在dst_output_sk函数中调用了skb_dst(skb)->output(sk, skb);

一、udp_sendmsg

UDP socket在传输层调用的发送函数为udp_sendmsg，这个函数内容好多。

首先获取发送的目的地址和目的端口，然后处理控制信息，接着选路，最后生成skb，将数据发送出去。发送报文时的skb就是在这个函数中生成的。

这个函数中有两个变量需要重点关注：corkreq、up->pending，这两个变量决定了udp_sendmsg函数的流程走向。

corkreq：表示是否使用缓冲机制，是否阻塞，意思就是把多个短的数据合成一个长的数据发送。

up->pending：表示当前sock还有数据没有发送到ip层，一般在设置了CORK标记的场景下才会设置这个标记。

转载自：

https://blog.packagecloud.io/eng/2017/02/06/monitoring-tuning-linux-networking-stack-sending-data/#udp_sendmsg

http://arthurchiao.art/blog/tuning-stack-tx-zh/#chap_5.1

http://blog.chinaunix.net/uid-14528823-id-4468600.html

int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct udp_sock *up = udp_sk(sk);
	struct flowi4 fl4_stack;
	struct flowi4 *fl4;
	int ulen = len;
	struct ipcm_cookie ipc;
	struct rtable *rt = NULL;
	int free = 0;
	int connected = 0;
	__be32 daddr, faddr, saddr;
	__be16 dport;
	u8  tos;
	/*获取pcflag标志确定该套接字是普通的UDP套接字还是轻量级套接字*/
	int err, is_udplite = IS_UDPLITE(sk);
	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
	struct sk_buff *skb;
	struct ip_options_data opt_copy;

	/*UDP数据报最长为64KB*/
	if (len > 0xFFFF)
		return -EMSGSIZE;

	/*
	 *	Check the flags.
	 */
	/*UDP不支持发送带外数据，如果发送标志中设置了MSG_OOB，则返回*/
	if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
		return -EOPNOTSUPP;

	ipc.opt = NULL;
	ipc.tx_flags = 0;
	ipc.ttl = 0;
	ipc.tos = -1;

	getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;

	fl4 = &inet->cork.fl.u.ip4;
        /*当前的sock有等待发送的数据，直接将数据追加*/
	if (up->pending) {
		/*
		 * There are pending frames.
		 * The socket lock must be held while it's corked.
		 */
		lock_sock(sk);
		if (likely(up->pending)) {
			if (unlikely(up->pending != AF_INET)) {
				release_sock(sk);
				return -EINVAL;
			}
			goto do_append_data;
		}
		release_sock(sk);
	}
	
	/*UDP数据报长度，包括UDP data + UDP header*/
	ulen += sizeof(struct udphdr);

	/*
	 *	Get and verify the address.
	 */
	/*获取目的IP地址和端口：目的地址和端口有两个可能的来源：
	1. 如果之前socket已经建立，那socket本身就存储了目标地址；
	2. 地址通过msghdr传入，通常为调用sendto发送UDP数据*/
	if (msg->msg_name) {
		/*地址信息保存到usin中*/
		DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
		if (msg->msg_namelen < sizeof(*usin))
			return -EINVAL;
		if (usin->sin_family != AF_INET) {
			if (usin->sin_family != AF_UNSPEC)
				return -EAFNOSUPPORT;
		}

		daddr = usin->sin_addr.s_addr;
		dport = usin->sin_port;
		if (dport == 0)
			return -EINVAL;
	} else {
		/*msg没有目的地址的情况：通常为先调用了connect,然后调用send发送UDP数据，
		UDP套接字调用connetc之后，UDP传输控制块状态为TCP_ESTABLISHED*/
		if (sk->sk_state != TCP_ESTABLISHED)
		/*即没有指明目的地址，又没有建立connect连接，则返错。*/
			return -EDESTADDRREQ;
		daddr = inet->inet_daddr;
		dport = inet->inet_dport;
		/* Open fast path for connected socket.
		   Route will not be used, if at least one option is set.
		 */
		connected = 1;
	}
	
	/*获取存储在 socket 上的源地址、发送网络设备索引（device index）和时间戳选项*/
	ipc.addr = inet->inet_saddr;
	ipc.oif = sk->sk_bound_dev_if;

	sock_tx_timestamp(sk, &ipc.tx_flags);

	/*msg中控制信息处理*/
	if (msg->msg_controllen) {
		/*调用ip_cmsg_send处理控制信息，包括IP选项等...*/
		err = ip_cmsg_send(sock_net(sk), msg, &ipc,
				   sk->sk_family == AF_INET6);
		if (unlikely(err)) {
			kfree(ipc.opt);
			return err;
		}
		if (ipc.opt)
			free = 1;
		connected = 0;
	}
	/*如果发送的数据中没有IP选项控制信息，则从正在使用的socket中获取IP选项信息*/
	if (!ipc.opt) {
		struct ip_options_rcu *inet_opt;

		rcu_read_lock();
		inet_opt = rcu_dereference(inet->inet_opt);
		if (inet_opt) {
			memcpy(&opt_copy, inet_opt,
			       sizeof(*inet_opt) + inet_opt->opt.optlen);
			ipc.opt = &opt_copy.opt;
		}
		rcu_read_unlock();
	}

	saddr = ipc.addr;
	ipc.addr = faddr = daddr;

	/*源路由选项处理*/
	if (ipc.opt && ipc.opt->opt.srr) {
		if (!daddr)
			return -EINVAL;
		faddr = ipc.opt->opt.faddr;
		connected = 0;
	}
	tos = get_rttos(&ipc, inet);
	if (sock_flag(sk, SOCK_LOCALROUTE) ||
	    (msg->msg_flags & MSG_DONTROUTE) ||
	    (ipc.opt && ipc.opt->opt.is_strictroute)) {
		tos |= RTO_ONLINK;
		connected = 0;
	}

	/*多播报文处理*/
	if (ipv4_is_multicast(daddr)) {
		if (!ipc.oif)
			ipc.oif = inet->mc_index;
		if (!saddr)
			saddr = inet->mc_addr;
		connected = 0;
	} else if (!ipc.oif)
		ipc.oif = inet->uc_index;

	/*路由相关处理，获取对应的路由缓存*/
	if (connected)
		rt = (struct rtable *)sk_dst_check(sk, 0);

	if (!rt) {
		struct net *net = sock_net(sk);

		fl4 = &fl4_stack;
		flowi4_init_output(fl4, ipc.oif, sk->sk_mark, tos,
				   RT_SCOPE_UNIVERSE, sk->sk_protocol,
				   inet_sk_flowi_flags(sk),
				   faddr, saddr, dport, inet->inet_sport);

		security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
		rt = ip_route_output_flow(net, fl4, sk);
		if (IS_ERR(rt)) {
			err = PTR_ERR(rt);
			rt = NULL;
			if (err == -ENETUNREACH)
				IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
			goto out;
		}

		err = -EACCES;
		if ((rt->rt_flags & RTCF_BROADCAST) &&
		    !sock_flag(sk, SOCK_BROADCAST))
			goto out;
		if (connected)
			sk_dst_set(sk, dst_clone(&rt->dst));
	}

	if (msg->msg_flags&MSG_CONFIRM)
		goto do_confirm;
back_from_confirm:

	saddr = fl4->saddr;
	if (!ipc.addr)
		daddr = ipc.addr = fl4->daddr;

	/* Lockless fast path for the non-corking case. */
	/*快速路径(大部分情况下都没有使用CORK,直接新建skb，并直接发送*/
	if (!corkreq) {
	/*将sock相应的skb队列中的所有skb合并成一个数据报文(skb)，实际使用skb_shinfo->frag_list将所有skb连接起来。
        为什么要这样?这里将所有skb都合并后，可能导致这个包的size大于mtu，那到IP层的时候还会进行进一步分片?
        原因是:udp是面向数据报文的，报文必须完整，属于同一个报文的数据必须要放到同一个skb中，否则对端无法知道这是同一个报文。
        那IP层怎么处理呢?就不考虑同一个报文的问题?IP层分片会携带相关头信息，对端会根据这些信息进行重组，重组后对传输层来说就是一个报文。
        分片其实就是IP层应该负责的。此时IP分片实际就是将原来skb->frag_list中的skb摘出来，不会做其它的操作，效率很高。*/
		skb = ip_make_skb(sk, fl4, getfrag, msg, ulen,
				  sizeof(struct udphdr), &ipc, &rt,
				  msg->msg_flags);
		err = PTR_ERR(skb);
		if (!IS_ERR_OR_NULL(skb))
			err = udp_send_skb(skb, fl4);
		goto out;
	}

	lock_sock(sk);
	if (unlikely(up->pending)) {
		/* The socket is already corked while preparing it. */
		/* ... which is an evident application bug. --ANK */
		release_sock(sk);

		net_dbg_ratelimited("cork app bug 2\n");
		err = -EINVAL;
		goto out;
	}
	/*
	 *	Now cork the socket to pend data.
	 */
	/*缓存目的地址、目的端口、源地址和源端口信息，便于在发送处理时方便获取信息。*/
	fl4 = &inet->cork.fl.u.ip4;
	fl4->daddr = daddr;
	fl4->saddr = saddr;
	fl4->fl4_dport = dport;
	fl4->fl4_sport = inet->inet_sport;
	/*设置AF_INET标记，表明正在处理UDP数据包*/
	up->pending = AF_INET;

do_append_data:
	up->len += ulen;
	/*调用IP层接口函数ip_append_data，进入IP层处理，主要工作为:
        将数据拷贝到适合的skb(利用发送队列中现有的或新创建)中，可能有两种情况: 1. 放入skb的线性
        区(skb->data)中，或者放入skb_shared_info的分片(frag)中，同时还需要考虑MTU对skb数据进行分割。*/
	err = ip_append_data(sk, fl4, getfrag, msg, ulen,
			     sizeof(struct udphdr), &ipc, &rt,
			     corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
	if (err)
		udp_flush_pending_frames(sk);
	else if (!corkreq)
		/*发送UDP数据报*/
		err = udp_push_pending_frames(sk);
	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
		up->pending = 0;
	release_sock(sk);

out:
	ip_rt_put(rt);
	if (free)
		kfree(ipc.opt);
	if (!err)
		return len;
	/*
	 * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
	 * ENOBUFS might not be good (it's not tunable per se), but otherwise
	 * we don't have a good statistic (IpOutDiscards but it can be too many
	 * things).  We could add another new stat but at least for now that
	 * seems like overkill.
	 */
	if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
		UDP_INC_STATS_USER(sock_net(sk),
				UDP_MIB_SNDBUFERRORS, is_udplite);
	}
	return err;

do_confirm:
	dst_confirm(&rt->dst);
	if (!(msg->msg_flags&MSG_PROBE) || len)
		goto back_from_confirm;
	err = 0;
	goto out;
}

二、ip_make_skb

这个函数中调用__ip_append_data将要发送的数据组织成一个个skb；

调用__ip_make_skb将sock相应的skb队列中的所有skb合并成一个数据报文(skb)，使用skb_shinfo->frag_list将所有skb连接起来。

这两个函数的分析后面都有。

struct sk_buff *ip_make_skb(struct sock *sk,
			    struct flowi4 *fl4,
			    int getfrag(void *from, char *to, int offset,
					int len, int odd, struct sk_buff *skb),
			    void *from, int length, int transhdrlen,
			    struct ipcm_cookie *ipc, struct rtable **rtp,
			    unsigned int flags)
{
	struct inet_cork cork;
	struct sk_buff_head queue;
	int err;

	if (flags & MSG_PROBE)
		return NULL;

	__skb_queue_head_init(&queue);

	cork.flags = 0;
	cork.addr = 0;
	cork.opt = NULL;
	err = ip_setup_cork(sk, &cork, ipc, rtp);
	if (err)
		return ERR_PTR(err);

	err = __ip_append_data(sk, fl4, &queue, &cork,
			       &current->task_frag, getfrag,
			       from, length, transhdrlen, flags);
	if (err) {
		__ip_flush_pending_frames(sk, &queue, &cork);
		return ERR_PTR(err);
	}

	return __ip_make_skb(sk, fl4, &queue, &cork);
}

三、udp_send_skb

主要作用：

1.skb生成UDP头；

2.处理校验和：软件校验和、硬件校验和、无校验和（如果禁用）；

3.调用ip_send_skb将skb发往ip层处理；

4.更新发送成功或失败的统计计数器。

static int udp_send_skb(struct sk_buff *skb, struct flowi4 *fl4)
{
	struct sock *sk = skb->sk;
	struct inet_sock *inet = inet_sk(sk);
	struct udphdr *uh;
	int err = 0;
	int is_udplite = IS_UDPLITE(sk);
	int offset = skb_transport_offset(skb);
	int len = skb->len - offset;
	__wsum csum = 0;

	/*
	 * Create a UDP header
	 */
	/*生成udp头*/
	uh = udp_hdr(skb);
	uh->source = inet->inet_sport;
	uh->dest = fl4->fl4_dport;
	uh->len = htons(len);
	uh->check = 0;

	/*处理轻量级UDP校验和*/
	if (is_udplite)  				 /*     UDP-Lite      */
		csum = udplite_csum(skb);

	/*如果socket校验和选项被关闭，(setsockopt带SO_NO_CHECK参数)，将不进行校验*/
	else if (sk->sk_no_check_tx) {   /* UDP csum disabled */

		skb->ip_summed = CHECKSUM_NONE;
		goto send;
	} 
	/*如果硬件支持校验和，将调用udp4_hwcsum来设置它。如果数据包是分段的，内核将在
	软件中生成校验和，在udp4_hwcsum源码中可以看到这一点。*/
	else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */

		udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
		goto send;
	} 
	/*调用udp_csum生成校验和*/
	else
		csum = udp_csum(skb);

	/* add protocol-dependent pseudo-header */
	/*添加伪头，生成校验字*/
	uh->check = csum_tcpudp_magic(fl4->saddr, fl4->daddr, len,
				      sk->sk_protocol, csum);
					  
	/*如果校验和为 0，则根据RFC 768，校验为全 1*/
	if (uh->check == 0)
		uh->check = CSUM_MANGLED_0;

send:
	err = ip_send_skb(sock_net(sk), skb);
	/*发送失败，并且错误是ENOBUFS(没有内存)、且错误queue(inet->recverr)没有启用，更新NDBUFERRORS*/
	if (err) {
		if (err == -ENOBUFS && !inet->recverr) {
			UDP_INC_STATS_USER(sock_net(sk),
					   UDP_MIB_SNDBUFERRORS, is_udplite);
			err = 0;
		}
	} 
	/*发送成功，更新OUTDATAGRAMS统计*/
	else
		UDP_INC_STATS_USER(sock_net(sk),
				   UDP_MIB_OUTDATAGRAMS, is_udplite);
	return err;
}

1. ip_send_skb

这个函数很简单，直接调用 ip_local_out发送skb，如果调用失败，更新相应的统计计数。

int ip_send_skb(struct net *net, struct sk_buff *skb)
{
	int err;

	err = ip_local_out(skb);
	if (err) {
		if (err > 0)
			err = net_xmit_errno(err);
		if (err)
			IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
	}

	return err;
}

net_xmit_errno：将底层错误转换为IP和UDP层所能理解的错误，如果发成错误，更新IP协议的OUTDISCARDS统计。

2. ip_local_out

static inline int ip_local_out(struct sk_buff *skb)
{
	return ip_local_out_sk(skb->sk, skb);
}

3. ip_local_out_sk 

在这个函数中调用__ip_local_out发送skb。

int ip_local_out_sk(struct sock *sk, struct sk_buff *skb)
{
	int err;

	err = __ip_local_out(skb);
	if (likely(err == 1))
		err = dst_output_sk(sk, skb);

	return err;
}

 4. __ip_local_out

int __ip_local_out(struct sk_buff *skb)
{
	return __ip_local_out_sk(skb->sk, skb);
}

5. __ip_local_out_sk

1.设置IP数据包的总长度；

2.计算校验和；

3.通过IP层NF_INET_LOCAL_OUT hook函数，放行后调用des_output_sk函数继续发送skb。

注意这里如果程序中没有定义CONFIG_NETFILTER，nf_hook()是直接返回1的，所以在ip_local_out_sk函数中会继续调用显示调用dst_output_sk函数发送skb。

int __ip_local_out_sk(struct sock *sk, struct sk_buff *skb)
{
	struct iphdr *iph = ip_hdr(skb);

	iph->tot_len = htons(skb->len);
	ip_send_check(iph);
	return nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT, sk, skb, NULL,
		       skb_dst(skb)->dev, dst_output_sk);
}

6. dst_output_sk 

/* Output packet to network from transport.  */
static inline int dst_output_sk(struct sock *sk, struct sk_buff *skb)
{
	return skb_dst(skb)->output(sk, skb);
}

这个output函数指针是在哪里设置的了？

在udp_sendmsg函数中调用ip_route_output_flow设置的，调用关系为：

ip_route_output_flow->__ip_route_output_key->__mkroute_output，在__mkroute_output函数中设置rth->dst.output = ip_output;

ip_output函数就放到网络层继续分析了。

四、ip_append_data

参考：Understanding Linux Network Internals.pdf

https://blog.csdn.net/xiaoyu_750516366/article/details/84981102

http://blog.chinaunix.net/uid-14528823-id-4462540.html

这个函数的内容也很多，主要作用：
将传输层要发送的数据组织成一个个skb，将skb挂到sk->sk_write_queue的队列上。函数重点是如何将数据组织成对应的skb。
主要依据是MSG_MORE标记、设备是否支持分散/聚合IO。一个skb对应一个IP报文。

先看一下执行ip_append_data函数后，skb的组织结构。

1.就一个SKB能装下所有数据的时候，不需要分片，最简单。

2.需要分片，没有设置MSG_MORE，设备不支持NETIF_F_SG

3.需要分片，设置MSG_MORE，设备不支持NETIF_F_SG 

4.设备支持NETIF_F_SG（MSG_MORE设置与否不管）

5.设备不支持NETIF_F_SG（MSG_MORE设置与否不管） 

 

6.多个frags时，设备支持NETIF_F_SG（MSG_MORE设置与否不管）  

7.多个skb共用一个分页

8.几个小函数对比

9.关于间须fraggap

10.ip_append_data函数主要流程。

cork结构和 ipcm_cookie结构比较重要，还没来得及仔细分析，先把网友的粘贴过来了，感谢前人努力。

struct cork

inet_sock中的cork成员非常关键，它影响了多次连续的ip_append_data()调用过程中该函数的执行流程。

struct inet_sock {
...
	struct {
		// 可取下面的IPCORK_OPT和IPCORK_ALLFRAG两个值的组合
		unsigned int flags;
		// 记录一个IP片段可以容纳的数据量，其实就是mtu，之所以记录是为了不用每次都计算一遍
		unsigned int fragsize;
		// 保存了IP选项和路由信息
		struct ip_options *opt;
		struct rtable *rt;
		// 当前IP报文（注意不是IP片段）中已经放入的数据长度，初始化时为0
		int	length; /* Total length of all frames */
		__be32	addr;
		struct flowi fl;
	} cork;
};
#define IPCORK_OPT	1	/* ip-options has been held in ipcork.opt */
#define IPCORK_ALLFRAG	2	/* always fragment (for ipv6 for now) */

struct ipcm_cookie

该结构作为ip_append_data()的一个入参，让高层协议将一些控制信息传递给ip_append_data()。

struct ipcm_cookie
{
	// IP地址，UDP调用ip_append_data()时传递的是目的地址
	__be32 addr;
	// 出口设备的网络设备索引
	int	oif;
	// IP选项
	struct ip_options *opt;
};

ip_append_data 

/*
 *	ip_append_data() and ip_append_page() can make one large IP datagram
 *	from many pieces of data. Each pieces will be holded on the socket
 *	until ip_push_pending_frames() is called. Each piece can be a page
 *	or non-page data.
 *
 *	Not only UDP, other transport protocols - e.g. raw sockets - can use
 *	this interface potentially.
 *
 *	LATER: length must be adjusted by pad at tail, when it is required.
 */
int ip_append_data(struct sock *sk, struct flowi4 *fl4,
		   int getfrag(void *from, char *to, int offset, int len,
			       int odd, struct sk_buff *skb),
		   void *from, int length, int transhdrlen,
		   struct ipcm_cookie *ipc, struct rtable **rtp,
		   unsigned int flags)
{
	struct inet_sock *inet = inet_sk(sk);
	int err;

	if (flags&MSG_PROBE)
		return 0;

	if (skb_queue_empty(&sk->sk_write_queue)) {
		err = ip_setup_cork(sk, &inet->cork.base, ipc, rtp);
		if (err)
			return err;
	} 
	/*只有第一个skb需要设置传输层头，不为空时，表示sk_write_queue已有sbk，
	所以后面skb不用添加传输层头，transhdrlen设置为0*/
	else {
		transhdrlen = 0;
	}

	/*调用__ip_append_data函数完成主要功能*/
	return __ip_append_data(sk, fl4, &sk->sk_write_queue, &inet->cork.base,
				sk_page_frag(sk), getfrag,
				from, length, transhdrlen, flags);
}

 __ip_append_data

static int __ip_append_data(struct sock *sk,
			    struct flowi4 *fl4,
			    struct sk_buff_head *queue,
			    struct inet_cork *cork,
			    struct page_frag *pfrag,
			    int getfrag(void *from, char *to, int offset,
					int len, int odd, struct sk_buff *skb),
			    void *from, int length, int transhdrlen,
			    unsigned int flags)
{
	struct inet_sock *inet = inet_sk(sk);
	struct sk_buff *skb;

	struct ip_options *opt = cork->opt;
	int hh_len;
	int exthdrlen;
	int mtu;
	int copy;
	int err;
	int offset = 0;
	unsigned int maxfraglen, fragheaderlen, maxnonfragsize;
	int csummode = CHECKSUM_NONE;
	struct rtable *rt = (struct rtable *)cork->dst;
	u32 tskey = 0;

	skb = skb_peek_tail(queue);

	/*exthdrlen:扩展首部，是否启用扩展首部是由路由项决定的。*/
	exthdrlen = !skb ? rt->dst.header_len : 0;
	mtu = cork->fragsize;
	if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&
	    sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
		tskey = sk->sk_tskey++;

	/*L2层首部长度*/
	hh_len = LL_RESERVED_SPACE(rt->dst.dev);
	
	/*IP层首部长度，包括选项部分*/
	fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
	
	/*8字节对齐后，每个IP分配的最大长度，包括IP首部*/
	maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
	maxnonfragsize = ip_sk_ignore_df(sk) ? 0xFFFF : mtu;

	/*长度判断，由于IP首部的total字段占4个字节，所以一个IP报文的长度(包括IP首部)最大就是0XFFFF，
	多次调用ip_append_data函数后，可能会出现超过该值。*/
	if (cork->length + length > maxnonfragsize - fragheaderlen) {
		ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
			       mtu - (opt ? opt->optlen : 0));
		return -EMSGSIZE;
	}

	/*
	 * transhdrlen > 0 means that this is the first fragment and we wish
	 * it won't be fragmented in the future.
	 */
	/*校验相关，先忽略*/
	if (transhdrlen &&
	    length + fragheaderlen <= mtu &&
	    rt->dst.dev->features & NETIF_F_V4_CSUM &&
	    !exthdrlen)
		csummode = CHECKSUM_PARTIAL;

	/*更新sock中缓存的报文长度*/
	cork->length += length;
	
	/*这种情况下，调用ip_ufo_append_data处理，先忽略*/
	if ((((length + fragheaderlen) > mtu) || (skb && skb_is_gso(skb))) &&
	    (sk->sk_protocol == IPPROTO_UDP) &&
	    (rt->dst.dev->features & NETIF_F_UFO) && !rt->dst.header_len &&
	    (sk->sk_type == SOCK_DGRAM) && !sk->sk_no_check_tx) {
		err = ip_ufo_append_data(sk, queue, getfrag, from, length,
					 hh_len, fragheaderlen, transhdrlen,
					 maxfraglen, flags);
		if (err)
			goto error;
		return 0;
	}

	/* So, what's going on in the loop below?
	 *
	 * We use calculated fragment length to generate chained skb,
	 * each of segments is IP fragment ready for sending to network after
	 * adding appropriate IP header.
	 */

	/*sk_write_queue队列为空，即第一次填充数据，直接去分配skb*/
	if (!skb)
		goto alloc_new_skb;

	/*这个大循环中，将length长数据填充到skb中。*/
	while (length > 0) {
		/* Check if the remaining data fits into current packet. */
		/*判断最后一个skb的剩余空间是否能够容纳当前数据*/
		copy = mtu - skb->len;
		/*最后一个skb不用考虑8字节对齐，如果最后一个skb装不下，就需要考虑8字节对齐(后面还要新生成skb,它就不是最后一个skb了)，
		更新容纳量为maxfraglen - skb->len*/
		if (copy < length)
			copy = maxfraglen - skb->len;
		/*copy==0，表示该skb装满了，并且是8字节对齐的，一点都不能装了，此时fraggap=0，直接分配新skb装数据；
		copy<=0，表示*该skb装满了，但是没有8字节对齐，需要将sbk最后的fraggap长度数据剪切到新的skb中，再在新skb中装数据*/
		if (copy <= 0) {
			char *data;
			unsigned int datalen;/*本次待拷贝的数据量*/
			unsigned int fraglen;/*分片的长度*/
			unsigned int fraggap;/*间隙长度*/
			unsigned int alloclen;/*分配的skb缓冲区大小*/
			struct sk_buff *skb_prev;
alloc_new_skb:
			skb_prev = skb;
			/*计算间隙fraggap的大小*/
			if (skb_prev)
				fraggap = skb_prev->len - maxfraglen;
			else
				fraggap = 0;

			/*
			 * If remaining data exceeds the mtu,
			 * we know we need more fragment(s).
			 */
			/*datalen(待添加的数据长度)=length(原始数据长度)+fraggap(间隙长度)*/
			datalen = length + fraggap;
			/*新生成一个skb也装不下，待添加的数据长度datalen更新为最大分片长度maxfraglen - fragheaderlen*/
			if (datalen > mtu - fragheaderlen)
				datalen = maxfraglen - fragheaderlen;
			
			/*分片的长度*/
			fraglen = datalen + fragheaderlen;

			/*分配的skb缓冲区大小：
			1.当设置了MSG_MORE标志(表示后面还有数据到达)，并且设备不支持分散/聚合IO时，直接分配MTU大小的缓存；
			2.否则，分配刚好够用的缓存区长度fraglen*/
			if ((flags & MSG_MORE) &&
			    !(rt->dst.dev->features&NETIF_F_SG))
				alloclen = mtu;
			else
				alloclen = fraglen;
			
			/*第一个skb需要再加上IPsec相关的头部长度*/
			alloclen += exthdrlen;

			/* The last fragment gets additional space at tail.
			 * Note, with MSG_MORE we overallocate on fragments,
			 * because we have no idea what fragment will be
			 * the last.
			 */
			/* 最有一个skb需要加上IPsec相关的尾部长度*/
			if (datalen == length + fraggap)
				alloclen += rt->dst.trailer_len;

			/*transhdrlen不为0，表示分配的是第一个skb，需要考虑l4层首部，此时调用sock_alloc_send_skb分配内存*/
			if (transhdrlen) {
				skb = sock_alloc_send_skb(sk,
						alloclen + hh_len + 15,
						(flags & MSG_DONTWAIT), &err);
			} 
			/*后面分配的skb调用sock_wmalloc处理*/
			else {
				skb = NULL;
				if (atomic_read(&sk->sk_wmem_alloc) <=
				    2 * sk->sk_sndbuf)
					skb = sock_wmalloc(sk,
							   alloclen + hh_len + 15, 1,
							   sk->sk_allocation);
				if (unlikely(!skb))
					err = -ENOBUFS;
			}
			if (!skb)
				goto error;

			/*
			 *	Fill in the control structures
			 */
			/*校验和相关*/
			skb->ip_summed = csummode;
			skb->csum = 0;
			
			/*预留l2头部长度*/
			skb_reserve(skb, hh_len);

			/* only the initial fragment is time stamped */
			skb_shinfo(skb)->tx_flags = cork->tx_flags;
			cork->tx_flags = 0;
			skb_shinfo(skb)->tskey = tskey;
			tskey = 0;

			/*
			 *	Find where to start putting bytes.
			 */
			/*skb->tail += len，是数据区扩大len字节，为存放三层头首部和数据预留空间*/
			data = skb_put(skb, fraglen + exthdrlen);
			/*设置IP头、传输层头指针位置*/
			skb_set_network_header(skb, exthdrlen);
			skb->transport_header = (skb->network_header +
						 fragheaderlen);
			/*设置data指针位置，就是数据开始存储的地方*/
			data += fragheaderlen + exthdrlen;

			/*完成上一个skb的fraggap数据剪切到当前skb，并且重新计算两个skb的校验和。*/
			if (fraggap) {
				skb->csum = skb_copy_and_csum_bits(
					skb_prev, maxfraglen,
					data + transhdrlen, fraggap, 0);
				skb_prev->csum = csum_sub(skb_prev->csum,
							  skb->csum);
				data += fraggap;
				pskb_trim_unique(skb_prev, maxfraglen);
			}

			/*调用getfrag拷贝copy字节数据内容到skb中*/
			copy = datalen - transhdrlen - fraggap;
			if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
				err = -EFAULT;
				kfree_skb(skb);
				goto error;
			}

			offset += copy;
			length -= datalen - fraggap;
			transhdrlen = 0;
			exthdrlen = 0;
			csummode = CHECKSUM_NONE;

			/*
			 * Put the packet on the pending queue.
			 */
			/*skb添加到sk_write_queue*/
			__skb_queue_tail(queue, skb);
			continue;
		}

		/*最后一个skb的剩余空间可以装下剩余数据*/
		if (copy > length)
			copy = length;
		
		/*设备不支持分散/聚合IO时，将数据拷贝到原来skb的线性缓冲区*/
		if (!(rt->dst.dev->features&NETIF_F_SG)) {
			unsigned int off;

			off = skb->len;
			if (getfrag(from, skb_put(skb, copy),
					offset, copy, off, skb) < 0) {
				__skb_trim(skb, off);
				err = -EFAULT;
				goto error;
			}
		} 
		/*设备支持分散/缓冲IO时，将数据拷贝到skb的frags数组中。--后面这段没有分析，直接拷贝的别人的分析，后面自己再分析一下*/
		else {
			int i = skb_shinfo(skb)->nr_frags;

			err = -ENOMEM;
			/*在分片列表(frags)中使用原有分片(返回相应分片的指针)或分配新页来存放数据*/
			if (!sk_page_frag_refill(sk, pfrag))
				goto error;
			/*
             * 如果传输控制块(sock)中的缓存页pfrag，不是当前skb->shared_info中的最后一个分片(分散聚集IO页面)所在的页面，则直接使用该页面，
             * 将其添加 到分片列表(分散聚集IO页面数组)中，否则说明传输控制块(sock)中的缓存页pfrag就是分散聚集IO页面的最后一个页面，
             * 则直接向其中拷贝数据即可。
             */
			if (!skb_can_coalesce(skb, i, pfrag->page,
					      pfrag->offset)) {
				err = -EMSGSIZE;
				if (i == MAX_SKB_FRAGS)
					goto error;

				__skb_fill_page_desc(skb, i, pfrag->page,
						     pfrag->offset, 0);
				skb_shinfo(skb)->nr_frags = ++i;
				get_page(pfrag->page);
			}
			copy = min_t(int, copy, pfrag->size - pfrag->offset);
			/*拷贝数据至skb中非线性区分片(分散聚集IO页面)中*/
			if (getfrag(from,
				    page_address(pfrag->page) + pfrag->offset,
				    offset, copy, skb->len, skb) < 0)
				goto error_efault;
			
			/*移动相应数据指针*/
			pfrag->offset += copy;
			/*增加分片大小*/
			skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
			/*增加skb数据相关大小*/
			skb->len += copy;
			skb->data_len += copy;
			skb->truesize += copy;
			/*增加sock发送缓存区已分配数据大小*/
			atomic_add(copy, &sk->sk_wmem_alloc);
		}
		offset += copy;
		/*length减去已经拷贝的大小，如果拷完了，则结束循环，否则继续拷贝*/
		length -= copy;
	}

	return 0;

error_efault:
	err = -EFAULT;
error:
	cork->length -= length;
	IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
	return err;
}

五、udp_push_pending_frames

将输出队列上的多个片段合成一个完整的ip数据报文，并通过ip_output输出。调用ip_finish_skb构造skb；调用udp_send_skb发送skb。

1. udp_push_pending_frames

/*
 * Push out all pending data as one UDP datagram. Socket is locked.
 */
int udp_push_pending_frames(struct sock *sk)
{
	struct udp_sock  *up = udp_sk(sk);
	struct inet_sock *inet = inet_sk(sk);
	struct flowi4 *fl4 = &inet->cork.fl.u.ip4;
	struct sk_buff *skb;
	int err = 0;

	skb = ip_finish_skb(sk, fl4);
	if (!skb)
		goto out;

	err = udp_send_skb(skb, fl4);

out:
	up->len = 0;
	up->pending = 0;
	return err;
}

2. ip_finish_skb 

static inline struct sk_buff *ip_finish_skb(struct sock *sk, struct flowi4 *fl4)
{
	return __ip_make_skb(sk, fl4, &sk->sk_write_queue, &inet_sk(sk)->cork.base);
}

3.  __ip_make_skb

将sock相应的skb队列中的所有skb合并成一个数据报文(skb)，使用skb_shinfo->frag_list将所有skb连接起来。填充IP头，对skb的组织进行了修改：

https://www.cnblogs.com/codestack/p/9265886.html

http://blog.chinaunix.net/uid-14528823-id-4468600.html

这个图就对应着函数中while ((tmp_skb = __skb_dequeue(queue)) != NULL)操作。

/*
 *	Combined all pending IP fragments on the socket as one IP datagram
 *	and push them out.
 */
struct sk_buff *__ip_make_skb(struct sock *sk,
			      struct flowi4 *fl4,
			      struct sk_buff_head *queue,
			      struct inet_cork *cork)
{
	struct sk_buff *skb, *tmp_skb;
	struct sk_buff **tail_skb;
	struct inet_sock *inet = inet_sk(sk);
	struct net *net = sock_net(sk);
	struct ip_options *opt = NULL;
	struct rtable *rt = (struct rtable *)cork->dst;
	struct iphdr *iph;
	__be16 df = 0;
	__u8 ttl;

	/*从sk_write_queue链表中获取skb*/
	skb = __skb_dequeue(queue);
	if (!skb)
		goto out;
	tail_skb = &(skb_shinfo(skb)->frag_list);

	/* move skb->data to ip header from ext header */
	/*调整skb->data到ip头*/
	if (skb->data < skb_network_header(skb))
		__skb_pull(skb, skb_network_offset(skb));
	while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
		__skb_pull(tmp_skb, skb_network_header_len(skb));
		*tail_skb = tmp_skb;
		tail_skb = &(tmp_skb->next);
		skb->len += tmp_skb->len;//skb总长度增加
		skb->data_len += tmp_skb->len;//skb的data长度增加
		skb->truesize += tmp_skb->truesize;
		tmp_skb->destructor = NULL;
		tmp_skb->sk = NULL;
	}

	/* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow
	 * to fragment the frame generated here. No matter, what transforms
	 * how transforms change size of the packet, it will come out.
	 */
	/*在不启用路由MTU时，允许对输出数据报进行分片*/
	skb->ignore_df = ip_sk_ignore_df(sk);

	/* DF bit is set when we want to see DF on outgoing frames.
	 * If ignore_df is set too, we still allow to fragment this frame
	 * locally. */
	/*如果启用了路由MTU发现功能，或者输出数据报的长度小于MTU且本地传输控制块输出的IP
	数据报不能分片，则给IP首部添加禁止分片标志*/
	if (inet->pmtudisc == IP_PMTUDISC_DO ||
	    inet->pmtudisc == IP_PMTUDISC_PROBE ||
	    (skb->len <= dst_mtu(&rt->dst) &&
	     ip_dont_fragment(sk, &rt->dst)))
		df = htons(IP_DF);

	/*如果IP选项信息已经保存到传输控制块中，则获取IP选项信息指针，用于构建IP首部中的选项*/
	if (cork->flags & IPCORK_OPT)
		opt = cork->opt;

	/*ttl获取*/
	if (cork->ttl != 0)
		ttl = cork->ttl;
	else if (rt->rt_type == RTN_MULTICAST)
		ttl = inet->mc_ttl;
	else
		ttl = ip_select_ttl(inet, &rt->dst);

	/*ip头信息填充*/
	iph = ip_hdr(skb);
	iph->version = 4;
	iph->ihl = 5;
	iph->tos = (cork->tos != -1) ? cork->tos : inet->tos;
	iph->frag_off = df;
	iph->ttl = ttl;
	iph->protocol = sk->sk_protocol;
	ip_copy_addrs(iph, fl4);
	ip_select_ident(net, skb, sk);

	if (opt) {
		iph->ihl += opt->optlen>>2;
		ip_options_build(skb, opt, cork->addr, rt, 0);
	}

	skb->priority = (cork->tos != -1) ? cork->priority: sk->sk_priority;
	skb->mark = sk->sk_mark;
	/*
	 * Steal rt from cork.dst to avoid a pair of atomic_inc/atomic_dec
	 * on dst refcount
	 */
	cork->dst = NULL;
	skb_dst_set(skb, &rt->dst);

	if (iph->protocol == IPPROTO_ICMP)
		icmp_out_count(net, ((struct icmphdr *)
			skb_transport_header(skb))->type);

	ip_cork_release(cork);
out:
	return skb;
}

🥴🥴🥴🥴🥴🥴