From 2a0c503e7afc6498157c35173896688a147efb34 Mon Sep 17 00:00:00 2001 From: Bosko Milekic Date: Thu, 21 Dec 2000 21:44:31 +0000 Subject: [PATCH] * Rename M_WAIT mbuf subsystem flag to M_TRYWAIT. This is because calls with M_WAIT (now M_TRYWAIT) may not wait forever when nothing is available for allocation, and may end up returning NULL. Hopefully we now communicate more of the right thing to developers and make it very clear that it's necessary to check whether calls with M_(TRY)WAIT also resulted in a failed allocation. M_TRYWAIT basically means "try harder, block if necessary, but don't necessarily wait forever." The time spent blocking is tunable with the kern.ipc.mbuf_wait sysctl. M_WAIT is now deprecated but still defined for the next little while. * Fix a typo in a comment in mbuf.h * Fix some code that was actually passing the mbuf subsystem's M_WAIT to malloc(). Made it pass M_WAITOK instead. If we were ever to redefine the value of the M_WAIT flag, this could have became a big problem. --- sys/dev/musycc/musycc.c | 4 ++-- sys/kern/uipc_mbuf.c | 18 +++++++++--------- sys/kern/uipc_socket.c | 18 +++++++++--------- sys/kern/uipc_syscalls.c | 6 +++--- sys/kern/uipc_usrreq.c | 2 +- sys/net/bpf.c | 4 ++-- sys/net/bpf_compat.h | 2 +- sys/net/if_ef.c | 4 ++-- sys/net/if_ethersubr.c | 4 ++-- sys/net/if_fddisubr.c | 2 +- sys/net/if_gif.c | 2 +- sys/net/if_sl.c | 4 ++-- sys/net/if_stf.c | 2 +- sys/net/ppp_tty.c | 2 +- sys/netatalk/aarp.c | 4 ++-- sys/netatalk/ddp_output.c | 4 ++-- sys/netatm/port.h | 2 +- sys/netinet/ip_output.c | 2 +- sys/netinet/raw_ip.c | 2 +- sys/netinet6/ip6_fw.c | 8 ++++---- sys/netinet6/ip6_output.c | 4 ++-- sys/netinet6/raw_ip6.c | 2 +- sys/netipx/spx_usrreq.c | 2 +- sys/netncp/ncp_rq.c | 16 ++++++++-------- sys/netncp/ncp_sock.c | 2 +- sys/netns/spp_usrreq.c | 2 +- sys/nfs/bootp_subr.c | 2 +- sys/nfs/krpc_subr.c | 10 +++++----- sys/nfs/nfs_common.c | 28 ++++++++++++++-------------- sys/nfs/nfs_common.h | 6 +++--- sys/nfs/nfs_nqlease.c | 4 ++-- sys/nfs/nfs_serv.c | 8 ++++---- sys/nfs/nfs_socket.c | 16 ++++++++-------- sys/nfs/nfs_srvcache.c | 4 ++-- sys/nfs/nfs_subs.c | 28 ++++++++++++++-------------- sys/nfs/nfs_syscalls.c | 4 ++-- sys/nfs/nfsm_subs.h | 6 +++--- sys/nfsclient/bootp_subr.c | 2 +- sys/nfsclient/krpc_subr.c | 10 +++++----- sys/nfsclient/nfs_nfsiod.c | 4 ++-- sys/nfsclient/nfs_socket.c | 16 ++++++++-------- sys/nfsclient/nfs_subs.c | 28 ++++++++++++++-------------- sys/nfsclient/nfsm_subs.h | 6 +++--- sys/nfsserver/nfs_serv.c | 8 ++++---- sys/nfsserver/nfs_srvcache.c | 4 ++-- sys/nfsserver/nfs_srvsock.c | 16 ++++++++-------- sys/nfsserver/nfs_srvsubs.c | 28 ++++++++++++++-------------- sys/nfsserver/nfs_syscalls.c | 4 ++-- sys/nfsserver/nfsm_subs.h | 6 +++--- sys/pci/if_mn.c | 10 +++++----- sys/sys/mbuf.h | 13 +++++++------ 51 files changed, 198 insertions(+), 197 deletions(-) diff --git a/sys/dev/musycc/musycc.c b/sys/dev/musycc/musycc.c index 85ec6e0415f1..98d53347945d 100644 --- a/sys/dev/musycc/musycc.c +++ b/sys/dev/musycc/musycc.c @@ -1207,8 +1207,8 @@ musycc_connect(hook_p hook) sc->mdt[ch][i].m = NULL; sc->mdt[ch][i].data = 0; - MGETHDR(m, M_WAIT, MT_DATA); - MCLGET(m, M_WAIT); + MGETHDR(m, M_TRYWAIT, MT_DATA); + MCLGET(m, M_TRYWAIT); sc->mdr[ch][i].m = m; sc->mdr[ch][i].data = vtophys(m->m_data); sc->mdr[ch][i].status = 1600; /* MTU */ diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c index 2c52f780053d..d8cc445ac6a0 100644 --- a/sys/kern/uipc_mbuf.c +++ b/sys/kern/uipc_mbuf.c @@ -206,8 +206,8 @@ m_alloc_ref(nmb, how) nbytes = round_page(nmb * sizeof(union mext_refcnt)); mtx_exit(&mcntfree.m_mtx, MTX_DEF); mtx_enter(&Giant, MTX_DEF); - if ((p = (caddr_t)kmem_malloc(mb_map, nbytes, how == M_WAIT ? M_WAIT : - M_NOWAIT)) == NULL) { + if ((p = (caddr_t)kmem_malloc(mb_map, nbytes, how == M_TRYWAIT ? + M_WAITOK : M_NOWAIT)) == NULL) { mtx_exit(&Giant, MTX_DEF); mtx_enter(&mcntfree.m_mtx, MTX_DEF); /* XXX: We must be holding it going out. */ @@ -265,11 +265,11 @@ m_mballoc(nmb, how) nbytes = round_page(nmb * MSIZE); /* XXX: The letting go of the mmbfree lock here may eventually - be moved to only be done for M_WAIT calls to kmem_malloc() */ + be moved to only be done for M_TRYWAIT calls to kmem_malloc() */ mtx_exit(&mmbfree.m_mtx, MTX_DEF); mtx_enter(&Giant, MTX_DEF); p = (caddr_t)kmem_malloc(mb_map, nbytes, M_NOWAIT); - if (p == 0 && how == M_WAIT) { + if (p == 0 && how == M_TRYWAIT) { atomic_add_long(&mbstat.m_wait, 1); p = (caddr_t)kmem_malloc(mb_map, nbytes, M_WAITOK); } @@ -302,8 +302,8 @@ m_mballoc(nmb, how) /* * Once the mb_map has been exhausted and if the call to the allocation macros - * (or, in some cases, functions) is with M_WAIT, then it is necessary to rely - * solely on reclaimed mbufs. + * (or, in some cases, functions) is with M_TRYWAIT, then it is necessary to + * rely solely on reclaimed mbufs. * * Here we request for the protocols to free up some resources and, if we * still cannot get anything, then we wait for an mbuf to be freed for a @@ -385,7 +385,7 @@ m_clalloc(ncl, how) mtx_exit(&mclfree.m_mtx, MTX_DEF); mtx_enter(&Giant, MTX_DEF); p = (caddr_t)kmem_malloc(mb_map, ctob(npg), - how != M_WAIT ? M_NOWAIT : M_WAITOK); + how == M_TRYWAIT ? M_WAITOK : M_NOWAIT); mtx_exit(&Giant, MTX_DEF); ncl = ncl * PAGE_SIZE / MCLBYTES; mtx_enter(&mclfree.m_mtx, MTX_DEF); @@ -414,7 +414,7 @@ m_clalloc(ncl, how) /* * Once the mb_map submap has been exhausted and the allocation is called with - * M_WAIT, we rely on the mclfree list. If nothing is free, we will + * M_TRYWAIT, we rely on the mclfree list. If nothing is free, we will * sleep for a designated amount of time (mbuf_wait) or until we're woken up * due to sudden mcluster availability. * @@ -578,7 +578,7 @@ m_prepend(m, len, 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_WAIT/M_DONTWAIT from caller. + * The wait parameter is a choice of M_TRYWAIT/M_DONTWAIT from caller. * Note that the copy is read-only, because clusters are not copied, * only their reference counts are incremented. */ diff --git a/sys/kern/uipc_socket.c b/sys/kern/uipc_socket.c index a93ee50c754e..fe7820562ea7 100644 --- a/sys/kern/uipc_socket.c +++ b/sys/kern/uipc_socket.c @@ -558,7 +558,7 @@ restart: top->m_flags |= M_EOR; } else do { if (top == 0) { - MGETHDR(m, M_WAIT, MT_DATA); + MGETHDR(m, M_TRYWAIT, MT_DATA); if (m == NULL) { error = ENOBUFS; goto release; @@ -567,7 +567,7 @@ restart: m->m_pkthdr.len = 0; m->m_pkthdr.rcvif = (struct ifnet *)0; } else { - MGET(m, M_WAIT, MT_DATA); + MGET(m, M_TRYWAIT, MT_DATA); if (m == NULL) { error = ENOBUFS; goto release; @@ -575,7 +575,7 @@ restart: mlen = MLEN; } if (resid >= MINCLSIZE) { - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) goto nopages; mlen = MCLBYTES; @@ -695,7 +695,7 @@ soreceive(so, psa, uio, mp0, controlp, flagsp) else flags = 0; if (flags & MSG_OOB) { - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); if (m == NULL) return (ENOBUFS); error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK); @@ -887,7 +887,7 @@ dontblock: moff += len; else { if (mp) - *mp = m_copym(m, 0, len, M_WAIT); + *mp = m_copym(m, 0, len, M_TRYWAIT); m->m_data += len; m->m_len -= len; so->so_rcv.sb_cc -= len; @@ -1390,11 +1390,11 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp) struct mbuf *m, *m_prev; int sopt_size = sopt->sopt_valsize; - MGET(m, sopt->sopt_p ? M_WAIT : M_DONTWAIT, MT_DATA); + MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_DATA); if (m == 0) return ENOBUFS; if (sopt_size > MLEN) { - MCLGET(m, sopt->sopt_p ? M_WAIT : M_DONTWAIT); + MCLGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) { m_free(m); return ENOBUFS; @@ -1408,13 +1408,13 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp) m_prev = m; while (sopt_size) { - MGET(m, sopt->sopt_p ? M_WAIT : M_DONTWAIT, MT_DATA); + MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_DATA); if (m == 0) { m_freem(*mp); return ENOBUFS; } if (sopt_size > MLEN) { - MCLGET(m, sopt->sopt_p ? M_WAIT : M_DONTWAIT); + MCLGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) { m_freem(*mp); return ENOBUFS; diff --git a/sys/kern/uipc_syscalls.c b/sys/kern/uipc_syscalls.c index d5b8ec5e2e20..812764fefe38 100644 --- a/sys/kern/uipc_syscalls.c +++ b/sys/kern/uipc_syscalls.c @@ -548,7 +548,7 @@ sendit(p, s, mp, flags) if (mp->msg_flags == MSG_COMPAT) { register struct cmsghdr *cm; - M_PREPEND(control, sizeof(*cm), M_WAIT); + M_PREPEND(control, sizeof(*cm), M_TRYWAIT); if (control == 0) { error = ENOBUFS; goto bad; @@ -1331,7 +1331,7 @@ sockargs(mp, buf, buflen, type) #endif return (EINVAL); } - m = m_get(M_WAIT, type); + m = m_get(M_TRYWAIT, type); if (m == NULL) return (ENOBUFS); m->m_len = buflen; @@ -1702,7 +1702,7 @@ retry_lookup: /* * Get an mbuf header and set it up as having external storage. */ - MGETHDR(m, M_WAIT, MT_DATA); + MGETHDR(m, M_TRYWAIT, MT_DATA); if (m == NULL) { error = ENOBUFS; sf_buf_free((void *)sf->kva, NULL); diff --git a/sys/kern/uipc_usrreq.c b/sys/kern/uipc_usrreq.c index d77b67bb7448..79477c9e74a0 100644 --- a/sys/kern/uipc_usrreq.c +++ b/sys/kern/uipc_usrreq.c @@ -1017,7 +1017,7 @@ unp_internalize(control, p) if (newlen - control->m_len > M_TRAILINGSPACE(control)) { if (control->m_flags & M_EXT) return (E2BIG); - MCLGET(control, M_WAIT); + MCLGET(control, M_TRYWAIT); if ((control->m_flags & M_EXT) == 0) return (ENOBUFS); diff --git a/sys/net/bpf.c b/sys/net/bpf.c index 12e375e37e9b..21eeff350047 100644 --- a/sys/net/bpf.c +++ b/sys/net/bpf.c @@ -231,12 +231,12 @@ bpf_movein(uio, linktype, mp, sockp, datlen) if ((unsigned)len > MCLBYTES) return (EIO); - MGETHDR(m, M_WAIT, MT_DATA); + MGETHDR(m, M_TRYWAIT, MT_DATA); if (m == 0) return (ENOBUFS); if (len > MHLEN) { #if BSD >= 199103 - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { #else MCLGET(m); diff --git a/sys/net/bpf_compat.h b/sys/net/bpf_compat.h index 0936b8490316..8ccaa23bdff7 100644 --- a/sys/net/bpf_compat.h +++ b/sys/net/bpf_compat.h @@ -46,7 +46,7 @@ */ #define malloc(size, type, canwait) bpf_alloc(size, canwait) #define free(cp, type) m_free(*(struct mbuf **)(cp - 8)) -#define M_WAITOK M_WAIT +#define M_WAITOK M_TRYWAIT /* This mapping works for our purposes. */ #define ERESTART EINTR diff --git a/sys/net/if_ef.c b/sys/net/if_ef.c index 4554a293afd8..f11fa70164d5 100644 --- a/sys/net/if_ef.c +++ b/sys/net/if_ef.c @@ -439,7 +439,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_WAIT); + M_PREPEND(m, ETHER_HDR_LEN + 3, M_TRYWAIT); if (m == NULL) { *mp = NULL; return ENOBUFS; @@ -462,7 +462,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_WAIT); + M_PREPEND(m, 8, M_TRYWAIT); if (m == NULL) { *mp = NULL; return ENOBUFS; diff --git a/sys/net/if_ethersubr.c b/sys/net/if_ethersubr.c index cfca49836fa1..ebd4b37294ae 100644 --- a/sys/net/if_ethersubr.c +++ b/sys/net/if_ethersubr.c @@ -221,7 +221,7 @@ ether_output(ifp, m, dst, rt0) if ( aa->aa_flags & AFA_PHASE2 ) { struct llc llc; - M_PREPEND(m, sizeof(struct llc), M_WAIT); + M_PREPEND(m, sizeof(struct llc), M_TRYWAIT); 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)); @@ -246,7 +246,7 @@ ether_output(ifp, m, dst, rt0) type = htons( m->m_pkthdr.len); break; case 0xe0e0: /* Novell 802.2 and Token-Ring */ - M_PREPEND(m, 3, M_WAIT); + M_PREPEND(m, 3, M_TRYWAIT); type = htons( m->m_pkthdr.len); cp = mtod(m, u_char *); *cp++ = 0xE0; diff --git a/sys/net/if_fddisubr.c b/sys/net/if_fddisubr.c index 186fec5f915a..b93414a25ce6 100644 --- a/sys/net/if_fddisubr.c +++ b/sys/net/if_fddisubr.c @@ -213,7 +213,7 @@ fddi_output(ifp, m, dst, rt0) if (aa->aa_flags & AFA_PHASE2) { struct llc llc; - M_PREPEND(m, sizeof(struct llc), M_WAIT); + M_PREPEND(m, sizeof(struct llc), M_TRYWAIT); if (m == 0) senderr(ENOBUFS); llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP; diff --git a/sys/net/if_gif.c b/sys/net/if_gif.c index 143f06f86ffa..f8af9109271d 100644 --- a/sys/net/if_gif.c +++ b/sys/net/if_gif.c @@ -118,7 +118,7 @@ gifattach(dummy) register int i; ngif = NGIF; - gif = sc = malloc (ngif * sizeof(struct gif_softc), M_DEVBUF, M_WAIT); + gif = sc = malloc (ngif * sizeof(struct gif_softc), M_DEVBUF, M_WAITOK); bzero(sc, ngif * sizeof(struct gif_softc)); for (i = 0; i < ngif; sc++, i++) { sc->gif_if.if_name = "gif"; diff --git a/sys/net/if_sl.c b/sys/net/if_sl.c index f7bc1f283a1d..d3f808541e35 100644 --- a/sys/net/if_sl.c +++ b/sys/net/if_sl.c @@ -253,9 +253,9 @@ slcreate() MALLOC(sc, struct sl_softc *, sizeof(*sc), M_SL, M_WAITOK | M_ZERO); - m = m_gethdr(M_WAIT, MT_DATA); + m = m_gethdr(M_TRYWAIT, MT_DATA); if (m != NULL) { - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { m_free(m); m = NULL; diff --git a/sys/net/if_stf.c b/sys/net/if_stf.c index 8ae33de21a3c..769e376ac0cd 100644 --- a/sys/net/if_stf.c +++ b/sys/net/if_stf.c @@ -173,7 +173,7 @@ stfattach(dummy) const struct encaptab *p; nstf = NSTF; - stf = malloc(nstf * sizeof(struct stf_softc), M_DEVBUF, M_WAIT); + stf = malloc(nstf * sizeof(struct stf_softc), M_DEVBUF, M_WAITOK); bzero(stf, nstf * sizeof(struct stf_softc)); sc = stf; diff --git a/sys/net/ppp_tty.c b/sys/net/ppp_tty.c index 16cc00903601..3a95fdb3e66a 100644 --- a/sys/net/ppp_tty.c +++ b/sys/net/ppp_tty.c @@ -391,7 +391,7 @@ pppwrite(tp, uio, flag) s = spltty(); for (mp = &m0; uio->uio_resid; mp = &m->m_next) { - MGET(m, M_WAIT, MT_DATA); + MGET(m, M_TRYWAIT, MT_DATA); if ((*mp = m) == NULL) { m_freem(m0); splx(s); diff --git a/sys/netatalk/aarp.c b/sys/netatalk/aarp.c index e5aa7c63192b..049387028003 100644 --- a/sys/netatalk/aarp.c +++ b/sys/netatalk/aarp.c @@ -161,7 +161,7 @@ aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat ) bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost, sizeof( eh->ether_dhost )); eh->ether_type = htons(sizeof(struct llc) + sizeof(struct ether_aarp)); - M_PREPEND( m, sizeof( struct llc ), M_WAIT ); + M_PREPEND( m, sizeof( struct llc ), M_TRYWAIT ); llc = mtod( m, struct llc *); llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP; llc->llc_control = LLC_UI; @@ -571,7 +571,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_WAIT ); + M_PREPEND( m, sizeof( struct llc ), M_TRYWAIT ); llc = mtod( m, struct llc *); llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP; llc->llc_control = LLC_UI; diff --git a/sys/netatalk/ddp_output.c b/sys/netatalk/ddp_output.c index 66e20dfe6181..3d48fd25e3be 100644 --- a/sys/netatalk/ddp_output.c +++ b/sys/netatalk/ddp_output.c @@ -48,7 +48,7 @@ ddp_output( struct mbuf *m, struct socket *so) struct ddpehdr *deh; struct ddpcb *ddp = sotoddpcb( so ); - M_PREPEND( m, sizeof( struct ddpehdr ), M_WAIT ); + M_PREPEND( m, sizeof( struct ddpehdr ), M_TRYWAIT ); deh = mtod( m, struct ddpehdr *); deh->deh_pad = 0; @@ -189,7 +189,7 @@ ddp_route( struct mbuf *m, struct route *ro) * packets end up poorly aligned due to the three byte elap header. */ if ( !(aa->aa_flags & AFA_PHASE2) ) { - MGET( m0, M_WAIT, MT_HEADER ); + MGET( m0, M_TRYWAIT, MT_HEADER ); if ( m0 == 0 ) { m_freem( m ); printf("ddp_route: no buffers\n"); diff --git a/sys/netatm/port.h b/sys/netatm/port.h index ca111c7b43e2..8ada59ffc362 100644 --- a/sys/netatm/port.h +++ b/sys/netatm/port.h @@ -210,7 +210,7 @@ #include typedef struct mbuf KBuffer; -#define KB_F_WAIT M_WAIT +#define KB_F_WAIT M_TRYWAIT #define KB_F_NOWAIT M_DONTWAIT #define KB_T_HEADER MT_HEADER diff --git a/sys/netinet/ip_output.c b/sys/netinet/ip_output.c index 21cdc0c3287d..fb8669c0261d 100644 --- a/sys/netinet/ip_output.c +++ b/sys/netinet/ip_output.c @@ -1115,7 +1115,7 @@ ip_ctloutput(so, sopt) error = EMSGSIZE; break; } - MGET(m, sopt->sopt_p ? M_WAIT : M_DONTWAIT, MT_HEADER); + MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_HEADER); if (m == 0) { error = ENOBUFS; break; diff --git a/sys/netinet/raw_ip.c b/sys/netinet/raw_ip.c index e15ee4e67a6b..0342d391c067 100644 --- a/sys/netinet/raw_ip.c +++ b/sys/netinet/raw_ip.c @@ -195,7 +195,7 @@ rip_output(m, so, dst) m_freem(m); return(EMSGSIZE); } - M_PREPEND(m, sizeof(struct ip), M_WAIT); + M_PREPEND(m, sizeof(struct ip), M_TRYWAIT); ip = mtod(m, struct ip *); ip->ip_tos = 0; ip->ip_off = 0; diff --git a/sys/netinet6/ip6_fw.c b/sys/netinet6/ip6_fw.c index f0f710f573f0..6bcef8a7ca2f 100644 --- a/sys/netinet6/ip6_fw.c +++ b/sys/netinet6/ip6_fw.c @@ -1045,11 +1045,11 @@ ip6_fw_ctl(int stage, struct mbuf **mm) if (stage == IPV6_FW_GET) { struct ip6_fw_chain *fcp = ip6_fw_chain.lh_first; - *mm = m = m_get(M_WAIT, MT_DATA); /* XXX */ + *mm = m = m_get(M_TRYWAIT, MT_DATA); /* XXX */ if (!m) return(ENOBUFS); if (sizeof *(fcp->rule) > MLEN) { - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { m_free(m); return(ENOBUFS); @@ -1058,14 +1058,14 @@ ip6_fw_ctl(int stage, struct mbuf **mm) for (; fcp; fcp = fcp->chain.le_next) { memcpy(m->m_data, fcp->rule, sizeof *(fcp->rule)); m->m_len = sizeof *(fcp->rule); - m->m_next = m_get(M_WAIT, MT_DATA); /* XXX */ + m->m_next = m_get(M_TRYWAIT, MT_DATA); /* XXX */ if (!m->m_next) { m_freem(*mm); return(ENOBUFS); } m = m->m_next; if (sizeof *(fcp->rule) > MLEN) { - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { m_freem(*mm); return(ENOBUFS); diff --git a/sys/netinet6/ip6_output.c b/sys/netinet6/ip6_output.c index f990d449d81f..a898cf2d68bb 100644 --- a/sys/netinet6/ip6_output.c +++ b/sys/netinet6/ip6_output.c @@ -1330,7 +1330,7 @@ ip6_ctloutput(so, sopt) break; } /* XXX */ - MGET(m, sopt->sopt_p ? M_WAIT : M_DONTWAIT, MT_HEADER); + MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_HEADER); if (m == 0) { error = ENOBUFS; break; @@ -1920,7 +1920,7 @@ ip6_getmoptions(optname, im6o, mp) { u_int *hlim, *loop, *ifindex; - *mp = m_get(M_WAIT, MT_HEADER); /*XXX*/ + *mp = m_get(M_TRYWAIT, MT_HEADER); /*XXX*/ switch (optname) { diff --git a/sys/netinet6/raw_ip6.c b/sys/netinet6/raw_ip6.c index 95c7d20af874..42f38fd5d62f 100644 --- a/sys/netinet6/raw_ip6.c +++ b/sys/netinet6/raw_ip6.c @@ -333,7 +333,7 @@ rip6_output(m, va_alist) code = icmp6->icmp6_code; } - M_PREPEND(m, sizeof(*ip6), M_WAIT); + M_PREPEND(m, sizeof(*ip6), M_TRYWAIT); ip6 = mtod(m, struct ip6_hdr *); /* diff --git a/sys/netipx/spx_usrreq.c b/sys/netipx/spx_usrreq.c index eef2445eed2e..b77b1b389daa 100644 --- a/sys/netipx/spx_usrreq.c +++ b/sys/netipx/spx_usrreq.c @@ -751,7 +751,7 @@ spx_output(cb, m0) * from usrreq(), so it is OK to * block. */ - m = m_copym(m0, 0, mtu, M_WAIT); + m = m_copym(m0, 0, mtu, M_TRYWAIT); if (cb->s_flags & SF_NEWCALL) { struct mbuf *mm = m; spx_newchecks[7]++; diff --git a/sys/netncp/ncp_rq.c b/sys/netncp/ncp_rq.c index 8cef7d2a74f4..e661f5edda82 100644 --- a/sys/netncp/ncp_rq.c +++ b/sys/netncp/ncp_rq.c @@ -60,9 +60,9 @@ ncp_rq_head(struct ncp_rq *rqp, u_int32_t ptype, u_int8_t fn,struct proc *p, bzero(rqp, sizeof(*rqp)); rqp->p = p; rqp->cred = cred; - m = m_gethdr(M_WAIT, MT_DATA); + m = m_gethdr(M_TRYWAIT, MT_DATA); if (m == NULL) - return ENOBUFS; /* if M_WAIT ? */ + return ENOBUFS; /* if M_TRYWAIT ? */ m->m_pkthdr.rcvif = NULL; rqp->rq = rqp->mrq = m; rqp->rp = NULL; @@ -106,9 +106,9 @@ m_getm(struct mbuf *top, int len) { mp = top; while (rest > 0) { /* NCPSDEBUG("%d\n",rest);*/ - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); if (rest > MINCLSIZE) { - MCLGET(m,M_WAIT); + MCLGET(m,M_TRYWAIT); mlen = ( (m->m_flags & M_EXT) == 0) ? MLEN : MCLBYTES; } else { mlen = MLEN; @@ -135,7 +135,7 @@ ncp_mchecksize(struct ncp_rq *rqp, int size) { panic("ncp_mchecksize\n"); if (M_TRAILINGSPACE(rqp->mrq)<(size)) { struct mbuf *m; - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); m->m_len = 0; rqp->bpos = mtod(m, caddr_t); rqp->mrq->m_next = m; @@ -435,7 +435,7 @@ ncp_rp_mbuf(struct ncp_rq *rqp, int size) { register struct mbuf *m=rqp->mrp, *rm; register unsigned count; - rm = m_copym(m, rqp->bpos - mtod(m,caddr_t), size, M_WAIT); + rm = m_copym(m, rqp->bpos - mtod(m,caddr_t), size, M_TRYWAIT); while (size > 0) { if (m == 0) { printf("ncp_rp_mbuf: can't advance\n"); @@ -555,9 +555,9 @@ nwfs_uiotombuf(uiop, mq, siz, bpos) while (left > 0) { mlen = M_TRAILINGSPACE(mp); if (mlen == 0) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); if (clflg) - MCLGET(mp, M_WAIT); + MCLGET(mp, M_TRYWAIT); mp->m_len = 0; mp2->m_next = mp; mp2 = mp; diff --git a/sys/netncp/ncp_sock.c b/sys/netncp/ncp_sock.c index 238f0ae33b2e..206c34147ef8 100644 --- a/sys/netncp/ncp_sock.c +++ b/sys/netncp/ncp_sock.c @@ -171,7 +171,7 @@ ncp_sock_send(struct socket *so, struct mbuf *top, struct ncp_rq *rqp) int sendwait; for(;;) { - m = m_copym(top, 0, M_COPYALL, M_WAIT); + m = m_copym(top, 0, M_COPYALL, M_TRYWAIT); /* NCPDDEBUG(m);*/ error = so->so_proto->pr_usrreqs->pru_sosend(so, to, 0, m, 0, flags, p); if (error == 0 || error == EINTR || error == ENETDOWN) diff --git a/sys/netns/spp_usrreq.c b/sys/netns/spp_usrreq.c index 4ab74ce1e250..8a14ff039f76 100644 --- a/sys/netns/spp_usrreq.c +++ b/sys/netns/spp_usrreq.c @@ -743,7 +743,7 @@ spp_output(cb, m0) * from usrreq(), so it is OK to * block. */ - m = m_copym(m0, 0, mtu, M_WAIT); + m = m_copym(m0, 0, mtu, M_TRYWAIT); if (cb->s_flags & SF_NEWCALL) { struct mbuf *mm = m; spp_newchecks[7]++; diff --git a/sys/nfs/bootp_subr.c b/sys/nfs/bootp_subr.c index 80375d79c284..9101ba749642 100644 --- a/sys/nfs/bootp_subr.c +++ b/sys/nfs/bootp_subr.c @@ -1755,7 +1755,7 @@ md_lookup_swap(struct sockaddr_in *mdsin, /* mountd server address */ u_int32_t v3[21]; } fattribs; - m = m_get(M_WAIT,MT_DATA); + m = m_get(M_TRYWAIT,MT_DATA); if (m == NULL) return ENOBUFS; diff --git a/sys/nfs/krpc_subr.c b/sys/nfs/krpc_subr.c index 054a2783a7d4..b7b1d2c28ebe 100644 --- a/sys/nfs/krpc_subr.c +++ b/sys/nfs/krpc_subr.c @@ -149,7 +149,7 @@ krpc_portmap(sin, prog, vers, portp, procp) return 0; } - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); if (m == NULL) return ENOBUFS; sdata = mtod(m, struct sdata *); @@ -275,7 +275,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) /* * Prepend RPC message header. */ - mhead = m_gethdr(M_WAIT, MT_DATA); + mhead = m_gethdr(M_TRYWAIT, MT_DATA); mhead->m_next = *data; call = mtod(mhead, struct rpc_call *); mhead->m_len = sizeof(*call); @@ -315,7 +315,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) timo = 0; for (;;) { /* Send RPC request (or re-send). */ - m = m_copym(mhead, 0, M_COPYALL, M_WAIT); + m = m_copym(mhead, 0, M_COPYALL, M_TRYWAIT); if (m == NULL) { error = ENOBUFS; goto out; @@ -471,9 +471,9 @@ xdr_string_encode(str, len) if (mlen > MCLBYTES) /* If too big, we just can't do it. */ return (NULL); - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); if (mlen > MLEN) { - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { (void) m_free(m); /* There can be only one. */ return (NULL); diff --git a/sys/nfs/nfs_common.c b/sys/nfs/nfs_common.c index 95138c347c18..c7e6917e87dc 100644 --- a/sys/nfs/nfs_common.c +++ b/sys/nfs/nfs_common.c @@ -588,9 +588,9 @@ nfsm_reqh(vp, procid, hsiz, bposp) struct nfsmount *nmp; int nqflag; - MGET(mb, M_WAIT, MT_DATA); + MGET(mb, M_TRYWAIT, MT_DATA); if (hsiz >= MINCLSIZE) - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); mb->m_len = 0; bpos = mtod(mb, caddr_t); @@ -646,9 +646,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, int siz, grpsiz, authsiz; authsiz = nfsm_rndup(auth_len); - MGETHDR(mb, M_WAIT, MT_DATA); + MGETHDR(mb, M_TRYWAIT, MT_DATA); if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) { - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) { MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED); } else { @@ -711,9 +711,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = auth_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -744,9 +744,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = verf_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -887,9 +887,9 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) while (left > 0) { mlen = M_TRAILINGSPACE(mp); if (mlen == 0) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); if (clflg) - MCLGET(mp, M_WAIT); + MCLGET(mp, M_TRYWAIT); mp->m_len = 0; mp2->m_next = mp; mp2 = mp; @@ -919,7 +919,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) } if (rem > 0) { if (rem > M_TRAILINGSPACE(mp)) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); mp->m_len = 0; mp2->m_next = mp; } @@ -968,7 +968,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) } else if (siz > MHLEN) { panic("nfs S too big"); } else { - MGET(mp2, M_WAIT, MT_DATA); + MGET(mp2, M_TRYWAIT, MT_DATA); mp2->m_next = mp->m_next; mp->m_next = mp2; mp->m_len -= left; @@ -1061,9 +1061,9 @@ nfsm_strtmbuf(mb, bpos, cp, siz) } /* Loop around adding mbufs */ while (siz > 0) { - MGET(m1, M_WAIT, MT_DATA); + MGET(m1, M_TRYWAIT, MT_DATA); if (siz > MLEN) - MCLGET(m1, M_WAIT); + MCLGET(m1, M_TRYWAIT); m1->m_len = NFSMSIZ(m1); m2->m_next = m1; m2 = m1; diff --git a/sys/nfs/nfs_common.h b/sys/nfs/nfs_common.h index 0990fe4e0121..d58ef15a6c2a 100644 --- a/sys/nfs/nfs_common.h +++ b/sys/nfs/nfs_common.h @@ -94,7 +94,7 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, #define nfsm_build(a,c,s) \ do { \ if ((s) > M_TRAILINGSPACE(mb)) { \ - MGET(mb2, M_WAIT, MT_DATA); \ + MGET(mb2, M_TRYWAIT, MT_DATA); \ if ((s) > MLEN) \ panic("build > MLEN"); \ mb->m_next = mb2; \ @@ -491,8 +491,8 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, if (bp >= be) { \ if (mp == mb) \ mp->m_len += bp-bpos; \ - MGET(mp, M_WAIT, MT_DATA); \ - MCLGET(mp, M_WAIT); \ + MGET(mp, M_TRYWAIT, MT_DATA); \ + MCLGET(mp, M_TRYWAIT); \ mp->m_len = NFSMSIZ(mp); \ mp2->m_next = mp; \ mp2 = mp; \ diff --git a/sys/nfs/nfs_nqlease.c b/sys/nfs/nfs_nqlease.c index 66690101afe8..379db2cc4ccd 100644 --- a/sys/nfs/nfs_nqlease.c +++ b/sys/nfs/nfs_nqlease.c @@ -554,7 +554,7 @@ nqsrv_send_eviction(vp, lp, slp, nam, cred) * Record Mark. */ if (sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | (m->m_pkthdr.len - NFSX_UNSIGNED)); } @@ -932,7 +932,7 @@ nqnfs_vacated(vp, cred) RPCAUTH_UNIX, 5 * NFSX_UNSIGNED, (char *)0, 0, (char *)NULL, mreq, i, &mheadend, &xid); if (nmp->nm_sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | (m->m_pkthdr.len - NFSX_UNSIGNED)); } diff --git a/sys/nfs/nfs_serv.c b/sys/nfs/nfs_serv.c index 0334f741e110..648384e6d5c0 100644 --- a/sys/nfs/nfs_serv.c +++ b/sys/nfs/nfs_serv.c @@ -689,8 +689,8 @@ nfsrv_readlink(nfsd, slp, procp, mrq) len = 0; i = 0; while (len < NFS_MAXPATHLEN) { - MGET(mp, M_WAIT, MT_DATA); - MCLGET(mp, M_WAIT); + MGET(mp, M_TRYWAIT, MT_DATA); + MCLGET(mp, M_TRYWAIT); mp->m_len = NFSMSIZ(mp); if (len == 0) mp3 = mp2 = mp; @@ -940,8 +940,8 @@ nfsrv_read(nfsd, slp, procp, mrq) i++; } if (left > 0) { - MGET(m, M_WAIT, MT_DATA); - MCLGET(m, M_WAIT); + MGET(m, M_TRYWAIT, MT_DATA); + MCLGET(m, M_TRYWAIT); m->m_len = 0; m2->m_next = m; m2 = m; diff --git a/sys/nfs/nfs_socket.c b/sys/nfs/nfs_socket.c index f1ace4ea522b..fefeea8ac8eb 100644 --- a/sys/nfs/nfs_socket.c +++ b/sys/nfs/nfs_socket.c @@ -590,7 +590,7 @@ tryagain: goto tryagain; } while (rep->r_flags & R_MUSTRESEND) { - m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT); + m = m_copym(rep->r_mreq, 0, M_COPYALL, M_TRYWAIT); nfsstats.rpcretries++; error = nfs_send(so, rep->r_nmp->nm_nam, m, rep); if (error) { @@ -1014,7 +1014,7 @@ kerbauth: * For stream protocols, insert a Sun RPC Record Mark. */ if (nmp->nm_sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | (m->m_pkthdr.len - NFSX_UNSIGNED)); } @@ -1058,7 +1058,7 @@ tryagain: if (nmp->nm_soflags & PR_CONNREQUIRED) error = nfs_sndlock(rep); if (!error) { - m2 = m_copym(m, 0, M_COPYALL, M_WAIT); + m2 = m_copym(m, 0, M_COPYALL, M_TRYWAIT); error = nfs_send(nmp->nm_so, nmp->nm_nam, m2, rep); if (nmp->nm_soflags & PR_CONNREQUIRED) nfs_sndunlock(rep); @@ -1237,7 +1237,7 @@ nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) caddr_t bpos; struct mbuf *mb, *mb2; - MGETHDR(mreq, M_WAIT, MT_DATA); + MGETHDR(mreq, M_TRYWAIT, MT_DATA); mb = mreq; /* * If this is a big reply, use a cluster else @@ -1245,7 +1245,7 @@ nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) */ siz += RPC_REPLYSIZ; if ((max_hdr + siz) >= MINCLSIZE) { - MCLGET(mreq, M_WAIT); + MCLGET(mreq, M_TRYWAIT); } else mreq->m_data += max_hdr; tl = mtod(mreq, u_int32_t *); @@ -1686,9 +1686,9 @@ nfs_realign(pm, hsiz) while ((m = *pm) != NULL) { if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) { - MGET(n, M_WAIT, MT_DATA); + MGET(n, M_TRYWAIT, MT_DATA); if (m->m_len >= MINCLSIZE) { - MCLGET(n, M_WAIT); + MCLGET(n, M_TRYWAIT); } n->m_len = 0; break; @@ -1978,7 +1978,7 @@ nfs_msg(p, server, msg) * 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_WAIT from an nfsd. + * be called with M_TRYWAIT from an nfsd. */ void nfsrv_rcv(so, arg, waitflag) diff --git a/sys/nfs/nfs_srvcache.c b/sys/nfs/nfs_srvcache.c index 99fae0eac9d9..e7b10dd6b6dc 100644 --- a/sys/nfs/nfs_srvcache.c +++ b/sys/nfs/nfs_srvcache.c @@ -201,7 +201,7 @@ loop: } else if (rp->rc_flag & RC_REPMBUF) { nfsstats.srvcache_nonidemdonehits++; *repp = m_copym(rp->rc_reply, 0, M_COPYALL, - M_WAIT); + M_TRYWAIT); ret = RC_REPLY; } else { nfsstats.srvcache_idemdonehits++; @@ -313,7 +313,7 @@ loop: rp->rc_flag |= RC_REPSTATUS; } else { rp->rc_reply = m_copym(repmbuf, - 0, M_COPYALL, M_WAIT); + 0, M_COPYALL, M_TRYWAIT); rp->rc_flag |= RC_REPMBUF; } } diff --git a/sys/nfs/nfs_subs.c b/sys/nfs/nfs_subs.c index 95138c347c18..c7e6917e87dc 100644 --- a/sys/nfs/nfs_subs.c +++ b/sys/nfs/nfs_subs.c @@ -588,9 +588,9 @@ nfsm_reqh(vp, procid, hsiz, bposp) struct nfsmount *nmp; int nqflag; - MGET(mb, M_WAIT, MT_DATA); + MGET(mb, M_TRYWAIT, MT_DATA); if (hsiz >= MINCLSIZE) - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); mb->m_len = 0; bpos = mtod(mb, caddr_t); @@ -646,9 +646,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, int siz, grpsiz, authsiz; authsiz = nfsm_rndup(auth_len); - MGETHDR(mb, M_WAIT, MT_DATA); + MGETHDR(mb, M_TRYWAIT, MT_DATA); if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) { - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) { MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED); } else { @@ -711,9 +711,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = auth_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -744,9 +744,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = verf_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -887,9 +887,9 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) while (left > 0) { mlen = M_TRAILINGSPACE(mp); if (mlen == 0) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); if (clflg) - MCLGET(mp, M_WAIT); + MCLGET(mp, M_TRYWAIT); mp->m_len = 0; mp2->m_next = mp; mp2 = mp; @@ -919,7 +919,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) } if (rem > 0) { if (rem > M_TRAILINGSPACE(mp)) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); mp->m_len = 0; mp2->m_next = mp; } @@ -968,7 +968,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) } else if (siz > MHLEN) { panic("nfs S too big"); } else { - MGET(mp2, M_WAIT, MT_DATA); + MGET(mp2, M_TRYWAIT, MT_DATA); mp2->m_next = mp->m_next; mp->m_next = mp2; mp->m_len -= left; @@ -1061,9 +1061,9 @@ nfsm_strtmbuf(mb, bpos, cp, siz) } /* Loop around adding mbufs */ while (siz > 0) { - MGET(m1, M_WAIT, MT_DATA); + MGET(m1, M_TRYWAIT, MT_DATA); if (siz > MLEN) - MCLGET(m1, M_WAIT); + MCLGET(m1, M_TRYWAIT); m1->m_len = NFSMSIZ(m1); m2->m_next = m1; m2 = m1; diff --git a/sys/nfs/nfs_syscalls.c b/sys/nfs/nfs_syscalls.c index d1a8ead7cdc8..4eb5c86eaf73 100644 --- a/sys/nfs/nfs_syscalls.c +++ b/sys/nfs/nfs_syscalls.c @@ -480,7 +480,7 @@ nfssvc_nfsd(nsd, argp, p) slp->ns_flag &= ~SLP_NEEDQ; (void) nfs_slplock(slp, 1); nfsrv_rcv(slp->ns_so, (caddr_t)slp, - M_WAIT); + M_TRYWAIT); nfs_slpunlock(slp); } error = nfsrv_dorec(slp, nfsd, &nd); @@ -632,7 +632,7 @@ nfssvc_nfsd(nsd, argp, p) * Record Mark. */ if (sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | siz); } if (slp->ns_so->so_proto->pr_flags & PR_CONNREQUIRED) diff --git a/sys/nfs/nfsm_subs.h b/sys/nfs/nfsm_subs.h index 0990fe4e0121..d58ef15a6c2a 100644 --- a/sys/nfs/nfsm_subs.h +++ b/sys/nfs/nfsm_subs.h @@ -94,7 +94,7 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, #define nfsm_build(a,c,s) \ do { \ if ((s) > M_TRAILINGSPACE(mb)) { \ - MGET(mb2, M_WAIT, MT_DATA); \ + MGET(mb2, M_TRYWAIT, MT_DATA); \ if ((s) > MLEN) \ panic("build > MLEN"); \ mb->m_next = mb2; \ @@ -491,8 +491,8 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, if (bp >= be) { \ if (mp == mb) \ mp->m_len += bp-bpos; \ - MGET(mp, M_WAIT, MT_DATA); \ - MCLGET(mp, M_WAIT); \ + MGET(mp, M_TRYWAIT, MT_DATA); \ + MCLGET(mp, M_TRYWAIT); \ mp->m_len = NFSMSIZ(mp); \ mp2->m_next = mp; \ mp2 = mp; \ diff --git a/sys/nfsclient/bootp_subr.c b/sys/nfsclient/bootp_subr.c index 80375d79c284..9101ba749642 100644 --- a/sys/nfsclient/bootp_subr.c +++ b/sys/nfsclient/bootp_subr.c @@ -1755,7 +1755,7 @@ md_lookup_swap(struct sockaddr_in *mdsin, /* mountd server address */ u_int32_t v3[21]; } fattribs; - m = m_get(M_WAIT,MT_DATA); + m = m_get(M_TRYWAIT,MT_DATA); if (m == NULL) return ENOBUFS; diff --git a/sys/nfsclient/krpc_subr.c b/sys/nfsclient/krpc_subr.c index 054a2783a7d4..b7b1d2c28ebe 100644 --- a/sys/nfsclient/krpc_subr.c +++ b/sys/nfsclient/krpc_subr.c @@ -149,7 +149,7 @@ krpc_portmap(sin, prog, vers, portp, procp) return 0; } - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); if (m == NULL) return ENOBUFS; sdata = mtod(m, struct sdata *); @@ -275,7 +275,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) /* * Prepend RPC message header. */ - mhead = m_gethdr(M_WAIT, MT_DATA); + mhead = m_gethdr(M_TRYWAIT, MT_DATA); mhead->m_next = *data; call = mtod(mhead, struct rpc_call *); mhead->m_len = sizeof(*call); @@ -315,7 +315,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) timo = 0; for (;;) { /* Send RPC request (or re-send). */ - m = m_copym(mhead, 0, M_COPYALL, M_WAIT); + m = m_copym(mhead, 0, M_COPYALL, M_TRYWAIT); if (m == NULL) { error = ENOBUFS; goto out; @@ -471,9 +471,9 @@ xdr_string_encode(str, len) if (mlen > MCLBYTES) /* If too big, we just can't do it. */ return (NULL); - m = m_get(M_WAIT, MT_DATA); + m = m_get(M_TRYWAIT, MT_DATA); if (mlen > MLEN) { - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { (void) m_free(m); /* There can be only one. */ return (NULL); diff --git a/sys/nfsclient/nfs_nfsiod.c b/sys/nfsclient/nfs_nfsiod.c index d1a8ead7cdc8..4eb5c86eaf73 100644 --- a/sys/nfsclient/nfs_nfsiod.c +++ b/sys/nfsclient/nfs_nfsiod.c @@ -480,7 +480,7 @@ nfssvc_nfsd(nsd, argp, p) slp->ns_flag &= ~SLP_NEEDQ; (void) nfs_slplock(slp, 1); nfsrv_rcv(slp->ns_so, (caddr_t)slp, - M_WAIT); + M_TRYWAIT); nfs_slpunlock(slp); } error = nfsrv_dorec(slp, nfsd, &nd); @@ -632,7 +632,7 @@ nfssvc_nfsd(nsd, argp, p) * Record Mark. */ if (sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | siz); } if (slp->ns_so->so_proto->pr_flags & PR_CONNREQUIRED) diff --git a/sys/nfsclient/nfs_socket.c b/sys/nfsclient/nfs_socket.c index f1ace4ea522b..fefeea8ac8eb 100644 --- a/sys/nfsclient/nfs_socket.c +++ b/sys/nfsclient/nfs_socket.c @@ -590,7 +590,7 @@ tryagain: goto tryagain; } while (rep->r_flags & R_MUSTRESEND) { - m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT); + m = m_copym(rep->r_mreq, 0, M_COPYALL, M_TRYWAIT); nfsstats.rpcretries++; error = nfs_send(so, rep->r_nmp->nm_nam, m, rep); if (error) { @@ -1014,7 +1014,7 @@ kerbauth: * For stream protocols, insert a Sun RPC Record Mark. */ if (nmp->nm_sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | (m->m_pkthdr.len - NFSX_UNSIGNED)); } @@ -1058,7 +1058,7 @@ tryagain: if (nmp->nm_soflags & PR_CONNREQUIRED) error = nfs_sndlock(rep); if (!error) { - m2 = m_copym(m, 0, M_COPYALL, M_WAIT); + m2 = m_copym(m, 0, M_COPYALL, M_TRYWAIT); error = nfs_send(nmp->nm_so, nmp->nm_nam, m2, rep); if (nmp->nm_soflags & PR_CONNREQUIRED) nfs_sndunlock(rep); @@ -1237,7 +1237,7 @@ nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) caddr_t bpos; struct mbuf *mb, *mb2; - MGETHDR(mreq, M_WAIT, MT_DATA); + MGETHDR(mreq, M_TRYWAIT, MT_DATA); mb = mreq; /* * If this is a big reply, use a cluster else @@ -1245,7 +1245,7 @@ nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) */ siz += RPC_REPLYSIZ; if ((max_hdr + siz) >= MINCLSIZE) { - MCLGET(mreq, M_WAIT); + MCLGET(mreq, M_TRYWAIT); } else mreq->m_data += max_hdr; tl = mtod(mreq, u_int32_t *); @@ -1686,9 +1686,9 @@ nfs_realign(pm, hsiz) while ((m = *pm) != NULL) { if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) { - MGET(n, M_WAIT, MT_DATA); + MGET(n, M_TRYWAIT, MT_DATA); if (m->m_len >= MINCLSIZE) { - MCLGET(n, M_WAIT); + MCLGET(n, M_TRYWAIT); } n->m_len = 0; break; @@ -1978,7 +1978,7 @@ nfs_msg(p, server, msg) * 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_WAIT from an nfsd. + * be called with M_TRYWAIT from an nfsd. */ void nfsrv_rcv(so, arg, waitflag) diff --git a/sys/nfsclient/nfs_subs.c b/sys/nfsclient/nfs_subs.c index 95138c347c18..c7e6917e87dc 100644 --- a/sys/nfsclient/nfs_subs.c +++ b/sys/nfsclient/nfs_subs.c @@ -588,9 +588,9 @@ nfsm_reqh(vp, procid, hsiz, bposp) struct nfsmount *nmp; int nqflag; - MGET(mb, M_WAIT, MT_DATA); + MGET(mb, M_TRYWAIT, MT_DATA); if (hsiz >= MINCLSIZE) - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); mb->m_len = 0; bpos = mtod(mb, caddr_t); @@ -646,9 +646,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, int siz, grpsiz, authsiz; authsiz = nfsm_rndup(auth_len); - MGETHDR(mb, M_WAIT, MT_DATA); + MGETHDR(mb, M_TRYWAIT, MT_DATA); if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) { - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) { MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED); } else { @@ -711,9 +711,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = auth_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -744,9 +744,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = verf_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -887,9 +887,9 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) while (left > 0) { mlen = M_TRAILINGSPACE(mp); if (mlen == 0) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); if (clflg) - MCLGET(mp, M_WAIT); + MCLGET(mp, M_TRYWAIT); mp->m_len = 0; mp2->m_next = mp; mp2 = mp; @@ -919,7 +919,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) } if (rem > 0) { if (rem > M_TRAILINGSPACE(mp)) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); mp->m_len = 0; mp2->m_next = mp; } @@ -968,7 +968,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) } else if (siz > MHLEN) { panic("nfs S too big"); } else { - MGET(mp2, M_WAIT, MT_DATA); + MGET(mp2, M_TRYWAIT, MT_DATA); mp2->m_next = mp->m_next; mp->m_next = mp2; mp->m_len -= left; @@ -1061,9 +1061,9 @@ nfsm_strtmbuf(mb, bpos, cp, siz) } /* Loop around adding mbufs */ while (siz > 0) { - MGET(m1, M_WAIT, MT_DATA); + MGET(m1, M_TRYWAIT, MT_DATA); if (siz > MLEN) - MCLGET(m1, M_WAIT); + MCLGET(m1, M_TRYWAIT); m1->m_len = NFSMSIZ(m1); m2->m_next = m1; m2 = m1; diff --git a/sys/nfsclient/nfsm_subs.h b/sys/nfsclient/nfsm_subs.h index 0990fe4e0121..d58ef15a6c2a 100644 --- a/sys/nfsclient/nfsm_subs.h +++ b/sys/nfsclient/nfsm_subs.h @@ -94,7 +94,7 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, #define nfsm_build(a,c,s) \ do { \ if ((s) > M_TRAILINGSPACE(mb)) { \ - MGET(mb2, M_WAIT, MT_DATA); \ + MGET(mb2, M_TRYWAIT, MT_DATA); \ if ((s) > MLEN) \ panic("build > MLEN"); \ mb->m_next = mb2; \ @@ -491,8 +491,8 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, if (bp >= be) { \ if (mp == mb) \ mp->m_len += bp-bpos; \ - MGET(mp, M_WAIT, MT_DATA); \ - MCLGET(mp, M_WAIT); \ + MGET(mp, M_TRYWAIT, MT_DATA); \ + MCLGET(mp, M_TRYWAIT); \ mp->m_len = NFSMSIZ(mp); \ mp2->m_next = mp; \ mp2 = mp; \ diff --git a/sys/nfsserver/nfs_serv.c b/sys/nfsserver/nfs_serv.c index 0334f741e110..648384e6d5c0 100644 --- a/sys/nfsserver/nfs_serv.c +++ b/sys/nfsserver/nfs_serv.c @@ -689,8 +689,8 @@ nfsrv_readlink(nfsd, slp, procp, mrq) len = 0; i = 0; while (len < NFS_MAXPATHLEN) { - MGET(mp, M_WAIT, MT_DATA); - MCLGET(mp, M_WAIT); + MGET(mp, M_TRYWAIT, MT_DATA); + MCLGET(mp, M_TRYWAIT); mp->m_len = NFSMSIZ(mp); if (len == 0) mp3 = mp2 = mp; @@ -940,8 +940,8 @@ nfsrv_read(nfsd, slp, procp, mrq) i++; } if (left > 0) { - MGET(m, M_WAIT, MT_DATA); - MCLGET(m, M_WAIT); + MGET(m, M_TRYWAIT, MT_DATA); + MCLGET(m, M_TRYWAIT); m->m_len = 0; m2->m_next = m; m2 = m; diff --git a/sys/nfsserver/nfs_srvcache.c b/sys/nfsserver/nfs_srvcache.c index 99fae0eac9d9..e7b10dd6b6dc 100644 --- a/sys/nfsserver/nfs_srvcache.c +++ b/sys/nfsserver/nfs_srvcache.c @@ -201,7 +201,7 @@ loop: } else if (rp->rc_flag & RC_REPMBUF) { nfsstats.srvcache_nonidemdonehits++; *repp = m_copym(rp->rc_reply, 0, M_COPYALL, - M_WAIT); + M_TRYWAIT); ret = RC_REPLY; } else { nfsstats.srvcache_idemdonehits++; @@ -313,7 +313,7 @@ loop: rp->rc_flag |= RC_REPSTATUS; } else { rp->rc_reply = m_copym(repmbuf, - 0, M_COPYALL, M_WAIT); + 0, M_COPYALL, M_TRYWAIT); rp->rc_flag |= RC_REPMBUF; } } diff --git a/sys/nfsserver/nfs_srvsock.c b/sys/nfsserver/nfs_srvsock.c index f1ace4ea522b..fefeea8ac8eb 100644 --- a/sys/nfsserver/nfs_srvsock.c +++ b/sys/nfsserver/nfs_srvsock.c @@ -590,7 +590,7 @@ tryagain: goto tryagain; } while (rep->r_flags & R_MUSTRESEND) { - m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT); + m = m_copym(rep->r_mreq, 0, M_COPYALL, M_TRYWAIT); nfsstats.rpcretries++; error = nfs_send(so, rep->r_nmp->nm_nam, m, rep); if (error) { @@ -1014,7 +1014,7 @@ kerbauth: * For stream protocols, insert a Sun RPC Record Mark. */ if (nmp->nm_sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | (m->m_pkthdr.len - NFSX_UNSIGNED)); } @@ -1058,7 +1058,7 @@ tryagain: if (nmp->nm_soflags & PR_CONNREQUIRED) error = nfs_sndlock(rep); if (!error) { - m2 = m_copym(m, 0, M_COPYALL, M_WAIT); + m2 = m_copym(m, 0, M_COPYALL, M_TRYWAIT); error = nfs_send(nmp->nm_so, nmp->nm_nam, m2, rep); if (nmp->nm_soflags & PR_CONNREQUIRED) nfs_sndunlock(rep); @@ -1237,7 +1237,7 @@ nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) caddr_t bpos; struct mbuf *mb, *mb2; - MGETHDR(mreq, M_WAIT, MT_DATA); + MGETHDR(mreq, M_TRYWAIT, MT_DATA); mb = mreq; /* * If this is a big reply, use a cluster else @@ -1245,7 +1245,7 @@ nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) */ siz += RPC_REPLYSIZ; if ((max_hdr + siz) >= MINCLSIZE) { - MCLGET(mreq, M_WAIT); + MCLGET(mreq, M_TRYWAIT); } else mreq->m_data += max_hdr; tl = mtod(mreq, u_int32_t *); @@ -1686,9 +1686,9 @@ nfs_realign(pm, hsiz) while ((m = *pm) != NULL) { if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) { - MGET(n, M_WAIT, MT_DATA); + MGET(n, M_TRYWAIT, MT_DATA); if (m->m_len >= MINCLSIZE) { - MCLGET(n, M_WAIT); + MCLGET(n, M_TRYWAIT); } n->m_len = 0; break; @@ -1978,7 +1978,7 @@ nfs_msg(p, server, msg) * 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_WAIT from an nfsd. + * be called with M_TRYWAIT from an nfsd. */ void nfsrv_rcv(so, arg, waitflag) diff --git a/sys/nfsserver/nfs_srvsubs.c b/sys/nfsserver/nfs_srvsubs.c index 95138c347c18..c7e6917e87dc 100644 --- a/sys/nfsserver/nfs_srvsubs.c +++ b/sys/nfsserver/nfs_srvsubs.c @@ -588,9 +588,9 @@ nfsm_reqh(vp, procid, hsiz, bposp) struct nfsmount *nmp; int nqflag; - MGET(mb, M_WAIT, MT_DATA); + MGET(mb, M_TRYWAIT, MT_DATA); if (hsiz >= MINCLSIZE) - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); mb->m_len = 0; bpos = mtod(mb, caddr_t); @@ -646,9 +646,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, int siz, grpsiz, authsiz; authsiz = nfsm_rndup(auth_len); - MGETHDR(mb, M_WAIT, MT_DATA); + MGETHDR(mb, M_TRYWAIT, MT_DATA); if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) { - MCLGET(mb, M_WAIT); + MCLGET(mb, M_TRYWAIT); } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) { MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED); } else { @@ -711,9 +711,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = auth_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -744,9 +744,9 @@ nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len, siz = verf_len; while (siz > 0) { if (M_TRAILINGSPACE(mb) == 0) { - MGET(mb2, M_WAIT, MT_DATA); + MGET(mb2, M_TRYWAIT, MT_DATA); if (siz >= MINCLSIZE) - MCLGET(mb2, M_WAIT); + MCLGET(mb2, M_TRYWAIT); mb->m_next = mb2; mb = mb2; mb->m_len = 0; @@ -887,9 +887,9 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) while (left > 0) { mlen = M_TRAILINGSPACE(mp); if (mlen == 0) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); if (clflg) - MCLGET(mp, M_WAIT); + MCLGET(mp, M_TRYWAIT); mp->m_len = 0; mp2->m_next = mp; mp2 = mp; @@ -919,7 +919,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos) } if (rem > 0) { if (rem > M_TRAILINGSPACE(mp)) { - MGET(mp, M_WAIT, MT_DATA); + MGET(mp, M_TRYWAIT, MT_DATA); mp->m_len = 0; mp2->m_next = mp; } @@ -968,7 +968,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) } else if (siz > MHLEN) { panic("nfs S too big"); } else { - MGET(mp2, M_WAIT, MT_DATA); + MGET(mp2, M_TRYWAIT, MT_DATA); mp2->m_next = mp->m_next; mp->m_next = mp2; mp->m_len -= left; @@ -1061,9 +1061,9 @@ nfsm_strtmbuf(mb, bpos, cp, siz) } /* Loop around adding mbufs */ while (siz > 0) { - MGET(m1, M_WAIT, MT_DATA); + MGET(m1, M_TRYWAIT, MT_DATA); if (siz > MLEN) - MCLGET(m1, M_WAIT); + MCLGET(m1, M_TRYWAIT); m1->m_len = NFSMSIZ(m1); m2->m_next = m1; m2 = m1; diff --git a/sys/nfsserver/nfs_syscalls.c b/sys/nfsserver/nfs_syscalls.c index d1a8ead7cdc8..4eb5c86eaf73 100644 --- a/sys/nfsserver/nfs_syscalls.c +++ b/sys/nfsserver/nfs_syscalls.c @@ -480,7 +480,7 @@ nfssvc_nfsd(nsd, argp, p) slp->ns_flag &= ~SLP_NEEDQ; (void) nfs_slplock(slp, 1); nfsrv_rcv(slp->ns_so, (caddr_t)slp, - M_WAIT); + M_TRYWAIT); nfs_slpunlock(slp); } error = nfsrv_dorec(slp, nfsd, &nd); @@ -632,7 +632,7 @@ nfssvc_nfsd(nsd, argp, p) * Record Mark. */ if (sotype == SOCK_STREAM) { - M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); + M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT); *mtod(m, u_int32_t *) = htonl(0x80000000 | siz); } if (slp->ns_so->so_proto->pr_flags & PR_CONNREQUIRED) diff --git a/sys/nfsserver/nfsm_subs.h b/sys/nfsserver/nfsm_subs.h index 0990fe4e0121..d58ef15a6c2a 100644 --- a/sys/nfsserver/nfsm_subs.h +++ b/sys/nfsserver/nfsm_subs.h @@ -94,7 +94,7 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, #define nfsm_build(a,c,s) \ do { \ if ((s) > M_TRAILINGSPACE(mb)) { \ - MGET(mb2, M_WAIT, MT_DATA); \ + MGET(mb2, M_TRYWAIT, MT_DATA); \ if ((s) > MLEN) \ panic("build > MLEN"); \ mb->m_next = mb2; \ @@ -491,8 +491,8 @@ struct mbuf *nfsm_rpchead __P((struct ucred *cr, int nmflag, int procid, if (bp >= be) { \ if (mp == mb) \ mp->m_len += bp-bpos; \ - MGET(mp, M_WAIT, MT_DATA); \ - MCLGET(mp, M_WAIT); \ + MGET(mp, M_TRYWAIT, MT_DATA); \ + MCLGET(mp, M_TRYWAIT); \ mp->m_len = NFSMSIZ(mp); \ mp2->m_next = mp; \ mp2 = mp; \ diff --git a/sys/pci/if_mn.c b/sys/pci/if_mn.c index 8028389c2159..e3af17164ad0 100644 --- a/sys/pci/if_mn.c +++ b/sys/pci/if_mn.c @@ -615,7 +615,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_WAIT, MT_DATA); + MGETHDR(m, M_TRYWAIT, MT_DATA); if (m == NULL) return ENOBUFS; m->m_pkthdr.len = 0; @@ -632,12 +632,12 @@ ngmn_connect(hook_p hook) dp = mn_alloc_desc(); m = NULL; - MGETHDR(m, M_WAIT, MT_DATA); + MGETHDR(m, M_TRYWAIT, MT_DATA); if (m == NULL) { mn_free_desc(dp); return (ENOBUFS); } - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { mn_free_desc(dp); m_freem(m); @@ -655,13 +655,13 @@ ngmn_connect(hook_p hook) dp2 = dp; dp = mn_alloc_desc(); m = NULL; - MGETHDR(m, M_WAIT, MT_DATA); + MGETHDR(m, M_TRYWAIT, MT_DATA); if (m == NULL) { mn_free_desc(dp); m_freem(m); return (ENOBUFS); } - MCLGET(m, M_WAIT); + MCLGET(m, M_TRYWAIT); if ((m->m_flags & M_EXT) == 0) { mn_free_desc(dp); m_freem(m); diff --git a/sys/sys/mbuf.h b/sys/sys/mbuf.h index f6cf06ea83d7..1643404b37af 100644 --- a/sys/sys/mbuf.h +++ b/sys/sys/mbuf.h @@ -227,7 +227,8 @@ struct mbstat { /* flags to m_get/MGET */ #define M_DONTWAIT 1 -#define M_WAIT 0 +#define M_TRYWAIT 0 +#define M_WAIT M_TRYWAIT /* XXX: Deprecated. */ /* * Normal mbuf clusters are normally treated as character arrays @@ -362,7 +363,7 @@ struct mcntfree_lst { mmbfree.m_head = (m_mget)->m_next; \ mbtypes[MT_FREE]--; \ } else { \ - if ((m_get_how) == M_WAIT) \ + if ((m_get_how) == M_TRYWAIT) \ (m_mget) = m_mballoc_wait(); \ } \ } while (0) @@ -429,7 +430,7 @@ struct mcntfree_lst { mbstat.m_clfree--; \ mclfree.m_head = ((union mcluster *)_mp)->mcl_next; \ } else { \ - if (_mhow == M_WAIT) \ + if (_mhow == M_TRYWAIT) \ _mp = m_clalloc_wait(); \ } \ (p) = _mp; \ @@ -460,7 +461,7 @@ struct mcntfree_lst { #define MEXTADD(m, buf, size, free, args, flags, type) do { \ struct mbuf *_mm = (m); \ \ - MEXT_INIT_REF(_mm, M_WAIT); \ + MEXT_INIT_REF(_mm, M_TRYWAIT); \ if (_mm->m_ext.ref_cnt != NULL) { \ _mm->m_flags |= (M_EXT | (flags)); \ _mm->m_ext.ext_buf = (caddr_t)(buf); \ @@ -588,8 +589,8 @@ struct mcntfree_lst { /* * Arrange to prepend space of size plen to mbuf m. * If a new mbuf must be allocated, how specifies whether to wait. - * If how is M_DONTWAIT and allocation fails, the original mbuf chain - * is freed and m is set to NULL. + * If the allocation fails, the original mbuf chain is freed and m is + * set to NULL. */ #define M_PREPEND(m, plen, how) do { \ struct mbuf **_mmp = &(m); \