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