大致的处理过程
TCP的接收流程：在tcp_v4_do_rcv中的相关处理(网卡收到报文触发)中，会首先通过tcp_check_urg设置tcp_sock的urg_data为TCP_URG_NOTYET(urgent point指向的可能不是本报文，而是后续报文或者前面收到的乱序报文)，并保存最新的urgent data的sequence和对于的1 BYTE urgent data到tcp_sock的urg_data (如果之前的urgent data没有读取，就会被覆盖)。
用户接收流程：在tcp_recvmsg流程中，如果发现当前的skb的数据中有urgent data，首先拷贝urgent data之前的数据，然后tcp_recvmsg退出，提示用户来接收OOB数据；在用户下一次调用tcp_recvmsg来接收数据的时候，会跳过urgent data，并设置urgent data数据接收完成
/* This is the 'fast' part of urgent handling. Linxu内核在默认情况下，把urgent data实现为OOB数据 TCP的接收流程：在tcp_v4_do_rcv中的相关处理(网卡收到报文触发)中，会首先通过tcp_check_urg设置tcp_sock的urg_data为 TCP_URG_NOTYET(urgent point指向的可能不是本报文，而是后续报文或者前面收到的乱序报文)，并保存最新的urgent data的sequence 和对于的1 BYTE urgent data到tcp_sock的urg_data (如果之前的urgent data没有读取，就会被覆盖)。 用户接收流程：在tcp_recvmsg流程中，如果发现当前的skb的数据中有urgent data，首先拷贝urgent data之前的数据， 然后tcp_recvmsg退出，提示用户来接收OOB数据；在用户下一次调用tcp_recvmsg来接收数据的时候，会跳过urgent data， 并设置urgent data数据接收完成。 相关的数据结构和定义 urg_data成员，其高8bit为urgent data的接收状态；其低8位为保存的1BYTE urgent数据。 urgent data的接收状态对应的宏的含义描述： #defineTCP_URG_VALID 0x0100 //*urgent data已经读到了tcp_sock::urg_data #defineTCP_URG_NOTYET 0x0200 //*已经发现有urgent data，还没有读取到tcp_sock::urg_data #defineTCP_URG_READ 0x0400 //*urgent data已经被用户通过MSG_OOB读取了 */ static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th) { struct tcp_sock *tp = tcp_sk(sk); /* Check if we get a new urgent pointer - normally not. */ if (th->urg)/*收到了urgent data,则检查和设置urg_data和urg_seq成员*/ tcp_check_urg(sk, th); /* Do we wait for any urgent data? - normally not... */ if (tp->urg_data == TCP_URG_NOTYET) { u32 ptr = tp->urg_seq - ntohl(th->seq) + (th->doff * 4) - th->syn; /* Is the urgent pointer pointing into this packet? 发现了有urgent data，但是还没有保存到tp->urg_data*/ */ if (ptr < skb->len) { u8 tmp; if (skb_copy_bits(skb, ptr, &tmp, 1)) BUG(); tp->urg_data = TCP_URG_VALID | tmp; if (!sock_flag(sk, SOCK_DEAD)) sk->sk_data_ready(sk); } } }
用户接收数据接口
用户接收URG数据的接口
static int tcp_recv_urg(struct sock *sk, struct msghdr *msg, int len, int flags) { struct tcp_sock *tp = tcp_sk(sk); /* No URG data to read. 用户已经读取过 或者没数据*/ if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data || tp->urg_data == TCP_URG_READ) return -EINVAL; /* Yes this is right ! */ if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE)) return -ENOTCONN; /*当前的tp->urg_data为合法的数据，可以读取*/ if (tp->urg_data & TCP_URG_VALID) { int err = 0; char c = tp->urg_data; if (!(flags & MSG_PEEK)) tp->urg_data = TCP_URG_READ; /* Read urgent data. */ msg->msg_flags |= MSG_OOB; if (len > 0) { if (!(flags & MSG_TRUNC)) err = memcpy_to_msg(msg, &c, 1); len = 1; } else msg->msg_flags |= MSG_TRUNC; return err ? -EFAULT : len; } if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN)) return 0; /* Fixed the recv(..., MSG_OOB) behaviour. BSD docs and * the available implementations agree in this case: * this call should never block, independent of the * blocking state of the socket. * Mike <pall@rz.uni-karlsruhe.de> */ return -EAGAIN; }
用户接收普通数据的接口中的相关处理
在用户接收数据的tcp_recvmsg函数中，在查找到待拷贝的skb后，首先拷贝urgent data数据前的数据，然后退出接收过程，在用户下一次执行tcp_recvmsg的时候跳过urgent data，设置urgent data读取结束
查找到准备拷贝的skb后的处理：
int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, int flags, int *addr_len) { ------------------------- /* Urgent data needs to be handled specially. */ if (flags & MSG_OOB) goto recv_urg; --------------------------------------------- /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. 在接收完urgent data数据前的所有数据之后， tcp_recvmsg的以下代码片段得到执行， 这段代码退出当前接收过程，提示用户有urgent data数据到来，需要用MSG_OOB来接收 */ if (tp->urg_data && tp->urg_seq == *seq) { if (copied) break; if (signal_pending(current)) { copied = timeo ? sock_intr_errno(timeo) : -EAGAIN; break; } } ------------------------------------- /* Do we have urgent data here? */ if (tp->urg_data) {/* 当前有urg_data数据*/ u32 urg_offset = tp->urg_seq - *seq; if (urg_offset < used) {/*urgent data在当前待拷贝的数据范围内*/ if (!urg_offset) {/*待拷贝的数据就是urgent data，跨过该urgent data， 只给用户读取后面的数据*/ if (!sock_flag(sk, SOCK_URGINLINE)) { ++*seq; urg_hole++; offset++; used--; if (!used) goto skip_copy; } } else/*指定只拷贝urgent data数据之前的，完成后在下一次循环 开始的位置，会退出循环，返回用户；下一次用户调用tcp_recvmsg 就进入到上面的分支了*/ used = urg_offset; } } --------------------- skip_copy:/*用户读取的数据跨过了urgent point，设置读取结束 开启fast path*/ if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) { tp->urg_data = 0; tcp_fast_path_check(sk); } ----------------------------------- out: release_sock(sk); return err; recv_urg: err = tcp_recv_urg(sk, msg, len, flags); goto out; }
TCP的urg数据，由于定义和实现上的混乱，当前已经不建议使用，但是为了兼容之前已经已经存在的实现，该机制会长期在内核中存在，如果不了解该机制及其内核行为，有可能就很难解释一些奇怪的问题：比如某段代码不小心地造成send接口事实上设置了MSG_OOB，就会造成接收端少了一个BYTE
} /* This is what the send packet queuing engine uses to pass * TCP per-packet control information to the transmission code. * We also store the host-order sequence numbers in here too. * This is 44 bytes if IPV6 is enabled. * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately. */ struct tcp_skb_cb { __u32 seq; /* Starting sequence number // 当前tcp包的第一个序列号*/ __u32 end_seq; /* SEQ + FIN + SYN + datalen// 表示当前tcp 包结束的序列号：seq + FIN + SYN + 数据长度len */ union { /* Note : tcp_tw_isn is used in input path only * (isn chosen by tcp_timewait_state_process()) * * tcp_gso_segs/size are used in write queue only, * cf tcp_skb_pcount()/tcp_skb_mss() */ __u32 tcp_tw_isn; struct { u16 tcp_gso_segs; u16 tcp_gso_size; }; }; __u8 tcp_flags; /* TCP header flags. (tcp[13]) tcp头的flag */ __u8 sacked; /* State flags for SACK/FACK. SACK/FACK的状态flag或者是sack option的偏移 */ #define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ #define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ #define TCPCB_LOST 0x04 /* SKB is lost */ #define TCPCB_TAGBITS 0x07 /* All tag bits */ #define TCPCB_REPAIRED 0x10 /* SKB repaired (no skb_mstamp) */ #define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */ #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS| TCPCB_REPAIRED) __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */ __u8 txstamp_ack:1, /* Record TX timestamp for ack? */ eor:1, /* Is skb MSG_EOR marked? */ unused:6; __u32 ack_seq; /* Sequence number ACK'd ack(确认)的序列号*/ union { struct { /* There is space for up to 24 bytes */ __u32 in_flight:30,/* Bytes in flight at transmit */ is_app_limited:1, /* cwnd not fully used? */ unused:1; /* pkts S/ACKed so far upon tx of skb, incl retrans: */ __u32 delivered; /* start of send pipeline phase */ struct skb_mstamp first_tx_mstamp; /* when we reached the "delivered" count */ struct skb_mstamp delivered_mstamp; } tx; /* only used for outgoing skbs */ union { struct inet_skb_parm h4; #if IS_ENABLED(CONFIG_IPV6) struct inet6_skb_parm h6; #endif } header; /* For incoming skbs */ }; }; static void tcp_data_queue(struct sock *sk, struct sk_buff *skb) { struct tcp_sock *tp = tcp_sk(sk); bool fragstolen = false; int eaten = -1; //没有数据部分，直接释放 if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) { __kfree_skb(skb); return; } skb_dst_drop(skb); __skb_pull(skb, tcp_hdr(skb)->doff * 4); tcp_ecn_accept_cwr(tp, skb); tp->rx_opt.dsack = 0; /* Queue data for delivery to the user. * Packets in sequence go to the receive queue. * Out of sequence packets to the out_of_order_queue. *///如果该数据包刚好是下一个要接收的数据，则可以直接copy到用户空间（如果存在且可用 if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {//非乱序包 if (tcp_receive_window(tp) == 0)//接受窗口满了，不能接受 goto out_of_window; /* Ok. In sequence. In window. */ if (tp->ucopy.task == current &&//应用程序上下文中，在tcp_recvmsg tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&//正要读取这个包，并且应用程序还有剩余缓存 sock_owned_by_user(sk) && !tp->urg_data) {//应用程序持有锁 int chunk = min_t(unsigned int, skb->len, tp->ucopy.len);/* 带读取长度和数据段长度的较小值 */ __set_current_state(TASK_RUNNING); if (!skb_copy_datagram_msg(skb, 0, tp->ucopy.msg, chunk)) {//copy数据到ucopy中 tp->ucopy.len -= chunk; tp->copied_seq += chunk; eaten = (chunk == skb->len); tcp_rcv_space_adjust(sk);//每次copy数据到ucopy都要调用该函数，动态更新sk_rcvbuf大小 } } if (eaten <= 0) {//没有copy到ucopy，或者没有全部copy queue_and_out: if (eaten < 0) {//没有copy /* 没有拷贝到用户空间，对内存进行检查 */ if (skb_queue_len(&sk->sk_receive_queue) == 0)//sk_receive_queue没有数据 sk_forced_mem_schedule(sk, skb->truesize);//检查是否需要分配配额 else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))//查看接收缓存空间够不够 goto drop; } eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);//添加到sk_receive_queue } tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);//尝试更新rcv_nxt if (skb->len) tcp_event_data_recv(sk, skb); if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) tcp_fin(sk); //fin处理 if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {//ofo队列非空 tcp_ofo_queue(sk);//尝试把ofo中的包移动到sk_receive_queue中 /* RFC2581. 4.2. SHOULD send immediate ACK, when * gap in queue is filled. */ if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) inet_csk(sk)->icsk_ack.pingpong = 0;//ofo队列被清空了，需要立即发送ack } if (tp->rx_opt.num_sacks)// 新数据到达导致返回给对方的SACK Block 调整 tcp_sack_remove(tp);//如果当前收到的包带sack，则删除其中不需要的部分，有可能ofo填充造成了rcv_next的移动 tcp_fast_path_check(sk);//当前是slow path, 尝试开启快速路径 重新设置 tcp 首部预测标志 if (eaten > 0) kfree_skb_partial(skb, fragstolen);//已经全部copy到ucopy，可以释放skb了 if (!sock_flag(sk, SOCK_DEAD)) sk->sk_data_ready(sk);//通知poll数据到达 return; } /* 重传 */ if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {//判断是否是重传的旧包，标记dsack /* A retransmit, 2nd most common case. Force an immediate ack. */ NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST); tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);//设置dsack out_of_window: tcp_enter_quickack_mode(sk);//进入快速ack inet_csk_schedule_ack(sk);///标记需要ack drop: tcp_drop(sk, skb); return; } /* Out of window. F.e. zero window probe. *///收到的包在接收窗口范围之外 /* 窗口以外的数据，比如零窗口探测报文段 */ if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp))) goto out_of_window; //乱序包或者需要dsack都要快速ack tcp_enter_quickack_mode(sk); /* 数据段重叠 */ if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) { /* Partial packet, seq < rcv_next < end_seq *///seq < rcv_next < end_seq,部分旧数据 SOCK_DEBUG(sk, "partial packet: rcv_next %X seq %X - %X ", tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq); tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);//设置dsack /* If window is closed, drop tail of packet. But after * remembering D-SACK for its head made in previous line. */ if (!tcp_receive_window(tp))//接收窗口不足，快速ack通知对方 goto out_of_window; goto queue_and_out;//调用tcp_queue_rcv添加到sk_receive_queue，会尝试合并 } tcp_data_queue_ofo(sk, skb);//乱续包，添加到ofo队列 }