sys/sys/sockbuf.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1990, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)socketvar.h 8.3 (Berkeley) 2/19/95
  32  */
  33 #ifndef _SYS_SOCKBUF_H_
  34 #define _SYS_SOCKBUF_H_
  35
  36 /*
  37  * Constants for sb_flags field of struct sockbuf/xsockbuf.
  38  */
  39 #define SB_TLS_RX       0x01            /* using KTLS on RX */
  40 #define SB_TLS_RX_RUNNING 0x02          /* KTLS RX operation running */
  41 #define SB_WAIT         0x04            /* someone is waiting for data/space */
  42 #define SB_SEL          0x08            /* someone is selecting */
  43 #define SB_ASYNC        0x10            /* ASYNC I/O, need signals */
  44 #define SB_UPCALL       0x20            /* someone wants an upcall */
  45 #define SB_NOINTR       0x40            /* operations not interruptible */
  46 #define SB_AIO          0x80            /* AIO operations queued */
  47 #define SB_KNOTE        0x100           /* kernel note attached */
  48 #define SB_NOCOALESCE   0x200           /* don't coalesce new data into existing mbufs */
  49 #define SB_IN_TOE       0x400           /* socket buffer is in the middle of an operation */
  50 #define SB_AUTOSIZE     0x800           /* automatically size socket buffer */
  51 #define SB_STOP         0x1000          /* backpressure indicator */
  52 #define SB_AIO_RUNNING  0x2000          /* AIO operation running */
  53 #define SB_UNUSED       0x4000          /* previously used for SB_TLS_IFNET */
  54 #define SB_TLS_RX_RESYNC 0x8000         /* KTLS RX lost HW sync */
  55
  56 #define SBS_CANTSENDMORE        0x0010  /* can't send more data to peer */
  57 #define SBS_CANTRCVMORE         0x0020  /* can't receive more data from peer */
  58 #define SBS_RCVATMARK           0x0040  /* at mark on input */
  59
  60 #if defined(_KERNEL) || defined(_WANT_SOCKET)
  61 #include <sys/_lock.h>
  62 #include <sys/_mutex.h>
  63 #include <sys/_sx.h>
  64 #include <sys/_task.h>
  65
  66 #define SB_MAX          (2*1024*1024)   /* default for max chars in sockbuf */
  67
  68 struct ktls_session;
  69 struct mbuf;
  70 struct sockaddr;
  71 struct socket;
  72 struct sockopt;
  73 struct thread;
  74 struct selinfo;
  75
  76 /*
  77  * Socket buffer
  78  *
  79  * A buffer starts with the fields that are accessed by I/O multiplexing
  80  * APIs like select(2), kevent(2) or AIO and thus are shared between different
  81  * buffer implementations.  They are protected by the SOCK_RECVBUF_LOCK()
  82  * or SOCK_SENDBUF_LOCK() of the owning socket.
  83  *
  84  * XXX: sb_acc, sb_ccc and sb_mbcnt shall become implementation specific
  85  * methods.
  86  *
  87  * Protocol specific implementations follow in a union.
  88  */
  89 struct sockbuf {
  90         struct  selinfo *sb_sel;        /* process selecting read/write */
  91         short   sb_state;               /* socket state on sockbuf */
  92         short   sb_flags;               /* flags, see above */
  93         u_int   sb_acc;                 /* available chars in buffer */
  94         u_int   sb_ccc;                 /* claimed chars in buffer */
  95         u_int   sb_mbcnt;               /* chars of mbufs used */
  96         u_int   sb_ctl;                 /* non-data chars in buffer */
  97         u_int   sb_hiwat;               /* max actual char count */
  98         u_int   sb_lowat;               /* low water mark */
  99         u_int   sb_mbmax;               /* max chars of mbufs to use */
 100         sbintime_t sb_timeo;            /* timeout for read/write */
 101         int     (*sb_upcall)(struct socket *, void *, int);
 102         void    *sb_upcallarg;
 103         TAILQ_HEAD(, kaiocb) sb_aiojobq;        /* pending AIO ops */
 104         struct  task sb_aiotask;                /* AIO task */
 105         union {
 106                 /*
 107                  * Classic BSD one-size-fits-all socket buffer, capable of
 108                  * doing streams and datagrams. The stream part is able
 109                  * to perform special features:
 110                  * - not ready data (sendfile)
 111                  * - TLS
 112                  */
 113                 struct {
 114                         /* compat: sockbuf lock pointer */
 115                         struct  mtx *sb_mtx;
 116                         /* first and last mbufs in the chain */
 117                         struct  mbuf *sb_mb;
 118                         struct  mbuf *sb_mbtail;
 119                         /* first mbuf of last record in socket buffer */
 120                         struct  mbuf *sb_lastrecord;
 121                         /* pointer to data to send next (TCP */
 122                         struct  mbuf *sb_sndptr;
 123                         /* pointer to first not ready buffer */
 124                         struct  mbuf *sb_fnrdy;
 125                         /* byte offset of ptr into chain, used with sb_sndptr */
 126                         u_int   sb_sndptroff;
 127                         /* TLS */
 128                         u_int   sb_tlscc;       /* TLS chain characters */
 129                         u_int   sb_tlsdcc;      /* characters being decrypted */
 130                         struct  mbuf *sb_mtls;  /*  TLS mbuf chain */
 131                         struct  mbuf *sb_mtlstail; /* last mbuf in TLS chain */
 132                         uint64_t sb_tls_seqno;  /* TLS seqno */
 133                         struct  ktls_session *sb_tls_info; /* TLS state */
 134                 };
 135                 /*
 136                  * PF_UNIX/SOCK_DGRAM
 137                  *
 138                  * Local protocol, thus we should buffer on the receive side
 139                  * only.  However, in one to many configuration we don't want
 140                  * a single receive buffer to be shared.  So we would link
 141                  * send buffers onto receive buffer.  All the fields are locked
 142                  * by the receive buffer lock.
 143                  */
 144                 struct {
 145                         /*
 146                          * For receive buffer: own queue of this buffer for
 147                          * unconnected sends.  For send buffer: queue lended
 148                          * to the peer receive buffer, to isolate ourselves
 149                          * from other senders.
 150                          */
 151                         STAILQ_HEAD(, mbuf)     uxdg_mb;
 152                         /* For receive buffer: datagram seen via MSG_PEEK. */
 153                         struct mbuf             *uxdg_peeked;
 154                         /*
 155                          * For receive buffer: queue of send buffers of
 156                          * connected peers.  For send buffer: linkage on
 157                          * connected peer receive buffer queue.
 158                          */
 159                         union {
 160                                 TAILQ_HEAD(, sockbuf)   uxdg_conns;
 161                                 TAILQ_ENTRY(sockbuf)    uxdg_clist;
 162                         };
 163                         /* Counters for this buffer uxdg_mb chain + peeked. */
 164                         u_int uxdg_cc;
 165                         u_int uxdg_ctl;
 166                         u_int uxdg_mbcnt;
 167                 };
 168         };
 169 };
 170
 171 #endif  /* defined(_KERNEL) || defined(_WANT_SOCKET) */
 172 #ifdef _KERNEL
 173
 174 /* 'which' values for KPIs that operate on one buffer of a socket. */
 175 typedef enum { SO_RCV, SO_SND } sb_which;
 176
 177 /*
 178  * Per-socket buffer mutex used to protect most fields in the socket buffer.
 179  * These make use of the mutex pointer embedded in struct sockbuf, which
 180  * currently just references mutexes in the containing socket.  The
 181  * SOCK_SENDBUF_LOCK() etc. macros can be used instead of or in combination with
 182  * these locking macros.
 183  */
 184 #define SOCKBUF_MTX(_sb)                ((_sb)->sb_mtx)
 185 #define SOCKBUF_LOCK(_sb)               mtx_lock(SOCKBUF_MTX(_sb))
 186 #define SOCKBUF_OWNED(_sb)              mtx_owned(SOCKBUF_MTX(_sb))
 187 #define SOCKBUF_UNLOCK(_sb)             mtx_unlock(SOCKBUF_MTX(_sb))
 188 #define SOCKBUF_LOCK_ASSERT(_sb)        mtx_assert(SOCKBUF_MTX(_sb), MA_OWNED)
 189 #define SOCKBUF_UNLOCK_ASSERT(_sb)      mtx_assert(SOCKBUF_MTX(_sb), MA_NOTOWNED)
 190
 191 /*
 192  * Socket buffer private mbuf(9) flags.
 193  */
 194 #define M_NOTREADY      M_PROTO1        /* m_data not populated yet */
 195 #define M_BLOCKED       M_PROTO2        /* M_NOTREADY in front of m */
 196 #define M_NOTAVAIL      (M_NOTREADY | M_BLOCKED)
 197
 198 void    sbappend(struct sockbuf *sb, struct mbuf *m, int flags);
 199 void    sbappend_locked(struct sockbuf *sb, struct mbuf *m, int flags);
 200 void    sbappendstream(struct sockbuf *sb, struct mbuf *m, int flags);
 201 void    sbappendstream_locked(struct sockbuf *sb, struct mbuf *m, int flags);
 202 int     sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa,
 203             struct mbuf *m0, struct mbuf *control);
 204 int     sbappendaddr_locked(struct sockbuf *sb, const struct sockaddr *asa,
 205             struct mbuf *m0, struct mbuf *control);
 206 int     sbappendaddr_nospacecheck_locked(struct sockbuf *sb,
 207             const struct sockaddr *asa, struct mbuf *m0, struct mbuf *control);
 208 void    sbappendcontrol(struct sockbuf *sb, struct mbuf *m0,
 209             struct mbuf *control, int flags);
 210 void    sbappendcontrol_locked(struct sockbuf *sb, struct mbuf *m0,
 211             struct mbuf *control, int flags);
 212 void    sbappendrecord(struct sockbuf *sb, struct mbuf *m0);
 213 void    sbappendrecord_locked(struct sockbuf *sb, struct mbuf *m0);
 214 void    sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n);
 215 struct mbuf *
 216         sbcreatecontrol(const void *p, u_int size, int type, int level,
 217             int wait);
 218 void    sbdestroy(struct socket *, sb_which);
 219 void    sbdrop(struct sockbuf *sb, int len);
 220 void    sbdrop_locked(struct sockbuf *sb, int len);
 221 struct mbuf *
 222         sbcut_locked(struct sockbuf *sb, int len);
 223 void    sbdroprecord(struct sockbuf *sb);
 224 void    sbdroprecord_locked(struct sockbuf *sb);
 225 void    sbflush(struct sockbuf *sb);
 226 void    sbflush_locked(struct sockbuf *sb);
 227 void    sbrelease(struct socket *, sb_which);
 228 void    sbrelease_locked(struct socket *, sb_which);
 229 int     sbsetopt(struct socket *so, struct sockopt *);
 230 bool    sbreserve_locked(struct socket *so, sb_which which, u_long cc,
 231             struct thread *td);
 232 bool    sbreserve_locked_limit(struct socket *so, sb_which which, u_long cc,
 233             u_long buf_max, struct thread *td);
 234 void    sbsndptr_adv(struct sockbuf *sb, struct mbuf *mb, u_int len);
 235 struct mbuf *
 236         sbsndptr_noadv(struct sockbuf *sb, u_int off, u_int *moff);
 237 struct mbuf *
 238         sbsndmbuf(struct sockbuf *sb, u_int off, u_int *moff);
 239 int     sbwait(struct socket *, sb_which);
 240 void    sballoc(struct sockbuf *, struct mbuf *);
 241 void    sbfree(struct sockbuf *, struct mbuf *);
 242 void    sballoc_ktls_rx(struct sockbuf *sb, struct mbuf *m);
 243 void    sbfree_ktls_rx(struct sockbuf *sb, struct mbuf *m);
 244 int     sbready(struct sockbuf *, struct mbuf *, int);
 245
 246 /*
 247  * Return how much data is available to be taken out of socket
 248  * buffer right now.
 249  */
 250 static inline u_int
 251 sbavail(struct sockbuf *sb)
 252 {
 253
 254 #if 0
 255         SOCKBUF_LOCK_ASSERT(sb);
 256 #endif
 257         return (sb->sb_acc);
 258 }
 259
 260 /*
 261  * Return how much data sits there in the socket buffer
 262  * It might be that some data is not yet ready to be read.
 263  */
 264 static inline u_int
 265 sbused(struct sockbuf *sb)
 266 {
 267
 268 #if 0
 269         SOCKBUF_LOCK_ASSERT(sb);
 270 #endif
 271         return (sb->sb_ccc);
 272 }
 273
 274 /*
 275  * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
 276  * This is problematical if the fields are unsigned, as the space might
 277  * still be negative (ccc > hiwat or mbcnt > mbmax).
 278  */
 279 static inline long
 280 sbspace(struct sockbuf *sb)
 281 {
 282         int bleft, mleft;               /* size should match sockbuf fields */
 283
 284 #if 0
 285         SOCKBUF_LOCK_ASSERT(sb);
 286 #endif
 287
 288         if (sb->sb_flags & SB_STOP)
 289                 return(0);
 290
 291         bleft = sb->sb_hiwat - sb->sb_ccc;
 292         mleft = sb->sb_mbmax - sb->sb_mbcnt;
 293
 294         return ((bleft < mleft) ? bleft : mleft);
 295 }
 296
 297 #define SB_EMPTY_FIXUP(sb) do {                                         \
 298         if ((sb)->sb_mb == NULL) {                                      \
 299                 (sb)->sb_mbtail = NULL;                                 \
 300                 (sb)->sb_lastrecord = NULL;                             \
 301         }                                                               \
 302 } while (/*CONSTCOND*/0)
 303
 304 #ifdef SOCKBUF_DEBUG
 305 void    sblastrecordchk(struct sockbuf *, const char *, int);
 306 void    sblastmbufchk(struct sockbuf *, const char *, int);
 307 void    sbcheck(struct sockbuf *, const char *, int);
 308 #define SBLASTRECORDCHK(sb)     sblastrecordchk((sb), __FILE__, __LINE__)
 309 #define SBLASTMBUFCHK(sb)       sblastmbufchk((sb), __FILE__, __LINE__)
 310 #define SBCHECK(sb)             sbcheck((sb), __FILE__, __LINE__)
 311 #else
 312 #define SBLASTRECORDCHK(sb)     do {} while (0)
 313 #define SBLASTMBUFCHK(sb)       do {} while (0)
 314 #define SBCHECK(sb)             do {} while (0)
 315 #endif /* SOCKBUF_DEBUG */
 316
 317 #endif /* _KERNEL */
 318
 319 #endif /* _SYS_SOCKBUF_H_ */