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_TLS_IFNET 0x4000 /* has used / is using ifnet KTLS */
54
55 #define SBS_CANTSENDMORE 0x0010 /* can't send more data to peer */
56 #define SBS_CANTRCVMORE 0x0020 /* can't receive more data from peer */
57 #define SBS_RCVATMARK 0x0040 /* at mark on input */
58
59 #if defined(_KERNEL) || defined(_WANT_SOCKET)
60 #include <sys/_lock.h>
61 #include <sys/_mutex.h>
62 #include <sys/_sx.h>
63 #include <sys/_task.h>
64
65 #define SB_MAX (2*1024*1024) /* default for max chars in sockbuf */
66
67 struct ktls_session;
68 struct mbuf;
69 struct sockaddr;
70 struct socket;
71 struct thread;
72 struct selinfo;
73
74 /*
75 * Variables for socket buffering.
76 *
77 * Locking key to struct sockbuf:
78 * (a) locked by SOCKBUF_LOCK().
79 */
80 struct sockbuf {
81 struct mtx sb_mtx; /* sockbuf lock */
82 struct sx sb_sx; /* prevent I/O interlacing */
83 struct selinfo *sb_sel; /* process selecting read/write */
84 short sb_state; /* (a) socket state on sockbuf */
85 #define sb_startzero sb_mb
86 struct mbuf *sb_mb; /* (a) the mbuf chain */
87 struct mbuf *sb_mbtail; /* (a) the last mbuf in the chain */
88 struct mbuf *sb_lastrecord; /* (a) first mbuf of last
89 * record in socket buffer */
90 struct mbuf *sb_sndptr; /* (a) pointer into mbuf chain */
91 struct mbuf *sb_fnrdy; /* (a) pointer to first not ready buffer */
92 u_int sb_sndptroff; /* (a) byte offset of ptr into chain */
93 u_int sb_acc; /* (a) available chars in buffer */
94 u_int sb_ccc; /* (a) claimed chars in buffer */
95 u_int sb_hiwat; /* (a) max actual char count */
96 u_int sb_mbcnt; /* (a) chars of mbufs used */
97 u_int sb_mcnt; /* (a) number of mbufs in buffer */
98 u_int sb_ccnt; /* (a) number of clusters in buffer */
99 u_int sb_mbmax; /* (a) max chars of mbufs to use */
100 u_int sb_ctl; /* (a) non-data chars in buffer */
101 u_int sb_tlscc; /* (a) TLS chain characters */
102 u_int sb_tlsdcc; /* (a) TLS characters being decrypted */
103 int sb_lowat; /* (a) low water mark */
104 sbintime_t sb_timeo; /* (a) timeout for read/write */
105 uint64_t sb_tls_seqno; /* (a) TLS seqno */
106 struct ktls_session *sb_tls_info; /* (a + b) TLS state */
107 struct mbuf *sb_mtls; /* (a) TLS mbuf chain */
108 struct mbuf *sb_mtlstail; /* (a) last mbuf in TLS chain */
109 short sb_flags; /* (a) flags, see above */
110 int (*sb_upcall)(struct socket *, void *, int); /* (a) */
111 void *sb_upcallarg; /* (a) */
112 TAILQ_HEAD(, kaiocb) sb_aiojobq; /* (a) pending AIO ops */
113 struct task sb_aiotask; /* AIO task */
114 };
115
116 #endif /* defined(_KERNEL) || defined(_WANT_SOCKET) */
117 #ifdef _KERNEL
118
119 /*
120 * Per-socket buffer mutex used to protect most fields in the socket
121 * buffer.
122 */
123 #define SOCKBUF_MTX(_sb) (&(_sb)->sb_mtx)
124 #define SOCKBUF_LOCK_INIT(_sb, _name) \
125 mtx_init(SOCKBUF_MTX(_sb), _name, NULL, MTX_DEF)
126 #define SOCKBUF_LOCK_DESTROY(_sb) mtx_destroy(SOCKBUF_MTX(_sb))
127 #define SOCKBUF_LOCK(_sb) mtx_lock(SOCKBUF_MTX(_sb))
128 #define SOCKBUF_OWNED(_sb) mtx_owned(SOCKBUF_MTX(_sb))
129 #define SOCKBUF_UNLOCK(_sb) mtx_unlock(SOCKBUF_MTX(_sb))
130 #define SOCKBUF_LOCK_ASSERT(_sb) mtx_assert(SOCKBUF_MTX(_sb), MA_OWNED)
131 #define SOCKBUF_UNLOCK_ASSERT(_sb) mtx_assert(SOCKBUF_MTX(_sb), MA_NOTOWNED)
132
133 /*
134 * Socket buffer private mbuf(9) flags.
135 */
136 #define M_NOTREADY M_PROTO1 /* m_data not populated yet */
137 #define M_BLOCKED M_PROTO2 /* M_NOTREADY in front of m */
138 #define M_NOTAVAIL (M_NOTREADY | M_BLOCKED)
139
140 void sbappend(struct sockbuf *sb, struct mbuf *m, int flags);
141 void sbappend_locked(struct sockbuf *sb, struct mbuf *m, int flags);
142 void sbappendstream(struct sockbuf *sb, struct mbuf *m, int flags);
143 void sbappendstream_locked(struct sockbuf *sb, struct mbuf *m, int flags);
144 int sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa,
145 struct mbuf *m0, struct mbuf *control);
146 int sbappendaddr_locked(struct sockbuf *sb, const struct sockaddr *asa,
147 struct mbuf *m0, struct mbuf *control);
148 int sbappendaddr_nospacecheck_locked(struct sockbuf *sb,
149 const struct sockaddr *asa, struct mbuf *m0, struct mbuf *control);
150 void sbappendcontrol(struct sockbuf *sb, struct mbuf *m0,
151 struct mbuf *control, int flags);
152 void sbappendcontrol_locked(struct sockbuf *sb, struct mbuf *m0,
153 struct mbuf *control, int flags);
154 void sbappendrecord(struct sockbuf *sb, struct mbuf *m0);
155 void sbappendrecord_locked(struct sockbuf *sb, struct mbuf *m0);
156 void sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n);
157 struct mbuf *
158 sbcreatecontrol(caddr_t p, int size, int type, int level);
159 struct mbuf *
160 sbcreatecontrol_how(void *p, int size, int type, int level,
161 int wait);
162 void sbdestroy(struct sockbuf *sb, struct socket *so);
163 void sbdrop(struct sockbuf *sb, int len);
164 void sbdrop_locked(struct sockbuf *sb, int len);
165 struct mbuf *
166 sbcut_locked(struct sockbuf *sb, int len);
167 void sbdroprecord(struct sockbuf *sb);
168 void sbdroprecord_locked(struct sockbuf *sb);
169 void sbflush(struct sockbuf *sb);
170 void sbflush_locked(struct sockbuf *sb);
171 void sbrelease(struct sockbuf *sb, struct socket *so);
172 void sbrelease_internal(struct sockbuf *sb, struct socket *so);
173 void sbrelease_locked(struct sockbuf *sb, struct socket *so);
174 int sbsetopt(struct socket *so, int cmd, u_long cc);
175 int sbreserve_locked(struct sockbuf *sb, u_long cc, struct socket *so,
176 struct thread *td);
177 int sbreserve_locked_limit(struct sockbuf *sb, u_long cc, struct socket *so,
178 u_long buf_max, struct thread *td);
179 void sbsndptr_adv(struct sockbuf *sb, struct mbuf *mb, u_int len);
180 struct mbuf *
181 sbsndptr_noadv(struct sockbuf *sb, u_int off, u_int *moff);
182 struct mbuf *
183 sbsndmbuf(struct sockbuf *sb, u_int off, u_int *moff);
184 int sbwait(struct sockbuf *sb);
185 void sballoc(struct sockbuf *, struct mbuf *);
186 void sbfree(struct sockbuf *, struct mbuf *);
187 void sballoc_ktls_rx(struct sockbuf *sb, struct mbuf *m);
188 void sbfree_ktls_rx(struct sockbuf *sb, struct mbuf *m);
189 int sbready(struct sockbuf *, struct mbuf *, int);
190
191 /*
192 * Return how much data is available to be taken out of socket
193 * buffer right now.
194 */
195 static inline u_int
sbavail(struct sockbuf * sb)196 sbavail(struct sockbuf *sb)
197 {
198
199 #if 0
200 SOCKBUF_LOCK_ASSERT(sb);
201 #endif
202 return (sb->sb_acc);
203 }
204
205 /*
206 * Return how much data sits there in the socket buffer
207 * It might be that some data is not yet ready to be read.
208 */
209 static inline u_int
sbused(struct sockbuf * sb)210 sbused(struct sockbuf *sb)
211 {
212
213 #if 0
214 SOCKBUF_LOCK_ASSERT(sb);
215 #endif
216 return (sb->sb_ccc);
217 }
218
219 /*
220 * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
221 * This is problematical if the fields are unsigned, as the space might
222 * still be negative (ccc > hiwat or mbcnt > mbmax).
223 */
224 static inline long
sbspace(struct sockbuf * sb)225 sbspace(struct sockbuf *sb)
226 {
227 int bleft, mleft; /* size should match sockbuf fields */
228
229 #if 0
230 SOCKBUF_LOCK_ASSERT(sb);
231 #endif
232
233 if (sb->sb_flags & SB_STOP)
234 return(0);
235
236 bleft = sb->sb_hiwat - sb->sb_ccc;
237 mleft = sb->sb_mbmax - sb->sb_mbcnt;
238
239 return ((bleft < mleft) ? bleft : mleft);
240 }
241
242 #define SB_EMPTY_FIXUP(sb) do { \
243 if ((sb)->sb_mb == NULL) { \
244 (sb)->sb_mbtail = NULL; \
245 (sb)->sb_lastrecord = NULL; \
246 } \
247 } while (/*CONSTCOND*/0)
248
249 #ifdef SOCKBUF_DEBUG
250 void sblastrecordchk(struct sockbuf *, const char *, int);
251 void sblastmbufchk(struct sockbuf *, const char *, int);
252 void sbcheck(struct sockbuf *, const char *, int);
253 #define SBLASTRECORDCHK(sb) sblastrecordchk((sb), __FILE__, __LINE__)
254 #define SBLASTMBUFCHK(sb) sblastmbufchk((sb), __FILE__, __LINE__)
255 #define SBCHECK(sb) sbcheck((sb), __FILE__, __LINE__)
256 #else
257 #define SBLASTRECORDCHK(sb) do {} while (0)
258 #define SBLASTMBUFCHK(sb) do {} while (0)
259 #define SBCHECK(sb) do {} while (0)
260 #endif /* SOCKBUF_DEBUG */
261
262 #endif /* _KERNEL */
263
264 #endif /* _SYS_SOCKBUF_H_ */
265