1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Copyright 2019, Joyent, Inc. 28 */ 29 30 #include <sys/types.h> 31 #include <inet/common.h> 32 #include <sys/stropts.h> 33 #include <sys/modctl.h> 34 #include <sys/dld.h> 35 #include <sys/softmac_impl.h> 36 37 dev_info_t *softmac_dip = NULL; 38 static kmem_cache_t *softmac_upper_cachep; 39 40 /* 41 * This function is a generic open(9E) entry point into the softmac for 42 * both the softmac module and the softmac driver. 43 */ 44 static int softmac_cmn_open(queue_t *, dev_t *, int, int, cred_t *); 45 46 /* 47 * The following softmac_mod_xxx() functions are (9E) entry point functions for 48 * the softmac module. 49 */ 50 static int softmac_mod_close(queue_t *, int, cred_t *); 51 static int softmac_mod_rput(queue_t *, mblk_t *); 52 static int softmac_mod_wput(queue_t *, mblk_t *); 53 static int softmac_mod_wsrv(queue_t *); 54 55 /* 56 * The following softmac_drv_xxx() functions are (9E) entry point functions for 57 * the softmac driver. 58 */ 59 static int softmac_drv_open(queue_t *, dev_t *, int, int, cred_t *); 60 static int softmac_drv_close(queue_t *, int, cred_t *); 61 static int softmac_drv_wput(queue_t *, mblk_t *); 62 static int softmac_drv_wsrv(queue_t *); 63 64 static int softmac_attach(dev_info_t *, ddi_attach_cmd_t); 65 static int softmac_detach(dev_info_t *, ddi_detach_cmd_t); 66 static int softmac_info(dev_info_t *, ddi_info_cmd_t, void *, void **); 67 68 static struct module_info softmac_modinfo = { 69 0, 70 SOFTMAC_DEV_NAME, 71 0, 72 INFPSZ, 73 65536, 74 1024 75 }; 76 77 /* 78 * hi-water mark is 1 because of the flow control mechanism implemented in 79 * dld. Refer to the comments in dld_str.c for details. 80 */ 81 static struct module_info softmac_dld_modinfo = { 82 0, 83 SOFTMAC_DEV_NAME, 84 0, 85 INFPSZ, 86 1, 87 0 88 }; 89 90 static struct qinit softmac_urinit = { 91 softmac_mod_rput, /* qi_putp */ 92 NULL, /* qi_srvp */ 93 softmac_cmn_open, /* qi_qopen */ 94 softmac_mod_close, /* qi_qclose */ 95 NULL, /* qi_qadmin */ 96 &softmac_modinfo /* qi_minfo */ 97 }; 98 99 static struct qinit softmac_uwinit = { 100 softmac_mod_wput, /* qi_putp */ 101 softmac_mod_wsrv, /* qi_srvp */ 102 NULL, /* qi_qopen */ 103 NULL, /* qi_qclose */ 104 NULL, /* qi_qadmin */ 105 &softmac_modinfo /* qi_minfo */ 106 }; 107 108 static struct streamtab softmac_tab = { 109 &softmac_urinit, /* st_rdinit */ 110 &softmac_uwinit /* st_wrinit */ 111 }; 112 113 DDI_DEFINE_STREAM_OPS(softmac_ops, nulldev, nulldev, softmac_attach, 114 softmac_detach, nodev, softmac_info, D_MP, &softmac_tab, 115 ddi_quiesce_not_supported); 116 117 static struct qinit softmac_dld_r_qinit = { 118 NULL, NULL, softmac_drv_open, softmac_drv_close, NULL, 119 &softmac_dld_modinfo 120 }; 121 122 static struct qinit softmac_dld_w_qinit = { 123 softmac_drv_wput, softmac_drv_wsrv, NULL, NULL, NULL, 124 &softmac_dld_modinfo 125 }; 126 127 static struct fmodsw softmac_fmodsw = { 128 SOFTMAC_DEV_NAME, 129 &softmac_tab, 130 D_MP 131 }; 132 133 static struct modldrv softmac_modldrv = { 134 &mod_driverops, 135 "softmac driver", 136 &softmac_ops 137 }; 138 139 static struct modlstrmod softmac_modlstrmod = { 140 &mod_strmodops, 141 "softmac module", 142 &softmac_fmodsw 143 }; 144 145 static struct modlinkage softmac_modlinkage = { 146 MODREV_1, 147 &softmac_modlstrmod, 148 &softmac_modldrv, 149 NULL 150 }; 151 152 static void softmac_dedicated_rx(void *, mac_resource_handle_t, mblk_t *, 153 mac_header_info_t *); 154 155 /*ARGSUSED*/ 156 static int 157 softmac_upper_constructor(void *buf, void *arg, int kmflag) 158 { 159 softmac_upper_t *sup = buf; 160 161 bzero(buf, sizeof (softmac_upper_t)); 162 163 mutex_init(&sup->su_mutex, NULL, MUTEX_DEFAULT, NULL); 164 cv_init(&sup->su_cv, NULL, CV_DEFAULT, NULL); 165 mutex_init(&sup->su_disp_mutex, NULL, MUTEX_DEFAULT, NULL); 166 cv_init(&sup->su_disp_cv, NULL, CV_DEFAULT, NULL); 167 list_create(&sup->su_req_list, sizeof (softmac_switch_req_t), 168 offsetof(softmac_switch_req_t, ssq_req_list_node)); 169 return (0); 170 } 171 172 /*ARGSUSED*/ 173 static void 174 softmac_upper_destructor(void *buf, void *arg) 175 { 176 softmac_upper_t *sup = buf; 177 178 ASSERT(sup->su_slp == NULL); 179 ASSERT(sup->su_pending_head == NULL && sup->su_pending_tail == NULL); 180 ASSERT(!sup->su_dlpi_pending); 181 ASSERT(!sup->su_active); 182 ASSERT(!sup->su_closing); 183 ASSERT(sup->su_tx_flow_mp == NULL); 184 ASSERT(sup->su_tx_inprocess == 0); 185 ASSERT(sup->su_mode == SOFTMAC_UNKNOWN); 186 ASSERT(!sup->su_tx_busy); 187 ASSERT(!sup->su_bound); 188 ASSERT(!sup->su_taskq_scheduled); 189 ASSERT(sup->su_tx_notify_func == NULL); 190 ASSERT(sup->su_tx_notify_arg == NULL); 191 ASSERT(list_is_empty(&sup->su_req_list)); 192 193 list_destroy(&sup->su_req_list); 194 mutex_destroy(&sup->su_mutex); 195 cv_destroy(&sup->su_cv); 196 mutex_destroy(&sup->su_disp_mutex); 197 cv_destroy(&sup->su_disp_cv); 198 } 199 200 int 201 _init(void) 202 { 203 int err; 204 205 mac_init_ops(NULL, SOFTMAC_DEV_NAME); 206 softmac_init(); 207 208 softmac_upper_cachep = kmem_cache_create("softmac_upper_cache", 209 sizeof (softmac_upper_t), 0, softmac_upper_constructor, 210 softmac_upper_destructor, NULL, NULL, NULL, 0); 211 ASSERT(softmac_upper_cachep != NULL); 212 213 if ((err = mod_install(&softmac_modlinkage)) != 0) { 214 softmac_fini(); 215 return (err); 216 } 217 218 return (0); 219 } 220 221 int 222 _fini(void) 223 { 224 int err; 225 226 if (softmac_busy()) 227 return (EBUSY); 228 229 if ((err = mod_remove(&softmac_modlinkage)) != 0) 230 return (err); 231 232 kmem_cache_destroy(softmac_upper_cachep); 233 softmac_fini(); 234 235 return (0); 236 } 237 238 int 239 _info(struct modinfo *modinfop) 240 { 241 return (mod_info(&softmac_modlinkage, modinfop)); 242 } 243 244 static int 245 softmac_cmn_open(queue_t *rq, dev_t *devp, int flag, int sflag, cred_t *credp) 246 { 247 softmac_lower_t *slp; 248 /* 249 * This is a self-cloning driver so that each queue should only 250 * get opened once. 251 */ 252 if (rq->q_ptr != NULL) 253 return (EBUSY); 254 255 if (sflag == MODOPEN) { 256 /* 257 * This is the softmac module pushed over an underlying 258 * legacy device. Initialize the lower structure. 259 */ 260 if ((slp = kmem_zalloc(sizeof (*slp), KM_NOSLEEP)) == NULL) 261 return (ENOMEM); 262 263 slp->sl_wq = WR(rq); 264 cv_init(&slp->sl_cv, NULL, CV_DRIVER, NULL); 265 mutex_init(&slp->sl_mutex, NULL, MUTEX_DRIVER, NULL); 266 slp->sl_pending_prim = DL_PRIM_INVAL; 267 rq->q_ptr = WR(rq)->q_ptr = slp; 268 qprocson(rq); 269 return (0); 270 } 271 272 /* 273 * Regular device open of a softmac DLPI node. We modify 274 * the queues' q_qinfo pointer such that all future STREAMS 275 * operations will go through another set of entry points 276 */ 277 rq->q_qinfo = &softmac_dld_r_qinit; 278 WR(rq)->q_qinfo = &softmac_dld_w_qinit; 279 return (softmac_drv_open(rq, devp, flag, sflag, credp)); 280 } 281 282 /* ARGSUSED */ 283 static int 284 softmac_mod_close(queue_t *rq, int flags __unused, cred_t *credp __unused) 285 { 286 softmac_lower_t *slp = rq->q_ptr; 287 288 /* 289 * Call the appropriate delete routine depending on whether this is 290 * a module or device. 291 */ 292 ASSERT(WR(rq)->q_next != NULL); 293 294 qprocsoff(rq); 295 296 slp->sl_softmac = NULL; 297 slp->sl_lh = NULL; 298 299 ASSERT(slp->sl_ack_mp == NULL); 300 ASSERT(slp->sl_pending_prim == DL_PRIM_INVAL); 301 ASSERT(slp->sl_pending_ioctl == B_FALSE); 302 303 cv_destroy(&slp->sl_cv); 304 mutex_destroy(&slp->sl_mutex); 305 306 kmem_free(slp, sizeof (*slp)); 307 return (0); 308 } 309 310 static int 311 softmac_mod_rput(queue_t *rq, mblk_t *mp) 312 { 313 softmac_lower_t *slp = rq->q_ptr; 314 softmac_lower_rxinfo_t *rxinfo; 315 union DL_primitives *dlp; 316 317 /* 318 * This is the softmac module. 319 */ 320 ASSERT(WR(rq)->q_next != NULL); 321 ASSERT((mp->b_next == NULL) && (mp->b_prev == NULL)); 322 323 switch (DB_TYPE(mp)) { 324 case M_DATA: { 325 326 /* 327 * If sl_rxinfo is non-NULL. This is dedicated-lower-stream 328 * created for fastpath. Directly call the rx callback. 329 */ 330 if ((rxinfo = slp->sl_rxinfo) != NULL) { 331 rxinfo->slr_rx(rxinfo->slr_arg, NULL, mp, NULL); 332 break; 333 } 334 335 /* 336 * A shared-lower-stream. Some driver starts to send up 337 * packets even it not in the DL_IDLE state, where 338 * sl_softmac is not set yet. Drop the packet in this case. 339 */ 340 if (slp->sl_softmac == NULL) { 341 freemsg(mp); 342 return (0); 343 } 344 345 /* 346 * If this message is looped back from the legacy devices, 347 * drop it as the Nemo framework will be responsible for 348 * looping it back by the mac_txloop() function. 349 */ 350 if (mp->b_flag & MSGNOLOOP) { 351 freemsg(mp); 352 return (0); 353 } 354 355 /* 356 * This is the most common case. 357 */ 358 if (DB_REF(mp) == 1) { 359 ASSERT(slp->sl_softmac != NULL); 360 mac_rx(slp->sl_softmac->smac_mh, NULL, mp); 361 return (0); 362 } else { 363 softmac_rput_process_data(slp, mp); 364 } 365 break; 366 } 367 case M_PROTO: 368 case M_PCPROTO: 369 if (MBLKL(mp) < sizeof (dlp->dl_primitive)) { 370 freemsg(mp); 371 break; 372 } 373 dlp = (union DL_primitives *)mp->b_rptr; 374 if (dlp->dl_primitive == DL_UNITDATA_IND) { 375 376 if ((rxinfo = slp->sl_rxinfo) != NULL) { 377 softmac_dedicated_rx(slp->sl_sup, NULL, mp, 378 NULL); 379 break; 380 } 381 382 cmn_err(CE_WARN, "got unexpected %s message", 383 dl_primstr(DL_UNITDATA_IND)); 384 freemsg(mp); 385 break; 386 } 387 /*FALLTHROUGH*/ 388 default: 389 softmac_rput_process_notdata(rq, slp->sl_sup, mp); 390 break; 391 } 392 return (0); 393 } 394 395 static int 396 softmac_mod_wput(queue_t *wq, mblk_t *mp) 397 { 398 /* 399 * This is the softmac module 400 */ 401 ASSERT(wq->q_next != NULL); 402 403 switch (DB_TYPE(mp)) { 404 case M_IOCTL: { 405 struct iocblk *ioc = (struct iocblk *)mp->b_rptr; 406 407 switch (ioc->ioc_cmd) { 408 case SMAC_IOC_START: { 409 softmac_lower_t *slp = wq->q_ptr; 410 smac_ioc_start_t *arg; 411 412 if (ioc->ioc_count != sizeof (*arg)) { 413 miocnak(wq, mp, 0, EINVAL); 414 break; 415 } 416 417 /* 418 * Assign the devname and perstream handle of the 419 * specific lower stream and return it as a part 420 * of the ioctl. 421 */ 422 arg = (smac_ioc_start_t *)mp->b_cont->b_rptr; 423 arg->si_slp = slp; 424 miocack(wq, mp, sizeof (*arg), 0); 425 break; 426 } 427 default: 428 miocnak(wq, mp, 0, EINVAL); 429 break; 430 } 431 break; 432 } 433 default: 434 freemsg(mp); 435 break; 436 } 437 return (0); 438 } 439 440 static int 441 softmac_mod_wsrv(queue_t *wq) 442 { 443 softmac_lower_t *slp = wq->q_ptr; 444 445 /* 446 * This is the softmac module 447 */ 448 ASSERT(wq->q_next != NULL); 449 450 /* 451 * Inform that the tx resource is available; mac_tx_update() will 452 * inform all the upper streams sharing this lower stream. 453 */ 454 if (slp->sl_sup != NULL) 455 qenable(slp->sl_sup->su_wq); 456 else if (slp->sl_softmac != NULL) 457 mac_tx_update(slp->sl_softmac->smac_mh); 458 return (0); 459 } 460 461 static int 462 softmac_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 463 { 464 ASSERT(ddi_get_instance(dip) == 0); 465 466 if (cmd != DDI_ATTACH) 467 return (DDI_FAILURE); 468 469 softmac_dip = dip; 470 471 return (DDI_SUCCESS); 472 } 473 474 /* ARGSUSED */ 475 static int 476 softmac_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 477 { 478 if (cmd != DDI_DETACH) 479 return (DDI_FAILURE); 480 481 softmac_dip = NULL; 482 return (DDI_SUCCESS); 483 } 484 485 /* ARGSUSED */ 486 static int 487 softmac_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 488 { 489 switch (infocmd) { 490 case DDI_INFO_DEVT2DEVINFO: 491 if (softmac_dip != NULL) { 492 *result = softmac_dip; 493 return (DDI_SUCCESS); 494 } 495 break; 496 497 case DDI_INFO_DEVT2INSTANCE: 498 *result = NULL; 499 return (DDI_SUCCESS); 500 501 } 502 503 return (DDI_FAILURE); 504 } 505 506 /*ARGSUSED*/ 507 static void 508 softmac_dedicated_rx(void *arg, mac_resource_handle_t mrh, mblk_t *mp, 509 mac_header_info_t *mhip) 510 { 511 queue_t *rq = ((softmac_upper_t *)arg)->su_rq; 512 513 if (canputnext(rq)) 514 putnext(rq, mp); 515 else 516 freemsg(mp); 517 } 518 519 /*ARGSUSED*/ 520 static int 521 softmac_drv_open(queue_t *rq, dev_t *devp, int flag, int sflag, cred_t *credp) 522 { 523 softmac_upper_t *sup = NULL; 524 softmac_t *softmac; 525 int err = 0; 526 527 /* 528 * This is a softmac device created for a legacy device, find the 529 * associated softmac and initialize the softmac_upper_t structure. 530 */ 531 if ((err = softmac_hold(*devp, &softmac)) != 0) 532 return (err); 533 534 sup = kmem_cache_alloc(softmac_upper_cachep, KM_NOSLEEP); 535 if (sup == NULL) { 536 err = ENOMEM; 537 goto fail; 538 } 539 540 ASSERT(list_is_empty(&sup->su_req_list)); 541 542 if ((sup->su_tx_flow_mp = allocb(1, BPRI_HI)) == NULL) { 543 err = ENOMEM; 544 goto fail; 545 } 546 547 sup->su_rq = rq; 548 sup->su_wq = WR(rq); 549 sup->su_softmac = softmac; 550 sup->su_mode = SOFTMAC_UNKNOWN; 551 552 sup->su_rxinfo.slr_arg = sup; 553 sup->su_rxinfo.slr_rx = softmac_dedicated_rx; 554 sup->su_direct_rxinfo.slr_arg = sup; 555 sup->su_direct_rxinfo.slr_rx = softmac_dedicated_rx; 556 557 if ((err = dld_str_open(rq, devp, sup)) != 0) { 558 freeb(sup->su_tx_flow_mp); 559 sup->su_tx_flow_mp = NULL; 560 goto fail; 561 } 562 563 return (0); 564 565 fail: 566 if (sup != NULL) 567 kmem_cache_free(softmac_upper_cachep, sup); 568 softmac_rele(softmac); 569 return (err); 570 } 571 572 /* ARGSUSED */ 573 static int 574 softmac_drv_close(queue_t *rq, int flags __unused, cred_t *credp __unused) 575 { 576 softmac_upper_t *sup = dld_str_private(rq); 577 softmac_t *softmac = sup->su_softmac; 578 579 ASSERT(WR(rq)->q_next == NULL); 580 581 qprocsoff(rq); 582 583 ASSERT(sup->su_tx_inprocess == 0); 584 585 /* 586 * Wait until the pending request are processed by the worker thread. 587 */ 588 mutex_enter(&sup->su_disp_mutex); 589 sup->su_closing = B_TRUE; 590 while (sup->su_dlpi_pending) 591 cv_wait(&sup->su_disp_cv, &sup->su_disp_mutex); 592 mutex_exit(&sup->su_disp_mutex); 593 594 softmac_upperstream_close(sup); 595 596 if (sup->su_tx_flow_mp != NULL) { 597 freeb(sup->su_tx_flow_mp); 598 sup->su_tx_flow_mp = NULL; 599 } 600 601 if (sup->su_active) { 602 mutex_enter(&softmac->smac_active_mutex); 603 softmac->smac_nactive--; 604 mutex_exit(&softmac->smac_active_mutex); 605 sup->su_active = B_FALSE; 606 } 607 608 sup->su_bound = B_FALSE; 609 sup->su_softmac = NULL; 610 sup->su_closing = B_FALSE; 611 612 kmem_cache_free(softmac_upper_cachep, sup); 613 614 softmac_rele(softmac); 615 return (dld_str_close(rq)); 616 } 617 618 static int 619 softmac_drv_wput(queue_t *wq, mblk_t *mp) 620 { 621 softmac_upper_t *sup = dld_str_private(wq); 622 t_uscalar_t prim; 623 624 ASSERT(wq->q_next == NULL); 625 626 switch (DB_TYPE(mp)) { 627 case M_DATA: 628 case M_MULTIDATA: 629 softmac_wput_data(sup, mp); 630 break; 631 case M_PROTO: 632 case M_PCPROTO: 633 634 if (MBLKL(mp) < sizeof (t_uscalar_t)) { 635 freemsg(mp); 636 return (0); 637 } 638 639 prim = ((union DL_primitives *)mp->b_rptr)->dl_primitive; 640 if (prim == DL_UNITDATA_REQ) { 641 softmac_wput_data(sup, mp); 642 return (0); 643 } 644 645 softmac_wput_nondata(sup, mp); 646 break; 647 default: 648 softmac_wput_nondata(sup, mp); 649 break; 650 } 651 return (0); 652 } 653 654 static int 655 softmac_drv_wsrv(queue_t *wq) 656 { 657 softmac_upper_t *sup = dld_str_private(wq); 658 659 ASSERT(wq->q_next == NULL); 660 661 mutex_enter(&sup->su_mutex); 662 if (sup->su_mode != SOFTMAC_FASTPATH) { 663 /* 664 * Bump su_tx_inprocess so that su_mode won't change. 665 */ 666 sup->su_tx_inprocess++; 667 mutex_exit(&sup->su_mutex); 668 (void) dld_wsrv(wq); 669 mutex_enter(&sup->su_mutex); 670 if (--sup->su_tx_inprocess == 0) 671 cv_signal(&sup->su_cv); 672 } else if (sup->su_tx_busy && SOFTMAC_CANPUTNEXT(sup->su_slp->sl_wq)) { 673 /* 674 * The flow-conctol of the dedicated-lower-stream is 675 * relieved. If DLD_CAPAB_DIRECT is enabled, call tx_notify 676 * callback to relieve the flow-control of the specific client, 677 * otherwise relieve the flow-control of all the upper-stream 678 * using the traditional STREAM mechanism. 679 */ 680 if (sup->su_tx_notify_func != NULL) { 681 sup->su_tx_inprocess++; 682 mutex_exit(&sup->su_mutex); 683 sup->su_tx_notify_func(sup->su_tx_notify_arg, 684 (mac_tx_cookie_t)sup); 685 mutex_enter(&sup->su_mutex); 686 if (--sup->su_tx_inprocess == 0) 687 cv_signal(&sup->su_cv); 688 } 689 ASSERT(sup->su_tx_flow_mp == NULL); 690 VERIFY((sup->su_tx_flow_mp = getq(wq)) != NULL); 691 sup->su_tx_busy = B_FALSE; 692 } 693 mutex_exit(&sup->su_mutex); 694 return (0); 695 } 696