xref: /freebsd/usr.sbin/ppp/mbuf.c (revision 2b15cb3d0922bd70ea592f0da9b4a5b167f4d53f) 
1 /*-
2  * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org>
3  *          based on work by Toshiharu OHNO <tony-o@iij.ad.jp>
4  *                           Internet Initiative Japan, Inc (IIJ)
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * $FreeBSD$
29  */
30 
31 #include <sys/types.h>
32 
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sysexits.h>
38 #include <termios.h>
39 
40 #include "defs.h"
41 #include "command.h"
42 #include "mbuf.h"
43 #include "log.h"
44 #include "descriptor.h"
45 #include "prompt.h"
46 #include "main.h"
47 
48 #define BUCKET_CHUNK	20
49 #define BUCKET_HASH	256
50 
51 struct mbucket;
52 
53 struct mfree {
54   struct mbucket *next;
55   size_t count;
56 };
57 
58 static struct mbucket {
59   union {
60     struct mbuf m;
61     struct mfree f;
62   } u;
63 } *bucket[(M_MAXLEN + sizeof(struct mbuf)) / BUCKET_HASH];
64 
65 #define M_BINDEX(sz)	(((sz) + sizeof(struct mbuf) - 1) / BUCKET_HASH)
66 #define M_BUCKET(sz)	(bucket + M_BINDEX(sz))
67 #define M_ROUNDUP(sz)	((M_BINDEX(sz) + 1) * BUCKET_HASH)
68 
69 static struct memmap {
70   struct mbuf *queue;
71   size_t fragments;
72   size_t octets;
73 } MemMap[MB_MAX + 1];
74 
75 static unsigned long long mbuf_Mallocs, mbuf_Frees;
76 
77 size_t
78 m_length(struct mbuf *bp)
79 {
80   size_t len;
81 
82   for (len = 0; bp; bp = bp->m_next)
83     len += bp->m_len;
84   return len;
85 }
86 
87 static const char *
88 mbuftype(int type)
89 {
90   static const char * const mbufdesc[MB_MAX] = {
91     "ip in", "ip out", "ipv6 in", "ipv6 out", "nat in", "nat out",
92     "mp in", "mp out", "vj in", "vj out", "icompd in", "icompd out",
93     "compd in", "compd out", "lqr in", "lqr out", "echo in", "echo out",
94     "proto in", "proto out", "acf in", "acf out", "sync in", "sync out",
95     "hdlc in", "hdlc out", "async in", "async out", "cbcp in", "cbcp out",
96     "chap in", "chap out", "pap in", "pap out", "ccp in", "ccp out",
97     "ipcp in", "ipcp out", "ipv6cp in", "ipv6cp out", "lcp in", "lcp out"
98   };
99 
100   return type < 0 || type >= MB_MAX ? "unknown" : mbufdesc[type];
101 }
102 
103 struct mbuf *
104 m_get(size_t m_len, int type)
105 {
106   struct mbucket **mb;
107   struct mbuf *bp;
108   size_t size;
109 
110   if (type > MB_MAX) {
111     log_Printf(LogERROR, "Bad mbuf type %d\n", type);
112     type = MB_UNKNOWN;
113   }
114 
115   if (m_len > M_MAXLEN || m_len == 0) {
116     log_Printf(LogERROR, "Request for mbuf size %lu (\"%s\") denied !\n",
117                (u_long)m_len, mbuftype(type));
118     AbortProgram(EX_OSERR);
119   }
120 
121   mb = M_BUCKET(m_len);
122   size = M_ROUNDUP(m_len);
123 
124   if (*mb) {
125     /* We've got some free blocks of the right size */
126     bp = &(*mb)->u.m;
127     if (--(*mb)->u.f.count == 0)
128       *mb = (*mb)->u.f.next;
129     else {
130       ((struct mbucket *)((char *)*mb + size))->u.f.count = (*mb)->u.f.count;
131       *mb = (struct mbucket *)((char *)*mb + size);
132       (*mb)->u.f.next = NULL;
133     }
134   } else {
135     /*
136      * Allocate another chunk of mbufs, use the first and put the rest on
137      * the free list
138      */
139     *mb = (struct mbucket *)malloc(BUCKET_CHUNK * size);
140     if (*mb == NULL) {
141       log_Printf(LogALERT, "Failed to allocate memory (%lu)\n",
142                  (unsigned long)BUCKET_CHUNK * size);
143       AbortProgram(EX_OSERR);
144     }
145     bp = &(*mb)->u.m;
146     *mb = (struct mbucket *)((char *)*mb + size);
147     (*mb)->u.f.count = BUCKET_CHUNK - 1;
148     (*mb)->u.f.next = NULL;
149   }
150 
151   mbuf_Mallocs++;
152 
153   memset(bp, '\0', sizeof(struct mbuf));
154   bp->m_size = size - sizeof *bp;
155   bp->m_len = m_len;
156   bp->m_type = type;
157 
158   MemMap[type].fragments++;
159   MemMap[type].octets += bp->m_size;
160 
161   return bp;
162 }
163 
164 struct mbuf *
165 m_free(struct mbuf *bp)
166 {
167   struct mbucket **mb, *f;
168   struct mbuf *nbp;
169 
170   if ((f = (struct mbucket *)bp) != NULL) {
171     MemMap[bp->m_type].fragments--;
172     MemMap[bp->m_type].octets -= bp->m_size;
173 
174     nbp = bp->m_next;
175     mb = M_BUCKET(bp->m_size);
176     f->u.f.next = *mb;
177     f->u.f.count = 1;
178     *mb = f;
179 
180     mbuf_Frees++;
181     bp = nbp;
182   }
183 
184   return bp;
185 }
186 
187 void
188 m_freem(struct mbuf *bp)
189 {
190   while (bp)
191     bp = m_free(bp);
192 }
193 
194 struct mbuf *
195 mbuf_Read(struct mbuf *bp, void *v, size_t len)
196 {
197   int nb;
198   u_char *ptr = v;
199 
200   while (bp && len > 0) {
201     if (len > bp->m_len)
202       nb = bp->m_len;
203     else
204       nb = len;
205     if (nb) {
206       memcpy(ptr, MBUF_CTOP(bp), nb);
207       ptr += nb;
208       bp->m_len -= nb;
209       len -= nb;
210       bp->m_offset += nb;
211     }
212     if (bp->m_len == 0)
213       bp = m_free(bp);
214   }
215 
216   while (bp && bp->m_len == 0)
217     bp = m_free(bp);
218 
219   return bp;
220 }
221 
222 size_t
223 mbuf_View(struct mbuf *bp, void *v, size_t len)
224 {
225   size_t nb, l = len;
226   u_char *ptr = v;
227 
228   while (bp && l > 0) {
229     if (l > bp->m_len)
230       nb = bp->m_len;
231     else
232       nb = l;
233     memcpy(ptr, MBUF_CTOP(bp), nb);
234     ptr += nb;
235     l -= nb;
236     bp = bp->m_next;
237   }
238 
239   return len - l;
240 }
241 
242 struct mbuf *
243 m_prepend(struct mbuf *bp, const void *ptr, size_t len, u_short extra)
244 {
245   struct mbuf *head;
246 
247   if (bp && bp->m_offset) {
248     if (bp->m_offset >= len) {
249       bp->m_offset -= len;
250       bp->m_len += len;
251       if (ptr)
252         memcpy(MBUF_CTOP(bp), ptr, len);
253       return bp;
254     }
255     len -= bp->m_offset;
256     if (ptr)
257       memcpy(bp + 1, (const char *)ptr + len, bp->m_offset);
258     bp->m_len += bp->m_offset;
259     bp->m_offset = 0;
260   }
261 
262   head = m_get(len + extra, bp ? bp->m_type : MB_UNKNOWN);
263   head->m_offset = extra;
264   head->m_len -= extra;
265   if (ptr)
266     memcpy(MBUF_CTOP(head), ptr, len);
267   head->m_next = bp;
268 
269   return head;
270 }
271 
272 struct mbuf *
273 m_adj(struct mbuf *bp, ssize_t n)
274 {
275   if (n > 0) {
276     while (bp) {
277       if ((size_t)n < bp->m_len) {
278         bp->m_len = n;
279         bp->m_offset += n;
280         return bp;
281       }
282       n -= bp->m_len;
283       bp = m_free(bp);
284     }
285   } else {
286     if ((n = m_length(bp) + n) <= 0) {
287       m_freem(bp);
288       return NULL;
289     }
290     for (; bp; bp = bp->m_next, n -= bp->m_len)
291       if ((size_t)n < bp->m_len) {
292         bp->m_len = n;
293         m_freem(bp->m_next);
294         bp->m_next = NULL;
295         break;
296       }
297   }
298 
299   return bp;
300 }
301 
302 void
303 mbuf_Write(struct mbuf *bp, const void *ptr, size_t m_len)
304 {
305   size_t plen;
306   int nb;
307 
308   plen = m_length(bp);
309   if (plen < m_len)
310     m_len = plen;
311 
312   while (m_len > 0) {
313     nb = (m_len < bp->m_len) ? m_len : bp->m_len;
314     memcpy(MBUF_CTOP(bp), ptr, nb);
315     m_len -= bp->m_len;
316     bp = bp->m_next;
317   }
318 }
319 
320 int
321 mbuf_Show(struct cmdargs const *arg)
322 {
323   int i;
324 
325   prompt_Printf(arg->prompt, "Fragments (octets) in use:\n");
326   for (i = 0; i < MB_MAX; i += 2)
327     prompt_Printf(arg->prompt, "%10.10s: %04lu (%06lu)\t"
328                   "%10.10s: %04lu (%06lu)\n",
329 	          mbuftype(i), (u_long)MemMap[i].fragments,
330                   (u_long)MemMap[i].octets, mbuftype(i+1),
331                   (u_long)MemMap[i+1].fragments, (u_long)MemMap[i+1].octets);
332 
333   if (i == MB_MAX)
334     prompt_Printf(arg->prompt, "%10.10s: %04lu (%06lu)\n",
335                   mbuftype(i), (u_long)MemMap[i].fragments,
336                   (u_long)MemMap[i].octets);
337 
338   prompt_Printf(arg->prompt, "Mallocs: %llu,   Frees: %llu\n",
339                 mbuf_Mallocs, mbuf_Frees);
340 
341   return 0;
342 }
343 
344 struct mbuf *
345 m_dequeue(struct mqueue *q)
346 {
347   struct mbuf *bp;
348 
349   log_Printf(LogDEBUG, "m_dequeue: queue len = %lu\n", (u_long)q->len);
350   bp = q->top;
351   if (bp) {
352     q->top = q->top->m_nextpkt;
353     q->len--;
354     if (q->top == NULL) {
355       q->last = q->top;
356       if (q->len)
357 	log_Printf(LogERROR, "m_dequeue: Not zero (%lu)!!!\n",
358                    (u_long)q->len);
359     }
360     bp->m_nextpkt = NULL;
361   }
362 
363   return bp;
364 }
365 
366 void
367 m_enqueue(struct mqueue *queue, struct mbuf *bp)
368 {
369   if (bp != NULL) {
370     if (queue->last) {
371       queue->last->m_nextpkt = bp;
372       queue->last = bp;
373     } else
374       queue->last = queue->top = bp;
375     queue->len++;
376     log_Printf(LogDEBUG, "m_enqueue: len = %lu\n", (unsigned long)queue->len);
377   }
378 }
379 
380 struct mbuf *
381 m_pullup(struct mbuf *bp)
382 {
383   /* Put it all in one contigous (aligned) mbuf */
384 
385   if (bp != NULL) {
386     if (bp->m_next != NULL) {
387       struct mbuf *nbp;
388       u_char *cp;
389 
390       nbp = m_get(m_length(bp), bp->m_type);
391 
392       for (cp = MBUF_CTOP(nbp); bp; bp = m_free(bp)) {
393         memcpy(cp, MBUF_CTOP(bp), bp->m_len);
394         cp += bp->m_len;
395       }
396       bp = nbp;
397     }
398 #ifndef __i386__	/* Do any other archs not care about alignment ? */
399     else if ((bp->m_offset & (sizeof(long) - 1)) != 0) {
400       bcopy(MBUF_CTOP(bp), bp + 1, bp->m_len);
401       bp->m_offset = 0;
402     }
403 #endif
404   }
405 
406   return bp;
407 }
408 
409 void
410 m_settype(struct mbuf *bp, int type)
411 {
412   for (; bp; bp = bp->m_next)
413     if (type != bp->m_type) {
414       MemMap[bp->m_type].fragments--;
415       MemMap[bp->m_type].octets -= bp->m_size;
416       bp->m_type = type;
417       MemMap[type].fragments++;
418       MemMap[type].octets += bp->m_size;
419     }
420 }
421 
422 struct mbuf *
423 m_append(struct mbuf *bp, const void *v, size_t sz)
424 {
425   struct mbuf *m = bp;
426 
427   if (m) {
428     while (m->m_next)
429       m = m->m_next;
430     if (m->m_size - m->m_len >= sz) {
431       if (v)
432         memcpy((char *)(m + 1) + m->m_len, v, sz);
433       m->m_len += sz;
434     } else
435       m->m_next = m_prepend(NULL, v, sz, 0);
436   } else
437     bp = m_prepend(NULL, v, sz, 0);
438 
439   return bp;
440 }
441