xref: /freebsd/sys/sys/mbuf.h (revision a1a4f1a0d87b594d3f17a97dc0127eec1417e6f6)
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  * $FreeBSD$
35  */
36 
37 #ifndef _SYS_MBUF_H_
38 #define _SYS_MBUF_H_
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 *)((intptr_t)(x) & ~(MSIZE-1)))
63 #define	mtocl(x)	(((uintptr_t)(x) - (uintptr_t)mbutl) >> MCLSHIFT)
64 #define	cltom(x)	((caddr_t)((uintptr_t)mbutl + \
65 			    ((uintptr_t)(x) << MCLSHIFT)))
66 
67 /* header at beginning of each mbuf: */
68 struct m_hdr {
69 	struct	mbuf *mh_next;		/* next buffer in chain */
70 	struct	mbuf *mh_nextpkt;	/* next chain in queue/record */
71 	caddr_t	mh_data;		/* location of data */
72 	int	mh_len;			/* amount of data in this mbuf */
73 	short	mh_type;		/* type of data in this mbuf */
74 	short	mh_flags;		/* flags; see below */
75 };
76 
77 /* record/packet header in first mbuf of chain; valid if M_PKTHDR set */
78 struct	pkthdr {
79 	struct	ifnet *rcvif;		/* rcv interface */
80 	int	len;			/* total packet length */
81 
82 	/* variables for ip and tcp reassembly */
83 	void	*header;		/* pointer to packet header */
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 #define M_FRAG		0x0400	/* packet is a fragment of a larger packet */
131 
132 /* flags copied when copying m_pkthdr */
133 #define	M_COPYFLAGS	(M_PKTHDR|M_EOR|M_PROTO1|M_BCAST|M_MCAST)
134 
135 /* mbuf types */
136 #define	MT_FREE		0	/* should be on free list */
137 #define	MT_DATA		1	/* dynamic (data) allocation */
138 #define	MT_HEADER	2	/* packet header */
139 /*efine	MT_SOCKET	3*/	/* socket structure */
140 /*efine	MT_PCB		4*/	/* protocol control block */
141 /*efine	MT_RTABLE	5*/	/* routing tables */
142 /*efine	MT_HTABLE	6*/	/* IMP host tables */
143 /*efine	MT_ATABLE	7*/	/* address resolution tables */
144 #define	MT_SONAME	8	/* socket name */
145 /*efine	MT_SOOPTS	10*/	/* socket options */
146 #define	MT_FTABLE	11	/* fragment reassembly header */
147 /*efine	MT_RIGHTS	12*/	/* access rights */
148 /*efine	MT_IFADDR	13*/	/* interface address */
149 #define MT_CONTROL	14	/* extra-data protocol message */
150 #define MT_OOBDATA	15	/* expedited data  */
151 
152 /* flags to m_get/MGET */
153 #define	M_DONTWAIT	1
154 #define	M_WAIT		0
155 
156 /* Freelists:
157  *
158  * Normal mbuf clusters are normally treated as character arrays
159  * after allocation, but use the first word of the buffer as a free list
160  * pointer while on the free list.
161  */
162 union mcluster {
163 	union	mcluster *mcl_next;
164 	char	mcl_buf[MCLBYTES];
165 };
166 
167 /*
168  * mbuf utility macros:
169  *
170  *	MBUFLOCK(code)
171  * prevents a section of code from from being interrupted by network
172  * drivers.
173  */
174 #define	MBUFLOCK(code) \
175 	do { int ms = splimp(); \
176 	  { code } \
177 	  splx(ms); \
178 	} while(0)
179 
180 /*
181  * mbuf allocation/deallocation macros:
182  *
183  *	MGET(struct mbuf *m, int how, int type)
184  * allocates an mbuf and initializes it to contain internal data.
185  *
186  *	MGETHDR(struct mbuf *m, int how, int type)
187  * allocates an mbuf and initializes it to contain a packet header
188  * and internal data.
189  */
190 #define	MGET(m, how, type) { \
191 	  int _ms = splimp(); \
192 	  if (mmbfree == 0) \
193 		(void)m_mballoc(1, (how)); \
194 	  if (((m) = mmbfree) != 0) { \
195 		mmbfree = (m)->m_next; \
196 		mbstat.m_mtypes[MT_FREE]--; \
197 		(m)->m_type = (type); \
198 		mbstat.m_mtypes[type]++; \
199 		(m)->m_next = (struct mbuf *)NULL; \
200 		(m)->m_nextpkt = (struct mbuf *)NULL; \
201 		(m)->m_data = (m)->m_dat; \
202 		(m)->m_flags = 0; \
203 		splx(_ms); \
204 	} else { \
205 		splx(_ms); \
206 		(m) = m_retry((how), (type)); \
207 	} \
208 }
209 
210 #define	MGETHDR(m, how, type) { \
211 	  int _ms = splimp(); \
212 	  if (mmbfree == 0) \
213 		(void)m_mballoc(1, (how)); \
214 	  if (((m) = mmbfree) != 0) { \
215 		mmbfree = (m)->m_next; \
216 		mbstat.m_mtypes[MT_FREE]--; \
217 		(m)->m_type = (type); \
218 		mbstat.m_mtypes[type]++; \
219 		(m)->m_next = (struct mbuf *)NULL; \
220 		(m)->m_nextpkt = (struct mbuf *)NULL; \
221 		(m)->m_data = (m)->m_pktdat; \
222 		(m)->m_flags = M_PKTHDR; \
223 		splx(_ms); \
224 	} else { \
225 		splx(_ms); \
226 		(m) = m_retryhdr((how), (type)); \
227 	} \
228 }
229 
230 /*
231  * Mbuf cluster macros.
232  * MCLALLOC(caddr_t p, int how) allocates an mbuf cluster.
233  * MCLGET adds such clusters to a normal mbuf;
234  * the flag M_EXT is set upon success.
235  * MCLFREE releases a reference to a cluster allocated by MCLALLOC,
236  * freeing the cluster if the reference count has reached 0.
237  */
238 #define	MCLALLOC(p, how) \
239 	MBUFLOCK( \
240 	  if (mclfree == 0) \
241 		(void)m_clalloc(1, (how)); \
242 	  if (((p) = (caddr_t)mclfree) != 0) { \
243 		++mclrefcnt[mtocl(p)]; \
244 		mbstat.m_clfree--; \
245 		mclfree = ((union mcluster *)(p))->mcl_next; \
246 	  } \
247 	)
248 
249 #define	MCLGET(m, how) \
250 	{ MCLALLOC((m)->m_ext.ext_buf, (how)); \
251 	  if ((m)->m_ext.ext_buf != NULL) { \
252 		(m)->m_data = (m)->m_ext.ext_buf; \
253 		(m)->m_flags |= M_EXT; \
254 		(m)->m_ext.ext_free = NULL;  \
255 		(m)->m_ext.ext_ref = NULL;  \
256 		(m)->m_ext.ext_size = MCLBYTES;  \
257 	  } \
258 	}
259 
260 #define	MCLFREE(p) \
261 	MBUFLOCK ( \
262 	  if (--mclrefcnt[mtocl(p)] == 0) { \
263 		((union mcluster *)(p))->mcl_next = mclfree; \
264 		mclfree = (union mcluster *)(p); \
265 		mbstat.m_clfree++; \
266 	  } \
267 	)
268 
269 /*
270  * MFREE(struct mbuf *m, struct mbuf *n)
271  * Free a single mbuf and associated external storage.
272  * Place the successor, if any, in n.
273  */
274 #define	MFREE(m, n) \
275 	MBUFLOCK(  \
276 	  mbstat.m_mtypes[(m)->m_type]--; \
277 	  if ((m)->m_flags & M_EXT) { \
278 		if ((m)->m_ext.ext_free) \
279 			(*((m)->m_ext.ext_free))((m)->m_ext.ext_buf, \
280 			    (m)->m_ext.ext_size); \
281 		else { \
282 			char *p = (m)->m_ext.ext_buf; \
283 			if (--mclrefcnt[mtocl(p)] == 0) { \
284 				((union mcluster *)(p))->mcl_next = mclfree; \
285 				mclfree = (union mcluster *)(p); \
286 				mbstat.m_clfree++; \
287 			} \
288 		} \
289 	  } \
290 	  (n) = (m)->m_next; \
291 	  (m)->m_type = MT_FREE; \
292 	  mbstat.m_mtypes[MT_FREE]++; \
293 	  (m)->m_next = mmbfree; \
294 	  mmbfree = (m); \
295 	)
296 
297 /*
298  * Copy mbuf pkthdr from from to to.
299  * from must have M_PKTHDR set, and to must be empty.
300  */
301 #define	M_COPY_PKTHDR(to, from) { \
302 	(to)->m_pkthdr = (from)->m_pkthdr; \
303 	(to)->m_flags = (from)->m_flags & M_COPYFLAGS; \
304 	(to)->m_data = (to)->m_pktdat; \
305 }
306 
307 /*
308  * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place
309  * an object of the specified size at the end of the mbuf, longword aligned.
310  */
311 #define	M_ALIGN(m, len) \
312 	{ (m)->m_data += (MLEN - (len)) &~ (sizeof(long) - 1); }
313 /*
314  * As above, for mbufs allocated with m_gethdr/MGETHDR
315  * or initialized by M_COPY_PKTHDR.
316  */
317 #define	MH_ALIGN(m, len) \
318 	{ (m)->m_data += (MHLEN - (len)) &~ (sizeof(long) - 1); }
319 
320 /*
321  * Compute the amount of space available
322  * before the current start of data in an mbuf.
323  */
324 #define	M_LEADINGSPACE(m) \
325 	((m)->m_flags & M_EXT ? /* (m)->m_data - (m)->m_ext.ext_buf */ 0 : \
326 	    (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat : \
327 	    (m)->m_data - (m)->m_dat)
328 
329 /*
330  * Compute the amount of space available
331  * after the end of data in an mbuf.
332  */
333 #define	M_TRAILINGSPACE(m) \
334 	((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size - \
335 	    ((m)->m_data + (m)->m_len) : \
336 	    &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
337 
338 /*
339  * Arrange to prepend space of size plen to mbuf m.
340  * If a new mbuf must be allocated, how specifies whether to wait.
341  * If how is M_DONTWAIT and allocation fails, the original mbuf chain
342  * is freed and m is set to NULL.
343  */
344 #define	M_PREPEND(m, plen, how) { \
345 	if (M_LEADINGSPACE(m) >= (plen)) { \
346 		(m)->m_data -= (plen); \
347 		(m)->m_len += (plen); \
348 	} else \
349 		(m) = m_prepend((m), (plen), (how)); \
350 	if ((m) && (m)->m_flags & M_PKTHDR) \
351 		(m)->m_pkthdr.len += (plen); \
352 }
353 
354 /* change mbuf to new type */
355 #define MCHTYPE(m, t) do { \
356 	MBUFLOCK(mbstat.m_mtypes[(m)->m_type]--; mbstat.m_mtypes[t]++;); \
357 	(m)->m_type = t;\
358 } while(0)
359 
360 /* length to m_copy to copy all */
361 #define	M_COPYALL	1000000000
362 
363 /* compatibility with 4.3 */
364 #define  m_copy(m, o, l)	m_copym((m), (o), (l), M_DONTWAIT)
365 
366 /*
367  * Mbuf statistics.
368  */
369 struct mbstat {
370 	u_long	m_mbufs;	/* mbufs obtained from page pool */
371 	u_long	m_clusters;	/* clusters obtained from page pool */
372 	u_long	m_spare;	/* spare field */
373 	u_long	m_clfree;	/* free clusters */
374 	u_long	m_drops;	/* times failed to find space */
375 	u_long	m_wait;		/* times waited for space */
376 	u_long	m_drain;	/* times drained protocols for space */
377 	u_short	m_mtypes[256];	/* type specific mbuf allocations */
378 	u_long	m_mcfail;	/* times m_copym failed */
379 	u_long	m_mpfail;	/* times m_pullup failed */
380 	u_long	m_msize;	/* length of an mbuf */
381 	u_long	m_mclbytes;	/* length of an mbuf cluster */
382 	u_long	m_minclsize;	/* min length of data to allocate a cluster */
383 	u_long	m_mlen;		/* length of data in an mbuf */
384 	u_long	m_mhlen;	/* length of data in a header mbuf */
385 };
386 
387 #ifdef	KERNEL
388 extern struct mbuf *mbutl;		/* virtual address of mclusters */
389 extern char	*mclrefcnt;		/* cluster reference counts */
390 extern struct mbstat mbstat;
391 extern int	nmbclusters;
392 extern int	nmbufs;
393 extern int	nsfbufs;
394 extern struct mbuf *mmbfree;
395 extern union mcluster *mclfree;
396 extern int	max_linkhdr;		/* largest link-level header */
397 extern int	max_protohdr;		/* largest protocol header */
398 extern int	max_hdr;		/* largest link+protocol header */
399 extern int	max_datalen;		/* MHLEN - max_hdr */
400 
401 struct	mbuf *m_copym __P((struct mbuf *, int, int, int));
402 struct	mbuf *m_copypacket __P((struct mbuf *, int));
403 struct	mbuf *m_devget __P((char *, int, int, struct ifnet *,
404 			    void (*copy)(char *, caddr_t, u_int)));
405 struct	mbuf *m_free __P((struct mbuf *));
406 struct	mbuf *m_get __P((int, int));
407 struct	mbuf *m_getclr __P((int, int));
408 struct	mbuf *m_gethdr __P((int, int));
409 struct	mbuf *m_prepend __P((struct mbuf *,int,int));
410 struct	mbuf *m_pullup __P((struct mbuf *, int));
411 struct	mbuf *m_retry __P((int, int));
412 struct	mbuf *m_retryhdr __P((int, int));
413 struct	mbuf *m_split __P((struct mbuf *,int,int));
414 void	m_adj __P((struct mbuf *, int));
415 void	m_cat __P((struct mbuf *,struct mbuf *));
416 int	m_mballoc __P((int, int));
417 int	m_clalloc __P((int, int));
418 void	m_copyback __P((struct mbuf *, int, int, caddr_t));
419 void	m_copydata __P((struct mbuf *,int,int,caddr_t));
420 void	m_freem __P((struct mbuf *));
421 #endif /* KERNEL */
422 
423 #endif /* !_SYS_MBUF_H_ */
424