Lines Matching full:m
74 static void sbcompress_ktls_rx(struct sockbuf *sb, struct mbuf *m,
84 sbm_clrprotoflags(struct mbuf *m, int flags)
91 while (m) {
92 m->m_flags &= mask;
93 m = m->m_next;
109 struct mbuf *m, *n;
117 for (m = m0; m != end; m = m->m_next) {
118 MPASS((m->m_flags & M_NOTREADY) == 0);
121 * socket buffer and 'm' is the new mbuf being copied
123 * are reversed and 'n' is the next mbuf after 'm'
125 * 'm'.
127 n = m->m_next;
130 if ((n != NULL) && (n != end) && (m->m_flags & M_EOR) == 0 &&
131 (m->m_flags & M_EXTPG) &&
133 !mbuf_has_tls_session(m) &&
138 trail_len = m->m_epg_trllen;
141 /* copy n's header to m's trailer */
142 memcpy(&m->m_epg_trail[trail_len],
144 m->m_epg_trllen += hdr_len;
145 m->m_len += hdr_len;
153 if ((m->m_flags & M_EXTPG) && m->m_len <= MLEN &&
154 !mbuf_has_tls_session(m)) {
155 ext_size = m->m_ext.ext_size;
156 if (mb_unmapped_compress(m) == 0)
160 while ((n != NULL) && (n != end) && (m->m_flags & M_EOR) == 0 &&
161 M_WRITABLE(m) &&
162 (m->m_flags & M_EXTPG) == 0 &&
164 !mbuf_has_tls_session(m) &&
166 n->m_len <= M_TRAILINGSPACE(m) &&
167 m->m_type == n->m_type) {
170 __func__, n, m));
171 m_copydata(n, 0, n->m_len, mtodo(m, m->m_len));
172 m->m_len += n->m_len;
173 m->m_next = n->m_next;
174 m->m_flags |= n->m_flags & M_EOR;
176 sb->sb_mbtail = m;
182 n = m->m_next;
190 * Mark ready "count" units of I/O starting with "m". Most mbufs
197 struct mbuf *m;
204 m = m0;
205 blocker = (sb->sb_fnrdy == m) ? M_BLOCKED : 0;
208 KASSERT(m->m_flags & M_NOTREADY,
209 ("%s: m %p !M_NOTREADY", __func__, m));
210 if ((m->m_flags & M_EXTPG) != 0 && m->m_epg_npgs != 0) {
211 if (count < m->m_epg_nrdy) {
212 m->m_epg_nrdy -= count;
216 count -= m->m_epg_nrdy;
217 m->m_epg_nrdy = 0;
221 m->m_flags &= ~(M_NOTREADY | blocker);
223 sb->sb_acc += m->m_len;
224 m = m->m_next;
232 if (m0 == m) {
233 MPASS(m->m_flags & M_NOTREADY);
238 sbready_compress(sb, m0, m);
243 for (; m && (m->m_flags & M_NOTREADY) == 0; m = m->m_next) {
244 KASSERT(m->m_flags & M_BLOCKED,
245 ("%s: m %p !M_BLOCKED", __func__, m));
246 m->m_flags &= ~M_BLOCKED;
247 sb->sb_acc += m->m_len;
250 sb->sb_fnrdy = m;
251 sbready_compress(sb, m0, m);
257 * Adjust sockbuf state reflecting allocation of m.
260 sballoc(struct sockbuf *sb, struct mbuf *m)
265 sb->sb_ccc += m->m_len;
268 if (m->m_flags & M_NOTREADY)
269 sb->sb_fnrdy = m;
271 sb->sb_acc += m->m_len;
273 m->m_flags |= M_BLOCKED;
275 if (m->m_type != MT_DATA && m->m_type != MT_OOBDATA)
276 sb->sb_ctl += m->m_len;
280 if (m->m_flags & M_EXT)
281 sb->sb_mbcnt += m->m_ext.ext_size;
285 * Adjust sockbuf state reflecting freeing of m.
288 sbfree(struct sockbuf *sb, struct mbuf *m)
295 sb->sb_ccc -= m->m_len;
297 if (!(m->m_flags & M_NOTAVAIL))
298 sb->sb_acc -= m->m_len;
300 if (m == sb->sb_fnrdy) {
303 KASSERT(m->m_flags & M_NOTREADY,
304 ("%s: m %p !M_NOTREADY", __func__, m));
306 n = m->m_next;
315 if (m->m_type != MT_DATA && m->m_type != MT_OOBDATA)
316 sb->sb_ctl -= m->m_len;
319 if (m->m_flags & M_EXT)
320 sb->sb_mbcnt -= m->m_ext.ext_size;
322 if (sb->sb_sndptr == m) {
327 sb->sb_sndptroff -= m->m_len;
337 sballoc_ktls_rx(struct sockbuf *sb, struct mbuf *m)
342 sb->sb_ccc += m->m_len;
343 sb->sb_tlscc += m->m_len;
347 if (m->m_flags & M_EXT)
348 sb->sb_mbcnt += m->m_ext.ext_size;
352 sbfree_ktls_rx(struct sockbuf *sb, struct mbuf *m)
359 sb->sb_ccc -= m->m_len;
360 sb->sb_tlscc -= m->m_len;
364 if (m->m_flags & M_EXT)
365 sb->sb_mbcnt -= m->m_ext.ext_size;
851 struct mbuf *m = sb->sb_mb;
855 while (m && m->m_nextpkt)
856 m = m->m_nextpkt;
858 if (m != sb->sb_lastrecord) {
860 __func__, sb->sb_mb, sb->sb_lastrecord, m);
862 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt)
863 printf("\t%p\n", m);
871 struct mbuf *m = sb->sb_mb;
876 while (m && m->m_nextpkt)
877 m = m->m_nextpkt;
879 while (m && m->m_next)
880 m = m->m_next;
882 if (m != sb->sb_mbtail) {
884 __func__, sb->sb_mb, sb->sb_mbtail, m);
886 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
888 for (n = m; n != NULL; n = n->m_next)
896 m = sb->sb_mtls;
897 while (m && m->m_next)
898 m = m->m_next;
900 if (m != sb->sb_mtlstail) {
902 __func__, sb->sb_mtls, sb->sb_mtlstail, m);
905 for (m = sb->sb_mtls; m != NULL; m = m->m_next) {
906 printf("%p ", m);
925 * Append mbuf chain m to the last record in the socket buffer sb. The
930 sbappend_locked(struct sockbuf *sb, struct mbuf *m, int flags)
936 if (m == NULL)
938 kmsan_check_mbuf(m, "sbappend");
939 sbm_clrprotoflags(m, flags);
947 sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
960 sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
969 sb->sb_lastrecord = m;
972 sbcompress(sb, m, n);
977 * Append mbuf chain m to the last record in the socket buffer sb. The
982 sbappend(struct sockbuf *sb, struct mbuf *m, int flags)
986 sbappend_locked(sb, m, flags);
997 sbappend_ktls_rx(struct sockbuf *sb, struct mbuf *m)
1009 MPASS((m->m_flags & M_PKTHDR) != 0);
1012 for (n = m; n != NULL; n = n->m_next) {
1014 ifp = m->m_pkthdr.leaf_rcvif;
1031 sbcompress_ktls_rx(sb, m, sb->sb_mtlstail);
1047 sbappendstream_locked(struct sockbuf *sb, struct mbuf *m, int flags)
1051 KASSERT(m->m_nextpkt == NULL,("sbappendstream 0"));
1053 kmsan_check_mbuf(m, "sbappend");
1062 sbappend_ktls_rx(sb, m);
1073 ktls_seq(sb, m);
1077 m_demote(m, 1, flags & PRUS_NOTREADY ? M_NOTREADY : 0);
1079 sbcompress(sb, m, sb->sb_mbtail);
1091 sbappendstream(struct sockbuf *sb, struct mbuf *m, int flags)
1095 sbappendstream_locked(sb, m, flags);
1103 struct mbuf *m, *n, *fnrdy;
1114 for (m = sb->sb_mb; m; m = n) {
1115 n = m->m_nextpkt;
1116 for (; m; m = m->m_next) {
1117 if (m->m_len == 0) {
1118 printf("sb %p empty mbuf %p\n", sb, m);
1121 if ((m->m_flags & M_NOTREADY) && fnrdy == NULL) {
1122 if (m != sb->sb_fnrdy) {
1123 printf("sb %p: fnrdy %p != m %p\n",
1124 sb, sb->sb_fnrdy, m);
1127 fnrdy = m;
1130 if (!(m->m_flags & M_NOTAVAIL)) {
1131 printf("sb %p: fnrdy %p, m %p is avail\n",
1132 sb, sb->sb_fnrdy, m);
1136 acc += m->m_len;
1137 ccc += m->m_len;
1139 if (m->m_flags & M_EXT) /*XXX*/ /* pretty sure this is bogus */
1140 mbcnt += m->m_ext.ext_size;
1154 for (m = sb->sb_mtls; m; m = m->m_next) {
1155 if (m->m_nextpkt != NULL) {
1156 printf("sb %p TLS mbuf %p with nextpkt\n", sb, m);
1159 if ((m->m_flags & M_NOTREADY) == 0) {
1160 printf("sb %p TLS mbuf %p ready\n", sb, m);
1163 tlscc += m->m_len;
1164 ccc += m->m_len;
1166 if (m->m_flags & M_EXT) /*XXX*/ /* pretty sure this is bogus */
1167 mbcnt += m->m_ext.ext_size;
1197 struct mbuf *m;
1215 m = m0->m_next;
1217 if (m && (m0->m_flags & M_EOR)) {
1219 m->m_flags |= M_EOR;
1222 sbcompress(sb, m, m0);
1242 struct mbuf *m, *n, *nlast;
1253 m = m_get(M_NOWAIT, MT_SONAME);
1254 if (m == NULL)
1256 m->m_len = asa->sa_len;
1257 bcopy(asa, mtod(m, caddr_t), asa->sa_len);
1277 m->m_next = control;
1278 for (n = m; n->m_next != NULL; n = n->m_next)
1282 SBLINKRECORD(sb, m);
1357 struct mbuf *m, *mlast;
1368 for (m = control; m->m_next; m = m->m_next)
1369 sballoc(sb, m);
1370 sballoc(sb, m);
1371 mlast = m;
1391 * Append the data in mbuf chain (m) into the socket buffer sb following mbuf
1411 sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
1418 while (m) {
1419 eor |= m->m_flags & M_EOR;
1420 if (m->m_len == 0 &&
1422 (((o = m->m_next) || (o = n)) &&
1423 o->m_type == m->m_type))) {
1424 if (sb->sb_lastrecord == m)
1425 sb->sb_lastrecord = m->m_next;
1426 m = m_free(m);
1432 !(m->m_flags & M_NOTREADY) &&
1434 !mbuf_has_tls_session(m) &&
1436 m->m_len <= MCLBYTES / 4 && /* XXX: Don't copy too much */
1437 m->m_len <= M_TRAILINGSPACE(n) &&
1438 n->m_type == m->m_type) {
1439 m_copydata(m, 0, m->m_len, mtodo(n, n->m_len));
1440 n->m_len += m->m_len;
1441 sb->sb_ccc += m->m_len;
1443 sb->sb_acc += m->m_len;
1444 if (m->m_type != MT_DATA && m->m_type != MT_OOBDATA)
1446 sb->sb_ctl += m->m_len;
1447 m = m_free(m);
1450 if (m->m_len <= MLEN && (m->m_flags & M_EXTPG) &&
1451 (m->m_flags & M_NOTREADY) == 0 &&
1452 !mbuf_has_tls_session(m))
1453 (void)mb_unmapped_compress(m);
1455 n->m_next = m;
1457 sb->sb_mb = m;
1458 sb->sb_mbtail = m;
1459 sballoc(sb, m);
1460 n = m;
1461 m->m_flags &= ~M_EOR;
1462 m = m->m_next;
1479 sbcompress_ktls_rx(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
1484 while (m) {
1485 KASSERT((m->m_flags & M_EOR) == 0,
1486 ("TLS RX mbuf %p with EOR", m));
1487 KASSERT(m->m_type == MT_DATA,
1488 ("TLS RX mbuf %p is not MT_DATA", m));
1489 KASSERT((m->m_flags & M_NOTREADY) != 0,
1490 ("TLS RX mbuf %p ready", m));
1491 KASSERT((m->m_flags & M_EXTPG) == 0,
1492 ("TLS RX mbuf %p unmapped", m));
1494 if (m->m_len == 0) {
1495 m = m_free(m);
1500 * Even though both 'n' and 'm' are NOTREADY, it's ok
1506 !((m->m_flags ^ n->m_flags) & M_DECRYPTED) &&
1508 m->m_len <= MCLBYTES / 4 && /* XXX: Don't copy too much */
1509 m->m_len <= M_TRAILINGSPACE(n)) {
1510 m_copydata(m, 0, m->m_len, mtodo(n, n->m_len));
1511 n->m_len += m->m_len;
1512 sb->sb_ccc += m->m_len;
1513 sb->sb_tlscc += m->m_len;
1514 m = m_free(m);
1518 n->m_next = m;
1520 sb->sb_mtls = m;
1521 sb->sb_mtlstail = m;
1522 sballoc_ktls_rx(sb, m);
1523 n = m;
1524 m = m->m_next;
1575 struct mbuf *m, *next, *mfree;
1583 next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
1588 if (m == NULL) {
1604 m = next;
1605 next = m->m_nextpkt;
1607 if (m->m_len > len) {
1608 KASSERT(!(m->m_flags & M_NOTAVAIL),
1609 ("%s: m %p M_NOTAVAIL", __func__, m));
1610 m->m_len -= len;
1611 m->m_data += len;
1616 if (m->m_type != MT_DATA && m->m_type != MT_OOBDATA)
1620 len -= m->m_len;
1623 sbfree_ktls_rx(sb, m);
1626 sbfree(sb, m);
1631 if (m->m_flags & M_NOTREADY && !is_tls)
1632 m = m->m_next;
1636 n = m->m_next;
1637 m->m_next = mfree;
1638 mfree = m;
1639 m = n;
1648 while (m && m->m_len == 0) {
1651 sbfree(sb, m);
1652 n = m->m_next;
1653 m->m_next = mfree;
1654 mfree = m;
1655 m = n;
1660 sb->sb_mtls = m;
1661 if (m == NULL)
1665 if (m) {
1666 sb->sb_mb = m;
1667 m->m_nextpkt = next;
1674 m = sb->sb_mb;
1675 if (m == NULL) {
1678 } else if (m->m_nextpkt == NULL) {
1679 sb->sb_lastrecord = m;
1723 struct mbuf *m;
1734 m = sb->sb_sndptr;
1738 return (m);
1748 struct mbuf *m;
1754 m = mb;
1755 while (m && (len > 0)) {
1756 if (len >= m->m_len) {
1757 len -= m->m_len;
1758 if (m->m_next) {
1759 sb->sb_sndptroff += m->m_len;
1760 sb->sb_sndptr = m->m_next;
1762 m = m->m_next;
1776 struct mbuf *m;
1785 m = sb->sb_mb;
1787 m = sb->sb_sndptr;
1790 while (off > 0 && m != NULL) {
1791 if (off < m->m_len)
1793 off -= m->m_len;
1794 m = m->m_next;
1797 return (m);
1807 struct mbuf *m;
1811 m = sb->sb_mb;
1812 if (m) {
1813 sb->sb_mb = m->m_nextpkt;
1815 sbfree(sb, m);
1816 m = m_free(m);
1817 } while (m);
1843 struct mbuf *m;
1855 m = m_getcl(wait, MT_CONTROL, 0);
1857 m = m_get(wait, MT_CONTROL);
1858 if (m == NULL)
1861 KASSERT(CMSG_SPACE(size) <= M_TRAILINGSPACE(m),
1867 cp = mtod(m, struct cmsghdr *);
1871 m->m_len = CMSG_SPACE(size);
1875 return (m);