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