d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replaced the misleading uses of a historical artefact M_TRYWAIT with M_WAIT.

Browse Source 
Removed dead code that assumed that M_TRYWAIT can return NULL; it's not true
since the advent of MBUMA.

Reviewed by:	arch

There are ongoing disputes as to whether we want to switch to directly using
UMA flags M_WAITOK/M_NOWAIT for mbuf(9) allocation.
This commit is contained in:
ru 2008-03-25 09:39:02 +00:00
parent 0655a583e2
commit 3b1bf8c2e9
36 changed files with 125 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
share/man/man9/mbuf.9
View File

@ -24,7 +24,7 @@
.\"
.\" $FreeBSD$
.\"
.Dd February 26, 2007
.Dd March 25, 2008
.Dt MBUF 9
.Os
.\"
@ -356,20 +356,10 @@ on failure.
The
.Fa how
argument is to be set to
.Dv M_TRYWAIT
.Dv M_WAIT
or
.Dv M_DONTWAIT .
It specifies whether the caller is willing to block if necessary.
If
.Fa how
is set to
.Dv M_TRYWAIT ,
a failed allocation will result in the caller being put
to sleep for a designated
kern.ipc.mbuf_wait
.Xr ( sysctl 8
tunable)
number of ticks.
A number of other functions and macros related to
.Vt mbufs
have the same argument because they may
@ -922,7 +912,7 @@ Upon success, the original chain will be freed and the new
chain will be returned.
.Fa how
should be either
.Dv M_TRYWAIT
.Dv M_WAIT
or
.Dv M_DONTWAIT ,
depending on the caller's preference.
@ -940,7 +930,7 @@ The original mbuf chain is always reclaimed and the reference
count of any shared mbuf clusters is decremented.
.Fa how
should be either
.Dv M_TRYWAIT
.Dv M_WAIT
or
.Dv M_DONTWAIT ,
depending on the caller's preference.

26
sys/dev/en/midway.c
View File

@ -835,27 +835,15 @@ copy_mbuf(struct mbuf *m)
{
struct mbuf *new;
MGET(new, M_TRYWAIT, MT_DATA);
if (new == NULL)
return (NULL);
MGET(new, M_WAIT, MT_DATA);
if (m->m_flags & M_PKTHDR) {
M_MOVE_PKTHDR(new, m);
if (m->m_len > MHLEN) {
MCLGET(new, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(new);
return (NULL);
}
}
if (m->m_len > MHLEN)
MCLGET(new, M_WAIT);
} else {
if (m->m_len > MLEN) {
MCLGET(new, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(new);
return (NULL);
}
}
if (m->m_len > MLEN)
MCLGET(new, M_WAIT);
}
bcopy(m->m_data, new->m_data, m->m_len);
@ -2932,9 +2920,7 @@ en_attach(struct en_softc *sc)
&en_utopia_methods);
utopia_init_media(&sc->utopia);
MGET(sc->padbuf, M_TRYWAIT, MT_DATA);
if (sc->padbuf == NULL)
goto fail;
MGET(sc->padbuf, M_WAIT, MT_DATA);
bzero(sc->padbuf->m_data, MLEN);
if (bus_dma_tag_create(NULL, 1, 0,

18
sys/dev/fatm/if_fatm.c
View File

@ -1776,21 +1776,11 @@ copy_mbuf(struct mbuf *m)
if (m->m_flags & M_PKTHDR) {
M_MOVE_PKTHDR(new, m);
if (m->m_len > MHLEN) {
MCLGET(new, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(new);
return (NULL);
}
}
if (m->m_len > MHLEN)
MCLGET(new, M_WAIT);
} else {
if (m->m_len > MLEN) {
MCLGET(new, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(new);
return (NULL);
}
}
if (m->m_len > MLEN)
MCLGET(new, M_WAIT);
}
bcopy(m->m_data, new->m_data, m->m_len);

16
sys/dev/firewire/if_fwe.c
View File

@ -357,19 +357,11 @@ fwe_init(void *arg)
STAILQ_INIT(&xferq->stdma);
xferq->stproc = NULL;
for (i = 0; i < xferq->bnchunk; i ++) {
m =
#if defined(__DragonFly__) || __FreeBSD_version < 500000
m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
#else
m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
#endif
m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
xferq->bulkxfer[i].mbuf = m;
if (m != NULL) {
m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
STAILQ_INSERT_TAIL(&xferq->stfree,
&xferq->bulkxfer[i], link);
} else
printf("%s: m_getcl failed\n", __FUNCTION__);
m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
STAILQ_INSERT_TAIL(&xferq->stfree,
&xferq->bulkxfer[i], link);
}
STAILQ_INIT(&fwe->xferlist);
for (i = 0; i < TX_MAX_QUEUE; i++) {

20
sys/dev/firewire/if_fwip.c
View File

@ -332,19 +332,11 @@ fwip_init(void *arg)
STAILQ_INIT(&xferq->stdma);
xferq->stproc = NULL;
for (i = 0; i < xferq->bnchunk; i ++) {
m =
#if defined(__DragonFly__) || __FreeBSD_version < 500000
m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
#else
m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
#endif
m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
xferq->bulkxfer[i].mbuf = m;
if (m != NULL) {
m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
STAILQ_INSERT_TAIL(&xferq->stfree,
&xferq->bulkxfer[i], link);
} else
printf("fwip_as_input: m_getcl failed\n");
m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
STAILQ_INSERT_TAIL(&xferq->stfree,
&xferq->bulkxfer[i], link);
}
fwip->fwb.start = INET_FIFO;
@ -356,7 +348,7 @@ fwip_init(void *arg)
xfer = fw_xfer_alloc(M_FWIP);
if (xfer == NULL)
break;
m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
xfer->recv.payload = mtod(m, uint32_t *);
xfer->recv.pay_len = MCLBYTES;
xfer->hand = fwip_unicast_input;
@ -876,7 +868,7 @@ fwip_unicast_input_recycle(struct fwip_softc *fwip, struct fw_xfer *xfer)
* We have finished with a unicast xfer. Allocate a new
* cluster and stick it on the back of the input queue.
*/
m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
xfer->mbuf = m;
xfer->recv.payload = mtod(m, uint32_t *);
xfer->recv.pay_len = MCLBYTES;

6
sys/dev/iscsi/initiator/isc_soc.c
View File

@ -100,7 +100,7 @@ isc_sendPDU(isc_session_t *sp, pduq_t *pq)
iv++;
#else /* USE_MBUF */
/* mbuf for the iSCSI header */
MGETHDR(mh, M_TRYWAIT, MT_DATA);
MGETHDR(mh, M_WAIT, MT_DATA);
mh->m_len = mh->m_pkthdr.len = sizeof(union ipdu_u);
mh->m_pkthdr.rcvif = NULL;
MH_ALIGN(mh, sizeof(union ipdu_u));
@ -160,7 +160,7 @@ isc_sendPDU(isc_session_t *sp, pduq_t *pq)
while (len > 0) {
int l;
MGET(md, M_TRYWAIT, MT_DATA);
MGET(md, M_WAIT, MT_DATA);
md->m_ext.ref_cnt = &nil_refcnt;
l = min(MCLBYTES, len);
MEXTADD(md, pp->ds + off, l, nil_fn,
@ -187,7 +187,7 @@ isc_sendPDU(isc_session_t *sp, pduq_t *pq)
iv->iov_len = sizeof(int);
iv++;
#else /* USE_MBUF */
MGET(me, M_TRYWAIT, MT_DATA);
MGET(me, M_WAIT, MT_DATA);
me->m_len = sizeof(int);
MH_ALIGN(mh, sizeof(int));
bcopy(&pp->ds_dig, me->m_data, sizeof(int));

24
sys/kern/subr_mchain.c
View File

@ -56,9 +56,7 @@ mb_init(struct mbchain *mbp)
{
struct mbuf *m;
m = m_gethdr(M_TRYWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
m = m_gethdr(M_WAIT, MT_DATA);
m->m_len = 0;
mb_initm(mbp, m);
return 0;
@ -113,9 +111,7 @@ mb_reserve(struct mbchain *mbp, int size)
panic("mb_reserve: size = %d\n", size);
m = mbp->mb_cur;
if (mbp->mb_mleft < size) {
mn = m_get(M_TRYWAIT, MT_DATA);
if (mn == NULL)
return NULL;
mn = m_get(M_WAIT, MT_DATA);
mbp->mb_cur = m->m_next = mn;
m = mn;
m->m_len = 0;
@ -190,11 +186,9 @@ mb_put_mem(struct mbchain *mbp, c_caddr_t source, int size, int type)
while (size > 0) {
if (mleft == 0) {
if (m->m_next == NULL) {
m = m_getm(m, size, M_TRYWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
} else
if (m->m_next == NULL)
m = m_getm(m, size, M_WAIT, MT_DATA);
else
m = m->m_next;
mleft = M_TRAILINGSPACE(m);
continue;
@ -295,9 +289,7 @@ md_init(struct mdchain *mdp)
{
struct mbuf *m;
m = m_gethdr(M_TRYWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
m = m_gethdr(M_WAIT, MT_DATA);
m->m_len = 0;
md_initm(mdp, m);
return 0;
@ -503,9 +495,7 @@ md_get_mbuf(struct mdchain *mdp, int size, struct mbuf **ret)
{
struct mbuf *m = mdp->md_cur, *rm;
rm = m_copym(m, mdp->md_pos - mtod(m, u_char*), size, M_TRYWAIT);
if (rm == NULL)
return EBADRPC;
rm = m_copym(m, mdp->md_pos - mtod(m, u_char*), size, M_WAIT);
md_get_mem(mdp, NULL, size, MB_MZERO);
*ret = rm;
return 0;

2
sys/kern/uipc_mbuf.c
View File

@ -519,7 +519,7 @@ m_prepend(struct mbuf *m, int len, int how)
/*
* Make a copy of an mbuf chain starting "off0" bytes from the beginning,
* continuing for "len" bytes. If len is M_COPYALL, copy to end of mbuf.
* The wait parameter is a choice of M_TRYWAIT/M_DONTWAIT from caller.
* The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
* Note that the copy is read-only, because clusters are not copied,
* only their reference counts are incremented.
*/

26
sys/kern/uipc_socket.c
View File

@ -860,16 +860,16 @@ sosend_copyin(struct uio *uio, struct mbuf **retmp, int atomic, long *space,
}
#else /* ZERO_COPY_SOCKETS */
if (top == NULL) {
m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
m->m_pkthdr.len = 0;
m->m_pkthdr.rcvif = NULL;
} else
m = m_getcl(M_TRYWAIT, MT_DATA, 0);
m = m_getcl(M_WAIT, MT_DATA, 0);
len = min(min(MCLBYTES, resid), *space);
#endif /* ZERO_COPY_SOCKETS */
} else {
if (top == NULL) {
m = m_gethdr(M_TRYWAIT, MT_DATA);
m = m_gethdr(M_WAIT, MT_DATA);
m->m_pkthdr.len = 0;
m->m_pkthdr.rcvif = NULL;
@ -881,7 +881,7 @@ sosend_copyin(struct uio *uio, struct mbuf **retmp, int atomic, long *space,
if (atomic && m && len < MHLEN)
MH_ALIGN(m, len);
} else {
m = m_get(M_TRYWAIT, MT_DATA);
m = m_get(M_WAIT, MT_DATA);
len = min(min(MLEN, resid), *space);
}
}
@ -1304,9 +1304,7 @@ soreceive_rcvoob(struct socket *so, struct uio *uio, int flags)
KASSERT(flags & MSG_OOB, ("soreceive_rcvoob: (flags & MSG_OOB) == 0"));
m = m_get(M_TRYWAIT, MT_DATA);
if (m == NULL)
return (ENOBUFS);
m = m_get(M_WAIT, MT_DATA);
error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK);
if (error)
goto bad;
@ -1718,11 +1716,11 @@ dontblock:
if (flags & MSG_DONTWAIT)
copy_flag = M_DONTWAIT;
else
copy_flag = M_TRYWAIT;
if (copy_flag == M_TRYWAIT)
copy_flag = M_WAIT;
if (copy_flag == M_WAIT)
SOCKBUF_UNLOCK(&so->so_rcv);
*mp = m_copym(m, 0, len, copy_flag);
if (copy_flag == M_TRYWAIT)
if (copy_flag == M_WAIT)
SOCKBUF_LOCK(&so->so_rcv);
if (*mp == NULL) {
/*
@ -2333,11 +2331,11 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp)
struct mbuf *m, *m_prev;
int sopt_size = sopt->sopt_valsize;
MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
MGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
if (sopt_size > MLEN) {
MCLGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT);
MCLGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(m);
return ENOBUFS;
@ -2351,13 +2349,13 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp)
m_prev = m;
while (sopt_size) {
MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
MGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT, MT_DATA);
if (m == NULL) {
m_freem(*mp);
return ENOBUFS;
}
if (sopt_size > MLEN) {
MCLGET(m, sopt->sopt_td != NULL ? M_TRYWAIT :
MCLGET(m, sopt->sopt_td != NULL ? M_WAIT :
M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_freem(m);

28
sys/kern/uipc_syscalls.c
View File

@ -705,16 +705,11 @@ sendit(td, s, mp, flags)
if (mp->msg_flags == MSG_COMPAT) {
struct cmsghdr *cm;
M_PREPEND(control, sizeof(*cm), M_TRYWAIT);
if (control == 0) {
error = ENOBUFS;
goto bad;
} else {
cm = mtod(control, struct cmsghdr *);
cm->cmsg_len = control->m_len;
cm->cmsg_level = SOL_SOCKET;
cm->cmsg_type = SCM_RIGHTS;
}
M_PREPEND(control, sizeof(*cm), M_WAIT);
cm = mtod(control, struct cmsghdr *);
cm->cmsg_len = control->m_len;
cm->cmsg_level = SOL_SOCKET;
cm->cmsg_type = SCM_RIGHTS;
}
#endif
} else {
@ -1627,16 +1622,9 @@ sockargs(mp, buf, buflen, type)
if ((u_int)buflen > MCLBYTES)
return (EINVAL);
}
m = m_get(M_TRYWAIT, type);
if (m == NULL)
return (ENOBUFS);
if ((u_int)buflen > MLEN) {
MCLGET(m, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(m);
return (ENOBUFS);
}
}
m = m_get(M_WAIT, type);
if ((u_int)buflen > MLEN)
MCLGET(m, M_WAIT);
m->m_len = buflen;
error = copyin(buf, mtod(m, caddr_t), (u_int)buflen);
if (error)

11
sys/net/bpf.c
View File

@ -386,13 +386,10 @@ bpf_movein(struct uio *uio, int linktype, struct ifnet *ifp, struct mbuf **mp,
if ((unsigned)len > MCLBYTES)
return (EIO);
if (len > MHLEN) {
m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
} else {
MGETHDR(m, M_TRYWAIT, MT_DATA);
}
if (m == NULL)
return (ENOBUFS);
if (len > MHLEN)
m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
else
MGETHDR(m, M_WAIT, MT_DATA);
m->m_pkthdr.len = m->m_len = len;
m->m_pkthdr.rcvif = NULL;
*mp = m;

12
sys/net/if_ef.c
View File

@ -415,11 +415,7 @@ ef_output(struct ifnet *ifp, struct mbuf **mp, struct sockaddr *dst, short *tp,
type = htons(m->m_pkthdr.len);
break;
case ETHER_FT_8022:
M_PREPEND(m, ETHER_HDR_LEN + 3, M_TRYWAIT);
if (m == NULL) {
*mp = NULL;
return ENOBUFS;
}
M_PREPEND(m, ETHER_HDR_LEN + 3, M_WAIT);
/*
* Ensure that ethernet header and next three bytes
* will fit into single mbuf
@ -438,11 +434,7 @@ ef_output(struct ifnet *ifp, struct mbuf **mp, struct sockaddr *dst, short *tp,
*hlen += 3;
break;
case ETHER_FT_SNAP:
M_PREPEND(m, 8, M_TRYWAIT);
if (m == NULL) {
*mp = NULL;
return ENOBUFS;
}
M_PREPEND(m, 8, M_WAIT);
type = htons(m->m_pkthdr.len);
cp = mtod(m, u_char *);
bcopy("\xAA\xAA\x03\x00\x00\x00\x81\x37", cp, 8);

4
sys/net/if_fddisubr.c
View File

@ -204,9 +204,7 @@ fddi_output(ifp, m, dst, rt0)
if (aa->aa_flags & AFA_PHASE2) {
struct llc llc;
M_PREPEND(m, LLC_SNAPFRAMELEN, M_TRYWAIT);
if (m == 0)
senderr(ENOBUFS);
M_PREPEND(m, LLC_SNAPFRAMELEN, M_WAIT);
llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
llc.llc_control = LLC_UI;
bcopy(at_org_code, llc.llc_snap.org_code, sizeof(at_org_code));

4
sys/net/if_iso88025subr.c
View File

@ -336,9 +336,7 @@ iso88025_output(ifp, m, dst, rt0)
bcopy((caddr_t)&(satoipx_addr(dst).x_host), (caddr_t)edst,
ISO88025_ADDR_LEN);
M_PREPEND(m, 3, M_TRYWAIT);
if (m == 0)
senderr(ENOBUFS);
M_PREPEND(m, 3, M_WAIT);
m = m_pullup(m, 3);
if (m == 0)
senderr(ENOBUFS);

16
sys/net/if_sl.c
View File

@ -298,20 +298,8 @@ slcreate(void)
return (NULL);
}
m = m_gethdr(M_TRYWAIT, MT_DATA);
if (m != NULL) {
MCLGET(m, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(m);
m = NULL;
}
}
if (m == NULL) {
printf("sl: can't allocate buffer\n");
free(sc, M_SL);
return (NULL);
}
m = m_gethdr(M_WAIT, MT_DATA);
MCLGET(m, M_WAIT);
sc->sc_ep = mtod(m, u_char *) + SLBUFSIZE;
sc->sc_mbuf = m;

2
sys/net/raw_cb.c
View File

@ -141,7 +141,7 @@ raw_bind(so, nam)
if (ifnet == 0)
return (EADDRNOTAVAIL);
rp = sotorawcb(so);
nam = m_copym(nam, 0, M_COPYALL, M_TRYWAIT);
nam = m_copym(nam, 0, M_COPYALL, M_WAIT);
rp->rcb_laddr = mtod(nam, struct sockaddr *);
return (0);
}

4
sys/netatalk/aarp.c
View File

@ -633,9 +633,7 @@ aarpprobe(void *arg)
sizeof(eh->ether_dhost));
eh->ether_type = htons(sizeof(struct llc) +
sizeof(struct ether_aarp));
M_PREPEND(m, sizeof(struct llc), M_TRYWAIT);
if (m == NULL)
return;
M_PREPEND(m, sizeof(struct llc), M_WAIT);
llc = mtod(m, struct llc *);
llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
llc->llc_control = LLC_UI;

2
sys/netatm/port.h
View File

@ -126,7 +126,7 @@
#include <sys/mbuf.h>
typedef struct mbuf KBuffer;
#define KB_F_WAIT M_TRYWAIT
#define KB_F_WAIT M_WAIT
#define KB_F_NOWAIT M_DONTWAIT
#define KB_T_HEADER MT_HEADER

2
sys/netinet/ip_output.c
View File

@ -823,7 +823,7 @@ ip_ctloutput(struct socket *so, struct sockopt *sopt)
error = EMSGSIZE;
break;
}
MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
MGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT, MT_DATA);
if (m == NULL) {
error = ENOBUFS;
break;

2
sys/netinet6/ip6_output.c
View File

@ -2729,7 +2729,7 @@ ip6_getmoptions(int optname, struct ip6_moptions *im6o, struct mbuf **mp)
{
u_int *hlim, *loop, *ifindex;
*mp = m_get(M_TRYWAIT, MT_HEADER); /* XXX */
*mp = m_get(M_WAIT, MT_HEADER); /* XXX */
switch (optname) {

2
sys/netncp/ncp_sock.c
View File

@ -163,7 +163,7 @@ ncp_sock_send(struct socket *so, struct mbuf *top, struct ncp_rq *rqp)
int error, flags=0;
for (;;) {
m = m_copym(top, 0, M_COPYALL, M_TRYWAIT);
m = m_copym(top, 0, M_COPYALL, M_WAIT);
/* NCPDDEBUG(m);*/
error = sosend(so, to, 0, m, 0, flags, td);
if (error == 0 || error == EINTR || error == ENETDOWN)

4
sys/netsmb/smb_iod.c
View File

@ -261,8 +261,8 @@ smb_iod_sendrq(struct smbiod *iod, struct smb_rq *rqp)
}
SMBSDEBUG("M:%04x, P:%04x, U:%04x, T:%04x\n", rqp->sr_mid, 0, 0, 0);
m_dumpm(rqp->sr_rq.mb_top);
m = m_copym(rqp->sr_rq.mb_top, 0, M_COPYALL, M_TRYWAIT);
error = rqp->sr_lerror = m ? SMB_TRAN_SEND(vcp, m, td) : ENOBUFS;
m = m_copym(rqp->sr_rq.mb_top, 0, M_COPYALL, M_WAIT);
error = rqp->sr_lerror = SMB_TRAN_SEND(vcp, m, td);
if (error == 0) {
getnanotime(&rqp->sr_timesent);
iod->iod_lastrqsent = rqp->sr_timesent;

4
sys/netsmb/smb_rq.c
View File

@ -433,9 +433,7 @@ smb_t2_placedata(struct mbuf *mtop, u_int16_t offset, u_int16_t count,
struct mbuf *m, *m0;
int len;
m0 = m_split(mtop, offset, M_TRYWAIT);
if (m0 == NULL)
return EBADRPC;
m0 = m_split(mtop, offset, M_WAIT);
len = m_length(m0, &m);
m->m_len -= len - count;
if (mdp->md_top == NULL) {

4
sys/netsmb/smb_trantcp.c
View File

@ -572,9 +572,7 @@ smb_nbst_send(struct smb_vc *vcp, struct mbuf *m0, struct thread *td)
error = ENOTCONN;
goto abort;
}
M_PREPEND(m0, 4, M_TRYWAIT);
if (m0 == NULL)
return ENOBUFS;
M_PREPEND(m0, 4, M_WAIT);
nb_sethdr(m0, NB_SSN_MESSAGE, m_fixhdr(m0) - 4);
error = nb_sosend(nbp->nbp_tso, m0, 0, td);
return error;

4
sys/nfs/nfs_common.c
View File

@ -263,7 +263,7 @@ nfsm_build_xx(int s, struct mbuf **mb, caddr_t *bpos)
void *ret;
if (s > M_TRAILINGSPACE(*mb)) {
MGET(mb2, M_TRYWAIT, MT_DATA);
MGET(mb2, M_WAIT, MT_DATA);
if (s > MLEN)
panic("build > MLEN");
(*mb)->m_next = mb2;
@ -280,7 +280,7 @@ nfsm_build_xx(int s, struct mbuf **mb, caddr_t *bpos)
void *
nfsm_dissect_xx(int s, struct mbuf **md, caddr_t *dpos)
{
return nfsm_dissect_xx_sub(s, md, dpos, M_TRYWAIT);
return nfsm_dissect_xx_sub(s, md, dpos, M_WAIT);
}
void *

23
sys/nfsclient/krpc_subr.c
View File

@ -151,9 +151,7 @@ krpc_portmap(struct sockaddr_in *sin, u_int prog, u_int vers, u_int16_t *portp,
return 0;
}
m = m_get(M_TRYWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
m = m_get(M_WAIT, MT_DATA);
sdata = mtod(m, struct sdata *);
m->m_len = sizeof(*sdata);
@ -274,7 +272,7 @@ krpc_call(struct sockaddr_in *sa, u_int prog, u_int vers, u_int func,
/*
* Prepend RPC message header.
*/
mhead = m_gethdr(M_TRYWAIT, MT_DATA);
mhead = m_gethdr(M_WAIT, MT_DATA);
mhead->m_next = *data;
call = mtod(mhead, struct krpc_call *);
mhead->m_len = sizeof(*call);
@ -308,11 +306,7 @@ krpc_call(struct sockaddr_in *sa, u_int prog, u_int vers, u_int func,
timo = 0;
for (;;) {
/* Send RPC request (or re-send). */
m = m_copym(mhead, 0, M_COPYALL, M_TRYWAIT);
if (m == NULL) {
error = ENOBUFS;
goto out;
}
m = m_copym(mhead, 0, M_COPYALL, M_WAIT);
error = sosend(so, (struct sockaddr *)sa, NULL, m,
NULL, 0, td);
if (error) {
@ -462,14 +456,9 @@ xdr_string_encode(char *str, int len)
if (mlen > MCLBYTES) /* If too big, we just can't do it. */
return (NULL);
m = m_get(M_TRYWAIT, MT_DATA);
if (mlen > MLEN) {
MCLGET(m, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
(void) m_free(m); /* There can be only one. */
return (NULL);
}
}
m = m_get(M_WAIT, MT_DATA);
if (mlen > MLEN)
MCLGET(m, M_WAIT);
xs = mtod(m, struct xdr_string *);
m->m_len = mlen;
xs->len = txdr_unsigned(len);

4
sys/nfsclient/nfs_socket.c
View File

@ -1169,7 +1169,7 @@ nfs_request(struct vnode *vp, struct mbuf *mrest, int procnum,
* For stream protocols, insert a Sun RPC Record Mark.
*/
if (nmp->nm_sotype == SOCK_STREAM) {
M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT);
M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
*mtod(m, u_int32_t *) = htonl(0x80000000 |
(m->m_pkthdr.len - NFSX_UNSIGNED));
}
@ -1213,7 +1213,7 @@ tryagain:
if (nmp->nm_sotype == SOCK_STREAM)
nmp->nm_nfstcpstate.sock_send_inprog++;
mtx_unlock(&nmp->nm_mtx);
m2 = m_copym(m, 0, M_COPYALL, M_TRYWAIT);
m2 = m_copym(m, 0, M_COPYALL, M_WAIT);
error = nfs_send(nmp->nm_so, nmp->nm_nam, m2, rep);
mtx_lock(&nmp->nm_mtx);
mtx_lock(&rep->r_mtx);

20
sys/nfsclient/nfs_subs.c
View File

@ -165,9 +165,9 @@ nfsm_reqhead(struct vnode *vp, u_long procid, int hsiz)
{
struct mbuf *mb;
MGET(mb, M_TRYWAIT, MT_DATA);
MGET(mb, M_WAIT, MT_DATA);
if (hsiz >= MINCLSIZE)
MCLGET(mb, M_TRYWAIT);
MCLGET(mb, M_WAIT);
mb->m_len = 0;
return (mb);
}
@ -191,9 +191,9 @@ nfsm_rpchead(struct ucred *cr, int nmflag, int procid, int auth_type,
int grpsiz, authsiz;
authsiz = nfsm_rndup(auth_len);
MGETHDR(mb, M_TRYWAIT, MT_DATA);
MGETHDR(mb, M_WAIT, MT_DATA);
if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) {
MCLGET(mb, M_TRYWAIT);
MCLGET(mb, M_WAIT);
} else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) {
MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED);
} else {
@ -286,9 +286,9 @@ nfsm_uiotombuf(struct uio *uiop, struct mbuf **mq, int siz, caddr_t *bpos)
while (left > 0) {
mlen = M_TRAILINGSPACE(mp);
if (mlen == 0) {
MGET(mp, M_TRYWAIT, MT_DATA);
MGET(mp, M_WAIT, MT_DATA);
if (clflg)
MCLGET(mp, M_TRYWAIT);
MCLGET(mp, M_WAIT);
mp->m_len = 0;
mp2->m_next = mp;
mp2 = mp;
@ -319,7 +319,7 @@ nfsm_uiotombuf(struct uio *uiop, struct mbuf **mq, int siz, caddr_t *bpos)
}
if (rem > 0) {
if (rem > M_TRAILINGSPACE(mp)) {
MGET(mp, M_TRYWAIT, MT_DATA);
MGET(mp, M_WAIT, MT_DATA);
mp->m_len = 0;
mp2->m_next = mp;
}
@ -364,9 +364,9 @@ nfsm_strtmbuf(struct mbuf **mb, char **bpos, const char *cp, long siz)
}
/* Loop around adding mbufs */
while (siz > 0) {
MGET(m1, M_TRYWAIT, MT_DATA);
MGET(m1, M_WAIT, MT_DATA);
if (siz > MLEN)
MCLGET(m1, M_TRYWAIT);
MCLGET(m1, M_WAIT);
m1->m_len = NFSMSIZ(m1);
m2->m_next = m1;
m2 = m1;
@ -563,7 +563,7 @@ nfs_loadattrcache(struct vnode **vpp, struct mbuf **mdp, caddr_t *dposp,
md = *mdp;
t1 = (mtod(md, caddr_t) + md->m_len) - *dposp;
cp2 = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, M_TRYWAIT);
cp2 = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, M_WAIT);
if (cp2 == NULL)
return EBADRPC;
fp = (struct nfs_fattr *)cp2;

8
sys/nfsserver/nfs_serv.c
View File

@ -686,8 +686,8 @@ nfsrv_readlink(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
len = 0;
i = 0;
while (len < NFS_MAXPATHLEN) {
MGET(nmp, M_TRYWAIT, MT_DATA);
MCLGET(nmp, M_TRYWAIT);
MGET(nmp, M_WAIT, MT_DATA);
MCLGET(nmp, M_WAIT);
nmp->m_len = NFSMSIZ(nmp);
if (len == 0)
mp3 = mp = nmp;
@ -935,8 +935,8 @@ nfsrv_read(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
i++;
}
if (left > 0) {
MGET(m, M_TRYWAIT, MT_DATA);
MCLGET(m, M_TRYWAIT);
MGET(m, M_WAIT, MT_DATA);
MCLGET(m, M_WAIT);
m->m_len = 0;
m2->m_next = m;
m2 = m;

4
sys/nfsserver/nfs_srvcache.c
View File

@ -227,7 +227,7 @@ loop:
nfsrvstats.srvcache_nonidemdonehits++;
NFSD_UNLOCK();
*repp = m_copym(rp->rc_reply, 0, M_COPYALL,
M_TRYWAIT);
M_WAIT);
NFSD_LOCK();
ret = RC_REPLY;
} else {
@ -348,7 +348,7 @@ loop:
} else {
NFSD_UNLOCK();
rp->rc_reply = m_copym(repmbuf,
0, M_COPYALL, M_TRYWAIT);
0, M_COPYALL, M_WAIT);
NFSD_LOCK();
rp->rc_flag |= RC_REPMBUF;
}

10
sys/nfsserver/nfs_srvsock.c
View File

@ -148,7 +148,7 @@ nfs_rephead(int siz, struct nfsrv_descript *nd, int err,
nd->nd_repstat = err;
if (err && (nd->nd_flag & ND_NFSV3) == 0) /* XXX recheck */
siz = 0;
MGETHDR(mreq, M_TRYWAIT, MT_DATA);
MGETHDR(mreq, M_WAIT, MT_DATA);
mb = mreq;
/*
* If this is a big reply, use a cluster else
@ -157,7 +157,7 @@ nfs_rephead(int siz, struct nfsrv_descript *nd, int err,
mreq->m_len = 6 * NFSX_UNSIGNED;
siz += RPC_REPLYSIZ;
if ((max_hdr + siz) >= MINCLSIZE) {
MCLGET(mreq, M_TRYWAIT);
MCLGET(mreq, M_WAIT);
} else
mreq->m_data += min(max_hdr, M_TRAILINGSPACE(mreq));
tl = mtod(mreq, u_int32_t *);
@ -244,9 +244,9 @@ nfs_realign(struct mbuf **pm, int hsiz) /* XXX COMMON */
++nfs_realign_test;
while ((m = *pm) != NULL) {
if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
MGET(n, M_TRYWAIT, MT_DATA);
MGET(n, M_WAIT, MT_DATA);
if (m->m_len >= MINCLSIZE) {
MCLGET(n, M_TRYWAIT);
MCLGET(n, M_WAIT);
}
n->m_len = 0;
break;
@ -401,7 +401,7 @@ nfsmout:
* Socket upcall routine for the nfsd sockets.
* The caddr_t arg is a pointer to the "struct nfssvc_sock".
* Essentially do as much as possible non-blocking, else punt and it will
* be called with M_TRYWAIT from an nfsd.
* be called with M_WAIT from an nfsd.
*/
void
nfsrv_rcv(struct socket *so, void *arg, int waitflag)

4
sys/nfsserver/nfs_srvsubs.c
View File

@ -1352,8 +1352,8 @@ nfsm_clget_xx(u_int32_t **tl, struct mbuf *mb, struct mbuf **mp,
if (*bp >= *be) {
if (*mp == mb)
(*mp)->m_len += *bp - bpos;
MGET(nmp, M_TRYWAIT, MT_DATA);
MCLGET(nmp, M_TRYWAIT);
MGET(nmp, M_WAIT, MT_DATA);
MCLGET(nmp, M_WAIT);
nmp->m_len = NFSMSIZ(nmp);
(*mp)->m_next = nmp;
*mp = nmp;

4
sys/nfsserver/nfs_syscalls.c
View File

@ -351,7 +351,7 @@ nfssvc_nfsd(struct thread *td)
(void) nfs_slplock(slp, 1);
NFSD_UNLOCK();
nfsrv_rcv(slp->ns_so, (caddr_t)slp,
M_TRYWAIT);
M_WAIT);
NFSD_LOCK();
nfs_slpunlock(slp);
}
@ -489,7 +489,7 @@ nfssvc_nfsd(struct thread *td)
* Record Mark.
*/
if (sotype == SOCK_STREAM) {
M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT);
M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
*mtod(m, u_int32_t *) = htonl(0x80000000 | siz);
}
NFSD_LOCK();

31
sys/pci/if_mn.c
View File

@ -693,9 +693,7 @@ ngmn_connect(hook_p hook)
/* Setup a transmit chain with one descriptor */
/* XXX: we actually send a 1 byte packet */
dp = mn_alloc_desc();
MGETHDR(m, M_TRYWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
MGETHDR(m, M_WAIT, MT_DATA);
m->m_pkthdr.len = 0;
dp->m = m;
dp->flags = 0xc0000000 + (1 << 16);
@ -710,17 +708,8 @@ ngmn_connect(hook_p hook)
dp = mn_alloc_desc();
m = NULL;
MGETHDR(m, M_TRYWAIT, MT_DATA);
if (m == NULL) {
mn_free_desc(dp);
return (ENOBUFS);
}
MCLGET(m, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
mn_free_desc(dp);
m_freem(m);
return (ENOBUFS);
}
MGETHDR(m, M_WAIT, MT_DATA);
MCLGET(m, M_WAIT);
dp->m = m;
dp->data = vtophys(m->m_data);
dp->flags = 0x40000000;
@ -733,18 +722,8 @@ ngmn_connect(hook_p hook)
dp2 = dp;
dp = mn_alloc_desc();
m = NULL;
MGETHDR(m, M_TRYWAIT, MT_DATA);
if (m == NULL) {
mn_free_desc(dp);
m_freem(m);
return (ENOBUFS);
}
MCLGET(m, M_TRYWAIT);
if ((m->m_flags & M_EXT) == 0) {
mn_free_desc(dp);
m_freem(m);
return (ENOBUFS);
}
MGETHDR(m, M_WAIT, MT_DATA);
MCLGET(m, M_WAIT);
dp->m = m;
dp->data = vtophys(m->m_data);
dp->flags = 0x00000000;

16
sys/rpc/rpcclnt.c
View File

@ -801,7 +801,7 @@ tryagain:
goto tryagain;
}
while (rep->r_flags & R_MUSTRESEND) {
m = m_copym(rep->r_mreq, 0, M_COPYALL, M_TRYWAIT);
m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT);
rpcstats.rpcretries++;
error = rpcclnt_send(so, rep->r_rpcclnt->rc_name, m, rep);
if (error) {
@ -1181,7 +1181,7 @@ rpcclnt_request(rpc, mrest, procnum, td, cred, reply)
* For stream protocols, insert a Sun RPC Record Mark.
*/
if (rpc->rc_sotype == SOCK_STREAM) {
M_PREPEND(m, RPCX_UNSIGNED, M_TRYWAIT);
M_PREPEND(m, RPCX_UNSIGNED, M_WAIT);
*mtod(m, u_int32_t *) = htonl(0x80000000 |
(m->m_pkthdr.len - RPCX_UNSIGNED));
}
@ -1229,7 +1229,7 @@ rpcclnt_request(rpc, mrest, procnum, td, cred, reply)
error = rpcclnt_sndlock(&rpc->rc_flag, task);
if (!error) {
error = rpcclnt_send(rpc->rc_so, rpc->rc_name,
m_copym(m, 0, M_COPYALL, M_TRYWAIT),
m_copym(m, 0, M_COPYALL, M_WAIT),
task);
if (rpc->rc_soflags & PR_CONNREQUIRED)
rpcclnt_sndunlock(&rpc->rc_flag);
@ -1750,9 +1750,9 @@ rpcclnt_realign(struct mbuf **pm, int hsiz)
while ((m = *pm) != NULL) {
if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
MGET(n, M_TRYWAIT, MT_DATA);
MGET(n, M_WAIT, MT_DATA);
if (m->m_len >= MINCLSIZE) {
MCLGET(n, M_TRYWAIT);
MCLGET(n, M_WAIT);
}
n->m_len = 0;
break;
@ -1826,9 +1826,9 @@ rpcclnt_buildheader(rc, procid, mrest, mrest_len, xidp, mheadend, cred)
struct mbuf *mreq, *mb2;
int error;
MGETHDR(mb, M_TRYWAIT, MT_DATA);
MGETHDR(mb, M_WAIT, MT_DATA);
if (6 * RPCX_UNSIGNED >= MINCLSIZE) {
MCLGET(mb, M_TRYWAIT);
MCLGET(mb, M_WAIT);
} else if (6 * RPCX_UNSIGNED < MHLEN) {
MH_ALIGN(mb, 6 * RPCX_UNSIGNED);
} else {
@ -1908,7 +1908,7 @@ rpcm_disct(mdp, dposp, siz, left, cp2)
} else if (siz > MHLEN) {
panic("rpc S too big");
} else {
MGET(mp2, M_TRYWAIT, MT_DATA);
MGET(mp2, M_WAIT, MT_DATA);
mp2->m_next = mp->m_next;
mp->m_next = mp2;
mp->m_len -= left;

4
sys/sys/mbuf.h
View File

@ -291,11 +291,11 @@ struct mbstat {
*
* The flag to use is as follows:
* - M_DONTWAIT or M_NOWAIT from an interrupt handler to not block allocation.
* - M_WAIT or M_WAITOK or M_TRYWAIT from wherever it is safe to block.
* - M_WAIT or M_WAITOK from wherever it is safe to block.
*
* M_DONTWAIT/M_NOWAIT means that we will not block the thread explicitly and
* if we cannot allocate immediately we may return NULL, whereas
* M_WAIT/M_WAITOK/M_TRYWAIT means that if we cannot allocate resources we
* M_WAIT/M_WAITOK means that if we cannot allocate resources we
* will block until they are available, and thus never return NULL.
*
* XXX Eventually just phase this out to use M_WAITOK/M_NOWAIT.