FreeBSD/Linux Kernel Cross Reference
sys/sys/sockbuf.h
1 /*-
2 * Copyright (c) 1982, 1986, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)socketvar.h 8.3 (Berkeley) 2/19/95
30 *
31 * $FreeBSD$
32 */
33 #ifndef _SYS_SOCKBUF_H_
34 #define _SYS_SOCKBUF_H_
35 #include <sys/selinfo.h> /* for struct selinfo */
36 #include <sys/_lock.h>
37 #include <sys/_mutex.h>
38 #include <sys/_sx.h>
39
40 #define SB_MAX (256*1024) /* default for max chars in sockbuf */
41
42 /*
43 * Constants for sb_flags field of struct sockbuf.
44 */
45 #define SB_WAIT 0x04 /* someone is waiting for data/space */
46 #define SB_SEL 0x08 /* someone is selecting */
47 #define SB_ASYNC 0x10 /* ASYNC I/O, need signals */
48 #define SB_UPCALL 0x20 /* someone wants an upcall */
49 #define SB_NOINTR 0x40 /* operations not interruptible */
50 #define SB_AIO 0x80 /* AIO operations queued */
51 #define SB_KNOTE 0x100 /* kernel note attached */
52 #define SB_NOCOALESCE 0x200 /* don't coalesce new data into existing mbufs */
53 #define SB_IN_TOE 0x400 /* socket buffer is in the middle of an operation */
54 #define SB_AUTOSIZE 0x800 /* automatically size socket buffer */
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 struct socket;
61 struct sockaddr;
62 struct mbuf;
63
64 struct xsockbuf {
65 u_int sb_cc;
66 u_int sb_hiwat;
67 u_int sb_mbcnt;
68 u_int sb_mcnt;
69 u_int sb_ccnt;
70 u_int sb_mbmax;
71 int sb_lowat;
72 int sb_timeo;
73 short sb_flags;
74 };
75
76 /*
77 * Variables for socket buffering.
78 */
79 struct sockbuf {
80 struct selinfo sb_sel; /* process selecting read/write */
81 struct mtx sb_mtx; /* sockbuf lock */
82 struct sx sb_sx; /* prevent I/O interlacing */
83 short sb_state; /* (c/d) socket state on sockbuf */
84 #define sb_startzero sb_mb
85 struct mbuf *sb_mb; /* (c/d) the mbuf chain */
86 struct mbuf *sb_mbtail; /* (c/d) the last mbuf in the chain */
87 struct mbuf *sb_lastrecord; /* (c/d) first mbuf of last
88 * record in socket buffer */
89 struct mbuf *sb_sndptr; /* (c/d) pointer into mbuf chain */
90 u_int sb_sndptroff; /* (c/d) byte offset of ptr into chain */
91 u_int sb_cc; /* (c/d) actual chars in buffer */
92 u_int sb_hiwat; /* (c/d) max actual char count */
93 u_int sb_mbcnt; /* (c/d) chars of mbufs used */
94 u_int sb_mcnt; /* (c/d) number of mbufs in buffer */
95 u_int sb_ccnt; /* (c/d) number of clusters in buffer */
96 u_int sb_mbmax; /* (c/d) max chars of mbufs to use */
97 u_int sb_ctl; /* (c/d) non-data chars in buffer */
98 int sb_lowat; /* (c/d) low water mark */
99 int sb_timeo; /* (c/d) timeout for read/write */
100 short sb_flags; /* (c/d) flags, see below */
101 };
102
103 #ifdef _KERNEL
104
105 /*
106 * Per-socket buffer mutex used to protect most fields in the socket
107 * buffer.
108 */
109 #define SOCKBUF_MTX(_sb) (&(_sb)->sb_mtx)
110 #define SOCKBUF_LOCK_INIT(_sb, _name) \
111 mtx_init(SOCKBUF_MTX(_sb), _name, NULL, MTX_DEF)
112 #define SOCKBUF_LOCK_DESTROY(_sb) mtx_destroy(SOCKBUF_MTX(_sb))
113 #define SOCKBUF_LOCK(_sb) mtx_lock(SOCKBUF_MTX(_sb))
114 #define SOCKBUF_OWNED(_sb) mtx_owned(SOCKBUF_MTX(_sb))
115 #define SOCKBUF_UNLOCK(_sb) mtx_unlock(SOCKBUF_MTX(_sb))
116 #define SOCKBUF_LOCK_ASSERT(_sb) mtx_assert(SOCKBUF_MTX(_sb), MA_OWNED)
117 #define SOCKBUF_UNLOCK_ASSERT(_sb) mtx_assert(SOCKBUF_MTX(_sb), MA_NOTOWNED)
118
119 void sbappend(struct sockbuf *sb, struct mbuf *m);
120 void sbappend_locked(struct sockbuf *sb, struct mbuf *m);
121 void sbappendstream(struct sockbuf *sb, struct mbuf *m);
122 void sbappendstream_locked(struct sockbuf *sb, struct mbuf *m);
123 int sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa,
124 struct mbuf *m0, struct mbuf *control);
125 int sbappendaddr_locked(struct sockbuf *sb, const struct sockaddr *asa,
126 struct mbuf *m0, struct mbuf *control);
127 int sbappendcontrol(struct sockbuf *sb, struct mbuf *m0,
128 struct mbuf *control);
129 int sbappendcontrol_locked(struct sockbuf *sb, struct mbuf *m0,
130 struct mbuf *control);
131 void sbappendrecord(struct sockbuf *sb, struct mbuf *m0);
132 void sbappendrecord_locked(struct sockbuf *sb, struct mbuf *m0);
133 void sbcheck(struct sockbuf *sb);
134 void sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n);
135 struct mbuf *
136 sbcreatecontrol(caddr_t p, int size, int type, int level);
137 void sbdestroy(struct sockbuf *sb, struct socket *so);
138 void sbdrop(struct sockbuf *sb, int len);
139 void sbdrop_locked(struct sockbuf *sb, int len);
140 void sbdroprecord(struct sockbuf *sb);
141 void sbdroprecord_locked(struct sockbuf *sb);
142 void sbflush(struct sockbuf *sb);
143 void sbflush_locked(struct sockbuf *sb);
144 void sbrelease(struct sockbuf *sb, struct socket *so);
145 void sbrelease_internal(struct sockbuf *sb, struct socket *so);
146 void sbrelease_locked(struct sockbuf *sb, struct socket *so);
147 int sbreserve(struct sockbuf *sb, u_long cc, struct socket *so,
148 struct thread *td);
149 int sbreserve_locked(struct sockbuf *sb, u_long cc, struct socket *so,
150 struct thread *td);
151 struct mbuf *
152 sbsndptr(struct sockbuf *sb, u_int off, u_int len, u_int *moff);
153 void sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb);
154 int sbwait(struct sockbuf *sb);
155 int sblock(struct sockbuf *sb, int flags);
156 void sbunlock(struct sockbuf *sb);
157
158 /*
159 * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
160 * This is problematical if the fields are unsigned, as the space might
161 * still be negative (cc > hiwat or mbcnt > mbmax). Should detect
162 * overflow and return 0. Should use "lmin" but it doesn't exist now.
163 */
164 #define sbspace(sb) \
165 ((long) imin((int)((sb)->sb_hiwat - (sb)->sb_cc), \
166 (int)((sb)->sb_mbmax - (sb)->sb_mbcnt)))
167
168 /* adjust counters in sb reflecting allocation of m */
169 #define sballoc(sb, m) { \
170 (sb)->sb_cc += (m)->m_len; \
171 if ((m)->m_type != MT_DATA && (m)->m_type != MT_OOBDATA) \
172 (sb)->sb_ctl += (m)->m_len; \
173 (sb)->sb_mbcnt += MSIZE; \
174 (sb)->sb_mcnt += 1; \
175 if ((m)->m_flags & M_EXT) { \
176 (sb)->sb_mbcnt += (m)->m_ext.ext_size; \
177 (sb)->sb_ccnt += 1; \
178 } \
179 }
180
181 /* adjust counters in sb reflecting freeing of m */
182 #define sbfree(sb, m) { \
183 (sb)->sb_cc -= (m)->m_len; \
184 if ((m)->m_type != MT_DATA && (m)->m_type != MT_OOBDATA) \
185 (sb)->sb_ctl -= (m)->m_len; \
186 (sb)->sb_mbcnt -= MSIZE; \
187 (sb)->sb_mcnt -= 1; \
188 if ((m)->m_flags & M_EXT) { \
189 (sb)->sb_mbcnt -= (m)->m_ext.ext_size; \
190 (sb)->sb_ccnt -= 1; \
191 } \
192 if ((sb)->sb_sndptr == (m)) { \
193 (sb)->sb_sndptr = NULL; \
194 (sb)->sb_sndptroff = 0; \
195 } \
196 if ((sb)->sb_sndptroff != 0) \
197 (sb)->sb_sndptroff -= (m)->m_len; \
198 }
199
200 #define SB_EMPTY_FIXUP(sb) do { \
201 if ((sb)->sb_mb == NULL) { \
202 (sb)->sb_mbtail = NULL; \
203 (sb)->sb_lastrecord = NULL; \
204 } \
205 } while (/*CONSTCOND*/0)
206
207 #ifdef SOCKBUF_DEBUG
208 void sblastrecordchk(struct sockbuf *, const char *, int);
209 #define SBLASTRECORDCHK(sb) sblastrecordchk((sb), __FILE__, __LINE__)
210
211 void sblastmbufchk(struct sockbuf *, const char *, int);
212 #define SBLASTMBUFCHK(sb) sblastmbufchk((sb), __FILE__, __LINE__)
213 #else
214 #define SBLASTRECORDCHK(sb) /* nothing */
215 #define SBLASTMBUFCHK(sb) /* nothing */
216 #endif /* SOCKBUF_DEBUG */
217
218 #endif /* _KERNEL */
219
220 #endif /* _SYS_SOCKBUF_H_ */
Cache object: 488f514661be200e5072ff7f3ed86c9e
|