Lines Matching full:m
234 * Attach the cluster from *m to *n, set up m_ext in *n
238 mb_dupcl(struct mbuf *n, struct mbuf *m)
242 KASSERT(m->m_flags & (M_EXT | M_EXTPG),
243 ("%s: M_EXT | M_EXTPG not set on %p", __func__, m));
259 if (m->m_flags & M_EXTPG) {
260 bcopy(&m->m_epg_startcopy, &n->m_epg_startcopy,
262 bcopy(&m->m_ext, &n->m_ext, m_epg_ext_copylen);
263 } else if (m->m_ext.ext_type == EXT_EXTREF)
264 bcopy(&m->m_ext, &n->m_ext, sizeof(struct m_ext));
266 bcopy(&m->m_ext, &n->m_ext, m_ext_copylen);
268 n->m_flags |= m->m_flags & (M_RDONLY | M_EXT | M_EXTPG);
271 if (m->m_ext.ext_flags & EXT_FLAG_EMBREF) {
272 refcnt = n->m_ext.ext_cnt = &m->m_ext.ext_count;
275 KASSERT(m->m_ext.ext_cnt != NULL,
276 ("%s: no refcounting pointer on %p", __func__, m));
277 refcnt = m->m_ext.ext_cnt;
287 m_demote_pkthdr(struct mbuf *m)
290 M_ASSERTPKTHDR(m);
291 M_ASSERT_NO_SND_TAG(m);
293 m_tag_delete_chain(m, NULL);
294 m->m_flags &= ~M_PKTHDR;
295 bzero(&m->m_pkthdr, sizeof(struct pkthdr));
306 struct mbuf *m;
310 for (m = all ? m0 : m0->m_next; m != NULL; m = m->m_next) {
311 KASSERT(m->m_nextpkt == NULL, ("%s: m_nextpkt in m %p, m0 %p",
312 __func__, m, m0));
313 if (m->m_flags & M_PKTHDR)
314 m_demote_pkthdr(m);
315 m->m_flags &= flags;
329 struct mbuf *m;
334 #define M_SANITY_ACTION(s) panic("mbuf %p: " s, m)
336 #define M_SANITY_ACTION(s) printf("mbuf %p: " s, m)
339 for (m = m0; m != NULL; m = m->m_next) {
345 a = M_START(m);
346 b = a + M_SIZE(m);
347 if ((caddr_t)m->m_data < a)
349 if ((caddr_t)m->m_data > b)
351 if ((caddr_t)m->m_data + m->m_len > b)
354 /* m->m_nextpkt may only be set on first mbuf in chain. */
355 if (m != m0 && m->m_nextpkt != NULL) {
357 m_freem(m->m_nextpkt);
358 m->m_nextpkt = (struct mbuf *)0xDEADC0DE;
360 M_SANITY_ACTION("m->m_nextpkt on in-chain mbuf");
365 pktlen += m->m_len;
368 if (m != m0 && m->m_flags & M_PKTHDR &&
369 !SLIST_EMPTY(&m->m_pkthdr.tags)) {
371 m_tag_delete_chain(m, NULL);
378 if (m != m0 && m->m_flags & M_PKTHDR) {
380 bzero(&m->m_pkthdr, sizeof(m->m_pkthdr));
381 m->m_flags &= ~M_PKTHDR;
387 m = m0;
388 if (pktlen && pktlen != m->m_pkthdr.len) {
390 m->m_pkthdr.len = 0;
403 m_pkthdr_init(struct mbuf *m, int how)
408 m->m_data = m->m_pktdat;
409 bzero(&m->m_pkthdr, sizeof(m->m_pkthdr));
411 m->m_pkthdr.numa_domain = M_NODOM;
415 error = mac_mbuf_init(m, how);
501 m_prepend(struct mbuf *m, int len, int how)
505 if (m->m_flags & M_PKTHDR)
506 mn = m_gethdr(how, m->m_type);
508 mn = m_get(how, m->m_type);
510 m_freem(m);
513 if (m->m_flags & M_PKTHDR)
514 m_move_pkthdr(mn, m);
515 mn->m_next = m;
516 m = mn;
517 if (len < M_SIZE(m))
518 M_ALIGN(m, len);
519 m->m_len = len;
520 return (m);
531 m_copym(struct mbuf *m, int off0, int len, int wait)
541 if (off == 0 && m->m_flags & M_PKTHDR)
544 KASSERT(m != NULL, ("m_copym, offset > size of mbuf chain"));
545 if (off < m->m_len)
547 off -= m->m_len;
548 m = m->m_next;
553 if (m == NULL) {
559 n = m_gethdr(wait, m->m_type);
561 n = m_get(wait, m->m_type);
566 if (!m_dup_pkthdr(n, m, wait))
574 n->m_len = min(len, m->m_len - off);
575 if (m->m_flags & (M_EXT | M_EXTPG)) {
576 n->m_data = m->m_data + off;
577 mb_dupcl(n, m);
579 bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
584 m = m->m_next;
596 * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
604 m_copypacket(struct mbuf *m, int how)
609 n = m_get(how, m->m_type);
614 if (!m_dup_pkthdr(n, m, how))
616 n->m_len = m->m_len;
617 if (m->m_flags & (M_EXT | M_EXTPG)) {
618 n->m_data = m->m_data;
619 mb_dupcl(n, m);
621 n->m_data = n->m_pktdat + (m->m_data - m->m_pktdat );
622 bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
625 m = m->m_next;
626 while (m) {
627 o = m_get(how, m->m_type);
634 n->m_len = m->m_len;
635 if (m->m_flags & (M_EXT | M_EXTPG)) {
636 n->m_data = m->m_data;
637 mb_dupcl(n, m);
639 bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
642 m = m->m_next;
651 m_copyfromunmapped(const struct mbuf *m, int off, int len, caddr_t cp)
659 KASSERT(off < m->m_len,
669 error = m_unmapped_uiomove(m, off, &uio, len);
679 m_copydata(const struct mbuf *m, int off, int len, caddr_t cp)
686 KASSERT(m != NULL, ("m_copydata, offset > size of mbuf chain"));
687 if (off < m->m_len)
689 off -= m->m_len;
690 m = m->m_next;
693 KASSERT(m != NULL, ("m_copydata, length > size of mbuf chain"));
694 count = min(m->m_len - off, len);
695 if ((m->m_flags & M_EXTPG) != 0)
696 m_copyfromunmapped(m, off, count, cp);
698 bcopy(mtod(m, caddr_t) + off, cp, count);
702 m = m->m_next;
712 m_dup(const struct mbuf *m, int how)
719 if (m == NULL)
721 M_ASSERTPKTHDR(m);
724 remain = m->m_pkthdr.len;
727 while (remain > 0 || top == NULL) { /* allow m->m_pkthdr.len == 0 */
732 n = m_getcl(how, m->m_type, 0);
735 n = m_get(how, m->m_type);
742 if (!m_dup_pkthdr(n, m, how)) {
757 while (n->m_len < nsize && m != NULL) {
758 int chunk = min(nsize - n->m_len, m->m_len - moff);
760 m_copydata(m, moff, chunk, n->m_data + n->m_len);
764 if (moff == m->m_len) {
765 m = m->m_next;
771 KASSERT((remain > 0 && m != NULL) || (remain == 0 && m == NULL),
782 * Concatenate mbuf chain n to m.
787 m_cat(struct mbuf *m, struct mbuf *n)
789 while (m->m_next)
790 m = m->m_next;
792 if (!M_WRITABLE(m) ||
794 M_TRAILINGSPACE(m) < n->m_len) {
796 m->m_next = n;
800 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
802 m->m_len += n->m_len;
811 m_catpkt(struct mbuf *m, struct mbuf *n)
814 M_ASSERTPKTHDR(m);
817 m->m_pkthdr.len += n->m_pkthdr.len;
820 m_cat(m, n);
827 struct mbuf *m;
830 if ((m = mp) == NULL)
836 while (m != NULL && len > 0) {
837 if (m->m_len <= len) {
838 len -= m->m_len;
839 m->m_len = 0;
840 m = m->m_next;
842 m->m_len -= len;
843 m->m_data += len;
860 count += m->m_len;
861 if (m->m_next == (struct mbuf *)0)
863 m = m->m_next;
865 if (m->m_len >= len) {
866 m->m_len -= len;
879 m = mp;
880 if (m->m_flags & M_PKTHDR)
881 m->m_pkthdr.len = count;
882 for (; m; m = m->m_next) {
883 if (m->m_len >= count) {
884 m->m_len = count;
885 if (m->m_next != NULL) {
886 m_freem(m->m_next);
887 m->m_next = NULL;
891 count -= m->m_len;
930 struct mbuf *m;
946 m = n;
948 len -= m->m_len;
952 m = m_get(M_NOWAIT, n->m_type);
953 if (m == NULL)
956 m_move_pkthdr(m, n);
958 space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
961 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
964 m->m_len += count;
973 (void) m_free(m);
976 m->m_next = n;
977 return (m);
991 struct mbuf *m;
996 m = m_get(M_NOWAIT, n->m_type);
997 if (m == NULL)
1000 m_move_pkthdr(m, n);
1001 m->m_data += dstoff;
1002 space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
1005 memcpy(mtod(m, caddr_t) + m->m_len, mtod(n, caddr_t),
1008 m->m_len += count;
1017 (void) m_free(m);
1020 m->m_next = n;
1021 return (m);
1040 struct mbuf *m, *n;
1044 for (m = m0; m && len > m->m_len; m = m->m_next)
1045 len -= m->m_len;
1046 if (m == NULL)
1048 remain = m->m_len - len;
1053 n->m_next = m->m_next;
1054 m->m_next = NULL;
1076 if (m->m_flags & (M_EXT | M_EXTPG))
1079 /* m can't be the lead packet */
1081 n->m_next = m_split(m, len, wait);
1092 n = m->m_next;
1093 m->m_next = NULL;
1096 n = m_get(wait, m->m_type);
1102 if (m->m_flags & (M_EXT | M_EXTPG)) {
1103 n->m_data = m->m_data + len;
1104 mb_dupcl(n, m);
1106 bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
1109 m->m_len = len;
1110 n->m_next = m->m_next;
1111 m->m_next = NULL;
1124 struct mbuf *m, *n;
1132 STAILQ_FOREACH(m, &head->mc_q, m_stailq) {
1134 if (m->m_flags & M_EXT)
1135 mlen += m->m_ext.ext_size;
1136 if (len > m->m_len)
1137 len -= m->m_len;
1141 if (__predict_false(m == NULL)) {
1145 remain = m->m_len - len;
1147 if (__predict_false((n = m_get(wait, m->m_type)) == NULL))
1150 if (m->m_flags & M_EXT) {
1151 n->m_data = m->m_data + len;
1152 mb_dupcl(n, m);
1154 bcopy(mtod(m, char *) + len, mtod(n, char *), remain);
1158 STAILQ_FIRST(&tail->mc_q) = STAILQ_NEXT(m, m_stailq);
1166 m->m_len -= remain;
1167 if (m->m_flags & M_EOR) {
1168 m->m_flags &= ~M_EOR;
1172 head->mc_q.stqh_last = &STAILQ_NEXT(m, m_stailq);
1173 STAILQ_NEXT(m, m_stailq) = NULL;
1189 struct mbuf *m;
1199 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1202 m = m_gethdr(M_NOWAIT, MT_DATA);
1206 if (m && totlen + off + max_linkhdr <= MHLEN) {
1207 m->m_data += max_linkhdr;
1211 if (m == NULL)
1213 m->m_pkthdr.rcvif = ifp;
1214 m->m_pkthdr.len = totlen;
1217 m = m_getcl(M_NOWAIT, MT_DATA, 0);
1220 m = m_get(M_NOWAIT, MT_DATA);
1223 if (m == NULL) {
1229 m->m_data += off;
1233 m->m_len = len = min(totlen, len);
1235 copy(buf, mtod(m, caddr_t), (u_int)len);
1237 bcopy(buf, mtod(m, caddr_t), (u_int)len);
1239 *mp = m;
1240 mp = &m->m_next;
1247 m_copytounmapped(const struct mbuf *m, int off, int len, c_caddr_t cp)
1255 KASSERT(off < m->m_len, ("m_copytounmapped: len exceeds mbuf length"));
1264 error = m_unmapped_uiomove(m, off, &uio, len);
1278 struct mbuf *m = m0, *n;
1283 while (off > (mlen = m->m_len)) {
1286 if (m->m_next == NULL) {
1287 n = m_get(M_NOWAIT, m->m_type);
1292 m->m_next = n;
1294 m = m->m_next;
1297 if (m->m_next == NULL && (len > m->m_len - off)) {
1298 m->m_len += min(len - (m->m_len - off),
1299 M_TRAILINGSPACE(m));
1301 mlen = min (m->m_len - off, len);
1302 if ((m->m_flags & M_EXTPG) != 0)
1303 m_copytounmapped(m, off, mlen, cp);
1305 bcopy(cp, off + mtod(m, caddr_t), (u_int)mlen);
1313 if (m->m_next == NULL) {
1314 n = m_get(M_NOWAIT, m->m_type);
1318 m->m_next = n;
1320 m = m->m_next;
1322 out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
1323 m->m_pkthdr.len = totlen;
1336 struct mbuf *m, *n;
1339 for (m = m0; m->m_next != NULL; m = m->m_next)
1342 space = M_TRAILINGSPACE(m);
1349 bcopy(cp, mtod(m, caddr_t) + m->m_len, space);
1350 m->m_len += space;
1358 n = m_get(M_NOWAIT, m->m_type);
1364 m->m_next = n;
1365 m = n;
1373 m_apply_extpg_one(struct mbuf *m, int off, int len,
1382 off += mtod(m, vm_offset_t);
1383 if (off < m->m_epg_hdrlen) {
1384 count = min(m->m_epg_hdrlen - off, len);
1385 rval = f(arg, m->m_epg_hdr + off, count);
1391 off -= m->m_epg_hdrlen;
1392 pgoff = m->m_epg_1st_off;
1393 for (i = 0; i < m->m_epg_npgs && len > 0; i++) {
1394 pglen = m_epg_pagelen(m, i, pgoff);
1397 p = (void *)PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff + off);
1408 KASSERT(off < m->m_epg_trllen,
1410 KASSERT(len <= m->m_epg_trllen - off,
1412 return (f(arg, m->m_epg_trail + off, len));
1419 m_apply_one(struct mbuf *m, int off, int len,
1422 if ((m->m_flags & M_EXTPG) != 0)
1423 return (m_apply_extpg_one(m, off, len, f, arg));
1425 return (f(arg, mtod(m, caddr_t) + off, len));
1433 m_apply(struct mbuf *m, int off, int len,
1442 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain "
1444 if (off < m->m_len)
1446 off -= m->m_len;
1447 m = m->m_next;
1450 KASSERT(m != NULL, ("m_apply, length > size of mbuf chain "
1452 count = min(m->m_len - off, len);
1453 rval = m_apply_one(m, off, count, f, arg);
1458 m = m->m_next;
1467 m_getptr(struct mbuf *m, int loc, int *off)
1472 if (m->m_len > loc) {
1474 return (m);
1476 loc -= m->m_len;
1477 if (m->m_next == NULL) {
1480 *off = m->m_len;
1481 return (m);
1485 m = m->m_next;
1492 m_print(const struct mbuf *m, int maxlen)
1498 if (m == NULL) {
1499 printf("mbuf: %p\n", m);
1503 if (m->m_flags & M_PKTHDR)
1504 len = m->m_pkthdr.len;
1507 m2 = m;
1540 struct mbuf *m;
1544 for (m = m0; m != NULL; m = m->m_next) {
1545 len += m->m_len;
1546 if (m->m_next == NULL)
1550 *last = m;
1648 frags_per_mbuf(struct mbuf *m)
1652 if ((m->m_flags & M_EXTPG) == 0)
1663 if (m->m_epg_hdrlen != 0)
1665 frags += m->m_epg_npgs;
1666 if (m->m_epg_trllen != 0)
1684 struct mbuf *m, *n, *n2, **prev;
1691 for (m = m0; m != NULL; m = m->m_next)
1692 curfrags += frags_per_mbuf(m);
1699 m = m0;
1702 n = m->m_next;
1705 if (M_WRITABLE(m) &&
1706 n->m_len < M_TRAILINGSPACE(m)) {
1708 mtod(m, char *) + m->m_len);
1709 m->m_len += n->m_len;
1710 m->m_next = n->m_next;
1716 m = n;
1727 m = m_getcl(how, MT_DATA, 0);
1728 if (m == NULL)
1730 m_copydata(n, 0, n->m_len, mtod(m, char *));
1732 mtod(m, char *) + n->m_len);
1733 m->m_len = n->m_len + n2->m_len;
1734 m->m_next = n2->m_next;
1735 *prev = m;
1847 mb_free_mext_pgs(struct mbuf *m)
1851 M_ASSERTEXTPG(m);
1852 for (int i = 0; i < m->m_epg_npgs; i++) {
1853 pg = PHYS_TO_VM_PAGE(m->m_epg_pa[i]);
1862 struct mbuf *m, *mb, *prev;
1900 m = NULL;
1905 if (m == NULL)
1906 m = mb;
1935 m->m_pkthdr.len += length;
1937 return (m);
1940 m_freem(m);
1957 struct mbuf *m;
1964 m = m_gethdr(how, MT_DATA);
1965 m->m_pkthdr.memlen = MSIZE;
1967 m = m_get(how, MT_DATA);
1968 if (m != NULL)
1969 m->m_data += lspace;
1970 return (m);
2049 m_unmapped_uiomove(const struct mbuf *m, int m_off, struct uio *uio, int len)
2054 M_ASSERTEXTPG(m);
2058 off = mtod(m, vm_offset_t);
2061 if (m->m_epg_hdrlen != 0) {
2062 if (off >= m->m_epg_hdrlen) {
2063 off -= m->m_epg_hdrlen;
2065 seglen = m->m_epg_hdrlen - off;
2071 &m->m_epg_hdr[segoff]), seglen, uio);
2074 pgoff = m->m_epg_1st_off;
2075 for (i = 0; i < m->m_epg_npgs && error == 0 && len > 0; i++) {
2076 pglen = m_epg_pagelen(m, i, pgoff);
2087 pg = PHYS_TO_VM_PAGE(m->m_epg_pa[i]);
2092 KASSERT((off + len) <= m->m_epg_trllen,
2094 m->m_epg_trllen, m_off));
2095 error = uiomove(__DECONST(void *, &m->m_epg_trail[off]),
2105 m_mbuftouio(struct uio *uio, const struct mbuf *m, int len)
2116 for (; m != NULL; m = m->m_next) {
2117 length = min(m->m_len, total - progress);
2119 if ((m->m_flags & M_EXTPG) != 0)
2120 error = m_unmapped_uiomove(m, 0, uio, length);
2122 error = uiomove(mtod(m, void *), length, uio);
2144 struct mbuf *m, *mprev;
2149 for (m = m0; m != NULL; m = mprev->m_next) {
2162 if ((m->m_flags & M_EXT) == 0) {
2164 m->m_len <= M_TRAILINGSPACE(mprev)) {
2167 mtod(m, caddr_t), m->m_len);
2168 mprev->m_len += m->m_len;
2169 mprev->m_next = m->m_next; /* unlink from chain */
2170 m_free(m); /* reclaim mbuf */
2172 mprev = m;
2179 if (M_WRITABLE(m)) {
2180 mprev = m;
2190 KASSERT(m->m_flags & M_EXT, ("m_flags 0x%x", m->m_flags));
2193 m->m_len <= M_TRAILINGSPACE(mprev)) {
2196 mtod(m, caddr_t), m->m_len);
2197 mprev->m_len += m->m_len;
2198 mprev->m_next = m->m_next; /* unlink from chain */
2199 m_free(m); /* reclaim mbuf */
2211 n = m_getcl(how, m->m_type, m->m_flags & M_COPYFLAGS);
2216 if (m->m_flags & M_PKTHDR) {
2217 KASSERT(mprev == NULL, ("%s: m0 %p, m %p has M_PKTHDR",
2218 __func__, m0, m));
2219 m_move_pkthdr(n, m);
2221 len = m->m_len;
2227 memcpy(mtod(n, caddr_t), mtod(m, caddr_t) + off, cc);
2241 n = m_getcl(how, m->m_type, m->m_flags & M_COPYFLAGS);
2248 n->m_next = m->m_next;
2253 m_free(m); /* release old mbuf */
2269 m_profile(struct mbuf *m)
2275 while (m) {
2277 used += m->m_len;
2278 if (m->m_flags & M_EXT) {
2279 wasted += MHLEN - sizeof(m->m_ext) +
2280 m->m_ext.ext_size - m->m_len;
2282 if (m->m_flags & M_PKTHDR)
2283 wasted += MHLEN - m->m_len;
2285 wasted += MLEN - m->m_len;
2287 m = m->m_next;