tcp_timer.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * Implementation of the Transmission Control Protocol(TCP).
  7. *
  8. * Version: $Id: tcp_timer.c,v 1.1.1.1 2007/06/12 07:27:14 eyryu Exp $
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Mark Evans, <evansmp@uhura.aston.ac.uk>
  13. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  14. * Florian La Roche, <flla@stud.uni-sb.de>
  15. * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
  16. * Linus Torvalds, <torvalds@cs.helsinki.fi>
  17. * Alan Cox, <gw4pts@gw4pts.ampr.org>
  18. * Matthew Dillon, <dillon@apollo.west.oic.com>
  19. * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
  20. * Jorge Cwik, <jorge@laser.satlink.net>
  21. */
  22. #include <linux/module.h>
  23. #include <net/tcp.h>
  24. int sysctl_tcp_syn_retries __read_mostly = TCP_SYN_RETRIES;
  25. int sysctl_tcp_synack_retries __read_mostly = TCP_SYNACK_RETRIES;
  26. int sysctl_tcp_keepalive_time __read_mostly = TCP_KEEPALIVE_TIME;
  27. int sysctl_tcp_keepalive_probes __read_mostly = TCP_KEEPALIVE_PROBES;
  28. int sysctl_tcp_keepalive_intvl __read_mostly = TCP_KEEPALIVE_INTVL;
  29. int sysctl_tcp_retries1 __read_mostly = TCP_RETR1;
  30. int sysctl_tcp_retries2 __read_mostly = TCP_RETR2;
  31. int sysctl_tcp_orphan_retries __read_mostly;
  32. static void tcp_write_timer(unsigned long);
  33. static void tcp_delack_timer(unsigned long);
  34. static void tcp_keepalive_timer (unsigned long data);
  35. void tcp_init_xmit_timers(struct sock *sk)
  36. {
  37. inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer,
  38. &tcp_keepalive_timer);
  39. }
  40. EXPORT_SYMBOL(tcp_init_xmit_timers);
  41. static void tcp_write_err(struct sock *sk)
  42. {
  43. sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
  44. sk->sk_error_report(sk);
  45. tcp_done(sk);
  46. NET_INC_STATS_BH(LINUX_MIB_TCPABORTONTIMEOUT);
  47. }
  48. /* Do not allow orphaned sockets to eat all our resources.
  49. * This is direct violation of TCP specs, but it is required
  50. * to prevent DoS attacks. It is called when a retransmission timeout
  51. * or zero probe timeout occurs on orphaned socket.
  52. *
  53. * Criteria is still not confirmed experimentally and may change.
  54. * We kill the socket, if:
  55. * 1. If number of orphaned sockets exceeds an administratively configured
  56. * limit.
  57. * 2. If we have strong memory pressure.
  58. */
  59. static int tcp_out_of_resources(struct sock *sk, int do_reset)
  60. {
  61. struct tcp_sock *tp = tcp_sk(sk);
  62. int orphans = atomic_read(&tcp_orphan_count);
  63. /* If peer does not open window for long time, or did not transmit
  64. * anything for long time, penalize it. */
  65. if ((s32)(tcp_time_stamp - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset)
  66. orphans <<= 1;
  67. /* If some dubious ICMP arrived, penalize even more. */
  68. if (sk->sk_err_soft)
  69. orphans <<= 1;
  70. if (orphans >= sysctl_tcp_max_orphans ||
  71. (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
  72. atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2])) {
  73. if (net_ratelimit())
  74. printk(KERN_INFO "Out of socket memory\n");
  75. /* Catch exceptional cases, when connection requires reset.
  76. * 1. Last segment was sent recently. */
  77. if ((s32)(tcp_time_stamp - tp->lsndtime) <= TCP_TIMEWAIT_LEN ||
  78. /* 2. Window is closed. */
  79. (!tp->snd_wnd && !tp->packets_out))
  80. do_reset = 1;
  81. if (do_reset)
  82. tcp_send_active_reset(sk, GFP_ATOMIC);
  83. tcp_done(sk);
  84. NET_INC_STATS_BH(LINUX_MIB_TCPABORTONMEMORY);
  85. return 1;
  86. }
  87. return 0;
  88. }
  89. /* Calculate maximal number or retries on an orphaned socket. */
  90. static int tcp_orphan_retries(struct sock *sk, int alive)
  91. {
  92. int retries = sysctl_tcp_orphan_retries; /* May be zero. */
  93. /* We know from an ICMP that something is wrong. */
  94. if (sk->sk_err_soft && !alive)
  95. retries = 0;
  96. /* However, if socket sent something recently, select some safe
  97. * number of retries. 8 corresponds to >100 seconds with minimal
  98. * RTO of 200msec. */
  99. if (retries == 0 && alive)
  100. retries = 8;
  101. return retries;
  102. }
  103. /* A write timeout has occurred. Process the after effects. */
  104. static int tcp_write_timeout(struct sock *sk)
  105. {
  106. struct inet_connection_sock *icsk = inet_csk(sk);
  107. struct tcp_sock *tp = tcp_sk(sk);
  108. int retry_until;
  109. int mss;
  110. if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
  111. if (icsk->icsk_retransmits)
  112. dst_negative_advice(&sk->sk_dst_cache);
  113. retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
  114. } else {
  115. if (icsk->icsk_retransmits >= sysctl_tcp_retries1) {
  116. /* Black hole detection */
  117. if (sysctl_tcp_mtu_probing) {
  118. if (!icsk->icsk_mtup.enabled) {
  119. icsk->icsk_mtup.enabled = 1;
  120. tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
  121. } else {
  122. mss = min(sysctl_tcp_base_mss,
  123. tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low)/2);
  124. mss = max(mss, 68 - tp->tcp_header_len);
  125. icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, mss);
  126. tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
  127. }
  128. }
  129. dst_negative_advice(&sk->sk_dst_cache);
  130. }
  131. retry_until = sysctl_tcp_retries2;
  132. if (sock_flag(sk, SOCK_DEAD)) {
  133. const int alive = (icsk->icsk_rto < TCP_RTO_MAX);
  134. retry_until = tcp_orphan_retries(sk, alive);
  135. if (tcp_out_of_resources(sk, alive || icsk->icsk_retransmits < retry_until))
  136. return 1;
  137. }
  138. }
  139. if (icsk->icsk_retransmits >= retry_until) {
  140. /* Has it gone just too far? */
  141. tcp_write_err(sk);
  142. return 1;
  143. }
  144. return 0;
  145. }
  146. static void tcp_delack_timer(unsigned long data)
  147. {
  148. struct sock *sk = (struct sock*)data;
  149. struct tcp_sock *tp = tcp_sk(sk);
  150. struct inet_connection_sock *icsk = inet_csk(sk);
  151. bh_lock_sock(sk);
  152. if (sock_owned_by_user(sk)) {
  153. /* Try again later. */
  154. icsk->icsk_ack.blocked = 1;
  155. NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
  156. sk_reset_timer(sk, &icsk->icsk_delack_timer, jiffies + TCP_DELACK_MIN);
  157. goto out_unlock;
  158. }
  159. sk_stream_mem_reclaim(sk);
  160. if (sk->sk_state == TCP_CLOSE || !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
  161. goto out;
  162. if (time_after(icsk->icsk_ack.timeout, jiffies)) {
  163. sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
  164. goto out;
  165. }
  166. icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
  167. if (!skb_queue_empty(&tp->ucopy.prequeue)) {
  168. struct sk_buff *skb;
  169. NET_INC_STATS_BH(LINUX_MIB_TCPSCHEDULERFAILED);
  170. while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
  171. sk->sk_backlog_rcv(sk, skb);
  172. tp->ucopy.memory = 0;
  173. }
  174. if (inet_csk_ack_scheduled(sk)) {
  175. if (!icsk->icsk_ack.pingpong) {
  176. /* Delayed ACK missed: inflate ATO. */
  177. icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto);
  178. } else {
  179. /* Delayed ACK missed: leave pingpong mode and
  180. * deflate ATO.
  181. */
  182. icsk->icsk_ack.pingpong = 0;
  183. icsk->icsk_ack.ato = TCP_ATO_MIN;
  184. }
  185. tcp_send_ack(sk);
  186. NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
  187. }
  188. TCP_CHECK_TIMER(sk);
  189. out:
  190. if (tcp_memory_pressure)
  191. sk_stream_mem_reclaim(sk);
  192. out_unlock:
  193. bh_unlock_sock(sk);
  194. sock_put(sk);
  195. }
  196. static void tcp_probe_timer(struct sock *sk)
  197. {
  198. struct inet_connection_sock *icsk = inet_csk(sk);
  199. struct tcp_sock *tp = tcp_sk(sk);
  200. int max_probes;
  201. if (tp->packets_out || !sk->sk_send_head) {
  202. icsk->icsk_probes_out = 0;
  203. return;
  204. }
  205. /* *WARNING* RFC 1122 forbids this
  206. *
  207. * It doesn't AFAIK, because we kill the retransmit timer -AK
  208. *
  209. * FIXME: We ought not to do it, Solaris 2.5 actually has fixing
  210. * this behaviour in Solaris down as a bug fix. [AC]
  211. *
  212. * Let me to explain. icsk_probes_out is zeroed by incoming ACKs
  213. * even if they advertise zero window. Hence, connection is killed only
  214. * if we received no ACKs for normal connection timeout. It is not killed
  215. * only because window stays zero for some time, window may be zero
  216. * until armageddon and even later. We are in full accordance
  217. * with RFCs, only probe timer combines both retransmission timeout
  218. * and probe timeout in one bottle. --ANK
  219. */
  220. max_probes = sysctl_tcp_retries2;
  221. if (sock_flag(sk, SOCK_DEAD)) {
  222. const int alive = ((icsk->icsk_rto << icsk->icsk_backoff) < TCP_RTO_MAX);
  223. max_probes = tcp_orphan_retries(sk, alive);
  224. if (tcp_out_of_resources(sk, alive || icsk->icsk_probes_out <= max_probes))
  225. return;
  226. }
  227. if (icsk->icsk_probes_out > max_probes) {
  228. tcp_write_err(sk);
  229. } else {
  230. /* Only send another probe if we didn't close things up. */
  231. tcp_send_probe0(sk);
  232. }
  233. }
  234. /*
  235. * The TCP retransmit timer.
  236. */
  237. static void tcp_retransmit_timer(struct sock *sk)
  238. {
  239. struct tcp_sock *tp = tcp_sk(sk);
  240. struct inet_connection_sock *icsk = inet_csk(sk);
  241. if (!tp->packets_out)
  242. goto out;
  243. BUG_TRAP(!skb_queue_empty(&sk->sk_write_queue));
  244. if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) &&
  245. !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) {
  246. /* Receiver dastardly shrinks window. Our retransmits
  247. * become zero probes, but we should not timeout this
  248. * connection. If the socket is an orphan, time it out,
  249. * we cannot allow such beasts to hang infinitely.
  250. */
  251. #ifdef TCP_DEBUG
  252. if (net_ratelimit()) {
  253. struct inet_sock *inet = inet_sk(sk);
  254. printk(KERN_DEBUG "TCP: Treason uncloaked! Peer %u.%u.%u.%u:%u/%u shrinks window %u:%u. Repaired.\n",
  255. NIPQUAD(inet->daddr), ntohs(inet->dport),
  256. inet->num, tp->snd_una, tp->snd_nxt);
  257. }
  258. #endif
  259. if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) {
  260. tcp_write_err(sk);
  261. goto out;
  262. }
  263. tcp_enter_loss(sk, 0);
  264. tcp_retransmit_skb(sk, skb_peek(&sk->sk_write_queue));
  265. __sk_dst_reset(sk);
  266. goto out_reset_timer;
  267. }
  268. if (tcp_write_timeout(sk))
  269. goto out;
  270. if (icsk->icsk_retransmits == 0) {
  271. if (icsk->icsk_ca_state == TCP_CA_Disorder ||
  272. icsk->icsk_ca_state == TCP_CA_Recovery) {
  273. if (tp->rx_opt.sack_ok) {
  274. if (icsk->icsk_ca_state == TCP_CA_Recovery)
  275. NET_INC_STATS_BH(LINUX_MIB_TCPSACKRECOVERYFAIL);
  276. else
  277. NET_INC_STATS_BH(LINUX_MIB_TCPSACKFAILURES);
  278. } else {
  279. if (icsk->icsk_ca_state == TCP_CA_Recovery)
  280. NET_INC_STATS_BH(LINUX_MIB_TCPRENORECOVERYFAIL);
  281. else
  282. NET_INC_STATS_BH(LINUX_MIB_TCPRENOFAILURES);
  283. }
  284. } else if (icsk->icsk_ca_state == TCP_CA_Loss) {
  285. NET_INC_STATS_BH(LINUX_MIB_TCPLOSSFAILURES);
  286. } else {
  287. NET_INC_STATS_BH(LINUX_MIB_TCPTIMEOUTS);
  288. }
  289. }
  290. if (tcp_use_frto(sk)) {
  291. tcp_enter_frto(sk);
  292. } else {
  293. tcp_enter_loss(sk, 0);
  294. }
  295. if (tcp_retransmit_skb(sk, skb_peek(&sk->sk_write_queue)) > 0) {
  296. /* Retransmission failed because of local congestion,
  297. * do not backoff.
  298. */
  299. if (!icsk->icsk_retransmits)
  300. icsk->icsk_retransmits = 1;
  301. inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
  302. min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL),
  303. TCP_RTO_MAX);
  304. goto out;
  305. }
  306. /* Increase the timeout each time we retransmit. Note that
  307. * we do not increase the rtt estimate. rto is initialized
  308. * from rtt, but increases here. Jacobson (SIGCOMM 88) suggests
  309. * that doubling rto each time is the least we can get away with.
  310. * In KA9Q, Karn uses this for the first few times, and then
  311. * goes to quadratic. netBSD doubles, but only goes up to *64,
  312. * and clamps at 1 to 64 sec afterwards. Note that 120 sec is
  313. * defined in the protocol as the maximum possible RTT. I guess
  314. * we'll have to use something other than TCP to talk to the
  315. * University of Mars.
  316. *
  317. * PAWS allows us longer timeouts and large windows, so once
  318. * implemented ftp to mars will work nicely. We will have to fix
  319. * the 120 second clamps though!
  320. */
  321. icsk->icsk_backoff++;
  322. icsk->icsk_retransmits++;
  323. out_reset_timer:
  324. icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX);
  325. inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX);
  326. if (icsk->icsk_retransmits > sysctl_tcp_retries1)
  327. __sk_dst_reset(sk);
  328. out:;
  329. }
  330. static void tcp_write_timer(unsigned long data)
  331. {
  332. struct sock *sk = (struct sock*)data;
  333. struct inet_connection_sock *icsk = inet_csk(sk);
  334. int event;
  335. bh_lock_sock(sk);
  336. if (sock_owned_by_user(sk)) {
  337. /* Try again later */
  338. sk_reset_timer(sk, &icsk->icsk_retransmit_timer, jiffies + (HZ / 20));
  339. goto out_unlock;
  340. }
  341. if (sk->sk_state == TCP_CLOSE || !icsk->icsk_pending)
  342. goto out;
  343. if (time_after(icsk->icsk_timeout, jiffies)) {
  344. sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
  345. goto out;
  346. }
  347. event = icsk->icsk_pending;
  348. icsk->icsk_pending = 0;
  349. switch (event) {
  350. case ICSK_TIME_RETRANS:
  351. tcp_retransmit_timer(sk);
  352. break;
  353. case ICSK_TIME_PROBE0:
  354. tcp_probe_timer(sk);
  355. break;
  356. }
  357. TCP_CHECK_TIMER(sk);
  358. out:
  359. sk_stream_mem_reclaim(sk);
  360. out_unlock:
  361. bh_unlock_sock(sk);
  362. sock_put(sk);
  363. }
  364. /*
  365. * Timer for listening sockets
  366. */
  367. static void tcp_synack_timer(struct sock *sk)
  368. {
  369. inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,
  370. TCP_TIMEOUT_INIT, TCP_RTO_MAX);
  371. }
  372. void tcp_set_keepalive(struct sock *sk, int val)
  373. {
  374. if ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))
  375. return;
  376. if (val && !sock_flag(sk, SOCK_KEEPOPEN))
  377. inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk)));
  378. else if (!val)
  379. inet_csk_delete_keepalive_timer(sk);
  380. }
  381. static void tcp_keepalive_timer (unsigned long data)
  382. {
  383. struct sock *sk = (struct sock *) data;
  384. struct inet_connection_sock *icsk = inet_csk(sk);
  385. struct tcp_sock *tp = tcp_sk(sk);
  386. __u32 elapsed;
  387. /* Only process if socket is not in use. */
  388. bh_lock_sock(sk);
  389. if (sock_owned_by_user(sk)) {
  390. /* Try again later. */
  391. inet_csk_reset_keepalive_timer (sk, HZ/20);
  392. goto out;
  393. }
  394. if (sk->sk_state == TCP_LISTEN) {
  395. tcp_synack_timer(sk);
  396. goto out;
  397. }
  398. if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {
  399. if (tp->linger2 >= 0) {
  400. const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;
  401. if (tmo > 0) {
  402. tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
  403. goto out;
  404. }
  405. }
  406. tcp_send_active_reset(sk, GFP_ATOMIC);
  407. goto death;
  408. }
  409. if (!sock_flag(sk, SOCK_KEEPOPEN) || sk->sk_state == TCP_CLOSE)
  410. goto out;
  411. elapsed = keepalive_time_when(tp);
  412. /* It is alive without keepalive 8) */
  413. if (tp->packets_out || sk->sk_send_head)
  414. goto resched;
  415. elapsed = tcp_time_stamp - tp->rcv_tstamp;
  416. if (elapsed >= keepalive_time_when(tp)) {
  417. if ((!tp->keepalive_probes && icsk->icsk_probes_out >= sysctl_tcp_keepalive_probes) ||
  418. (tp->keepalive_probes && icsk->icsk_probes_out >= tp->keepalive_probes)) {
  419. tcp_send_active_reset(sk, GFP_ATOMIC);
  420. tcp_write_err(sk);
  421. goto out;
  422. }
  423. if (tcp_write_wakeup(sk) <= 0) {
  424. icsk->icsk_probes_out++;
  425. elapsed = keepalive_intvl_when(tp);
  426. } else {
  427. /* If keepalive was lost due to local congestion,
  428. * try harder.
  429. */
  430. elapsed = TCP_RESOURCE_PROBE_INTERVAL;
  431. }
  432. } else {
  433. /* It is tp->rcv_tstamp + keepalive_time_when(tp) */
  434. elapsed = keepalive_time_when(tp) - elapsed;
  435. }
  436. TCP_CHECK_TIMER(sk);
  437. sk_stream_mem_reclaim(sk);
  438. resched:
  439. inet_csk_reset_keepalive_timer (sk, elapsed);
  440. goto out;
  441. death:
  442. tcp_done(sk);
  443. out:
  444. bh_unlock_sock(sk);
  445. sock_put(sk);
  446. }