1c0dd49bdSEiji Ota /* 2c0dd49bdSEiji Ota * CDDL HEADER START 3c0dd49bdSEiji Ota * 4c0dd49bdSEiji Ota * The contents of this file are subject to the terms of the 5c0dd49bdSEiji Ota * Common Development and Distribution License (the "License"). 6c0dd49bdSEiji Ota * You may not use this file except in compliance with the License. 7c0dd49bdSEiji Ota * 8c0dd49bdSEiji Ota * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9c0dd49bdSEiji Ota * or http://www.opensolaris.org/os/licensing. 10c0dd49bdSEiji Ota * See the License for the specific language governing permissions 11c0dd49bdSEiji Ota * and limitations under the License. 12c0dd49bdSEiji Ota * 13c0dd49bdSEiji Ota * When distributing Covered Code, include this CDDL HEADER in each 14c0dd49bdSEiji Ota * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15c0dd49bdSEiji Ota * If applicable, add the following below this CDDL HEADER, with the 16c0dd49bdSEiji Ota * fields enclosed by brackets "[]" replaced with your own identifying 17c0dd49bdSEiji Ota * information: Portions Copyright [yyyy] [name of copyright owner] 18c0dd49bdSEiji Ota * 19c0dd49bdSEiji Ota * CDDL HEADER END 20c0dd49bdSEiji Ota */ 21c0dd49bdSEiji Ota /* 22c0dd49bdSEiji Ota * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 23c0dd49bdSEiji Ota */ 24c0dd49bdSEiji Ota #include <sys/types.h> 25c0dd49bdSEiji Ota #include <sys/stream.h> 26c0dd49bdSEiji Ota #include <sys/dlpi.h> 27c0dd49bdSEiji Ota #include <sys/stropts.h> 28c0dd49bdSEiji Ota #include <sys/strsun.h> 29c0dd49bdSEiji Ota #include <sys/sysmacros.h> 30c0dd49bdSEiji Ota #include <sys/strlog.h> 31c0dd49bdSEiji Ota #include <sys/ddi.h> 32c0dd49bdSEiji Ota #include <sys/cmn_err.h> 33c0dd49bdSEiji Ota #include <sys/socket.h> 34c0dd49bdSEiji Ota #include <net/if.h> 35c0dd49bdSEiji Ota #include <net/if_types.h> 36c0dd49bdSEiji Ota #include <netinet/in.h> 37c0dd49bdSEiji Ota #include <sys/ethernet.h> 38c0dd49bdSEiji Ota #include <inet/arp.h> 39c0dd49bdSEiji Ota #include <inet/ip.h> 40c0dd49bdSEiji Ota #include <inet/ip6.h> 41c0dd49bdSEiji Ota #include <inet/ip_ire.h> 42c0dd49bdSEiji Ota #include <inet/ip_if.h> 43c0dd49bdSEiji Ota #include <inet/ip_ftable.h> 44c0dd49bdSEiji Ota 45c0dd49bdSEiji Ota #include <sys/sunddi.h> 46c0dd49bdSEiji Ota #include <sys/ksynch.h> 47c0dd49bdSEiji Ota 48c0dd49bdSEiji Ota #include <sys/rds.h> 49c0dd49bdSEiji Ota #include <sys/socket.h> 50c0dd49bdSEiji Ota #include <sys/socketvar.h> 51c0dd49bdSEiji Ota #include <sys/sockio.h> 52c0dd49bdSEiji Ota #include <sys/sysmacros.h> 53c0dd49bdSEiji Ota #include <inet/common.h> 54c0dd49bdSEiji Ota #include <inet/ip.h> 55c0dd49bdSEiji Ota #include <net/if_types.h> 56c0dd49bdSEiji Ota 57c0dd49bdSEiji Ota #include <sys/ib/clients/rdsv3/rdsv3.h> 58c0dd49bdSEiji Ota #include <sys/ib/clients/rdsv3/rdma.h> 59c0dd49bdSEiji Ota #include <sys/ib/clients/rdsv3/ib.h> 60c0dd49bdSEiji Ota #include <sys/ib/clients/rdsv3/rdsv3_impl.h> 61c0dd49bdSEiji Ota #include <sys/ib/clients/rdsv3/rdsv3_debug.h> 62c0dd49bdSEiji Ota 63c0dd49bdSEiji Ota #include <sys/dls.h> 64c0dd49bdSEiji Ota #include <sys/mac.h> 65c0dd49bdSEiji Ota #include <sys/mac_client.h> 66c0dd49bdSEiji Ota #include <sys/mac_provider.h> 67c0dd49bdSEiji Ota #include <sys/mac_client_priv.h> 68c0dd49bdSEiji Ota 69*66266859SToomas Soome uint_t rdsv3_one_sec_in_hz; 70c0dd49bdSEiji Ota ddi_taskq_t *rdsv3_taskq = NULL; 71c0dd49bdSEiji Ota extern kmem_cache_t *rdsv3_alloc_cache; 72c0dd49bdSEiji Ota 73c0dd49bdSEiji Ota extern unsigned int ip_ocsum(ushort_t *address, int halfword_count, 74c0dd49bdSEiji Ota unsigned int sum); 75c0dd49bdSEiji Ota 76c0dd49bdSEiji Ota /* 77c0dd49bdSEiji Ota * Check if the IP interface named by `lifrp' is RDS-capable. 78c0dd49bdSEiji Ota */ 79c0dd49bdSEiji Ota boolean_t 80c0dd49bdSEiji Ota rdsv3_capable_interface(struct lifreq *lifrp) 81c0dd49bdSEiji Ota { 82c0dd49bdSEiji Ota char ifname[LIFNAMSIZ]; 83c0dd49bdSEiji Ota char drv[MAXLINKNAMELEN]; 84c0dd49bdSEiji Ota uint_t ppa; 85c0dd49bdSEiji Ota char *cp; 86c0dd49bdSEiji Ota 87c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_capable_interface", "Enter"); 88c0dd49bdSEiji Ota 89c0dd49bdSEiji Ota if (lifrp->lifr_type == IFT_IB) 90c0dd49bdSEiji Ota return (B_TRUE); 91c0dd49bdSEiji Ota 92c0dd49bdSEiji Ota /* 93c0dd49bdSEiji Ota * Strip off the logical interface portion before getting 94c0dd49bdSEiji Ota * intimate with the name. 95c0dd49bdSEiji Ota */ 96c0dd49bdSEiji Ota (void) strlcpy(ifname, lifrp->lifr_name, LIFNAMSIZ); 97c0dd49bdSEiji Ota if ((cp = strchr(ifname, ':')) != NULL) 98c0dd49bdSEiji Ota *cp = '\0'; 99c0dd49bdSEiji Ota 100c0dd49bdSEiji Ota if (strcmp("lo0", ifname) == 0) { 101c0dd49bdSEiji Ota /* 102c0dd49bdSEiji Ota * loopback is considered RDS-capable 103c0dd49bdSEiji Ota */ 104c0dd49bdSEiji Ota return (B_TRUE); 105c0dd49bdSEiji Ota } 106c0dd49bdSEiji Ota 107c0dd49bdSEiji Ota return (ddi_parse(ifname, drv, &ppa) == DDI_SUCCESS && 108c0dd49bdSEiji Ota rdsv3_if_lookup_by_name(drv)); 109c0dd49bdSEiji Ota } 110c0dd49bdSEiji Ota 111c0dd49bdSEiji Ota int 112c0dd49bdSEiji Ota rdsv3_do_ip_ioctl(ksocket_t so4, void **ipaddrs, int *size, int *nifs) 113c0dd49bdSEiji Ota { 114c0dd49bdSEiji Ota struct lifnum lifn; 115c0dd49bdSEiji Ota struct lifconf lifc; 116c0dd49bdSEiji Ota struct lifreq *lp, *rlp, lifr; 117c0dd49bdSEiji Ota int rval = 0; 118c0dd49bdSEiji Ota int numifs; 119c0dd49bdSEiji Ota int bufsize, rbufsize; 120c0dd49bdSEiji Ota void *buf, *rbuf; 121c0dd49bdSEiji Ota int i, j, n, rc; 122c0dd49bdSEiji Ota 123c0dd49bdSEiji Ota *ipaddrs = NULL; 124c0dd49bdSEiji Ota *size = 0; 125c0dd49bdSEiji Ota *nifs = 0; 126c0dd49bdSEiji Ota 127c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_do_ip_ioctl", "Enter"); 128c0dd49bdSEiji Ota 129c0dd49bdSEiji Ota retry_count: 130c0dd49bdSEiji Ota /* snapshot the current number of interfaces */ 131c0dd49bdSEiji Ota lifn.lifn_family = PF_UNSPEC; 132c0dd49bdSEiji Ota lifn.lifn_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES; 133c0dd49bdSEiji Ota lifn.lifn_count = 0; 134c0dd49bdSEiji Ota rval = ksocket_ioctl(so4, SIOCGLIFNUM, (intptr_t)&lifn, &rval, 135c0dd49bdSEiji Ota CRED()); 136c0dd49bdSEiji Ota if (rval != 0) { 137c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl", 138c0dd49bdSEiji Ota "ksocket_ioctl returned: %d", rval); 139c0dd49bdSEiji Ota return (rval); 140c0dd49bdSEiji Ota } 141c0dd49bdSEiji Ota 142c0dd49bdSEiji Ota numifs = lifn.lifn_count; 143c0dd49bdSEiji Ota if (numifs <= 0) { 144c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl", "No interfaces found"); 145c0dd49bdSEiji Ota return (0); 146c0dd49bdSEiji Ota } 147c0dd49bdSEiji Ota 148c0dd49bdSEiji Ota /* allocate extra room in case more interfaces appear */ 149c0dd49bdSEiji Ota numifs += 10; 150c0dd49bdSEiji Ota 151c0dd49bdSEiji Ota /* get the interface names and ip addresses */ 152c0dd49bdSEiji Ota bufsize = numifs * sizeof (struct lifreq); 153c0dd49bdSEiji Ota buf = kmem_alloc(bufsize, KM_SLEEP); 154c0dd49bdSEiji Ota 155c0dd49bdSEiji Ota lifc.lifc_family = AF_UNSPEC; 156c0dd49bdSEiji Ota lifc.lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES; 157c0dd49bdSEiji Ota lifc.lifc_len = bufsize; 158c0dd49bdSEiji Ota lifc.lifc_buf = buf; 159c0dd49bdSEiji Ota rc = ksocket_ioctl(so4, SIOCGLIFCONF, (intptr_t)&lifc, &rval, CRED()); 160c0dd49bdSEiji Ota if (rc != 0) { 161c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl", "SIOCGLIFCONF failed"); 162c0dd49bdSEiji Ota kmem_free(buf, bufsize); 163c0dd49bdSEiji Ota return (rc); 164c0dd49bdSEiji Ota } 165c0dd49bdSEiji Ota /* if our extra room is used up, try again */ 166c0dd49bdSEiji Ota if (bufsize <= lifc.lifc_len) { 167c0dd49bdSEiji Ota kmem_free(buf, bufsize); 168c0dd49bdSEiji Ota buf = NULL; 169c0dd49bdSEiji Ota goto retry_count; 170c0dd49bdSEiji Ota } 171c0dd49bdSEiji Ota /* calc actual number of ifconfs */ 172c0dd49bdSEiji Ota n = lifc.lifc_len / sizeof (struct lifreq); 173c0dd49bdSEiji Ota 174c0dd49bdSEiji Ota /* 175c0dd49bdSEiji Ota * Count the RDS interfaces 176c0dd49bdSEiji Ota */ 177c0dd49bdSEiji Ota for (i = 0, j = 0, lp = lifc.lifc_req; i < n; i++, lp++) { 178c0dd49bdSEiji Ota 179c0dd49bdSEiji Ota /* 180c0dd49bdSEiji Ota * Copy as the SIOCGLIFFLAGS ioctl is destructive 181c0dd49bdSEiji Ota */ 182c0dd49bdSEiji Ota bcopy(lp, &lifr, sizeof (struct lifreq)); 183c0dd49bdSEiji Ota /* 184c0dd49bdSEiji Ota * fetch the flags using the socket of the correct family 185c0dd49bdSEiji Ota */ 186c0dd49bdSEiji Ota switch (lifr.lifr_addr.ss_family) { 187c0dd49bdSEiji Ota case AF_INET: 188c0dd49bdSEiji Ota rc = ksocket_ioctl(so4, SIOCGLIFFLAGS, (intptr_t)&lifr, 189c0dd49bdSEiji Ota &rval, CRED()); 190c0dd49bdSEiji Ota break; 191c0dd49bdSEiji Ota default: 192c0dd49bdSEiji Ota continue; 193c0dd49bdSEiji Ota } 194c0dd49bdSEiji Ota 195c0dd49bdSEiji Ota if (rc != 0) continue; 196c0dd49bdSEiji Ota 197c0dd49bdSEiji Ota /* 198c0dd49bdSEiji Ota * If we got the flags, skip uninteresting 199c0dd49bdSEiji Ota * interfaces based on flags 200c0dd49bdSEiji Ota */ 201c0dd49bdSEiji Ota if ((lifr.lifr_flags & IFF_UP) != IFF_UP) 202c0dd49bdSEiji Ota continue; 203c0dd49bdSEiji Ota if (lifr.lifr_flags & 204c0dd49bdSEiji Ota (IFF_ANYCAST|IFF_NOLOCAL|IFF_DEPRECATED)) 205c0dd49bdSEiji Ota continue; 206c0dd49bdSEiji Ota if (!rdsv3_capable_interface(&lifr)) 207c0dd49bdSEiji Ota continue; 208c0dd49bdSEiji Ota j++; 209c0dd49bdSEiji Ota } 210c0dd49bdSEiji Ota 211c0dd49bdSEiji Ota if (j <= 0) { 212c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl", "No RDS interfaces"); 213c0dd49bdSEiji Ota kmem_free(buf, bufsize); 214c0dd49bdSEiji Ota return (rval); 215c0dd49bdSEiji Ota } 216c0dd49bdSEiji Ota 217c0dd49bdSEiji Ota numifs = j; 218c0dd49bdSEiji Ota 219c0dd49bdSEiji Ota /* This is the buffer we pass back */ 220c0dd49bdSEiji Ota rbufsize = numifs * sizeof (struct lifreq); 221c0dd49bdSEiji Ota rbuf = kmem_alloc(rbufsize, KM_SLEEP); 222c0dd49bdSEiji Ota rlp = (struct lifreq *)rbuf; 223c0dd49bdSEiji Ota 224c0dd49bdSEiji Ota /* 225c0dd49bdSEiji Ota * Examine the array of interfaces and filter uninteresting ones 226c0dd49bdSEiji Ota */ 227c0dd49bdSEiji Ota for (i = 0, lp = lifc.lifc_req; i < n; i++, lp++) { 228c0dd49bdSEiji Ota 229c0dd49bdSEiji Ota /* 230c0dd49bdSEiji Ota * Copy the address as the SIOCGLIFFLAGS ioctl is destructive 231c0dd49bdSEiji Ota */ 232c0dd49bdSEiji Ota bcopy(lp, &lifr, sizeof (struct lifreq)); 233c0dd49bdSEiji Ota /* 234c0dd49bdSEiji Ota * fetch the flags using the socket of the correct family 235c0dd49bdSEiji Ota */ 236c0dd49bdSEiji Ota switch (lifr.lifr_addr.ss_family) { 237c0dd49bdSEiji Ota case AF_INET: 238c0dd49bdSEiji Ota rc = ksocket_ioctl(so4, SIOCGLIFFLAGS, (intptr_t)&lifr, 239c0dd49bdSEiji Ota &rval, CRED()); 240c0dd49bdSEiji Ota break; 241c0dd49bdSEiji Ota default: 242c0dd49bdSEiji Ota continue; 243c0dd49bdSEiji Ota } 244c0dd49bdSEiji Ota 245c0dd49bdSEiji Ota 246c0dd49bdSEiji Ota if (rc != 0) { 247c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl", 248c0dd49bdSEiji Ota "ksocket_ioctl failed" " for %s", lifr.lifr_name); 249c0dd49bdSEiji Ota continue; 250c0dd49bdSEiji Ota } 251c0dd49bdSEiji Ota 252c0dd49bdSEiji Ota /* 253c0dd49bdSEiji Ota * If we got the flags, skip uninteresting 254c0dd49bdSEiji Ota * interfaces based on flags 255c0dd49bdSEiji Ota */ 256c0dd49bdSEiji Ota if ((lifr.lifr_flags & IFF_UP) != IFF_UP) 257c0dd49bdSEiji Ota continue; 258c0dd49bdSEiji Ota if (lifr.lifr_flags & 259c0dd49bdSEiji Ota (IFF_ANYCAST|IFF_NOLOCAL|IFF_DEPRECATED)) 260c0dd49bdSEiji Ota continue; 261c0dd49bdSEiji Ota if (!rdsv3_capable_interface(&lifr)) 262c0dd49bdSEiji Ota continue; 263c0dd49bdSEiji Ota 264c0dd49bdSEiji Ota /* save the record */ 265c0dd49bdSEiji Ota bcopy(lp, rlp, sizeof (struct lifreq)); 266b27516f5Sagiri rlp->lifr_addr.ss_family = AF_INET_OFFLOAD; 267c0dd49bdSEiji Ota rlp++; 268c0dd49bdSEiji Ota } 269c0dd49bdSEiji Ota 270c0dd49bdSEiji Ota kmem_free(buf, bufsize); 271c0dd49bdSEiji Ota 272c0dd49bdSEiji Ota *ipaddrs = rbuf; 273c0dd49bdSEiji Ota *size = rbufsize; 274c0dd49bdSEiji Ota *nifs = numifs; 275c0dd49bdSEiji Ota 276c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_do_ip_ioctl", "Return"); 277c0dd49bdSEiji Ota 278c0dd49bdSEiji Ota return (rval); 279c0dd49bdSEiji Ota } 280c0dd49bdSEiji Ota 281c0dd49bdSEiji Ota /* 282c0dd49bdSEiji Ota * Check if the IP interface named by `ifrp' is RDS-capable. 283c0dd49bdSEiji Ota */ 284c0dd49bdSEiji Ota boolean_t 285c0dd49bdSEiji Ota rdsv3_capable_interface_old(struct ifreq *ifrp) 286c0dd49bdSEiji Ota { 287c0dd49bdSEiji Ota char ifname[IFNAMSIZ]; 288c0dd49bdSEiji Ota char drv[MAXLINKNAMELEN]; 289c0dd49bdSEiji Ota uint_t ppa; 290c0dd49bdSEiji Ota char *cp; 291c0dd49bdSEiji Ota 292c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_capable_interface_old", "Enter"); 293c0dd49bdSEiji Ota 294c0dd49bdSEiji Ota /* 295c0dd49bdSEiji Ota * Strip off the logical interface portion before getting 296c0dd49bdSEiji Ota * intimate with the name. 297c0dd49bdSEiji Ota */ 298c0dd49bdSEiji Ota (void) strlcpy(ifname, ifrp->ifr_name, IFNAMSIZ); 299c0dd49bdSEiji Ota if ((cp = strchr(ifname, ':')) != NULL) 300c0dd49bdSEiji Ota *cp = '\0'; 301c0dd49bdSEiji Ota 302c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_capable_interface_old", "ifname: %s", ifname); 303c0dd49bdSEiji Ota 304c0dd49bdSEiji Ota if ((strcmp("lo0", ifname) == 0) || 305c0dd49bdSEiji Ota (strncmp("ibd", ifname, 3) == 0)) { 306c0dd49bdSEiji Ota /* 307c0dd49bdSEiji Ota * loopback and IB are considered RDS-capable 308c0dd49bdSEiji Ota */ 309c0dd49bdSEiji Ota return (B_TRUE); 310c0dd49bdSEiji Ota } 311c0dd49bdSEiji Ota 312c0dd49bdSEiji Ota return (ddi_parse(ifname, drv, &ppa) == DDI_SUCCESS && 313c0dd49bdSEiji Ota rdsv3_if_lookup_by_name(drv)); 314c0dd49bdSEiji Ota } 315c0dd49bdSEiji Ota 316c0dd49bdSEiji Ota int 317c0dd49bdSEiji Ota rdsv3_do_ip_ioctl_old(ksocket_t so4, void **ipaddrs, int *size, int *nifs) 318c0dd49bdSEiji Ota { 319c0dd49bdSEiji Ota uint_t ifn; 320c0dd49bdSEiji Ota struct ifconf ifc; 321c0dd49bdSEiji Ota struct ifreq *lp, *rlp, ifr; 322c0dd49bdSEiji Ota int rval = 0; 323c0dd49bdSEiji Ota int numifs; 324c0dd49bdSEiji Ota int bufsize, rbufsize; 325c0dd49bdSEiji Ota void *buf, *rbuf; 326c0dd49bdSEiji Ota int i, j, n, rc; 327c0dd49bdSEiji Ota 328c0dd49bdSEiji Ota *ipaddrs = NULL; 329c0dd49bdSEiji Ota *size = 0; 330c0dd49bdSEiji Ota *nifs = 0; 331c0dd49bdSEiji Ota 332c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_do_ip_ioctl_old", "Enter"); 333c0dd49bdSEiji Ota 334c0dd49bdSEiji Ota retry_count: 335c0dd49bdSEiji Ota rval = ksocket_ioctl(so4, SIOCGIFNUM, (intptr_t)&ifn, &rval, 336c0dd49bdSEiji Ota CRED()); 337c0dd49bdSEiji Ota if (rval != 0) { 338c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 339c0dd49bdSEiji Ota "ksocket_ioctl(SIOCGIFNUM) returned: %d", rval); 340c0dd49bdSEiji Ota return (rval); 341c0dd49bdSEiji Ota } 342c0dd49bdSEiji Ota 343c0dd49bdSEiji Ota numifs = ifn; 344c0dd49bdSEiji Ota if (numifs <= 0) { 345c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", "No interfaces found"); 346c0dd49bdSEiji Ota return (0); 347c0dd49bdSEiji Ota } 348c0dd49bdSEiji Ota 349c0dd49bdSEiji Ota /* allocate extra room in case more interfaces appear */ 350c0dd49bdSEiji Ota numifs += 10; 351c0dd49bdSEiji Ota 352c0dd49bdSEiji Ota /* get the interface names and ip addresses */ 353c0dd49bdSEiji Ota bufsize = numifs * sizeof (struct ifreq); 354c0dd49bdSEiji Ota buf = kmem_alloc(bufsize, KM_SLEEP); 355c0dd49bdSEiji Ota 356c0dd49bdSEiji Ota ifc.ifc_len = bufsize; 357c0dd49bdSEiji Ota ifc.ifc_buf = buf; 358c0dd49bdSEiji Ota rc = ksocket_ioctl(so4, SIOCGIFCONF, (intptr_t)&ifc, &rval, CRED()); 359c0dd49bdSEiji Ota if (rc != 0) { 360c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 361c0dd49bdSEiji Ota "SIOCGLIFCONF failed: %d", rc); 362c0dd49bdSEiji Ota kmem_free(buf, bufsize); 363c0dd49bdSEiji Ota return (rc); 364c0dd49bdSEiji Ota } 365c0dd49bdSEiji Ota /* if our extra room is used up, try again */ 366c0dd49bdSEiji Ota if (bufsize <= ifc.ifc_len) { 367c0dd49bdSEiji Ota kmem_free(buf, bufsize); 368c0dd49bdSEiji Ota buf = NULL; 369c0dd49bdSEiji Ota goto retry_count; 370c0dd49bdSEiji Ota } 371c0dd49bdSEiji Ota /* calc actual number of ifconfs */ 372c0dd49bdSEiji Ota n = ifc.ifc_len / sizeof (struct ifreq); 373c0dd49bdSEiji Ota 374c0dd49bdSEiji Ota /* 375c0dd49bdSEiji Ota * Count the RDS interfaces 376c0dd49bdSEiji Ota */ 377c0dd49bdSEiji Ota for (i = 0, j = 0, lp = ifc.ifc_req; i < n; i++, lp++) { 378c0dd49bdSEiji Ota 379c0dd49bdSEiji Ota /* 380c0dd49bdSEiji Ota * Copy as the SIOCGIFFLAGS ioctl is destructive 381c0dd49bdSEiji Ota */ 382c0dd49bdSEiji Ota bcopy(lp, &ifr, sizeof (struct ifreq)); 383c0dd49bdSEiji Ota /* 384c0dd49bdSEiji Ota * fetch the flags using the socket of the correct family 385c0dd49bdSEiji Ota */ 386c0dd49bdSEiji Ota switch (ifr.ifr_addr.sa_family) { 387c0dd49bdSEiji Ota case AF_INET: 388c0dd49bdSEiji Ota rc = ksocket_ioctl(so4, SIOCGIFFLAGS, (intptr_t)&ifr, 389c0dd49bdSEiji Ota &rval, CRED()); 390c0dd49bdSEiji Ota break; 391c0dd49bdSEiji Ota default: 392c0dd49bdSEiji Ota continue; 393c0dd49bdSEiji Ota } 394c0dd49bdSEiji Ota 395c0dd49bdSEiji Ota if (rc != 0) continue; 396c0dd49bdSEiji Ota 397c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 398c0dd49bdSEiji Ota "1. ifr_name: %s, flags: %d", ifr.ifr_name, 399c0dd49bdSEiji Ota (ushort_t)ifr.ifr_flags); 400c0dd49bdSEiji Ota 401c0dd49bdSEiji Ota /* 402c0dd49bdSEiji Ota * If we got the flags, skip uninteresting 403c0dd49bdSEiji Ota * interfaces based on flags 404c0dd49bdSEiji Ota */ 405c0dd49bdSEiji Ota if ((((ushort_t)ifr.ifr_flags) & IFF_UP) != IFF_UP) 406c0dd49bdSEiji Ota continue; 407c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 408c0dd49bdSEiji Ota "2. ifr_name: %s, flags: %d", ifr.ifr_name, 409c0dd49bdSEiji Ota (ushort_t)ifr.ifr_flags); 410c0dd49bdSEiji Ota if (((ushort_t)ifr.ifr_flags) & 411c0dd49bdSEiji Ota (IFF_ANYCAST|IFF_NOLOCAL|IFF_DEPRECATED)) 412c0dd49bdSEiji Ota continue; 413c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 414c0dd49bdSEiji Ota "3. ifr_name: %s, flags: %d", ifr.ifr_name, 415c0dd49bdSEiji Ota (ushort_t)ifr.ifr_flags); 416c0dd49bdSEiji Ota if (!rdsv3_capable_interface_old(&ifr)) 417c0dd49bdSEiji Ota continue; 418c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 419c0dd49bdSEiji Ota "4. ifr_name: %s, flags: %d", ifr.ifr_name, 420c0dd49bdSEiji Ota (ushort_t)ifr.ifr_flags); 421c0dd49bdSEiji Ota j++; 422c0dd49bdSEiji Ota } 423c0dd49bdSEiji Ota 424c0dd49bdSEiji Ota if (j <= 0) { 425c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", "No RDS interfaces"); 426c0dd49bdSEiji Ota kmem_free(buf, bufsize); 427c0dd49bdSEiji Ota return (rval); 428c0dd49bdSEiji Ota } 429c0dd49bdSEiji Ota 430c0dd49bdSEiji Ota numifs = j; 431c0dd49bdSEiji Ota 432c0dd49bdSEiji Ota /* This is the buffer we pass back */ 433c0dd49bdSEiji Ota rbufsize = numifs * sizeof (struct ifreq); 434c0dd49bdSEiji Ota rbuf = kmem_alloc(rbufsize, KM_SLEEP); 435c0dd49bdSEiji Ota rlp = (struct ifreq *)rbuf; 436c0dd49bdSEiji Ota 437c0dd49bdSEiji Ota /* 438c0dd49bdSEiji Ota * Examine the array of interfaces and filter uninteresting ones 439c0dd49bdSEiji Ota */ 440c0dd49bdSEiji Ota for (i = 0, lp = ifc.ifc_req; i < n; i++, lp++) { 441c0dd49bdSEiji Ota 442c0dd49bdSEiji Ota /* 443c0dd49bdSEiji Ota * Copy the address as the SIOCGIFFLAGS ioctl is destructive 444c0dd49bdSEiji Ota */ 445c0dd49bdSEiji Ota bcopy(lp, &ifr, sizeof (struct ifreq)); 446c0dd49bdSEiji Ota /* 447c0dd49bdSEiji Ota * fetch the flags using the socket of the correct family 448c0dd49bdSEiji Ota */ 449c0dd49bdSEiji Ota switch (ifr.ifr_addr.sa_family) { 450c0dd49bdSEiji Ota case AF_INET: 451c0dd49bdSEiji Ota rc = ksocket_ioctl(so4, SIOCGIFFLAGS, (intptr_t)&ifr, 452c0dd49bdSEiji Ota &rval, CRED()); 453c0dd49bdSEiji Ota break; 454c0dd49bdSEiji Ota default: 455c0dd49bdSEiji Ota continue; 456c0dd49bdSEiji Ota } 457c0dd49bdSEiji Ota 458c0dd49bdSEiji Ota 459c0dd49bdSEiji Ota if (rc != 0) { 460c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_do_ip_ioctl_old", 461c0dd49bdSEiji Ota "ksocket_ioctl failed: %d for %s", 462c0dd49bdSEiji Ota rc, ifr.ifr_name); 463c0dd49bdSEiji Ota continue; 464c0dd49bdSEiji Ota } 465c0dd49bdSEiji Ota 466c0dd49bdSEiji Ota /* 467c0dd49bdSEiji Ota * If we got the flags, skip uninteresting 468c0dd49bdSEiji Ota * interfaces based on flags 469c0dd49bdSEiji Ota */ 470c0dd49bdSEiji Ota if ((((ushort_t)ifr.ifr_flags) & IFF_UP) != IFF_UP) 471c0dd49bdSEiji Ota continue; 472c0dd49bdSEiji Ota if (((ushort_t)ifr.ifr_flags) & 473c0dd49bdSEiji Ota (IFF_ANYCAST|IFF_NOLOCAL|IFF_DEPRECATED)) 474c0dd49bdSEiji Ota continue; 475c0dd49bdSEiji Ota if (!rdsv3_capable_interface_old(&ifr)) 476c0dd49bdSEiji Ota continue; 477c0dd49bdSEiji Ota 478c0dd49bdSEiji Ota /* save the record */ 479c0dd49bdSEiji Ota bcopy(lp, rlp, sizeof (struct ifreq)); 480b27516f5Sagiri rlp->ifr_addr.sa_family = AF_INET_OFFLOAD; 481c0dd49bdSEiji Ota rlp++; 482c0dd49bdSEiji Ota } 483c0dd49bdSEiji Ota 484c0dd49bdSEiji Ota kmem_free(buf, bufsize); 485c0dd49bdSEiji Ota 486c0dd49bdSEiji Ota *ipaddrs = rbuf; 487c0dd49bdSEiji Ota *size = rbufsize; 488c0dd49bdSEiji Ota *nifs = numifs; 489c0dd49bdSEiji Ota 490c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_do_ip_ioctl_old", "Return"); 491c0dd49bdSEiji Ota 492c0dd49bdSEiji Ota return (rval); 493c0dd49bdSEiji Ota } 494c0dd49bdSEiji Ota 495c0dd49bdSEiji Ota boolean_t 496c0dd49bdSEiji Ota rdsv3_isloopback(ipaddr_t addr) 497c0dd49bdSEiji Ota { 498c0dd49bdSEiji Ota ip_stack_t *ipst; 499c0dd49bdSEiji Ota 500c0dd49bdSEiji Ota ipst = netstack_find_by_zoneid(GLOBAL_ZONEID)->netstack_ip; 501c0dd49bdSEiji Ota ASSERT(ipst != NULL); 502c0dd49bdSEiji Ota if (ip_type_v4(addr, ipst) != IRE_LOOPBACK) { 503c0dd49bdSEiji Ota netstack_rele(ipst->ips_netstack); 504c0dd49bdSEiji Ota return (B_FALSE); 505c0dd49bdSEiji Ota } 506c0dd49bdSEiji Ota netstack_rele(ipst->ips_netstack); 507c0dd49bdSEiji Ota return (B_TRUE); 508c0dd49bdSEiji Ota } 509c0dd49bdSEiji Ota 510c0dd49bdSEiji Ota /* 511c0dd49bdSEiji Ota * Work Queue Implementation 512c0dd49bdSEiji Ota */ 513c0dd49bdSEiji Ota 514c0dd49bdSEiji Ota #define RDSV3_WQ_THREAD_IDLE 0 515c0dd49bdSEiji Ota #define RDSV3_WQ_THREAD_RUNNING 1 516c0dd49bdSEiji Ota #define RDSV3_WQ_THREAD_FLUSHING 2 517c0dd49bdSEiji Ota #define RDSV3_WQ_THREAD_EXITING 3 518c0dd49bdSEiji Ota 519c0dd49bdSEiji Ota /* worker thread */ 520c0dd49bdSEiji Ota void 521c0dd49bdSEiji Ota rdsv3_worker_thread(void *arg) 522c0dd49bdSEiji Ota { 523c0dd49bdSEiji Ota rdsv3_workqueue_struct_t *wq = arg; 524c0dd49bdSEiji Ota rdsv3_work_t *work; 525c0dd49bdSEiji Ota 526c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_worker_thread", "Enter(wq: 0x%p)", wq); 527c0dd49bdSEiji Ota 528c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 529c0dd49bdSEiji Ota work = list_remove_head(&wq->wq_queue); 530c0dd49bdSEiji Ota while (work) { 531c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 532c0dd49bdSEiji Ota 533c0dd49bdSEiji Ota /* process work */ 534c0dd49bdSEiji Ota work->func(work); 535c0dd49bdSEiji Ota 536c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 537c0dd49bdSEiji Ota work = list_remove_head(&wq->wq_queue); 538c0dd49bdSEiji Ota } 539c0dd49bdSEiji Ota 540c0dd49bdSEiji Ota /* No more work, go home, until called again */ 541c0dd49bdSEiji Ota if (wq->wq_state != RDSV3_WQ_THREAD_EXITING) { 542c0dd49bdSEiji Ota wq->wq_state = RDSV3_WQ_THREAD_IDLE; 543c0dd49bdSEiji Ota } 544c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 545c0dd49bdSEiji Ota 546c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_worker_thread", "Return(wq: 0x%p)", wq); 547c0dd49bdSEiji Ota } 548c0dd49bdSEiji Ota 549c0dd49bdSEiji Ota /* XXX */ 550c0dd49bdSEiji Ota void 551c0dd49bdSEiji Ota rdsv3_flush_workqueue(rdsv3_workqueue_struct_t *wq) 552c0dd49bdSEiji Ota { 553c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_flush_workqueue", "Enter(wq: %p)", wq); 554c0dd49bdSEiji Ota 555c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 556c0dd49bdSEiji Ota switch (wq->wq_state) { 557c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_IDLE: 558c0dd49bdSEiji Ota /* nothing to do */ 559c0dd49bdSEiji Ota ASSERT(list_is_empty(&wq->wq_queue)); 560c0dd49bdSEiji Ota break; 561c0dd49bdSEiji Ota 562c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_RUNNING: 563c0dd49bdSEiji Ota wq->wq_state = RDSV3_WQ_THREAD_FLUSHING; 564c0dd49bdSEiji Ota /* FALLTHRU */ 565c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_FLUSHING: 566c0dd49bdSEiji Ota /* already flushing, wait until the flushing is complete */ 567c0dd49bdSEiji Ota do { 568c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 569c0dd49bdSEiji Ota delay(drv_usectohz(1000000)); 570c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 571c0dd49bdSEiji Ota } while (wq->wq_state == RDSV3_WQ_THREAD_FLUSHING); 572c0dd49bdSEiji Ota break; 573c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_EXITING: 574c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 575c0dd49bdSEiji Ota rdsv3_worker_thread(wq); 576c0dd49bdSEiji Ota return; 577c0dd49bdSEiji Ota } 578c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 579c0dd49bdSEiji Ota 580c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_flush_workqueue", "Return(wq: %p)", wq); 581c0dd49bdSEiji Ota } 582c0dd49bdSEiji Ota 583c0dd49bdSEiji Ota void 584c0dd49bdSEiji Ota rdsv3_queue_work(rdsv3_workqueue_struct_t *wq, rdsv3_work_t *wp) 585c0dd49bdSEiji Ota { 586c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_queue_work", "Enter(wq: %p, wp: %p)", wq, wp); 587c0dd49bdSEiji Ota 588c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 589c0dd49bdSEiji Ota 590c0dd49bdSEiji Ota if (list_link_active(&wp->work_item)) { 591c0dd49bdSEiji Ota /* This is already in the queue, ignore this call */ 592c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 593c0dd49bdSEiji Ota RDSV3_DPRINTF3("rdsv3_queue_work", "already queued: %p", wp); 594c0dd49bdSEiji Ota return; 595c0dd49bdSEiji Ota } 596c0dd49bdSEiji Ota 597c0dd49bdSEiji Ota switch (wq->wq_state) { 598c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_RUNNING: 599c0dd49bdSEiji Ota list_insert_tail(&wq->wq_queue, wp); 600c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 601c0dd49bdSEiji Ota break; 602c0dd49bdSEiji Ota 603c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_FLUSHING: 604c0dd49bdSEiji Ota do { 605c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 606c0dd49bdSEiji Ota delay(drv_usectohz(1000000)); 607c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 608c0dd49bdSEiji Ota } while (wq->wq_state == RDSV3_WQ_THREAD_FLUSHING); 609c0dd49bdSEiji Ota 610c0dd49bdSEiji Ota if (wq->wq_state == RDSV3_WQ_THREAD_RUNNING) { 611c0dd49bdSEiji Ota list_insert_tail(&wq->wq_queue, wp); 612c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 613c0dd49bdSEiji Ota break; 614c0dd49bdSEiji Ota } 615c0dd49bdSEiji Ota /* FALLTHRU */ 616c0dd49bdSEiji Ota 617c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_IDLE: 618c0dd49bdSEiji Ota list_insert_tail(&wq->wq_queue, wp); 619c0dd49bdSEiji Ota wq->wq_state = RDSV3_WQ_THREAD_RUNNING; 620c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 621c0dd49bdSEiji Ota 622c0dd49bdSEiji Ota (void) ddi_taskq_dispatch(rdsv3_taskq, rdsv3_worker_thread, wq, 623c0dd49bdSEiji Ota DDI_SLEEP); 624c0dd49bdSEiji Ota break; 625c0dd49bdSEiji Ota 626c0dd49bdSEiji Ota case RDSV3_WQ_THREAD_EXITING: 627c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 628c0dd49bdSEiji Ota break; 629c0dd49bdSEiji Ota } 630c0dd49bdSEiji Ota 631c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_queue_work", "Return(wq: %p, wp: %p)", wq, wp); 632c0dd49bdSEiji Ota } 633c0dd49bdSEiji Ota 634c0dd49bdSEiji Ota /* timeout handler for delayed work queuing */ 635c0dd49bdSEiji Ota void 636c0dd49bdSEiji Ota rdsv3_work_timeout_handler(void *arg) 637c0dd49bdSEiji Ota { 638c0dd49bdSEiji Ota rdsv3_delayed_work_t *dwp = (rdsv3_delayed_work_t *)arg; 639c0dd49bdSEiji Ota 640c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_work_timeout_handler", 641c0dd49bdSEiji Ota "Enter(wq: %p, wp: %p)", dwp->wq, &dwp->work); 642c0dd49bdSEiji Ota 643c0dd49bdSEiji Ota mutex_enter(&dwp->lock); 644c0dd49bdSEiji Ota dwp->timeid = 0; 645c0dd49bdSEiji Ota mutex_exit(&dwp->lock); 646c0dd49bdSEiji Ota 647c0dd49bdSEiji Ota mutex_enter(&dwp->wq->wq_lock); 648c0dd49bdSEiji Ota dwp->wq->wq_pending--; 649c0dd49bdSEiji Ota if (dwp->wq->wq_state == RDSV3_WQ_THREAD_EXITING) { 650c0dd49bdSEiji Ota mutex_exit(&dwp->wq->wq_lock); 651c0dd49bdSEiji Ota return; 652c0dd49bdSEiji Ota } 653c0dd49bdSEiji Ota mutex_exit(&dwp->wq->wq_lock); 654c0dd49bdSEiji Ota 655c0dd49bdSEiji Ota rdsv3_queue_work(dwp->wq, &dwp->work); 656c0dd49bdSEiji Ota 657c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_work_timeout_handler", 658c0dd49bdSEiji Ota "Return(wq: %p, wp: %p)", dwp->wq, &dwp->work); 659c0dd49bdSEiji Ota } 660c0dd49bdSEiji Ota 661c0dd49bdSEiji Ota void 662c0dd49bdSEiji Ota rdsv3_queue_delayed_work(rdsv3_workqueue_struct_t *wq, 663c0dd49bdSEiji Ota rdsv3_delayed_work_t *dwp, uint_t delay) 664c0dd49bdSEiji Ota { 665c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_queue_delayed_work", 666c0dd49bdSEiji Ota "Enter(wq: %p, wp: %p)", wq, dwp); 667c0dd49bdSEiji Ota 668c0dd49bdSEiji Ota if (delay == 0) { 669c0dd49bdSEiji Ota rdsv3_queue_work(wq, &dwp->work); 670c0dd49bdSEiji Ota return; 671c0dd49bdSEiji Ota } 672c0dd49bdSEiji Ota 673c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 674c0dd49bdSEiji Ota if (wq->wq_state == RDSV3_WQ_THREAD_EXITING) { 675c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 676c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_queue_delayed_work", 677c0dd49bdSEiji Ota "WQ exiting - don't queue (wq: %p, wp: %p)", wq, dwp); 678c0dd49bdSEiji Ota return; 679c0dd49bdSEiji Ota } 680c0dd49bdSEiji Ota wq->wq_pending++; 681c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 682c0dd49bdSEiji Ota 683c0dd49bdSEiji Ota mutex_enter(&dwp->lock); 684c0dd49bdSEiji Ota if (dwp->timeid == 0) { 685c0dd49bdSEiji Ota dwp->wq = wq; 686c0dd49bdSEiji Ota dwp->timeid = timeout(rdsv3_work_timeout_handler, dwp, 687c0dd49bdSEiji Ota jiffies + (delay * rdsv3_one_sec_in_hz)); 688c0dd49bdSEiji Ota mutex_exit(&dwp->lock); 689c0dd49bdSEiji Ota } else { 690c0dd49bdSEiji Ota mutex_exit(&dwp->lock); 691c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_queue_delayed_work", "Already queued: %p", 692c0dd49bdSEiji Ota dwp); 693c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 694c0dd49bdSEiji Ota wq->wq_pending--; 695c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 696c0dd49bdSEiji Ota } 697c0dd49bdSEiji Ota 698c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_queue_delayed_work", 699c0dd49bdSEiji Ota "Return(wq: %p, wp: %p)", wq, dwp); 700c0dd49bdSEiji Ota } 701c0dd49bdSEiji Ota 702c0dd49bdSEiji Ota void 703c0dd49bdSEiji Ota rdsv3_cancel_delayed_work(rdsv3_delayed_work_t *dwp) 704c0dd49bdSEiji Ota { 705c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_cancel_delayed_work", 706c0dd49bdSEiji Ota "Enter(wq: %p, dwp: %p)", dwp->wq, dwp); 707c0dd49bdSEiji Ota 708c0dd49bdSEiji Ota mutex_enter(&dwp->lock); 709c0dd49bdSEiji Ota if (dwp->timeid != 0) { 710c0dd49bdSEiji Ota (void) untimeout(dwp->timeid); 711c0dd49bdSEiji Ota dwp->timeid = 0; 712c0dd49bdSEiji Ota } else { 713c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_cancel_delayed_work", 714c0dd49bdSEiji Ota "Nothing to cancel (wq: %p, dwp: %p)", dwp->wq, dwp); 715c0dd49bdSEiji Ota mutex_exit(&dwp->lock); 716c0dd49bdSEiji Ota return; 717c0dd49bdSEiji Ota } 718c0dd49bdSEiji Ota mutex_exit(&dwp->lock); 719c0dd49bdSEiji Ota 720c0dd49bdSEiji Ota mutex_enter(&dwp->wq->wq_lock); 721c0dd49bdSEiji Ota dwp->wq->wq_pending--; 722c0dd49bdSEiji Ota mutex_exit(&dwp->wq->wq_lock); 723c0dd49bdSEiji Ota 724c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_cancel_delayed_work", 725c0dd49bdSEiji Ota "Return(wq: %p, dwp: %p)", dwp->wq, dwp); 726c0dd49bdSEiji Ota } 727c0dd49bdSEiji Ota 728c0dd49bdSEiji Ota void 729c0dd49bdSEiji Ota rdsv3_destroy_task_workqueue(rdsv3_workqueue_struct_t *wq) 730c0dd49bdSEiji Ota { 731c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_destroy_workqueue", "Enter"); 732c0dd49bdSEiji Ota 733c0dd49bdSEiji Ota ASSERT(wq); 734c0dd49bdSEiji Ota 735c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 736c0dd49bdSEiji Ota wq->wq_state = RDSV3_WQ_THREAD_EXITING; 737c0dd49bdSEiji Ota 738c0dd49bdSEiji Ota while (wq->wq_pending > 0) { 739c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 740c0dd49bdSEiji Ota delay(drv_usectohz(1000000)); 741c0dd49bdSEiji Ota mutex_enter(&wq->wq_lock); 742c0dd49bdSEiji Ota }; 743c0dd49bdSEiji Ota mutex_exit(&wq->wq_lock); 744c0dd49bdSEiji Ota 745c0dd49bdSEiji Ota rdsv3_flush_workqueue(wq); 746c0dd49bdSEiji Ota 747c0dd49bdSEiji Ota list_destroy(&wq->wq_queue); 748c0dd49bdSEiji Ota mutex_destroy(&wq->wq_lock); 749c0dd49bdSEiji Ota kmem_free(wq, sizeof (rdsv3_workqueue_struct_t)); 750c0dd49bdSEiji Ota 751c0dd49bdSEiji Ota ASSERT(rdsv3_taskq); 752c0dd49bdSEiji Ota ddi_taskq_destroy(rdsv3_taskq); 753c0dd49bdSEiji Ota 754c0dd49bdSEiji Ota wq = NULL; 755c0dd49bdSEiji Ota rdsv3_taskq = NULL; 756c0dd49bdSEiji Ota 757c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_destroy_workqueue", "Return"); 758c0dd49bdSEiji Ota } 759c0dd49bdSEiji Ota 760c0dd49bdSEiji Ota /* ARGSUSED */ 761c0dd49bdSEiji Ota void 762c0dd49bdSEiji Ota rdsv3_rdma_init_worker(struct rdsv3_work_s *work) 763c0dd49bdSEiji Ota { 764c0dd49bdSEiji Ota rdsv3_rdma_init(); 765c0dd49bdSEiji Ota } 766c0dd49bdSEiji Ota 7675d5562f5SEiji Ota #define RDSV3_NUM_TASKQ_THREADS 1 768c0dd49bdSEiji Ota rdsv3_workqueue_struct_t * 769c0dd49bdSEiji Ota rdsv3_create_task_workqueue(char *name) 770c0dd49bdSEiji Ota { 771c0dd49bdSEiji Ota rdsv3_workqueue_struct_t *wq; 772c0dd49bdSEiji Ota 773c0dd49bdSEiji Ota RDSV3_DPRINTF2("create_singlethread_workqueue", "Enter (dip: %p)", 774c0dd49bdSEiji Ota rdsv3_dev_info); 775c0dd49bdSEiji Ota 776c0dd49bdSEiji Ota rdsv3_taskq = ddi_taskq_create(rdsv3_dev_info, name, 777c0dd49bdSEiji Ota RDSV3_NUM_TASKQ_THREADS, TASKQ_DEFAULTPRI, 0); 778c0dd49bdSEiji Ota if (rdsv3_taskq == NULL) { 7796e18d381Sagiri RDSV3_DPRINTF2(__FILE__, 780c0dd49bdSEiji Ota "ddi_taskq_create failed for rdsv3_taskq"); 781c0dd49bdSEiji Ota return (NULL); 782c0dd49bdSEiji Ota } 783c0dd49bdSEiji Ota 784c0dd49bdSEiji Ota wq = kmem_zalloc(sizeof (rdsv3_workqueue_struct_t), KM_NOSLEEP); 785c0dd49bdSEiji Ota if (wq == NULL) { 7866e18d381Sagiri RDSV3_DPRINTF2(__FILE__, "kmem_zalloc failed for wq"); 787c0dd49bdSEiji Ota ddi_taskq_destroy(rdsv3_taskq); 788c0dd49bdSEiji Ota return (NULL); 789c0dd49bdSEiji Ota } 790c0dd49bdSEiji Ota 791c0dd49bdSEiji Ota list_create(&wq->wq_queue, sizeof (struct rdsv3_work_s), 792c0dd49bdSEiji Ota offsetof(struct rdsv3_work_s, work_item)); 793c0dd49bdSEiji Ota mutex_init(&wq->wq_lock, NULL, MUTEX_DRIVER, NULL); 794c0dd49bdSEiji Ota wq->wq_state = RDSV3_WQ_THREAD_IDLE; 795c0dd49bdSEiji Ota wq->wq_pending = 0; 796c0dd49bdSEiji Ota rdsv3_one_sec_in_hz = drv_usectohz(1000000); 797c0dd49bdSEiji Ota 798c0dd49bdSEiji Ota RDSV3_DPRINTF2("create_singlethread_workqueue", "Return"); 799c0dd49bdSEiji Ota 800c0dd49bdSEiji Ota return (wq); 801c0dd49bdSEiji Ota } 802c0dd49bdSEiji Ota 803c0dd49bdSEiji Ota /* 804c0dd49bdSEiji Ota * Implementation for struct sock 805c0dd49bdSEiji Ota */ 806c0dd49bdSEiji Ota 807c0dd49bdSEiji Ota void 808c0dd49bdSEiji Ota rdsv3_sock_exit_data(struct rsock *sk) 809c0dd49bdSEiji Ota { 810c0dd49bdSEiji Ota struct rdsv3_sock *rs = sk->sk_protinfo; 811c0dd49bdSEiji Ota 812c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_sock_exit_data", "rs: %p sk: %p", rs, sk); 813c0dd49bdSEiji Ota 814c0dd49bdSEiji Ota ASSERT(rs != NULL); 815c0dd49bdSEiji Ota ASSERT(rdsv3_sk_sock_flag(sk, SOCK_DEAD)); 816c0dd49bdSEiji Ota 817c0dd49bdSEiji Ota rs->rs_sk = NULL; 818c0dd49bdSEiji Ota 819c0dd49bdSEiji Ota list_destroy(&rs->rs_send_queue); 820c0dd49bdSEiji Ota list_destroy(&rs->rs_notify_queue); 821c0dd49bdSEiji Ota list_destroy(&rs->rs_recv_queue); 822c0dd49bdSEiji Ota 823c0dd49bdSEiji Ota rw_destroy(&rs->rs_recv_lock); 824c0dd49bdSEiji Ota mutex_destroy(&rs->rs_lock); 825c0dd49bdSEiji Ota 826c0dd49bdSEiji Ota mutex_destroy(&rs->rs_rdma_lock); 827c0dd49bdSEiji Ota avl_destroy(&rs->rs_rdma_keys); 828c0dd49bdSEiji Ota 8295d5562f5SEiji Ota mutex_destroy(&rs->rs_conn_lock); 8305d5562f5SEiji Ota mutex_destroy(&rs->rs_congested_lock); 8315d5562f5SEiji Ota cv_destroy(&rs->rs_congested_cv); 8325d5562f5SEiji Ota 833c0dd49bdSEiji Ota rdsv3_exit_waitqueue(sk->sk_sleep); 834c0dd49bdSEiji Ota kmem_free(sk->sk_sleep, sizeof (rdsv3_wait_queue_t)); 835c0dd49bdSEiji Ota mutex_destroy(&sk->sk_lock); 836c0dd49bdSEiji Ota 837c0dd49bdSEiji Ota kmem_cache_free(rdsv3_alloc_cache, sk); 838c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_sock_exit_data", "rs: %p sk: %p", rs, sk); 839c0dd49bdSEiji Ota } 840c0dd49bdSEiji Ota 841c0dd49bdSEiji Ota /* XXX - figure out right values */ 842c0dd49bdSEiji Ota #define RDSV3_RECV_HIWATER (256 * 1024) 843c0dd49bdSEiji Ota #define RDSV3_RECV_LOWATER 128 844c0dd49bdSEiji Ota #define RDSV3_XMIT_HIWATER (256 * 1024) 845c0dd49bdSEiji Ota #define RDSV3_XMIT_LOWATER 1024 846c0dd49bdSEiji Ota 847c0dd49bdSEiji Ota struct rsock * 848c0dd49bdSEiji Ota rdsv3_sk_alloc() 849c0dd49bdSEiji Ota { 850c0dd49bdSEiji Ota struct rsock *sk; 851c0dd49bdSEiji Ota 852c0dd49bdSEiji Ota sk = kmem_cache_alloc(rdsv3_alloc_cache, KM_SLEEP); 853c0dd49bdSEiji Ota if (sk == NULL) { 854c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_create", "kmem_cache_alloc failed"); 855c0dd49bdSEiji Ota return (NULL); 856c0dd49bdSEiji Ota } 857c0dd49bdSEiji Ota 858c0dd49bdSEiji Ota bzero(sk, sizeof (struct rsock) + sizeof (struct rdsv3_sock)); 859c0dd49bdSEiji Ota return (sk); 860c0dd49bdSEiji Ota } 861c0dd49bdSEiji Ota 862c0dd49bdSEiji Ota void 863c0dd49bdSEiji Ota rdsv3_sock_init_data(struct rsock *sk) 864c0dd49bdSEiji Ota { 865c0dd49bdSEiji Ota sk->sk_sleep = kmem_zalloc(sizeof (rdsv3_wait_queue_t), KM_SLEEP); 866c0dd49bdSEiji Ota rdsv3_init_waitqueue(sk->sk_sleep); 867c0dd49bdSEiji Ota 868c0dd49bdSEiji Ota mutex_init(&sk->sk_lock, NULL, MUTEX_DRIVER, NULL); 869c0dd49bdSEiji Ota sk->sk_refcount = 1; 870c0dd49bdSEiji Ota sk->sk_protinfo = (struct rdsv3_sock *)(sk + 1); 871c0dd49bdSEiji Ota sk->sk_sndbuf = RDSV3_XMIT_HIWATER; 872c0dd49bdSEiji Ota sk->sk_rcvbuf = RDSV3_RECV_HIWATER; 873c0dd49bdSEiji Ota } 874c0dd49bdSEiji Ota 875c0dd49bdSEiji Ota /* 876c0dd49bdSEiji Ota * Connection cache 877c0dd49bdSEiji Ota */ 878c0dd49bdSEiji Ota /* ARGSUSED */ 879c0dd49bdSEiji Ota int 880c0dd49bdSEiji Ota rdsv3_conn_constructor(void *buf, void *arg, int kmflags) 881c0dd49bdSEiji Ota { 882c0dd49bdSEiji Ota struct rdsv3_connection *conn = buf; 883c0dd49bdSEiji Ota 884c0dd49bdSEiji Ota bzero(conn, sizeof (struct rdsv3_connection)); 885c0dd49bdSEiji Ota 886c0dd49bdSEiji Ota conn->c_next_tx_seq = 1; 887c0dd49bdSEiji Ota mutex_init(&conn->c_lock, NULL, MUTEX_DRIVER, NULL); 888c0dd49bdSEiji Ota mutex_init(&conn->c_send_lock, NULL, MUTEX_DRIVER, NULL); 8895d5562f5SEiji Ota conn->c_send_generation = 1; 8905d5562f5SEiji Ota conn->c_senders = 0; 8915d5562f5SEiji Ota 892c0dd49bdSEiji Ota list_create(&conn->c_send_queue, sizeof (struct rdsv3_message), 893c0dd49bdSEiji Ota offsetof(struct rdsv3_message, m_conn_item)); 894c0dd49bdSEiji Ota list_create(&conn->c_retrans, sizeof (struct rdsv3_message), 895c0dd49bdSEiji Ota offsetof(struct rdsv3_message, m_conn_item)); 896c0dd49bdSEiji Ota return (0); 897c0dd49bdSEiji Ota } 898c0dd49bdSEiji Ota 899c0dd49bdSEiji Ota /* ARGSUSED */ 900c0dd49bdSEiji Ota void 901c0dd49bdSEiji Ota rdsv3_conn_destructor(void *buf, void *arg) 902c0dd49bdSEiji Ota { 903c0dd49bdSEiji Ota struct rdsv3_connection *conn = buf; 904c0dd49bdSEiji Ota 905c0dd49bdSEiji Ota ASSERT(list_is_empty(&conn->c_send_queue)); 906c0dd49bdSEiji Ota ASSERT(list_is_empty(&conn->c_retrans)); 907c0dd49bdSEiji Ota list_destroy(&conn->c_send_queue); 908c0dd49bdSEiji Ota list_destroy(&conn->c_retrans); 909c0dd49bdSEiji Ota mutex_destroy(&conn->c_send_lock); 910c0dd49bdSEiji Ota mutex_destroy(&conn->c_lock); 911c0dd49bdSEiji Ota } 912c0dd49bdSEiji Ota 913c0dd49bdSEiji Ota int 914c0dd49bdSEiji Ota rdsv3_conn_compare(const void *conn1, const void *conn2) 915c0dd49bdSEiji Ota { 916c0dd49bdSEiji Ota uint32_be_t laddr1, faddr1, laddr2, faddr2; 917c0dd49bdSEiji Ota 918c0dd49bdSEiji Ota laddr1 = ((rdsv3_conn_info_t *)conn1)->c_laddr; 919c0dd49bdSEiji Ota laddr2 = ((struct rdsv3_connection *)conn2)->c_laddr; 920c0dd49bdSEiji Ota 921c0dd49bdSEiji Ota if (laddr1 == laddr2) { 922c0dd49bdSEiji Ota faddr1 = ((rdsv3_conn_info_t *)conn1)->c_faddr; 923c0dd49bdSEiji Ota faddr2 = ((struct rdsv3_connection *)conn2)->c_faddr; 924c0dd49bdSEiji Ota if (faddr1 == faddr2) 925c0dd49bdSEiji Ota return (0); 926c0dd49bdSEiji Ota if (faddr1 < faddr2) 927c0dd49bdSEiji Ota return (-1); 928c0dd49bdSEiji Ota return (1); 929c0dd49bdSEiji Ota } 930c0dd49bdSEiji Ota 931c0dd49bdSEiji Ota if (laddr1 < laddr2) 932c0dd49bdSEiji Ota return (-1); 933c0dd49bdSEiji Ota 934c0dd49bdSEiji Ota return (1); 935c0dd49bdSEiji Ota } 936c0dd49bdSEiji Ota 937d2b539e7Sagiri /* rdsv3_ib_incoming cache */ 938d2b539e7Sagiri /* ARGSUSED */ 939d2b539e7Sagiri int 940d2b539e7Sagiri rdsv3_ib_inc_constructor(void *buf, void *arg, int kmflags) 941d2b539e7Sagiri { 942d2b539e7Sagiri list_create(&((struct rdsv3_ib_incoming *)buf)->ii_frags, 943d2b539e7Sagiri sizeof (struct rdsv3_page_frag), 944d2b539e7Sagiri offsetof(struct rdsv3_page_frag, f_item)); 945d2b539e7Sagiri 946d2b539e7Sagiri return (0); 947d2b539e7Sagiri } 948d2b539e7Sagiri 949d2b539e7Sagiri /* ARGSUSED */ 950d2b539e7Sagiri void 951d2b539e7Sagiri rdsv3_ib_inc_destructor(void *buf, void *arg) 952d2b539e7Sagiri { 953d2b539e7Sagiri list_destroy(&((struct rdsv3_ib_incoming *)buf)->ii_frags); 954d2b539e7Sagiri } 955d2b539e7Sagiri 956d2b539e7Sagiri /* ib_frag_slab cache */ 957d2b539e7Sagiri /* ARGSUSED */ 958d2b539e7Sagiri int 959d2b539e7Sagiri rdsv3_ib_frag_constructor(void *buf, void *arg, int kmflags) 960d2b539e7Sagiri { 961d2b539e7Sagiri struct rdsv3_page_frag *frag = (struct rdsv3_page_frag *)buf; 962d2b539e7Sagiri struct rdsv3_ib_device *rds_ibdev = (struct rdsv3_ib_device *)arg; 963d2b539e7Sagiri ibt_iov_attr_t iov_attr; 964d2b539e7Sagiri ibt_iov_t iov_arr[1]; 965d2b539e7Sagiri ibt_all_wr_t wr; 966d2b539e7Sagiri 967d2b539e7Sagiri bzero(frag, sizeof (struct rdsv3_page_frag)); 968d2b539e7Sagiri list_link_init(&frag->f_item); 969d2b539e7Sagiri 970d2b539e7Sagiri frag->f_page = kmem_alloc(PAGE_SIZE, kmflags); 971d2b539e7Sagiri if (frag->f_page == NULL) { 972d2b539e7Sagiri RDSV3_DPRINTF2("rdsv3_ib_frag_constructor", 973d2b539e7Sagiri "kmem_alloc for %d failed", PAGE_SIZE); 974d2b539e7Sagiri return (-1); 975d2b539e7Sagiri } 976d2b539e7Sagiri frag->f_offset = 0; 977d2b539e7Sagiri 978d2b539e7Sagiri iov_attr.iov_as = NULL; 979d2b539e7Sagiri iov_attr.iov = &iov_arr[0]; 980d2b539e7Sagiri iov_attr.iov_buf = NULL; 981d2b539e7Sagiri iov_attr.iov_list_len = 1; 982d2b539e7Sagiri iov_attr.iov_wr_nds = 1; 983d2b539e7Sagiri iov_attr.iov_lso_hdr_sz = 0; 984d2b539e7Sagiri iov_attr.iov_flags = IBT_IOV_SLEEP | IBT_IOV_RECV; 985d2b539e7Sagiri 986d2b539e7Sagiri iov_arr[0].iov_addr = frag->f_page; 987d2b539e7Sagiri iov_arr[0].iov_len = PAGE_SIZE; 988d2b539e7Sagiri 989d2b539e7Sagiri wr.recv.wr_nds = 1; 990d2b539e7Sagiri wr.recv.wr_sgl = &frag->f_sge; 991d2b539e7Sagiri 992d2b539e7Sagiri if (ibt_map_mem_iov(ib_get_ibt_hca_hdl(rds_ibdev->dev), 993d2b539e7Sagiri &iov_attr, &wr, &frag->f_mapped) != IBT_SUCCESS) { 994d2b539e7Sagiri RDSV3_DPRINTF2("rdsv3_ib_frag_constructor", 995d2b539e7Sagiri "ibt_map_mem_iov failed"); 996d2b539e7Sagiri kmem_free(frag->f_page, PAGE_SIZE); 997d2b539e7Sagiri return (-1); 998d2b539e7Sagiri } 999d2b539e7Sagiri 1000d2b539e7Sagiri return (0); 1001d2b539e7Sagiri } 1002d2b539e7Sagiri 1003d2b539e7Sagiri /* ARGSUSED */ 1004d2b539e7Sagiri void 1005d2b539e7Sagiri rdsv3_ib_frag_destructor(void *buf, void *arg) 1006d2b539e7Sagiri { 1007d2b539e7Sagiri struct rdsv3_page_frag *frag = (struct rdsv3_page_frag *)buf; 1008d2b539e7Sagiri struct rdsv3_ib_device *rds_ibdev = (struct rdsv3_ib_device *)arg; 1009d2b539e7Sagiri 1010d2b539e7Sagiri /* unmap the page */ 1011d2b539e7Sagiri if (ibt_unmap_mem_iov(ib_get_ibt_hca_hdl(rds_ibdev->dev), 1012d2b539e7Sagiri frag->f_mapped) != IBT_SUCCESS) 1013d2b539e7Sagiri RDSV3_DPRINTF2("rdsv3_ib_frag_destructor", 1014d2b539e7Sagiri "ibt_unmap_mem_iov failed"); 1015d2b539e7Sagiri 1016d2b539e7Sagiri /* free the page */ 1017d2b539e7Sagiri kmem_free(frag->f_page, PAGE_SIZE); 1018d2b539e7Sagiri } 1019d2b539e7Sagiri 1020c0dd49bdSEiji Ota /* loop.c */ 1021c0dd49bdSEiji Ota extern kmutex_t loop_conns_lock; 1022c0dd49bdSEiji Ota extern list_t loop_conns; 1023c0dd49bdSEiji Ota 1024c0dd49bdSEiji Ota struct rdsv3_loop_connection 1025c0dd49bdSEiji Ota { 1026c0dd49bdSEiji Ota struct list_node loop_node; 1027c0dd49bdSEiji Ota struct rdsv3_connection *conn; 1028c0dd49bdSEiji Ota }; 1029c0dd49bdSEiji Ota 1030c0dd49bdSEiji Ota void 1031c0dd49bdSEiji Ota rdsv3_loop_init(void) 1032c0dd49bdSEiji Ota { 1033c0dd49bdSEiji Ota list_create(&loop_conns, sizeof (struct rdsv3_loop_connection), 1034c0dd49bdSEiji Ota offsetof(struct rdsv3_loop_connection, loop_node)); 1035c0dd49bdSEiji Ota mutex_init(&loop_conns_lock, NULL, MUTEX_DRIVER, NULL); 1036c0dd49bdSEiji Ota } 1037c0dd49bdSEiji Ota 1038c0dd49bdSEiji Ota /* rdma.c */ 1039c0dd49bdSEiji Ota /* IB Rkey is used here for comparison */ 1040c0dd49bdSEiji Ota int 1041c0dd49bdSEiji Ota rdsv3_mr_compare(const void *mr1, const void *mr2) 1042c0dd49bdSEiji Ota { 1043c0dd49bdSEiji Ota uint32_t key1 = *(uint32_t *)mr1; 1044c0dd49bdSEiji Ota uint32_t key2 = ((struct rdsv3_mr *)mr2)->r_key; 1045c0dd49bdSEiji Ota 1046c0dd49bdSEiji Ota if (key1 < key2) 1047c0dd49bdSEiji Ota return (-1); 1048c0dd49bdSEiji Ota if (key1 > key2) 1049c0dd49bdSEiji Ota return (1); 1050c0dd49bdSEiji Ota return (0); 1051c0dd49bdSEiji Ota } 1052c0dd49bdSEiji Ota 1053c0dd49bdSEiji Ota /* transport.c */ 1054cadbfdc3SEiji Ota extern struct rdsv3_transport *transports[]; 1055c0dd49bdSEiji Ota extern krwlock_t trans_sem; 1056c0dd49bdSEiji Ota 1057c0dd49bdSEiji Ota void 1058c0dd49bdSEiji Ota rdsv3_trans_exit(void) 1059c0dd49bdSEiji Ota { 1060c0dd49bdSEiji Ota struct rdsv3_transport *trans; 1061cadbfdc3SEiji Ota int i; 1062c0dd49bdSEiji Ota 1063c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_trans_exit", "Enter"); 1064c0dd49bdSEiji Ota 1065c0dd49bdSEiji Ota /* currently, only IB transport */ 1066c0dd49bdSEiji Ota rw_enter(&trans_sem, RW_READER); 1067c0dd49bdSEiji Ota trans = NULL; 1068cadbfdc3SEiji Ota for (i = 0; i < RDS_TRANS_COUNT; i++) { 1069cadbfdc3SEiji Ota if (transports[i]) { 1070cadbfdc3SEiji Ota trans = transports[i]; 1071cadbfdc3SEiji Ota break; 1072cadbfdc3SEiji Ota } 1073cadbfdc3SEiji Ota } 1074c0dd49bdSEiji Ota rw_exit(&trans_sem); 1075c0dd49bdSEiji Ota 1076c0dd49bdSEiji Ota /* trans->exit() will remove the trans from the list */ 1077c0dd49bdSEiji Ota if (trans) 1078c0dd49bdSEiji Ota trans->exit(); 1079c0dd49bdSEiji Ota 1080c0dd49bdSEiji Ota rw_destroy(&trans_sem); 1081c0dd49bdSEiji Ota 1082c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_trans_exit", "Return"); 1083c0dd49bdSEiji Ota } 1084c0dd49bdSEiji Ota 1085c0dd49bdSEiji Ota void 1086c0dd49bdSEiji Ota rdsv3_trans_init() 1087c0dd49bdSEiji Ota { 1088c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_trans_init", "Enter"); 1089c0dd49bdSEiji Ota 1090c0dd49bdSEiji Ota rw_init(&trans_sem, NULL, RW_DRIVER, NULL); 1091c0dd49bdSEiji Ota 1092c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_trans_init", "Return"); 1093c0dd49bdSEiji Ota } 1094c0dd49bdSEiji Ota 1095c0dd49bdSEiji Ota int 1096c0dd49bdSEiji Ota rdsv3_put_cmsg(struct nmsghdr *msg, int level, int type, size_t size, 1097c0dd49bdSEiji Ota void *payload) 1098c0dd49bdSEiji Ota { 1099c0dd49bdSEiji Ota struct cmsghdr *cp; 1100c0dd49bdSEiji Ota char *bp; 1101c0dd49bdSEiji Ota size_t cmlen; 1102c0dd49bdSEiji Ota size_t cmspace; 1103c0dd49bdSEiji Ota size_t bufsz; 1104c0dd49bdSEiji Ota 1105c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_put_cmsg", 1106c0dd49bdSEiji Ota "Enter(msg: %p level: %d type: %d sz: %d)", 1107c0dd49bdSEiji Ota msg, level, type, size); 1108c0dd49bdSEiji Ota 11099b3d509cSEiji Ota if (msg == NULL || msg->msg_controllen == 0) { 1110c0dd49bdSEiji Ota return (0); 1111c0dd49bdSEiji Ota } 1112c0dd49bdSEiji Ota /* check for first cmsg or this is another cmsg to be appended */ 1113c0dd49bdSEiji Ota if (msg->msg_control == NULL) 1114c0dd49bdSEiji Ota msg->msg_controllen = 0; 1115c0dd49bdSEiji Ota 1116c0dd49bdSEiji Ota cmlen = CMSG_LEN(size); 1117c0dd49bdSEiji Ota cmspace = CMSG_SPACE(size); 1118c0dd49bdSEiji Ota bufsz = msg->msg_controllen + cmspace; 1119c0dd49bdSEiji Ota 1120c0dd49bdSEiji Ota /* extend the existing cmsg to append the next cmsg */ 1121c0dd49bdSEiji Ota bp = kmem_alloc(bufsz, KM_SLEEP); 1122c0dd49bdSEiji Ota if (msg->msg_control) { 1123c0dd49bdSEiji Ota bcopy(msg->msg_control, bp, msg->msg_controllen); 1124c0dd49bdSEiji Ota kmem_free(msg->msg_control, (size_t)msg->msg_controllen); 1125c0dd49bdSEiji Ota } 1126c0dd49bdSEiji Ota 1127c0dd49bdSEiji Ota /* assign payload the proper cmsg location */ 1128c0dd49bdSEiji Ota cp = (struct cmsghdr *)(bp + msg->msg_controllen); 1129c0dd49bdSEiji Ota cp->cmsg_len = cmlen; 1130c0dd49bdSEiji Ota cp->cmsg_level = level; 1131c0dd49bdSEiji Ota cp->cmsg_type = type; 1132c0dd49bdSEiji Ota 1133c0dd49bdSEiji Ota bcopy(payload, CMSG_DATA(cp), cmlen - 1134c0dd49bdSEiji Ota (unsigned int)_CMSG_DATA_ALIGN(sizeof (struct cmsghdr))); 1135c0dd49bdSEiji Ota 1136c0dd49bdSEiji Ota msg->msg_control = bp; 1137c0dd49bdSEiji Ota msg->msg_controllen = bufsz; 1138c0dd49bdSEiji Ota 1139c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_put_cmsg", "Return(cmsg_len: %d)", cp->cmsg_len); 1140c0dd49bdSEiji Ota 1141c0dd49bdSEiji Ota return (0); 1142c0dd49bdSEiji Ota } 1143c0dd49bdSEiji Ota 1144c0dd49bdSEiji Ota /* ARGSUSED */ 1145c0dd49bdSEiji Ota int 1146c0dd49bdSEiji Ota rdsv3_verify_bind_address(ipaddr_t addr) 1147c0dd49bdSEiji Ota { 1148c0dd49bdSEiji Ota return (1); 1149c0dd49bdSEiji Ota } 1150c0dd49bdSEiji Ota 1151c0dd49bdSEiji Ota /* checksum */ 1152c0dd49bdSEiji Ota uint16_t 1153c0dd49bdSEiji Ota rdsv3_ip_fast_csum(void *hdr, size_t length) 1154c0dd49bdSEiji Ota { 1155c0dd49bdSEiji Ota return (0xffff & 1156c0dd49bdSEiji Ota (uint16_t)(~ip_ocsum((ushort_t *)hdr, (int)length <<1, 0))); 1157c0dd49bdSEiji Ota } 1158c0dd49bdSEiji Ota 1159c0dd49bdSEiji Ota /* scatterlist implementation */ 1160c0dd49bdSEiji Ota /* ARGSUSED */ 1161c0dd49bdSEiji Ota caddr_t 1162c0dd49bdSEiji Ota rdsv3_ib_sg_dma_address(ib_device_t *dev, struct rdsv3_scatterlist *scat, 1163c0dd49bdSEiji Ota uint_t offset) 1164c0dd49bdSEiji Ota { 1165c0dd49bdSEiji Ota return (0); 1166c0dd49bdSEiji Ota } 1167c0dd49bdSEiji Ota 1168c0dd49bdSEiji Ota uint_t 1169c0dd49bdSEiji Ota rdsv3_ib_dma_map_sg(struct ib_device *dev, struct rdsv3_scatterlist *scat, 1170c0dd49bdSEiji Ota uint_t num) 1171c0dd49bdSEiji Ota { 1172c0dd49bdSEiji Ota struct rdsv3_scatterlist *s, *first; 1173c0dd49bdSEiji Ota ibt_iov_t *iov; 1174c0dd49bdSEiji Ota ibt_wr_ds_t *sgl; 1175c0dd49bdSEiji Ota ibt_iov_attr_t iov_attr; 1176c0dd49bdSEiji Ota ibt_send_wr_t swr; 1177c0dd49bdSEiji Ota uint_t i; 1178c0dd49bdSEiji Ota 1179c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_ib_dma_map_sg", "scat %p, num: %d", scat, num); 1180c0dd49bdSEiji Ota 1181c0dd49bdSEiji Ota s = first = &scat[0]; 1182c0dd49bdSEiji Ota ASSERT(first->mihdl == NULL); 1183c0dd49bdSEiji Ota 1184c0dd49bdSEiji Ota iov = kmem_alloc(num * sizeof (ibt_iov_t), KM_SLEEP); 1185c0dd49bdSEiji Ota sgl = kmem_zalloc((num * 2) * sizeof (ibt_wr_ds_t), KM_SLEEP); 1186c0dd49bdSEiji Ota 1187c0dd49bdSEiji Ota for (i = 0; i < num; i++, s++) { 1188c0dd49bdSEiji Ota iov[i].iov_addr = s->vaddr; 1189c0dd49bdSEiji Ota iov[i].iov_len = s->length; 1190c0dd49bdSEiji Ota } 1191c0dd49bdSEiji Ota 1192c0dd49bdSEiji Ota iov_attr.iov_as = NULL; 1193c0dd49bdSEiji Ota iov_attr.iov = iov; 1194c0dd49bdSEiji Ota iov_attr.iov_buf = NULL; 1195c0dd49bdSEiji Ota iov_attr.iov_list_len = num; 1196c0dd49bdSEiji Ota iov_attr.iov_wr_nds = num * 2; 1197c0dd49bdSEiji Ota iov_attr.iov_lso_hdr_sz = 0; 1198c0dd49bdSEiji Ota iov_attr.iov_flags = IBT_IOV_SLEEP; 1199c0dd49bdSEiji Ota 1200c0dd49bdSEiji Ota swr.wr_sgl = sgl; 1201c0dd49bdSEiji Ota 1202c0dd49bdSEiji Ota i = ibt_map_mem_iov(ib_get_ibt_hca_hdl(dev), 1203c0dd49bdSEiji Ota &iov_attr, (ibt_all_wr_t *)&swr, &first->mihdl); 1204c0dd49bdSEiji Ota kmem_free(iov, num * sizeof (ibt_iov_t)); 1205c0dd49bdSEiji Ota if (i != IBT_SUCCESS) { 1206c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_ib_dma_map_sg", 1207c0dd49bdSEiji Ota "ibt_map_mem_iov returned: %d", i); 1208c0dd49bdSEiji Ota return (0); 1209c0dd49bdSEiji Ota } 1210c0dd49bdSEiji Ota 1211c0dd49bdSEiji Ota s = first; 1212c0dd49bdSEiji Ota for (i = 0; i < num; i++, s++, sgl++) { 1213c0dd49bdSEiji Ota s->sgl = sgl; 1214c0dd49bdSEiji Ota } 1215c0dd49bdSEiji Ota 1216c0dd49bdSEiji Ota return (num); 1217c0dd49bdSEiji Ota } 1218c0dd49bdSEiji Ota 1219c0dd49bdSEiji Ota void 1220c0dd49bdSEiji Ota rdsv3_ib_dma_unmap_sg(ib_device_t *dev, struct rdsv3_scatterlist *scat, 1221c0dd49bdSEiji Ota uint_t num) 1222c0dd49bdSEiji Ota { 1223c0dd49bdSEiji Ota /* Zero length messages have no scatter gather entries */ 1224c0dd49bdSEiji Ota if (num != 0) { 1225c0dd49bdSEiji Ota ASSERT(scat->mihdl != NULL); 1226c0dd49bdSEiji Ota ASSERT(scat->sgl != NULL); 1227c0dd49bdSEiji Ota 1228c0dd49bdSEiji Ota (void) ibt_unmap_mem_iov(ib_get_ibt_hca_hdl(dev), scat->mihdl); 1229c0dd49bdSEiji Ota 1230c0dd49bdSEiji Ota kmem_free(scat->sgl, (num * 2) * sizeof (ibt_wr_ds_t)); 1231c0dd49bdSEiji Ota scat->sgl = NULL; 1232c0dd49bdSEiji Ota scat->mihdl = NULL; 1233c0dd49bdSEiji Ota } 1234c0dd49bdSEiji Ota } 1235c0dd49bdSEiji Ota 1236c0dd49bdSEiji Ota int 1237c0dd49bdSEiji Ota rdsv3_ib_alloc_hdrs(ib_device_t *dev, struct rdsv3_ib_connection *ic) 1238c0dd49bdSEiji Ota { 1239c0dd49bdSEiji Ota caddr_t addr; 1240c0dd49bdSEiji Ota size_t size; 1241c0dd49bdSEiji Ota ibt_mr_attr_t mr_attr; 1242c0dd49bdSEiji Ota ibt_mr_desc_t mr_desc; 1243c0dd49bdSEiji Ota ibt_mr_hdl_t mr_hdl; 1244c0dd49bdSEiji Ota int ret; 1245c0dd49bdSEiji Ota 1246c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_ib_alloc_hdrs", "Enter(dev: %p)", dev); 1247c0dd49bdSEiji Ota 1248c0dd49bdSEiji Ota ASSERT(ic->i_mr == NULL); 1249c0dd49bdSEiji Ota 1250c0dd49bdSEiji Ota size = (ic->i_send_ring.w_nr + ic->i_recv_ring.w_nr + 1) * 1251c0dd49bdSEiji Ota sizeof (struct rdsv3_header); 1252c0dd49bdSEiji Ota 1253c0dd49bdSEiji Ota addr = kmem_zalloc(size, KM_NOSLEEP); 1254c0dd49bdSEiji Ota if (addr == NULL) 1255c0dd49bdSEiji Ota return (-1); 1256c0dd49bdSEiji Ota 1257c0dd49bdSEiji Ota mr_attr.mr_vaddr = (ib_vaddr_t)(uintptr_t)addr; 1258c0dd49bdSEiji Ota mr_attr.mr_len = size; 1259c0dd49bdSEiji Ota mr_attr.mr_as = NULL; 1260c0dd49bdSEiji Ota mr_attr.mr_flags = IBT_MR_ENABLE_LOCAL_WRITE; 1261c0dd49bdSEiji Ota ret = ibt_register_mr(ib_get_ibt_hca_hdl(dev), RDSV3_PD2PDHDL(ic->i_pd), 1262c0dd49bdSEiji Ota &mr_attr, &mr_hdl, &mr_desc); 1263c0dd49bdSEiji Ota if (ret != IBT_SUCCESS) { 1264c0dd49bdSEiji Ota RDSV3_DPRINTF2("rdsv3_ib_alloc_hdrs", 1265c0dd49bdSEiji Ota "ibt_register_mr returned: " "%d", ret); 1266c0dd49bdSEiji Ota return (-1); 1267c0dd49bdSEiji Ota } 1268c0dd49bdSEiji Ota 1269c0dd49bdSEiji Ota ic->i_mr = 1270c0dd49bdSEiji Ota (struct rdsv3_hdrs_mr *)kmem_alloc(sizeof (struct rdsv3_hdrs_mr), 1271c0dd49bdSEiji Ota KM_SLEEP); 1272c0dd49bdSEiji Ota ic->i_mr->addr = addr; 1273c0dd49bdSEiji Ota ic->i_mr->size = size; 1274c0dd49bdSEiji Ota ic->i_mr->hdl = mr_hdl; 1275c0dd49bdSEiji Ota ic->i_mr->lkey = mr_desc.md_lkey; 1276c0dd49bdSEiji Ota 1277c0dd49bdSEiji Ota ic->i_send_hdrs = (struct rdsv3_header *)addr; 1278c0dd49bdSEiji Ota ic->i_send_hdrs_dma = (uint64_t)(uintptr_t)addr; 1279c0dd49bdSEiji Ota 1280c0dd49bdSEiji Ota ic->i_recv_hdrs = (struct rdsv3_header *)(addr + 1281c0dd49bdSEiji Ota (ic->i_send_ring.w_nr * sizeof (struct rdsv3_header))); 1282c0dd49bdSEiji Ota ic->i_recv_hdrs_dma = (uint64_t)(uintptr_t)(addr + 1283c0dd49bdSEiji Ota (ic->i_send_ring.w_nr * sizeof (struct rdsv3_header))); 1284c0dd49bdSEiji Ota 1285c0dd49bdSEiji Ota ic->i_ack = (struct rdsv3_header *)(addr + 1286c0dd49bdSEiji Ota ((ic->i_send_ring.w_nr + ic->i_recv_ring.w_nr) * 1287c0dd49bdSEiji Ota sizeof (struct rdsv3_header))); 1288c0dd49bdSEiji Ota ic->i_ack_dma = (uint64_t)(uintptr_t)(addr + 1289c0dd49bdSEiji Ota ((ic->i_send_ring.w_nr + ic->i_recv_ring.w_nr) * 1290c0dd49bdSEiji Ota sizeof (struct rdsv3_header))); 1291c0dd49bdSEiji Ota 1292c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_ib_alloc_hdrs", "Return(dev: %p)", dev); 1293c0dd49bdSEiji Ota 1294c0dd49bdSEiji Ota return (0); 1295c0dd49bdSEiji Ota } 1296c0dd49bdSEiji Ota 1297c0dd49bdSEiji Ota void 1298c0dd49bdSEiji Ota rdsv3_ib_free_hdrs(ib_device_t *dev, struct rdsv3_ib_connection *ic) 1299c0dd49bdSEiji Ota { 1300c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_ib_free_hdrs", "Enter(dev: %p)", dev); 1301c0dd49bdSEiji Ota ASSERT(ic->i_mr != NULL); 1302c0dd49bdSEiji Ota 1303c0dd49bdSEiji Ota ic->i_send_hdrs = NULL; 13049af7e484SToomas Soome ic->i_send_hdrs_dma = 0; 1305c0dd49bdSEiji Ota 1306c0dd49bdSEiji Ota ic->i_recv_hdrs = NULL; 13079af7e484SToomas Soome ic->i_recv_hdrs_dma = 0; 1308c0dd49bdSEiji Ota 1309c0dd49bdSEiji Ota ic->i_ack = NULL; 13109af7e484SToomas Soome ic->i_ack_dma = 0; 1311c0dd49bdSEiji Ota 1312c0dd49bdSEiji Ota (void) ibt_deregister_mr(ib_get_ibt_hca_hdl(dev), ic->i_mr->hdl); 1313c0dd49bdSEiji Ota 1314c0dd49bdSEiji Ota kmem_free(ic->i_mr->addr, ic->i_mr->size); 1315c0dd49bdSEiji Ota kmem_free(ic->i_mr, sizeof (struct rdsv3_hdrs_mr)); 1316c0dd49bdSEiji Ota 1317c0dd49bdSEiji Ota ic->i_mr = NULL; 1318c0dd49bdSEiji Ota RDSV3_DPRINTF4("rdsv3_ib_free_hdrs", "Return(dev: %p)", dev); 1319c0dd49bdSEiji Ota } 1320cadbfdc3SEiji Ota 1321cadbfdc3SEiji Ota /* 1322cadbfdc3SEiji Ota * atomic_add_unless - add unless the number is a given value 1323cadbfdc3SEiji Ota * @v: pointer of type atomic_t 1324cadbfdc3SEiji Ota * @a: the amount to add to v... 1325cadbfdc3SEiji Ota * @u: ...unless v is equal to u. 1326cadbfdc3SEiji Ota * 1327cadbfdc3SEiji Ota * Atomically adds @a to @v, so long as it was not @u. 1328cadbfdc3SEiji Ota * Returns non-zero if @v was not @u, and zero otherwise. 1329cadbfdc3SEiji Ota */ 1330cadbfdc3SEiji Ota int 1331cadbfdc3SEiji Ota atomic_add_unless(atomic_t *v, uint_t a, ulong_t u) 1332cadbfdc3SEiji Ota { 1333cadbfdc3SEiji Ota uint_t c, old; 1334cadbfdc3SEiji Ota 1335cadbfdc3SEiji Ota c = *v; 1336cadbfdc3SEiji Ota while (c != u && (old = atomic_cas_uint(v, c, c + a)) != c) { 1337cadbfdc3SEiji Ota c = old; 1338cadbfdc3SEiji Ota } 1339cadbfdc3SEiji Ota return ((ulong_t)c != u); 1340cadbfdc3SEiji Ota } 1341