/*
* As above, except the mbuf chain
* begins a new record.
*/
void
sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
{
struct mbuf *m;
KASSERT(solocked(sb->sb_so));
if (m0 == 0)
return;
#ifdef MBUFTRACE
m_claimm(m0, sb->sb_mowner);
#endif
/*
* Put the first mbuf on the queue.
* Note this permits zero length records.
*/
sballoc(sb, m0);
SBLASTRECORDCHK(sb, "sbappendrecord 1");
SBLINKRECORD(sb, m0);
m = m0->m_next;
m0->m_next = 0;
if (m && (m0->m_flags & M_EOR)) {
m0->m_flags &= ~M_EOR;
m->m_flags |= M_EOR;
}
sbcompress(sb, m, m0);
SBLASTRECORDCHK(sb, "sbappendrecord 2");
}
/*
* As above, except the mbuf chain begins a new record.
*/
void
sbappendrecord_locked(struct sockbuf *sb, struct mbuf *m0)
{
struct mbuf *m;
SOCKBUF_LOCK_ASSERT(sb);
if (m0 == NULL)
return;
m_clrprotoflags(m0);
/*
* Put the first mbuf on the queue. Note this permits zero length
* records.
*/
sballoc(sb, m0);
SBLASTRECORDCHK(sb);
SBLINKRECORD(sb, m0);
sb->sb_mbtail = m0;
m = m0->m_next;
m0->m_next = 0;
if (m && (m0->m_flags & M_EOR)) {
m0->m_flags &= ~M_EOR;
m->m_flags |= M_EOR;
}
/* always call sbcompress() so it can do SBLASTMBUFCHK() */
sbcompress(sb, m, m0);
}
/*
* Append mbuf chain m to the last record in the socket buffer sb.
* The additional space associated the mbuf chain is recorded in sb.
* Empty mbufs are discarded and mbufs are compacted where possible.
*
* If M_EOR is set in the first or last mbuf of the last record, the
* mbuf chain is appended as a new record. M_EOR is usually just set
* in the last mbuf of the last record's mbuf chain (see sbcompress()),
* but this may be changed in the future since there is no real need
* to propogate the flag any more.
*/
void
sbappend(struct sockbuf *sb, struct mbuf *m)
{
struct mbuf *n;
mbuftrackid(m, 16);
if (m) {
n = sb->sb_lastrecord;
if (n) {
if (n->m_flags & M_EOR) {
sbappendrecord(sb, m);
return;
}
}
n = sb->sb_lastmbuf;
if (n) {
if (n->m_flags & M_EOR) {
sbappendrecord(sb, m);
return;
}
}
sbcompress(sb, m, n);
}
}
/*
* sbappendstream() is an optimized form of sbappend() for protocols
* such as TCP that only have one record in the socket buffer, are
* not PR_ATOMIC, nor allow MT_CONTROL data. A protocol that uses
* sbappendstream() must use sbappendstream() exclusively.
*/
void
sbappendstream(struct sockbuf *sb, struct mbuf *m)
{
mbuftrackid(m, 17);
KKASSERT(m->m_nextpkt == NULL);
sbcompress(sb, m, sb->sb_lastmbuf);
}
/*
* Append mbuf chain m to the last record in the
* socket buffer sb. The additional space associated
* the mbuf chain is recorded in sb. Empty mbufs are
* discarded and mbufs are compacted where possible.
*/
void
sbappend(struct sockbuf *sb, struct mbuf *m)
{
struct mbuf *n;
if (m == NULL)
return;
SBLASTRECORDCHK(sb, "sbappend 1");
if ((n = sb->sb_lastrecord) != NULL) {
/*
* XXX Would like to simply use sb_mbtail here, but
* XXX I need to verify that I won't miss an EOR that
* XXX way.
*/
do {
if (n->m_flags & M_EOR) {
sbappendrecord(sb, m); /* XXXXXX!!!! */
return;
}
} while (n->m_next && (n = n->m_next));
} else {
/*
* If this is the first record in the socket buffer, it's
* also the last record.
*/
sb->sb_lastrecord = m;
}
sbcompress(sb, m, n);
SBLASTRECORDCHK(sb, "sbappend 2");
}
/*
* This version of sbappend() should only be used when the caller
* absolutely knows that there will never be more than one record
* in the socket buffer, that is, a stream protocol (such as TCP).
*/
void
sbappendstream(struct sockbuf *sb, struct mbuf *m)
{
KDASSERT(m->m_nextpkt == NULL);
KASSERT(sb->sb_mb == sb->sb_lastrecord);
SBLASTMBUFCHK(sb, __func__);
sbcompress(sb, m, sb->sb_mbtail);
sb->sb_lastrecord = sb->sb_mb;
SBLASTRECORDCHK(sb, __func__);
}
/*
* This version of sbappend() should only be used when the caller absolutely
* knows that there will never be more than one record in the socket buffer,
* that is, a stream protocol (such as TCP).
*/
void
sbappendstream_locked(struct sockbuf *sb, struct mbuf *m)
{
SOCKBUF_LOCK_ASSERT(sb);
KASSERT(m->m_nextpkt == NULL,("sbappendstream 0"));
KASSERT(sb->sb_mb == sb->sb_lastrecord,("sbappendstream 1"));
SBLASTMBUFCHK(sb);
sbcompress(sb, m, sb->sb_mbtail);
sb->sb_lastrecord = sb->sb_mb;
SBLASTRECORDCHK(sb);
}
/*
* Same as sbappend(), except the mbuf chain begins a new record.
*/
void
sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
{
struct mbuf *firstmbuf;
struct mbuf *secondmbuf;
if (m0 == NULL)
return;
mbuftrackid(m0, 18);
sbcheck(sb);
/*
* Break the first mbuf off from the rest of the mbuf chain.
*/
firstmbuf = m0;
secondmbuf = m0->m_next;
m0->m_next = NULL;
/*
* Insert the first mbuf of the m0 mbuf chain as the last record of
* the sockbuf. Note this permits zero length records! Keep the
* sockbuf state consistent.
*/
if (sb->sb_mb == NULL)
sb->sb_mb = firstmbuf;
else
sb->sb_lastrecord->m_nextpkt = firstmbuf;
sb->sb_lastrecord = firstmbuf; /* update hint for new last record */
sb->sb_lastmbuf = firstmbuf; /* update hint for new last mbuf */
/*
* propagate the EOR flag so sbcompress() can pick it up
*/
if ((firstmbuf->m_flags & M_EOR) && (secondmbuf != NULL)) {
firstmbuf->m_flags &= ~M_EOR;
secondmbuf->m_flags |= M_EOR;
}
/*
* The succeeding call to sbcompress() omits accounting for
* the first mbuf, so do it here.
*/
sballoc(sb, firstmbuf);
/* Compact the rest of the mbuf chain in after the first mbuf. */
sbcompress(sb, secondmbuf, firstmbuf);
}
/*
* As above except that OOB data
* is inserted at the beginning of the sockbuf,
* but after any other OOB data.
*/
void
sbinsertoob(struct sockbuf *sb, struct mbuf *m0)
{
struct mbuf *m, **mp;
KASSERT(solocked(sb->sb_so));
if (m0 == 0)
return;
SBLASTRECORDCHK(sb, "sbinsertoob 1");
for (mp = &sb->sb_mb; (m = *mp) != NULL; mp = &((*mp)->m_nextpkt)) {
again:
switch (m->m_type) {
case MT_OOBDATA:
continue; /* WANT next train */
case MT_CONTROL:
if ((m = m->m_next) != NULL)
goto again; /* inspect THIS train further */
}
break;
}
/*
* Put the first mbuf on the queue.
* Note this permits zero length records.
*/
sballoc(sb, m0);
m0->m_nextpkt = *mp;
if (*mp == NULL) {
/* m0 is actually the new tail */
sb->sb_lastrecord = m0;
}
*mp = m0;
m = m0->m_next;
m0->m_next = 0;
if (m && (m0->m_flags & M_EOR)) {
m0->m_flags &= ~M_EOR;
m->m_flags |= M_EOR;
}
sbcompress(sb, m, m0);
SBLASTRECORDCHK(sb, "sbinsertoob 2");
}
/*
* Append mbuf chain m to the last record in the socket buffer sb. The
* additional space associated the mbuf chain is recorded in sb. Empty mbufs
* are discarded and mbufs are compacted where possible.
*/
void
sbappend_locked(struct sockbuf *sb, struct mbuf *m, int flags)
{
struct mbuf *n;
SOCKBUF_LOCK_ASSERT(sb);
if (m == NULL)
return;
sbm_clrprotoflags(m, flags);
SBLASTRECORDCHK(sb);
n = sb->sb_mb;
if (n) {
while (n->m_nextpkt)
n = n->m_nextpkt;
do {
if (n->m_flags & M_EOR) {
sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
return;
}
} while (n->m_next && (n = n->m_next));
} else {
/*
* XXX Would like to simply use sb_mbtail here, but
* XXX I need to verify that I won't miss an EOR that
* XXX way.
*/
if ((n = sb->sb_lastrecord) != NULL) {
do {
if (n->m_flags & M_EOR) {
sbappendrecord_locked(sb, m); /* XXXXXX!!!! */
return;
}
} while (n->m_next && (n = n->m_next));
} else {
/*
* If this is the first record in the socket buffer,
* it's also the last record.
*/
sb->sb_lastrecord = m;
}
}
sbcompress(sb, m, n);
SBLASTRECORDCHK(sb);
}
/*
* This version of sbappend() should only be used when the caller absolutely
* knows that there will never be more than one record in the socket buffer,
* that is, a stream protocol (such as TCP).
*/
void
sbappendstream_locked(struct sockbuf *sb, struct mbuf *m, int flags)
{
SOCKBUF_LOCK_ASSERT(sb);
KASSERT(m->m_nextpkt == NULL,("sbappendstream 0"));
KASSERT(sb->sb_mb == sb->sb_lastrecord,("sbappendstream 1"));
SBLASTMBUFCHK(sb);
/* Remove all packet headers and mbuf tags to get a pure data chain. */
m_demote(m, 1, flags & PRUS_NOTREADY ? M_NOTREADY : 0);
sbcompress(sb, m, sb->sb_mbtail);
sb->sb_lastrecord = sb->sb_mb;
SBLASTRECORDCHK(sb);
}
/*
* This version of sbappend() should only be used when the caller
* absolutely knows that there will never be more than one record
* in the socket buffer, that is, a stream protocol (such as TCP).
*/
void
sbappendstream(struct sockbuf *sb, struct mbuf *m)
{
KASSERT(solocked(sb->sb_so));
KDASSERT(m->m_nextpkt == NULL);
KASSERT(sb->sb_mb == sb->sb_lastrecord);
SBLASTMBUFCHK(sb, __func__);
#ifdef MBUFTRACE
m_claimm(m, sb->sb_mowner);
#endif
service_reflect_tx_socket_buf(sb->sb_so, m->m_len);
sbcompress(sb, m, sb->sb_mbtail);
sb->sb_lastrecord = sb->sb_mb;
SBLASTRECORDCHK(sb, __func__);
}
/*
* As above, except the mbuf chain
* begins a new record.
*/
void
sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
{
struct mbuf *m;
if (m0 == NULL)
return;
/*
* Put the first mbuf on the queue.
* Note this permits zero length records.
*/
sballoc(sb, m0);
SBLASTRECORDCHK(sb, "sbappendrecord 1");
SBLINKRECORD(sb, m0);
m = m0->m_next;
m0->m_next = NULL;
if (m && (m0->m_flags & M_EOR)) {
m0->m_flags &= ~M_EOR;
m->m_flags |= M_EOR;
}
sbcompress(sb, m, m0);
SBLASTRECORDCHK(sb, "sbappendrecord 2");
}
