| 1 | /* $NetBSD: uipc_mbuf2.c,v 1.30 2013/10/08 19:59:49 christos Exp $ */ |
| 2 | /* $KAME: uipc_mbuf2.c,v 1.29 2001/02/14 13:42:10 itojun Exp $ */ |
| 3 | |
| 4 | /* |
| 5 | * Copyright (C) 1999 WIDE Project. |
| 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 project 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 PROJECT 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 PROJECT 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 | |
| 33 | /* |
| 34 | * Copyright (c) 1982, 1986, 1988, 1991, 1993 |
| 35 | * The Regents of the University of California. All rights reserved. |
| 36 | * |
| 37 | * Redistribution and use in source and binary forms, with or without |
| 38 | * modification, are permitted provided that the following conditions |
| 39 | * are met: |
| 40 | * 1. Redistributions of source code must retain the above copyright |
| 41 | * notice, this list of conditions and the following disclaimer. |
| 42 | * 2. Redistributions in binary form must reproduce the above copyright |
| 43 | * notice, this list of conditions and the following disclaimer in the |
| 44 | * documentation and/or other materials provided with the distribution. |
| 45 | * 3. Neither the name of the University nor the names of its contributors |
| 46 | * may be used to endorse or promote products derived from this software |
| 47 | * without specific prior written permission. |
| 48 | * |
| 49 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 50 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 51 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 52 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 53 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 54 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 55 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 56 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 57 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 58 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 59 | * SUCH DAMAGE. |
| 60 | * |
| 61 | * @(#)uipc_mbuf.c 8.4 (Berkeley) 2/14/95 |
| 62 | */ |
| 63 | |
| 64 | #include <sys/cdefs.h> |
| 65 | __KERNEL_RCSID(0, "$NetBSD: uipc_mbuf2.c,v 1.30 2013/10/08 19:59:49 christos Exp $" ); |
| 66 | |
| 67 | #include <sys/param.h> |
| 68 | #include <sys/systm.h> |
| 69 | #include <sys/proc.h> |
| 70 | #include <sys/malloc.h> |
| 71 | #include <sys/mbuf.h> |
| 72 | |
| 73 | MALLOC_DEFINE(M_PACKET_TAGS, "packet tags" , "Packet-attached information" ); |
| 74 | |
| 75 | /* |
| 76 | * ensure that [off, off + len) is contiguous on the mbuf chain "m". |
| 77 | * packet chain before "off" is kept untouched. |
| 78 | * if offp == NULL, the target will start at <retval, 0> on resulting chain. |
| 79 | * if offp != NULL, the target will start at <retval, *offp> on resulting chain. |
| 80 | * |
| 81 | * on error return (NULL return value), original "m" will be freed. |
| 82 | * |
| 83 | * XXX M_TRAILINGSPACE/M_LEADINGSPACE on shared cluster (sharedcluster) |
| 84 | */ |
| 85 | struct mbuf * |
| 86 | m_pulldown(struct mbuf *m, int off, int len, int *offp) |
| 87 | { |
| 88 | struct mbuf *n, *o; |
| 89 | int hlen, tlen, olen; |
| 90 | int sharedcluster; |
| 91 | |
| 92 | /* check invalid arguments. */ |
| 93 | if (m == NULL) |
| 94 | panic("m == NULL in m_pulldown()" ); |
| 95 | if (len > MCLBYTES) { |
| 96 | m_freem(m); |
| 97 | return NULL; /* impossible */ |
| 98 | } |
| 99 | |
| 100 | n = m; |
| 101 | while (n != NULL && off > 0) { |
| 102 | if (n->m_len > off) |
| 103 | break; |
| 104 | off -= n->m_len; |
| 105 | n = n->m_next; |
| 106 | } |
| 107 | /* be sure to point non-empty mbuf */ |
| 108 | while (n != NULL && n->m_len == 0) |
| 109 | n = n->m_next; |
| 110 | if (!n) { |
| 111 | m_freem(m); |
| 112 | return NULL; /* mbuf chain too short */ |
| 113 | } |
| 114 | |
| 115 | sharedcluster = M_READONLY(n); |
| 116 | |
| 117 | /* |
| 118 | * the target data is on <n, off>. |
| 119 | * if we got enough data on the mbuf "n", we're done. |
| 120 | */ |
| 121 | if ((off == 0 || offp) && len <= n->m_len - off && !sharedcluster) |
| 122 | goto ok; |
| 123 | |
| 124 | /* |
| 125 | * when len <= n->m_len - off and off != 0, it is a special case. |
| 126 | * len bytes from <n, off> sits in single mbuf, but the caller does |
| 127 | * not like the starting position (off). |
| 128 | * chop the current mbuf into two pieces, set off to 0. |
| 129 | */ |
| 130 | if (len <= n->m_len - off) { |
| 131 | struct mbuf *mlast; |
| 132 | |
| 133 | o = m_dup(n, off, n->m_len - off, M_DONTWAIT); |
| 134 | if (o == NULL) { |
| 135 | m_freem(m); |
| 136 | return NULL; /* ENOBUFS */ |
| 137 | } |
| 138 | KASSERT(o->m_len >= len); |
| 139 | for (mlast = o; mlast->m_next != NULL; mlast = mlast->m_next) |
| 140 | ; |
| 141 | n->m_len = off; |
| 142 | mlast->m_next = n->m_next; |
| 143 | n->m_next = o; |
| 144 | n = o; |
| 145 | off = 0; |
| 146 | goto ok; |
| 147 | } |
| 148 | |
| 149 | /* |
| 150 | * we need to take hlen from <n, off> and tlen from <n->m_next, 0>, |
| 151 | * and construct contiguous mbuf with m_len == len. |
| 152 | * note that hlen + tlen == len, and tlen > 0. |
| 153 | */ |
| 154 | hlen = n->m_len - off; |
| 155 | tlen = len - hlen; |
| 156 | |
| 157 | /* |
| 158 | * ensure that we have enough trailing data on mbuf chain. |
| 159 | * if not, we can do nothing about the chain. |
| 160 | */ |
| 161 | olen = 0; |
| 162 | for (o = n->m_next; o != NULL; o = o->m_next) |
| 163 | olen += o->m_len; |
| 164 | if (hlen + olen < len) { |
| 165 | m_freem(m); |
| 166 | return NULL; /* mbuf chain too short */ |
| 167 | } |
| 168 | |
| 169 | /* |
| 170 | * easy cases first. |
| 171 | * we need to use m_copydata() to get data from <n->m_next, 0>. |
| 172 | */ |
| 173 | if ((off == 0 || offp) && M_TRAILINGSPACE(n) >= tlen && |
| 174 | !sharedcluster) { |
| 175 | m_copydata(n->m_next, 0, tlen, mtod(n, char *) + n->m_len); |
| 176 | n->m_len += tlen; |
| 177 | m_adj(n->m_next, tlen); |
| 178 | goto ok; |
| 179 | } |
| 180 | if ((off == 0 || offp) && M_LEADINGSPACE(n->m_next) >= hlen && |
| 181 | !sharedcluster && n->m_next->m_len >= tlen) { |
| 182 | n->m_next->m_data -= hlen; |
| 183 | n->m_next->m_len += hlen; |
| 184 | memcpy(mtod(n->m_next, void *), mtod(n, char *) + off, hlen); |
| 185 | n->m_len -= hlen; |
| 186 | n = n->m_next; |
| 187 | off = 0; |
| 188 | goto ok; |
| 189 | } |
| 190 | |
| 191 | /* |
| 192 | * now, we need to do the hard way. don't m_copy as there's no room |
| 193 | * on both end. |
| 194 | */ |
| 195 | o = m_get(M_DONTWAIT, m->m_type); |
| 196 | if (o && len > MLEN) { |
| 197 | MCLGET(o, M_DONTWAIT); |
| 198 | if ((o->m_flags & M_EXT) == 0) { |
| 199 | m_free(o); |
| 200 | o = NULL; |
| 201 | } |
| 202 | } |
| 203 | if (!o) { |
| 204 | m_freem(m); |
| 205 | return NULL; /* ENOBUFS */ |
| 206 | } |
| 207 | /* get hlen from <n, off> into <o, 0> */ |
| 208 | o->m_len = hlen; |
| 209 | memcpy(mtod(o, void *), mtod(n, char *) + off, hlen); |
| 210 | n->m_len -= hlen; |
| 211 | /* get tlen from <n->m_next, 0> into <o, hlen> */ |
| 212 | m_copydata(n->m_next, 0, tlen, mtod(o, char *) + o->m_len); |
| 213 | o->m_len += tlen; |
| 214 | m_adj(n->m_next, tlen); |
| 215 | o->m_next = n->m_next; |
| 216 | n->m_next = o; |
| 217 | n = o; |
| 218 | off = 0; |
| 219 | |
| 220 | ok: |
| 221 | if (offp) |
| 222 | *offp = off; |
| 223 | return n; |
| 224 | } |
| 225 | |
| 226 | /* |
| 227 | * FreeBSD 4.6 introduced m_getcl(), which performs `fast' allocation |
| 228 | * mbuf clusters from a cache of recently-freed clusters. (If the cache |
| 229 | * is empty, new clusters are allocated en-masse). |
| 230 | * On NetBSD, for now, implement the `cache' as a function |
| 231 | * using normal NetBSD mbuf/cluster allocation macros. Replace this |
| 232 | * with fast-cache code, if and when NetBSD implements one. |
| 233 | */ |
| 234 | struct mbuf * |
| 235 | m_getcl(int how, int type, int flags) |
| 236 | { |
| 237 | struct mbuf *mp; |
| 238 | |
| 239 | if ((flags & M_PKTHDR) != 0) |
| 240 | mp = m_gethdr(how, type); |
| 241 | else |
| 242 | mp = m_get(how, type); |
| 243 | |
| 244 | if (mp == NULL) |
| 245 | return NULL; |
| 246 | |
| 247 | MCLGET(mp, how); |
| 248 | if ((mp->m_flags & M_EXT) != 0) |
| 249 | return mp; |
| 250 | |
| 251 | m_free(mp); |
| 252 | return NULL; |
| 253 | } |
| 254 | |
| 255 | /* Get a packet tag structure along with specified data following. */ |
| 256 | struct m_tag * |
| 257 | m_tag_get(int type, int len, int wait) |
| 258 | { |
| 259 | struct m_tag *t; |
| 260 | |
| 261 | if (len < 0) |
| 262 | return (NULL); |
| 263 | t = malloc(len + sizeof(struct m_tag), M_PACKET_TAGS, wait); |
| 264 | if (t == NULL) |
| 265 | return (NULL); |
| 266 | t->m_tag_id = type; |
| 267 | t->m_tag_len = len; |
| 268 | return (t); |
| 269 | } |
| 270 | |
| 271 | /* Free a packet tag. */ |
| 272 | void |
| 273 | m_tag_free(struct m_tag *t) |
| 274 | { |
| 275 | |
| 276 | free(t, M_PACKET_TAGS); |
| 277 | } |
| 278 | |
| 279 | /* Prepend a packet tag. */ |
| 280 | void |
| 281 | m_tag_prepend(struct mbuf *m, struct m_tag *t) |
| 282 | { |
| 283 | |
| 284 | SLIST_INSERT_HEAD(&m->m_pkthdr.tags, t, m_tag_link); |
| 285 | } |
| 286 | |
| 287 | /* Unlink a packet tag. */ |
| 288 | void |
| 289 | m_tag_unlink(struct mbuf *m, struct m_tag *t) |
| 290 | { |
| 291 | |
| 292 | SLIST_REMOVE(&m->m_pkthdr.tags, t, m_tag, m_tag_link); |
| 293 | } |
| 294 | |
| 295 | /* Unlink and free a packet tag. */ |
| 296 | void |
| 297 | m_tag_delete(struct mbuf *m, struct m_tag *t) |
| 298 | { |
| 299 | |
| 300 | m_tag_unlink(m, t); |
| 301 | m_tag_free(t); |
| 302 | } |
| 303 | |
| 304 | /* Unlink and free a packet tag chain, starting from given tag. */ |
| 305 | void |
| 306 | m_tag_delete_chain(struct mbuf *m, struct m_tag *t) |
| 307 | { |
| 308 | struct m_tag *p, *q; |
| 309 | |
| 310 | if (t != NULL) |
| 311 | p = t; |
| 312 | else |
| 313 | p = SLIST_FIRST(&m->m_pkthdr.tags); |
| 314 | if (p == NULL) |
| 315 | return; |
| 316 | while ((q = SLIST_NEXT(p, m_tag_link)) != NULL) |
| 317 | m_tag_delete(m, q); |
| 318 | m_tag_delete(m, p); |
| 319 | } |
| 320 | |
| 321 | /* |
| 322 | * Strip off all tags that would normally vanish when |
| 323 | * passing through a network interface. Only persistent |
| 324 | * tags will exist after this; these are expected to remain |
| 325 | * so long as the mbuf chain exists, regardless of the |
| 326 | * path the mbufs take. |
| 327 | */ |
| 328 | void |
| 329 | m_tag_delete_nonpersistent(struct mbuf *m) |
| 330 | { |
| 331 | /* NetBSD has no persistent tags yet, so just delete all tags. */ |
| 332 | m_tag_delete_chain(m, NULL); |
| 333 | } |
| 334 | |
| 335 | |
| 336 | /* Find a tag, starting from a given position. */ |
| 337 | struct m_tag * |
| 338 | m_tag_find(const struct mbuf *m, int type, struct m_tag *t) |
| 339 | { |
| 340 | struct m_tag *p; |
| 341 | |
| 342 | if (t == NULL) |
| 343 | p = SLIST_FIRST(&m->m_pkthdr.tags); |
| 344 | else |
| 345 | p = SLIST_NEXT(t, m_tag_link); |
| 346 | while (p != NULL) { |
| 347 | if (p->m_tag_id == type) |
| 348 | return (p); |
| 349 | p = SLIST_NEXT(p, m_tag_link); |
| 350 | } |
| 351 | return (NULL); |
| 352 | } |
| 353 | |
| 354 | /* Copy a single tag. */ |
| 355 | struct m_tag * |
| 356 | m_tag_copy(struct m_tag *t) |
| 357 | { |
| 358 | struct m_tag *p; |
| 359 | |
| 360 | p = m_tag_get(t->m_tag_id, t->m_tag_len, M_NOWAIT); |
| 361 | if (p == NULL) |
| 362 | return (NULL); |
| 363 | memcpy(p + 1, t + 1, t->m_tag_len); /* Copy the data */ |
| 364 | return (p); |
| 365 | } |
| 366 | |
| 367 | /* |
| 368 | * Copy two tag chains. The destination mbuf (to) loses any attached |
| 369 | * tags even if the operation fails. This should not be a problem, as |
| 370 | * m_tag_copy_chain() is typically called with a newly-allocated |
| 371 | * destination mbuf. |
| 372 | */ |
| 373 | int |
| 374 | m_tag_copy_chain(struct mbuf *to, struct mbuf *from) |
| 375 | { |
| 376 | struct m_tag *p, *t, *tprev = NULL; |
| 377 | |
| 378 | m_tag_delete_chain(to, NULL); |
| 379 | SLIST_FOREACH(p, &from->m_pkthdr.tags, m_tag_link) { |
| 380 | t = m_tag_copy(p); |
| 381 | if (t == NULL) { |
| 382 | m_tag_delete_chain(to, NULL); |
| 383 | return (0); |
| 384 | } |
| 385 | if (tprev == NULL) |
| 386 | SLIST_INSERT_HEAD(&to->m_pkthdr.tags, t, m_tag_link); |
| 387 | else |
| 388 | SLIST_INSERT_AFTER(tprev, t, m_tag_link); |
| 389 | tprev = t; |
| 390 | } |
| 391 | return (1); |
| 392 | } |
| 393 | |
| 394 | /* Initialize tags on an mbuf. */ |
| 395 | void |
| 396 | m_tag_init(struct mbuf *m) |
| 397 | { |
| 398 | |
| 399 | SLIST_INIT(&m->m_pkthdr.tags); |
| 400 | } |
| 401 | |
| 402 | /* Get first tag in chain. */ |
| 403 | struct m_tag * |
| 404 | m_tag_first(struct mbuf *m) |
| 405 | { |
| 406 | |
| 407 | return (SLIST_FIRST(&m->m_pkthdr.tags)); |
| 408 | } |
| 409 | |
| 410 | /* Get next tag in chain. */ |
| 411 | struct m_tag * |
| 412 | m_tag_next(struct mbuf *m, struct m_tag *t) |
| 413 | { |
| 414 | |
| 415 | return (SLIST_NEXT(t, m_tag_link)); |
| 416 | } |
| 417 | |