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_UNUSED 0x4000 /* previously used for SB_TLS_IFNET */ 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_ */ 322