Lines Matching defs:sb
531 sbwait(struct sockbuf *sb)
537 so = sb->sb_so;
541 sb->sb_flags |= SB_NOTIFY;
543 if ((sb->sb_flags & SB_NOINTR) != 0)
544 error = cv_timedwait(&sb->sb_cv, lock, sb->sb_timeo);
546 error = cv_timedwait_sig(&sb->sb_cv, lock, sb->sb_timeo);
558 sowakeup(struct socket *so, struct sockbuf *sb, int code)
563 KASSERT(sb->sb_so == so);
586 sb->sb_flags &= ~SB_NOTIFY;
587 selnotify(&sb->sb_sel, band, NOTE_SUBMIT);
588 cv_broadcast(&sb->sb_cv);
589 if (sb->sb_flags & SB_ASYNC)
591 if (sb->sb_flags & SB_UPCALL)
704 sbreserve(struct sockbuf *sb, u_long cc, struct socket *so)
711 KASSERT(sb->sb_so == so);
720 if (!chgsbsize(uidinfo, &sb->sb_hiwat, cc, maxcc))
722 sb->sb_mbmax = uimin(cc * 2, sb_max);
723 if (sb->sb_lowat > sb->sb_hiwat)
724 sb->sb_lowat = sb->sb_hiwat;
734 sbrelease(struct sockbuf *sb, struct socket *so)
737 KASSERT(sb->sb_so == so);
739 sbflush(sb);
740 (void)chgsbsize(so->so_uidinfo, &sb->sb_hiwat, 0, RLIM_INFINITY);
741 sb->sb_mbmax = 0;
771 sblastrecordchk(struct sockbuf *sb, const char *where)
773 struct mbuf *m = sb->sb_mb;
775 KASSERT(solocked(sb->sb_so));
780 if (m != sb->sb_lastrecord) {
782 sb->sb_mb, sb->sb_lastrecord, m);
784 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt)
791 sblastmbufchk(struct sockbuf *sb, const char *where)
793 struct mbuf *m = sb->sb_mb;
796 KASSERT(solocked(sb->sb_so));
804 if (m != sb->sb_mbtail) {
806 sb->sb_mb, sb->sb_mbtail, m);
808 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
822 #define SBLINKRECORDCHAIN(sb, m0, mlast) \
824 if ((sb)->sb_lastrecord != NULL) \
825 (sb)->sb_lastrecord->m_nextpkt = (m0); \
827 (sb)->sb_mb = (m0); \
828 (sb)->sb_lastrecord = (mlast); \
832 #define SBLINKRECORD(sb, m0) \
833 SBLINKRECORDCHAIN(sb, m0, m0)
837 * socket buffer sb. The additional space associated
838 * the mbuf chain is recorded in sb. Empty mbufs are
842 sbappend(struct sockbuf *sb, struct mbuf *m)
846 KASSERT(solocked(sb->sb_so));
852 m_claimm(m, sb->sb_mowner);
855 SBLASTRECORDCHK(sb, "sbappend 1");
857 if ((n = sb->sb_lastrecord) != NULL) {
865 sbappendrecord(sb, m); /* XXXXXX!!!! */
874 sb->sb_lastrecord = m;
876 sbcompress(sb, m, n);
877 SBLASTRECORDCHK(sb, "sbappend 2");
886 sbappendstream(struct sockbuf *sb, struct mbuf *m)
889 KASSERT(solocked(sb->sb_so));
891 KASSERT(sb->sb_mb == sb->sb_lastrecord);
893 SBLASTMBUFCHK(sb, __func__);
896 m_claimm(m, sb->sb_mowner);
899 sbcompress(sb, m, sb->sb_mbtail);
901 sb->sb_lastrecord = sb->sb_mb;
902 SBLASTRECORDCHK(sb, __func__);
907 sbcheck(struct sockbuf *sb)
912 KASSERT(solocked(sb->sb_so));
916 for (m = sb->sb_mb; m; m = m->m_nextpkt) {
926 if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
927 printf("cc %lu != %lu || mbcnt %lu != %lu\n", len, sb->sb_cc,
928 mbcnt, sb->sb_mbcnt);
939 sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
943 KASSERT(solocked(sb->sb_so));
949 m_claimm(m0, sb->sb_mowner);
955 sballoc(sb, m0);
956 SBLASTRECORDCHK(sb, "sbappendrecord 1");
957 SBLINKRECORD(sb, m0);
964 sbcompress(sb, m, m0);
965 SBLASTRECORDCHK(sb, "sbappendrecord 2");
974 sbinsertoob(struct sockbuf *sb, struct mbuf *m0)
978 KASSERT(solocked(sb->sb_so));
983 SBLASTRECORDCHK(sb, "sbinsertoob 1");
985 for (mp = &sb->sb_mb; (m = *mp) != NULL; mp = &((*mp)->m_nextpkt)) {
1002 sballoc(sb, m0);
1006 sb->sb_lastrecord = m0;
1015 sbcompress(sb, m, m0);
1016 SBLASTRECORDCHK(sb, "sbinsertoob 2");
1026 sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa, struct mbuf *m0,
1032 KASSERT(solocked(sb->sb_so));
1041 m_claimm(m0, sb->sb_mowner);
1046 MCLAIM(n, sb->sb_mowner);
1050 if (space > sbspace(sb))
1055 MCLAIM(m, sb->sb_mowner);
1076 SBLASTRECORDCHK(sb, "sbappendaddr 1");
1079 sballoc(sb, n);
1080 sballoc(sb, n);
1082 SBLINKRECORD(sb, m);
1084 sb->sb_mbtail = nlast;
1085 SBLASTMBUFCHK(sb, "sbappendaddr");
1086 SBLASTRECORDCHK(sb, "sbappendaddr 2");
1096 m_prepend_sockaddr(struct sockbuf *sb, struct mbuf *m0,
1102 KASSERT(solocked(sb->sb_so));
1108 MCLAIM(m, sb->sb_mowner);
1129 sbappendaddrchain(struct sockbuf *sb, const struct sockaddr *asa,
1135 KASSERT(solocked(sb->sb_so));
1139 * SB_PRIO_NONE --> honour normal sb limits
1156 space = sbspace(sb);
1169 m_claimm(m, sb->sb_mowner);
1173 n = m_prepend_sockaddr(sb, m, asa);
1189 sballoc(sb, np);
1192 SBLASTRECORDCHK(sb, "sbappendaddrchain 1");
1195 SBLINKRECORDCHAIN(sb, n0, nlast);
1197 SBLASTRECORDCHK(sb, "sbappendaddrchain 2");
1201 sb->sb_mbtail = m;
1202 SBLASTMBUFCHK(sb, "sbappendaddrchain");
1217 sbfree(sb, np);
1227 sbappendcontrol(struct sockbuf *sb, struct mbuf *m0, struct mbuf *control)
1232 KASSERT(solocked(sb->sb_so));
1239 MCLAIM(m, sb->sb_mowner);
1245 MCLAIM(m, sb->sb_mowner);
1248 if (space > sbspace(sb))
1252 SBLASTRECORDCHK(sb, "sbappendcontrol 1");
1255 sballoc(sb, m);
1256 sballoc(sb, m);
1258 SBLINKRECORD(sb, control);
1260 sb->sb_mbtail = mlast;
1261 SBLASTMBUFCHK(sb, "sbappendcontrol");
1262 SBLASTRECORDCHK(sb, "sbappendcontrol 2");
1269 * buffer sb following mbuf n. If n
1273 sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
1278 KASSERT(solocked(sb->sb_so));
1287 if (sb->sb_lastrecord == m)
1288 sb->sb_lastrecord = m->m_next;
1300 sb->sb_cc += m->m_len;
1307 sb->sb_mb = m;
1308 sb->sb_mbtail = m;
1309 sballoc(sb, m);
1321 SBLASTMBUFCHK(sb, __func__);
1329 sbflush(struct sockbuf *sb)
1332 KASSERT(solocked(sb->sb_so));
1333 KASSERT((sb->sb_flags & SB_LOCK) == 0);
1335 while (sb->sb_mbcnt)
1336 sbdrop(sb, (int)sb->sb_cc);
1338 KASSERT(sb->sb_cc == 0);
1339 KASSERT(sb->sb_mb == NULL);
1340 KASSERT(sb->sb_mbtail == NULL);
1341 KASSERT(sb->sb_lastrecord == NULL);
1348 sbdrop(struct sockbuf *sb, int len)
1352 KASSERT(solocked(sb->sb_so));
1354 next = (m = sb->sb_mb) ? m->m_nextpkt : NULL;
1359 sb, len, sb->sb_cc);
1367 sb->sb_cc -= len;
1371 sbfree(sb, m);
1375 sbfree(sb, m);
1379 sb->sb_mb = m;
1382 sb->sb_mb = next;
1388 m = sb->sb_mb;
1390 sb->sb_mbtail = NULL;
1391 sb->sb_lastrecord = NULL;
1393 sb->sb_lastrecord = m;
1401 sbdroprecord(struct sockbuf *sb)
1405 KASSERT(solocked(sb->sb_so));
1407 m = sb->sb_mb;
1409 sb->sb_mb = m->m_nextpkt;
1411 sbfree(sb, m);
1415 SB_EMPTY_FIXUP(sb);
1526 * Set lock on sockbuf sb; sleep if lock is already held.
1531 sblock(struct sockbuf *sb, int wf)
1537 KASSERT(solocked(sb->sb_so));
1540 if (__predict_true((sb->sb_flags & SB_LOCK) == 0)) {
1541 sb->sb_flags |= SB_LOCK;
1546 so = sb->sb_so;
1548 if ((sb->sb_flags & SB_NOINTR) != 0) {
1561 sbunlock(struct sockbuf *sb)
1565 so = sb->sb_so;
1568 KASSERT((sb->sb_flags & SB_LOCK) != 0);
1570 sb->sb_flags &= ~SB_LOCK;