2 * Copyright (c) 2001-2003
3 * Fraunhofer Institute for Open Communication Systems (FhG Fokus).
6 * Author: Hartmut Brandt <harti@freebsd.org>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * In-kernel UNI stack message functions.
31 * $FreeBSD: src/sys/netgraph/atm/ngatmbase.c,v 1.3 2005/01/07 01:45:40 imp Exp $
32 * $DragonFly: src/sys/netgraph7/atm/ngatmbase.c,v 1.2 2008/06/26 23:05:37 dillon Exp $
33 * $DragonFly: src/sys/netgraph7/atm/ngatmbase.c,v 1.2 2008/06/26 23:05:37 dillon Exp $
36 #include <sys/param.h>
37 #include <sys/module.h>
38 #include <sys/kernel.h>
39 #include <sys/malloc.h>
40 #include <sys/systm.h>
42 #include <sys/mutex.h>
44 #include <machine/stdarg.h>
45 #include <netnatm/unimsg.h>
46 #include "atm/ngatmbase.h"
48 #define NGATMBASE_VERSION 1
50 static int ngatm_handler(module_t, int, void *);
52 static moduledata_t ngatm_data = {
58 MODULE_VERSION(ngatmbase, NGATMBASE_VERSION);
59 DECLARE_MODULE(ngatmbase, ngatm_data, SI_SUB_EXEC, SI_ORDER_ANY);
61 /*********************************************************************/
63 * UNI Stack message handling functions
65 MALLOC_DEFINE(M_UNIMSG, "unimsg", "uni message buffers");
66 MALLOC_DEFINE(M_UNIMSGHDR, "unimsghdr", "uni message headers");
70 /* mutex to protect the free list (and the used list if debugging) */
71 static struct mtx ngatm_unilist_mtx;
74 * Initialize UNI message subsystem
79 mtx_init(&ngatm_unilist_mtx, "netgraph UNI msg header lists", NULL,
84 * Ensure, that the message can be extended by at least s bytes.
85 * Re-allocate the message (not the header). If that failes,
86 * free the entire message and return ENOMEM. Free space at the start of
87 * the message is retained.
90 uni_msg_extend(struct uni_msg *m, size_t s)
95 lead = uni_msg_leading(m);
97 s += lead + len + EXTRA;
98 if ((b = kmalloc(s, M_UNIMSG, MB_DONTWAIT)) == NULL) {
103 bcopy(m->b_rptr, b + lead, len);
104 kfree(m->b_buf, M_UNIMSG);
107 m->b_rptr = m->b_buf + lead;
108 m->b_wptr = m->b_rptr + len;
109 m->b_lim = m->b_buf + s;
115 * Append a buffer to the message, making space if needed.
116 * If reallocation files, ENOMEM is returned and the message freed.
119 uni_msg_append(struct uni_msg *m, void *buf, size_t size)
123 if ((error = uni_msg_ensure(m, size)))
125 bcopy(buf, m->b_wptr, size);
132 * Pack/unpack data from/into mbufs. Assume, that the (optional) header
133 * fits into the first mbuf, ie. hdrlen < MHLEN. Note, that the message
134 * can be NULL, but hdrlen should not be 0 in this case.
137 uni_msg_pack_mbuf(struct uni_msg *msg, void *hdr, size_t hdrlen)
139 struct mbuf *m, *m0, *last;
142 MGETHDR(m0, MB_DONTWAIT, MT_DATA);
146 KASSERT(hdrlen <= MHLEN, ("uni_msg_pack_mbuf: hdrlen > MHLEN"));
149 bcopy(hdr, m0->m_data, hdrlen);
151 m0->m_pkthdr.len = hdrlen;
154 if ((n = uni_msg_len(msg)) > MHLEN) {
155 MCLGET(m0, MB_DONTWAIT);
156 if (!(m0->m_flags & M_EXT))
162 bcopy(msg->b_rptr, m0->m_data, n);
165 m0->m_pkthdr.len = n;
169 while (msg != NULL && (n = uni_msg_len(msg)) != 0) {
170 MGET(m, MB_DONTWAIT, MT_DATA);
177 MCLGET(m, MB_DONTWAIT);
178 if (!(m->m_flags & M_EXT))
184 bcopy(msg->b_rptr, m->m_data, n);
187 m0->m_pkthdr.len += n;
200 * Prepend a debugging header to each message
203 LIST_ENTRY(ngatm_msg) link;
210 * These are the lists of free and used message headers.
212 static LIST_HEAD(, ngatm_msg) ngatm_freeuni =
213 LIST_HEAD_INITIALIZER(ngatm_freeuni);
214 static LIST_HEAD(, ngatm_msg) ngatm_useduni =
215 LIST_HEAD_INITIALIZER(ngatm_useduni);
218 * Clean-up UNI message subsystem
225 /* free all free message headers */
226 while ((h = LIST_FIRST(&ngatm_freeuni)) != NULL) {
227 LIST_REMOVE(h, link);
228 kfree(h, M_UNIMSGHDR);
231 /* forget about still used messages */
232 LIST_FOREACH(h, &ngatm_useduni, link)
233 printf("unimsg header in use: %p (%s, %d)\n",
234 &h->msg, h->file, h->line);
236 mtx_destroy(&ngatm_unilist_mtx);
240 * Allocate a message, that can hold at least s bytes.
243 _uni_msg_alloc(size_t s, const char *file, int line)
247 mtx_lock(&ngatm_unilist_mtx);
248 if ((m = LIST_FIRST(&ngatm_freeuni)) != NULL)
249 LIST_REMOVE(m, link);
250 mtx_unlock(&ngatm_unilist_mtx);
253 (m = kmalloc(sizeof(*m), M_UNIMSGHDR, M_WAITOK | M_NULLOK)) == NULL)
257 if((m->msg.b_buf = kmalloc(s, M_UNIMSG, M_WAITOK | M_NULLOK | M_ZERO)) == NULL) {
258 mtx_lock(&ngatm_unilist_mtx);
259 LIST_INSERT_HEAD(&ngatm_freeuni, m, link);
260 mtx_unlock(&ngatm_unilist_mtx);
263 m->msg.b_rptr = m->msg.b_wptr = m->msg.b_buf;
264 m->msg.b_lim = m->msg.b_buf + s;
268 mtx_lock(&ngatm_unilist_mtx);
269 LIST_INSERT_HEAD(&ngatm_useduni, m, link);
270 mtx_unlock(&ngatm_unilist_mtx);
275 * Destroy a UNI message.
276 * The header is inserted into the free header list.
279 _uni_msg_destroy(struct uni_msg *m, const char *file, int line)
281 struct ngatm_msg *h, *d;
283 d = (struct ngatm_msg *)((char *)m - offsetof(struct ngatm_msg, msg));
285 mtx_lock(&ngatm_unilist_mtx);
286 LIST_FOREACH(h, &ngatm_useduni, link)
292 * Not on used list. Ups.
294 LIST_FOREACH(h, &ngatm_freeuni, link)
299 printf("uni_msg %p was never allocated; found "
300 "in %s:%u\n", m, file, line);
302 printf("uni_msg %p was already destroyed in %s,%d; "
303 "found in %s:%u\n", m, h->file, h->line,
306 kfree(m->b_buf, M_UNIMSG);
308 LIST_REMOVE(d, link);
309 LIST_INSERT_HEAD(&ngatm_freeuni, d, link);
315 mtx_unlock(&ngatm_unilist_mtx);
318 #else /* !NGATM_DEBUG */
321 * This assumes, that sizeof(struct uni_msg) >= sizeof(struct ngatm_msg)
322 * and the alignment requirements of are the same.
325 LIST_ENTRY(ngatm_msg) link;
328 /* Lists of free message headers. */
329 static LIST_HEAD(, ngatm_msg) ngatm_freeuni =
330 LIST_HEAD_INITIALIZER(ngatm_freeuni);
333 * Clean-up UNI message subsystem
340 /* free all free message headers */
341 while ((h = LIST_FIRST(&ngatm_freeuni)) != NULL) {
342 LIST_REMOVE(h, link);
343 kfree(h, M_UNIMSGHDR);
346 mtx_destroy(&ngatm_unilist_mtx);
350 * Allocate a message, that can hold at least s bytes.
353 uni_msg_alloc(size_t s)
358 mtx_lock(&ngatm_unilist_mtx);
359 if ((a = LIST_FIRST(&ngatm_freeuni)) != NULL)
360 LIST_REMOVE(a, link);
361 mtx_unlock(&ngatm_unilist_mtx);
364 if ((m = kmalloc(sizeof(*m), M_UNIMSGHDR, M_WAITOK | M_NULLOK)) == NULL)
366 a = (struct ngatm_msg *)m;
368 m = (struct uni_msg *)a;
371 if((m->b_buf = kmalloc(s, M_UNIMSG, M_WAITOK | M_NULLOK | M_ZERO)) == NULL) {
372 mtx_lock(&ngatm_unilist_mtx);
373 LIST_INSERT_HEAD(&ngatm_freeuni, a, link);
374 mtx_unlock(&ngatm_unilist_mtx);
377 m->b_rptr = m->b_wptr = m->b_buf;
378 m->b_lim = m->b_buf + s;
384 * Destroy a UNI message.
385 * The header is inserted into the free header list.
388 uni_msg_destroy(struct uni_msg *m)
392 a = (struct ngatm_msg *)m;
394 kfree(m->b_buf, M_UNIMSG);
396 mtx_lock(&ngatm_unilist_mtx);
397 LIST_INSERT_HEAD(&ngatm_freeuni, a, link);
398 mtx_unlock(&ngatm_unilist_mtx);
404 * Build a message from a number of buffers. Arguments are pairs
405 * of (void *, size_t) ending with a NULL pointer.
409 _uni_msg_build(const char *file, int line, void *ptr, ...)
412 uni_msg_build(void *ptr, ...)
424 n = va_arg(ap, size_t);
426 p1 = va_arg(ap, void *);
431 if ((m = _uni_msg_alloc(len, file, line)) == NULL)
433 if ((m = uni_msg_alloc(len)) == NULL)
440 n = va_arg(ap, size_t);
441 bcopy(p1, m->b_wptr, n);
443 p1 = va_arg(ap, void *);
451 * Unpack an mbuf chain into a uni_msg buffer.
455 _uni_msg_unpack_mbuf(struct mbuf *m, struct uni_msg **pmsg, const char *file,
459 uni_msg_unpack_mbuf(struct mbuf *m, struct uni_msg **pmsg)
462 if (!(m->m_flags & M_PKTHDR)) {
463 printf("%s: bogus packet %p\n", __func__, m);
467 if ((*pmsg = _uni_msg_alloc(m->m_pkthdr.len, file, line)) == NULL)
469 if ((*pmsg = uni_msg_alloc(m->m_pkthdr.len)) == NULL)
473 m_copydata(m, 0, m->m_pkthdr.len, (*pmsg)->b_wptr);
474 (*pmsg)->b_wptr += m->m_pkthdr.len;
479 /*********************************************************************/
482 ngatm_handler(module_t mod, int what, void *arg)