xref: /freebsd/sys/sys/mbuf.h (revision b856b51d149811d68ab9e72daa609f00e13c2ec3)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1988, 1993
5  *	The Regents of the University of California.
6  * 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  * $FreeBSD$
34  */
35 
36 #ifndef _SYS_MBUF_H_
37 #define	_SYS_MBUF_H_
38 
39 /* XXX: These includes suck. Sorry! */
40 #include <sys/queue.h>
41 #ifdef _KERNEL
42 #include <sys/systm.h>
43 #include <sys/refcount.h>
44 #include <vm/uma.h>
45 #ifdef WITNESS
46 #include <sys/lock.h>
47 #endif
48 #endif
49 
50 #ifdef _KERNEL
51 #include <sys/sdt.h>
52 
53 #define	MBUF_PROBE1(probe, arg0)					\
54 	SDT_PROBE1(sdt, , , probe, arg0)
55 #define	MBUF_PROBE2(probe, arg0, arg1)					\
56 	SDT_PROBE2(sdt, , , probe, arg0, arg1)
57 #define	MBUF_PROBE3(probe, arg0, arg1, arg2)				\
58 	SDT_PROBE3(sdt, , , probe, arg0, arg1, arg2)
59 #define	MBUF_PROBE4(probe, arg0, arg1, arg2, arg3)			\
60 	SDT_PROBE4(sdt, , , probe, arg0, arg1, arg2, arg3)
61 #define	MBUF_PROBE5(probe, arg0, arg1, arg2, arg3, arg4)		\
62 	SDT_PROBE5(sdt, , , probe, arg0, arg1, arg2, arg3, arg4)
63 
64 SDT_PROBE_DECLARE(sdt, , , m__init);
65 SDT_PROBE_DECLARE(sdt, , , m__gethdr);
66 SDT_PROBE_DECLARE(sdt, , , m__get);
67 SDT_PROBE_DECLARE(sdt, , , m__getcl);
68 SDT_PROBE_DECLARE(sdt, , , m__getjcl);
69 SDT_PROBE_DECLARE(sdt, , , m__clget);
70 SDT_PROBE_DECLARE(sdt, , , m__cljget);
71 SDT_PROBE_DECLARE(sdt, , , m__cljset);
72 SDT_PROBE_DECLARE(sdt, , , m__free);
73 SDT_PROBE_DECLARE(sdt, , , m__freem);
74 
75 #endif /* _KERNEL */
76 
77 /*
78  * Mbufs are of a single size, MSIZE (sys/param.h), which includes overhead.
79  * An mbuf may add a single "mbuf cluster" of size MCLBYTES (also in
80  * sys/param.h), which has no additional overhead and is used instead of the
81  * internal data area; this is done when at least MINCLSIZE of data must be
82  * stored.  Additionally, it is possible to allocate a separate buffer
83  * externally and attach it to the mbuf in a way similar to that of mbuf
84  * clusters.
85  *
86  * NB: These calculation do not take actual compiler-induced alignment and
87  * padding inside the complete struct mbuf into account.  Appropriate
88  * attention is required when changing members of struct mbuf.
89  *
90  * MLEN is data length in a normal mbuf.
91  * MHLEN is data length in an mbuf with pktheader.
92  * MINCLSIZE is a smallest amount of data that should be put into cluster.
93  *
94  * Compile-time assertions in uipc_mbuf.c test these values to ensure that
95  * they are sensible.
96  */
97 struct mbuf;
98 #define	MHSIZE		offsetof(struct mbuf, m_dat)
99 #define	MPKTHSIZE	offsetof(struct mbuf, m_pktdat)
100 #define	MLEN		((int)(MSIZE - MHSIZE))
101 #define	MHLEN		((int)(MSIZE - MPKTHSIZE))
102 #define	MINCLSIZE	(MHLEN + 1)
103 #define	M_NODOM		255
104 
105 #ifdef _KERNEL
106 /*-
107  * Macro for type conversion: convert mbuf pointer to data pointer of correct
108  * type:
109  *
110  * mtod(m, t)	-- Convert mbuf pointer to data pointer of correct type.
111  * mtodo(m, o) -- Same as above but with offset 'o' into data.
112  */
113 #define	mtod(m, t)	((t)((m)->m_data))
114 #define	mtodo(m, o)	((void *)(((m)->m_data) + (o)))
115 
116 /*
117  * Argument structure passed to UMA routines during mbuf and packet
118  * allocations.
119  */
120 struct mb_args {
121 	int	flags;	/* Flags for mbuf being allocated */
122 	short	type;	/* Type of mbuf being allocated */
123 };
124 #endif /* _KERNEL */
125 
126 /*
127  * Packet tag structure (see below for details).
128  */
129 struct m_tag {
130 	SLIST_ENTRY(m_tag)	m_tag_link;	/* List of packet tags */
131 	u_int16_t		m_tag_id;	/* Tag ID */
132 	u_int16_t		m_tag_len;	/* Length of data */
133 	u_int32_t		m_tag_cookie;	/* ABI/Module ID */
134 	void			(*m_tag_free)(struct m_tag *);
135 };
136 
137 /*
138  * Static network interface owned tag.
139  * Allocated through ifp->if_snd_tag_alloc().
140  */
141 struct m_snd_tag {
142 	struct ifnet *ifp;		/* network interface tag belongs to */
143 	volatile u_int refcount;
144 	u_int	type;			/* One of IF_SND_TAG_TYPE_*. */
145 };
146 
147 /*
148  * Record/packet header in first mbuf of chain; valid only if M_PKTHDR is set.
149  * Size ILP32: 48
150  *	 LP64: 56
151  * Compile-time assertions in uipc_mbuf.c test these values to ensure that
152  * they are correct.
153  */
154 struct pkthdr {
155 	union {
156 		struct m_snd_tag *snd_tag;	/* send tag, if any */
157 		struct ifnet	*rcvif;		/* rcv interface */
158 	};
159 	SLIST_HEAD(packet_tags, m_tag) tags; /* list of packet tags */
160 	int32_t		 len;		/* total packet length */
161 
162 	/* Layer crossing persistent information. */
163 	uint32_t	 flowid;	/* packet's 4-tuple system */
164 	uint32_t	 csum_flags;	/* checksum and offload features */
165 	uint16_t	 fibnum;	/* this packet should use this fib */
166 	uint8_t		 numa_domain;	/* NUMA domain of recvd pkt */
167 	uint8_t		 rsstype;	/* hash type */
168 	union {
169 		uint64_t	rcv_tstmp;	/* timestamp in ns */
170 		struct {
171 			uint8_t		 l2hlen;	/* layer 2 hdr len */
172 			uint8_t		 l3hlen;	/* layer 3 hdr len */
173 			uint8_t		 l4hlen;	/* layer 4 hdr len */
174 			uint8_t		 l5hlen;	/* layer 5 hdr len */
175 			uint8_t		 inner_l2hlen;
176 			uint8_t		 inner_l3hlen;
177 			uint8_t		 inner_l4hlen;
178 			uint8_t		 inner_l5hlen;
179 		};
180 	};
181 	union {
182 		uint8_t  eight[8];
183 		uint16_t sixteen[4];
184 		uint32_t thirtytwo[2];
185 		uint64_t sixtyfour[1];
186 		uintptr_t unintptr[1];
187 		void	*ptr;
188 	} PH_per;
189 
190 	/* Layer specific non-persistent local storage for reassembly, etc. */
191 	union {
192 		uint8_t  eight[8];
193 		uint16_t sixteen[4];
194 		uint32_t thirtytwo[2];
195 		uint64_t sixtyfour[1];
196 		uintptr_t unintptr[1];
197 		void 	*ptr;
198 	} PH_loc;
199 };
200 #define	ether_vtag	PH_per.sixteen[0]
201 #define	PH_vt		PH_per
202 #define	vt_nrecs	sixteen[0]	  /* mld and v6-ND */
203 #define	tso_segsz	PH_per.sixteen[1] /* inbound after LRO */
204 #define	lro_nsegs	tso_segsz	  /* inbound after LRO */
205 #define	csum_data	PH_per.thirtytwo[1] /* inbound from hardware up */
206 #define lro_len		PH_loc.sixteen[0] /* inbound during LRO (no reassembly) */
207 #define lro_csum	PH_loc.sixteen[1] /* inbound during LRO (no reassembly) */
208 #define lro_etype	PH_loc.sixteen[2] /* inbound during LRO (no reassembly) */
209 /* Note PH_loc is used during IP reassembly (all 8 bytes as a ptr) */
210 
211 /*
212  * TLS records for TLS 1.0-1.2 can have the following header lengths:
213  * - 5 (AES-CBC with implicit IV)
214  * - 21 (AES-CBC with explicit IV)
215  * - 13 (AES-GCM with 8 byte explicit IV)
216  */
217 #define	MBUF_PEXT_HDR_LEN	23
218 
219 /*
220  * TLS records for TLS 1.0-1.2 can have the following maximum trailer
221  * lengths:
222  * - 16 (AES-GCM)
223  * - 36 (AES-CBC with SHA1 and up to 16 bytes of padding)
224  * - 48 (AES-CBC with SHA2-256 and up to 16 bytes of padding)
225  * - 64 (AES-CBC with SHA2-384 and up to 16 bytes of padding)
226  */
227 #define	MBUF_PEXT_TRAIL_LEN	64
228 
229 #if defined(__LP64__)
230 #define MBUF_PEXT_MAX_PGS (40 / sizeof(vm_paddr_t))
231 #else
232 #define MBUF_PEXT_MAX_PGS (72 / sizeof(vm_paddr_t))
233 #endif
234 
235 #define	MBUF_PEXT_MAX_BYTES						\
236     (MBUF_PEXT_MAX_PGS * PAGE_SIZE + MBUF_PEXT_HDR_LEN + MBUF_PEXT_TRAIL_LEN)
237 
238 struct ktls_session;
239 struct socket;
240 
241 /*
242  * Description of external storage mapped into mbuf; valid only if M_EXT is
243  * set.
244  * Size ILP32: 28
245  *	 LP64: 48
246  * Compile-time assertions in uipc_mbuf.c test these values to ensure that
247  * they are correct.
248  */
249 typedef	void m_ext_free_t(struct mbuf *);
250 struct m_ext {
251 	union {
252 		/*
253 		 * If EXT_FLAG_EMBREF is set, then we use refcount in the
254 		 * mbuf, the 'ext_count' member.  Otherwise, we have a
255 		 * shadow copy and we use pointer 'ext_cnt'.  The original
256 		 * mbuf is responsible to carry the pointer to free routine
257 		 * and its arguments.  They aren't copied into shadows in
258 		 * mb_dupcl() to avoid dereferencing next cachelines.
259 		 */
260 		volatile u_int	 ext_count;
261 		volatile u_int	*ext_cnt;
262 	};
263 	uint32_t	 ext_size;	/* size of buffer, for ext_free */
264 	uint32_t	 ext_type:8,	/* type of external storage */
265 			 ext_flags:24;	/* external storage mbuf flags */
266 	union {
267 		struct {
268 			/*
269 			 * Regular M_EXT mbuf:
270 			 * o ext_buf always points to the external buffer.
271 			 * o ext_free (below) and two optional arguments
272 			 *   ext_arg1 and ext_arg2 store the free context for
273 			 *   the external storage.  They are set only in the
274 			 *   refcount carrying mbuf, the one with
275 			 *   EXT_FLAG_EMBREF flag, with exclusion for
276 			 *   EXT_EXTREF type, where the free context is copied
277 			 *   into all mbufs that use same external storage.
278 			 */
279 			char 	*ext_buf;	/* start of buffer */
280 #define	m_ext_copylen	offsetof(struct m_ext, ext_arg2)
281 			void	*ext_arg2;
282 		};
283 		struct {
284 			/*
285 			 * Multi-page M_EXTPG mbuf:
286 			 * o extpg_pa - page vector.
287 			 * o extpg_trail and extpg_hdr - TLS trailer and
288 			 *   header.
289 			 * Uses ext_free and may also use ext_arg1.
290 			 */
291 			vm_paddr_t	extpg_pa[MBUF_PEXT_MAX_PGS];
292 			char		extpg_trail[MBUF_PEXT_TRAIL_LEN];
293 			char		extpg_hdr[MBUF_PEXT_HDR_LEN];
294 			/* Pretend these 3 fields are part of mbuf itself. */
295 #define	m_epg_pa	m_ext.extpg_pa
296 #define	m_epg_trail	m_ext.extpg_trail
297 #define	m_epg_hdr	m_ext.extpg_hdr
298 #define	m_epg_ext_copylen	offsetof(struct m_ext, ext_free)
299 		};
300 	};
301 	/*
302 	 * Free method and optional argument pointer, both
303 	 * used by M_EXT and M_EXTPG.
304 	 */
305 	m_ext_free_t	*ext_free;
306 	void		*ext_arg1;
307 };
308 
309 /*
310  * The core of the mbuf object along with some shortcut defines for practical
311  * purposes.
312  */
313 struct mbuf {
314 	/*
315 	 * Header present at the beginning of every mbuf.
316 	 * Size ILP32: 24
317 	 *      LP64: 32
318 	 * Compile-time assertions in uipc_mbuf.c test these values to ensure
319 	 * that they are correct.
320 	 */
321 	union {	/* next buffer in chain */
322 		struct mbuf		*m_next;
323 		SLIST_ENTRY(mbuf)	m_slist;
324 		STAILQ_ENTRY(mbuf)	m_stailq;
325 	};
326 	union {	/* next chain in queue/record */
327 		struct mbuf		*m_nextpkt;
328 		SLIST_ENTRY(mbuf)	m_slistpkt;
329 		STAILQ_ENTRY(mbuf)	m_stailqpkt;
330 	};
331 	caddr_t		 m_data;	/* location of data */
332 	int32_t		 m_len;		/* amount of data in this mbuf */
333 	uint32_t	 m_type:8,	/* type of data in this mbuf */
334 			 m_flags:24;	/* flags; see below */
335 #if !defined(__LP64__)
336 	uint32_t	 m_pad;		/* pad for 64bit alignment */
337 #endif
338 
339 	/*
340 	 * A set of optional headers (packet header, external storage header)
341 	 * and internal data storage.  Historically, these arrays were sized
342 	 * to MHLEN (space left after a packet header) and MLEN (space left
343 	 * after only a regular mbuf header); they are now variable size in
344 	 * order to support future work on variable-size mbufs.
345 	 */
346 	union {
347 		struct {
348 			union {
349 				/* M_PKTHDR set. */
350 				struct pkthdr	m_pkthdr;
351 
352 				/* M_EXTPG set.
353 				 * Multi-page M_EXTPG mbuf has its meta data
354 				 * split between the below anonymous structure
355 				 * and m_ext.  It carries vector of pages,
356 				 * optional header and trailer char vectors
357 				 * and pointers to socket/TLS data.
358 				 */
359 #define	m_epg_startcopy		m_epg_npgs
360 #define	m_epg_endcopy		m_epg_stailq
361 				struct {
362 					/* Overall count of pages and count of
363 					 * pages with I/O pending. */
364 					uint8_t	m_epg_npgs;
365 					uint8_t	m_epg_nrdy;
366 					/* TLS header and trailer lengths.
367 					 * The data itself resides in m_ext. */
368 					uint8_t	m_epg_hdrlen;
369 					uint8_t	m_epg_trllen;
370 					/* Offset into 1st page and length of
371 					 * data in the last page. */
372 					uint16_t m_epg_1st_off;
373 					uint16_t m_epg_last_len;
374 					uint8_t	m_epg_flags;
375 #define	EPG_FLAG_ANON	0x1	/* Data can be encrypted in place. */
376 #define	EPG_FLAG_2FREE	0x2	/* Scheduled for free. */
377 					uint8_t	m_epg_record_type;
378 					uint8_t	__spare[2];
379 					int	m_epg_enc_cnt;
380 					struct ktls_session *m_epg_tls;
381 					struct socket	*m_epg_so;
382 					uint64_t	m_epg_seqno;
383 					STAILQ_ENTRY(mbuf) m_epg_stailq;
384 				};
385 			};
386 			union {
387 				/* M_EXT or M_EXTPG set. */
388 				struct m_ext	m_ext;
389 				/* M_PKTHDR set, neither M_EXT nor M_EXTPG. */
390 				char		m_pktdat[0];
391 			};
392 		};
393 		char	m_dat[0];			/* !M_PKTHDR, !M_EXT */
394 	};
395 };
396 
397 #ifdef _KERNEL
398 static inline int
399 m_epg_pagelen(const struct mbuf *m, int pidx, int pgoff)
400 {
401 
402 	KASSERT(pgoff == 0 || pidx == 0,
403 	    ("page %d with non-zero offset %d in %p", pidx, pgoff, m));
404 
405 	if (pidx == m->m_epg_npgs - 1) {
406 		return (m->m_epg_last_len);
407 	} else {
408 		return (PAGE_SIZE - pgoff);
409 	}
410 }
411 
412 #ifdef INVARIANTS
413 #define	MCHECK(ex, msg)	KASSERT((ex),				\
414 	    ("Multi page mbuf %p with " #msg " at %s:%d",	\
415 	    m, __FILE__, __LINE__))
416 /*
417  * NB: This expects a non-empty buffer (npgs > 0 and
418  * last_pg_len > 0).
419  */
420 #define	MBUF_EXT_PGS_ASSERT_SANITY(m)	do {				\
421 	MCHECK(m->m_epg_npgs > 0, "no valid pages");		\
422 	MCHECK(m->m_epg_npgs <= nitems(m->m_epg_pa),		\
423 	    "too many pages");						\
424 	MCHECK(m->m_epg_nrdy <= m->m_epg_npgs,			\
425 	    "too many ready pages");					\
426 	MCHECK(m->m_epg_1st_off < PAGE_SIZE,			\
427 		"too large page offset");				\
428 	MCHECK(m->m_epg_last_len > 0, "zero last page length");	\
429 	MCHECK(m->m_epg_last_len <= PAGE_SIZE,			\
430 	    "too large last page length");				\
431 	if (m->m_epg_npgs == 1)					\
432 		MCHECK(m->m_epg_1st_off +			\
433 		    m->m_epg_last_len <=	 PAGE_SIZE,		\
434 		    "single page too large");				\
435 	MCHECK(m->m_epg_hdrlen <= sizeof(m->m_epg_hdr),		\
436 	    "too large header length");					\
437 	MCHECK(m->m_epg_trllen <= sizeof(m->m_epg_trail),	\
438 	    "too large header length");					\
439 } while (0)
440 #else
441 #define	MBUF_EXT_PGS_ASSERT_SANITY(m)	do {} while (0);
442 #endif
443 #endif
444 
445 /*
446  * mbuf flags of global significance and layer crossing.
447  * Those of only protocol/layer specific significance are to be mapped
448  * to M_PROTO[1-11] and cleared at layer handoff boundaries.
449  * NB: Limited to the lower 24 bits.
450  */
451 #define	M_EXT		0x00000001 /* has associated external storage */
452 #define	M_PKTHDR	0x00000002 /* start of record */
453 #define	M_EOR		0x00000004 /* end of record */
454 #define	M_RDONLY	0x00000008 /* associated data is marked read-only */
455 #define	M_BCAST		0x00000010 /* send/received as link-level broadcast */
456 #define	M_MCAST		0x00000020 /* send/received as link-level multicast */
457 #define	M_PROMISC	0x00000040 /* packet was not for us */
458 #define	M_VLANTAG	0x00000080 /* ether_vtag is valid */
459 #define	M_EXTPG		0x00000100 /* has array of unmapped pages and TLS */
460 #define	M_NOFREE	0x00000200 /* do not free mbuf, embedded in cluster */
461 #define	M_TSTMP		0x00000400 /* rcv_tstmp field is valid */
462 #define	M_TSTMP_HPREC	0x00000800 /* rcv_tstmp is high-prec, typically
463 				      hw-stamped on port (useful for IEEE 1588
464 				      and 802.1AS) */
465 #define M_TSTMP_LRO	0x00001000 /* Time LRO pushed in pkt is valid in (PH_loc) */
466 
467 #define	M_PROTO1	0x00002000 /* protocol-specific */
468 #define	M_PROTO2	0x00004000 /* protocol-specific */
469 #define	M_PROTO3	0x00008000 /* protocol-specific */
470 #define	M_PROTO4	0x00010000 /* protocol-specific */
471 #define	M_PROTO5	0x00020000 /* protocol-specific */
472 #define	M_PROTO6	0x00040000 /* protocol-specific */
473 #define	M_PROTO7	0x00080000 /* protocol-specific */
474 #define	M_PROTO8	0x00100000 /* protocol-specific */
475 #define	M_PROTO9	0x00200000 /* protocol-specific */
476 #define	M_PROTO10	0x00400000 /* protocol-specific */
477 #define	M_PROTO11	0x00800000 /* protocol-specific */
478 
479 #define MB_DTOR_SKIP	0x1	/* don't pollute the cache by touching a freed mbuf */
480 
481 /*
482  * Flags to purge when crossing layers.
483  */
484 #define	M_PROTOFLAGS \
485     (M_PROTO1|M_PROTO2|M_PROTO3|M_PROTO4|M_PROTO5|M_PROTO6|M_PROTO7|M_PROTO8|\
486      M_PROTO9|M_PROTO10|M_PROTO11)
487 
488 /*
489  * Flags preserved when copying m_pkthdr.
490  */
491 #define M_COPYFLAGS \
492     (M_PKTHDR|M_EOR|M_RDONLY|M_BCAST|M_MCAST|M_PROMISC|M_VLANTAG|M_TSTMP| \
493      M_TSTMP_HPREC|M_TSTMP_LRO|M_PROTOFLAGS)
494 
495 /*
496  * Mbuf flag description for use with printf(9) %b identifier.
497  */
498 #define	M_FLAG_BITS \
499     "\20\1M_EXT\2M_PKTHDR\3M_EOR\4M_RDONLY\5M_BCAST\6M_MCAST" \
500     "\7M_PROMISC\10M_VLANTAG\11M_EXTPG\12M_NOFREE\13M_TSTMP\14M_TSTMP_HPREC\15M_TSTMP_LRO"
501 #define	M_FLAG_PROTOBITS \
502     "\16M_PROTO1\17M_PROTO2\20M_PROTO3\21M_PROTO4" \
503     "\22M_PROTO5\23M_PROTO6\24M_PROTO7\25M_PROTO8\26M_PROTO9" \
504     "\27M_PROTO10\28M_PROTO11"
505 #define	M_FLAG_PRINTF (M_FLAG_BITS M_FLAG_PROTOBITS)
506 
507 /*
508  * Network interface cards are able to hash protocol fields (such as IPv4
509  * addresses and TCP port numbers) classify packets into flows.  These flows
510  * can then be used to maintain ordering while delivering packets to the OS
511  * via parallel input queues, as well as to provide a stateless affinity
512  * model.  NIC drivers can pass up the hash via m->m_pkthdr.flowid, and set
513  * m_flag fields to indicate how the hash should be interpreted by the
514  * network stack.
515  *
516  * Most NICs support RSS, which provides ordering and explicit affinity, and
517  * use the hash m_flag bits to indicate what header fields were covered by
518  * the hash.  M_HASHTYPE_OPAQUE and M_HASHTYPE_OPAQUE_HASH can be set by non-
519  * RSS cards or configurations that provide an opaque flow identifier, allowing
520  * for ordering and distribution without explicit affinity.  Additionally,
521  * M_HASHTYPE_OPAQUE_HASH indicates that the flow identifier has hash
522  * properties.
523  *
524  * The meaning of the IPV6_EX suffix:
525  * "o  Home address from the home address option in the IPv6 destination
526  *     options header.  If the extension header is not present, use the Source
527  *     IPv6 Address.
528  *  o  IPv6 address that is contained in the Routing-Header-Type-2 from the
529  *     associated extension header.  If the extension header is not present,
530  *     use the Destination IPv6 Address."
531  * Quoted from:
532  * https://docs.microsoft.com/en-us/windows-hardware/drivers/network/rss-hashing-types#ndishashipv6ex
533  */
534 #define	M_HASHTYPE_HASHPROP		0x80	/* has hash properties */
535 #define	M_HASHTYPE_INNER		0x40	/* calculated from inner headers */
536 #define	M_HASHTYPE_HASH(t)		(M_HASHTYPE_HASHPROP | (t))
537 /* Microsoft RSS standard hash types */
538 #define	M_HASHTYPE_NONE			0
539 #define	M_HASHTYPE_RSS_IPV4		M_HASHTYPE_HASH(1) /* IPv4 2-tuple */
540 #define	M_HASHTYPE_RSS_TCP_IPV4		M_HASHTYPE_HASH(2) /* TCPv4 4-tuple */
541 #define	M_HASHTYPE_RSS_IPV6		M_HASHTYPE_HASH(3) /* IPv6 2-tuple */
542 #define	M_HASHTYPE_RSS_TCP_IPV6		M_HASHTYPE_HASH(4) /* TCPv6 4-tuple */
543 #define	M_HASHTYPE_RSS_IPV6_EX		M_HASHTYPE_HASH(5) /* IPv6 2-tuple +
544 							    * ext hdrs */
545 #define	M_HASHTYPE_RSS_TCP_IPV6_EX	M_HASHTYPE_HASH(6) /* TCPv6 4-tuple +
546 							    * ext hdrs */
547 #define	M_HASHTYPE_RSS_UDP_IPV4		M_HASHTYPE_HASH(7) /* IPv4 UDP 4-tuple*/
548 #define	M_HASHTYPE_RSS_UDP_IPV6		M_HASHTYPE_HASH(9) /* IPv6 UDP 4-tuple*/
549 #define	M_HASHTYPE_RSS_UDP_IPV6_EX	M_HASHTYPE_HASH(10)/* IPv6 UDP 4-tuple +
550 							    * ext hdrs */
551 
552 #define	M_HASHTYPE_OPAQUE		0x3f	/* ordering, not affinity */
553 #define	M_HASHTYPE_OPAQUE_HASH		M_HASHTYPE_HASH(M_HASHTYPE_OPAQUE)
554 						/* ordering+hash, not affinity*/
555 
556 #define	M_HASHTYPE_CLEAR(m)	((m)->m_pkthdr.rsstype = 0)
557 #define	M_HASHTYPE_GET(m)	((m)->m_pkthdr.rsstype & ~M_HASHTYPE_INNER)
558 #define	M_HASHTYPE_SET(m, v)	((m)->m_pkthdr.rsstype = (v))
559 #define	M_HASHTYPE_TEST(m, v)	(M_HASHTYPE_GET(m) == (v))
560 #define	M_HASHTYPE_ISHASH(m)	\
561     (((m)->m_pkthdr.rsstype & M_HASHTYPE_HASHPROP) != 0)
562 #define	M_HASHTYPE_SETINNER(m)	do {			\
563 	(m)->m_pkthdr.rsstype |= M_HASHTYPE_INNER;	\
564     } while (0)
565 
566 /*
567  * External mbuf storage buffer types.
568  */
569 #define	EXT_CLUSTER	1	/* mbuf cluster */
570 #define	EXT_SFBUF	2	/* sendfile(2)'s sf_buf */
571 #define	EXT_JUMBOP	3	/* jumbo cluster page sized */
572 #define	EXT_JUMBO9	4	/* jumbo cluster 9216 bytes */
573 #define	EXT_JUMBO16	5	/* jumbo cluster 16184 bytes */
574 #define	EXT_PACKET	6	/* mbuf+cluster from packet zone */
575 #define	EXT_MBUF	7	/* external mbuf reference */
576 #define	EXT_RXRING	8	/* data in NIC receive ring */
577 
578 #define	EXT_VENDOR1	224	/* for vendor-internal use */
579 #define	EXT_VENDOR2	225	/* for vendor-internal use */
580 #define	EXT_VENDOR3	226	/* for vendor-internal use */
581 #define	EXT_VENDOR4	227	/* for vendor-internal use */
582 
583 #define	EXT_EXP1	244	/* for experimental use */
584 #define	EXT_EXP2	245	/* for experimental use */
585 #define	EXT_EXP3	246	/* for experimental use */
586 #define	EXT_EXP4	247	/* for experimental use */
587 
588 #define	EXT_NET_DRV	252	/* custom ext_buf provided by net driver(s) */
589 #define	EXT_MOD_TYPE	253	/* custom module's ext_buf type */
590 #define	EXT_DISPOSABLE	254	/* can throw this buffer away w/page flipping */
591 #define	EXT_EXTREF	255	/* has externally maintained ext_cnt ptr */
592 
593 /*
594  * Flags for external mbuf buffer types.
595  * NB: limited to the lower 24 bits.
596  */
597 #define	EXT_FLAG_EMBREF		0x000001	/* embedded ext_count */
598 #define	EXT_FLAG_EXTREF		0x000002	/* external ext_cnt, notyet */
599 
600 #define	EXT_FLAG_NOFREE		0x000010	/* don't free mbuf to pool, notyet */
601 
602 #define	EXT_FLAG_VENDOR1	0x010000	/* These flags are vendor */
603 #define	EXT_FLAG_VENDOR2	0x020000	/* or submodule specific, */
604 #define	EXT_FLAG_VENDOR3	0x040000	/* not used by mbuf code. */
605 #define	EXT_FLAG_VENDOR4	0x080000	/* Set/read by submodule. */
606 
607 #define	EXT_FLAG_EXP1		0x100000	/* for experimental use */
608 #define	EXT_FLAG_EXP2		0x200000	/* for experimental use */
609 #define	EXT_FLAG_EXP3		0x400000	/* for experimental use */
610 #define	EXT_FLAG_EXP4		0x800000	/* for experimental use */
611 
612 /*
613  * EXT flag description for use with printf(9) %b identifier.
614  */
615 #define	EXT_FLAG_BITS \
616     "\20\1EXT_FLAG_EMBREF\2EXT_FLAG_EXTREF\5EXT_FLAG_NOFREE" \
617     "\21EXT_FLAG_VENDOR1\22EXT_FLAG_VENDOR2\23EXT_FLAG_VENDOR3" \
618     "\24EXT_FLAG_VENDOR4\25EXT_FLAG_EXP1\26EXT_FLAG_EXP2\27EXT_FLAG_EXP3" \
619     "\30EXT_FLAG_EXP4"
620 
621 /*
622  * Flags indicating checksum, segmentation and other offload work to be
623  * done, or already done, by hardware or lower layers.  It is split into
624  * separate inbound and outbound flags.
625  *
626  * Outbound flags that are set by upper protocol layers requesting lower
627  * layers, or ideally the hardware, to perform these offloading tasks.
628  * For outbound packets this field and its flags can be directly tested
629  * against ifnet if_hwassist.  Note that the outbound and the inbound flags do
630  * not collide right now but they could be allowed to (as long as the flags are
631  * scrubbed appropriately when the direction of an mbuf changes).  CSUM_BITS
632  * would also have to split into CSUM_BITS_TX and CSUM_BITS_RX.
633  *
634  * CSUM_INNER_<x> is the same as CSUM_<x> but it applies to the inner frame.
635  * The CSUM_ENCAP_<x> bits identify the outer encapsulation.
636  */
637 #define	CSUM_IP			0x00000001	/* IP header checksum offload */
638 #define	CSUM_IP_UDP		0x00000002	/* UDP checksum offload */
639 #define	CSUM_IP_TCP		0x00000004	/* TCP checksum offload */
640 #define	CSUM_IP_SCTP		0x00000008	/* SCTP checksum offload */
641 #define	CSUM_IP_TSO		0x00000010	/* TCP segmentation offload */
642 #define	CSUM_IP_ISCSI		0x00000020	/* iSCSI checksum offload */
643 
644 #define	CSUM_INNER_IP6_UDP	0x00000040
645 #define	CSUM_INNER_IP6_TCP	0x00000080
646 #define	CSUM_INNER_IP6_TSO	0x00000100
647 #define	CSUM_IP6_UDP		0x00000200	/* UDP checksum offload */
648 #define	CSUM_IP6_TCP		0x00000400	/* TCP checksum offload */
649 #define	CSUM_IP6_SCTP		0x00000800	/* SCTP checksum offload */
650 #define	CSUM_IP6_TSO		0x00001000	/* TCP segmentation offload */
651 #define	CSUM_IP6_ISCSI		0x00002000	/* iSCSI checksum offload */
652 
653 #define	CSUM_INNER_IP		0x00004000
654 #define	CSUM_INNER_IP_UDP	0x00008000
655 #define	CSUM_INNER_IP_TCP	0x00010000
656 #define	CSUM_INNER_IP_TSO	0x00020000
657 
658 #define	CSUM_ENCAP_VXLAN	0x00040000	/* VXLAN outer encapsulation */
659 #define	CSUM_ENCAP_RSVD1	0x00080000
660 
661 /* Inbound checksum support where the checksum was verified by hardware. */
662 #define	CSUM_INNER_L3_CALC	0x00100000
663 #define	CSUM_INNER_L3_VALID	0x00200000
664 #define	CSUM_INNER_L4_CALC	0x00400000
665 #define	CSUM_INNER_L4_VALID	0x00800000
666 #define	CSUM_L3_CALC		0x01000000	/* calculated layer 3 csum */
667 #define	CSUM_L3_VALID		0x02000000	/* checksum is correct */
668 #define	CSUM_L4_CALC		0x04000000	/* calculated layer 4 csum */
669 #define	CSUM_L4_VALID		0x08000000	/* checksum is correct */
670 #define	CSUM_L5_CALC		0x10000000	/* calculated layer 5 csum */
671 #define	CSUM_L5_VALID		0x20000000	/* checksum is correct */
672 #define	CSUM_COALESCED		0x40000000	/* contains merged segments */
673 
674 #define	CSUM_SND_TAG		0x80000000	/* Packet header has send tag */
675 
676 #define CSUM_FLAGS_TX (CSUM_IP | CSUM_IP_UDP | CSUM_IP_TCP | CSUM_IP_SCTP | \
677     CSUM_IP_TSO | CSUM_IP_ISCSI | CSUM_INNER_IP6_UDP | CSUM_INNER_IP6_TCP | \
678     CSUM_INNER_IP6_TSO | CSUM_IP6_UDP | CSUM_IP6_TCP | CSUM_IP6_SCTP | \
679     CSUM_IP6_TSO | CSUM_IP6_ISCSI | CSUM_INNER_IP | CSUM_INNER_IP_UDP | \
680     CSUM_INNER_IP_TCP | CSUM_INNER_IP_TSO | CSUM_ENCAP_VXLAN | \
681     CSUM_ENCAP_RSVD1 | CSUM_SND_TAG)
682 
683 #define CSUM_FLAGS_RX (CSUM_INNER_L3_CALC | CSUM_INNER_L3_VALID | \
684     CSUM_INNER_L4_CALC | CSUM_INNER_L4_VALID | CSUM_L3_CALC | CSUM_L3_VALID | \
685     CSUM_L4_CALC | CSUM_L4_VALID | CSUM_L5_CALC | CSUM_L5_VALID | \
686     CSUM_COALESCED)
687 
688 /*
689  * CSUM flag description for use with printf(9) %b identifier.
690  */
691 #define	CSUM_BITS \
692     "\20\1CSUM_IP\2CSUM_IP_UDP\3CSUM_IP_TCP\4CSUM_IP_SCTP\5CSUM_IP_TSO" \
693     "\6CSUM_IP_ISCSI\7CSUM_INNER_IP6_UDP\10CSUM_INNER_IP6_TCP" \
694     "\11CSUM_INNER_IP6_TSO\12CSUM_IP6_UDP\13CSUM_IP6_TCP\14CSUM_IP6_SCTP" \
695     "\15CSUM_IP6_TSO\16CSUM_IP6_ISCSI\17CSUM_INNER_IP\20CSUM_INNER_IP_UDP" \
696     "\21CSUM_INNER_IP_TCP\22CSUM_INNER_IP_TSO\23CSUM_ENCAP_VXLAN" \
697     "\24CSUM_ENCAP_RSVD1\25CSUM_INNER_L3_CALC\26CSUM_INNER_L3_VALID" \
698     "\27CSUM_INNER_L4_CALC\30CSUM_INNER_L4_VALID\31CSUM_L3_CALC" \
699     "\32CSUM_L3_VALID\33CSUM_L4_CALC\34CSUM_L4_VALID\35CSUM_L5_CALC" \
700     "\36CSUM_L5_VALID\37CSUM_COALESCED\40CSUM_SND_TAG"
701 
702 /* CSUM flags compatibility mappings. */
703 #define	CSUM_IP_CHECKED		CSUM_L3_CALC
704 #define	CSUM_IP_VALID		CSUM_L3_VALID
705 #define	CSUM_DATA_VALID		CSUM_L4_VALID
706 #define	CSUM_PSEUDO_HDR		CSUM_L4_CALC
707 #define	CSUM_SCTP_VALID		CSUM_L4_VALID
708 #define	CSUM_DELAY_DATA		(CSUM_TCP|CSUM_UDP)
709 #define	CSUM_DELAY_IP		CSUM_IP		/* Only v4, no v6 IP hdr csum */
710 #define	CSUM_DELAY_DATA_IPV6	(CSUM_TCP_IPV6|CSUM_UDP_IPV6)
711 #define	CSUM_DATA_VALID_IPV6	CSUM_DATA_VALID
712 #define	CSUM_TCP		CSUM_IP_TCP
713 #define	CSUM_UDP		CSUM_IP_UDP
714 #define	CSUM_SCTP		CSUM_IP_SCTP
715 #define	CSUM_TSO		(CSUM_IP_TSO|CSUM_IP6_TSO)
716 #define	CSUM_INNER_TSO		(CSUM_INNER_IP_TSO|CSUM_INNER_IP6_TSO)
717 #define	CSUM_UDP_IPV6		CSUM_IP6_UDP
718 #define	CSUM_TCP_IPV6		CSUM_IP6_TCP
719 #define	CSUM_SCTP_IPV6		CSUM_IP6_SCTP
720 
721 /*
722  * mbuf types describing the content of the mbuf (including external storage).
723  */
724 #define	MT_NOTMBUF	0	/* USED INTERNALLY ONLY! Object is not mbuf */
725 #define	MT_DATA		1	/* dynamic (data) allocation */
726 #define	MT_HEADER	MT_DATA	/* packet header, use M_PKTHDR instead */
727 
728 #define	MT_VENDOR1	4	/* for vendor-internal use */
729 #define	MT_VENDOR2	5	/* for vendor-internal use */
730 #define	MT_VENDOR3	6	/* for vendor-internal use */
731 #define	MT_VENDOR4	7	/* for vendor-internal use */
732 
733 #define	MT_SONAME	8	/* socket name */
734 
735 #define	MT_EXP1		9	/* for experimental use */
736 #define	MT_EXP2		10	/* for experimental use */
737 #define	MT_EXP3		11	/* for experimental use */
738 #define	MT_EXP4		12	/* for experimental use */
739 
740 #define	MT_CONTROL	14	/* extra-data protocol message */
741 #define	MT_EXTCONTROL	15	/* control message with externalized contents */
742 #define	MT_OOBDATA	16	/* expedited data  */
743 
744 #define	MT_NOINIT	255	/* Not a type but a flag to allocate
745 				   a non-initialized mbuf */
746 
747 /*
748  * String names of mbuf-related UMA(9) and malloc(9) types.  Exposed to
749  * !_KERNEL so that monitoring tools can look up the zones with
750  * libmemstat(3).
751  */
752 #define	MBUF_MEM_NAME		"mbuf"
753 #define	MBUF_CLUSTER_MEM_NAME	"mbuf_cluster"
754 #define	MBUF_PACKET_MEM_NAME	"mbuf_packet"
755 #define	MBUF_JUMBOP_MEM_NAME	"mbuf_jumbo_page"
756 #define	MBUF_JUMBO9_MEM_NAME	"mbuf_jumbo_9k"
757 #define	MBUF_JUMBO16_MEM_NAME	"mbuf_jumbo_16k"
758 #define	MBUF_TAG_MEM_NAME	"mbuf_tag"
759 #define	MBUF_EXTREFCNT_MEM_NAME	"mbuf_ext_refcnt"
760 #define	MBUF_EXTPGS_MEM_NAME	"mbuf_extpgs"
761 
762 #ifdef _KERNEL
763 union if_snd_tag_alloc_params;
764 
765 #ifdef WITNESS
766 #define	MBUF_CHECKSLEEP(how) do {					\
767 	if (how == M_WAITOK)						\
768 		WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,		\
769 		    "Sleeping in \"%s\"", __func__);			\
770 } while (0)
771 #else
772 #define	MBUF_CHECKSLEEP(how)
773 #endif
774 
775 /*
776  * Network buffer allocation API
777  *
778  * The rest of it is defined in kern/kern_mbuf.c
779  */
780 extern uma_zone_t	zone_mbuf;
781 extern uma_zone_t	zone_clust;
782 extern uma_zone_t	zone_pack;
783 extern uma_zone_t	zone_jumbop;
784 extern uma_zone_t	zone_jumbo9;
785 extern uma_zone_t	zone_jumbo16;
786 extern uma_zone_t	zone_extpgs;
787 
788 void		 mb_dupcl(struct mbuf *, struct mbuf *);
789 void		 mb_free_ext(struct mbuf *);
790 void		 mb_free_extpg(struct mbuf *);
791 void		 mb_free_mext_pgs(struct mbuf *);
792 struct mbuf	*mb_alloc_ext_pgs(int, m_ext_free_t);
793 struct mbuf	*mb_alloc_ext_plus_pages(int, int);
794 struct mbuf	*mb_mapped_to_unmapped(struct mbuf *, int, int, int,
795 		    struct mbuf **);
796 int		 mb_unmapped_compress(struct mbuf *m);
797 struct mbuf 	*mb_unmapped_to_ext(struct mbuf *m);
798 void		 mb_free_notready(struct mbuf *m, int count);
799 void		 m_adj(struct mbuf *, int);
800 void		 m_adj_decap(struct mbuf *, int);
801 int		 m_apply(struct mbuf *, int, int,
802 		    int (*)(void *, void *, u_int), void *);
803 int		 m_append(struct mbuf *, int, c_caddr_t);
804 void		 m_cat(struct mbuf *, struct mbuf *);
805 void		 m_catpkt(struct mbuf *, struct mbuf *);
806 int		 m_clget(struct mbuf *m, int how);
807 void 		*m_cljget(struct mbuf *m, int how, int size);
808 struct mbuf	*m_collapse(struct mbuf *, int, int);
809 void		 m_copyback(struct mbuf *, int, int, c_caddr_t);
810 void		 m_copydata(const struct mbuf *, int, int, caddr_t);
811 struct mbuf	*m_copym(struct mbuf *, int, int, int);
812 struct mbuf	*m_copypacket(struct mbuf *, int);
813 void		 m_copy_pkthdr(struct mbuf *, struct mbuf *);
814 struct mbuf	*m_copyup(struct mbuf *, int, int);
815 struct mbuf	*m_defrag(struct mbuf *, int);
816 void		 m_demote_pkthdr(struct mbuf *);
817 void		 m_demote(struct mbuf *, int, int);
818 struct mbuf	*m_devget(char *, int, int, struct ifnet *,
819 		    void (*)(char *, caddr_t, u_int));
820 void		 m_dispose_extcontrolm(struct mbuf *m);
821 struct mbuf	*m_dup(const struct mbuf *, int);
822 int		 m_dup_pkthdr(struct mbuf *, const struct mbuf *, int);
823 void		 m_extadd(struct mbuf *, char *, u_int, m_ext_free_t,
824 		    void *, void *, int, int);
825 u_int		 m_fixhdr(struct mbuf *);
826 struct mbuf	*m_fragment(struct mbuf *, int, int);
827 void		 m_freem(struct mbuf *);
828 struct mbuf	*m_get2(int, int, short, int);
829 struct mbuf	*m_getjcl(int, short, int, int);
830 struct mbuf	*m_getm2(struct mbuf *, int, int, short, int);
831 struct mbuf	*m_getptr(struct mbuf *, int, int *);
832 u_int		 m_length(struct mbuf *, struct mbuf **);
833 int		 m_mbuftouio(struct uio *, const struct mbuf *, int);
834 int		 m_unmappedtouio(const struct mbuf *, int, struct uio *, int);
835 void		 m_move_pkthdr(struct mbuf *, struct mbuf *);
836 int		 m_pkthdr_init(struct mbuf *, int);
837 struct mbuf	*m_prepend(struct mbuf *, int, int);
838 void		 m_print(const struct mbuf *, int);
839 struct mbuf	*m_pulldown(struct mbuf *, int, int, int *);
840 struct mbuf	*m_pullup(struct mbuf *, int);
841 int		 m_sanity(struct mbuf *, int);
842 struct mbuf	*m_split(struct mbuf *, int, int);
843 struct mbuf	*m_uiotombuf(struct uio *, int, int, int, int);
844 struct mbuf	*m_unshare(struct mbuf *, int);
845 int		 m_snd_tag_alloc(struct ifnet *,
846 		    union if_snd_tag_alloc_params *, struct m_snd_tag **);
847 void		 m_snd_tag_init(struct m_snd_tag *, struct ifnet *, u_int);
848 void		 m_snd_tag_destroy(struct m_snd_tag *);
849 
850 static __inline int
851 m_gettype(int size)
852 {
853 	int type;
854 
855 	switch (size) {
856 	case MSIZE:
857 		type = EXT_MBUF;
858 		break;
859 	case MCLBYTES:
860 		type = EXT_CLUSTER;
861 		break;
862 #if MJUMPAGESIZE != MCLBYTES
863 	case MJUMPAGESIZE:
864 		type = EXT_JUMBOP;
865 		break;
866 #endif
867 	case MJUM9BYTES:
868 		type = EXT_JUMBO9;
869 		break;
870 	case MJUM16BYTES:
871 		type = EXT_JUMBO16;
872 		break;
873 	default:
874 		panic("%s: invalid cluster size %d", __func__, size);
875 	}
876 
877 	return (type);
878 }
879 
880 /*
881  * Associated an external reference counted buffer with an mbuf.
882  */
883 static __inline void
884 m_extaddref(struct mbuf *m, char *buf, u_int size, u_int *ref_cnt,
885     m_ext_free_t freef, void *arg1, void *arg2)
886 {
887 
888 	KASSERT(ref_cnt != NULL, ("%s: ref_cnt not provided", __func__));
889 
890 	atomic_add_int(ref_cnt, 1);
891 	m->m_flags |= M_EXT;
892 	m->m_ext.ext_buf = buf;
893 	m->m_ext.ext_cnt = ref_cnt;
894 	m->m_data = m->m_ext.ext_buf;
895 	m->m_ext.ext_size = size;
896 	m->m_ext.ext_free = freef;
897 	m->m_ext.ext_arg1 = arg1;
898 	m->m_ext.ext_arg2 = arg2;
899 	m->m_ext.ext_type = EXT_EXTREF;
900 	m->m_ext.ext_flags = 0;
901 }
902 
903 static __inline uma_zone_t
904 m_getzone(int size)
905 {
906 	uma_zone_t zone;
907 
908 	switch (size) {
909 	case MCLBYTES:
910 		zone = zone_clust;
911 		break;
912 #if MJUMPAGESIZE != MCLBYTES
913 	case MJUMPAGESIZE:
914 		zone = zone_jumbop;
915 		break;
916 #endif
917 	case MJUM9BYTES:
918 		zone = zone_jumbo9;
919 		break;
920 	case MJUM16BYTES:
921 		zone = zone_jumbo16;
922 		break;
923 	default:
924 		panic("%s: invalid cluster size %d", __func__, size);
925 	}
926 
927 	return (zone);
928 }
929 
930 /*
931  * Initialize an mbuf with linear storage.
932  *
933  * Inline because the consumer text overhead will be roughly the same to
934  * initialize or call a function with this many parameters and M_PKTHDR
935  * should go away with constant propagation for !MGETHDR.
936  */
937 static __inline int
938 m_init(struct mbuf *m, int how, short type, int flags)
939 {
940 	int error;
941 
942 	m->m_next = NULL;
943 	m->m_nextpkt = NULL;
944 	m->m_data = m->m_dat;
945 	m->m_len = 0;
946 	m->m_flags = flags;
947 	m->m_type = type;
948 	if (flags & M_PKTHDR)
949 		error = m_pkthdr_init(m, how);
950 	else
951 		error = 0;
952 
953 	MBUF_PROBE5(m__init, m, how, type, flags, error);
954 	return (error);
955 }
956 
957 static __inline struct mbuf *
958 m_get(int how, short type)
959 {
960 	struct mbuf *m;
961 	struct mb_args args;
962 
963 	args.flags = 0;
964 	args.type = type;
965 	m = uma_zalloc_arg(zone_mbuf, &args, how);
966 	MBUF_PROBE3(m__get, how, type, m);
967 	return (m);
968 }
969 
970 static __inline struct mbuf *
971 m_gethdr(int how, short type)
972 {
973 	struct mbuf *m;
974 	struct mb_args args;
975 
976 	args.flags = M_PKTHDR;
977 	args.type = type;
978 	m = uma_zalloc_arg(zone_mbuf, &args, how);
979 	MBUF_PROBE3(m__gethdr, how, type, m);
980 	return (m);
981 }
982 
983 static __inline struct mbuf *
984 m_getcl(int how, short type, int flags)
985 {
986 	struct mbuf *m;
987 	struct mb_args args;
988 
989 	args.flags = flags;
990 	args.type = type;
991 	m = uma_zalloc_arg(zone_pack, &args, how);
992 	MBUF_PROBE4(m__getcl, how, type, flags, m);
993 	return (m);
994 }
995 
996 /*
997  * XXX: m_cljset() is a dangerous API.  One must attach only a new,
998  * unreferenced cluster to an mbuf(9).  It is not possible to assert
999  * that, so care can be taken only by users of the API.
1000  */
1001 static __inline void
1002 m_cljset(struct mbuf *m, void *cl, int type)
1003 {
1004 	int size;
1005 
1006 	switch (type) {
1007 	case EXT_CLUSTER:
1008 		size = MCLBYTES;
1009 		break;
1010 #if MJUMPAGESIZE != MCLBYTES
1011 	case EXT_JUMBOP:
1012 		size = MJUMPAGESIZE;
1013 		break;
1014 #endif
1015 	case EXT_JUMBO9:
1016 		size = MJUM9BYTES;
1017 		break;
1018 	case EXT_JUMBO16:
1019 		size = MJUM16BYTES;
1020 		break;
1021 	default:
1022 		panic("%s: unknown cluster type %d", __func__, type);
1023 		break;
1024 	}
1025 
1026 	m->m_data = m->m_ext.ext_buf = cl;
1027 	m->m_ext.ext_free = m->m_ext.ext_arg1 = m->m_ext.ext_arg2 = NULL;
1028 	m->m_ext.ext_size = size;
1029 	m->m_ext.ext_type = type;
1030 	m->m_ext.ext_flags = EXT_FLAG_EMBREF;
1031 	m->m_ext.ext_count = 1;
1032 	m->m_flags |= M_EXT;
1033 	MBUF_PROBE3(m__cljset, m, cl, type);
1034 }
1035 
1036 static __inline void
1037 m_chtype(struct mbuf *m, short new_type)
1038 {
1039 
1040 	m->m_type = new_type;
1041 }
1042 
1043 static __inline void
1044 m_clrprotoflags(struct mbuf *m)
1045 {
1046 
1047 	while (m) {
1048 		m->m_flags &= ~M_PROTOFLAGS;
1049 		m = m->m_next;
1050 	}
1051 }
1052 
1053 static __inline struct mbuf *
1054 m_last(struct mbuf *m)
1055 {
1056 
1057 	while (m->m_next)
1058 		m = m->m_next;
1059 	return (m);
1060 }
1061 
1062 static inline u_int
1063 m_extrefcnt(struct mbuf *m)
1064 {
1065 
1066 	KASSERT(m->m_flags & M_EXT, ("%s: M_EXT missing", __func__));
1067 
1068 	return ((m->m_ext.ext_flags & EXT_FLAG_EMBREF) ? m->m_ext.ext_count :
1069 	    *m->m_ext.ext_cnt);
1070 }
1071 
1072 /*
1073  * mbuf, cluster, and external object allocation macros (for compatibility
1074  * purposes).
1075  */
1076 #define	M_MOVE_PKTHDR(to, from)	m_move_pkthdr((to), (from))
1077 #define	MGET(m, how, type)	((m) = m_get((how), (type)))
1078 #define	MGETHDR(m, how, type)	((m) = m_gethdr((how), (type)))
1079 #define	MCLGET(m, how)		m_clget((m), (how))
1080 #define	MEXTADD(m, buf, size, free, arg1, arg2, flags, type)		\
1081     m_extadd((m), (char *)(buf), (size), (free), (arg1), (arg2),	\
1082     (flags), (type))
1083 #define	m_getm(m, len, how, type)					\
1084     m_getm2((m), (len), (how), (type), M_PKTHDR)
1085 
1086 /*
1087  * Evaluate TRUE if it's safe to write to the mbuf m's data region (this can
1088  * be both the local data payload, or an external buffer area, depending on
1089  * whether M_EXT is set).
1090  */
1091 #define	M_WRITABLE(m)	(((m)->m_flags & (M_RDONLY | M_EXTPG)) == 0 &&	\
1092 			 (!(((m)->m_flags & M_EXT)) ||			\
1093 			 (m_extrefcnt(m) == 1)))
1094 
1095 /* Check if the supplied mbuf has a packet header, or else panic. */
1096 #define	M_ASSERTPKTHDR(m)						\
1097 	KASSERT((m) != NULL && (m)->m_flags & M_PKTHDR,			\
1098 	    ("%s: no mbuf packet header!", __func__))
1099 
1100 /* Check if mbuf is multipage. */
1101 #define M_ASSERTEXTPG(m)						\
1102 	KASSERT(((m)->m_flags & (M_EXTPG|M_PKTHDR)) == M_EXTPG,		\
1103 	    ("%s: m %p is not multipage!", __func__, m))
1104 
1105 /*
1106  * Ensure that the supplied mbuf is a valid, non-free mbuf.
1107  *
1108  * XXX: Broken at the moment.  Need some UMA magic to make it work again.
1109  */
1110 #define	M_ASSERTVALID(m)						\
1111 	KASSERT((((struct mbuf *)m)->m_flags & 0) == 0,			\
1112 	    ("%s: attempted use of a free mbuf!", __func__))
1113 
1114 /*
1115  * Return the address of the start of the buffer associated with an mbuf,
1116  * handling external storage, packet-header mbufs, and regular data mbufs.
1117  */
1118 #define	M_START(m)							\
1119 	(((m)->m_flags & M_EXTPG) ? NULL :				\
1120 	 ((m)->m_flags & M_EXT) ? (m)->m_ext.ext_buf :			\
1121 	 ((m)->m_flags & M_PKTHDR) ? &(m)->m_pktdat[0] :		\
1122 	 &(m)->m_dat[0])
1123 
1124 /*
1125  * Return the size of the buffer associated with an mbuf, handling external
1126  * storage, packet-header mbufs, and regular data mbufs.
1127  */
1128 #define	M_SIZE(m)							\
1129 	(((m)->m_flags & M_EXT) ? (m)->m_ext.ext_size :			\
1130 	 ((m)->m_flags & M_PKTHDR) ? MHLEN :				\
1131 	 MLEN)
1132 
1133 /*
1134  * Set the m_data pointer of a newly allocated mbuf to place an object of the
1135  * specified size at the end of the mbuf, longword aligned.
1136  *
1137  * NB: Historically, we had M_ALIGN(), MH_ALIGN(), and MEXT_ALIGN() as
1138  * separate macros, each asserting that it was called at the proper moment.
1139  * This required callers to themselves test the storage type and call the
1140  * right one.  Rather than require callers to be aware of those layout
1141  * decisions, we centralize here.
1142  */
1143 static __inline void
1144 m_align(struct mbuf *m, int len)
1145 {
1146 #ifdef INVARIANTS
1147 	const char *msg = "%s: not a virgin mbuf";
1148 #endif
1149 	int adjust;
1150 
1151 	KASSERT(m->m_data == M_START(m), (msg, __func__));
1152 
1153 	adjust = M_SIZE(m) - len;
1154 	m->m_data += adjust &~ (sizeof(long)-1);
1155 }
1156 
1157 #define	M_ALIGN(m, len)		m_align(m, len)
1158 #define	MH_ALIGN(m, len)	m_align(m, len)
1159 #define	MEXT_ALIGN(m, len)	m_align(m, len)
1160 
1161 /*
1162  * Compute the amount of space available before the current start of data in
1163  * an mbuf.
1164  *
1165  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
1166  * of checking writability of the mbuf data area rests solely with the caller.
1167  *
1168  * NB: In previous versions, M_LEADINGSPACE() would only check M_WRITABLE()
1169  * for mbufs with external storage.  We now allow mbuf-embedded data to be
1170  * read-only as well.
1171  */
1172 #define	M_LEADINGSPACE(m)						\
1173 	(M_WRITABLE(m) ? ((m)->m_data - M_START(m)) : 0)
1174 
1175 /*
1176  * Compute the amount of space available after the end of data in an mbuf.
1177  *
1178  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
1179  * of checking writability of the mbuf data area rests solely with the caller.
1180  *
1181  * NB: In previous versions, M_TRAILINGSPACE() would only check M_WRITABLE()
1182  * for mbufs with external storage.  We now allow mbuf-embedded data to be
1183  * read-only as well.
1184  */
1185 #define	M_TRAILINGSPACE(m)						\
1186 	(M_WRITABLE(m) ?						\
1187 	    ((M_START(m) + M_SIZE(m)) - ((m)->m_data + (m)->m_len)) : 0)
1188 
1189 /*
1190  * Arrange to prepend space of size plen to mbuf m.  If a new mbuf must be
1191  * allocated, how specifies whether to wait.  If the allocation fails, the
1192  * original mbuf chain is freed and m is set to NULL.
1193  */
1194 #define	M_PREPEND(m, plen, how) do {					\
1195 	struct mbuf **_mmp = &(m);					\
1196 	struct mbuf *_mm = *_mmp;					\
1197 	int _mplen = (plen);						\
1198 	int __mhow = (how);						\
1199 									\
1200 	MBUF_CHECKSLEEP(how);						\
1201 	if (M_LEADINGSPACE(_mm) >= _mplen) {				\
1202 		_mm->m_data -= _mplen;					\
1203 		_mm->m_len += _mplen;					\
1204 	} else								\
1205 		_mm = m_prepend(_mm, _mplen, __mhow);			\
1206 	if (_mm != NULL && _mm->m_flags & M_PKTHDR)			\
1207 		_mm->m_pkthdr.len += _mplen;				\
1208 	*_mmp = _mm;							\
1209 } while (0)
1210 
1211 /*
1212  * Change mbuf to new type.  This is a relatively expensive operation and
1213  * should be avoided.
1214  */
1215 #define	MCHTYPE(m, t)	m_chtype((m), (t))
1216 
1217 /* Return the rcvif of a packet header. */
1218 static __inline struct ifnet *
1219 m_rcvif(struct mbuf *m)
1220 {
1221 
1222 	M_ASSERTPKTHDR(m);
1223 	if (m->m_pkthdr.csum_flags & CSUM_SND_TAG)
1224 		return (NULL);
1225 	return (m->m_pkthdr.rcvif);
1226 }
1227 
1228 /* Length to m_copy to copy all. */
1229 #define	M_COPYALL	1000000000
1230 
1231 extern int		max_datalen;	/* MHLEN - max_hdr */
1232 extern int		max_hdr;	/* Largest link + protocol header */
1233 extern int		max_linkhdr;	/* Largest link-level header */
1234 extern int		max_protohdr;	/* Largest protocol header */
1235 extern int		nmbclusters;	/* Maximum number of clusters */
1236 extern bool		mb_use_ext_pgs;	/* Use ext_pgs for sendfile */
1237 
1238 /*-
1239  * Network packets may have annotations attached by affixing a list of
1240  * "packet tags" to the pkthdr structure.  Packet tags are dynamically
1241  * allocated semi-opaque data structures that have a fixed header
1242  * (struct m_tag) that specifies the size of the memory block and a
1243  * <cookie,type> pair that identifies it.  The cookie is a 32-bit unique
1244  * unsigned value used to identify a module or ABI.  By convention this value
1245  * is chosen as the date+time that the module is created, expressed as the
1246  * number of seconds since the epoch (e.g., using date -u +'%s').  The type
1247  * value is an ABI/module-specific value that identifies a particular
1248  * annotation and is private to the module.  For compatibility with systems
1249  * like OpenBSD that define packet tags w/o an ABI/module cookie, the value
1250  * PACKET_ABI_COMPAT is used to implement m_tag_get and m_tag_find
1251  * compatibility shim functions and several tag types are defined below.
1252  * Users that do not require compatibility should use a private cookie value
1253  * so that packet tag-related definitions can be maintained privately.
1254  *
1255  * Note that the packet tag returned by m_tag_alloc has the default memory
1256  * alignment implemented by malloc.  To reference private data one can use a
1257  * construct like:
1258  *
1259  *	struct m_tag *mtag = m_tag_alloc(...);
1260  *	struct foo *p = (struct foo *)(mtag+1);
1261  *
1262  * if the alignment of struct m_tag is sufficient for referencing members of
1263  * struct foo.  Otherwise it is necessary to embed struct m_tag within the
1264  * private data structure to insure proper alignment; e.g.,
1265  *
1266  *	struct foo {
1267  *		struct m_tag	tag;
1268  *		...
1269  *	};
1270  *	struct foo *p = (struct foo *) m_tag_alloc(...);
1271  *	struct m_tag *mtag = &p->tag;
1272  */
1273 
1274 /*
1275  * Persistent tags stay with an mbuf until the mbuf is reclaimed.  Otherwise
1276  * tags are expected to ``vanish'' when they pass through a network
1277  * interface.  For most interfaces this happens normally as the tags are
1278  * reclaimed when the mbuf is free'd.  However in some special cases
1279  * reclaiming must be done manually.  An example is packets that pass through
1280  * the loopback interface.  Also, one must be careful to do this when
1281  * ``turning around'' packets (e.g., icmp_reflect).
1282  *
1283  * To mark a tag persistent bit-or this flag in when defining the tag id.
1284  * The tag will then be treated as described above.
1285  */
1286 #define	MTAG_PERSISTENT				0x800
1287 
1288 #define	PACKET_TAG_NONE				0  /* Nadda */
1289 
1290 /* Packet tags for use with PACKET_ABI_COMPAT. */
1291 #define	PACKET_TAG_IPSEC_IN_DONE		1  /* IPsec applied, in */
1292 #define	PACKET_TAG_IPSEC_OUT_DONE		2  /* IPsec applied, out */
1293 #define	PACKET_TAG_IPSEC_IN_CRYPTO_DONE		3  /* NIC IPsec crypto done */
1294 #define	PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED	4  /* NIC IPsec crypto req'ed */
1295 #define	PACKET_TAG_IPSEC_IN_COULD_DO_CRYPTO	5  /* NIC notifies IPsec */
1296 #define	PACKET_TAG_IPSEC_PENDING_TDB		6  /* Reminder to do IPsec */
1297 #define	PACKET_TAG_BRIDGE			7  /* Bridge processing done */
1298 #define	PACKET_TAG_GIF				8  /* GIF processing done */
1299 #define	PACKET_TAG_GRE				9  /* GRE processing done */
1300 #define	PACKET_TAG_IN_PACKET_CHECKSUM		10 /* NIC checksumming done */
1301 #define	PACKET_TAG_ENCAP			11 /* Encap.  processing */
1302 #define	PACKET_TAG_IPSEC_SOCKET			12 /* IPSEC socket ref */
1303 #define	PACKET_TAG_IPSEC_HISTORY		13 /* IPSEC history */
1304 #define	PACKET_TAG_IPV6_INPUT			14 /* IPV6 input processing */
1305 #define	PACKET_TAG_DUMMYNET			15 /* dummynet info */
1306 #define	PACKET_TAG_DIVERT			17 /* divert info */
1307 #define	PACKET_TAG_IPFORWARD			18 /* ipforward info */
1308 #define	PACKET_TAG_MACLABEL	(19 | MTAG_PERSISTENT) /* MAC label */
1309 #define	PACKET_TAG_PF		(21 | MTAG_PERSISTENT) /* PF/ALTQ information */
1310 #define	PACKET_TAG_RTSOCKFAM			25 /* rtsock sa family */
1311 #define	PACKET_TAG_IPOPTIONS			27 /* Saved IP options */
1312 #define	PACKET_TAG_CARP				28 /* CARP info */
1313 #define	PACKET_TAG_IPSEC_NAT_T_PORTS		29 /* two uint16_t */
1314 #define	PACKET_TAG_ND_OUTGOING			30 /* ND outgoing */
1315 
1316 /* Specific cookies and tags. */
1317 
1318 /* Packet tag routines. */
1319 struct m_tag	*m_tag_alloc(u_int32_t, int, int, int);
1320 void		 m_tag_delete(struct mbuf *, struct m_tag *);
1321 void		 m_tag_delete_chain(struct mbuf *, struct m_tag *);
1322 void		 m_tag_free_default(struct m_tag *);
1323 struct m_tag	*m_tag_locate(struct mbuf *, u_int32_t, int, struct m_tag *);
1324 struct m_tag	*m_tag_copy(struct m_tag *, int);
1325 int		 m_tag_copy_chain(struct mbuf *, const struct mbuf *, int);
1326 void		 m_tag_delete_nonpersistent(struct mbuf *);
1327 
1328 /*
1329  * Initialize the list of tags associated with an mbuf.
1330  */
1331 static __inline void
1332 m_tag_init(struct mbuf *m)
1333 {
1334 
1335 	SLIST_INIT(&m->m_pkthdr.tags);
1336 }
1337 
1338 /*
1339  * Set up the contents of a tag.  Note that this does not fill in the free
1340  * method; the caller is expected to do that.
1341  *
1342  * XXX probably should be called m_tag_init, but that was already taken.
1343  */
1344 static __inline void
1345 m_tag_setup(struct m_tag *t, u_int32_t cookie, int type, int len)
1346 {
1347 
1348 	t->m_tag_id = type;
1349 	t->m_tag_len = len;
1350 	t->m_tag_cookie = cookie;
1351 }
1352 
1353 /*
1354  * Reclaim resources associated with a tag.
1355  */
1356 static __inline void
1357 m_tag_free(struct m_tag *t)
1358 {
1359 
1360 	(*t->m_tag_free)(t);
1361 }
1362 
1363 /*
1364  * Return the first tag associated with an mbuf.
1365  */
1366 static __inline struct m_tag *
1367 m_tag_first(struct mbuf *m)
1368 {
1369 
1370 	return (SLIST_FIRST(&m->m_pkthdr.tags));
1371 }
1372 
1373 /*
1374  * Return the next tag in the list of tags associated with an mbuf.
1375  */
1376 static __inline struct m_tag *
1377 m_tag_next(struct mbuf *m __unused, struct m_tag *t)
1378 {
1379 
1380 	return (SLIST_NEXT(t, m_tag_link));
1381 }
1382 
1383 /*
1384  * Prepend a tag to the list of tags associated with an mbuf.
1385  */
1386 static __inline void
1387 m_tag_prepend(struct mbuf *m, struct m_tag *t)
1388 {
1389 
1390 	SLIST_INSERT_HEAD(&m->m_pkthdr.tags, t, m_tag_link);
1391 }
1392 
1393 /*
1394  * Unlink a tag from the list of tags associated with an mbuf.
1395  */
1396 static __inline void
1397 m_tag_unlink(struct mbuf *m, struct m_tag *t)
1398 {
1399 
1400 	SLIST_REMOVE(&m->m_pkthdr.tags, t, m_tag, m_tag_link);
1401 }
1402 
1403 /* These are for OpenBSD compatibility. */
1404 #define	MTAG_ABI_COMPAT		0		/* compatibility ABI */
1405 
1406 static __inline struct m_tag *
1407 m_tag_get(int type, int length, int wait)
1408 {
1409 	return (m_tag_alloc(MTAG_ABI_COMPAT, type, length, wait));
1410 }
1411 
1412 static __inline struct m_tag *
1413 m_tag_find(struct mbuf *m, int type, struct m_tag *start)
1414 {
1415 	return (SLIST_EMPTY(&m->m_pkthdr.tags) ? (struct m_tag *)NULL :
1416 	    m_tag_locate(m, MTAG_ABI_COMPAT, type, start));
1417 }
1418 
1419 static inline struct m_snd_tag *
1420 m_snd_tag_ref(struct m_snd_tag *mst)
1421 {
1422 
1423 	refcount_acquire(&mst->refcount);
1424 	return (mst);
1425 }
1426 
1427 static inline void
1428 m_snd_tag_rele(struct m_snd_tag *mst)
1429 {
1430 
1431 	if (refcount_release(&mst->refcount))
1432 		m_snd_tag_destroy(mst);
1433 }
1434 
1435 static __inline struct mbuf *
1436 m_free(struct mbuf *m)
1437 {
1438 	struct mbuf *n = m->m_next;
1439 
1440 	MBUF_PROBE1(m__free, m);
1441 	if ((m->m_flags & (M_PKTHDR|M_NOFREE)) == (M_PKTHDR|M_NOFREE))
1442 		m_tag_delete_chain(m, NULL);
1443 	if (m->m_flags & M_PKTHDR && m->m_pkthdr.csum_flags & CSUM_SND_TAG)
1444 		m_snd_tag_rele(m->m_pkthdr.snd_tag);
1445 	if (m->m_flags & M_EXTPG)
1446 		mb_free_extpg(m);
1447 	else if (m->m_flags & M_EXT)
1448 		mb_free_ext(m);
1449 	else if ((m->m_flags & M_NOFREE) == 0)
1450 		uma_zfree(zone_mbuf, m);
1451 	return (n);
1452 }
1453 
1454 static __inline int
1455 rt_m_getfib(struct mbuf *m)
1456 {
1457 	KASSERT(m->m_flags & M_PKTHDR , ("Attempt to get FIB from non header mbuf."));
1458 	return (m->m_pkthdr.fibnum);
1459 }
1460 
1461 #define M_GETFIB(_m)   rt_m_getfib(_m)
1462 
1463 #define M_SETFIB(_m, _fib) do {						\
1464         KASSERT((_m)->m_flags & M_PKTHDR, ("Attempt to set FIB on non header mbuf."));	\
1465 	((_m)->m_pkthdr.fibnum) = (_fib);				\
1466 } while (0)
1467 
1468 /* flags passed as first argument for "m_xxx_tcpip_hash()" */
1469 #define	MBUF_HASHFLAG_L2	(1 << 2)
1470 #define	MBUF_HASHFLAG_L3	(1 << 3)
1471 #define	MBUF_HASHFLAG_L4	(1 << 4)
1472 
1473 /* mbuf hashing helper routines */
1474 uint32_t	m_ether_tcpip_hash_init(void);
1475 uint32_t	m_ether_tcpip_hash(const uint32_t, const struct mbuf *, uint32_t);
1476 uint32_t	m_infiniband_tcpip_hash_init(void);
1477 uint32_t	m_infiniband_tcpip_hash(const uint32_t, const struct mbuf *, uint32_t);
1478 
1479 #ifdef MBUF_PROFILING
1480  void m_profile(struct mbuf *m);
1481  #define M_PROFILE(m) m_profile(m)
1482 #else
1483  #define M_PROFILE(m)
1484 #endif
1485 
1486 struct mbufq {
1487 	STAILQ_HEAD(, mbuf)	mq_head;
1488 	int			mq_len;
1489 	int			mq_maxlen;
1490 };
1491 
1492 static inline void
1493 mbufq_init(struct mbufq *mq, int maxlen)
1494 {
1495 
1496 	STAILQ_INIT(&mq->mq_head);
1497 	mq->mq_maxlen = maxlen;
1498 	mq->mq_len = 0;
1499 }
1500 
1501 static inline struct mbuf *
1502 mbufq_flush(struct mbufq *mq)
1503 {
1504 	struct mbuf *m;
1505 
1506 	m = STAILQ_FIRST(&mq->mq_head);
1507 	STAILQ_INIT(&mq->mq_head);
1508 	mq->mq_len = 0;
1509 	return (m);
1510 }
1511 
1512 static inline void
1513 mbufq_drain(struct mbufq *mq)
1514 {
1515 	struct mbuf *m, *n;
1516 
1517 	n = mbufq_flush(mq);
1518 	while ((m = n) != NULL) {
1519 		n = STAILQ_NEXT(m, m_stailqpkt);
1520 		m_freem(m);
1521 	}
1522 }
1523 
1524 static inline struct mbuf *
1525 mbufq_first(const struct mbufq *mq)
1526 {
1527 
1528 	return (STAILQ_FIRST(&mq->mq_head));
1529 }
1530 
1531 static inline struct mbuf *
1532 mbufq_last(const struct mbufq *mq)
1533 {
1534 
1535 	return (STAILQ_LAST(&mq->mq_head, mbuf, m_stailqpkt));
1536 }
1537 
1538 static inline int
1539 mbufq_full(const struct mbufq *mq)
1540 {
1541 
1542 	return (mq->mq_maxlen > 0 && mq->mq_len >= mq->mq_maxlen);
1543 }
1544 
1545 static inline int
1546 mbufq_len(const struct mbufq *mq)
1547 {
1548 
1549 	return (mq->mq_len);
1550 }
1551 
1552 static inline int
1553 mbufq_enqueue(struct mbufq *mq, struct mbuf *m)
1554 {
1555 
1556 	if (mbufq_full(mq))
1557 		return (ENOBUFS);
1558 	STAILQ_INSERT_TAIL(&mq->mq_head, m, m_stailqpkt);
1559 	mq->mq_len++;
1560 	return (0);
1561 }
1562 
1563 static inline struct mbuf *
1564 mbufq_dequeue(struct mbufq *mq)
1565 {
1566 	struct mbuf *m;
1567 
1568 	m = STAILQ_FIRST(&mq->mq_head);
1569 	if (m) {
1570 		STAILQ_REMOVE_HEAD(&mq->mq_head, m_stailqpkt);
1571 		m->m_nextpkt = NULL;
1572 		mq->mq_len--;
1573 	}
1574 	return (m);
1575 }
1576 
1577 static inline void
1578 mbufq_prepend(struct mbufq *mq, struct mbuf *m)
1579 {
1580 
1581 	STAILQ_INSERT_HEAD(&mq->mq_head, m, m_stailqpkt);
1582 	mq->mq_len++;
1583 }
1584 
1585 /*
1586  * Note: this doesn't enforce the maximum list size for dst.
1587  */
1588 static inline void
1589 mbufq_concat(struct mbufq *mq_dst, struct mbufq *mq_src)
1590 {
1591 
1592 	mq_dst->mq_len += mq_src->mq_len;
1593 	STAILQ_CONCAT(&mq_dst->mq_head, &mq_src->mq_head);
1594 	mq_src->mq_len = 0;
1595 }
1596 
1597 #ifdef _SYS_TIMESPEC_H_
1598 static inline void
1599 mbuf_tstmp2timespec(struct mbuf *m, struct timespec *ts)
1600 {
1601 
1602 	KASSERT((m->m_flags & M_PKTHDR) != 0, ("mbuf %p no M_PKTHDR", m));
1603 	KASSERT((m->m_flags & (M_TSTMP|M_TSTMP_LRO)) != 0, ("mbuf %p no M_TSTMP or M_TSTMP_LRO", m));
1604 	ts->tv_sec = m->m_pkthdr.rcv_tstmp / 1000000000;
1605 	ts->tv_nsec = m->m_pkthdr.rcv_tstmp % 1000000000;
1606 }
1607 #endif
1608 
1609 #ifdef DEBUGNET
1610 /* Invoked from the debugnet client code. */
1611 void	debugnet_mbuf_drain(void);
1612 void	debugnet_mbuf_start(void);
1613 void	debugnet_mbuf_finish(void);
1614 void	debugnet_mbuf_reinit(int nmbuf, int nclust, int clsize);
1615 #endif
1616 
1617 static inline bool
1618 mbuf_has_tls_session(struct mbuf *m)
1619 {
1620 
1621 	if (m->m_flags & M_EXTPG) {
1622 		if (m->m_epg_tls != NULL) {
1623 			return (true);
1624 		}
1625 	}
1626 	return (false);
1627 }
1628 
1629 #endif /* _KERNEL */
1630 #endif /* !_SYS_MBUF_H_ */
1631