/*
* Create a "control" mbuf containing the specified data
* with the specified type for presentation on a socket buffer.
*/
struct mbuf *
sbcreatecontrol(caddr_t p, int size, int type, int level)
{
struct cmsghdr *cp;
struct mbuf *m;
if (CMSG_SPACE((u_int)size) > MCLBYTES)
return (NULL);
m = m_getl(CMSG_SPACE((u_int)size), MB_DONTWAIT, MT_CONTROL, 0, NULL);
if (m == NULL)
return (NULL);
m->m_len = CMSG_SPACE(size);
cp = mtod(m, struct cmsghdr *);
if (p != NULL)
memcpy(CMSG_DATA(cp), p, size);
cp->cmsg_len = CMSG_LEN(size);
cp->cmsg_level = level;
cp->cmsg_type = type;
mbuftrackid(m, 24);
return (m);
}
/*
* Send on a socket.
* If send must go all at once and message is larger than
* send buffering, then hard error.
* Lock against other senders.
* If must go all at once and not enough room now, then
* inform user that this would block and do nothing.
* Otherwise, if nonblocking, send as much as possible.
* The data to be sent is described by "uio" if nonzero,
* otherwise by the mbuf chain "top" (which must be null
* if uio is not). Data provided in mbuf chain must be small
* enough to send all at once.
*
* Returns nonzero on error, timeout or signal; callers
* must check for short counts if EINTR/ERESTART are returned.
* Data and control buffers are freed on return.
*/
int
sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
struct mbuf *top, struct mbuf *control, int flags,
struct thread *td)
{
struct mbuf **mp;
struct mbuf *m;
size_t resid;
int space, len;
int clen = 0, error, dontroute, mlen;
int atomic = sosendallatonce(so) || top;
int pru_flags;
if (uio) {
resid = uio->uio_resid;
} else {
resid = (size_t)top->m_pkthdr.len;
#ifdef INVARIANTS
len = 0;
for (m = top; m; m = m->m_next)
len += m->m_len;
KKASSERT(top->m_pkthdr.len == len);
#endif
}
/*
* WARNING! resid is unsigned, space and len are signed. space
* can wind up negative if the sockbuf is overcommitted.
*
* Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
* type sockets since that's an error.
*/
if (so->so_type == SOCK_STREAM && (flags & MSG_EOR)) {
error = EINVAL;
goto out;
}
dontroute =
(flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
(so->so_proto->pr_flags & PR_ATOMIC);
if (td->td_lwp != NULL)
td->td_lwp->lwp_ru.ru_msgsnd++;
if (control)
clen = control->m_len;
#define gotoerr(errcode) { error = errcode; goto release; }
restart:
error = ssb_lock(&so->so_snd, SBLOCKWAIT(flags));
if (error)
goto out;
do {
if (so->so_state & SS_CANTSENDMORE)
gotoerr(EPIPE);
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
goto release;
}
if ((so->so_state & SS_ISCONNECTED) == 0) {
/*
* `sendto' and `sendmsg' is allowed on a connection-
* based socket if it supports implied connect.
* Return ENOTCONN if not connected and no address is
* supplied.
*/
if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
(so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
if ((so->so_state & SS_ISCONFIRMING) == 0 &&
!(resid == 0 && clen != 0))
gotoerr(ENOTCONN);
} else if (addr == 0)
gotoerr(so->so_proto->pr_flags & PR_CONNREQUIRED ?
ENOTCONN : EDESTADDRREQ);
}
if ((atomic && resid > so->so_snd.ssb_hiwat) ||
clen > so->so_snd.ssb_hiwat) {
gotoerr(EMSGSIZE);
}
space = ssb_space(&so->so_snd);
if (flags & MSG_OOB)
space += 1024;
if ((space < 0 || (size_t)space < resid + clen) && uio &&
(atomic || space < so->so_snd.ssb_lowat || space < clen)) {
if (flags & (MSG_FNONBLOCKING|MSG_DONTWAIT))
gotoerr(EWOULDBLOCK);
ssb_unlock(&so->so_snd);
error = ssb_wait(&so->so_snd);
if (error)
goto out;
goto restart;
}
mp = ⊤
space -= clen;
do {
if (uio == NULL) {
/*
* Data is prepackaged in "top".
*/
resid = 0;
if (flags & MSG_EOR)
top->m_flags |= M_EOR;
} else do {
if (resid > INT_MAX)
resid = INT_MAX;
m = m_getl((int)resid, MB_WAIT, MT_DATA,
top == NULL ? M_PKTHDR : 0, &mlen);
if (top == NULL) {
m->m_pkthdr.len = 0;
m->m_pkthdr.rcvif = NULL;
}
len = imin((int)szmin(mlen, resid), space);
if (resid < MINCLSIZE) {
/*
* For datagram protocols, leave room
* for protocol headers in first mbuf.
*/
if (atomic && top == 0 && len < mlen)
MH_ALIGN(m, len);
}
space -= len;
error = uiomove(mtod(m, caddr_t), (size_t)len, uio);
resid = uio->uio_resid;
m->m_len = len;
*mp = m;
top->m_pkthdr.len += len;
if (error)
goto release;
mp = &m->m_next;
if (resid == 0) {
if (flags & MSG_EOR)
top->m_flags |= M_EOR;
break;
}
} while (space > 0 && atomic);
if (dontroute)
so->so_options |= SO_DONTROUTE;
if (flags & MSG_OOB) {
pru_flags = PRUS_OOB;
} else if ((flags & MSG_EOF) &&
(so->so_proto->pr_flags & PR_IMPLOPCL) &&
(resid == 0)) {
/*
* If the user set MSG_EOF, the protocol
* understands this flag and nothing left to
* send then use PRU_SEND_EOF instead of PRU_SEND.
*/
pru_flags = PRUS_EOF;
} else if (resid > 0 && space > 0) {
/* If there is more to send, set PRUS_MORETOCOME */
pru_flags = PRUS_MORETOCOME;
} else {
pru_flags = 0;
}
/*
* XXX all the SS_CANTSENDMORE checks previously
* done could be out of date. We could have recieved
* a reset packet in an interrupt or maybe we slept
* while doing page faults in uiomove() etc. We could
* probably recheck again inside the splnet() protection
* here, but there are probably other places that this
* also happens. We must rethink this.
*/
error = so_pru_send(so, pru_flags, top, addr, control, td);
if (dontroute)
so->so_options &= ~SO_DONTROUTE;
clen = 0;
control = 0;
top = NULL;
mp = ⊤
if (error)
goto release;
} while (resid && space > 0);
} while (resid);
release:
ssb_unlock(&so->so_snd);
out:
if (top)
m_freem(top);
if (control)
m_freem(control);
return (error);
}
static void
epread(struct ep_softc *sc)
{
struct mbuf *top, *mcur, *m;
struct ifnet *ifp;
int lenthisone;
short rx_fifo2, status;
short rx_fifo;
ifp = &sc->arpcom.ac_if;
status = inw(BASE + EP_W1_RX_STATUS);
read_again:
if (status & ERR_RX) {
IFNET_STAT_INC(ifp, ierrors, 1);
if (status & ERR_RX_OVERRUN) {
/*
* we can think the rx latency is actually greather than we
* expect
*/
#ifdef EP_LOCAL_STATS
if (EP_FTST(sc, F_RX_FIRST))
sc->rx_overrunf++;
else
sc->rx_overrunl++;
#endif
}
goto out;
}
rx_fifo = rx_fifo2 = status & RX_BYTES_MASK;
if (EP_FTST(sc, F_RX_FIRST)) {
m = m_getl(rx_fifo, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL);
if (!m)
goto out;
sc->top = sc->mcur = top = m;
#define EROUND ((sizeof(struct ether_header) + 3) & ~3)
#define EOFF (EROUND - sizeof(struct ether_header))
top->m_data += EOFF;
/* Read what should be the header. */
insw(BASE + EP_W1_RX_PIO_RD_1,
mtod(top, caddr_t), sizeof(struct ether_header) / 2);
top->m_len = sizeof(struct ether_header);
rx_fifo -= sizeof(struct ether_header);
sc->cur_len = rx_fifo2;
} else {
/* come here if we didn't have a complete packet last time */
top = sc->top;
m = sc->mcur;
sc->cur_len += rx_fifo2;
}
/* Reads what is left in the RX FIFO */
while (rx_fifo > 0) {
lenthisone = min(rx_fifo, M_TRAILINGSPACE(m));
if (lenthisone == 0) { /* no room in this one */
mcur = m;
m = m_getl(rx_fifo, MB_DONTWAIT, MT_DATA, 0, NULL);
if (!m)
goto out;
m->m_len = 0;
mcur->m_next = m;
lenthisone = min(rx_fifo, M_TRAILINGSPACE(m));
}
if (EP_FTST(sc, F_ACCESS_32_BITS)) { /* default for EISA configured cards*/
insl(BASE + EP_W1_RX_PIO_RD_1, mtod(m, caddr_t) + m->m_len,
lenthisone / 4);
m->m_len += (lenthisone & ~3);
if (lenthisone & 3)
insb(BASE + EP_W1_RX_PIO_RD_1,
mtod(m, caddr_t) + m->m_len,
lenthisone & 3);
m->m_len += (lenthisone & 3);
} else {
insw(BASE + EP_W1_RX_PIO_RD_1, mtod(m, caddr_t) + m->m_len,
lenthisone / 2);
m->m_len += lenthisone;
if (lenthisone & 1)
*(mtod(m, caddr_t) + m->m_len - 1) = inb(BASE + EP_W1_RX_PIO_RD_1);
}
rx_fifo -= lenthisone;
}
if (status & ERR_RX_INCOMPLETE) { /* we haven't received the complete
* packet */
sc->mcur = m;
#ifdef EP_LOCAL_STATS
sc->rx_no_first++; /* to know how often we come here */
#endif
EP_FRST(sc, F_RX_FIRST);
if (!((status = inw(BASE + EP_W1_RX_STATUS)) & ERR_RX_INCOMPLETE)) {
/* we see if by now, the packet has completly arrived */
goto read_again;
}
outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_NEXT_EARLY_THRESH);
return;
}
outw(BASE + EP_COMMAND, RX_DISCARD_TOP_PACK);
IFNET_STAT_INC(ifp, ipackets, 1);
EP_FSET(sc, F_RX_FIRST);
top->m_pkthdr.rcvif = &sc->arpcom.ac_if;
top->m_pkthdr.len = sc->cur_len;
ifp->if_input(ifp, top);
sc->top = 0;
while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
return;
out:
outw(BASE + EP_COMMAND, RX_DISCARD_TOP_PACK);
if (sc->top) {
m_freem(sc->top);
sc->top = 0;
#ifdef EP_LOCAL_STATS
sc->rx_no_mbuf++;
#endif
}
EP_FSET(sc, F_RX_FIRST);
while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
}
