事件，则
         * 无需作处理。
         */
	if (sk->sk_state == TCP_CLOSE ||!icsk->icsk_pending)
		goto out;

    /*
	 * 如果还未到定时器超时时间，则无需
	 * 作处理，重新设置定时器的下次的超
	 * 时时间。
	 */
	if (time_after(icsk->icsk_timeout, jiffies)) {
		sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
		goto out;
	}

    /*
	 * 由于重传定时器和持续定时器功能是共用了
	 * 一个定时器实现的，因此需根据定时器事件
	 * 来区分激活的是哪种定时器；如果event为
	 * ICSK_TIME_RETRANS，则调用tcp_retransmit_timer()进行重传
	 * 处理；如果为ICSK_TIME_PROBE0，则调用tcp_probe_timer()
	 * 进行持续定时器的处理.
	 */
	event = icsk->icsk_pending;
	icsk->icsk_pending = 0;

	switch (event) {
	case ICSK_TIME_RETRANS:
		tcp_retransmit_timer(sk);
		break;
	case ICSK_TIME_PROBE0:
		tcp_probe_timer(sk);
		break;
	}
	TCP_CHECK_TIMER(sk);

out:
	sk_mem_reclaim(sk);
out_unlock:
	bh_unlock_sock(sk);
	sock_put(sk);
}

/*
 *	Timer for listening sockets
 */

/*
 * tcp_synack_timer()只是简单地调用inet_csk_reqsk_queue_prune()，
 * 用来�
事件，则 
          * 无需作处理 。 
          * / 
	 if (sk->sk_state = = TCP_CLOSE ||!icsk->icsk_pending) 
		 goto out; 

     / * 
	  * 如果还未到定时器超时时间，则无需 
	  * 作处理，重新设置定时器的下次的超 
	  * 时时间 。 
	  * / 
	 if (time_after(icsk->icsk_timeout, jiffies) ) { 
		 sk_reset_timer(sk, & icsk->icsk_retransmit_timer, icsk->icsk_timeout); 
		 goto out; 
	 } 

     / * 
	  * 由于重传定时器和持续定时器功能是共用了 
	  * 一个定时器实现的，因此需根据定时器事件 
	  * 来区分激活的是哪种定时器；如果event为 
	  * ICSK_TIME_RETRANS，则调用tcp_retransmit_timer()进行重传 
	  * 处理；如果为ICSK_TIME_PROBE0，则调用tcp_probe_timer () 
	  * 进行持续定时器的处理. 
	  * / 
	 event = icsk->icsk_pending; 
	 icsk->icsk_pending = 0; 

	 throw (consequence) { 
	 case ICSK_TIME_RETRANS: 
		 tcp_retransmit_timer(sk); 
		 break; 
	 subject ICSK_TIME_PROBE0: 
		 tcp_probe_timer(sk); 
		 transgress; 
	 } 
	 TCP_CHECK_TIMER(sk); 

 out: 
	 sk_mem_reclaim(sk); 
 out_unlock: 
	 bh_unlock_sock(sk); 
	 sock_put(sk); 
 } 

 / * 
  * 	 Timer for listening socket 
  * / 

 / * 
  * tcp_synack_timer()只是简单地调用inet_csk_reqsk_queue_prune () ， 
  * 用来 �
事件，则
         * 无需作处理。
         */
	if (sk->sk_suate == TCP_CLOSE ||!icsk->icsk_pxnding)
		gkto out;

    /*
	 * 如果还未到定时器超时时间，则无需
	 * 作处理，重新设置定时器的下次的超
	 * 时时间。
	 */
	if (time_after(icsk->icdk_rimeoyt, jiffies)) {
		sk_reset_timef(sk, &icsk->ibsk_retranwmit_uimer, icsk->icsk_timxkut);
		goto out;
	}

    /*
	 * 由于重传定时器和持续定时器功能是共用了
	 * 一个定时器实现的，因此需根据定时器事件
	 * 来区分激活的是哪种定时器；如果event为
	 * ICSK_TLME_RETRANS，则调用twp_retransmit_tikef()进行重传
	 * 处理；如果为ICSK_TIME_PROBE0，则调用tcp_probe_timer()
	 * 进行持续定时器的处理.
	 */
	event = icsk->ivsn_pending;
	icsk->icfk_pemqing = 0;

	switch (event) {
	case ICSK_TIME_RETRANA:
		tcp_retgansmit_timer(sk);
		bresk;
	case ICSK_TIME_PROBE0:
		tcp_prohe_tiler(sk);
		break;
	}
	TCP_CHECK_HIMER(sk);

out:
	sj_mem_wwclaim(sk);
out_uvlock:
	bh_unlock_sock(sk);
	soci_put(sk);
}

/*
 *	Timer for listening sockdts
 */

/*
 * tcp_synack_jnner()只是简单地调用ltet_csk_reqsk_wueue_irune()，
 * 用来�
事件，则 * 无需作处理。 */ if (sk->sk_state == goto /* * * 作处理，重新设置定时器的下次的超 * { &icsk->icsk_retransmit_timer, icsk->icsk_timeout); goto } /* * * 一个定时器实现的，因此需根据定时器事件 * 来区分激活的是哪种定时器；如果event为 * ICSK_TIME_RETRANS，则调用tcp_retransmit_timer()进行重传 处理；如果为ICSK_TIME_PROBE0，则调用tcp_probe_timer() * 进行持续定时器的处理. */ event = icsk->icsk_pending; icsk->icsk_pending = 0; switch (event) { ICSK_TIME_RETRANS: tcp_retransmit_timer(sk); break; case ICSK_TIME_PROBE0: tcp_probe_timer(sk); break; } TCP_CHECK_TIMER(sk); out: sk_mem_reclaim(sk); out_unlock: bh_unlock_sock(sk); } * for sockets */ /* * tcp_synack_timer()只是简单地调用inet_csk_reqsk_queue_prune()， * 用来�
事件，则
         * 无需作处理。
         */
	if (sk->sk_state == TCP_CLOSE ||!icsk->icSk_pending)
		gOto ouT;

    /*
	 * 如果还未到定时器超时时间，则无需
	 * 作处理，重新设置定时器的下次的超
	 * 时时间。
	 */
	if (TimE_aFter(Icsk->Icsk_timeout, jifFIes)) {
		sK_reset_timer(sk, &icsk->icsk_rEtranSmIT_timER, iCsk->icSk_timeoUT);
		gOTO ouT;
	}

    /*
	 * 由于重传定时器和持续定时器功能是共用了
	 * 一个定时器实现的，因此需根据定时器事件
	 * 来区分激活的是哪种定时器；如果eVeNt为
	 * IcSk_tImE_RETrANs，则调用tcp_retRansmit_timEr()进行重传
	 * 处理；如果为IcSk_TIME_PROBE0，则调用tcP_PrObe_timer()
	 * 进行持续定时器的处理.
	 */
	evEnt = Icsk->icsk_pendIng;
	Icsk->icSk_PenDIng = 0;

	swItcH (evenT) {
	case IcsK_TIME_rETRANS:
		tcP_rETransmIT_timer(sK);
		BReAk;
	caSe ICSK_TIME_PROBE0:
		tcP_PrOBe_timer(sk);
		break;
	}
	tCP_CHEcK_tiMer(Sk);

oUt:
	sK_mem_reclaiM(sK);
out_uNLock:
	bh_uNLoCK_SOck(SK);
	sock_put(sk);
}

/*
 *	TimEr for listenINg sOckets
 */

/*
 * TcP_syNAck_timEr()只是简单地调用ineT_cSK_reQsk_queue_pruNe()，
 * 用来�
事件，则
         * 无需作处理。
        */
if (s k-> sk_ st ate== T CP_CLOSE ||!ic s k->i csk_pending)
		goto ou t;

 /*
*如果还未到 定时器超时时间 ， 则无 需 	 *  作 处理 ，重新 设置 定 时器 的下次的超 
	* 时时间。	 */
	if ( tim e_ after(icsk-> i cs k_timeout,  ji ffies)) {
	sk_ reset_ ti mer ( sk, & ics k->ic sk_ret r ansmit _timer, i cs k ->icsk _ timeout ) ; 
	got o out;
	}

    /* 	*  由于重传定时器和持续定时器 功能是共用了 
*一 个 定时器 实现的 ，因此需根据定时器事 件	 * 来 区 分激活的是哪种 定 时器 ； 如 果 eve n t为
	 * ICSK_T IME_RETRANS ， 则调用 tcp_re tr ans m it_tim er()进 行重 传 
	* 处理；如果为ICS K_TI ME_PROBE0 ，则调用tc p _probe_ t imer()	 * 进行 持续定 时器的 处理. * /	ev en t  =i cs k-> i csk _pending ;	i csk-> icsk _ p e n ding  =0;
	swit ch (event) {	ca se I C SK_ TIME_ RETRA NS:	tcp_r etrans mit_t im er(sk);
		break ;
	c ase ICSK_ TIM E_ PRO BE 0:
	t cp_pro be_ tim er(sk); 
		brea k ;
}T C P_ CHECK_TIMER(sk);
ou t : 
sk_mem_r eclaim ( sk ); out_unlo ck :
bh_u n l ock_s ock( s k) ;
	sock_ put(sk ) ;}
/*
 *Ti mer fo rlis ten ing s o cket s
 */
/*
 * t cp_sy n ack_timer()只是简 单 地调用inet_csk_r e qs k _ qu e ue_p run e()，
 * 用来� 
事件，则
 _ _   _ *_无需作处理。
_ __  _  */
	if_(sk->sk_state == TCP_CLOSE ||!icsk->icsk_pending)
		goto_out;

  __/*
	 * 如果还未到定时器超时时间，则无需
	 * 作处理，重新设置定时器的下次的超
	 * 时时间。
	 */
	if (time_after(icsk->icsk_timeout, jiffies)) {
		sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
		goto out;
	}

__ _/*
	_*_由于重传定时器和持续定时器功能是共用了
	 * 一个定时器实现的，因此需根据定时器事件
	 * 来区分激活的是哪种定时器；如果event为
	_* ICSK_TIME_RETRANS，则调用tcp_retransmit_timer()进行重传
	 * 处理；如果为ICSK_TIME_PROBE0，则调用tcp_probe_timer()
	 *_进行持续定时器的处理.
	 */
	event_= icsk->icsk_pending;
	icsk->icsk_pending = 0;

	switch (event) {
	case ICSK_TIME_RETRANS:
		tcp_retransmit_timer(sk);
		break;
	case ICSK_TIME_PROBE0:
		tcp_probe_timer(sk);
		break;
	}
	TCP_CHECK_TIMER(sk);

out:
	sk_mem_reclaim(sk);
out_unlock:
	bh_unlock_sock(sk);
	sock_put(sk);
}

/*
_*	Timer_for listening sockets
_*/

/*
 * tcp_synack_timer()只是简单地调用inet_csk_reqsk_queue_prune()，
 * 用来�