1 | /* |
---|
2 | * Copyright (c) 1982, 1986, 1988, 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 | * 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 8.5 (Berkeley) 2/19/95 |
---|
34 | * $Id$ |
---|
35 | */ |
---|
36 | |
---|
37 | #ifndef _SYS_MBUF_H_ |
---|
38 | #define _SYS_MBUF_H_ |
---|
39 | |
---|
40 | #ifndef M_WAITOK |
---|
41 | #include <sys/malloc.h> |
---|
42 | #endif |
---|
43 | |
---|
44 | /* |
---|
45 | * Mbufs are of a single size, MSIZE (machine/machparam.h), which |
---|
46 | * includes overhead. An mbuf may add a single "mbuf cluster" of size |
---|
47 | * MCLBYTES (also in machine/machparam.h), which has no additional overhead |
---|
48 | * and is used instead of the internal data area; this is done when |
---|
49 | * at least MINCLSIZE of data must be stored. |
---|
50 | */ |
---|
51 | |
---|
52 | #define MLEN (MSIZE - sizeof(struct m_hdr)) /* normal data len */ |
---|
53 | #define MHLEN (MLEN - sizeof(struct pkthdr)) /* data len w/pkthdr */ |
---|
54 | |
---|
55 | #define MINCLSIZE (MHLEN + MLEN) /* smallest amount to put in cluster */ |
---|
56 | #define M_MAXCOMPRESS (MHLEN / 2) /* max amount to copy for compression */ |
---|
57 | |
---|
58 | /* |
---|
59 | * Macros for type conversion |
---|
60 | * mtod(m,t) - convert mbuf pointer to data pointer of correct type |
---|
61 | * dtom(x) - convert data pointer within mbuf to mbuf pointer (XXX) |
---|
62 | * mtocl(x) - convert pointer within cluster to cluster index # |
---|
63 | * cltom(x) - convert cluster # to ptr to beginning of cluster |
---|
64 | */ |
---|
65 | #define mtod(m,t) ((t)((m)->m_data)) |
---|
66 | #define dtom(x) ((struct mbuf *)((long)(x) & ~(MSIZE-1))) |
---|
67 | #define mtocl(x) (((u_long)(x) - (u_long)mbutl) >> MCLSHIFT) |
---|
68 | #define cltom(x) ((caddr_t)((u_long)mbutl + ((u_long)(x) << MCLSHIFT))) |
---|
69 | |
---|
70 | /* header at beginning of each mbuf: */ |
---|
71 | struct m_hdr { |
---|
72 | struct mbuf *mh_next; /* next buffer in chain */ |
---|
73 | struct mbuf *mh_nextpkt; /* next chain in queue/record */ |
---|
74 | caddr_t mh_data; /* location of data */ |
---|
75 | int mh_len; /* amount of data in this mbuf */ |
---|
76 | short mh_type; /* type of data in this mbuf */ |
---|
77 | short mh_flags; /* flags; see below */ |
---|
78 | }; |
---|
79 | |
---|
80 | /* record/packet header in first mbuf of chain; valid if M_PKTHDR set */ |
---|
81 | struct pkthdr { |
---|
82 | struct ifnet *rcvif; /* rcv interface */ |
---|
83 | int len; /* total packet length */ |
---|
84 | }; |
---|
85 | |
---|
86 | /* description of external storage mapped into mbuf, valid if M_EXT set */ |
---|
87 | struct m_ext { |
---|
88 | caddr_t ext_buf; /* start of buffer */ |
---|
89 | void (*ext_free) /* free routine if not the usual */ |
---|
90 | __P((caddr_t, u_int)); |
---|
91 | u_int ext_size; /* size of buffer, for ext_free */ |
---|
92 | void (*ext_ref) /* add a reference to the ext object */ |
---|
93 | __P((caddr_t, u_int)); |
---|
94 | }; |
---|
95 | |
---|
96 | struct mbuf { |
---|
97 | struct m_hdr m_hdr; |
---|
98 | union { |
---|
99 | struct { |
---|
100 | struct pkthdr MH_pkthdr; /* M_PKTHDR set */ |
---|
101 | union { |
---|
102 | struct m_ext MH_ext; /* M_EXT set */ |
---|
103 | char MH_databuf[MHLEN]; |
---|
104 | } MH_dat; |
---|
105 | } MH; |
---|
106 | char M_databuf[MLEN]; /* !M_PKTHDR, !M_EXT */ |
---|
107 | } M_dat; |
---|
108 | }; |
---|
109 | #define m_next m_hdr.mh_next |
---|
110 | #define m_len m_hdr.mh_len |
---|
111 | #define m_data m_hdr.mh_data |
---|
112 | #define m_type m_hdr.mh_type |
---|
113 | #define m_flags m_hdr.mh_flags |
---|
114 | #define m_nextpkt m_hdr.mh_nextpkt |
---|
115 | #define m_act m_nextpkt |
---|
116 | #define m_pkthdr M_dat.MH.MH_pkthdr |
---|
117 | #define m_ext M_dat.MH.MH_dat.MH_ext |
---|
118 | #define m_pktdat M_dat.MH.MH_dat.MH_databuf |
---|
119 | #define m_dat M_dat.M_databuf |
---|
120 | |
---|
121 | /* mbuf flags */ |
---|
122 | #define M_EXT 0x0001 /* has associated external storage */ |
---|
123 | #define M_PKTHDR 0x0002 /* start of record */ |
---|
124 | #define M_EOR 0x0004 /* end of record */ |
---|
125 | #define M_PROTO1 0x0008 /* protocol-specific */ |
---|
126 | |
---|
127 | /* mbuf pkthdr flags, also in m_flags */ |
---|
128 | #define M_BCAST 0x0100 /* send/received as link-level broadcast */ |
---|
129 | #define M_MCAST 0x0200 /* send/received as link-level multicast */ |
---|
130 | |
---|
131 | /* flags copied when copying m_pkthdr */ |
---|
132 | #define M_COPYFLAGS (M_PKTHDR|M_EOR|M_PROTO1|M_BCAST|M_MCAST) |
---|
133 | |
---|
134 | /* mbuf types */ |
---|
135 | #define MT_FREE 0 /* should be on free list */ |
---|
136 | #define MT_DATA 1 /* dynamic (data) allocation */ |
---|
137 | #define MT_HEADER 2 /* packet header */ |
---|
138 | #define MT_SOCKET 3 /* socket structure */ |
---|
139 | #define MT_PCB 4 /* protocol control block */ |
---|
140 | #define MT_RTABLE 5 /* routing tables */ |
---|
141 | #define MT_HTABLE 6 /* IMP host tables */ |
---|
142 | #define MT_ATABLE 7 /* address resolution tables */ |
---|
143 | #define MT_SONAME 8 /* socket name */ |
---|
144 | #define MT_SOOPTS 10 /* socket options */ |
---|
145 | #define MT_FTABLE 11 /* fragment reassembly header */ |
---|
146 | #define MT_RIGHTS 12 /* access rights */ |
---|
147 | #define MT_IFADDR 13 /* interface address */ |
---|
148 | #define MT_CONTROL 14 /* extra-data protocol message */ |
---|
149 | #define MT_OOBDATA 15 /* expedited data */ |
---|
150 | |
---|
151 | /* flags to m_get/MGET */ |
---|
152 | #define M_DONTWAIT M_NOWAIT |
---|
153 | #define M_WAIT M_WAITOK |
---|
154 | |
---|
155 | /* Freelists: |
---|
156 | * |
---|
157 | * Normal mbuf clusters are normally treated as character arrays |
---|
158 | * after allocation, but use the first word of the buffer as a free list |
---|
159 | * pointer while on the free list. |
---|
160 | */ |
---|
161 | union mcluster { |
---|
162 | union mcluster *mcl_next; |
---|
163 | char mcl_buf[MCLBYTES]; |
---|
164 | }; |
---|
165 | |
---|
166 | /* |
---|
167 | * mbuf utility macros: |
---|
168 | * |
---|
169 | * MBUFLOCK(code) |
---|
170 | * prevents a section of code from from being interrupted by network |
---|
171 | * drivers. |
---|
172 | */ |
---|
173 | #define MBUFLOCK(code) \ |
---|
174 | { int ms = splimp(); \ |
---|
175 | { code } \ |
---|
176 | splx(ms); \ |
---|
177 | } |
---|
178 | |
---|
179 | /* |
---|
180 | * mbuf allocation/deallocation macros: |
---|
181 | * |
---|
182 | * MGET(struct mbuf *m, int how, int type) |
---|
183 | * allocates an mbuf and initializes it to contain internal data. |
---|
184 | * |
---|
185 | * MGETHDR(struct mbuf *m, int how, int type) |
---|
186 | * allocates an mbuf and initializes it to contain a packet header |
---|
187 | * and internal data. |
---|
188 | */ |
---|
189 | #define MGET(m, how, type) { \ |
---|
190 | int _ms = splimp(); \ |
---|
191 | if (mmbfree == 0) \ |
---|
192 | (void)m_mballoc(1, (how)); \ |
---|
193 | if (((m) = mmbfree) != 0) { \ |
---|
194 | mmbfree = (m)->m_next; \ |
---|
195 | mbstat.m_mtypes[MT_FREE]--; \ |
---|
196 | (m)->m_type = (type); \ |
---|
197 | mbstat.m_mtypes[type]++; \ |
---|
198 | (m)->m_next = (struct mbuf *)NULL; \ |
---|
199 | (m)->m_nextpkt = (struct mbuf *)NULL; \ |
---|
200 | (m)->m_data = (m)->m_dat; \ |
---|
201 | (m)->m_flags = 0; \ |
---|
202 | splx(_ms); \ |
---|
203 | } else { \ |
---|
204 | splx(_ms); \ |
---|
205 | (m) = m_retry((how), (type)); \ |
---|
206 | } \ |
---|
207 | } |
---|
208 | |
---|
209 | #define MGETHDR(m, how, type) { \ |
---|
210 | int _ms = splimp(); \ |
---|
211 | if (mmbfree == 0) \ |
---|
212 | (void)m_mballoc(1, (how)); \ |
---|
213 | if (((m) = mmbfree) != 0) { \ |
---|
214 | mmbfree = (m)->m_next; \ |
---|
215 | mbstat.m_mtypes[MT_FREE]--; \ |
---|
216 | (m)->m_type = (type); \ |
---|
217 | mbstat.m_mtypes[type]++; \ |
---|
218 | (m)->m_next = (struct mbuf *)NULL; \ |
---|
219 | (m)->m_nextpkt = (struct mbuf *)NULL; \ |
---|
220 | (m)->m_data = (m)->m_pktdat; \ |
---|
221 | (m)->m_flags = M_PKTHDR; \ |
---|
222 | splx(_ms); \ |
---|
223 | } else { \ |
---|
224 | splx(_ms); \ |
---|
225 | (m) = m_retryhdr((how), (type)); \ |
---|
226 | } \ |
---|
227 | } |
---|
228 | |
---|
229 | /* |
---|
230 | * Mbuf cluster macros. |
---|
231 | * MCLALLOC(caddr_t p, int how) allocates an mbuf cluster. |
---|
232 | * MCLGET adds such clusters to a normal mbuf; |
---|
233 | * the flag M_EXT is set upon success. |
---|
234 | * MCLFREE releases a reference to a cluster allocated by MCLALLOC, |
---|
235 | * freeing the cluster if the reference count has reached 0. |
---|
236 | */ |
---|
237 | #define MCLALLOC(p, how) \ |
---|
238 | MBUFLOCK( \ |
---|
239 | if (mclfree == 0) \ |
---|
240 | (void)m_clalloc(1, (how)); \ |
---|
241 | if (((p) = (caddr_t)mclfree) != 0) { \ |
---|
242 | ++mclrefcnt[mtocl(p)]; \ |
---|
243 | mbstat.m_clfree--; \ |
---|
244 | mclfree = ((union mcluster *)(p))->mcl_next; \ |
---|
245 | } \ |
---|
246 | ) |
---|
247 | |
---|
248 | #define MCLGET(m, how) \ |
---|
249 | { MCLALLOC((m)->m_ext.ext_buf, (how)); \ |
---|
250 | if ((m)->m_ext.ext_buf != NULL) { \ |
---|
251 | (m)->m_data = (m)->m_ext.ext_buf; \ |
---|
252 | (m)->m_flags |= M_EXT; \ |
---|
253 | (m)->m_ext.ext_free = NULL; \ |
---|
254 | (m)->m_ext.ext_ref = NULL; \ |
---|
255 | (m)->m_ext.ext_size = MCLBYTES; \ |
---|
256 | } \ |
---|
257 | } |
---|
258 | |
---|
259 | #define MCLFREE(p) \ |
---|
260 | MBUFLOCK ( \ |
---|
261 | if (--mclrefcnt[mtocl(p)] == 0) { \ |
---|
262 | ((union mcluster *)(p))->mcl_next = mclfree; \ |
---|
263 | mclfree = (union mcluster *)(p); \ |
---|
264 | mbstat.m_clfree++; \ |
---|
265 | } \ |
---|
266 | ) |
---|
267 | |
---|
268 | /* |
---|
269 | * MFREE(struct mbuf *m, struct mbuf *n) |
---|
270 | * Free a single mbuf and associated external storage. |
---|
271 | * Place the successor, if any, in n. |
---|
272 | */ |
---|
273 | #define MFREE(m, n) \ |
---|
274 | MBUFLOCK( \ |
---|
275 | mbstat.m_mtypes[(m)->m_type]--; \ |
---|
276 | if ((m)->m_flags & M_EXT) { \ |
---|
277 | if ((m)->m_ext.ext_free) \ |
---|
278 | (*((m)->m_ext.ext_free))((m)->m_ext.ext_buf, \ |
---|
279 | (m)->m_ext.ext_size); \ |
---|
280 | else { \ |
---|
281 | char *p = (m)->m_ext.ext_buf; \ |
---|
282 | if (--mclrefcnt[mtocl(p)] == 0) { \ |
---|
283 | ((union mcluster *)(p))->mcl_next = mclfree; \ |
---|
284 | mclfree = (union mcluster *)(p); \ |
---|
285 | mbstat.m_clfree++; \ |
---|
286 | } \ |
---|
287 | } \ |
---|
288 | } \ |
---|
289 | (n) = (m)->m_next; \ |
---|
290 | (m)->m_type = MT_FREE; \ |
---|
291 | mbstat.m_mtypes[MT_FREE]++; \ |
---|
292 | (m)->m_next = mmbfree; \ |
---|
293 | mmbfree = (m); \ |
---|
294 | ) |
---|
295 | |
---|
296 | /* |
---|
297 | * Copy mbuf pkthdr from from to to. |
---|
298 | * from must have M_PKTHDR set, and to must be empty. |
---|
299 | */ |
---|
300 | #define M_COPY_PKTHDR(to, from) { \ |
---|
301 | (to)->m_pkthdr = (from)->m_pkthdr; \ |
---|
302 | (to)->m_flags = (from)->m_flags & M_COPYFLAGS; \ |
---|
303 | (to)->m_data = (to)->m_pktdat; \ |
---|
304 | } |
---|
305 | |
---|
306 | /* |
---|
307 | * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place |
---|
308 | * an object of the specified size at the end of the mbuf, longword aligned. |
---|
309 | */ |
---|
310 | #define M_ALIGN(m, len) \ |
---|
311 | { (m)->m_data += (MLEN - (len)) &~ (sizeof(long) - 1); } |
---|
312 | /* |
---|
313 | * As above, for mbufs allocated with m_gethdr/MGETHDR |
---|
314 | * or initialized by M_COPY_PKTHDR. |
---|
315 | */ |
---|
316 | #define MH_ALIGN(m, len) \ |
---|
317 | { (m)->m_data += (MHLEN - (len)) &~ (sizeof(long) - 1); } |
---|
318 | |
---|
319 | /* |
---|
320 | * Compute the amount of space available |
---|
321 | * before the current start of data in an mbuf. |
---|
322 | */ |
---|
323 | #define M_LEADINGSPACE(m) \ |
---|
324 | ((m)->m_flags & M_EXT ? /* (m)->m_data - (m)->m_ext.ext_buf */ 0 : \ |
---|
325 | (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat : \ |
---|
326 | (m)->m_data - (m)->m_dat) |
---|
327 | |
---|
328 | /* |
---|
329 | * Compute the amount of space available |
---|
330 | * after the end of data in an mbuf. |
---|
331 | */ |
---|
332 | #define M_TRAILINGSPACE(m) \ |
---|
333 | ((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size - \ |
---|
334 | ((m)->m_data + (m)->m_len) : \ |
---|
335 | &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len)) |
---|
336 | |
---|
337 | /* |
---|
338 | * Arrange to prepend space of size plen to mbuf m. |
---|
339 | * If a new mbuf must be allocated, how specifies whether to wait. |
---|
340 | * If how is M_DONTWAIT and allocation fails, the original mbuf chain |
---|
341 | * is freed and m is set to NULL. |
---|
342 | */ |
---|
343 | #define M_PREPEND(m, plen, how) { \ |
---|
344 | if (M_LEADINGSPACE(m) >= (plen)) { \ |
---|
345 | (m)->m_data -= (plen); \ |
---|
346 | (m)->m_len += (plen); \ |
---|
347 | } else \ |
---|
348 | (m) = m_prepend((m), (plen), (how)); \ |
---|
349 | if ((m) && (m)->m_flags & M_PKTHDR) \ |
---|
350 | (m)->m_pkthdr.len += (plen); \ |
---|
351 | } |
---|
352 | |
---|
353 | /* change mbuf to new type */ |
---|
354 | #define MCHTYPE(m, t) { \ |
---|
355 | MBUFLOCK(mbstat.m_mtypes[(m)->m_type]--; mbstat.m_mtypes[t]++;) \ |
---|
356 | (m)->m_type = t;\ |
---|
357 | } |
---|
358 | |
---|
359 | /* length to m_copy to copy all */ |
---|
360 | #define M_COPYALL 1000000000 |
---|
361 | |
---|
362 | /* compatibility with 4.3 */ |
---|
363 | #define m_copy(m, o, l) m_copym((m), (o), (l), M_DONTWAIT) |
---|
364 | |
---|
365 | /* |
---|
366 | * Mbuf statistics. |
---|
367 | */ |
---|
368 | struct mbstat { |
---|
369 | u_long m_mbufs; /* mbufs obtained from page pool */ |
---|
370 | u_long m_clusters; /* clusters obtained from page pool */ |
---|
371 | u_long m_spare; /* spare field */ |
---|
372 | u_long m_clfree; /* free clusters */ |
---|
373 | u_long m_drops; /* times failed to find space */ |
---|
374 | u_long m_wait; /* times waited for space */ |
---|
375 | u_long m_drain; /* times drained protocols for space */ |
---|
376 | u_short m_mtypes[256]; /* type specific mbuf allocations */ |
---|
377 | }; |
---|
378 | |
---|
379 | #ifdef KERNEL |
---|
380 | extern struct mbuf *mbutl; /* virtual address of mclusters */ |
---|
381 | extern char *mclrefcnt; /* cluster reference counts */ |
---|
382 | extern struct mbstat mbstat; |
---|
383 | extern int nmbclusters; |
---|
384 | extern int nmbufs; |
---|
385 | extern struct mbuf *mmbfree; |
---|
386 | extern union mcluster *mclfree; |
---|
387 | extern int max_linkhdr; /* largest link-level header */ |
---|
388 | extern int max_protohdr; /* largest protocol header */ |
---|
389 | extern int max_hdr; /* largest link+protocol header */ |
---|
390 | extern int max_datalen; /* MHLEN - max_hdr */ |
---|
391 | extern int mbtypes[]; /* XXX */ |
---|
392 | |
---|
393 | struct mbuf *m_copym __P((struct mbuf *, int, int, int)); |
---|
394 | struct mbuf *m_copypacket __P((struct mbuf *, int)); |
---|
395 | struct mbuf *m_devget __P((char *, int, int, struct ifnet *, |
---|
396 | void (*copy)(char *, caddr_t, u_int))); |
---|
397 | struct mbuf *m_free __P((struct mbuf *)); |
---|
398 | struct mbuf *m_get __P((int, int)); |
---|
399 | struct mbuf *m_getclr __P((int, int)); |
---|
400 | struct mbuf *m_gethdr __P((int, int)); |
---|
401 | struct mbuf *m_prepend __P((struct mbuf *,int,int)); |
---|
402 | struct mbuf *m_pullup __P((struct mbuf *, int)); |
---|
403 | struct mbuf *m_retry __P((int, int)); |
---|
404 | struct mbuf *m_retryhdr __P((int, int)); |
---|
405 | struct mbuf *m_split __P((struct mbuf *,int,int)); |
---|
406 | void m_adj __P((struct mbuf *, int)); |
---|
407 | void m_cat __P((struct mbuf *,struct mbuf *)); |
---|
408 | int m_mballoc __P((int, int)); |
---|
409 | int m_clalloc __P((int, int)); |
---|
410 | int m_copyback __P((struct mbuf *, int, int, caddr_t)); |
---|
411 | int m_copydata __P((struct mbuf *, int, int, caddr_t)); |
---|
412 | void m_freem __P((struct mbuf *)); |
---|
413 | void m_reclaim __P((void)); |
---|
414 | |
---|
415 | #ifdef MBTYPES |
---|
416 | int mbtypes[] = { /* XXX */ |
---|
417 | M_FREE, /* MT_FREE 0 should be on free list */ |
---|
418 | M_MBUF, /* MT_DATA 1 dynamic (data) allocation */ |
---|
419 | M_MBUF, /* MT_HEADER 2 packet header */ |
---|
420 | M_SOCKET, /* MT_SOCKET 3 socket structure */ |
---|
421 | M_PCB, /* MT_PCB 4 protocol control block */ |
---|
422 | M_RTABLE, /* MT_RTABLE 5 routing tables */ |
---|
423 | M_HTABLE, /* MT_HTABLE 6 IMP host tables */ |
---|
424 | 0, /* MT_ATABLE 7 address resolution tables */ |
---|
425 | M_MBUF, /* MT_SONAME 8 socket name */ |
---|
426 | 0, /* 9 */ |
---|
427 | M_SOOPTS, /* MT_SOOPTS 10 socket options */ |
---|
428 | M_FTABLE, /* MT_FTABLE 11 fragment reassembly header */ |
---|
429 | M_MBUF, /* MT_RIGHTS 12 access rights */ |
---|
430 | M_IFADDR, /* MT_IFADDR 13 interface address */ |
---|
431 | M_MBUF, /* MT_CONTROL 14 extra-data protocol message */ |
---|
432 | M_MBUF, /* MT_OOBDATA 15 expedited data */ |
---|
433 | #ifdef DATAKIT |
---|
434 | 25, 26, 27, 28, 29, 30, 31, 32 /* datakit ugliness */ |
---|
435 | #endif |
---|
436 | }; |
---|
437 | #endif |
---|
438 | #endif |
---|
439 | |
---|
440 | #endif /* !_SYS_MBUF_H_ */ |
---|