git.oblomov.eu Git - linux-2.6/blob - include/net/tcp.h

   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  *              Definitions for the TCP module.
   7  *
   8  * Version:     @(#)tcp.h       1.0.5   05/23/93
   9  *
  10  * Authors:     Ross Biro
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *
  13  *              This program is free software; you can redistribute it and/or
  14  *              modify it under the terms of the GNU General Public License
  15  *              as published by the Free Software Foundation; either version
  16  *              2 of the License, or (at your option) any later version.
  17  */
  18 #ifndef _TCP_H
  19 #define _TCP_H
  20
  21 #define TCP_DEBUG 1
  22 #define FASTRETRANS_DEBUG 1
  23
  24 #include <linux/config.h>
  25 #include <linux/list.h>
  26 #include <linux/tcp.h>
  27 #include <linux/slab.h>
  28 #include <linux/cache.h>
  29 #include <linux/percpu.h>
  30
  31 #include <net/inet_connection_sock.h>
  32 #include <net/inet_timewait_sock.h>
  33 #include <net/inet_hashtables.h>
  34 #include <net/checksum.h>
  35 #include <net/request_sock.h>
  36 #include <net/sock.h>
  37 #include <net/snmp.h>
  38 #include <net/ip.h>
  39 #include <net/tcp_states.h>
  40
  41 #include <linux/seq_file.h>
  42
  43 extern struct inet_hashinfo tcp_hashinfo;
  44
  45 extern atomic_t tcp_orphan_count;
  46 extern void tcp_time_wait(struct sock *sk, int state, int timeo);
  47 extern void inet_twsk_deschedule(struct inet_timewait_sock *tw,
  48                                  struct inet_timewait_death_row *twdr);
  49
  50 #define MAX_TCP_HEADER  (128 + MAX_HEADER)
  51
  52 /*
  53  * Never offer a window over 32767 without using window scaling. Some
  54  * poor stacks do signed 16bit maths!
  55  */
  56 #define MAX_TCP_WINDOW          32767U
  57
  58 /* Minimal accepted MSS. It is (60+60+8) - (20+20). */
  59 #define TCP_MIN_MSS             88U
  60
  61 /* Minimal RCV_MSS. */
  62 #define TCP_MIN_RCVMSS          536U
  63
  64 /* After receiving this amount of duplicate ACKs fast retransmit starts. */
  65 #define TCP_FASTRETRANS_THRESH 3
  66
  67 /* Maximal reordering. */
  68 #define TCP_MAX_REORDERING      127
  69
  70 /* Maximal number of ACKs sent quickly to accelerate slow-start. */
  71 #define TCP_MAX_QUICKACKS       16U
  72
  73 /* urg_data states */
  74 #define TCP_URG_VALID   0x0100
  75 #define TCP_URG_NOTYET  0x0200
  76 #define TCP_URG_READ    0x0400
  77
  78 #define TCP_RETR1       3       /*
  79                                  * This is how many retries it does before it
  80                                  * tries to figure out if the gateway is
  81                                  * down. Minimal RFC value is 3; it corresponds
  82                                  * to ~3sec-8min depending on RTO.
  83                                  */
  84
  85 #define TCP_RETR2       15      /*
  86                                  * This should take at least
  87                                  * 90 minutes to time out.
  88                                  * RFC1122 says that the limit is 100 sec.
  89                                  * 15 is ~13-30min depending on RTO.
  90                                  */
  91
  92 #define TCP_SYN_RETRIES  5      /* number of times to retry active opening a
  93                                  * connection: ~180sec is RFC minumum   */
  94
  95 #define TCP_SYNACK_RETRIES 5    /* number of times to retry passive opening a
  96                                  * connection: ~180sec is RFC minumum   */
  97
  98
  99 #define TCP_ORPHAN_RETRIES 7    /* number of times to retry on an orphaned
 100                                  * socket. 7 is ~50sec-16min.
 101                                  */
 102
 103
 104 #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
 105                                   * state, about 60 seconds     */
 106 #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN
 107                                  /* BSD style FIN_WAIT2 deadlock breaker.
 108                                   * It used to be 3min, new value is 60sec,
 109                                   * to combine FIN-WAIT-2 timeout with
 110                                   * TIME-WAIT timer.
 111                                   */
 112
 113 #define TCP_DELACK_MAX  ((unsigned)(HZ/5))      /* maximal time to delay before sending an ACK */
 114 #if HZ >= 100
 115 #define TCP_DELACK_MIN  ((unsigned)(HZ/25))     /* minimal time to delay before sending an ACK */
 116 #define TCP_ATO_MIN     ((unsigned)(HZ/25))
 117 #else
 118 #define TCP_DELACK_MIN  4U
 119 #define TCP_ATO_MIN     4U
 120 #endif
 121 #define TCP_RTO_MAX     ((unsigned)(120*HZ))
 122 #define TCP_RTO_MIN     ((unsigned)(HZ/5))
 123 #define TCP_TIMEOUT_INIT ((unsigned)(3*HZ))     /* RFC 1122 initial RTO value   */
 124
 125 #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
 126                                                          * for local resources.
 127                                                          */
 128
 129 #define TCP_KEEPALIVE_TIME      (120*60*HZ)     /* two hours */
 130 #define TCP_KEEPALIVE_PROBES    9               /* Max of 9 keepalive probes    */
 131 #define TCP_KEEPALIVE_INTVL     (75*HZ)
 132
 133 #define MAX_TCP_KEEPIDLE        32767
 134 #define MAX_TCP_KEEPINTVL       32767
 135 #define MAX_TCP_KEEPCNT         127
 136 #define MAX_TCP_SYNCNT          127
 137
 138 #define TCP_SYNQ_INTERVAL       (HZ/5)  /* Period of SYNACK timer */
 139 #define TCP_SYNQ_HSIZE          512     /* Size of SYNACK hash table */
 140
 141 #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24)
 142 #define TCP_PAWS_MSL    60              /* Per-host timestamps are invalidated
 143                                          * after this time. It should be equal
 144                                          * (or greater than) TCP_TIMEWAIT_LEN
 145                                          * to provide reliability equal to one
 146                                          * provided by timewait state.
 147                                          */
 148 #define TCP_PAWS_WINDOW 1               /* Replay window for per-host
 149                                          * timestamps. It must be less than
 150                                          * minimal timewait lifetime.
 151                                          */
 152 /*
 153  *      TCP option
 154  */
 155
 156 #define TCPOPT_NOP              1       /* Padding */
 157 #define TCPOPT_EOL              0       /* End of options */
 158 #define TCPOPT_MSS              2       /* Segment size negotiating */
 159 #define TCPOPT_WINDOW           3       /* Window scaling */
 160 #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
 161 #define TCPOPT_SACK             5       /* SACK Block */
 162 #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
 163
 164 /*
 165  *     TCP option lengths
 166  */
 167
 168 #define TCPOLEN_MSS            4
 169 #define TCPOLEN_WINDOW         3
 170 #define TCPOLEN_SACK_PERM      2
 171 #define TCPOLEN_TIMESTAMP      10
 172
 173 /* But this is what stacks really send out. */
 174 #define TCPOLEN_TSTAMP_ALIGNED          12
 175 #define TCPOLEN_WSCALE_ALIGNED          4
 176 #define TCPOLEN_SACKPERM_ALIGNED        4
 177 #define TCPOLEN_SACK_BASE               2
 178 #define TCPOLEN_SACK_BASE_ALIGNED       4
 179 #define TCPOLEN_SACK_PERBLOCK           8
 180
 181 /* Flags in tp->nonagle */
 182 #define TCP_NAGLE_OFF           1       /* Nagle's algo is disabled */
 183 #define TCP_NAGLE_CORK          2       /* Socket is corked         */
 184 #define TCP_NAGLE_PUSH          4       /* Cork is overriden for already queued data */
 185
 186 extern struct inet_timewait_death_row tcp_death_row;
 187
 188 /* sysctl variables for tcp */
 189 extern int sysctl_tcp_timestamps;
 190 extern int sysctl_tcp_window_scaling;
 191 extern int sysctl_tcp_sack;
 192 extern int sysctl_tcp_fin_timeout;
 193 extern int sysctl_tcp_keepalive_time;
 194 extern int sysctl_tcp_keepalive_probes;
 195 extern int sysctl_tcp_keepalive_intvl;
 196 extern int sysctl_tcp_syn_retries;
 197 extern int sysctl_tcp_synack_retries;
 198 extern int sysctl_tcp_retries1;
 199 extern int sysctl_tcp_retries2;
 200 extern int sysctl_tcp_orphan_retries;
 201 extern int sysctl_tcp_syncookies;
 202 extern int sysctl_tcp_retrans_collapse;
 203 extern int sysctl_tcp_stdurg;
 204 extern int sysctl_tcp_rfc1337;
 205 extern int sysctl_tcp_abort_on_overflow;
 206 extern int sysctl_tcp_max_orphans;
 207 extern int sysctl_tcp_fack;
 208 extern int sysctl_tcp_reordering;
 209 extern int sysctl_tcp_ecn;
 210 extern int sysctl_tcp_dsack;
 211 extern int sysctl_tcp_mem[3];
 212 extern int sysctl_tcp_wmem[3];
 213 extern int sysctl_tcp_rmem[3];
 214 extern int sysctl_tcp_app_win;
 215 extern int sysctl_tcp_adv_win_scale;
 216 extern int sysctl_tcp_tw_reuse;
 217 extern int sysctl_tcp_frto;
 218 extern int sysctl_tcp_low_latency;
 219 extern int sysctl_tcp_nometrics_save;
 220 extern int sysctl_tcp_moderate_rcvbuf;
 221 extern int sysctl_tcp_tso_win_divisor;
 222
 223 extern atomic_t tcp_memory_allocated;
 224 extern atomic_t tcp_sockets_allocated;
 225 extern int tcp_memory_pressure;
 226
 227 /*
 228  *      Pointers to address related TCP functions
 229  *      (i.e. things that depend on the address family)
 230  */
 231
 232 struct tcp_func {
 233         int                     (*queue_xmit)           (struct sk_buff *skb,
 234                                                          int ipfragok);
 235
 236         void                    (*send_check)           (struct sock *sk,
 237                                                          struct tcphdr *th,
 238                                                          int len,
 239                                                          struct sk_buff *skb);
 240
 241         int                     (*rebuild_header)       (struct sock *sk);
 242
 243         int                     (*conn_request)         (struct sock *sk,
 244                                                          struct sk_buff *skb);
 245
 246         struct sock *           (*syn_recv_sock)        (struct sock *sk,
 247                                                          struct sk_buff *skb,
 248                                                          struct request_sock *req,
 249                                                          struct dst_entry *dst);
 250
 251         int                     (*remember_stamp)       (struct sock *sk);
 252
 253         __u16                   net_header_len;
 254
 255         int                     (*setsockopt)           (struct sock *sk,
 256                                                          int level,
 257                                                          int optname,
 258                                                          char __user *optval,
 259                                                          int optlen);
 260
 261         int                     (*getsockopt)           (struct sock *sk,
 262                                                          int level,
 263                                                          int optname,
 264                                                          char __user *optval,
 265                                                          int __user *optlen);
 266
 267
 268         void                    (*addr2sockaddr)        (struct sock *sk,
 269                                                          struct sockaddr *);
 270
 271         int sockaddr_len;
 272 };
 273
 274 /*
 275  * The next routines deal with comparing 32 bit unsigned ints
 276  * and worry about wraparound (automatic with unsigned arithmetic).
 277  */
 278
 279 static inline int before(__u32 seq1, __u32 seq2)
 280 {
 281         return (__s32)(seq1-seq2) < 0;
 282 }
 283
 284 static inline int after(__u32 seq1, __u32 seq2)
 285 {
 286         return (__s32)(seq2-seq1) < 0;
 287 }
 288
 289
 290 /* is s2<=s1<=s3 ? */
 291 static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
 292 {
 293         return seq3 - seq2 >= seq1 - seq2;
 294 }
 295
 296
 297 extern struct proto tcp_prot;
 298
 299 DECLARE_SNMP_STAT(struct tcp_mib, tcp_statistics);
 300 #define TCP_INC_STATS(field)            SNMP_INC_STATS(tcp_statistics, field)
 301 #define TCP_INC_STATS_BH(field)         SNMP_INC_STATS_BH(tcp_statistics, field)
 302 #define TCP_INC_STATS_USER(field)       SNMP_INC_STATS_USER(tcp_statistics, field)
 303 #define TCP_DEC_STATS(field)            SNMP_DEC_STATS(tcp_statistics, field)
 304 #define TCP_ADD_STATS_BH(field, val)    SNMP_ADD_STATS_BH(tcp_statistics, field, val)
 305 #define TCP_ADD_STATS_USER(field, val)  SNMP_ADD_STATS_USER(tcp_statistics, field, val)
 306
 307 extern void                     tcp_v4_err(struct sk_buff *skb, u32);
 308
 309 extern void                     tcp_shutdown (struct sock *sk, int how);
 310
 311 extern int                      tcp_v4_rcv(struct sk_buff *skb);
 312
 313 extern int                      tcp_v4_remember_stamp(struct sock *sk);
 314
 315 extern int                      tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
 316
 317 extern int                      tcp_sendmsg(struct kiocb *iocb, struct sock *sk,
 318                                             struct msghdr *msg, size_t size);
 319 extern ssize_t                  tcp_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags);
 320
 321 extern int                      tcp_ioctl(struct sock *sk,
 322                                           int cmd,
 323                                           unsigned long arg);
 324
 325 extern int                      tcp_rcv_state_process(struct sock *sk,
 326                                                       struct sk_buff *skb,
 327                                                       struct tcphdr *th,
 328                                                       unsigned len);
 329
 330 extern int                      tcp_rcv_established(struct sock *sk,
 331                                                     struct sk_buff *skb,
 332                                                     struct tcphdr *th,
 333                                                     unsigned len);
 334
 335 extern void                     tcp_rcv_space_adjust(struct sock *sk);
 336
 337 static inline void tcp_dec_quickack_mode(struct sock *sk,
 338                                          const unsigned int pkts)
 339 {
 340         struct inet_connection_sock *icsk = inet_csk(sk);
 341
 342         if (icsk->icsk_ack.quick) {
 343                 if (pkts >= icsk->icsk_ack.quick) {
 344                         icsk->icsk_ack.quick = 0;
 345                         /* Leaving quickack mode we deflate ATO. */
 346                         icsk->icsk_ack.ato   = TCP_ATO_MIN;
 347                 } else
 348                         icsk->icsk_ack.quick -= pkts;
 349         }
 350 }
 351
 352 extern void tcp_enter_quickack_mode(struct sock *sk);
 353
 354 static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
 355 {
 356         rx_opt->tstamp_ok = rx_opt->sack_ok = rx_opt->wscale_ok = rx_opt->snd_wscale = 0;
 357 }
 358
 359 enum tcp_tw_status
 360 {
 361         TCP_TW_SUCCESS = 0,
 362         TCP_TW_RST = 1,
 363         TCP_TW_ACK = 2,
 364         TCP_TW_SYN = 3
 365 };
 366
 367
 368 extern enum tcp_tw_status       tcp_timewait_state_process(struct inet_timewait_sock *tw,
 369                                                            struct sk_buff *skb,
 370                                                            const struct tcphdr *th);
 371
 372 extern struct sock *            tcp_check_req(struct sock *sk,struct sk_buff *skb,
 373                                               struct request_sock *req,
 374                                               struct request_sock **prev);
 375 extern int                      tcp_child_process(struct sock *parent,
 376                                                   struct sock *child,
 377                                                   struct sk_buff *skb);
 378 extern void                     tcp_enter_frto(struct sock *sk);
 379 extern void                     tcp_enter_loss(struct sock *sk, int how);
 380 extern void                     tcp_clear_retrans(struct tcp_sock *tp);
 381 extern void                     tcp_update_metrics(struct sock *sk);
 382
 383 extern void                     tcp_close(struct sock *sk,
 384                                           long timeout);
 385 extern unsigned int             tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait);
 386
 387 extern int                      tcp_getsockopt(struct sock *sk, int level,
 388                                                int optname,
 389                                                char __user *optval,
 390                                                int __user *optlen);
 391 extern int                      tcp_setsockopt(struct sock *sk, int level,
 392                                                int optname, char __user *optval,
 393                                                int optlen);
 394 extern void                     tcp_set_keepalive(struct sock *sk, int val);
 395 extern int                      tcp_recvmsg(struct kiocb *iocb, struct sock *sk,
 396                                             struct msghdr *msg,
 397                                             size_t len, int nonblock,
 398                                             int flags, int *addr_len);
 399
 400 extern void                     tcp_parse_options(struct sk_buff *skb,
 401                                                   struct tcp_options_received *opt_rx,
 402                                                   int estab);
 403
 404 /*
 405  *      TCP v4 functions exported for the inet6 API
 406  */
 407
 408 extern void                     tcp_v4_send_check(struct sock *sk,
 409                                                   struct tcphdr *th, int len,
 410                                                   struct sk_buff *skb);
 411
 412 extern int                      tcp_v4_conn_request(struct sock *sk,
 413                                                     struct sk_buff *skb);
 414
 415 extern struct sock *            tcp_create_openreq_child(struct sock *sk,
 416                                                          struct request_sock *req,
 417                                                          struct sk_buff *skb);
 418
 419 extern struct sock *            tcp_v4_syn_recv_sock(struct sock *sk,
 420                                                      struct sk_buff *skb,
 421                                                      struct request_sock *req,
 422                                                         struct dst_entry *dst);
 423
 424 extern int                      tcp_v4_do_rcv(struct sock *sk,
 425                                               struct sk_buff *skb);
 426
 427 extern int                      tcp_v4_connect(struct sock *sk,
 428                                                struct sockaddr *uaddr,
 429                                                int addr_len);
 430
 431 extern int                      tcp_connect(struct sock *sk);
 432
 433 extern struct sk_buff *         tcp_make_synack(struct sock *sk,
 434                                                 struct dst_entry *dst,
 435                                                 struct request_sock *req);
 436
 437 extern int                      tcp_disconnect(struct sock *sk, int flags);
 438
 439 extern void                     tcp_unhash(struct sock *sk);
 440
 441 extern int                      tcp_v4_hash_connecting(struct sock *sk);
 442
 443
 444 /* From syncookies.c */
 445 extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
 446                                     struct ip_options *opt);
 447 extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb,
 448                                      __u16 *mss);
 449
 450 /* tcp_output.c */
 451
 452 extern void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp,
 453                                       unsigned int cur_mss, int nonagle);
 454 extern int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp);
 455 extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
 456 extern void tcp_xmit_retransmit_queue(struct sock *);
 457 extern void tcp_simple_retransmit(struct sock *);
 458 extern int tcp_trim_head(struct sock *, struct sk_buff *, u32);
 459
 460 extern void tcp_send_probe0(struct sock *);
 461 extern void tcp_send_partial(struct sock *);
 462 extern int  tcp_write_wakeup(struct sock *);
 463 extern void tcp_send_fin(struct sock *sk);
 464 extern void tcp_send_active_reset(struct sock *sk,
 465                                   unsigned int __nocast priority);
 466 extern int  tcp_send_synack(struct sock *);
 467 extern void tcp_push_one(struct sock *, unsigned int mss_now);
 468 extern void tcp_send_ack(struct sock *sk);
 469 extern void tcp_send_delayed_ack(struct sock *sk);
 470
 471 /* tcp_input.c */
 472 extern void tcp_cwnd_application_limited(struct sock *sk);
 473
 474 /* tcp_timer.c */
 475 extern void tcp_init_xmit_timers(struct sock *);
 476 static inline void tcp_clear_xmit_timers(struct sock *sk)
 477 {
 478         inet_csk_clear_xmit_timers(sk);
 479 }
 480
 481 extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
 482 extern unsigned int tcp_current_mss(struct sock *sk, int large);
 483
 484 /* tcp_diag.c */
 485 extern void tcp_get_info(struct sock *, struct tcp_info *);
 486
 487 /* Read 'sendfile()'-style from a TCP socket */
 488 typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
 489                                 unsigned int, size_t);
 490 extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
 491                          sk_read_actor_t recv_actor);
 492
 493 /* Initialize RCV_MSS value.
 494  * RCV_MSS is an our guess about MSS used by the peer.
 495  * We haven't any direct information about the MSS.
 496  * It's better to underestimate the RCV_MSS rather than overestimate.
 497  * Overestimations make us ACKing less frequently than needed.
 498  * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss().
 499  */
 500
 501 static inline void tcp_initialize_rcv_mss(struct sock *sk)
 502 {
 503         struct tcp_sock *tp = tcp_sk(sk);
 504         unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);
 505
 506         hint = min(hint, tp->rcv_wnd/2);
 507         hint = min(hint, TCP_MIN_RCVMSS);
 508         hint = max(hint, TCP_MIN_MSS);
 509
 510         inet_csk(sk)->icsk_ack.rcv_mss = hint;
 511 }
 512
 513 static __inline__ void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
 514 {
 515         tp->pred_flags = htonl((tp->tcp_header_len << 26) |
 516                                ntohl(TCP_FLAG_ACK) |
 517                                snd_wnd);
 518 }
 519
 520 static __inline__ void tcp_fast_path_on(struct tcp_sock *tp)
 521 {
 522         __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
 523 }
 524
 525 static inline void tcp_fast_path_check(struct sock *sk, struct tcp_sock *tp)
 526 {
 527         if (skb_queue_empty(&tp->out_of_order_queue) &&
 528             tp->rcv_wnd &&
 529             atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
 530             !tp->urg_data)
 531                 tcp_fast_path_on(tp);
 532 }
 533
 534 /* Compute the actual receive window we are currently advertising.
 535  * Rcv_nxt can be after the window if our peer push more data
 536  * than the offered window.
 537  */
 538 static __inline__ u32 tcp_receive_window(const struct tcp_sock *tp)
 539 {
 540         s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
 541
 542         if (win < 0)
 543                 win = 0;
 544         return (u32) win;
 545 }
 546
 547 /* Choose a new window, without checks for shrinking, and without
 548  * scaling applied to the result.  The caller does these things
 549  * if necessary.  This is a "raw" window selection.
 550  */
 551 extern u32      __tcp_select_window(struct sock *sk);
 552
 553 /* TCP timestamps are only 32-bits, this causes a slight
 554  * complication on 64-bit systems since we store a snapshot
 555  * of jiffies in the buffer control blocks below.  We decidely
 556  * only use of the low 32-bits of jiffies and hide the ugly
 557  * casts with the following macro.
 558  */
 559 #define tcp_time_stamp          ((__u32)(jiffies))
 560
 561 /* This is what the send packet queueing engine uses to pass
 562  * TCP per-packet control information to the transmission
 563  * code.  We also store the host-order sequence numbers in
 564  * here too.  This is 36 bytes on 32-bit architectures,
 565  * 40 bytes on 64-bit machines, if this grows please adjust
 566  * skbuff.h:skbuff->cb[xxx] size appropriately.
 567  */
 568 struct tcp_skb_cb {
 569         union {
 570                 struct inet_skb_parm    h4;
 571 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
 572                 struct inet6_skb_parm   h6;
 573 #endif
 574         } header;       /* For incoming frames          */
 575         __u32           seq;            /* Starting sequence number     */
 576         __u32           end_seq;        /* SEQ + FIN + SYN + datalen    */
 577         __u32           when;           /* used to compute rtt's        */
 578         __u8            flags;          /* TCP header flags.            */
 579
 580         /* NOTE: These must match up to the flags byte in a
 581          *       real TCP header.
 582          */
 583 #define TCPCB_FLAG_FIN          0x01
 584 #define TCPCB_FLAG_SYN          0x02
 585 #define TCPCB_FLAG_RST          0x04
 586 #define TCPCB_FLAG_PSH          0x08
 587 #define TCPCB_FLAG_ACK          0x10
 588 #define TCPCB_FLAG_URG          0x20
 589 #define TCPCB_FLAG_ECE          0x40
 590 #define TCPCB_FLAG_CWR          0x80
 591
 592         __u8            sacked;         /* State flags for SACK/FACK.   */
 593 #define TCPCB_SACKED_ACKED      0x01    /* SKB ACK'd by a SACK block    */
 594 #define TCPCB_SACKED_RETRANS    0x02    /* SKB retransmitted            */
 595 #define TCPCB_LOST              0x04    /* SKB is lost                  */
 596 #define TCPCB_TAGBITS           0x07    /* All tag bits                 */
 597
 598 #define TCPCB_EVER_RETRANS      0x80    /* Ever retransmitted frame     */
 599 #define TCPCB_RETRANS           (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
 600
 601 #define TCPCB_URG               0x20    /* Urgent pointer advenced here */
 602
 603 #define TCPCB_AT_TAIL           (TCPCB_URG)
 604
 605         __u16           urg_ptr;        /* Valid w/URG flags is set.    */
 606         __u32           ack_seq;        /* Sequence number ACK'd        */
 607 };
 608
 609 #define TCP_SKB_CB(__skb)       ((struct tcp_skb_cb *)&((__skb)->cb[0]))
 610
 611 #include <net/tcp_ecn.h>
 612
 613 /* Due to TSO, an SKB can be composed of multiple actual
 614  * packets.  To keep these tracked properly, we use this.
 615  */
 616 static inline int tcp_skb_pcount(const struct sk_buff *skb)
 617 {
 618         return skb_shinfo(skb)->tso_segs;
 619 }
 620
 621 /* This is valid iff tcp_skb_pcount() > 1. */
 622 static inline int tcp_skb_mss(const struct sk_buff *skb)
 623 {
 624         return skb_shinfo(skb)->tso_size;
 625 }
 626
 627 static inline void tcp_dec_pcount_approx(__u32 *count,
 628                                          const struct sk_buff *skb)
 629 {
 630         if (*count) {
 631                 *count -= tcp_skb_pcount(skb);
 632                 if ((int)*count < 0)
 633                         *count = 0;
 634         }
 635 }
 636
 637 static inline void tcp_packets_out_inc(struct sock *sk,
 638                                        struct tcp_sock *tp,
 639                                        const struct sk_buff *skb)
 640 {
 641         int orig = tp->packets_out;
 642
 643         tp->packets_out += tcp_skb_pcount(skb);
 644         if (!orig)
 645                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
 646                                           inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
 647 }
 648
 649 static inline void tcp_packets_out_dec(struct tcp_sock *tp,
 650                                        const struct sk_buff *skb)
 651 {
 652         tp->packets_out -= tcp_skb_pcount(skb);
 653 }
 654
 655 /* Events passed to congestion control interface */
 656 enum tcp_ca_event {
 657         CA_EVENT_TX_START,      /* first transmit when no packets in flight */
 658         CA_EVENT_CWND_RESTART,  /* congestion window restart */
 659         CA_EVENT_COMPLETE_CWR,  /* end of congestion recovery */
 660         CA_EVENT_FRTO,          /* fast recovery timeout */
 661         CA_EVENT_LOSS,          /* loss timeout */
 662         CA_EVENT_FAST_ACK,      /* in sequence ack */
 663         CA_EVENT_SLOW_ACK,      /* other ack */
 664 };
 665
 666 /*
 667  * Interface for adding new TCP congestion control handlers
 668  */
 669 #define TCP_CA_NAME_MAX 16
 670 struct tcp_congestion_ops {
 671         struct list_head        list;
 672
 673         /* initialize private data (optional) */
 674         void (*init)(struct tcp_sock *tp);
 675         /* cleanup private data  (optional) */
 676         void (*release)(struct tcp_sock *tp);
 677
 678         /* return slow start threshold (required) */
 679         u32 (*ssthresh)(struct tcp_sock *tp);
 680         /* lower bound for congestion window (optional) */
 681         u32 (*min_cwnd)(struct tcp_sock *tp);
 682         /* do new cwnd calculation (required) */
 683         void (*cong_avoid)(struct tcp_sock *tp, u32 ack,
 684                            u32 rtt, u32 in_flight, int good_ack);
 685         /* round trip time sample per acked packet (optional) */
 686         void (*rtt_sample)(struct tcp_sock *tp, u32 usrtt);
 687         /* call before changing ca_state (optional) */
 688         void (*set_state)(struct tcp_sock *tp, u8 new_state);
 689         /* call when cwnd event occurs (optional) */
 690         void (*cwnd_event)(struct tcp_sock *tp, enum tcp_ca_event ev);
 691         /* new value of cwnd after loss (optional) */
 692         u32  (*undo_cwnd)(struct tcp_sock *tp);
 693         /* hook for packet ack accounting (optional) */
 694         void (*pkts_acked)(struct tcp_sock *tp, u32 num_acked);
 695         /* get info for tcp_diag (optional) */
 696         void (*get_info)(struct tcp_sock *tp, u32 ext, struct sk_buff *skb);
 697
 698         char            name[TCP_CA_NAME_MAX];
 699         struct module   *owner;
 700 };
 701
 702 extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
 703 extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
 704
 705 extern void tcp_init_congestion_control(struct tcp_sock *tp);
 706 extern void tcp_cleanup_congestion_control(struct tcp_sock *tp);
 707 extern int tcp_set_default_congestion_control(const char *name);
 708 extern void tcp_get_default_congestion_control(char *name);
 709 extern int tcp_set_congestion_control(struct tcp_sock *tp, const char *name);
 710
 711 extern struct tcp_congestion_ops tcp_init_congestion_ops;
 712 extern u32 tcp_reno_ssthresh(struct tcp_sock *tp);
 713 extern void tcp_reno_cong_avoid(struct tcp_sock *tp, u32 ack,
 714                                 u32 rtt, u32 in_flight, int flag);
 715 extern u32 tcp_reno_min_cwnd(struct tcp_sock *tp);
 716 extern struct tcp_congestion_ops tcp_reno;
 717
 718 static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)
 719 {
 720         if (tp->ca_ops->set_state)
 721                 tp->ca_ops->set_state(tp, ca_state);
 722         tp->ca_state = ca_state;
 723 }
 724
 725 static inline void tcp_ca_event(struct tcp_sock *tp, enum tcp_ca_event event)
 726 {
 727         if (tp->ca_ops->cwnd_event)
 728                 tp->ca_ops->cwnd_event(tp, event);
 729 }
 730
 731 /* This determines how many packets are "in the network" to the best
 732  * of our knowledge.  In many cases it is conservative, but where
 733  * detailed information is available from the receiver (via SACK
 734  * blocks etc.) we can make more aggressive calculations.
 735  *
 736  * Use this for decisions involving congestion control, use just
 737  * tp->packets_out to determine if the send queue is empty or not.
 738  *
 739  * Read this equation as:
 740  *
 741  *      "Packets sent once on transmission queue" MINUS
 742  *      "Packets left network, but not honestly ACKed yet" PLUS
 743  *      "Packets fast retransmitted"
 744  */
 745 static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
 746 {
 747         return (tp->packets_out - tp->left_out + tp->retrans_out);
 748 }
 749
 750 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
 751  * The exception is rate halving phase, when cwnd is decreasing towards
 752  * ssthresh.
 753  */
 754 static inline __u32 tcp_current_ssthresh(struct tcp_sock *tp)
 755 {
 756         if ((1<<tp->ca_state)&(TCPF_CA_CWR|TCPF_CA_Recovery))
 757                 return tp->snd_ssthresh;
 758         else
 759                 return max(tp->snd_ssthresh,
 760                            ((tp->snd_cwnd >> 1) +
 761                             (tp->snd_cwnd >> 2)));
 762 }
 763
 764 static inline void tcp_sync_left_out(struct tcp_sock *tp)
 765 {
 766         if (tp->rx_opt.sack_ok &&
 767             (tp->sacked_out >= tp->packets_out - tp->lost_out))
 768                 tp->sacked_out = tp->packets_out - tp->lost_out;
 769         tp->left_out = tp->sacked_out + tp->lost_out;
 770 }
 771
 772 /* Set slow start threshold and cwnd not falling to slow start */
 773 static inline void __tcp_enter_cwr(struct tcp_sock *tp)
 774 {
 775         tp->undo_marker = 0;
 776         tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
 777         tp->snd_cwnd = min(tp->snd_cwnd,
 778                            tcp_packets_in_flight(tp) + 1U);
 779         tp->snd_cwnd_cnt = 0;
 780         tp->high_seq = tp->snd_nxt;
 781         tp->snd_cwnd_stamp = tcp_time_stamp;
 782         TCP_ECN_queue_cwr(tp);
 783 }
 784
 785 static inline void tcp_enter_cwr(struct tcp_sock *tp)
 786 {
 787         tp->prior_ssthresh = 0;
 788         if (tp->ca_state < TCP_CA_CWR) {
 789                 __tcp_enter_cwr(tp);
 790                 tcp_set_ca_state(tp, TCP_CA_CWR);
 791         }
 792 }
 793
 794 extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst);
 795
 796 /* Slow start with delack produces 3 packets of burst, so that
 797  * it is safe "de facto".
 798  */
 799 static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
 800 {
 801         return 3;
 802 }
 803
 804 static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss,
 805                                            const struct sk_buff *skb)
 806 {
 807         if (skb->len < mss)
 808                 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
 809 }
 810
 811 static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp)
 812 {
 813         const struct inet_connection_sock *icsk = inet_csk(sk);
 814         if (!tp->packets_out && !icsk->icsk_pending)
 815                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
 816                                           icsk->icsk_rto, TCP_RTO_MAX);
 817 }
 818
 819 static __inline__ void tcp_push_pending_frames(struct sock *sk,
 820                                                struct tcp_sock *tp)
 821 {
 822         __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle);
 823 }
 824
 825 static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq)
 826 {
 827         tp->snd_wl1 = seq;
 828 }
 829
 830 static __inline__ void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq)
 831 {
 832         tp->snd_wl1 = seq;
 833 }
 834
 835 /*
 836  * Calculate(/check) TCP checksum
 837  */
 838 static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len,
 839                                    unsigned long saddr, unsigned long daddr,
 840                                    unsigned long base)
 841 {
 842         return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
 843 }
 844
 845 static __inline__ int __tcp_checksum_complete(struct sk_buff *skb)
 846 {
 847         return (unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
 848 }
 849
 850 static __inline__ int tcp_checksum_complete(struct sk_buff *skb)
 851 {
 852         return skb->ip_summed != CHECKSUM_UNNECESSARY &&
 853                 __tcp_checksum_complete(skb);
 854 }
 855
 856 /* Prequeue for VJ style copy to user, combined with checksumming. */
 857
 858 static __inline__ void tcp_prequeue_init(struct tcp_sock *tp)
 859 {
 860         tp->ucopy.task = NULL;
 861         tp->ucopy.len = 0;
 862         tp->ucopy.memory = 0;
 863         skb_queue_head_init(&tp->ucopy.prequeue);
 864 }
 865
 866 /* Packet is added to VJ-style prequeue for processing in process
 867  * context, if a reader task is waiting. Apparently, this exciting
 868  * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
 869  * failed somewhere. Latency? Burstiness? Well, at least now we will
 870  * see, why it failed. 8)8)                               --ANK
 871  *
 872  * NOTE: is this not too big to inline?
 873  */
 874 static __inline__ int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
 875 {
 876         struct tcp_sock *tp = tcp_sk(sk);
 877
 878         if (!sysctl_tcp_low_latency && tp->ucopy.task) {
 879                 __skb_queue_tail(&tp->ucopy.prequeue, skb);
 880                 tp->ucopy.memory += skb->truesize;
 881                 if (tp->ucopy.memory > sk->sk_rcvbuf) {
 882                         struct sk_buff *skb1;
 883
 884                         BUG_ON(sock_owned_by_user(sk));
 885
 886                         while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
 887                                 sk->sk_backlog_rcv(sk, skb1);
 888                                 NET_INC_STATS_BH(LINUX_MIB_TCPPREQUEUEDROPPED);
 889                         }
 890
 891                         tp->ucopy.memory = 0;
 892                 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
 893                         wake_up_interruptible(sk->sk_sleep);
 894                         if (!inet_csk_ack_scheduled(sk))
 895                                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
 896                                                           (3 * TCP_RTO_MIN) / 4,
 897                                                           TCP_RTO_MAX);
 898                 }
 899                 return 1;
 900         }
 901         return 0;
 902 }
 903
 904
 905 #undef STATE_TRACE
 906
 907 #ifdef STATE_TRACE
 908 static const char *statename[]={
 909         "Unused","Established","Syn Sent","Syn Recv",
 910         "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
 911         "Close Wait","Last ACK","Listen","Closing"
 912 };
 913 #endif
 914
 915 static __inline__ void tcp_set_state(struct sock *sk, int state)
 916 {
 917         int oldstate = sk->sk_state;
 918
 919         switch (state) {
 920         case TCP_ESTABLISHED:
 921                 if (oldstate != TCP_ESTABLISHED)
 922                         TCP_INC_STATS(TCP_MIB_CURRESTAB);
 923                 break;
 924
 925         case TCP_CLOSE:
 926                 if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
 927                         TCP_INC_STATS(TCP_MIB_ESTABRESETS);
 928
 929                 sk->sk_prot->unhash(sk);
 930                 if (inet_csk(sk)->icsk_bind_hash &&
 931                     !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
 932                         inet_put_port(&tcp_hashinfo, sk);
 933                 /* fall through */
 934         default:
 935                 if (oldstate==TCP_ESTABLISHED)
 936                         TCP_DEC_STATS(TCP_MIB_CURRESTAB);
 937         }
 938
 939         /* Change state AFTER socket is unhashed to avoid closed
 940          * socket sitting in hash tables.
 941          */
 942         sk->sk_state = state;
 943
 944 #ifdef STATE_TRACE
 945         SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
 946 #endif
 947 }
 948
 949 static __inline__ void tcp_done(struct sock *sk)
 950 {
 951         tcp_set_state(sk, TCP_CLOSE);
 952         tcp_clear_xmit_timers(sk);
 953
 954         sk->sk_shutdown = SHUTDOWN_MASK;
 955
 956         if (!sock_flag(sk, SOCK_DEAD))
 957                 sk->sk_state_change(sk);
 958         else
 959                 inet_csk_destroy_sock(sk);
 960 }
 961
 962 static __inline__ void tcp_sack_reset(struct tcp_options_received *rx_opt)
 963 {
 964         rx_opt->dsack = 0;
 965         rx_opt->eff_sacks = 0;
 966         rx_opt->num_sacks = 0;
 967 }
 968
 969 static __inline__ void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp, __u32 tstamp)
 970 {
 971         if (tp->rx_opt.tstamp_ok) {
 972                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
 973                                           (TCPOPT_NOP << 16) |
 974                                           (TCPOPT_TIMESTAMP << 8) |
 975                                           TCPOLEN_TIMESTAMP);
 976                 *ptr++ = htonl(tstamp);
 977                 *ptr++ = htonl(tp->rx_opt.ts_recent);
 978         }
 979         if (tp->rx_opt.eff_sacks) {
 980                 struct tcp_sack_block *sp = tp->rx_opt.dsack ? tp->duplicate_sack : tp->selective_acks;
 981                 int this_sack;
 982
 983                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
 984                                           (TCPOPT_NOP << 16) |
 985                                           (TCPOPT_SACK << 8) |
 986                                           (TCPOLEN_SACK_BASE +
 987                                            (tp->rx_opt.eff_sacks * TCPOLEN_SACK_PERBLOCK)));
 988                 for(this_sack = 0; this_sack < tp->rx_opt.eff_sacks; this_sack++) {
 989                         *ptr++ = htonl(sp[this_sack].start_seq);
 990                         *ptr++ = htonl(sp[this_sack].end_seq);
 991                 }
 992                 if (tp->rx_opt.dsack) {
 993                         tp->rx_opt.dsack = 0;
 994                         tp->rx_opt.eff_sacks--;
 995                 }
 996         }
 997 }
 998
 999 /* Construct a tcp options header for a SYN or SYN_ACK packet.
1000  * If this is every changed make sure to change the definition of
1001  * MAX_SYN_SIZE to match the new maximum number of options that you
1002  * can generate.
1003  */
1004 static inline void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack,
1005                                              int offer_wscale, int wscale, __u32 tstamp, __u32 ts_recent)
1006 {
1007         /* We always get an MSS option.
1008          * The option bytes which will be seen in normal data
1009          * packets should timestamps be used, must be in the MSS
1010          * advertised.  But we subtract them from tp->mss_cache so
1011          * that calculations in tcp_sendmsg are simpler etc.
1012          * So account for this fact here if necessary.  If we
1013          * don't do this correctly, as a receiver we won't
1014          * recognize data packets as being full sized when we
1015          * should, and thus we won't abide by the delayed ACK
1016          * rules correctly.
1017          * SACKs don't matter, we never delay an ACK when we
1018          * have any of those going out.
1019          */
1020         *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss);
1021         if (ts) {
1022                 if(sack)
1023                         *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) |
1024                                                   (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1025                 else
1026                         *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1027                                                   (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1028                 *ptr++ = htonl(tstamp);         /* TSVAL */
1029                 *ptr++ = htonl(ts_recent);      /* TSECR */
1030         } else if(sack)
1031                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1032                                           (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM);
1033         if (offer_wscale)
1034                 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale));
1035 }
1036
1037 /* Determine a window scaling and initial window to offer. */
1038 extern void tcp_select_initial_window(int __space, __u32 mss,
1039                                       __u32 *rcv_wnd, __u32 *window_clamp,
1040                                       int wscale_ok, __u8 *rcv_wscale);
1041
1042 static inline int tcp_win_from_space(int space)
1043 {
1044         return sysctl_tcp_adv_win_scale<=0 ?
1045                 (space>>(-sysctl_tcp_adv_win_scale)) :
1046                 space - (space>>sysctl_tcp_adv_win_scale);
1047 }
1048
1049 /* Note: caller must be prepared to deal with negative returns */
1050 static inline int tcp_space(const struct sock *sk)
1051 {
1052         return tcp_win_from_space(sk->sk_rcvbuf -
1053                                   atomic_read(&sk->sk_rmem_alloc));
1054 }
1055
1056 static inline int tcp_full_space(const struct sock *sk)
1057 {
1058         return tcp_win_from_space(sk->sk_rcvbuf);
1059 }
1060
1061 static __inline__ void tcp_openreq_init(struct request_sock *req,
1062                                         struct tcp_options_received *rx_opt,
1063                                         struct sk_buff *skb)
1064 {
1065         struct inet_request_sock *ireq = inet_rsk(req);
1066
1067         req->rcv_wnd = 0;               /* So that tcp_send_synack() knows! */
1068         tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
1069         req->mss = rx_opt->mss_clamp;
1070         req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
1071         ireq->tstamp_ok = rx_opt->tstamp_ok;
1072         ireq->sack_ok = rx_opt->sack_ok;
1073         ireq->snd_wscale = rx_opt->snd_wscale;
1074         ireq->wscale_ok = rx_opt->wscale_ok;
1075         ireq->acked = 0;
1076         ireq->ecn_ok = 0;
1077         ireq->rmt_port = skb->h.th->source;
1078 }
1079
1080 extern void tcp_enter_memory_pressure(void);
1081
1082 static inline int keepalive_intvl_when(const struct tcp_sock *tp)
1083 {
1084         return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
1085 }
1086
1087 static inline int keepalive_time_when(const struct tcp_sock *tp)
1088 {
1089         return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
1090 }
1091
1092 static inline int tcp_fin_time(const struct sock *sk)
1093 {
1094         int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout;
1095         const int rto = inet_csk(sk)->icsk_rto;
1096
1097         if (fin_timeout < (rto << 2) - (rto >> 1))
1098                 fin_timeout = (rto << 2) - (rto >> 1);
1099
1100         return fin_timeout;
1101 }
1102
1103 static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, int rst)
1104 {
1105         if ((s32)(rx_opt->rcv_tsval - rx_opt->ts_recent) >= 0)
1106                 return 0;
1107         if (xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)
1108                 return 0;
1109
1110         /* RST segments are not recommended to carry timestamp,
1111            and, if they do, it is recommended to ignore PAWS because
1112            "their cleanup function should take precedence over timestamps."
1113            Certainly, it is mistake. It is necessary to understand the reasons
1114            of this constraint to relax it: if peer reboots, clock may go
1115            out-of-sync and half-open connections will not be reset.
1116            Actually, the problem would be not existing if all
1117            the implementations followed draft about maintaining clock
1118            via reboots. Linux-2.2 DOES NOT!
1119
1120            However, we can relax time bounds for RST segments to MSL.
1121          */
1122         if (rst && xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL)
1123                 return 0;
1124         return 1;
1125 }
1126
1127 #define TCP_CHECK_TIMER(sk) do { } while (0)
1128
1129 static inline int tcp_use_frto(const struct sock *sk)
1130 {
1131         const struct tcp_sock *tp = tcp_sk(sk);
1132
1133         /* F-RTO must be activated in sysctl and there must be some
1134          * unsent new data, and the advertised window should allow
1135          * sending it.
1136          */
1137         return (sysctl_tcp_frto && sk->sk_send_head &&
1138                 !after(TCP_SKB_CB(sk->sk_send_head)->end_seq,
1139                        tp->snd_una + tp->snd_wnd));
1140 }
1141
1142 static inline void tcp_mib_init(void)
1143 {
1144         /* See RFC 2012 */
1145         TCP_ADD_STATS_USER(TCP_MIB_RTOALGORITHM, 1);
1146         TCP_ADD_STATS_USER(TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
1147         TCP_ADD_STATS_USER(TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
1148         TCP_ADD_STATS_USER(TCP_MIB_MAXCONN, -1);
1149 }
1150
1151 /* /proc */
1152 enum tcp_seq_states {
1153         TCP_SEQ_STATE_LISTENING,
1154         TCP_SEQ_STATE_OPENREQ,
1155         TCP_SEQ_STATE_ESTABLISHED,
1156         TCP_SEQ_STATE_TIME_WAIT,
1157 };
1158
1159 struct tcp_seq_afinfo {
1160         struct module           *owner;
1161         char                    *name;
1162         sa_family_t             family;
1163         int                     (*seq_show) (struct seq_file *m, void *v);
1164         struct file_operations  *seq_fops;
1165 };
1166
1167 struct tcp_iter_state {
1168         sa_family_t             family;
1169         enum tcp_seq_states     state;
1170         struct sock             *syn_wait_sk;
1171         int                     bucket, sbucket, num, uid;
1172         struct seq_operations   seq_ops;
1173 };
1174
1175 extern int tcp_proc_register(struct tcp_seq_afinfo *afinfo);
1176 extern void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo);
1177
1178 #endif  /* _TCP_H */