freebsd-nq/sys/netatalk/ddp_usrreq.c
Robert Watson d4b5cae49b Reimplement the netisr framework in order to support parallel netisr
threads:

- Support up to one netisr thread per CPU, each processings its own
  workstream, or set of per-protocol queues.  Threads may be bound
  to specific CPUs, or allowed to migrate, based on a global policy.

  In the future it would be desirable to support topology-centric
  policies, such as "one netisr per package".

- Allow each protocol to advertise an ordering policy, which can
  currently be one of:

  NETISR_POLICY_SOURCE: packets must maintain ordering with respect to
    an implicit or explicit source (such as an interface or socket).

  NETISR_POLICY_FLOW: make use of mbuf flow identifiers to place work,
    as well as allowing protocols to provide a flow generation function
    for mbufs without flow identifers (m2flow).  Falls back on
    NETISR_POLICY_SOURCE if now flow ID is available.

  NETISR_POLICY_CPU: allow protocols to inspect and assign a CPU for
    each packet handled by netisr (m2cpuid).

- Provide utility functions for querying the number of workstreams
  being used, as well as a mapping function from workstream to CPU ID,
  which protocols may use in work placement decisions.

- Add explicit interfaces to get and set per-protocol queue limits, and
  get and clear drop counters, which query data or apply changes across
  all workstreams.

- Add a more extensible netisr registration interface, in which
  protocols declare 'struct netisr_handler' structures for each
  registered NETISR_ type.  These include name, handler function,
  optional mbuf to flow ID function, optional mbuf to CPU ID function,
  queue limit, and ordering policy.  Padding is present to allow these
  to be expanded in the future.  If no queue limit is declared, then
  a default is used.

- Queue limits are now per-workstream, and raised from the previous
  IFQ_MAXLEN default of 50 to 256.

- All protocols are updated to use the new registration interface, and
  with the exception of netnatm, default queue limits.  Most protocols
  register as NETISR_POLICY_SOURCE, except IPv4 and IPv6, which use
  NETISR_POLICY_FLOW, and will therefore take advantage of driver-
  generated flow IDs if present.

- Formalize a non-packet based interface between interface polling and
  the netisr, rather than having polling pretend to be two protocols.
  Provide two explicit hooks in the netisr worker for start and end
  events for runs: netisr_poll() and netisr_pollmore(), as well as a
  function, netisr_sched_poll(), to allow the polling code to schedule
  netisr execution.  DEVICE_POLLING still embeds single-netisr
  assumptions in its implementation, so for now if it is compiled into
  the kernel, a single and un-bound netisr thread is enforced
  regardless of tunable configuration.

In the default configuration, the new netisr implementation maintains
the same basic assumptions as the previous implementation: a single,
un-bound worker thread processes all deferred work, and direct dispatch
is enabled by default wherever possible.

Performance measurement shows a marginal performance improvement over
the old implementation due to the use of batched dequeue.

An rmlock is used to synchronize use and registration/unregistration
using the framework; currently, synchronized use is disabled
(replicating current netisr policy) due to a measurable 3%-6% hit in
ping-pong micro-benchmarking.  It will be enabled once further rmlock
optimization has taken place.  However, in practice, netisrs are
rarely registered or unregistered at runtime.

A new man page for netisr will follow, but since one doesn't currently
exist, it hasn't been updated.

This change is not appropriate for MFC, although the polling shutdown
handler should be merged to 7-STABLE.

Bump __FreeBSD_version.

Reviewed by:	bz
2009-06-01 10:41:38 +00:00

331 lines
7.6 KiB
C

/*-
* Copyright (c) 2004-2009 Robert N. M. Watson
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* Copyright (c) 1990, 1994 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* This product includes software developed by the University of
* California, Berkeley and its contributors.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Wesley Craig
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-764-2278
* netatalk@umich.edu
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <net/if.h>
#include <net/route.h>
#include <net/netisr.h>
#include <netatalk/at.h>
#include <netatalk/at_var.h>
#include <netatalk/ddp_var.h>
#include <netatalk/ddp_pcb.h>
#include <netatalk/at_extern.h>
static u_long ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
static u_long ddp_recvspace = 10 * (587 + sizeof(struct sockaddr_at));
static const struct netisr_handler atalk1_nh = {
.nh_name = "atalk1",
.nh_handler = at1intr,
.nh_proto = NETISR_ATALK1,
.nh_policy = NETISR_POLICY_SOURCE,
};
static const struct netisr_handler atalk2_nh = {
.nh_name = "atalk2",
.nh_handler = at2intr,
.nh_proto = NETISR_ATALK2,
.nh_policy = NETISR_POLICY_SOURCE,
};
static const struct netisr_handler aarp_nh = {
.nh_name = "aarp",
.nh_handler = aarpintr,
.nh_proto = NETISR_AARP,
.nh_policy = NETISR_POLICY_SOURCE,
};
static int
ddp_attach(struct socket *so, int proto, struct thread *td)
{
int error = 0;
KASSERT(sotoddpcb(so) == NULL, ("ddp_attach: ddp != NULL"));
/*
* Allocate socket buffer space first so that it's present
* before first use.
*/
error = soreserve(so, ddp_sendspace, ddp_recvspace);
if (error)
return (error);
DDP_LIST_XLOCK();
error = at_pcballoc(so);
DDP_LIST_XUNLOCK();
return (error);
}
static void
ddp_detach(struct socket *so)
{
struct ddpcb *ddp;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_detach: ddp == NULL"));
DDP_LIST_XLOCK();
DDP_LOCK(ddp);
at_pcbdetach(so, ddp);
DDP_LIST_XUNLOCK();
}
static int
ddp_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
{
struct ddpcb *ddp;
int error = 0;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_bind: ddp == NULL"));
DDP_LIST_XLOCK();
DDP_LOCK(ddp);
error = at_pcbsetaddr(ddp, nam, td);
DDP_UNLOCK(ddp);
DDP_LIST_XUNLOCK();
return (error);
}
static int
ddp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
{
struct ddpcb *ddp;
int error = 0;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_connect: ddp == NULL"));
DDP_LIST_XLOCK();
DDP_LOCK(ddp);
if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
DDP_UNLOCK(ddp);
DDP_LIST_XUNLOCK();
return (EISCONN);
}
error = at_pcbconnect( ddp, nam, td );
DDP_UNLOCK(ddp);
DDP_LIST_XUNLOCK();
if (error == 0)
soisconnected(so);
return (error);
}
static int
ddp_disconnect(struct socket *so)
{
struct ddpcb *ddp;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_disconnect: ddp == NULL"));
DDP_LOCK(ddp);
if (ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE) {
DDP_UNLOCK(ddp);
return (ENOTCONN);
}
at_pcbdisconnect(ddp);
ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
DDP_UNLOCK(ddp);
soisdisconnected(so);
return (0);
}
static int
ddp_shutdown(struct socket *so)
{
KASSERT(sotoddpcb(so) != NULL, ("ddp_shutdown: ddp == NULL"));
socantsendmore(so);
return (0);
}
static int
ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
struct mbuf *control, struct thread *td)
{
struct ddpcb *ddp;
int error = 0;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_send: ddp == NULL"));
if (control && control->m_len)
return (EINVAL);
if (addr != NULL) {
DDP_LIST_XLOCK();
DDP_LOCK(ddp);
if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
error = EISCONN;
goto out;
}
error = at_pcbconnect(ddp, addr, td);
if (error == 0) {
error = ddp_output(m, so);
at_pcbdisconnect(ddp);
}
out:
DDP_UNLOCK(ddp);
DDP_LIST_XUNLOCK();
} else {
DDP_LOCK(ddp);
if (ddp->ddp_fsat.sat_port == ATADDR_ANYPORT)
error = ENOTCONN;
else
error = ddp_output(m, so);
DDP_UNLOCK(ddp);
}
return (error);
}
/*
* XXXRW: This is never called because we only invoke abort on stream
* protocols.
*/
static void
ddp_abort(struct socket *so)
{
struct ddpcb *ddp;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_abort: ddp == NULL"));
DDP_LOCK(ddp);
at_pcbdisconnect(ddp);
DDP_UNLOCK(ddp);
soisdisconnected(so);
}
static void
ddp_close(struct socket *so)
{
struct ddpcb *ddp;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("ddp_close: ddp == NULL"));
DDP_LOCK(ddp);
at_pcbdisconnect(ddp);
DDP_UNLOCK(ddp);
soisdisconnected(so);
}
void
ddp_init(void)
{
DDP_LIST_LOCK_INIT();
netisr_register(&atalk1_nh);
netisr_register(&atalk2_nh);
netisr_register(&aarp_nh);
}
#if 0
static void
ddp_clean(void)
{
struct ddpcp *ddp;
for (ddp = ddpcb_list; ddp != NULL; ddp = ddp->ddp_next)
at_pcbdetach(ddp->ddp_socket, ddp);
DDP_LIST_LOCK_DESTROY();
}
#endif
static int
at_getpeeraddr(struct socket *so, struct sockaddr **nam)
{
return (EOPNOTSUPP);
}
static int
at_getsockaddr(struct socket *so, struct sockaddr **nam)
{
struct ddpcb *ddp;
ddp = sotoddpcb(so);
KASSERT(ddp != NULL, ("at_getsockaddr: ddp == NULL"));
DDP_LOCK(ddp);
at_sockaddr(ddp, nam);
DDP_UNLOCK(ddp);
return (0);
}
struct pr_usrreqs ddp_usrreqs = {
.pru_abort = ddp_abort,
.pru_attach = ddp_attach,
.pru_bind = ddp_bind,
.pru_connect = ddp_connect,
.pru_control = at_control,
.pru_detach = ddp_detach,
.pru_disconnect = ddp_disconnect,
.pru_peeraddr = at_getpeeraddr,
.pru_send = ddp_send,
.pru_shutdown = ddp_shutdown,
.pru_sockaddr = at_getsockaddr,
.pru_close = ddp_close,
};