Lines Matching refs:sb
479 sbwait(struct sockbuf *sb)
481 boolean_t nointr = (sb->sb_flags & SB_NOINTR);
483 struct socket *so = sb->sb_so;
489 panic("%s: null so, sb=%p sb_flags=0x%x lr=%p\n",
490 __func__, sb, sb->sb_flags, lr_saved);
493 panic("%s: sb=%p sb_flags=0x%x sb_so=%p usecount=%d lr=%p "
494 "lrh= %s\n", __func__, sb, sb->sb_flags, so,
506 ts.tv_sec = sb->sb_timeo.tv_sec;
507 ts.tv_nsec = sb->sb_timeo.tv_usec * 1000;
509 sb->sb_waiters++;
510 VERIFY(sb->sb_waiters != 0);
512 error = msleep((caddr_t)&sb->sb_cc, mutex_held,
516 VERIFY(sb->sb_waiters != 0);
517 sb->sb_waiters--;
520 panic("%s: 2 sb=%p sb_flags=0x%x sb_so=%p usecount=%d lr=%p "
521 "lrh= %s\n", __func__, sb, sb->sb_flags, so,
540 sbwakeup(struct sockbuf *sb)
542 if (sb->sb_waiters > 0)
543 wakeup((caddr_t)&sb->sb_cc);
552 sowakeup(struct socket *so, struct sockbuf *sb)
558 SOCK_TYPE(so), (uint32_t)sb->sb_sel.si_flags, sb->sb_flags,
559 (sb->sb_flags & SB_RECV) ? "rcv" : "snd"));
562 sb->sb_flags &= ~SB_SEL;
563 selwakeup(&sb->sb_sel);
564 sbwakeup(sb);
571 if (sb->sb_flags & SB_KNOTE) {
572 KNOTE(&sb->sb_sel.si_note, SO_FILT_HINT_LOCKED);
574 if (sb->sb_flags & SB_UPCALL) {
578 sb_upcall = sb->sb_upcall;
579 sb_upcallarg = sb->sb_upcallarg;
598 if ((sb->sb_flags & SB_RECV)) {
680 sbreserve(struct sockbuf *sb, u_int32_t cc)
684 sb->sb_hiwat = cc;
685 sb->sb_mbmax = min(cc * sb_efficiency, sb_max);
686 if (sb->sb_lowat > sb->sb_hiwat)
687 sb->sb_lowat = sb->sb_hiwat;
696 sbrelease(struct sockbuf *sb)
698 sbflush(sb);
699 sb->sb_hiwat = 0;
700 sb->sb_mbmax = 0;
730 * socket buffer sb. The additional space associated
731 * the mbuf chain is recorded in sb. Empty mbufs are
735 sbappend(struct sockbuf *sb, struct mbuf *m)
737 struct socket *so = sb->sb_so;
739 if (m == NULL || (sb->sb_flags & SB_DROP)) {
745 SBLASTRECORDCHK(sb, "sbappend 1");
747 if (sb->sb_lastrecord != NULL && (sb->sb_mbtail->m_flags & M_EOR))
748 return (sbappendrecord(sb, m));
750 if (sb->sb_flags & SB_RECV && !(m && m->m_flags & M_SKIPCFIL)) {
752 SBLASTRECORDCHK(sb, "sbappend 2");
769 if (sb->sb_lastrecord == NULL)
770 sb->sb_lastrecord = m;
772 sbcompress(sb, m, sb->sb_mbtail);
773 SBLASTRECORDCHK(sb, "sbappend 3");
781 sbappendstream(struct sockbuf *sb, struct mbuf *m)
783 struct socket *so = sb->sb_so;
785 if (m == NULL || (sb->sb_flags & SB_DROP)) {
791 if (m->m_nextpkt != NULL || (sb->sb_mb != sb->sb_lastrecord)) {
793 m->m_nextpkt, sb->sb_mb, sb->sb_lastrecord);
797 SBLASTMBUFCHK(sb, __func__);
799 if (sb->sb_flags & SB_RECV && !(m && m->m_flags & M_SKIPCFIL)) {
801 SBLASTRECORDCHK(sb, "sbappendstream 1");
817 sbcompress(sb, m, sb->sb_mbtail);
818 sb->sb_lastrecord = sb->sb_mb;
819 SBLASTRECORDCHK(sb, "sbappendstream 2");
825 sbcheck(struct sockbuf *sb)
832 if (sb->sb_so->so_proto->pr_getlock != NULL)
833 mutex_held = (*sb->sb_so->so_proto->pr_getlock)(sb->sb_so, 0);
835 mutex_held = sb->sb_so->so_proto->pr_domain->dom_mtx;
842 for (m = sb->sb_mb; m; m = n) {
852 if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
853 panic("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
854 mbcnt, sb->sb_mbcnt);
860 sblastrecordchk(struct sockbuf *sb, const char *where)
862 struct mbuf *m = sb->sb_mb;
867 if (m != sb->sb_lastrecord) {
870 (uint64_t)VM_KERNEL_ADDRPERM(sb->sb_mb),
871 (uint64_t)VM_KERNEL_ADDRPERM(sb->sb_lastrecord),
874 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt)
881 sblastmbufchk(struct sockbuf *sb, const char *where)
883 struct mbuf *m = sb->sb_mb;
892 if (m != sb->sb_mbtail) {
894 (uint64_t)VM_KERNEL_ADDRPERM(sb->sb_mb),
895 (uint64_t)VM_KERNEL_ADDRPERM(sb->sb_mbtail),
898 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
912 sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
917 if (m0 == NULL || (sb->sb_flags & SB_DROP)) {
926 if (space > sbspace(sb) && !(sb->sb_flags & SB_UNIX)) {
931 if (sb->sb_flags & SB_RECV && !(m0 && m0->m_flags & M_SKIPCFIL)) {
932 int error = sflt_data_in(sb->sb_so, NULL, &m0, NULL,
937 error = cfil_sock_data_in(sb->sb_so, NULL, m0, NULL, 0);
941 SBLASTRECORDCHK(sb, "sbappendrecord 1");
953 sballoc(sb, m0);
954 SBLASTRECORDCHK(sb, "sbappendrecord 2");
955 if (sb->sb_lastrecord != NULL) {
956 sb->sb_lastrecord->m_nextpkt = m0;
958 sb->sb_mb = m0;
960 sb->sb_lastrecord = m0;
961 sb->sb_mbtail = m0;
969 sbcompress(sb, m, m0);
970 SBLASTRECORDCHK(sb, "sbappendrecord 3");
980 sbinsertoob(struct sockbuf *sb, struct mbuf *m0)
988 SBLASTRECORDCHK(sb, "sbinsertoob 1");
990 if ((sb->sb_flags & SB_RECV && !(m0->m_flags & M_SKIPCFIL)) != 0) {
991 int error = sflt_data_in(sb->sb_so, NULL, &m0, NULL,
994 SBLASTRECORDCHK(sb, "sbinsertoob 2");
998 error = cfil_sock_data_in(sb->sb_so, NULL, m0, NULL, 0);
1011 for (mp = &sb->sb_mb; *mp; mp = &((*mp)->m_nextpkt)) {
1030 sballoc(sb, m0);
1034 sb->sb_lastrecord = m0;
1043 sbcompress(sb, m, m0);
1044 SBLASTRECORDCHK(sb, "sbinsertoob 3");
1058 sbappendaddr_internal(struct sockbuf *sb, struct sockaddr *asa,
1074 if (space > sbspace(sb))
1089 SBLASTRECORDCHK(sb, "sbappendadddr 1");
1092 sballoc(sb, n);
1093 sballoc(sb, n);
1096 if (sb->sb_lastrecord != NULL) {
1097 sb->sb_lastrecord->m_nextpkt = m;
1099 sb->sb_mb = m;
1101 sb->sb_lastrecord = m;
1102 sb->sb_mbtail = nlast;
1104 SBLASTMBUFCHK(sb, __func__);
1105 SBLASTRECORDCHK(sb, "sbappendadddr 2");
1107 postevent(0, sb, EV_RWBYTES);
1120 sbappendaddr(struct sockbuf *sb, struct sockaddr *asa, struct mbuf *m0,
1124 boolean_t sb_unix = (sb->sb_flags & SB_UNIX);
1132 if (sb->sb_flags & SB_DROP) {
1143 if (sb->sb_flags & SB_RECV && !(m0 && m0->m_flags & M_SKIPCFIL)) {
1145 error = sflt_data_in(sb->sb_so, asa, &m0, &control, 0);
1146 SBLASTRECORDCHK(sb, __func__);
1150 error = cfil_sock_data_in(sb->sb_so, asa, m0, control, 0);
1168 result = sbappendaddr_internal(sb, asa, m0, control);
1182 sbappendcontrol_internal(struct sockbuf *sb, struct mbuf *m0,
1199 if (space > sbspace(sb) && !(sb->sb_flags & SB_UNIX))
1202 SBLASTRECORDCHK(sb, "sbappendcontrol 1");
1205 sballoc(sb, m);
1206 sballoc(sb, m);
1209 if (sb->sb_lastrecord != NULL) {
1210 sb->sb_lastrecord->m_nextpkt = control;
1212 sb->sb_mb = control;
1214 sb->sb_lastrecord = control;
1215 sb->sb_mbtail = mlast;
1217 SBLASTMBUFCHK(sb, __func__);
1218 SBLASTRECORDCHK(sb, "sbappendcontrol 2");
1220 postevent(0, sb, EV_RWBYTES);
1225 sbappendcontrol(struct sockbuf *sb, struct mbuf *m0, struct mbuf *control,
1229 boolean_t sb_unix = (sb->sb_flags & SB_UNIX);
1234 if (sb->sb_flags & SB_DROP) {
1244 if (sb->sb_flags & SB_RECV && !(m0 && m0->m_flags & M_SKIPCFIL)) {
1247 error = sflt_data_in(sb->sb_so, NULL, &m0, &control, 0);
1248 SBLASTRECORDCHK(sb, __func__);
1252 error = cfil_sock_data_in(sb->sb_so, NULL, m0, control, 0);
1270 result = sbappendcontrol_internal(sb, m0, control);
1288 sbappendmsgstream_rcv(struct sockbuf *sb, struct mbuf *m, uint32_t seqnum,
1294 struct socket *so = sb->sb_so;
1298 VERIFY(sb->sb_flags & SB_RECV);
1327 if (unordered && !sbreserve(sb, sb->sb_hiwat + data_len)) {
1336 if (!unordered && (sb->sb_mbtail != NULL) &&
1337 !(sb->sb_mbtail->m_flags & M_UNORDERED_DATA)) {
1338 sb->sb_mbtail->m_flags &= ~M_EOR;
1339 sbcompress(sb, m, sb->sb_mbtail);
1342 ret = sbappendrecord(sb, m);
1344 VERIFY(sb->sb_mbtail->m_flags & M_EOR);
1379 sbappendmptcpstream_rcv(struct sockbuf *sb, struct mbuf *m)
1381 struct socket *so = sb->sb_so;
1385 VERIFY((sb->sb_flags & (SB_RECV|SB_NOCOMPRESS)) ==
1388 if (m == NULL || m_pktlen(m) == 0 || (sb->sb_flags & SB_DROP) ||
1397 if (m->m_nextpkt != NULL || (sb->sb_mb != sb->sb_lastrecord)) {
1399 m->m_nextpkt, sb->sb_mb, sb->sb_lastrecord);
1403 SBLASTMBUFCHK(sb, __func__);
1410 sbcompress(sb, m, sb->sb_mbtail);
1411 sb->sb_lastrecord = sb->sb_mb;
1412 SBLASTRECORDCHK(sb, __func__);
1421 sbappendmsg_snd(struct sockbuf *sb, struct mbuf *m)
1423 struct socket *so = sb->sb_so;
1429 if (m->m_nextpkt != NULL || (sb->sb_mb != sb->sb_lastrecord))
1431 m->m_nextpkt, sb->sb_mb, sb->sb_lastrecord);
1433 SBLASTMBUFCHK(sb, __func__);
1435 if (m == NULL || (sb->sb_flags & SB_DROP) || so->so_msg_state == NULL) {
1473 sballoc(sb, m);
1477 sballoc(sb, m);
1493 SBLASTRECORDCHK(sb, "sbappendstream 2");
1494 postevent(0, sb, EV_RWBYTES);
1623 * buffer sb following mbuf n. If n
1627 sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
1629 int eor = 0, compress = (!(sb->sb_flags & SB_NOCOMPRESS));
1636 sb->sb_mbtail = n;
1644 if (sb->sb_lastrecord == m)
1645 sb->sb_lastrecord = m->m_next;
1659 sb->sb_cc += m->m_len;
1663 sb->sb_ctl += m->m_len;
1671 sb->sb_mb = m;
1672 sb->sb_mbtail = m;
1673 sballoc(sb, m);
1686 SBLASTMBUFCHK(sb, __func__);
1687 postevent(0, sb, EV_RWBYTES);
1691 sb_empty_assert(struct sockbuf *sb, const char *where)
1693 if (!(sb->sb_cc == 0 && sb->sb_mb == NULL && sb->sb_mbcnt == 0 &&
1694 sb->sb_mbtail == NULL && sb->sb_lastrecord == NULL)) {
1695 panic("%s: sb %p so %p cc %d mbcnt %d mb %p mbtail %p "
1696 "lastrecord %p\n", where, sb, sb->sb_so, sb->sb_cc,
1697 sb->sb_mbcnt, sb->sb_mb, sb->sb_mbtail,
1698 sb->sb_lastrecord);
1719 sbflush(struct sockbuf *sb)
1722 struct socket *so = sb->sb_so;
1730 panic("%s: null so, sb=%p sb_flags=0x%x lr=%p\n",
1731 __func__, sb, sb->sb_flags, lr_saved);
1734 panic("%s: sb=%p sb_flags=0x%x sb_so=%p usecount=%d lr=%p "
1735 "lrh= %s\n", __func__, sb, sb->sb_flags, so,
1760 (void) sblock(sb, SBL_WAIT | SBL_NOINTR | SBL_IGNDEFUNCT);
1761 VERIFY(sb->sb_flags & SB_LOCK);
1763 while (sb->sb_mbcnt > 0) {
1765 * Don't call sbdrop(sb, 0) if the leading mbuf is non-empty:
1768 if (!sb->sb_cc && (sb->sb_mb == NULL || sb->sb_mb->m_len))
1770 sbdrop(sb, (int)sb->sb_cc);
1773 if (!(sb->sb_flags & SB_RECV) && (so->so_flags & SOF_ENABLE_MSGS)) {
1782 sb_empty_assert(sb, __func__);
1783 postevent(0, sb, EV_RWBYTES);
1785 sbunlock(sb, TRUE); /* keep socket locked */
1800 sbdrop(struct sockbuf *sb, int len)
1805 next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
1808 (!(sb->sb_flags & SB_RECV)) &&
1809 ((sb->sb_so->so_flags & SOF_MP_SUBFLOW) ||
1810 ((SOCK_CHECK_DOM(sb->sb_so, PF_MULTIPATH)) &&
1811 (SOCK_CHECK_PROTO(sb->sb_so, IPPROTO_TCP)))) &&
1812 (!(sb->sb_so->so_flags1 & SOF1_POST_FALLBACK_SYNC))) {
1816 KERNEL_DEBUG((DBG_FNC_SBDROP | DBG_FUNC_START), sb, len, 0, 0, 0);
1838 sb->sb_cc = 0;
1839 sb->sb_mbcnt = 0;
1840 if (!(sb->sb_flags & SB_RECV) &&
1841 (sb->sb_so->so_flags & SOF_ENABLE_MSGS)) {
1842 sb->sb_so->so_msg_state->
1854 sb->sb_cc -= len;
1857 sb->sb_ctl -= len;
1861 sbfree(sb, m);
1867 sbfree(sb, m);
1878 sb->sb_mb = m;
1881 sb->sb_mb = next;
1889 m = sb->sb_mb;
1891 sb->sb_mbtail = NULL;
1892 sb->sb_lastrecord = NULL;
1894 sb->sb_lastrecord = m;
1898 cfil_sock_buf_update(sb);
1901 postevent(0, sb, EV_RWBYTES);
1903 KERNEL_DEBUG((DBG_FNC_SBDROP | DBG_FUNC_END), sb, 0, 0, 0, 0);
1911 sbdroprecord(struct sockbuf *sb)
1915 m = sb->sb_mb;
1917 sb->sb_mb = m->m_nextpkt;
1919 sbfree(sb, m);
1924 SB_EMPTY_FIXUP(sb);
1925 postevent(0, sb, EV_RWBYTES);
2136 struct stat *sb;
2138 sb = (struct stat *)ub;
2139 sb->st_blksize = so->so_snd.sb_hiwat;
2252 sb_notify(struct sockbuf *sb)
2254 return (sb->sb_waiters > 0 ||
2255 (sb->sb_flags & (SB_SEL|SB_ASYNC|SB_UPCALL|SB_KNOTE)));
2265 sbspace(struct sockbuf *sb)
2268 int space = imin((int)(sb->sb_hiwat - sb->sb_cc),
2269 (int)(sb->sb_mbmax - sb->sb_mbcnt));
2275 pending = cfil_sock_data_space(sb);
2365 /* adjust counters in sb reflecting allocation of m */
2368 sballoc(struct sockbuf *sb, struct mbuf *m)
2371 sb->sb_cc += m->m_len;
2374 sb->sb_ctl += m->m_len;
2375 sb->sb_mbcnt += MSIZE;
2378 sb->sb_mbcnt += m->m_ext.ext_size;
2387 /* adjust counters in sb reflecting freeing of m */
2389 sbfree(struct sockbuf *sb, struct mbuf *m)
2393 sb->sb_cc -= m->m_len;
2396 sb->sb_ctl -= m->m_len;
2397 sb->sb_mbcnt -= MSIZE;
2399 sb->sb_mbcnt -= m->m_ext.ext_size;
2407 * Set lock on sockbuf sb; sleep if lock is already held.
2412 sblock(struct sockbuf *sb, uint32_t flags)
2414 boolean_t nointr = ((sb->sb_flags & SB_NOINTR) || (flags & SBL_NOINTR));
2416 struct socket *so = sb->sb_so;
2425 panic("%s: null so, sb=%p sb_flags=0x%x lr=%p\n",
2426 __func__, sb, sb->sb_flags, lr_saved);
2429 panic("%s: sb=%p sb_flags=0x%x sb_so=%p usecount=%d lr=%p "
2430 "lrh= %s\n", __func__, sb, sb->sb_flags, so,
2438 if ((so->so_flags & SOF_CONTENT_FILTER) && sb->sb_cfil_thread == tp) {
2443 if (!(so->so_flags & SOF_DEFUNCT) && !(sb->sb_flags & SB_LOCK))
2445 __func__, sb);
2451 if ((sb->sb_flags & SB_LOCK) && !(flags & SBL_WAIT))
2454 * We may get here from sorflush(), in which case "sb" may not
2458 wchan = (sb->sb_flags & SB_RECV) ?
2465 while ((sb->sb_flags & SB_LOCK) ||
2467 sb->sb_cfil_thread != NULL)) {
2483 sb->sb_wantlock++;
2484 VERIFY(sb->sb_wantlock != 0);
2490 VERIFY(sb->sb_wantlock != 0);
2491 sb->sb_wantlock--;
2505 sb->sb_flags |= SB_LOCK;
2510 * Release lock on sockbuf sb
2513 sbunlock(struct sockbuf *sb, boolean_t keeplocked)
2516 struct socket *so = sb->sb_so;
2521 panic("%s: null so, sb=%p sb_flags=0x%x lr=%p\n",
2522 __func__, sb, sb->sb_flags, lr_saved);
2525 panic("%s: sb=%p sb_flags=0x%x sb_so=%p usecount=%d lr=%p "
2526 "lrh= %s\n", __func__, sb, sb->sb_flags, so,
2534 if ((so->so_flags & SOF_CONTENT_FILTER) && sb->sb_cfil_thread == tp) {
2540 !(sb->sb_flags & SB_LOCK) &&
2544 __func__, sb);
2548 VERIFY((sb->sb_flags & SB_LOCK) ||
2552 sb->sb_flags &= ~SB_LOCK;
2554 if (sb->sb_wantlock > 0) {
2556 * We may get here from sorflush(), in which case "sb" may not
2560 wakeup((sb->sb_flags & SB_RECV) ? &so->so_rcv.sb_flags :
2778 sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
2780 xsb->sb_cc = sb->sb_cc;
2781 xsb->sb_hiwat = sb->sb_hiwat;
2782 xsb->sb_mbcnt = sb->sb_mbcnt;
2783 xsb->sb_mbmax = sb->sb_mbmax;
2784 xsb->sb_lowat = sb->sb_lowat;
2785 xsb->sb_flags = sb->sb_flags;
2787 (sb->sb_timeo.tv_sec * hz) + sb->sb_timeo.tv_usec / tick;
2788 if (xsb->sb_timeo == 0 && sb->sb_timeo.tv_usec != 0)