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