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 2018 Joyent, Inc.
24 * Copyright 2016 OmniTI Computer Consulting, Inc. All rights reserved.
25 */
26
27 #include <sys/types.h>
28 #include <sys/cred.h>
29 #include <sys/sysmacros.h>
30 #include <sys/conf.h>
31 #include <sys/cmn_err.h>
32 #include <sys/list.h>
33 #include <sys/ksynch.h>
34 #include <sys/kmem.h>
35 #include <sys/stream.h>
36 #include <sys/modctl.h>
37 #include <sys/ddi.h>
38 #include <sys/sunddi.h>
39 #include <sys/atomic.h>
40 #include <sys/stat.h>
41 #include <sys/modhash.h>
42 #include <sys/strsubr.h>
43 #include <sys/strsun.h>
44 #include <sys/dlpi.h>
45 #include <sys/mac.h>
46 #include <sys/mac_provider.h>
47 #include <sys/mac_client.h>
48 #include <sys/mac_client_priv.h>
49 #include <sys/mac_ether.h>
50 #include <sys/dls.h>
51 #include <sys/pattr.h>
52 #include <sys/time.h>
53 #include <sys/vlan.h>
54 #include <sys/vnic.h>
55 #include <sys/vnic_impl.h>
56 #include <sys/mac_impl.h>
57 #include <sys/mac_flow_impl.h>
58 #include <inet/ip_impl.h>
59
60 /*
61 * Note that for best performance, the VNIC is a passthrough design.
62 * For each VNIC corresponds a MAC client of the underlying MAC (lower MAC).
63 * This MAC client is opened by the VNIC driver at VNIC creation,
64 * and closed when the VNIC is deleted.
65 * When a MAC client of the VNIC itself opens a VNIC, the MAC layer
66 * (upper MAC) detects that the MAC being opened is a VNIC. Instead
67 * of allocating a new MAC client, it asks the VNIC driver to return
68 * the lower MAC client handle associated with the VNIC, and that handle
69 * is returned to the upper MAC client directly. This allows access
70 * by upper MAC clients of the VNIC to have direct access to the lower
71 * MAC client for the control path and data path.
72 *
73 * Due to this passthrough, some of the entry points exported by the
74 * VNIC driver are never directly invoked. These entry points include
75 * vnic_m_start, vnic_m_stop, vnic_m_promisc, vnic_m_multicst, etc.
76 *
77 * VNICs support multiple upper mac clients to enable support for
78 * multiple MAC addresses on the VNIC. When the VNIC is created the
79 * initial mac client is the primary upper mac. Any additional mac
80 * clients are secondary macs.
81 */
82
83 static int vnic_m_start(void *);
84 static void vnic_m_stop(void *);
85 static int vnic_m_promisc(void *, boolean_t);
86 static int vnic_m_multicst(void *, boolean_t, const uint8_t *);
87 static int vnic_m_unicst(void *, const uint8_t *);
88 static int vnic_m_stat(void *, uint_t, uint64_t *);
89 static void vnic_m_ioctl(void *, queue_t *, mblk_t *);
90 static int vnic_m_setprop(void *, const char *, mac_prop_id_t, uint_t,
91 const void *);
92 static int vnic_m_getprop(void *, const char *, mac_prop_id_t, uint_t, void *);
93 static void vnic_m_propinfo(void *, const char *, mac_prop_id_t,
94 mac_prop_info_handle_t);
95 static mblk_t *vnic_m_tx(void *, mblk_t *);
96 static boolean_t vnic_m_capab_get(void *, mac_capab_t, void *);
97 static void vnic_notify_cb(void *, mac_notify_type_t);
98 static void vnic_cleanup_secondary_macs(vnic_t *, int);
99
100 static kmem_cache_t *vnic_cache;
101 static krwlock_t vnic_lock;
102 static uint_t vnic_count;
103
104 #define ANCHOR_VNIC_MIN_MTU 576
105 #define ANCHOR_VNIC_MAX_MTU 9000
106
107 /* hash of VNICs (vnic_t's), keyed by VNIC id */
108 static mod_hash_t *vnic_hash;
109 #define VNIC_HASHSZ 64
110 #define VNIC_HASH_KEY(vnic_id) ((mod_hash_key_t)(uintptr_t)vnic_id)
111
112 #define VNIC_M_CALLBACK_FLAGS \
113 (MC_IOCTL | MC_GETCAPAB | MC_SETPROP | MC_GETPROP | MC_PROPINFO)
114
115 static mac_callbacks_t vnic_m_callbacks = {
116 VNIC_M_CALLBACK_FLAGS,
117 vnic_m_stat,
118 vnic_m_start,
119 vnic_m_stop,
120 vnic_m_promisc,
121 vnic_m_multicst,
122 vnic_m_unicst,
123 vnic_m_tx,
124 NULL,
125 vnic_m_ioctl,
126 vnic_m_capab_get,
127 NULL,
128 NULL,
129 vnic_m_setprop,
130 vnic_m_getprop,
131 vnic_m_propinfo
132 };
133
134 void
135 vnic_dev_init(void)
136 {
137 vnic_cache = kmem_cache_create("vnic_cache",
138 sizeof (vnic_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
139
140 vnic_hash = mod_hash_create_idhash("vnic_hash",
141 VNIC_HASHSZ, mod_hash_null_valdtor);
142
143 rw_init(&vnic_lock, NULL, RW_DEFAULT, NULL);
144
145 vnic_count = 0;
146 }
147
148 void
149 vnic_dev_fini(void)
150 {
151 ASSERT(vnic_count == 0);
152
153 rw_destroy(&vnic_lock);
154 mod_hash_destroy_idhash(vnic_hash);
155 kmem_cache_destroy(vnic_cache);
156 }
157
158 uint_t
159 vnic_dev_count(void)
160 {
161 return (vnic_count);
162 }
163
164 static vnic_ioc_diag_t
165 vnic_mac2vnic_diag(mac_diag_t diag)
166 {
167 switch (diag) {
168 case MAC_DIAG_MACADDR_NIC:
169 return (VNIC_IOC_DIAG_MACADDR_NIC);
170 case MAC_DIAG_MACADDR_INUSE:
171 return (VNIC_IOC_DIAG_MACADDR_INUSE);
172 case MAC_DIAG_MACADDR_INVALID:
173 return (VNIC_IOC_DIAG_MACADDR_INVALID);
174 case MAC_DIAG_MACADDRLEN_INVALID:
175 return (VNIC_IOC_DIAG_MACADDRLEN_INVALID);
176 case MAC_DIAG_MACFACTORYSLOTINVALID:
177 return (VNIC_IOC_DIAG_MACFACTORYSLOTINVALID);
178 case MAC_DIAG_MACFACTORYSLOTUSED:
179 return (VNIC_IOC_DIAG_MACFACTORYSLOTUSED);
180 case MAC_DIAG_MACFACTORYSLOTALLUSED:
181 return (VNIC_IOC_DIAG_MACFACTORYSLOTALLUSED);
182 case MAC_DIAG_MACFACTORYNOTSUP:
183 return (VNIC_IOC_DIAG_MACFACTORYNOTSUP);
184 case MAC_DIAG_MACPREFIX_INVALID:
185 return (VNIC_IOC_DIAG_MACPREFIX_INVALID);
186 case MAC_DIAG_MACPREFIXLEN_INVALID:
187 return (VNIC_IOC_DIAG_MACPREFIXLEN_INVALID);
188 case MAC_DIAG_MACNO_HWRINGS:
189 return (VNIC_IOC_DIAG_NO_HWRINGS);
190 default:
191 return (VNIC_IOC_DIAG_NONE);
192 }
193 }
194
195 static int
196 vnic_unicast_add(vnic_t *vnic, vnic_mac_addr_type_t vnic_addr_type,
197 int *addr_slot, uint_t prefix_len, int *addr_len_ptr_arg,
198 uint8_t *mac_addr_arg, uint16_t flags, vnic_ioc_diag_t *diag,
199 uint16_t vid, boolean_t req_hwgrp_flag)
200 {
201 mac_diag_t mac_diag;
202 uint16_t mac_flags = 0;
203 int err;
204 uint_t addr_len;
205
206 if (flags & VNIC_IOC_CREATE_NODUPCHECK)
207 mac_flags |= MAC_UNICAST_NODUPCHECK;
208
209 switch (vnic_addr_type) {
210 case VNIC_MAC_ADDR_TYPE_FIXED:
211 case VNIC_MAC_ADDR_TYPE_VRID:
212 /*
213 * The MAC address value to assign to the VNIC
214 * is already provided in mac_addr_arg. addr_len_ptr_arg
215 * already contains the MAC address length.
216 */
217 break;
218
219 case VNIC_MAC_ADDR_TYPE_RANDOM:
220 /*
221 * Random MAC address. There are two sub-cases:
222 *
223 * 1 - If mac_len == 0, a new MAC address is generated.
224 * The length of the MAC address to generated depends
225 * on the type of MAC used. The prefix to use for the MAC
226 * address is stored in the most significant bytes
227 * of the mac_addr argument, and its length is specified
228 * by the mac_prefix_len argument. This prefix can
229 * correspond to a IEEE OUI in the case of Ethernet,
230 * for example.
231 *
232 * 2 - If mac_len > 0, the address was already picked
233 * randomly, and is now passed back during VNIC
234 * re-creation. The mac_addr argument contains the MAC
235 * address that was generated. We distinguish this
236 * case from the fixed MAC address case, since we
237 * want the user consumers to know, when they query
238 * the list of VNICs, that a VNIC was assigned a
239 * random MAC address vs assigned a fixed address
240 * specified by the user.
241 */
242
243 /*
244 * If it's a pre-generated address, we're done. mac_addr_arg
245 * and addr_len_ptr_arg already contain the MAC address
246 * value and length.
247 */
248 if (*addr_len_ptr_arg > 0)
249 break;
250
251 /* generate a new random MAC address */
252 if ((err = mac_addr_random(vnic->vn_mch,
253 prefix_len, mac_addr_arg, &mac_diag)) != 0) {
254 *diag = vnic_mac2vnic_diag(mac_diag);
255 return (err);
256 }
257 *addr_len_ptr_arg = mac_addr_len(vnic->vn_lower_mh);
258 break;
259
260 case VNIC_MAC_ADDR_TYPE_FACTORY:
261 err = mac_addr_factory_reserve(vnic->vn_mch, addr_slot);
262 if (err != 0) {
263 if (err == EINVAL)
264 *diag = VNIC_IOC_DIAG_MACFACTORYSLOTINVALID;
265 if (err == EBUSY)
266 *diag = VNIC_IOC_DIAG_MACFACTORYSLOTUSED;
267 if (err == ENOSPC)
268 *diag = VNIC_IOC_DIAG_MACFACTORYSLOTALLUSED;
269 return (err);
270 }
271
272 mac_addr_factory_value(vnic->vn_lower_mh, *addr_slot,
273 mac_addr_arg, &addr_len, NULL, NULL);
274 *addr_len_ptr_arg = addr_len;
275 break;
276
277 case VNIC_MAC_ADDR_TYPE_AUTO:
278 /* first try to allocate a factory MAC address */
279 err = mac_addr_factory_reserve(vnic->vn_mch, addr_slot);
280 if (err == 0) {
281 mac_addr_factory_value(vnic->vn_lower_mh, *addr_slot,
282 mac_addr_arg, &addr_len, NULL, NULL);
283 vnic_addr_type = VNIC_MAC_ADDR_TYPE_FACTORY;
284 *addr_len_ptr_arg = addr_len;
285 break;
286 }
287
288 /*
289 * Allocating a factory MAC address failed, generate a
290 * random MAC address instead.
291 */
292 if ((err = mac_addr_random(vnic->vn_mch,
293 prefix_len, mac_addr_arg, &mac_diag)) != 0) {
294 *diag = vnic_mac2vnic_diag(mac_diag);
295 return (err);
296 }
297 *addr_len_ptr_arg = mac_addr_len(vnic->vn_lower_mh);
298 vnic_addr_type = VNIC_MAC_ADDR_TYPE_RANDOM;
299 break;
300 case VNIC_MAC_ADDR_TYPE_PRIMARY:
301 /*
302 * We get the address here since we copy it in the
303 * vnic's vn_addr.
304 * We can't ask for hardware resources since we
305 * don't currently support hardware classification
306 * for these MAC clients.
307 */
308 if (req_hwgrp_flag) {
309 *diag = VNIC_IOC_DIAG_NO_HWRINGS;
310 return (ENOTSUP);
311 }
312 mac_unicast_primary_get(vnic->vn_lower_mh, mac_addr_arg);
313 *addr_len_ptr_arg = mac_addr_len(vnic->vn_lower_mh);
314 mac_flags |= MAC_UNICAST_VNIC_PRIMARY;
315 break;
316 }
317
318 vnic->vn_addr_type = vnic_addr_type;
319
320 err = mac_unicast_add(vnic->vn_mch, mac_addr_arg, mac_flags,
321 &vnic->vn_muh, vid, &mac_diag);
322 if (err != 0) {
323 if (vnic_addr_type == VNIC_MAC_ADDR_TYPE_FACTORY) {
324 /* release factory MAC address */
325 mac_addr_factory_release(vnic->vn_mch, *addr_slot);
326 }
327 *diag = vnic_mac2vnic_diag(mac_diag);
328 }
329
330 return (err);
331 }
332
333 /*
334 * Create a new VNIC upon request from administrator.
335 * Returns 0 on success, an errno on failure.
336 */
337 /* ARGSUSED */
338 int
339 vnic_dev_create(datalink_id_t vnic_id, datalink_id_t linkid,
340 vnic_mac_addr_type_t *vnic_addr_type, int *mac_len, uchar_t *mac_addr,
341 int *mac_slot, uint_t mac_prefix_len, uint16_t vid, vrid_t vrid,
342 int af, mac_resource_props_t *mrp, uint32_t flags, vnic_ioc_diag_t *diag,
343 cred_t *credp)
344 {
345 vnic_t *vnic;
346 mac_register_t *mac;
347 int err;
348 boolean_t is_anchor = ((flags & VNIC_IOC_CREATE_ANCHOR) != 0);
349 char vnic_name[MAXNAMELEN];
350 const mac_info_t *minfop;
351 uint32_t req_hwgrp_flag = B_FALSE;
352
353 *diag = VNIC_IOC_DIAG_NONE;
354
355 rw_enter(&vnic_lock, RW_WRITER);
356
357 /* Does a VNIC with the same id already exist? */
358 err = mod_hash_find(vnic_hash, VNIC_HASH_KEY(vnic_id),
359 (mod_hash_val_t *)&vnic);
360 if (err == 0) {
361 rw_exit(&vnic_lock);
362 return (EEXIST);
363 }
364
365 vnic = kmem_cache_alloc(vnic_cache, KM_NOSLEEP);
366 if (vnic == NULL) {
367 rw_exit(&vnic_lock);
368 return (ENOMEM);
369 }
370
371 bzero(vnic, sizeof (*vnic));
372
373 vnic->vn_ls = LINK_STATE_UNKNOWN;
374 vnic->vn_id = vnic_id;
375 vnic->vn_link_id = linkid;
376 vnic->vn_vrid = vrid;
377 vnic->vn_af = af;
378
379 if (!is_anchor) {
380 if (linkid == DATALINK_INVALID_LINKID) {
381 err = EINVAL;
382 goto bail;
383 }
384
385 /*
386 * Open the lower MAC and assign its initial bandwidth and
387 * MAC address. We do this here during VNIC creation and
388 * do not wait until the upper MAC client open so that we
389 * can validate the VNIC creation parameters (bandwidth,
390 * MAC address, etc) and reserve a factory MAC address if
391 * one was requested.
392 */
393 err = mac_open_by_linkid(linkid, &vnic->vn_lower_mh);
394 if (err != 0)
395 goto bail;
396
397 /*
398 * VNIC(vlan) over VNICs(vlans) is not supported.
399 */
400 if (mac_is_vnic(vnic->vn_lower_mh)) {
401 err = EINVAL;
402 goto bail;
403 }
404
405 /* only ethernet support for now */
406 minfop = mac_info(vnic->vn_lower_mh);
407 if (minfop->mi_nativemedia != DL_ETHER) {
408 err = ENOTSUP;
409 goto bail;
410 }
411
412 (void) dls_mgmt_get_linkinfo(vnic_id, vnic_name, NULL, NULL,
413 NULL);
414 err = mac_client_open(vnic->vn_lower_mh, &vnic->vn_mch,
415 vnic_name, MAC_OPEN_FLAGS_IS_VNIC);
416 if (err != 0)
417 goto bail;
418
419 /* assign a MAC address to the VNIC */
420
421 err = vnic_unicast_add(vnic, *vnic_addr_type, mac_slot,
422 mac_prefix_len, mac_len, mac_addr, flags, diag, vid,
423 req_hwgrp_flag);
424 if (err != 0) {
425 vnic->vn_muh = NULL;
426 if (diag != NULL && req_hwgrp_flag)
427 *diag = VNIC_IOC_DIAG_NO_HWRINGS;
428 goto bail;
429 }
430
431 /* register to receive notification from underlying MAC */
432 vnic->vn_mnh = mac_notify_add(vnic->vn_lower_mh, vnic_notify_cb,
433 vnic);
434
435 *vnic_addr_type = vnic->vn_addr_type;
436 vnic->vn_addr_len = *mac_len;
437 vnic->vn_vid = vid;
438
439 bcopy(mac_addr, vnic->vn_addr, vnic->vn_addr_len);
440
441 if (vnic->vn_addr_type == VNIC_MAC_ADDR_TYPE_FACTORY)
442 vnic->vn_slot_id = *mac_slot;
443
444 /*
445 * Set the initial VNIC capabilities. If the VNIC is created
446 * over MACs which does not support nactive vlan, disable
447 * VNIC's hardware checksum capability if its VID is not 0,
448 * since the underlying MAC would get the hardware checksum
449 * offset wrong in case of VLAN packets.
450 */
451 if (vid == 0 || !mac_capab_get(vnic->vn_lower_mh,
452 MAC_CAPAB_NO_NATIVEVLAN, NULL)) {
453 if (!mac_capab_get(vnic->vn_lower_mh, MAC_CAPAB_HCKSUM,
454 &vnic->vn_hcksum_txflags))
455 vnic->vn_hcksum_txflags = 0;
456 } else {
457 vnic->vn_hcksum_txflags = 0;
458 }
459 }
460
461 /* register with the MAC module */
462 if ((mac = mac_alloc(MAC_VERSION)) == NULL)
463 goto bail;
464
465 mac->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
466 mac->m_driver = vnic;
467 mac->m_dip = vnic_get_dip();
468 mac->m_instance = (uint_t)-1;
469 mac->m_src_addr = vnic->vn_addr;
470 mac->m_callbacks = &vnic_m_callbacks;
471
472 if (!is_anchor) {
473 /*
474 * If this is a VNIC based VLAN, then we check for the
475 * margin unless it has been created with the force
476 * flag. If we are configuring a VLAN over an etherstub,
477 * we don't check the margin even if force is not set.
478 */
479 if (vid == 0 || (flags & VNIC_IOC_CREATE_FORCE) != 0) {
480 if (vid != VLAN_ID_NONE)
481 vnic->vn_force = B_TRUE;
482 /*
483 * As the current margin size of the underlying mac is
484 * used to determine the margin size of the VNIC
485 * itself, request the underlying mac not to change
486 * to a smaller margin size.
487 */
488 err = mac_margin_add(vnic->vn_lower_mh,
489 &vnic->vn_margin, B_TRUE);
490 ASSERT(err == 0);
491 } else {
492 vnic->vn_margin = VLAN_TAGSZ;
493 err = mac_margin_add(vnic->vn_lower_mh,
494 &vnic->vn_margin, B_FALSE);
495 if (err != 0) {
496 mac_free(mac);
497 if (diag != NULL)
498 *diag = VNIC_IOC_DIAG_MACMARGIN_INVALID;
499 goto bail;
500 }
501 }
502
503 mac_sdu_get(vnic->vn_lower_mh, &mac->m_min_sdu,
504 &mac->m_max_sdu);
505 err = mac_mtu_add(vnic->vn_lower_mh, &mac->m_max_sdu, B_FALSE);
506 if (err != 0) {
507 VERIFY(mac_margin_remove(vnic->vn_lower_mh,
508 vnic->vn_margin) == 0);
509 mac_free(mac);
510 if (diag != NULL)
511 *diag = VNIC_IOC_DIAG_MACMTU_INVALID;
512 goto bail;
513 }
514 vnic->vn_mtu = mac->m_max_sdu;
515 } else {
516 vnic->vn_margin = VLAN_TAGSZ;
517 mac->m_min_sdu = 1;
518 mac->m_max_sdu = ANCHOR_VNIC_MAX_MTU;
519 vnic->vn_mtu = ANCHOR_VNIC_MAX_MTU;
520 }
521
522 mac->m_margin = vnic->vn_margin;
523
524 err = mac_register(mac, &vnic->vn_mh);
525 mac_free(mac);
526 if (err != 0) {
527 if (!is_anchor) {
528 VERIFY(mac_mtu_remove(vnic->vn_lower_mh,
529 vnic->vn_mtu) == 0);
530 VERIFY(mac_margin_remove(vnic->vn_lower_mh,
531 vnic->vn_margin) == 0);
532 }
533 goto bail;
534 }
535
536 /* Set the VNIC's MAC in the client */
537 if (!is_anchor) {
538 mac_set_upper_mac(vnic->vn_mch, vnic->vn_mh, mrp);
539
540 if (mrp != NULL) {
541 if ((mrp->mrp_mask & MRP_RX_RINGS) != 0 ||
542 (mrp->mrp_mask & MRP_TX_RINGS) != 0) {
543 req_hwgrp_flag = B_TRUE;
544 }
545 err = mac_client_set_resources(vnic->vn_mch, mrp);
546 if (err != 0) {
547 VERIFY(mac_mtu_remove(vnic->vn_lower_mh,
548 vnic->vn_mtu) == 0);
549 VERIFY(mac_margin_remove(vnic->vn_lower_mh,
550 vnic->vn_margin) == 0);
551 (void) mac_unregister(vnic->vn_mh);
552 goto bail;
553 }
554 }
555 }
556
557 err = dls_devnet_create(vnic->vn_mh, vnic->vn_id, crgetzoneid(credp));
558 if (err != 0) {
559 VERIFY(is_anchor || mac_margin_remove(vnic->vn_lower_mh,
560 vnic->vn_margin) == 0);
561 if (!is_anchor) {
562 VERIFY(mac_mtu_remove(vnic->vn_lower_mh,
563 vnic->vn_mtu) == 0);
564 VERIFY(mac_margin_remove(vnic->vn_lower_mh,
565 vnic->vn_margin) == 0);
566 }
567 (void) mac_unregister(vnic->vn_mh);
568 goto bail;
569 }
570
571 /* add new VNIC to hash table */
572 err = mod_hash_insert(vnic_hash, VNIC_HASH_KEY(vnic_id),
573 (mod_hash_val_t)vnic);
574 ASSERT(err == 0);
575 vnic_count++;
576
577 /*
578 * Now that we've enabled this VNIC, we should go through and update the
579 * link state by setting it to our parents.
580 */
581 vnic->vn_enabled = B_TRUE;
582
583 if (is_anchor) {
584 vnic->vn_ls = LINK_STATE_UP;
585 } else {
586 vnic->vn_ls = mac_client_stat_get(vnic->vn_mch,
587 MAC_STAT_LINK_STATE);
588 }
589 mac_link_update(vnic->vn_mh, vnic->vn_ls);
590
591 rw_exit(&vnic_lock);
592
593 return (0);
594
595 bail:
596 rw_exit(&vnic_lock);
597 if (!is_anchor) {
598 if (vnic->vn_mnh != NULL)
599 (void) mac_notify_remove(vnic->vn_mnh, B_TRUE);
600 if (vnic->vn_muh != NULL)
601 (void) mac_unicast_remove(vnic->vn_mch, vnic->vn_muh);
602 if (vnic->vn_mch != NULL)
603 mac_client_close(vnic->vn_mch, MAC_CLOSE_FLAGS_IS_VNIC);
604 if (vnic->vn_lower_mh != NULL)
605 mac_close(vnic->vn_lower_mh);
606 }
607
608 kmem_cache_free(vnic_cache, vnic);
609 return (err);
610 }
611
612 /*
613 * Modify the properties of an existing VNIC.
614 */
615 /* ARGSUSED */
616 int
617 vnic_dev_modify(datalink_id_t vnic_id, uint_t modify_mask,
618 vnic_mac_addr_type_t mac_addr_type, uint_t mac_len, uchar_t *mac_addr,
619 uint_t mac_slot, mac_resource_props_t *mrp)
620 {
621 vnic_t *vnic = NULL;
622
623 rw_enter(&vnic_lock, RW_WRITER);
624
625 if (mod_hash_find(vnic_hash, VNIC_HASH_KEY(vnic_id),
626 (mod_hash_val_t *)&vnic) != 0) {
627 rw_exit(&vnic_lock);
628 return (ENOENT);
629 }
630
631 rw_exit(&vnic_lock);
632
633 return (0);
634 }
635
636 /* ARGSUSED */
637 int
638 vnic_dev_delete(datalink_id_t vnic_id, uint32_t flags, cred_t *credp)
639 {
640 vnic_t *vnic = NULL;
641 mod_hash_val_t val;
642 datalink_id_t tmpid;
643 int rc;
644
645 rw_enter(&vnic_lock, RW_WRITER);
646
647 if (mod_hash_find(vnic_hash, VNIC_HASH_KEY(vnic_id),
648 (mod_hash_val_t *)&vnic) != 0) {
649 rw_exit(&vnic_lock);
650 return (ENOENT);
651 }
652
653 if ((rc = dls_devnet_destroy(vnic->vn_mh, &tmpid, B_TRUE)) != 0) {
654 rw_exit(&vnic_lock);
655 return (rc);
656 }
657
658 ASSERT(vnic_id == tmpid);
659
660 /*
661 * We cannot unregister the MAC yet. Unregistering would
662 * free up mac_impl_t which should not happen at this time.
663 * So disable mac_impl_t by calling mac_disable(). This will prevent
664 * any new claims on mac_impl_t.
665 */
666 if ((rc = mac_disable(vnic->vn_mh)) != 0) {
667 (void) dls_devnet_create(vnic->vn_mh, vnic_id,
668 crgetzoneid(credp));
669 rw_exit(&vnic_lock);
670 return (rc);
671 }
672
673 vnic_cleanup_secondary_macs(vnic, vnic->vn_nhandles);
674
675 vnic->vn_enabled = B_FALSE;
676 (void) mod_hash_remove(vnic_hash, VNIC_HASH_KEY(vnic_id), &val);
677 ASSERT(vnic == (vnic_t *)val);
678 vnic_count--;
679 rw_exit(&vnic_lock);
680
681 /*
682 * XXX-nicolas shouldn't have a void cast here, if it's
683 * expected that the function will never fail, then we should
684 * have an ASSERT().
685 */
686 (void) mac_unregister(vnic->vn_mh);
687
688 if (vnic->vn_lower_mh != NULL) {
689 /*
690 * Check if MAC address for the vnic was obtained from the
691 * factory MAC addresses. If yes, release it.
692 */
693 if (vnic->vn_addr_type == VNIC_MAC_ADDR_TYPE_FACTORY) {
694 (void) mac_addr_factory_release(vnic->vn_mch,
695 vnic->vn_slot_id);
696 }
697 (void) mac_margin_remove(vnic->vn_lower_mh, vnic->vn_margin);
698 (void) mac_mtu_remove(vnic->vn_lower_mh, vnic->vn_mtu);
699 (void) mac_notify_remove(vnic->vn_mnh, B_TRUE);
700 (void) mac_unicast_remove(vnic->vn_mch, vnic->vn_muh);
701 mac_client_close(vnic->vn_mch, MAC_CLOSE_FLAGS_IS_VNIC);
702 mac_close(vnic->vn_lower_mh);
703 }
704
705 kmem_cache_free(vnic_cache, vnic);
706 return (0);
707 }
708
709 /* ARGSUSED */
710 mblk_t *
711 vnic_m_tx(void *arg, mblk_t *mp_chain)
712 {
713 /*
714 * This function could be invoked for an anchor VNIC when sending
715 * broadcast and multicast packets, and unicast packets which did
716 * not match any local known destination.
717 */
718 freemsgchain(mp_chain);
719 return (NULL);
720 }
721
722 /*ARGSUSED*/
723 static void
724 vnic_m_ioctl(void *arg, queue_t *q, mblk_t *mp)
725 {
726 miocnak(q, mp, 0, ENOTSUP);
727 }
728
729 /*
730 * This entry point cannot be passed-through, since it is invoked
731 * for the per-VNIC kstats which must be exported independently
732 * of the existence of VNIC MAC clients.
733 */
734 static int
735 vnic_m_stat(void *arg, uint_t stat, uint64_t *val)
736 {
737 vnic_t *vnic = arg;
738 int rval = 0;
739
740 if (vnic->vn_lower_mh == NULL) {
741 /*
742 * It's an anchor VNIC, which does not have any
743 * statistics in itself.
744 */
745 return (ENOTSUP);
746 }
747
748 /*
749 * ENOTSUP must be reported for unsupported stats, the VNIC
750 * driver reports a subset of the stats that would
751 * be returned by a real piece of hardware.
752 */
753
754 switch (stat) {
755 case MAC_STAT_LINK_STATE:
756 case MAC_STAT_LINK_UP:
757 case MAC_STAT_PROMISC:
758 case MAC_STAT_IFSPEED:
759 case MAC_STAT_MULTIRCV:
760 case MAC_STAT_MULTIXMT:
761 case MAC_STAT_BRDCSTRCV:
762 case MAC_STAT_BRDCSTXMT:
763 case MAC_STAT_OPACKETS:
764 case MAC_STAT_OBYTES:
765 case MAC_STAT_IERRORS:
766 case MAC_STAT_OERRORS:
767 case MAC_STAT_RBYTES:
768 case MAC_STAT_IPACKETS:
769 *val = mac_client_stat_get(vnic->vn_mch, stat);
770 break;
771 default:
772 rval = ENOTSUP;
773 }
774
775 return (rval);
776 }
777
778 /*
779 * Invoked by the upper MAC to retrieve the lower MAC client handle
780 * corresponding to a VNIC. A pointer to this function is obtained
781 * by the upper MAC via capability query.
782 *
783 * XXX-nicolas Note: this currently causes all VNIC MAC clients to
784 * receive the same MAC client handle for the same VNIC. This is ok
785 * as long as we have only one VNIC MAC client which sends and
786 * receives data, but we don't currently enforce this at the MAC layer.
787 */
788 static void *
789 vnic_mac_client_handle(void *vnic_arg)
790 {
791 vnic_t *vnic = vnic_arg;
792
793 return (vnic->vn_mch);
794 }
795
796 /*
797 * Invoked when updating the primary MAC so that the secondary MACs are
798 * kept in sync.
799 */
800 static void
801 vnic_mac_secondary_update(void *vnic_arg)
802 {
803 vnic_t *vn = vnic_arg;
804 int i;
805
806 for (i = 1; i <= vn->vn_nhandles; i++) {
807 mac_secondary_dup(vn->vn_mc_handles[0], vn->vn_mc_handles[i]);
808 }
809 }
810
811 /*
812 * Return information about the specified capability.
813 */
814 /* ARGSUSED */
815 static boolean_t
816 vnic_m_capab_get(void *arg, mac_capab_t cap, void *cap_data)
817 {
818 vnic_t *vnic = arg;
819
820 switch (cap) {
821 case MAC_CAPAB_HCKSUM: {
822 uint32_t *hcksum_txflags = cap_data;
823
824 *hcksum_txflags = vnic->vn_hcksum_txflags &
825 (HCKSUM_INET_FULL_V4 | HCKSUM_IPHDRCKSUM |
826 HCKSUM_INET_PARTIAL);
827 break;
828 }
829 case MAC_CAPAB_VNIC: {
830 mac_capab_vnic_t *vnic_capab = cap_data;
831
832 if (vnic->vn_lower_mh == NULL) {
833 /*
834 * It's an anchor VNIC, we don't have an underlying
835 * NIC and MAC client handle.
836 */
837 return (B_FALSE);
838 }
839
840 if (vnic_capab != NULL) {
841 vnic_capab->mcv_arg = vnic;
842 vnic_capab->mcv_mac_client_handle =
843 vnic_mac_client_handle;
844 vnic_capab->mcv_mac_secondary_update =
845 vnic_mac_secondary_update;
846 }
847 break;
848 }
849 case MAC_CAPAB_ANCHOR_VNIC: {
850 /* since it's an anchor VNIC we don't have lower mac handle */
851 if (vnic->vn_lower_mh == NULL) {
852 ASSERT(vnic->vn_link_id == 0);
853 return (B_TRUE);
854 }
855 return (B_FALSE);
856 }
857 case MAC_CAPAB_NO_NATIVEVLAN:
858 return (B_FALSE);
859 case MAC_CAPAB_NO_ZCOPY:
860 return (B_TRUE);
861 case MAC_CAPAB_VRRP: {
862 mac_capab_vrrp_t *vrrp_capab = cap_data;
863
864 if (vnic->vn_vrid != 0) {
865 if (vrrp_capab != NULL)
866 vrrp_capab->mcv_af = vnic->vn_af;
867 return (B_TRUE);
868 }
869 return (B_FALSE);
870 }
871 default:
872 return (B_FALSE);
873 }
874 return (B_TRUE);
875 }
876
877 /* ARGSUSED */
878 static int
879 vnic_m_start(void *arg)
880 {
881 return (0);
882 }
883
884 /* ARGSUSED */
885 static void
886 vnic_m_stop(void *arg)
887 {
888 }
889
890 /* ARGSUSED */
891 static int
892 vnic_m_promisc(void *arg, boolean_t on)
893 {
894 return (0);
895 }
896
897 /* ARGSUSED */
898 static int
899 vnic_m_multicst(void *arg, boolean_t add, const uint8_t *addrp)
900 {
901 return (0);
902 }
903
904 static int
905 vnic_m_unicst(void *arg, const uint8_t *macaddr)
906 {
907 vnic_t *vnic = arg;
908
909 return (mac_vnic_unicast_set(vnic->vn_mch, macaddr));
910 }
911
912 static void
913 vnic_cleanup_secondary_macs(vnic_t *vn, int cnt)
914 {
915 int i;
916
917 /* Remove existing secondaries (primary is at 0) */
918 for (i = 1; i <= cnt; i++) {
919 mac_rx_clear(vn->vn_mc_handles[i]);
920
921 /* unicast handle might not have been set yet */
922 if (vn->vn_mu_handles[i] != NULL)
923 (void) mac_unicast_remove(vn->vn_mc_handles[i],
924 vn->vn_mu_handles[i]);
925
926 mac_secondary_cleanup(vn->vn_mc_handles[i]);
927
928 mac_client_close(vn->vn_mc_handles[i], MAC_CLOSE_FLAGS_IS_VNIC);
929
930 vn->vn_mu_handles[i] = NULL;
931 vn->vn_mc_handles[i] = NULL;
932 }
933
934 vn->vn_nhandles = 0;
935 }
936
937 /*
938 * Setup secondary MAC addresses on the vnic. Due to limitations in the mac
939 * code, each mac address must be associated with a mac_client (and the
940 * flow that goes along with the client) so we need to create those clients
941 * here.
942 */
943 static int
944 vnic_set_secondary_macs(vnic_t *vn, mac_secondary_addr_t *msa)
945 {
946 int i, err;
947 char primary_name[MAXNAMELEN];
948
949 /* First, remove pre-existing secondaries */
950 ASSERT(vn->vn_nhandles < MPT_MAXMACADDR);
951 vnic_cleanup_secondary_macs(vn, vn->vn_nhandles);
952
953 if (msa->ms_addrcnt == (uint32_t)-1)
954 msa->ms_addrcnt = 0;
955
956 vn->vn_nhandles = msa->ms_addrcnt;
957
958 (void) dls_mgmt_get_linkinfo(vn->vn_id, primary_name, NULL, NULL, NULL);
959
960 /*
961 * Now add the new secondary MACs
962 * Recall that the primary MAC address is the first element.
963 * The secondary clients are named after the primary with their
964 * index to distinguish them.
965 */
966 for (i = 1; i <= vn->vn_nhandles; i++) {
967 uint8_t *addr;
968 mac_diag_t mac_diag;
969 char secondary_name[MAXNAMELEN];
970
971 (void) snprintf(secondary_name, sizeof (secondary_name),
972 "%s%02d", primary_name, i);
973
974 err = mac_client_open(vn->vn_lower_mh, &vn->vn_mc_handles[i],
975 secondary_name, MAC_OPEN_FLAGS_IS_VNIC);
976 if (err != 0) {
977 /* Remove any that we successfully added */
978 vnic_cleanup_secondary_macs(vn, --i);
979 return (err);
980 }
981
982 /*
983 * Assign a MAC address to the VNIC
984 *
985 * Normally this would be done with vnic_unicast_add but since
986 * we know these are fixed adddresses, and since we need to
987 * save this in the proper array slot, we bypass that function
988 * and go direct.
989 */
990 addr = msa->ms_addrs[i - 1];
991 err = mac_unicast_add(vn->vn_mc_handles[i], addr, 0,
992 &vn->vn_mu_handles[i], vn->vn_vid, &mac_diag);
993 if (err != 0) {
994 /* Remove any that we successfully added */
995 vnic_cleanup_secondary_macs(vn, i);
996 return (err);
997 }
998
999 /*
1000 * Setup the secondary the same way as the primary (i.e.
1001 * receiver function/argument (e.g. i_dls_link_rx, mac_pkt_drop,
1002 * etc.), the promisc list, and the resource controls).
1003 */
1004 mac_secondary_dup(vn->vn_mc_handles[0], vn->vn_mc_handles[i]);
1005 }
1006
1007 return (0);
1008 }
1009
1010 static int
1011 vnic_get_secondary_macs(vnic_t *vn, uint_t pr_valsize, void *pr_val)
1012 {
1013 int i;
1014 mac_secondary_addr_t msa;
1015
1016 if (pr_valsize < sizeof (msa))
1017 return (EINVAL);
1018
1019 /* Get existing addresses (primary is at 0) */
1020 ASSERT(vn->vn_nhandles < MPT_MAXMACADDR);
1021 for (i = 1; i <= vn->vn_nhandles; i++) {
1022 ASSERT(vn->vn_mc_handles[i] != NULL);
1023 mac_unicast_secondary_get(vn->vn_mc_handles[i],
1024 msa.ms_addrs[i - 1]);
1025 }
1026 msa.ms_addrcnt = vn->vn_nhandles;
1027
1028 bcopy(&msa, pr_val, sizeof (msa));
1029 return (0);
1030 }
1031
1032 /*
1033 * Callback functions for set/get of properties
1034 */
1035 /*ARGSUSED*/
1036 static int
1037 vnic_m_setprop(void *m_driver, const char *pr_name, mac_prop_id_t pr_num,
1038 uint_t pr_valsize, const void *pr_val)
1039 {
1040 int err = 0;
1041 vnic_t *vn = m_driver;
1042
1043 switch (pr_num) {
1044 case MAC_PROP_MTU: {
1045 uint32_t mtu;
1046
1047 if (pr_valsize < sizeof (mtu)) {
1048 err = EINVAL;
1049 break;
1050 }
1051 bcopy(pr_val, &mtu, sizeof (mtu));
1052
1053 if (vn->vn_link_id == DATALINK_INVALID_LINKID) {
1054 if (mtu < ANCHOR_VNIC_MIN_MTU ||
1055 mtu > ANCHOR_VNIC_MAX_MTU) {
1056 err = EINVAL;
1057 break;
1058 }
1059 } else {
1060 err = mac_mtu_add(vn->vn_lower_mh, &mtu, B_FALSE);
1061 /*
1062 * If it's not supported to set a value here, translate
1063 * that to EINVAL, so user land gets a better idea of
1064 * what went wrong. This realistically means that they
1065 * violated the output of prop info.
1066 */
1067 if (err == ENOTSUP)
1068 err = EINVAL;
1069 if (err != 0)
1070 break;
1071 VERIFY(mac_mtu_remove(vn->vn_lower_mh,
1072 vn->vn_mtu) == 0);
1073 }
1074 vn->vn_mtu = mtu;
1075 err = mac_maxsdu_update(vn->vn_mh, mtu);
1076 break;
1077 }
1078 case MAC_PROP_VN_PROMISC_FILTERED: {
1079 boolean_t filtered;
1080
1081 if (pr_valsize < sizeof (filtered)) {
1082 err = EINVAL;
1083 break;
1084 }
1085
1086 bcopy(pr_val, &filtered, sizeof (filtered));
1087 mac_set_promisc_filtered(vn->vn_mch, filtered);
1088 break;
1089 }
1090 case MAC_PROP_SECONDARY_ADDRS: {
1091 mac_secondary_addr_t msa;
1092
1093 bcopy(pr_val, &msa, sizeof (msa));
1094 err = vnic_set_secondary_macs(vn, &msa);
1095 break;
1096 }
1097 case MAC_PROP_PRIVATE: {
1098 long val, i;
1099 const char *v;
1100
1101 if (vn->vn_link_id != DATALINK_INVALID_LINKID ||
1102 strcmp(pr_name, "_linkstate") != 0) {
1103 err = ENOTSUP;
1104 break;
1105 }
1106
1107 for (v = pr_val, i = 0; i < pr_valsize; i++, v++) {
1108 if (*v == '\0')
1109 break;
1110 }
1111 if (i == pr_valsize) {
1112 err = EINVAL;
1113 break;
1114 }
1115
1116 (void) ddi_strtol(pr_val, (char **)NULL, 0, &val);
1117 if (val != LINK_STATE_UP && val != LINK_STATE_DOWN) {
1118 err = EINVAL;
1119 break;
1120 }
1121 vn->vn_ls = val;
1122 mac_link_update(vn->vn_mh, vn->vn_ls);
1123 break;
1124 }
1125 default:
1126 err = ENOTSUP;
1127 break;
1128 }
1129 return (err);
1130 }
1131
1132 /* ARGSUSED */
1133 static int
1134 vnic_m_getprop(void *arg, const char *pr_name, mac_prop_id_t pr_num,
1135 uint_t pr_valsize, void *pr_val)
1136 {
1137 vnic_t *vn = arg;
1138 int ret = 0;
1139 boolean_t out;
1140
1141 switch (pr_num) {
1142 case MAC_PROP_VN_PROMISC_FILTERED:
1143 out = mac_get_promisc_filtered(vn->vn_mch);
1144 ASSERT(pr_valsize >= sizeof (boolean_t));
1145 bcopy(&out, pr_val, sizeof (boolean_t));
1146 break;
1147 case MAC_PROP_SECONDARY_ADDRS:
1148 ret = vnic_get_secondary_macs(vn, pr_valsize, pr_val);
1149 break;
1150 case MAC_PROP_PRIVATE:
1151 if (vn->vn_link_id != DATALINK_INVALID_LINKID) {
1152 ret = EINVAL;
1153 break;
1154 }
1155
1156 if (strcmp(pr_name, "_linkstate") != 0) {
1157 ret = EINVAL;
1158 break;
1159 }
1160 (void) snprintf(pr_val, pr_valsize, "%d", vn->vn_ls);
1161 break;
1162 default:
1163 ret = ENOTSUP;
1164 break;
1165 }
1166
1167 return (ret);
1168 }
1169
1170 /* ARGSUSED */
1171 static void
1172 vnic_m_propinfo(void *m_driver, const char *pr_name,
1173 mac_prop_id_t pr_num, mac_prop_info_handle_t prh)
1174 {
1175 vnic_t *vn = m_driver;
1176
1177 switch (pr_num) {
1178 case MAC_PROP_MTU:
1179 if (vn->vn_link_id == DATALINK_INVALID_LINKID) {
1180 mac_prop_info_set_range_uint32(prh,
1181 ANCHOR_VNIC_MIN_MTU, ANCHOR_VNIC_MAX_MTU);
1182 } else {
1183 uint32_t max;
1184 mac_perim_handle_t mph;
1185 mac_propval_range_t range;
1186
1187 /*
1188 * The valid range for a VNIC's MTU is the minimum that
1189 * the device supports and the current value of the
1190 * device. A VNIC cannot increase the current MTU of the
1191 * device. Therefore we need to get the range from the
1192 * propinfo endpoint and current mtu from the
1193 * traditional property endpoint.
1194 */
1195 mac_perim_enter_by_mh(vn->vn_lower_mh, &mph);
1196 if (mac_get_prop(vn->vn_lower_mh, MAC_PROP_MTU, "mtu",
1197 &max, sizeof (uint32_t)) != 0) {
1198 mac_perim_exit(mph);
1199 return;
1200 }
1201
1202 range.mpr_count = 1;
1203 if (mac_prop_info(vn->vn_lower_mh, MAC_PROP_MTU, "mtu",
1204 NULL, 0, &range, NULL) != 0) {
1205 mac_perim_exit(mph);
1206 return;
1207 }
1208
1209 mac_prop_info_set_default_uint32(prh, max);
1210 mac_prop_info_set_range_uint32(prh,
1211 range.mpr_range_uint32[0].mpur_min, max);
1212 mac_perim_exit(mph);
1213 }
1214 break;
1215 case MAC_PROP_PRIVATE:
1216 if (vn->vn_link_id != DATALINK_INVALID_LINKID)
1217 break;
1218
1219 if (strcmp(pr_name, "_linkstate") == 0) {
1220 char buf[16];
1221
1222 mac_prop_info_set_perm(prh, MAC_PROP_PERM_RW);
1223 (void) snprintf(buf, sizeof (buf), "%d", vn->vn_ls);
1224 mac_prop_info_set_default_str(prh, buf);
1225 }
1226 break;
1227 }
1228 }
1229
1230
1231 int
1232 vnic_info(vnic_info_t *info, cred_t *credp)
1233 {
1234 vnic_t *vnic;
1235 int err;
1236
1237 /* Make sure that the VNIC link is visible from the caller's zone. */
1238 if (!dls_devnet_islinkvisible(info->vn_vnic_id, crgetzoneid(credp)))
1239 return (ENOENT);
1240
1241 rw_enter(&vnic_lock, RW_WRITER);
1242
1243 err = mod_hash_find(vnic_hash, VNIC_HASH_KEY(info->vn_vnic_id),
1244 (mod_hash_val_t *)&vnic);
1245 if (err != 0) {
1246 rw_exit(&vnic_lock);
1247 return (ENOENT);
1248 }
1249
1250 info->vn_link_id = vnic->vn_link_id;
1251 info->vn_mac_addr_type = vnic->vn_addr_type;
1252 info->vn_mac_len = vnic->vn_addr_len;
1253 bcopy(vnic->vn_addr, info->vn_mac_addr, MAXMACADDRLEN);
1254 info->vn_mac_slot = vnic->vn_slot_id;
1255 info->vn_mac_prefix_len = 0;
1256 info->vn_vid = vnic->vn_vid;
1257 info->vn_force = vnic->vn_force;
1258 info->vn_vrid = vnic->vn_vrid;
1259 info->vn_af = vnic->vn_af;
1260
1261 bzero(&info->vn_resource_props, sizeof (mac_resource_props_t));
1262 if (vnic->vn_mch != NULL)
1263 mac_client_get_resources(vnic->vn_mch,
1264 &info->vn_resource_props);
1265
1266 rw_exit(&vnic_lock);
1267 return (0);
1268 }
1269
1270 static void
1271 vnic_notify_cb(void *arg, mac_notify_type_t type)
1272 {
1273 vnic_t *vnic = arg;
1274
1275 /*
1276 * Do not deliver notifications if the vnic is not fully initialized
1277 * or is in process of being torn down.
1278 */
1279 if (!vnic->vn_enabled)
1280 return;
1281
1282 switch (type) {
1283 case MAC_NOTE_UNICST:
1284 /*
1285 * Only the VLAN VNIC needs to be notified with primary MAC
1286 * address change.
1287 */
1288 if (vnic->vn_addr_type != VNIC_MAC_ADDR_TYPE_PRIMARY)
1289 return;
1290
1291 /* the unicast MAC address value */
1292 mac_unicast_primary_get(vnic->vn_lower_mh, vnic->vn_addr);
1293
1294 /* notify its upper layer MAC about MAC address change */
1295 mac_unicst_update(vnic->vn_mh, (const uint8_t *)vnic->vn_addr);
1296 break;
1297
1298 case MAC_NOTE_LINK:
1299 vnic->vn_ls = mac_client_stat_get(vnic->vn_mch,
1300 MAC_STAT_LINK_STATE);
1301 mac_link_update(vnic->vn_mh, vnic->vn_ls);
1302 break;
1303
1304 default:
1305 break;
1306 }
1307 }