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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * The softmac driver is used to "unify" non-GLDv3 drivers to the GLDv3
28 * framework. It also creates the kernel datalink structure for each
29 * physical network device.
30 *
31 * Specifically, a softmac will be created for each physical network device
32 * (dip) during the device's post-attach process. When this softmac is
33 * created, the following will also be done:
34 * - create the device's <link name, linkid> mapping;
35 * - register the mac if this is a non-GLDv3 device and the media type is
36 * supported by the GLDv3 framework;
37 * - create the kernel data-link structure for this physical device;
38 *
39 * This softmac will be destroyed during the device's pre-detach process,
40 * and all the above will be undone.
41 */
42
43 #include <sys/types.h>
44 #include <sys/file.h>
45 #include <sys/cred.h>
46 #include <sys/dlpi.h>
47 #include <sys/mac_provider.h>
48 #include <sys/disp.h>
49 #include <sys/sunndi.h>
50 #include <sys/modhash.h>
51 #include <sys/stropts.h>
52 #include <sys/sysmacros.h>
53 #include <sys/vlan.h>
54 #include <sys/softmac_impl.h>
55 #include <sys/softmac.h>
56 #include <sys/dls.h>
57
58 /* Used as a parameter to the mod hash walk of softmac structures */
59 typedef struct {
60 softmac_t *smw_softmac;
61 boolean_t smw_retry;
62 } softmac_walk_t;
63
64 /*
65 * Softmac hash table including softmacs for both style-2 and style-1 devices.
66 */
67 static krwlock_t softmac_hash_lock;
68 static mod_hash_t *softmac_hash;
69 static kmutex_t smac_global_lock;
70 static kcondvar_t smac_global_cv;
71
72 static kmem_cache_t *softmac_cachep;
73
74 #define SOFTMAC_HASHSZ 64
75
76 static void softmac_create_task(void *);
77 static void softmac_mac_register(softmac_t *);
78 static int softmac_create_datalink(softmac_t *);
79 static int softmac_m_start(void *);
80 static void softmac_m_stop(void *);
81 static int softmac_m_open(void *);
82 static void softmac_m_close(void *);
83 static boolean_t softmac_m_getcapab(void *, mac_capab_t, void *);
84 static int softmac_m_setprop(void *, const char *, mac_prop_id_t,
85 uint_t, const void *);
86 static int softmac_m_getprop(void *, const char *, mac_prop_id_t,
87 uint_t, void *);
88 static void softmac_m_propinfo(void *, const char *, mac_prop_id_t,
89 mac_prop_info_handle_t);
90
91 #define SOFTMAC_M_CALLBACK_FLAGS \
92 (MC_IOCTL | MC_GETCAPAB | MC_OPEN | MC_CLOSE | MC_SETPROP | \
93 MC_GETPROP | MC_PROPINFO)
94
95 static mac_callbacks_t softmac_m_callbacks = {
96 SOFTMAC_M_CALLBACK_FLAGS,
97 softmac_m_stat,
98 softmac_m_start,
99 softmac_m_stop,
100 softmac_m_promisc,
101 softmac_m_multicst,
102 softmac_m_unicst,
103 softmac_m_tx,
104 NULL,
105 softmac_m_ioctl,
106 softmac_m_getcapab,
107 softmac_m_open,
108 softmac_m_close,
109 softmac_m_setprop,
110 softmac_m_getprop,
111 softmac_m_propinfo
112 };
113
114 /*ARGSUSED*/
115 static int
softmac_constructor(void * buf,void * arg,int kmflag)116 softmac_constructor(void *buf, void *arg, int kmflag)
117 {
118 softmac_t *softmac = buf;
119
120 bzero(buf, sizeof (softmac_t));
121 mutex_init(&softmac->smac_mutex, NULL, MUTEX_DEFAULT, NULL);
122 mutex_init(&softmac->smac_active_mutex, NULL, MUTEX_DEFAULT, NULL);
123 mutex_init(&softmac->smac_fp_mutex, NULL, MUTEX_DEFAULT, NULL);
124 cv_init(&softmac->smac_cv, NULL, CV_DEFAULT, NULL);
125 cv_init(&softmac->smac_fp_cv, NULL, CV_DEFAULT, NULL);
126 list_create(&softmac->smac_sup_list, sizeof (softmac_upper_t),
127 offsetof(softmac_upper_t, su_list_node));
128 return (0);
129 }
130
131 /*ARGSUSED*/
132 static void
softmac_destructor(void * buf,void * arg)133 softmac_destructor(void *buf, void *arg)
134 {
135 softmac_t *softmac = buf;
136
137 ASSERT(softmac->smac_fp_disable_clients == 0);
138 ASSERT(!softmac->smac_fastpath_admin_disabled);
139
140 ASSERT(!(softmac->smac_flags & SOFTMAC_ATTACH_DONE));
141 ASSERT(softmac->smac_hold_cnt == 0);
142 ASSERT(softmac->smac_attachok_cnt == 0);
143 ASSERT(softmac->smac_mh == NULL);
144 ASSERT(softmac->smac_softmac[0] == NULL &&
145 softmac->smac_softmac[1] == NULL);
146 ASSERT(softmac->smac_lower == NULL);
147 ASSERT(softmac->smac_active == B_FALSE);
148 ASSERT(softmac->smac_nactive == 0);
149 ASSERT(list_is_empty(&softmac->smac_sup_list));
150
151 list_destroy(&softmac->smac_sup_list);
152 mutex_destroy(&softmac->smac_mutex);
153 mutex_destroy(&softmac->smac_active_mutex);
154 mutex_destroy(&softmac->smac_fp_mutex);
155 cv_destroy(&softmac->smac_cv);
156 cv_destroy(&softmac->smac_fp_cv);
157 }
158
159 void
softmac_init()160 softmac_init()
161 {
162 softmac_hash = mod_hash_create_extended("softmac_hash",
163 SOFTMAC_HASHSZ, mod_hash_null_keydtor, mod_hash_null_valdtor,
164 mod_hash_bystr, NULL, mod_hash_strkey_cmp, KM_SLEEP);
165
166 rw_init(&softmac_hash_lock, NULL, RW_DEFAULT, NULL);
167 mutex_init(&smac_global_lock, NULL, MUTEX_DRIVER, NULL);
168 cv_init(&smac_global_cv, NULL, CV_DRIVER, NULL);
169
170 softmac_cachep = kmem_cache_create("softmac_cache",
171 sizeof (softmac_t), 0, softmac_constructor,
172 softmac_destructor, NULL, NULL, NULL, 0);
173 ASSERT(softmac_cachep != NULL);
174 softmac_fp_init();
175 }
176
177 void
softmac_fini()178 softmac_fini()
179 {
180 softmac_fp_fini();
181 kmem_cache_destroy(softmac_cachep);
182 rw_destroy(&softmac_hash_lock);
183 mod_hash_destroy_hash(softmac_hash);
184 mutex_destroy(&smac_global_lock);
185 cv_destroy(&smac_global_cv);
186 }
187
188 /* ARGSUSED */
189 static uint_t
softmac_exist(mod_hash_key_t key,mod_hash_val_t * val,void * arg)190 softmac_exist(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
191 {
192 boolean_t *pexist = arg;
193
194 *pexist = B_TRUE;
195 return (MH_WALK_TERMINATE);
196 }
197
198 boolean_t
softmac_busy()199 softmac_busy()
200 {
201 boolean_t exist = B_FALSE;
202
203 rw_enter(&softmac_hash_lock, RW_READER);
204 mod_hash_walk(softmac_hash, softmac_exist, &exist);
205 rw_exit(&softmac_hash_lock);
206 return (exist);
207 }
208
209 /*
210 *
211 * softmac_create() is called for each minor node during the post-attach of
212 * each DDI_NT_NET device instance. Note that it is possible that a device
213 * instance has two minor nodes (DLPI style-1 and style-2), so that for that
214 * specific device, softmac_create() could be called twice.
215 *
216 * A softmac_t is used to track each DDI_NT_NET device, and a softmac_dev_t
217 * is created to track each minor node.
218 *
219 * For each minor node of a legacy device, a taskq is started to finish
220 * softmac_mac_register(), which will finish the rest of work (see comments
221 * above softmac_mac_register()).
222 *
223 * softmac state machine
224 * --------------------------------------------------------------------------
225 * OLD STATE EVENT NEW STATE
226 * --------------------------------------------------------------------------
227 * UNINIT attach of 1st minor node ATTACH_INPROG
228 * okcnt = 0 net_postattach -> softmac_create okcnt = 1
229 *
230 * ATTACH_INPROG attach of 2nd minor node (GLDv3) ATTACH_DONE
231 * okcnt = 1 net_postattach -> softmac_create okcnt = 2
232 *
233 * ATTACH_INPROG attach of 2nd minor node (legacy) ATTACH_INPROG
234 * okcnt = 1 net_postattach -> softmac_create okcnt = 2
235 * schedule softmac_mac_register
236 *
237 * ATTACH_INPROG legacy device node ATTACH_DONE
238 * okcnt = 2 softmac_mac_register okcnt = 2
239 *
240 * ATTACH_DONE detach of 1st minor node DETACH_INPROG
241 * okcnt = 2 (success) okcnt = 1
242 *
243 * DETACH_INPROG detach of 2nd minor node UNINIT (or free)
244 * okcnt = 1 (success) okcnt = 0
245 *
246 * ATTACH_DONE detach failure state unchanged
247 * DETACH_INPROG left = okcnt
248 *
249 * DETACH_INPROG reattach ATTACH_INPROG
250 * okcnt = 0,1 net_postattach -> softmac_create
251 *
252 * ATTACH_DONE reattach ATTACH_DONE
253 * left != 0 net_postattach -> softmac_create left = 0
254 *
255 * Abbreviation notes:
256 * states have SOFTMAC_ prefix,
257 * okcnt - softmac_attach_okcnt,
258 * left - softmac_attached_left
259 */
260
261 #ifdef DEBUG
262 void
softmac_state_verify(softmac_t * softmac)263 softmac_state_verify(softmac_t *softmac)
264 {
265 ASSERT(MUTEX_HELD(&softmac->smac_mutex));
266
267 /*
268 * There are at most 2 minor nodes, one per DLPI style
269 */
270 ASSERT(softmac->smac_cnt <= 2 && softmac->smac_attachok_cnt <= 2);
271
272 /*
273 * The smac_attachok_cnt represents the number of attaches i.e. the
274 * number of times net_postattach -> softmac_create() has been called
275 * for a device instance.
276 */
277 ASSERT(softmac->smac_attachok_cnt == SMAC_NONZERO_NODECNT(softmac));
278
279 /*
280 * softmac_create (or softmac_mac_register) -> softmac_create_datalink
281 * happens only after all minor nodes have been attached
282 */
283 ASSERT(softmac->smac_state != SOFTMAC_ATTACH_DONE ||
284 softmac->smac_attachok_cnt == softmac->smac_cnt);
285
286 if (softmac->smac_attachok_cnt == 0) {
287 ASSERT(softmac->smac_state == SOFTMAC_UNINIT);
288 ASSERT(softmac->smac_mh == NULL);
289 } else if (softmac->smac_attachok_cnt < softmac->smac_cnt) {
290 ASSERT(softmac->smac_state == SOFTMAC_ATTACH_INPROG ||
291 softmac->smac_state == SOFTMAC_DETACH_INPROG);
292 ASSERT(softmac->smac_mh == NULL);
293 } else {
294 /*
295 * In the stable condition the state whould be
296 * SOFTMAC_ATTACH_DONE. But there is a small transient window
297 * in softmac_destroy where we change the state to
298 * SOFTMAC_DETACH_INPROG and drop the lock before doing
299 * the link destroy
300 */
301 ASSERT(softmac->smac_attachok_cnt == softmac->smac_cnt);
302 ASSERT(softmac->smac_state != SOFTMAC_UNINIT);
303 }
304 if (softmac->smac_mh != NULL)
305 ASSERT(softmac->smac_attachok_cnt == softmac->smac_cnt);
306 }
307 #endif
308
309 #ifdef DEBUG
310 #define SOFTMAC_STATE_VERIFY(softmac) softmac_state_verify(softmac)
311 #else
312 #define SOFTMAC_STATE_VERIFY(softmac)
313 #endif
314
315 int
softmac_create(dev_info_t * dip,dev_t dev)316 softmac_create(dev_info_t *dip, dev_t dev)
317 {
318 char devname[MAXNAMELEN];
319 softmac_t *softmac;
320 softmac_dev_t *softmac_dev = NULL;
321 int index;
322 int ppa, err = 0;
323
324 /*
325 * Force the softmac driver to be attached.
326 */
327 if (i_ddi_attach_pseudo_node(SOFTMAC_DEV_NAME) == NULL) {
328 cmn_err(CE_WARN, "softmac_create:softmac attach fails");
329 return (ENXIO);
330 }
331
332 if (GLDV3_DRV(ddi_driver_major(dip))) {
333 minor_t minor = getminor(dev);
334 /*
335 * For GLDv3, we don't care about the DLPI style 2
336 * compatibility node. (We know that all such devices
337 * have style 1 nodes.)
338 */
339 if ((strcmp(ddi_driver_name(dip), "clone") == 0) ||
340 (getmajor(dev) == ddi_name_to_major("clone")) ||
341 (minor == 0)) {
342 return (0);
343 }
344
345 /*
346 * Likewise, we know that the minor number for DLPI style 1
347 * nodes is constrained to a maximum value.
348 */
349 if (minor >= DLS_MAX_MINOR) {
350 return (ENOTSUP);
351 }
352 /*
353 * Otherwise we can decode the instance from the minor number,
354 * which allows for situations with multiple mac instances
355 * for a single dev_info_t.
356 */
357 ppa = DLS_MINOR2INST(minor);
358 } else {
359 /*
360 * For legacy drivers, we just have to limit them to
361 * two minor nodes, one style 1 and one style 2, and
362 * we assume the ddi_get_instance() is the PPA.
363 * Drivers that need more flexibility should be ported
364 * to GLDv3.
365 */
366 ppa = ddi_get_instance(dip);
367 if (i_ddi_minor_node_count(dip, DDI_NT_NET) > 2) {
368 cmn_err(CE_WARN, "%s has more than 2 minor nodes; "
369 "unsupported", devname);
370 return (ENOTSUP);
371 }
372 }
373
374 (void) snprintf(devname, MAXNAMELEN, "%s%d", ddi_driver_name(dip), ppa);
375
376 /*
377 * Check whether the softmac for the specified device already exists
378 */
379 rw_enter(&softmac_hash_lock, RW_WRITER);
380 if ((mod_hash_find(softmac_hash, (mod_hash_key_t)devname,
381 (mod_hash_val_t *)&softmac)) != 0) {
382
383 softmac = kmem_cache_alloc(softmac_cachep, KM_SLEEP);
384 (void) strlcpy(softmac->smac_devname, devname, MAXNAMELEN);
385
386 err = mod_hash_insert(softmac_hash,
387 (mod_hash_key_t)softmac->smac_devname,
388 (mod_hash_val_t)softmac);
389 ASSERT(err == 0);
390 mutex_enter(&smac_global_lock);
391 cv_broadcast(&smac_global_cv);
392 mutex_exit(&smac_global_lock);
393 }
394
395 mutex_enter(&softmac->smac_mutex);
396 SOFTMAC_STATE_VERIFY(softmac);
397 if (softmac->smac_state != SOFTMAC_ATTACH_DONE)
398 softmac->smac_state = SOFTMAC_ATTACH_INPROG;
399 if (softmac->smac_attachok_cnt == 0) {
400 /*
401 * Initialize the softmac if this is the post-attach of the
402 * first minor node.
403 */
404 softmac->smac_flags = 0;
405 softmac->smac_umajor = ddi_driver_major(dip);
406 softmac->smac_uppa = ppa;
407
408 /*
409 * For GLDv3, we ignore the style 2 node (see the logic
410 * above on that), and we should have exactly one attach
411 * per MAC instance (possibly more than one per dev_info_t).
412 */
413 if (GLDV3_DRV(ddi_driver_major(dip))) {
414 softmac->smac_flags |= SOFTMAC_GLDV3;
415 softmac->smac_cnt = 1;
416 } else {
417 softmac->smac_cnt =
418 i_ddi_minor_node_count(dip, DDI_NT_NET);
419 }
420 }
421
422 index = (getmajor(dev) == ddi_name_to_major("clone"));
423 if (softmac->smac_softmac[index] != NULL) {
424 /*
425 * This is possible if the post_attach() is called after
426 * pre_detach() fails. This seems to be a defect of the DACF
427 * framework. We work around it by using a smac_attached_left
428 * field that tracks this
429 */
430 ASSERT(softmac->smac_attached_left != 0);
431 softmac->smac_attached_left--;
432 mutex_exit(&softmac->smac_mutex);
433 rw_exit(&softmac_hash_lock);
434 return (0);
435
436 }
437 mutex_exit(&softmac->smac_mutex);
438 rw_exit(&softmac_hash_lock);
439
440 softmac_dev = kmem_zalloc(sizeof (softmac_dev_t), KM_SLEEP);
441 softmac_dev->sd_dev = dev;
442
443 mutex_enter(&softmac->smac_mutex);
444 softmac->smac_softmac[index] = softmac_dev;
445 /*
446 * Continue to register the mac and create the datalink only when all
447 * the minor nodes are attached.
448 */
449 if (++softmac->smac_attachok_cnt != softmac->smac_cnt) {
450 mutex_exit(&softmac->smac_mutex);
451 return (0);
452 }
453
454 /*
455 * All of the minor nodes have been attached; start a taskq
456 * to do the rest of the work. We use a taskq instead of
457 * doing the work here because:
458 *
459 * We could be called as a result of a open() system call
460 * where spec_open() already SLOCKED the snode. Using a taskq
461 * sidesteps the risk that our ldi_open_by_dev() call would
462 * deadlock trying to set SLOCKED on the snode again.
463 *
464 * The devfs design requires that the downcalls don't use any
465 * interruptible cv_wait which happens when we do door upcalls.
466 * Otherwise the downcalls which may be holding devfs resources
467 * may cause a deadlock if the thread is stopped. Also we need to make
468 * sure these downcalls into softmac_create or softmac_destroy
469 * don't cv_wait on any devfs related condition. Thus softmac_destroy
470 * returns EBUSY if the asynchronous threads started in softmac_create
471 * haven't finished.
472 */
473 (void) taskq_dispatch(system_taskq, softmac_create_task,
474 softmac, TQ_SLEEP);
475 mutex_exit(&softmac->smac_mutex);
476 return (0);
477 }
478
479 static boolean_t
softmac_m_getcapab(void * arg,mac_capab_t cap,void * cap_data)480 softmac_m_getcapab(void *arg, mac_capab_t cap, void *cap_data)
481 {
482 softmac_t *softmac = arg;
483
484 if (!(softmac->smac_capab_flags & cap))
485 return (B_FALSE);
486
487 switch (cap) {
488 case MAC_CAPAB_HCKSUM: {
489 uint32_t *txflags = cap_data;
490
491 *txflags = softmac->smac_hcksum_txflags;
492 break;
493 }
494 case MAC_CAPAB_LEGACY: {
495 mac_capab_legacy_t *legacy = cap_data;
496
497 /*
498 * The caller is not interested in the details.
499 */
500 if (legacy == NULL)
501 break;
502
503 legacy->ml_unsup_note = ~softmac->smac_notifications &
504 (DL_NOTE_LINK_UP | DL_NOTE_LINK_DOWN | DL_NOTE_SPEED);
505 legacy->ml_active_set = softmac_active_set;
506 legacy->ml_active_clear = softmac_active_clear;
507 legacy->ml_fastpath_disable = softmac_fastpath_disable;
508 legacy->ml_fastpath_enable = softmac_fastpath_enable;
509 legacy->ml_dev = makedevice(softmac->smac_umajor,
510 softmac->smac_uppa + 1);
511 break;
512 }
513
514 /*
515 * For the capabilities below, there's nothing for us to fill in;
516 * simply return B_TRUE if we support it.
517 */
518 case MAC_CAPAB_NO_ZCOPY:
519 case MAC_CAPAB_NO_NATIVEVLAN:
520 default:
521 break;
522 }
523 return (B_TRUE);
524 }
525
526 static int
softmac_update_info(softmac_t * softmac,datalink_id_t * linkidp)527 softmac_update_info(softmac_t *softmac, datalink_id_t *linkidp)
528 {
529 datalink_id_t linkid = DATALINK_INVALID_LINKID;
530 uint32_t media;
531 int err;
532
533 if ((err = dls_mgmt_update(softmac->smac_devname, softmac->smac_media,
534 softmac->smac_flags & SOFTMAC_NOSUPP, &media, &linkid)) == 0) {
535 *linkidp = linkid;
536 }
537
538 if (err == EEXIST) {
539 /*
540 * There is a link name conflict. Either:
541 *
542 * - An existing link with the same device name with a
543 * different media type from of the given type.
544 * Mark this link back to persistent only; or
545 *
546 * - We cannot assign the "suggested" name because
547 * GLDv3 and therefore vanity naming is not supported
548 * for this link type. Delete this link's <link name,
549 * linkid> mapping.
550 */
551 if (media != softmac->smac_media) {
552 cmn_err(CE_WARN, "%s device %s conflicts with "
553 "existing %s device %s.",
554 dl_mactypestr(softmac->smac_media),
555 softmac->smac_devname, dl_mactypestr(media),
556 softmac->smac_devname);
557 (void) dls_mgmt_destroy(linkid, B_FALSE);
558 } else {
559 cmn_err(CE_WARN, "link name %s is already in-use.",
560 softmac->smac_devname);
561 (void) dls_mgmt_destroy(linkid, B_TRUE);
562 }
563
564 cmn_err(CE_WARN, "%s device might not be available "
565 "for use.", softmac->smac_devname);
566 cmn_err(CE_WARN, "See dladm(8) for more information.");
567 }
568
569 return (err);
570 }
571
572 /*
573 * This function:
574 * 1. provides the link's media type to dlmgmtd.
575 * 2. creates the GLDv3 datalink if the media type is supported by GLDv3.
576 */
577 static int
softmac_create_datalink(softmac_t * softmac)578 softmac_create_datalink(softmac_t *softmac)
579 {
580 datalink_id_t linkid = DATALINK_INVALID_LINKID;
581 int err;
582
583 /*
584 * Inform dlmgmtd of this link so that softmac_hold_device() is able
585 * to know the existence of this link. If this failed with EBADF,
586 * it might be because dlmgmtd was not started in time (e.g.,
587 * diskless boot); ignore the failure and continue to create
588 * the GLDv3 datalink if needed.
589 */
590 err = dls_mgmt_create(softmac->smac_devname,
591 makedevice(softmac->smac_umajor, softmac->smac_uppa + 1),
592 DATALINK_CLASS_PHYS, DL_OTHER, B_TRUE, &linkid);
593 if (err != 0 && err != EBADF)
594 return (err);
595
596 /*
597 * Provide the media type of the physical link to dlmgmtd.
598 */
599 if ((err != EBADF) &&
600 ((err = softmac_update_info(softmac, &linkid)) != 0)) {
601 return (err);
602 }
603
604 /*
605 * Create the GLDv3 datalink.
606 */
607 if (!(softmac->smac_flags & SOFTMAC_NOSUPP)) {
608 err = dls_devnet_create(softmac->smac_mh, linkid,
609 crgetzoneid(CRED()));
610 if (err != 0) {
611 cmn_err(CE_WARN, "dls_devnet_create failed for %s",
612 softmac->smac_devname);
613 return (err);
614 }
615 }
616
617 if (linkid == DATALINK_INVALID_LINKID) {
618 mutex_enter(&softmac->smac_mutex);
619 softmac->smac_flags |= SOFTMAC_NEED_RECREATE;
620 mutex_exit(&softmac->smac_mutex);
621 }
622
623 return (0);
624 }
625
626 static void
softmac_create_task(void * arg)627 softmac_create_task(void *arg)
628 {
629 softmac_t *softmac = arg;
630 mac_handle_t mh;
631 int err;
632
633 if (!GLDV3_DRV(softmac->smac_umajor)) {
634 softmac_mac_register(softmac);
635 return;
636 }
637
638 if ((err = mac_open(softmac->smac_devname, &mh)) != 0)
639 goto done;
640
641 mutex_enter(&softmac->smac_mutex);
642 softmac->smac_media = (mac_info(mh))->mi_nativemedia;
643 softmac->smac_mh = mh;
644 mutex_exit(&softmac->smac_mutex);
645
646 /*
647 * We can safely release the reference on the mac because
648 * this mac will only be unregistered and destroyed when
649 * the device detaches, and the softmac will be destroyed
650 * before then (in the pre-detach routine of the device).
651 */
652 mac_close(mh);
653
654 /*
655 * Create the GLDv3 datalink for this mac.
656 */
657 err = softmac_create_datalink(softmac);
658
659 done:
660 mutex_enter(&softmac->smac_mutex);
661 if (err != 0)
662 softmac->smac_mh = NULL;
663 softmac->smac_attacherr = err;
664 softmac->smac_state = SOFTMAC_ATTACH_DONE;
665 cv_broadcast(&softmac->smac_cv);
666 mutex_exit(&softmac->smac_mutex);
667 }
668
669 /*
670 * This function is only called for legacy devices. It:
671 * 1. registers the MAC for the legacy devices whose media type is supported
672 * by the GLDv3 framework.
673 * 2. creates the GLDv3 datalink if the media type is supported by GLDv3.
674 */
675 static void
softmac_mac_register(softmac_t * softmac)676 softmac_mac_register(softmac_t *softmac)
677 {
678 softmac_dev_t *softmac_dev;
679 dev_t dev;
680 ldi_handle_t lh = NULL;
681 ldi_ident_t li = NULL;
682 int index;
683 boolean_t native_vlan = B_FALSE;
684 int err;
685
686 /*
687 * Note that we do not need any locks to access this softmac pointer,
688 * as softmac_destroy() will wait until this function is called.
689 */
690 ASSERT(softmac != NULL);
691 ASSERT(softmac->smac_state == SOFTMAC_ATTACH_INPROG &&
692 softmac->smac_attachok_cnt == softmac->smac_cnt);
693
694 if ((err = ldi_ident_from_dip(softmac_dip, &li)) != 0) {
695 mutex_enter(&softmac->smac_mutex);
696 goto done;
697 }
698
699 /*
700 * Determine whether this legacy device support VLANs by opening
701 * the style-2 device node (if it exists) and attaching to a VLAN
702 * PPA (1000 + ppa).
703 */
704 dev = makedevice(ddi_name_to_major("clone"), softmac->smac_umajor);
705 err = ldi_open_by_dev(&dev, OTYP_CHR, FREAD|FWRITE, kcred, &lh, li);
706 if (err == 0) {
707 if (dl_attach(lh, softmac->smac_uppa + 1 * 1000, NULL) == 0)
708 native_vlan = B_TRUE;
709 (void) ldi_close(lh, FREAD|FWRITE, kcred);
710 }
711
712 err = EINVAL;
713 for (index = 0; index < 2; index++) {
714 dl_info_ack_t dlia;
715 dl_error_ack_t dlea;
716 uint32_t notes;
717 struct strioctl iocb;
718 uint32_t margin;
719 int rval;
720
721 if ((softmac_dev = softmac->smac_softmac[index]) == NULL)
722 continue;
723
724 softmac->smac_dev = dev = softmac_dev->sd_dev;
725 if (ldi_open_by_dev(&dev, OTYP_CHR, FREAD|FWRITE, kcred, &lh,
726 li) != 0) {
727 continue;
728 }
729
730 /*
731 * Pop all the intermediate modules in order to negotiate
732 * capabilities correctly.
733 */
734 while (ldi_ioctl(lh, I_POP, 0, FKIOCTL, kcred, &rval) == 0)
735 ;
736
737 /* DLPI style-1 or DLPI style-2? */
738 if ((rval = dl_info(lh, &dlia, NULL, NULL, &dlea)) != 0) {
739 if (rval == ENOTSUP) {
740 cmn_err(CE_NOTE, "softmac: received "
741 "DL_ERROR_ACK to DL_INFO_ACK; "
742 "DLPI errno 0x%x, UNIX errno %d",
743 dlea.dl_errno, dlea.dl_unix_errno);
744 }
745 (void) ldi_close(lh, FREAD|FWRITE, kcred);
746 continue;
747 }
748
749 /*
750 * Currently only DL_ETHER has GLDv3 mac plugin support.
751 * For media types that GLDv3 does not support, create a
752 * link id for it.
753 */
754 if ((softmac->smac_media = dlia.dl_mac_type) != DL_ETHER) {
755 (void) ldi_close(lh, FREAD|FWRITE, kcred);
756 err = 0;
757 break;
758 }
759
760 if ((dlia.dl_provider_style == DL_STYLE2) &&
761 (dl_attach(lh, softmac->smac_uppa, NULL) != 0)) {
762 (void) ldi_close(lh, FREAD|FWRITE, kcred);
763 continue;
764 }
765
766 if ((rval = dl_bind(lh, 0, NULL)) != 0) {
767 if (rval == ENOTSUP) {
768 cmn_err(CE_NOTE, "softmac: received "
769 "DL_ERROR_ACK to DL_BIND_ACK; "
770 "DLPI errno 0x%x, UNIX errno %d",
771 dlea.dl_errno, dlea.dl_unix_errno);
772 }
773 (void) ldi_close(lh, FREAD|FWRITE, kcred);
774 continue;
775 }
776
777 /*
778 * Call dl_info() after dl_bind() because some drivers only
779 * provide correct information (e.g. MAC address) once bound.
780 */
781 softmac->smac_addrlen = sizeof (softmac->smac_unicst_addr);
782 if ((rval = dl_info(lh, &dlia, softmac->smac_unicst_addr,
783 &softmac->smac_addrlen, &dlea)) != 0) {
784 if (rval == ENOTSUP) {
785 cmn_err(CE_NOTE, "softmac: received "
786 "DL_ERROR_ACK to DL_INFO_ACK; "
787 "DLPI errno 0x%x, UNIX errno %d",
788 dlea.dl_errno, dlea.dl_unix_errno);
789 }
790 (void) ldi_close(lh, FREAD|FWRITE, kcred);
791 continue;
792 }
793
794 softmac->smac_style = dlia.dl_provider_style;
795 softmac->smac_saplen = ABS(dlia.dl_sap_length);
796 softmac->smac_min_sdu = dlia.dl_min_sdu;
797 softmac->smac_max_sdu = dlia.dl_max_sdu;
798
799 if ((softmac->smac_saplen != sizeof (uint16_t)) ||
800 (softmac->smac_addrlen != ETHERADDRL) ||
801 (dlia.dl_brdcst_addr_length != ETHERADDRL) ||
802 (dlia.dl_brdcst_addr_offset == 0)) {
803 (void) ldi_close(lh, FREAD|FWRITE, kcred);
804 continue;
805 }
806
807 /*
808 * Check other DLPI capabilities. Note that this must be after
809 * dl_bind() because some drivers return DL_ERROR_ACK if the
810 * stream is not bound. It is also before mac_register(), so
811 * we don't need any lock protection here.
812 */
813 softmac->smac_capab_flags =
814 (MAC_CAPAB_NO_ZCOPY | MAC_CAPAB_LEGACY);
815
816 softmac->smac_no_capability_req = B_FALSE;
817 if (softmac_fill_capab(lh, softmac) != 0)
818 softmac->smac_no_capability_req = B_TRUE;
819
820 /*
821 * Check the margin of the underlying driver.
822 */
823 margin = 0;
824 iocb.ic_cmd = DLIOCMARGININFO;
825 iocb.ic_timout = INFTIM;
826 iocb.ic_len = sizeof (margin);
827 iocb.ic_dp = (char *)&margin;
828 softmac->smac_margin = 0;
829
830 if (ldi_ioctl(lh, I_STR, (intptr_t)&iocb, FKIOCTL, kcred,
831 &rval) == 0) {
832 softmac->smac_margin = margin;
833 }
834
835 /*
836 * If the legacy driver doesn't support DLIOCMARGININFO, but
837 * it can support native VLAN, correct its margin value to 4.
838 */
839 if (native_vlan) {
840 if (softmac->smac_margin == 0)
841 softmac->smac_margin = VLAN_TAGSZ;
842 } else {
843 softmac->smac_capab_flags |= MAC_CAPAB_NO_NATIVEVLAN;
844 }
845
846 /*
847 * Not all drivers support DL_NOTIFY_REQ, so ignore ENOTSUP.
848 */
849 softmac->smac_notifications = 0;
850 notes = DL_NOTE_PHYS_ADDR | DL_NOTE_LINK_UP | DL_NOTE_LINK_DOWN;
851 switch (dl_notify(lh, ¬es, NULL)) {
852 case 0:
853 softmac->smac_notifications = notes;
854 break;
855 case ENOTSUP:
856 break;
857 default:
858 (void) ldi_close(lh, FREAD|FWRITE, kcred);
859 continue;
860 }
861
862 (void) ldi_close(lh, FREAD|FWRITE, kcred);
863 err = 0;
864 break;
865 }
866 ldi_ident_release(li);
867
868 mutex_enter(&softmac->smac_mutex);
869
870 if (err != 0)
871 goto done;
872
873 if (softmac->smac_media != DL_ETHER)
874 softmac->smac_flags |= SOFTMAC_NOSUPP;
875
876 /*
877 * Finally, we're ready to register ourselves with the MAC layer
878 * interface; if this succeeds, we're all ready to start()
879 */
880 if (!(softmac->smac_flags & SOFTMAC_NOSUPP)) {
881 mac_register_t *macp;
882
883 if ((macp = mac_alloc(MAC_VERSION)) == NULL) {
884 err = ENOMEM;
885 goto done;
886 }
887
888 macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
889 macp->m_driver = softmac;
890 macp->m_dip = softmac_dip;
891
892 macp->m_margin = softmac->smac_margin;
893 macp->m_src_addr = softmac->smac_unicst_addr;
894 macp->m_min_sdu = softmac->smac_min_sdu;
895 macp->m_max_sdu = softmac->smac_max_sdu;
896 macp->m_callbacks = &softmac_m_callbacks;
897 macp->m_instance = (uint_t)-1;
898
899 err = mac_register(macp, &softmac->smac_mh);
900 mac_free(macp);
901 if (err != 0) {
902 cmn_err(CE_WARN, "mac_register failed for %s",
903 softmac->smac_devname);
904 goto done;
905 }
906 }
907 mutex_exit(&softmac->smac_mutex);
908
909 /*
910 * Try to create the datalink for this softmac.
911 */
912 if ((err = softmac_create_datalink(softmac)) != 0) {
913 if (!(softmac->smac_flags & SOFTMAC_NOSUPP))
914 (void) mac_unregister(softmac->smac_mh);
915 mutex_enter(&softmac->smac_mutex);
916 softmac->smac_mh = NULL;
917 goto done;
918 }
919 /*
920 * If succeed, create the thread which handles the DL_NOTIFY_IND from
921 * the lower stream.
922 */
923 mutex_enter(&softmac->smac_mutex);
924 if (softmac->smac_mh != NULL) {
925 softmac->smac_notify_thread = thread_create(NULL, 0,
926 softmac_notify_thread, softmac, 0, &p0,
927 TS_RUN, minclsyspri);
928 }
929
930 done:
931 ASSERT(softmac->smac_state == SOFTMAC_ATTACH_INPROG &&
932 softmac->smac_attachok_cnt == softmac->smac_cnt);
933 softmac->smac_state = SOFTMAC_ATTACH_DONE;
934 softmac->smac_attacherr = err;
935 cv_broadcast(&softmac->smac_cv);
936 mutex_exit(&softmac->smac_mutex);
937 }
938
939 int
softmac_destroy(dev_info_t * dip,dev_t dev)940 softmac_destroy(dev_info_t *dip, dev_t dev)
941 {
942 char devname[MAXNAMELEN];
943 softmac_t *softmac;
944 softmac_dev_t *softmac_dev;
945 int index;
946 int ppa, err;
947 datalink_id_t linkid;
948 mac_handle_t smac_mh;
949 uint32_t smac_flags;
950
951 if (GLDV3_DRV(ddi_driver_major(dip))) {
952 minor_t minor = getminor(dev);
953 /*
954 * For an explanation of this logic, see the
955 * equivalent code in softmac_create.
956 */
957 if ((strcmp(ddi_driver_name(dip), "clone") == 0) ||
958 (getmajor(dev) == ddi_name_to_major("clone")) ||
959 (minor == 0)) {
960 return (0);
961 }
962 if (minor >= DLS_MAX_MINOR) {
963 return (ENOTSUP);
964 }
965 ppa = DLS_MINOR2INST(minor);
966 } else {
967 ppa = ddi_get_instance(dip);
968 }
969
970 (void) snprintf(devname, MAXNAMELEN, "%s%d", ddi_driver_name(dip), ppa);
971
972 /*
973 * We are called only from the predetach entry point. The DACF
974 * framework ensures there can't be a concurrent postattach call
975 * for the same softmac. The softmac found out from the modhash
976 * below can't vanish beneath us since this is the only place where
977 * it is deleted.
978 */
979 err = mod_hash_find(softmac_hash, (mod_hash_key_t)devname,
980 (mod_hash_val_t *)&softmac);
981 ASSERT(err == 0);
982
983 mutex_enter(&softmac->smac_mutex);
984 SOFTMAC_STATE_VERIFY(softmac);
985
986 /*
987 * Fail the predetach routine if this softmac is in-use.
988 * Make sure these downcalls into softmac_create or softmac_destroy
989 * don't cv_wait on any devfs related condition. Thus softmac_destroy
990 * returns EBUSY if the asynchronous thread started in softmac_create
991 * hasn't finished
992 */
993 if ((softmac->smac_hold_cnt != 0) ||
994 (softmac->smac_state == SOFTMAC_ATTACH_INPROG)) {
995 softmac->smac_attached_left = softmac->smac_attachok_cnt;
996 mutex_exit(&softmac->smac_mutex);
997 return (EBUSY);
998 }
999
1000 /*
1001 * Even if the predetach of one minor node has already failed
1002 * (smac_attached_left is not 0), the DACF framework will continue
1003 * to call the predetach routines of the other minor nodes,
1004 * so we fail these calls here.
1005 */
1006 if (softmac->smac_attached_left != 0) {
1007 mutex_exit(&softmac->smac_mutex);
1008 return (EBUSY);
1009 }
1010
1011 smac_mh = softmac->smac_mh;
1012 smac_flags = softmac->smac_flags;
1013 softmac->smac_state = SOFTMAC_DETACH_INPROG;
1014 mutex_exit(&softmac->smac_mutex);
1015
1016 if (smac_mh != NULL) {
1017 /*
1018 * This is the first minor node that is being detached for this
1019 * softmac.
1020 */
1021 ASSERT(softmac->smac_attachok_cnt == softmac->smac_cnt);
1022 if (!(smac_flags & SOFTMAC_NOSUPP)) {
1023 if ((err = dls_devnet_destroy(smac_mh, &linkid,
1024 B_FALSE)) != 0) {
1025 goto error;
1026 }
1027 }
1028 /*
1029 * If softmac_mac_register() succeeds in registering the mac
1030 * of the legacy device, unregister it.
1031 */
1032 if (!(smac_flags & (SOFTMAC_GLDV3 | SOFTMAC_NOSUPP))) {
1033 if ((err = mac_disable_nowait(smac_mh)) != 0) {
1034 (void) dls_devnet_create(smac_mh, linkid,
1035 crgetzoneid(CRED()));
1036 goto error;
1037 }
1038 /*
1039 * Ask softmac_notify_thread to quit, and wait for
1040 * that to be done.
1041 */
1042 mutex_enter(&softmac->smac_mutex);
1043 softmac->smac_flags |= SOFTMAC_NOTIFY_QUIT;
1044 cv_broadcast(&softmac->smac_cv);
1045 while (softmac->smac_notify_thread != NULL) {
1046 cv_wait(&softmac->smac_cv,
1047 &softmac->smac_mutex);
1048 }
1049 mutex_exit(&softmac->smac_mutex);
1050 VERIFY(mac_unregister(smac_mh) == 0);
1051 }
1052 softmac->smac_mh = NULL;
1053 }
1054
1055 /*
1056 * Free softmac_dev
1057 */
1058 rw_enter(&softmac_hash_lock, RW_WRITER);
1059 mutex_enter(&softmac->smac_mutex);
1060
1061 ASSERT(softmac->smac_state == SOFTMAC_DETACH_INPROG &&
1062 softmac->smac_attachok_cnt != 0);
1063 softmac->smac_mh = NULL;
1064 index = (getmajor(dev) == ddi_name_to_major("clone"));
1065 softmac_dev = softmac->smac_softmac[index];
1066 ASSERT(softmac_dev != NULL);
1067 softmac->smac_softmac[index] = NULL;
1068 kmem_free(softmac_dev, sizeof (softmac_dev_t));
1069
1070 if (--softmac->smac_attachok_cnt == 0) {
1071 mod_hash_val_t hashval;
1072
1073 softmac->smac_state = SOFTMAC_UNINIT;
1074 if (softmac->smac_hold_cnt != 0) {
1075 /*
1076 * Someone did a softmac_hold_device while we dropped
1077 * the locks. Leave the softmac itself intact which
1078 * will be reused by the reattach
1079 */
1080 mutex_exit(&softmac->smac_mutex);
1081 rw_exit(&softmac_hash_lock);
1082 return (0);
1083 }
1084 err = mod_hash_remove(softmac_hash,
1085 (mod_hash_key_t)devname,
1086 (mod_hash_val_t *)&hashval);
1087 ASSERT(err == 0);
1088
1089 mutex_exit(&softmac->smac_mutex);
1090 rw_exit(&softmac_hash_lock);
1091 ASSERT(softmac->smac_fp_disable_clients == 0);
1092 softmac->smac_fastpath_admin_disabled = B_FALSE;
1093 kmem_cache_free(softmac_cachep, softmac);
1094 return (0);
1095 }
1096 mutex_exit(&softmac->smac_mutex);
1097 rw_exit(&softmac_hash_lock);
1098 return (0);
1099
1100 error:
1101 mutex_enter(&softmac->smac_mutex);
1102 softmac->smac_attached_left = softmac->smac_attachok_cnt;
1103 softmac->smac_state = SOFTMAC_ATTACH_DONE;
1104 cv_broadcast(&softmac->smac_cv);
1105 mutex_exit(&softmac->smac_mutex);
1106 return (err);
1107 }
1108
1109 /*
1110 * This function is called as the result of a newly started dlmgmtd daemon.
1111 *
1112 * We walk through every softmac that was created but failed to notify
1113 * dlmgmtd about it (whose SOFTMAC_NEED_RECREATE flag is set). This occurs
1114 * when softmacs are created before dlmgmtd is ready. For example, during
1115 * diskless boot, a network device is used (and therefore attached) before
1116 * the datalink-management service starts dlmgmtd.
1117 */
1118 /* ARGSUSED */
1119 static uint_t
softmac_mac_recreate(mod_hash_key_t key,mod_hash_val_t * val,void * arg)1120 softmac_mac_recreate(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
1121 {
1122 softmac_t *softmac = (softmac_t *)val;
1123 datalink_id_t linkid;
1124 int err;
1125 softmac_walk_t *smwp = arg;
1126
1127 /*
1128 * The framework itself must not hold any locks across calls to the
1129 * mac perimeter. Thus this function does not call any framework
1130 * function that needs to grab the mac perimeter.
1131 */
1132 ASSERT(RW_READ_HELD(&softmac_hash_lock));
1133
1134 smwp->smw_retry = B_FALSE;
1135 mutex_enter(&softmac->smac_mutex);
1136 SOFTMAC_STATE_VERIFY(softmac);
1137 if (softmac->smac_state == SOFTMAC_ATTACH_INPROG) {
1138 /*
1139 * Wait till softmac_create or softmac_mac_register finishes
1140 * Hold the softmac to ensure it stays around. The wait itself
1141 * is done in the caller, since we need to drop all locks
1142 * including the mod hash's internal lock before calling
1143 * cv_wait.
1144 */
1145 smwp->smw_retry = B_TRUE;
1146 smwp->smw_softmac = softmac;
1147 softmac->smac_hold_cnt++;
1148 return (MH_WALK_TERMINATE);
1149 }
1150
1151 if ((softmac->smac_state != SOFTMAC_ATTACH_DONE) ||
1152 !(softmac->smac_flags & SOFTMAC_NEED_RECREATE)) {
1153 mutex_exit(&softmac->smac_mutex);
1154 return (MH_WALK_CONTINUE);
1155 }
1156
1157 /*
1158 * Bumping up the smac_hold_cnt allows us to drop the lock. It also
1159 * makes softmac_destroy() return failure on an attempted device detach.
1160 * We don't want to hold the lock across calls to other subsystems
1161 * like kstats, which will happen in the call to dls_devnet_recreate
1162 */
1163 softmac->smac_hold_cnt++;
1164 mutex_exit(&softmac->smac_mutex);
1165
1166 if (dls_mgmt_create(softmac->smac_devname,
1167 makedevice(softmac->smac_umajor, softmac->smac_uppa + 1),
1168 DATALINK_CLASS_PHYS, softmac->smac_media, B_TRUE, &linkid) != 0) {
1169 softmac_rele_device((dls_dev_handle_t)softmac);
1170 return (MH_WALK_CONTINUE);
1171 }
1172
1173 if ((err = softmac_update_info(softmac, &linkid)) != 0) {
1174 cmn_err(CE_WARN, "softmac: softmac_update_info() for %s "
1175 "failed (%d)", softmac->smac_devname, err);
1176 softmac_rele_device((dls_dev_handle_t)softmac);
1177 return (MH_WALK_CONTINUE);
1178 }
1179
1180 /*
1181 * Create a link for this MAC. The link name will be the same
1182 * as the MAC name.
1183 */
1184 if (!(softmac->smac_flags & SOFTMAC_NOSUPP)) {
1185 err = dls_devnet_recreate(softmac->smac_mh, linkid);
1186 if (err != 0) {
1187 cmn_err(CE_WARN, "softmac: dls_devnet_recreate() for "
1188 "%s (linkid %d) failed (%d)",
1189 softmac->smac_devname, linkid, err);
1190 }
1191 }
1192
1193 mutex_enter(&softmac->smac_mutex);
1194 softmac->smac_flags &= ~SOFTMAC_NEED_RECREATE;
1195 ASSERT(softmac->smac_hold_cnt != 0);
1196 softmac->smac_hold_cnt--;
1197 mutex_exit(&softmac->smac_mutex);
1198
1199 return (MH_WALK_CONTINUE);
1200 }
1201
1202 /*
1203 * See comments above softmac_mac_recreate().
1204 */
1205 void
softmac_recreate()1206 softmac_recreate()
1207 {
1208 softmac_walk_t smw;
1209 softmac_t *softmac;
1210
1211 /*
1212 * Walk through the softmac_hash table. Request to create the
1213 * [link name, linkid] mapping if we failed to do so.
1214 */
1215 do {
1216 smw.smw_retry = B_FALSE;
1217 rw_enter(&softmac_hash_lock, RW_READER);
1218 mod_hash_walk(softmac_hash, softmac_mac_recreate, &smw);
1219 rw_exit(&softmac_hash_lock);
1220 if (smw.smw_retry) {
1221 /*
1222 * softmac_create or softmac_mac_register hasn't yet
1223 * finished and the softmac is not yet in the
1224 * SOFTMAC_ATTACH_DONE state.
1225 */
1226 softmac = smw.smw_softmac;
1227 cv_wait(&softmac->smac_cv, &softmac->smac_mutex);
1228 softmac->smac_hold_cnt--;
1229 mutex_exit(&softmac->smac_mutex);
1230 }
1231 } while (smw.smw_retry);
1232 }
1233
1234 static int
softmac_m_start(void * arg)1235 softmac_m_start(void *arg)
1236 {
1237 softmac_t *softmac = arg;
1238 softmac_lower_t *slp = softmac->smac_lower;
1239 int err;
1240
1241 ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
1242 /*
1243 * Bind to SAP 2 on token ring, 0 on other interface types.
1244 * (SAP 0 has special significance on token ring).
1245 * Note that the receive-side packets could come anytime after bind.
1246 */
1247 err = softmac_send_bind_req(slp, softmac->smac_media == DL_TPR ? 2 : 0);
1248 if (err != 0)
1249 return (err);
1250
1251 /*
1252 * Put the lower stream to the DL_PROMISC_SAP mode in order to receive
1253 * all packets of interest.
1254 *
1255 * some driver (e.g. the old legacy eri driver) incorrectly passes up
1256 * packets to DL_PROMISC_SAP stream when the lower stream is not bound,
1257 * so that we send DL_PROMISON_REQ after DL_BIND_REQ.
1258 */
1259 err = softmac_send_promisc_req(slp, DL_PROMISC_SAP, B_TRUE);
1260 if (err != 0) {
1261 (void) softmac_send_unbind_req(slp);
1262 return (err);
1263 }
1264
1265 /*
1266 * Enable capabilities the underlying driver claims to support.
1267 * Some driver requires this being called after the stream is bound.
1268 */
1269 if ((err = softmac_capab_enable(slp)) != 0) {
1270 (void) softmac_send_promisc_req(slp, DL_PROMISC_SAP, B_FALSE);
1271 (void) softmac_send_unbind_req(slp);
1272 }
1273
1274 return (err);
1275 }
1276
1277 /* ARGSUSED */
1278 static void
softmac_m_stop(void * arg)1279 softmac_m_stop(void *arg)
1280 {
1281 softmac_t *softmac = arg;
1282 softmac_lower_t *slp = softmac->smac_lower;
1283
1284 ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
1285
1286 /*
1287 * It is not needed to reset zerocopy, MDT or HCKSUM capabilities.
1288 */
1289 (void) softmac_send_promisc_req(slp, DL_PROMISC_SAP, B_FALSE);
1290 (void) softmac_send_unbind_req(slp);
1291 }
1292
1293 /*
1294 * Set up the lower stream above the legacy device. There are two different
1295 * type of lower streams:
1296 *
1297 * - Shared lower-stream
1298 *
1299 * Shared by all GLDv3 MAC clients. Put the lower stream to the DLIOCRAW
1300 * mode to send and receive the raw data. Further, put the lower stream into
1301 * DL_PROMISC_SAP mode to receive all packets of interest.
1302 *
1303 * - Dedicated lower-stream
1304 *
1305 * The lower-stream which is dedicated to upper IP/ARP stream. This is used
1306 * as fast-path for IP. In this case, the second argument is the pointer to
1307 * the softmac upper-stream.
1308 */
1309 int
softmac_lower_setup(softmac_t * softmac,softmac_upper_t * sup,softmac_lower_t ** slpp)1310 softmac_lower_setup(softmac_t *softmac, softmac_upper_t *sup,
1311 softmac_lower_t **slpp)
1312 {
1313 ldi_ident_t li;
1314 dev_t dev;
1315 ldi_handle_t lh = NULL;
1316 softmac_lower_t *slp = NULL;
1317 smac_ioc_start_t start_arg;
1318 struct strioctl strioc;
1319 uint32_t notifications;
1320 int err, rval;
1321
1322 if ((err = ldi_ident_from_dip(softmac_dip, &li)) != 0)
1323 return (err);
1324
1325 /*
1326 * The GLDv3 framework makes sure that mac_unregister(), mac_open(),
1327 * and mac_close() cannot be called at the same time. So we don't
1328 * need any protection to access softmac here.
1329 */
1330 dev = softmac->smac_dev;
1331
1332 err = ldi_open_by_dev(&dev, OTYP_CHR, FREAD|FWRITE, kcred, &lh, li);
1333 ldi_ident_release(li);
1334 if (err != 0)
1335 goto done;
1336
1337 /*
1338 * Pop all the intermediate modules. The autopushed modules will
1339 * be pushed when the softmac node is opened.
1340 */
1341 while (ldi_ioctl(lh, I_POP, 0, FKIOCTL, kcred, &rval) == 0)
1342 ;
1343
1344 if ((softmac->smac_style == DL_STYLE2) &&
1345 ((err = dl_attach(lh, softmac->smac_uppa, NULL)) != 0)) {
1346 goto done;
1347 }
1348
1349 /*
1350 * If this is the shared-lower-stream, put the lower stream to
1351 * the DLIOCRAW mode to send/receive raw data.
1352 */
1353 if ((sup == NULL) && (err = ldi_ioctl(lh, DLIOCRAW, 0, FKIOCTL,
1354 kcred, &rval)) != 0) {
1355 goto done;
1356 }
1357
1358 /*
1359 * Then push the softmac shim layer atop the lower stream.
1360 */
1361 if ((err = ldi_ioctl(lh, I_PUSH, (intptr_t)SOFTMAC_DEV_NAME, FKIOCTL,
1362 kcred, &rval)) != 0) {
1363 goto done;
1364 }
1365
1366 /*
1367 * Send the ioctl to get the slp pointer.
1368 */
1369 strioc.ic_cmd = SMAC_IOC_START;
1370 strioc.ic_timout = INFTIM;
1371 strioc.ic_len = sizeof (start_arg);
1372 strioc.ic_dp = (char *)&start_arg;
1373
1374 if ((err = ldi_ioctl(lh, I_STR, (intptr_t)&strioc, FKIOCTL,
1375 kcred, &rval)) != 0) {
1376 goto done;
1377 }
1378 slp = start_arg.si_slp;
1379 slp->sl_sup = sup;
1380 slp->sl_lh = lh;
1381 slp->sl_softmac = softmac;
1382 *slpp = slp;
1383
1384 if (sup != NULL) {
1385 slp->sl_rxinfo = &sup->su_rxinfo;
1386 } else {
1387 /*
1388 * Send DL_NOTIFY_REQ to enable certain DL_NOTIFY_IND.
1389 * We don't have to wait for the ack.
1390 */
1391 notifications = DL_NOTE_PHYS_ADDR | DL_NOTE_LINK_UP |
1392 DL_NOTE_LINK_DOWN | DL_NOTE_PROMISC_ON_PHYS |
1393 DL_NOTE_PROMISC_OFF_PHYS;
1394
1395 (void) softmac_send_notify_req(slp,
1396 (notifications & softmac->smac_notifications));
1397 }
1398
1399 done:
1400 if (err != 0)
1401 (void) ldi_close(lh, FREAD|FWRITE, kcred);
1402 return (err);
1403 }
1404
1405 static int
softmac_m_open(void * arg)1406 softmac_m_open(void *arg)
1407 {
1408 softmac_t *softmac = arg;
1409 softmac_lower_t *slp;
1410 int err;
1411
1412 ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
1413
1414 if ((err = softmac_lower_setup(softmac, NULL, &slp)) != 0)
1415 return (err);
1416
1417 softmac->smac_lower = slp;
1418 return (0);
1419 }
1420
1421 static void
softmac_m_close(void * arg)1422 softmac_m_close(void *arg)
1423 {
1424 softmac_t *softmac = arg;
1425 softmac_lower_t *slp;
1426
1427 ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
1428 slp = softmac->smac_lower;
1429 ASSERT(slp != NULL);
1430
1431 /*
1432 * Note that slp is destroyed when lh is closed.
1433 */
1434 (void) ldi_close(slp->sl_lh, FREAD|FWRITE, kcred);
1435 softmac->smac_lower = NULL;
1436 }
1437
1438 /*
1439 * Softmac supports two priviate link properteis:
1440 *
1441 * - "_fastpath"
1442 *
1443 * This is a read-only link property which points out the current data-path
1444 * model of the given legacy link. The possible values are "disabled" and
1445 * "enabled".
1446 *
1447 * - "_disable_fastpath"
1448 *
1449 * This is a read-write link property which can be used to disable or enable
1450 * the fast-path of the given legacy link. The possible values are "true"
1451 * and "false". Note that even when "_disable_fastpath" is set to be
1452 * "false", the fast-path may still not be enabled since there may be
1453 * other mac cleints that request the fast-path to be disabled.
1454 */
1455 /* ARGSUSED */
1456 static int
softmac_m_setprop(void * arg,const char * name,mac_prop_id_t id,uint_t valsize,const void * val)1457 softmac_m_setprop(void *arg, const char *name, mac_prop_id_t id,
1458 uint_t valsize, const void *val)
1459 {
1460 softmac_t *softmac = arg;
1461
1462 if (id != MAC_PROP_PRIVATE || strcmp(name, "_disable_fastpath") != 0)
1463 return (ENOTSUP);
1464
1465 if (strcmp(val, "true") == 0)
1466 return (softmac_datapath_switch(softmac, B_TRUE, B_TRUE));
1467 else if (strcmp(val, "false") == 0)
1468 return (softmac_datapath_switch(softmac, B_FALSE, B_TRUE));
1469 else
1470 return (EINVAL);
1471 }
1472
1473 static int
softmac_m_getprop(void * arg,const char * name,mac_prop_id_t id,uint_t valsize,void * val)1474 softmac_m_getprop(void *arg, const char *name, mac_prop_id_t id,
1475 uint_t valsize, void *val)
1476 {
1477 softmac_t *softmac = arg;
1478 char *fpstr;
1479
1480 if (id != MAC_PROP_PRIVATE)
1481 return (ENOTSUP);
1482
1483 if (strcmp(name, "_fastpath") == 0) {
1484 mutex_enter(&softmac->smac_fp_mutex);
1485 fpstr = (DATAPATH_MODE(softmac) == SOFTMAC_SLOWPATH) ?
1486 "disabled" : "enabled";
1487 mutex_exit(&softmac->smac_fp_mutex);
1488 } else if (strcmp(name, "_disable_fastpath") == 0) {
1489 fpstr = softmac->smac_fastpath_admin_disabled ?
1490 "true" : "false";
1491 } else if (strcmp(name, "_softmac") == 0) {
1492 fpstr = "true";
1493 } else {
1494 return (ENOTSUP);
1495 }
1496
1497 return (strlcpy(val, fpstr, valsize) >= valsize ? EINVAL : 0);
1498 }
1499
1500 static void
softmac_m_propinfo(void * arg,const char * name,mac_prop_id_t id,mac_prop_info_handle_t prh)1501 softmac_m_propinfo(void *arg, const char *name, mac_prop_id_t id,
1502 mac_prop_info_handle_t prh)
1503 {
1504 _NOTE(ARGUNUSED(arg));
1505
1506 if (id != MAC_PROP_PRIVATE)
1507 return;
1508
1509 if (strcmp(name, "_fastpath") == 0) {
1510 mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
1511 } else if (strcmp(name, "_disable_fastpath") == 0) {
1512 mac_prop_info_set_default_str(prh, "false");
1513 }
1514
1515 }
1516
1517 int
softmac_hold_device(dev_t dev,dls_dev_handle_t * ddhp)1518 softmac_hold_device(dev_t dev, dls_dev_handle_t *ddhp)
1519 {
1520 dev_info_t *dip;
1521 char devname[MAXNAMELEN];
1522 softmac_t *softmac;
1523 major_t major;
1524 int ppa, err = 0, inst;
1525
1526 major = getmajor(dev);
1527 ppa = getminor(dev) - 1;
1528
1529 /*
1530 * For GLDv3 devices, look up the device instance using getinfo(9e).
1531 * Otherwise, fall back to the old assumption that inst == ppa. The
1532 * GLDV3_DRV() macro depends on the driver module being loaded, hence
1533 * the call to ddi_hold_driver().
1534 */
1535 if (ddi_hold_driver(major) == NULL)
1536 return (ENXIO);
1537 if (GLDV3_DRV(major)) {
1538 if ((inst = dev_to_instance(dev)) < 0)
1539 err = ENOENT;
1540 } else {
1541 inst = ppa;
1542 }
1543 ddi_rele_driver(major);
1544 if (err != 0)
1545 return (err);
1546
1547 /*
1548 * First try to hold this device instance to force device to attach
1549 * and ensure that the softmac entry gets created in net_postattach().
1550 */
1551 if ((dip = ddi_hold_devi_by_instance(major, inst, 0)) == NULL)
1552 return (ENOENT);
1553
1554 /*
1555 * Exclude non-physical network device instances, for example, aggr0.
1556 * Note: this check *must* occur after the dip is held, or else
1557 * NETWORK_PHYSDRV might return false incorrectly. The
1558 * DN_NETWORK_PHYSDRIVER flag used by NETWORK_PHYSDRV() gets set if
1559 * ddi_create_minor_node() is called during the device's attach
1560 * phase.
1561 */
1562 if (!NETWORK_PHYSDRV(major)) {
1563 ddi_release_devi(dip);
1564 return (ENOENT);
1565 }
1566
1567 /* Now wait for its softmac to be created. */
1568 (void) snprintf(devname, MAXNAMELEN, "%s%d", ddi_major_to_name(major),
1569 ppa);
1570 again:
1571 rw_enter(&softmac_hash_lock, RW_READER);
1572
1573 if (mod_hash_find(softmac_hash, (mod_hash_key_t)devname,
1574 (mod_hash_val_t *)&softmac) != 0) {
1575 /*
1576 * This is rare but possible. It could happen when pre-detach
1577 * routine of the device succeeds. But the softmac will then
1578 * be recreated when device fails to detach (as this device
1579 * is held).
1580 */
1581 mutex_enter(&smac_global_lock);
1582 rw_exit(&softmac_hash_lock);
1583 cv_wait(&smac_global_cv, &smac_global_lock);
1584 mutex_exit(&smac_global_lock);
1585 goto again;
1586 }
1587
1588 /*
1589 * Bump smac_hold_cnt to prevent device detach.
1590 */
1591 mutex_enter(&softmac->smac_mutex);
1592 softmac->smac_hold_cnt++;
1593 rw_exit(&softmac_hash_lock);
1594
1595 /*
1596 * Wait till the device is fully attached.
1597 */
1598 while (softmac->smac_state != SOFTMAC_ATTACH_DONE)
1599 cv_wait(&softmac->smac_cv, &softmac->smac_mutex);
1600
1601 SOFTMAC_STATE_VERIFY(softmac);
1602
1603 if ((err = softmac->smac_attacherr) != 0)
1604 softmac->smac_hold_cnt--;
1605 else
1606 *ddhp = (dls_dev_handle_t)softmac;
1607 mutex_exit(&softmac->smac_mutex);
1608
1609 ddi_release_devi(dip);
1610 return (err);
1611 }
1612
1613 void
softmac_rele_device(dls_dev_handle_t ddh)1614 softmac_rele_device(dls_dev_handle_t ddh)
1615 {
1616 if (ddh != NULL)
1617 softmac_rele((softmac_t *)ddh);
1618 }
1619
1620 int
softmac_hold(dev_t dev,softmac_t ** softmacp)1621 softmac_hold(dev_t dev, softmac_t **softmacp)
1622 {
1623 softmac_t *softmac;
1624 char *drv;
1625 mac_handle_t mh;
1626 char mac[MAXNAMELEN];
1627 int err;
1628
1629 if ((drv = ddi_major_to_name(getmajor(dev))) == NULL)
1630 return (EINVAL);
1631
1632 (void) snprintf(mac, MAXNAMELEN, "%s%d", drv, getminor(dev) - 1);
1633 if ((err = mac_open(mac, &mh)) != 0)
1634 return (err);
1635
1636 softmac = (softmac_t *)mac_driver(mh);
1637
1638 mutex_enter(&softmac->smac_mutex);
1639 softmac->smac_hold_cnt++;
1640 mutex_exit(&softmac->smac_mutex);
1641 mac_close(mh);
1642 *softmacp = softmac;
1643 return (0);
1644 }
1645
1646 void
softmac_rele(softmac_t * softmac)1647 softmac_rele(softmac_t *softmac)
1648 {
1649 mutex_enter(&softmac->smac_mutex);
1650 softmac->smac_hold_cnt--;
1651 mutex_exit(&softmac->smac_mutex);
1652 }
1653