Lines Matching refs:sb
68 static struct mbuf *sbcut_internal(struct sockbuf *sb, int len);
69 static void sbflush_internal(struct sockbuf *sb);
124 sbwait(struct sockbuf *sb)
127 SOCKBUF_LOCK_ASSERT(sb);
129 sb->sb_flags |= SB_WAIT;
130 return (msleep_sbt(&sb->sb_cc, &sb->sb_mtx,
131 (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait",
132 sb->sb_timeo, 0, 0));
136 sblock(struct sockbuf *sb, int flags)
143 if ((sb->sb_flags & SB_NOINTR) ||
145 sx_xlock(&sb->sb_sx);
148 return (sx_xlock_sig(&sb->sb_sx));
150 if (sx_try_xlock(&sb->sb_sx) == 0)
157 sbunlock(struct sockbuf *sb)
160 sx_xunlock(&sb->sb_sx);
176 sowakeup(struct socket *so, struct sockbuf *sb)
180 SOCKBUF_LOCK_ASSERT(sb);
182 selwakeuppri(&sb->sb_sel, PSOCK);
183 if (!SEL_WAITING(&sb->sb_sel))
184 sb->sb_flags &= ~SB_SEL;
185 if (sb->sb_flags & SB_WAIT) {
186 sb->sb_flags &= ~SB_WAIT;
187 wakeup(&sb->sb_cc);
189 KNOTE_LOCKED(&sb->sb_sel.si_note, 0);
190 if (sb->sb_upcall != NULL) {
191 ret = sb->sb_upcall(so, sb->sb_upcallarg, M_NOWAIT);
193 KASSERT(sb == &so->so_rcv,
199 if (sb->sb_flags & SB_AIO)
200 aio_swake(so, sb);
201 SOCKBUF_UNLOCK(sb);
206 mtx_assert(SOCKBUF_MTX(sb), MA_NOTOWNED);
289 sbreserve_locked(struct sockbuf *sb, u_long cc, struct socket *so,
294 SOCKBUF_LOCK_ASSERT(sb);
311 if (!chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, cc,
314 sb->sb_mbmax = min(cc * sb_efficiency, sb_max);
315 if (sb->sb_lowat > sb->sb_hiwat)
316 sb->sb_lowat = sb->sb_hiwat;
321 sbreserve(struct sockbuf *sb, u_long cc, struct socket *so,
326 SOCKBUF_LOCK(sb);
327 error = sbreserve_locked(sb, cc, so, td);
328 SOCKBUF_UNLOCK(sb);
336 sbrelease_internal(struct sockbuf *sb, struct socket *so)
339 sbflush_internal(sb);
340 (void)chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, 0,
342 sb->sb_mbmax = 0;
346 sbrelease_locked(struct sockbuf *sb, struct socket *so)
349 SOCKBUF_LOCK_ASSERT(sb);
351 sbrelease_internal(sb, so);
355 sbrelease(struct sockbuf *sb, struct socket *so)
358 SOCKBUF_LOCK(sb);
359 sbrelease_locked(sb, so);
360 SOCKBUF_UNLOCK(sb);
364 sbdestroy(struct sockbuf *sb, struct socket *so)
367 sbrelease_internal(sb, so);
394 sblastrecordchk(struct sockbuf *sb, const char *file, int line)
396 struct mbuf *m = sb->sb_mb;
398 SOCKBUF_LOCK_ASSERT(sb);
403 if (m != sb->sb_lastrecord) {
405 __func__, sb->sb_mb, sb->sb_lastrecord, m);
407 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt)
414 sblastmbufchk(struct sockbuf *sb, const char *file, int line)
416 struct mbuf *m = sb->sb_mb;
419 SOCKBUF_LOCK_ASSERT(sb);
427 if (m != sb->sb_mbtail) {
429 __func__, sb->sb_mb, sb->sb_mbtail, m);
431 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
442 #define SBLINKRECORD(sb, m0) do { \
443 SOCKBUF_LOCK_ASSERT(sb); \
444 if ((sb)->sb_lastrecord != NULL) \
445 (sb)->sb_lastrecord->m_nextpkt = (m0); \
447 (sb)->sb_mb = (m0); \
448 (sb)->sb_lastrecord = (m0); \
452 * Append mbuf chain m to the last record in the socket buffer sb. The
453 * additional space associated the mbuf chain is recorded in sb. Empty mbufs
457 sbappend_locked(struct sockbuf *sb, struct mbuf *m)
461 SOCKBUF_LOCK_ASSERT(sb);
466 SBLASTRECORDCHK(sb);
467 n = sb->sb_mb;
473 sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
483 if ((n = sb->sb_lastrecord) != NULL) {
486 sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
495 sb->sb_lastrecord = m;
498 sbcompress(sb, m, n);
499 SBLASTRECORDCHK(sb);
503 * Append mbuf chain m to the last record in the socket buffer sb. The
504 * additional space associated the mbuf chain is recorded in sb. Empty mbufs
508 sbappend(struct sockbuf *sb, struct mbuf *m)
511 SOCKBUF_LOCK(sb);
512 sbappend_locked(sb, m);
513 SOCKBUF_UNLOCK(sb);
522 sbappendstream_locked(struct sockbuf *sb, struct mbuf *m)
524 SOCKBUF_LOCK_ASSERT(sb);
527 KASSERT(sb->sb_mb == sb->sb_lastrecord,("sbappendstream 1"));
529 SBLASTMBUFCHK(sb);
534 sbcompress(sb, m, sb->sb_mbtail);
536 sb->sb_lastrecord = sb->sb_mb;
537 SBLASTRECORDCHK(sb);
546 sbappendstream(struct sockbuf *sb, struct mbuf *m)
549 SOCKBUF_LOCK(sb);
550 sbappendstream_locked(sb, m);
551 SOCKBUF_UNLOCK(sb);
556 sbcheck(struct sockbuf *sb)
562 SOCKBUF_LOCK_ASSERT(sb);
564 for (m = sb->sb_mb; m; m = n) {
573 if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
574 printf("cc %ld != %u || mbcnt %ld != %u\n", len, sb->sb_cc,
575 mbcnt, sb->sb_mbcnt);
585 sbappendrecord_locked(struct sockbuf *sb, struct mbuf *m0)
589 SOCKBUF_LOCK_ASSERT(sb);
597 sballoc(sb, m0);
598 SBLASTRECORDCHK(sb);
599 SBLINKRECORD(sb, m0);
600 sb->sb_mbtail = m0;
608 sbcompress(sb, m, m0);
615 sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
618 SOCKBUF_LOCK(sb);
619 sbappendrecord_locked(sb, m0);
620 SOCKBUF_UNLOCK(sb);
630 sbappendaddr_locked(struct sockbuf *sb, const struct sockaddr *asa,
636 SOCKBUF_LOCK_ASSERT(sb);
644 if (space > sbspace(sb))
661 sballoc(sb, n);
662 sballoc(sb, n);
664 SBLINKRECORD(sb, m);
666 sb->sb_mbtail = nlast;
667 SBLASTMBUFCHK(sb);
669 SBLASTRECORDCHK(sb);
680 sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa,
685 SOCKBUF_LOCK(sb);
686 retval = sbappendaddr_locked(sb, asa, m0, control);
687 SOCKBUF_UNLOCK(sb);
692 sbappendcontrol_locked(struct sockbuf *sb, struct mbuf *m0,
698 SOCKBUF_LOCK_ASSERT(sb);
704 if (space > sbspace(sb))
708 SBLASTRECORDCHK(sb);
711 sballoc(sb, m);
712 sballoc(sb, m);
714 SBLINKRECORD(sb, control);
716 sb->sb_mbtail = mlast;
717 SBLASTMBUFCHK(sb);
719 SBLASTRECORDCHK(sb);
724 sbappendcontrol(struct sockbuf *sb, struct mbuf *m0, struct mbuf *control)
728 SOCKBUF_LOCK(sb);
729 retval = sbappendcontrol_locked(sb, m0, control);
730 SOCKBUF_UNLOCK(sb);
735 * Append the data in mbuf chain (m) into the socket buffer sb following mbuf
755 sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
760 SOCKBUF_LOCK_ASSERT(sb);
768 if (sb->sb_lastrecord == m)
769 sb->sb_lastrecord = m->m_next;
775 ((sb->sb_flags & SB_NOCOALESCE) == 0) &&
782 sb->sb_cc += m->m_len;
785 sb->sb_ctl += m->m_len;
792 sb->sb_mb = m;
793 sb->sb_mbtail = m;
794 sballoc(sb, m);
804 SBLASTMBUFCHK(sb);
811 sbflush_internal(struct sockbuf *sb)
814 while (sb->sb_mbcnt) {
816 * Don't call sbdrop(sb, 0) if the leading mbuf is non-empty:
819 if (!sb->sb_cc && (sb->sb_mb == NULL || sb->sb_mb->m_len))
821 m_freem(sbcut_internal(sb, (int)sb->sb_cc));
823 if (sb->sb_cc || sb->sb_mb || sb->sb_mbcnt)
825 sb->sb_cc, (void *)sb->sb_mb, sb->sb_mbcnt);
829 sbflush_locked(struct sockbuf *sb)
832 SOCKBUF_LOCK_ASSERT(sb);
833 sbflush_internal(sb);
837 sbflush(struct sockbuf *sb)
840 SOCKBUF_LOCK(sb);
841 sbflush_locked(sb);
842 SOCKBUF_UNLOCK(sb);
849 sbcut_internal(struct sockbuf *sb, int len)
853 next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
867 sb->sb_cc -= len;
868 if (sb->sb_sndptroff != 0)
869 sb->sb_sndptroff -= len;
871 sb->sb_ctl -= len;
875 sbfree(sb, m);
882 sbfree(sb, m);
889 sb->sb_mb = m;
892 sb->sb_mb = next;
897 m = sb->sb_mb;
899 sb->sb_mbtail = NULL;
900 sb->sb_lastrecord = NULL;
902 sb->sb_lastrecord = m;
912 sbdrop_locked(struct sockbuf *sb, int len)
915 SOCKBUF_LOCK_ASSERT(sb);
916 m_freem(sbcut_internal(sb, len));
924 sbcut_locked(struct sockbuf *sb, int len)
927 SOCKBUF_LOCK_ASSERT(sb);
928 return (sbcut_internal(sb, len));
932 sbdrop(struct sockbuf *sb, int len)
936 SOCKBUF_LOCK(sb);
937 mfree = sbcut_internal(sb, len);
938 SOCKBUF_UNLOCK(sb);
948 sbsndptr(struct sockbuf *sb, u_int off, u_int len, u_int *moff)
952 KASSERT(sb->sb_mb != NULL, ("%s: sb_mb is NULL", __func__));
953 KASSERT(off + len <= sb->sb_cc, ("%s: beyond sb", __func__));
954 KASSERT(sb->sb_sndptroff <= sb->sb_cc, ("%s: sndptroff broken", __func__));
960 if (sb->sb_sndptroff > off) {
962 return (sb->sb_mb);
966 *moff = off - sb->sb_sndptroff;
967 m = ret = sb->sb_sndptr ? sb->sb_sndptr : sb->sb_mb;
970 sb->sb_sndptroff += m->m_len;
973 ("mbuf %p in sockbuf %p chain has no valid data", ret, sb));
977 for (off = off - sb->sb_sndptroff + len - 1;
980 sb->sb_sndptroff += m->m_len;
984 panic("%s: sockbuf %p and mbuf %p clashing", __func__, sb, ret);
985 sb->sb_sndptr = m;
995 sbdroprecord_locked(struct sockbuf *sb)
999 SOCKBUF_LOCK_ASSERT(sb);
1001 m = sb->sb_mb;
1003 sb->sb_mb = m->m_nextpkt;
1005 sbfree(sb, m);
1009 SB_EMPTY_FIXUP(sb);
1017 sbdroprecord(struct sockbuf *sb)
1020 SOCKBUF_LOCK(sb);
1021 sbdroprecord_locked(sb);
1022 SOCKBUF_UNLOCK(sb);
1069 sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
1072 xsb->sb_cc = sb->sb_cc;
1073 xsb->sb_hiwat = sb->sb_hiwat;
1074 xsb->sb_mbcnt = sb->sb_mbcnt;
1075 xsb->sb_mcnt = sb->sb_mcnt;
1076 xsb->sb_ccnt = sb->sb_ccnt;
1077 xsb->sb_mbmax = sb->sb_mbmax;
1078 xsb->sb_lowat = sb->sb_lowat;
1079 xsb->sb_flags = sb->sb_flags;
1080 xsb->sb_timeo = sb->sb_timeo;