route: Suppress duplicated rtmsgs on ARP input path.

route: Suppress duplicated rtmsgs on route_output(RTM_CHANGE) path

route: Suppress duplicated rtmsgs generated by rtlookup() in rt_setgate()

Add 'generate_report' parameter to rt_setgate().  In rt_setgate(), instead
of passing RTL_REPORTMSG to rtlookup(), we pass 'generated_report' to
rtlookup().

For rtrequset1(RTM_ADD) and rtredirect(), which always go through all CPUs,
we only need to generate rtmsg on CPU0.  For {arp,atm,nd6}_rtrequest(),
there is no need to generated rtmsg.

rtsock: Fill in the correct rtm_index for RTM_ADD and RTM_CHANGE messages.

Obtained-from: OpenBSD via FreeBSD (part of net/rtsock.c rev1.133)

rtsock: Use M_ASSERTPKTHDR()

rtsock: Break long line

rtsock: Fill in the rtm_index field whenever we have an interface pointer.

Obtained-from: FreeBSD (net/rtsock.c rev1.123)

rtsock: White space

rtsock: Use rtsearch_global() for RTM_GET

rtsock: Unbreak RTM_LOCK support by using rtsearch_global()

route: Add rtsearch_global(), which is used to fix RTM_CHANGE support.

rtsearch_global() forwards a netmsg to each CPUs.  On each CPU, it
uses radix tree lookup function to locate the requested route, if the
route is found, then call the passed in callback.  The callback could
return error thus terminate the message forwarding.  If the requested
route was not found on any of the CPUs, then ESRCH is replied on the
last CPU.

rtsock: Minor style change

rtsock: Fix a reversed condition

rtsock: Fix !SO_USELOOPBACK support in route_output()

Old BSD code assumes that rts_input() is synchronous, so clear/set
sp_family could be used to skip the current rawcb.  However, our
rts_input() is asynchronous, thus the clear/set sp_family trick no
longer takes any effect.

Reimplement the rawcb skipping in the following way:
- Record the address of rawcb to be skipped in netmsg.
- Extend raw_input() interface to accept a 'skip' argument.  At the
  beginning of the rawcb list iteration, check the address of the
  current rawcb against the 'skip'.

busdma(9): Dup i386 busdma_machdep.c to vkernel

busdma(9): Dup i386 busdma_machdep.c to amd64

Unbreak LINT build

sis(4): Rework busdma(9) related bits

- RX/TX descriptor rings need to be 4bytes aligned.
- RX buffers need to be 4bytes aligned.
- Create TX/RX buffer busdma map at attaching time and destroy them
  at detaching time.
- Rework sis_newbuf() by utilizing bus_dmamap_load_mbuf_segment().
- Factor sis_setup_rxdesc() out of sis_newbuf() and call it on RX
  error handling path.
- Rework sis_encap() by utilizing bus_dmamap_load_mbuf_defrag().
- Correct IFF_OACTIVE handling in sis_start()/sis_txeof().

sis(4): Move software specific fields out of hardware descriptor structure

bce(4): Remove unnecessary bus_dmamap_sync()

bce(4): Adjust RX path to avoid fatal error caused by busdma failure

- Create tmp busdma map for loading mbuf on RX path, so busdma map
  loading failure will not be fatal.
- Don't unload RX buffer's busdma map until we could make sure that
  new RX buffer could be loaded.
- On RX path, if error happens, we only need to reconfigure RX desc,
  so just call bce_setup_rxdesc_std().
- Make sure that sw_chain_cons and sw_chain_prod are same, else
  log error and reconfigure the RX desc indiced by sw_chain_cons.
- Utilize bus_dmamap_load_mbuf_segment().

bce(4): Factor RX desc setup out of bce_newbuf_std()

bce(4): Utilize bus_dmamap_load_mbuf_defrag()

bce(4): Use coherent for non-buffer data storage

- Utilize bus_dmamem_coherent_any()
- Put RX/TX pages into coherent memory
- Don't sync coherent memory

bce(4): Correct parameters passed to busdma(9) functions

stge(4): Remove unnecessary bus_dmamap_sync()

stge(4): Adjust TX path

- Utilize bus_dmamap_load_mbuf_defrag()
- Sync TX buffer before setup the TX desc
- In stge_{txeof,start}(), use the same condition to clear/set IFF_OACTIVE

stge(4): Utilize bus_dmamap_load_mbuf_segment()

stge(4): Don't sync coherent memory

stge(4): Adjust the error handling code on stge_dma_alloc()

stge(4): Utilize bus_dmamem_coherent_any()

stge(4): Regroup busdma tag creation; prepare for the upcoming changes

stge(4): Correct parameters passed to busdma(9) functions

et(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

et(4): Split RX/TX mbuf busdma tag

et(4): Don't sync coherent memory

et(4): Utilize bus_dmamem_coherent_any()

busdma(9): Add bus_dmamem_coherent_any()

This function is a simplified version of bus_dmamem_coherent(),
see the comment in sys/bus_dma.h for details.

et(4): Utilize bus_dmamem_coherent()

et(4): Correct parameters passed to busdma(9) functions

msk(4): Align TX buffer to 64bytes boundary instead of 8bytes boundary

The correct alignment boundary is found out by using busdma(9)'s
alignment constraint.  However, it seems that using in-place copy
results in better performance than let busdma(9) to bounce misaligned
TX buffer, especially with tiny packets; probably due to the "in-place"

msk(4): Align TX buffer to 8bytes boundary to improve TX performance

The performance improvement is ~100Mbps (from 83xMbps to 93xMbps) for
bulk data.  This is accidentally found by forcing msk(4) to bounce TX
buffers to lower address during a busdma(4) test (bounce pages are
PAGE_SIZE aligned).

busdma(9): Obey alignment constraint by default

msk(4): Avoid busdma map leakage on error handling path

msk(4): Adjust TX path

- Utilize bus_dmamap_load_mbuf_defrag().
- Fix the IFF_OACTIVE setting in msk_start().  This restores the
  fragmented UDP output performance.
- Sync TX buffer before setup TX desc.
- Remove unnecessary bus_dmamap_sync().

msk(4): Utilize bus_dmamap_load_mbuf_segment()

msk(4): Utilize bus_dmamem_coherent() and don't sync coherent memory

msk(4): Correct parameters passed to busdma(9) functions

sk(4): Utilize bus_dmamap_load_mbuf_defrag()

sk(4): Adjust RX path a little bit

- Utilize bus_dmamap_load_mbuf_segment()
- Don't try m_devget(); it does not help much, if the NIC is quenched
  by the peer, e.g. by line rate fragmented UDP datagrams
- Move bus_dmamap_sync() from sk_rxeof() into sk_newbuf_std()

sk(4): Rework busdma(9) related bits

- According to data sheet, sk(4) does support 64bits address space.
  However, the RX/TX descriptors' high 32bits must be same, i.e.
  descriptors' can't spread above and below 4Gbytes boundary.  Since
  sk(4)'s RX/TX descriptors are in contiguous memory, this means we
  only need to make sure that the contiguous memory does not cross
  4Gbytes boundary.
- RX/TX descriptors' is 8bytes aligned not 64bytes aligned.
- Split RX/TX descriptor rings.
- Use bus_dmamem_coherent() to allocate RX/TX descriptor rings.
- Don't sync coherent memory.

sk(4): Adjust TX path a little bit.

rl(4): Don't use magic number

rl(4): Rework busdma(9) related bits

- Correct parameters passed to busdma(9) functions.
- Split RX/TX busdma tag.
- Use bus_dmamem_coherent() to allocate RX buffers.
- Create TX buffer busdma map at attach time and destroy them only
  at detach time.
- Rework rl_encap().
- Don't sync RX buffers, which is coherent memory.

bge(4): Remove unnecessary bus_dmamap_sync()

bge(4): Utilize bus_dmamap_load_mbuf_{defrag,segment}()

bge(4): Rework bge_newbuf_{std,jumbo}()

- Always fill the std RX ring, instead of leaving it half full.
  On modern system, 1MBytes non-contiguous memory will not be
  the source of trouble.
- Record RX buffer's physical address along with the RX mbuf.
- Factor out bge_setup_rxdesc_{std,jumbo}(); call them if RX errors
  happen.
- Move RX std buffer busdma map sync/unload into bge_newbuf_std()
- Use temporary busdma map to load RX std buffer, so that the busdma
  map loading failure will not be fatal.

bge(4): Split RX/TX mbuf busdma tags

bge(4): Don't sync coherent memory

bge(4): Utilize bus_dmamem_coherent()

bge(4): Correct busdma parameters

if_bgereg.h: Remove extra white space

busdma(9): Update FreeBSD RSCID.

busdma(9): Don't record/use boundary in bounce zone

Bounce zone's boundary does not make any sense for PAGE_SIZE
contiguous allocation which also aligned on multiple or one
PAGE_SIZE.

busdma(9): Use the passed in 'flags' instead of hard coding BUS_DMA_NOWAIT

jme(4): Don't sync coherent memory

re(4): Don't sync coherent memory

nfe(4): Coherent memory does not need to be synced

xl(4): Coherent memory does not need to be synced

bfe(4): Coherent memory does not need to be synced

jme(4): Move TX buffer syncing before setting up TX desc

jme(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

jme(4): Depend on parent busdma tag to apply lowaddr constraint

jme(4): jme_dma_free() is only called on detach path now

jme(4): Utilize bus_dmamem_coherent()

jme(4): Fix busdma(9) parameters

jme(4): Rely on busdma(9) to do the boundary check

busdma(9): Add sysctl node to show whether aligment constraint is obeyed or not

busdma(9): Obey alignment constraint, disabled by default

- Obey alignment constraint
  Obtained-from: FreeBSD
- Correct "cross page boundary" check in bus_dmamem_alloc()
- Make sure that after kmalloc() retry, memory will not cross page
  boundary and is properly aligned.  If not, print backtrace; should
  panic though.
- Factor out BUS_DMA_KMALLOC(), so we don't duplicate the conditions
  in bus_dmamem_alloc() and bus_dmamem_free()
- Assert the input memory is properly aligned, if caller told us so

busdma(9): get rid of bounce_lowaddr, which serves no purpose

xl(4): Remove unused bus_dmamap_sync()

xl(4): Rework xl_encap()

xl(4): Rework xl_newbuf()

- Utilize bus_dmamap_load_mbuf_segment()
- Move setting buffer address before clearing status
- Add init flag, so we could use M_WAIT during device initialization
- Move bus_dmamap_sync(POSTREAD) into xl_newbuf() and do busdma sync
  and unload iff we previously loaded a mbuf.

xl(4): Split RX and TX mbuf busdma tag

xl(4): Utilize bus_dmamem_coherent()

xl(4): Allocate parent busdma tag, which is used to constraint lowaddr

nfe(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

re(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

busdma(9): Add BUS_DMA_ALIGNED hint flag

This flag is used to give hint to busdma(9) that all to-be-loaded
memory is proper aligned, thus no bounce pages should be allocated.
This will be used when busdma obeys alignment requirement.

It could save us some bounce page memory under following situation:
Some NICs require RX buffer to be 4 or 8 bytes aligned while our mbuf
cluster allocation always promises 2048 bytes alignment.

Rename BUS_DMA_ONEPAGE to BUS_DMA_ONEBPAGE, should have done that
in the first place though ...

bfe(4): Utilize bus_dmamap_load_mbuf_defrag()

busdma(9): Add bus_dmamap_load_mbuf_defrag()

This function is mainly used to avoid code duplication in various
(should be many) NIC driver code.

bfe(4): Utilize bus_dmamap_load_mbuf_segment()

busdma(9): Add bus_dmamap_load_mbuf_segment()

See the comment in sys/bus_dma.h for detailed information
about this function.

Let bus_dmamap_load_mbuf() call this function with busdma tag's
segments and nsegments.

Inspired-by: FreeBSD's bus_dmamap_load_mbuf_sg()

nfe(4): busdma(9) fixes

On RX path:
- Unload busdma map iff the map has already been loaded
- Add missing bus_dmamap_sync()

On TX path:
- Reduce log verbosity
- Move buffer content's bus_dmamap_sync() to the proper place

Misc:
- Nuke unnecessary bus_dmamap_sync()

busdma(9): More bounce page bug fixing

Turn on BUS_DMA_MIN_ALLOC_COMP, iff we do allocate bounce pages for
the busdma tag.

busdma(9): Add tunable and read-only sysctl node for max # of bounce
pages per bounce zone.

nfe(4): Always set high part of the address if the NIC supports
40bits address space accessing.

nfe(4): busdma(9) correction

- Use bus_dmamem_coherent()
- Fix busdma(9) parameters

re(4): add missing BUS_DMA_WAITOK

bfe(4): Add missing BUS_DMA_WAITOK