TCP拥塞控制算法内核实现剖析（一）

内核版本：2.6.37

主要源文件：linux-2.6.37/ net/ ipv4/ Tcp_cong.c 

本文主要分析RENO及TCP拥塞控制基础的实现

======================================================================================================

struct sock *sk 和 struct tcp_sock *tp 的转换

在include/ linux/ Tcp.h中，static inline struct tcp_sock *tcp_sk(const struct sock *sk) {        return (struct tcp_sock *)sk ;}给出struct sock *sk,struct tcp_sock *tp = tcp_sk(sk) ;

 

tcp_sock结构

struct tcp_sock{       ... u32 window_clamp ; /* Maximal window to advertise */ u32 rcv_ssthresh ; /* Current window clamp */ u32 rcv_wnd ; /* Current receiver window */       ... /* snd_wll 记录发送窗口更新时，造成窗口更新的那个数据报的第一个序号。  * 它主要用于在下一次判断是否需要更新发送窗口。  */ u32 snd_wll ; /* Sequence for window update */  u32 snd_wnd ; /* 发送窗口的大小，直接取值于来自对方的数据报的TCP首部 */ /* Maximal window ever seen from peer 记录来自对方通告的窗口的最大值 */ /* First byte we want an ack for 发送窗口的左边沿 */ u32 max_window ;  u32 snd_una ;         ... /*  * Slow start and congestion control  */ u32 snd_ssthresh ; /* Slow start size threshold */ u32 snd_cwnd ; /* Sending congestion window */ /*表示在当前的拥塞控制窗口中已经发送的数据段的个数*/ u32 snd_cwnd_cnt ; /* Linear increase counter */  u32 snd_cwnd_clamp ; /* Do not allow snd_cwnd to grow above this */        ... u32 mss_cache ; /* cached effective mss , not including SACKS */ u32 bytes_acked ; /* Appropriate Byte Counting - RFC3465 */       ...}

拥塞避免算法关键部分

/* In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd ( or alternative w ) */void tcp_cong_avoid_ai(struct tcp_sock *tp , u32 w){        if ( tp->snd_cwnd_cnt >= w) {                   if ( tp->snd_cwnd < tp->snd_cwnd_clamp)                        tp->snd_cwnd++ ;                   tp->snd_cwnd_cnt = 0 ;        } else {                   tp->snd_cwnd_cnt ++ ;        }                }EXPORT_SYMBOL_GPL(tcp_cong_avoid_ai) ;

慢启动算法

void tcp_slow_start( struct tcp_sock *tp ){ int cnt ; /* increase in packets *//* RFC3465 : ABC slow start * Increase only after a full MSS of bytes is acked * * TCP sender SHOULD increase cwnd by the number of * previously unacknowledged bytes ACKed by each incoming  * acknowledgment , provided the increase is not more than L */ /* ack的数据少于MSS */ if ( sysctl_tcp_abc && tp->bytes_acked < tp->mss_cached )          return ;/* 此时不是应该进入拥塞避免？*/ if ( sysctl_tcp_max_ssthresh >0 && tcp->snd_cwnd >sysctl_tcp_max_ssthresh)        cnt = sysctl_tcp_max_ssthresh >> 1 ; /* limited slow start */ else         cnt = tp->snd_cwnd ; /* exponential increase *//* RFC3465 : ABC * We MAY increase by 2 if discovered delayed ack   *//* 如果接收方启用了延时确认，此时收到的确认代表两个MSS数据报*/if ( sysctl_tcp_abc >1 && tp->bytes_acked >= 2*tp->mss_cache )         cnt <<= 1 ;tp->bytes_acked = 0 ; tp->snd_cwnd_cnt += cnt ; /* 此时snd_cwnd_cnt等于snd_cwnd或2*snd_cwnd */ while( tp->snd_cwnd_cnt >= tp->snd_cwnd ) {         tp->snd_cwnd_cnt -= tp->snd_cwnd ;        if( tp->snd_cwnd < tp->snd_cwnd_clamp )                tp->snd_cwnd++ ; }}EXPORT_SYMBOL_GPL( tcp_slow_start ) ;

代表拥塞算法的结构体

#define TCP_CA_NAME_MAX 16struct tcp_congestion_ops {        struct list_head list ;        unsigned long flags ;        /* initialize private data (optional) */        void (*init) (struct sock *sk) ;        /* cleanup private data (optional) */         void (*release) (struct sock *sk) ;        /* return slow start threshold (required) */        u32 (*ssthresh) (struct sock *sk) ;        /* lower bound for congestion window (optional) */        u32 (*min_cwnd) (const struct sock *sk) ;        /* do new cwnd calculation (required) */        void (*cong_avoid) (struct sock *sk , u32 ack , u32 in_flight ) ;        /* call before changing ca_state (optional) */        void (*set_state) (struct sock *sk , u8 new_state) ;        /* call when cwnd event occurs (optional) */        void (*cwnd_event) (struct sock *sk , enum tcp_ca_event ev) ;        /* new value of cwnd after loss (optional) */        u32 (*undo_cwnd) (struct sock *sk) ;        /* hook for packet ack accounting (optional) */        void (*pkts_acked) (struct sock *sk , u32 num_acked , s32 rtt_us) ;        /* get info for inet_diag (optional) */        void (*get_info) (struct sock *sk , u32 ext , struct sk_buff *skb) ;        char name[TCP_CA_NAME_MAX] ;        struct module *owner ;}

 

在Tcp_cong.c中，有全局变量：

int sysctl_tcp_max_ssthresh = 0 ;

/* define DEFINE_SPINLOCK(x) spinlock_t x = __SPIN_LOCK_UNLOCKED(x) */

static DEFINE_SPINLOCK( tcp_cong_list_lock ) ;

static LIST_HEAD( tcp_cong_list ) ; // tcp拥塞控制算法链表，其元素为tcp_congestion_ops

/*

 BUG_ON( ) ; 如果BUG_ON中的条件为真就调用BUG，它输出一些信息，然后调用panic函数挂起系统。

 char *strncpy( char * dest , char *src , size_t n ) ;

 它与strcpy不同之处在于复制n个字符，而不是把所有的字符拷贝（包括结尾'\0'）。

  当src的长度小于n时，dst内的未复制空间用'\0'填充。否则，复制n个字符到dst，没有加'\0'。这里就要注意在字符串dst结尾处理加'\0'的情况了。

 rcu_read_lock() // 读者在读取由RCU保护的共享数据时使用该函数标记它进入读端临界区。

 rcu_read_unlock() // 该函数与rcu_read_lock配对使用，用以标记读者退出读端临界区。

*/

 

对拥塞控制算法的一些操作（读写增减注册等）

/* Get current default congestion control */void tcp_get_default_congestion_control( char *name ){        struct tcp_congestion_ops *ca ;        /* We will always have reno */        BUG_ON( list_empty( &tcp_cong_list) ) ;        rcu_read_lock( ) ;        ca = list_entry( tcp_cong_list . next , struct tcp_congestion_ops , list ) ;        strncpy( name , ca->name , TCP_CA_NAME_MAX ) ;        rcu_read_unlock( ) ;}

 

struct sock——representation of sockets

 struct inet_sock——representation of INET sockets

 struct inet_connection_sock——INET connection oriented sockets

 struct tcp_sock——tcp sockets

 以上几种socket越分越细，比如inet_connection_sock是在inet_sock上的扩展，具有自己特有的属性。

 tcp_sock是TCP协议专用的一个socket表示，它是在struct inet_connection_sock基础进行扩展，主要是增加了滑动窗口协议，避免拥塞算法等一些TCP专有属性。

 

struct inet_connection_sock {        ...        // Pluggable congestion control hook        const struct tcp_congestion_ops *icsk_ca_ops ;         ...        u32 icsk_ca_priv[16] ;#define ICSK_CA_PRIV_SIZE (16*sizeof(u32))}

 

举例：//有一个初始化了得struct sock *sk

struct inet_connection_sock *icsk = inet_csk( sk ) ;

printk(KERN_INFO "%s" , icsk->icsk_ca_ops->name) ; //当前连接拥塞控制算法名称

 

struct inet_sock {        ...        /* Socket demultiplex comparisons on incoming packets */        __be32 inet_daddr ;        __be16 inet_dport ;        __be32 inet_saddr ;        __be16 inet_sport ;        __be16 inet_num ; // local port         __be32 inet_rcv_saddr ; // Bound local IPv4 addr        ...}

 

/* Built list of non-restricted congestion control values*/void tcp_get_allowed_congestion_control( char *buf , size_t maxlen){        struct tcp_congestion_ops *ca ;        size_t offs = 0 ;        *buf = '\0' ; //有必要？         rcu_read_lock() ;        list_for_each_entry( ca , &tcp_cong_list , list ) {                if( !( ca->flags & TCP_CONG_NON_RESTRICTED)) //排除有限制的。限制和非限制区别？                         continue;                offs += snprintf( buf+offs , maxlen-offs , "%s%s" , offs == 0?"" : " " , ca->name) ;        }        rcu_read_unlock() ;}

 

/* Simple linear search , don't expect many entries! */static struct tcp_congestion_ops*tcp_ca_find( const char *name){        struct tcp_congestion_ops *e ;        list_for_each_entry_rcu( e , &tcp_cong_list , list ) {                if( strcmp(e->name , name)==0)                        return e ;         }         return NULL ;}

 

/* * Attach new congestion control algorithm to the list  * of available options. */int tcp_register_congestion_control( struct tcp_congestion_ops *ca ){        int ret = 0 ;        /* all algorithms must implement ssthresh and cong_avoid ops */        if ( !ca->ssthresh || !ca->cong_avoid ) {                printk(KERN_ERR "TCP %s does not implement required ops\n",                            ca->name) ;                return -EINVAL ;        }        spin_lock(&tcp_cong_list_lock) ;        if( tcp_ca_find (ca->name)) {                printk(KERN_NOTICE "TCP %s already registered\n", ca->name) ;                ret = -EEXIST; //不能直接return，不然会造成死锁         } else {                list_add_tail_rcu( &ca->list , &tcp_cong_list) ;                printk(KERN_INFO "TCP %s registered\n", ca->name) ;        }        spin_unlock(&tcp_cong_list_lock) ;        return ret ;}

======================================================================================================