Annotation of sys/sys/mbuf.h, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: mbuf.h,v 1.92 2007/07/20 09:59:19 claudio Exp $ */
2: /* $NetBSD: mbuf.h,v 1.19 1996/02/09 18:25:14 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1988, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)mbuf.h 8.5 (Berkeley) 2/19/95
33: */
34:
35: #ifndef _SYS_MALLOC_H_
36: #include <sys/malloc.h>
37: #endif
38: #include <sys/pool.h>
39: #include <sys/queue.h>
40:
41: /*
42: * Mbufs are of a single size, MSIZE (machine/param.h), which
43: * includes overhead. An mbuf may add a single "mbuf cluster" of size
44: * MCLBYTES (also in machine/param.h), which has no additional overhead
45: * and is used instead of the internal data area; this is done when
46: * at least MINCLSIZE of data must be stored.
47: */
48:
49: #define MLEN (MSIZE - sizeof(struct m_hdr)) /* normal data len */
50: #define MHLEN (MLEN - sizeof(struct pkthdr)) /* data len w/pkthdr */
51:
52: #define MINCLSIZE (MHLEN + 1) /* smallest amount to put in cluster */
53: #define M_MAXCOMPRESS (MHLEN / 2) /* max amount to copy for compression */
54:
55: /* Packet tags structure */
56: struct m_tag {
57: SLIST_ENTRY(m_tag) m_tag_link; /* List of packet tags */
58: u_int16_t m_tag_id; /* Tag ID */
59: u_int16_t m_tag_len; /* Length of data */
60: };
61:
62: /*
63: * Macros for type conversion
64: * mtod(m,t) - convert mbuf pointer to data pointer of correct type
65: */
66: #define mtod(m,t) ((t)((m)->m_data))
67:
68: /* header at beginning of each mbuf: */
69: struct m_hdr {
70: struct mbuf *mh_next; /* next buffer in chain */
71: struct mbuf *mh_nextpkt; /* next chain in queue/record */
72: caddr_t mh_data; /* location of data */
73: u_int mh_len; /* amount of data in this mbuf */
74: short mh_type; /* type of data in this mbuf */
75: u_short mh_flags; /* flags; see below */
76: };
77:
78: /* pf stuff */
79: struct pkthdr_pf {
80: void *hdr; /* saved hdr pos in mbuf, for ECN */
81: u_int rtableid; /* alternate routing table id */
82: u_int32_t qid; /* queue id */
83: u_int16_t tag; /* tag id */
84: u_int8_t flags;
85: u_int8_t routed;
86: };
87:
88: /* pkthdr_pf.flags */
89: #define PF_TAG_GENERATED 0x01
90: #define PF_TAG_FRAGCACHE 0x02
91: #define PF_TAG_TRANSLATE_LOCALHOST 0x04
92:
93: /* record/packet header in first mbuf of chain; valid if M_PKTHDR set */
94: struct pkthdr {
95: struct ifnet *rcvif; /* rcv interface */
96: SLIST_HEAD(packet_tags, m_tag) tags; /* list of packet tags */
97: int len; /* total packet length */
98: int csum_flags; /* checksum flags */
99: struct pkthdr_pf pf;
100: };
101:
102: /* description of external storage mapped into mbuf, valid if M_EXT set */
103: struct m_ext {
104: caddr_t ext_buf; /* start of buffer */
105: /* free routine if not the usual */
106: void (*ext_free)(caddr_t, u_int, void *);
107: void *ext_arg; /* argument for ext_free */
108: u_int ext_size; /* size of buffer, for ext_free */
109: int ext_type;
110: struct mbuf *ext_nextref;
111: struct mbuf *ext_prevref;
112: #ifdef DEBUG
113: const char *ext_ofile;
114: const char *ext_nfile;
115: int ext_oline;
116: int ext_nline;
117: #endif
118: };
119:
120: struct mbuf {
121: struct m_hdr m_hdr;
122: union {
123: struct {
124: struct pkthdr MH_pkthdr; /* M_PKTHDR set */
125: union {
126: struct m_ext MH_ext; /* M_EXT set */
127: char MH_databuf[MHLEN];
128: } MH_dat;
129: } MH;
130: char M_databuf[MLEN]; /* !M_PKTHDR, !M_EXT */
131: } M_dat;
132: };
133: #define m_next m_hdr.mh_next
134: #define m_len m_hdr.mh_len
135: #define m_data m_hdr.mh_data
136: #define m_type m_hdr.mh_type
137: #define m_flags m_hdr.mh_flags
138: #define m_nextpkt m_hdr.mh_nextpkt
139: #define m_act m_nextpkt
140: #define m_pkthdr M_dat.MH.MH_pkthdr
141: #define m_ext M_dat.MH.MH_dat.MH_ext
142: #define m_pktdat M_dat.MH.MH_dat.MH_databuf
143: #define m_dat M_dat.M_databuf
144:
145: /* mbuf flags */
146: #define M_EXT 0x0001 /* has associated external storage */
147: #define M_PKTHDR 0x0002 /* start of record */
148: #define M_EOR 0x0004 /* end of record */
149: #define M_CLUSTER 0x0008 /* external storage is a cluster */
150: #define M_PROTO1 0x0010 /* protocol-specific */
151:
152: /* mbuf pkthdr flags, also in m_flags */
153: #define M_BCAST 0x0100 /* send/received as link-level broadcast */
154: #define M_MCAST 0x0200 /* send/received as link-level multicast */
155: #define M_CONF 0x0400 /* payload was encrypted (ESP-transport) */
156: #define M_AUTH 0x0800 /* payload was authenticated (AH or ESP auth) */
157: #define M_AUTH_AH 0x2000 /* header was authenticated (AH) */
158: #define M_TUNNEL 0x1000 /* IP-in-IP added by tunnel mode IPsec */
159: #define M_ANYCAST6 0x4000 /* received as IPv6 anycast */
160: #define M_LINK0 0x8000 /* link layer specific flag */
161: #define M_LOOP 0x0040 /* for Mbuf statistics */
162: #define M_FILDROP 0x0080 /* dropped by bpf filter */
163:
164: /* flags copied when copying m_pkthdr */
165: #define M_COPYFLAGS (M_PKTHDR|M_EOR|M_PROTO1|M_BCAST|M_MCAST|M_CONF|\
166: M_AUTH|M_ANYCAST6|M_LOOP|M_TUNNEL|M_LINK0|M_FILDROP)
167:
168: /* Checksumming flags */
169: #define M_IPV4_CSUM_OUT 0x0001 /* IPv4 checksum needed */
170: #define M_TCPV4_CSUM_OUT 0x0002 /* TCP checksum needed */
171: #define M_UDPV4_CSUM_OUT 0x0004 /* UDP checksum needed */
172: #define M_IPV4_CSUM_IN_OK 0x0008 /* IPv4 checksum verified */
173: #define M_IPV4_CSUM_IN_BAD 0x0010 /* IPv4 checksum bad */
174: #define M_TCP_CSUM_IN_OK 0x0020 /* TCP/IPv4 checksum verified */
175: #define M_TCP_CSUM_IN_BAD 0x0040 /* TCP/IPv4 checksum bad */
176: #define M_UDP_CSUM_IN_OK 0x0080 /* UDP/IPv4 checksum verified */
177: #define M_UDP_CSUM_IN_BAD 0x0100 /* UDP/IPv4 checksum bad */
178:
179: /* mbuf types */
180: #define MT_FREE 0 /* should be on free list */
181: #define MT_DATA 1 /* dynamic (data) allocation */
182: #define MT_HEADER 2 /* packet header */
183: #define MT_SONAME 3 /* socket name */
184: #define MT_SOOPTS 4 /* socket options */
185: #define MT_FTABLE 5 /* fragment reassembly header */
186: #define MT_CONTROL 6 /* extra-data protocol message */
187: #define MT_OOBDATA 7 /* expedited data */
188:
189: /* flags to m_get/MGET */
190: #define M_DONTWAIT M_NOWAIT
191: #define M_WAIT M_WAITOK
192:
193: /*
194: * mbuf utility macros:
195: *
196: * MBUFLOCK(code)
197: * prevents a section of code from from being interrupted by network
198: * drivers.
199: */
200: #define MBUFLOCK(code) do {\
201: int ms = splvm(); \
202: { code } \
203: splx(ms); \
204: } while(/* CONSTCOND */ 0)
205:
206: /*
207: * mbuf allocation/deallocation macros:
208: *
209: * MGET(struct mbuf *m, int how, int type)
210: * allocates an mbuf and initializes it to contain internal data.
211: *
212: * MGETHDR(struct mbuf *m, int how, int type)
213: * allocates an mbuf and initializes it to contain a packet header
214: * and internal data.
215: */
216: #define MGET(m, how, type) m = m_get((how), (type))
217:
218: #define MGETHDR(m, how, type) m = m_gethdr((how), (type))
219:
220: /*
221: * Macros for tracking external storage associated with an mbuf.
222: *
223: * Note: add and delete reference must be called at splvm().
224: */
225: #ifdef DEBUG
226: #define MCLREFDEBUGN(m, file, line) do { \
227: (m)->m_ext.ext_nfile = (file); \
228: (m)->m_ext.ext_nline = (line); \
229: } while (/* CONSTCOND */ 0)
230: #define MCLREFDEBUGO(m, file, line) do { \
231: (m)->m_ext.ext_ofile = (file); \
232: (m)->m_ext.ext_oline = (line); \
233: } while (/* CONSTCOND */ 0)
234: #else
235: #define MCLREFDEBUGN(m, file, line)
236: #define MCLREFDEBUGO(m, file, line)
237: #endif
238:
239: #define MCLBUFREF(p)
240: #define MCLISREFERENCED(m) ((m)->m_ext.ext_nextref != (m))
241: #define _MCLDEREFERENCE(m) do { \
242: (m)->m_ext.ext_nextref->m_ext.ext_prevref = \
243: (m)->m_ext.ext_prevref; \
244: (m)->m_ext.ext_prevref->m_ext.ext_nextref = \
245: (m)->m_ext.ext_nextref; \
246: } while (/* CONSTCOND */ 0)
247: #define _MCLADDREFERENCE(o, n) do { \
248: (n)->m_flags |= ((o)->m_flags & (M_EXT|M_CLUSTER)); \
249: (n)->m_ext.ext_nextref = (o)->m_ext.ext_nextref; \
250: (n)->m_ext.ext_prevref = (o); \
251: (o)->m_ext.ext_nextref = (n); \
252: (n)->m_ext.ext_nextref->m_ext.ext_prevref = (n); \
253: MCLREFDEBUGN((n), __FILE__, __LINE__); \
254: } while (/* CONSTCOND */ 0)
255: #define MCLINITREFERENCE(m) do { \
256: (m)->m_ext.ext_prevref = (m); \
257: (m)->m_ext.ext_nextref = (m); \
258: MCLREFDEBUGO((m), __FILE__, __LINE__); \
259: MCLREFDEBUGN((m), NULL, 0); \
260: } while (/* CONSTCOND */ 0)
261:
262: #define MCLADDREFERENCE(o, n) MBUFLOCK(_MCLADDREFERENCE((o), (n));)
263:
264: /*
265: * Macros for mbuf external storage.
266: *
267: * MCLGET allocates and adds an mbuf cluster to a normal mbuf;
268: * the flag M_EXT is set upon success.
269: *
270: * MEXTMALLOC allocates external storage and adds it to
271: * a normal mbuf; the flag M_EXT is set upon success.
272: *
273: * MEXTADD adds pre-allocated external storage to
274: * a normal mbuf; the flag M_EXT is set upon success.
275: */
276: #define MEXTMALLOC(m, size, how) do { \
277: (m)->m_ext.ext_buf = \
278: (caddr_t)malloc((size), mbtypes[(m)->m_type], (how)); \
279: if ((m)->m_ext.ext_buf != NULL) { \
280: (m)->m_data = (m)->m_ext.ext_buf; \
281: (m)->m_flags |= M_EXT; \
282: (m)->m_flags &= ~M_CLUSTER; \
283: (m)->m_ext.ext_size = (size); \
284: (m)->m_ext.ext_free = NULL; \
285: (m)->m_ext.ext_arg = NULL; \
286: (m)->m_ext.ext_type = mbtypes[(m)->m_type]; \
287: MCLINITREFERENCE(m); \
288: } \
289: } while (/* CONSTCOND */ 0)
290:
291: #define MEXTADD(m, buf, size, type, free, arg) do { \
292: (m)->m_data = (m)->m_ext.ext_buf = (caddr_t)(buf); \
293: (m)->m_flags |= M_EXT; \
294: (m)->m_flags &= ~M_CLUSTER; \
295: (m)->m_ext.ext_size = (size); \
296: (m)->m_ext.ext_free = (free); \
297: (m)->m_ext.ext_arg = (arg); \
298: (m)->m_ext.ext_type = (type); \
299: MCLINITREFERENCE(m); \
300: } while (/* CONSTCOND */ 0)
301:
302: /*
303: * Reset the data pointer on an mbuf.
304: */
305: #define MRESETDATA(m) \
306: do { \
307: if ((m)->m_flags & M_EXT) \
308: (m)->m_data = (m)->m_ext.ext_buf; \
309: else if ((m)->m_flags & M_PKTHDR) \
310: (m)->m_data = (m)->m_pktdat; \
311: else \
312: (m)->m_data = (m)->m_dat; \
313: } while (/* CONSTCOND */ 0)
314:
315: #define MCLGET(m, how) m_clget(m, how)
316:
317: /*
318: * MFREE(struct mbuf *m, struct mbuf *n)
319: * Free a single mbuf and associated external storage.
320: * Place the successor, if any, in n.
321: */
322: #define MFREE(m, n) n = m_free((m))
323:
324: /*
325: * Move just m_pkthdr from from to to,
326: * remove M_PKTHDR and clean the tag for from.
327: */
328: #define M_MOVE_HDR(to, from) { \
329: (to)->m_pkthdr = (from)->m_pkthdr; \
330: (from)->m_flags &= ~M_PKTHDR; \
331: SLIST_INIT(&(from)->m_pkthdr.tags); \
332: }
333:
334: /*
335: * Duplicate just m_pkthdr from from to to.
336: */
337: #define M_DUP_HDR(to, from) { \
338: (to)->m_pkthdr = (from)->m_pkthdr; \
339: SLIST_INIT(&(to)->m_pkthdr.tags); \
340: m_tag_copy_chain((to), (from)); \
341: }
342:
343: /*
344: * Duplicate mbuf pkthdr from from to to.
345: * from must have M_PKTHDR set, and to must be empty.
346: */
347: #define M_DUP_PKTHDR(to, from) { \
348: (to)->m_flags = (from)->m_flags & M_COPYFLAGS; \
349: M_DUP_HDR((to), (from)); \
350: (to)->m_data = (to)->m_pktdat; \
351: }
352:
353: /*
354: * MOVE mbuf pkthdr from from to to.
355: * from must have M_PKTHDR set, and to must be empty.
356: */
357: #define M_MOVE_PKTHDR(to, from) { \
358: (to)->m_flags = (from)->m_flags & M_COPYFLAGS; \
359: M_MOVE_HDR((to), (from)); \
360: (to)->m_data = (to)->m_pktdat; \
361: }
362:
363: /*
364: * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place
365: * an object of the specified size at the end of the mbuf, longword aligned.
366: */
367: #define M_ALIGN(m, len) \
368: { (m)->m_data += (MLEN - (len)) &~ (sizeof(long) - 1); }
369: /*
370: * As above, for mbufs allocated with m_gethdr/MGETHDR
371: * or initialized by M_MOVE_PKTHDR.
372: */
373: #define MH_ALIGN(m, len) \
374: { (m)->m_data += (MHLEN - (len)) &~ (sizeof(long) - 1); }
375:
376: /*
377: * Determine if an mbuf's data area is read-only. This is true for
378: * non-cluster external storage and for clusters that are being
379: * referenced by more than one mbuf.
380: */
381: #define M_READONLY(m) \
382: (((m)->m_flags & M_EXT) != 0 && \
383: (((m)->m_flags & M_CLUSTER) == 0 || MCLISREFERENCED(m)))
384:
385: /*
386: * Compute the amount of space available
387: * before the current start of data in an mbuf.
388: */
389: #define _M_LEADINGSPACE(m) \
390: ((m)->m_flags & M_EXT ? (m)->m_data - (m)->m_ext.ext_buf : \
391: (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat : \
392: (m)->m_data - (m)->m_dat)
393:
394: #define M_LEADINGSPACE(m) \
395: (M_READONLY((m)) ? 0 : _M_LEADINGSPACE((m)))
396:
397: /*
398: * Compute the amount of space available
399: * after the end of data in an mbuf.
400: */
401: #define _M_TRAILINGSPACE(m) \
402: ((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size - \
403: ((m)->m_data + (m)->m_len) : \
404: &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
405:
406: #define M_TRAILINGSPACE(m) \
407: (M_READONLY((m)) ? 0 : _M_TRAILINGSPACE((m)))
408:
409: /*
410: * Arrange to prepend space of size plen to mbuf m.
411: * If a new mbuf must be allocated, how specifies whether to wait.
412: * If how is M_DONTWAIT and allocation fails, the original mbuf chain
413: * is freed and m is set to NULL.
414: */
415: #define M_PREPEND(m, plen, how) { \
416: if (M_LEADINGSPACE(m) >= (plen)) { \
417: (m)->m_data -= (plen); \
418: (m)->m_len += (plen); \
419: } else \
420: (m) = m_prepend((m), (plen), (how)); \
421: if ((m) && (m)->m_flags & M_PKTHDR) \
422: (m)->m_pkthdr.len += (plen); \
423: }
424:
425: /* change mbuf to new type */
426: #define MCHTYPE(m, t) { \
427: MBUFLOCK(mbstat.m_mtypes[(m)->m_type]--; mbstat.m_mtypes[t]++;); \
428: (m)->m_type = t;\
429: }
430:
431: /* length to m_copy to copy all */
432: #define M_COPYALL 1000000000
433:
434: /* compatibility with 4.3 */
435: #define m_copy(m, o, l) m_copym((m), (o), (l), M_DONTWAIT)
436:
437: /*
438: * Mbuf statistics.
439: * For statistics related to mbuf and cluster allocations, see also the
440: * pool headers (mbpool and mclpool).
441: */
442: struct mbstat {
443: u_long _m_spare; /* formerly m_mbufs */
444: u_long _m_spare1; /* formerly m_clusters */
445: u_long _m_spare2; /* spare field */
446: u_long _m_spare3; /* formely m_clfree - free clusters */
447: u_long m_drops; /* times failed to find space */
448: u_long m_wait; /* times waited for space */
449: u_long m_drain; /* times drained protocols for space */
450: u_short m_mtypes[256]; /* type specific mbuf allocations */
451: };
452:
453: #ifdef _KERNEL
454: extern struct mbstat mbstat;
455: extern int nmbclust; /* limit on the # of clusters */
456: extern int mblowat; /* mbuf low water mark */
457: extern int mcllowat; /* mbuf cluster low water mark */
458: extern int max_linkhdr; /* largest link-level header */
459: extern int max_protohdr; /* largest protocol header */
460: extern int max_hdr; /* largest link+protocol header */
461: extern int max_datalen; /* MHLEN - max_hdr */
462: extern int mbtypes[]; /* XXX */
463: extern struct pool mbpool;
464: extern struct pool mclpool;
465:
466: void mbinit(void);
467: struct mbuf *m_copym2(struct mbuf *, int, int, int);
468: struct mbuf *m_copym(struct mbuf *, int, int, int);
469: struct mbuf *m_free(struct mbuf *);
470: struct mbuf *m_get(int, int);
471: struct mbuf *m_getclr(int, int);
472: struct mbuf *m_gethdr(int, int);
473: struct mbuf *m_prepend(struct mbuf *, int, int);
474: struct mbuf *m_pulldown(struct mbuf *, int, int, int *);
475: struct mbuf *m_pullup(struct mbuf *, int);
476: struct mbuf *m_pullup2(struct mbuf *, int);
477: struct mbuf *m_split(struct mbuf *, int, int);
478: struct mbuf *m_inject(struct mbuf *, int, int, int);
479: struct mbuf *m_getptr(struct mbuf *, int, int *);
480: void m_clget(struct mbuf *, int);
481: void m_adj(struct mbuf *, int);
482: int m_clalloc(int, int);
483: void m_copyback(struct mbuf *, int, int, const void *);
484: void m_freem(struct mbuf *);
485: void m_reclaim(void *, int);
486: void m_copydata(struct mbuf *, int, int, caddr_t);
487: void m_cat(struct mbuf *, struct mbuf *);
488: struct mbuf *m_devget(char *, int, int, struct ifnet *,
489: void (*)(const void *, void *, size_t));
490: void m_zero(struct mbuf *);
491: int m_apply(struct mbuf *, int, int,
492: int (*)(caddr_t, caddr_t, unsigned int), caddr_t);
493:
494: /* Packet tag routines */
495: struct m_tag *m_tag_get(int, int, int);
496: void m_tag_prepend(struct mbuf *, struct m_tag *);
497: void m_tag_delete(struct mbuf *, struct m_tag *);
498: void m_tag_delete_chain(struct mbuf *);
499: struct m_tag *m_tag_find(struct mbuf *, int, struct m_tag *);
500: struct m_tag *m_tag_copy(struct m_tag *);
501: int m_tag_copy_chain(struct mbuf *, struct mbuf *);
502: void m_tag_init(struct mbuf *);
503: struct m_tag *m_tag_first(struct mbuf *);
504: struct m_tag *m_tag_next(struct mbuf *, struct m_tag *);
505:
506: /* Packet tag types */
507: #define PACKET_TAG_NONE 0 /* Nadda */
508: #define PACKET_TAG_IPSEC_IN_DONE 1 /* IPsec applied, in */
509: #define PACKET_TAG_IPSEC_OUT_DONE 2 /* IPsec applied, out */
510: #define PACKET_TAG_IPSEC_IN_CRYPTO_DONE 3 /* NIC IPsec crypto done */
511: #define PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED 4 /* NIC IPsec crypto req'ed */
512: #define PACKET_TAG_IPSEC_IN_COULD_DO_CRYPTO 5 /* NIC notifies IPsec */
513: #define PACKET_TAG_IPSEC_PENDING_TDB 6 /* Reminder to do IPsec */
514: #define PACKET_TAG_BRIDGE 7 /* Bridge processing done */
515: #define PACKET_TAG_GIF 8 /* GIF processing done */
516: #define PACKET_TAG_GRE 9 /* GRE processing done */
517: #define PACKET_TAG_IN_PACKET_CHECKSUM 10 /* NIC checksumming done */
518: #define PACKET_TAG_DLT 17 /* data link layer type */
519:
520: #ifdef MBTYPES
521: int mbtypes[] = { /* XXX */
522: M_FREE, /* MT_FREE 0 should be on free list */
523: M_MBUF, /* MT_DATA 1 dynamic (data) allocation */
524: M_MBUF, /* MT_HEADER 2 packet header */
525: M_MBUF, /* MT_SONAME 8 socket name */
526: M_SOOPTS, /* MT_SOOPTS 10 socket options */
527: M_FTABLE, /* MT_FTABLE 11 fragment reassembly header */
528: M_MBUF, /* MT_CONTROL 14 extra-data protocol message */
529: M_MBUF, /* MT_OOBDATA 15 expedited data */
530: };
531: #endif /* MBTYPES */
532: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to mbuf.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / sys