/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" /* * gld - Generic LAN Driver Version 2, PSARC/1997/382 * * This is a utility module that provides generic facilities for * LAN drivers. The DLPI protocol and most STREAMS interfaces * are handled here. * * It no longer provides compatibility with drivers * implemented according to the GLD v0 documentation published * in 1993. (See PSARC 2003/728) */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * Macro to atomically increment counters of type uint32_t, uint64_t * and ulong_t. */ #define BUMP(stat, delta) do { \ _NOTE(CONSTANTCONDITION) \ if (sizeof (stat) == sizeof (uint32_t)) { \ atomic_add_32((uint32_t *)&stat, delta); \ _NOTE(CONSTANTCONDITION) \ } else if (sizeof (stat) == sizeof (uint64_t)) { \ atomic_add_64((uint64_t *)&stat, delta); \ } \ _NOTE(CONSTANTCONDITION) \ } while (0) #define UPDATE_STATS(vlan, pktinfo, number) { \ if ((pktinfo).isBroadcast) \ (vlan)->gldv_stats->glds_brdcstxmt += (number); \ else if ((pktinfo).isMulticast) \ (vlan)->gldv_stats->glds_multixmt += (number); \ (vlan)->gldv_stats->glds_bytexmt64 += (pktinfo).pktLen; \ (vlan)->gldv_stats->glds_pktxmt64 += (number); \ } #ifdef GLD_DEBUG int gld_debug = GLDERRS; #endif /* called from gld_register */ static int gld_initstats(gld_mac_info_t *); /* called from kstat mechanism, and from wsrv's get_statistics */ static int gld_update_kstat(kstat_t *, int); /* statistics for additional vlans */ static int gld_init_vlan_stats(gld_vlan_t *); static int gld_update_vlan_kstat(kstat_t *, int); /* called from gld_getinfo */ static dev_info_t *gld_finddevinfo(dev_t); /* called from wput, wsrv, unidata, and v0_sched to send a packet */ /* also from the source routing stuff for sending RDE protocol packets */ static int gld_start(queue_t *, mblk_t *, int, uint32_t); static int gld_start_mdt(queue_t *, mblk_t *, int); /* called from gld_start[_mdt] to loopback packet(s) in promiscuous mode */ static void gld_precv(gld_mac_info_t *, gld_vlan_t *, mblk_t *); static void gld_precv_mdt(gld_mac_info_t *, gld_vlan_t *, mblk_t *, pdesc_t *, pktinfo_t *); /* receive group: called from gld_recv and gld_precv* with maclock held */ static void gld_sendup(gld_mac_info_t *, gld_vlan_t *, pktinfo_t *, mblk_t *, int (*)()); static int gld_accept(gld_t *, pktinfo_t *); static int gld_mcmatch(gld_t *, pktinfo_t *); static int gld_multicast(unsigned char *, gld_t *); static int gld_paccept(gld_t *, pktinfo_t *); static void gld_passon(gld_t *, mblk_t *, pktinfo_t *, void (*)(queue_t *, mblk_t *)); static mblk_t *gld_addudind(gld_t *, mblk_t *, pktinfo_t *); /* wsrv group: called from wsrv, single threaded per queue */ static int gld_ioctl(queue_t *, mblk_t *); static void gld_fastpath(gld_t *, queue_t *, mblk_t *); static int gld_cmds(queue_t *, mblk_t *); static mblk_t *gld_bindack(queue_t *, mblk_t *); static int gld_notify_req(queue_t *, mblk_t *); static int gld_udqos(queue_t *, mblk_t *); static int gld_bind(queue_t *, mblk_t *); static int gld_unbind(queue_t *, mblk_t *); static int gld_inforeq(queue_t *, mblk_t *); static int gld_unitdata(queue_t *, mblk_t *); static int gldattach(queue_t *, mblk_t *); static int gldunattach(queue_t *, mblk_t *); static int gld_enable_multi(queue_t *, mblk_t *); static int gld_disable_multi(queue_t *, mblk_t *); static void gld_send_disable_multi(gld_mac_info_t *, gld_mcast_t *); static int gld_promisc(queue_t *, mblk_t *, t_uscalar_t, boolean_t); static int gld_physaddr(queue_t *, mblk_t *); static int gld_setaddr(queue_t *, mblk_t *); static int gld_get_statistics(queue_t *, mblk_t *); static int gld_cap(queue_t *, mblk_t *); static int gld_cap_ack(queue_t *, mblk_t *); static int gld_cap_enable(queue_t *, mblk_t *); /* misc utilities, some requiring various mutexes held */ static int gld_start_mac(gld_mac_info_t *); static void gld_stop_mac(gld_mac_info_t *); static void gld_set_ipq(gld_t *); static void gld_flushqueue(queue_t *); static glddev_t *gld_devlookup(int); static int gld_findminor(glddev_t *); static void gldinsque(void *, void *); static void gldremque(void *); void gld_bitrevcopy(caddr_t, caddr_t, size_t); void gld_bitreverse(uchar_t *, size_t); char *gld_macaddr_sprintf(char *, unsigned char *, int); static gld_vlan_t *gld_add_vlan(gld_mac_info_t *, uint32_t vid); static void gld_rem_vlan(gld_vlan_t *); gld_vlan_t *gld_find_vlan(gld_mac_info_t *, uint32_t); gld_vlan_t *gld_get_vlan(gld_mac_info_t *, uint32_t); #ifdef GLD_DEBUG static void gld_check_assertions(void); extern void gld_sr_dump(gld_mac_info_t *); #endif /* * Allocate and zero-out "number" structures each of type "structure" in * kernel memory. */ #define GETSTRUCT(structure, number) \ (kmem_zalloc((uint_t)(sizeof (structure) * (number)), KM_NOSLEEP)) #define abs(a) ((a) < 0 ? -(a) : a) uint32_t gld_global_options = GLD_OPT_NO_ETHRXSNAP; /* * VLANs are only supported on ethernet devices that manipulate VLAN headers * themselves. */ #define VLAN_CAPABLE(macinfo) \ ((macinfo)->gldm_type == DL_ETHER && \ (macinfo)->gldm_send_tagged != NULL) /* * The set of notifications generatable by GLD itself, the additional * set that can be generated if the MAC driver provide the link-state * tracking callback capability, and the set supported by the GLD * notification code below. * * PLEASE keep these in sync with what the code actually does! */ static const uint32_t gld_internal_notes = DL_NOTE_PROMISC_ON_PHYS | DL_NOTE_PROMISC_OFF_PHYS | DL_NOTE_PHYS_ADDR; static const uint32_t gld_linkstate_notes = DL_NOTE_LINK_DOWN | DL_NOTE_LINK_UP | DL_NOTE_SPEED; static const uint32_t gld_supported_notes = DL_NOTE_PROMISC_ON_PHYS | DL_NOTE_PROMISC_OFF_PHYS | DL_NOTE_PHYS_ADDR | DL_NOTE_LINK_DOWN | DL_NOTE_LINK_UP | DL_NOTE_SPEED; /* Media must correspond to #defines in gld.h */ static char *gld_media[] = { "unknown", /* GLDM_UNKNOWN - driver cannot determine media */ "aui", /* GLDM_AUI */ "bnc", /* GLDM_BNC */ "twpair", /* GLDM_TP */ "fiber", /* GLDM_FIBER */ "100baseT", /* GLDM_100BT */ "100vgAnyLan", /* GLDM_VGANYLAN */ "10baseT", /* GLDM_10BT */ "ring4", /* GLDM_RING4 */ "ring16", /* GLDM_RING16 */ "PHY/MII", /* GLDM_PHYMII */ "100baseTX", /* GLDM_100BTX */ "100baseT4", /* GLDM_100BT4 */ "unknown", /* skip */ "ipib", /* GLDM_IB */ }; /* Must correspond to #defines in gld.h */ static char *gld_duplex[] = { "unknown", /* GLD_DUPLEX_UNKNOWN - not known or not applicable */ "half", /* GLD_DUPLEX_HALF */ "full" /* GLD_DUPLEX_FULL */ }; extern int gld_interpret_ether(gld_mac_info_t *, mblk_t *, pktinfo_t *, int); extern int gld_interpret_fddi(gld_mac_info_t *, mblk_t *, pktinfo_t *, int); extern int gld_interpret_tr(gld_mac_info_t *, mblk_t *, pktinfo_t *, int); extern int gld_interpret_ib(gld_mac_info_t *, mblk_t *, pktinfo_t *, int); extern void gld_interpret_mdt_ib(gld_mac_info_t *, mblk_t *, pdescinfo_t *, pktinfo_t *, int); extern mblk_t *gld_fastpath_ether(gld_t *, mblk_t *); extern mblk_t *gld_fastpath_fddi(gld_t *, mblk_t *); extern mblk_t *gld_fastpath_tr(gld_t *, mblk_t *); extern mblk_t *gld_fastpath_ib(gld_t *, mblk_t *); extern mblk_t *gld_unitdata_ether(gld_t *, mblk_t *); extern mblk_t *gld_unitdata_fddi(gld_t *, mblk_t *); extern mblk_t *gld_unitdata_tr(gld_t *, mblk_t *); extern mblk_t *gld_unitdata_ib(gld_t *, mblk_t *); extern void gld_init_ether(gld_mac_info_t *); extern void gld_init_fddi(gld_mac_info_t *); extern void gld_init_tr(gld_mac_info_t *); extern void gld_init_ib(gld_mac_info_t *); extern void gld_uninit_ether(gld_mac_info_t *); extern void gld_uninit_fddi(gld_mac_info_t *); extern void gld_uninit_tr(gld_mac_info_t *); extern void gld_uninit_ib(gld_mac_info_t *); /* * Interface types currently supported by GLD. * If you add new types, you must check all "XXX" strings in the GLD source * for implementation issues that may affect the support of your new type. * In particular, any type with gldm_addrlen > 6, or gldm_saplen != -2, will * require generalizing this GLD source to handle the new cases. In other * words there are assumptions built into the code in a few places that must * be fixed. Be sure to turn on DEBUG/ASSERT code when testing a new type. */ static gld_interface_t interfaces[] = { /* Ethernet Bus */ { DL_ETHER, (uint_t)-1, sizeof (struct ether_mac_frm), gld_interpret_ether, NULL, gld_fastpath_ether, gld_unitdata_ether, gld_init_ether, gld_uninit_ether, "ether" }, /* Fiber Distributed data interface */ { DL_FDDI, 4352, sizeof (struct fddi_mac_frm), gld_interpret_fddi, NULL, gld_fastpath_fddi, gld_unitdata_fddi, gld_init_fddi, gld_uninit_fddi, "fddi" }, /* Token Ring interface */ { DL_TPR, 17914, -1, /* variable header size */ gld_interpret_tr, NULL, gld_fastpath_tr, gld_unitdata_tr, gld_init_tr, gld_uninit_tr, "tpr" }, /* Infiniband */ { DL_IB, 4092, sizeof (struct ipoib_header), gld_interpret_ib, gld_interpret_mdt_ib, gld_fastpath_ib, gld_unitdata_ib, gld_init_ib, gld_uninit_ib, "ipib" }, }; /* * bit reversal lookup table. */ static uchar_t bit_rev[] = { 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, }; /* * User priorities, mapped from b_band. */ static uint32_t user_priority[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 }; #define UPRI(gld, band) ((band != 0) ? user_priority[(band)] : (gld)->gld_upri) static struct glddevice gld_device_list; /* Per-system root of GLD tables */ /* * Module linkage information for the kernel. */ static struct modldrv modlmisc = { &mod_miscops, /* Type of module - a utility provider */ "Generic LAN Driver (" GLD_VERSION_STRING ") %I%" #ifdef GLD_DEBUG " DEBUG" #endif }; static struct modlinkage modlinkage = { MODREV_1, &modlmisc, NULL }; int _init(void) { int e; /* initialize gld_device_list mutex */ mutex_init(&gld_device_list.gld_devlock, NULL, MUTEX_DRIVER, NULL); /* initialize device driver (per-major) list */ gld_device_list.gld_next = gld_device_list.gld_prev = &gld_device_list; if ((e = mod_install(&modlinkage)) != 0) mutex_destroy(&gld_device_list.gld_devlock); return (e); } int _fini(void) { int e; if ((e = mod_remove(&modlinkage)) != 0) return (e); ASSERT(gld_device_list.gld_next == (glddev_t *)&gld_device_list.gld_next); ASSERT(gld_device_list.gld_prev == (glddev_t *)&gld_device_list.gld_next); mutex_destroy(&gld_device_list.gld_devlock); return (e); } int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } /* * GLD service routines */ /* So this gld binary maybe can be forward compatible with future v2 drivers */ #define GLD_MAC_RESERVED (16 * sizeof (caddr_t)) /*ARGSUSED*/ gld_mac_info_t * gld_mac_alloc(dev_info_t *devinfo) { gld_mac_info_t *macinfo; macinfo = kmem_zalloc(sizeof (gld_mac_info_t) + GLD_MAC_RESERVED, KM_SLEEP); /* * The setting of gldm_driver_version will not be documented or allowed * until a future release. */ macinfo->gldm_driver_version = GLD_VERSION_200; /* * GLD's version. This also is undocumented for now, but will be * available if needed in the future. */ macinfo->gldm_GLD_version = GLD_VERSION; return (macinfo); } /* * gld_mac_free must be called after the driver has removed interrupts * and completely stopped calling gld_recv() and gld_sched(). At that * point the interrupt routine is guaranteed by the system to have been * exited and the maclock is no longer needed. Of course, it is * expected (required) that (assuming gld_register() succeeded), * gld_unregister() was called before gld_mac_free(). */ void gld_mac_free(gld_mac_info_t *macinfo) { ASSERT(macinfo); ASSERT(macinfo->gldm_GLD_version == GLD_VERSION); /* * Assert that if we made it through gld_register, then we must * have unregistered. */ ASSERT(!GLDM_LOCK_INITED(macinfo) || (macinfo->gldm_GLD_flags & GLD_UNREGISTERED)); GLDM_LOCK_DESTROY(macinfo); kmem_free(macinfo, sizeof (gld_mac_info_t) + GLD_MAC_RESERVED); } /* * gld_register -- called once per device instance (PPA) * * During its attach routine, a real device driver will register with GLD * so that later opens and dl_attach_reqs will work. The arguments are the * devinfo pointer, the device name, and a macinfo structure describing the * physical device instance. */ int gld_register(dev_info_t *devinfo, char *devname, gld_mac_info_t *macinfo) { int mediatype; int major = ddi_name_to_major(devname), i; glddev_t *glddev; gld_mac_pvt_t *mac_pvt; char minordev[32]; char pbuf[3*GLD_MAX_ADDRLEN]; gld_interface_t *ifp; ASSERT(devinfo != NULL); ASSERT(macinfo != NULL); if (macinfo->gldm_driver_version != GLD_VERSION) return (DDI_FAILURE); mediatype = macinfo->gldm_type; /* * Entry points should be ready for us. * ioctl is optional. * set_multicast and get_stats are optional in v0. * intr is only required if you add an interrupt. */ ASSERT(macinfo->gldm_reset != NULL); ASSERT(macinfo->gldm_start != NULL); ASSERT(macinfo->gldm_stop != NULL); ASSERT(macinfo->gldm_set_mac_addr != NULL); ASSERT(macinfo->gldm_set_promiscuous != NULL); ASSERT(macinfo->gldm_send != NULL); ASSERT(macinfo->gldm_maxpkt >= macinfo->gldm_minpkt); ASSERT(macinfo->gldm_GLD_version == GLD_VERSION); ASSERT(macinfo->gldm_broadcast_addr != NULL); ASSERT(macinfo->gldm_vendor_addr != NULL); ASSERT(macinfo->gldm_ident != NULL); if (macinfo->gldm_addrlen > GLD_MAX_ADDRLEN) { cmn_err(CE_WARN, "GLD: %s driver gldm_addrlen %d > %d not sup" "ported", devname, macinfo->gldm_addrlen, GLD_MAX_ADDRLEN); return (DDI_FAILURE); } /* * GLD only functions properly with saplen == -2 */ if (macinfo->gldm_saplen != -2) { cmn_err(CE_WARN, "GLD: %s driver gldm_saplen %d != -2 " "not supported", devname, macinfo->gldm_saplen); return (DDI_FAILURE); } /* see gld_rsrv() */ if (ddi_getprop(DDI_DEV_T_NONE, devinfo, 0, "fast_recv", 0)) macinfo->gldm_options |= GLDOPT_FAST_RECV; mutex_enter(&gld_device_list.gld_devlock); glddev = gld_devlookup(major); /* * Allocate per-driver (major) data structure if necessary */ if (glddev == NULL) { /* first occurrence of this device name (major number) */ glddev = GETSTRUCT(glddev_t, 1); if (glddev == NULL) { mutex_exit(&gld_device_list.gld_devlock); return (DDI_FAILURE); } (void) strncpy(glddev->gld_name, devname, sizeof (glddev->gld_name) - 1); glddev->gld_major = major; glddev->gld_nextminor = GLD_MIN_CLONE_MINOR; glddev->gld_mac_next = glddev->gld_mac_prev = (gld_mac_info_t *)&glddev->gld_mac_next; glddev->gld_str_next = glddev->gld_str_prev = (gld_t *)&glddev->gld_str_next; mutex_init(&glddev->gld_devlock, NULL, MUTEX_DRIVER, NULL); /* allow increase of number of supported multicast addrs */ glddev->gld_multisize = ddi_getprop(DDI_DEV_T_NONE, devinfo, 0, "multisize", GLD_MAX_MULTICAST); /* * Optionally restrict DLPI provider style * * -1 - don't create style 1 nodes * -2 - don't create style 2 nodes */ glddev->gld_styles = ddi_getprop(DDI_DEV_T_NONE, devinfo, 0, "gld-provider-styles", 0); /* Stuff that's needed before any PPA gets attached */ glddev->gld_type = macinfo->gldm_type; glddev->gld_minsdu = macinfo->gldm_minpkt; glddev->gld_saplen = macinfo->gldm_saplen; glddev->gld_addrlen = macinfo->gldm_addrlen; glddev->gld_broadcast = kmem_zalloc(macinfo->gldm_addrlen, KM_SLEEP); bcopy(macinfo->gldm_broadcast_addr, glddev->gld_broadcast, macinfo->gldm_addrlen); glddev->gld_maxsdu = macinfo->gldm_maxpkt; gldinsque(glddev, gld_device_list.gld_prev); } glddev->gld_ndevice++; /* Now glddev can't go away until we unregister this mac (or fail) */ mutex_exit(&gld_device_list.gld_devlock); /* * Per-instance initialization */ /* * Initialize per-mac structure that is private to GLD. * Set up interface pointer. These are device class specific pointers * used to handle FDDI/TR/ETHER/IPoIB specific packets. */ for (i = 0; i < sizeof (interfaces)/sizeof (*interfaces); i++) { if (mediatype != interfaces[i].mac_type) continue; macinfo->gldm_mac_pvt = kmem_zalloc(sizeof (gld_mac_pvt_t), KM_SLEEP); ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep = ifp = &interfaces[i]; break; } if (ifp == NULL) { cmn_err(CE_WARN, "GLD: this version does not support %s driver " "of type %d", devname, mediatype); goto failure; } /* * Driver can only register MTU within legal media range. */ if (macinfo->gldm_maxpkt > ifp->mtu_size) { cmn_err(CE_WARN, "GLD: oversize MTU is specified by driver %s", devname); goto failure; } /* * For now, only Infiniband drivers can use MDT. Do not add * support for Ethernet, FDDI or TR. */ if (macinfo->gldm_mdt_pre != NULL) { if (mediatype != DL_IB) { cmn_err(CE_WARN, "GLD: MDT not supported for %s " "driver of type %d", devname, mediatype); goto failure; } /* * Validate entry points. */ if ((macinfo->gldm_mdt_send == NULL) || (macinfo->gldm_mdt_post == NULL)) { cmn_err(CE_WARN, "GLD: invalid MDT entry points for " "%s driver of type %d", devname, mediatype); goto failure; } macinfo->gldm_options |= GLDOPT_MDT; } mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; mac_pvt->major_dev = glddev; mac_pvt->curr_macaddr = kmem_zalloc(macinfo->gldm_addrlen, KM_SLEEP); /* * XXX Do bit-reversed devices store gldm_vendor in canonical * format or in wire format? Also gldm_broadcast. For now * we are assuming canonical, but I'm not sure that makes the * most sense for ease of driver implementation. */ bcopy(macinfo->gldm_vendor_addr, mac_pvt->curr_macaddr, macinfo->gldm_addrlen); mac_pvt->statistics = kmem_zalloc(sizeof (struct gld_stats), KM_SLEEP); /* * The available set of notifications is those generatable by GLD * itself, plus those corresponding to the capabilities of the MAC * driver, intersected with those supported by gld_notify_ind() above. */ mac_pvt->notifications = gld_internal_notes; if (macinfo->gldm_capabilities & GLD_CAP_LINKSTATE) mac_pvt->notifications |= gld_linkstate_notes; mac_pvt->notifications &= gld_supported_notes; GLDM_LOCK_INIT(macinfo); ddi_set_driver_private(devinfo, macinfo); /* * Now atomically get a PPA and put ourselves on the mac list. */ mutex_enter(&glddev->gld_devlock); #ifdef DEBUG if (macinfo->gldm_ppa != ddi_get_instance(devinfo)) cmn_err(CE_WARN, "%s%d instance != ppa %d", ddi_driver_name(devinfo), ddi_get_instance(devinfo), macinfo->gldm_ppa); #endif /* * Create style 2 node (gated by gld-provider-styles property). * * NOTE: When the CLONE_DEV flag is specified to * ddi_create_minor_node() the minor number argument is * immaterial. Opens of that node will go via the clone * driver and gld_open() will always be passed a dev_t with * minor of zero. */ if (glddev->gld_styles != -2) { if (ddi_create_minor_node(devinfo, glddev->gld_name, S_IFCHR, 0, DDI_NT_NET, CLONE_DEV) == DDI_FAILURE) { mutex_exit(&glddev->gld_devlock); goto late_failure; } } /* * Create style 1 node (gated by gld-provider-styles property) */ if (glddev->gld_styles != -1) { (void) sprintf(minordev, "%s%d", glddev->gld_name, macinfo->gldm_ppa); if (ddi_create_minor_node(devinfo, minordev, S_IFCHR, GLD_STYLE1_PPA_TO_MINOR(macinfo->gldm_ppa), DDI_NT_NET, 0) != DDI_SUCCESS) { mutex_exit(&glddev->gld_devlock); goto late_failure; } } /* add ourselves to this major device's linked list of instances */ gldinsque(macinfo, glddev->gld_mac_prev); mutex_exit(&glddev->gld_devlock); /* * Unfortunately we need the ppa before we call gld_initstats(); * otherwise we would like to do this just above the mutex_enter * above. In which case we could have set MAC_READY inside the * mutex and we wouldn't have needed to check it in open and * DL_ATTACH. We wouldn't like to do the initstats/kstat_create * inside the mutex because it might get taken in our kstat_update * routine and cause a deadlock with kstat_chain_lock. */ /* gld_initstats() calls (*ifp->init)() */ if (gld_initstats(macinfo) != GLD_SUCCESS) { mutex_enter(&glddev->gld_devlock); gldremque(macinfo); mutex_exit(&glddev->gld_devlock); goto late_failure; } /* * Need to indicate we are NOW ready to process interrupts; * any interrupt before this is set is for someone else. * This flag is also now used to tell open, et. al. that this * mac is now fully ready and available for use. */ GLDM_LOCK(macinfo, RW_WRITER); macinfo->gldm_GLD_flags |= GLD_MAC_READY; GLDM_UNLOCK(macinfo); /* log local ethernet address -- XXX not DDI compliant */ if (macinfo->gldm_addrlen == sizeof (struct ether_addr)) (void) localetheraddr( (struct ether_addr *)macinfo->gldm_vendor_addr, NULL); /* now put announcement into the message buffer */ cmn_err(CE_CONT, "!%s%d: %s: type \"%s\" mac address %s\n", glddev->gld_name, macinfo->gldm_ppa, macinfo->gldm_ident, mac_pvt->interfacep->mac_string, gld_macaddr_sprintf(pbuf, macinfo->gldm_vendor_addr, macinfo->gldm_addrlen)); ddi_report_dev(devinfo); return (DDI_SUCCESS); late_failure: ddi_remove_minor_node(devinfo, NULL); GLDM_LOCK_DESTROY(macinfo); if (mac_pvt->curr_macaddr != NULL) kmem_free(mac_pvt->curr_macaddr, macinfo->gldm_addrlen); if (mac_pvt->statistics != NULL) kmem_free(mac_pvt->statistics, sizeof (struct gld_stats)); kmem_free(macinfo->gldm_mac_pvt, sizeof (gld_mac_pvt_t)); macinfo->gldm_mac_pvt = NULL; failure: mutex_enter(&gld_device_list.gld_devlock); glddev->gld_ndevice--; /* * Note that just because this goes to zero here does not necessarily * mean that we were the one who added the glddev above. It's * possible that the first mac unattached while were were in here * failing to attach the second mac. But we're now the last. */ if (glddev->gld_ndevice == 0) { /* There should be no macinfos left */ ASSERT(glddev->gld_mac_next == (gld_mac_info_t *)&glddev->gld_mac_next); ASSERT(glddev->gld_mac_prev == (gld_mac_info_t *)&glddev->gld_mac_next); /* * There should be no DL_UNATTACHED streams: the system * should not have detached the "first" devinfo which has * all the open style 2 streams. * * XXX This is not clear. See gld_getinfo and Bug 1165519 */ ASSERT(glddev->gld_str_next == (gld_t *)&glddev->gld_str_next); ASSERT(glddev->gld_str_prev == (gld_t *)&glddev->gld_str_next); gldremque(glddev); mutex_destroy(&glddev->gld_devlock); if (glddev->gld_broadcast != NULL) kmem_free(glddev->gld_broadcast, glddev->gld_addrlen); kmem_free(glddev, sizeof (glddev_t)); } mutex_exit(&gld_device_list.gld_devlock); return (DDI_FAILURE); } /* * gld_unregister (macinfo) * remove the macinfo structure from local structures * this is cleanup for a driver to be unloaded */ int gld_unregister(gld_mac_info_t *macinfo) { gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; glddev_t *glddev = mac_pvt->major_dev; gld_interface_t *ifp; int multisize = sizeof (gld_mcast_t) * glddev->gld_multisize; mutex_enter(&glddev->gld_devlock); GLDM_LOCK(macinfo, RW_WRITER); if (mac_pvt->nvlan > 0) { GLDM_UNLOCK(macinfo); mutex_exit(&glddev->gld_devlock); return (DDI_FAILURE); } #ifdef GLD_DEBUG { int i; for (i = 0; i < VLAN_HASHSZ; i++) { if ((mac_pvt->vlan_hash[i] != NULL)) cmn_err(CE_PANIC, "%s, line %d: " "mac_pvt->vlan_hash[%d] != NULL", __FILE__, __LINE__, i); } } #endif /* Delete this mac */ gldremque(macinfo); /* Disallow further entries to gld_recv() and gld_sched() */ macinfo->gldm_GLD_flags |= GLD_UNREGISTERED; GLDM_UNLOCK(macinfo); mutex_exit(&glddev->gld_devlock); ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep; (*ifp->uninit)(macinfo); ASSERT(mac_pvt->kstatp); kstat_delete(mac_pvt->kstatp); ASSERT(GLDM_LOCK_INITED(macinfo)); kmem_free(mac_pvt->curr_macaddr, macinfo->gldm_addrlen); kmem_free(mac_pvt->statistics, sizeof (struct gld_stats)); if (mac_pvt->mcast_table != NULL) kmem_free(mac_pvt->mcast_table, multisize); kmem_free(macinfo->gldm_mac_pvt, sizeof (gld_mac_pvt_t)); macinfo->gldm_mac_pvt = (caddr_t)NULL; /* We now have one fewer instance for this major device */ mutex_enter(&gld_device_list.gld_devlock); glddev->gld_ndevice--; if (glddev->gld_ndevice == 0) { /* There should be no macinfos left */ ASSERT(glddev->gld_mac_next == (gld_mac_info_t *)&glddev->gld_mac_next); ASSERT(glddev->gld_mac_prev == (gld_mac_info_t *)&glddev->gld_mac_next); /* * There should be no DL_UNATTACHED streams: the system * should not have detached the "first" devinfo which has * all the open style 2 streams. * * XXX This is not clear. See gld_getinfo and Bug 1165519 */ ASSERT(glddev->gld_str_next == (gld_t *)&glddev->gld_str_next); ASSERT(glddev->gld_str_prev == (gld_t *)&glddev->gld_str_next); ddi_remove_minor_node(macinfo->gldm_devinfo, NULL); gldremque(glddev); mutex_destroy(&glddev->gld_devlock); if (glddev->gld_broadcast != NULL) kmem_free(glddev->gld_broadcast, glddev->gld_addrlen); kmem_free(glddev, sizeof (glddev_t)); } mutex_exit(&gld_device_list.gld_devlock); return (DDI_SUCCESS); } /* * gld_initstats * called from gld_register */ static int gld_initstats(gld_mac_info_t *macinfo) { gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; struct gldkstats *sp; glddev_t *glddev; kstat_t *ksp; gld_interface_t *ifp; glddev = mac_pvt->major_dev; if ((ksp = kstat_create(glddev->gld_name, macinfo->gldm_ppa, NULL, "net", KSTAT_TYPE_NAMED, sizeof (struct gldkstats) / sizeof (kstat_named_t), 0)) == NULL) { cmn_err(CE_WARN, "GLD: failed to create kstat structure for %s%d", glddev->gld_name, macinfo->gldm_ppa); return (GLD_FAILURE); } mac_pvt->kstatp = ksp; ksp->ks_update = gld_update_kstat; ksp->ks_private = (void *)macinfo; sp = ksp->ks_data; kstat_named_init(&sp->glds_pktrcv, "ipackets", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_pktxmt, "opackets", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_errrcv, "ierrors", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_errxmt, "oerrors", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_bytexmt, "obytes", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_bytercv, "rbytes", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_multixmt, "multixmt", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_multircv, "multircv", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_brdcstxmt, "brdcstxmt", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_brdcstrcv, "brdcstrcv", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_blocked, "blocked", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_noxmtbuf, "noxmtbuf", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_norcvbuf, "norcvbuf", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_xmtretry, "xmtretry", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_intr, "intr", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_pktrcv64, "ipackets64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_pktxmt64, "opackets64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_bytexmt64, "obytes64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_bytercv64, "rbytes64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_unknowns, "unknowns", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_speed, "ifspeed", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_media, "media", KSTAT_DATA_CHAR); kstat_named_init(&sp->glds_prom, "promisc", KSTAT_DATA_CHAR); kstat_named_init(&sp->glds_overflow, "oflo", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_underflow, "uflo", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_missed, "missed", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_xmtbadinterp, "xmt_badinterp", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_rcvbadinterp, "rcv_badinterp", KSTAT_DATA_UINT32); ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep; (*ifp->init)(macinfo); kstat_install(ksp); return (GLD_SUCCESS); } /* called from kstat mechanism, and from wsrv's get_statistics_req */ static int gld_update_kstat(kstat_t *ksp, int rw) { gld_mac_info_t *macinfo; gld_mac_pvt_t *mac_pvt; struct gldkstats *gsp; struct gld_stats *stats; if (rw == KSTAT_WRITE) return (EACCES); macinfo = (gld_mac_info_t *)ksp->ks_private; ASSERT(macinfo != NULL); GLDM_LOCK(macinfo, RW_WRITER); if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) { GLDM_UNLOCK(macinfo); return (EIO); /* this one's not ready yet */ } if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) { GLDM_UNLOCK(macinfo); return (EIO); /* this one's not ready any more */ } mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; gsp = mac_pvt->kstatp->ks_data; ASSERT(gsp); stats = mac_pvt->statistics; if (macinfo->gldm_get_stats) (void) (*macinfo->gldm_get_stats)(macinfo, stats); gsp->glds_pktxmt.value.ui32 = stats->glds_pktxmt64 & 0xffffffff; gsp->glds_bytexmt.value.ui32 = stats->glds_bytexmt64 & 0xffffffff; gsp->glds_multixmt.value.ul = stats->glds_multixmt; gsp->glds_brdcstxmt.value.ul = stats->glds_brdcstxmt; gsp->glds_noxmtbuf.value.ul = stats->glds_noxmtbuf; /* 0 for now */ gsp->glds_xmtretry.value.ul = stats->glds_xmtretry; gsp->glds_pktxmt64.value.ui64 = stats->glds_pktxmt64; gsp->glds_bytexmt64.value.ui64 = stats->glds_bytexmt64; gsp->glds_xmtbadinterp.value.ui32 = stats->glds_xmtbadinterp; gsp->glds_pktrcv.value.ui32 = stats->glds_pktrcv64 & 0xffffffff; gsp->glds_errxmt.value.ul = stats->glds_errxmt; gsp->glds_errrcv.value.ul = stats->glds_errrcv; gsp->glds_bytercv.value.ui32 = stats->glds_bytercv64 & 0xffffffff; gsp->glds_multircv.value.ul = stats->glds_multircv; gsp->glds_brdcstrcv.value.ul = stats->glds_brdcstrcv; gsp->glds_blocked.value.ul = stats->glds_blocked; gsp->glds_overflow.value.ul = stats->glds_overflow; gsp->glds_underflow.value.ul = stats->glds_underflow; gsp->glds_missed.value.ul = stats->glds_missed; gsp->glds_norcvbuf.value.ul = stats->glds_norcvbuf + stats->glds_gldnorcvbuf; gsp->glds_intr.value.ul = stats->glds_intr; gsp->glds_speed.value.ui64 = stats->glds_speed; gsp->glds_unknowns.value.ul = stats->glds_unknowns; gsp->glds_pktrcv64.value.ui64 = stats->glds_pktrcv64; gsp->glds_bytercv64.value.ui64 = stats->glds_bytercv64; gsp->glds_rcvbadinterp.value.ui32 = stats->glds_rcvbadinterp; if (mac_pvt->nprom) (void) strcpy(gsp->glds_prom.value.c, "phys"); else if (mac_pvt->nprom_multi) (void) strcpy(gsp->glds_prom.value.c, "multi"); else (void) strcpy(gsp->glds_prom.value.c, "off"); (void) strcpy(gsp->glds_media.value.c, gld_media[ stats->glds_media < sizeof (gld_media) / sizeof (gld_media[0]) ? stats->glds_media : 0]); switch (macinfo->gldm_type) { case DL_ETHER: gsp->glds_frame.value.ul = stats->glds_frame; gsp->glds_crc.value.ul = stats->glds_crc; gsp->glds_collisions.value.ul = stats->glds_collisions; gsp->glds_excoll.value.ul = stats->glds_excoll; gsp->glds_defer.value.ul = stats->glds_defer; gsp->glds_short.value.ul = stats->glds_short; gsp->glds_xmtlatecoll.value.ul = stats->glds_xmtlatecoll; gsp->glds_nocarrier.value.ul = stats->glds_nocarrier; gsp->glds_dot3_first_coll.value.ui32 = stats->glds_dot3_first_coll; gsp->glds_dot3_multi_coll.value.ui32 = stats->glds_dot3_multi_coll; gsp->glds_dot3_sqe_error.value.ui32 = stats->glds_dot3_sqe_error; gsp->glds_dot3_mac_xmt_error.value.ui32 = stats->glds_dot3_mac_xmt_error; gsp->glds_dot3_mac_rcv_error.value.ui32 = stats->glds_dot3_mac_rcv_error; gsp->glds_dot3_frame_too_long.value.ui32 = stats->glds_dot3_frame_too_long; (void) strcpy(gsp->glds_duplex.value.c, gld_duplex[ stats->glds_duplex < sizeof (gld_duplex) / sizeof (gld_duplex[0]) ? stats->glds_duplex : 0]); break; case DL_TPR: gsp->glds_dot5_line_error.value.ui32 = stats->glds_dot5_line_error; gsp->glds_dot5_burst_error.value.ui32 = stats->glds_dot5_burst_error; gsp->glds_dot5_signal_loss.value.ui32 = stats->glds_dot5_signal_loss; gsp->glds_dot5_ace_error.value.ui32 = stats->glds_dot5_ace_error; gsp->glds_dot5_internal_error.value.ui32 = stats->glds_dot5_internal_error; gsp->glds_dot5_lost_frame_error.value.ui32 = stats->glds_dot5_lost_frame_error; gsp->glds_dot5_frame_copied_error.value.ui32 = stats->glds_dot5_frame_copied_error; gsp->glds_dot5_token_error.value.ui32 = stats->glds_dot5_token_error; gsp->glds_dot5_freq_error.value.ui32 = stats->glds_dot5_freq_error; break; case DL_FDDI: gsp->glds_fddi_mac_error.value.ui32 = stats->glds_fddi_mac_error; gsp->glds_fddi_mac_lost.value.ui32 = stats->glds_fddi_mac_lost; gsp->glds_fddi_mac_token.value.ui32 = stats->glds_fddi_mac_token; gsp->glds_fddi_mac_tvx_expired.value.ui32 = stats->glds_fddi_mac_tvx_expired; gsp->glds_fddi_mac_late.value.ui32 = stats->glds_fddi_mac_late; gsp->glds_fddi_mac_ring_op.value.ui32 = stats->glds_fddi_mac_ring_op; break; case DL_IB: break; default: break; } GLDM_UNLOCK(macinfo); #ifdef GLD_DEBUG gld_check_assertions(); if (gld_debug & GLDRDE) gld_sr_dump(macinfo); #endif return (0); } static int gld_init_vlan_stats(gld_vlan_t *vlan) { gld_mac_info_t *mac = vlan->gldv_mac; gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)mac->gldm_mac_pvt; struct gldkstats *sp; glddev_t *glddev; kstat_t *ksp; char *name; int instance; glddev = mac_pvt->major_dev; name = glddev->gld_name; instance = (vlan->gldv_id * GLD_VLAN_SCALE) + mac->gldm_ppa; if ((ksp = kstat_create(name, instance, NULL, "net", KSTAT_TYPE_NAMED, sizeof (struct gldkstats) / sizeof (kstat_named_t), 0)) == NULL) { cmn_err(CE_WARN, "GLD: failed to create kstat structure for %s%d", name, instance); return (GLD_FAILURE); } vlan->gldv_kstatp = ksp; ksp->ks_update = gld_update_vlan_kstat; ksp->ks_private = (void *)vlan; sp = ksp->ks_data; kstat_named_init(&sp->glds_pktrcv, "ipackets", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_pktxmt, "opackets", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_errrcv, "ierrors", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_errxmt, "oerrors", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_bytexmt, "obytes", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_bytercv, "rbytes", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_multixmt, "multixmt", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_multircv, "multircv", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_brdcstxmt, "brdcstxmt", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_brdcstrcv, "brdcstrcv", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_blocked, "blocked", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_noxmtbuf, "noxmtbuf", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_norcvbuf, "norcvbuf", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_xmtretry, "xmtretry", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_intr, "intr", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_pktrcv64, "ipackets64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_pktxmt64, "opackets64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_bytexmt64, "obytes64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_bytercv64, "rbytes64", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_unknowns, "unknowns", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_speed, "ifspeed", KSTAT_DATA_UINT64); kstat_named_init(&sp->glds_media, "media", KSTAT_DATA_CHAR); kstat_named_init(&sp->glds_prom, "promisc", KSTAT_DATA_CHAR); kstat_named_init(&sp->glds_overflow, "oflo", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_underflow, "uflo", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_missed, "missed", KSTAT_DATA_ULONG); kstat_named_init(&sp->glds_xmtbadinterp, "xmt_badinterp", KSTAT_DATA_UINT32); kstat_named_init(&sp->glds_rcvbadinterp, "rcv_badinterp", KSTAT_DATA_UINT32); kstat_install(ksp); return (GLD_SUCCESS); } static int gld_update_vlan_kstat(kstat_t *ksp, int rw) { gld_vlan_t *vlan; gld_mac_info_t *macinfo; struct gldkstats *gsp; struct gld_stats *stats; if (rw == KSTAT_WRITE) return (EACCES); vlan = (gld_vlan_t *)ksp->ks_private; ASSERT(vlan != NULL); macinfo = vlan->gldv_mac; GLDM_LOCK(macinfo, RW_WRITER); gsp = vlan->gldv_kstatp->ks_data; ASSERT(gsp); stats = vlan->gldv_stats; gsp->glds_pktxmt.value.ui32 = stats->glds_pktxmt64 & 0xffffffff; gsp->glds_bytexmt.value.ui32 = stats->glds_bytexmt64 & 0xffffffff; gsp->glds_errxmt.value.ul = stats->glds_errxmt; gsp->glds_multixmt.value.ul = stats->glds_multixmt; gsp->glds_brdcstxmt.value.ul = stats->glds_brdcstxmt; gsp->glds_noxmtbuf.value.ul = stats->glds_noxmtbuf; gsp->glds_xmtretry.value.ul = stats->glds_xmtretry; gsp->glds_pktxmt64.value.ui64 = stats->glds_pktxmt64; gsp->glds_bytexmt64.value.ui64 = stats->glds_bytexmt64; gsp->glds_pktrcv.value.ui32 = stats->glds_pktrcv64 & 0xffffffff; gsp->glds_bytercv.value.ui32 = stats->glds_bytercv64 & 0xffffffff; gsp->glds_errrcv.value.ul = stats->glds_errrcv; gsp->glds_multircv.value.ul = stats->glds_multircv; gsp->glds_brdcstrcv.value.ul = stats->glds_brdcstrcv; gsp->glds_blocked.value.ul = stats->glds_blocked; gsp->glds_pktrcv64.value.ui64 = stats->glds_pktrcv64; gsp->glds_bytercv64.value.ui64 = stats->glds_bytercv64; GLDM_UNLOCK(macinfo); return (0); } /* * The device dependent driver specifies gld_getinfo as its getinfo routine. */ /*ARGSUSED*/ int gld_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp) { dev_info_t *devinfo; minor_t minor = getminor((dev_t)arg); int rc = DDI_FAILURE; switch (cmd) { case DDI_INFO_DEVT2DEVINFO: if ((devinfo = gld_finddevinfo((dev_t)arg)) != NULL) { *(dev_info_t **)resultp = devinfo; rc = DDI_SUCCESS; } break; case DDI_INFO_DEVT2INSTANCE: /* Need static mapping for deferred attach */ if (minor == GLD_USE_STYLE2) { /* * Style 2: this minor number does not correspond to * any particular instance number. */ rc = DDI_FAILURE; } else if (minor <= GLD_MAX_STYLE1_MINOR) { /* Style 1: calculate the PPA from the minor */ *resultp = (void *)GLD_STYLE1_MINOR_TO_PPA(minor); rc = DDI_SUCCESS; } else { /* Clone: look for it. Not a static mapping */ if ((devinfo = gld_finddevinfo((dev_t)arg)) != NULL) { *resultp = (void *)ddi_get_instance(devinfo); rc = DDI_SUCCESS; } } break; } return (rc); } /* called from gld_getinfo */ dev_info_t * gld_finddevinfo(dev_t dev) { minor_t minor = getminor(dev); glddev_t *device; gld_mac_info_t *mac; gld_vlan_t *vlan; gld_t *str; dev_info_t *devinfo = NULL; int i; if (minor == GLD_USE_STYLE2) { /* * Style 2: this minor number does not correspond to * any particular instance number. * * XXX We don't know what to say. See Bug 1165519. */ return (NULL); } mutex_enter(&gld_device_list.gld_devlock); /* hold the device */ device = gld_devlookup(getmajor(dev)); if (device == NULL) { /* There are no attached instances of this device */ mutex_exit(&gld_device_list.gld_devlock); return (NULL); } /* * Search all attached macs and streams. * * XXX We don't bother checking the DL_UNATTACHED streams since * we don't know what devinfo we should report back even if we * found the minor. Maybe we should associate streams that are * not currently attached to a PPA with the "first" devinfo node * of the major device to attach -- the one that created the * minor node for the generic device. */ mutex_enter(&device->gld_devlock); for (mac = device->gld_mac_next; mac != (gld_mac_info_t *)&device->gld_mac_next; mac = mac->gldm_next) { gld_mac_pvt_t *pvt = (gld_mac_pvt_t *)mac->gldm_mac_pvt; if (!(mac->gldm_GLD_flags & GLD_MAC_READY)) continue; /* this one's not ready yet */ if (minor <= GLD_MAX_STYLE1_MINOR) { /* Style 1 -- look for the corresponding PPA */ if (minor == GLD_STYLE1_PPA_TO_MINOR(mac->gldm_ppa)) { devinfo = mac->gldm_devinfo; goto out; /* found it! */ } else continue; /* not this PPA */ } /* We are looking for a clone */ for (i = 0; i < VLAN_HASHSZ; i++) { for (vlan = pvt->vlan_hash[i]; vlan != NULL; vlan = vlan->gldv_next) { for (str = vlan->gldv_str_next; str != (gld_t *)&vlan->gldv_str_next; str = str->gld_next) { ASSERT(str->gld_mac_info == mac); if (minor == str->gld_minor) { devinfo = mac->gldm_devinfo; goto out; } } } } } out: mutex_exit(&device->gld_devlock); mutex_exit(&gld_device_list.gld_devlock); return (devinfo); } /* * STREAMS open routine. The device dependent driver specifies this as its * open entry point. */ /*ARGSUSED2*/ int gld_open(queue_t *q, dev_t *dev, int flag, int sflag, cred_t *cred) { gld_mac_pvt_t *mac_pvt; gld_t *gld; glddev_t *glddev; gld_mac_info_t *macinfo; minor_t minor = getminor(*dev); gld_vlan_t *vlan; t_uscalar_t ppa; ASSERT(q != NULL); if (minor > GLD_MAX_STYLE1_MINOR) return (ENXIO); ASSERT(q->q_ptr == NULL); /* Clone device gives us a fresh Q */ /* Find our per-major glddev_t structure */ mutex_enter(&gld_device_list.gld_devlock); glddev = gld_devlookup(getmajor(*dev)); /* * This glddev will hang around since detach (and therefore * gld_unregister) can't run while we're here in the open routine. */ mutex_exit(&gld_device_list.gld_devlock); if (glddev == NULL) return (ENXIO); #ifdef GLD_DEBUG if (gld_debug & GLDPROT) { if (minor == GLD_USE_STYLE2) cmn_err(CE_NOTE, "gld_open(%p, Style 2)", (void *)q); else cmn_err(CE_NOTE, "gld_open(%p, Style 1, minor = %d)", (void *)q, minor); } #endif /* * get a per-stream structure and link things together so we * can easily find them later. */ gld = kmem_zalloc(sizeof (gld_t), KM_SLEEP); /* * fill in the structure and state info */ gld->gld_qptr = q; gld->gld_device = glddev; gld->gld_state = DL_UNATTACHED; /* * we must atomically find a free minor number and add the stream * to a list, because gld_findminor has to traverse the lists to * determine which minor numbers are free. */ mutex_enter(&glddev->gld_devlock); /* find a free minor device number for the clone */ gld->gld_minor = gld_findminor(glddev); if (gld->gld_minor == 0) { mutex_exit(&glddev->gld_devlock); kmem_free(gld, sizeof (gld_t)); return (ENOSR); } #ifdef GLD_VERBOSE_DEBUG if (gld_debug & GLDPROT) cmn_err(CE_NOTE, "gld_open() gld ptr: %p minor: %d", (void *)gld, gld->gld_minor); #endif if (minor == GLD_USE_STYLE2) { gld->gld_style = DL_STYLE2; *dev = makedevice(getmajor(*dev), gld->gld_minor); WR(q)->q_ptr = q->q_ptr = (caddr_t)gld; gldinsque(gld, glddev->gld_str_prev); #ifdef GLD_VERBOSE_DEBUG if (gld_debug & GLDPROT) cmn_err(CE_NOTE, "GLDstruct added to device list"); #endif (void) qassociate(q, -1); goto done; } gld->gld_style = DL_STYLE1; /* the PPA is actually 1 less than the minordev */ ppa = GLD_STYLE1_MINOR_TO_PPA(minor); for (macinfo = glddev->gld_mac_next; macinfo != (gld_mac_info_t *)(&glddev->gld_mac_next); macinfo = macinfo->gldm_next) { ASSERT(macinfo != NULL); if (macinfo->gldm_ppa != ppa) continue; if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) continue; /* this one's not ready yet */ /* * we found the correct PPA */ GLDM_LOCK(macinfo, RW_WRITER); gld->gld_mac_info = macinfo; if (macinfo->gldm_send_tagged != NULL) gld->gld_send = macinfo->gldm_send_tagged; else gld->gld_send = macinfo->gldm_send; /* now ready for action */ gld->gld_state = DL_UNBOUND; if ((vlan = gld_get_vlan(macinfo, VLAN_VID_NONE)) == NULL) { GLDM_UNLOCK(macinfo); mutex_exit(&glddev->gld_devlock); kmem_free(gld, sizeof (gld_t)); return (EIO); } mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; if (!mac_pvt->started) { if (gld_start_mac(macinfo) != GLD_SUCCESS) { gld_rem_vlan(vlan); GLDM_UNLOCK(macinfo); mutex_exit(&glddev->gld_devlock); kmem_free(gld, sizeof (gld_t)); return (EIO); } } gld->gld_vlan = vlan; vlan->gldv_nstreams++; gldinsque(gld, vlan->gldv_str_prev); *dev = makedevice(getmajor(*dev), gld->gld_minor); WR(q)->q_ptr = q->q_ptr = (caddr_t)gld; GLDM_UNLOCK(macinfo); #ifdef GLD_VERBOSE_DEBUG if (gld_debug & GLDPROT) cmn_err(CE_NOTE, "GLDstruct added to instance list"); #endif break; } if (gld->gld_state == DL_UNATTACHED) { mutex_exit(&glddev->gld_devlock); kmem_free(gld, sizeof (gld_t)); return (ENXIO); } done: mutex_exit(&glddev->gld_devlock); noenable(WR(q)); /* We'll do the qenables manually */ qprocson(q); /* start the queues running */ qenable(WR(q)); return (0); } /* * normal stream close call checks current status and cleans up * data structures that were dynamically allocated */ /*ARGSUSED1*/ int gld_close(queue_t *q, int flag, cred_t *cred) { gld_t *gld = (gld_t *)q->q_ptr; glddev_t *glddev = gld->gld_device; ASSERT(q); ASSERT(gld); #ifdef GLD_DEBUG if (gld_debug & GLDPROT) { cmn_err(CE_NOTE, "gld_close(%p, Style %d)", (void *)q, (gld->gld_style & 0x1) + 1); } #endif /* Hold all device streams lists still while we check for a macinfo */ mutex_enter(&glddev->gld_devlock); if (gld->gld_mac_info != NULL) { /* If there's a macinfo, block recv while we change state */ GLDM_LOCK(gld->gld_mac_info, RW_WRITER); gld->gld_flags |= GLD_STR_CLOSING; /* no more rcv putnexts */ GLDM_UNLOCK(gld->gld_mac_info); } else { /* no mac DL_ATTACHED right now */ gld->gld_flags |= GLD_STR_CLOSING; } mutex_exit(&glddev->gld_devlock); /* * qprocsoff before we call gld_unbind/gldunattach, so that * we know wsrv isn't in there trying to undo what we're doing. */ qprocsoff(q); ASSERT(gld->gld_wput_count == 0); gld->gld_wput_count = 0; /* just in case */ if (gld->gld_state == DL_IDLE) { /* Need to unbind */ ASSERT(gld->gld_mac_info != NULL); (void) gld_unbind(WR(q), NULL); } if (gld->gld_state == DL_UNBOUND) { /* * Need to unattach * For style 2 stream, gldunattach also * associate queue with NULL dip */ ASSERT(gld->gld_mac_info != NULL); (void) gldunattach(WR(q), NULL); } /* disassociate the stream from the device */ q->q_ptr = WR(q)->q_ptr = NULL; /* * Since we unattached above (if necessary), we know that we're * on the per-major list of unattached streams, rather than a * per-PPA list. So we know we should hold the devlock. */ mutex_enter(&glddev->gld_devlock); gldremque(gld); /* remove from Style 2 list */ mutex_exit(&glddev->gld_devlock); kmem_free(gld, sizeof (gld_t)); return (0); } /* * gld_rsrv (q) * simple read service procedure * purpose is to avoid the time it takes for packets * to move through IP so we can get them off the board * as fast as possible due to limited PC resources. * * This is not normally used in the current implementation. It * can be selected with the undocumented property "fast_recv". * If that property is set, gld_recv will send the packet * upstream with a putq() rather than a putnext(), thus causing * this routine to be scheduled. */ int gld_rsrv(queue_t *q) { mblk_t *mp; while ((mp = getq(q)) != NULL) { if (canputnext(q)) { putnext(q, mp); } else { freemsg(mp); } } return (0); } /* * gld_wput (q, mp) * general gld stream write put routine. Receives fastpath data from upper * modules and processes it immediately. ioctl and M_PROTO/M_PCPROTO are * queued for later processing by the service procedure. */ int gld_wput(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)(q->q_ptr); int rc; boolean_t multidata = B_TRUE; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_wput(%p %p): type %x", (void *)q, (void *)mp, DB_TYPE(mp)); #endif switch (DB_TYPE(mp)) { case M_DATA: /* fast data / raw support */ /* we must be DL_ATTACHED and DL_BOUND to do this */ /* Tricky to access memory without taking the mutex */ if ((gld->gld_flags & (GLD_RAW | GLD_FAST)) == 0 || gld->gld_state != DL_IDLE) { merror(q, mp, EPROTO); break; } multidata = B_FALSE; /* LINTED: E_CASE_FALLTHRU */ case M_MULTIDATA: /* Only call gld_start() directly if nothing queued ahead */ /* No guarantees about ordering with different threads */ if (q->q_first) goto use_wsrv; /* * This can happen if wsrv has taken off the last mblk but * is still processing it. */ membar_consumer(); if (gld->gld_in_wsrv) goto use_wsrv; /* * Keep a count of current wput calls to start. * Nonzero count delays any attempted DL_UNBIND. * See comments above gld_start(). */ atomic_add_32((uint32_t *)&gld->gld_wput_count, 1); membar_enter(); /* Recheck state now wput_count is set to prevent DL_UNBIND */ /* If this Q is in process of DL_UNBIND, don't call start */ if (gld->gld_state != DL_IDLE || gld->gld_in_unbind) { /* Extremely unlikely */ atomic_add_32((uint32_t *)&gld->gld_wput_count, -1); goto use_wsrv; } rc = (multidata) ? gld_start_mdt(q, mp, GLD_WPUT) : gld_start(q, mp, GLD_WPUT, UPRI(gld, mp->b_band)); /* Allow DL_UNBIND again */ membar_exit(); atomic_add_32((uint32_t *)&gld->gld_wput_count, -1); if (rc == GLD_NORESOURCES) qenable(q); break; /* Done with this packet */ use_wsrv: /* Q not empty, in DL_DETACH, or start gave NORESOURCES */ (void) putq(q, mp); qenable(q); break; case M_IOCTL: /* ioctl relies on wsrv single threading per queue */ (void) putq(q, mp); qenable(q); break; case M_CTL: (void) putq(q, mp); qenable(q); break; case M_FLUSH: /* canonical flush handling */ /* XXX Should these be FLUSHALL? */ if (*mp->b_rptr & FLUSHW) flushq(q, 0); if (*mp->b_rptr & FLUSHR) { flushq(RD(q), 0); *mp->b_rptr &= ~FLUSHW; qreply(q, mp); } else freemsg(mp); break; case M_PROTO: case M_PCPROTO: /* these rely on wsrv single threading per queue */ (void) putq(q, mp); qenable(q); break; default: #ifdef GLD_DEBUG if (gld_debug & GLDETRACE) cmn_err(CE_WARN, "gld: Unexpected packet type from queue: 0x%x", DB_TYPE(mp)); #endif freemsg(mp); } return (0); } /* * gld_wsrv - Incoming messages are processed according to the DLPI protocol * specification. * * wsrv is single-threaded per Q. We make use of this to avoid taking the * lock for reading data items that are only ever written by us. */ int gld_wsrv(queue_t *q) { mblk_t *mp; gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo; union DL_primitives *prim; int err; boolean_t multidata; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_wsrv(%p)", (void *)q); #endif ASSERT(!gld->gld_in_wsrv); gld->gld_xwait = B_FALSE; /* We are now going to process this Q */ if (q->q_first == NULL) return (0); macinfo = gld->gld_mac_info; /* * Help wput avoid a call to gld_start if there might be a message * previously queued by that thread being processed here. */ gld->gld_in_wsrv = B_TRUE; membar_enter(); while ((mp = getq(q)) != NULL) { switch (DB_TYPE(mp)) { case M_DATA: case M_MULTIDATA: multidata = (DB_TYPE(mp) == M_MULTIDATA); /* * retry of a previously processed UNITDATA_REQ * or is a RAW or FAST message from above. */ if (macinfo == NULL) { /* No longer attached to a PPA, drop packet */ freemsg(mp); break; } gld->gld_sched_ran = B_FALSE; membar_enter(); err = (multidata) ? gld_start_mdt(q, mp, GLD_WSRV) : gld_start(q, mp, GLD_WSRV, UPRI(gld, mp->b_band)); if (err == GLD_NORESOURCES) { /* gld_sched will qenable us later */ gld->gld_xwait = B_TRUE; /* want qenable */ membar_enter(); /* * v2: we're not holding the lock; it's * possible that the driver could have already * called gld_sched (following up on its * return of GLD_NORESOURCES), before we got a * chance to do the putbq() and set gld_xwait. * So if we saw a call to gld_sched that * examined this queue, since our call to * gld_start() above, then it's possible we've * already seen the only call to gld_sched() * we're ever going to see. So we better retry * transmitting this packet right now. */ if (gld->gld_sched_ran) { #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_wsrv: " "sched was called"); #endif break; /* try again right now */ } gld->gld_in_wsrv = B_FALSE; return (0); } break; case M_IOCTL: (void) gld_ioctl(q, mp); break; case M_CTL: if (macinfo == NULL) { freemsg(mp); break; } if (macinfo->gldm_mctl != NULL) { GLDM_LOCK(macinfo, RW_WRITER); (void) (*macinfo->gldm_mctl) (macinfo, q, mp); GLDM_UNLOCK(macinfo); } else { /* This driver doesn't recognize, just drop */ freemsg(mp); } break; case M_PROTO: /* Will be an DLPI message of some type */ case M_PCPROTO: if ((err = gld_cmds(q, mp)) != GLDE_OK) { if (err == GLDE_RETRY) { gld->gld_in_wsrv = B_FALSE; return (0); /* quit while we're ahead */ } prim = (union DL_primitives *)mp->b_rptr; dlerrorack(q, mp, prim->dl_primitive, err, 0); } break; default: /* This should never happen */ #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_wsrv: db_type(%x) not supported", mp->b_datap->db_type); #endif freemsg(mp); /* unknown types are discarded */ break; } } membar_exit(); gld->gld_in_wsrv = B_FALSE; return (0); } /* * gld_start() can get called from gld_wput(), gld_wsrv(), or gld_unitdata(). * * We only come directly from wput() in the GLD_FAST (fastpath) or RAW case. * * In particular, we must avoid calling gld_precv*() if we came from wput(). * gld_precv*() is where we, on the transmit side, loop back our outgoing * packets to the receive side if we are in physical promiscuous mode. * Since the receive side holds a lock across its call to the upstream * putnext, and that upstream module could well have looped back to our * wput() routine on the same thread, we cannot call gld_precv* from here * for fear of causing a recursive lock entry in our receive code. * * There is a problem here when coming from gld_wput(). While wput * only comes here if the queue is attached to a PPA and bound to a SAP * and there are no messages on the queue ahead of the M_DATA that could * change that, it is theoretically possible that another thread could * now wput a DL_UNBIND and a DL_DETACH message, and the wsrv() routine * could wake up and process them, before we finish processing this * send of the M_DATA. This can only possibly happen on a Style 2 RAW or * FAST (fastpath) stream: non RAW/FAST streams always go through wsrv(), * and Style 1 streams only DL_DETACH in the close routine, where * qprocsoff() protects us. If this happens we could end up calling * gldm_send() after we have detached the stream and possibly called * gldm_stop(). Worse, once the number of attached streams goes to zero, * detach/unregister could be called, and the macinfo could go away entirely. * * No one has ever seen this happen. * * It is some trouble to fix this, and we would rather not add any mutex * logic into the wput() routine, which is supposed to be a "fast" * path. * * What I've done is use an atomic counter to keep a count of the number * of threads currently calling gld_start() from wput() on this stream. * If DL_DETACH sees this as nonzero, it putbqs the request back onto * the queue and qenables, hoping to have better luck next time. Since * people shouldn't be trying to send after they've asked to DL_DETACH, * hopefully very soon all the wput=>start threads should have returned * and the DL_DETACH will succeed. It's hard to test this since the odds * of the failure even trying to happen are so small. I probably could * have ignored the whole issue and never been the worse for it. */ static int gld_start(queue_t *q, mblk_t *mp, int caller, uint32_t upri) { mblk_t *nmp; gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo; gld_mac_pvt_t *mac_pvt; int rc; gld_interface_t *ifp; pktinfo_t pktinfo; uint32_t vtag; gld_vlan_t *vlan; ASSERT(DB_TYPE(mp) == M_DATA); macinfo = gld->gld_mac_info; mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; ifp = mac_pvt->interfacep; vlan = (gld_vlan_t *)gld->gld_vlan; if ((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_TX) != 0) { freemsg(mp); #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_start: failed to interpret outbound packet"); #endif vlan->gldv_stats->glds_xmtbadinterp++; return (GLD_BADARG); } /* * We're not holding the lock for this check. If the promiscuous * state is in flux it doesn't matter much if we get this wrong. */ if (mac_pvt->nprom > 0) { /* * We want to loopback to the receive side, but to avoid * recursive lock entry: if we came from wput(), which * could have looped back via IP from our own receive * interrupt thread, we decline this request. wput() * will then queue the packet for wsrv(). This means * that when snoop is running we don't get the advantage * of the wput() multithreaded direct entry to the * driver's send routine. */ if (caller == GLD_WPUT) { (void) putbq(q, mp); return (GLD_NORESOURCES); } if (macinfo->gldm_capabilities & GLD_CAP_ZEROCOPY) nmp = dupmsg_noloan(mp); else nmp = dupmsg(mp); } else nmp = NULL; /* we need no loopback */ vtag = GLD_MK_VTAG(vlan->gldv_ptag, upri); if (ifp->hdr_size > 0 && pktinfo.pktLen > ifp->hdr_size + (vtag == 0 ? 0 : VTAG_SIZE) + macinfo->gldm_maxpkt) { freemsg(mp); /* discard oversized outbound packet */ if (nmp) freemsg(nmp); /* free the duped message */ #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_start: oversize outbound packet, size %d," "max %d", pktinfo.pktLen, ifp->hdr_size + macinfo->gldm_maxpkt); #endif vlan->gldv_stats->glds_xmtbadinterp++; return (GLD_BADARG); } rc = (*gld->gld_send)(macinfo, mp, vtag); if (rc != GLD_SUCCESS) { if (rc == GLD_NORESOURCES) { vlan->gldv_stats->glds_xmtretry++; (void) putbq(q, mp); } else { /* transmit error; drop the packet */ freemsg(mp); /* We're supposed to count failed attempts as well */ UPDATE_STATS(vlan, pktinfo, 1); #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_start: gldm_send failed %d", rc); #endif } if (nmp) freemsg(nmp); /* free the dupped message */ return (rc); } UPDATE_STATS(vlan, pktinfo, 1); /* * Loopback case. The message needs to be returned back on * the read side. This would silently fail if the dumpmsg fails * above. This is probably OK, if there is no memory to dup the * block, then there isn't much we could do anyway. */ if (nmp) { GLDM_LOCK(macinfo, RW_WRITER); gld_precv(macinfo, vlan, nmp); GLDM_UNLOCK(macinfo); } return (GLD_SUCCESS); } /* * With MDT V.2 a single message mp can have one header area and multiple * payload areas. A packet is described by dl_pkt_info, and each packet can * span multiple payload areas (currently with TCP, each packet will have one * header and at the most two payload areas). MACs might have a limit on the * number of payload segments (i.e. per packet scatter-gather limit), and * MDT V.2 has a way of specifying that with mdt_span_limit; the MAC driver * might also have a limit on the total number of payloads in a message, and * that is specified by mdt_max_pld. */ static int gld_start_mdt(queue_t *q, mblk_t *mp, int caller) { mblk_t *nextmp; gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo = gld->gld_mac_info; gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; int numpacks, mdtpacks; gld_interface_t *ifp = mac_pvt->interfacep; pktinfo_t pktinfo; gld_vlan_t *vlan = (gld_vlan_t *)gld->gld_vlan; boolean_t doloop = B_FALSE; multidata_t *dlmdp; pdescinfo_t pinfo; pdesc_t *dl_pkt; void *cookie; uint_t totLen = 0; ASSERT(DB_TYPE(mp) == M_MULTIDATA); /* * We're not holding the lock for this check. If the promiscuous * state is in flux it doesn't matter much if we get this wrong. */ if (mac_pvt->nprom > 0) { /* * We want to loopback to the receive side, but to avoid * recursive lock entry: if we came from wput(), which * could have looped back via IP from our own receive * interrupt thread, we decline this request. wput() * will then queue the packet for wsrv(). This means * that when snoop is running we don't get the advantage * of the wput() multithreaded direct entry to the * driver's send routine. */ if (caller == GLD_WPUT) { (void) putbq(q, mp); return (GLD_NORESOURCES); } doloop = B_TRUE; /* * unlike the M_DATA case, we don't have to call * dupmsg_noloan here because mmd_transform * (called by gld_precv_mdt) will make a copy of * each dblk. */ } while (mp != NULL) { /* * The lower layer driver only gets a single multidata * message; this also makes it easier to handle noresources. */ nextmp = mp->b_cont; mp->b_cont = NULL; /* * Get number of packets in this message; if nothing * to transmit, go to next message. */ dlmdp = mmd_getmultidata(mp); if ((mdtpacks = (int)mmd_getcnt(dlmdp, NULL, NULL)) == 0) { freemsg(mp); mp = nextmp; continue; } /* * Run interpreter to populate media specific pktinfo fields. * This collects per MDT message information like sap, * broad/multicast etc. */ (void) (*ifp->interpreter_mdt)(macinfo, mp, NULL, &pktinfo, GLD_MDT_TX); numpacks = (*macinfo->gldm_mdt_pre)(macinfo, mp, &cookie); if (numpacks > 0) { /* * Driver indicates it can transmit at least 1, and * possibly all, packets in MDT message. */ int count = numpacks; for (dl_pkt = mmd_getfirstpdesc(dlmdp, &pinfo); (dl_pkt != NULL); dl_pkt = mmd_getnextpdesc(dl_pkt, &pinfo)) { /* * Format this packet by adding link header and * adjusting pdescinfo to include it; get * packet length. */ (void) (*ifp->interpreter_mdt)(macinfo, NULL, &pinfo, &pktinfo, GLD_MDT_TXPKT); totLen += pktinfo.pktLen; /* * Loop back packet before handing to the * driver. */ if (doloop && mmd_adjpdesc(dl_pkt, &pinfo) != NULL) { GLDM_LOCK(macinfo, RW_WRITER); gld_precv_mdt(macinfo, vlan, mp, dl_pkt, &pktinfo); GLDM_UNLOCK(macinfo); } /* * And send off to driver. */ (*macinfo->gldm_mdt_send)(macinfo, cookie, &pinfo); /* * Be careful not to invoke getnextpdesc if we * already sent the last packet, since driver * might have posted it to hardware causing a * completion and freemsg() so the MDT data * structures might not be valid anymore. */ if (--count == 0) break; } (*macinfo->gldm_mdt_post)(macinfo, mp, cookie); pktinfo.pktLen = totLen; UPDATE_STATS(vlan, pktinfo, numpacks); /* * In the noresources case (when driver indicates it * can not transmit all packets in the MDT message), * adjust to skip the first few packets on retrial. */ if (numpacks != mdtpacks) { /* * Release already processed packet descriptors. */ for (count = 0; count < numpacks; count++) { dl_pkt = mmd_getfirstpdesc(dlmdp, &pinfo); mmd_rempdesc(dl_pkt); } vlan->gldv_stats->glds_xmtretry++; mp->b_cont = nextmp; (void) putbq(q, mp); return (GLD_NORESOURCES); } } else if (numpacks == 0) { /* * Driver indicates it can not transmit any packets * currently and will request retrial later. */ vlan->gldv_stats->glds_xmtretry++; mp->b_cont = nextmp; (void) putbq(q, mp); return (GLD_NORESOURCES); } else { ASSERT(numpacks == -1); /* * We're supposed to count failed attempts as well. */ dl_pkt = mmd_getfirstpdesc(dlmdp, &pinfo); while (dl_pkt != NULL) { /* * Call interpreter to determine total packet * bytes that are being dropped. */ (void) (*ifp->interpreter_mdt)(macinfo, NULL, &pinfo, &pktinfo, GLD_MDT_TXPKT); totLen += pktinfo.pktLen; dl_pkt = mmd_getnextpdesc(dl_pkt, &pinfo); } pktinfo.pktLen = totLen; UPDATE_STATS(vlan, pktinfo, mdtpacks); /* * Transmit error; drop the message, move on * to the next one. */ freemsg(mp); } /* * Process the next multidata block, if there is one. */ mp = nextmp; } return (GLD_SUCCESS); } /* * gld_intr (macinfo) */ uint_t gld_intr(gld_mac_info_t *macinfo) { ASSERT(macinfo != NULL); if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) return (DDI_INTR_UNCLAIMED); return ((*macinfo->gldm_intr)(macinfo)); } /* * gld_sched (macinfo) * * This routine scans the streams that refer to a specific macinfo * structure and causes the STREAMS scheduler to try to run them if * they are marked as waiting for the transmit buffer. */ void gld_sched(gld_mac_info_t *macinfo) { gld_mac_pvt_t *mac_pvt; gld_t *gld; gld_vlan_t *vlan; int i; ASSERT(macinfo != NULL); GLDM_LOCK(macinfo, RW_WRITER); if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) { /* We're probably being called from a leftover interrupt */ GLDM_UNLOCK(macinfo); return; } mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; for (i = 0; i < VLAN_HASHSZ; i++) { for (vlan = mac_pvt->vlan_hash[i]; vlan != NULL; vlan = vlan->gldv_next) { for (gld = vlan->gldv_str_next; gld != (gld_t *)&vlan->gldv_str_next; gld = gld->gld_next) { ASSERT(gld->gld_mac_info == macinfo); gld->gld_sched_ran = B_TRUE; membar_enter(); if (gld->gld_xwait) { gld->gld_xwait = B_FALSE; qenable(WR(gld->gld_qptr)); } } } } GLDM_UNLOCK(macinfo); } /* * gld_precv (macinfo, mp) * called from gld_start to loopback a packet when in promiscuous mode */ static void gld_precv(gld_mac_info_t *macinfo, gld_vlan_t *vlan, mblk_t *mp) { gld_mac_pvt_t *mac_pvt; gld_interface_t *ifp; pktinfo_t pktinfo; ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; ifp = mac_pvt->interfacep; /* * call the media specific packet interpreter routine */ if ((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_RXLOOP) != 0) { freemsg(mp); BUMP(vlan->gldv_stats->glds_rcvbadinterp, 1); #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_precv: interpreter failed"); #endif return; } gld_sendup(macinfo, vlan, &pktinfo, mp, gld_paccept); } /* * called from gld_start_mdt to loopback packet(s) when in promiscuous mode */ static void gld_precv_mdt(gld_mac_info_t *macinfo, gld_vlan_t *vlan, mblk_t *mp, pdesc_t *dl_pkt, pktinfo_t *pktinfo) { mblk_t *adjmp; gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; gld_interface_t *ifp = mac_pvt->interfacep; ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); /* * Get source/destination. */ (void) (*ifp->interpreter_mdt)(macinfo, mp, NULL, pktinfo, GLD_MDT_RXLOOP); if ((adjmp = mmd_transform(dl_pkt)) != NULL) gld_sendup(macinfo, vlan, pktinfo, adjmp, gld_paccept); } /* * gld_recv (macinfo, mp) * called with an mac-level packet in a mblock; take the maclock, * try the ip4q and ip6q hack, and otherwise call gld_sendup. * * V0 drivers already are holding the mutex when they call us. */ void gld_recv(gld_mac_info_t *macinfo, mblk_t *mp) { gld_recv_tagged(macinfo, mp, VLAN_VTAG_NONE); } void gld_recv_tagged(gld_mac_info_t *macinfo, mblk_t *mp, uint32_t vtag) { gld_mac_pvt_t *mac_pvt; char pbuf[3*GLD_MAX_ADDRLEN]; pktinfo_t pktinfo; gld_interface_t *ifp; queue_t *ipq = NULL; gld_vlan_t *vlan; uint32_t vid; ASSERT(macinfo != NULL); ASSERT(mp->b_datap->db_ref); GLDM_LOCK(macinfo, RW_READER); if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) { /* We're probably being called from a leftover interrupt */ freemsg(mp); goto done; } vid = GLD_VTAG_VID(vtag); if ((vlan = gld_find_vlan(macinfo, vid)) == NULL) { freemsg(mp); goto done; } /* * Check whether underlying media code supports the IPQ hack, * and if so, whether the interpreter can quickly parse the * packet to get some relevant parameters. */ mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; ifp = mac_pvt->interfacep; if (((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_RXQUICK) == 0) && (vlan->gldv_ipq_flags == 0)) { switch (pktinfo.ethertype) { case ETHERTYPE_IP: ipq = vlan->gldv_ipq; break; case ETHERTYPE_IPV6: ipq = vlan->gldv_ipv6q; break; } } BUMP(vlan->gldv_stats->glds_bytercv64, pktinfo.pktLen); BUMP(vlan->gldv_stats->glds_pktrcv64, 1); /* * Special case for IP; we can simply do the putnext here, if: * o ipq != NULL, and therefore: * - the device type supports IPQ (ethernet and IPoIB); * - the interpreter could quickly parse the packet; * - there are no PROMISC_SAP streams (on this VLAN); * - there is one, and only one, IP stream bound (to this VLAN); * - that stream is a "fastpath" stream; * - the packet is of type ETHERTYPE_IP or ETHERTYPE_IPV6 * * o the packet is specifically for me, and therefore: * - the packet is not multicast or broadcast (fastpath only * wants unicast packets). * * o the stream is not asserting flow control. */ if (ipq != NULL && pktinfo.isForMe && canputnext(ipq)) { /* * Skip the mac header. We know there is no LLC1/SNAP header * in this packet */ mp->b_rptr += pktinfo.macLen; putnext(ipq, mp); goto done; } /* * call the media specific packet interpreter routine */ if ((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_RX) != 0) { BUMP(vlan->gldv_stats->glds_rcvbadinterp, 1); #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_recv_tagged: interpreter failed"); #endif freemsg(mp); goto done; } /* * This is safe even if vtag is VLAN_VTAG_NONE */ pktinfo.vid = vid; pktinfo.cfi = GLD_VTAG_CFI(vtag); #ifdef GLD_DEBUG if (pktinfo.cfi != VLAN_CFI_ETHER) cmn_err(CE_WARN, "gld_recv_tagged: non-ETHER CFI"); #endif pktinfo.user_pri = GLD_VTAG_PRI(vtag); #ifdef GLD_DEBUG if ((gld_debug & GLDRECV) && (!(gld_debug & GLDNOBR) || (!pktinfo.isBroadcast && !pktinfo.isMulticast))) { char pbuf2[3*GLD_MAX_ADDRLEN]; cmn_err(CE_CONT, "gld_recv_tagged: machdr=<%s -> %s>\n", gld_macaddr_sprintf(pbuf, pktinfo.shost, macinfo->gldm_addrlen), gld_macaddr_sprintf(pbuf2, pktinfo.dhost, macinfo->gldm_addrlen)); cmn_err(CE_CONT, "gld_recv_tagged: VlanId %d UserPri %d\n", pktinfo.vid, pktinfo.user_pri); cmn_err(CE_CONT, "gld_recv_tagged: ethertype: %4x Len: %4d " "Hdr: %d,%d isMulticast: %s\n", pktinfo.ethertype, pktinfo.pktLen, pktinfo.macLen, pktinfo.hdrLen, pktinfo.isMulticast ? "Y" : "N"); } #endif gld_sendup(macinfo, vlan, &pktinfo, mp, gld_accept); done: GLDM_UNLOCK(macinfo); } /* =================================================================== */ /* receive group: called from gld_recv and gld_precv* with maclock held */ /* =================================================================== */ /* * gld_sendup (macinfo, mp) * called with an ethernet packet in a mblock; must decide whether * packet is for us and which streams to queue it to. */ static void gld_sendup(gld_mac_info_t *macinfo, gld_vlan_t *vlan, pktinfo_t *pktinfo, mblk_t *mp, int (*acceptfunc)()) { gld_t *gld; gld_t *fgld = NULL; mblk_t *nmp; void (*send)(queue_t *qp, mblk_t *mp); int (*cansend)(queue_t *qp); #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_sendup(%p, %p)", (void *)mp, (void *)macinfo); #endif ASSERT(mp != NULL); ASSERT(macinfo != NULL); ASSERT(vlan != NULL); ASSERT(pktinfo != NULL); ASSERT(GLDM_LOCK_HELD(macinfo)); /* * The "fast" in "GLDOPT_FAST_RECV" refers to the speed at which * gld_recv returns to the caller's interrupt routine. The total * network throughput would normally be lower when selecting this * option, because we putq the messages and process them later, * instead of sending them with putnext now. Some time critical * device might need this, so it's here but undocumented. */ if (macinfo->gldm_options & GLDOPT_FAST_RECV) { send = (void (*)(queue_t *, mblk_t *))putq; cansend = canput; } else { send = (void (*)(queue_t *, mblk_t *))putnext; cansend = canputnext; } /* * Search all the streams attached to this macinfo looking for * those eligible to receive the present packet. */ for (gld = vlan->gldv_str_next; gld != (gld_t *)&vlan->gldv_str_next; gld = gld->gld_next) { #ifdef GLD_VERBOSE_DEBUG cmn_err(CE_NOTE, "gld_sendup: SAP: %4x QPTR: %p QSTATE: %s", gld->gld_sap, (void *)gld->gld_qptr, gld->gld_state == DL_IDLE ? "IDLE": "NOT IDLE"); #endif ASSERT(gld->gld_qptr != NULL); ASSERT(gld->gld_state == DL_IDLE || gld->gld_state == DL_UNBOUND); ASSERT(gld->gld_mac_info == macinfo); ASSERT(gld->gld_vlan == vlan); if (gld->gld_state != DL_IDLE) continue; /* not eligible to receive */ if (gld->gld_flags & GLD_STR_CLOSING) continue; /* not eligible to receive */ #ifdef GLD_DEBUG if ((gld_debug & GLDRECV) && (!(gld_debug & GLDNOBR) || (!pktinfo->isBroadcast && !pktinfo->isMulticast))) cmn_err(CE_NOTE, "gld_sendup: queue sap: %4x promis: %s %s %s", gld->gld_sap, gld->gld_flags & GLD_PROM_PHYS ? "phys " : " ", gld->gld_flags & GLD_PROM_SAP ? "sap " : " ", gld->gld_flags & GLD_PROM_MULT ? "multi" : " "); #endif /* * The accept function differs depending on whether this is * a packet that we received from the wire or a loopback. */ if ((*acceptfunc)(gld, pktinfo)) { /* sap matches */ pktinfo->wasAccepted = 1; /* known protocol */ if (!(*cansend)(gld->gld_qptr)) { /* * Upper stream is not accepting messages, i.e. * it is flow controlled, therefore we will * forgo sending the message up this stream. */ #ifdef GLD_DEBUG if (gld_debug & GLDETRACE) cmn_err(CE_WARN, "gld_sendup: canput failed"); #endif BUMP(vlan->gldv_stats->glds_blocked, 1); qenable(gld->gld_qptr); continue; } /* * we are trying to avoid an extra dumpmsg() here. * If this is the first eligible queue, remember the * queue and send up the message after the loop. */ if (!fgld) { fgld = gld; continue; } /* duplicate the packet for this stream */ nmp = dupmsg(mp); if (nmp == NULL) { BUMP(vlan->gldv_stats->glds_gldnorcvbuf, 1); #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_sendup: dupmsg failed"); #endif break; /* couldn't get resources; drop it */ } /* pass the message up the stream */ gld_passon(gld, nmp, pktinfo, send); } } ASSERT(mp); /* send the original dup of the packet up the first stream found */ if (fgld) gld_passon(fgld, mp, pktinfo, send); else freemsg(mp); /* no streams matched */ /* We do not count looped back packets */ if (acceptfunc == gld_paccept) return; /* transmit loopback case */ if (pktinfo->isBroadcast) BUMP(vlan->gldv_stats->glds_brdcstrcv, 1); else if (pktinfo->isMulticast) BUMP(vlan->gldv_stats->glds_multircv, 1); /* No stream accepted this packet */ if (!pktinfo->wasAccepted) BUMP(vlan->gldv_stats->glds_unknowns, 1); } /* * A packet matches a stream if: * the stream accepts EtherType encoded packets and the type matches * or the stream accepts LLC packets and the packet is an LLC packet */ #define MATCH(stream, pktinfo) \ ((stream->gld_ethertype && stream->gld_sap == pktinfo->ethertype) || \ (!stream->gld_ethertype && pktinfo->isLLC)) /* * This function validates a packet for sending up a particular * stream. The message header has been parsed and its characteristic * are recorded in the pktinfo data structure. The streams stack info * are presented in gld data structures. */ static int gld_accept(gld_t *gld, pktinfo_t *pktinfo) { /* * if there is no match do not bother checking further. */ if (!MATCH(gld, pktinfo) && !(gld->gld_flags & GLD_PROM_SAP)) return (0); /* * We don't accept any packet from the hardware if we originated it. * (Contrast gld_paccept, the send-loopback accept function.) */ if (pktinfo->isLooped) return (0); /* * If the packet is broadcast or sent to us directly we will accept it. * Also we will accept multicast packets requested by the stream. */ if (pktinfo->isForMe || pktinfo->isBroadcast || gld_mcmatch(gld, pktinfo)) return (1); /* * Finally, accept anything else if we're in promiscuous mode */ if (gld->gld_flags & GLD_PROM_PHYS) return (1); return (0); } /* * Return TRUE if the given multicast address is one * of those that this particular Stream is interested in. */ static int gld_mcmatch(gld_t *gld, pktinfo_t *pktinfo) { /* * Return FALSE if not a multicast address. */ if (!pktinfo->isMulticast) return (0); /* * Check if all multicasts have been enabled for this Stream */ if (gld->gld_flags & GLD_PROM_MULT) return (1); /* * Return FALSE if no multicast addresses enabled for this Stream. */ if (!gld->gld_mcast) return (0); /* * Otherwise, look for it in the table. */ return (gld_multicast(pktinfo->dhost, gld)); } /* * gld_multicast determines if the address is a multicast address for * this stream. */ static int gld_multicast(unsigned char *macaddr, gld_t *gld) { int i; ASSERT(GLDM_LOCK_HELD(gld->gld_mac_info)); if (!gld->gld_mcast) return (0); for (i = 0; i < gld->gld_multicnt; i++) { if (gld->gld_mcast[i]) { ASSERT(gld->gld_mcast[i]->gldm_refcnt); if (mac_eq(gld->gld_mcast[i]->gldm_addr, macaddr, gld->gld_mac_info->gldm_addrlen)) return (1); } } return (0); } /* * accept function for looped back packets */ static int gld_paccept(gld_t *gld, pktinfo_t *pktinfo) { return (gld->gld_flags & GLD_PROM_PHYS && (MATCH(gld, pktinfo) || gld->gld_flags & GLD_PROM_SAP)); } static void gld_passon(gld_t *gld, mblk_t *mp, pktinfo_t *pktinfo, void (*send)(queue_t *qp, mblk_t *mp)) { int skiplen; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_passon(%p, %p, %p)", (void *)gld, (void *)mp, (void *)pktinfo); if ((gld_debug & GLDRECV) && (!(gld_debug & GLDNOBR) || (!pktinfo->isBroadcast && !pktinfo->isMulticast))) cmn_err(CE_NOTE, "gld_passon: q: %p mblk: %p minor: %d sap: %x", (void *)gld->gld_qptr->q_next, (void *)mp, gld->gld_minor, gld->gld_sap); #endif /* * Figure out how much of the packet header to throw away. * * RAW streams expect to see the whole packet. * * Other streams expect to see the packet with the MAC header * removed. * * Normal DLPI (non RAW/FAST) streams also want the * DL_UNITDATA_IND M_PROTO message block prepended to the M_DATA. */ if (gld->gld_flags & GLD_RAW) { skiplen = 0; } else { skiplen = pktinfo->macLen; /* skip mac header */ if (gld->gld_ethertype) skiplen += pktinfo->hdrLen; /* skip any extra */ } if (skiplen >= pktinfo->pktLen) { /* * If the interpreter did its job right, then it cannot be * asking us to skip more bytes than are in the packet! * However, there could be zero data bytes left after the * amount to skip. DLPI specifies that passed M_DATA blocks * should contain at least one byte of data, so if we have * none we just drop it. */ ASSERT(!(skiplen > pktinfo->pktLen)); freemsg(mp); return; } /* * Skip over the header(s), taking care to possibly handle message * fragments shorter than the amount we need to skip. Hopefully * the driver will put the entire packet, or at least the entire * header, into a single message block. But we handle it if not. */ while (skiplen >= MBLKL(mp)) { mblk_t *tmp = mp; skiplen -= MBLKL(mp); mp = mp->b_cont; ASSERT(mp != NULL); /* because skiplen < pktinfo->pktLen */ freeb(tmp); } mp->b_rptr += skiplen; /* Add M_PROTO if necessary, and pass upstream */ if (((gld->gld_flags & GLD_FAST) && !pktinfo->isMulticast && !pktinfo->isBroadcast) || (gld->gld_flags & GLD_RAW)) { /* RAW/FAST: just send up the M_DATA */ (*send)(gld->gld_qptr, mp); } else { /* everybody else wants to see a unitdata_ind structure */ mp = gld_addudind(gld, mp, pktinfo); if (mp) (*send)(gld->gld_qptr, mp); /* if it failed, gld_addudind already bumped statistic */ } } /* * gld_addudind(gld, mp, pktinfo) * format a DL_UNITDATA_IND message to be sent upstream to the user */ static mblk_t * gld_addudind(gld_t *gld, mblk_t *mp, pktinfo_t *pktinfo) { gld_mac_info_t *macinfo = gld->gld_mac_info; gld_vlan_t *vlan = (gld_vlan_t *)gld->gld_vlan; dl_unitdata_ind_t *dludindp; mblk_t *nmp; int size; int type; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_addudind(%p, %p, %p)", (void *)gld, (void *)mp, (void *)pktinfo); #endif ASSERT(macinfo != NULL); /* * Allocate the DL_UNITDATA_IND M_PROTO header, if allocation fails * might as well discard since we can't go further */ size = sizeof (dl_unitdata_ind_t) + 2 * (macinfo->gldm_addrlen + abs(macinfo->gldm_saplen)); if ((nmp = allocb(size, BPRI_MED)) == NULL) { freemsg(mp); BUMP(vlan->gldv_stats->glds_gldnorcvbuf, 1); #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_addudind: allocb failed"); #endif return ((mblk_t *)NULL); } DB_TYPE(nmp) = M_PROTO; nmp->b_rptr = nmp->b_datap->db_lim - size; type = (gld->gld_ethertype) ? pktinfo->ethertype : 0; /* * now setup the DL_UNITDATA_IND header * * XXX This looks broken if the saps aren't two bytes. */ dludindp = (dl_unitdata_ind_t *)nmp->b_rptr; dludindp->dl_primitive = DL_UNITDATA_IND; dludindp->dl_src_addr_length = dludindp->dl_dest_addr_length = macinfo->gldm_addrlen + abs(macinfo->gldm_saplen); dludindp->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t); dludindp->dl_src_addr_offset = dludindp->dl_dest_addr_offset + dludindp->dl_dest_addr_length; dludindp->dl_group_address = (pktinfo->isMulticast || pktinfo->isBroadcast); nmp->b_wptr = nmp->b_rptr + dludindp->dl_dest_addr_offset; mac_copy(pktinfo->dhost, nmp->b_wptr, macinfo->gldm_addrlen); nmp->b_wptr += macinfo->gldm_addrlen; ASSERT(macinfo->gldm_saplen == -2); /* XXX following code assumes */ *(ushort_t *)(nmp->b_wptr) = type; nmp->b_wptr += abs(macinfo->gldm_saplen); ASSERT(nmp->b_wptr == nmp->b_rptr + dludindp->dl_src_addr_offset); mac_copy(pktinfo->shost, nmp->b_wptr, macinfo->gldm_addrlen); nmp->b_wptr += macinfo->gldm_addrlen; *(ushort_t *)(nmp->b_wptr) = type; nmp->b_wptr += abs(macinfo->gldm_saplen); if (pktinfo->nosource) dludindp->dl_src_addr_offset = dludindp->dl_src_addr_length = 0; linkb(nmp, mp); return (nmp); } /* ======================================================= */ /* wsrv group: called from wsrv, single threaded per queue */ /* ======================================================= */ /* * We go to some trouble to avoid taking the same lock during normal * transmit processing as we do during normal receive processing. * * Elements of the per-instance macinfo and per-stream gld_t structures * are for the most part protected by the GLDM_LOCK rwlock/mutex. * (Elements of the gld_mac_pvt_t structure are considered part of the * macinfo structure for purposes of this discussion). * * However, it is more complicated than that: * * Elements of the macinfo structure that are set before the macinfo * structure is added to its device list by gld_register(), and never * thereafter modified, are accessed without requiring taking the lock. * A similar rule applies to those elements of the gld_t structure that * are written by gld_open() before the stream is added to any list. * * Most other elements of the macinfo structure may only be read or * written while holding the maclock. * * Most writable elements of the gld_t structure are written only * within the single-threaded domain of wsrv() and subsidiaries. * (This domain includes open/close while qprocs are not on.) * The maclock need not be taken while within that domain * simply to read those elements. Writing to them, even within * that domain, or reading from it outside that domain, requires * holding the maclock. Exception: if the stream is not * presently attached to a PPA, there is no associated macinfo, * and no maclock need be taken. * * The curr_macaddr element of the mac private structure is also * protected by the GLDM_LOCK rwlock/mutex, like most other members * of that structure. However, there are a few instances in the * transmit path where we choose to forgo lock protection when * reading this variable. This is to avoid lock contention between * threads executing the DL_UNITDATA_REQ case and receive threads. * In doing so we will take a small risk or a few corrupted packets * during the short an rare times when someone is changing the interface's * physical address. We consider the small cost in this rare case to be * worth the benefit of reduced lock contention under normal operating * conditions. The risk/cost is small because: * 1. there is no guarantee at this layer of uncorrupted delivery. * 2. the physaddr doesn't change very often - no performance hit. * 3. if the physaddr changes, other stuff is going to be screwed * up for a while anyway, while other sites refigure ARP, etc., * so losing a couple of packets is the least of our worries. * * The list of streams associated with a macinfo is protected by * two locks: the per-macinfo maclock, and the per-major-device * gld_devlock. Both must be held to modify the list, but either * may be held to protect the list during reading/traversing. This * allows independent locking for multiple instances in the receive * path (using macinfo), while facilitating routines that must search * the entire set of streams associated with a major device, such as * gld_findminor(), gld_finddevinfo(), close(). The "nstreams" * macinfo element, and the gld_mac_info gld_t element, are similarly * protected, since they change at exactly the same time macinfo * streams list does. * * The list of macinfo structures associated with a major device * structure is protected by the gld_devlock, as is the per-major * list of Style 2 streams in the DL_UNATTACHED state. * * The list of major devices is kept on a module-global list * gld_device_list, which has its own lock to protect the list. * * When it is necessary to hold more than one lock at a time, they * are acquired in this "outside in" order: * gld_device_list.gld_devlock * glddev->gld_devlock * GLDM_LOCK(macinfo) * * Finally, there are some "volatile" elements of the gld_t structure * used for synchronization between various routines that don't share * the same mutexes. See the routines for details. These are: * gld_xwait between gld_wsrv() and gld_sched() * gld_sched_ran between gld_wsrv() and gld_sched() * gld_in_unbind between gld_wput() and wsrv's gld_unbind() * gld_wput_count between gld_wput() and wsrv's gld_unbind() * gld_in_wsrv between gld_wput() and gld_wsrv() * (used in conjunction with q->q_first) */ /* * gld_ioctl (q, mp) * handles all ioctl requests passed downstream. This routine is * passed a pointer to the message block with the ioctl request in it, and a * pointer to the queue so it can respond to the ioctl request with an ack. */ int gld_ioctl(queue_t *q, mblk_t *mp) { struct iocblk *iocp; gld_t *gld; gld_mac_info_t *macinfo; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_ioctl(%p %p)", (void *)q, (void *)mp); #endif gld = (gld_t *)q->q_ptr; iocp = (struct iocblk *)mp->b_rptr; switch (iocp->ioc_cmd) { case DLIOCRAW: /* raw M_DATA mode */ gld->gld_flags |= GLD_RAW; DB_TYPE(mp) = M_IOCACK; qreply(q, mp); break; case DL_IOC_HDR_INFO: /* fastpath */ if (gld_global_options & GLD_OPT_NO_FASTPATH) { miocnak(q, mp, 0, EINVAL); break; } gld_fastpath(gld, q, mp); break; default: macinfo = gld->gld_mac_info; if (macinfo == NULL || macinfo->gldm_ioctl == NULL) { miocnak(q, mp, 0, EINVAL); break; } GLDM_LOCK(macinfo, RW_WRITER); (void) (*macinfo->gldm_ioctl) (macinfo, q, mp); GLDM_UNLOCK(macinfo); break; } return (0); } /* * Since the rules for "fastpath" mode don't seem to be documented * anywhere, I will describe GLD's rules for fastpath users here: * * Once in this mode you remain there until close. * If you unbind/rebind you should get a new header using DL_IOC_HDR_INFO. * You must be bound (DL_IDLE) to transmit. * There are other rules not listed above. */ static void gld_fastpath(gld_t *gld, queue_t *q, mblk_t *mp) { gld_interface_t *ifp; gld_mac_info_t *macinfo; dl_unitdata_req_t *dludp; mblk_t *nmp; t_scalar_t off, len; uint_t maclen; int error; gld_vlan_t *vlan; if (gld->gld_state != DL_IDLE) { miocnak(q, mp, 0, EINVAL); return; } macinfo = gld->gld_mac_info; ASSERT(macinfo != NULL); maclen = macinfo->gldm_addrlen + abs(macinfo->gldm_saplen); error = miocpullup(mp, sizeof (dl_unitdata_req_t) + maclen); if (error != 0) { miocnak(q, mp, 0, error); return; } dludp = (dl_unitdata_req_t *)mp->b_cont->b_rptr; off = dludp->dl_dest_addr_offset; len = dludp->dl_dest_addr_length; if (dludp->dl_primitive != DL_UNITDATA_REQ || !MBLKIN(mp->b_cont, off, len) || len != maclen) { miocnak(q, mp, 0, EINVAL); return; } /* * We take his fastpath request as a declaration that he will accept * M_DATA messages from us, whether or not we are willing to accept * them from him. This allows us to have fastpath in one direction * (flow upstream) even on media with Source Routing, where we are * unable to provide a fixed MAC header to be prepended to downstream * flowing packets. So we set GLD_FAST whether or not we decide to * allow him to send M_DATA down to us. */ GLDM_LOCK(macinfo, RW_WRITER); gld->gld_flags |= GLD_FAST; vlan = (gld_vlan_t *)gld->gld_vlan; vlan->gldv_ipq_flags &= ~IPQ_DISABLED; GLDM_UNLOCK(macinfo); ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep; /* This will fail for Source Routing media */ /* Also on Ethernet on 802.2 SAPs */ if ((nmp = (*ifp->mkfastpath)(gld, mp)) == NULL) { miocnak(q, mp, 0, ENOMEM); return; } /* * Link new mblk in after the "request" mblks. */ linkb(mp, nmp); miocack(q, mp, msgdsize(mp->b_cont), 0); } /* * gld_cmds (q, mp) * process the DL commands as defined in dlpi.h * note that the primitives return status which is passed back * to the service procedure. If the value is GLDE_RETRY, then * it is assumed that processing must stop and the primitive has * been put back onto the queue. If the value is any other error, * then an error ack is generated by the service procedure. */ static int gld_cmds(queue_t *q, mblk_t *mp) { union DL_primitives *dlp = (union DL_primitives *)mp->b_rptr; gld_t *gld = (gld_t *)(q->q_ptr); int result = DL_BADPRIM; int mblkl = MBLKL(mp); t_uscalar_t dlreq; /* Make sure we have at least dlp->dl_primitive */ if (mblkl < sizeof (dlp->dl_primitive)) return (DL_BADPRIM); dlreq = dlp->dl_primitive; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_cmds(%p, %p):dlp=%p, dlp->dl_primitive=%d", (void *)q, (void *)mp, (void *)dlp, dlreq); #endif switch (dlreq) { case DL_UDQOS_REQ: if (mblkl < DL_UDQOS_REQ_SIZE) break; result = gld_udqos(q, mp); break; case DL_BIND_REQ: if (mblkl < DL_BIND_REQ_SIZE) break; result = gld_bind(q, mp); break; case DL_UNBIND_REQ: if (mblkl < DL_UNBIND_REQ_SIZE) break; result = gld_unbind(q, mp); break; case DL_UNITDATA_REQ: if (mblkl < DL_UNITDATA_REQ_SIZE) break; result = gld_unitdata(q, mp); break; case DL_INFO_REQ: if (mblkl < DL_INFO_REQ_SIZE) break; result = gld_inforeq(q, mp); break; case DL_ATTACH_REQ: if (mblkl < DL_ATTACH_REQ_SIZE) break; if (gld->gld_style == DL_STYLE2) result = gldattach(q, mp); else result = DL_NOTSUPPORTED; break; case DL_DETACH_REQ: if (mblkl < DL_DETACH_REQ_SIZE) break; if (gld->gld_style == DL_STYLE2) result = gldunattach(q, mp); else result = DL_NOTSUPPORTED; break; case DL_ENABMULTI_REQ: if (mblkl < DL_ENABMULTI_REQ_SIZE) break; result = gld_enable_multi(q, mp); break; case DL_DISABMULTI_REQ: if (mblkl < DL_DISABMULTI_REQ_SIZE) break; result = gld_disable_multi(q, mp); break; case DL_PHYS_ADDR_REQ: if (mblkl < DL_PHYS_ADDR_REQ_SIZE) break; result = gld_physaddr(q, mp); break; case DL_SET_PHYS_ADDR_REQ: if (mblkl < DL_SET_PHYS_ADDR_REQ_SIZE) break; result = gld_setaddr(q, mp); break; case DL_PROMISCON_REQ: if (mblkl < DL_PROMISCON_REQ_SIZE) break; result = gld_promisc(q, mp, dlreq, B_TRUE); break; case DL_PROMISCOFF_REQ: if (mblkl < DL_PROMISCOFF_REQ_SIZE) break; result = gld_promisc(q, mp, dlreq, B_FALSE); break; case DL_GET_STATISTICS_REQ: if (mblkl < DL_GET_STATISTICS_REQ_SIZE) break; result = gld_get_statistics(q, mp); break; case DL_CAPABILITY_REQ: if (mblkl < DL_CAPABILITY_REQ_SIZE) break; result = gld_cap(q, mp); break; case DL_NOTIFY_REQ: if (mblkl < DL_NOTIFY_REQ_SIZE) break; result = gld_notify_req(q, mp); break; case DL_XID_REQ: case DL_XID_RES: case DL_TEST_REQ: case DL_TEST_RES: case DL_CONTROL_REQ: case DL_PASSIVE_REQ: result = DL_NOTSUPPORTED; break; default: #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_WARN, "gld_cmds: unknown M_PROTO message: %d", dlreq); #endif result = DL_BADPRIM; } return (result); } static int gld_cap(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; dl_capability_req_t *dlp = (dl_capability_req_t *)mp->b_rptr; if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); if (dlp->dl_sub_length == 0) return (gld_cap_ack(q, mp)); return (gld_cap_enable(q, mp)); } static int gld_cap_ack(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo = gld->gld_mac_info; gld_interface_t *ifp; dl_capability_ack_t *dlap; dl_capability_sub_t *dlsp; size_t size = sizeof (dl_capability_ack_t); size_t subsize = 0; ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep; if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_ANY) subsize += sizeof (dl_capability_sub_t) + sizeof (dl_capab_hcksum_t); if (macinfo->gldm_capabilities & GLD_CAP_ZEROCOPY) subsize += sizeof (dl_capability_sub_t) + sizeof (dl_capab_zerocopy_t); if (macinfo->gldm_options & GLDOPT_MDT) subsize += (sizeof (dl_capability_sub_t) + sizeof (dl_capab_mdt_t)); if ((mp = mexchange(q, mp, size + subsize, M_PROTO, DL_CAPABILITY_ACK)) == NULL) return (GLDE_OK); dlap = (dl_capability_ack_t *)mp->b_rptr; dlap->dl_sub_offset = 0; if ((dlap->dl_sub_length = subsize) != 0) dlap->dl_sub_offset = sizeof (dl_capability_ack_t); dlsp = (dl_capability_sub_t *)&dlap[1]; if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_ANY) { dl_capab_hcksum_t *dlhp = (dl_capab_hcksum_t *)&dlsp[1]; dlsp->dl_cap = DL_CAPAB_HCKSUM; dlsp->dl_length = sizeof (dl_capab_hcksum_t); dlhp->hcksum_version = HCKSUM_VERSION_1; dlhp->hcksum_txflags = 0; if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_PARTIAL) dlhp->hcksum_txflags |= HCKSUM_INET_PARTIAL; if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_FULL_V4) dlhp->hcksum_txflags |= HCKSUM_INET_FULL_V4; if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_FULL_V6) dlhp->hcksum_txflags |= HCKSUM_INET_FULL_V6; if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_IPHDR) dlhp->hcksum_txflags |= HCKSUM_IPHDRCKSUM; dlcapabsetqid(&(dlhp->hcksum_mid), RD(q)); dlsp = (dl_capability_sub_t *)&dlhp[1]; } if (macinfo->gldm_capabilities & GLD_CAP_ZEROCOPY) { dl_capab_zerocopy_t *dlzp = (dl_capab_zerocopy_t *)&dlsp[1]; dlsp->dl_cap = DL_CAPAB_ZEROCOPY; dlsp->dl_length = sizeof (dl_capab_zerocopy_t); dlzp->zerocopy_version = ZEROCOPY_VERSION_1; dlzp->zerocopy_flags = DL_CAPAB_VMSAFE_MEM; dlcapabsetqid(&(dlzp->zerocopy_mid), RD(q)); dlsp = (dl_capability_sub_t *)&dlzp[1]; } if (macinfo->gldm_options & GLDOPT_MDT) { dl_capab_mdt_t *dlmp = (dl_capab_mdt_t *)&dlsp[1]; dlsp->dl_cap = DL_CAPAB_MDT; dlsp->dl_length = sizeof (dl_capab_mdt_t); dlmp->mdt_version = MDT_VERSION_2; dlmp->mdt_max_pld = macinfo->gldm_mdt_segs; dlmp->mdt_span_limit = macinfo->gldm_mdt_sgl; dlcapabsetqid(&dlmp->mdt_mid, OTHERQ(q)); dlmp->mdt_flags = DL_CAPAB_MDT_ENABLE; dlmp->mdt_hdr_head = ifp->hdr_size; dlmp->mdt_hdr_tail = 0; } qreply(q, mp); return (GLDE_OK); } static int gld_cap_enable(queue_t *q, mblk_t *mp) { dl_capability_req_t *dlp; dl_capability_sub_t *dlsp; dl_capab_hcksum_t *dlhp; offset_t off; size_t len; size_t size; offset_t end; dlp = (dl_capability_req_t *)mp->b_rptr; dlp->dl_primitive = DL_CAPABILITY_ACK; off = dlp->dl_sub_offset; len = dlp->dl_sub_length; if (!MBLKIN(mp, off, len)) return (DL_BADPRIM); end = off + len; while (off < end) { dlsp = (dl_capability_sub_t *)(mp->b_rptr + off); size = sizeof (dl_capability_sub_t) + dlsp->dl_length; if (off + size > end) return (DL_BADPRIM); switch (dlsp->dl_cap) { case DL_CAPAB_HCKSUM: dlhp = (dl_capab_hcksum_t *)&dlsp[1]; /* nothing useful we can do with the contents */ dlcapabsetqid(&(dlhp->hcksum_mid), RD(q)); break; default: break; } off += size; } qreply(q, mp); return (GLDE_OK); } /* * Send a copy of the DL_NOTIFY_IND message to each stream that has * requested the specific that the message carries AND is * eligible and ready to receive the notification immediately. * * This routine ignores flow control. Notifications will be sent regardless. * * In all cases, the original message passed in is freed at the end of * the routine. */ static void gld_notify_qs(gld_mac_info_t *macinfo, mblk_t *mp, uint32_t notification) { gld_mac_pvt_t *mac_pvt; gld_vlan_t *vlan; gld_t *gld; mblk_t *nmp; int i; ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; /* * Search all the streams attached to this macinfo looking * for those eligible to receive the present notification. */ for (i = 0; i < VLAN_HASHSZ; i++) { for (vlan = mac_pvt->vlan_hash[i]; vlan != NULL; vlan = vlan->gldv_next) { for (gld = vlan->gldv_str_next; gld != (gld_t *)&vlan->gldv_str_next; gld = gld->gld_next) { ASSERT(gld->gld_qptr != NULL); ASSERT(gld->gld_state == DL_IDLE || gld->gld_state == DL_UNBOUND); ASSERT(gld->gld_mac_info == macinfo); if (gld->gld_flags & GLD_STR_CLOSING) continue; /* not eligible - skip */ if (!(notification & gld->gld_notifications)) continue; /* not wanted - skip */ if ((nmp = dupmsg(mp)) == NULL) continue; /* can't copy - skip */ /* * All OK; send dup'd notification up this * stream */ qreply(WR(gld->gld_qptr), nmp); } } } /* * Drop the original message block now */ freemsg(mp); } /* * For each (understood) bit in the argument, contruct * a DL_NOTIFY_IND message and send it to the specified , or to all * eligible queues if is NULL. */ static void gld_notify_ind(gld_mac_info_t *macinfo, uint32_t notifications, queue_t *q) { gld_mac_pvt_t *mac_pvt; dl_notify_ind_t *dlnip; struct gld_stats *stats; mblk_t *mp; size_t size; uint32_t bit; GLDM_LOCK(macinfo, RW_WRITER); /* * The following cases shouldn't happen, but just in case the * MAC driver calls gld_linkstate() at an inappropriate time, we * check anyway ... */ if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) { GLDM_UNLOCK(macinfo); return; /* not ready yet */ } if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) { GLDM_UNLOCK(macinfo); return; /* not ready anymore */ } /* * Make sure the kstats are up to date, 'cos we use some of * the kstat values below, specifically the link speed ... */ mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; stats = mac_pvt->statistics; if (macinfo->gldm_get_stats) (void) (*macinfo->gldm_get_stats)(macinfo, stats); for (bit = 1; notifications != 0; bit <<= 1) { if ((notifications & bit) == 0) continue; notifications &= ~bit; size = DL_NOTIFY_IND_SIZE; if (bit == DL_NOTE_PHYS_ADDR) size += macinfo->gldm_addrlen; if ((mp = allocb(size, BPRI_MED)) == NULL) continue; mp->b_datap->db_type = M_PROTO; mp->b_wptr = mp->b_rptr + size; dlnip = (dl_notify_ind_t *)mp->b_rptr; dlnip->dl_primitive = DL_NOTIFY_IND; dlnip->dl_notification = 0; dlnip->dl_data = 0; dlnip->dl_addr_length = 0; dlnip->dl_addr_offset = 0; switch (bit) { case DL_NOTE_PROMISC_ON_PHYS: case DL_NOTE_PROMISC_OFF_PHYS: if (mac_pvt->nprom != 0) dlnip->dl_notification = bit; break; case DL_NOTE_LINK_DOWN: if (macinfo->gldm_linkstate == GLD_LINKSTATE_DOWN) dlnip->dl_notification = bit; break; case DL_NOTE_LINK_UP: if (macinfo->gldm_linkstate == GLD_LINKSTATE_UP) dlnip->dl_notification = bit; break; case DL_NOTE_SPEED: /* * Conversion required here: * GLD keeps the speed in bit/s in a uint64 * DLPI wants it in kb/s in a uint32 * Fortunately this is still big enough for 10Gb/s! */ dlnip->dl_notification = bit; dlnip->dl_data = stats->glds_speed/1000ULL; break; case DL_NOTE_PHYS_ADDR: dlnip->dl_notification = bit; dlnip->dl_data = DL_CURR_PHYS_ADDR; dlnip->dl_addr_offset = sizeof (dl_notify_ind_t); dlnip->dl_addr_length = macinfo->gldm_addrlen + abs(macinfo->gldm_saplen); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; mac_copy(mac_pvt->curr_macaddr, mp->b_rptr + sizeof (dl_notify_ind_t), macinfo->gldm_addrlen); break; default: break; } if (dlnip->dl_notification == 0) freemsg(mp); else if (q != NULL) qreply(q, mp); else gld_notify_qs(macinfo, mp, bit); } GLDM_UNLOCK(macinfo); } /* * gld_notify_req - handle a DL_NOTIFY_REQ message */ static int gld_notify_req(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo; gld_mac_pvt_t *pvt; dl_notify_req_t *dlnrp; dl_notify_ack_t *dlnap; ASSERT(gld != NULL); ASSERT(gld->gld_qptr == RD(q)); dlnrp = (dl_notify_req_t *)mp->b_rptr; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_notify_req(%p %p)", (void *)q, (void *)mp); #endif if (gld->gld_state == DL_UNATTACHED) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_notify_req: wrong state (%d)", gld->gld_state); #endif return (DL_OUTSTATE); } /* * Remember what notifications are required by this stream */ macinfo = gld->gld_mac_info; pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; gld->gld_notifications = dlnrp->dl_notifications & pvt->notifications; /* * The return DL_NOTIFY_ACK carries the bitset of notifications * that this driver can provide, independently of which ones have * previously been or are now being requested. */ if ((mp = mexchange(q, mp, sizeof (dl_notify_ack_t), M_PCPROTO, DL_NOTIFY_ACK)) == NULL) return (DL_SYSERR); dlnap = (dl_notify_ack_t *)mp->b_rptr; dlnap->dl_notifications = pvt->notifications; qreply(q, mp); /* * A side effect of a DL_NOTIFY_REQ is that after the DL_NOTIFY_ACK * reply, the the requestor gets zero or more DL_NOTIFY_IND messages * that provide the current status. */ gld_notify_ind(macinfo, gld->gld_notifications, q); return (GLDE_OK); } /* * gld_linkstate() * Called by driver to tell GLD the state of the physical link. * As a side effect, sends a DL_NOTE_LINK_UP or DL_NOTE_LINK_DOWN * notification to each client that has previously requested such * notifications */ void gld_linkstate(gld_mac_info_t *macinfo, int32_t newstate) { uint32_t notification; switch (newstate) { default: return; case GLD_LINKSTATE_DOWN: notification = DL_NOTE_LINK_DOWN; break; case GLD_LINKSTATE_UP: notification = DL_NOTE_LINK_UP | DL_NOTE_SPEED; break; case GLD_LINKSTATE_UNKNOWN: notification = 0; break; } GLDM_LOCK(macinfo, RW_WRITER); if (macinfo->gldm_linkstate == newstate) notification = 0; else macinfo->gldm_linkstate = newstate; GLDM_UNLOCK(macinfo); if (notification) gld_notify_ind(macinfo, notification, NULL); } /* * gld_udqos - set the current QoS parameters (priority only at the moment). */ static int gld_udqos(queue_t *q, mblk_t *mp) { dl_udqos_req_t *dlp; gld_t *gld = (gld_t *)q->q_ptr; int off; int len; dl_qos_cl_sel1_t *selp; ASSERT(gld); ASSERT(gld->gld_qptr == RD(q)); #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_udqos(%p %p)", (void *)q, (void *)mp); #endif if (gld->gld_state != DL_IDLE) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_udqos: wrong state (%d)", gld->gld_state); #endif return (DL_OUTSTATE); } dlp = (dl_udqos_req_t *)mp->b_rptr; off = dlp->dl_qos_offset; len = dlp->dl_qos_length; if (len != sizeof (dl_qos_cl_sel1_t) || !MBLKIN(mp, off, len)) return (DL_BADQOSTYPE); selp = (dl_qos_cl_sel1_t *)(mp->b_rptr + off); if (selp->dl_qos_type != DL_QOS_CL_SEL1) return (DL_BADQOSTYPE); if (selp->dl_trans_delay != 0 && selp->dl_trans_delay != DL_QOS_DONT_CARE) return (DL_BADQOSPARAM); if (selp->dl_protection != 0 && selp->dl_protection != DL_QOS_DONT_CARE) return (DL_BADQOSPARAM); if (selp->dl_residual_error != 0 && selp->dl_residual_error != DL_QOS_DONT_CARE) return (DL_BADQOSPARAM); if (selp->dl_priority < 0 || selp->dl_priority > 7) return (DL_BADQOSPARAM); gld->gld_upri = selp->dl_priority; dlokack(q, mp, DL_UDQOS_REQ); return (GLDE_OK); } static mblk_t * gld_bindack(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo = gld->gld_mac_info; gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; dl_bind_ack_t *dlp; size_t size; t_uscalar_t addrlen; uchar_t *sapp; addrlen = macinfo->gldm_addrlen + abs(macinfo->gldm_saplen); size = sizeof (dl_bind_ack_t) + addrlen; if ((mp = mexchange(q, mp, size, M_PCPROTO, DL_BIND_ACK)) == NULL) return (NULL); dlp = (dl_bind_ack_t *)mp->b_rptr; dlp->dl_sap = gld->gld_sap; dlp->dl_addr_length = addrlen; dlp->dl_addr_offset = sizeof (dl_bind_ack_t); dlp->dl_max_conind = 0; dlp->dl_xidtest_flg = 0; mac_copy(mac_pvt->curr_macaddr, (uchar_t *)&dlp[1], macinfo->gldm_addrlen); sapp = mp->b_rptr + dlp->dl_addr_offset + macinfo->gldm_addrlen; *(ushort_t *)sapp = gld->gld_sap; return (mp); } /* * gld_bind - determine if a SAP is already allocated and whether it is legal * to do the bind at this time */ static int gld_bind(queue_t *q, mblk_t *mp) { ulong_t sap; dl_bind_req_t *dlp; gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo = gld->gld_mac_info; ASSERT(gld); ASSERT(gld->gld_qptr == RD(q)); #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_bind(%p %p)", (void *)q, (void *)mp); #endif dlp = (dl_bind_req_t *)mp->b_rptr; sap = dlp->dl_sap; #ifdef GLD_DEBUG if (gld_debug & GLDPROT) cmn_err(CE_NOTE, "gld_bind: lsap=%lx", sap); #endif if (gld->gld_state != DL_UNBOUND) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_bind: bound or not attached (%d)", gld->gld_state); #endif return (DL_OUTSTATE); } ASSERT(macinfo); if (dlp->dl_service_mode != DL_CLDLS) { return (DL_UNSUPPORTED); } if (dlp->dl_xidtest_flg & (DL_AUTO_XID | DL_AUTO_TEST)) { return (DL_NOAUTO); } /* * Check sap validity and decide whether this stream accepts * IEEE 802.2 (LLC) packets. */ if (sap > ETHERTYPE_MAX) return (DL_BADSAP); /* * Decide whether the SAP value selects EtherType encoding/decoding. * For compatibility with monolithic ethernet drivers, the range of * SAP values is different for DL_ETHER media. */ switch (macinfo->gldm_type) { case DL_ETHER: gld->gld_ethertype = (sap > ETHERMTU); break; default: gld->gld_ethertype = (sap > GLD_MAX_802_SAP); break; } /* if we get to here, then the SAP is legal enough */ GLDM_LOCK(macinfo, RW_WRITER); gld->gld_state = DL_IDLE; /* bound and ready */ gld->gld_sap = sap; gld_set_ipq(gld); #ifdef GLD_DEBUG if (gld_debug & GLDPROT) cmn_err(CE_NOTE, "gld_bind: ok - sap = %d", gld->gld_sap); #endif /* ACK the BIND */ mp = gld_bindack(q, mp); GLDM_UNLOCK(macinfo); if (mp != NULL) { qreply(q, mp); return (GLDE_OK); } return (DL_SYSERR); } /* * gld_unbind - perform an unbind of an LSAP or ether type on the stream. * The stream is still open and can be re-bound. */ static int gld_unbind(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo = gld->gld_mac_info; ASSERT(gld); #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_unbind(%p %p)", (void *)q, (void *)mp); #endif if (gld->gld_state != DL_IDLE) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_unbind: wrong state (%d)", gld->gld_state); #endif return (DL_OUTSTATE); } ASSERT(macinfo); /* * Avoid unbinding (DL_UNBIND_REQ) while FAST/RAW is inside wput. * See comments above gld_start(). */ gld->gld_in_unbind = B_TRUE; /* disallow wput=>start */ membar_enter(); if (gld->gld_wput_count != 0) { gld->gld_in_unbind = B_FALSE; ASSERT(mp); /* we didn't come from close */ #ifdef GLD_DEBUG if (gld_debug & GLDETRACE) cmn_err(CE_NOTE, "gld_unbind: defer for wput"); #endif (void) putbq(q, mp); qenable(q); /* try again soon */ return (GLDE_RETRY); } GLDM_LOCK(macinfo, RW_WRITER); gld->gld_state = DL_UNBOUND; gld->gld_sap = 0; gld_set_ipq(gld); GLDM_UNLOCK(macinfo); membar_exit(); gld->gld_in_unbind = B_FALSE; /* mp is NULL if we came from close */ if (mp) { gld_flushqueue(q); /* flush the queues */ dlokack(q, mp, DL_UNBIND_REQ); } return (GLDE_OK); } /* * gld_inforeq - generate the response to an info request */ static int gld_inforeq(queue_t *q, mblk_t *mp) { gld_t *gld; dl_info_ack_t *dlp; int bufsize; glddev_t *glddev; gld_mac_info_t *macinfo; gld_mac_pvt_t *mac_pvt; int sel_offset = 0; int range_offset = 0; int addr_offset; int addr_length; int sap_length; int brdcst_offset; int brdcst_length; gld_vlan_t *vlan; uchar_t *sapp; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_inforeq(%p %p)", (void *)q, (void *)mp); #endif gld = (gld_t *)q->q_ptr; ASSERT(gld); glddev = gld->gld_device; ASSERT(glddev); if (gld->gld_state == DL_IDLE || gld->gld_state == DL_UNBOUND) { macinfo = gld->gld_mac_info; ASSERT(macinfo != NULL); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; addr_length = macinfo->gldm_addrlen; sap_length = macinfo->gldm_saplen; brdcst_length = macinfo->gldm_addrlen; } else { addr_length = glddev->gld_addrlen; sap_length = glddev->gld_saplen; brdcst_length = glddev->gld_addrlen; } bufsize = sizeof (dl_info_ack_t); addr_offset = bufsize; bufsize += addr_length; bufsize += abs(sap_length); brdcst_offset = bufsize; bufsize += brdcst_length; if ((vlan = (gld_vlan_t *)gld->gld_vlan) != NULL && vlan->gldv_id != VLAN_VID_NONE) { sel_offset = P2ROUNDUP(bufsize, sizeof (int64_t)); bufsize = sel_offset + sizeof (dl_qos_cl_sel1_t); range_offset = P2ROUNDUP(bufsize, sizeof (int64_t)); bufsize = range_offset + sizeof (dl_qos_cl_range1_t); } if ((mp = mexchange(q, mp, bufsize, M_PCPROTO, DL_INFO_ACK)) == NULL) return (GLDE_OK); /* nothing more to be done */ bzero(mp->b_rptr, bufsize); dlp = (dl_info_ack_t *)mp->b_rptr; dlp->dl_primitive = DL_INFO_ACK; dlp->dl_version = DL_VERSION_2; dlp->dl_service_mode = DL_CLDLS; dlp->dl_current_state = gld->gld_state; dlp->dl_provider_style = gld->gld_style; if (sel_offset != 0) { dl_qos_cl_sel1_t *selp; dl_qos_cl_range1_t *rangep; ASSERT(range_offset != 0); dlp->dl_qos_offset = sel_offset; dlp->dl_qos_length = sizeof (dl_qos_cl_sel1_t); dlp->dl_qos_range_offset = range_offset; dlp->dl_qos_range_length = sizeof (dl_qos_cl_range1_t); selp = (dl_qos_cl_sel1_t *)(mp->b_rptr + sel_offset); selp->dl_qos_type = DL_QOS_CL_SEL1; selp->dl_priority = gld->gld_upri; rangep = (dl_qos_cl_range1_t *)(mp->b_rptr + range_offset); rangep->dl_qos_type = DL_QOS_CL_RANGE1; rangep->dl_priority.dl_min = 0; rangep->dl_priority.dl_max = 7; } if (gld->gld_state == DL_IDLE || gld->gld_state == DL_UNBOUND) { dlp->dl_min_sdu = macinfo->gldm_minpkt; dlp->dl_max_sdu = macinfo->gldm_maxpkt; dlp->dl_mac_type = macinfo->gldm_type; dlp->dl_addr_length = addr_length + abs(sap_length); dlp->dl_sap_length = sap_length; if (gld->gld_state == DL_IDLE) { /* * If we are bound to a non-LLC SAP on any medium * other than Ethernet, then we need room for a * SNAP header. So we have to adjust the MTU size * accordingly. XXX I suppose this should be done * in gldutil.c, but it seems likely that this will * always be true for everything GLD supports but * Ethernet. Check this if you add another medium. */ if ((macinfo->gldm_type == DL_TPR || macinfo->gldm_type == DL_FDDI) && gld->gld_ethertype) dlp->dl_max_sdu -= LLC_SNAP_HDR_LEN; /* copy macaddr and sap */ dlp->dl_addr_offset = addr_offset; mac_copy(mac_pvt->curr_macaddr, mp->b_rptr + addr_offset, macinfo->gldm_addrlen); sapp = mp->b_rptr + addr_offset + macinfo->gldm_addrlen; *(ushort_t *)sapp = gld->gld_sap; } else { dlp->dl_addr_offset = 0; } /* copy broadcast addr */ dlp->dl_brdcst_addr_length = macinfo->gldm_addrlen; dlp->dl_brdcst_addr_offset = brdcst_offset; mac_copy((caddr_t)macinfo->gldm_broadcast_addr, mp->b_rptr + brdcst_offset, brdcst_length); } else { /* * No PPA is attached. * The best we can do is use the values provided * by the first mac that called gld_register. */ dlp->dl_min_sdu = glddev->gld_minsdu; dlp->dl_max_sdu = glddev->gld_maxsdu; dlp->dl_mac_type = glddev->gld_type; dlp->dl_addr_length = addr_length + abs(sap_length); dlp->dl_sap_length = sap_length; dlp->dl_addr_offset = 0; dlp->dl_brdcst_addr_offset = brdcst_offset; dlp->dl_brdcst_addr_length = brdcst_length; mac_copy((caddr_t)glddev->gld_broadcast, mp->b_rptr + brdcst_offset, brdcst_length); } qreply(q, mp); return (GLDE_OK); } /* * gld_unitdata (q, mp) * send a datagram. Destination address/lsap is in M_PROTO * message (first mblock), data is in remainder of message. * */ static int gld_unitdata(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr; gld_mac_info_t *macinfo = gld->gld_mac_info; size_t msglen; mblk_t *nmp; gld_interface_t *ifp; uint32_t start; uint32_t stuff; uint32_t end; uint32_t value; uint32_t flags; uint32_t upri; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_unitdata(%p %p)", (void *)q, (void *)mp); #endif if (gld->gld_state != DL_IDLE) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_unitdata: wrong state (%d)", gld->gld_state); #endif dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset, dlp->dl_dest_addr_length, DL_OUTSTATE, 0); return (GLDE_OK); } ASSERT(macinfo != NULL); if (!MBLKIN(mp, dlp->dl_dest_addr_offset, dlp->dl_dest_addr_length) || dlp->dl_dest_addr_length != macinfo->gldm_addrlen + abs(macinfo->gldm_saplen)) { dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset, dlp->dl_dest_addr_length, DL_BADADDR, 0); return (GLDE_OK); } upri = dlp->dl_priority.dl_max; msglen = msgdsize(mp); if (msglen == 0 || msglen > macinfo->gldm_maxpkt) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_unitdata: bad msglen (%d)", (int)msglen); #endif dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset, dlp->dl_dest_addr_length, DL_BADDATA, 0); return (GLDE_OK); } ASSERT(mp->b_cont != NULL); /* because msgdsize(mp) is nonzero */ ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep; /* grab any checksum information that may be present */ hcksum_retrieve(mp->b_cont, NULL, NULL, &start, &stuff, &end, &value, &flags); /* * Prepend a valid header for transmission */ if ((nmp = (*ifp->mkunitdata)(gld, mp)) == NULL) { #ifdef GLD_DEBUG if (gld_debug & GLDERRS) cmn_err(CE_NOTE, "gld_unitdata: mkunitdata failed."); #endif dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset, dlp->dl_dest_addr_length, DL_SYSERR, ENOSR); return (GLDE_OK); } /* apply any checksum information to the first block in the chain */ (void) hcksum_assoc(nmp, NULL, NULL, start, stuff, end, value, flags, 0); if (gld_start(q, nmp, GLD_WSRV, upri) == GLD_NORESOURCES) { qenable(q); return (GLDE_RETRY); } return (GLDE_OK); } /* * gldattach(q, mp) * DLPI DL_ATTACH_REQ * this attaches the stream to a PPA */ static int gldattach(queue_t *q, mblk_t *mp) { dl_attach_req_t *at; gld_mac_info_t *macinfo; gld_t *gld = (gld_t *)q->q_ptr; glddev_t *glddev; gld_mac_pvt_t *mac_pvt; uint32_t ppa; uint32_t vid; gld_vlan_t *vlan; at = (dl_attach_req_t *)mp->b_rptr; if (gld->gld_state != DL_UNATTACHED) return (DL_OUTSTATE); ASSERT(!gld->gld_mac_info); ppa = at->dl_ppa % GLD_VLAN_SCALE; /* 0 .. 999 */ vid = at->dl_ppa / GLD_VLAN_SCALE; /* 0 .. 4094 */ if (vid > VLAN_VID_MAX) return (DL_BADPPA); glddev = gld->gld_device; mutex_enter(&glddev->gld_devlock); for (macinfo = glddev->gld_mac_next; macinfo != (gld_mac_info_t *)&glddev->gld_mac_next; macinfo = macinfo->gldm_next) { int inst; ASSERT(macinfo != NULL); if (macinfo->gldm_ppa != ppa) continue; if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) continue; /* this one's not ready yet */ /* * VLAN sanity check */ if (vid != VLAN_VID_NONE && !VLAN_CAPABLE(macinfo)) { mutex_exit(&glddev->gld_devlock); return (DL_BADPPA); } /* * We found the correct PPA, hold the instance */ inst = ddi_get_instance(macinfo->gldm_devinfo); if (inst == -1 || qassociate(q, inst) != 0) { mutex_exit(&glddev->gld_devlock); return (DL_BADPPA); } /* Take the stream off the per-driver-class list */ gldremque(gld); /* * We must hold the lock to prevent multiple calls * to the reset and start routines. */ GLDM_LOCK(macinfo, RW_WRITER); gld->gld_mac_info = macinfo; if (macinfo->gldm_send_tagged != NULL) gld->gld_send = macinfo->gldm_send_tagged; else gld->gld_send = macinfo->gldm_send; if ((vlan = gld_get_vlan(macinfo, vid)) == NULL) { GLDM_UNLOCK(macinfo); gldinsque(gld, glddev->gld_str_prev); mutex_exit(&glddev->gld_devlock); (void) qassociate(q, -1); return (DL_BADPPA); } mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; if (!mac_pvt->started) { if (gld_start_mac(macinfo) != GLD_SUCCESS) { gld_rem_vlan(vlan); GLDM_UNLOCK(macinfo); gldinsque(gld, glddev->gld_str_prev); mutex_exit(&glddev->gld_devlock); dlerrorack(q, mp, DL_ATTACH_REQ, DL_SYSERR, EIO); (void) qassociate(q, -1); return (GLDE_OK); } } gld->gld_vlan = vlan; vlan->gldv_nstreams++; gldinsque(gld, vlan->gldv_str_prev); gld->gld_state = DL_UNBOUND; GLDM_UNLOCK(macinfo); #ifdef GLD_DEBUG if (gld_debug & GLDPROT) { cmn_err(CE_NOTE, "gldattach(%p, %p, PPA = %d)", (void *)q, (void *)mp, macinfo->gldm_ppa); } #endif mutex_exit(&glddev->gld_devlock); dlokack(q, mp, DL_ATTACH_REQ); return (GLDE_OK); } mutex_exit(&glddev->gld_devlock); return (DL_BADPPA); } /* * gldunattach(q, mp) * DLPI DL_DETACH_REQ * detaches the mac layer from the stream */ int gldunattach(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; glddev_t *glddev = gld->gld_device; gld_mac_info_t *macinfo = gld->gld_mac_info; int state = gld->gld_state; int i; gld_mac_pvt_t *mac_pvt; gld_vlan_t *vlan; boolean_t phys_off; boolean_t mult_off; int op = GLD_MAC_PROMISC_NOOP; if (state != DL_UNBOUND) return (DL_OUTSTATE); ASSERT(macinfo != NULL); ASSERT(gld->gld_sap == 0); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; #ifdef GLD_DEBUG if (gld_debug & GLDPROT) { cmn_err(CE_NOTE, "gldunattach(%p, %p, PPA = %d)", (void *)q, (void *)mp, macinfo->gldm_ppa); } #endif GLDM_LOCK(macinfo, RW_WRITER); if (gld->gld_mcast) { for (i = 0; i < gld->gld_multicnt; i++) { gld_mcast_t *mcast; if ((mcast = gld->gld_mcast[i]) != NULL) { ASSERT(mcast->gldm_refcnt); gld_send_disable_multi(macinfo, mcast); } } kmem_free(gld->gld_mcast, sizeof (gld_mcast_t *) * gld->gld_multicnt); gld->gld_mcast = NULL; gld->gld_multicnt = 0; } /* decide if we need to turn off any promiscuity */ phys_off = (gld->gld_flags & GLD_PROM_PHYS && --mac_pvt->nprom == 0); mult_off = (gld->gld_flags & GLD_PROM_MULT && --mac_pvt->nprom_multi == 0); gld->gld_flags &= ~(GLD_PROM_PHYS | GLD_PROM_SAP | GLD_PROM_MULT); if (phys_off) { op = (mac_pvt->nprom_multi == 0) ? GLD_MAC_PROMISC_NONE : GLD_MAC_PROMISC_MULTI; } else if (mult_off) { op = (mac_pvt->nprom == 0) ? GLD_MAC_PROMISC_NONE : GLD_MAC_PROMISC_NOOP; /* phys overrides multi */ } if (op != GLD_MAC_PROMISC_NOOP) (void) (*macinfo->gldm_set_promiscuous)(macinfo, op); GLDM_UNLOCK(macinfo); if (phys_off) gld_notify_ind(macinfo, DL_NOTE_PROMISC_OFF_PHYS, NULL); /* * We need to hold both locks when modifying the mac stream list * to protect findminor as well as everyone else. */ mutex_enter(&glddev->gld_devlock); GLDM_LOCK(macinfo, RW_WRITER); /* disassociate this stream with its vlan and underlying mac */ gldremque(gld); vlan = (gld_vlan_t *)gld->gld_vlan; if (--vlan->gldv_nstreams == 0) { gld_rem_vlan(vlan); gld->gld_vlan = NULL; } gld->gld_mac_info = NULL; gld->gld_state = DL_UNATTACHED; /* cleanup mac layer if last vlan */ if (mac_pvt->nvlan == 0) { gld_stop_mac(macinfo); macinfo->gldm_GLD_flags &= ~GLD_INTR_WAIT; } /* make sure no references to this gld for gld_v0_sched */ if (mac_pvt->last_sched == gld) mac_pvt->last_sched = NULL; GLDM_UNLOCK(macinfo); /* put the stream on the unattached Style 2 list */ gldinsque(gld, glddev->gld_str_prev); mutex_exit(&glddev->gld_devlock); /* There will be no mp if we were called from close */ if (mp) { dlokack(q, mp, DL_DETACH_REQ); } if (gld->gld_style == DL_STYLE2) (void) qassociate(q, -1); return (GLDE_OK); } /* * gld_enable_multi (q, mp) * Enables multicast address on the stream. If the mac layer * isn't enabled for this address, enable at that level as well. */ static int gld_enable_multi(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; glddev_t *glddev; gld_mac_info_t *macinfo = gld->gld_mac_info; unsigned char *maddr; dl_enabmulti_req_t *multi; gld_mcast_t *mcast; int i, rc; gld_mac_pvt_t *mac_pvt; #ifdef GLD_DEBUG if (gld_debug & GLDPROT) { cmn_err(CE_NOTE, "gld_enable_multi(%p, %p)", (void *)q, (void *)mp); } #endif if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); ASSERT(macinfo != NULL); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; if (macinfo->gldm_set_multicast == NULL) { return (DL_UNSUPPORTED); } multi = (dl_enabmulti_req_t *)mp->b_rptr; if (!MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length) || multi->dl_addr_length != macinfo->gldm_addrlen) return (DL_BADADDR); /* request appears to be valid */ glddev = mac_pvt->major_dev; ASSERT(glddev == gld->gld_device); maddr = mp->b_rptr + multi->dl_addr_offset; /* * The multicast addresses live in a per-device table, along * with a reference count. Each stream has a table that * points to entries in the device table, with the reference * count reflecting the number of streams pointing at it. If * this multicast address is already in the per-device table, * all we have to do is point at it. */ GLDM_LOCK(macinfo, RW_WRITER); /* does this address appear in current table? */ if (gld->gld_mcast == NULL) { /* no mcast addresses -- allocate table */ gld->gld_mcast = GETSTRUCT(gld_mcast_t *, glddev->gld_multisize); if (gld->gld_mcast == NULL) { GLDM_UNLOCK(macinfo); dlerrorack(q, mp, DL_ENABMULTI_REQ, DL_SYSERR, ENOSR); return (GLDE_OK); } gld->gld_multicnt = glddev->gld_multisize; } else { for (i = 0; i < gld->gld_multicnt; i++) { if (gld->gld_mcast[i] && mac_eq(gld->gld_mcast[i]->gldm_addr, maddr, macinfo->gldm_addrlen)) { /* this is a match -- just succeed */ ASSERT(gld->gld_mcast[i]->gldm_refcnt); GLDM_UNLOCK(macinfo); dlokack(q, mp, DL_ENABMULTI_REQ); return (GLDE_OK); } } } /* * it wasn't in the stream so check to see if the mac layer has it */ mcast = NULL; if (mac_pvt->mcast_table == NULL) { mac_pvt->mcast_table = GETSTRUCT(gld_mcast_t, glddev->gld_multisize); if (mac_pvt->mcast_table == NULL) { GLDM_UNLOCK(macinfo); dlerrorack(q, mp, DL_ENABMULTI_REQ, DL_SYSERR, ENOSR); return (GLDE_OK); } } else { for (i = 0; i < glddev->gld_multisize; i++) { if (mac_pvt->mcast_table[i].gldm_refcnt && mac_eq(mac_pvt->mcast_table[i].gldm_addr, maddr, macinfo->gldm_addrlen)) { mcast = &mac_pvt->mcast_table[i]; break; } } } if (mcast == NULL) { /* not in mac layer -- find an empty mac slot to fill in */ for (i = 0; i < glddev->gld_multisize; i++) { if (mac_pvt->mcast_table[i].gldm_refcnt == 0) { mcast = &mac_pvt->mcast_table[i]; mac_copy(maddr, mcast->gldm_addr, macinfo->gldm_addrlen); break; } } } if (mcast == NULL) { /* couldn't get a mac layer slot */ GLDM_UNLOCK(macinfo); return (DL_TOOMANY); } /* now we have a mac layer slot in mcast -- get a stream slot */ for (i = 0; i < gld->gld_multicnt; i++) { if (gld->gld_mcast[i] != NULL) continue; /* found an empty slot */ if (!mcast->gldm_refcnt) { /* set mcast in hardware */ unsigned char cmaddr[GLD_MAX_ADDRLEN]; ASSERT(sizeof (cmaddr) >= macinfo->gldm_addrlen); cmac_copy(maddr, cmaddr, macinfo->gldm_addrlen, macinfo); rc = (*macinfo->gldm_set_multicast) (macinfo, cmaddr, GLD_MULTI_ENABLE); if (rc == GLD_NOTSUPPORTED) { GLDM_UNLOCK(macinfo); return (DL_NOTSUPPORTED); } else if (rc == GLD_NORESOURCES) { GLDM_UNLOCK(macinfo); return (DL_TOOMANY); } else if (rc == GLD_BADARG) { GLDM_UNLOCK(macinfo); return (DL_BADADDR); } else if (rc == GLD_RETRY) { /* * The putbq and gld_xwait must be * within the lock to prevent races * with gld_sched. */ (void) putbq(q, mp); gld->gld_xwait = B_TRUE; GLDM_UNLOCK(macinfo); return (GLDE_RETRY); } else if (rc != GLD_SUCCESS) { GLDM_UNLOCK(macinfo); dlerrorack(q, mp, DL_ENABMULTI_REQ, DL_SYSERR, EIO); return (GLDE_OK); } } gld->gld_mcast[i] = mcast; mcast->gldm_refcnt++; GLDM_UNLOCK(macinfo); dlokack(q, mp, DL_ENABMULTI_REQ); return (GLDE_OK); } /* couldn't get a stream slot */ GLDM_UNLOCK(macinfo); return (DL_TOOMANY); } /* * gld_disable_multi (q, mp) * Disable the multicast address on the stream. If last * reference for the mac layer, disable there as well. */ static int gld_disable_multi(queue_t *q, mblk_t *mp) { gld_t *gld; gld_mac_info_t *macinfo; unsigned char *maddr; dl_disabmulti_req_t *multi; int i; gld_mcast_t *mcast; #ifdef GLD_DEBUG if (gld_debug & GLDPROT) { cmn_err(CE_NOTE, "gld_disable_multi(%p, %p)", (void *)q, (void *)mp); } #endif gld = (gld_t *)q->q_ptr; if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); macinfo = gld->gld_mac_info; ASSERT(macinfo != NULL); if (macinfo->gldm_set_multicast == NULL) { return (DL_UNSUPPORTED); } multi = (dl_disabmulti_req_t *)mp->b_rptr; if (!MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length) || multi->dl_addr_length != macinfo->gldm_addrlen) return (DL_BADADDR); maddr = mp->b_rptr + multi->dl_addr_offset; /* request appears to be valid */ /* does this address appear in current table? */ GLDM_LOCK(macinfo, RW_WRITER); if (gld->gld_mcast != NULL) { for (i = 0; i < gld->gld_multicnt; i++) if (((mcast = gld->gld_mcast[i]) != NULL) && mac_eq(mcast->gldm_addr, maddr, macinfo->gldm_addrlen)) { ASSERT(mcast->gldm_refcnt); gld_send_disable_multi(macinfo, mcast); gld->gld_mcast[i] = NULL; GLDM_UNLOCK(macinfo); dlokack(q, mp, DL_DISABMULTI_REQ); return (GLDE_OK); } } GLDM_UNLOCK(macinfo); return (DL_NOTENAB); /* not an enabled address */ } /* * gld_send_disable_multi(macinfo, mcast) * this function is used to disable a multicast address if the reference * count goes to zero. The disable request will then be forwarded to the * lower stream. */ static void gld_send_disable_multi(gld_mac_info_t *macinfo, gld_mcast_t *mcast) { ASSERT(macinfo != NULL); ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); ASSERT(mcast != NULL); ASSERT(mcast->gldm_refcnt); if (!mcast->gldm_refcnt) { return; /* "cannot happen" */ } if (--mcast->gldm_refcnt > 0) { return; } /* * This must be converted from canonical form to device form. * The refcnt is now zero so we can trash the data. */ if (macinfo->gldm_options & GLDOPT_CANONICAL_ADDR) gld_bitreverse(mcast->gldm_addr, macinfo->gldm_addrlen); /* XXX Ought to check for GLD_NORESOURCES or GLD_FAILURE */ (void) (*macinfo->gldm_set_multicast) (macinfo, mcast->gldm_addr, GLD_MULTI_DISABLE); } /* * gld_promisc (q, mp, req, on) * enable or disable the use of promiscuous mode with the hardware */ static int gld_promisc(queue_t *q, mblk_t *mp, t_uscalar_t req, boolean_t on) { gld_t *gld; gld_mac_info_t *macinfo; gld_mac_pvt_t *mac_pvt; gld_vlan_t *vlan; union DL_primitives *prim; int macrc = GLD_SUCCESS; int dlerr = GLDE_OK; int op = GLD_MAC_PROMISC_NOOP; #ifdef GLD_DEBUG if (gld_debug & GLDTRACE) cmn_err(CE_NOTE, "gld_promisc(%p, %p, %d, %d)", (void *)q, (void *)mp, req, on); #endif ASSERT(mp != NULL); prim = (union DL_primitives *)mp->b_rptr; /* XXX I think spec allows promisc in unattached state */ gld = (gld_t *)q->q_ptr; if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); macinfo = gld->gld_mac_info; ASSERT(macinfo != NULL); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; vlan = (gld_vlan_t *)gld->gld_vlan; ASSERT(vlan != NULL); GLDM_LOCK(macinfo, RW_WRITER); /* * Work out what request (if any) has to be made to the MAC layer */ if (on) { switch (prim->promiscon_req.dl_level) { default: dlerr = DL_UNSUPPORTED; /* this is an error */ break; case DL_PROMISC_PHYS: if (mac_pvt->nprom == 0) op = GLD_MAC_PROMISC_PHYS; break; case DL_PROMISC_MULTI: if (mac_pvt->nprom_multi == 0) if (mac_pvt->nprom == 0) op = GLD_MAC_PROMISC_MULTI; break; case DL_PROMISC_SAP: /* We can do this without reference to the MAC */ break; } } else { switch (prim->promiscoff_req.dl_level) { default: dlerr = DL_UNSUPPORTED; /* this is an error */ break; case DL_PROMISC_PHYS: if (!(gld->gld_flags & GLD_PROM_PHYS)) dlerr = DL_NOTENAB; else if (mac_pvt->nprom == 1) if (mac_pvt->nprom_multi) op = GLD_MAC_PROMISC_MULTI; else op = GLD_MAC_PROMISC_NONE; break; case DL_PROMISC_MULTI: if (!(gld->gld_flags & GLD_PROM_MULT)) dlerr = DL_NOTENAB; else if (mac_pvt->nprom_multi == 1) if (mac_pvt->nprom == 0) op = GLD_MAC_PROMISC_NONE; break; case DL_PROMISC_SAP: if (!(gld->gld_flags & GLD_PROM_SAP)) dlerr = DL_NOTENAB; /* We can do this without reference to the MAC */ break; } } /* * The request was invalid in some way so no need to continue. */ if (dlerr != GLDE_OK) { GLDM_UNLOCK(macinfo); return (dlerr); } /* * Issue the request to the MAC layer, if required */ if (op != GLD_MAC_PROMISC_NOOP) { macrc = (*macinfo->gldm_set_promiscuous)(macinfo, op); } /* * On success, update the appropriate flags & refcounts */ if (macrc == GLD_SUCCESS) { if (on) { switch (prim->promiscon_req.dl_level) { case DL_PROMISC_PHYS: mac_pvt->nprom++; gld->gld_flags |= GLD_PROM_PHYS; break; case DL_PROMISC_MULTI: mac_pvt->nprom_multi++; gld->gld_flags |= GLD_PROM_MULT; break; case DL_PROMISC_SAP: gld->gld_flags |= GLD_PROM_SAP; break; default: break; } } else { switch (prim->promiscoff_req.dl_level) { case DL_PROMISC_PHYS: mac_pvt->nprom--; gld->gld_flags &= ~GLD_PROM_PHYS; break; case DL_PROMISC_MULTI: mac_pvt->nprom_multi--; gld->gld_flags &= ~GLD_PROM_MULT; break; case DL_PROMISC_SAP: gld->gld_flags &= ~GLD_PROM_SAP; break; default: break; } } } else if (macrc == GLD_RETRY) { /* * The putbq and gld_xwait must be within the lock to * prevent races with gld_sched. */ (void) putbq(q, mp); gld->gld_xwait = B_TRUE; } /* * Update VLAN IPQ status -- it may have changed */ if (gld->gld_flags & (GLD_PROM_SAP | GLD_PROM_MULT | GLD_PROM_PHYS)) vlan->gldv_ipq_flags |= IPQ_FORBIDDEN; else vlan->gldv_ipq_flags &= ~IPQ_FORBIDDEN; GLDM_UNLOCK(macinfo); /* * Finally, decide how to reply. * * If is not GLD_SUCCESS, the request was put to the MAC * layer but failed. In such cases, we can return a DL_* error * code and let the caller send an error-ack reply upstream, or * we can send a reply here and then return GLDE_OK so that the * caller doesn't also respond. * * If physical-promiscuous mode was (successfully) switched on or * off, send a notification (DL_NOTIFY_IND) to anyone interested. */ switch (macrc) { case GLD_NOTSUPPORTED: return (DL_NOTSUPPORTED); case GLD_NORESOURCES: dlerrorack(q, mp, req, DL_SYSERR, ENOSR); return (GLDE_OK); case GLD_RETRY: return (GLDE_RETRY); default: dlerrorack(q, mp, req, DL_SYSERR, EIO); return (GLDE_OK); case GLD_SUCCESS: dlokack(q, mp, req); break; } switch (op) { case GLD_MAC_PROMISC_NOOP: break; case GLD_MAC_PROMISC_PHYS: gld_notify_ind(macinfo, DL_NOTE_PROMISC_ON_PHYS, NULL); break; default: gld_notify_ind(macinfo, DL_NOTE_PROMISC_OFF_PHYS, NULL); break; } return (GLDE_OK); } /* * gld_physaddr() * get the current or factory physical address value */ static int gld_physaddr(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo; union DL_primitives *prim = (union DL_primitives *)mp->b_rptr; unsigned char addr[GLD_MAX_ADDRLEN]; if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); macinfo = (gld_mac_info_t *)gld->gld_mac_info; ASSERT(macinfo != NULL); ASSERT(macinfo->gldm_addrlen <= GLD_MAX_ADDRLEN); switch (prim->physaddr_req.dl_addr_type) { case DL_FACT_PHYS_ADDR: mac_copy((caddr_t)macinfo->gldm_vendor_addr, (caddr_t)addr, macinfo->gldm_addrlen); break; case DL_CURR_PHYS_ADDR: /* make a copy so we don't hold the lock across qreply */ GLDM_LOCK(macinfo, RW_WRITER); mac_copy((caddr_t) ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr, (caddr_t)addr, macinfo->gldm_addrlen); GLDM_UNLOCK(macinfo); break; default: return (DL_BADPRIM); } dlphysaddrack(q, mp, (caddr_t)addr, macinfo->gldm_addrlen); return (GLDE_OK); } /* * gld_setaddr() * change the hardware's physical address to a user specified value */ static int gld_setaddr(queue_t *q, mblk_t *mp) { gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo; gld_mac_pvt_t *mac_pvt; union DL_primitives *prim = (union DL_primitives *)mp->b_rptr; unsigned char *addr; unsigned char cmaddr[GLD_MAX_ADDRLEN]; int rc; gld_vlan_t *vlan; if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); vlan = (gld_vlan_t *)gld->gld_vlan; ASSERT(vlan != NULL); if (vlan->gldv_id != VLAN_VID_NONE) return (DL_NOTSUPPORTED); macinfo = (gld_mac_info_t *)gld->gld_mac_info; ASSERT(macinfo != NULL); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; if (!MBLKIN(mp, prim->set_physaddr_req.dl_addr_offset, prim->set_physaddr_req.dl_addr_length) || prim->set_physaddr_req.dl_addr_length != macinfo->gldm_addrlen) return (DL_BADADDR); GLDM_LOCK(macinfo, RW_WRITER); /* now do the set at the hardware level */ addr = mp->b_rptr + prim->set_physaddr_req.dl_addr_offset; ASSERT(sizeof (cmaddr) >= macinfo->gldm_addrlen); cmac_copy(addr, cmaddr, macinfo->gldm_addrlen, macinfo); rc = (*macinfo->gldm_set_mac_addr)(macinfo, cmaddr); if (rc == GLD_SUCCESS) mac_copy(addr, mac_pvt->curr_macaddr, macinfo->gldm_addrlen); GLDM_UNLOCK(macinfo); switch (rc) { case GLD_SUCCESS: break; case GLD_NOTSUPPORTED: return (DL_NOTSUPPORTED); case GLD_BADARG: return (DL_BADADDR); case GLD_NORESOURCES: dlerrorack(q, mp, DL_SET_PHYS_ADDR_REQ, DL_SYSERR, ENOSR); return (GLDE_OK); default: dlerrorack(q, mp, DL_SET_PHYS_ADDR_REQ, DL_SYSERR, EIO); return (GLDE_OK); } gld_notify_ind(macinfo, DL_NOTE_PHYS_ADDR, NULL); dlokack(q, mp, DL_SET_PHYS_ADDR_REQ); return (GLDE_OK); } int gld_get_statistics(queue_t *q, mblk_t *mp) { dl_get_statistics_ack_t *dlsp; gld_t *gld = (gld_t *)q->q_ptr; gld_mac_info_t *macinfo = gld->gld_mac_info; gld_mac_pvt_t *mac_pvt; if (gld->gld_state == DL_UNATTACHED) return (DL_OUTSTATE); ASSERT(macinfo != NULL); mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; (void) gld_update_kstat(mac_pvt->kstatp, KSTAT_READ); mp = mexchange(q, mp, DL_GET_STATISTICS_ACK_SIZE + sizeof (struct gldkstats), M_PCPROTO, DL_GET_STATISTICS_ACK); if (mp == NULL) return (GLDE_OK); /* mexchange already sent merror */ dlsp = (dl_get_statistics_ack_t *)mp->b_rptr; dlsp->dl_primitive = DL_GET_STATISTICS_ACK; dlsp->dl_stat_length = sizeof (struct gldkstats); dlsp->dl_stat_offset = DL_GET_STATISTICS_ACK_SIZE; GLDM_LOCK(macinfo, RW_WRITER); bcopy(mac_pvt->kstatp->ks_data, (mp->b_rptr + DL_GET_STATISTICS_ACK_SIZE), sizeof (struct gldkstats)); GLDM_UNLOCK(macinfo); qreply(q, mp); return (GLDE_OK); } /* =================================================== */ /* misc utilities, some requiring various mutexes held */ /* =================================================== */ /* * Initialize and start the driver. */ static int gld_start_mac(gld_mac_info_t *macinfo) { int rc; unsigned char cmaddr[GLD_MAX_ADDRLEN]; gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); ASSERT(!mac_pvt->started); rc = (*macinfo->gldm_reset)(macinfo); if (rc != GLD_SUCCESS) return (GLD_FAILURE); /* set the addr after we reset the device */ ASSERT(sizeof (cmaddr) >= macinfo->gldm_addrlen); cmac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt) ->curr_macaddr, cmaddr, macinfo->gldm_addrlen, macinfo); rc = (*macinfo->gldm_set_mac_addr)(macinfo, cmaddr); ASSERT(rc != GLD_BADARG); /* this address was good before */ if (rc != GLD_SUCCESS && rc != GLD_NOTSUPPORTED) return (GLD_FAILURE); rc = (*macinfo->gldm_start)(macinfo); if (rc != GLD_SUCCESS) return (GLD_FAILURE); mac_pvt->started = B_TRUE; return (GLD_SUCCESS); } /* * Stop the driver. */ static void gld_stop_mac(gld_mac_info_t *macinfo) { gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); ASSERT(mac_pvt->started); (void) (*macinfo->gldm_stop)(macinfo); mac_pvt->started = B_FALSE; } /* * gld_set_ipq will set a pointer to the queue which is bound to the * IP sap if: * o the device type is ethernet or IPoIB. * o there is no stream in SAP promiscuous mode. * o there is exactly one stream bound to the IP sap. * o the stream is in "fastpath" mode. */ static void gld_set_ipq(gld_t *gld) { gld_vlan_t *vlan; gld_mac_info_t *macinfo = gld->gld_mac_info; gld_t *ip_gld = NULL; uint_t ipq_candidates = 0; gld_t *ipv6_gld = NULL; uint_t ipv6q_candidates = 0; ASSERT(GLDM_LOCK_HELD_WRITE(macinfo)); /* The ipq code in gld_recv() is intimate with ethernet/IPoIB */ if (((macinfo->gldm_type != DL_ETHER) && (macinfo->gldm_type != DL_IB)) || (gld_global_options & GLD_OPT_NO_IPQ)) return; vlan = (gld_vlan_t *)gld->gld_vlan; ASSERT(vlan != NULL); /* clear down any previously defined ipqs */ vlan->gldv_ipq = NULL; vlan->gldv_ipv6q = NULL; /* Try to find a single stream eligible to receive IP packets */ for (gld = vlan->gldv_str_next; gld != (gld_t *)&vlan->gldv_str_next; gld = gld->gld_next) { if (gld->gld_state != DL_IDLE) continue; /* not eligible to receive */ if (gld->gld_flags & GLD_STR_CLOSING) continue; /* not eligible to receive */ if (gld->gld_sap == ETHERTYPE_IP) { ip_gld = gld; ipq_candidates++; } if (gld->gld_sap == ETHERTYPE_IPV6) { ipv6_gld = gld; ipv6q_candidates++; } } if (ipq_candidates == 1) { ASSERT(ip_gld != NULL); if (ip_gld->gld_flags & GLD_FAST) /* eligible for ipq */ vlan->gldv_ipq = ip_gld->gld_qptr; } if (ipv6q_candidates == 1) { ASSERT(ipv6_gld != NULL); if (ipv6_gld->gld_flags & GLD_FAST) /* eligible for ipq */ vlan->gldv_ipv6q = ipv6_gld->gld_qptr; } } /* * gld_flushqueue (q) * used by DLPI primitives that require flushing the queues. * essentially, this is DL_UNBIND_REQ. */ static void gld_flushqueue(queue_t *q) { /* flush all data in both queues */ /* XXX Should these be FLUSHALL? */ flushq(q, FLUSHDATA); flushq(WR(q), FLUSHDATA); /* flush all the queues upstream */ (void) putctl1(q, M_FLUSH, FLUSHRW); } /* * gld_devlookup (major) * search the device table for the device with specified * major number and return a pointer to it if it exists */ static glddev_t * gld_devlookup(int major) { struct glddevice *dev; ASSERT(mutex_owned(&gld_device_list.gld_devlock)); for (dev = gld_device_list.gld_next; dev != &gld_device_list; dev = dev->gld_next) { ASSERT(dev); if (dev->gld_major == major) return (dev); } return (NULL); } /* * gld_findminor(device) * Returns a minor number currently unused by any stream in the current * device class (major) list. */ static int gld_findminor(glddev_t *device) { gld_t *next; gld_mac_info_t *nextmac; gld_vlan_t *nextvlan; int minor; int i; ASSERT(mutex_owned(&device->gld_devlock)); /* The fast way */ if (device->gld_nextminor >= GLD_MIN_CLONE_MINOR && device->gld_nextminor <= GLD_MAX_CLONE_MINOR) return (device->gld_nextminor++); /* The steady way */ for (minor = GLD_MIN_CLONE_MINOR; minor <= GLD_MAX_CLONE_MINOR; minor++) { /* Search all unattached streams */ for (next = device->gld_str_next; next != (gld_t *)&device->gld_str_next; next = next->gld_next) { if (minor == next->gld_minor) goto nextminor; } /* Search all attached streams; we don't need maclock because */ /* mac stream list is protected by devlock as well as maclock */ for (nextmac = device->gld_mac_next; nextmac != (gld_mac_info_t *)&device->gld_mac_next; nextmac = nextmac->gldm_next) { gld_mac_pvt_t *pvt = (gld_mac_pvt_t *)nextmac->gldm_mac_pvt; if (!(nextmac->gldm_GLD_flags & GLD_MAC_READY)) continue; /* this one's not ready yet */ for (i = 0; i < VLAN_HASHSZ; i++) { for (nextvlan = pvt->vlan_hash[i]; nextvlan != NULL; nextvlan = nextvlan->gldv_next) { for (next = nextvlan->gldv_str_next; next != (gld_t *)&nextvlan->gldv_str_next; next = next->gld_next) { if (minor == next->gld_minor) goto nextminor; } } } } return (minor); nextminor: /* don't need to do anything */ ; } cmn_err(CE_WARN, "GLD ran out of minor numbers for %s", device->gld_name); return (0); } /* * version of insque/remque for use by this driver */ struct qelem { struct qelem *q_forw; struct qelem *q_back; /* rest of structure */ }; static void gldinsque(void *elem, void *pred) { struct qelem *pelem = elem; struct qelem *ppred = pred; struct qelem *pnext = ppred->q_forw; pelem->q_forw = pnext; pelem->q_back = ppred; ppred->q_forw = pelem; pnext->q_back = pelem; } static void gldremque(void *arg) { struct qelem *pelem = arg; struct qelem *elem = arg; pelem->q_forw->q_back = pelem->q_back; pelem->q_back->q_forw = pelem->q_forw; elem->q_back = elem->q_forw = NULL; } static gld_vlan_t * gld_add_vlan(gld_mac_info_t *macinfo, uint32_t vid) { gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; gld_vlan_t **pp; gld_vlan_t *p; pp = &(mac_pvt->vlan_hash[vid % VLAN_HASHSZ]); while ((p = *pp) != NULL) { ASSERT(p->gldv_id != vid); pp = &(p->gldv_next); } if ((p = kmem_zalloc(sizeof (gld_vlan_t), KM_NOSLEEP)) == NULL) return (NULL); p->gldv_mac = macinfo; p->gldv_id = vid; if (vid == VLAN_VID_NONE) { p->gldv_ptag = VLAN_VTAG_NONE; p->gldv_stats = mac_pvt->statistics; p->gldv_kstatp = NULL; } else { p->gldv_ptag = GLD_MK_PTAG(VLAN_CFI_ETHER, vid); p->gldv_stats = kmem_zalloc(sizeof (struct gld_stats), KM_SLEEP); if (gld_init_vlan_stats(p) != GLD_SUCCESS) { kmem_free(p->gldv_stats, sizeof (struct gld_stats)); kmem_free(p, sizeof (gld_vlan_t)); return (NULL); } } p->gldv_str_next = p->gldv_str_prev = (gld_t *)&p->gldv_str_next; mac_pvt->nvlan++; *pp = p; return (p); } static void gld_rem_vlan(gld_vlan_t *vlan) { gld_mac_info_t *macinfo = vlan->gldv_mac; gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; gld_vlan_t **pp; gld_vlan_t *p; pp = &(mac_pvt->vlan_hash[vlan->gldv_id % VLAN_HASHSZ]); while ((p = *pp) != NULL) { if (p->gldv_id == vlan->gldv_id) break; pp = &(p->gldv_next); } ASSERT(p != NULL); *pp = p->gldv_next; mac_pvt->nvlan--; if (p->gldv_id != VLAN_VID_NONE) { ASSERT(p->gldv_kstatp != NULL); kstat_delete(p->gldv_kstatp); kmem_free(p->gldv_stats, sizeof (struct gld_stats)); } kmem_free(p, sizeof (gld_vlan_t)); } gld_vlan_t * gld_find_vlan(gld_mac_info_t *macinfo, uint32_t vid) { gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt; gld_vlan_t *p; p = mac_pvt->vlan_hash[vid % VLAN_HASHSZ]; while (p != NULL) { if (p->gldv_id == vid) return (p); p = p->gldv_next; } return (NULL); } gld_vlan_t * gld_get_vlan(gld_mac_info_t *macinfo, uint32_t vid) { gld_vlan_t *vlan; if ((vlan = gld_find_vlan(macinfo, vid)) == NULL) vlan = gld_add_vlan(macinfo, vid); return (vlan); } /* * gld_bitrevcopy() * This is essentially bcopy, with the ability to bit reverse the * the source bytes. The MAC addresses bytes as transmitted by FDDI * interfaces are bit reversed. */ void gld_bitrevcopy(caddr_t src, caddr_t target, size_t n) { while (n--) *target++ = bit_rev[(uchar_t)*src++]; } /* * gld_bitreverse() * Convert the bit order by swaping all the bits, using a * lookup table. */ void gld_bitreverse(uchar_t *rptr, size_t n) { while (n--) { *rptr = bit_rev[*rptr]; rptr++; } } char * gld_macaddr_sprintf(char *etherbuf, unsigned char *ap, int len) { int i; char *cp = etherbuf; static char digits[] = "0123456789abcdef"; for (i = 0; i < len; i++) { *cp++ = digits[*ap >> 4]; *cp++ = digits[*ap++ & 0xf]; *cp++ = ':'; } *--cp = 0; return (etherbuf); } #ifdef GLD_DEBUG static void gld_check_assertions() { glddev_t *dev; gld_mac_info_t *mac; gld_t *str; gld_vlan_t *vlan; int i; mutex_enter(&gld_device_list.gld_devlock); for (dev = gld_device_list.gld_next; dev != (glddev_t *)&gld_device_list.gld_next; dev = dev->gld_next) { mutex_enter(&dev->gld_devlock); ASSERT(dev->gld_broadcast != NULL); for (str = dev->gld_str_next; str != (gld_t *)&dev->gld_str_next; str = str->gld_next) { ASSERT(str->gld_device == dev); ASSERT(str->gld_mac_info == NULL); ASSERT(str->gld_qptr != NULL); ASSERT(str->gld_minor >= GLD_MIN_CLONE_MINOR); ASSERT(str->gld_multicnt == 0); ASSERT(str->gld_mcast == NULL); ASSERT(!(str->gld_flags & (GLD_PROM_PHYS|GLD_PROM_MULT|GLD_PROM_SAP))); ASSERT(str->gld_sap == 0); ASSERT(str->gld_state == DL_UNATTACHED); } for (mac = dev->gld_mac_next; mac != (gld_mac_info_t *)&dev->gld_mac_next; mac = mac->gldm_next) { int nvlan = 0; gld_mac_pvt_t *pvt = (gld_mac_pvt_t *)mac->gldm_mac_pvt; if (!(mac->gldm_GLD_flags & GLD_MAC_READY)) continue; /* this one's not ready yet */ GLDM_LOCK(mac, RW_WRITER); ASSERT(mac->gldm_devinfo != NULL); ASSERT(mac->gldm_mac_pvt != NULL); ASSERT(pvt->interfacep != NULL); ASSERT(pvt->kstatp != NULL); ASSERT(pvt->statistics != NULL); ASSERT(pvt->major_dev == dev); for (i = 0; i < VLAN_HASHSZ; i++) { for (vlan = pvt->vlan_hash[i]; vlan != NULL; vlan = vlan->gldv_next) { int nstr = 0; ASSERT(vlan->gldv_mac == mac); for (str = vlan->gldv_str_next; str != (gld_t *)&vlan->gldv_str_next; str = str->gld_next) { ASSERT(str->gld_device == dev); ASSERT(str->gld_mac_info == mac); ASSERT(str->gld_qptr != NULL); ASSERT(str->gld_minor >= GLD_MIN_CLONE_MINOR); ASSERT( str->gld_multicnt == 0 || str->gld_mcast); nstr++; } ASSERT(vlan->gldv_nstreams == nstr); nvlan++; } } ASSERT(pvt->nvlan == nvlan); GLDM_UNLOCK(mac); } mutex_exit(&dev->gld_devlock); } mutex_exit(&gld_device_list.gld_devlock); } #endif