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 * Data-Link Driver 28 */ 29 #include <sys/sysmacros.h> 30 #include <sys/strsubr.h> 31 #include <sys/strsun.h> 32 #include <sys/vlan.h> 33 #include <sys/dld_impl.h> 34 #include <sys/mac_client.h> 35 #include <sys/mac_client_impl.h> 36 #include <sys/mac_client_priv.h> 37 38 typedef void proto_reqfunc_t(dld_str_t *, mblk_t *); 39 40 static proto_reqfunc_t proto_info_req, proto_attach_req, proto_detach_req, 41 proto_bind_req, proto_unbind_req, proto_promiscon_req, proto_promiscoff_req, 42 proto_enabmulti_req, proto_disabmulti_req, proto_physaddr_req, 43 proto_setphysaddr_req, proto_udqos_req, proto_req, proto_capability_req, 44 proto_notify_req, proto_passive_req; 45 46 static void proto_capability_advertise(dld_str_t *, mblk_t *); 47 static int dld_capab_poll_disable(dld_str_t *, dld_capab_poll_t *); 48 49 #define DL_ACK_PENDING(state) \ 50 ((state) == DL_ATTACH_PENDING || \ 51 (state) == DL_DETACH_PENDING || \ 52 (state) == DL_BIND_PENDING || \ 53 (state) == DL_UNBIND_PENDING) 54 55 /* 56 * Process a DLPI protocol message. 57 * The primitives DL_BIND_REQ, DL_ENABMULTI_REQ, DL_PROMISCON_REQ, 58 * DL_SET_PHYS_ADDR_REQ put the data link below our dld_str_t into an 59 * 'active' state. The primitive DL_PASSIVE_REQ marks our dld_str_t 60 * as 'passive' and forbids it from being subsequently made 'active' 61 * by the above primitives. 62 */ 63 void 64 dld_proto(dld_str_t *dsp, mblk_t *mp) 65 { 66 t_uscalar_t prim; 67 68 if (MBLKL(mp) < sizeof (t_uscalar_t)) { 69 freemsg(mp); 70 return; 71 } 72 prim = ((union DL_primitives *)mp->b_rptr)->dl_primitive; 73 74 switch (prim) { 75 case DL_INFO_REQ: 76 proto_info_req(dsp, mp); 77 break; 78 case DL_BIND_REQ: 79 proto_bind_req(dsp, mp); 80 break; 81 case DL_UNBIND_REQ: 82 proto_unbind_req(dsp, mp); 83 break; 84 case DL_UNITDATA_REQ: 85 proto_unitdata_req(dsp, mp); 86 break; 87 case DL_UDQOS_REQ: 88 proto_udqos_req(dsp, mp); 89 break; 90 case DL_ATTACH_REQ: 91 proto_attach_req(dsp, mp); 92 break; 93 case DL_DETACH_REQ: 94 proto_detach_req(dsp, mp); 95 break; 96 case DL_ENABMULTI_REQ: 97 proto_enabmulti_req(dsp, mp); 98 break; 99 case DL_DISABMULTI_REQ: 100 proto_disabmulti_req(dsp, mp); 101 break; 102 case DL_PROMISCON_REQ: 103 proto_promiscon_req(dsp, mp); 104 break; 105 case DL_PROMISCOFF_REQ: 106 proto_promiscoff_req(dsp, mp); 107 break; 108 case DL_PHYS_ADDR_REQ: 109 proto_physaddr_req(dsp, mp); 110 break; 111 case DL_SET_PHYS_ADDR_REQ: 112 proto_setphysaddr_req(dsp, mp); 113 break; 114 case DL_NOTIFY_REQ: 115 proto_notify_req(dsp, mp); 116 break; 117 case DL_CAPABILITY_REQ: 118 proto_capability_req(dsp, mp); 119 break; 120 case DL_PASSIVE_REQ: 121 proto_passive_req(dsp, mp); 122 break; 123 default: 124 proto_req(dsp, mp); 125 break; 126 } 127 } 128 129 #define NEG(x) -(x) 130 typedef struct dl_info_ack_wrapper { 131 dl_info_ack_t dl_info; 132 uint8_t dl_addr[MAXMACADDRLEN + sizeof (uint16_t)]; 133 uint8_t dl_brdcst_addr[MAXMACADDRLEN]; 134 dl_qos_cl_range1_t dl_qos_range1; 135 dl_qos_cl_sel1_t dl_qos_sel1; 136 } dl_info_ack_wrapper_t; 137 138 /* 139 * DL_INFO_REQ 140 */ 141 static void 142 proto_info_req(dld_str_t *dsp, mblk_t *mp) 143 { 144 dl_info_ack_wrapper_t *dlwp; 145 dl_info_ack_t *dlp; 146 dl_qos_cl_sel1_t *selp; 147 dl_qos_cl_range1_t *rangep; 148 uint8_t *addr; 149 uint8_t *brdcst_addr; 150 uint_t addr_length; 151 uint_t sap_length; 152 mac_info_t minfo; 153 mac_info_t *minfop; 154 queue_t *q = dsp->ds_wq; 155 156 /* 157 * Swap the request message for one large enough to contain the 158 * wrapper structure defined above. 159 */ 160 if ((mp = mexchange(q, mp, sizeof (dl_info_ack_wrapper_t), 161 M_PCPROTO, 0)) == NULL) 162 return; 163 164 bzero(mp->b_rptr, sizeof (dl_info_ack_wrapper_t)); 165 dlwp = (dl_info_ack_wrapper_t *)mp->b_rptr; 166 167 dlp = &(dlwp->dl_info); 168 ASSERT(dlp == (dl_info_ack_t *)mp->b_rptr); 169 170 dlp->dl_primitive = DL_INFO_ACK; 171 172 /* 173 * Set up the sub-structure pointers. 174 */ 175 addr = dlwp->dl_addr; 176 brdcst_addr = dlwp->dl_brdcst_addr; 177 rangep = &(dlwp->dl_qos_range1); 178 selp = &(dlwp->dl_qos_sel1); 179 180 /* 181 * This driver supports only version 2 connectionless DLPI provider 182 * nodes. 183 */ 184 dlp->dl_service_mode = DL_CLDLS; 185 dlp->dl_version = DL_VERSION_2; 186 187 /* 188 * Set the style of the provider 189 */ 190 dlp->dl_provider_style = dsp->ds_style; 191 ASSERT(dlp->dl_provider_style == DL_STYLE1 || 192 dlp->dl_provider_style == DL_STYLE2); 193 194 /* 195 * Set the current DLPI state. 196 */ 197 dlp->dl_current_state = dsp->ds_dlstate; 198 199 /* 200 * Gratuitously set the media type. This is to deal with modules 201 * that assume the media type is known prior to DL_ATTACH_REQ 202 * being completed. 203 */ 204 dlp->dl_mac_type = DL_ETHER; 205 206 /* 207 * If the stream is not at least attached we try to retrieve the 208 * mac_info using mac_info_get() 209 */ 210 if (dsp->ds_dlstate == DL_UNATTACHED || 211 dsp->ds_dlstate == DL_ATTACH_PENDING || 212 dsp->ds_dlstate == DL_DETACH_PENDING) { 213 if (!mac_info_get(ddi_major_to_name(dsp->ds_major), &minfo)) { 214 /* 215 * Cannot find mac_info. giving up. 216 */ 217 goto done; 218 } 219 minfop = &minfo; 220 } else { 221 minfop = (mac_info_t *)dsp->ds_mip; 222 /* We can only get the sdu if we're attached. */ 223 mac_sdu_get(dsp->ds_mh, &dlp->dl_min_sdu, &dlp->dl_max_sdu); 224 } 225 226 /* 227 * Set the media type (properly this time). 228 */ 229 if (dsp->ds_native) 230 dlp->dl_mac_type = minfop->mi_nativemedia; 231 else 232 dlp->dl_mac_type = minfop->mi_media; 233 234 /* 235 * Set the DLSAP length. We only support 16 bit values and they 236 * appear after the MAC address portion of DLSAP addresses. 237 */ 238 sap_length = sizeof (uint16_t); 239 dlp->dl_sap_length = NEG(sap_length); 240 241 addr_length = minfop->mi_addr_length; 242 243 /* 244 * Copy in the media broadcast address. 245 */ 246 if (minfop->mi_brdcst_addr != NULL) { 247 dlp->dl_brdcst_addr_offset = 248 (uintptr_t)brdcst_addr - (uintptr_t)dlp; 249 bcopy(minfop->mi_brdcst_addr, brdcst_addr, addr_length); 250 dlp->dl_brdcst_addr_length = addr_length; 251 } 252 253 /* Only VLAN links and links that have a normal tag mode support QOS. */ 254 if ((dsp->ds_mch != NULL && 255 mac_client_vid(dsp->ds_mch) != VLAN_ID_NONE) || 256 (dsp->ds_dlp != NULL && 257 dsp->ds_dlp->dl_tagmode == LINK_TAGMODE_NORMAL)) { 258 dlp->dl_qos_range_offset = (uintptr_t)rangep - (uintptr_t)dlp; 259 dlp->dl_qos_range_length = sizeof (dl_qos_cl_range1_t); 260 261 rangep->dl_qos_type = DL_QOS_CL_RANGE1; 262 rangep->dl_trans_delay.dl_target_value = DL_UNKNOWN; 263 rangep->dl_trans_delay.dl_accept_value = DL_UNKNOWN; 264 rangep->dl_protection.dl_min = DL_UNKNOWN; 265 rangep->dl_protection.dl_max = DL_UNKNOWN; 266 rangep->dl_residual_error = DL_UNKNOWN; 267 268 /* 269 * Specify the supported range of priorities. 270 */ 271 rangep->dl_priority.dl_min = 0; 272 rangep->dl_priority.dl_max = (1 << VLAN_PRI_SIZE) - 1; 273 274 dlp->dl_qos_offset = (uintptr_t)selp - (uintptr_t)dlp; 275 dlp->dl_qos_length = sizeof (dl_qos_cl_sel1_t); 276 277 selp->dl_qos_type = DL_QOS_CL_SEL1; 278 selp->dl_trans_delay = DL_UNKNOWN; 279 selp->dl_protection = DL_UNKNOWN; 280 selp->dl_residual_error = DL_UNKNOWN; 281 282 /* 283 * Specify the current priority (which can be changed by 284 * the DL_UDQOS_REQ primitive). 285 */ 286 selp->dl_priority = dsp->ds_pri; 287 } 288 289 dlp->dl_addr_length = addr_length + sizeof (uint16_t); 290 if (dsp->ds_dlstate == DL_IDLE) { 291 /* 292 * The stream is bound. Therefore we can formulate a valid 293 * DLSAP address. 294 */ 295 dlp->dl_addr_offset = (uintptr_t)addr - (uintptr_t)dlp; 296 if (addr_length > 0) 297 mac_unicast_primary_get(dsp->ds_mh, addr); 298 299 *(uint16_t *)(addr + addr_length) = dsp->ds_sap; 300 } 301 302 done: 303 ASSERT(IMPLY(dlp->dl_qos_offset != 0, dlp->dl_qos_length != 0)); 304 ASSERT(IMPLY(dlp->dl_qos_range_offset != 0, 305 dlp->dl_qos_range_length != 0)); 306 ASSERT(IMPLY(dlp->dl_addr_offset != 0, dlp->dl_addr_length != 0)); 307 ASSERT(IMPLY(dlp->dl_brdcst_addr_offset != 0, 308 dlp->dl_brdcst_addr_length != 0)); 309 310 qreply(q, mp); 311 } 312 313 /* 314 * DL_ATTACH_REQ 315 */ 316 static void 317 proto_attach_req(dld_str_t *dsp, mblk_t *mp) 318 { 319 dl_attach_req_t *dlp = (dl_attach_req_t *)mp->b_rptr; 320 int err = 0; 321 t_uscalar_t dl_err; 322 queue_t *q = dsp->ds_wq; 323 324 if (MBLKL(mp) < sizeof (dl_attach_req_t) || 325 dlp->dl_ppa < 0 || dsp->ds_style == DL_STYLE1) { 326 dl_err = DL_BADPRIM; 327 goto failed; 328 } 329 330 if (dsp->ds_dlstate != DL_UNATTACHED) { 331 dl_err = DL_OUTSTATE; 332 goto failed; 333 } 334 335 dsp->ds_dlstate = DL_ATTACH_PENDING; 336 337 err = dld_str_attach(dsp, dlp->dl_ppa); 338 if (err != 0) { 339 switch (err) { 340 case ENOENT: 341 dl_err = DL_BADPPA; 342 err = 0; 343 break; 344 default: 345 dl_err = DL_SYSERR; 346 break; 347 } 348 dsp->ds_dlstate = DL_UNATTACHED; 349 goto failed; 350 } 351 ASSERT(dsp->ds_dlstate == DL_UNBOUND); 352 dlokack(q, mp, DL_ATTACH_REQ); 353 return; 354 355 failed: 356 dlerrorack(q, mp, DL_ATTACH_REQ, dl_err, (t_uscalar_t)err); 357 } 358 359 /* 360 * DL_DETACH_REQ 361 */ 362 static void 363 proto_detach_req(dld_str_t *dsp, mblk_t *mp) 364 { 365 queue_t *q = dsp->ds_wq; 366 t_uscalar_t dl_err; 367 368 if (MBLKL(mp) < sizeof (dl_detach_req_t)) { 369 dl_err = DL_BADPRIM; 370 goto failed; 371 } 372 373 if (dsp->ds_dlstate != DL_UNBOUND) { 374 dl_err = DL_OUTSTATE; 375 goto failed; 376 } 377 378 if (dsp->ds_style == DL_STYLE1) { 379 dl_err = DL_BADPRIM; 380 goto failed; 381 } 382 383 ASSERT(dsp->ds_datathr_cnt == 0); 384 dsp->ds_dlstate = DL_DETACH_PENDING; 385 386 dld_str_detach(dsp); 387 dlokack(dsp->ds_wq, mp, DL_DETACH_REQ); 388 return; 389 390 failed: 391 dlerrorack(q, mp, DL_DETACH_REQ, dl_err, 0); 392 } 393 394 /* 395 * DL_BIND_REQ 396 */ 397 static void 398 proto_bind_req(dld_str_t *dsp, mblk_t *mp) 399 { 400 dl_bind_req_t *dlp = (dl_bind_req_t *)mp->b_rptr; 401 int err = 0; 402 uint8_t dlsap_addr[MAXMACADDRLEN + sizeof (uint16_t)]; 403 uint_t dlsap_addr_length; 404 t_uscalar_t dl_err; 405 t_scalar_t sap; 406 queue_t *q = dsp->ds_wq; 407 mac_perim_handle_t mph; 408 void *mdip; 409 int32_t intr_cpu; 410 411 if (MBLKL(mp) < sizeof (dl_bind_req_t)) { 412 dl_err = DL_BADPRIM; 413 goto failed; 414 } 415 416 if (dlp->dl_xidtest_flg != 0) { 417 dl_err = DL_NOAUTO; 418 goto failed; 419 } 420 421 if (dlp->dl_service_mode != DL_CLDLS) { 422 dl_err = DL_UNSUPPORTED; 423 goto failed; 424 } 425 426 if (dsp->ds_dlstate != DL_UNBOUND) { 427 dl_err = DL_OUTSTATE; 428 goto failed; 429 } 430 431 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 432 433 if ((err = dls_active_set(dsp)) != 0) { 434 dl_err = DL_SYSERR; 435 goto failed2; 436 } 437 438 dsp->ds_dlstate = DL_BIND_PENDING; 439 /* 440 * Set the receive callback. 441 */ 442 dls_rx_set(dsp, (dsp->ds_mode == DLD_RAW) ? 443 dld_str_rx_raw : dld_str_rx_unitdata, dsp); 444 445 /* 446 * Bind the channel such that it can receive packets. 447 */ 448 sap = dlp->dl_sap; 449 err = dls_bind(dsp, sap); 450 if (err != 0) { 451 switch (err) { 452 case EINVAL: 453 dl_err = DL_BADADDR; 454 err = 0; 455 break; 456 default: 457 dl_err = DL_SYSERR; 458 break; 459 } 460 461 dsp->ds_dlstate = DL_UNBOUND; 462 dls_active_clear(dsp, B_FALSE); 463 goto failed2; 464 } 465 466 intr_cpu = mac_client_intr_cpu(dsp->ds_mch); 467 mdip = mac_get_devinfo(dsp->ds_mh); 468 mac_perim_exit(mph); 469 470 /* 471 * We do this after we get out of the perim to avoid deadlocks 472 * etc. since part of mac_client_retarget_intr is to walk the 473 * device tree in order to find and retarget the interrupts. 474 */ 475 mac_client_set_intr_cpu(mdip, dsp->ds_mch, intr_cpu); 476 477 /* 478 * Copy in MAC address. 479 */ 480 dlsap_addr_length = dsp->ds_mip->mi_addr_length; 481 mac_unicast_primary_get(dsp->ds_mh, dlsap_addr); 482 483 /* 484 * Copy in the SAP. 485 */ 486 *(uint16_t *)(dlsap_addr + dlsap_addr_length) = sap; 487 dlsap_addr_length += sizeof (uint16_t); 488 489 dsp->ds_dlstate = DL_IDLE; 490 dlbindack(q, mp, sap, dlsap_addr, dlsap_addr_length, 0, 0); 491 return; 492 493 failed2: 494 mac_perim_exit(mph); 495 failed: 496 dlerrorack(q, mp, DL_BIND_REQ, dl_err, (t_uscalar_t)err); 497 } 498 499 /* 500 * DL_UNBIND_REQ 501 */ 502 static void 503 proto_unbind_req(dld_str_t *dsp, mblk_t *mp) 504 { 505 queue_t *q = dsp->ds_wq; 506 t_uscalar_t dl_err; 507 mac_perim_handle_t mph; 508 509 if (MBLKL(mp) < sizeof (dl_unbind_req_t)) { 510 dl_err = DL_BADPRIM; 511 goto failed; 512 } 513 514 if (dsp->ds_dlstate != DL_IDLE) { 515 dl_err = DL_OUTSTATE; 516 goto failed; 517 } 518 519 mutex_enter(&dsp->ds_lock); 520 while (dsp->ds_datathr_cnt != 0) 521 cv_wait(&dsp->ds_datathr_cv, &dsp->ds_lock); 522 523 dsp->ds_dlstate = DL_UNBIND_PENDING; 524 mutex_exit(&dsp->ds_lock); 525 526 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 527 /* 528 * Unbind the channel to stop packets being received. 529 */ 530 dls_unbind(dsp); 531 532 /* 533 * Disable polling mode, if it is enabled. 534 */ 535 (void) dld_capab_poll_disable(dsp, NULL); 536 537 /* 538 * Clear LSO flags. 539 */ 540 dsp->ds_lso = B_FALSE; 541 dsp->ds_lso_max = 0; 542 543 /* 544 * Clear the receive callback. 545 */ 546 dls_rx_set(dsp, NULL, NULL); 547 dsp->ds_direct = B_FALSE; 548 549 /* 550 * Set the mode back to the default (unitdata). 551 */ 552 dsp->ds_mode = DLD_UNITDATA; 553 dsp->ds_dlstate = DL_UNBOUND; 554 555 dls_active_clear(dsp, B_FALSE); 556 mac_perim_exit(mph); 557 dlokack(dsp->ds_wq, mp, DL_UNBIND_REQ); 558 return; 559 failed: 560 dlerrorack(q, mp, DL_UNBIND_REQ, dl_err, 0); 561 } 562 563 /* 564 * DL_PROMISCON_REQ 565 */ 566 static void 567 proto_promiscon_req(dld_str_t *dsp, mblk_t *mp) 568 { 569 dl_promiscon_req_t *dlp = (dl_promiscon_req_t *)mp->b_rptr; 570 int err = 0; 571 t_uscalar_t dl_err; 572 uint32_t promisc_saved; 573 queue_t *q = dsp->ds_wq; 574 mac_perim_handle_t mph; 575 576 if (MBLKL(mp) < sizeof (dl_promiscon_req_t)) { 577 dl_err = DL_BADPRIM; 578 goto failed; 579 } 580 581 if (dsp->ds_dlstate == DL_UNATTACHED || 582 DL_ACK_PENDING(dsp->ds_dlstate)) { 583 dl_err = DL_OUTSTATE; 584 goto failed; 585 } 586 587 promisc_saved = dsp->ds_promisc; 588 switch (dlp->dl_level) { 589 case DL_PROMISC_SAP: 590 dsp->ds_promisc |= DLS_PROMISC_SAP; 591 break; 592 593 case DL_PROMISC_MULTI: 594 dsp->ds_promisc |= DLS_PROMISC_MULTI; 595 break; 596 597 case DL_PROMISC_PHYS: 598 dsp->ds_promisc |= DLS_PROMISC_PHYS; 599 break; 600 601 default: 602 dl_err = DL_NOTSUPPORTED; 603 goto failed; 604 } 605 606 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 607 608 if ((promisc_saved == 0) && (err = dls_active_set(dsp)) != 0) { 609 dsp->ds_promisc = promisc_saved; 610 dl_err = DL_SYSERR; 611 goto failed2; 612 } 613 614 /* 615 * Adjust channel promiscuity. 616 */ 617 err = dls_promisc(dsp, promisc_saved); 618 619 if (err != 0) { 620 dl_err = DL_SYSERR; 621 dsp->ds_promisc = promisc_saved; 622 if (promisc_saved == 0) 623 dls_active_clear(dsp, B_FALSE); 624 goto failed2; 625 } 626 627 mac_perim_exit(mph); 628 629 dlokack(q, mp, DL_PROMISCON_REQ); 630 return; 631 632 failed2: 633 mac_perim_exit(mph); 634 failed: 635 dlerrorack(q, mp, DL_PROMISCON_REQ, dl_err, (t_uscalar_t)err); 636 } 637 638 /* 639 * DL_PROMISCOFF_REQ 640 */ 641 static void 642 proto_promiscoff_req(dld_str_t *dsp, mblk_t *mp) 643 { 644 dl_promiscoff_req_t *dlp = (dl_promiscoff_req_t *)mp->b_rptr; 645 int err = 0; 646 t_uscalar_t dl_err; 647 uint32_t promisc_saved; 648 queue_t *q = dsp->ds_wq; 649 mac_perim_handle_t mph; 650 651 if (MBLKL(mp) < sizeof (dl_promiscoff_req_t)) { 652 dl_err = DL_BADPRIM; 653 goto failed; 654 } 655 656 if (dsp->ds_dlstate == DL_UNATTACHED || 657 DL_ACK_PENDING(dsp->ds_dlstate)) { 658 dl_err = DL_OUTSTATE; 659 goto failed; 660 } 661 662 promisc_saved = dsp->ds_promisc; 663 switch (dlp->dl_level) { 664 case DL_PROMISC_SAP: 665 if (!(dsp->ds_promisc & DLS_PROMISC_SAP)) { 666 dl_err = DL_NOTENAB; 667 goto failed; 668 } 669 dsp->ds_promisc &= ~DLS_PROMISC_SAP; 670 break; 671 672 case DL_PROMISC_MULTI: 673 if (!(dsp->ds_promisc & DLS_PROMISC_MULTI)) { 674 dl_err = DL_NOTENAB; 675 goto failed; 676 } 677 dsp->ds_promisc &= ~DLS_PROMISC_MULTI; 678 break; 679 680 case DL_PROMISC_PHYS: 681 if (!(dsp->ds_promisc & DLS_PROMISC_PHYS)) { 682 dl_err = DL_NOTENAB; 683 goto failed; 684 } 685 dsp->ds_promisc &= ~DLS_PROMISC_PHYS; 686 break; 687 688 default: 689 dl_err = DL_NOTSUPPORTED; 690 goto failed; 691 } 692 693 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 694 /* 695 * Adjust channel promiscuity. 696 */ 697 err = dls_promisc(dsp, promisc_saved); 698 699 if (err != 0) { 700 mac_perim_exit(mph); 701 dl_err = DL_SYSERR; 702 goto failed; 703 } 704 705 if (dsp->ds_promisc == 0) 706 dls_active_clear(dsp, B_FALSE); 707 708 mac_perim_exit(mph); 709 710 dlokack(q, mp, DL_PROMISCOFF_REQ); 711 return; 712 failed: 713 dlerrorack(q, mp, DL_PROMISCOFF_REQ, dl_err, (t_uscalar_t)err); 714 } 715 716 /* 717 * DL_ENABMULTI_REQ 718 */ 719 static void 720 proto_enabmulti_req(dld_str_t *dsp, mblk_t *mp) 721 { 722 dl_enabmulti_req_t *dlp = (dl_enabmulti_req_t *)mp->b_rptr; 723 int err = 0; 724 t_uscalar_t dl_err; 725 queue_t *q = dsp->ds_wq; 726 mac_perim_handle_t mph; 727 728 if (dsp->ds_dlstate == DL_UNATTACHED || 729 DL_ACK_PENDING(dsp->ds_dlstate)) { 730 dl_err = DL_OUTSTATE; 731 goto failed; 732 } 733 734 if (MBLKL(mp) < sizeof (dl_enabmulti_req_t) || 735 !MBLKIN(mp, dlp->dl_addr_offset, dlp->dl_addr_length) || 736 dlp->dl_addr_length != dsp->ds_mip->mi_addr_length) { 737 dl_err = DL_BADPRIM; 738 goto failed; 739 } 740 741 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 742 743 if ((dsp->ds_dmap == NULL) && (err = dls_active_set(dsp)) != 0) { 744 dl_err = DL_SYSERR; 745 goto failed2; 746 } 747 748 err = dls_multicst_add(dsp, mp->b_rptr + dlp->dl_addr_offset); 749 if (err != 0) { 750 switch (err) { 751 case EINVAL: 752 dl_err = DL_BADADDR; 753 err = 0; 754 break; 755 case ENOSPC: 756 dl_err = DL_TOOMANY; 757 err = 0; 758 break; 759 default: 760 dl_err = DL_SYSERR; 761 break; 762 } 763 if (dsp->ds_dmap == NULL) 764 dls_active_clear(dsp, B_FALSE); 765 goto failed2; 766 } 767 768 mac_perim_exit(mph); 769 770 dlokack(q, mp, DL_ENABMULTI_REQ); 771 return; 772 773 failed2: 774 mac_perim_exit(mph); 775 failed: 776 dlerrorack(q, mp, DL_ENABMULTI_REQ, dl_err, (t_uscalar_t)err); 777 } 778 779 /* 780 * DL_DISABMULTI_REQ 781 */ 782 static void 783 proto_disabmulti_req(dld_str_t *dsp, mblk_t *mp) 784 { 785 dl_disabmulti_req_t *dlp = (dl_disabmulti_req_t *)mp->b_rptr; 786 int err = 0; 787 t_uscalar_t dl_err; 788 queue_t *q = dsp->ds_wq; 789 mac_perim_handle_t mph; 790 791 if (dsp->ds_dlstate == DL_UNATTACHED || 792 DL_ACK_PENDING(dsp->ds_dlstate)) { 793 dl_err = DL_OUTSTATE; 794 goto failed; 795 } 796 797 if (MBLKL(mp) < sizeof (dl_disabmulti_req_t) || 798 !MBLKIN(mp, dlp->dl_addr_offset, dlp->dl_addr_length) || 799 dlp->dl_addr_length != dsp->ds_mip->mi_addr_length) { 800 dl_err = DL_BADPRIM; 801 goto failed; 802 } 803 804 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 805 err = dls_multicst_remove(dsp, mp->b_rptr + dlp->dl_addr_offset); 806 if ((err == 0) && (dsp->ds_dmap == NULL)) 807 dls_active_clear(dsp, B_FALSE); 808 mac_perim_exit(mph); 809 810 if (err != 0) { 811 switch (err) { 812 case EINVAL: 813 dl_err = DL_BADADDR; 814 err = 0; 815 break; 816 817 case ENOENT: 818 dl_err = DL_NOTENAB; 819 err = 0; 820 break; 821 822 default: 823 dl_err = DL_SYSERR; 824 break; 825 } 826 goto failed; 827 } 828 dlokack(q, mp, DL_DISABMULTI_REQ); 829 return; 830 failed: 831 dlerrorack(q, mp, DL_DISABMULTI_REQ, dl_err, (t_uscalar_t)err); 832 } 833 834 /* 835 * DL_PHYS_ADDR_REQ 836 */ 837 static void 838 proto_physaddr_req(dld_str_t *dsp, mblk_t *mp) 839 { 840 dl_phys_addr_req_t *dlp = (dl_phys_addr_req_t *)mp->b_rptr; 841 queue_t *q = dsp->ds_wq; 842 t_uscalar_t dl_err; 843 char *addr; 844 uint_t addr_length; 845 846 if (MBLKL(mp) < sizeof (dl_phys_addr_req_t)) { 847 dl_err = DL_BADPRIM; 848 goto failed; 849 } 850 851 if (dsp->ds_dlstate == DL_UNATTACHED || 852 DL_ACK_PENDING(dsp->ds_dlstate)) { 853 dl_err = DL_OUTSTATE; 854 goto failed; 855 } 856 857 if (dlp->dl_addr_type != DL_CURR_PHYS_ADDR && 858 dlp->dl_addr_type != DL_FACT_PHYS_ADDR) { 859 dl_err = DL_UNSUPPORTED; 860 goto failed; 861 } 862 863 addr_length = dsp->ds_mip->mi_addr_length; 864 if (addr_length > 0) { 865 addr = kmem_alloc(addr_length, KM_SLEEP); 866 if (dlp->dl_addr_type == DL_CURR_PHYS_ADDR) 867 mac_unicast_primary_get(dsp->ds_mh, (uint8_t *)addr); 868 else 869 bcopy(dsp->ds_mip->mi_unicst_addr, addr, addr_length); 870 871 dlphysaddrack(q, mp, addr, (t_uscalar_t)addr_length); 872 kmem_free(addr, addr_length); 873 } else { 874 dlphysaddrack(q, mp, NULL, 0); 875 } 876 return; 877 failed: 878 dlerrorack(q, mp, DL_PHYS_ADDR_REQ, dl_err, 0); 879 } 880 881 /* 882 * DL_SET_PHYS_ADDR_REQ 883 */ 884 static void 885 proto_setphysaddr_req(dld_str_t *dsp, mblk_t *mp) 886 { 887 dl_set_phys_addr_req_t *dlp = (dl_set_phys_addr_req_t *)mp->b_rptr; 888 int err = 0; 889 t_uscalar_t dl_err; 890 queue_t *q = dsp->ds_wq; 891 mac_perim_handle_t mph; 892 893 if (dsp->ds_dlstate == DL_UNATTACHED || 894 DL_ACK_PENDING(dsp->ds_dlstate)) { 895 dl_err = DL_OUTSTATE; 896 goto failed; 897 } 898 899 if (MBLKL(mp) < sizeof (dl_set_phys_addr_req_t) || 900 !MBLKIN(mp, dlp->dl_addr_offset, dlp->dl_addr_length) || 901 dlp->dl_addr_length != dsp->ds_mip->mi_addr_length) { 902 dl_err = DL_BADPRIM; 903 goto failed; 904 } 905 906 mac_perim_enter_by_mh(dsp->ds_mh, &mph); 907 908 if ((err = dls_active_set(dsp)) != 0) { 909 dl_err = DL_SYSERR; 910 goto failed2; 911 } 912 913 err = mac_unicast_primary_set(dsp->ds_mh, 914 mp->b_rptr + dlp->dl_addr_offset); 915 if (err != 0) { 916 switch (err) { 917 case EINVAL: 918 dl_err = DL_BADADDR; 919 err = 0; 920 break; 921 922 default: 923 dl_err = DL_SYSERR; 924 break; 925 } 926 dls_active_clear(dsp, B_FALSE); 927 goto failed2; 928 929 } 930 931 mac_perim_exit(mph); 932 933 dlokack(q, mp, DL_SET_PHYS_ADDR_REQ); 934 return; 935 936 failed2: 937 mac_perim_exit(mph); 938 failed: 939 dlerrorack(q, mp, DL_SET_PHYS_ADDR_REQ, dl_err, (t_uscalar_t)err); 940 } 941 942 /* 943 * DL_UDQOS_REQ 944 */ 945 static void 946 proto_udqos_req(dld_str_t *dsp, mblk_t *mp) 947 { 948 dl_udqos_req_t *dlp = (dl_udqos_req_t *)mp->b_rptr; 949 dl_qos_cl_sel1_t *selp; 950 int off, len; 951 t_uscalar_t dl_err; 952 queue_t *q = dsp->ds_wq; 953 954 off = dlp->dl_qos_offset; 955 len = dlp->dl_qos_length; 956 957 if (MBLKL(mp) < sizeof (dl_udqos_req_t) || !MBLKIN(mp, off, len)) { 958 dl_err = DL_BADPRIM; 959 goto failed; 960 } 961 962 selp = (dl_qos_cl_sel1_t *)(mp->b_rptr + off); 963 if (selp->dl_qos_type != DL_QOS_CL_SEL1) { 964 dl_err = DL_BADQOSTYPE; 965 goto failed; 966 } 967 968 if (selp->dl_priority > (1 << VLAN_PRI_SIZE) - 1 || 969 selp->dl_priority < 0) { 970 dl_err = DL_BADQOSPARAM; 971 goto failed; 972 } 973 974 dsp->ds_pri = selp->dl_priority; 975 dlokack(q, mp, DL_UDQOS_REQ); 976 return; 977 failed: 978 dlerrorack(q, mp, DL_UDQOS_REQ, dl_err, 0); 979 } 980 981 static boolean_t 982 check_ip_above(queue_t *q) 983 { 984 queue_t *next_q; 985 boolean_t ret = B_TRUE; 986 987 claimstr(q); 988 next_q = q->q_next; 989 if (strcmp(next_q->q_qinfo->qi_minfo->mi_idname, "ip") != 0) 990 ret = B_FALSE; 991 releasestr(q); 992 return (ret); 993 } 994 995 /* 996 * DL_CAPABILITY_REQ 997 */ 998 static void 999 proto_capability_req(dld_str_t *dsp, mblk_t *mp) 1000 { 1001 dl_capability_req_t *dlp = (dl_capability_req_t *)mp->b_rptr; 1002 dl_capability_sub_t *sp; 1003 size_t size, len; 1004 offset_t off, end; 1005 t_uscalar_t dl_err; 1006 queue_t *q = dsp->ds_wq; 1007 1008 if (MBLKL(mp) < sizeof (dl_capability_req_t)) { 1009 dl_err = DL_BADPRIM; 1010 goto failed; 1011 } 1012 1013 if (dsp->ds_dlstate == DL_UNATTACHED || 1014 DL_ACK_PENDING(dsp->ds_dlstate)) { 1015 dl_err = DL_OUTSTATE; 1016 goto failed; 1017 } 1018 1019 /* 1020 * This request is overloaded. If there are no requested capabilities 1021 * then we just want to acknowledge with all the capabilities we 1022 * support. Otherwise we enable the set of capabilities requested. 1023 */ 1024 if (dlp->dl_sub_length == 0) { 1025 proto_capability_advertise(dsp, mp); 1026 return; 1027 } 1028 1029 if (!MBLKIN(mp, dlp->dl_sub_offset, dlp->dl_sub_length)) { 1030 dl_err = DL_BADPRIM; 1031 goto failed; 1032 } 1033 1034 dlp->dl_primitive = DL_CAPABILITY_ACK; 1035 1036 off = dlp->dl_sub_offset; 1037 len = dlp->dl_sub_length; 1038 1039 /* 1040 * Walk the list of capabilities to be enabled. 1041 */ 1042 for (end = off + len; off < end; ) { 1043 sp = (dl_capability_sub_t *)(mp->b_rptr + off); 1044 size = sizeof (dl_capability_sub_t) + sp->dl_length; 1045 1046 if (off + size > end || 1047 !IS_P2ALIGNED(off, sizeof (uint32_t))) { 1048 dl_err = DL_BADPRIM; 1049 goto failed; 1050 } 1051 1052 switch (sp->dl_cap) { 1053 /* 1054 * TCP/IP checksum offload to hardware. 1055 */ 1056 case DL_CAPAB_HCKSUM: { 1057 dl_capab_hcksum_t *hcksump; 1058 dl_capab_hcksum_t hcksum; 1059 1060 hcksump = (dl_capab_hcksum_t *)&sp[1]; 1061 /* 1062 * Copy for alignment. 1063 */ 1064 bcopy(hcksump, &hcksum, sizeof (dl_capab_hcksum_t)); 1065 dlcapabsetqid(&(hcksum.hcksum_mid), dsp->ds_rq); 1066 bcopy(&hcksum, hcksump, sizeof (dl_capab_hcksum_t)); 1067 break; 1068 } 1069 1070 case DL_CAPAB_DLD: { 1071 dl_capab_dld_t *dldp; 1072 dl_capab_dld_t dld; 1073 1074 dldp = (dl_capab_dld_t *)&sp[1]; 1075 /* 1076 * Copy for alignment. 1077 */ 1078 bcopy(dldp, &dld, sizeof (dl_capab_dld_t)); 1079 dlcapabsetqid(&(dld.dld_mid), dsp->ds_rq); 1080 bcopy(&dld, dldp, sizeof (dl_capab_dld_t)); 1081 break; 1082 } 1083 default: 1084 break; 1085 } 1086 off += size; 1087 } 1088 qreply(q, mp); 1089 return; 1090 failed: 1091 dlerrorack(q, mp, DL_CAPABILITY_REQ, dl_err, 0); 1092 } 1093 1094 /* 1095 * DL_NOTIFY_REQ 1096 */ 1097 static void 1098 proto_notify_req(dld_str_t *dsp, mblk_t *mp) 1099 { 1100 dl_notify_req_t *dlp = (dl_notify_req_t *)mp->b_rptr; 1101 t_uscalar_t dl_err; 1102 queue_t *q = dsp->ds_wq; 1103 uint_t note = 1104 DL_NOTE_PROMISC_ON_PHYS | 1105 DL_NOTE_PROMISC_OFF_PHYS | 1106 DL_NOTE_PHYS_ADDR | 1107 DL_NOTE_LINK_UP | 1108 DL_NOTE_LINK_DOWN | 1109 DL_NOTE_CAPAB_RENEG | 1110 DL_NOTE_FASTPATH_FLUSH | 1111 DL_NOTE_SPEED; 1112 1113 if (MBLKL(mp) < sizeof (dl_notify_req_t)) { 1114 dl_err = DL_BADPRIM; 1115 goto failed; 1116 } 1117 1118 if (dsp->ds_dlstate == DL_UNATTACHED || 1119 DL_ACK_PENDING(dsp->ds_dlstate)) { 1120 dl_err = DL_OUTSTATE; 1121 goto failed; 1122 } 1123 1124 note &= ~(mac_no_notification(dsp->ds_mh)); 1125 1126 /* 1127 * Cache the notifications that are being enabled. 1128 */ 1129 dsp->ds_notifications = dlp->dl_notifications & note; 1130 /* 1131 * The ACK carries all notifications regardless of which set is 1132 * being enabled. 1133 */ 1134 dlnotifyack(q, mp, note); 1135 1136 /* 1137 * Generate DL_NOTIFY_IND messages for each enabled notification. 1138 */ 1139 if (dsp->ds_notifications != 0) { 1140 dld_str_notify_ind(dsp); 1141 } 1142 return; 1143 failed: 1144 dlerrorack(q, mp, DL_NOTIFY_REQ, dl_err, 0); 1145 } 1146 1147 /* 1148 * DL_UINTDATA_REQ 1149 */ 1150 void 1151 proto_unitdata_req(dld_str_t *dsp, mblk_t *mp) 1152 { 1153 queue_t *q = dsp->ds_wq; 1154 dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr; 1155 off_t off; 1156 size_t len, size; 1157 const uint8_t *addr; 1158 uint16_t sap; 1159 uint_t addr_length; 1160 mblk_t *bp, *payload; 1161 uint32_t start, stuff, end, value, flags; 1162 t_uscalar_t dl_err; 1163 uint_t max_sdu; 1164 1165 if (MBLKL(mp) < sizeof (dl_unitdata_req_t) || mp->b_cont == NULL) { 1166 dlerrorack(q, mp, DL_UNITDATA_REQ, DL_BADPRIM, 0); 1167 return; 1168 } 1169 1170 mutex_enter(&dsp->ds_lock); 1171 if (dsp->ds_dlstate != DL_IDLE) { 1172 mutex_exit(&dsp->ds_lock); 1173 dlerrorack(q, mp, DL_UNITDATA_REQ, DL_OUTSTATE, 0); 1174 return; 1175 } 1176 DLD_DATATHR_INC(dsp); 1177 mutex_exit(&dsp->ds_lock); 1178 1179 addr_length = dsp->ds_mip->mi_addr_length; 1180 1181 off = dlp->dl_dest_addr_offset; 1182 len = dlp->dl_dest_addr_length; 1183 1184 if (!MBLKIN(mp, off, len) || !IS_P2ALIGNED(off, sizeof (uint16_t))) { 1185 dl_err = DL_BADPRIM; 1186 goto failed; 1187 } 1188 1189 if (len != addr_length + sizeof (uint16_t)) { 1190 dl_err = DL_BADADDR; 1191 goto failed; 1192 } 1193 1194 addr = mp->b_rptr + off; 1195 sap = *(uint16_t *)(mp->b_rptr + off + addr_length); 1196 1197 /* 1198 * Check the length of the packet and the block types. 1199 */ 1200 size = 0; 1201 payload = mp->b_cont; 1202 for (bp = payload; bp != NULL; bp = bp->b_cont) { 1203 if (DB_TYPE(bp) != M_DATA) 1204 goto baddata; 1205 1206 size += MBLKL(bp); 1207 } 1208 1209 mac_sdu_get(dsp->ds_mh, NULL, &max_sdu); 1210 if (size > max_sdu) 1211 goto baddata; 1212 1213 /* 1214 * Build a packet header. 1215 */ 1216 if ((bp = dls_header(dsp, addr, sap, dlp->dl_priority.dl_max, 1217 &payload)) == NULL) { 1218 dl_err = DL_BADADDR; 1219 goto failed; 1220 } 1221 1222 /* 1223 * We no longer need the M_PROTO header, so free it. 1224 */ 1225 freeb(mp); 1226 1227 /* 1228 * Transfer the checksum offload information if it is present. 1229 */ 1230 hcksum_retrieve(payload, NULL, NULL, &start, &stuff, &end, &value, 1231 &flags); 1232 (void) hcksum_assoc(bp, NULL, NULL, start, stuff, end, value, flags, 0); 1233 1234 /* 1235 * Link the payload onto the new header. 1236 */ 1237 ASSERT(bp->b_cont == NULL); 1238 bp->b_cont = payload; 1239 1240 /* 1241 * No lock can be held across modules and putnext()'s, 1242 * which can happen here with the call from DLD_TX(). 1243 */ 1244 if (DLD_TX(dsp, bp, 0, 0) != NULL) { 1245 /* flow-controlled */ 1246 DLD_SETQFULL(dsp); 1247 } 1248 DLD_DATATHR_DCR(dsp); 1249 return; 1250 1251 failed: 1252 dlerrorack(q, mp, DL_UNITDATA_REQ, dl_err, 0); 1253 DLD_DATATHR_DCR(dsp); 1254 return; 1255 1256 baddata: 1257 dluderrorind(q, mp, (void *)addr, len, DL_BADDATA, 0); 1258 DLD_DATATHR_DCR(dsp); 1259 } 1260 1261 /* 1262 * DL_PASSIVE_REQ 1263 */ 1264 static void 1265 proto_passive_req(dld_str_t *dsp, mblk_t *mp) 1266 { 1267 t_uscalar_t dl_err; 1268 1269 /* 1270 * If we've already become active by issuing an active primitive, 1271 * then it's too late to try to become passive. 1272 */ 1273 if (dsp->ds_passivestate == DLD_ACTIVE) { 1274 dl_err = DL_OUTSTATE; 1275 goto failed; 1276 } 1277 1278 if (MBLKL(mp) < sizeof (dl_passive_req_t)) { 1279 dl_err = DL_BADPRIM; 1280 goto failed; 1281 } 1282 1283 dsp->ds_passivestate = DLD_PASSIVE; 1284 dlokack(dsp->ds_wq, mp, DL_PASSIVE_REQ); 1285 return; 1286 failed: 1287 dlerrorack(dsp->ds_wq, mp, DL_PASSIVE_REQ, dl_err, 0); 1288 } 1289 1290 1291 /* 1292 * Catch-all handler. 1293 */ 1294 static void 1295 proto_req(dld_str_t *dsp, mblk_t *mp) 1296 { 1297 union DL_primitives *dlp = (union DL_primitives *)mp->b_rptr; 1298 1299 dlerrorack(dsp->ds_wq, mp, dlp->dl_primitive, DL_UNSUPPORTED, 0); 1300 } 1301 1302 static int 1303 dld_capab_perim(dld_str_t *dsp, void *data, uint_t flags) 1304 { 1305 switch (flags) { 1306 case DLD_ENABLE: 1307 mac_perim_enter_by_mh(dsp->ds_mh, (mac_perim_handle_t *)data); 1308 return (0); 1309 1310 case DLD_DISABLE: 1311 mac_perim_exit((mac_perim_handle_t)data); 1312 return (0); 1313 1314 case DLD_QUERY: 1315 return (mac_perim_held(dsp->ds_mh)); 1316 } 1317 return (0); 1318 } 1319 1320 static int 1321 dld_capab_direct(dld_str_t *dsp, void *data, uint_t flags) 1322 { 1323 dld_capab_direct_t *direct = data; 1324 1325 ASSERT(MAC_PERIM_HELD(dsp->ds_mh)); 1326 1327 switch (flags) { 1328 case DLD_ENABLE: 1329 dls_rx_set(dsp, (dls_rx_t)direct->di_rx_cf, 1330 direct->di_rx_ch); 1331 1332 direct->di_tx_df = (uintptr_t)str_mdata_fastpath_put; 1333 direct->di_tx_dh = dsp; 1334 direct->di_tx_cb_df = (uintptr_t)mac_client_tx_notify; 1335 direct->di_tx_cb_dh = dsp->ds_mch; 1336 direct->di_tx_fctl_df = (uintptr_t)mac_tx_is_flow_blocked; 1337 direct->di_tx_fctl_dh = dsp->ds_mch; 1338 1339 dsp->ds_direct = B_TRUE; 1340 1341 return (0); 1342 1343 case DLD_DISABLE: 1344 dls_rx_set(dsp, (dsp->ds_mode == DLD_FASTPATH) ? 1345 dld_str_rx_fastpath : dld_str_rx_unitdata, (void *)dsp); 1346 dsp->ds_direct = B_FALSE; 1347 1348 return (0); 1349 } 1350 return (ENOTSUP); 1351 } 1352 1353 /* 1354 * dld_capab_poll_enable() 1355 * 1356 * This function is misnamed. All polling and fanouts are run out of the 1357 * lower mac (in case of VNIC and the only mac in case of NICs). The 1358 * availability of Rx ring and promiscous mode is all taken care between 1359 * the soft ring set (mac_srs), the Rx ring, and S/W classifier. Any 1360 * fanout necessary is done by the soft rings that are part of the 1361 * mac_srs (by default mac_srs sends the packets up via a TCP and 1362 * non TCP soft ring). 1363 * 1364 * The mac_srs (or its associated soft rings) always store the ill_rx_ring 1365 * (the cookie returned when they registered with IP during plumb) as their 1366 * 2nd argument which is passed up as mac_resource_handle_t. The upcall 1367 * function and 1st argument is what the caller registered when they 1368 * called mac_rx_classify_flow_add() to register the flow. For VNIC, 1369 * the function is vnic_rx and argument is vnic_t. For regular NIC 1370 * case, it mac_rx_default and mac_handle_t. As explained above, the 1371 * mac_srs (or its soft ring) will add the ill_rx_ring (mac_resource_handle_t) 1372 * from its stored 2nd argument. 1373 */ 1374 static int 1375 dld_capab_poll_enable(dld_str_t *dsp, dld_capab_poll_t *poll) 1376 { 1377 if (dsp->ds_polling) 1378 return (EINVAL); 1379 1380 if ((dld_opt & DLD_OPT_NO_POLL) != 0 || dsp->ds_mode == DLD_RAW) 1381 return (ENOTSUP); 1382 1383 /* 1384 * Enable client polling if and only if DLS bypass is possible. 1385 * Special cases like VLANs need DLS processing in the Rx data path. 1386 * In such a case we can neither allow the client (IP) to directly 1387 * poll the softring (since DLS processing hasn't been done) nor can 1388 * we allow DLS bypass. 1389 */ 1390 if (!mac_rx_bypass_set(dsp->ds_mch, dsp->ds_rx, dsp->ds_rx_arg)) 1391 return (ENOTSUP); 1392 1393 /* 1394 * Register soft ring resources. This will come in handy later if 1395 * the user decides to modify CPU bindings to use more CPUs for the 1396 * device in which case we will switch to fanout using soft rings. 1397 */ 1398 mac_resource_set_common(dsp->ds_mch, 1399 (mac_resource_add_t)poll->poll_ring_add_cf, 1400 (mac_resource_remove_t)poll->poll_ring_remove_cf, 1401 (mac_resource_quiesce_t)poll->poll_ring_quiesce_cf, 1402 (mac_resource_restart_t)poll->poll_ring_restart_cf, 1403 (mac_resource_bind_t)poll->poll_ring_bind_cf, 1404 poll->poll_ring_ch); 1405 1406 mac_client_poll_enable(dsp->ds_mch); 1407 1408 dsp->ds_polling = B_TRUE; 1409 return (0); 1410 } 1411 1412 /* ARGSUSED */ 1413 static int 1414 dld_capab_poll_disable(dld_str_t *dsp, dld_capab_poll_t *poll) 1415 { 1416 if (!dsp->ds_polling) 1417 return (EINVAL); 1418 1419 mac_client_poll_disable(dsp->ds_mch); 1420 mac_resource_set(dsp->ds_mch, NULL, NULL); 1421 1422 dsp->ds_polling = B_FALSE; 1423 return (0); 1424 } 1425 1426 static int 1427 dld_capab_poll(dld_str_t *dsp, void *data, uint_t flags) 1428 { 1429 dld_capab_poll_t *poll = data; 1430 1431 ASSERT(MAC_PERIM_HELD(dsp->ds_mh)); 1432 1433 switch (flags) { 1434 case DLD_ENABLE: 1435 return (dld_capab_poll_enable(dsp, poll)); 1436 case DLD_DISABLE: 1437 return (dld_capab_poll_disable(dsp, poll)); 1438 } 1439 return (ENOTSUP); 1440 } 1441 1442 static int 1443 dld_capab_lso(dld_str_t *dsp, void *data, uint_t flags) 1444 { 1445 dld_capab_lso_t *lso = data; 1446 1447 ASSERT(MAC_PERIM_HELD(dsp->ds_mh)); 1448 1449 switch (flags) { 1450 case DLD_ENABLE: { 1451 mac_capab_lso_t mac_lso; 1452 1453 /* 1454 * Check if LSO is supported on this MAC & enable LSO 1455 * accordingly. 1456 */ 1457 if (mac_capab_get(dsp->ds_mh, MAC_CAPAB_LSO, &mac_lso)) { 1458 lso->lso_max = mac_lso.lso_basic_tcp_ipv4.lso_max; 1459 lso->lso_flags = 0; 1460 /* translate the flag for mac clients */ 1461 if ((mac_lso.lso_flags & LSO_TX_BASIC_TCP_IPV4) != 0) 1462 lso->lso_flags |= DLD_LSO_TX_BASIC_TCP_IPV4; 1463 dsp->ds_lso = B_TRUE; 1464 dsp->ds_lso_max = lso->lso_max; 1465 } else { 1466 dsp->ds_lso = B_FALSE; 1467 dsp->ds_lso_max = 0; 1468 return (ENOTSUP); 1469 } 1470 return (0); 1471 } 1472 case DLD_DISABLE: { 1473 dsp->ds_lso = B_FALSE; 1474 dsp->ds_lso_max = 0; 1475 return (0); 1476 } 1477 } 1478 return (ENOTSUP); 1479 } 1480 1481 static int 1482 dld_capab(dld_str_t *dsp, uint_t type, void *data, uint_t flags) 1483 { 1484 int err; 1485 1486 /* 1487 * Don't enable direct callback capabilities unless the caller is 1488 * the IP client. When a module is inserted in a stream (_I_INSERT) 1489 * the stack initiates capability disable, but due to races, the 1490 * module insertion may complete before the capability disable 1491 * completes. So we limit the check to DLD_ENABLE case. 1492 */ 1493 if ((flags == DLD_ENABLE && type != DLD_CAPAB_PERIM) && 1494 (dsp->ds_sap != ETHERTYPE_IP || !check_ip_above(dsp->ds_rq))) { 1495 return (ENOTSUP); 1496 } 1497 1498 switch (type) { 1499 case DLD_CAPAB_DIRECT: 1500 err = dld_capab_direct(dsp, data, flags); 1501 break; 1502 1503 case DLD_CAPAB_POLL: 1504 err = dld_capab_poll(dsp, data, flags); 1505 break; 1506 1507 case DLD_CAPAB_PERIM: 1508 err = dld_capab_perim(dsp, data, flags); 1509 break; 1510 1511 case DLD_CAPAB_LSO: 1512 err = dld_capab_lso(dsp, data, flags); 1513 break; 1514 1515 default: 1516 err = ENOTSUP; 1517 break; 1518 } 1519 1520 return (err); 1521 } 1522 1523 /* 1524 * DL_CAPABILITY_ACK/DL_ERROR_ACK 1525 */ 1526 static void 1527 proto_capability_advertise(dld_str_t *dsp, mblk_t *mp) 1528 { 1529 dl_capability_ack_t *dlap; 1530 dl_capability_sub_t *dlsp; 1531 size_t subsize; 1532 dl_capab_dld_t dld; 1533 dl_capab_hcksum_t hcksum; 1534 dl_capab_zerocopy_t zcopy; 1535 uint8_t *ptr; 1536 queue_t *q = dsp->ds_wq; 1537 mblk_t *mp1; 1538 boolean_t is_vlan; 1539 boolean_t hcksum_capable = B_FALSE; 1540 boolean_t zcopy_capable = B_FALSE; 1541 boolean_t dld_capable = B_FALSE; 1542 1543 /* 1544 * Initially assume no capabilities. 1545 */ 1546 subsize = 0; 1547 is_vlan = (mac_client_vid(dsp->ds_mch) != VLAN_ID_NONE); 1548 1549 /* 1550 * Check if checksum offload is supported on this MAC. Don't 1551 * advertise DL_CAPAB_HCKSUM if the underlying MAC is VLAN incapable, 1552 * since it might not be able to do the hardware checksum offload 1553 * with the correct offset. 1554 */ 1555 bzero(&hcksum, sizeof (dl_capab_hcksum_t)); 1556 if ((!is_vlan || (!mac_capab_get(dsp->ds_mh, MAC_CAPAB_NO_NATIVEVLAN, 1557 NULL))) && mac_capab_get(dsp->ds_mh, MAC_CAPAB_HCKSUM, 1558 &hcksum.hcksum_txflags)) { 1559 if (hcksum.hcksum_txflags != 0) { 1560 hcksum_capable = B_TRUE; 1561 subsize += sizeof (dl_capability_sub_t) + 1562 sizeof (dl_capab_hcksum_t); 1563 } 1564 } 1565 1566 /* 1567 * Check if zerocopy is supported on this interface. 1568 * If advertising DL_CAPAB_ZEROCOPY has not been explicitly disabled 1569 * then reserve space for that capability. 1570 */ 1571 if (!mac_capab_get(dsp->ds_mh, MAC_CAPAB_NO_ZCOPY, NULL) && 1572 !(dld_opt & DLD_OPT_NO_ZEROCOPY)) { 1573 zcopy_capable = B_TRUE; 1574 subsize += sizeof (dl_capability_sub_t) + 1575 sizeof (dl_capab_zerocopy_t); 1576 } 1577 1578 /* 1579 * Direct capability negotiation interface between IP and DLD 1580 */ 1581 if (dsp->ds_sap == ETHERTYPE_IP && check_ip_above(dsp->ds_rq)) { 1582 dld_capable = B_TRUE; 1583 subsize += sizeof (dl_capability_sub_t) + 1584 sizeof (dl_capab_dld_t); 1585 } 1586 1587 /* 1588 * If there are no capabilities to advertise or if we 1589 * can't allocate a response, send a DL_ERROR_ACK. 1590 */ 1591 if ((mp1 = reallocb(mp, 1592 sizeof (dl_capability_ack_t) + subsize, 0)) == NULL) { 1593 dlerrorack(q, mp, DL_CAPABILITY_REQ, DL_NOTSUPPORTED, 0); 1594 return; 1595 } 1596 1597 mp = mp1; 1598 DB_TYPE(mp) = M_PROTO; 1599 mp->b_wptr = mp->b_rptr + sizeof (dl_capability_ack_t) + subsize; 1600 bzero(mp->b_rptr, MBLKL(mp)); 1601 dlap = (dl_capability_ack_t *)mp->b_rptr; 1602 dlap->dl_primitive = DL_CAPABILITY_ACK; 1603 dlap->dl_sub_offset = sizeof (dl_capability_ack_t); 1604 dlap->dl_sub_length = subsize; 1605 ptr = (uint8_t *)&dlap[1]; 1606 1607 /* 1608 * TCP/IP checksum offload. 1609 */ 1610 if (hcksum_capable) { 1611 dlsp = (dl_capability_sub_t *)ptr; 1612 1613 dlsp->dl_cap = DL_CAPAB_HCKSUM; 1614 dlsp->dl_length = sizeof (dl_capab_hcksum_t); 1615 ptr += sizeof (dl_capability_sub_t); 1616 1617 hcksum.hcksum_version = HCKSUM_VERSION_1; 1618 dlcapabsetqid(&(hcksum.hcksum_mid), dsp->ds_rq); 1619 bcopy(&hcksum, ptr, sizeof (dl_capab_hcksum_t)); 1620 ptr += sizeof (dl_capab_hcksum_t); 1621 } 1622 1623 /* 1624 * Zero copy 1625 */ 1626 if (zcopy_capable) { 1627 dlsp = (dl_capability_sub_t *)ptr; 1628 1629 dlsp->dl_cap = DL_CAPAB_ZEROCOPY; 1630 dlsp->dl_length = sizeof (dl_capab_zerocopy_t); 1631 ptr += sizeof (dl_capability_sub_t); 1632 1633 bzero(&zcopy, sizeof (dl_capab_zerocopy_t)); 1634 zcopy.zerocopy_version = ZEROCOPY_VERSION_1; 1635 zcopy.zerocopy_flags = DL_CAPAB_VMSAFE_MEM; 1636 1637 dlcapabsetqid(&(zcopy.zerocopy_mid), dsp->ds_rq); 1638 bcopy(&zcopy, ptr, sizeof (dl_capab_zerocopy_t)); 1639 ptr += sizeof (dl_capab_zerocopy_t); 1640 } 1641 1642 /* 1643 * Direct capability negotiation interface between IP and DLD. 1644 * Refer to dld.h for details. 1645 */ 1646 if (dld_capable) { 1647 dlsp = (dl_capability_sub_t *)ptr; 1648 dlsp->dl_cap = DL_CAPAB_DLD; 1649 dlsp->dl_length = sizeof (dl_capab_dld_t); 1650 ptr += sizeof (dl_capability_sub_t); 1651 1652 bzero(&dld, sizeof (dl_capab_dld_t)); 1653 dld.dld_version = DLD_CURRENT_VERSION; 1654 dld.dld_capab = (uintptr_t)dld_capab; 1655 dld.dld_capab_handle = (uintptr_t)dsp; 1656 1657 dlcapabsetqid(&(dld.dld_mid), dsp->ds_rq); 1658 bcopy(&dld, ptr, sizeof (dl_capab_dld_t)); 1659 ptr += sizeof (dl_capab_dld_t); 1660 } 1661 1662 ASSERT(ptr == mp->b_rptr + sizeof (dl_capability_ack_t) + subsize); 1663 qreply(q, mp); 1664 } 1665 1666 /* 1667 * Disable any enabled capabilities. 1668 */ 1669 void 1670 dld_capabilities_disable(dld_str_t *dsp) 1671 { 1672 if (dsp->ds_polling) 1673 (void) dld_capab_poll_disable(dsp, NULL); 1674 } 1675