LXR linux/include/net/inet_connection

   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/*
   3 * NET          Generic infrastructure for INET connection oriented protocols.
   4 *
   5 *              Definitions for inet_connection_sock 
   6 *
   7 * Authors:     Many people, see the TCP sources
   8 *
   9 *              From code originally in TCP
  10 */
  11#ifndef _INET_CONNECTION_SOCK_H
  12#define _INET_CONNECTION_SOCK_H
  13
  14#include <linux/compiler.h>
  15#include <linux/string.h>
  16#include <linux/timer.h>
  17#include <linux/poll.h>
  18#include <linux/kernel.h>
  19#include <linux/sockptr.h>
  20
  21#include <net/inet_sock.h>
  22#include <net/request_sock.h>
  23
  24/* Cancel timers, when they are not required. */
  25#undef INET_CSK_CLEAR_TIMERS
  26
  27struct inet_bind_bucket;
  28struct tcp_congestion_ops;
  29
  30/*
  31 * Pointers to address related TCP functions
  32 * (i.e. things that depend on the address family)
  33 */
  34struct inet_connection_sock_af_ops {
  35        int         (*queue_xmit)(struct sock *sk, struct sk_buff *skb, struct flowi *fl);
  36        void        (*send_check)(struct sock *sk, struct sk_buff *skb);
  37        int         (*rebuild_header)(struct sock *sk);
  38        void        (*sk_rx_dst_set)(struct sock *sk, const struct sk_buff *skb);
  39        int         (*conn_request)(struct sock *sk, struct sk_buff *skb);
  40        struct sock *(*syn_recv_sock)(const struct sock *sk, struct sk_buff *skb,
  41                                      struct request_sock *req,
  42                                      struct dst_entry *dst,
  43                                      struct request_sock *req_unhash,
  44                                      bool *own_req);
  45        u16         net_header_len;
  46        u16         net_frag_header_len;
  47        u16         sockaddr_len;
  48        int         (*setsockopt)(struct sock *sk, int level, int optname,
  49                                  sockptr_t optval, unsigned int optlen);
  50        int         (*getsockopt)(struct sock *sk, int level, int optname,
  51                                  char __user *optval, int __user *optlen);
  52        void        (*addr2sockaddr)(struct sock *sk, struct sockaddr *);
  53        void        (*mtu_reduced)(struct sock *sk);
  54};
  55
  56/** inet_connection_sock - INET connection oriented sock
  57 *
  58 * @icsk_accept_queue:     FIFO of established children
  59 * @icsk_bind_hash:        Bind node
  60 * @icsk_timeout:          Timeout
  61 * @icsk_retransmit_timer: Resend (no ack)
  62 * @icsk_rto:              Retransmit timeout
  63 * @icsk_pmtu_cookie       Last pmtu seen by socket
  64 * @icsk_ca_ops            Pluggable congestion control hook
  65 * @icsk_af_ops            Operations which are AF_INET{4,6} specific
  66 * @icsk_ulp_ops           Pluggable ULP control hook
  67 * @icsk_ulp_data          ULP private data
  68 * @icsk_clean_acked       Clean acked data hook
  69 * @icsk_listen_portaddr_node   hash to the portaddr listener hashtable
  70 * @icsk_ca_state:         Congestion control state
  71 * @icsk_retransmits:      Number of unrecovered [RTO] timeouts
  72 * @icsk_pending:          Scheduled timer event
  73 * @icsk_backoff:          Backoff
  74 * @icsk_syn_retries:      Number of allowed SYN (or equivalent) retries
  75 * @icsk_probes_out:       unanswered 0 window probes
  76 * @icsk_ext_hdr_len:      Network protocol overhead (IP/IPv6 options)
  77 * @icsk_ack:              Delayed ACK control data
  78 * @icsk_mtup;             MTU probing control data
  79 */
  80struct inet_connection_sock {
  81        /* inet_sock has to be the first member! */
  82        struct inet_sock          icsk_inet;
  83        struct request_sock_queue icsk_accept_queue;
  84        struct inet_bind_bucket   *icsk_bind_hash;
  85        unsigned long             icsk_timeout;
  86        struct timer_list         icsk_retransmit_timer;
  87        struct timer_list         icsk_delack_timer;
  88        __u32                     icsk_rto;
  89        __u32                     icsk_rto_min;
  90        __u32                     icsk_delack_max;
  91        __u32                     icsk_pmtu_cookie;
  92        const struct tcp_congestion_ops *icsk_ca_ops;
  93        const struct inet_connection_sock_af_ops *icsk_af_ops;
  94        const struct tcp_ulp_ops  *icsk_ulp_ops;
  95        void __rcu                *icsk_ulp_data;
  96        void (*icsk_clean_acked)(struct sock *sk, u32 acked_seq);
  97        struct hlist_node         icsk_listen_portaddr_node;
  98        unsigned int              (*icsk_sync_mss)(struct sock *sk, u32 pmtu);
  99        __u8                      icsk_ca_state:5,
 100                                  icsk_ca_initialized:1,
 101                                  icsk_ca_setsockopt:1,
 102                                  icsk_ca_dst_locked:1;
 103        __u8                      icsk_retransmits;
 104        __u8                      icsk_pending;
 105        __u8                      icsk_backoff;
 106        __u8                      icsk_syn_retries;
 107        __u8                      icsk_probes_out;
 108        __u16                     icsk_ext_hdr_len;
 109        struct {
 110                __u8              pending;       /* ACK is pending                         */
 111                __u8              quick;         /* Scheduled number of quick acks         */
 112                __u8              pingpong;      /* The session is interactive             */
 113                __u8              retry;         /* Number of attempts                     */
 114                __u32             ato;           /* Predicted tick of soft clock           */
 115                unsigned long     timeout;       /* Currently scheduled timeout            */
 116                __u32             lrcvtime;      /* timestamp of last received data packet */
 117                __u16             last_seg_size; /* Size of last incoming segment          */
 118                __u16             rcv_mss;       /* MSS used for delayed ACK decisions     */
 119        } icsk_ack;
 120        struct {
 121                int               enabled;
 122
 123                /* Range of MTUs to search */
 124                int               search_high;
 125                int               search_low;
 126
 127                /* Information on the current probe. */
 128                int               probe_size;
 129
 130                u32               probe_timestamp;
 131        } icsk_mtup;
 132        u32                       icsk_user_timeout;
 133
 134        u64                       icsk_ca_priv[104 / sizeof(u64)];
 135#define ICSK_CA_PRIV_SIZE      (13 * sizeof(u64))
 136};
 137
 138#define ICSK_TIME_RETRANS       1       /* Retransmit timer */
 139#define ICSK_TIME_DACK          2       /* Delayed ack timer */
 140#define ICSK_TIME_PROBE0        3       /* Zero window probe timer */
 141#define ICSK_TIME_EARLY_RETRANS 4       /* Early retransmit timer */
 142#define ICSK_TIME_LOSS_PROBE    5       /* Tail loss probe timer */
 143#define ICSK_TIME_REO_TIMEOUT   6       /* Reordering timer */
 144
 145static inline struct inet_connection_sock *inet_csk(const struct sock *sk)
 146{
 147        return (struct inet_connection_sock *)sk;
 148}
 149
 150static inline void *inet_csk_ca(const struct sock *sk)
 151{
 152        return (void *)inet_csk(sk)->icsk_ca_priv;
 153}
 154
 155struct sock *inet_csk_clone_lock(const struct sock *sk,
 156                                 const struct request_sock *req,
 157                                 const gfp_t priority);
 158
 159enum inet_csk_ack_state_t {
 160        ICSK_ACK_SCHED  = 1,
 161        ICSK_ACK_TIMER  = 2,
 162        ICSK_ACK_PUSHED = 4,
 163        ICSK_ACK_PUSHED2 = 8,
 164        ICSK_ACK_NOW = 16       /* Send the next ACK immediately (once) */
 165};
 166
 167void inet_csk_init_xmit_timers(struct sock *sk,
 168                               void (*retransmit_handler)(struct timer_list *),
 169                               void (*delack_handler)(struct timer_list *),
 170                               void (*keepalive_handler)(struct timer_list *));
 171void inet_csk_clear_xmit_timers(struct sock *sk);
 172
 173static inline void inet_csk_schedule_ack(struct sock *sk)
 174{
 175        inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_SCHED;
 176}
 177
 178static inline int inet_csk_ack_scheduled(const struct sock *sk)
 179{
 180        return inet_csk(sk)->icsk_ack.pending & ICSK_ACK_SCHED;
 181}
 182
 183static inline void inet_csk_delack_init(struct sock *sk)
 184{
 185        memset(&inet_csk(sk)->icsk_ack, 0, sizeof(inet_csk(sk)->icsk_ack));
 186}
 187
 188void inet_csk_delete_keepalive_timer(struct sock *sk);
 189void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long timeout);
 190
 191static inline void inet_csk_clear_xmit_timer(struct sock *sk, const int what)
 192{
 193        struct inet_connection_sock *icsk = inet_csk(sk);
 194
 195        if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
 196                icsk->icsk_pending = 0;
 197#ifdef INET_CSK_CLEAR_TIMERS
 198                sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
 199#endif
 200        } else if (what == ICSK_TIME_DACK) {
 201                icsk->icsk_ack.pending = 0;
 202                icsk->icsk_ack.retry = 0;
 203#ifdef INET_CSK_CLEAR_TIMERS
 204                sk_stop_timer(sk, &icsk->icsk_delack_timer);
 205#endif
 206        } else {
 207                pr_debug("inet_csk BUG: unknown timer value\n");
 208        }
 209}
 210
 211/*
 212 *      Reset the retransmission timer
 213 */
 214static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
 215                                             unsigned long when,
 216                                             const unsigned long max_when)
 217{
 218        struct inet_connection_sock *icsk = inet_csk(sk);
 219
 220        if (when > max_when) {
 221                pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",
 222                         sk, what, when, (void *)_THIS_IP_);
 223                when = max_when;
 224        }
 225
 226        if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0 ||
 227            what == ICSK_TIME_EARLY_RETRANS || what == ICSK_TIME_LOSS_PROBE ||
 228            what == ICSK_TIME_REO_TIMEOUT) {
 229                icsk->icsk_pending = what;
 230                icsk->icsk_timeout = jiffies + when;
 231                sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
 232        } else if (what == ICSK_TIME_DACK) {
 233                icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
 234                icsk->icsk_ack.timeout = jiffies + when;
 235                sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
 236        } else {
 237                pr_debug("inet_csk BUG: unknown timer value\n");
 238        }
 239}
 240
 241static inline unsigned long
 242inet_csk_rto_backoff(const struct inet_connection_sock *icsk,
 243                     unsigned long max_when)
 244{
 245        u64 when = (u64)icsk->icsk_rto << icsk->icsk_backoff;
 246
 247        return (unsigned long)min_t(u64, when, max_when);
 248}
 249
 250struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern);
 251
 252int inet_csk_get_port(struct sock *sk, unsigned short snum);
 253
 254struct dst_entry *inet_csk_route_req(const struct sock *sk, struct flowi4 *fl4,
 255                                     const struct request_sock *req);
 256struct dst_entry *inet_csk_route_child_sock(const struct sock *sk,
 257                                            struct sock *newsk,
 258                                            const struct request_sock *req);
 259
 260struct sock *inet_csk_reqsk_queue_add(struct sock *sk,
 261                                      struct request_sock *req,
 262                                      struct sock *child);
 263void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req,
 264                                   unsigned long timeout);
 265struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child,
 266                                         struct request_sock *req,
 267                                         bool own_req);
 268
 269static inline void inet_csk_reqsk_queue_added(struct sock *sk)
 270{
 271        reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue);
 272}
 273
 274static inline int inet_csk_reqsk_queue_len(const struct sock *sk)
 275{
 276        return reqsk_queue_len(&inet_csk(sk)->icsk_accept_queue);
 277}
 278
 279static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk)
 280{
 281        return inet_csk_reqsk_queue_len(sk) >= sk->sk_max_ack_backlog;
 282}
 283
 284void inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req);
 285void inet_csk_reqsk_queue_drop_and_put(struct sock *sk, struct request_sock *req);
 286
 287static inline void inet_csk_prepare_for_destroy_sock(struct sock *sk)
 288{
 289        /* The below has to be done to allow calling inet_csk_destroy_sock */
 290        sock_set_flag(sk, SOCK_DEAD);
 291        percpu_counter_inc(sk->sk_prot->orphan_count);
 292}
 293
 294void inet_csk_destroy_sock(struct sock *sk);
 295void inet_csk_prepare_forced_close(struct sock *sk);
 296
 297/*
 298 * LISTEN is a special case for poll..
 299 */
 300static inline __poll_t inet_csk_listen_poll(const struct sock *sk)
 301{
 302        return !reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue) ?
 303                        (EPOLLIN | EPOLLRDNORM) : 0;
 304}
 305
 306int inet_csk_listen_start(struct sock *sk, int backlog);
 307void inet_csk_listen_stop(struct sock *sk);
 308
 309void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr);
 310
 311/* update the fast reuse flag when adding a socket */
 312void inet_csk_update_fastreuse(struct inet_bind_bucket *tb,
 313                               struct sock *sk);
 314
 315struct dst_entry *inet_csk_update_pmtu(struct sock *sk, u32 mtu);
 316
 317#define TCP_PINGPONG_THRESH     3
 318
 319static inline void inet_csk_enter_pingpong_mode(struct sock *sk)
 320{
 321        inet_csk(sk)->icsk_ack.pingpong = TCP_PINGPONG_THRESH;
 322}
 323
 324static inline void inet_csk_exit_pingpong_mode(struct sock *sk)
 325{
 326        inet_csk(sk)->icsk_ack.pingpong = 0;
 327}
 328
 329static inline bool inet_csk_in_pingpong_mode(struct sock *sk)
 330{
 331        return inet_csk(sk)->icsk_ack.pingpong >= TCP_PINGPONG_THRESH;
 332}
 333
 334static inline void inet_csk_inc_pingpong_cnt(struct sock *sk)
 335{
 336        struct inet_connection_sock *icsk = inet_csk(sk);
 337
 338        if (icsk->icsk_ack.pingpong < U8_MAX)
 339                icsk->icsk_ack.pingpong++;
 340}
 341
 342static inline bool inet_csk_has_ulp(struct sock *sk)
 343{
 344        return inet_sk(sk)->is_icsk && !!inet_csk(sk)->icsk_ulp_ops;
 345}
 346
 347#endif /* _INET_CONNECTION_SOCK_H */
 348