uipc_mbuf.c revision 1.28 1 1.28 thorpej /* $NetBSD: uipc_mbuf.c,v 1.28 1998/08/01 01:35:20 thorpej Exp $ */
2 1.10 cgd
3 1.1 cgd /*
4 1.9 mycroft * Copyright (c) 1982, 1986, 1988, 1991, 1993
5 1.9 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 cgd *
7 1.1 cgd * Redistribution and use in source and binary forms, with or without
8 1.1 cgd * modification, are permitted provided that the following conditions
9 1.1 cgd * are met:
10 1.1 cgd * 1. Redistributions of source code must retain the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer.
12 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 cgd * notice, this list of conditions and the following disclaimer in the
14 1.1 cgd * documentation and/or other materials provided with the distribution.
15 1.1 cgd * 3. All advertising materials mentioning features or use of this software
16 1.1 cgd * must display the following acknowledgement:
17 1.1 cgd * This product includes software developed by the University of
18 1.1 cgd * California, Berkeley and its contributors.
19 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
20 1.1 cgd * may be used to endorse or promote products derived from this software
21 1.1 cgd * without specific prior written permission.
22 1.1 cgd *
23 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 1.1 cgd * SUCH DAMAGE.
34 1.1 cgd *
35 1.26 fvdl * @(#)uipc_mbuf.c 8.4 (Berkeley) 2/14/95
36 1.1 cgd */
37 1.24 mrg
38 1.24 mrg #include "opt_uvm.h"
39 1.1 cgd
40 1.6 mycroft #include <sys/param.h>
41 1.6 mycroft #include <sys/systm.h>
42 1.6 mycroft #include <sys/proc.h>
43 1.6 mycroft #include <sys/malloc.h>
44 1.9 mycroft #include <sys/map.h>
45 1.1 cgd #define MBTYPES
46 1.6 mycroft #include <sys/mbuf.h>
47 1.6 mycroft #include <sys/kernel.h>
48 1.6 mycroft #include <sys/syslog.h>
49 1.6 mycroft #include <sys/domain.h>
50 1.6 mycroft #include <sys/protosw.h>
51 1.28 thorpej #include <sys/pool.h>
52 1.27 matt #include <sys/socket.h>
53 1.27 matt #include <net/if.h>
54 1.6 mycroft
55 1.6 mycroft #include <vm/vm.h>
56 1.14 christos
57 1.23 mrg #if defined(UVM)
58 1.23 mrg #include <uvm/uvm_extern.h>
59 1.23 mrg #endif
60 1.23 mrg
61 1.28 thorpej struct pool mbpool; /* mbuf pool */
62 1.28 thorpej struct pool mclpool; /* mbuf cluster pool */
63 1.28 thorpej
64 1.18 thorpej struct mbuf *mbutl;
65 1.18 thorpej struct mbstat mbstat;
66 1.18 thorpej union mcluster *mclfree;
67 1.18 thorpej int max_linkhdr;
68 1.18 thorpej int max_protohdr;
69 1.18 thorpej int max_hdr;
70 1.18 thorpej int max_datalen;
71 1.18 thorpej
72 1.1 cgd extern vm_map_t mb_map;
73 1.1 cgd
74 1.28 thorpej void *mclpool_alloc __P((unsigned long, int, int));
75 1.28 thorpej void mclpool_release __P((void *, unsigned long, int));
76 1.28 thorpej
77 1.28 thorpej /*
78 1.28 thorpej * Initialize the mbuf allcator. Note, this cannot allocate any
79 1.28 thorpej * memory itself; we are called before mb_map has been allocated.
80 1.28 thorpej */
81 1.4 jtc void
82 1.1 cgd mbinit()
83 1.1 cgd {
84 1.1 cgd
85 1.28 thorpej /* XXX malloc types! */
86 1.28 thorpej pool_init(&mbpool, MSIZE, 0, 0, 0, "mbpl", 0, NULL, NULL, 0);
87 1.28 thorpej pool_init(&mclpool, MCLBYTES, 0, 0, 0, "mclpl", 0, mclpool_alloc,
88 1.28 thorpej mclpool_release, 0);
89 1.28 thorpej }
90 1.28 thorpej
91 1.28 thorpej void *
92 1.28 thorpej mclpool_alloc(sz, flags, mtype)
93 1.28 thorpej unsigned long sz;
94 1.28 thorpej int flags;
95 1.28 thorpej int mtype;
96 1.28 thorpej {
97 1.28 thorpej
98 1.28 thorpej #if defined(UVM)
99 1.28 thorpej return ((void *)uvm_km_alloc_poolpage1(mb_map, uvmexp.mb_object));
100 1.28 thorpej #else
101 1.28 thorpej return ((void *)kmem_alloc_poolpage1(mb_map));
102 1.28 thorpej #endif
103 1.1 cgd }
104 1.1 cgd
105 1.28 thorpej void
106 1.28 thorpej mclpool_release(v, sz, mtype)
107 1.28 thorpej void *v;
108 1.28 thorpej unsigned long sz;
109 1.28 thorpej int mtype;
110 1.1 cgd {
111 1.1 cgd
112 1.23 mrg #if defined(UVM)
113 1.28 thorpej uvm_km_free_poolpage1(mb_map, (vm_offset_t)v);
114 1.23 mrg #else
115 1.28 thorpej kmem_free_poolpage1(mb_map, (vm_offset_t)v);
116 1.23 mrg #endif
117 1.1 cgd }
118 1.1 cgd
119 1.1 cgd /*
120 1.1 cgd * When MGET failes, ask protocols to free space when short of memory,
121 1.1 cgd * then re-attempt to allocate an mbuf.
122 1.1 cgd */
123 1.1 cgd struct mbuf *
124 1.1 cgd m_retry(i, t)
125 1.1 cgd int i, t;
126 1.1 cgd {
127 1.27 matt struct mbuf *m;
128 1.1 cgd
129 1.1 cgd m_reclaim();
130 1.1 cgd #define m_retry(i, t) (struct mbuf *)0
131 1.1 cgd MGET(m, i, t);
132 1.1 cgd #undef m_retry
133 1.18 thorpej if (m != NULL)
134 1.18 thorpej mbstat.m_wait++;
135 1.18 thorpej else
136 1.18 thorpej mbstat.m_drops++;
137 1.1 cgd return (m);
138 1.1 cgd }
139 1.1 cgd
140 1.1 cgd /*
141 1.1 cgd * As above; retry an MGETHDR.
142 1.1 cgd */
143 1.1 cgd struct mbuf *
144 1.1 cgd m_retryhdr(i, t)
145 1.1 cgd int i, t;
146 1.1 cgd {
147 1.27 matt struct mbuf *m;
148 1.1 cgd
149 1.1 cgd m_reclaim();
150 1.1 cgd #define m_retryhdr(i, t) (struct mbuf *)0
151 1.1 cgd MGETHDR(m, i, t);
152 1.1 cgd #undef m_retryhdr
153 1.18 thorpej if (m != NULL)
154 1.18 thorpej mbstat.m_wait++;
155 1.18 thorpej else
156 1.18 thorpej mbstat.m_drops++;
157 1.1 cgd return (m);
158 1.1 cgd }
159 1.1 cgd
160 1.14 christos void
161 1.1 cgd m_reclaim()
162 1.1 cgd {
163 1.27 matt struct domain *dp;
164 1.27 matt struct protosw *pr;
165 1.27 matt struct ifnet *ifp;
166 1.1 cgd int s = splimp();
167 1.1 cgd
168 1.1 cgd for (dp = domains; dp; dp = dp->dom_next)
169 1.1 cgd for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
170 1.1 cgd if (pr->pr_drain)
171 1.1 cgd (*pr->pr_drain)();
172 1.27 matt for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list))
173 1.27 matt if (ifp->if_drain)
174 1.27 matt (*ifp->if_drain)(ifp);
175 1.1 cgd splx(s);
176 1.1 cgd mbstat.m_drain++;
177 1.1 cgd }
178 1.1 cgd
179 1.1 cgd /*
180 1.1 cgd * Space allocation routines.
181 1.1 cgd * These are also available as macros
182 1.1 cgd * for critical paths.
183 1.1 cgd */
184 1.1 cgd struct mbuf *
185 1.5 cgd m_get(nowait, type)
186 1.5 cgd int nowait, type;
187 1.1 cgd {
188 1.27 matt struct mbuf *m;
189 1.1 cgd
190 1.5 cgd MGET(m, nowait, type);
191 1.1 cgd return (m);
192 1.1 cgd }
193 1.1 cgd
194 1.1 cgd struct mbuf *
195 1.5 cgd m_gethdr(nowait, type)
196 1.5 cgd int nowait, type;
197 1.1 cgd {
198 1.27 matt struct mbuf *m;
199 1.1 cgd
200 1.5 cgd MGETHDR(m, nowait, type);
201 1.1 cgd return (m);
202 1.1 cgd }
203 1.1 cgd
204 1.1 cgd struct mbuf *
205 1.5 cgd m_getclr(nowait, type)
206 1.5 cgd int nowait, type;
207 1.1 cgd {
208 1.27 matt struct mbuf *m;
209 1.1 cgd
210 1.5 cgd MGET(m, nowait, type);
211 1.1 cgd if (m == 0)
212 1.1 cgd return (0);
213 1.1 cgd bzero(mtod(m, caddr_t), MLEN);
214 1.1 cgd return (m);
215 1.1 cgd }
216 1.1 cgd
217 1.1 cgd struct mbuf *
218 1.1 cgd m_free(m)
219 1.1 cgd struct mbuf *m;
220 1.1 cgd {
221 1.27 matt struct mbuf *n;
222 1.1 cgd
223 1.1 cgd MFREE(m, n);
224 1.1 cgd return (n);
225 1.1 cgd }
226 1.1 cgd
227 1.9 mycroft void
228 1.1 cgd m_freem(m)
229 1.27 matt struct mbuf *m;
230 1.1 cgd {
231 1.27 matt struct mbuf *n;
232 1.1 cgd
233 1.1 cgd if (m == NULL)
234 1.1 cgd return;
235 1.1 cgd do {
236 1.1 cgd MFREE(m, n);
237 1.18 thorpej m = n;
238 1.18 thorpej } while (m);
239 1.1 cgd }
240 1.1 cgd
241 1.1 cgd /*
242 1.1 cgd * Mbuffer utility routines.
243 1.1 cgd */
244 1.1 cgd
245 1.1 cgd /*
246 1.1 cgd * Lesser-used path for M_PREPEND:
247 1.1 cgd * allocate new mbuf to prepend to chain,
248 1.1 cgd * copy junk along.
249 1.1 cgd */
250 1.1 cgd struct mbuf *
251 1.9 mycroft m_prepend(m, len, how)
252 1.27 matt struct mbuf *m;
253 1.9 mycroft int len, how;
254 1.1 cgd {
255 1.1 cgd struct mbuf *mn;
256 1.1 cgd
257 1.9 mycroft MGET(mn, how, m->m_type);
258 1.1 cgd if (mn == (struct mbuf *)NULL) {
259 1.1 cgd m_freem(m);
260 1.1 cgd return ((struct mbuf *)NULL);
261 1.1 cgd }
262 1.1 cgd if (m->m_flags & M_PKTHDR) {
263 1.1 cgd M_COPY_PKTHDR(mn, m);
264 1.1 cgd m->m_flags &= ~M_PKTHDR;
265 1.1 cgd }
266 1.1 cgd mn->m_next = m;
267 1.1 cgd m = mn;
268 1.1 cgd if (len < MHLEN)
269 1.1 cgd MH_ALIGN(m, len);
270 1.1 cgd m->m_len = len;
271 1.1 cgd return (m);
272 1.1 cgd }
273 1.1 cgd
274 1.1 cgd /*
275 1.1 cgd * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
276 1.1 cgd * continuing for "len" bytes. If len is M_COPYALL, copy to end of mbuf.
277 1.1 cgd * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
278 1.1 cgd */
279 1.1 cgd int MCFail;
280 1.1 cgd
281 1.1 cgd struct mbuf *
282 1.1 cgd m_copym(m, off0, len, wait)
283 1.27 matt struct mbuf *m;
284 1.1 cgd int off0, wait;
285 1.27 matt int len;
286 1.1 cgd {
287 1.27 matt struct mbuf *n, **np;
288 1.27 matt int off = off0;
289 1.1 cgd struct mbuf *top;
290 1.1 cgd int copyhdr = 0;
291 1.1 cgd
292 1.1 cgd if (off < 0 || len < 0)
293 1.1 cgd panic("m_copym");
294 1.1 cgd if (off == 0 && m->m_flags & M_PKTHDR)
295 1.1 cgd copyhdr = 1;
296 1.1 cgd while (off > 0) {
297 1.1 cgd if (m == 0)
298 1.1 cgd panic("m_copym");
299 1.1 cgd if (off < m->m_len)
300 1.1 cgd break;
301 1.1 cgd off -= m->m_len;
302 1.1 cgd m = m->m_next;
303 1.1 cgd }
304 1.1 cgd np = ⊤
305 1.1 cgd top = 0;
306 1.1 cgd while (len > 0) {
307 1.1 cgd if (m == 0) {
308 1.1 cgd if (len != M_COPYALL)
309 1.1 cgd panic("m_copym");
310 1.1 cgd break;
311 1.1 cgd }
312 1.1 cgd MGET(n, wait, m->m_type);
313 1.1 cgd *np = n;
314 1.1 cgd if (n == 0)
315 1.1 cgd goto nospace;
316 1.1 cgd if (copyhdr) {
317 1.1 cgd M_COPY_PKTHDR(n, m);
318 1.1 cgd if (len == M_COPYALL)
319 1.1 cgd n->m_pkthdr.len -= off0;
320 1.1 cgd else
321 1.1 cgd n->m_pkthdr.len = len;
322 1.1 cgd copyhdr = 0;
323 1.1 cgd }
324 1.9 mycroft n->m_len = min(len, m->m_len - off);
325 1.1 cgd if (m->m_flags & M_EXT) {
326 1.1 cgd n->m_data = m->m_data + off;
327 1.1 cgd n->m_ext = m->m_ext;
328 1.18 thorpej MCLADDREFERENCE(m, n);
329 1.1 cgd } else
330 1.1 cgd bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
331 1.1 cgd (unsigned)n->m_len);
332 1.1 cgd if (len != M_COPYALL)
333 1.1 cgd len -= n->m_len;
334 1.1 cgd off = 0;
335 1.1 cgd m = m->m_next;
336 1.1 cgd np = &n->m_next;
337 1.1 cgd }
338 1.1 cgd if (top == 0)
339 1.1 cgd MCFail++;
340 1.1 cgd return (top);
341 1.1 cgd nospace:
342 1.1 cgd m_freem(top);
343 1.1 cgd MCFail++;
344 1.1 cgd return (0);
345 1.1 cgd }
346 1.1 cgd
347 1.1 cgd /*
348 1.18 thorpej * Copy an entire packet, including header (which must be present).
349 1.18 thorpej * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
350 1.18 thorpej */
351 1.18 thorpej struct mbuf *
352 1.18 thorpej m_copypacket(m, how)
353 1.18 thorpej struct mbuf *m;
354 1.18 thorpej int how;
355 1.18 thorpej {
356 1.18 thorpej struct mbuf *top, *n, *o;
357 1.18 thorpej
358 1.18 thorpej MGET(n, how, m->m_type);
359 1.18 thorpej top = n;
360 1.18 thorpej if (!n)
361 1.18 thorpej goto nospace;
362 1.18 thorpej
363 1.18 thorpej M_COPY_PKTHDR(n, m);
364 1.18 thorpej n->m_len = m->m_len;
365 1.18 thorpej if (m->m_flags & M_EXT) {
366 1.18 thorpej n->m_data = m->m_data;
367 1.18 thorpej n->m_ext = m->m_ext;
368 1.18 thorpej MCLADDREFERENCE(m, n);
369 1.18 thorpej } else {
370 1.18 thorpej bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
371 1.18 thorpej }
372 1.18 thorpej
373 1.18 thorpej m = m->m_next;
374 1.18 thorpej while (m) {
375 1.18 thorpej MGET(o, how, m->m_type);
376 1.18 thorpej if (!o)
377 1.18 thorpej goto nospace;
378 1.18 thorpej
379 1.18 thorpej n->m_next = o;
380 1.18 thorpej n = n->m_next;
381 1.18 thorpej
382 1.18 thorpej n->m_len = m->m_len;
383 1.18 thorpej if (m->m_flags & M_EXT) {
384 1.18 thorpej n->m_data = m->m_data;
385 1.18 thorpej n->m_ext = m->m_ext;
386 1.18 thorpej MCLADDREFERENCE(m, n);
387 1.18 thorpej } else {
388 1.18 thorpej bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
389 1.18 thorpej }
390 1.18 thorpej
391 1.18 thorpej m = m->m_next;
392 1.18 thorpej }
393 1.18 thorpej return top;
394 1.18 thorpej nospace:
395 1.18 thorpej m_freem(top);
396 1.18 thorpej MCFail++;
397 1.18 thorpej return 0;
398 1.18 thorpej }
399 1.18 thorpej
400 1.18 thorpej /*
401 1.1 cgd * Copy data from an mbuf chain starting "off" bytes from the beginning,
402 1.1 cgd * continuing for "len" bytes, into the indicated buffer.
403 1.1 cgd */
404 1.14 christos void
405 1.1 cgd m_copydata(m, off, len, cp)
406 1.27 matt struct mbuf *m;
407 1.27 matt int off;
408 1.27 matt int len;
409 1.1 cgd caddr_t cp;
410 1.1 cgd {
411 1.27 matt unsigned count;
412 1.1 cgd
413 1.1 cgd if (off < 0 || len < 0)
414 1.1 cgd panic("m_copydata");
415 1.1 cgd while (off > 0) {
416 1.1 cgd if (m == 0)
417 1.1 cgd panic("m_copydata");
418 1.1 cgd if (off < m->m_len)
419 1.1 cgd break;
420 1.1 cgd off -= m->m_len;
421 1.1 cgd m = m->m_next;
422 1.1 cgd }
423 1.1 cgd while (len > 0) {
424 1.1 cgd if (m == 0)
425 1.1 cgd panic("m_copydata");
426 1.9 mycroft count = min(m->m_len - off, len);
427 1.1 cgd bcopy(mtod(m, caddr_t) + off, cp, count);
428 1.1 cgd len -= count;
429 1.1 cgd cp += count;
430 1.1 cgd off = 0;
431 1.1 cgd m = m->m_next;
432 1.1 cgd }
433 1.1 cgd }
434 1.1 cgd
435 1.1 cgd /*
436 1.1 cgd * Concatenate mbuf chain n to m.
437 1.1 cgd * Both chains must be of the same type (e.g. MT_DATA).
438 1.1 cgd * Any m_pkthdr is not updated.
439 1.1 cgd */
440 1.14 christos void
441 1.1 cgd m_cat(m, n)
442 1.27 matt struct mbuf *m, *n;
443 1.1 cgd {
444 1.1 cgd while (m->m_next)
445 1.1 cgd m = m->m_next;
446 1.1 cgd while (n) {
447 1.1 cgd if (m->m_flags & M_EXT ||
448 1.1 cgd m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
449 1.1 cgd /* just join the two chains */
450 1.1 cgd m->m_next = n;
451 1.1 cgd return;
452 1.1 cgd }
453 1.1 cgd /* splat the data from one into the other */
454 1.1 cgd bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
455 1.1 cgd (u_int)n->m_len);
456 1.1 cgd m->m_len += n->m_len;
457 1.1 cgd n = m_free(n);
458 1.1 cgd }
459 1.1 cgd }
460 1.1 cgd
461 1.11 mycroft void
462 1.1 cgd m_adj(mp, req_len)
463 1.1 cgd struct mbuf *mp;
464 1.8 deraadt int req_len;
465 1.1 cgd {
466 1.27 matt int len = req_len;
467 1.27 matt struct mbuf *m;
468 1.27 matt int count;
469 1.1 cgd
470 1.1 cgd if ((m = mp) == NULL)
471 1.1 cgd return;
472 1.1 cgd if (len >= 0) {
473 1.1 cgd /*
474 1.1 cgd * Trim from head.
475 1.1 cgd */
476 1.1 cgd while (m != NULL && len > 0) {
477 1.1 cgd if (m->m_len <= len) {
478 1.1 cgd len -= m->m_len;
479 1.1 cgd m->m_len = 0;
480 1.1 cgd m = m->m_next;
481 1.1 cgd } else {
482 1.1 cgd m->m_len -= len;
483 1.1 cgd m->m_data += len;
484 1.1 cgd len = 0;
485 1.1 cgd }
486 1.1 cgd }
487 1.1 cgd m = mp;
488 1.1 cgd if (mp->m_flags & M_PKTHDR)
489 1.1 cgd m->m_pkthdr.len -= (req_len - len);
490 1.1 cgd } else {
491 1.1 cgd /*
492 1.1 cgd * Trim from tail. Scan the mbuf chain,
493 1.1 cgd * calculating its length and finding the last mbuf.
494 1.1 cgd * If the adjustment only affects this mbuf, then just
495 1.1 cgd * adjust and return. Otherwise, rescan and truncate
496 1.1 cgd * after the remaining size.
497 1.1 cgd */
498 1.1 cgd len = -len;
499 1.1 cgd count = 0;
500 1.1 cgd for (;;) {
501 1.1 cgd count += m->m_len;
502 1.1 cgd if (m->m_next == (struct mbuf *)0)
503 1.1 cgd break;
504 1.1 cgd m = m->m_next;
505 1.1 cgd }
506 1.1 cgd if (m->m_len >= len) {
507 1.1 cgd m->m_len -= len;
508 1.8 deraadt if (mp->m_flags & M_PKTHDR)
509 1.8 deraadt mp->m_pkthdr.len -= len;
510 1.1 cgd return;
511 1.1 cgd }
512 1.1 cgd count -= len;
513 1.1 cgd if (count < 0)
514 1.1 cgd count = 0;
515 1.1 cgd /*
516 1.1 cgd * Correct length for chain is "count".
517 1.1 cgd * Find the mbuf with last data, adjust its length,
518 1.1 cgd * and toss data from remaining mbufs on chain.
519 1.1 cgd */
520 1.1 cgd m = mp;
521 1.1 cgd if (m->m_flags & M_PKTHDR)
522 1.1 cgd m->m_pkthdr.len = count;
523 1.1 cgd for (; m; m = m->m_next) {
524 1.1 cgd if (m->m_len >= count) {
525 1.1 cgd m->m_len = count;
526 1.1 cgd break;
527 1.1 cgd }
528 1.1 cgd count -= m->m_len;
529 1.1 cgd }
530 1.18 thorpej while (m->m_next)
531 1.18 thorpej (m = m->m_next) ->m_len = 0;
532 1.1 cgd }
533 1.1 cgd }
534 1.1 cgd
535 1.1 cgd /*
536 1.1 cgd * Rearange an mbuf chain so that len bytes are contiguous
537 1.1 cgd * and in the data area of an mbuf (so that mtod and dtom
538 1.1 cgd * will work for a structure of size len). Returns the resulting
539 1.1 cgd * mbuf chain on success, frees it and returns null on failure.
540 1.1 cgd * If there is room, it will add up to max_protohdr-len extra bytes to the
541 1.1 cgd * contiguous region in an attempt to avoid being called next time.
542 1.1 cgd */
543 1.1 cgd int MPFail;
544 1.1 cgd
545 1.1 cgd struct mbuf *
546 1.1 cgd m_pullup(n, len)
547 1.27 matt struct mbuf *n;
548 1.1 cgd int len;
549 1.1 cgd {
550 1.27 matt struct mbuf *m;
551 1.27 matt int count;
552 1.1 cgd int space;
553 1.1 cgd
554 1.1 cgd /*
555 1.1 cgd * If first mbuf has no cluster, and has room for len bytes
556 1.1 cgd * without shifting current data, pullup into it,
557 1.1 cgd * otherwise allocate a new mbuf to prepend to the chain.
558 1.1 cgd */
559 1.1 cgd if ((n->m_flags & M_EXT) == 0 &&
560 1.1 cgd n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
561 1.1 cgd if (n->m_len >= len)
562 1.1 cgd return (n);
563 1.1 cgd m = n;
564 1.1 cgd n = n->m_next;
565 1.1 cgd len -= m->m_len;
566 1.1 cgd } else {
567 1.1 cgd if (len > MHLEN)
568 1.1 cgd goto bad;
569 1.1 cgd MGET(m, M_DONTWAIT, n->m_type);
570 1.1 cgd if (m == 0)
571 1.1 cgd goto bad;
572 1.1 cgd m->m_len = 0;
573 1.1 cgd if (n->m_flags & M_PKTHDR) {
574 1.1 cgd M_COPY_PKTHDR(m, n);
575 1.1 cgd n->m_flags &= ~M_PKTHDR;
576 1.1 cgd }
577 1.1 cgd }
578 1.1 cgd space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
579 1.1 cgd do {
580 1.1 cgd count = min(min(max(len, max_protohdr), space), n->m_len);
581 1.1 cgd bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
582 1.1 cgd (unsigned)count);
583 1.1 cgd len -= count;
584 1.1 cgd m->m_len += count;
585 1.1 cgd n->m_len -= count;
586 1.1 cgd space -= count;
587 1.1 cgd if (n->m_len)
588 1.1 cgd n->m_data += count;
589 1.1 cgd else
590 1.1 cgd n = m_free(n);
591 1.1 cgd } while (len > 0 && n);
592 1.1 cgd if (len > 0) {
593 1.1 cgd (void) m_free(m);
594 1.1 cgd goto bad;
595 1.1 cgd }
596 1.1 cgd m->m_next = n;
597 1.1 cgd return (m);
598 1.1 cgd bad:
599 1.1 cgd m_freem(n);
600 1.1 cgd MPFail++;
601 1.1 cgd return (0);
602 1.9 mycroft }
603 1.9 mycroft
604 1.9 mycroft /*
605 1.9 mycroft * Partition an mbuf chain in two pieces, returning the tail --
606 1.9 mycroft * all but the first len0 bytes. In case of failure, it returns NULL and
607 1.9 mycroft * attempts to restore the chain to its original state.
608 1.9 mycroft */
609 1.9 mycroft struct mbuf *
610 1.9 mycroft m_split(m0, len0, wait)
611 1.27 matt struct mbuf *m0;
612 1.9 mycroft int len0, wait;
613 1.9 mycroft {
614 1.27 matt struct mbuf *m, *n;
615 1.22 thorpej unsigned len = len0, remain, len_save;
616 1.9 mycroft
617 1.9 mycroft for (m = m0; m && len > m->m_len; m = m->m_next)
618 1.9 mycroft len -= m->m_len;
619 1.9 mycroft if (m == 0)
620 1.9 mycroft return (0);
621 1.9 mycroft remain = m->m_len - len;
622 1.9 mycroft if (m0->m_flags & M_PKTHDR) {
623 1.9 mycroft MGETHDR(n, wait, m0->m_type);
624 1.9 mycroft if (n == 0)
625 1.9 mycroft return (0);
626 1.9 mycroft n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
627 1.9 mycroft n->m_pkthdr.len = m0->m_pkthdr.len - len0;
628 1.22 thorpej len_save = m0->m_pkthdr.len;
629 1.9 mycroft m0->m_pkthdr.len = len0;
630 1.9 mycroft if (m->m_flags & M_EXT)
631 1.9 mycroft goto extpacket;
632 1.9 mycroft if (remain > MHLEN) {
633 1.9 mycroft /* m can't be the lead packet */
634 1.9 mycroft MH_ALIGN(n, 0);
635 1.9 mycroft n->m_next = m_split(m, len, wait);
636 1.9 mycroft if (n->m_next == 0) {
637 1.9 mycroft (void) m_free(n);
638 1.22 thorpej m0->m_pkthdr.len = len_save;
639 1.9 mycroft return (0);
640 1.9 mycroft } else
641 1.9 mycroft return (n);
642 1.9 mycroft } else
643 1.9 mycroft MH_ALIGN(n, remain);
644 1.9 mycroft } else if (remain == 0) {
645 1.9 mycroft n = m->m_next;
646 1.9 mycroft m->m_next = 0;
647 1.9 mycroft return (n);
648 1.9 mycroft } else {
649 1.9 mycroft MGET(n, wait, m->m_type);
650 1.9 mycroft if (n == 0)
651 1.9 mycroft return (0);
652 1.9 mycroft M_ALIGN(n, remain);
653 1.9 mycroft }
654 1.9 mycroft extpacket:
655 1.9 mycroft if (m->m_flags & M_EXT) {
656 1.9 mycroft n->m_ext = m->m_ext;
657 1.18 thorpej MCLADDREFERENCE(m, n);
658 1.9 mycroft n->m_data = m->m_data + len;
659 1.9 mycroft } else {
660 1.9 mycroft bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
661 1.9 mycroft }
662 1.9 mycroft n->m_len = remain;
663 1.9 mycroft m->m_len = len;
664 1.9 mycroft n->m_next = m->m_next;
665 1.9 mycroft m->m_next = 0;
666 1.9 mycroft return (n);
667 1.9 mycroft }
668 1.9 mycroft /*
669 1.9 mycroft * Routine to copy from device local memory into mbufs.
670 1.9 mycroft */
671 1.9 mycroft struct mbuf *
672 1.9 mycroft m_devget(buf, totlen, off0, ifp, copy)
673 1.9 mycroft char *buf;
674 1.9 mycroft int totlen, off0;
675 1.9 mycroft struct ifnet *ifp;
676 1.18 thorpej void (*copy) __P((const void *from, void *to, size_t len));
677 1.9 mycroft {
678 1.27 matt struct mbuf *m;
679 1.9 mycroft struct mbuf *top = 0, **mp = ⊤
680 1.27 matt int off = off0, len;
681 1.27 matt char *cp;
682 1.9 mycroft char *epkt;
683 1.9 mycroft
684 1.9 mycroft cp = buf;
685 1.9 mycroft epkt = cp + totlen;
686 1.9 mycroft if (off) {
687 1.13 cgd /*
688 1.13 cgd * If 'off' is non-zero, packet is trailer-encapsulated,
689 1.13 cgd * so we have to skip the type and length fields.
690 1.13 cgd */
691 1.13 cgd cp += off + 2 * sizeof(u_int16_t);
692 1.13 cgd totlen -= 2 * sizeof(u_int16_t);
693 1.9 mycroft }
694 1.9 mycroft MGETHDR(m, M_DONTWAIT, MT_DATA);
695 1.9 mycroft if (m == 0)
696 1.9 mycroft return (0);
697 1.9 mycroft m->m_pkthdr.rcvif = ifp;
698 1.9 mycroft m->m_pkthdr.len = totlen;
699 1.9 mycroft m->m_len = MHLEN;
700 1.9 mycroft
701 1.9 mycroft while (totlen > 0) {
702 1.9 mycroft if (top) {
703 1.9 mycroft MGET(m, M_DONTWAIT, MT_DATA);
704 1.9 mycroft if (m == 0) {
705 1.9 mycroft m_freem(top);
706 1.9 mycroft return (0);
707 1.9 mycroft }
708 1.9 mycroft m->m_len = MLEN;
709 1.9 mycroft }
710 1.9 mycroft len = min(totlen, epkt - cp);
711 1.9 mycroft if (len >= MINCLSIZE) {
712 1.9 mycroft MCLGET(m, M_DONTWAIT);
713 1.19 mycroft if ((m->m_flags & M_EXT) == 0) {
714 1.20 mycroft m_free(m);
715 1.19 mycroft m_freem(top);
716 1.19 mycroft return (0);
717 1.19 mycroft }
718 1.19 mycroft m->m_len = len = min(len, MCLBYTES);
719 1.9 mycroft } else {
720 1.9 mycroft /*
721 1.9 mycroft * Place initial small packet/header at end of mbuf.
722 1.9 mycroft */
723 1.9 mycroft if (len < m->m_len) {
724 1.9 mycroft if (top == 0 && len + max_linkhdr <= m->m_len)
725 1.9 mycroft m->m_data += max_linkhdr;
726 1.9 mycroft m->m_len = len;
727 1.9 mycroft } else
728 1.9 mycroft len = m->m_len;
729 1.9 mycroft }
730 1.9 mycroft if (copy)
731 1.14 christos copy(cp, mtod(m, caddr_t), (size_t)len);
732 1.9 mycroft else
733 1.14 christos bcopy(cp, mtod(m, caddr_t), (size_t)len);
734 1.9 mycroft cp += len;
735 1.9 mycroft *mp = m;
736 1.9 mycroft mp = &m->m_next;
737 1.9 mycroft totlen -= len;
738 1.9 mycroft if (cp == epkt)
739 1.9 mycroft cp = buf;
740 1.9 mycroft }
741 1.9 mycroft return (top);
742 1.18 thorpej }
743 1.18 thorpej
744 1.18 thorpej /*
745 1.18 thorpej * Copy data from a buffer back into the indicated mbuf chain,
746 1.18 thorpej * starting "off" bytes from the beginning, extending the mbuf
747 1.18 thorpej * chain if necessary.
748 1.18 thorpej */
749 1.18 thorpej void
750 1.18 thorpej m_copyback(m0, off, len, cp)
751 1.18 thorpej struct mbuf *m0;
752 1.27 matt int off;
753 1.27 matt int len;
754 1.18 thorpej caddr_t cp;
755 1.18 thorpej {
756 1.27 matt int mlen;
757 1.27 matt struct mbuf *m = m0, *n;
758 1.18 thorpej int totlen = 0;
759 1.18 thorpej
760 1.18 thorpej if (m0 == 0)
761 1.18 thorpej return;
762 1.18 thorpej while (off > (mlen = m->m_len)) {
763 1.18 thorpej off -= mlen;
764 1.18 thorpej totlen += mlen;
765 1.18 thorpej if (m->m_next == 0) {
766 1.18 thorpej n = m_getclr(M_DONTWAIT, m->m_type);
767 1.18 thorpej if (n == 0)
768 1.18 thorpej goto out;
769 1.18 thorpej n->m_len = min(MLEN, len + off);
770 1.18 thorpej m->m_next = n;
771 1.18 thorpej }
772 1.18 thorpej m = m->m_next;
773 1.18 thorpej }
774 1.18 thorpej while (len > 0) {
775 1.18 thorpej mlen = min (m->m_len - off, len);
776 1.18 thorpej bcopy(cp, mtod(m, caddr_t) + off, (unsigned)mlen);
777 1.18 thorpej cp += mlen;
778 1.18 thorpej len -= mlen;
779 1.18 thorpej mlen += off;
780 1.18 thorpej off = 0;
781 1.18 thorpej totlen += mlen;
782 1.18 thorpej if (len == 0)
783 1.18 thorpej break;
784 1.18 thorpej if (m->m_next == 0) {
785 1.18 thorpej n = m_get(M_DONTWAIT, m->m_type);
786 1.18 thorpej if (n == 0)
787 1.18 thorpej break;
788 1.18 thorpej n->m_len = min(MLEN, len);
789 1.18 thorpej m->m_next = n;
790 1.18 thorpej }
791 1.18 thorpej m = m->m_next;
792 1.18 thorpej }
793 1.18 thorpej out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
794 1.18 thorpej m->m_pkthdr.len = totlen;
795 1.1 cgd }
796