Lines Matching defs:sb
74 static void sbcompress_ktls_rx(struct sockbuf *sb, struct mbuf *m,
77 static struct mbuf *sbcut_internal(struct sockbuf *sb, int len);
78 static void sbflush_internal(struct sockbuf *sb);
107 sbready_compress(struct sockbuf *sb, struct mbuf *m0, struct mbuf *end)
112 SOCKBUF_LOCK_ASSERT(sb);
114 if ((sb->sb_flags & SB_NOCOALESCE) != 0)
157 sb->sb_mbcnt -= ext_size;
168 KASSERT(sb->sb_lastrecord != n,
175 if (sb->sb_mbtail == n)
176 sb->sb_mbtail = m;
178 sb->sb_mbcnt -= MSIZE;
180 sb->sb_mbcnt -= n->m_ext.ext_size;
185 SBLASTRECORDCHK(sb);
186 SBLASTMBUFCHK(sb);
195 sbready(struct sockbuf *sb, struct mbuf *m0, int count)
200 SOCKBUF_LOCK_ASSERT(sb);
201 KASSERT(sb->sb_fnrdy != NULL, ("%s: sb %p NULL fnrdy", __func__, sb));
205 blocker = (sb->sb_fnrdy == m) ? M_BLOCKED : 0;
223 sb->sb_acc += m->m_len;
238 sbready_compress(sb, m0, m);
247 sb->sb_acc += m->m_len;
250 sb->sb_fnrdy = m;
251 sbready_compress(sb, m0, m);
260 sballoc(struct sockbuf *sb, struct mbuf *m)
263 SOCKBUF_LOCK_ASSERT(sb);
265 sb->sb_ccc += m->m_len;
267 if (sb->sb_fnrdy == NULL) {
269 sb->sb_fnrdy = m;
271 sb->sb_acc += m->m_len;
276 sb->sb_ctl += m->m_len;
278 sb->sb_mbcnt += MSIZE;
281 sb->sb_mbcnt += m->m_ext.ext_size;
288 sbfree(struct sockbuf *sb, struct mbuf *m)
292 SOCKBUF_LOCK_ASSERT(sb);
295 sb->sb_ccc -= m->m_len;
298 sb->sb_acc -= m->m_len;
300 if (m == sb->sb_fnrdy) {
309 sb->sb_acc += n->m_len;
312 sb->sb_fnrdy = n;
316 sb->sb_ctl -= m->m_len;
318 sb->sb_mbcnt -= MSIZE;
320 sb->sb_mbcnt -= m->m_ext.ext_size;
322 if (sb->sb_sndptr == m) {
323 sb->sb_sndptr = NULL;
324 sb->sb_sndptroff = 0;
326 if (sb->sb_sndptroff != 0)
327 sb->sb_sndptroff -= m->m_len;
337 sballoc_ktls_rx(struct sockbuf *sb, struct mbuf *m)
340 SOCKBUF_LOCK_ASSERT(sb);
342 sb->sb_ccc += m->m_len;
343 sb->sb_tlscc += m->m_len;
345 sb->sb_mbcnt += MSIZE;
348 sb->sb_mbcnt += m->m_ext.ext_size;
352 sbfree_ktls_rx(struct sockbuf *sb, struct mbuf *m)
356 SOCKBUF_LOCK_ASSERT(sb);
359 sb->sb_ccc -= m->m_len;
360 sb->sb_tlscc -= m->m_len;
362 sb->sb_mbcnt -= MSIZE;
365 sb->sb_mbcnt -= m->m_ext.ext_size;
452 struct sockbuf *sb;
456 sb = sobuf(so, which);
457 sb->sb_flags |= SB_WAIT;
458 return (msleep_sbt(&sb->sb_acc, soeventmtx(so, which),
459 (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait",
460 sb->sb_timeo, 0, 0));
478 struct sockbuf *sb;
483 sb = sobuf(so, which);
484 selwakeuppri(sb->sb_sel, PSOCK);
485 if (!SEL_WAITING(sb->sb_sel))
486 sb->sb_flags &= ~SB_SEL;
487 if (sb->sb_flags & SB_WAIT) {
488 sb->sb_flags &= ~SB_WAIT;
489 wakeup(&sb->sb_acc);
491 KNOTE_LOCKED(&sb->sb_sel->si_note, 0);
492 if (sb->sb_upcall != NULL) {
493 ret = sb->sb_upcall(so, sb->sb_upcallarg, M_NOWAIT);
495 KASSERT(sb == &so->so_rcv,
501 if (sb->sb_flags & SB_AIO)
541 sb_notify(const struct sockbuf *sb)
543 return ((sb->sb_flags & (SB_WAIT | SB_SEL | SB_ASYNC |
654 struct sockbuf *sb = sobuf(so, which);
672 if (!chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, cc,
675 sb->sb_mbmax = min(cc * sb_efficiency, buf_max);
676 if (sb->sb_lowat > sb->sb_hiwat)
677 sb->sb_lowat = sb->sb_hiwat;
691 struct sockbuf *sb;
709 sb = NULL;
730 sb = &so->so_snd;
735 sb = &so->so_rcv;
739 flags = &sb->sb_flags;
740 hiwat = &sb->sb_hiwat;
741 lowat = &sb->sb_lowat;
786 struct sockbuf *sb = sobuf(so, which);
788 sbflush_internal(sb);
789 (void)chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, 0,
791 sb->sb_mbmax = 0;
816 struct sockbuf *sb = sobuf(so, which);
818 if (sb->sb_tls_info != NULL)
819 ktls_free(sb->sb_tls_info);
820 sb->sb_tls_info = NULL;
849 sblastrecordchk(struct sockbuf *sb, const char *file, int line)
851 struct mbuf *m = sb->sb_mb;
853 SOCKBUF_LOCK_ASSERT(sb);
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)
869 sblastmbufchk(struct sockbuf *sb, const char *file, int line)
871 struct mbuf *m = sb->sb_mb;
874 SOCKBUF_LOCK_ASSERT(sb);
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) {
896 m = sb->sb_mtls;
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) {
915 #define SBLINKRECORD(sb, m0) do { \
916 SOCKBUF_LOCK_ASSERT(sb); \
917 if ((sb)->sb_lastrecord != NULL) \
918 (sb)->sb_lastrecord->m_nextpkt = (m0); \
920 (sb)->sb_mb = (m0); \
921 (sb)->sb_lastrecord = (m0); \
925 * Append mbuf chain m to the last record in the socket buffer sb. The
926 * additional space associated the mbuf chain is recorded in sb. Empty mbufs
930 sbappend_locked(struct sockbuf *sb, struct mbuf *m, int flags)
934 SOCKBUF_LOCK_ASSERT(sb);
940 SBLASTRECORDCHK(sb);
941 n = sb->sb_mb;
947 sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
957 if ((n = sb->sb_lastrecord) != NULL) {
960 sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
969 sb->sb_lastrecord = m;
972 sbcompress(sb, m, n);
973 SBLASTRECORDCHK(sb);
977 * Append mbuf chain m to the last record in the socket buffer sb. The
978 * additional space associated the mbuf chain is recorded in sb. Empty mbufs
982 sbappend(struct sockbuf *sb, struct mbuf *m, int flags)
985 SOCKBUF_LOCK(sb);
986 sbappend_locked(sb, m, flags);
987 SOCKBUF_UNLOCK(sb);
997 sbappend_ktls_rx(struct sockbuf *sb, struct mbuf *m)
1006 SBLASTMBUFCHK(sb);
1031 sbcompress_ktls_rx(sb, m, sb->sb_mtlstail);
1032 ktls_check_rx(sb);
1035 if (ifp != NULL && sb->sb_tls_info->rx_ifp != NULL &&
1036 sb->sb_tls_info->rx_ifp != ifp)
1037 ktls_input_ifp_mismatch(sb, ifp);
1047 sbappendstream_locked(struct sockbuf *sb, struct mbuf *m, int flags)
1049 SOCKBUF_LOCK_ASSERT(sb);
1061 if (sb->sb_flags & SB_TLS_RX) {
1062 sbappend_ktls_rx(sb, m);
1067 KASSERT(sb->sb_mb == sb->sb_lastrecord,("sbappendstream 1"));
1069 SBLASTMBUFCHK(sb);
1072 if (sb->sb_tls_info != NULL)
1073 ktls_seq(sb, m);
1079 sbcompress(sb, m, sb->sb_mbtail);
1081 sb->sb_lastrecord = sb->sb_mb;
1082 SBLASTRECORDCHK(sb);
1091 sbappendstream(struct sockbuf *sb, struct mbuf *m, int flags)
1094 SOCKBUF_LOCK(sb);
1095 sbappendstream_locked(sb, m, flags);
1096 SOCKBUF_UNLOCK(sb);
1101 sbcheck(struct sockbuf *sb, const char *file, int line)
1109 SOCKBUF_LOCK_ASSERT(sb);
1114 for (m = sb->sb_mb; m; m = n) {
1118 printf("sb %p empty mbuf %p\n", sb, m);
1122 if (m != sb->sb_fnrdy) {
1123 printf("sb %p: fnrdy %p != m %p\n",
1124 sb, sb->sb_fnrdy, m);
1131 printf("sb %p: fnrdy %p, m %p is avail\n",
1132 sb, sb->sb_fnrdy, m);
1151 ccc += sb->sb_tlsdcc;
1154 for (m = sb->sb_mtls; m; m = m->m_next) {
1156 printf("sb %p TLS mbuf %p with nextpkt\n", sb, m);
1160 printf("sb %p TLS mbuf %p ready\n", sb, m);
1170 if (sb->sb_tlscc != tlscc) {
1171 printf("tlscc %ld/%u dcc %u\n", tlscc, sb->sb_tlscc,
1172 sb->sb_tlsdcc);
1176 if (acc != sb->sb_acc || ccc != sb->sb_ccc || mbcnt != sb->sb_mbcnt) {
1178 acc, sb->sb_acc, ccc, sb->sb_ccc, mbcnt, sb->sb_mbcnt);
1180 printf("tlscc %ld/%u dcc %u\n", tlscc, sb->sb_tlscc,
1181 sb->sb_tlsdcc);
1195 sbappendrecord_locked(struct sockbuf *sb, struct mbuf *m0)
1199 SOCKBUF_LOCK_ASSERT(sb);
1211 sballoc(sb, m0);
1212 SBLASTRECORDCHK(sb);
1213 SBLINKRECORD(sb, m0);
1214 sb->sb_mbtail = m0;
1222 sbcompress(sb, m, m0);
1229 sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
1232 SOCKBUF_LOCK(sb);
1233 sbappendrecord_locked(sb, m0);
1234 SOCKBUF_UNLOCK(sb);
1239 sbappendaddr_locked_internal(struct sockbuf *sb, const struct sockaddr *asa,
1279 sballoc(sb, n);
1280 sballoc(sb, n);
1282 SBLINKRECORD(sb, m);
1284 sb->sb_mbtail = nlast;
1285 SBLASTMBUFCHK(sb);
1287 SBLASTRECORDCHK(sb);
1298 sbappendaddr_locked(struct sockbuf *sb, const struct sockaddr *asa,
1304 SOCKBUF_LOCK_ASSERT(sb);
1312 if (space > sbspace(sb))
1314 return (sbappendaddr_locked_internal(sb, asa, m0, control, ctrl_last));
1324 sbappendaddr_nospacecheck_locked(struct sockbuf *sb, const struct sockaddr *asa,
1329 SOCKBUF_LOCK_ASSERT(sb);
1332 return (sbappendaddr_locked_internal(sb, asa, m0, control, ctrl_last));
1342 sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa,
1347 SOCKBUF_LOCK(sb);
1348 retval = sbappendaddr_locked(sb, asa, m0, control);
1349 SOCKBUF_UNLOCK(sb);
1354 sbappendcontrol_locked(struct sockbuf *sb, struct mbuf *m0,
1366 SBLASTRECORDCHK(sb);
1369 sballoc(sb, m);
1370 sballoc(sb, m);
1372 SBLINKRECORD(sb, control);
1374 sb->sb_mbtail = mlast;
1375 SBLASTMBUFCHK(sb);
1377 SBLASTRECORDCHK(sb);
1381 sbappendcontrol(struct sockbuf *sb, struct mbuf *m0, struct mbuf *control,
1385 SOCKBUF_LOCK(sb);
1386 sbappendcontrol_locked(sb, m0, control, flags);
1387 SOCKBUF_UNLOCK(sb);
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)
1416 SOCKBUF_LOCK_ASSERT(sb);
1424 if (sb->sb_lastrecord == m)
1425 sb->sb_lastrecord = m->m_next;
1431 ((sb->sb_flags & SB_NOCOALESCE) == 0) &&
1441 sb->sb_ccc += m->m_len;
1442 if (sb->sb_fnrdy == NULL)
1443 sb->sb_acc += m->m_len;
1446 sb->sb_ctl += m->m_len;
1457 sb->sb_mb = m;
1458 sb->sb_mbtail = m;
1459 sballoc(sb, m);
1469 SBLASTMBUFCHK(sb);
1479 sbcompress_ktls_rx(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
1482 SOCKBUF_LOCK_ASSERT(sb);
1505 ((sb->sb_flags & SB_NOCOALESCE) == 0) &&
1512 sb->sb_ccc += m->m_len;
1513 sb->sb_tlscc += m->m_len;
1520 sb->sb_mtls = m;
1521 sb->sb_mtlstail = m;
1522 sballoc_ktls_rx(sb, m);
1527 SBLASTMBUFCHK(sb);
1535 sbflush_internal(struct sockbuf *sb)
1538 while (sb->sb_mbcnt || sb->sb_tlsdcc) {
1540 * Don't call sbcut(sb, 0) if the leading mbuf is non-empty:
1543 if (sb->sb_ccc == 0 && (sb->sb_mb == NULL || sb->sb_mb->m_len))
1545 m_freem(sbcut_internal(sb, (int)sb->sb_ccc));
1547 KASSERT(sb->sb_ccc == 0 && sb->sb_mb == 0 && sb->sb_mbcnt == 0,
1549 sb->sb_ccc, (void *)sb->sb_mb, sb->sb_mbcnt));
1553 sbflush_locked(struct sockbuf *sb)
1556 SOCKBUF_LOCK_ASSERT(sb);
1557 sbflush_internal(sb);
1561 sbflush(struct sockbuf *sb)
1564 SOCKBUF_LOCK(sb);
1565 sbflush_locked(sb);
1566 SOCKBUF_UNLOCK(sb);
1573 sbcut_internal(struct sockbuf *sb, int len)
1580 KASSERT(len <= sb->sb_ccc, ("%s: len: %d is > ccc: %u",
1581 __func__, len, sb->sb_ccc));
1583 next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
1591 if (sb->sb_tlsdcc != 0) {
1592 MPASS(len >= sb->sb_tlsdcc);
1593 len -= sb->sb_tlsdcc;
1594 sb->sb_ccc -= sb->sb_tlsdcc;
1595 sb->sb_tlsdcc = 0;
1599 next = sb->sb_mtls;
1612 sb->sb_ccc -= len;
1613 sb->sb_acc -= len;
1614 if (sb->sb_sndptroff != 0)
1615 sb->sb_sndptroff -= len;
1617 sb->sb_ctl -= len;
1623 sbfree_ktls_rx(sb, m);
1626 sbfree(sb, m);
1651 sbfree(sb, m);
1659 sb->sb_mb = NULL;
1660 sb->sb_mtls = m;
1662 sb->sb_mtlstail = NULL;
1666 sb->sb_mb = m;
1669 sb->sb_mb = next;
1674 m = sb->sb_mb;
1676 sb->sb_mbtail = NULL;
1677 sb->sb_lastrecord = NULL;
1679 sb->sb_lastrecord = m;
1689 sbdrop_locked(struct sockbuf *sb, int len)
1692 SOCKBUF_LOCK_ASSERT(sb);
1693 m_freem(sbcut_internal(sb, len));
1701 sbcut_locked(struct sockbuf *sb, int len)
1704 SOCKBUF_LOCK_ASSERT(sb);
1705 return (sbcut_internal(sb, len));
1709 sbdrop(struct sockbuf *sb, int len)
1713 SOCKBUF_LOCK(sb);
1714 mfree = sbcut_internal(sb, len);
1715 SOCKBUF_UNLOCK(sb);
1721 sbsndptr_noadv(struct sockbuf *sb, uint32_t off, uint32_t *moff)
1725 KASSERT(sb->sb_mb != NULL, ("%s: sb_mb is NULL", __func__));
1726 if (sb->sb_sndptr == NULL || sb->sb_sndptroff > off) {
1728 if (sb->sb_sndptr == NULL) {
1729 sb->sb_sndptr = sb->sb_mb;
1730 sb->sb_sndptroff = 0;
1732 return (sb->sb_mb);
1734 m = sb->sb_sndptr;
1735 off -= sb->sb_sndptroff;
1742 sbsndptr_adv(struct sockbuf *sb, struct mbuf *mb, uint32_t len)
1750 if (mb != sb->sb_sndptr) {
1759 sb->sb_sndptroff += m->m_len;
1760 sb->sb_sndptr = m->m_next;
1774 sbsndmbuf(struct sockbuf *sb, u_int off, u_int *moff)
1778 KASSERT(sb->sb_mb != NULL, ("%s: sb_mb is NULL", __func__));
1784 if (sb->sb_sndptr == NULL || sb->sb_sndptroff > off) {
1785 m = sb->sb_mb;
1787 m = sb->sb_sndptr;
1788 off -= sb->sb_sndptroff;
1805 sbdroprecord_locked(struct sockbuf *sb)
1809 SOCKBUF_LOCK_ASSERT(sb);
1811 m = sb->sb_mb;
1813 sb->sb_mb = m->m_nextpkt;
1815 sbfree(sb, m);
1819 SB_EMPTY_FIXUP(sb);
1827 sbdroprecord(struct sockbuf *sb)
1830 SOCKBUF_LOCK(sb);
1831 sbdroprecord_locked(sb);
1832 SOCKBUF_UNLOCK(sb);
1886 sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
1889 xsb->sb_cc = sb->sb_ccc;
1890 xsb->sb_hiwat = sb->sb_hiwat;
1891 xsb->sb_mbcnt = sb->sb_mbcnt;
1892 xsb->sb_mbmax = sb->sb_mbmax;
1893 xsb->sb_lowat = sb->sb_lowat;
1894 xsb->sb_flags = sb->sb_flags;
1895 xsb->sb_timeo = sb->sb_timeo;