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