kernel: Move us to using M_NOWAIT and M_WAITOK for mbuf functions.
authorSascha Wildner <saw@online.de>
Thu, 19 Feb 2015 00:16:23 +0000 (01:16 +0100)
committerSascha Wildner <saw@online.de>
Thu, 19 Feb 2015 00:39:08 +0000 (01:39 +0100)
The main reason is that our having to use the MB_WAIT and MB_DONTWAIT
flags was a recurring issue when porting drivers from FreeBSD because
it tended to get forgotten and the code would compile anyway with the
wrong constants. And since MB_WAIT and MB_DONTWAIT ended up as ocflags
for an objcache_get() or objcache_reclaimlist call (which use M_WAITOK
and M_NOWAIT), it was just one big converting back and forth with some
sanitization in between.

This commit allows M_* again for the mbuf functions and keeps the
sanitizing as it was before: when M_WAITOK is among the passed flags,
objcache functions will be called with M_WAITOK and when it is absent,
they will be called with M_NOWAIT. All other flags are scrubbed by the
MB_OCFLAG() macro which does the same as the former MBTOM().

Approved-by: dillon
257 files changed:
share/man/man9/mbuf.9
sys/bus/firewire/fwohci.c
sys/bus/u4b/net/if_axe.c
sys/bus/u4b/net/if_axge.c
sys/bus/u4b/net/if_urndis.c
sys/bus/u4b/net/usb_ethernet.c
sys/bus/u4b/wlan/if_rum.c
sys/bus/u4b/wlan/if_run.c
sys/bus/u4b/wlan/if_urtwn.c
sys/dev/crypto/hifn/hifn7751.c
sys/dev/crypto/safe/safe.c
sys/dev/crypto/ubsec/ubsec.c
sys/dev/disk/iscsi/initiator/isc_soc.c
sys/dev/misc/musycc/musycc.c
sys/dev/netif/acx/if_acx.c
sys/dev/netif/age/if_age.c
sys/dev/netif/alc/if_alc.c
sys/dev/netif/ale/if_ale.c
sys/dev/netif/an/if_an.c
sys/dev/netif/ar/if_ar.c
sys/dev/netif/ath/ath/if_ath_rx.c
sys/dev/netif/ath/ath/if_ath_rx_edma.c
sys/dev/netif/bce/if_bce.c
sys/dev/netif/bfe/if_bfe.c
sys/dev/netif/bge/if_bge.c
sys/dev/netif/bnx/if_bnx.c
sys/dev/netif/bwi/if_bwi.c
sys/dev/netif/bwn/bwn/if_bwn.c
sys/dev/netif/cs/if_cs.c
sys/dev/netif/dc/if_dc.c
sys/dev/netif/de/if_de.c
sys/dev/netif/ed/if_ed.c
sys/dev/netif/em/if_em.c
sys/dev/netif/emx/if_emx.c
sys/dev/netif/ep/if_ep.c
sys/dev/netif/et/if_et.c
sys/dev/netif/ex/if_ex.c
sys/dev/netif/fe/if_fe.c
sys/dev/netif/fwe/if_fwe.c
sys/dev/netif/fxp/if_fxp.c
sys/dev/netif/igb/if_igb.c
sys/dev/netif/iwi/if_iwi.c
sys/dev/netif/iwl/iwl2100.c
sys/dev/netif/iwn/if_iwn.c
sys/dev/netif/ix/if_ix.c
sys/dev/netif/jme/if_jme.c
sys/dev/netif/lge/if_lge.c
sys/dev/netif/lnc/lance.c
sys/dev/netif/mn/if_mn.c
sys/dev/netif/msk/if_msk.c
sys/dev/netif/mxge/if_mxge.c
sys/dev/netif/my/if_my.c
sys/dev/netif/ndis/if_ndis.c
sys/dev/netif/nfe/if_nfe.c
sys/dev/netif/nge/if_nge.c
sys/dev/netif/oce/oce_if.c
sys/dev/netif/pcn/if_pcn.c
sys/dev/netif/ral/rt2560.c
sys/dev/netif/ral/rt2661.c
sys/dev/netif/ral/rt2860.c
sys/dev/netif/re/if_re.c
sys/dev/netif/rl/if_rl.c
sys/dev/netif/rtw/rtw.c
sys/dev/netif/sbni/if_sbni.c
sys/dev/netif/sbsh/if_sbsh.c
sys/dev/netif/sf/if_sf.c
sys/dev/netif/sis/if_sis.c
sys/dev/netif/sk/if_sk.c
sys/dev/netif/sln/if_sln.c
sys/dev/netif/sn/if_sn.c
sys/dev/netif/sr/if_sr.c
sys/dev/netif/ste/if_ste.c
sys/dev/netif/stge/if_stge.c
sys/dev/netif/ti/if_ti.c
sys/dev/netif/tl/if_tl.c
sys/dev/netif/tx/if_tx.c
sys/dev/netif/txp/if_txp.c
sys/dev/netif/vge/if_vge.c
sys/dev/netif/vr/if_vr.c
sys/dev/netif/vx/if_vx.c
sys/dev/netif/wb/if_wb.c
sys/dev/netif/wi/if_wi.c
sys/dev/netif/wpi/if_wpi.c
sys/dev/netif/xe/if_xe.c
sys/dev/netif/xl/if_xl.c
sys/dev/virtual/virtio/net/if_vtnet.c
sys/dev/virtual/vkernel/net/if_vke.c
sys/emulation/43bsd/43bsd_socket.c
sys/emulation/linux/linux_socket.c
sys/emulation/ndis/kern_ndis.c
sys/kern/libmchain/subr_mchain.c
sys/kern/subr_busdma.c
sys/kern/uipc_mbuf.c
sys/kern/uipc_mbuf2.c
sys/kern/uipc_sockbuf.c
sys/kern/uipc_socket.c
sys/kern/uipc_socket2.c
sys/kern/uipc_syscalls.c
sys/kern/uipc_usrreq.c
sys/net/bpf.c
sys/net/bridge/bridgestp.c
sys/net/bridge/if_bridge.c
sys/net/bsd_comp.c
sys/net/gre/if_gre.c
sys/net/if_ethersubr.c
sys/net/if_loop.c
sys/net/ip6fw/ip6_fw.c
sys/net/ip_mroute/ip_mroute.c
sys/net/ipfw/ip_fw2.c
sys/net/lagg/ieee8023ad_lacp.c
sys/net/netmap/netmap_generic.c
sys/net/pf/pf.c
sys/net/pf/pf_norm.c
sys/net/ppp/if_ppp.c
sys/net/ppp_layer/ppp_deflate.c
sys/net/ppp_layer/ppp_tty.c
sys/net/raw_cb.c
sys/net/raw_usrreq.c
sys/net/route.c
sys/net/rtsock.c
sys/net/sl/if_sl.c
sys/net/sppp/if_spppsubr.c
sys/net/stf/if_stf.c
sys/net/tap/if_tap.c
sys/net/tun/if_tun.c
sys/net/vlan/if_vlan_ether.c
sys/netbt/hci_link.c
sys/netbt/hci_socket.c
sys/netbt/hci_unit.c
sys/netbt/l2cap_signal.c
sys/netbt/l2cap_socket.c
sys/netbt/l2cap_upper.c
sys/netbt/rfcomm_dlc.c
sys/netbt/rfcomm_session.c
sys/netbt/rfcomm_socket.c
sys/netbt/sco_socket.c
sys/netbt/sco_upper.c
sys/netgraph/UI/ng_UI.c
sys/netgraph/bridge/ng_bridge.c
sys/netgraph/cisco/ng_cisco.c
sys/netgraph/frame_relay/ng_frame_relay.c
sys/netgraph/l2tp/ng_l2tp.c
sys/netgraph/lmi/ng_lmi.c
sys/netgraph/ppp/ng_ppp.c
sys/netgraph/pppoe/ng_pppoe.c
sys/netgraph/pptpgre/ng_pptpgre.c
sys/netgraph/rfc1490/ng_rfc1490.c
sys/netgraph/tee/ng_tee.c
sys/netgraph/tty/ng_tty.c
sys/netgraph/vjc/ng_vjc.c
sys/netgraph7/UI/ng_UI.c
sys/netgraph7/bluetooth/drivers/bt3c/ng_bt3c_pccard.c
sys/netgraph7/bluetooth/drivers/h4/ng_h4.c
sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c
sys/netgraph7/bluetooth/hci/ng_hci_cmds.c
sys/netgraph7/bluetooth/hci/ng_hci_evnt.c
sys/netgraph7/bluetooth/hci/ng_hci_misc.c
sys/netgraph7/bluetooth/hci/ng_hci_ulpi.c
sys/netgraph7/bluetooth/l2cap/ng_l2cap_cmds.h
sys/netgraph7/bluetooth/l2cap/ng_l2cap_evnt.c
sys/netgraph7/bluetooth/l2cap/ng_l2cap_llpi.c
sys/netgraph7/bluetooth/l2cap/ng_l2cap_misc.c
sys/netgraph7/bluetooth/socket/ng_btsocket_hci_raw.c
sys/netgraph7/bluetooth/socket/ng_btsocket_l2cap.c
sys/netgraph7/bluetooth/socket/ng_btsocket_rfcomm.c
sys/netgraph7/bridge/ng_bridge.c
sys/netgraph7/cisco/ng_cisco.c
sys/netgraph7/frame_relay/ng_frame_relay.c
sys/netgraph7/hub/ng_hub.c
sys/netgraph7/iface/ng_iface.c
sys/netgraph7/ksocket/ng_ksocket.c
sys/netgraph7/l2tp/ng_l2tp.c
sys/netgraph7/lmi/ng_lmi.c
sys/netgraph7/mppc/ng_mppc.c
sys/netgraph7/netflow/netflow.c
sys/netgraph7/ng_device.c
sys/netgraph7/ng_gif.c
sys/netgraph7/ng_gif_demux.c
sys/netgraph7/ng_ipfw.c
sys/netgraph7/ng_source.c
sys/netgraph7/ng_tag.c
sys/netgraph7/ng_vlan.c
sys/netgraph7/one2many/ng_one2many.c
sys/netgraph7/ppp/ng_ppp.c
sys/netgraph7/pppoe/ng_pppoe.c
sys/netgraph7/pptpgre/ng_pptpgre.c
sys/netgraph7/rfc1490/ng_rfc1490.c
sys/netgraph7/tee/ng_tee.c
sys/netgraph7/tty/ng_tty.c
sys/netgraph7/vjc/ng_vjc.c
sys/netinet/if_ether.c
sys/netinet/igmp.c
sys/netinet/in_gif.c
sys/netinet/ip_carp.c
sys/netinet/ip_divert.c
sys/netinet/ip_encap.c
sys/netinet/ip_icmp.c
sys/netinet/ip_input.c
sys/netinet/ip_output.c
sys/netinet/raw_ip.c
sys/netinet/tcp_output.c
sys/netinet/tcp_subr.c
sys/netinet/tcp_syncache.c
sys/netinet/udp_usrreq.c
sys/netinet6/ah_core.c
sys/netinet6/ah_input.c
sys/netinet6/ah_output.c
sys/netinet6/esp_core.c
sys/netinet6/esp_input.c
sys/netinet6/esp_output.c
sys/netinet6/frag6.c
sys/netinet6/icmp6.c
sys/netinet6/in6_gif.c
sys/netinet6/ip6_input.c
sys/netinet6/ip6_mroute.c
sys/netinet6/ip6_output.c
sys/netinet6/ipcomp_core.c
sys/netinet6/ipcomp_output.c
sys/netinet6/ipsec.c
sys/netinet6/mld6.c
sys/netinet6/nd6_nbr.c
sys/netinet6/raw_ip6.c
sys/netinet6/udp6_output.c
sys/netproto/802_11/README.DRAGONFLY
sys/netproto/802_11/wlan/ieee80211_dragonfly.c
sys/netproto/802_11/wlan/ieee80211_hostap.c
sys/netproto/802_11/wlan/ieee80211_ht.c
sys/netproto/802_11/wlan/ieee80211_hwmp.c
sys/netproto/802_11/wlan/ieee80211_input.c
sys/netproto/802_11/wlan/ieee80211_mesh.c
sys/netproto/802_11/wlan/ieee80211_output.c
sys/netproto/802_11/wlan/ieee80211_superg.c
sys/netproto/802_11/wlan/ieee80211_wds.c
sys/netproto/802_11/wlan_ccmp/ieee80211_crypto_ccmp.c
sys/netproto/802_11/wlan_tkip/ieee80211_crypto_tkip.c
sys/netproto/802_11/wlan_wep/ieee80211_crypto_wep.c
sys/netproto/ipsec/ipsec_input.c
sys/netproto/ipsec/ipsec_mbuf.c
sys/netproto/ipsec/ipsec_output.c
sys/netproto/ipsec/key.c
sys/netproto/ipsec/keysock.c
sys/netproto/ipsec/xform_ipip.c
sys/netproto/key/key.c
sys/netproto/key/keysock.c
sys/netproto/mpls/mpls_output.c
sys/netproto/smb/smb_iod.c
sys/netproto/smb/smb_rq.c
sys/netproto/smb/smb_trantcp.c
sys/sys/mbuf.h
sys/vfs/nfs/krpc_subr.c
sys/vfs/nfs/nfs_mountrpc.c
sys/vfs/nfs/nfs_serv.c
sys/vfs/nfs/nfs_socket.c
sys/vfs/nfs/nfs_srvcache.c
sys/vfs/nfs/nfs_syscalls.c
sys/vfs/nfs/nfsm_subs.c
tools/tools/netrate/pktgen/pktgen.c

index a7b0f24..b79eceb 100644 (file)
@@ -24,7 +24,7 @@
 .\"
 .\" $FreeBSD: src/share/man/man9/mbuf.9,v 1.27.2.1 2003/05/28 13:53:18 yar Exp $
 .\"
-.Dd September 17, 2010
+.Dd February 19, 2015
 .Dt MBUF 9
 .Os
 .\"
@@ -241,14 +241,14 @@ on failure.
 The
 .Fa how
 argument is to be set to
-.Dv MB_WAIT
+.Dv M_WAITOK
 or
-.Dv MB_DONTWAIT .
+.Dv M_NOWAIT .
 It specifies whether the caller is willing to block if necessary.
 If
 .Fa how
 is set to
-.Dv MB_WAIT ,
+.Dv M_WAITOK ,
 a failed allocation will result in the caller being put
 to sleep for a designated
 .Va kern.ipc.mbuf_wait
@@ -258,14 +258,6 @@ number of ticks.
 A number of other mbuf-related
 functions and macros have the same argument because they may
 at some point need to allocate new mbufs.
-.Pp
-Programmers should be careful not to confuse the mbuf allocation flag
-.Dv MB_DONTWAIT
-with the
-.Xr kmalloc 9
-allocation flag,
-.Dv M_NOWAIT .
-They are not the same.
 .It Fn MGETHDR mbuf how type
 Allocate an mbuf and initialize it to contain a packet header
 and internal data.
index 778ee65..c1896ed 100644 (file)
@@ -931,7 +931,7 @@ again:
 
                                if (firewire_debug)
                                        device_printf(sc->fc.dev, "EFBIG.\n");
-                               m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+                               m0 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                                if (m0 != NULL) {
                                        m_copydata(xfer->mbuf, 0,
                                                xfer->mbuf->m_pkthdr.len,
index 070bc24..dd2d991 100644 (file)
@@ -1118,7 +1118,7 @@ axe_rxeof(struct usb_ether *ue, struct usb_page_cache *pc, unsigned int offset,
                return (EINVAL);
        }
 
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                IFNET_STAT_INC(ifp, iqdrops, 1);
                return (ENOMEM);
index 6d2b47e..90f244f 100644 (file)
@@ -986,7 +986,7 @@ axge_rxeof(struct usb_ether *ue, struct usb_page_cache *pc,
                return;
        }
 
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                IFNET_STAT_INC(ifp, iqdrops, 1);
                return;
index 9686a63..8c4214a 100644 (file)
@@ -861,9 +861,9 @@ urndis_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
                                    msg.rm_datalen, (unsigned)MCLBYTES);
                                goto tr_setup;
                        } else if (msg.rm_datalen > (uint32_t)(MHLEN - ETHER_ALIGN)) {
-                               m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+                               m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                        } else {
-                               m = m_gethdr(MB_DONTWAIT, MT_DATA);
+                               m = m_gethdr(M_NOWAIT, MT_DATA);
                        }
 
                        /* check if we have a buffer */
index be4823e..ee16703 100644 (file)
@@ -548,7 +548,7 @@ uether_newbuf(void)
 {
        struct mbuf *m_new;
 
-       m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL)
                return (NULL);
        m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
index 7dfdadb..d962c27 100644 (file)
@@ -917,7 +917,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
                        goto tr_setup;
                }
 
-               m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (m == NULL) {
                        DPRINTF("could not allocate mbuf\n");
                        IFNET_STAT_INC(ifp, ierrors, 1);
index 5b95109..02edb51 100644 (file)
@@ -2926,7 +2926,7 @@ run_bulk_rx_callback(struct usb_xfer *xfer, usb_error_t error)
        case USB_ST_SETUP:
 tr_setup:
                if (sc->rx_m == NULL) {
-                       sc->rx_m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR,
+                       sc->rx_m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
                            MJUMPAGESIZE /* xfer can be bigger than MCLBYTES */);
                }
                if (sc->rx_m == NULL) {
@@ -3001,7 +3001,7 @@ tr_setup:
                }
 
                /* copy aggregated frames to another mbuf */
-               m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m0 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (__predict_false(m0 == NULL)) {
                        DPRINTF("could not allocate mbuf\n");
                        ifp->if_ierrors++;
index 4045357..c7eeb07 100644 (file)
@@ -677,7 +677,7 @@ urtwn_rx_frame(struct urtwn_softc *sc, uint8_t *buf, int pktlen, int *rssi_p)
                rssi = URTWN_RSSI(rssi);
        }
 
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                device_printf(sc->sc_dev, "could not create RX mbuf\n");
                return (NULL);
index 4379561..766e352 100644 (file)
@@ -1919,14 +1919,14 @@ hifn_crypto(
                        totlen = cmd->src_mapsize;
                        if (cmd->src_m->m_flags & M_PKTHDR) {
                                len = MHLEN;
-                               MGETHDR(m0, MB_DONTWAIT, MT_DATA);
-                               if (m0 && !m_dup_pkthdr(m0, cmd->src_m, MB_DONTWAIT)) {
+                               MGETHDR(m0, M_NOWAIT, MT_DATA);
+                               if (m0 && !m_dup_pkthdr(m0, cmd->src_m, M_NOWAIT)) {
                                        m_free(m0);
                                        m0 = NULL;
                                }
                        } else {
                                len = MLEN;
-                               MGET(m0, MB_DONTWAIT, MT_DATA);
+                               MGET(m0, M_NOWAIT, MT_DATA);
                        }
                        if (m0 == NULL) {
                                hifnstats.hst_nomem_mbuf++;
@@ -1934,7 +1934,7 @@ hifn_crypto(
                                goto err_srcmap;
                        }
                        if (totlen >= MINCLSIZE) {
-                               MCLGET(m0, MB_DONTWAIT);
+                               MCLGET(m0, M_NOWAIT);
                                if ((m0->m_flags & M_EXT) == 0) {
                                        hifnstats.hst_nomem_mcl++;
                                        err = dma->cmdu ? ERESTART : ENOMEM;
@@ -1948,7 +1948,7 @@ hifn_crypto(
                        mlast = m0;
 
                        while (totlen > 0) {
-                               MGET(m, MB_DONTWAIT, MT_DATA);
+                               MGET(m, M_NOWAIT, MT_DATA);
                                if (m == NULL) {
                                        hifnstats.hst_nomem_mbuf++;
                                        err = dma->cmdu ? ERESTART : ENOMEM;
@@ -1957,7 +1957,7 @@ hifn_crypto(
                                }
                                len = MLEN;
                                if (totlen >= MINCLSIZE) {
-                                       MCLGET(m, MB_DONTWAIT);
+                                       MCLGET(m, M_NOWAIT);
                                        if ((m->m_flags & M_EXT) == 0) {
                                                hifnstats.hst_nomem_mcl++;
                                                err = dma->cmdu ? ERESTART : ENOMEM;
index 7eef940..8a0bb43 100644 (file)
@@ -1321,15 +1321,15 @@ safe_process(device_t dev, struct cryptop *crp, int hint)
                                totlen = re->re_src_mapsize;
                                if (re->re_src_m->m_flags & M_PKTHDR) {
                                        len = MHLEN;
-                                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                                       MGETHDR(m, M_NOWAIT, MT_DATA);
                                        if (m && !m_dup_pkthdr(m, re->re_src_m,
-                                           MB_DONTWAIT)) {
+                                           M_NOWAIT)) {
                                                m_free(m);
                                                m = NULL;
                                        }
                                } else {
                                        len = MLEN;
-                                       MGET(m, MB_DONTWAIT, MT_DATA);
+                                       MGET(m, M_NOWAIT, MT_DATA);
                                }
                                if (m == NULL) {
                                        safestats.st_nombuf++;
@@ -1337,7 +1337,7 @@ safe_process(device_t dev, struct cryptop *crp, int hint)
                                        goto errout;
                                }
                                if (totlen >= MINCLSIZE) {
-                                       MCLGET(m, MB_DONTWAIT);
+                                       MCLGET(m, M_NOWAIT);
                                        if ((m->m_flags & M_EXT) == 0) {
                                                m_free(m);
                                                safestats.st_nomcl++;
@@ -1353,7 +1353,7 @@ safe_process(device_t dev, struct cryptop *crp, int hint)
 
                                while (totlen > 0) {
                                        if (top) {
-                                               MGET(m, MB_DONTWAIT, MT_DATA);
+                                               MGET(m, M_NOWAIT, MT_DATA);
                                                if (m == NULL) {
                                                        m_freem(top);
                                                        safestats.st_nombuf++;
@@ -1364,7 +1364,7 @@ safe_process(device_t dev, struct cryptop *crp, int hint)
                                                len = MLEN;
                                        }
                                        if (top && totlen >= MINCLSIZE) {
-                                               MCLGET(m, MB_DONTWAIT);
+                                               MCLGET(m, M_NOWAIT);
                                                if ((m->m_flags & M_EXT) == 0) {
                                                        *mp = m;
                                                        m_freem(top);
index acdcafe..7922c1a 100644 (file)
@@ -1356,14 +1356,14 @@ ubsec_process(device_t dev, struct cryptop *crp, int hint)
                                totlen = q->q_src_mapsize;
                                if (q->q_src_m->m_flags & M_PKTHDR) {
                                        len = MHLEN;
-                                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
-                                       if (m && !m_dup_pkthdr(m, q->q_src_m, MB_DONTWAIT)) {
+                                       MGETHDR(m, M_NOWAIT, MT_DATA);
+                                       if (m && !m_dup_pkthdr(m, q->q_src_m, M_NOWAIT)) {
                                                m_free(m);
                                                m = NULL;
                                        }
                                } else {
                                        len = MLEN;
-                                       MGET(m, MB_DONTWAIT, MT_DATA);
+                                       MGET(m, M_NOWAIT, MT_DATA);
                                }
                                if (m == NULL) {
                                        ubsecstats.hst_nombuf++;
@@ -1371,7 +1371,7 @@ ubsec_process(device_t dev, struct cryptop *crp, int hint)
                                        goto errout;
                                }
                                if (totlen >= MINCLSIZE) {
-                                       MCLGET(m, MB_DONTWAIT);
+                                       MCLGET(m, M_NOWAIT);
                                        if ((m->m_flags & M_EXT) == 0) {
                                                m_free(m);
                                                ubsecstats.hst_nomcl++;
@@ -1386,7 +1386,7 @@ ubsec_process(device_t dev, struct cryptop *crp, int hint)
 
                                while (totlen > 0) {
                                        if (top) {
-                                               MGET(m, MB_DONTWAIT, MT_DATA);
+                                               MGET(m, M_NOWAIT, MT_DATA);
                                                if (m == NULL) {
                                                        m_freem(top);
                                                        ubsecstats.hst_nombuf++;
@@ -1396,7 +1396,7 @@ ubsec_process(device_t dev, struct cryptop *crp, int hint)
                                                len = MLEN;
                                        }
                                        if (top && totlen >= MINCLSIZE) {
-                                               MCLGET(m, MB_DONTWAIT);
+                                               MCLGET(m, M_NOWAIT);
                                                if ((m->m_flags & M_EXT) == 0) {
                                                        *mp = m;
                                                        m_freem(top);
index 0225c4f..5350fbc 100644 (file)
@@ -112,7 +112,7 @@ isc_sendPDU(isc_session_t *sp, pduq_t *pq)
      /*
       | mbuf for the iSCSI header
       */
-     MGETHDR(mh, MB_TRYWAIT, MT_DATA);
+     MGETHDR(mh, M_WAITOK, 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));
@@ -154,7 +154,7 @@ isc_sendPDU(isc_session_t *sp, pduq_t *pq)
           while(len > 0) {
                 int       l;
 
-              MGET(md, MB_TRYWAIT, MT_DATA);
+              MGET(md, M_WAITOK, MT_DATA);
               pq->refcnt++;
 
                 l = min(MCLBYTES, len);
@@ -180,7 +180,7 @@ isc_sendPDU(isc_session_t *sp, pduq_t *pq)
 
          pp->ds_dig = sp->dataDigest(pp->ds, pp->ds_len, 0);
 
-         MGET(me, MB_TRYWAIT, MT_DATA);
+         MGET(me, M_WAITOK, MT_DATA);
           me->m_len = sizeof(int);
           MH_ALIGN(mh, sizeof(int));
           bcopy(&pp->ds_dig, me->m_data, sizeof(int));
index 2a1210e..9be6b01 100644 (file)
@@ -695,9 +695,9 @@ musycc_intr0_rx_eom(struct softc *sc, int ch)
                m->m_len = m->m_pkthdr.len = status & 0x3fff;
                error = (status >> 16) & 0xf;
                if (error == 0) {
-                       MGETHDR(m2, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m2, M_NOWAIT, MT_DATA);
                        if (m2 != NULL) {
-                               MCLGET(m2, MB_DONTWAIT);
+                               MCLGET(m2, M_NOWAIT);
                                if((m2->m_flags & M_EXT) != 0) {
                                        /* Substitute the mbuf+cluster. */
                                        md->m = m2;
@@ -1278,13 +1278,13 @@ musycc_connect(hook_p hook)
                sc->mdt[ch][i].m = NULL;
                sc->mdt[ch][i].data = 0;
 
-               MGETHDR(m, MB_WAIT, MT_DATA);
+               MGETHDR(m, M_WAITOK, MT_DATA);
                if (m == NULL)
                        goto errfree;
-               MCLGET(m, MB_WAIT);
+               MCLGET(m, M_WAITOK);
                if ((m->m_flags & M_EXT) == 0) {
                        /* We've waited mbuf_wait and still got nothing.
-                          We're calling with MB_TRYWAIT anyway - a little
+                          We're calling with MB_WAITOK anyway - a little
                           defensive programming costs us very little - if
                           anything at all in the case of error. */
                        m_free(m);
index ffe5e87..dc4530e 100644 (file)
@@ -2336,7 +2336,7 @@ acx_newbuf(struct acx_softc *sc, struct acx_rxbuf *rb, int wait)
 
        bd = &sc->sc_buf_data;
 
-       m = m_getcl(wait ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(wait ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return ENOBUFS;
 
@@ -2401,7 +2401,7 @@ acx_encap(struct acx_softc *sc, struct acx_txbuf *txbuf, struct mbuf *m,
        if (error) {    /* error == EFBIG */
                struct mbuf *m_new;
 
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL) {
                        if_printf(&sc->sc_ic.ic_if, "can't defrag tx mbuf\n");
                        error = ENOBUFS;
index 22ab8af..0f8fb80 100644 (file)
@@ -1467,7 +1467,7 @@ age_encap(struct age_softc *sc, struct mbuf **m_head)
                error = EFBIG;
        }
        if (error == EFBIG) {
-               m = m_defrag(*m_head, MB_DONTWAIT);
+               m = m_defrag(*m_head, M_NOWAIT);
                if (m == NULL) {
                        m_freem(*m_head);
                        *m_head = NULL;
@@ -2747,7 +2747,7 @@ age_newbuf(struct age_softc *sc, struct age_rxdesc *rxd, int init)
        bus_dmamap_t map;
        int error;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return (ENOBUFS);
 
index 6a1fb26..4715f3f 100644 (file)
@@ -2640,7 +2640,7 @@ alc_encap(struct alc_softc *sc, struct mbuf **m_head)
 
                if (M_WRITABLE(m) == 0) {
                        /* Get a writable copy. */
-                       m = m_dup(*m_head, MB_DONTWAIT);
+                       m = m_dup(*m_head, M_NOWAIT);
                        /* Release original mbufs. */
                        m_freem(*m_head);
                        if (m == NULL) {
@@ -3318,7 +3318,7 @@ alc_newbuf(struct alc_softc *sc, struct alc_rxdesc *rxd, boolean_t wait)
        int nsegs;
        int error;
 
-       m = m_getcl(wait ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(wait ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return (ENOBUFS);
        m->m_len = m->m_pkthdr.len = MCLBYTES;
index e74b433..d324cbd 100644 (file)
@@ -1540,7 +1540,7 @@ ale_encap(struct ale_softc *sc, struct mbuf **m_head)
                                      *m_head, ale_dmamap_buf_cb, &ctx,
                                      BUS_DMA_NOWAIT);
        if (error == EFBIG) {
-               m = m_defrag(*m_head, MB_DONTWAIT);
+               m = m_defrag(*m_head, M_NOWAIT);
                if (m == NULL) {
                        m_freem(*m_head);
                        *m_head = NULL;
index fec76f1..aaba2dd 100644 (file)
@@ -892,7 +892,7 @@ an_rxeof(struct an_softc *sc)
                        }
                        BPF_TAP(ifp, bpf_buf, len);
                } else {
-                       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+                       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                        if (m == NULL) {
                                IFNET_STAT_INC(ifp, ierrors, 1);
                                return;
@@ -970,7 +970,7 @@ an_rxeof(struct an_softc *sc)
                        if (an_rx_desc.an_done && !an_rx_desc.an_valid) {
                                buf = sc->an_rx_buffer[count].an_dma_vaddr;
 
-                               m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+                               m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                                if (m == NULL) {
                                        IFNET_STAT_INC(ifp, ierrors, 1);
                                        return;
index 6a540bd..c5ae425 100644 (file)
@@ -1686,7 +1686,7 @@ ar_get_packets(struct ar_softc *sc)
        while(ar_packet_avail(sc, &len, &rxstat)) {
                TRC(kprintf("apa: len %d, rxstat %x\n", len, rxstat));
                if(((rxstat & SCA_DESC_ERRORS) == 0) && (len < MCLBYTES)) {
-                       m =  m_getl(len, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL);
+                       m =  m_getl(len, M_NOWAIT, MT_DATA, M_PKTHDR, NULL);
                        if(m == NULL) {
                                /* eat packet if get mbuf fail!! */
                                ar_eat_packet(sc, 1);
index 2fb8731..4d2798f 100644 (file)
@@ -254,7 +254,7 @@ ath_legacy_rxbuf_init(struct ath_softc *sc, struct ath_buf *bf)
                 * multiple of the cache line size.  Not doing this
                 * causes weird stuff to happen (for the 5210 at least).
                 */
-               m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (m == NULL) {
                        DPRINTF(sc, ATH_DEBUG_ANY,
                                "%s: no mbuf/cluster\n", __func__);
index e5152cb..cc7d06e 100644 (file)
@@ -659,9 +659,9 @@ ath_edma_rxbuf_init(struct ath_softc *sc, struct ath_buf *bf)
        ATH_RX_LOCK_ASSERT(sc);
 
 #if defined(__DragonFly__)
-       m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, sc->sc_edma_bufsize);
+       m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, sc->sc_edma_bufsize);
 #else
-       m = m_getm(NULL, sc->sc_edma_bufsize, MB_DONTWAIT, MT_DATA);
+       m = m_getm(NULL, sc->sc_edma_bufsize, M_NOWAIT, MT_DATA);
 #endif
        if (! m)
                return (ENOBUFS);               /* XXX ?*/
index 2c6d673..59ac0eb 100644 (file)
@@ -3867,7 +3867,7 @@ bce_newbuf_std(struct bce_rx_ring *rxr, uint16_t *prod, uint16_t chain_prod,
        int error, nseg;
 
        /* This is a new mbuf allocation. */
-       m_new = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL)
                return ENOBUFS;
 
index 7877989..2605b99 100644 (file)
@@ -565,7 +565,7 @@ bfe_newbuf(struct bfe_softc *sc, int c, int init)
        struct mbuf *m;
        int error, nsegs;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return ENOBUFS;
        m->m_len = m->m_pkthdr.len = MCLBYTES;
index 58b2cf6..01120df 100644 (file)
@@ -1021,7 +1021,7 @@ bge_newbuf_std(struct bge_softc *sc, int i, int init)
        bus_dmamap_t map;
        int error, nsegs;
 
-       m_new = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL)
                return ENOBUFS;
        m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
@@ -1084,7 +1084,7 @@ bge_newbuf_jumbo(struct bge_softc *sc, int i, int init)
        bus_addr_t paddr;
 
        /* Allocate the mbuf. */
-       MGETHDR(m_new, init ? MB_WAIT : MB_DONTWAIT, MT_DATA);
+       MGETHDR(m_new, init ? M_WAITOK : M_NOWAIT, MT_DATA);
        if (m_new == NULL)
                return ENOBUFS;
 
@@ -3573,7 +3573,7 @@ bge_encap(struct bge_softc *sc, struct mbuf **m_head0, uint32_t *txidx,
                 * DMA read operation.  If it fails, keep moving on using
                 * the original mbuf chain.
                 */
-               m_new = m_defrag(m_head, MB_DONTWAIT);
+               m_new = m_defrag(m_head, M_NOWAIT);
                if (m_new != NULL)
                        *m_head0 = m_head = m_new;
        }
@@ -5041,7 +5041,7 @@ bge_defrag_shortdma(struct mbuf *m)
        }
 
        if (found > 1)
-               n = m_defrag(m, MB_DONTWAIT);
+               n = m_defrag(m, M_NOWAIT);
        else
                n = m;
        return n;
index bcd8e67..8f4354d 100644 (file)
@@ -811,7 +811,7 @@ bnx_newbuf_std(struct bnx_rx_ret_ring *ret, int i, int init)
        rb = &ret->bnx_std->bnx_rx_std_buf[i];
        KASSERT(!rb->bnx_rx_refilled, ("RX buf %dth has been refilled", i));
 
-       m_new = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL) {
                error = ENOBUFS;
                goto back;
@@ -883,7 +883,7 @@ bnx_newbuf_jumbo(struct bnx_softc *sc, int i, int init)
        bus_addr_t paddr;
 
        /* Allocate the mbuf. */
-       MGETHDR(m_new, init ? MB_WAIT : MB_DONTWAIT, MT_DATA);
+       MGETHDR(m_new, init ? M_WAITOK : M_NOWAIT, MT_DATA);
        if (m_new == NULL)
                return ENOBUFS;
 
@@ -3447,7 +3447,7 @@ bnx_encap(struct bnx_tx_ring *txr, struct mbuf **m_head0, uint32_t *txidx,
                 * DMA read operation.  If it fails, keep moving on using
                 * the original mbuf chain.
                 */
-               m_new = m_defrag(m_head, MB_DONTWAIT);
+               m_new = m_defrag(m_head, M_NOWAIT);
                if (m_new != NULL)
                        *m_head0 = m_head = m_new;
        }
@@ -5039,7 +5039,7 @@ bnx_defrag_shortdma(struct mbuf *m)
        }
 
        if (found > 1)
-               n = m_defrag(m, MB_DONTWAIT);
+               n = m_defrag(m, M_NOWAIT);
        else
                n = m;
        return n;
index bff5797..cde7360 100644 (file)
@@ -2611,7 +2611,7 @@ bwi_newbuf(struct bwi_softc *sc, int buf_idx, int init)
 
        KKASSERT(buf_idx < BWI_RX_NDESC);
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                error = ENOBUFS;
 
@@ -3087,7 +3087,7 @@ bwi_encap(struct bwi_softc *sc, int idx, struct mbuf *m,
        /*
         * Setup the embedded TX header
         */
-       M_PREPEND(m, sizeof(*hdr), MB_DONTWAIT);
+       M_PREPEND(m, sizeof(*hdr), M_NOWAIT);
        if (m == NULL) {
                if_printf(&ic->ic_if, "prepend TX header failed\n");
                return ENOBUFS;
@@ -3148,7 +3148,7 @@ bwi_encap(struct bwi_softc *sc, int idx, struct mbuf *m,
        if (error) {    /* error == EFBIG */
                struct mbuf *m_new;
 
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL) {
                        if_printf(&ic->ic_if, "can't defrag TX buffer\n");
                        error = ENOBUFS;
index 54da33a..1d986d4 100644 (file)
@@ -1390,7 +1390,7 @@ bwn_pio_tx_start(struct bwn_mac *mac, struct ieee80211_node *ni, struct mbuf *m)
                /*
                 * XXX please removes m_defrag(9)
                 */
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL) {
                        device_printf(sc->sc_dev,
                            "%s: can't defrag TX buffer\n",
@@ -1497,7 +1497,7 @@ bwn_dma_tx_start(struct bwn_mac *mac, struct ieee80211_node *ni, struct mbuf *m)
        if (error) {    /* error == EFBIG */
                struct mbuf *m_new;
 
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL) {
                        if_printf(ifp, "%s: can't defrag TX buffer\n",
                            __func__);
@@ -9019,7 +9019,7 @@ ready:
        padding = (macstat & BWN_RX_MAC_PADDING) ? 2 : 0;
        totlen = len + padding;
        KASSERT(totlen <= MCLBYTES, ("too big..\n"));
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                device_printf(sc->sc_dev, "%s: out of memory", __func__);
                goto error;
@@ -9078,7 +9078,7 @@ bwn_dma_newbuf(struct bwn_dma_ring *dr, struct bwn_dmadesc_generic *desc,
        struct mbuf *m;
        int error;
 
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                error = ENOBUFS;
 
index 970aa9e..05aa1f2 100644 (file)
@@ -839,12 +839,12 @@ cs_get_packet(struct cs_softc *sc)
                return -1;
        }
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m==NULL)
                return -1;
 
        if (length > MHLEN) {
-               MCLGET(m, MB_DONTWAIT);
+               MCLGET(m, M_NOWAIT);
                if (!(m->m_flags & M_EXT)) {
                        m_freem(m);
                        return -1;
index b8e7508..95b307e 100644 (file)
@@ -2318,7 +2318,7 @@ dc_newbuf(struct dc_softc *sc, int i, struct mbuf *m)
        c = &sc->dc_ldata->dc_rx_list[i];
 
        if (m == NULL) {
-               m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m_new = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (m_new == NULL)
                        return (ENOBUFS);
                m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
@@ -3128,7 +3128,7 @@ dc_start(struct ifnet *ifp, struct ifaltq_subque *ifsq)
                        }
 
                        /* only coalesce if have >1 mbufs */
-                       m_defragged = m_defrag(m_head, MB_DONTWAIT);
+                       m_defragged = m_defrag(m_head, M_NOWAIT);
                        if (m_defragged == NULL) {
                                ifq_set_oactive(&ifp->if_snd);
                                ifq_prepend(&ifp->if_snd, m_head);
index 94e0570..d4618c9 100644 (file)
@@ -145,7 +145,7 @@ tulip_txprobe(tulip_softc_t *sc)
      * either is connected so the transmit is the only way
      * to verify the connectivity.
      */
-    MGETHDR(m, MB_DONTWAIT, MT_DATA);
+    MGETHDR(m, M_NOWAIT, MT_DATA);
     if (m == NULL)
        return 0;
     /*
@@ -3133,11 +3133,11 @@ tulip_rx_intr(tulip_softc_t *sc)
 
 #if defined(TULIP_COPY_RXDATA)
            if (!accept || total_len >= (MHLEN - 2))
-               m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m0 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
            else
-               m0 = m_gethdr(MB_DONTWAIT, MT_DATA);
+               m0 = m_gethdr(M_NOWAIT, MT_DATA);
 #else
-           m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+           m0 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 #endif
 
            if (accept
@@ -3495,7 +3495,7 @@ tulip_txput(tulip_softc_t *sc, struct mbuf *m)
                 * entries that we can use for one packet, so we have
                 * recopy it into one mbuf and then try again.
                 */
-               m0 = m_defrag(m, MB_DONTWAIT);
+               m0 = m_defrag(m, M_NOWAIT);
                if (m0 == NULL)
                    goto finish;
                m = m0;
index eb9f1ce..c831b07 100644 (file)
@@ -2756,7 +2756,7 @@ ed_get_packet(struct ed_softc *sc, char *buf, u_short len)
         * to the header. The +2 is to compensate for the alignment
         * fixup below.
         */
-       m = m_getl(len + 2, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL);
+       m = m_getl(len + 2, M_NOWAIT, MT_DATA, M_PKTHDR, NULL);
        if (m == NULL)
                return;
        m->m_pkthdr.rcvif = ifp;
index 2b87aab..75a556f 100644 (file)
@@ -3091,7 +3091,7 @@ em_newbuf(struct adapter *adapter, int i, int init)
        struct em_buffer *rx_buffer;
        int error, nseg;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                adapter->mbuf_cluster_failed++;
                if (init) {
index ba0356c..aa79ea3 100644 (file)
@@ -2680,7 +2680,7 @@ emx_newbuf(struct emx_rxdata *rdata, int i, int init)
        struct emx_rxbuf *rx_buffer;
        int error, nseg;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                if (init) {
                        if_printf(&rdata->sc->arpcom.ac_if,
index 0ddf5d9..f50e642 100644 (file)
@@ -663,7 +663,7 @@ read_again:
     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);
+       m = m_getl(rx_fifo, M_NOWAIT, MT_DATA, M_PKTHDR, NULL);
        if (!m)
            goto out;
        sc->top = sc->mcur = top = m;
@@ -689,7 +689,7 @@ read_again:
        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);
+           m = m_getl(rx_fifo, M_NOWAIT, MT_DATA, 0, NULL);
            if (!m)
                goto out;
            m->m_len = 0;
index 55a2f11..4d06ac4 100644 (file)
@@ -2104,7 +2104,7 @@ et_newbuf(struct et_rxbuf_data *rbd, int buf_idx, int init, int len0)
        KKASSERT(buf_idx < ET_RX_NDESC);
        rb = &rbd->rbd_buf[buf_idx];
 
-       m = m_getl(len0, init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR, &len);
+       m = m_getl(len0, init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR, &len);
        if (m == NULL) {
                error = ENOBUFS;
 
@@ -2363,7 +2363,7 @@ et_newbuf_jumbo(struct et_rxbuf_data *rbd, int buf_idx, int init)
 
        error = ENOBUFS;
 
-       MGETHDR(m, init ? MB_WAIT : MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, init ? M_WAITOK : M_NOWAIT, MT_DATA);
        if (m == NULL) {
                if (init) {
                        if_printf(&sc->arpcom.ac_if, "MGETHDR failed\n");
index 98eab9f..d64a118 100644 (file)
@@ -683,7 +683,7 @@ ex_rx_intr(struct ex_softc *sc)
                pkt_len = inw(iobase + IO_PORT_REG);
 
                if (rx_status & RCV_OK_bit) {
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT, MT_DATA);
                        ipkt = m;
                        if (ipkt == NULL) {
                                IFNET_STAT_INC(ifp, iqdrops, 1);
@@ -694,7 +694,7 @@ ex_rx_intr(struct ex_softc *sc)
 
                                while (pkt_len > 0) {
                                        if (pkt_len > MINCLSIZE) {
-                                               MCLGET(m, MB_DONTWAIT);
+                                               MCLGET(m, M_NOWAIT);
                                                if (m->m_flags & M_EXT) {
                                                        m->m_len = MCLBYTES;
                                                } else {
@@ -719,7 +719,7 @@ ex_rx_intr(struct ex_softc *sc)
                                        pkt_len -= m->m_len;
 
                                        if (pkt_len > 0) {
-                                               MGET(m->m_next, MB_DONTWAIT, MT_DATA);
+                                               MGET(m->m_next, M_NOWAIT, MT_DATA);
                                                if (m->m_next == NULL) {
                                                        m_freem(ipkt);
                                                        IFNET_STAT_INC(ifp, iqdrops, 1);
index b7254a3..277ca94 100644 (file)
@@ -1847,13 +1847,13 @@ fe_get_packet (struct fe_softc * sc, u_short len)
         */
 
        /* Allocate an mbuf with packet header info.  */
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL)
                return -1;
 
        /* Attach a cluster if this packet doesn't fit in a normal mbuf.  */
        if (len > MHLEN - NFS_MAGIC_OFFSET) {
-               MCLGET(m, MB_DONTWAIT);
+               MCLGET(m, M_NOWAIT);
                if (!(m->m_flags & M_EXT)) {
                        m_freem(m);
                        return -1;
index 0483765..f6d2004 100644 (file)
@@ -346,7 +346,7 @@ found:
                STAILQ_INIT(&xferq->stdma);
                xferq->stproc = NULL;
                for (i = 0; i < xferq->bnchunk; i ++) {
-                       m = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
+                       m = m_getcl(M_WAITOK, MT_DATA, M_PKTHDR);
                        xferq->bulkxfer[i].mbuf = m;
                        if (m != NULL) {
                                m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
@@ -504,7 +504,7 @@ fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
                BPF_MTAP(ifp, m);
 
                /* keep ip packet alignment for alpha */
-               M_PREPEND(m, ETHER_ALIGN, MB_DONTWAIT);
+               M_PREPEND(m, ETHER_ALIGN, M_NOWAIT);
                fp = &xfer->send.hdr;
                *(u_int32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
                fp->mode.stream.len = m->m_pkthdr.len;
@@ -550,7 +550,7 @@ fwe_as_input(struct fw_xferq *xferq)
                m = sxfer->mbuf;
 
                /* insert new rbuf */
-               sxfer->mbuf = m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               sxfer->mbuf = m0 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (m0 != NULL) {
                        m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
                        STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
index 934dcbb..a5bfd10 100644 (file)
@@ -1106,7 +1106,7 @@ tbdinit:
                                continue;
                        }
 
-                       mn = m_dup(mb_head, MB_DONTWAIT);
+                       mn = m_dup(mb_head, M_NOWAIT);
                        if (mn == NULL) {
                                m_freem(mb_head);
                                IFNET_STAT_INC(ifp, oerrors, 1);
@@ -1957,7 +1957,7 @@ fxp_add_rfabuf(struct fxp_softc *sc, struct mbuf *oldm)
        struct mbuf *m;
        struct fxp_rfa *rfa, *p_rfa;
 
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) { /* try to recycle the old mbuf instead */
                if (oldm == NULL)
                        return 1;
index 10f3923..3006c10 100644 (file)
@@ -2324,7 +2324,7 @@ igb_newbuf(struct igb_rx_ring *rxr, int i, boolean_t wait)
        struct igb_rx_buf *rxbuf;
        int error, nseg;
 
-       m = m_getcl(wait ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(wait ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                if (wait) {
                        if_printf(&rxr->sc->arpcom.ac_if,
index 5a3bc9c..8135de7 100644 (file)
@@ -782,7 +782,7 @@ iwi_alloc_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring, int count)
                        goto fail;
                }
 
-               data->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               data->m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (data->m == NULL) {
                        device_printf(sc->sc_dev,
                            "could not allocate rx mbuf\n");
@@ -1232,7 +1232,7 @@ iwi_frame_intr(struct iwi_softc *sc, struct iwi_rx_data *data, int i,
         * drop the received packet and reuse the old mbuf. In the unlikely
         * case that the old mbuf can't be reloaded either, explicitly panic.
         */
-       mnew = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (mnew == NULL) {
                IFNET_STAT_INC(ifp, ierrors, 1);
                return;
@@ -1859,7 +1859,7 @@ iwi_tx_start(struct ifnet *ifp, struct mbuf *m0, struct ieee80211_node *ni,
                return error;
        }
        if (error != 0) {
-               mnew = m_defrag(m0, MB_DONTWAIT);
+               mnew = m_defrag(m0, M_NOWAIT);
                if (mnew == NULL) {
                        device_printf(sc->sc_dev,
                            "could not defragment mbuf\n");
index e0e4e4e..02b608f 100644 (file)
@@ -1653,7 +1653,7 @@ iwl2100_alloc_cmd(struct iwl2100_softc *sc)
 {
        KKASSERT(sc->sc_cmd == NULL);
 
-       sc->sc_cmd = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
+       sc->sc_cmd = m_getcl(M_WAITOK, MT_DATA, M_PKTHDR);
        if (sc->sc_cmd == NULL)
                return ENOBUFS;
        return 0;
@@ -1673,7 +1673,7 @@ iwl2100_newbuf(struct iwl2100_softc *sc, int buf_idx, int init)
        KKASSERT(buf_idx < IWL2100_RX_NDESC);
        rb = &rr->rr_buf[buf_idx];
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                error = ENOBUFS;
 
@@ -3332,7 +3332,7 @@ iwl2100_encap(struct iwl2100_softc *sc, struct mbuf *m)
        /*
         * Prepend and setup hardware TX header
         */
-       M_PREPEND(m, sizeof(*th), MB_DONTWAIT);
+       M_PREPEND(m, sizeof(*th), M_NOWAIT);
        if (m == NULL) {
                if_printf(&sc->sc_ic.ic_if, "prepend TX header failed\n");
                return ENOBUFS;
@@ -3372,7 +3372,7 @@ iwl2100_encap(struct iwl2100_softc *sc, struct mbuf *m)
        if (error) {    /* error == EFBIG */
                struct mbuf *m_new;
 
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL) {
                        if_printf(&sc->sc_ic.ic_if, "can't defrag TX mbuf\n");
                        error = ENOBUFS;
index ee909de..ba891bf 100644 (file)
@@ -1922,7 +1922,7 @@ iwn_alloc_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
                        goto fail;
                }
 
-               data->m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR,
+               data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
                                   IWN_RBUF_SIZE);
                if (data->m == NULL) {
                        device_printf(sc->sc_dev,
@@ -3060,7 +3060,7 @@ iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
                return;
        }
 
-       m1 = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, IWN_RBUF_SIZE);
+       m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, IWN_RBUF_SIZE);
        if (m1 == NULL) {
                DPRINTF(sc, IWN_DEBUG_ANY, "%s: no mbuf to restock ring\n",
                    __func__);
@@ -4649,7 +4649,7 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni)
                }
                /* Too many DMA segments, linearize mbuf. */
 #if defined(__DragonFly__)
-               m1 = m_defrag(m, MB_DONTWAIT);
+               m1 = m_defrag(m, M_NOWAIT);
 #else
                m1 = m_collapse(m, M_NOWAIT, IWN_MAX_SCATTER);
 #endif
@@ -4872,7 +4872,7 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m,
                }
                /* Too many DMA segments, linearize mbuf. */
 #if defined(__DragonFly__)
-               m1 = m_defrag(m, MB_DONTWAIT);
+               m1 = m_defrag(m, M_NOWAIT);
 #else
                m1 = m_collapse(m, M_NOWAIT, IWN_MAX_SCATTER);
 #endif
@@ -5210,7 +5210,7 @@ iwn_cmd(struct iwn_softc *sc, int code, const void *buf, int size, int async)
                /* Command is too large to fit in a descriptor. */
                if (totlen > MCLBYTES)
                        return EINVAL;
-               m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
+               m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
                if (m == NULL)
                        return ENOMEM;
                cmd = mtod(m, struct iwn_tx_cmd *);
index 6cfaa0e..7c52cd8 100644 (file)
@@ -3931,9 +3931,9 @@ ix_newbuf(struct ix_rx_ring *rxr, int i, boolean_t wait)
        struct ix_rx_buf *rxbuf;
        int flags, error, nseg;
 
-       flags = MB_DONTWAIT;
+       flags = M_NOWAIT;
        if (__predict_false(wait))
-               flags = MB_WAIT;
+               flags = M_WAITOK;
 
        m = m_getjcl(flags, MT_DATA, M_PKTHDR, rxr->rx_mbuf_sz);
        if (m == NULL) {
index acc6d07..ef085fe 100644 (file)
@@ -3069,7 +3069,7 @@ jme_newbuf(struct jme_rxdata *rdata, struct jme_rxdesc *rxd, int init)
        bus_dmamap_t map;
        int error, nsegs;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return ENOBUFS;
        /*
index 8c26601..d2c9262 100644 (file)
@@ -664,7 +664,7 @@ lge_newbuf(struct lge_softc *sc, struct lge_rx_desc *c, struct mbuf *m)
        struct lge_jslot *buf;
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL) {
                        kprintf("lge%d: no memory for rx list "
                            "-- packet dropped!\n", sc->lge_unit);
@@ -1168,7 +1168,7 @@ again:
                                continue;
                        }
 
-                       m_defragged = m_defrag(m_head, MB_DONTWAIT);
+                       m_defragged = m_defrag(m_head, M_NOWAIT);
                        if (m_defragged == NULL) {
                                m_freem(m_head);
                                continue;
index 87889f6..f2fc0bc 100644 (file)
@@ -1,6 +1,5 @@
 /*     $NetBSD: lance.c,v 1.34 2005/12/24 20:27:30 perry Exp $ */
 /*     $FreeBSD: src/sys/dev/le/lance.c,v 1.2 2006/05/16 21:04:01 marius Exp $ */
-/*     $DragonFly: src/sys/dev/netif/lnc/lance.c,v 1.7 2008/05/14 11:59:20 sephe Exp $ */
 
 
 /*-
@@ -346,7 +345,7 @@ lance_get(struct lance_softc *sc, int boff, int totlen)
        }
 
        do {
-               newm = m_getl(totlen, MB_DONTWAIT, MT_DATA,
+               newm = m_getl(totlen, M_NOWAIT, MT_DATA,
                              m0 == NULL ? M_PKTHDR : 0, &mlen);
                if (newm == NULL)
                        goto bad;
index aab52b6..46441bb 100644 (file)
@@ -683,7 +683,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, MB_WAIT, MT_DATA);
+       MGETHDR(m, M_WAITOK, MT_DATA);
        if (m == NULL)
                return (ENOBUFS);
        m->m_pkthdr.len = 0;
@@ -700,12 +700,12 @@ ngmn_connect(hook_p hook)
 
        dp = mn_alloc_desc();
        m = NULL;
-       MGETHDR(m, MB_WAIT, MT_DATA);
+       MGETHDR(m, M_WAITOK, MT_DATA);
        if (m == NULL) {
                mn_free_desc(dp);
                return (ENOBUFS);
        }
-       MCLGET(m, MB_WAIT);
+       MCLGET(m, M_WAITOK);
        if ((m->m_flags & M_EXT) == 0) {
                mn_free_desc(dp);
                m_freem(m);
@@ -723,13 +723,13 @@ ngmn_connect(hook_p hook)
                dp2 = dp;
                dp = mn_alloc_desc();
                m = NULL;
-               MGETHDR(m, MB_WAIT, MT_DATA);
+               MGETHDR(m, M_WAITOK, MT_DATA);
                if (m == NULL) {
                        mn_free_desc(dp);
                        m_freem(m);
                        return (ENOBUFS);
                }
-               MCLGET(m, MB_WAIT);
+               MCLGET(m, M_WAITOK);
                if ((m->m_flags & M_EXT) == 0) {
                        mn_free_desc(dp);
                        m_freem(m);
@@ -1171,12 +1171,12 @@ mn_rx_intr(struct softc *sc, u_int32_t vector)
 
                /* Replenish desc + mbuf supplies */
                if (!m) {
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT, MT_DATA);
                        if (m == NULL) {
                                mn_free_desc(dp);
                                return; /* ENOBUFS */
                        }
-                       MCLGET(m, MB_DONTWAIT);
+                       MCLGET(m, M_NOWAIT);
                        if((m->m_flags & M_EXT) == 0) {
                                mn_free_desc(dp);
                                m_freem(m);
index 38480b1..e4b70b0 100644 (file)
@@ -724,7 +724,7 @@ msk_newbuf(struct msk_if_softc *sc_if, int idx, int init)
        bus_dmamap_t map;
        int error, nseg;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return (ENOBUFS);
 
@@ -773,7 +773,7 @@ msk_jumbo_newbuf(struct msk_if_softc *sc_if, int idx)
        int nsegs;
        void *buf;
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL)
                return (ENOBUFS);
        buf = msk_jalloc(sc_if);
@@ -2427,7 +2427,7 @@ msk_encap(struct msk_if_softc *sc_if, struct mbuf **m_head)
                }
        }
        if (defrag) {
-               m = m_defrag(*m_head, MB_DONTWAIT);
+               m = m_defrag(*m_head, M_NOWAIT);
                if (m == NULL) {
                        m_freem(*m_head);
                        *m_head = NULL;
index 209c5a9..1327de1 100644 (file)
@@ -2058,9 +2058,9 @@ mxge_get_buf_small(mxge_rx_ring_t *rx, bus_dmamap_t map, int idx,
        struct mbuf *m;
        int cnt, err, mflag;
 
-       mflag = MB_DONTWAIT;
+       mflag = M_NOWAIT;
        if (__predict_false(init))
-               mflag = MB_WAIT;
+               mflag = M_WAITOK;
 
        m = m_gethdr(mflag, MT_DATA);
        if (m == NULL) {
@@ -2108,9 +2108,9 @@ mxge_get_buf_big(mxge_rx_ring_t *rx, bus_dmamap_t map, int idx,
        struct mbuf *m;
        int cnt, err, mflag;
 
-       mflag = MB_DONTWAIT;
+       mflag = M_NOWAIT;
        if (__predict_false(init))
-               mflag = MB_WAIT;
+               mflag = M_WAITOK;
 
        if (rx->cl_size == MCLBYTES)
                m = m_getcl(mflag, MT_DATA, M_PKTHDR);
index 393c8b4..1830f2a 100644 (file)
@@ -1058,13 +1058,13 @@ my_newbuf(struct my_softc * sc, struct my_chain_onefrag * c)
 {
        struct mbuf    *m_new = NULL;
 
-       MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m_new, M_NOWAIT, MT_DATA);
        if (m_new == NULL) {
                kprintf("my%d: no memory for rx list -- packet dropped!\n",
                       sc->my_unit);
                return (ENOBUFS);
        }
-       MCLGET(m_new, MB_DONTWAIT);
+       MCLGET(m_new, M_NOWAIT);
        if (!(m_new->m_flags & M_EXT)) {
                kprintf("my%d: no memory for rx list -- packet dropped!\n",
                       sc->my_unit);
@@ -1287,13 +1287,13 @@ my_encap(struct my_softc * sc, struct my_chain * c, struct mbuf * m_head)
         * chain.
         */
        m = m_head;
-       MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m_new, M_NOWAIT, MT_DATA);
        if (m_new == NULL) {
                kprintf("my%d: no memory for tx list", sc->my_unit);
                return (1);
        }
        if (m_head->m_pkthdr.len > MHLEN) {
-               MCLGET(m_new, MB_DONTWAIT);
+               MCLGET(m_new, M_NOWAIT);
                if (!(m_new->m_flags & M_EXT)) {
                        m_freem(m_new);
                        kprintf("my%d: no memory for tx list", sc->my_unit);
index 3493801..ab32274 100644 (file)
@@ -1166,7 +1166,7 @@ ndis_rxeof_eth(ndis_handle adapter, ndis_handle ctx, char *addr, void *hdr,
 
        block = adapter;
 
-       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return;
 
@@ -1399,7 +1399,7 @@ ndis_rxeof(ndis_handle adapter, ndis_packet **packets, uint32_t pktcnt)
                } else {
 #ifdef notdef
                        if (p->np_oob.npo_status == NDIS_STATUS_RESOURCES) {
-                               m = m_dup(m0, MB_DONTWAIT);
+                               m = m_dup(m0, M_NOWAIT);
                                /*
                                 * NOTE: we want to destroy the mbuf here, but
                                 * we don't actually want to return it to the
@@ -1417,7 +1417,7 @@ ndis_rxeof(ndis_handle adapter, ndis_packet **packets, uint32_t pktcnt)
                        } else
                                p->np_oob.npo_status = NDIS_STATUS_PENDING;
 #endif
-                       m = m_dup(m0, MB_DONTWAIT);
+                       m = m_dup(m0, M_NOWAIT);
                        if (p->np_oob.npo_status == NDIS_STATUS_RESOURCES)
                                p->np_refcnt++;
                        else
index b67cf8c..5c65e59 100644 (file)
@@ -2202,7 +2202,7 @@ nfe_newbuf_std(struct nfe_softc *sc, struct nfe_rx_ring *ring, int idx,
        struct mbuf *m;
        int nsegs, error;
 
-       m = m_getcl(wait ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(wait ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return ENOBUFS;
        m->m_len = m->m_pkthdr.len = MCLBYTES;
@@ -2251,7 +2251,7 @@ nfe_newbuf_jumbo(struct nfe_softc *sc, struct nfe_rx_ring *ring, int idx,
        struct nfe_jbuf *jbuf;
        struct mbuf *m;
 
-       MGETHDR(m, wait ? MB_WAIT : MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, wait ? M_WAITOK : M_NOWAIT, MT_DATA);
        if (m == NULL)
                return ENOBUFS;
 
index 2506b7a..4fc949e 100644 (file)
@@ -1038,7 +1038,7 @@ nge_newbuf(struct nge_softc *sc, struct nge_desc *c, struct mbuf *m)
        struct nge_jslot *buf;
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL) {
                        kprintf("nge%d: no memory for rx list "
                            "-- packet dropped!\n", sc->nge_unit);
@@ -1669,7 +1669,7 @@ again:
                                break;
                        }
 
-                       m_defragged = m_defrag(m_head, MB_DONTWAIT);
+                       m_defragged = m_defrag(m_head, M_NOWAIT);
                        if (m_defragged == NULL) {
                                m_freem(m_head);
                                continue;
index ae9235d..b6e0f65 100644 (file)
@@ -947,7 +947,7 @@ retry:
 
        } else if (rc == EFBIG) {
                if (retry_cnt == 0) {
-                       m_temp = m_defrag(m, MB_DONTWAIT);
+                       m_temp = m_defrag(m, M_NOWAIT);
                        if (m_temp == NULL)
                                goto free_ret;
                        m = m_temp;
@@ -1033,7 +1033,7 @@ oce_tso_setup(POCE_SOFTC sc, struct mbuf **mpp)
        m = *mpp;
 
        if (M_WRITABLE(m) == 0) {
-               m = m_dup(*mpp, MB_DONTWAIT);
+               m = m_dup(*mpp, M_NOWAIT);
                if (!m)
                        return NULL;
                m_freem(*mpp);
@@ -1529,7 +1529,7 @@ oce_alloc_rx_bufs(struct oce_rq *rq, int count)
                        break;  /* no more room */
 
                pd = &rq->pckts[rq->packets_in];
-               pd->mbuf = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               pd->mbuf = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (pd->mbuf == NULL)
                        break;
 
index 5b34bd1..ffddea9 100644 (file)
@@ -723,11 +723,11 @@ pcn_newbuf(struct pcn_softc *sc, int idx, struct mbuf *m)
        c = &sc->pcn_ldata->pcn_rx_list[idx];
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL)
                        return(ENOBUFS);
 
-               MCLGET(m_new, MB_DONTWAIT);
+               MCLGET(m_new, M_NOWAIT);
                if (!(m_new->m_flags & M_EXT)) {
                        m_freem(m_new);
                        return(ENOBUFS);
@@ -1039,7 +1039,7 @@ again:
                                break;
                        }
 
-                       m_defragged = m_defrag(m_head, MB_DONTWAIT);
+                       m_defragged = m_defrag(m_head, M_NOWAIT);
                        if (m_defragged == NULL) {
                                m_freem(m_head);
                                continue;
index 65eeee5..c4b6626 100644 (file)
@@ -669,7 +669,7 @@ rt2560_alloc_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring,
                        goto fail;
                }
 
-               data->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               data->m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (data->m == NULL) {
                        device_printf(sc->sc_dev,
                            "could not allocate rx mbuf\n");
@@ -1157,7 +1157,7 @@ rt2560_decryption_intr(struct rt2560_softc *sc)
                 * mbuf. In the unlikely case that the old mbuf can't be
                 * reloaded either, explicitly panic.
                 */
-               mnew = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (mnew == NULL) {
                        IFNET_STAT_INC(ifp, ierrors, 1);
                        goto skip;
@@ -1834,7 +1834,7 @@ rt2560_tx_data(struct rt2560_softc *sc, struct mbuf *m0,
                return error;
        }
        if (error != 0) {
-               mnew = m_defrag(m0, MB_DONTWAIT);
+               mnew = m_defrag(m0, M_NOWAIT);
                if (mnew == NULL) {
                        device_printf(sc->sc_dev,
                            "could not defragment mbuf\n");
index 556ae57..8b9fc54 100644 (file)
@@ -679,7 +679,7 @@ rt2661_alloc_rx_ring(struct rt2661_softc *sc, struct rt2661_rx_ring *ring,
                        goto fail;
                }
 
-               data->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               data->m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (data->m == NULL) {
                        device_printf(sc->sc_dev,
                            "could not allocate rx mbuf\n");
@@ -1028,7 +1028,7 @@ rt2661_rx_intr(struct rt2661_softc *sc)
                 * mbuf. In the unlikely case that the old mbuf can't be
                 * reloaded either, explicitly panic.
                 */
-               mnew = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (mnew == NULL) {
                        IFNET_STAT_INC(ifp, ierrors, 1);
                        goto skip;
@@ -1526,7 +1526,7 @@ rt2661_tx_data(struct rt2661_softc *sc, struct mbuf *m0,
                return error;
        }
        if (error != 0) {
-               mnew = m_defrag(m0, MB_DONTWAIT);
+               mnew = m_defrag(m0, M_NOWAIT);
                if (mnew == NULL) {
                        device_printf(sc->sc_dev,
                            "could not defragment mbuf\n");
index 147e4db..c431bbb 100644 (file)
@@ -741,7 +741,7 @@ rt2860_alloc_rx_ring(struct rt2860_softc *sc, struct rt2860_rx_ring *ring)
                        goto fail;
                }
 
-               data->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               data->m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (data->m == NULL) {
                        device_printf(sc->sc_dev,
                            "could not allocate rx mbuf\n");
@@ -1236,7 +1236,7 @@ rt2860_rx_intr(struct rt2860_softc *sc)
                }
 #endif
 
-               m1 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m1 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (__predict_false(m1 == NULL)) {
                        IFNET_STAT_INC(ifp, ierrors, 1);
                        goto skip;
@@ -1615,7 +1615,7 @@ rt2860_tx(struct rt2860_softc *sc, struct mbuf *m, struct ieee80211_node *ni)
                }
        }
        if (__predict_false(error != 0)) {
-               m1 = m_defrag(m, MB_DONTWAIT);
+               m1 = m_defrag(m, M_NOWAIT);
                if (m1 == NULL) {
                        device_printf(sc->sc_dev,
                            "could not defragment mbuf\n");
@@ -1868,7 +1868,7 @@ rt2860_tx_raw(struct rt2860_softc *sc, struct mbuf *m,
                }
        }
        if (__predict_false(error != 0)) {
-               m1 = m_defrag(m, MB_DONTWAIT);
+               m1 = m_defrag(m, M_NOWAIT);
                if (m1 == NULL) {
                        device_printf(sc->sc_dev,
                            "could not defragment mbuf\n");
index 985dba4..c660574 100644 (file)
@@ -814,7 +814,7 @@ re_diag(struct re_softc *sc)
 
        /* Allocate a single mbuf */
 
-       MGETHDR(m0, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m0, M_NOWAIT, MT_DATA);
        if (m0 == NULL)
                return(ENOBUFS);
 
@@ -1741,7 +1741,7 @@ re_newbuf_std(struct re_softc *sc, int idx, int init)
        struct mbuf *m;
        int error, nsegs;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                error = ENOBUFS;
 
@@ -1798,7 +1798,7 @@ re_newbuf_jumbo(struct re_softc *sc, int idx, int init)
        struct re_jbuf *jbuf;
        int error = 0;
 
-       MGETHDR(m, init ? MB_WAIT : MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, init ? M_WAITOK : M_NOWAIT, MT_DATA);
        if (m == NULL) {
                error = ENOBUFS;
                if (init) {
index 86285fe..b95aa26 100644 (file)
@@ -1300,7 +1300,7 @@ rl_encap(struct rl_softc *sc, struct mbuf *m_head)
         * TX buffers, plus we can only have one fragment buffer
         * per packet.  We have to copy pretty much all the time.
         */
-       m_new = m_defrag(m_head, MB_DONTWAIT);
+       m_new = m_defrag(m_head, M_NOWAIT);
        if (m_new == NULL) {
                m_freem(m_head);
                return ENOBUFS;
index 0be2a05..297dd10 100644 (file)
@@ -1203,7 +1203,7 @@ rtw_rxsoft_alloc(struct rtw_softc *sc, struct rtw_rxsoft *rs, int waitok)
        struct mbuf *m;
        int rc;
 
-       m = m_getcl(waitok ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(waitok ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return ENOBUFS;
 
@@ -3066,7 +3066,7 @@ rtw_load_txbuf(struct rtw_softc *sc, struct rtw_txsoft *ts,
                if (error == 0)
                        bus_dmamap_unload(sc->sc_txsoft_dmat, ts->ts_dmamap);
 
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL) {
                        if_printf(&sc->sc_ic.ic_if, "can't defrag tx mbuf\n");
                        error = ENOBUFS;
index f071b96..b2b5b33 100644 (file)
@@ -798,7 +798,7 @@ get_rx_buf(struct sbni_softc *sc)
 {
        struct mbuf *m;
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL) {
                kprintf("%s: cannot allocate header mbuf\n",
                       sc->arpcom.ac_if.if_xname);
@@ -813,7 +813,7 @@ get_rx_buf(struct sbni_softc *sc)
         */
        if (ETHER_MAX_LEN + 2 > MHLEN) {
                /* Attach an mbuf cluster */
-               MCLGET(m, MB_DONTWAIT);
+               MCLGET(m, M_NOWAIT);
                if ((m->m_flags & M_EXT) == 0) {
                        m_freem(m);
                        return (0);
index 3d81414..78c3301 100644 (file)
@@ -681,7 +681,7 @@ repack(struct sbsh_softc *sc, struct mbuf *m)
 {
        struct mbuf  *m_new;
 
-       MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m_new, M_NOWAIT, MT_DATA);
        if (!m_new) {
                if_printf (&sc->arpcom.ac_if,
                           "unable to get mbuf.\n");
@@ -689,7 +689,7 @@ repack(struct sbsh_softc *sc, struct mbuf *m)
        }
 
        if (m->m_pkthdr.len > MHLEN) {
-               MCLGET(m_new, MB_DONTWAIT);
+               MCLGET(m_new, M_NOWAIT);
                if (!(m_new->m_flags & M_EXT)) {
                        m_freem(m_new);
                        if_printf (&sc->arpcom.ac_if,
@@ -738,7 +738,7 @@ alloc_rx_buffers(struct sbsh_softc *sc)
        struct mbuf     *m;
 
        while (sc->tail_rq != ((sc->head_rq - 1) & (RQLEN - 1))) {
-               MGETHDR(m, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m, M_NOWAIT, MT_DATA);
                if (!m) {
                        if_printf (&sc->arpcom.ac_if,
                                   "unable to get mbuf.\n");
@@ -746,7 +746,7 @@ alloc_rx_buffers(struct sbsh_softc *sc)
                }
 
                if (SBNI16_MAX_FRAME > MHLEN) {
-                       MCLGET(m, MB_DONTWAIT);
+                       MCLGET(m, M_NOWAIT);
                        if (!(m->m_flags & M_EXT)) {
                                m_freem(m);
                                if_printf (&sc->arpcom.ac_if,
index 3405c80..ad44580 100644 (file)
@@ -871,11 +871,11 @@ sf_newbuf(struct sf_softc *sc, struct sf_rx_bufdesc_type0 *c,
        struct mbuf             *m_new = NULL;
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL)
                        return(ENOBUFS);
 
-               MCLGET(m_new, MB_DONTWAIT);
+               MCLGET(m_new, M_NOWAIT);
                if (!(m_new->m_flags & M_EXT)) {
                        m_freem(m_new);
                        return(ENOBUFS);
@@ -1302,7 +1302,7 @@ again:
                                continue;
                        }
 
-                       m_defragged = m_defrag(m_head, MB_DONTWAIT);
+                       m_defragged = m_defrag(m_head, M_NOWAIT);
                        if (m_defragged == NULL) {
                                m_freem(m_head);
                                continue;
index d84a657..5e0c2b5 100644 (file)
@@ -1293,7 +1293,7 @@ sis_newbuf(struct sis_softc *sc, int idx, int init)
        struct mbuf *m;
        int nseg, error;
 
-       m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL) {
                if (init)
                        if_printf(&sc->arpcom.ac_if, "can't alloc RX mbuf\n");
index 4f237b5..f961eb9 100644 (file)
@@ -762,7 +762,7 @@ sk_newbuf_jumbo(struct sk_if_softc *sc_if, int idx, int wait)
 
        KKASSERT(idx < SK_RX_RING_CNT && idx >= 0);
 
-       MGETHDR(m_new, wait ? MB_WAIT : MB_DONTWAIT, MT_DATA);
+       MGETHDR(m_new, wait ? M_WAITOK : M_NOWAIT, MT_DATA);
        if (m_new == NULL)
                return ENOBUFS;
 
@@ -818,7 +818,7 @@ sk_newbuf_std(struct sk_if_softc *sc_if, int idx, int wait)
 
        KKASSERT(idx < SK_RX_RING_CNT && idx >= 0);
 
-       m_new = m_getcl(wait ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(wait ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL)
                return ENOBUFS;
 
index 82bda0b..5086e07 100644 (file)
@@ -751,14 +751,14 @@ sln_tx(struct ifnet *ifp, struct ifaltq_subque *ifsq)
                if (m_head == NULL)
                        break;
 
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL) {
                        if_printf(ifp, "no memory for tx descriptor");
                        m_freem(m_head);
                        break;
                }
                if ((m_head->m_pkthdr.len > MHLEN) || (60 > MHLEN)) {
-                       MCLGET(m_new, MB_DONTWAIT);
+                       MCLGET(m_new, M_NOWAIT);
                        if (!(m_new->m_flags & M_EXT)) {
                                m_freem(m_new);
                                m_freem(m_head);
index 03f44ec..066a07a 100644 (file)
@@ -1016,7 +1016,7 @@ read_another:
        /*
         * Allocate a header mbuf from the kernel.
         */
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL)
                goto out;
 
@@ -1026,7 +1026,7 @@ read_another:
        /*
         * Attach an mbuf cluster
         */
-       MCLGET(m, MB_DONTWAIT);
+       MCLGET(m, M_NOWAIT);
 
        /*
         * Insist on getting a cluster
index 8fc8796..fbb5661 100644 (file)
@@ -1992,7 +1992,7 @@ sr_get_packets(struct sr_softc *sc)
                               sc->unit, rxstat, len);
 #endif
 
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT, MT_DATA);
                        if (m == NULL) {
                                /*
                                 * eat (flush) packet if get mbuf fail!!
@@ -2010,7 +2010,7 @@ sr_get_packets(struct sr_softc *sc)
 #endif /* NETGRAPH */
                        m->m_pkthdr.len = m->m_len = len;
                        if (len > MHLEN) {
-                               MCLGET(m, MB_DONTWAIT);
+                               MCLGET(m, M_NOWAIT);
                                if ((m->m_flags & M_EXT) == 0) {
                                        /*
                                         * We couldn't get a big enough
index 4360728..10c081a 100644 (file)
@@ -1024,10 +1024,10 @@ ste_newbuf(struct ste_softc *sc, struct ste_chain_onefrag *c,
        struct mbuf             *m_new = NULL;
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL)
                        return(ENOBUFS);
-               MCLGET(m_new, MB_DONTWAIT);
+               MCLGET(m_new, M_NOWAIT);
                if (!(m_new->m_flags & M_EXT)) {
                        m_freem(m_new);
                        return(ENOBUFS);
@@ -1378,13 +1378,13 @@ encap_retry:
                 * mbuf chain first. Bail out if we can't get the
                 * new buffers.  Code borrowed from if_fxp.c.
                 */
-               MGETHDR(mn, MB_DONTWAIT, MT_DATA);
+               MGETHDR(mn, M_NOWAIT, MT_DATA);
                if (mn == NULL) {
                        m_freem(m_head);
                        return ENOMEM;
                }
                if (m_head->m_pkthdr.len > MHLEN) {
-                       MCLGET(mn, MB_DONTWAIT);
+                       MCLGET(mn, M_NOWAIT);
                        if ((mn->m_flags & M_EXT) == 0) {
                                m_freem(mn);
                                m_freem(m_head);
index 3a36181..31dc548 100644 (file)
@@ -1528,7 +1528,7 @@ stge_fixup_rx(struct stge_softc *sc, struct mbuf *m)
                m->m_data += ETHER_HDR_LEN;
                n = m;
        } else {
-               MGETHDR(n, MB_DONTWAIT, MT_DATA);
+               MGETHDR(n, M_NOWAIT, MT_DATA);
                if (n != NULL) {
                        bcopy(m->m_data, n->m_data, ETHER_HDR_LEN);
                        m->m_data += ETHER_HDR_LEN;
@@ -2325,7 +2325,7 @@ stge_newbuf(struct stge_softc *sc, int idx, int waitok)
        bus_dmamap_t map;
        int error, nseg;
 
-       m = m_getcl(waitok ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m = m_getcl(waitok ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m == NULL)
                return ENOBUFS;
        m->m_len = m->m_pkthdr.len = MCLBYTES;
index 2dc4609..b37c3b9 100644 (file)
@@ -692,7 +692,7 @@ ti_newbuf_std(struct ti_softc *sc, int i, struct mbuf *m)
        struct ti_rx_desc *r;
 
        if (m == NULL) {
-               m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m_new = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (m_new == NULL)
                        return (ENOBUFS);
                m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
@@ -728,7 +728,7 @@ ti_newbuf_mini(struct ti_softc *sc, int i, struct mbuf *m)
        struct ti_rx_desc *r;
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL) {
                        return(ENOBUFS);
                }
@@ -766,7 +766,7 @@ ti_newbuf_jumbo(struct ti_softc *sc, int i, struct mbuf *m)
 
        if (m == NULL) {
                /* Allocate the mbuf. */
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL) {
                        return(ENOBUFS);
                }
index 02171ac..0057a57 100644 (file)
@@ -1345,7 +1345,7 @@ tl_newbuf(struct tl_softc *sc, struct tl_chain_onefrag *c)
 {
        struct mbuf *m_new;
 
-       m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL)
                return (ENOBUFS);
 
@@ -1771,7 +1771,7 @@ tl_encap(struct tl_softc *sc, struct tl_chain *c, struct mbuf *m_head)
        if (m != NULL) {
                struct mbuf *m_new;
 
-               m_new = m_getl(m_head->m_pkthdr.len, MB_DONTWAIT, MT_DATA,
+               m_new = m_getl(m_head->m_pkthdr.len, M_NOWAIT, MT_DATA,
                               M_PKTHDR, NULL);
                if (m_new == NULL) {
                        if_printf(&sc->arpcom.ac_if, "no memory for tx list\n");
index caf4820..7c66ce7 100644 (file)
@@ -510,7 +510,7 @@ epic_ifstart(struct ifnet *ifp, struct ifaltq_subque *ifsq)
                /* If packet was more than EPIC_MAX_FRAGS parts, */
                /* recopy packet to new allocated mbuf cluster */
                if (NULL != m) {
-                       m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+                       m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                        if (NULL == m) {
                                m_freem(m0);
                                IFNET_STAT_INC(ifp, oerrors, 1);
@@ -584,7 +584,7 @@ epic_rx_done(epic_softc_t *sc)
                m = buf->mbuf;
 
                /* Try to get mbuf cluster */
-               buf->mbuf = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               buf->mbuf = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (NULL == buf->mbuf) {
                        buf->mbuf = m;
                        desc->status = 0x8000;
@@ -1289,7 +1289,7 @@ epic_queue_last_packet(epic_softc_t *sc)
        if ((desc->status & 0x8000) || (buf->mbuf != NULL))
                return (EBUSY);
 
-       MGETHDR(m0, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m0, M_NOWAIT, MT_DATA);
        if (NULL == m0)
                return (ENOBUFS);
 
@@ -1420,7 +1420,7 @@ epic_init_rings(epic_softc_t *sc)
                        return EFAULT;
                }
 
-               buf->mbuf = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               buf->mbuf = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (NULL == buf->mbuf) {
                        epic_free_rings(sc);
                        return ENOBUFS;
index 0042f51..f97bb29 100644 (file)
@@ -686,13 +686,13 @@ txp_rx_reclaim(struct txp_softc *sc, struct txp_rx_ring *r)
                         */
                        struct mbuf *mnew;
 
-                       MGETHDR(mnew, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(mnew, M_NOWAIT, MT_DATA);
                        if (mnew == NULL) {
                                m_freem(m);
                                goto next;
                        }
                        if (m->m_len > (MHLEN - 2)) {
-                               MCLGET(mnew, MB_DONTWAIT);
+                               MCLGET(mnew, M_NOWAIT);
                                if (!(mnew->m_flags & M_EXT)) {
                                        m_freem(mnew);
                                        m_freem(m);
@@ -764,11 +764,11 @@ txp_rxbuf_reclaim(struct txp_softc *sc)
                if (sd->sd_mbuf != NULL)
                        break;
 
-               MGETHDR(sd->sd_mbuf, MB_DONTWAIT, MT_DATA);
+               MGETHDR(sd->sd_mbuf, M_NOWAIT, MT_DATA);
                if (sd->sd_mbuf == NULL)
                        goto err_sd;
 
-               MCLGET(sd->sd_mbuf, MB_DONTWAIT);
+               MCLGET(sd->sd_mbuf, M_NOWAIT);
                if ((sd->sd_mbuf->m_flags & M_EXT) == 0)
                        goto err_mbuf;
                sd->sd_mbuf->m_pkthdr.rcvif = ifp;
@@ -1047,11 +1047,11 @@ txp_rxring_fill(struct txp_softc *sc)
 
        for (i = 0; i < RXBUF_ENTRIES; i++) {
                sd = sc->sc_rxbufs[i].rb_sd;
-               MGETHDR(sd->sd_mbuf, MB_DONTWAIT, MT_DATA);
+               MGETHDR(sd->sd_mbuf, M_NOWAIT, MT_DATA);
                if (sd->sd_mbuf == NULL)
                        return(ENOBUFS);
 
-               MCLGET(sd->sd_mbuf, MB_DONTWAIT);
+               MCLGET(sd->sd_mbuf, M_NOWAIT);
                if ((sd->sd_mbuf->m_flags & M_EXT) == 0) {
                        m_freem(sd->sd_mbuf);
                        return(ENOBUFS);
@@ -1230,7 +1230,7 @@ again:
                                goto oactive;
                        }
 
-                       m_defragged = m_defrag(m, MB_DONTWAIT);
+                       m_defragged = m_defrag(m, M_NOWAIT);
                        if (m_defragged == NULL) {
                                m_freem(m);
                                continue;
index f3bc6b4..74ead1e 100644 (file)
@@ -1112,7 +1112,7 @@ vge_newbuf(struct vge_softc *sc, int idx, struct mbuf *m)
        int i, error;
 
        if (m == NULL) {
-               n = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               n = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (n == NULL)
                        return (ENOBUFS);
                m = n;
@@ -1638,7 +1638,7 @@ vge_encap(struct vge_softc *sc, struct mbuf *m_head, int idx)
        if (error || arg.vge_maxsegs == 0) {
                struct mbuf *m_new;
 
-               m_new = m_defrag(m_head, MB_DONTWAIT);
+               m_new = m_defrag(m_head, M_NOWAIT);
                if (m_new == NULL) {
                        error = ENOBUFS;
                        goto fail;
index eda67d8..4e8da76 100644 (file)
@@ -930,7 +930,7 @@ vr_newbuf(struct vr_softc *sc, struct vr_chain_onefrag *c, struct mbuf *m)
        struct mbuf *m_new = NULL;
 
        if (m == NULL) {
-               m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m_new = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (m_new == NULL)
                        return (ENOBUFS);
                m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
index 513aa43..4a15c85 100644 (file)
@@ -28,8 +28,6 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/vx/if_vx.c,v 1.25.2.6 2002/02/13 00:43:10 dillon Exp $
- * $DragonFly: src/sys/dev/netif/vx/if_vx.c,v 1.29 2008/05/14 11:59:22 sephe Exp $
- *
  */
 
 /*
@@ -738,7 +736,7 @@ vxget(struct vx_softc *sc, u_int totlen)
     m = sc->mb[sc->next_mb];
     sc->mb[sc->next_mb] = NULL;
     if (m == NULL) {
-        MGETHDR(m, MB_DONTWAIT, MT_DATA);
+        MGETHDR(m, M_NOWAIT, MT_DATA);
         if (m == NULL)
             return NULL;
     } else {
@@ -777,7 +775,7 @@ vxget(struct vx_softc *sc, u_int totlen)
             m = sc->mb[sc->next_mb];
             sc->mb[sc->next_mb] = NULL;
             if (m == NULL) {
-                MGET(m, MB_DONTWAIT, MT_DATA);
+                MGET(m, M_NOWAIT, MT_DATA);
                 if (m == NULL) {
                     crit_exit();
                     m_freem(top);
@@ -789,7 +787,7 @@ vxget(struct vx_softc *sc, u_int totlen)
             len = MLEN;
         }
         if (totlen >= MINCLSIZE) {
-           MCLGET(m, MB_DONTWAIT);
+           MCLGET(m, M_NOWAIT);
            if (m->m_flags & M_EXT)
                len = MCLBYTES;
         }
@@ -963,7 +961,7 @@ vxmbuffill_serialized(void *sp)
     i = sc->last_mb;
     do {
        if (sc->mb[i] == NULL)
-           MGET(sc->mb[i], MB_DONTWAIT, MT_DATA);
+           MGET(sc->mb[i], M_NOWAIT, MT_DATA);
        if (sc->mb[i] == NULL)
            break;
        i = (i + 1) % MAX_MBS;
index 66c8147..71081aa 100644 (file)
@@ -929,7 +929,7 @@ wb_newbuf(struct wb_softc *sc, struct wb_chain_onefrag *c, struct mbuf *m)
        struct mbuf *m_new = NULL;
 
        if (m == NULL) {
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL)
                        return(ENOBUFS);
 
@@ -1247,11 +1247,11 @@ wb_encap(struct wb_softc *sc, struct wb_chain *c, struct mbuf *m_head)
        if (m != NULL) {
                struct mbuf *m_new = NULL;
 
-               MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m_new, M_NOWAIT, MT_DATA);
                if (m_new == NULL)
                        return(1);
                if (m_head->m_pkthdr.len > MHLEN) {
-                       MCLGET(m_new, MB_DONTWAIT);
+                       MCLGET(m_new, M_NOWAIT);
                        if ((m_new->m_flags & M_EXT) == 0) {
                                m_freem(m_new);
                                return(1);
index b8ace23..8e5f3d1 100644 (file)
@@ -1319,9 +1319,9 @@ wi_rx_intr(struct wi_softc *sc)
        }
 
        if (off + len > MHLEN)
-               m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
        else
-               m = m_gethdr(MB_DONTWAIT, MT_DATA);
+               m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL) {
                CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX);
                IFNET_STAT_INC(ifp, ierrors, 1);
index 97ea955..5bebf5b 100644 (file)
@@ -1033,7 +1033,7 @@ wpi_alloc_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring)
                            __func__, error);
                        goto fail;
                }
-               m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
+               m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
                if (m == NULL) {
                        device_printf(sc->sc_dev,
                           "%s: could not allocate rx mbuf\n", __func__);
@@ -1556,7 +1556,7 @@ wpi_rx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc,
        }
 
        /* XXX don't need mbuf, just dma buffer */
-       mnew = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
+       mnew = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
        if (mnew == NULL) {
                DPRINTFN(WPI_DEBUG_RX, ("%s: no mbuf to restock ring\n",
                    __func__));
@@ -2066,7 +2066,7 @@ wpi_tx_data(struct wpi_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
        }
        if (error != 0) {
                /* XXX use m_collapse */
-               mnew = m_defrag(m0, MB_DONTWAIT);
+               mnew = m_defrag(m0, M_NOWAIT);
                if (mnew == NULL) {
                        device_printf(sc->sc_dev,
                            "could not defragment mbuf\n");
index c061e64..a2a4e9c 100644 (file)
@@ -765,14 +765,14 @@ xe_intr(void *xscp)
         * packet length (we always read 16-bit words).
         * XXX - Surely there's a better way to do this alignment?
         */
-       MGETHDR(mbp, MB_DONTWAIT, MT_DATA);
+       MGETHDR(mbp, M_NOWAIT, MT_DATA);
        if (mbp == NULL) {
          IFNET_STAT_INC(ifp, iqdrops, 1);
          continue;
        }
 
        if (len + 3 > MHLEN) {
-         MCLGET(mbp, MB_DONTWAIT);
+         MCLGET(mbp, M_NOWAIT);
          if ((mbp->m_flags & M_EXT) == 0) {
            m_freem(mbp);
            IFNET_STAT_INC(ifp, iqdrops, 1);
index 0bd5632..692b892 100644 (file)
@@ -1881,7 +1881,7 @@ xl_newbuf(struct xl_softc *sc, struct xl_chain_onefrag *c, int init)
        int                     error, nsegs;
        bus_dma_segment_t       seg;
 
-       m_new = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
+       m_new = m_getcl(init ? M_WAITOK : M_NOWAIT, MT_DATA, M_PKTHDR);
        if (m_new == NULL)
                return(ENOBUFS);
 
index 7311314..c5fec4e 100644 (file)
@@ -1183,7 +1183,7 @@ vtnet_alloc_rxbuf(struct vtnet_softc *sc, int nbufs, struct mbuf **m_tailp)
 
        /*use getcl instead of getjcl. see  if_mxge.c comment line 2398*/
        //m_head = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, clsize);
-       m_head = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR );
+       m_head = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR );
        if (m_head == NULL)
                goto fail;
 
@@ -1196,7 +1196,7 @@ vtnet_alloc_rxbuf(struct vtnet_softc *sc, int nbufs, struct mbuf **m_tailp)
 
                for (i = 0; i < nbufs - 1; i++) {
                        //m = m_getjcl(M_DONTWAIT, MT_DATA, 0, clsize);
-                       m = m_getcl(MB_DONTWAIT, MT_DATA, 0);
+                       m = m_getcl(M_NOWAIT, MT_DATA, 0);
                        if (m == NULL)
                                goto fail;
 
@@ -1850,8 +1850,8 @@ again:
                if (collapsed)
                        goto fail;
 
-               //m = m_collapse(m, MB_DONTWAIT, VTNET_MAX_TX_SEGS - 1);
-               m = m_defrag(m, MB_DONTWAIT);
+               //m = m_collapse(m, M_NOWAIT, VTNET_MAX_TX_SEGS - 1);
+               m = m_defrag(m, M_NOWAIT);
                if (m == NULL)
                        goto fail;
 
@@ -1878,13 +1878,13 @@ vtnet_vlan_tag_insert(struct mbuf *m)
        struct ether_vlan_header *evl;
 
        if (M_WRITABLE(m) == 0) {
-               n = m_dup(m, MB_DONTWAIT);
+               n = m_dup(m, M_NOWAIT);
                m_freem(m);
                if ((m = n) == NULL)
                        return (NULL);
        }
 
-       M_PREPEND(m, ETHER_VLAN_ENCAP_LEN, MB_DONTWAIT);
+       M_PREPEND(m, ETHER_VLAN_ENCAP_LEN, M_NOWAIT);
        if (m == NULL)
                return (NULL);
        if (m->m_len < sizeof(struct ether_vlan_header)) {
index 32e45ba..7856e6f 100644 (file)
@@ -316,7 +316,7 @@ vke_init(void *xsc)
        sc->sc_rxfifo->array = kmalloc(ringsize, M_DEVBUF, M_WAITOK | M_ZERO);
 
        for (i = 0; i < sc->sc_ringsize; i++) {
-               sc->sc_rxfifo->array[i] = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
+               sc->sc_rxfifo->array[i] = m_getcl(M_WAITOK, MT_DATA, M_PKTHDR);
                sc->sc_txfifo->array[i] = NULL;
                sc->sc_txfifo_done->array[i] = NULL;
        }
@@ -536,7 +536,7 @@ vke_rx_intr(cothread_t cotd)
        cothread_unlock(cotd, 0);
 
        while ((m = vke_rxfifo_sniff(sc)) != NULL) {
-               nm = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
+               nm = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
                if (nm) {
                        vke_rxfifo_dequeue(sc, nm);
                        ifp->if_input(ifp, m, NULL, -1);
index d50b05e..bfd67dd 100644 (file)
@@ -274,7 +274,7 @@ sys_osendmsg(struct osendmsg_args *uap)
                        error = EINVAL;
                        goto cleanup;
                }
-               control = m_get(MB_WAIT, MT_CONTROL);
+               control = m_get(M_WAITOK, MT_CONTROL);
                if (control == NULL) {
                        error = ENOBUFS;
                        goto cleanup;
@@ -293,7 +293,7 @@ sys_osendmsg(struct osendmsg_args *uap)
                 * control data with the proper cmsghdr structure
                 * so that the kernel recognizes it as access rights.
                 */
-               M_PREPEND(control, sizeof(*cm), MB_WAIT);
+               M_PREPEND(control, sizeof(*cm), M_WAITOK);
                if (control == NULL) {
                        error = ENOBUFS;
                        goto cleanup;
index 5912a55..633a728 100644 (file)
@@ -868,7 +868,7 @@ linux_sendmsg(struct linux_sendmsg_args *args, size_t *res)
                        error = EINVAL;
                        goto cleanup;
                }
-               control = m_get(MB_WAIT, MT_CONTROL);
+               control = m_get(M_WAITOK, MT_CONTROL);
                if (control == NULL) {
                        error = ENOBUFS;
                        goto cleanup;
index 5143334..b10282a 100644 (file)
@@ -668,9 +668,9 @@ ndis_ptom(struct mbuf **m0, ndis_packet *p)
        for (buf = priv->npp_head; buf != NULL; buf = buf->mdl_next) {
                if (buf == priv->npp_head) {
                        /* XXX swildner: why not MT_HEADER? (see FreeBSD) */
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT, MT_DATA);
                } else {
-                       MGET(m, MB_DONTWAIT, MT_DATA);
+                       MGET(m, M_NOWAIT, MT_DATA);
                }
                if (m == NULL) {
                        m_freem(*m0);
index f62de35..8ba5da5 100644 (file)
@@ -71,7 +71,7 @@ mb_init(struct mbchain *mbp)
 {
        struct mbuf *m;
 
-       m = m_gethdr(MB_WAIT, MT_DATA);
+       m = m_gethdr(M_WAITOK, MT_DATA);
        if (m == NULL) 
                return ENOBUFS;
        m->m_pkthdr.rcvif = NULL;
@@ -129,7 +129,7 @@ mb_reserve(struct mbchain *mbp, int size)
                panic("mb_reserve: size = %d", size);
        m = mbp->mb_cur;
        if (mbp->mb_mleft < size) {
-               mn = m_get(MB_WAIT, MT_DATA);
+               mn = m_get(M_WAITOK, MT_DATA);
                if (mn == NULL)
                        return NULL;
                mbp->mb_cur = m->m_next = mn;
@@ -207,7 +207,7 @@ 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_next = m_getc(size, MB_WAIT, MT_DATA);
+                               m->m_next = m_getc(size, M_WAITOK, MT_DATA);
                                if (m->m_next == NULL)
                                        return ENOBUFS;
                        }
@@ -311,7 +311,7 @@ md_init(struct mdchain *mdp)
 {
        struct mbuf *m;
 
-       m = m_gethdr(MB_WAIT, MT_DATA);
+       m = m_gethdr(M_WAITOK, MT_DATA);
        if (m == NULL) 
                return ENOBUFS;
        m->m_pkthdr.rcvif = NULL;
@@ -520,7 +520,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, MB_WAIT);
+       rm = m_copym(m, mdp->md_pos - mtod(m, u_char*), size, M_WAITOK);
        if (rm == NULL)
                return EBADRPC;
        md_get_mem(mdp, NULL, size, MB_MZERO);
index 3e4e797..41a015b 100644 (file)
@@ -129,7 +129,7 @@ bus_dmamap_load_mbuf_defrag(bus_dma_tag_t dmat, bus_dmamap_t map,
        if (error == EFBIG) {
                struct mbuf *m_new;
 
-               m_new = m_defrag(m, MB_DONTWAIT);
+               m_new = m_defrag(m, M_NOWAIT);
                if (m_new == NULL)
                        return ENOBUFS;
                else
index a4bc987..81fa933 100644 (file)
@@ -847,14 +847,14 @@ m_get(int how, int type)
 {
        struct mbuf *m;
        int ntries = 0;
-       int ocf = MBTOM(how);
+       int ocf = MB_OCFLAG(how);
 
 retryonce:
 
        m = objcache_get(mbuf_cache, ocf);
 
        if (m == NULL) {
-               if ((how & MB_TRYWAIT) && ntries++ == 0) {
+               if ((ocf & M_WAITOK) && ntries++ == 0) {
                        struct objcache *reclaimlist[] = {
                                mbufphdr_cache,
                                mbufcluster_cache,
@@ -884,7 +884,7 @@ struct mbuf *
 m_gethdr(int how, int type)
 {
        struct mbuf *m;
-       int ocf = MBTOM(how);
+       int ocf = MB_OCFLAG(how);
        int ntries = 0;
 
 retryonce:
@@ -892,7 +892,7 @@ retryonce:
        m = objcache_get(mbufphdr_cache, ocf);
 
        if (m == NULL) {
-               if ((how & MB_TRYWAIT) && ntries++ == 0) {
+               if ((ocf & M_WAITOK) && ntries++ == 0) {
                        struct objcache *reclaimlist[] = {
                                mbuf_cache,
                                mbufcluster_cache, mbufphdrcluster_cache,
@@ -937,7 +937,7 @@ m_getcl_cache(int how, short type, int flags, struct objcache *mbclc,
     struct objcache *mbphclc, u_long *cl_stats)
 {
        struct mbuf *m = NULL;
-       int ocflags = MBTOM(how);
+       int ocflags = MB_OCFLAG(how);
        int ntries = 0;
 
 retryonce:
@@ -948,7 +948,7 @@ retryonce:
                m = objcache_get(mbclc, ocflags);
 
        if (m == NULL) {
-               if ((how & MB_TRYWAIT) && ntries++ == 0) {
+               if ((ocflags & M_WAITOK) && ntries++ == 0) {
                        struct objcache *reclaimlist[1];
 
                        if (flags & M_PKTHDR)
@@ -1077,7 +1077,7 @@ m_mclget(struct mbuf *m, int how)
        struct mbcluster *mcl;
 
        KKASSERT((m->m_flags & M_EXT) == 0);
-       mcl = objcache_get(mclmeta_cache, MBTOM(how));
+       mcl = objcache_get(mclmeta_cache, MB_OCFLAG(how));
        if (mcl != NULL) {
                linkcluster(m, mcl);
                ++mbstat[mycpu->gd_cpuid].m_clusters;
@@ -1363,7 +1363,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 MB_WAIT/MB_DONTWAIT from caller.
+ * The wait parameter is a choice of M_WAITOK/M_NOWAIT from caller.
  * Note that the copy is read-only, because clusters are not copied,
  * only their reference counts are incremented.
  */
@@ -1601,8 +1601,8 @@ nospace0:
  * copying any mbuf clusters.  This is typically used to realign a data
  * chain by nfs_realign().
  *
- * The original chain is left intact.  how should be MB_WAIT or MB_DONTWAIT
- * and NULL can be returned if MB_DONTWAIT is passed.
+ * The original chain is left intact.  how should be M_WAITOK or M_NOWAIT
+ * and NULL can be returned if M_NOWAIT is passed.
  *
  * Be careful to use cluster mbufs, a large mbuf chain converted to non
  * cluster mbufs can exhaust our supply of mbufs.
@@ -1964,9 +1964,9 @@ m_pullup(struct mbuf *n, int len)
                if (len > MHLEN)
                        goto bad;
                if (n->m_flags & M_PKTHDR)
-                       m = m_gethdr(MB_DONTWAIT, n->m_type);
+                       m = m_gethdr(M_NOWAIT, n->m_type);
                else
-                       m = m_get(MB_DONTWAIT, n->m_type);
+                       m = m_get(M_NOWAIT, n->m_type);
                if (m == NULL)
                        goto bad;
                m->m_len = 0;
@@ -2086,7 +2086,7 @@ m_devget(char *buf, int len, int offset, struct ifnet *ifp,
        flags = M_PKTHDR;
 
        while (len > 0) {
-               m = m_getl(len, MB_DONTWAIT, MT_DATA, flags, &nsize);
+               m = m_getl(len, M_NOWAIT, MT_DATA, flags, &nsize);
                if (m == NULL) {
                        m_freem(mfirst);
                        return (NULL);
@@ -2141,7 +2141,7 @@ m_devpad(struct mbuf *m, int padto)
                        struct mbuf *n;
 
                        /* Allocate new empty mbuf, pad it.  Compact later. */
-                       MGET(n, MB_DONTWAIT, MT_DATA);
+                       MGET(n, M_NOWAIT, MT_DATA);
                        if (n == NULL)
                                return ENOBUFS;
                        n->m_len = 0;
@@ -2177,7 +2177,7 @@ m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
                off -= mlen;
                totlen += mlen;
                if (m->m_next == NULL) {
-                       n = m_getclr(MB_DONTWAIT, m->m_type);
+                       n = m_getclr(M_NOWAIT, m->m_type);
                        if (n == NULL)
                                goto out;
                        n->m_len = min(MLEN, len + off);
@@ -2196,7 +2196,7 @@ m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
                if (len == 0)
                        break;
                if (m->m_next == NULL) {
-                       n = m_get(MB_DONTWAIT, m->m_type);
+                       n = m_get(M_NOWAIT, m->m_type);
                        if (n == NULL)
                                break;
                        n->m_len = min(MLEN, len);
@@ -2240,7 +2240,7 @@ m_append(struct mbuf *m0, int len, c_caddr_t cp)
                 * Allocate a new mbuf; could check space
                 * and allocate a cluster instead.
                 */
-               n = m_get(MB_DONTWAIT, m->m_type);
+               n = m_get(M_NOWAIT, m->m_type);
                if (n == NULL)
                        break;
                n->m_len = min(MLEN, remainder);
@@ -2468,7 +2468,7 @@ m_uiomove(struct uio *uio)
                        resid = INT_MAX;
                else
                        resid = (int)uio->uio_resid;
-               m = m_getl(resid, MB_WAIT, MT_DATA, flags, &nsize);
+               m = m_getl(resid, M_WAITOK, MT_DATA, flags, &nsize);
                if (flags) {
                        m->m_pkthdr.len = 0;
                        /* Leave room for protocol headers. */
index 4bd412d..50129ad 100644 (file)
@@ -1,5 +1,4 @@
 /*     $FreeBSD: src/sys/kern/uipc_mbuf2.c,v 1.2.2.5 2003/01/23 21:06:44 sam Exp $     */
-/*     $DragonFly: src/sys/kern/uipc_mbuf2.c,v 1.15 2007/10/20 10:28:44 sephe Exp $    */
 /*     $KAME: uipc_mbuf2.c,v 1.31 2001/11/28 11:08:53 itojun Exp $     */
 /*     $NetBSD: uipc_mbuf.c,v 1.40 1999/04/01 00:23:25 thorpej Exp $   */
 
@@ -142,7 +141,7 @@ m_pulldown(struct mbuf *m, int off, int len, int *offp)
         * chop the current mbuf into two pieces, set off to 0.
         */
        if (len <= n->m_len - off) {
-               o = m_dup1(n, off, n->m_len - off, MB_DONTWAIT);
+               o = m_dup1(n, off, n->m_len - off, M_NOWAIT);
                if (o == NULL) {
                        m_freem(m);
                        return NULL;    /* ENOBUFS */
@@ -201,7 +200,7 @@ m_pulldown(struct mbuf *m, int off, int len, int *offp)
         * now, we need to do the hard way.  don't m_copy as there's no room
         * on both end.
         */
-       o = m_getl(len, MB_DONTWAIT, m->m_type, 0, NULL);
+       o = m_getl(len, M_NOWAIT, m->m_type, 0, NULL);
        if (!o) {
                m_freem(m);
                return NULL;    /* ENOBUFS */
@@ -260,7 +259,7 @@ m_tag_alloc(uint32_t cookie, int type, int len, int wait)
 
        if (len < 0)
                return NULL;
-       t = kmalloc(len + sizeof(struct m_tag), M_PACKET_TAGS, MBTOM(wait));
+       t = kmalloc(len + sizeof(struct m_tag), M_PACKET_TAGS, MB_OCFLAG(wait));
        if (t == NULL)
                return NULL;
        t->m_tag_id = type;
index 6738603..12a9b07 100644 (file)
@@ -29,7 +29,6 @@
  *
  * @(#)uipc_socket2.c  8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/kern/uipc_socket2.c,v 1.55.2.17 2002/08/31 19:04:55 dwmalone Exp $
- * $DragonFly: src/sys/kern/uipc_sockbuf.c,v 1.3 2007/08/09 01:10:04 dillon Exp $
  */
 
 #include "opt_param.h"
@@ -248,7 +247,7 @@ sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa, struct mbuf *m0,
        }
        if (asa->sa_len > MLEN)
                return (0);
-       MGET(m, MB_DONTWAIT, MT_SONAME);
+       MGET(m, M_NOWAIT, MT_SONAME);
        if (m == NULL)
                return (0);
        KKASSERT(m->m_nextpkt == NULL);
@@ -591,7 +590,7 @@ sbcreatecontrol(caddr_t p, int size, int type, int level)
 
        if (CMSG_SPACE((u_int)size) > MCLBYTES)
                return (NULL);
-       m = m_getl(CMSG_SPACE((u_int)size), MB_DONTWAIT, MT_CONTROL, 0, NULL);
+       m = m_getl(CMSG_SPACE((u_int)size), M_NOWAIT, MT_CONTROL, 0, NULL);
        if (m == NULL)
                return (NULL);
        m->m_len = CMSG_SPACE(size);
index 8f8ef41..55cd664 100644 (file)
@@ -889,7 +889,7 @@ restart:
                    } else do {
                        if (resid > INT_MAX)
                                resid = INT_MAX;
-                       m = m_getl((int)resid, MB_WAIT, MT_DATA,
+                       m = m_getl((int)resid, M_WAITOK, MT_DATA,
                                   top == NULL ? M_PKTHDR : 0, &mlen);
                        if (top == NULL) {
                                m->m_pkthdr.len = 0;
@@ -1049,7 +1049,7 @@ restart:
                } else {
                        int nsize;
 
-                       top = m_getl(uio->uio_resid + hdrlen, MB_WAIT,
+                       top = m_getl(uio->uio_resid + hdrlen, M_WAITOK,
                            MT_DATA, M_PKTHDR, &nsize);
                        KASSERT(nsize >= uio->uio_resid + hdrlen,
                            ("sosendudp invalid nsize %d, "
@@ -1184,10 +1184,10 @@ restart:
                        if (resid > INT_MAX)
                                resid = INT_MAX;
                        if (tcp_sosend_jcluster) {
-                               m = m_getlj((int)resid, MB_WAIT, MT_DATA,
+                               m = m_getlj((int)resid, M_WAITOK, MT_DATA,
                                           top == NULL ? M_PKTHDR : 0, &mlen);
                        } else {
-                               m = m_getl((int)resid, MB_WAIT, MT_DATA,
+                               m = m_getl((int)resid, M_WAITOK, MT_DATA,
                                           top == NULL ? M_PKTHDR : 0, &mlen);
                        }
                        if (top == NULL) {
@@ -1309,7 +1309,7 @@ soreceive(struct socket *so, struct sockaddr **psa, struct uio *uio,
        else
                flags = 0;
        if (flags & MSG_OOB) {
-               m = m_get(MB_WAIT, MT_DATA);
+               m = m_get(M_WAITOK, MT_DATA);
                if (m == NULL)
                        return (ENOBUFS);
                error = so_pru_rcvoob(so, m, flags & MSG_PEEK);
@@ -1524,7 +1524,7 @@ dontblock:
                                moff += len;
                        } else {
                                if (sio) {
-                                       n = m_copym(m, 0, len, MB_WAIT);
+                                       n = m_copym(m, 0, len, M_WAITOK);
                                        if (n)
                                                sbappend(sio, n);
                                }
@@ -1639,7 +1639,7 @@ sorecvtcp(struct socket *so, struct sockaddr **psa, struct uio *uio,
        else
                flags = 0;
        if (flags & MSG_OOB) {
-               m = m_get(MB_WAIT, MT_DATA);
+               m = m_get(M_WAITOK, MT_DATA);
                if (m == NULL)
                        return (ENOBUFS);
                error = so_pru_rcvoob(so, m, flags & MSG_PEEK);
@@ -1851,7 +1851,7 @@ dontblock:
                if (offset) {
                        KKASSERT(m);
                        if (sio) {
-                               n = m_copym(m, 0, offset, MB_WAIT);
+                               n = m_copym(m, 0, offset, M_WAITOK);
                                if (n)
                                        sbappend(sio, n);
                        }
@@ -2415,7 +2415,7 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp)
        struct mbuf *m, *m_prev;
        int sopt_size = sopt->sopt_valsize, msize;
 
-       m = m_getl(sopt_size, sopt->sopt_td ? MB_WAIT : MB_DONTWAIT, MT_DATA,
+       m = m_getl(sopt_size, sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA,
                   0, &msize);
        if (m == NULL)
                return (ENOBUFS);
@@ -2425,7 +2425,7 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp)
        m_prev = m;
 
        while (sopt_size > 0) {
-               m = m_getl(sopt_size, sopt->sopt_td ? MB_WAIT : MB_DONTWAIT,
+               m = m_getl(sopt_size, sopt->sopt_td ? M_WAITOK : M_NOWAIT,
                           MT_DATA, 0, &msize);
                if (m == NULL) {
                        m_freem(*mp);
index 7ad2c51..ac8e860 100644 (file)
@@ -29,7 +29,6 @@
  *
  *     @(#)uipc_socket2.c      8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/kern/uipc_socket2.c,v 1.55.2.17 2002/08/31 19:04:55 dwmalone Exp $
- * $DragonFly: src/sys/kern/uipc_socket2.c,v 1.33 2008/09/02 16:17:52 dillon Exp $
  */
 
 #include "opt_param.h"
@@ -561,7 +560,7 @@ sowakeup(struct socket *so, struct signalsockbuf *ssb)
        if ((so->so_state & SS_ASYNC) && so->so_sigio != NULL)
                pgsigio(so->so_sigio, SIGIO, 0);
        if (ssb->ssb_flags & SSB_UPCALL)
-               (*so->so_upcall)(so, so->so_upcallarg, MB_DONTWAIT);
+               (*so->so_upcall)(so, so->so_upcallarg, M_NOWAIT);
        KNOTE(&kqinfo->ki_note, 0);
 
        /*
index 294565d..2901dcb 100644 (file)
@@ -813,7 +813,7 @@ sys_sendmsg(struct sendmsg_args *uap)
                        error = EINVAL;
                        goto cleanup;
                }
-               control = m_get(MB_WAIT, MT_CONTROL);
+               control = m_get(M_WAITOK, MT_CONTROL);
                if (control == NULL) {
                        error = ENOBUFS;
                        goto cleanup;
@@ -1758,7 +1758,7 @@ retry_lookup:
                /*
                 * Get an mbuf header and set it up as having external storage.
                 */
-               MGETHDR(m, MB_WAIT, MT_DATA);
+               MGETHDR(m, M_WAITOK, MT_DATA);
                if (m == NULL) {
                        error = ENOBUFS;
                        vm_page_wakeup(pg);
index c3b9278..3ff4365 100644 (file)
@@ -1502,7 +1502,7 @@ unp_internalize(struct mbuf *control, struct thread *td)
                        error = E2BIG;
                        goto done;
                }
-               MCLGET(control, MB_WAIT);
+               MCLGET(control, M_WAITOK);
                if (!(control->m_flags & M_EXT)) {
                        error = ENOBUFS;
                        goto done;
index 33dbaba..ef436b9 100644 (file)
@@ -212,7 +212,7 @@ bpf_movein(struct uio *uio, int linktype, struct mbuf **mp,
        if ((unsigned)len > MCLBYTES)
                return(EIO);
 
-       m = m_getl(len, MB_WAIT, MT_DATA, M_PKTHDR, NULL);
+       m = m_getl(len, M_WAITOK, MT_DATA, M_PKTHDR, NULL);
        if (m == NULL)
                return(ENOBUFS);
        m->m_pkthdr.len = m->m_len = len;
index 02eb95b..7235c26 100644 (file)
@@ -253,7 +253,7 @@ bstp_send_config_bpdu(struct bridge_softc *sc, struct bridge_iflist *bif,
        if ((ifp->if_flags & IFF_RUNNING) == 0)
                return;
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL)
                return;
 
@@ -435,7 +435,7 @@ bstp_transmit_tcn(struct bridge_softc *sc)
        if ((ifp->if_flags & IFF_RUNNING) == 0)
                return;
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL)
                return;
 
index 41dce2c..c1a2107 100644 (file)
@@ -2219,7 +2219,7 @@ bridge_output(struct ifnet *ifp, struct mbuf *m)
                                used = 1;
                                mc = m;
                        } else {
-                               mc = m_copypacket(m, MB_DONTWAIT);
+                               mc = m_copypacket(m, M_NOWAIT);
                                if (mc == NULL) {
                                        IFNET_STAT_INC(bifp, oerrors, 1);
                                        continue;
@@ -2736,7 +2736,7 @@ bridge_input(struct ifnet *ifp, struct mbuf *m)
                 * for bridge processing; return the original packet for
                 * local processing.
                 */
-               mc = m_dup(m, MB_DONTWAIT);
+               mc = m_dup(m, M_NOWAIT);
                if (mc == NULL)
                        goto out;
 
@@ -2758,7 +2758,7 @@ bridge_input(struct ifnet *ifp, struct mbuf *m)
                 */
                KASSERT(bifp->if_bridge == NULL,
                        ("loop created in bridge_input"));
-               mc2 = m_dup(m, MB_DONTWAIT);
+               mc2 = m_dup(m, M_NOWAIT);
 #ifdef notyet
                if (mc2 != NULL) {
                        /* Keep the layer3 header aligned */
@@ -2954,7 +2954,7 @@ bridge_start_bcast(struct bridge_softc *sc, struct mbuf *m)
                        mc = m;
                        used = 1;
                } else {
-                       mc = m_copypacket(m, MB_DONTWAIT);
+                       mc = m_copypacket(m, M_NOWAIT);
                        if (mc == NULL) {
                                IFNET_STAT_INC(bifp, oerrors, 1);
                                continue;
@@ -3087,7 +3087,7 @@ bridge_broadcast(struct bridge_softc *sc, struct ifnet *src_if,
                        mc = m;
                        used = 1;
                } else {
-                       mc = m_copypacket(m, MB_DONTWAIT);
+                       mc = m_copypacket(m, M_NOWAIT);
                        if (mc == NULL) {
                                IFNET_STAT_INC(sc->sc_ifp, oerrors, 1);
                                continue;
@@ -3152,7 +3152,7 @@ bridge_span(struct bridge_softc *sc, struct mbuf *m)
                if ((dst_if->if_flags & IFF_RUNNING) == 0)
                        continue;
 
-               mc = m_copypacket(m, MB_DONTWAIT);
+               mc = m_copypacket(m, M_NOWAIT);
                if (mc == NULL) {
                        IFNET_STAT_INC(sc->sc_ifp, oerrors, 1);
                        continue;
@@ -4056,13 +4056,13 @@ bridge_pfil(struct mbuf **mp, struct ifnet *bifp, struct ifnet *ifp, int dir)
         * Finally, put everything back the way it was and return
         */
        if (snap) {
-               M_PREPEND(*mp, sizeof(struct llc), MB_DONTWAIT);
+               M_PREPEND(*mp, sizeof(struct llc), M_NOWAIT);
                if (*mp == NULL)
                        return (error);
                bcopy(&llc1, mtod(*mp, caddr_t), sizeof(struct llc));
        }
 
-       M_PREPEND(*mp, ETHER_HDR_LEN, MB_DONTWAIT);
+       M_PREPEND(*mp, ETHER_HDR_LEN, M_NOWAIT);
        if (*mp == NULL)
                return (error);
        bcopy(&eh2, mtod(*mp, caddr_t), ETHER_HDR_LEN);
@@ -4265,7 +4265,7 @@ bridge_fragment(struct ifnet *ifp, struct mbuf *m, struct ether_header *eh,
        for (m0 = m; m0; m0 = m0->m_nextpkt) {
                if (error == 0) {
                        if (snap) {
-                               M_PREPEND(m0, sizeof(struct llc), MB_DONTWAIT);
+                               M_PREPEND(m0, sizeof(struct llc), M_NOWAIT);
                                if (m0 == NULL) {
                                        error = ENOBUFS;
                                        continue;
@@ -4273,7 +4273,7 @@ bridge_fragment(struct ifnet *ifp, struct mbuf *m, struct ether_header *eh,
                                bcopy(llc, mtod(m0, caddr_t),
                                    sizeof(struct llc));
                        }
-                       M_PREPEND(m0, ETHER_HDR_LEN, MB_DONTWAIT);
+                       M_PREPEND(m0, ETHER_HDR_LEN, M_NOWAIT);
                        if (m0 == NULL) {
                                error = ENOBUFS;
                                continue;
index 619f9f6..3401da1 100644 (file)
@@ -468,12 +468,12 @@ bsd_compress(void *state, struct mbuf **mret, struct mbuf *mp,
        *wptr++ = (v);                                  \
        if (wptr >= cp_end) {                           \
            m->m_len = wptr - mtod(m, u_char *);        \
-           MGET(m->m_next, MB_DONTWAIT, MT_DATA);      \
+           MGET(m->m_next, M_NOWAIT, MT_DATA);         \
            m = m->m_next;                              \
            if (m) {                                    \
                m->m_len = 0;                           \
                if (maxolen - olen > MLEN)              \
-                   MCLGET(m, MB_DONTWAIT);             \
+                   MCLGET(m, M_NOWAIT);                \
                wptr = mtod(m, u_char *);               \
                cp_end = wptr + M_TRAILINGSPACE(m);     \
            } else                                      \
@@ -510,12 +510,12 @@ bsd_compress(void *state, struct mbuf **mret, struct mbuf *mp,
        maxolen = slen;
 
     /* Allocate one mbuf to start with. */
-    MGET(m, MB_DONTWAIT, MT_DATA);
+    MGET(m, M_NOWAIT, MT_DATA);
     *mret = m;
     if (m != NULL) {
        m->m_len = 0;
        if (maxolen + db->hdrlen > MLEN)
-           MCLGET(m, MB_DONTWAIT);
+           MCLGET(m, M_NOWAIT);
        m->m_data += db->hdrlen;
        wptr = mtod(m, u_char *);
        cp_end = wptr + M_TRAILINGSPACE(m);
@@ -840,13 +840,13 @@ bsd_decompress(void *state, struct mbuf *cmp, struct mbuf **dmpp)
     /*
      * Allocate one mbuf to start with.
      */
-    MGETHDR(dmp, MB_DONTWAIT, MT_DATA);
+    MGETHDR(dmp, M_NOWAIT, MT_DATA);
     if (dmp == NULL)
        return DECOMP_ERROR;
     mret = dmp;
     dmp->m_len = 0;
     dmp->m_next = NULL;
-    MCLGET(dmp, MB_DONTWAIT);
+    MCLGET(dmp, M_NOWAIT);
     dmp->m_data += db->hdrlen;
     wptr = mtod(dmp, u_char *);
     space = M_TRAILINGSPACE(dmp) - PPP_HDRLEN + 1;
@@ -952,7 +952,7 @@ bsd_decompress(void *state, struct mbuf *cmp, struct mbuf **dmpp)
         */
        if ((space -= codelen + extra) < 0) {
            dmp->m_len = wptr - mtod(dmp, u_char *);
-           MGET(m, MB_DONTWAIT, MT_DATA);
+           MGET(m, M_NOWAIT, MT_DATA);
            if (m == NULL) {
                m_freem(mret);
                return DECOMP_ERROR;
@@ -960,7 +960,7 @@ bsd_decompress(void *state, struct mbuf *cmp, struct mbuf **dmpp)
            m->m_len = 0;
            m->m_next = NULL;
            dmp->m_next = m;
-           MCLGET(m, MB_DONTWAIT);
+           MCLGET(m, M_NOWAIT);
            space = M_TRAILINGSPACE(m) - (codelen + extra);
            if (space < 0) {
                /* now that's what I call *compression*. */
index fc7db67..c47da15 100644 (file)
@@ -312,7 +312,7 @@ gre_output_serialized(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 
                        if ((m->m_data - msiz) < m->m_pktdat) {
                                /* need new mbuf */
-                               MGETHDR(m0, MB_DONTWAIT, MT_HEADER);
+                               MGETHDR(m0, M_NOWAIT, MT_HEADER);
                                if (m0 == NULL) {
                                        m_freem(m);
                                        error = ENOBUFS;
@@ -353,7 +353,7 @@ gre_output_serialized(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
                        error = EAFNOSUPPORT;
                        goto end;
                }
-               M_PREPEND(m, sizeof(struct greip), MB_DONTWAIT);
+               M_PREPEND(m, sizeof(struct greip), M_NOWAIT);
        } else {
                m_freem(m);
                error = EINVAL;
index 838f5c8..8cb2f62 100644 (file)
@@ -226,7 +226,7 @@ ether_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
        if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING))
                gotoerr(ENETDOWN);
 
-       M_PREPEND(m, sizeof(struct ether_header), MB_DONTWAIT);
+       M_PREPEND(m, sizeof(struct ether_header), M_NOWAIT);
        if (m == NULL)
                return (ENOBUFS);
        m->m_pkthdr.csum_lhlen = sizeof(struct ether_header);
@@ -311,7 +311,7 @@ ether_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
                if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
                        struct mbuf *n;
 
-                       if ((n = m_copypacket(m, MB_DONTWAIT)) != NULL) {
+                       if ((n = m_copypacket(m, M_NOWAIT)) != NULL) {
                                n->m_pkthdr.csum_flags |= csum_flags;
                                if (csum_flags & CSUM_DATA_VALID)
                                        n->m_pkthdr.csum_data = 0xffff;
@@ -910,7 +910,7 @@ ether_restore_header(struct mbuf **m0, const struct ether_header *eh,
        } else {
                ether_prepend_hdr++;
 
-               M_PREPEND(m, ETHER_HDR_LEN, MB_DONTWAIT);
+               M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT);
                if (m != NULL) {
                        bcopy(save_eh, mtod(m, struct ether_header *),
                              ETHER_HDR_LEN);
@@ -1101,7 +1101,7 @@ post_stats:
                         * Put back the ethernet header so netgraph has a
                         * consistent view of inbound packets.
                         */
-                       M_PREPEND(m, ETHER_HDR_LEN, MB_DONTWAIT);
+                       M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT);
                        if (m == NULL) {
                                /*
                                 * M_PREPEND frees the mbuf in case of failure.
index 62a17bc..623efe9 100644 (file)
@@ -223,7 +223,7 @@ rel:
                 */
                ifq_classify(&ifp->if_snd, m, af, &pktattr);
 
-               M_PREPEND(m, sizeof(int32_t), MB_DONTWAIT);
+               M_PREPEND(m, sizeof(int32_t), M_NOWAIT);
                if (m == NULL)
                        return(ENOBUFS);
                afp = mtod(m, int32_t *);
index 9dd63cb..91c9f77 100644 (file)
@@ -1100,11 +1100,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(MB_WAIT, MT_DATA); /* XXX */
+               *mm = m = m_get(M_WAITOK, MT_DATA); /* XXX */
                if (!m)
                        return(ENOBUFS);
                if (sizeof *(fcp->rule) > MLEN) {
-                       MCLGET(m, MB_WAIT);
+                       MCLGET(m, M_WAITOK);
                        if ((m->m_flags & M_EXT) == 0) {
                                m_free(m);
                                return(ENOBUFS);
@@ -1113,14 +1113,14 @@ ip6_fw_ctl(int stage, struct mbuf **mm)
                for (; fcp; fcp = fcp->chain.le_next) {
                        bcopy(fcp->rule, m->m_data, sizeof *(fcp->rule));
                        m->m_len = sizeof *(fcp->rule);
-                       m->m_next = m_get(MB_WAIT, MT_DATA); /* XXX */
+                       m->m_next = m_get(M_WAITOK, MT_DATA); /* XXX */
                        if (!m->m_next) {
                                m_freem(*mm);
                                return(ENOBUFS);
                        }
                        m = m->m_next;
                        if (sizeof *(fcp->rule) > MLEN) {
-                               MCLGET(m, MB_WAIT);
+                               MCLGET(m, M_WAITOK);
                                if ((m->m_flags & M_EXT) == 0) {
                                        m_freem(*mm);
                                        return(ENOBUFS);
index 492cbd0..eff6706 100644 (file)
@@ -1253,7 +1253,7 @@ X_ip_mforward(struct ip *ip, struct ifnet *ifp, struct mbuf *m,
                return ENOBUFS;
        }
 
-       mb0 = m_copypacket(m, MB_DONTWAIT);
+       mb0 = m_copypacket(m, M_NOWAIT);
        if (mb0 && (M_HASCL(mb0) || mb0->m_len < hlen))
            mb0 = m_pullup(mb0, hlen);
        if (mb0 == NULL) {
@@ -1624,7 +1624,7 @@ phyint_send(struct ip *ip, struct vif *vifp, struct mbuf *m)
      * the IP header is actually copied, not just referenced,
      * so that ip_output() only scribbles on the copy.
      */
-    mb_copy = m_copypacket(m, MB_DONTWAIT);
+    mb_copy = m_copypacket(m, M_NOWAIT);
     if (mb_copy && (M_HASCL(mb_copy) || mb_copy->m_len < hlen))
        mb_copy = m_pullup(mb_copy, hlen);
     if (mb_copy == NULL)
@@ -1654,13 +1654,13 @@ encap_send(struct ip *ip, struct vif *vifp, struct mbuf *m)
      * new mbuf so we can modify it.  Try to fill the new
      * mbuf since if we don't the ethernet driver will.
      */
-    MGETHDR(mb_copy, MB_DONTWAIT, MT_HEADER);
+    MGETHDR(mb_copy, M_NOWAIT, MT_HEADER);
     if (mb_copy == NULL)
        return;
     mb_copy->m_data += max_linkhdr;
     mb_copy->m_len = sizeof(multicast_encap_iphdr);
 
-    if ((mb_copy->m_next = m_copypacket(m, MB_DONTWAIT)) == NULL) {
+    if ((mb_copy->m_next = m_copypacket(m, M_NOWAIT)) == NULL) {
        m_freem(mb_copy);
        return;
     }
@@ -2568,7 +2568,7 @@ bw_upcalls_send(void)
      * Allocate a new mbuf, initialize it with the header and
      * the payload for the pending calls.
      */
-    MGETHDR(m, MB_DONTWAIT, MT_HEADER);
+    MGETHDR(m, M_NOWAIT, MT_HEADER);
     if (m == NULL) {
        log(LOG_WARNING, "bw_upcalls_send: cannot allocate mbuf\n");
        return;
@@ -2857,7 +2857,7 @@ pim_register_prepare(struct ip *ip, struct mbuf *m)
      * Copy the old packet & pullup its IP header into the
      * new mbuf so we can modify it.
      */
-    mb_copy = m_copypacket(m, MB_DONTWAIT);
+    mb_copy = m_copypacket(m, M_NOWAIT);
     if (mb_copy == NULL)
        return NULL;
     mb_copy = m_pullup(mb_copy, ip->ip_hl << 2);
@@ -2902,7 +2902,7 @@ pim_register_send_upcall(struct ip *ip, struct vif *vifp,
     /*
      * Add a new mbuf with an upcall header
      */
-    MGETHDR(mb_first, MB_DONTWAIT, MT_HEADER);
+    MGETHDR(mb_first, M_NOWAIT, MT_HEADER);
     if (mb_first == NULL) {
        m_freem(mb_copy);
        return ENOBUFS;
@@ -2960,7 +2960,7 @@ pim_register_send_rp(struct ip *ip, struct vif *vifp,
     /*
      * Add a new mbuf with the encapsulating header
      */
-    MGETHDR(mb_first, MB_DONTWAIT, MT_HEADER);
+    MGETHDR(mb_first, M_NOWAIT, MT_HEADER);
     if (mb_first == NULL) {
        m_freem(mb_copy);
        return ENOBUFS;
index cef01d0..0afc943 100644 (file)
@@ -1416,7 +1416,7 @@ send_pkt(struct ipfw_flow_id *id, uint32_t seq, uint32_t ack, int flags)
        struct tcphdr *tcp;
        struct route sro;       /* fake route */
 
-       MGETHDR(m, MB_DONTWAIT, MT_HEADER);
+       MGETHDR(m, M_NOWAIT, MT_HEADER);
        if (m == NULL)
                return;
        m->m_pkthdr.rcvif = NULL;
@@ -2321,7 +2321,7 @@ check_body:
                                        break;
 
                                mtag = m_tag_get(PACKET_TAG_IPFW_DIVERT,
-                                                sizeof(*divinfo), MB_DONTWAIT);
+                                                sizeof(*divinfo), M_NOWAIT);
                                if (mtag == NULL) {
                                        retval = IP_FW_DENY;
                                        goto done;
@@ -2392,7 +2392,7 @@ check_body:
                                        struct sockaddr_in *sin;
 
                                        mtag = m_tag_get(PACKET_TAG_IPFORWARD,
-                                              sizeof(*sin), MB_DONTWAIT);
+                                              sizeof(*sin), M_NOWAIT);
                                        if (mtag == NULL) {
                                                retval = IP_FW_DENY;
                                                goto done;
@@ -2458,7 +2458,7 @@ ipfw_dummynet_io(struct mbuf *m, int pipe_nr, int dir, struct ip_fw_args *fwa)
 
        M_ASSERTPKTHDR(m);
 
-       mtag = m_tag_get(PACKET_TAG_DUMMYNET, sizeof(*pkt), MB_DONTWAIT);
+       mtag = m_tag_get(PACKET_TAG_DUMMYNET, sizeof(*pkt), M_NOWAIT);
        if (mtag == NULL) {
                m_freem(m);
                return;
index 6e8b338..7a134d2 100644 (file)
@@ -359,7 +359,7 @@ lacp_xmit_lacpdu(struct lacp_port *lp)
 
        LACP_LOCK_ASSERT(lp->lp_lsc);
 
-       m = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL) {
                return (ENOMEM);
        }
@@ -413,7 +413,7 @@ lacp_xmit_marker(struct lacp_port *lp)
 
        LACP_LOCK_ASSERT(lp->lp_lsc);
 
-       m = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL) {
                return (ENOMEM);
        }
index 59b108e..f1e71f9 100644 (file)
@@ -91,7 +91,7 @@ __FBSDID("$FreeBSD: head/sys/dev/netmap/netmap.c 257666 2013-11-05 01:06:22Z lui
 /*
  * we allocate an EXT_PACKET
  */
-#define netmap_get_mbuf(len) m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR)
+#define netmap_get_mbuf(len) m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR)
 
 /* mbuf destructor, also need to change the type to EXT_EXTREF,
  * add an M_NOFREE flag, and then clear the flag and
index 0cc306e..531247b 100644 (file)
@@ -2143,7 +2143,7 @@ pf_send_tcp(const struct pf_rule *r, sa_family_t af,
         * DragonFly doesn't zero the auxillary pkghdr fields, only fw_flags,
         * so make sure pf.flags is clear.
         */
-       m = m_gethdr(MB_DONTWAIT, MT_HEADER);
+       m = m_gethdr(M_NOWAIT, MT_HEADER);
        if (m == NULL) {
                return;
        }
@@ -6022,7 +6022,7 @@ pf_route(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp,
        }
 
        if (r->rt == PF_DUPTO) {
-               if ((m0 = m_dup(*m, MB_DONTWAIT)) == NULL) {
+               if ((m0 = m_dup(*m, M_NOWAIT)) == NULL) {
                        return;
                }
        } else {
@@ -6212,7 +6212,7 @@ pf_route6(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp,
        }
 
        if (r->rt == PF_DUPTO) {
-               if ((m0 = m_dup(*m, MB_DONTWAIT)) == NULL)
+               if ((m0 = m_dup(*m, M_NOWAIT)) == NULL)
                        return;
        } else {
                if ((r->rt == PF_REPLYTO) == (r->direction == dir))
index 6900020..d4ab380 100644 (file)
@@ -616,7 +616,7 @@ pf_fragcache(struct mbuf **m0, struct ip *h, struct pf_fragment **frag, int mff,
                                 * than this mbuf magic.  For my next trick,
                                 * I'll pull a rabbit out of my laptop.
                                 */
-                               *m0 = m_dup(m, MB_DONTWAIT);
+                               *m0 = m_dup(m, M_NOWAIT);
                                /* From KAME Project : We have missed this! */
                                m_adj(*m0, (h->ip_hl << 2) -
                                    (*m0)->m_pkthdr.len);
index c287862..f8d930b 100644 (file)
@@ -771,7 +771,7 @@ pppoutput_serialized(struct ifnet *ifp, struct ifaltq_subque *ifsq,
      * (This assumes M_LEADINGSPACE is always 0 for a cluster mbuf.)
      */
     if (M_LEADINGSPACE(m0) < PPP_HDRLEN) {
-       m0 = m_prepend(m0, PPP_HDRLEN, MB_DONTWAIT);
+       m0 = m_prepend(m0, PPP_HDRLEN, M_NOWAIT);
        if (m0 == NULL) {
            error = ENOBUFS;
            goto bad;
@@ -1353,13 +1353,13 @@ ppp_inproc(struct ppp_softc *sc, struct mbuf *m)
        }
 
        /* Copy the PPP and IP headers into a new mbuf. */
-       MGETHDR(mp, MB_DONTWAIT, MT_DATA);
+       MGETHDR(mp, M_NOWAIT, MT_DATA);
        if (mp == NULL)
            goto bad;
        mp->m_len = 0;
        mp->m_next = NULL;
        if (hlen + PPP_HDRLEN > MHLEN) {
-           MCLGET(mp, MB_DONTWAIT);
+           MCLGET(mp, M_NOWAIT);
            if (M_TRAILINGSPACE(mp) < hlen + PPP_HDRLEN) {
                m_freem(mp);
                goto bad;       /* lose if big headers and no clusters */
@@ -1415,7 +1415,7 @@ ppp_inproc(struct ppp_softc *sc, struct mbuf *m)
      * whole cluster on it.
      */
     if (ilen <= MHLEN && M_IS_CLUSTER(m)) {
-       MGETHDR(mp, MB_DONTWAIT, MT_DATA);
+       MGETHDR(mp, M_NOWAIT, MT_DATA);
        if (mp != NULL) {
            m_copydata(m, 0, ilen, mtod(mp, caddr_t));
            m_freem(m);
index bf5f3b6..43a920f 100644 (file)
@@ -237,12 +237,12 @@ z_compress(void *arg, struct mbuf **mret, struct mbuf *mp, int orig_len,
     /* Allocate one mbuf initially. */
     if (maxolen > orig_len)
        maxolen = orig_len;
-    MGET(m, MB_DONTWAIT, MT_DATA);
+    MGET(m, M_NOWAIT, MT_DATA);
     *mret = m;
     if (m != NULL) {
        m->m_len = 0;
        if (maxolen + state->hdrlen > MLEN)
-           MCLGET(m, MB_DONTWAIT);
+           MCLGET(m, M_NOWAIT);
        wspace = M_TRAILINGSPACE(m);
        if (state->hdrlen + PPP_HDRLEN + 2 < wspace) {
            m->m_data += state->hdrlen;
@@ -297,12 +297,12 @@ z_compress(void *arg, struct mbuf **mret, struct mbuf *mp, int orig_len,
            if (m != NULL) {
                m->m_len = wspace;
                olen += wspace;
-               MGET(m->m_next, MB_DONTWAIT, MT_DATA);
+               MGET(m->m_next, M_NOWAIT, MT_DATA);
                m = m->m_next;
                if (m != NULL) {
                    m->m_len = 0;
                    if (maxolen - olen > MLEN)
-                       MCLGET(m, MB_DONTWAIT);
+                       MCLGET(m, M_NOWAIT);
                    state->strm.next_out = mtod(m, u_char *);
                    state->strm.avail_out = wspace = M_TRAILINGSPACE(m);
                }
@@ -483,13 +483,13 @@ z_decompress(void *arg, struct mbuf *mi, struct mbuf **mop)
     ++state->seqno;
 
     /* Allocate an output mbuf. */
-    MGETHDR(mo, MB_DONTWAIT, MT_DATA);
+    MGETHDR(mo, M_NOWAIT, MT_DATA);
     if (mo == NULL)
        return DECOMP_ERROR;
     mo_head = mo;
     mo->m_len = 0;
     mo->m_next = NULL;
-    MCLGET(mo, MB_DONTWAIT);
+    MCLGET(mo, M_NOWAIT);
     ospace = M_TRAILINGSPACE(mo);
     if (state->hdrlen + PPP_HDRLEN < ospace) {
        mo->m_data += state->hdrlen;
@@ -558,13 +558,13 @@ z_decompress(void *arg, struct mbuf *mi, struct mbuf **mop)
            } else {
                mo->m_len = ospace;
                olen += ospace;
-               MGET(mo->m_next, MB_DONTWAIT, MT_DATA);
+               MGET(mo->m_next, M_NOWAIT, MT_DATA);
                mo = mo->m_next;
                if (mo == NULL) {
                    m_freem(mo_head);
                    return DECOMP_ERROR;
                }
-               MCLGET(mo, MB_DONTWAIT);
+               MCLGET(mo, M_NOWAIT);
                state->strm.next_out = mtod(mo, u_char *);
                state->strm.avail_out = ospace = M_TRAILINGSPACE(mo);
            }
index 00ab1d2..496965b 100644 (file)
@@ -73,7 +73,6 @@
  */
 
 /* $FreeBSD: src/sys/net/ppp_tty.c,v 1.43.2.1 2002/02/13 00:43:11 dillon Exp $ */
-/* $DragonFly: src/sys/net/ppp_layer/ppp_tty.c,v 1.25 2008/05/14 11:59:23 sephe Exp $ */
 
 #include "opt_ppp.h"           /* XXX for ppp_defs.h */
 
@@ -409,11 +408,11 @@ pppwrite(struct tty *tp, struct uio *uio, int flag)
     crit_enter();
     for (mp = &m0; uio->uio_resid; mp = &m->m_next) {
        if (mp == &m0) {
-               MGETHDR(m, MB_WAIT, MT_DATA);
+               MGETHDR(m, M_WAITOK, MT_DATA);
                m->m_pkthdr.len = uio->uio_resid - PPP_HDRLEN;
                m->m_pkthdr.rcvif = NULL;
        } else {
-               MGET(m, MB_WAIT, MT_DATA);
+               MGET(m, M_WAITOK, MT_DATA);
        }
        if ((*mp = m) == NULL) {
            m_freem(m0);
@@ -423,7 +422,7 @@ pppwrite(struct tty *tp, struct uio *uio, int flag)
        }
        m->m_len = 0;
        if (uio->uio_resid >= MCLBYTES / 2)
-           MCLGET(m, MB_DONTWAIT);
+           MCLGET(m, M_NOWAIT);
        len = M_TRAILINGSPACE(m);
        if (len > uio->uio_resid)
            len = uio->uio_resid;
@@ -838,11 +837,11 @@ pppgetm(struct ppp_softc *sc)
     mp = &sc->sc_m;
     for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
        if ((m = *mp) == NULL) {
-           MGETHDR(m, MB_DONTWAIT, MT_DATA);
+           MGETHDR(m, M_NOWAIT, MT_DATA);
            if (m == NULL)
                break;
            *mp = m;
-           MCLGET(m, MB_DONTWAIT);
+           MCLGET(m, M_NOWAIT);
        }
        len -= M_DATASIZE(m);
        mp = &m->m_next;
index c181302..63e1ca1 100644 (file)
@@ -28,7 +28,6 @@
  *
  *     @(#)raw_cb.c    8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/net/raw_cb.c,v 1.16 1999/08/28 00:48:27 peter Exp $
- * $DragonFly: src/sys/net/raw_cb.c,v 1.11 2006/09/05 00:55:46 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -121,7 +120,7 @@ raw_bind(struct socket *so, struct mbuf *nam)
        if (ifnet == NULL)
                return (EADDRNOTAVAIL);
        rp = sotorawcb(so);
-       nam = m_copym(nam, 0, M_COPYALL, MB_TRYWAIT);
+       nam = m_copym(nam, 0, M_COPYALL, M_WAITOK);
        rp->rcb_laddr = mtod(nam, struct sockaddr *);
        return (0);
 }
index fa87199..2c6bdd0 100644 (file)
@@ -28,7 +28,6 @@
  *
  *     @(#)raw_usrreq.c        8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/net/raw_usrreq.c,v 1.18 1999/08/28 00:48:28 peter Exp $
- * $DragonFly: src/sys/net/raw_usrreq.c,v 1.14 2007/06/24 20:00:00 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -104,7 +103,7 @@ raw_input(struct mbuf *m0, const struct sockproto *proto,
                if (last) {
                        struct mbuf *n;
 
-                       n = m_copypacket(m, MB_DONTWAIT);
+                       n = m_copypacket(m, M_NOWAIT);
                        if (n != NULL) {
                                lwkt_gettoken(&last->so_rcv.ssb_token);
                                if (ssb_appendaddr(&last->so_rcv, src, n,
index 06bb456..3d1ec31 100644 (file)
@@ -1517,7 +1517,7 @@ rtinit(struct ifaddr *ifa, int cmd, int flags)
                 * (Assuming we have a mask)
                 */
                if (netmask != NULL) {
-                       m = m_get(MB_DONTWAIT, MT_SONAME);
+                       m = m_get(M_NOWAIT, MT_SONAME);
                        if (m == NULL)
                                return (ENOBUFS);
                        mbuftrackid(m, 34);
index e92d60b..884e4e2 100644 (file)
@@ -910,7 +910,7 @@ rt_msg_mbuf(int type, struct rt_addrinfo *rtinfo)
        hlen = rt_msghdrsize(type);
        KASSERT(hlen <= MCLBYTES, ("rt_msg_mbuf: hlen %d doesn't fit", hlen));
 
-       m = m_getl(hlen, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL);
+       m = m_getl(hlen, M_NOWAIT, MT_DATA, M_PKTHDR, NULL);
        if (m == NULL)
                return (NULL);
        mbuftrackid(m, 32);
@@ -1183,8 +1183,8 @@ rt_ieee80211msg(struct ifnet *ifp, int what, void *data, size_t data_len)
         * NB: we assume m is a single mbuf.
         */
        if (data_len > M_TRAILINGSPACE(m)) {
-               /* XXX use m_getb(data_len, MB_DONTWAIT, MT_DATA, 0); */
-               struct mbuf *n = m_get(MB_DONTWAIT, MT_DATA);
+               /* XXX use m_getb(data_len, M_NOWAIT, MT_DATA, 0); */
+               struct mbuf *n = m_get(M_NOWAIT, MT_DATA);
                if (n == NULL) {
                        m_freem(m);
                        return;
index f082cad..44b2586 100644 (file)
@@ -30,7 +30,6 @@
  *
  *     @(#)if_sl.c     8.6 (Berkeley) 2/1/94
  * $FreeBSD: src/sys/net/if_sl.c,v 1.84.2.2 2002/02/13 00:43:10 dillon Exp $
- * $DragonFly: src/sys/net/sl/if_sl.c,v 1.32 2008/05/14 11:59:23 sephe Exp $
  */
 
 /*
@@ -746,7 +745,7 @@ sl_btom(struct sl_softc *sc, int len)
        if (len >= MCLBYTES)
                return (NULL);
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL)
                return (NULL);
 
@@ -758,7 +757,7 @@ sl_btom(struct sl_softc *sc, int len)
         * guarantees that packet will fit in a cluster.
         */
        if (len >= MHLEN) {
-               MCLGET(m, MB_DONTWAIT);
+               MCLGET(m, M_NOWAIT);
                if ((m->m_flags & M_EXT) == 0) {
                        /*
                         * we couldn't get a cluster - if memory's this
index b412bc8..9819085 100644 (file)
@@ -558,7 +558,7 @@ drop2:
                                 * enough leading space in the existing mbuf).
                                 */
                                m_adj(m, vjlen);
-                               M_PREPEND(m, hlen, MB_DONTWAIT);
+                               M_PREPEND(m, hlen, M_NOWAIT);
                                if (m == NULL)
                                        goto drop2;
                                bcopy(iphdr, mtod(m, u_char *), hlen);
@@ -796,7 +796,7 @@ sppp_output_serialized(struct ifnet *ifp, struct ifaltq_subque *ifsq,
        /*
         * Prepend general data packet PPP header. For now, IP only.
         */
-       M_PREPEND (m, PPP_HEADER_LEN, MB_DONTWAIT);
+       M_PREPEND (m, PPP_HEADER_LEN, M_NOWAIT);
        if (! m) {
                if (debug)
                        log(LOG_DEBUG, SPP_FMT "no memory for transmit header\n",
@@ -1282,7 +1282,7 @@ sppp_cisco_send(struct sppp *sp, int type, long par1, long par2)
 
        getmicrouptime(&tv);
 
-       MGETHDR (m, MB_DONTWAIT, MT_DATA);
+       MGETHDR (m, M_NOWAIT, MT_DATA);
        if (! m)
                return;
        m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + CISCO_PACKET_LEN;
@@ -1338,7 +1338,7 @@ sppp_cp_send(struct sppp *sp, u_short proto, u_char type,
 
        if (len > MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN)
                len = MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN;
-       MGETHDR (m, MB_DONTWAIT, MT_DATA);
+       MGETHDR (m, M_NOWAIT, MT_DATA);
        if (! m)
                return;
        m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + LCP_HEADER_LEN + len;
@@ -4633,7 +4633,7 @@ sppp_auth_send(const struct cp *cp, struct sppp *sp,
        struct ifaltq_subque *ifsq;
        __va_list ap;
 
-       MGETHDR (m, MB_DONTWAIT, MT_DATA);
+       MGETHDR (m, M_NOWAIT, MT_DATA);
        if (! m)
                return;
        m->m_pkthdr.rcvif = 0;
index 64effaf..7dae157 100644 (file)
@@ -1,5 +1,4 @@
 /*     $FreeBSD: src/sys/net/if_stf.c,v 1.1.2.11 2003/01/23 21:06:44 sam Exp $ */
-/*     $DragonFly: src/sys/net/stf/if_stf.c,v 1.25 2008/10/27 02:56:30 sephe Exp $     */
 /*     $KAME: if_stf.c,v 1.73 2001/12/03 11:08:30 keiichi Exp $        */
 
 /*
@@ -373,7 +372,7 @@ stf_output_serialized(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
                bpf_reltoken();
        }
 
-       M_PREPEND(m, sizeof(struct ip), MB_DONTWAIT);
+       M_PREPEND(m, sizeof(struct ip), M_NOWAIT);
        if (m && m->m_len < sizeof(struct ip))
                m = m_pullup(m, sizeof(struct ip));
        if (m == NULL)
index 15e7349..cd9b9b6 100644 (file)
@@ -927,7 +927,7 @@ tapwrite(struct dev_write_args *ap)
        tlen = uio->uio_resid;
 
        /* get a header mbuf */
-       MGETHDR(m, MB_WAIT, MT_DATA);
+       MGETHDR(m, M_WAITOK, MT_DATA);
        if (m == NULL)
                return (ENOBUFS);
        mlen = MHLEN;
@@ -942,7 +942,7 @@ tapwrite(struct dev_write_args *ap)
                *mp = m;
                mp = &m->m_next;
                if (uio->uio_resid > 0) {
-                       MGET(m, MB_WAIT, MT_DATA);
+                       MGET(m, M_WAITOK, MT_DATA);
                        if (m == NULL) {
                                error = ENOBUFS;
                                break;
index dc8e599..8f1b9ce 100644 (file)
@@ -355,7 +355,7 @@ tunoutput_serialized(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
        /* prepend sockaddr? this may abort if the mbuf allocation fails */
        if (tp->tun_flags & TUN_LMODE) {
                /* allocate space for sockaddr */
-               M_PREPEND(m0, dst->sa_len, MB_DONTWAIT);
+               M_PREPEND(m0, dst->sa_len, M_NOWAIT);
 
                /* if allocation failed drop packet */
                if (m0 == NULL){
@@ -368,7 +368,7 @@ tunoutput_serialized(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
 
        if (tp->tun_flags & TUN_IFHEAD) {
                /* Prepend the address family */
-               M_PREPEND(m0, 4, MB_DONTWAIT);
+               M_PREPEND(m0, 4, M_NOWAIT);
 
                /* if allocation failed drop packet */
                if (m0 == NULL){
@@ -598,7 +598,7 @@ tunwrite(struct dev_write_args *ap)
        tlen = uio->uio_resid;
 
        /* get a header mbuf */
-       MGETHDR(m, MB_WAIT, MT_DATA);
+       MGETHDR(m, M_WAITOK, MT_DATA);
        if (m == NULL)
                return ENOBUFS;
        mlen = MHLEN;
@@ -611,7 +611,7 @@ tunwrite(struct dev_write_args *ap)
                *mp = m;
                mp = &m->m_next;
                if (uio->uio_resid > 0) {
-                       MGET (m, MB_WAIT, MT_DATA);
+                       MGET (m, M_WAITOK, MT_DATA);
                        if (m == NULL) {
                                error = ENOBUFS;
                                break;
index f2de53a..ce9d429 100644 (file)
@@ -76,7 +76,7 @@ vlan_start_dispatch(netmsg_t msg)
                uint16_t vlantag = m->m_pkthdr.ether_vlantag;
                struct ether_vlan_header *evl;
 
-               M_PREPEND(m, EVL_ENCAPLEN, MB_DONTWAIT);
+               M_PREPEND(m, EVL_ENCAPLEN, M_NOWAIT);
                if (m == NULL) {
                        if_printf(ifp, "vlan%u M_PREPEND failed", vlantag);
                        return;
@@ -129,7 +129,7 @@ vlan_ether_ptap(struct bpf_if *bp, struct mbuf *m, uint16_t vlantag)
        bpf_ptap(bp, m, &evh, ETHER_HDR_LEN + EVL_ENCAPLEN);
 
        /* XXX assumes data was left intact */
-       M_PREPEND(m, ETHER_HDR_LEN, MB_WAIT);
+       M_PREPEND(m, ETHER_HDR_LEN, M_WAITOK);
 }
 
 void
index 8995ff1..d85981f 100644 (file)
@@ -1,4 +1,3 @@
-/* $DragonFly: src/sys/netbt/hci_link.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
 /* $OpenBSD: src/sys/netbt/hci_link.c,v 1.7 2008/02/24 21:34:48 uwe Exp $ */
 /* $NetBSD: hci_link.c,v 1.16 2007/11/10 23:12:22 plunky Exp $ */
 
@@ -566,7 +565,7 @@ hci_acl_send(struct mbuf *m, struct hci_link *link,
 
        while (plen > 0) {
                if (plen > mlen) {
-                       n = m_split(m, mlen, MB_DONTWAIT);
+                       n = m_split(m, mlen, M_NOWAIT);
                        if (n == NULL)
                                goto nomem;
                } else {
@@ -655,7 +654,7 @@ hci_acl_start(struct hci_link *link)
                        handle = HCI_MK_CON_HANDLE(link->hl_handle,
                                                HCI_PACKET_FRAGMENT, 0);
 
-               M_PREPEND(m, sizeof(*hdr), MB_DONTWAIT);
+               M_PREPEND(m, sizeof(*hdr), M_NOWAIT);
                if (m == NULL)
                        break;
 
index 87d7efa..bededfc 100644 (file)
@@ -513,7 +513,7 @@ hci_send(struct hci_pcb *pcb, struct mbuf *m, bdaddr_t *addr)
        }
 
        /* makes a copy for precious to keep */
-       m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
+       m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
        if (m0 == NULL) {
                err = ENOMEM;
                goto bad;
@@ -999,7 +999,7 @@ hci_mtap(struct mbuf *m, struct hci_unit *unit)
                /*
                 * copy to socket
                 */
-               m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
+               m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
                if (m0 && sbappendaddr(&pcb->hp_socket->so_rcv.sb,
                                (struct sockaddr *)&sa, m0, ctlmsg)) {
                        sorwakeup(pcb->hp_socket);
index 0fced4d..fc83344 100644 (file)
@@ -1,4 +1,3 @@
-/* $DragonFly: src/sys/netbt/hci_unit.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
 /* $OpenBSD: src/sys/netbt/hci_unit.c,v 1.8 2008/02/24 21:34:48 uwe Exp $ */
 /* $NetBSD: hci_unit.c,v 1.9 2007/12/30 18:26:42 plunky Exp $ */
 
@@ -290,7 +289,7 @@ hci_send_cmd(struct hci_unit *unit, uint16_t opcode, void *buf, uint8_t len)
 
        KKASSERT(unit != NULL);
 
-       m = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL)
                return ENOMEM;
 
index 4e02721..4638960 100644 (file)
@@ -1,4 +1,3 @@
-/* $DragonFly: src/sys/netbt/l2cap_signal.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
 /* $OpenBSD: src/sys/netbt/l2cap_signal.c,v 1.3 2008/02/24 21:34:48 uwe Exp $ */
 /* $NetBSD: l2cap_signal.c,v 1.9 2007/11/10 23:12:23 plunky Exp $ */
 
@@ -952,7 +951,7 @@ l2cap_send_signal(struct hci_link *link, uint8_t code, uint8_t ident,
                    device_get_nameunit(link->hl_unit->hci_dev));
 #endif
 
-       m = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL)
                return ENOMEM;
 
index 94a0639..129b667 100644 (file)
@@ -116,7 +116,7 @@ l2cap_ctloutput(netmsg_t msg)
 
        switch(sopt->sopt_dir) {
        case PRCO_GETOPT:
-               m = m_get(MB_DONTWAIT, MT_DATA);
+               m = m_get(M_NOWAIT, MT_DATA);
                if (m == NULL) {
                    error = ENOMEM;
                    break;
@@ -429,13 +429,13 @@ l2cap_ssend(netmsg_t msg)
                goto out;
        }
 
-       m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
+       m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
        if (m0 == NULL) {
                error = ENOMEM;
                goto out;
        }
 
-       m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
+       m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
        if (m0 == NULL) {
                error = ENOMEM;
                goto out;
index 2f37462..b7406e6 100644 (file)
@@ -382,7 +382,7 @@ l2cap_send(struct l2cap_channel *chan, struct mbuf *m)
                plen, chan->lc_lcid, chan->lc_pending);
 
        /* Encapsulate with B-Frame */
-       M_PREPEND(m, sizeof(l2cap_hdr_t), MB_DONTWAIT);
+       M_PREPEND(m, sizeof(l2cap_hdr_t), M_NOWAIT);
        if (m == NULL)
                return ENOMEM;
 
index ad4ef4f..904d415 100644 (file)
@@ -1,4 +1,3 @@
-/* $DragonFly: src/sys/netbt/rfcomm_dlc.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
 /* $OpenBSD: src/sys/netbt/rfcomm_dlc.c,v 1.2 2008/02/24 21:34:48 uwe Exp $ */
 /* $NetBSD: rfcomm_dlc.c,v 1.4 2007/11/03 17:20:17 plunky Exp $ */
 
@@ -380,7 +379,7 @@ rfcomm_dlc_start(struct rfcomm_dlc *dlc)
                         */
                        m = dlc->rd_txbuf;
                        if (len < m->m_pkthdr.len) {
-                               dlc->rd_txbuf = m_split(m, len, MB_DONTWAIT);
+                               dlc->rd_txbuf = m_split(m, len, M_NOWAIT);
                                if (dlc->rd_txbuf == NULL) {
                                        dlc->rd_txbuf = m;
                                        break;
index 58531e3..47c81ce 100644 (file)
@@ -1,4 +1,3 @@
-/* $DragonFly: src/sys/netbt/rfcomm_session.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
 /* $OpenBSD: src/sys/netbt/rfcomm_session.c,v 1.3 2008/02/24 21:34:48 uwe Exp $ */
 /* $NetBSD: rfcomm_session.c,v 1.12 2008/01/31 19:30:23 plunky Exp $ */
 
@@ -1462,7 +1461,7 @@ rfcomm_session_send_frame(struct rfcomm_session *rs, int type, int dlci)
        if (credit == NULL)
                return ENOMEM;
 
-       m = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL) {
                zfree(rfcomm_credit_pool, credit);
                return ENOMEM;
@@ -1552,7 +1551,7 @@ rfcomm_session_send_uih(struct rfcomm_session *rs, struct rfcomm_dlc *dlc,
         * If there are credits to be sent, we will set the PF
         * flag and include them in the frame.
         */
-       m0 = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m0 = m_gethdr(M_NOWAIT, MT_DATA);
        if (m0 == NULL)
                goto nomem;
 
@@ -1636,7 +1635,7 @@ rfcomm_session_send_mcc(struct rfcomm_session *rs, int cr,
        uint8_t *hdr;
        int hlen;
 
-       m = m_gethdr(MB_DONTWAIT, MT_DATA);
+       m = m_gethdr(M_NOWAIT, MT_DATA);
        if (m == NULL)
                return ENOMEM;
 
index d526f64..9261284 100644 (file)
@@ -113,7 +113,7 @@ rfcomm_ctloutput(netmsg_t msg)
 
        switch(sopt->sopt_dir) {
        case PRCO_GETOPT:
-               m = m_get(MB_WAIT, MT_DATA);
+               m = m_get(M_WAITOK, MT_DATA);
                crit_enter();
                m->m_len = rfcomm_getopt(pcb, sopt->sopt_name, mtod(m, void *));
                crit_exit();            
@@ -439,7 +439,7 @@ rfcomm_ssend(netmsg_t msg)
                control = NULL;
        }
 
-       m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
+       m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
        if (m0) {
                sbappendstream(&so->so_snd.sb, m);
                error = rfcomm_send(pcb, m0);
index 7a8da06..831c4fc 100644 (file)
@@ -107,7 +107,7 @@ sco_ctloutput(netmsg_t msg)
 
        switch(sopt->sopt_dir) {
        case PRCO_GETOPT:
-               m = m_get(MB_WAIT, MT_DATA);
+               m = m_get(M_WAITOK, MT_DATA);
                m->m_len = sco_getopt(pcb, sopt->sopt_name, mtod(m, uint8_t *));
                if (m->m_len == 0) {
                        m_freem(m);
@@ -120,7 +120,7 @@ sco_ctloutput(netmsg_t msg)
                break;
 
        case PRCO_SETOPT:
-               m = m_get(MB_WAIT, MT_DATA);
+               m = m_get(M_WAITOK, MT_DATA);
                KKASSERT(m != NULL);
                err = soopt_to_kbuf(sopt, mtod(m,void*), m->m_len, m->m_len); 
 
@@ -396,7 +396,7 @@ sco_ssend(netmsg_t msg)
                goto out;
        }
 
-       m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
+       m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
        if (m0 == NULL) {
                error = ENOMEM;
                goto out;
index 657c5ec..0d63a3e 100644 (file)
@@ -296,7 +296,7 @@ sco_send(struct sco_pcb *pcb, struct mbuf *m)
                return EMSGSIZE;
        }
 
-       M_PREPEND(m, sizeof(hci_scodata_hdr_t), MB_DONTWAIT);
+       M_PREPEND(m, sizeof(hci_scodata_hdr_t), M_NOWAIT);
        if (m == NULL)
                return ENOMEM;
 
index 944e1ca..a823c39 100644 (file)
@@ -181,7 +181,7 @@ ng_UI_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
                m_adj(m, ptr - start);
                NG_SEND_DATA(error, priv->uplink, m, meta);     /* m -> NULL */
        } else if (hook == priv->uplink) {
-               M_PREPEND(m, 1, MB_DONTWAIT);   /* Prepend IP NLPID */
+               M_PREPEND(m, 1, M_NOWAIT);      /* Prepend IP NLPID */
                if (!m)
                        ERROUT(ENOBUFS);
                mtod(m, u_char *)[0] = HDLC_UI;
index 3c9fc2f..3d9fb21 100644 (file)
@@ -673,7 +673,7 @@ ng_bridge_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
                        m2 = m;
                        meta2 = meta;
                }  else {
-                       m2 = m_dup(m, MB_DONTWAIT);     /* XXX m_copypacket() */
+                       m2 = m_dup(m, M_NOWAIT);        /* XXX m_copypacket() */
                        if (m2 == NULL) {
                                link->stats.memoryFailures++;
                                NG_FREE_DATA(m, meta);
index 34871e8..e7ae26d 100644 (file)
@@ -360,7 +360,7 @@ cisco_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
 
        /* OK so it came from a protocol, heading out. Prepend general data
           packet header. For now, IP,IPX only  */
-       M_PREPEND(m, CISCO_HEADER_LEN, MB_DONTWAIT);
+       M_PREPEND(m, CISCO_HEADER_LEN, M_NOWAIT);
        if (!m) {
                error = ENOBUFS;
                goto out;
@@ -597,7 +597,7 @@ cisco_send(sc_p sc, int type, long par1, long par2)
 
        getmicrotime(&time);
 
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (!m)
                return (ENOBUFS);
 
index 4202373..7893448 100644 (file)
@@ -371,7 +371,7 @@ ngfrm_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
        alen = sc->addrlen;
        if (alen == 0)
                alen = 2;       /* default value for transmit */
-       M_PREPEND(m, alen, MB_DONTWAIT);
+       M_PREPEND(m, alen, M_NOWAIT);
        if (m == NULL) {
                error = ENOBUFS;
                goto bad;
index 34a55e7..3ba96a2 100644 (file)
@@ -838,7 +838,7 @@ ng_l2tp_recv_lower(node_p node, struct mbuf *m, meta_p meta)
                 * later because of a memory error, because then the upper
                 * layer would never get the packet.
                 */
-               M_PREPEND(m, 2, MB_DONTWAIT);
+               M_PREPEND(m, 2, M_NOWAIT);
                if (m == NULL) {
                        priv->stats.memoryFailures++;
                        NG_FREE_META(meta);
@@ -937,7 +937,7 @@ ng_l2tp_recv_ctrl(node_p node, struct mbuf *m, meta_p meta)
        }
 
        /* Copy packet */
-       if ((m = L2TP_COPY_MBUF(seq->xwin[i], MB_DONTWAIT)) == NULL) {
+       if ((m = L2TP_COPY_MBUF(seq->xwin[i], M_NOWAIT)) == NULL) {
                priv->stats.memoryFailures++;
                return (ENOBUFS);
        }
@@ -969,7 +969,7 @@ ng_l2tp_recv_data(node_p node, struct mbuf *m, meta_p meta, hookpriv_p hpriv)
        M_PREPEND(m, 6
            + (2 * (hpriv->conf.include_length != 0))
            + (4 * (hpriv->conf.enable_dseq != 0)),
-           MB_DONTWAIT);
+           M_NOWAIT);
        if (m == NULL) {
                priv->stats.memoryFailures++;
                NG_FREE_META(meta);
@@ -1204,7 +1204,7 @@ ng_l2tp_seq_recv_nr(priv_p priv, u_int16_t nr)
         */
        while ((i = L2TP_SEQ_DIFF(seq->ns, seq->rack)) < seq->cwnd
            && seq->xwin[i] != NULL) {
-               if ((m = L2TP_COPY_MBUF(seq->xwin[i], MB_DONTWAIT)) == NULL)
+               if ((m = L2TP_COPY_MBUF(seq->xwin[i], M_NOWAIT)) == NULL)
                        priv->stats.memoryFailures++;
                else
                        ng_l2tp_xmit_ctrl(priv, m, seq->ns);
@@ -1348,7 +1348,7 @@ ng_l2tp_seq_rack_timeout(void *arg)
        seq->acks = 0;
 
        /* Retransmit oldest unack'd packet */
-       if ((m = L2TP_COPY_MBUF(seq->xwin[0], MB_DONTWAIT)) == NULL)
+       if ((m = L2TP_COPY_MBUF(seq->xwin[0], M_NOWAIT)) == NULL)
                priv->stats.memoryFailures++;
        else
                ng_l2tp_xmit_ctrl(priv, m, seq->rack);
@@ -1375,7 +1375,7 @@ ng_l2tp_xmit_ctrl(priv_p priv, struct mbuf *m, u_int16_t ns)
        if (m == NULL) {
 
                /* Create a new mbuf for ZLB packet */
-               MGETHDR(m, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m, M_NOWAIT, MT_DATA);
                if (m == NULL) {
                        priv->stats.memoryFailures++;
                        return (ENOBUFS);
@@ -1394,7 +1394,7 @@ ng_l2tp_xmit_ctrl(priv_p priv, struct mbuf *m, u_int16_t ns)
                m_adj(m, 2);
 
                /* Make room for L2TP header */
-               M_PREPEND(m, 12, MB_DONTWAIT);
+               M_PREPEND(m, 12, M_NOWAIT);
                if (m == NULL) {
                        priv->stats.memoryFailures++;
                        return (ENOBUFS);
index 54cda2b..8152b70 100644 (file)
@@ -330,7 +330,7 @@ nglmi_inquire(sc_p sc, int full)
 
        if (sc->lmi_channel == NULL)
                return;
-       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+       MGETHDR(m, M_NOWAIT, MT_DATA);
        if (m == NULL) {
                log(LOG_ERR, "nglmi: unable to start up LMI processing\n");
                return;
index cb5bca2..2442562 100644 (file)
@@ -1545,7 +1545,7 @@ deliver:
                        /* Split off next fragment as "m2" */
                        m2 = m;
                        if (!lastFragment) {
-                               struct mbuf *n = m_split(m, len, MB_DONTWAIT);
+                               struct mbuf *n = m_split(m, len, M_NOWAIT);
 
                                if (n == NULL) {
                                        NG_FREE_DATA(m, meta);
@@ -1863,7 +1863,7 @@ ng_ppp_addproto(struct mbuf *m, int proto, int compOK)
 static struct mbuf *
 ng_ppp_prepend(struct mbuf *m, const void *buf, int len)
 {
-       M_PREPEND(m, len, MB_DONTWAIT);
+       M_PREPEND(m, len, M_NOWAIT);
        if (m == NULL || (m->m_len < len && (m = m_pullup(m, len)) == NULL))
                return (NULL);
        bcopy(buf, mtod(m, u_char *), len);
index af9b869..adeb2bb 100644 (file)
@@ -659,14 +659,14 @@ AAA
                                kprintf("pppoe: Session out of memory\n");
                                LEAVE(ENOMEM);
                        }
-                       MGETHDR(neg->m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(neg->m, M_NOWAIT, MT_DATA);
                        if(neg->m == NULL) {
                                kprintf("pppoe: Session out of mbufs\n");
                                kfree(neg, M_NETGRAPH);
                                LEAVE(ENOBUFS);
                        }
                        neg->m->m_pkthdr.rcvif = NULL;
-                       MCLGET(neg->m, MB_DONTWAIT);
+                       MCLGET(neg->m, M_NOWAIT);
                        if ((neg->m->m_flags & M_EXT) == 0) {
                                kprintf("pppoe: Session out of mcls\n");
                                m_freem(neg->m);
@@ -1283,7 +1283,7 @@ AAA
                         * But first correct the length.
                         */
                        sp->pkt_hdr.ph.length = htons((short)(m->m_pkthdr.len));
-                       M_PREPEND(m, sizeof(*wh), MB_DONTWAIT);
+                       M_PREPEND(m, sizeof(*wh), M_NOWAIT);
                        if (m == NULL) {
                                LEAVE(ENOBUFS);
                        }
@@ -1457,7 +1457,7 @@ AAA
                                wh->eh.ether_type = ETHERTYPE_PPPOE_DISC;
 
                        /* generate a packet of that type */
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT, MT_DATA);
                        if(m == NULL)
                                kprintf("pppoe: Session out of mbufs\n");
                        else {
@@ -1528,7 +1528,7 @@ AAA
        case    PPPOE_SINIT:
        case    PPPOE_SREQ:
                /* timeouts on these produce resends */
-               m0 = m_copypacket(sp->neg->m, MB_DONTWAIT);
+               m0 = m_copypacket(sp->neg->m, M_NOWAIT);
                NG_SEND_DATA( error, privp->ethernet_hook, m0, dummy);
                callout_reset(&neg->timeout_ch, neg->timeout * hz,
                                pppoe_ticker, hook);
@@ -1575,7 +1575,7 @@ AAA
 
        case    PPPOE_NEWCONNECTED:
                /* send the PADS without a timeout - we're now connected */
-               m0 = m_copypacket(sp->neg->m, MB_DONTWAIT);
+               m0 = m_copypacket(sp->neg->m, M_NOWAIT);
                NG_SEND_DATA( error, privp->ethernet_hook, m0, dummy);
                break;
 
@@ -1590,7 +1590,7 @@ AAA
                 * send the offer but if they don't respond
                 * in PPPOE_OFFER_TIMEOUT seconds, forget about it.
                 */
-               m0 = m_copypacket(sp->neg->m, MB_DONTWAIT);
+               m0 = m_copypacket(sp->neg->m, M_NOWAIT);
                NG_SEND_DATA( error, privp->ethernet_hook, m0, dummy);
                callout_reset(&neg->timeout_ch, PPPOE_OFFER_TIMEOUT * hz,
                                pppoe_ticker, hook);
@@ -1598,7 +1598,7 @@ AAA
 
        case    PPPOE_SINIT:
        case    PPPOE_SREQ:
-               m0 = m_copypacket(sp->neg->m, MB_DONTWAIT);
+               m0 = m_copypacket(sp->neg->m, M_NOWAIT);
                NG_SEND_DATA( error, privp->ethernet_hook, m0, dummy);
                callout_reset(&neg->timeout_ch, PPPOE_INITIAL_TIMEOUT * hz,
                                pppoe_ticker, hook);
index 48c3c38..dd14c1f 100644 (file)
@@ -528,7 +528,7 @@ ng_pptpgre_xmit(node_p node, struct mbuf *m, meta_p meta)
        /* Prepend GRE header to outgoing frame */
        grelen = sizeof(*gre) + sizeof(u_int32_t) * (gre->hasSeq + gre->hasAck);
        if (m == NULL) {
-               MGETHDR(m, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m, M_NOWAIT, MT_DATA);
                if (m == NULL) {
                        priv->stats.memoryFailures++;
                        NG_FREE_META(meta);
@@ -537,7 +537,7 @@ ng_pptpgre_xmit(node_p node, struct mbuf *m, meta_p meta)
                m->m_len = m->m_pkthdr.len = grelen;
                m->m_pkthdr.rcvif = NULL;
        } else {
-               M_PREPEND(m, grelen, MB_DONTWAIT);
+               M_PREPEND(m, grelen, M_NOWAIT);
                if (m == NULL || (m->m_len < grelen
                    && (m = m_pullup(m, grelen)) == NULL)) {
                        priv->stats.memoryFailures++;
index 0b3c2fb..6d3a396 100644 (file)
@@ -283,14 +283,14 @@ ng_rfc1490_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
                        break;
                }
        } else if (hook == priv->ppp) {
-               M_PREPEND(m, 2, MB_DONTWAIT);   /* Prepend PPP NLPID */
+               M_PREPEND(m, 2, M_NOWAIT);      /* Prepend PPP NLPID */
                if (!m)
                        ERROUT(ENOBUFS);
                mtod(m, u_char *)[0] = HDLC_UI;
                mtod(m, u_char *)[1] = NLPID_PPP;
                NG_SEND_DATA(error, priv->downlink, m, meta);
        } else if (hook == priv->inet) {
-               M_PREPEND(m, 2, MB_DONTWAIT);   /* Prepend IP NLPID */
+               M_PREPEND(m, 2, M_NOWAIT);      /* Prepend IP NLPID */
                if (!m)
                        ERROUT(ENOBUFS);
                mtod(m, u_char *)[0] = HDLC_UI;
index b557bf3..a050733 100644 (file)
@@ -308,7 +308,7 @@ ngt_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
                meta_p meta2;
 
                /* Copy packet */
-               m2 = m_dup(m, MB_DONTWAIT);
+               m2 = m_dup(m, M_NOWAIT);
                if (m2 == NULL) {
                        NG_FREE_DATA(m, meta);
                        return (ENOBUFS);
index 8576f72..9fbb366 100644 (file)
@@ -374,7 +374,7 @@ ngt_input(int c, struct tty *tp)
 
        /* Get a new header mbuf if we need one */
        if (!(m = sc->m)) {
-               MGETHDR(m, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m, M_NOWAIT, MT_DATA);
                if (!m) {
                        if (sc->flags & FLG_DEBUG)
                                log(LOG_ERR,
index e65c396..59ea1a5 100644 (file)
@@ -479,7 +479,7 @@ ng_vjc_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
                m_adj(m, vjlen);
 
                /* Copy the reconstructed TCP/IP headers into a new mbuf */
-               MGETHDR(hm, MB_DONTWAIT, MT_DATA);
+               MGETHDR(hm, M_NOWAIT, MT_DATA);
                if (hm == NULL) {
                        priv->slc.sls_errorin++;
                        NG_FREE_DATA(m, meta);
@@ -488,7 +488,7 @@ ng_vjc_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
                hm->m_len = 0;
                hm->m_pkthdr.rcvif = NULL;
                if (hlen > MHLEN) {             /* unlikely, but can happen */
-                       MCLGET(hm, MB_DONTWAIT);
+                       MCLGET(hm, M_NOWAIT);
                        if ((hm->m_flags & M_EXT) == 0) {
                                m_freem(hm);
                                priv->slc.sls_errorin++;
index 454dde7..680e7f4 100644 (file)
@@ -190,7 +190,7 @@ ng_UI_rcvdata(hook_p hook, item_p item)
                m_adj(m, ptr - start);
                NG_FWD_NEW_DATA(error, item, priv->uplink, m);  /* m -> NULL */
        } else if (hook == priv->uplink) {
-               M_PREPEND(m, 1, MB_DONTWAIT);   /* Prepend IP NLPID */
+               M_PREPEND(m, 1, M_NOWAIT);      /* Prepend IP NLPID */
                if (!m)
                        ERROUT(ENOBUFS);
                mtod(m, u_char *)[0] = HDLC_UI;
index 5354c7c..5d1eb03 100644 (file)
@@ -799,7 +799,7 @@ bt3c_receive(bt3c_softc_p sc)
                        sc->state = NG_BT3C_W4_PKT_IND;
                        sc->want = 1;
 
-                       MGETHDR(sc->m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(sc->m, M_NOWAIT, MT_DATA);
                        if (sc->m == NULL) {
                                NG_BT3C_ERR(sc->dev, "Could not get mbuf\n");
                                NG_BT3C_STAT_IERROR(sc->stat);
@@ -807,7 +807,7 @@ bt3c_receive(bt3c_softc_p sc)
                                break; /* XXX lost of sync */
                        }
 
-                       MCLGET(sc->m, MB_DONTWAIT);
+                       MCLGET(sc->m, M_NOWAIT);
                        if (!(sc->m->m_flags & M_EXT)) {
                                NG_FREE_M(sc->m);
 
index c47dc0f..d226f4e 100644 (file)
@@ -536,7 +536,7 @@ ng_h4_input(int c, struct tty *tp)
                if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) {
                        struct mbuf     *m = NULL;
 
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT, MT_DATA);
                        if (m != NULL) {
                                m->m_pkthdr.len = 0;
 
index 758e1fd..6aeba86 100644 (file)
@@ -807,13 +807,13 @@ ubt_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
        switch (USB_GET_STATE(xfer)) {
        case USB_ST_TRANSFERRED:
                /* Allocate a new mbuf */
-               MGETHDR(m, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m, M_NOWAIT, MT_DATA);
                if (m == NULL) {
                        UBT_STAT_IERROR(sc);
                        goto submit_next;
                }
 
-               MCLGET(m, MB_DONTWAIT);
+               MCLGET(m, M_NOWAIT);
                if (!(m->m_flags & M_EXT)) {
                        UBT_STAT_IERROR(sc);
                        goto submit_next;
@@ -907,13 +907,13 @@ ubt_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
        switch (USB_GET_STATE(xfer)) {
        case USB_ST_TRANSFERRED:
                /* Allocate new mbuf */
-               MGETHDR(m, MB_DONTWAIT, MT_DATA);
+               MGETHDR(m, M_NOWAIT, MT_DATA);
                if (m == NULL) {
                        UBT_STAT_IERROR(sc);
                        goto submit_next;
                }
 
-               MCLGET(m, MB_DONTWAIT);
+               MCLGET(m, M_NOWAIT);
                if (!(m->m_flags & M_EXT)) {
                        UBT_STAT_IERROR(sc);
                        goto submit_next;
@@ -1117,13 +1117,13 @@ ubt_isoc_read_one_frame(struct usb_xfer *xfer, int frame_no)
        while (total > 0) {
                if (m == NULL) {
                        /* Start new reassembly buffer */
-                       MGETHDR(m, MB_DONTWAIT, MT_DATA);
+                       MGETHDR(m, M_NOWAIT,