Index: head/sys/netinet/udp_usrreq.c

#define UH_WLOCKED 2

#define UH_RLOCKED 1

#define UH_UNLOCKED 0

static int

udp_output(struct inpcb *inp, struct mbuf *m, struct sockaddr *addr,

struct mbuf *control, struct thread *td)

u_short fport, lport;

int unlock_udbinfo;

/*

* udp_output() may need to temporarily bind or connect the current

* inpcb. As such, we don't know up front whether we will need the

error = EINVAL;

goto release;

}

error = in_pcbbind_setup(inp, (struct sockaddr *)&src,

&laddr.s_addr, &lport, td->td_ucred);

if (error)

goto release;

}

/*

* Jail may rewrite the destination address, so let it do

* that before we use it.

*/

error = prison_remote_ip4(td->td_ucred, &sin->sin_addr);

if (error)

goto release;

/*

* If a local address or port hasn't yet been selected, or if

}

}

/*

* Calculate data length and get a mbuf for UDP, IP, and possible

* link-layer headers. Immediate slide the data pointer back forward

INP_HASH_WUNLOCK(&V_udbinfo);

else if (unlock_udbinfo == UH_RLOCKED)

INP_HASH_RUNLOCK(&V_udbinfo);

error = ip_output(m, inp->inp_options, NULL, ipflags,

inp->inp_moptions, inp);

if (unlock_udbinfo == UH_WLOCKED)

{

struct inpcb *inp;

inp = sotoinpcb(so);

KASSERT(inp != NULL, ("udp_send: inp == NULL"));

return (udp_output(inp, m, addr, control, td));

Index: head/sys/netinet/ip_output.c

extern int in_mcast_loop;

extern struct protosw inetsw[];

/*

* IP output. The packet in mbuf chain m contains a skeletal IP

* header (with len, off, ttl, proto, tos, src, dst).

#endif

M_ASSERTPKTHDR(m);

if (inp != NULL) {

INP_LOCK_ASSERT(inp);

M_SETFIB(m, inp->inp_inc.inc_fibnum);

}

#endif

}

if (opt) {

int len = 0;

else

isbroadcast = in_broadcast(dst->sin_addr, ifp);

}

/*

* Calculate MTU. If we have a route that is up, use that,

* otherwise use the interface's MTU.

}

sendit:

#ifdef IPSEC

switch(ip_ipsec_output(&m, inp, &flags, &error)) {

case 1:

if (!PFIL_HOOKED(&V_inet_pfil_hook))

goto passout;

/* Run through list of hooks for output packets. */

odst.s_addr = ip->ip_dst.s_addr;

error = pfil_run_hooks(&V_inet_pfil_hook, &m, ifp, PFIL_OUT, inp);

#endif /* IPFIREWALL_FORWARD */

passout:

/* 127/8 must not appear on wire - RFC1122. */

if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||

(ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {

* to avoid confusing lower layers.

*/

m->m_flags &= ~(M_PROTOFLAGS);

error = (*ifp->if_output)(ifp, m,

(struct sockaddr *)dst, ro);

goto done;

Index: head/sys/kern/uipc_syscalls.c

return (error);

}

static int

sendit(td, s, mp, flags)

struct thread *td;

return (ECAPMODE);

#endif

if (mp->msg_name != NULL) {

error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);

if (error) {

} else {

to = NULL;

}

if (mp->msg_control) {

if (mp->msg_controllen < sizeof(struct cmsghdr)

control = NULL;

}

error = kern_sendit(td, s, mp, flags, control, UIO_USERSPACE);

bad:

rights = CAP_WRITE;

if (mp->msg_name != NULL)

rights |= CAP_CONNECT;

error = getsock_cap(td->td_proc->p_fd, s, rights, &fp, NULL);

if (error)

return (error);

ktruio = cloneuio(&auio);

#endif

len = auio.uio_resid;

error = sosend(so, mp->msg_name, &auio, 0, control, flags, td);

if (error) {

if (auio.uio_resid != len && (error == ERESTART ||

struct iovec aiov;

int error;

msg.msg_name = uap->to;

msg.msg_namelen = uap->tolen;

msg.msg_iov = &aiov;

Index: head/sys/kern/uipc_socket.c

return (error);

}

#ifdef ZERO_COPY_SOCKETS

struct so_zerocopy_stats{

int size_ok;

int atomic = sosendallatonce(so) || top;

#endif

KASSERT(so->so_type == SOCK_DGRAM, ("sodgram_send: !SOCK_DGRAM"));

KASSERT(so->so_proto->pr_flags & PR_ATOMIC,

("sodgram_send: !PR_ATOMIC"));

error = EMSGSIZE;

goto out;

}

if (uio == NULL) {

resid = 0;

if (flags & MSG_EOR)

#endif

resid = uio->uio_resid;

}

KASSERT(resid == 0, ("sosend_dgram: resid != 0"));

/*

* XXXRW: Frobbing SO_DONTROUTE here is even worse without sblock

so->so_options |= SO_DONTROUTE;

SOCK_UNLOCK(so);

}

/*

* XXX all the SBS_CANTSENDMORE checks previously done could be out

* of date. We could have recieved a reset packet in an interrupt or

Index: head/sys/dev/netmap/netmap.c

SYSCTL_INT(_dev_netmap, OID_AUTO, no_pendintr,

CTLFLAG_RW, &netmap_no_pendintr, 0, "Always look for new received packets.");

/*------------- memory allocator -----------------*/

#ifdef NETMAP_MEM2

#include "netmap_mem2.c"

kring->nr_hwcur + kring->nr_hwavail, len);

na->nm_lock(ifp, NETMAP_CORE_LOCK, 0);

if (kring->nr_hwavail >= lim) {

goto done; /* no space */

}

if (len > NETMAP_BUF_SIZE) {

netmap_loader(__unused struct module *module, int event, __unused void *arg)

{

int error = 0;

switch (event) {

case MOD_LOAD:

error = netmap_init();

Index: head/sys/dev/ixgbe/ixgbe.c

* be a reference on how to implement netmap support in a driver.

* Additional comments are in ixgbe_netmap.h .

*

* that extend the standard driver.

*/

#include <dev/netmap/ixgbe_netmap.h>

#endif /* DEV_NETMAP */

/*********************************************************************

struct tx_ring *txr;

int i = 0, err = 0;

/* Which queue to use */

if ((m->m_flags & M_FLOWID) != 0)

i = m->m_pkthdr.flowid % adapter->num_queues;

else

i = curcpu % adapter->num_queues;

txr = &adapter->tx_rings[i];

que = &adapter->queues[i];

if (((txr->queue_status & IXGBE_QUEUE_DEPLETED) == 0) &&

IXGBE_TX_TRYLOCK(txr)) {

err = ixgbe_mq_start_locked(ifp, txr, m);

IXGBE_TX_UNLOCK(txr);

} else {

err = drbr_enqueue(ifp, txr->br, m);

taskqueue_enqueue(que->tq, &que->que_task);

}

/* Process the queue */

while (next != NULL) {

if ((err = ixgbe_xmit(txr, &next)) != 0) {

if (next != NULL)

err = drbr_enqueue(ifp, txr->br, next);

txr->queue_status |= IXGBE_QUEUE_DEPLETED;

break;

}

next = drbr_dequeue(ifp, txr->br);

}

txbuf = &txr->tx_buffers[first];

map = txbuf->map;

/*

* Map the packet for DMA.

*/

*m_headp = NULL;

return (error);

}

/* Make certain there are enough descriptors */

if (nsegs > txr->tx_avail - 2) {

#endif

#ifdef IXGBE_FDIR

/* Do the flow director magic */

if ((txr->atr_sample) && (!adapter->fdir_reinit)) {

++txr->atr_count;

Index: head/sys/net/pfil.c

VNET_DEFINE(struct pfilheadhead, pfil_head_list);

#define V_pfil_head_list VNET(pfil_head_list)

/*

* pfil_run_hooks() runs the specified packet filter hooks.

*/

struct packet_filter_hook *pfh;

struct mbuf *m = *mp;

int rv = 0;

PFIL_RLOCK(ph, &rmpt);

KASSERT(ph->ph_nhooks >= 0, ("Pfil hook count dropped < 0"));

for (pfh = pfil_hook_get(dir, ph); pfh != NULL;

pfh = TAILQ_NEXT(pfh, pfil_link)) {

Index: head/sys/net/if_ethersubr.c

#define V_ether_ipfw VNET(ether_ipfw)

#endif

/*

* Ethernet output routine.

* Encapsulate a packet of type family for the local net.

int loop_copy = 1;

int hlen; /* link layer header length */

if (ro != NULL) {

if (!(m->m_flags & (M_BCAST | M_MCAST)))

lle = ro->ro_lle;

switch (dst->sa_family) {

#ifdef INET

case AF_INET:

if (lle != NULL && (lle->la_flags & LLE_VALID))

memcpy(edst, &lle->ll_addr.mac16, sizeof(edst));

else

return (if_simloop(ifp, m, dst->sa_family, 0));

}

/*

* Add local net header. If no space in first mbuf,

* allocate another.

if (m == NULL)

senderr(ENOBUFS);

eh = mtod(m, struct ether_header *);

(void)memcpy(&eh->ether_type, &type,

sizeof(eh->ether_type));

(void)memcpy(eh->ether_dhost, edst, sizeof (edst));

if (hdrcmplt)

(void)memcpy(eh->ether_shost, esrc,

sizeof(eh->ether_shost));

(void)memcpy(eh->ether_shost, IF_LLADDR(ifp),

sizeof(eh->ether_shost));

/*

* If a simplex interface, and the packet is being sent to our

* Ethernet address or a broadcast address, loopback a copy.

}

}

/*

* Bridges require special output handling.

*/

return (0);

}

/* Continue with link-layer output */

return ether_output_frame(ifp, m);

}

}

#endif

/*

* Queue message on interface, update output statistics if

* successful, and start output if interface not yet active.