5c95d686a1
for unknown events. A number of modules return EINVAL in this instance, and I have left those alone for now and instead taught MOD_QUIESCE to accept this as "didn't do anything".
662 lines
16 KiB
C
662 lines
16 KiB
C
/*
|
|
* Copyright (c) 2003
|
|
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
|
|
* 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.
|
|
*
|
|
* Author: Harti Brandt <harti@freebsd.org>
|
|
*
|
|
* HARP pseudo-driver. This driver when loaded attaches to all ngATM drivers
|
|
* in the system and creates a HARP physical interface for each of them.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/module.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/syslog.h>
|
|
|
|
#include <sys/sockio.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_var.h>
|
|
#include <net/if_types.h>
|
|
#include <net/if_media.h>
|
|
#include <net/netisr.h>
|
|
|
|
#include <netatm/port.h>
|
|
#include <netatm/queue.h>
|
|
#include <netatm/atm.h>
|
|
#include <netatm/atm_sys.h>
|
|
#include <netatm/atm_sap.h>
|
|
#include <netatm/atm_cm.h>
|
|
#include <netatm/atm_if.h>
|
|
#include <netatm/atm_stack.h>
|
|
#include <netatm/atm_pcb.h>
|
|
#include <netatm/atm_var.h>
|
|
#include <netatm/atm_vc.h>
|
|
|
|
#include <net/if_atm.h>
|
|
|
|
#define HARP_MTU 9188
|
|
|
|
/*
|
|
* Physical interface softc
|
|
*/
|
|
struct harp_softc {
|
|
Cmn_unit cmn;
|
|
struct ifnet *parent;
|
|
LIST_ENTRY(harp_softc) link;
|
|
};
|
|
|
|
struct harp_vcc {
|
|
struct cmn_vcc cmn;
|
|
};
|
|
|
|
MODULE_VERSION(harp, 1);
|
|
MODULE_DEPEND(harp, atm, 1, 1, 1);
|
|
|
|
/* hooks from if_atmsubr.c */
|
|
extern void (*atm_harp_input_p)(struct ifnet *ifp, struct mbuf **m,
|
|
struct atm_pseudohdr *ah, void *rxhand);
|
|
extern void (*atm_harp_attach_p)(struct ifnet *);
|
|
extern void (*atm_harp_detach_p)(struct ifnet *);
|
|
|
|
static MALLOC_DEFINE(M_HARP, "harp", "Harp pseudo interface");
|
|
|
|
static uma_zone_t harp_nif_zone;
|
|
static uma_zone_t harp_vcc_zone;
|
|
|
|
/* List of all existing 'harp' interfaces */
|
|
static LIST_HEAD(, harp_softc) harp_softc_list =
|
|
LIST_HEAD_INITIALIZER(harp_softc_list);
|
|
|
|
static struct stack_defn harp_svaal5 = {
|
|
NULL,
|
|
SAP_CPCS_AAL5,
|
|
SDF_TERM,
|
|
atm_dev_inst,
|
|
atm_dev_lower,
|
|
NULL,
|
|
0,
|
|
};
|
|
|
|
static struct stack_defn *harp_services = &harp_svaal5;
|
|
|
|
/*
|
|
* Map between constants
|
|
*/
|
|
static const struct {
|
|
u_int vendor;
|
|
u_int api;
|
|
u_int dev;
|
|
} map_devs[] = {
|
|
[ATM_DEVICE_UNKNOWN] =
|
|
{ VENDOR_UNKNOWN, VENDAPI_UNKNOWN, DEV_UNKNOWN },
|
|
[ATM_DEVICE_PCA200E] =
|
|
{ VENDOR_FORE, VENDAPI_FORE_1, DEV_FORE_PCA200E },
|
|
[ATM_DEVICE_HE155] =
|
|
{ VENDOR_FORE, VENDAPI_FORE_2, DEV_FORE_HE155 },
|
|
[ATM_DEVICE_HE622] =
|
|
{ VENDOR_FORE, VENDAPI_FORE_2, DEV_FORE_HE622 },
|
|
[ATM_DEVICE_ENI155P] =
|
|
{ VENDOR_ENI, VENDAPI_ENI_1, DEV_ENI_155P },
|
|
[ATM_DEVICE_ADP155P] =
|
|
{ VENDOR_ENI, VENDAPI_ENI_1, DEV_ENI_155P },
|
|
[ATM_DEVICE_FORELE25] =
|
|
{ VENDOR_FORE, VENDAPI_IDT_1, DEV_FORE_LE25 },
|
|
[ATM_DEVICE_FORELE155] =
|
|
{ VENDOR_FORE, VENDAPI_IDT_1, DEV_FORE_LE155 },
|
|
[ATM_DEVICE_NICSTAR25] =
|
|
{ VENDOR_IDT, VENDAPI_IDT_1, DEV_IDT_25 },
|
|
[ATM_DEVICE_NICSTAR155] =
|
|
{ VENDOR_IDT, VENDAPI_IDT_1, DEV_IDT_155 },
|
|
[ATM_DEVICE_IDTABR25] =
|
|
{ VENDOR_IDT, VENDAPI_IDT_2, DEV_IDTABR_25 },
|
|
[ATM_DEVICE_IDTABR155] =
|
|
{ VENDOR_IDT, VENDAPI_IDT_2, DEV_IDTABR_155 },
|
|
[ATM_DEVICE_PROATM25] =
|
|
{ VENDOR_PROSUM, VENDAPI_IDT_2, DEV_PROATM_25 },
|
|
[ATM_DEVICE_PROATM155] =
|
|
{ VENDOR_PROSUM, VENDAPI_IDT_2, DEV_PROATM_155 },
|
|
};
|
|
|
|
/*
|
|
* Return zero if this interface is ok for us.
|
|
* XXX This should go away when we have full ngATM-ified the en driver.
|
|
*/
|
|
static int
|
|
harp_check_if(const struct ifnet *ifp)
|
|
{
|
|
if (ifp->if_type == IFT_ATM && strcmp(ifp->if_dname, "en"))
|
|
return (0);
|
|
else
|
|
return (-1);
|
|
}
|
|
|
|
/*
|
|
* Instantiate a VCC stack.
|
|
*
|
|
* Could check for correct attributes here.
|
|
*/
|
|
static int
|
|
harp_instvcc(Cmn_unit *up, Cmn_vcc *vp)
|
|
{
|
|
struct harp_softc *sc;
|
|
|
|
if (up == NULL || vp == NULL || vp->cv_connvc == NULL)
|
|
return (EINVAL);
|
|
|
|
sc = (struct harp_softc *)up;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Open a VCC.
|
|
*/
|
|
static int
|
|
harp_openvcc(Cmn_unit *up, Cmn_vcc *vp)
|
|
{
|
|
struct harp_softc *sc;
|
|
struct atmio_openvcc data;
|
|
Atm_attributes *attrib;
|
|
struct vccb *vccinf;
|
|
const struct ifatm_mib *mib;
|
|
int err;
|
|
|
|
if (up == NULL || vp == NULL || vp->cv_connvc == NULL)
|
|
return (EINVAL);
|
|
|
|
sc = (struct harp_softc *)up;
|
|
mib = sc->parent->if_linkmib;
|
|
|
|
attrib = &vp->cv_connvc->cvc_attr;
|
|
vccinf = vp->cv_connvc->cvc_vcc;
|
|
|
|
if (attrib == NULL || vccinf == NULL)
|
|
return (EINVAL);
|
|
|
|
if (vccinf->vc_vpi >= (1 << mib->vpi_bits) ||
|
|
vccinf->vc_vci >= (1 << mib->vci_bits))
|
|
return (EINVAL);
|
|
|
|
memset(&data, 0, sizeof(data));
|
|
|
|
switch (attrib->aal.type) {
|
|
|
|
case ATM_AAL0:
|
|
data.param.aal = ATMIO_AAL_0;
|
|
break;
|
|
|
|
case ATM_AAL5:
|
|
data.param.aal = ATMIO_AAL_5;
|
|
break;
|
|
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
data.param.vpi = vccinf->vc_vpi;
|
|
data.param.vci = vccinf->vc_vci;
|
|
data.param.rmtu = HARP_MTU;
|
|
data.param.tmtu = HARP_MTU;
|
|
|
|
switch (attrib->bearer.v.bearer_class) {
|
|
|
|
case T_ATM_CLASS_C:
|
|
data.param.traffic = ATMIO_TRAFFIC_VBR;
|
|
break;
|
|
|
|
case T_ATM_CLASS_X:
|
|
switch (attrib->bearer.v.traffic_type) {
|
|
|
|
case T_ATM_CBR:
|
|
data.param.traffic = ATMIO_TRAFFIC_CBR;
|
|
break;
|
|
|
|
case T_ATM_VBR:
|
|
data.param.traffic = ATMIO_TRAFFIC_VBR;
|
|
break;
|
|
|
|
case T_ATM_ABR:
|
|
/* not really supported by HARP */
|
|
return (EINVAL);
|
|
|
|
default:
|
|
case T_ATM_UBR:
|
|
data.param.traffic = ATMIO_TRAFFIC_UBR;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
data.param.tparam.pcr = attrib->traffic.v.forward.PCR_all_traffic;
|
|
data.param.tparam.scr = attrib->traffic.v.forward.SCR_all_traffic;
|
|
data.param.tparam.mbs = attrib->traffic.v.forward.MBS_all_traffic;
|
|
|
|
data.rxhand = sc;
|
|
data.param.flags = ATMIO_FLAG_HARP;
|
|
|
|
err = (*sc->parent->if_ioctl)(sc->parent, SIOCATMOPENVCC,
|
|
(caddr_t)&data);
|
|
|
|
return (err);
|
|
}
|
|
|
|
/*
|
|
* Close VCC
|
|
*/
|
|
static int
|
|
harp_closevcc(Cmn_unit *up, Cmn_vcc *vp)
|
|
{
|
|
struct harp_softc *sc;
|
|
struct atmio_closevcc data;
|
|
int err;
|
|
|
|
if (vp == NULL || vp->cv_connvc == NULL ||
|
|
vp->cv_connvc->cvc_vcc == NULL)
|
|
return (EINVAL);
|
|
|
|
sc = (struct harp_softc *)up;
|
|
|
|
data.vpi = vp->cv_connvc->cvc_vcc->vc_vpi;
|
|
data.vci = vp->cv_connvc->cvc_vcc->vc_vci;
|
|
|
|
err = (*sc->parent->if_ioctl)(sc->parent, SIOCATMCLOSEVCC,
|
|
(caddr_t)&data);
|
|
|
|
return (err);
|
|
}
|
|
|
|
/*
|
|
* IOCTLs
|
|
*/
|
|
static int
|
|
harp_ioctl(int code, caddr_t addr, caddr_t arg)
|
|
{
|
|
return (ENOSYS);
|
|
}
|
|
|
|
/*
|
|
* Output data
|
|
*/
|
|
static void
|
|
harp_output(Cmn_unit *cu, Cmn_vcc *cv, KBuffer *m)
|
|
{
|
|
struct harp_softc *sc = (struct harp_softc *)cu;
|
|
struct atm_pseudohdr *aph;
|
|
int error;
|
|
int mlen;
|
|
|
|
if (cv == NULL || cv->cv_connvc == NULL ||
|
|
cv->cv_connvc->cvc_vcc == NULL) {
|
|
m_freem(m);
|
|
return;
|
|
}
|
|
M_ASSERTPKTHDR(m);
|
|
|
|
/*
|
|
* Harp seems very broken with regard to mbuf handling. The length
|
|
* in the packet header is mostly broken here so recompute it.
|
|
*/
|
|
m->m_pkthdr.len = mlen = m_length(m, NULL);
|
|
|
|
/*
|
|
* Prepend pseudo-hdr. Drivers don't care about the flags.
|
|
*/
|
|
M_PREPEND(m, sizeof(*aph), M_DONTWAIT);
|
|
if (m == NULL)
|
|
return;
|
|
|
|
aph = mtod(m, struct atm_pseudohdr *);
|
|
ATM_PH_VPI(aph) = cv->cv_connvc->cvc_vcc->vc_vpi;
|
|
ATM_PH_SETVCI(aph, cv->cv_connvc->cvc_vcc->vc_vci);
|
|
ATM_PH_FLAGS(aph) = 0;
|
|
|
|
error = atm_output(sc->parent, m, NULL, NULL);
|
|
|
|
if (error) {
|
|
printf("%s: error %d\n", __func__, error);
|
|
sc->cmn.cu_pif.pif_oerrors++;
|
|
cv->cv_connvc->cvc_vcc->vc_oerrors++;
|
|
if (cv->cv_connvc->cvc_vcc->vc_nif)
|
|
cv->cv_connvc->cvc_vcc->vc_nif->nif_if.if_oerrors++;
|
|
return;
|
|
}
|
|
|
|
/* statistics */
|
|
sc->cmn.cu_pif.pif_opdus++;
|
|
sc->cmn.cu_pif.pif_obytes += mlen;
|
|
cv->cv_connvc->cvc_vcc->vc_opdus++;
|
|
cv->cv_connvc->cvc_vcc->vc_obytes += mlen;
|
|
if (cv->cv_connvc->cvc_vcc->vc_nif) {
|
|
cv->cv_connvc->cvc_vcc->vc_nif->nif_obytes += mlen;
|
|
cv->cv_connvc->cvc_vcc->vc_nif->nif_if.if_obytes += mlen;
|
|
cv->cv_connvc->cvc_vcc->vc_nif->nif_if.if_opackets++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Attach a new interface
|
|
*/
|
|
static void
|
|
harp_attach(struct ifnet *parent)
|
|
{
|
|
struct harp_softc *sc;
|
|
const struct ifatm_mib *mib;
|
|
int error;
|
|
|
|
if (harp_check_if(parent) != 0)
|
|
return;
|
|
|
|
sc = malloc(sizeof(*sc), M_HARP, M_WAITOK | M_ZERO);
|
|
|
|
sc->parent = parent;
|
|
sc->cmn.cu_unit = parent->if_dunit;
|
|
sc->cmn.cu_mtu = HARP_MTU;
|
|
sc->cmn.cu_ioctl = harp_ioctl;
|
|
sc->cmn.cu_instvcc = harp_instvcc;
|
|
sc->cmn.cu_openvcc = harp_openvcc;
|
|
sc->cmn.cu_closevcc = harp_closevcc;
|
|
sc->cmn.cu_output = harp_output;
|
|
sc->cmn.cu_vcc_zone = harp_vcc_zone;
|
|
sc->cmn.cu_nif_zone = harp_nif_zone;
|
|
sc->cmn.cu_softc = sc;
|
|
|
|
/* config */
|
|
mib = parent->if_linkmib;
|
|
if (mib->device >= sizeof(map_devs) / sizeof(map_devs[0])) {
|
|
sc->cmn.cu_config.ac_vendor = VENDOR_UNKNOWN;
|
|
sc->cmn.cu_config.ac_vendapi = VENDAPI_UNKNOWN;
|
|
sc->cmn.cu_config.ac_device = DEV_UNKNOWN;
|
|
} else {
|
|
sc->cmn.cu_config.ac_vendor = map_devs[mib->device].vendor;
|
|
sc->cmn.cu_config.ac_vendapi = map_devs[mib->device].api;
|
|
sc->cmn.cu_config.ac_device = map_devs[mib->device].dev;
|
|
}
|
|
|
|
switch (mib->media) {
|
|
|
|
case IFM_ATM_UTP_25:
|
|
sc->cmn.cu_config.ac_media = MEDIA_UTP25;;
|
|
break;
|
|
|
|
case IFM_ATM_TAXI_100:
|
|
sc->cmn.cu_config.ac_media = MEDIA_TAXI_100;
|
|
break;
|
|
|
|
case IFM_ATM_TAXI_140:
|
|
sc->cmn.cu_config.ac_media = MEDIA_TAXI_140;
|
|
break;
|
|
|
|
case IFM_ATM_MM_155:
|
|
case IFM_ATM_SM_155:
|
|
sc->cmn.cu_config.ac_media = MEDIA_OC3C;
|
|
break;
|
|
|
|
case IFM_ATM_MM_622:
|
|
case IFM_ATM_SM_622:
|
|
sc->cmn.cu_config.ac_media = MEDIA_OC12C;
|
|
break;
|
|
|
|
case IFM_ATM_UTP_155:
|
|
sc->cmn.cu_config.ac_media = MEDIA_UTP155;
|
|
break;
|
|
|
|
default:
|
|
sc->cmn.cu_config.ac_media = MEDIA_UNKNOWN;
|
|
break;
|
|
}
|
|
sc->cmn.cu_config.ac_bustype = BUS_PCI;
|
|
sc->cmn.cu_pif.pif_pcr = mib->pcr;
|
|
sc->cmn.cu_pif.pif_maxvpi = (1 << mib->vpi_bits) - 1;
|
|
sc->cmn.cu_pif.pif_maxvci = (1 << mib->vci_bits) - 1;
|
|
|
|
snprintf(sc->cmn.cu_config.ac_hard_vers,
|
|
sizeof(sc->cmn.cu_config.ac_hard_vers), "0x%lx",
|
|
(u_long)mib->hw_version);
|
|
snprintf(sc->cmn.cu_config.ac_firm_vers,
|
|
sizeof(sc->cmn.cu_config.ac_firm_vers), "0x%lx",
|
|
(u_long)mib->sw_version);
|
|
sc->cmn.cu_config.ac_serial = mib->serial;
|
|
sc->cmn.cu_config.ac_ram = 0;
|
|
sc->cmn.cu_config.ac_ramsize = 0;
|
|
|
|
sc->cmn.cu_config.ac_macaddr.ma_data[0] =
|
|
sc->cmn.cu_pif.pif_macaddr.ma_data[0] = mib->esi[0];
|
|
sc->cmn.cu_config.ac_macaddr.ma_data[1] =
|
|
sc->cmn.cu_pif.pif_macaddr.ma_data[1] = mib->esi[1];
|
|
sc->cmn.cu_config.ac_macaddr.ma_data[2] =
|
|
sc->cmn.cu_pif.pif_macaddr.ma_data[2] = mib->esi[2];
|
|
sc->cmn.cu_config.ac_macaddr.ma_data[3] =
|
|
sc->cmn.cu_pif.pif_macaddr.ma_data[3] = mib->esi[3];
|
|
sc->cmn.cu_config.ac_macaddr.ma_data[4] =
|
|
sc->cmn.cu_pif.pif_macaddr.ma_data[4] = mib->esi[4];
|
|
sc->cmn.cu_config.ac_macaddr.ma_data[5] =
|
|
sc->cmn.cu_pif.pif_macaddr.ma_data[5] = mib->esi[5];
|
|
|
|
error = atm_physif_register(&sc->cmn, parent->if_dname, harp_services);
|
|
if (error) {
|
|
log(LOG_ERR, "%s: pif registration failed %d\n",
|
|
parent->if_dname, error);
|
|
free(sc, M_HARP);
|
|
return;
|
|
}
|
|
LIST_INSERT_HEAD(&harp_softc_list, sc, link);
|
|
|
|
sc->cmn.cu_flags |= CUF_INITED;
|
|
}
|
|
|
|
/*
|
|
* Destroy a cloned device
|
|
*/
|
|
static void
|
|
harp_detach(struct ifnet *ifp)
|
|
{
|
|
struct harp_softc *sc;
|
|
int error;
|
|
|
|
LIST_FOREACH(sc, &harp_softc_list, link)
|
|
if (sc->parent == ifp)
|
|
break;
|
|
if (sc == NULL)
|
|
return;
|
|
|
|
error = atm_physif_deregister(&sc->cmn);
|
|
if (error)
|
|
log(LOG_ERR, "%s: de-registration failed %d\n", ifp->if_dname,
|
|
error);
|
|
|
|
LIST_REMOVE(sc, link);
|
|
|
|
free(sc, M_HARP);
|
|
}
|
|
|
|
/*
|
|
* Pass PDU up the stack
|
|
*/
|
|
static void
|
|
harp_recv_stack(void *tok, KBuffer *m)
|
|
{
|
|
Cmn_vcc *vcc = tok;
|
|
int err;
|
|
|
|
M_ASSERTPKTHDR(m);
|
|
STACK_CALL(CPCS_UNITDATA_SIG, vcc->cv_upper, vcc->cv_toku,
|
|
vcc->cv_connvc, (intptr_t)m, 0, err);
|
|
if (err) {
|
|
printf("%s: error %d\n", __func__, err);
|
|
KB_FREEALL(m);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Possible input from NATM
|
|
*/
|
|
static void
|
|
harp_input(struct ifnet *ifp, struct mbuf **mp, struct atm_pseudohdr *ah,
|
|
void *rxhand)
|
|
{
|
|
struct harp_softc *sc = rxhand;
|
|
Cmn_vcc *vcc;
|
|
char *cp;
|
|
u_int pfxlen;
|
|
struct mbuf *m, *m0;
|
|
int mlen;
|
|
|
|
if ((ATM_PH_FLAGS(ah) & ATMIO_FLAG_HARP) == 0)
|
|
return;
|
|
|
|
/* grab the packet */
|
|
m = *mp;
|
|
*mp = NULL;
|
|
|
|
if (sc->parent != ifp) {
|
|
printf("%s: parent=%p ifp=%p\n", __func__, sc->parent, ifp);
|
|
goto drop;
|
|
}
|
|
|
|
vcc = atm_dev_vcc_find(&sc->cmn, ATM_PH_VPI(ah),
|
|
ATM_PH_VCI(ah), VCC_IN);
|
|
if (vcc == NULL) {
|
|
printf("%s: VCC %u/%u not found\n", __func__,ATM_PH_VPI(ah),
|
|
ATM_PH_VCI(ah));
|
|
goto drop;
|
|
}
|
|
|
|
/* fit two pointers into the mbuf - assume, that the the data is
|
|
* pointer aligned. If it doesn't fit into the first mbuf, prepend
|
|
* another one.
|
|
* Don't count the new fields in the packet length (XXX)
|
|
*/
|
|
mlen = m->m_pkthdr.len;
|
|
pfxlen = sizeof(atm_intr_func_t) + sizeof(void *);
|
|
if (M_LEADINGSPACE(m) < pfxlen) {
|
|
MGETHDR(m0, 0, MT_DATA);
|
|
if (m0 == NULL) {
|
|
printf("%s: no leading space in buffer\n", __func__);
|
|
goto drop;
|
|
}
|
|
m0->m_len = 0;
|
|
m0->m_next = m;
|
|
|
|
M_MOVE_PKTHDR(m0, m);
|
|
|
|
m = m0;
|
|
}
|
|
m->m_len += pfxlen;
|
|
m->m_data -= pfxlen;
|
|
cp = mtod(m, char *);
|
|
*((atm_intr_func_t *)cp) = harp_recv_stack;
|
|
cp += sizeof(atm_intr_func_t);
|
|
*((void **)cp) = (void *)vcc;
|
|
|
|
/* count the packet */
|
|
sc->cmn.cu_pif.pif_ipdus++;
|
|
sc->cmn.cu_pif.pif_ibytes += mlen;
|
|
vcc->cv_connvc->cvc_vcc->vc_ipdus++;
|
|
vcc->cv_connvc->cvc_vcc->vc_ibytes += mlen;
|
|
if (vcc->cv_connvc->cvc_vcc->vc_nif) {
|
|
vcc->cv_connvc->cvc_vcc->vc_nif->nif_ibytes += mlen;
|
|
vcc->cv_connvc->cvc_vcc->vc_nif->nif_if.if_ipackets++;
|
|
vcc->cv_connvc->cvc_vcc->vc_nif->nif_if.if_ibytes += mlen;
|
|
}
|
|
|
|
/* hand it off */
|
|
netisr_dispatch(NETISR_ATM, m);
|
|
return;
|
|
|
|
drop:
|
|
m_freem(m);
|
|
}
|
|
|
|
/*
|
|
* Module loading/unloading
|
|
*/
|
|
static int
|
|
harp_modevent(module_t mod, int event, void *data)
|
|
{
|
|
struct ifnet *ifp;
|
|
|
|
switch (event) {
|
|
|
|
case MOD_LOAD:
|
|
harp_nif_zone = uma_zcreate("harp nif", sizeof(struct atm_nif),
|
|
NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
|
|
if (harp_nif_zone == NULL)
|
|
panic("%s: nif_zone", __func__);
|
|
|
|
harp_vcc_zone = uma_zcreate("harp vcc", sizeof(struct harp_vcc),
|
|
NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
|
|
if (harp_vcc_zone == NULL)
|
|
panic("%s: vcc_zone", __func__);
|
|
|
|
/* Create harp interfaces for all existing ATM interfaces */
|
|
TAILQ_FOREACH(ifp, &ifnet, if_link)
|
|
harp_attach(ifp);
|
|
|
|
atm_harp_attach_p = harp_attach;
|
|
atm_harp_detach_p = harp_detach;
|
|
atm_harp_input_p = harp_input;
|
|
break;
|
|
|
|
case MOD_UNLOAD:
|
|
atm_harp_attach_p = NULL;
|
|
atm_harp_detach_p = NULL;
|
|
atm_harp_input_p = NULL;
|
|
|
|
while (!LIST_EMPTY(&harp_softc_list))
|
|
harp_detach(LIST_FIRST(&harp_softc_list)->parent);
|
|
|
|
uma_zdestroy(harp_nif_zone);
|
|
uma_zdestroy(harp_vcc_zone);
|
|
|
|
break;
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static moduledata_t harp_mod = {
|
|
"if_harp",
|
|
harp_modevent,
|
|
0
|
|
};
|
|
|
|
DECLARE_MODULE(harp, harp_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
|