Commit | Line | Data |
---|---|---|
b688fc87 WJ |
1 | /* |
2 | * Copyright (c) 1982, 1986, 1988 Regents of the University of California. | |
3 | * 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 | * 3. All advertising materials mentioning features or use of this software | |
14 | * must display the following acknowledgement: | |
15 | * This product includes software developed by the University of | |
16 | * California, Berkeley and its contributors. | |
17 | * 4. Neither the name of the University nor the names of its contributors | |
18 | * may be used to endorse or promote products derived from this software | |
19 | * without specific prior written permission. | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
31 | * SUCH DAMAGE. | |
32 | * | |
33 | * @(#)mbuf.h 7.14 (Berkeley) 12/5/90 | |
34 | */ | |
35 | ||
36 | #ifndef M_WAITOK | |
37 | #include "malloc.h" | |
38 | #endif | |
39 | ||
40 | /* | |
41 | * Mbufs are of a single size, MSIZE (machine/machparam.h), which | |
42 | * includes overhead. An mbuf may add a single "mbuf cluster" of size | |
43 | * MCLBYTES (also in machine/machparam.h), which has no additional overhead | |
44 | * and is used instead of the internal data area; this is done when | |
45 | * at least MINCLSIZE of data must be stored. | |
46 | */ | |
47 | ||
48 | #define MLEN (MSIZE - sizeof(struct m_hdr)) /* normal data len */ | |
49 | #define MHLEN (MLEN - sizeof(struct pkthdr)) /* data len w/pkthdr */ | |
50 | ||
51 | #define MINCLSIZE (MHLEN + MLEN) /* smallest amount to put in cluster */ | |
52 | #define M_MAXCOMPRESS (MHLEN / 2) /* max amount to copy for compression */ | |
53 | ||
54 | /* | |
55 | * Macros for type conversion | |
56 | * mtod(m,t) - convert mbuf pointer to data pointer of correct type | |
57 | * dtom(x) - convert data pointer within mbuf to mbuf pointer (XXX) | |
58 | * mtocl(x) - convert pointer within cluster to cluster index # | |
59 | * cltom(x) - convert cluster # to ptr to beginning of cluster | |
60 | */ | |
61 | #define mtod(m,t) ((t)((m)->m_data)) | |
62 | #define dtom(x) ((struct mbuf *)((int)(x) & ~(MSIZE-1))) | |
63 | #define mtocl(x) (((u_int)(x) - (u_int)mbutl) >> MCLSHIFT) | |
64 | #define cltom(x) ((caddr_t)((u_int)mbutl + ((u_int)(x) >> MCLSHIFT))) | |
65 | ||
66 | /* header at beginning of each mbuf: */ | |
67 | struct m_hdr { | |
68 | struct mbuf *mh_next; /* next buffer in chain */ | |
69 | struct mbuf *mh_nextpkt; /* next chain in queue/record */ | |
70 | int mh_len; /* amount of data in this mbuf */ | |
71 | caddr_t mh_data; /* location of data */ | |
72 | short mh_type; /* type of data in this mbuf */ | |
73 | short mh_flags; /* flags; see below */ | |
74 | }; | |
75 | ||
76 | /* record/packet header in first mbuf of chain; valid if M_PKTHDR set */ | |
77 | struct pkthdr { | |
78 | int len; /* total packet length */ | |
79 | struct ifnet *rcvif; /* rcv interface */ | |
80 | }; | |
81 | ||
82 | /* description of external storage mapped into mbuf, valid if M_EXT set */ | |
83 | struct m_ext { | |
84 | caddr_t ext_buf; /* start of buffer */ | |
85 | void (*ext_free)(); /* free routine if not the usual */ | |
86 | u_int ext_size; /* size of buffer, for ext_free */ | |
87 | }; | |
88 | ||
89 | struct mbuf { | |
90 | struct m_hdr m_hdr; | |
91 | union { | |
92 | struct { | |
93 | struct pkthdr MH_pkthdr; /* M_PKTHDR set */ | |
94 | union { | |
95 | struct m_ext MH_ext; /* M_EXT set */ | |
96 | char MH_databuf[MHLEN]; | |
97 | } MH_dat; | |
98 | } MH; | |
99 | char M_databuf[MLEN]; /* !M_PKTHDR, !M_EXT */ | |
100 | } M_dat; | |
101 | }; | |
102 | #define m_next m_hdr.mh_next | |
103 | #define m_len m_hdr.mh_len | |
104 | #define m_data m_hdr.mh_data | |
105 | #define m_type m_hdr.mh_type | |
106 | #define m_flags m_hdr.mh_flags | |
107 | #define m_nextpkt m_hdr.mh_nextpkt | |
108 | #define m_act m_nextpkt | |
109 | #define m_pkthdr M_dat.MH.MH_pkthdr | |
110 | #define m_ext M_dat.MH.MH_dat.MH_ext | |
111 | #define m_pktdat M_dat.MH.MH_dat.MH_databuf | |
112 | #define m_dat M_dat.M_databuf | |
113 | ||
114 | /* mbuf flags */ | |
115 | #define M_EXT 0x0001 /* has associated external storage */ | |
116 | #define M_PKTHDR 0x0002 /* start of record */ | |
117 | #define M_EOR 0x0004 /* end of record */ | |
118 | ||
119 | /* mbuf pkthdr flags, also in m_flags */ | |
120 | #define M_BCAST 0x0100 /* send/received as link-level broadcast */ | |
121 | #define M_MCAST 0x0200 /* send/received as link-level multicast */ | |
122 | ||
123 | /* flags copied when copying m_pkthdr */ | |
124 | #define M_COPYFLAGS (M_PKTHDR|M_EOR|M_BCAST|M_MCAST) | |
125 | ||
126 | /* mbuf types */ | |
127 | #define MT_FREE 0 /* should be on free list */ | |
128 | #define MT_DATA 1 /* dynamic (data) allocation */ | |
129 | #define MT_HEADER 2 /* packet header */ | |
130 | #define MT_SOCKET 3 /* socket structure */ | |
131 | #define MT_PCB 4 /* protocol control block */ | |
132 | #define MT_RTABLE 5 /* routing tables */ | |
133 | #define MT_HTABLE 6 /* IMP host tables */ | |
134 | #define MT_ATABLE 7 /* address resolution tables */ | |
135 | #define MT_SONAME 8 /* socket name */ | |
136 | #define MT_SOOPTS 10 /* socket options */ | |
137 | #define MT_FTABLE 11 /* fragment reassembly header */ | |
138 | #define MT_RIGHTS 12 /* access rights */ | |
139 | #define MT_IFADDR 13 /* interface address */ | |
140 | #define MT_CONTROL 14 /* extra-data protocol message */ | |
141 | #define MT_OOBDATA 15 /* expedited data */ | |
142 | ||
143 | /* flags to m_get/MGET */ | |
144 | #define M_DONTWAIT M_NOWAIT | |
145 | #define M_WAIT M_WAITOK | |
146 | ||
147 | /* | |
148 | * mbuf allocation/deallocation macros: | |
149 | * | |
150 | * MGET(struct mbuf *m, int how, int type) | |
151 | * allocates an mbuf and initializes it to contain internal data. | |
152 | * | |
153 | * MGETHDR(struct mbuf *m, int how, int type) | |
154 | * allocates an mbuf and initializes it to contain a packet header | |
155 | * and internal data. | |
156 | */ | |
157 | #define MGET(m, how, type) { \ | |
158 | MALLOC((m), struct mbuf *, MSIZE, mbtypes[type], (how)); \ | |
159 | if (m) { \ | |
160 | (m)->m_type = (type); \ | |
161 | mbstat.m_mtypes[type]++; \ | |
162 | (m)->m_next = (struct mbuf *)NULL; \ | |
163 | (m)->m_nextpkt = (struct mbuf *)NULL; \ | |
164 | (m)->m_data = (m)->m_dat; \ | |
165 | (m)->m_flags = 0; \ | |
166 | } else \ | |
167 | (m) = m_retry((how), (type)); \ | |
168 | } | |
169 | ||
170 | #define MGETHDR(m, how, type) { \ | |
171 | MALLOC((m), struct mbuf *, MSIZE, mbtypes[type], (how)); \ | |
172 | if (m) { \ | |
173 | (m)->m_type = (type); \ | |
174 | mbstat.m_mtypes[type]++; \ | |
175 | (m)->m_next = (struct mbuf *)NULL; \ | |
176 | (m)->m_nextpkt = (struct mbuf *)NULL; \ | |
177 | (m)->m_data = (m)->m_pktdat; \ | |
178 | (m)->m_flags = M_PKTHDR; \ | |
179 | } else \ | |
180 | (m) = m_retryhdr((how), (type)); \ | |
181 | } | |
182 | ||
183 | /* | |
184 | * Mbuf cluster macros. | |
185 | * MCLALLOC(caddr_t p, int how) allocates an mbuf cluster. | |
186 | * MCLGET adds such clusters to a normal mbuf; | |
187 | * the flag M_EXT is set upon success. | |
188 | * MCLFREE releases a reference to a cluster allocated by MCLALLOC, | |
189 | * freeing the cluster if the reference count has reached 0. | |
190 | * | |
191 | * Normal mbuf clusters are normally treated as character arrays | |
192 | * after allocation, but use the first word of the buffer as a free list | |
193 | * pointer while on the free list. | |
194 | */ | |
195 | union mcluster { | |
196 | union mcluster *mcl_next; | |
197 | char mcl_buf[MCLBYTES]; | |
198 | }; | |
199 | ||
200 | #define MCLALLOC(p, how) \ | |
201 | { int ms = splimp(); \ | |
202 | if (mclfree == 0) \ | |
203 | (void)m_clalloc(1, (how)); \ | |
204 | if ((p) = (caddr_t)mclfree) { \ | |
205 | ++mclrefcnt[mtocl(p)]; \ | |
206 | mbstat.m_clfree--; \ | |
207 | mclfree = ((union mcluster *)(p))->mcl_next; \ | |
208 | } \ | |
209 | splx(ms); \ | |
210 | } | |
211 | ||
212 | #define MCLGET(m, how) \ | |
213 | { MCLALLOC((m)->m_ext.ext_buf, (how)); \ | |
214 | if ((m)->m_ext.ext_buf != NULL) { \ | |
215 | (m)->m_data = (m)->m_ext.ext_buf; \ | |
216 | (m)->m_flags |= M_EXT; \ | |
217 | (m)->m_ext.ext_size = MCLBYTES; \ | |
218 | } \ | |
219 | } | |
220 | ||
221 | #define MCLFREE(p) \ | |
222 | { int ms = splimp(); \ | |
223 | if (--mclrefcnt[mtocl(p)] == 0) { \ | |
224 | ((union mcluster *)(p))->mcl_next = mclfree; \ | |
225 | mclfree = (union mcluster *)(p); \ | |
226 | mbstat.m_clfree++; \ | |
227 | } \ | |
228 | splx(ms); \ | |
229 | } | |
230 | ||
231 | /* | |
232 | * MFREE(struct mbuf *m, struct mbuf *n) | |
233 | * Free a single mbuf and associated external storage. | |
234 | * Place the successor, if any, in n. | |
235 | */ | |
236 | #ifdef notyet | |
237 | #define MFREE(m, n) \ | |
238 | { mbstat.m_mtypes[(m)->m_type]--; \ | |
239 | if ((m)->m_flags & M_EXT) { \ | |
240 | if ((m)->m_ext.ext_free) \ | |
241 | (*((m)->m_ext.ext_free))((m)->m_ext.ext_buf, \ | |
242 | (m)->m_ext.ext_size); \ | |
243 | else \ | |
244 | MCLFREE((m)->m_ext.ext_buf); \ | |
245 | } \ | |
246 | (n) = (m)->m_next; \ | |
247 | FREE((m), mbtypes[(m)->m_type]); \ | |
248 | } | |
249 | #else /* notyet */ | |
250 | #define MFREE(m, nn) \ | |
251 | { mbstat.m_mtypes[(m)->m_type]--; \ | |
252 | if ((m)->m_flags & M_EXT) { \ | |
253 | MCLFREE((m)->m_ext.ext_buf); \ | |
254 | } \ | |
255 | (nn) = (m)->m_next; \ | |
256 | FREE((m), mbtypes[(m)->m_type]); \ | |
257 | } | |
258 | #endif | |
259 | ||
260 | /* | |
261 | * Copy mbuf pkthdr from from to to. | |
262 | * from must have M_PKTHDR set, and to must be empty. | |
263 | */ | |
264 | #define M_COPY_PKTHDR(to, from) { \ | |
265 | (to)->m_pkthdr = (from)->m_pkthdr; \ | |
266 | (to)->m_flags = (from)->m_flags & M_COPYFLAGS; \ | |
267 | (to)->m_data = (to)->m_pktdat; \ | |
268 | } | |
269 | ||
270 | /* | |
271 | * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place | |
272 | * an object of the specified size at the end of the mbuf, longword aligned. | |
273 | */ | |
274 | #define M_ALIGN(m, len) \ | |
275 | { (m)->m_data += (MLEN - (len)) &~ (sizeof(long) - 1); } | |
276 | /* | |
277 | * As above, for mbufs allocated with m_gethdr/MGETHDR | |
278 | * or initialized by M_COPY_PKTHDR. | |
279 | */ | |
280 | #define MH_ALIGN(m, len) \ | |
281 | { (m)->m_data += (MHLEN - (len)) &~ (sizeof(long) - 1); } | |
282 | ||
283 | /* | |
284 | * Compute the amount of space available | |
285 | * before the current start of data in an mbuf. | |
286 | */ | |
287 | #define M_LEADINGSPACE(m) \ | |
288 | ((m)->m_flags & M_EXT ? /* (m)->m_data - (m)->m_ext.ext_buf */ 0 : \ | |
289 | (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat : \ | |
290 | (m)->m_data - (m)->m_dat) | |
291 | ||
292 | /* | |
293 | * Compute the amount of space available | |
294 | * after the end of data in an mbuf. | |
295 | */ | |
296 | #define M_TRAILINGSPACE(m) \ | |
297 | ((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size - \ | |
298 | ((m)->m_data + (m)->m_len) : \ | |
299 | &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len)) | |
300 | ||
301 | /* | |
302 | * Arrange to prepend space of size plen to mbuf m. | |
303 | * If a new mbuf must be allocated, how specifies whether to wait. | |
304 | * If how is M_DONTWAIT and allocation fails, the original mbuf chain | |
305 | * is freed and m is set to NULL. | |
306 | */ | |
307 | #define M_PREPEND(m, plen, how) { \ | |
308 | if (M_LEADINGSPACE(m) >= (plen)) { \ | |
309 | (m)->m_data -= (plen); \ | |
310 | (m)->m_len += (plen); \ | |
311 | } else \ | |
312 | (m) = m_prepend((m), (plen), (how)); \ | |
313 | if ((m) && (m)->m_flags & M_PKTHDR) \ | |
314 | (m)->m_pkthdr.len += (plen); \ | |
315 | } | |
316 | ||
317 | /* change mbuf to new type */ | |
318 | #define MCHTYPE(m, t) { \ | |
319 | mbstat.m_mtypes[(m)->m_type]--; \ | |
320 | mbstat.m_mtypes[t]++; \ | |
321 | (m)->m_type = t;\ | |
322 | } | |
323 | ||
324 | /* length to m_copy to copy all */ | |
325 | #define M_COPYALL 1000000000 | |
326 | ||
327 | /* compatiblity with 4.3 */ | |
328 | #define m_copy(m, o, l) m_copym((m), (o), (l), M_DONTWAIT) | |
329 | ||
330 | /* | |
331 | * Mbuf statistics. | |
332 | */ | |
333 | struct mbstat { | |
334 | u_long m_mbufs; /* mbufs obtained from page pool */ | |
335 | u_long m_clusters; /* clusters obtained from page pool */ | |
336 | u_long m_spare; /* spare field */ | |
337 | u_long m_clfree; /* free clusters */ | |
338 | u_long m_drops; /* times failed to find space */ | |
339 | u_long m_wait; /* times waited for space */ | |
340 | u_long m_drain; /* times drained protocols for space */ | |
341 | u_short m_mtypes[256]; /* type specific mbuf allocations */ | |
342 | }; | |
343 | ||
344 | #ifdef KERNEL | |
345 | extern struct mbuf *mbutl; /* virtual address of mclusters */ | |
346 | extern char *mclrefcnt; /* cluster reference counts */ | |
347 | struct mbstat mbstat; | |
348 | int nmbclusters; | |
349 | union mcluster *mclfree; | |
350 | int max_linkhdr; /* largest link-level header */ | |
351 | int max_protohdr; /* largest protocol header */ | |
352 | int max_hdr; /* largest link+protocol header */ | |
353 | int max_datalen; /* MHLEN - max_hdr */ | |
354 | struct mbuf *m_get(), *m_gethdr(), *m_getclr(), *m_retry(), *m_retryhdr(); | |
355 | struct mbuf *m_free(), *m_copym(), *m_pullup(), *m_prepend(); | |
356 | int m_clalloc(); | |
357 | extern int mbtypes[]; /* XXX */ | |
358 | ||
359 | #ifdef MBTYPES | |
360 | int mbtypes[] = { /* XXX */ | |
361 | M_FREE, /* MT_FREE 0 /* should be on free list */ | |
362 | M_MBUF, /* MT_DATA 1 /* dynamic (data) allocation */ | |
363 | M_MBUF, /* MT_HEADER 2 /* packet header */ | |
364 | M_SOCKET, /* MT_SOCKET 3 /* socket structure */ | |
365 | M_PCB, /* MT_PCB 4 /* protocol control block */ | |
366 | M_RTABLE, /* MT_RTABLE 5 /* routing tables */ | |
367 | M_HTABLE, /* MT_HTABLE 6 /* IMP host tables */ | |
368 | 0, /* MT_ATABLE 7 /* address resolution tables */ | |
369 | M_MBUF, /* MT_SONAME 8 /* socket name */ | |
370 | 0, /* 9 */ | |
371 | M_SOOPTS, /* MT_SOOPTS 10 /* socket options */ | |
372 | M_FTABLE, /* MT_FTABLE 11 /* fragment reassembly header */ | |
373 | M_MBUF, /* MT_RIGHTS 12 /* access rights */ | |
374 | M_IFADDR, /* MT_IFADDR 13 /* interface address */ | |
375 | M_MBUF, /* MT_CONTROL 14 /* extra-data protocol message */ | |
376 | M_MBUF, /* MT_OOBDATA 15 /* expedited data */ | |
377 | #ifdef DATAKIT | |
378 | 25, 26, 27, 28, 29, 30, 31, 32 /* datakit ugliness */ | |
379 | #endif | |
380 | }; | |
381 | #endif | |
382 | #endif |