Lines Matching full:m
147 #define M_DATABUF(m) ((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf : \
148 (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
149 #define M_SIZE(m) ((m)->m_flags & M_EXT ? (m)->m_ext.ext_size : \
150 (m)->m_flags & M_PKTHDR ? MHLEN : MLEN)
237 struct mbuf *m;
242 m = pool_get(&mbpool, nowait == M_WAIT ? PR_WAITOK : PR_NOWAIT);
243 if (m == NULL)
250 m->m_type = type;
251 m->m_next = NULL;
252 m->m_nextpkt = NULL;
253 m->m_data = m->m_dat;
254 m->m_flags = 0;
256 return (m);
266 struct mbuf *m;
271 m = pool_get(&mbpool, nowait == M_WAIT ? PR_WAITOK : PR_NOWAIT);
272 if (m == NULL)
279 m->m_type = type;
281 return (m_inithdr(m));
285 m_inithdr(struct mbuf *m)
288 m->m_next = NULL;
289 m->m_nextpkt = NULL;
290 m->m_data = m->m_pktdat;
291 m->m_flags = M_PKTHDR;
292 memset(&m->m_pkthdr, 0, sizeof(m->m_pkthdr));
293 m->m_pkthdr.pf.prio = IFQ_DEFPRIO;
295 return (m);
299 m_clearhdr(struct mbuf *m)
302 m_tag_delete_chain(m);
304 pf_mbuf_unlink_state_key(m);
305 pf_mbuf_unlink_inpcb(m);
308 memset(&m->m_pkthdr, 0, sizeof(m->m_pkthdr));
312 m_removehdr(struct mbuf *m)
314 KASSERT(m->m_flags & M_PKTHDR);
315 m_clearhdr(m);
316 m->m_flags &= ~M_PKTHDR;
320 m_resethdr(struct mbuf *m)
322 int len = m->m_pkthdr.len;
323 u_int8_t loopcnt = m->m_pkthdr.ph_loopcnt;
325 KASSERT(m->m_flags & M_PKTHDR);
326 m->m_flags &= (M_EXT|M_PKTHDR|M_EOR|M_EXTWR|M_ZEROIZE);
327 m_clearhdr(m);
329 m->m_pkthdr.pf.prio = IFQ_DEFPRIO;
330 m->m_pkthdr.len = len;
331 m->m_pkthdr.ph_loopcnt = loopcnt;
335 m_calchdrlen(struct mbuf *m)
340 KASSERT(m->m_flags & M_PKTHDR);
341 for (n = m; n; n = n->m_next)
343 m->m_pkthdr.len = plen;
349 struct mbuf *m;
351 MGET(m, nowait, type);
352 if (m == NULL)
354 memset(mtod(m, caddr_t), 0, MLEN);
355 return (m);
374 m_clget(struct mbuf *m, int how, u_int pktlen)
386 if (m == NULL) {
391 m = m0;
399 MEXTADD(m, buf, pp->pr_size, M_EXTWR, MEXTFREE_POOL, pp);
400 return (m);
410 m_free(struct mbuf *m)
415 if (m == NULL)
419 counters_dec(mbstat, m->m_type);
422 n = m->m_next;
423 if (m->m_flags & M_ZEROIZE) {
424 m_zero(m);
429 if (m->m_flags & M_PKTHDR) {
430 m_tag_delete_chain(m);
432 pf_mbuf_unlink_state_key(m);
433 pf_mbuf_unlink_inpcb(m);
436 if (m->m_flags & M_EXT)
437 m_extfree(m);
439 pool_put(&mbpool, m);
464 m_extunref(struct mbuf *m)
468 if (!MCLISREFERENCED(m))
472 if (MCLISREFERENCED(m)) {
473 m->m_ext.ext_nextref->m_ext.ext_prevref =
474 m->m_ext.ext_prevref;
475 m->m_ext.ext_prevref->m_ext.ext_nextref =
476 m->m_ext.ext_nextref;
498 m_extfree(struct mbuf *m)
500 if (m_extunref(m) == 0) {
501 KASSERT(m->m_ext.ext_free_fn < num_extfree_fns);
502 mextfree_fns[m->m_ext.ext_free_fn](m->m_ext.ext_buf,
503 m->m_ext.ext_size, m->m_ext.ext_arg);
506 m->m_flags &= ~(M_EXT|M_EXTWR);
510 m_freem(struct mbuf *m)
514 if (m == NULL)
517 n = m->m_nextpkt;
520 m = m_free(m);
521 while (m != NULL);
527 m_purge(struct mbuf *m)
529 while (m != NULL)
530 m = m_freem(m);
540 m_defrag(struct mbuf *m, int how)
544 if (m->m_next == NULL)
547 KASSERT(m->m_flags & M_PKTHDR);
550 if ((m0 = m_gethdr(how, m->m_type)) == NULL)
552 if (m->m_pkthdr.len > MHLEN) {
553 MCLGETL(m0, how, m->m_pkthdr.len);
559 m_copydata(m, 0, m->m_pkthdr.len, mtod(m0, caddr_t));
560 m0->m_pkthdr.len = m0->m_len = m->m_pkthdr.len;
563 m_freem(m->m_next);
564 m->m_next = NULL;
565 if (m->m_flags & M_EXT)
566 m_extfree(m);
574 memcpy(&m->m_ext, &m0->m_ext, sizeof(struct mbuf_ext));
575 MCLINITREFERENCE(m);
576 m->m_flags |= m0->m_flags & (M_EXT|M_EXTWR);
577 m->m_data = m->m_ext.ext_buf;
579 m->m_data = m->m_pktdat;
580 memcpy(m->m_data, m0->m_data, m0->m_len);
582 m->m_pkthdr.len = m->m_len = m0->m_len;
598 m_prepend(struct mbuf *m, int len, int how)
605 if (m_leadingspace(m) >= len) {
606 m->m_data -= len;
607 m->m_len += len;
610 MGET(mn, how, m->m_type);
612 m_freem(m);
615 if (m->m_flags & M_PKTHDR)
616 M_MOVE_PKTHDR(mn, m);
617 mn->m_next = m;
618 m = mn;
619 m_align(m, len);
620 m->m_len = len;
622 if (m->m_flags & M_PKTHDR)
623 m->m_pkthdr.len += len;
624 return (m);
635 struct mbuf *m, *n, **np;
643 if ((m = m_getptr(m0, off, &off)) == NULL)
648 if (m == NULL) {
650 panic("m_copym0: m == NULL and not COPYALL");
653 MGET(n, wait, m->m_type);
664 n->m_len = min(len, m->m_len - off);
665 if (m->m_flags & M_EXT) {
666 n->m_data = m->m_data + off;
667 n->m_ext = m->m_ext;
668 MCLADDREFERENCE(m, n);
670 n->m_data += m->m_data -
671 (m->m_flags & M_PKTHDR ? m->m_pktdat : m->m_dat);
673 memcpy(mtod(n, caddr_t), mtod(m, caddr_t) + off,
680 if (off > m->m_len)
683 if (off == m->m_len) {
684 m = m->m_next;
700 m_copydata(struct mbuf *m, int off, int len, void *p)
709 if ((m = m_getptr(m, off, &off)) == NULL)
712 if (m == NULL)
714 count = min(m->m_len - off, len);
715 memmove(cp, mtod(m, caddr_t) + off, count);
719 m = m->m_next;
733 struct mbuf *m = m0, *n;
739 while (off > (mlen = m->m_len)) {
742 if (m->m_next == NULL) {
743 if ((n = m_get(wait, m->m_type)) == NULL) {
758 m->m_next = n;
760 m = m->m_next;
764 if (m->m_next == NULL && (len > m->m_len - off))
765 m->m_len += min(len - (m->m_len - off),
766 m_trailingspace(m));
767 mlen = min(m->m_len - off, len);
768 memmove(mtod(m, caddr_t) + off, cp, mlen);
776 if (m->m_next == NULL) {
777 if ((n = m_get(wait, m->m_type)) == NULL) {
791 m->m_next = n;
793 m = m->m_next;
796 if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
797 m->m_pkthdr.len = totlen;
803 * Concatenate mbuf chain n to m.
804 * n might be copied into m (when n->m_len is small), therefore data portion of
810 m_cat(struct mbuf *m, struct mbuf *n)
812 while (m->m_next)
813 m = m->m_next;
815 if (M_READONLY(m) || n->m_len > m_trailingspace(m)) {
817 m->m_next = n;
821 memcpy(mtod(m, caddr_t) + m->m_len, mtod(n, caddr_t),
823 m->m_len += n->m_len;
832 struct mbuf *m;
841 m = mp;
842 while (m != NULL && len > 0) {
843 if (m->m_len <= len) {
844 len -= m->m_len;
845 m->m_data += m->m_len;
846 m->m_len = 0;
847 m = m->m_next;
849 m->m_data += len;
850 m->m_len -= len;
866 m = mp;
868 count += m->m_len;
869 if (m->m_next == NULL)
871 m = m->m_next;
873 if (m->m_len >= len) {
874 m->m_len -= len;
889 m = mp;
891 if (m->m_len >= count) {
892 m->m_len = count;
895 count -= m->m_len;
896 m = m->m_next;
898 while ((m = m->m_next) != NULL)
899 m->m_len = 0;
912 struct mbuf *m;
922 m = m0->m_next;
923 if (m == NULL)
928 while (m->m_len == 0) {
929 m = m_free(m);
930 if (m == NULL)
934 adj = mtod(m, unsigned long) & (sizeof(long) - 1);
959 m0->m_next = m;
960 m = m0;
963 MGET(m0, M_DONTWAIT, m->m_type);
973 if (m->m_flags & M_PKTHDR)
974 M_MOVE_PKTHDR(m0, m);
983 space = min(len, m->m_len);
984 memcpy(mtod(m0, caddr_t) + m0->m_len, mtod(m, caddr_t), space);
987 m->m_len -= space;
989 if (m->m_len > 0)
990 m->m_data += space;
992 m = m_free(m);
997 if (m == NULL)
1001 m0->m_next = m; /* link the chain back up */
1006 m_freem(m);
1016 m_getptr(struct mbuf *m, int loc, int *off)
1020 if (m->m_len > loc) {
1022 return (m);
1024 loc -= m->m_len;
1026 if (m->m_next == NULL) {
1029 *off = m->m_len;
1030 return (m);
1035 m = m->m_next;
1051 struct mbuf *m, *n;
1054 for (m = m0; m && len > m->m_len; m = m->m_next)
1055 len -= m->m_len;
1056 if (m == NULL)
1058 remain = m->m_len - len;
1071 n->m_next = m->m_next;
1072 m->m_next = NULL;
1076 if ((m->m_flags & M_EXT) == 0 && remain > MHLEN) {
1077 /* m can't be the lead packet */
1079 n->m_next = m_split(m, len, wait);
1090 n = m->m_next;
1091 m->m_next = NULL;
1094 MGET(n, wait, m->m_type);
1098 if (m->m_flags & M_EXT) {
1099 n->m_ext = m->m_ext;
1100 MCLADDREFERENCE(m, n);
1101 n->m_data = m->m_data + len;
1104 memcpy(mtod(n, caddr_t), mtod(m, caddr_t) + len, remain);
1107 m->m_len = len;
1108 n->m_next = m->m_next;
1109 m->m_next = NULL;
1124 struct mbuf *m;
1136 for (m = m0; m && skip > m->m_len; m = m->m_next)
1137 skip -= m->m_len;
1138 if (m == NULL)
1141 * At this point skip is the offset into the mbuf m
1146 * the contents of m as needed.
1148 remain = m->m_len - skip; /* data to move */
1149 if (skip < remain && hlen <= m_leadingspace(m)) {
1151 memmove(m->m_data-hlen, m->m_data, skip);
1152 m->m_data -= hlen;
1153 m->m_len += hlen;
1155 } else if (hlen > m_trailingspace(m)) {
1159 MGET(n, M_DONTWAIT, m->m_type);
1170 memcpy(n->m_data, mtod(m, char *) + skip, remain);
1172 m->m_len -= remain;
1174 n->m_next = m->m_next;
1175 m->m_next = n;
1178 if (hlen <= m_trailingspace(m)) {
1179 m->m_len += hlen;
1182 n = m_get(M_DONTWAIT, m->m_type);
1188 n->m_next = m->m_next;
1189 m->m_next = n;
1192 m = n; /* ... of new mbuf */
1200 memmove(mtod(m, caddr_t) + skip + hlen,
1201 mtod(m, caddr_t) + skip, remain);
1202 m->m_len += hlen;
1206 return m;
1216 struct mbuf *m;
1226 MGETHDR(m, M_DONTWAIT, MT_DATA);
1227 if (m == NULL)
1230 m->m_pkthdr.len = totlen;
1236 MGET(m, M_DONTWAIT, MT_DATA);
1237 if (m == NULL) {
1250 MCLGET(m, M_DONTWAIT);
1251 if (m->m_flags & M_EXT)
1256 m->m_data += max_linkhdr;
1262 m->m_data += off;
1267 m->m_len = len = min(totlen, len);
1268 memcpy(mtod(m, void *), buf, (size_t)len);
1271 *mp = m;
1272 mp = &m->m_next;
1279 m_zero(struct mbuf *m)
1281 if (M_READONLY(m)) {
1283 if ((m->m_flags & M_EXT) && MCLISREFERENCED(m)) {
1284 m->m_ext.ext_nextref->m_flags |= M_ZEROIZE;
1285 m->m_ext.ext_prevref->m_flags |= M_ZEROIZE;
1291 explicit_bzero(M_DATABUF(m), M_SIZE(m));
1299 m_apply(struct mbuf *m, int off, int len,
1310 if (m == NULL)
1312 if (off < m->m_len)
1314 off -= m->m_len;
1315 m = m->m_next;
1318 if (m == NULL)
1320 count = min(m->m_len - off, len);
1322 rval = f(fstate, mtod(m, caddr_t) + off, count);
1328 m = m->m_next;
1339 m_leadingspace(struct mbuf *m)
1341 if (M_READONLY(m))
1343 KASSERT(m->m_data >= M_DATABUF(m));
1344 return m->m_data - M_DATABUF(m);
1352 m_trailingspace(struct mbuf *m)
1354 if (M_READONLY(m))
1356 KASSERT(M_DATABUF(m) + M_SIZE(m) >= (m->m_data + m->m_len));
1357 return M_DATABUF(m) + M_SIZE(m) - (m->m_data + m->m_len);
1365 m_align(struct mbuf *m, int len)
1367 KASSERT(len >= 0 && !M_READONLY(m));
1368 KASSERT(m->m_data == M_DATABUF(m)); /* newly-allocated check */
1369 KASSERT(((len + sizeof(long) - 1) &~ (sizeof(long) - 1)) <= M_SIZE(m));
1371 m->m_data = M_DATABUF(m) + ((M_SIZE(m) - (len)) &~ (sizeof(long) - 1));
1410 struct mbuf *m;
1419 m = m_get(wait, m0->m_type);
1420 if (m == NULL)
1423 if (m_dup_pkthdr(m, m0, wait) != 0)
1427 MCLGETL(m, wait, len);
1428 if (!ISSET(m->m_flags, M_EXT))
1432 m->m_len = m->m_pkthdr.len = len;
1433 m_adj(m, adj);
1434 m_copydata(m0, 0, m0->m_pkthdr.len, mtod(m, caddr_t));
1436 return (m);
1439 m_freem(m);
1444 m_microtime(const struct mbuf *m, struct timeval *tv)
1446 if (ISSET(m->m_pkthdr.csum_flags, M_TIMESTAMP)) {
1449 NSEC_TO_TIMEVAL(m->m_pkthdr.ph_timestamp, &utv);
1501 struct mbuf *m = v;
1503 (*pr)("mbuf %p\n", m);
1504 (*pr)("m_type: %i\tm_flags: %b\n", m->m_type, m->m_flags, M_BITS);
1505 (*pr)("m_next: %p\tm_nextpkt: %p\n", m->m_next, m->m_nextpkt);
1506 (*pr)("m_data: %p\tm_len: %u\n", m->m_data, m->m_len);
1507 (*pr)("m_dat: %p\tm_pktdat: %p\n", m->m_dat, m->m_pktdat);
1508 if (m->m_flags & M_PKTHDR) {
1510 m->m_pkthdr.ph_ifidx, m->m_pkthdr.len);
1512 SLIST_FIRST(&m->m_pkthdr.ph_tags),
1513 m->m_pkthdr.ph_tagsset, MTAG_BITS);
1515 m->m_pkthdr.ph_flowid, m->m_pkthdr.ph_loopcnt);
1517 m->m_pkthdr.csum_flags, MCS_BITS);
1519 m->m_pkthdr.ether_vtag, m->m_pkthdr.ph_rtableid);
1521 m->m_pkthdr.pf.statekey, m->m_pkthdr.pf.inp);
1523 m->m_pkthdr.pf.qid, m->m_pkthdr.pf.tag);
1525 m->m_pkthdr.pf.flags, MPF_BITS);
1527 m->m_pkthdr.pf.routed, m->m_pkthdr.pf.prio);
1529 if (m->m_flags & M_EXT) {
1531 m->m_ext.ext_buf, m->m_ext.ext_size);
1533 m->m_ext.ext_free_fn, m->m_ext.ext_arg);
1535 m->m_ext.ext_nextref, m->m_ext.ext_prevref);
1555 struct mbuf *m;
1559 for (m = v; m != NULL; m = m->m_next) {
1563 len += m->m_len;
1564 size += M_SIZE(m);
1565 type = (m->m_type >= 0 && m->m_type < MT_NTYPES) ?
1566 m_types[m->m_type] : "???";
1567 (*pr)("%s mbuf %p, %s, off %zd, len %u", indent, m, type,
1568 m->m_data - M_DATABUF(m), m->m_len);
1569 if (m->m_flags & M_PKTHDR)
1570 (*pr)(", pktlen %d", m->m_pkthdr.len);
1571 if (m->m_flags & M_EXT)
1572 (*pr)(", clsize %u", m->m_ext.ext_size);
1575 m->m_flags & M_PKTHDR ? MHLEN : MLEN);
1590 struct mbuf *m, *n;
1594 for (m = v; m != NULL; m = m->m_nextpkt) {
1599 m_print_chain(m, deep, pr);
1602 for (n = m; n != NULL; n = n->m_next) {
1607 (*pr)("%s mbuf %p, chain %zu", indent, m, chain);
1608 if (m->m_flags & M_PKTHDR)
1609 (*pr)(", pktlen %d", m->m_pkthdr.len);
1630 ml_enqueue(struct mbuf_list *ml, struct mbuf *m)
1633 ml->ml_head = ml->ml_tail = m;
1635 ml->ml_tail->m_nextpkt = m;
1636 ml->ml_tail = m;
1639 m->m_nextpkt = NULL;
1661 struct mbuf *m;
1663 m = ml->ml_head;
1664 if (m != NULL) {
1665 ml->ml_head = m->m_nextpkt;
1669 m->m_nextpkt = NULL;
1673 return (m);
1691 struct mbuf *m, *n;
1694 for (m = ml->ml_head; m != NULL; m = n) {
1695 n = m->m_nextpkt;
1696 m_freem(m);
1708 struct mbuf *m;
1710 m = ml->ml_head;
1711 if (m == NULL)
1714 KASSERT(ISSET(m->m_flags, M_PKTHDR));
1715 return (m->m_pkthdr.len);
1731 mq_push(struct mbuf_queue *mq, struct mbuf *m)
1740 ml_enqueue(&mq->mq_list, m);
1750 mq_enqueue(struct mbuf_queue *mq, struct mbuf *m)
1756 ml_enqueue(&mq->mq_list, m);
1764 m_freem(m);
1772 struct mbuf *m;
1775 m = ml_dequeue(&mq->mq_list);
1778 return (m);
1784 struct mbuf *m;
1797 while ((m = ml_dequeue(ml)) != NULL)
1798 m_freem(m);