Index: /home/luigi/FreeBSD/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)

int unlock_udbinfo;

u_char tos;

/*

* 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: /home/luigi/FreeBSD/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);

flow_to_route(fle, ro);

}

#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);

}

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: /home/luigi/FreeBSD/head/sys/kern/uipc_mbuf.c

&m_defragrandomfailures, 0, "");

#endif

/*

* Allocate a given length worth of mbufs and/or clusters (whatever fits

* best) and return a pointer to the top of the allocated chain. If an

KASSERT(off >= 0, ("m_copydata, negative off %d", off));

KASSERT(len >= 0, ("m_copydata, negative len %d", len));

while (off > 0) {

KASSERT(m != NULL, ("m_copydata, offset > size of mbuf chain"));

if (off < m->m_len)

Index: /home/luigi/FreeBSD/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: /home/luigi/FreeBSD/head/sys/dev/ixgbe/ixgbe.c

* 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];

err = ixgbe_mq_start_locked(ifp, txr, m);

IXGBE_TX_UNLOCK(txr);

} else {

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

taskqueue_enqueue(que->tq, &txr->txq_task);

}

/* Process the queue */

while (next != NULL) {

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

if (next != NULL)

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

break;

if (txr->tx_avail < IXGBE_TX_OP_THRESHOLD)

ixgbe_txeof(txr);

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

}

txbuf = &txr->tx_buffers[first];

map = txbuf->map;

/*

* Map the packet for DMA.

*/

return (error);

}

}

/* Make certain there are enough descriptors */

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

Index: /home/luigi/FreeBSD/head/sys/net/pfil.c

VNET_DEFINE(struct rmlock, pfil_lock);

#define V_pfil_lock VNET(pfil_lock)

/*

* 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: /home/luigi/FreeBSD/head/sys/net/if_ethersubr.c

#define senderr(e) do { error = (e); goto bad;} while (0)

/*

* 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);

}

return (0);

}

/*

* Queue message on interface, update output statistics if

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