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 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright 2018 Joyent, Inc.
26 */
27
28 #include <sys/types.h>
29 #include <sys/errno.h>
30 #include <sys/param.h>
31 #include <sys/callb.h>
32 #include <sys/stream.h>
33 #include <sys/kmem.h>
34 #include <sys/conf.h>
35 #include <sys/devops.h>
36 #include <sys/ksynch.h>
37 #include <sys/stat.h>
38 #include <sys/modctl.h>
39 #include <sys/modhash.h>
40 #include <sys/debug.h>
41 #include <sys/ethernet.h>
42 #include <sys/dlpi.h>
43 #include <net/if.h>
44 #include <sys/mac_provider.h>
45 #include <sys/mac_client.h>
46 #include <sys/mac_client_priv.h>
47 #include <sys/mac_ether.h>
48 #include <sys/ddi.h>
49 #include <sys/sunddi.h>
50 #include <sys/strsun.h>
51 #include <sys/note.h>
52 #include <sys/atomic.h>
53 #include <sys/vnet.h>
54 #include <sys/vlan.h>
55 #include <sys/vnet_mailbox.h>
56 #include <sys/vnet_common.h>
57 #include <sys/dds.h>
58 #include <sys/strsubr.h>
59 #include <sys/taskq.h>
60
61 /*
62 * Function prototypes.
63 */
64
65 /* DDI entrypoints */
66 static int vnetdevinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
67 static int vnetattach(dev_info_t *, ddi_attach_cmd_t);
68 static int vnetdetach(dev_info_t *, ddi_detach_cmd_t);
69
70 /* MAC entrypoints */
71 static int vnet_m_stat(void *, uint_t, uint64_t *);
72 static int vnet_m_start(void *);
73 static void vnet_m_stop(void *);
74 static int vnet_m_promisc(void *, boolean_t);
75 static int vnet_m_multicst(void *, boolean_t, const uint8_t *);
76 static int vnet_m_unicst(void *, const uint8_t *);
77 mblk_t *vnet_m_tx(void *, mblk_t *);
78 static void vnet_m_ioctl(void *arg, queue_t *q, mblk_t *mp);
79 #ifdef VNET_IOC_DEBUG
80 static void vnet_force_link_state(vnet_t *vnetp, queue_t *q, mblk_t *mp);
81 #endif
82 static boolean_t vnet_m_capab(void *arg, mac_capab_t cap, void *cap_data);
83 static void vnet_get_ring(void *arg, mac_ring_type_t rtype, const int g_index,
84 const int r_index, mac_ring_info_t *infop, mac_ring_handle_t r_handle);
85 static void vnet_get_group(void *arg, mac_ring_type_t type, const int index,
86 mac_group_info_t *infop, mac_group_handle_t handle);
87 static int vnet_rx_ring_start(mac_ring_driver_t rdriver, uint64_t mr_gen_num);
88 static void vnet_rx_ring_stop(mac_ring_driver_t rdriver);
89 static int vnet_rx_ring_stat(mac_ring_driver_t rdriver, uint_t stat,
90 uint64_t *val);
91 static int vnet_tx_ring_start(mac_ring_driver_t rdriver, uint64_t mr_gen_num);
92 static void vnet_tx_ring_stop(mac_ring_driver_t rdriver);
93 static int vnet_tx_ring_stat(mac_ring_driver_t rdriver, uint_t stat,
94 uint64_t *val);
95 static int vnet_ring_enable_intr(void *arg);
96 static int vnet_ring_disable_intr(void *arg);
97 static mblk_t *vnet_rx_poll(void *arg, int bytes_to_pickup);
98 static int vnet_addmac(void *arg, const uint8_t *mac_addr);
99 static int vnet_remmac(void *arg, const uint8_t *mac_addr);
100
101 /* vnet internal functions */
102 static int vnet_unattach(vnet_t *vnetp);
103 static void vnet_ring_grp_init(vnet_t *vnetp);
104 static void vnet_ring_grp_uninit(vnet_t *vnetp);
105 static int vnet_mac_register(vnet_t *);
106 static int vnet_read_mac_address(vnet_t *vnetp);
107 static int vnet_bind_vgenring(vnet_res_t *vresp);
108 static void vnet_unbind_vgenring(vnet_res_t *vresp);
109 static int vnet_bind_hwrings(vnet_t *vnetp);
110 static void vnet_unbind_hwrings(vnet_t *vnetp);
111 static int vnet_bind_rings(vnet_res_t *vresp);
112 static void vnet_unbind_rings(vnet_res_t *vresp);
113 static int vnet_hio_stat(void *, uint_t, uint64_t *);
114 static int vnet_hio_start(void *);
115 static void vnet_hio_stop(void *);
116 mblk_t *vnet_hio_tx(void *, mblk_t *);
117
118 /* Forwarding database (FDB) routines */
119 static void vnet_fdb_create(vnet_t *vnetp);
120 static void vnet_fdb_destroy(vnet_t *vnetp);
121 static vnet_res_t *vnet_fdbe_find(vnet_t *vnetp, struct ether_addr *addrp);
122 static void vnet_fdbe_find_cb(mod_hash_key_t key, mod_hash_val_t val);
123 void vnet_fdbe_add(vnet_t *vnetp, vnet_res_t *vresp);
124 static void vnet_fdbe_del(vnet_t *vnetp, vnet_res_t *vresp);
125
126 static void vnet_rx_frames_untag(uint16_t pvid, mblk_t **mp);
127 static void vnet_rx(vio_net_handle_t vrh, mblk_t *mp);
128 static void vnet_tx_update(vio_net_handle_t vrh);
129 static void vnet_res_start_task(void *arg);
130 static void vnet_start_resources(vnet_t *vnetp);
131 static void vnet_stop_resources(vnet_t *vnetp);
132 static void vnet_dispatch_res_task(vnet_t *vnetp);
133 static void vnet_res_start_task(void *arg);
134 static void vnet_handle_res_err(vio_net_handle_t vrh, vio_net_err_val_t err);
135 static void vnet_add_resource(vnet_t *vnetp, vnet_res_t *vresp);
136 static vnet_res_t *vnet_rem_resource(vnet_t *vnetp, vnet_res_t *vresp);
137 static void vnet_tx_notify_thread(void *);
138
139 /* Exported to vnet_gen */
140 int vnet_mtu_update(vnet_t *vnetp, uint32_t mtu);
141 void vnet_link_update(vnet_t *vnetp, link_state_t link_state);
142 void vnet_dds_cleanup_hio(vnet_t *vnetp);
143
144 static kstat_t *vnet_hio_setup_kstats(char *ks_mod, char *ks_name,
145 vnet_res_t *vresp);
146 static int vnet_hio_update_kstats(kstat_t *ksp, int rw);
147 static void vnet_hio_get_stats(vnet_res_t *vresp, vnet_hio_stats_t *statsp);
148 static void vnet_hio_destroy_kstats(kstat_t *ksp);
149
150 /* Exported to to vnet_dds */
151 int vnet_send_dds_msg(vnet_t *vnetp, void *dmsg);
152 int vnet_hio_mac_init(vnet_t *vnetp, char *ifname);
153 void vnet_hio_mac_cleanup(vnet_t *vnetp);
154
155 /* Externs that are imported from vnet_gen */
156 extern int vgen_init(void *vnetp, uint64_t regprop, dev_info_t *vnetdip,
157 const uint8_t *macaddr, void **vgenhdl);
158 extern int vgen_init_mdeg(void *arg);
159 extern void vgen_uninit(void *arg);
160 extern int vgen_dds_tx(void *arg, void *dmsg);
161 extern int vgen_enable_intr(void *arg);
162 extern int vgen_disable_intr(void *arg);
163 extern mblk_t *vgen_rx_poll(void *arg, int bytes_to_pickup);
164
165 /* Externs that are imported from vnet_dds */
166 extern void vdds_mod_init(void);
167 extern void vdds_mod_fini(void);
168 extern int vdds_init(vnet_t *vnetp);
169 extern void vdds_cleanup(vnet_t *vnetp);
170 extern void vdds_process_dds_msg(vnet_t *vnetp, vio_dds_msg_t *dmsg);
171 extern void vdds_cleanup_hybrid_res(void *arg);
172 extern void vdds_cleanup_hio(vnet_t *vnetp);
173
174 extern pri_t minclsyspri;
175
176 #define DRV_NAME "vnet"
177 #define VNET_FDBE_REFHOLD(p) \
178 { \
179 atomic_inc_32(&(p)->refcnt); \
180 ASSERT((p)->refcnt != 0); \
181 }
182
183 #define VNET_FDBE_REFRELE(p) \
184 { \
185 ASSERT((p)->refcnt != 0); \
186 atomic_dec_32(&(p)->refcnt); \
187 }
188
189 #ifdef VNET_IOC_DEBUG
190 #define VNET_M_CALLBACK_FLAGS (MC_IOCTL | MC_GETCAPAB)
191 #else
192 #define VNET_M_CALLBACK_FLAGS (MC_GETCAPAB)
193 #endif
194
195 static mac_callbacks_t vnet_m_callbacks = {
196 VNET_M_CALLBACK_FLAGS,
197 vnet_m_stat,
198 vnet_m_start,
199 vnet_m_stop,
200 vnet_m_promisc,
201 vnet_m_multicst,
202 NULL, /* m_unicst entry must be NULL while rx rings are exposed */
203 NULL, /* m_tx entry must be NULL while tx rings are exposed */
204 NULL,
205 vnet_m_ioctl,
206 vnet_m_capab,
207 NULL
208 };
209
210 static mac_callbacks_t vnet_hio_res_callbacks = {
211 0,
212 vnet_hio_stat,
213 vnet_hio_start,
214 vnet_hio_stop,
215 NULL,
216 NULL,
217 NULL,
218 vnet_hio_tx,
219 NULL,
220 NULL,
221 NULL
222 };
223
224 /*
225 * Linked list of "vnet_t" structures - one per instance.
226 */
227 static vnet_t *vnet_headp = NULL;
228 static krwlock_t vnet_rw;
229
230 /* Tunables */
231 uint32_t vnet_num_descriptors = VNET_NUM_DESCRIPTORS;
232
233 /*
234 * Configure tx serialization in mac layer for the vnet device. This tunable
235 * should be enabled to improve performance only if HybridIO is configured for
236 * the vnet device.
237 */
238 boolean_t vnet_mac_tx_serialize = B_FALSE;
239
240 /* Configure enqueing at Rx soft rings in mac layer for the vnet device */
241 boolean_t vnet_mac_rx_queuing = B_TRUE;
242
243 /*
244 * Set this to non-zero to enable additional internal receive buffer pools
245 * based on the MTU of the device for better performance at the cost of more
246 * memory consumption. This is turned off by default, to use allocb(9F) for
247 * receive buffer allocations of sizes > 2K.
248 */
249 boolean_t vnet_jumbo_rxpools = B_FALSE;
250
251 /* # of chains in fdb hash table */
252 uint32_t vnet_fdb_nchains = VNET_NFDB_HASH;
253
254 /* Internal tunables */
255 uint32_t vnet_ethermtu = 1500; /* mtu of the device */
256
257 /*
258 * Default vlan id. This is only used internally when the "default-vlan-id"
259 * property is not present in the MD device node. Therefore, this should not be
260 * used as a tunable; if this value is changed, the corresponding variable
261 * should be updated to the same value in vsw and also other vnets connected to
262 * the same vsw.
263 */
264 uint16_t vnet_default_vlan_id = 1;
265
266 /* delay in usec to wait for all references on a fdb entry to be dropped */
267 uint32_t vnet_fdbe_refcnt_delay = 10;
268
269 static struct ether_addr etherbroadcastaddr = {
270 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
271 };
272
273 /* mac_open() retry delay in usec */
274 uint32_t vnet_mac_open_delay = 100; /* 0.1 ms */
275
276 /* max # of mac_open() retries */
277 uint32_t vnet_mac_open_retries = 100;
278
279 /*
280 * Property names
281 */
282 static char macaddr_propname[] = "local-mac-address";
283
284 /*
285 * This is the string displayed by modinfo(1m).
286 */
287 static char vnet_ident[] = "vnet driver";
288 extern struct mod_ops mod_driverops;
289 static struct cb_ops cb_vnetops = {
290 nulldev, /* cb_open */
291 nulldev, /* cb_close */
292 nodev, /* cb_strategy */
293 nodev, /* cb_print */
294 nodev, /* cb_dump */
295 nodev, /* cb_read */
296 nodev, /* cb_write */
297 nodev, /* cb_ioctl */
298 nodev, /* cb_devmap */
299 nodev, /* cb_mmap */
300 nodev, /* cb_segmap */
301 nochpoll, /* cb_chpoll */
302 ddi_prop_op, /* cb_prop_op */
303 NULL, /* cb_stream */
304 (int)(D_MP) /* cb_flag */
305 };
306
307 static struct dev_ops vnetops = {
308 DEVO_REV, /* devo_rev */
309 0, /* devo_refcnt */
310 NULL, /* devo_getinfo */
311 nulldev, /* devo_identify */
312 nulldev, /* devo_probe */
313 vnetattach, /* devo_attach */
314 vnetdetach, /* devo_detach */
315 nodev, /* devo_reset */
316 &cb_vnetops, /* devo_cb_ops */
317 (struct bus_ops *)NULL, /* devo_bus_ops */
318 NULL, /* devo_power */
319 ddi_quiesce_not_supported, /* devo_quiesce */
320 };
321
322 static struct modldrv modldrv = {
323 &mod_driverops, /* Type of module. This one is a driver */
324 vnet_ident, /* ID string */
325 &vnetops /* driver specific ops */
326 };
327
328 static struct modlinkage modlinkage = {
329 MODREV_1, (void *)&modldrv, NULL
330 };
331
332 #ifdef DEBUG
333
334 #define DEBUG_PRINTF debug_printf
335
336 /*
337 * Print debug messages - set to 0xf to enable all msgs
338 */
339 int vnet_dbglevel = 0x8;
340
341 static void
342 debug_printf(const char *fname, void *arg, const char *fmt, ...)
343 {
344 char buf[512];
345 va_list ap;
346 vnet_t *vnetp = (vnet_t *)arg;
347 char *bufp = buf;
348
349 if (vnetp == NULL) {
350 (void) sprintf(bufp, "%s: ", fname);
351 bufp += strlen(bufp);
352 } else {
353 (void) sprintf(bufp, "vnet%d:%s: ", vnetp->instance, fname);
354 bufp += strlen(bufp);
355 }
356 va_start(ap, fmt);
357 (void) vsprintf(bufp, fmt, ap);
358 va_end(ap);
359 cmn_err(CE_CONT, "%s\n", buf);
360 }
361
362 #endif
363
364 /* _init(9E): initialize the loadable module */
365 int
366 _init(void)
367 {
368 int status;
369
370 DBG1(NULL, "enter\n");
371
372 mac_init_ops(&vnetops, "vnet");
373 status = mod_install(&modlinkage);
374 if (status != 0) {
375 mac_fini_ops(&vnetops);
376 }
377 vdds_mod_init();
378 DBG1(NULL, "exit(%d)\n", status);
379 return (status);
380 }
381
382 /* _fini(9E): prepare the module for unloading. */
383 int
384 _fini(void)
385 {
386 int status;
387
388 DBG1(NULL, "enter\n");
389
390 status = mod_remove(&modlinkage);
391 if (status != 0)
392 return (status);
393 mac_fini_ops(&vnetops);
394 vdds_mod_fini();
395
396 DBG1(NULL, "exit(%d)\n", status);
397 return (status);
398 }
399
400 /* _info(9E): return information about the loadable module */
401 int
402 _info(struct modinfo *modinfop)
403 {
404 return (mod_info(&modlinkage, modinfop));
405 }
406
407 /*
408 * attach(9E): attach a device to the system.
409 * called once for each instance of the device on the system.
410 */
411 static int
412 vnetattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
413 {
414 vnet_t *vnetp;
415 int status;
416 int instance;
417 uint64_t reg;
418 char qname[TASKQ_NAMELEN];
419 vnet_attach_progress_t attach_progress;
420
421 attach_progress = AST_init;
422
423 switch (cmd) {
424 case DDI_ATTACH:
425 break;
426 case DDI_RESUME:
427 case DDI_PM_RESUME:
428 default:
429 goto vnet_attach_fail;
430 }
431
432 instance = ddi_get_instance(dip);
433 DBG1(NULL, "instance(%d) enter\n", instance);
434
435 /* allocate vnet_t and mac_t structures */
436 vnetp = kmem_zalloc(sizeof (vnet_t), KM_SLEEP);
437 vnetp->dip = dip;
438 vnetp->instance = instance;
439 rw_init(&vnetp->vrwlock, NULL, RW_DRIVER, NULL);
440 rw_init(&vnetp->vsw_fp_rw, NULL, RW_DRIVER, NULL);
441 attach_progress |= AST_vnet_alloc;
442
443 vnet_ring_grp_init(vnetp);
444 attach_progress |= AST_ring_init;
445
446 status = vdds_init(vnetp);
447 if (status != 0) {
448 goto vnet_attach_fail;
449 }
450 attach_progress |= AST_vdds_init;
451
452 /* setup links to vnet_t from both devinfo and mac_t */
453 ddi_set_driver_private(dip, (caddr_t)vnetp);
454
455 /* read the mac address */
456 status = vnet_read_mac_address(vnetp);
457 if (status != DDI_SUCCESS) {
458 goto vnet_attach_fail;
459 }
460 attach_progress |= AST_read_macaddr;
461
462 reg = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
463 DDI_PROP_DONTPASS, "reg", -1);
464 if (reg == -1) {
465 goto vnet_attach_fail;
466 }
467 vnetp->reg = reg;
468
469 vnet_fdb_create(vnetp);
470 attach_progress |= AST_fdbh_alloc;
471
472 (void) snprintf(qname, TASKQ_NAMELEN, "vres_taskq%d", instance);
473 if ((vnetp->taskqp = ddi_taskq_create(dip, qname, 1,
474 TASKQ_DEFAULTPRI, 0)) == NULL) {
475 cmn_err(CE_WARN, "!vnet%d: Unable to create task queue",
476 instance);
477 goto vnet_attach_fail;
478 }
479 attach_progress |= AST_taskq_create;
480
481 /* add to the list of vnet devices */
482 WRITE_ENTER(&vnet_rw);
483 vnetp->nextp = vnet_headp;
484 vnet_headp = vnetp;
485 RW_EXIT(&vnet_rw);
486
487 attach_progress |= AST_vnet_list;
488
489 /*
490 * Initialize the generic vnet plugin which provides communication via
491 * sun4v LDC (logical domain channel) based resources. This involves 2
492 * steps; first, vgen_init() is invoked to read the various properties
493 * of the vnet device from its MD node (including its mtu which is
494 * needed to mac_register()) and obtain a handle to the vgen layer.
495 * After mac_register() is done and we have a mac handle, we then
496 * invoke vgen_init_mdeg() which registers with the the MD event
497 * generator (mdeg) framework to allow LDC resource notifications.
498 * Note: this sequence also allows us to report the correct default #
499 * of pseudo rings (2TX and 3RX) in vnet_m_capab() which gets invoked
500 * in the context of mac_register(); and avoids conflicting with
501 * dynamic pseudo rx rings which get added/removed as a result of mdeg
502 * events in vgen.
503 */
504 status = vgen_init(vnetp, reg, vnetp->dip,
505 (uint8_t *)vnetp->curr_macaddr, &vnetp->vgenhdl);
506 if (status != DDI_SUCCESS) {
507 DERR(vnetp, "vgen_init() failed\n");
508 goto vnet_attach_fail;
509 }
510 attach_progress |= AST_vgen_init;
511
512 status = vnet_mac_register(vnetp);
513 if (status != DDI_SUCCESS) {
514 goto vnet_attach_fail;
515 }
516 vnetp->link_state = LINK_STATE_UNKNOWN;
517 attach_progress |= AST_macreg;
518
519 status = vgen_init_mdeg(vnetp->vgenhdl);
520 if (status != DDI_SUCCESS) {
521 goto vnet_attach_fail;
522 }
523 attach_progress |= AST_init_mdeg;
524
525 vnetp->attach_progress = attach_progress;
526
527 DBG1(NULL, "instance(%d) exit\n", instance);
528 return (DDI_SUCCESS);
529
530 vnet_attach_fail:
531 vnetp->attach_progress = attach_progress;
532 status = vnet_unattach(vnetp);
533 ASSERT(status == 0);
534 return (DDI_FAILURE);
535 }
536
537 /*
538 * detach(9E): detach a device from the system.
539 */
540 static int
541 vnetdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
542 {
543 vnet_t *vnetp;
544 int instance;
545
546 instance = ddi_get_instance(dip);
547 DBG1(NULL, "instance(%d) enter\n", instance);
548
549 vnetp = ddi_get_driver_private(dip);
550 if (vnetp == NULL) {
551 goto vnet_detach_fail;
552 }
553
554 switch (cmd) {
555 case DDI_DETACH:
556 break;
557 case DDI_SUSPEND:
558 case DDI_PM_SUSPEND:
559 default:
560 goto vnet_detach_fail;
561 }
562
563 if (vnet_unattach(vnetp) != 0) {
564 goto vnet_detach_fail;
565 }
566
567 return (DDI_SUCCESS);
568
569 vnet_detach_fail:
570 return (DDI_FAILURE);
571 }
572
573 /*
574 * Common routine to handle vnetattach() failure and vnetdetach(). Note that
575 * the only reason this function could fail is if mac_unregister() fails.
576 * Otherwise, this function must ensure that all resources are freed and return
577 * success.
578 */
579 static int
580 vnet_unattach(vnet_t *vnetp)
581 {
582 vnet_attach_progress_t attach_progress;
583
584 attach_progress = vnetp->attach_progress;
585
586 /*
587 * Disable the mac device in the gldv3 subsystem. This can fail, in
588 * particular if there are still any open references to this mac
589 * device; in which case we just return failure without continuing to
590 * detach further.
591 * If it succeeds, we then invoke vgen_uninit() which should unregister
592 * any pseudo rings registered with the mac layer. Note we keep the
593 * AST_macreg flag on, so we can unregister with the mac layer at
594 * the end of this routine.
595 */
596 if (attach_progress & AST_macreg) {
597 if (mac_disable(vnetp->mh) != 0) {
598 return (1);
599 }
600 }
601
602 /*
603 * Now that we have disabled the device, we must finish all other steps
604 * and successfully return from this function; otherwise we will end up
605 * leaving the device in a broken/unusable state.
606 *
607 * First, release any hybrid resources assigned to this vnet device.
608 */
609 if (attach_progress & AST_vdds_init) {
610 vdds_cleanup(vnetp);
611 attach_progress &= ~AST_vdds_init;
612 }
613
614 /*
615 * Uninit vgen. This stops further mdeg callbacks to this vnet
616 * device and/or its ports; and detaches any existing ports.
617 */
618 if (attach_progress & (AST_vgen_init|AST_init_mdeg)) {
619 vgen_uninit(vnetp->vgenhdl);
620 attach_progress &= ~AST_vgen_init;
621 attach_progress &= ~AST_init_mdeg;
622 }
623
624 /* Destroy the taskq. */
625 if (attach_progress & AST_taskq_create) {
626 ddi_taskq_destroy(vnetp->taskqp);
627 attach_progress &= ~AST_taskq_create;
628 }
629
630 /* Destroy fdb. */
631 if (attach_progress & AST_fdbh_alloc) {
632 vnet_fdb_destroy(vnetp);
633 attach_progress &= ~AST_fdbh_alloc;
634 }
635
636 /* Remove from the device list */
637 if (attach_progress & AST_vnet_list) {
638 vnet_t **vnetpp;
639 /* unlink from instance(vnet_t) list */
640 WRITE_ENTER(&vnet_rw);
641 for (vnetpp = &vnet_headp; *vnetpp;
642 vnetpp = &(*vnetpp)->nextp) {
643 if (*vnetpp == vnetp) {
644 *vnetpp = vnetp->nextp;
645 break;
646 }
647 }
648 RW_EXIT(&vnet_rw);
649 attach_progress &= ~AST_vnet_list;
650 }
651
652 if (attach_progress & AST_ring_init) {
653 vnet_ring_grp_uninit(vnetp);
654 attach_progress &= ~AST_ring_init;
655 }
656
657 if (attach_progress & AST_macreg) {
658 VERIFY(mac_unregister(vnetp->mh) == 0);
659 vnetp->mh = NULL;
660 attach_progress &= ~AST_macreg;
661 }
662
663 if (attach_progress & AST_vnet_alloc) {
664 rw_destroy(&vnetp->vrwlock);
665 rw_destroy(&vnetp->vsw_fp_rw);
666 attach_progress &= ~AST_vnet_list;
667 KMEM_FREE(vnetp);
668 }
669
670 return (0);
671 }
672
673 /* enable the device for transmit/receive */
674 static int
675 vnet_m_start(void *arg)
676 {
677 vnet_t *vnetp = arg;
678
679 DBG1(vnetp, "enter\n");
680
681 WRITE_ENTER(&vnetp->vrwlock);
682 vnetp->flags |= VNET_STARTED;
683 vnet_start_resources(vnetp);
684 RW_EXIT(&vnetp->vrwlock);
685
686 DBG1(vnetp, "exit\n");
687 return (VNET_SUCCESS);
688
689 }
690
691 /* stop transmit/receive for the device */
692 static void
693 vnet_m_stop(void *arg)
694 {
695 vnet_t *vnetp = arg;
696
697 DBG1(vnetp, "enter\n");
698
699 WRITE_ENTER(&vnetp->vrwlock);
700 if (vnetp->flags & VNET_STARTED) {
701 /*
702 * Set the flags appropriately; this should prevent starting of
703 * any new resources that are added(see vnet_res_start_task()),
704 * while we release the vrwlock in vnet_stop_resources() before
705 * stopping each resource.
706 */
707 vnetp->flags &= ~VNET_STARTED;
708 vnetp->flags |= VNET_STOPPING;
709 vnet_stop_resources(vnetp);
710 vnetp->flags &= ~VNET_STOPPING;
711 }
712 RW_EXIT(&vnetp->vrwlock);
713
714 DBG1(vnetp, "exit\n");
715 }
716
717 /* set the unicast mac address of the device */
718 static int
719 vnet_m_unicst(void *arg, const uint8_t *macaddr)
720 {
721 _NOTE(ARGUNUSED(macaddr))
722
723 vnet_t *vnetp = arg;
724
725 DBG1(vnetp, "enter\n");
726 /*
727 * NOTE: setting mac address dynamically is not supported.
728 */
729 DBG1(vnetp, "exit\n");
730
731 return (VNET_FAILURE);
732 }
733
734 /* enable/disable a multicast address */
735 static int
736 vnet_m_multicst(void *arg, boolean_t add, const uint8_t *mca)
737 {
738 _NOTE(ARGUNUSED(add, mca))
739
740 vnet_t *vnetp = arg;
741 vnet_res_t *vresp;
742 mac_register_t *macp;
743 mac_callbacks_t *cbp;
744 int rv = VNET_SUCCESS;
745
746 DBG1(vnetp, "enter\n");
747
748 READ_ENTER(&vnetp->vsw_fp_rw);
749 if (vnetp->vsw_fp == NULL) {
750 RW_EXIT(&vnetp->vsw_fp_rw);
751 return (EAGAIN);
752 }
753 VNET_FDBE_REFHOLD(vnetp->vsw_fp);
754 RW_EXIT(&vnetp->vsw_fp_rw);
755
756 vresp = vnetp->vsw_fp;
757 macp = &vresp->macreg;
758 cbp = macp->m_callbacks;
759 rv = cbp->mc_multicst(macp->m_driver, add, mca);
760
761 VNET_FDBE_REFRELE(vnetp->vsw_fp);
762
763 DBG1(vnetp, "exit(%d)\n", rv);
764 return (rv);
765 }
766
767 /* set or clear promiscuous mode on the device */
768 static int
769 vnet_m_promisc(void *arg, boolean_t on)
770 {
771 _NOTE(ARGUNUSED(on))
772
773 vnet_t *vnetp = arg;
774 DBG1(vnetp, "enter\n");
775 /*
776 * NOTE: setting promiscuous mode is not supported, just return success.
777 */
778 DBG1(vnetp, "exit\n");
779 return (VNET_SUCCESS);
780 }
781
782 /*
783 * Transmit a chain of packets. This function provides switching functionality
784 * based on the destination mac address to reach other guests (within ldoms) or
785 * external hosts.
786 */
787 mblk_t *
788 vnet_tx_ring_send(void *arg, mblk_t *mp)
789 {
790 vnet_pseudo_tx_ring_t *tx_ringp;
791 vnet_tx_ring_stats_t *statsp;
792 vnet_t *vnetp;
793 vnet_res_t *vresp;
794 mblk_t *next;
795 mblk_t *resid_mp;
796 mac_register_t *macp;
797 struct ether_header *ehp;
798 boolean_t is_unicast;
799 boolean_t is_pvid; /* non-default pvid ? */
800 boolean_t hres; /* Hybrid resource ? */
801 void *tx_arg;
802 size_t size;
803
804 tx_ringp = (vnet_pseudo_tx_ring_t *)arg;
805 statsp = &tx_ringp->tx_ring_stats;
806 vnetp = (vnet_t *)tx_ringp->vnetp;
807 DBG1(vnetp, "enter\n");
808 ASSERT(mp != NULL);
809
810 is_pvid = (vnetp->pvid != vnetp->default_vlan_id) ? B_TRUE : B_FALSE;
811
812 while (mp != NULL) {
813
814 next = mp->b_next;
815 mp->b_next = NULL;
816
817 /* update stats */
818 size = msgsize(mp);
819
820 /*
821 * Find fdb entry for the destination
822 * and hold a reference to it.
823 */
824 ehp = (struct ether_header *)mp->b_rptr;
825 vresp = vnet_fdbe_find(vnetp, &ehp->ether_dhost);
826 if (vresp != NULL) {
827
828 /*
829 * Destination found in FDB.
830 * The destination is a vnet device within ldoms
831 * and directly reachable, invoke the tx function
832 * in the fdb entry.
833 */
834 macp = &vresp->macreg;
835 resid_mp = macp->m_callbacks->mc_tx(macp->m_driver, mp);
836
837 /* tx done; now release ref on fdb entry */
838 VNET_FDBE_REFRELE(vresp);
839
840 if (resid_mp != NULL) {
841 /* m_tx failed */
842 mp->b_next = next;
843 break;
844 }
845 } else {
846 is_unicast = !(IS_BROADCAST(ehp) ||
847 (IS_MULTICAST(ehp)));
848 /*
849 * Destination is not in FDB.
850 * If the destination is broadcast or multicast,
851 * then forward the packet to vswitch.
852 * If a Hybrid resource avilable, then send the
853 * unicast packet via hybrid resource, otherwise
854 * forward it to vswitch.
855 */
856 READ_ENTER(&vnetp->vsw_fp_rw);
857
858 if ((is_unicast) && (vnetp->hio_fp != NULL)) {
859 vresp = vnetp->hio_fp;
860 hres = B_TRUE;
861 } else {
862 vresp = vnetp->vsw_fp;
863 hres = B_FALSE;
864 }
865 if (vresp == NULL) {
866 /*
867 * no fdb entry to vsw? drop the packet.
868 */
869 RW_EXIT(&vnetp->vsw_fp_rw);
870 freemsg(mp);
871 mp = next;
872 continue;
873 }
874
875 /* ref hold the fdb entry to vsw */
876 VNET_FDBE_REFHOLD(vresp);
877
878 RW_EXIT(&vnetp->vsw_fp_rw);
879
880 /*
881 * In the case of a hybrid resource we need to insert
882 * the tag for the pvid case here; unlike packets that
883 * are destined to a vnet/vsw in which case the vgen
884 * layer does the tagging before sending it over ldc.
885 */
886 if (hres == B_TRUE) {
887 /*
888 * Determine if the frame being transmitted
889 * over the hybrid resource is untagged. If so,
890 * insert the tag before transmitting.
891 */
892 if (is_pvid == B_TRUE &&
893 ehp->ether_type != htons(ETHERTYPE_VLAN)) {
894
895 mp = vnet_vlan_insert_tag(mp,
896 vnetp->pvid);
897 if (mp == NULL) {
898 VNET_FDBE_REFRELE(vresp);
899 mp = next;
900 continue;
901 }
902
903 }
904
905 macp = &vresp->macreg;
906 tx_arg = tx_ringp;
907 } else {
908 macp = &vresp->macreg;
909 tx_arg = macp->m_driver;
910 }
911 resid_mp = macp->m_callbacks->mc_tx(tx_arg, mp);
912
913 /* tx done; now release ref on fdb entry */
914 VNET_FDBE_REFRELE(vresp);
915
916 if (resid_mp != NULL) {
917 /* m_tx failed */
918 mp->b_next = next;
919 break;
920 }
921 }
922
923 statsp->obytes += size;
924 statsp->opackets++;
925 mp = next;
926 }
927
928 DBG1(vnetp, "exit\n");
929 return (mp);
930 }
931
932 /* get statistics from the device */
933 int
934 vnet_m_stat(void *arg, uint_t stat, uint64_t *val)
935 {
936 vnet_t *vnetp = arg;
937 vnet_res_t *vresp;
938 mac_register_t *macp;
939 mac_callbacks_t *cbp;
940 uint64_t val_total = 0;
941
942 DBG1(vnetp, "enter\n");
943
944 /*
945 * get the specified statistic from each transport and return the
946 * aggregate val. This obviously only works for counters.
947 */
948 if ((IS_MAC_STAT(stat) && !MAC_STAT_ISACOUNTER(stat)) ||
949 (IS_MACTYPE_STAT(stat) && !ETHER_STAT_ISACOUNTER(stat))) {
950 return (ENOTSUP);
951 }
952
953 READ_ENTER(&vnetp->vrwlock);
954 for (vresp = vnetp->vres_list; vresp != NULL; vresp = vresp->nextp) {
955 macp = &vresp->macreg;
956 cbp = macp->m_callbacks;
957 if (cbp->mc_getstat(macp->m_driver, stat, val) == 0)
958 val_total += *val;
959 }
960 RW_EXIT(&vnetp->vrwlock);
961
962 *val = val_total;
963
964 DBG1(vnetp, "exit\n");
965 return (0);
966 }
967
968 static void
969 vnet_ring_grp_init(vnet_t *vnetp)
970 {
971 vnet_pseudo_rx_group_t *rx_grp;
972 vnet_pseudo_rx_ring_t *rx_ringp;
973 vnet_pseudo_tx_group_t *tx_grp;
974 vnet_pseudo_tx_ring_t *tx_ringp;
975 int i;
976
977 tx_grp = &vnetp->tx_grp[0];
978 tx_ringp = kmem_zalloc(sizeof (vnet_pseudo_tx_ring_t) *
979 VNET_NUM_PSEUDO_TXRINGS, KM_SLEEP);
980 for (i = 0; i < VNET_NUM_PSEUDO_TXRINGS; i++) {
981 tx_ringp[i].state |= VNET_TXRING_SHARED;
982 }
983 tx_grp->rings = tx_ringp;
984 tx_grp->ring_cnt = VNET_NUM_PSEUDO_TXRINGS;
985 mutex_init(&tx_grp->flowctl_lock, NULL, MUTEX_DRIVER, NULL);
986 cv_init(&tx_grp->flowctl_cv, NULL, CV_DRIVER, NULL);
987 tx_grp->flowctl_thread = thread_create(NULL, 0,
988 vnet_tx_notify_thread, tx_grp, 0, &p0, TS_RUN, minclsyspri);
989
990 rx_grp = &vnetp->rx_grp[0];
991 rx_grp->max_ring_cnt = MAX_RINGS_PER_GROUP;
992 rw_init(&rx_grp->lock, NULL, RW_DRIVER, NULL);
993 rx_ringp = kmem_zalloc(sizeof (vnet_pseudo_rx_ring_t) *
994 rx_grp->max_ring_cnt, KM_SLEEP);
995
996 /*
997 * Setup the first 3 Pseudo RX Rings that are reserved;
998 * 1 for LDC resource to vswitch + 2 for RX rings of Hybrid resource.
999 */
1000 rx_ringp[0].state |= VNET_RXRING_INUSE|VNET_RXRING_LDC_SERVICE;
1001 rx_ringp[0].index = 0;
1002 rx_ringp[1].state |= VNET_RXRING_INUSE|VNET_RXRING_HYBRID;
1003 rx_ringp[1].index = 1;
1004 rx_ringp[2].state |= VNET_RXRING_INUSE|VNET_RXRING_HYBRID;
1005 rx_ringp[2].index = 2;
1006
1007 rx_grp->ring_cnt = VNET_NUM_PSEUDO_RXRINGS_DEFAULT;
1008 rx_grp->rings = rx_ringp;
1009
1010 for (i = VNET_NUM_PSEUDO_RXRINGS_DEFAULT;
1011 i < rx_grp->max_ring_cnt; i++) {
1012 rx_ringp = &rx_grp->rings[i];
1013 rx_ringp->state = VNET_RXRING_FREE;
1014 rx_ringp->index = i;
1015 }
1016 }
1017
1018 static void
1019 vnet_ring_grp_uninit(vnet_t *vnetp)
1020 {
1021 vnet_pseudo_rx_group_t *rx_grp;
1022 vnet_pseudo_tx_group_t *tx_grp;
1023 kt_did_t tid = 0;
1024
1025 tx_grp = &vnetp->tx_grp[0];
1026
1027 /* Inform tx_notify_thread to exit */
1028 mutex_enter(&tx_grp->flowctl_lock);
1029 if (tx_grp->flowctl_thread != NULL) {
1030 tid = tx_grp->flowctl_thread->t_did;
1031 tx_grp->flowctl_done = B_TRUE;
1032 cv_signal(&tx_grp->flowctl_cv);
1033 }
1034 mutex_exit(&tx_grp->flowctl_lock);
1035 if (tid != 0)
1036 thread_join(tid);
1037
1038 if (tx_grp->rings != NULL) {
1039 ASSERT(tx_grp->ring_cnt == VNET_NUM_PSEUDO_TXRINGS);
1040 kmem_free(tx_grp->rings, sizeof (vnet_pseudo_tx_ring_t) *
1041 tx_grp->ring_cnt);
1042 tx_grp->rings = NULL;
1043 }
1044
1045 rx_grp = &vnetp->rx_grp[0];
1046 if (rx_grp->rings != NULL) {
1047 ASSERT(rx_grp->max_ring_cnt == MAX_RINGS_PER_GROUP);
1048 ASSERT(rx_grp->ring_cnt == VNET_NUM_PSEUDO_RXRINGS_DEFAULT);
1049 kmem_free(rx_grp->rings, sizeof (vnet_pseudo_rx_ring_t) *
1050 rx_grp->max_ring_cnt);
1051 rx_grp->rings = NULL;
1052 }
1053 }
1054
1055 static vnet_pseudo_rx_ring_t *
1056 vnet_alloc_pseudo_rx_ring(vnet_t *vnetp)
1057 {
1058 vnet_pseudo_rx_group_t *rx_grp;
1059 vnet_pseudo_rx_ring_t *rx_ringp;
1060 int index;
1061
1062 rx_grp = &vnetp->rx_grp[0];
1063 WRITE_ENTER(&rx_grp->lock);
1064
1065 if (rx_grp->ring_cnt == rx_grp->max_ring_cnt) {
1066 /* no rings available */
1067 RW_EXIT(&rx_grp->lock);
1068 return (NULL);
1069 }
1070
1071 for (index = VNET_NUM_PSEUDO_RXRINGS_DEFAULT;
1072 index < rx_grp->max_ring_cnt; index++) {
1073 rx_ringp = &rx_grp->rings[index];
1074 if (rx_ringp->state == VNET_RXRING_FREE) {
1075 rx_ringp->state |= VNET_RXRING_INUSE;
1076 rx_grp->ring_cnt++;
1077 break;
1078 }
1079 }
1080
1081 RW_EXIT(&rx_grp->lock);
1082 return (rx_ringp);
1083 }
1084
1085 static void
1086 vnet_free_pseudo_rx_ring(vnet_t *vnetp, vnet_pseudo_rx_ring_t *ringp)
1087 {
1088 vnet_pseudo_rx_group_t *rx_grp;
1089
1090 ASSERT(ringp->index >= VNET_NUM_PSEUDO_RXRINGS_DEFAULT);
1091 rx_grp = &vnetp->rx_grp[0];
1092 WRITE_ENTER(&rx_grp->lock);
1093
1094 if (ringp->state != VNET_RXRING_FREE) {
1095 ringp->state = VNET_RXRING_FREE;
1096 ringp->handle = NULL;
1097 rx_grp->ring_cnt--;
1098 }
1099
1100 RW_EXIT(&rx_grp->lock);
1101 }
1102
1103 /* wrapper function for mac_register() */
1104 static int
1105 vnet_mac_register(vnet_t *vnetp)
1106 {
1107 mac_register_t *macp;
1108 int err;
1109
1110 if ((macp = mac_alloc(MAC_VERSION)) == NULL)
1111 return (DDI_FAILURE);
1112 macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
1113 macp->m_driver = vnetp;
1114 macp->m_dip = vnetp->dip;
1115 macp->m_src_addr = vnetp->curr_macaddr;
1116 macp->m_callbacks = &vnet_m_callbacks;
1117 macp->m_min_sdu = 0;
1118 macp->m_max_sdu = vnetp->mtu;
1119 macp->m_margin = VLAN_TAGSZ;
1120
1121 macp->m_v12n = MAC_VIRT_LEVEL1;
1122
1123 /*
1124 * Finally, we're ready to register ourselves with the MAC layer
1125 * interface; if this succeeds, we're all ready to start()
1126 */
1127 err = mac_register(macp, &vnetp->mh);
1128 mac_free(macp);
1129 return (err == 0 ? DDI_SUCCESS : DDI_FAILURE);
1130 }
1131
1132 /* read the mac address of the device */
1133 static int
1134 vnet_read_mac_address(vnet_t *vnetp)
1135 {
1136 uchar_t *macaddr;
1137 uint32_t size;
1138 int rv;
1139
1140 rv = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, vnetp->dip,
1141 DDI_PROP_DONTPASS, macaddr_propname, &macaddr, &size);
1142 if ((rv != DDI_PROP_SUCCESS) || (size != ETHERADDRL)) {
1143 DWARN(vnetp, "prop_lookup failed(%s) err(%d)\n",
1144 macaddr_propname, rv);
1145 return (DDI_FAILURE);
1146 }
1147 bcopy(macaddr, (caddr_t)vnetp->vendor_addr, ETHERADDRL);
1148 bcopy(macaddr, (caddr_t)vnetp->curr_macaddr, ETHERADDRL);
1149 ddi_prop_free(macaddr);
1150
1151 return (DDI_SUCCESS);
1152 }
1153
1154 static void
1155 vnet_fdb_create(vnet_t *vnetp)
1156 {
1157 char hashname[MAXNAMELEN];
1158
1159 (void) snprintf(hashname, MAXNAMELEN, "vnet%d-fdbhash",
1160 vnetp->instance);
1161 vnetp->fdb_nchains = vnet_fdb_nchains;
1162 vnetp->fdb_hashp = mod_hash_create_ptrhash(hashname, vnetp->fdb_nchains,
1163 mod_hash_null_valdtor, sizeof (void *));
1164 }
1165
1166 static void
1167 vnet_fdb_destroy(vnet_t *vnetp)
1168 {
1169 /* destroy fdb-hash-table */
1170 if (vnetp->fdb_hashp != NULL) {
1171 mod_hash_destroy_hash(vnetp->fdb_hashp);
1172 vnetp->fdb_hashp = NULL;
1173 vnetp->fdb_nchains = 0;
1174 }
1175 }
1176
1177 /*
1178 * Add an entry into the fdb.
1179 */
1180 void
1181 vnet_fdbe_add(vnet_t *vnetp, vnet_res_t *vresp)
1182 {
1183 uint64_t addr = 0;
1184 int rv;
1185
1186 KEY_HASH(addr, vresp->rem_macaddr);
1187
1188 /*
1189 * If the entry being added corresponds to LDC_SERVICE resource,
1190 * that is, vswitch connection, it is added to the hash and also
1191 * the entry is cached, an additional reference count reflects
1192 * this. The HYBRID resource is not added to the hash, but only
1193 * cached, as it is only used for sending out packets for unknown
1194 * unicast destinations.
1195 */
1196 (vresp->type == VIO_NET_RES_LDC_SERVICE) ?
1197 (vresp->refcnt = 1) : (vresp->refcnt = 0);
1198
1199 /*
1200 * Note: duplicate keys will be rejected by mod_hash.
1201 */
1202 if (vresp->type != VIO_NET_RES_HYBRID) {
1203 rv = mod_hash_insert(vnetp->fdb_hashp, (mod_hash_key_t)addr,
1204 (mod_hash_val_t)vresp);
1205 if (rv != 0) {
1206 DWARN(vnetp, "Duplicate macaddr key(%lx)\n", addr);
1207 return;
1208 }
1209 }
1210
1211 if (vresp->type == VIO_NET_RES_LDC_SERVICE) {
1212 /* Cache the fdb entry to vsw-port */
1213 WRITE_ENTER(&vnetp->vsw_fp_rw);
1214 if (vnetp->vsw_fp == NULL)
1215 vnetp->vsw_fp = vresp;
1216 RW_EXIT(&vnetp->vsw_fp_rw);
1217 } else if (vresp->type == VIO_NET_RES_HYBRID) {
1218 /* Cache the fdb entry to hybrid resource */
1219 WRITE_ENTER(&vnetp->vsw_fp_rw);
1220 if (vnetp->hio_fp == NULL)
1221 vnetp->hio_fp = vresp;
1222 RW_EXIT(&vnetp->vsw_fp_rw);
1223 }
1224 }
1225
1226 /*
1227 * Remove an entry from fdb.
1228 */
1229 static void
1230 vnet_fdbe_del(vnet_t *vnetp, vnet_res_t *vresp)
1231 {
1232 uint64_t addr = 0;
1233 int rv;
1234 uint32_t refcnt;
1235 vnet_res_t *tmp;
1236
1237 KEY_HASH(addr, vresp->rem_macaddr);
1238
1239 /*
1240 * Remove the entry from fdb hash table.
1241 * This prevents further references to this fdb entry.
1242 */
1243 if (vresp->type != VIO_NET_RES_HYBRID) {
1244 rv = mod_hash_remove(vnetp->fdb_hashp, (mod_hash_key_t)addr,
1245 (mod_hash_val_t *)&tmp);
1246 if (rv != 0) {
1247 /*
1248 * As the resources are added to the hash only
1249 * after they are started, this can occur if
1250 * a resource unregisters before it is ever started.
1251 */
1252 return;
1253 }
1254 }
1255
1256 if (vresp->type == VIO_NET_RES_LDC_SERVICE) {
1257 WRITE_ENTER(&vnetp->vsw_fp_rw);
1258
1259 ASSERT(tmp == vnetp->vsw_fp);
1260 vnetp->vsw_fp = NULL;
1261
1262 RW_EXIT(&vnetp->vsw_fp_rw);
1263 } else if (vresp->type == VIO_NET_RES_HYBRID) {
1264 WRITE_ENTER(&vnetp->vsw_fp_rw);
1265
1266 vnetp->hio_fp = NULL;
1267
1268 RW_EXIT(&vnetp->vsw_fp_rw);
1269 }
1270
1271 /*
1272 * If there are threads already ref holding before the entry was
1273 * removed from hash table, then wait for ref count to drop to zero.
1274 */
1275 (vresp->type == VIO_NET_RES_LDC_SERVICE) ?
1276 (refcnt = 1) : (refcnt = 0);
1277 while (vresp->refcnt > refcnt) {
1278 delay(drv_usectohz(vnet_fdbe_refcnt_delay));
1279 }
1280 }
1281
1282 /*
1283 * Search fdb for a given mac address. If an entry is found, hold
1284 * a reference to it and return the entry; else returns NULL.
1285 */
1286 static vnet_res_t *
1287 vnet_fdbe_find(vnet_t *vnetp, struct ether_addr *addrp)
1288 {
1289 uint64_t key = 0;
1290 vnet_res_t *vresp;
1291 int rv;
1292
1293 KEY_HASH(key, addrp->ether_addr_octet);
1294
1295 rv = mod_hash_find_cb(vnetp->fdb_hashp, (mod_hash_key_t)key,
1296 (mod_hash_val_t *)&vresp, vnet_fdbe_find_cb);
1297
1298 if (rv != 0)
1299 return (NULL);
1300
1301 return (vresp);
1302 }
1303
1304 /*
1305 * Callback function provided to mod_hash_find_cb(). After finding the fdb
1306 * entry corresponding to the key (macaddr), this callback will be invoked by
1307 * mod_hash_find_cb() to atomically increment the reference count on the fdb
1308 * entry before returning the found entry.
1309 */
1310 static void
1311 vnet_fdbe_find_cb(mod_hash_key_t key, mod_hash_val_t val)
1312 {
1313 _NOTE(ARGUNUSED(key))
1314 VNET_FDBE_REFHOLD((vnet_res_t *)val);
1315 }
1316
1317 /*
1318 * Frames received that are tagged with the pvid of the vnet device must be
1319 * untagged before sending up the stack. This function walks the chain of rx
1320 * frames, untags any such frames and returns the updated chain.
1321 *
1322 * Arguments:
1323 * pvid: pvid of the vnet device for which packets are being received
1324 * mp: head of pkt chain to be validated and untagged
1325 *
1326 * Returns:
1327 * mp: head of updated chain of packets
1328 */
1329 static void
1330 vnet_rx_frames_untag(uint16_t pvid, mblk_t **mp)
1331 {
1332 struct ether_vlan_header *evhp;
1333 mblk_t *bp;
1334 mblk_t *bpt;
1335 mblk_t *bph;
1336 mblk_t *bpn;
1337
1338 bpn = bph = bpt = NULL;
1339
1340 for (bp = *mp; bp != NULL; bp = bpn) {
1341
1342 bpn = bp->b_next;
1343 bp->b_next = bp->b_prev = NULL;
1344
1345 evhp = (struct ether_vlan_header *)bp->b_rptr;
1346
1347 if (ntohs(evhp->ether_tpid) == ETHERTYPE_VLAN &&
1348 VLAN_ID(ntohs(evhp->ether_tci)) == pvid) {
1349
1350 bp = vnet_vlan_remove_tag(bp);
1351 if (bp == NULL) {
1352 continue;
1353 }
1354
1355 }
1356
1357 /* build a chain of processed packets */
1358 if (bph == NULL) {
1359 bph = bpt = bp;
1360 } else {
1361 bpt->b_next = bp;
1362 bpt = bp;
1363 }
1364
1365 }
1366
1367 *mp = bph;
1368 }
1369
1370 static void
1371 vnet_rx(vio_net_handle_t vrh, mblk_t *mp)
1372 {
1373 vnet_res_t *vresp = (vnet_res_t *)vrh;
1374 vnet_t *vnetp = vresp->vnetp;
1375 vnet_pseudo_rx_ring_t *ringp;
1376
1377 if ((vnetp == NULL) || (vnetp->mh == 0)) {
1378 freemsgchain(mp);
1379 return;
1380 }
1381
1382 ringp = vresp->rx_ringp;
1383 mac_rx_ring(vnetp->mh, ringp->handle, mp, ringp->gen_num);
1384 }
1385
1386 void
1387 vnet_tx_update(vio_net_handle_t vrh)
1388 {
1389 vnet_res_t *vresp = (vnet_res_t *)vrh;
1390 vnet_t *vnetp = vresp->vnetp;
1391 vnet_pseudo_tx_ring_t *tx_ringp;
1392 vnet_pseudo_tx_group_t *tx_grp;
1393 int i;
1394
1395 if (vnetp == NULL || vnetp->mh == NULL) {
1396 return;
1397 }
1398
1399 /*
1400 * Currently, the tx hwring API (used to access rings that belong to
1401 * a Hybrid IO resource) does not provide us a per ring flow ctrl
1402 * update; also the pseudo rings are shared by the ports/ldcs in the
1403 * vgen layer. Thus we can't figure out which pseudo ring is being
1404 * re-enabled for transmits. To work around this, when we get a tx
1405 * restart notification from below, we simply propagate that to all
1406 * the tx pseudo rings registered with the mac layer above.
1407 *
1408 * There are a couple of side effects with this approach, but they are
1409 * not harmful, as outlined below:
1410 *
1411 * A) We might send an invalid ring_update() for a ring that is not
1412 * really flow controlled. This will not have any effect in the mac
1413 * layer and packets will continue to be transmitted on that ring.
1414 *
1415 * B) We might end up clearing the flow control in the mac layer for
1416 * a ring that is still flow controlled in the underlying resource.
1417 * This will result in the mac layer restarting transmit, only to be
1418 * flow controlled again on that ring.
1419 */
1420 tx_grp = &vnetp->tx_grp[0];
1421 for (i = 0; i < tx_grp->ring_cnt; i++) {
1422 tx_ringp = &tx_grp->rings[i];
1423 mac_tx_ring_update(vnetp->mh, tx_ringp->handle);
1424 }
1425 }
1426
1427 /*
1428 * vnet_tx_notify_thread:
1429 *
1430 * vnet_tx_ring_update() callback function wakes up this thread when
1431 * it gets called. This thread will call mac_tx_ring_update() to
1432 * notify upper mac of flow control getting relieved. Note that
1433 * vnet_tx_ring_update() cannot call mac_tx_ring_update() directly
1434 * because vnet_tx_ring_update() is called from lower mac with
1435 * mi_rw_lock held and mac_tx_ring_update() would also try to grab
1436 * the same lock.
1437 */
1438 static void
1439 vnet_tx_notify_thread(void *arg)
1440 {
1441 callb_cpr_t cprinfo;
1442 vnet_pseudo_tx_group_t *tx_grp = (vnet_pseudo_tx_group_t *)arg;
1443 vnet_pseudo_tx_ring_t *tx_ringp;
1444 vnet_t *vnetp;
1445 int i;
1446
1447 CALLB_CPR_INIT(&cprinfo, &tx_grp->flowctl_lock, callb_generic_cpr,
1448 "vnet_tx_notify_thread");
1449
1450 mutex_enter(&tx_grp->flowctl_lock);
1451 while (!tx_grp->flowctl_done) {
1452 CALLB_CPR_SAFE_BEGIN(&cprinfo);
1453 cv_wait(&tx_grp->flowctl_cv, &tx_grp->flowctl_lock);
1454 CALLB_CPR_SAFE_END(&cprinfo, &tx_grp->flowctl_lock);
1455
1456 for (i = 0; i < tx_grp->ring_cnt; i++) {
1457 tx_ringp = &tx_grp->rings[i];
1458 if (tx_ringp->woken_up) {
1459 tx_ringp->woken_up = B_FALSE;
1460 vnetp = tx_ringp->vnetp;
1461 mac_tx_ring_update(vnetp->mh, tx_ringp->handle);
1462 }
1463 }
1464 }
1465 /*
1466 * The tx_grp is being destroyed, exit the thread.
1467 */
1468 tx_grp->flowctl_thread = NULL;
1469 CALLB_CPR_EXIT(&cprinfo);
1470 thread_exit();
1471 }
1472
1473 void
1474 vnet_tx_ring_update(void *arg1, uintptr_t arg2)
1475 {
1476 vnet_t *vnetp = (vnet_t *)arg1;
1477 vnet_pseudo_tx_group_t *tx_grp;
1478 vnet_pseudo_tx_ring_t *tx_ringp;
1479 int i;
1480
1481 tx_grp = &vnetp->tx_grp[0];
1482 for (i = 0; i < tx_grp->ring_cnt; i++) {
1483 tx_ringp = &tx_grp->rings[i];
1484 if (tx_ringp->hw_rh == (mac_ring_handle_t)arg2) {
1485 mutex_enter(&tx_grp->flowctl_lock);
1486 tx_ringp->woken_up = B_TRUE;
1487 cv_signal(&tx_grp->flowctl_cv);
1488 mutex_exit(&tx_grp->flowctl_lock);
1489 break;
1490 }
1491 }
1492 }
1493
1494 /*
1495 * Update the new mtu of vnet into the mac layer. First check if the device has
1496 * been plumbed and if so fail the mtu update. Returns 0 on success.
1497 */
1498 int
1499 vnet_mtu_update(vnet_t *vnetp, uint32_t mtu)
1500 {
1501 int rv;
1502
1503 if (vnetp == NULL || vnetp->mh == NULL) {
1504 return (EINVAL);
1505 }
1506
1507 WRITE_ENTER(&vnetp->vrwlock);
1508
1509 if (vnetp->flags & VNET_STARTED) {
1510 RW_EXIT(&vnetp->vrwlock);
1511 cmn_err(CE_NOTE, "!vnet%d: Unable to process mtu "
1512 "update as the device is plumbed\n",
1513 vnetp->instance);
1514 return (EBUSY);
1515 }
1516
1517 /* update mtu in the mac layer */
1518 rv = mac_maxsdu_update(vnetp->mh, mtu);
1519 if (rv != 0) {
1520 RW_EXIT(&vnetp->vrwlock);
1521 cmn_err(CE_NOTE,
1522 "!vnet%d: Unable to update mtu with mac layer\n",
1523 vnetp->instance);
1524 return (EIO);
1525 }
1526
1527 vnetp->mtu = mtu;
1528
1529 RW_EXIT(&vnetp->vrwlock);
1530
1531 return (0);
1532 }
1533
1534 /*
1535 * Update the link state of vnet to the mac layer.
1536 */
1537 void
1538 vnet_link_update(vnet_t *vnetp, link_state_t link_state)
1539 {
1540 if (vnetp == NULL || vnetp->mh == NULL) {
1541 return;
1542 }
1543
1544 WRITE_ENTER(&vnetp->vrwlock);
1545 if (vnetp->link_state == link_state) {
1546 RW_EXIT(&vnetp->vrwlock);
1547 return;
1548 }
1549 vnetp->link_state = link_state;
1550 RW_EXIT(&vnetp->vrwlock);
1551
1552 mac_link_update(vnetp->mh, link_state);
1553 }
1554
1555 /*
1556 * vio_net_resource_reg -- An interface called to register a resource
1557 * with vnet.
1558 * macp -- a GLDv3 mac_register that has all the details of
1559 * a resource and its callbacks etc.
1560 * type -- resource type.
1561 * local_macaddr -- resource's MAC address. This is used to
1562 * associate a resource with a corresponding vnet.
1563 * remote_macaddr -- remote side MAC address. This is ignored for
1564 * the Hybrid resources.
1565 * vhp -- A handle returned to the caller.
1566 * vcb -- A set of callbacks provided to the callers.
1567 */
1568 int vio_net_resource_reg(mac_register_t *macp, vio_net_res_type_t type,
1569 ether_addr_t local_macaddr, ether_addr_t rem_macaddr, vio_net_handle_t *vhp,
1570 vio_net_callbacks_t *vcb)
1571 {
1572 vnet_t *vnetp;
1573 vnet_res_t *vresp;
1574
1575 vresp = kmem_zalloc(sizeof (vnet_res_t), KM_SLEEP);
1576 ether_copy(local_macaddr, vresp->local_macaddr);
1577 ether_copy(rem_macaddr, vresp->rem_macaddr);
1578 vresp->type = type;
1579 bcopy(macp, &vresp->macreg, sizeof (mac_register_t));
1580
1581 DBG1(NULL, "Resource Registerig type=0%X\n", type);
1582
1583 READ_ENTER(&vnet_rw);
1584 vnetp = vnet_headp;
1585 while (vnetp != NULL) {
1586 if (VNET_MATCH_RES(vresp, vnetp)) {
1587 vresp->vnetp = vnetp;
1588
1589 /* Setup kstats for hio resource */
1590 if (vresp->type == VIO_NET_RES_HYBRID) {
1591 vresp->ksp = vnet_hio_setup_kstats(DRV_NAME,
1592 "hio", vresp);
1593 if (vresp->ksp == NULL) {
1594 cmn_err(CE_NOTE, "!vnet%d: Cannot "
1595 "create kstats for hio resource",
1596 vnetp->instance);
1597 }
1598 }
1599 vnet_add_resource(vnetp, vresp);
1600 break;
1601 }
1602 vnetp = vnetp->nextp;
1603 }
1604 RW_EXIT(&vnet_rw);
1605 if (vresp->vnetp == NULL) {
1606 DWARN(NULL, "No vnet instance");
1607 kmem_free(vresp, sizeof (vnet_res_t));
1608 return (ENXIO);
1609 }
1610
1611 *vhp = vresp;
1612 vcb->vio_net_rx_cb = vnet_rx;
1613 vcb->vio_net_tx_update = vnet_tx_update;
1614 vcb->vio_net_report_err = vnet_handle_res_err;
1615
1616 /* Bind the resource to pseudo ring(s) */
1617 if (vnet_bind_rings(vresp) != 0) {
1618 (void) vnet_rem_resource(vnetp, vresp);
1619 vnet_hio_destroy_kstats(vresp->ksp);
1620 KMEM_FREE(vresp);
1621 return (1);
1622 }
1623
1624 /* Dispatch a task to start resources */
1625 vnet_dispatch_res_task(vnetp);
1626 return (0);
1627 }
1628
1629 /*
1630 * vio_net_resource_unreg -- An interface to unregister a resource.
1631 */
1632 void
1633 vio_net_resource_unreg(vio_net_handle_t vhp)
1634 {
1635 vnet_res_t *vresp = (vnet_res_t *)vhp;
1636 vnet_t *vnetp = vresp->vnetp;
1637
1638 DBG1(NULL, "Resource Registerig hdl=0x%p", vhp);
1639
1640 ASSERT(vnetp != NULL);
1641 /*
1642 * Remove the resource from fdb; this ensures
1643 * there are no references to the resource.
1644 */
1645 vnet_fdbe_del(vnetp, vresp);
1646
1647 vnet_unbind_rings(vresp);
1648
1649 /* Now remove the resource from the list */
1650 (void) vnet_rem_resource(vnetp, vresp);
1651
1652 vnet_hio_destroy_kstats(vresp->ksp);
1653 KMEM_FREE(vresp);
1654 }
1655
1656 static void
1657 vnet_add_resource(vnet_t *vnetp, vnet_res_t *vresp)
1658 {
1659 WRITE_ENTER(&vnetp->vrwlock);
1660 vresp->nextp = vnetp->vres_list;
1661 vnetp->vres_list = vresp;
1662 RW_EXIT(&vnetp->vrwlock);
1663 }
1664
1665 static vnet_res_t *
1666 vnet_rem_resource(vnet_t *vnetp, vnet_res_t *vresp)
1667 {
1668 vnet_res_t *vrp;
1669
1670 WRITE_ENTER(&vnetp->vrwlock);
1671 if (vresp == vnetp->vres_list) {
1672 vnetp->vres_list = vresp->nextp;
1673 } else {
1674 vrp = vnetp->vres_list;
1675 while (vrp->nextp != NULL) {
1676 if (vrp->nextp == vresp) {
1677 vrp->nextp = vresp->nextp;
1678 break;
1679 }
1680 vrp = vrp->nextp;
1681 }
1682 }
1683 vresp->vnetp = NULL;
1684 vresp->nextp = NULL;
1685
1686 RW_EXIT(&vnetp->vrwlock);
1687
1688 return (vresp);
1689 }
1690
1691 /*
1692 * vnet_dds_rx -- an interface called by vgen to DDS messages.
1693 */
1694 void
1695 vnet_dds_rx(void *arg, void *dmsg)
1696 {
1697 vnet_t *vnetp = arg;
1698 vdds_process_dds_msg(vnetp, dmsg);
1699 }
1700
1701 /*
1702 * vnet_send_dds_msg -- An interface provided to DDS to send
1703 * DDS messages. This simply sends meessages via vgen.
1704 */
1705 int
1706 vnet_send_dds_msg(vnet_t *vnetp, void *dmsg)
1707 {
1708 int rv;
1709
1710 if (vnetp->vgenhdl != NULL) {
1711 rv = vgen_dds_tx(vnetp->vgenhdl, dmsg);
1712 }
1713 return (rv);
1714 }
1715
1716 /*
1717 * vnet_cleanup_hio -- an interface called by vgen to cleanup hio resources.
1718 */
1719 void
1720 vnet_dds_cleanup_hio(vnet_t *vnetp)
1721 {
1722 vdds_cleanup_hio(vnetp);
1723 }
1724
1725 /*
1726 * vnet_handle_res_err -- A callback function called by a resource
1727 * to report an error. For example, vgen can call to report
1728 * an LDC down/reset event. This will trigger cleanup of associated
1729 * Hybrid resource.
1730 */
1731 /* ARGSUSED */
1732 static void
1733 vnet_handle_res_err(vio_net_handle_t vrh, vio_net_err_val_t err)
1734 {
1735 vnet_res_t *vresp = (vnet_res_t *)vrh;
1736 vnet_t *vnetp = vresp->vnetp;
1737
1738 if (vnetp == NULL) {
1739 return;
1740 }
1741 if ((vresp->type != VIO_NET_RES_LDC_SERVICE) &&
1742 (vresp->type != VIO_NET_RES_HYBRID)) {
1743 return;
1744 }
1745
1746 vdds_cleanup_hio(vnetp);
1747 }
1748
1749 /*
1750 * vnet_dispatch_res_task -- A function to dispatch tasks start resources.
1751 */
1752 static void
1753 vnet_dispatch_res_task(vnet_t *vnetp)
1754 {
1755 int rv;
1756
1757 /*
1758 * Dispatch the task. It could be the case that vnetp->flags does
1759 * not have VNET_STARTED set. This is ok as vnet_rest_start_task()
1760 * can abort the task when the task is started. See related comments
1761 * in vnet_m_stop() and vnet_stop_resources().
1762 */
1763 rv = ddi_taskq_dispatch(vnetp->taskqp, vnet_res_start_task,
1764 vnetp, DDI_NOSLEEP);
1765 if (rv != DDI_SUCCESS) {
1766 cmn_err(CE_WARN,
1767 "vnet%d:Can't dispatch start resource task",
1768 vnetp->instance);
1769 }
1770 }
1771
1772 /*
1773 * vnet_res_start_task -- A taskq callback function that starts a resource.
1774 */
1775 static void
1776 vnet_res_start_task(void *arg)
1777 {
1778 vnet_t *vnetp = arg;
1779
1780 WRITE_ENTER(&vnetp->vrwlock);
1781 if (vnetp->flags & VNET_STARTED) {
1782 vnet_start_resources(vnetp);
1783 }
1784 RW_EXIT(&vnetp->vrwlock);
1785 }
1786
1787 /*
1788 * vnet_start_resources -- starts all resources associated with
1789 * a vnet.
1790 */
1791 static void
1792 vnet_start_resources(vnet_t *vnetp)
1793 {
1794 mac_register_t *macp;
1795 mac_callbacks_t *cbp;
1796 vnet_res_t *vresp;
1797 int rv;
1798
1799 DBG1(vnetp, "enter\n");
1800
1801 ASSERT(RW_WRITE_HELD(&vnetp->vrwlock));
1802
1803 for (vresp = vnetp->vres_list; vresp != NULL; vresp = vresp->nextp) {
1804 /* skip if it is already started */
1805 if (vresp->flags & VNET_STARTED) {
1806 continue;
1807 }
1808 macp = &vresp->macreg;
1809 cbp = macp->m_callbacks;
1810 rv = cbp->mc_start(macp->m_driver);
1811 if (rv == 0) {
1812 /*
1813 * Successfully started the resource, so now
1814 * add it to the fdb.
1815 */
1816 vresp->flags |= VNET_STARTED;
1817 vnet_fdbe_add(vnetp, vresp);
1818 }
1819 }
1820
1821 DBG1(vnetp, "exit\n");
1822
1823 }
1824
1825 /*
1826 * vnet_stop_resources -- stop all resources associated with a vnet.
1827 */
1828 static void
1829 vnet_stop_resources(vnet_t *vnetp)
1830 {
1831 vnet_res_t *vresp;
1832 mac_register_t *macp;
1833 mac_callbacks_t *cbp;
1834
1835 DBG1(vnetp, "enter\n");
1836
1837 ASSERT(RW_WRITE_HELD(&vnetp->vrwlock));
1838
1839 for (vresp = vnetp->vres_list; vresp != NULL; ) {
1840 if (vresp->flags & VNET_STARTED) {
1841 /*
1842 * Release the lock while invoking mc_stop() of the
1843 * underlying resource. We hold a reference to this
1844 * resource to prevent being removed from the list in
1845 * vio_net_resource_unreg(). Note that new resources
1846 * can be added to the head of the list while the lock
1847 * is released, but they won't be started, as
1848 * VNET_STARTED flag has been cleared for the vnet
1849 * device in vnet_m_stop(). Also, while the lock is
1850 * released a resource could be removed from the list
1851 * in vio_net_resource_unreg(); but that is ok, as we
1852 * re-acquire the lock and only then access the forward
1853 * link (vresp->nextp) to continue with the next
1854 * resource.
1855 */
1856 vresp->flags &= ~VNET_STARTED;
1857 vresp->flags |= VNET_STOPPING;
1858 macp = &vresp->macreg;
1859 cbp = macp->m_callbacks;
1860 VNET_FDBE_REFHOLD(vresp);
1861 RW_EXIT(&vnetp->vrwlock);
1862
1863 cbp->mc_stop(macp->m_driver);
1864
1865 WRITE_ENTER(&vnetp->vrwlock);
1866 vresp->flags &= ~VNET_STOPPING;
1867 VNET_FDBE_REFRELE(vresp);
1868 }
1869 vresp = vresp->nextp;
1870 }
1871 DBG1(vnetp, "exit\n");
1872 }
1873
1874 /*
1875 * Setup kstats for the HIO statistics.
1876 * NOTE: the synchronization for the statistics is the
1877 * responsibility of the caller.
1878 */
1879 kstat_t *
1880 vnet_hio_setup_kstats(char *ks_mod, char *ks_name, vnet_res_t *vresp)
1881 {
1882 kstat_t *ksp;
1883 vnet_t *vnetp = vresp->vnetp;
1884 vnet_hio_kstats_t *hiokp;
1885 size_t size;
1886
1887 ASSERT(vnetp != NULL);
1888 size = sizeof (vnet_hio_kstats_t) / sizeof (kstat_named_t);
1889 ksp = kstat_create(ks_mod, vnetp->instance, ks_name, "net",
1890 KSTAT_TYPE_NAMED, size, 0);
1891 if (ksp == NULL) {
1892 return (NULL);
1893 }
1894
1895 hiokp = (vnet_hio_kstats_t *)ksp->ks_data;
1896 kstat_named_init(&hiokp->ipackets, "ipackets",
1897 KSTAT_DATA_ULONG);
1898 kstat_named_init(&hiokp->ierrors, "ierrors",
1899 KSTAT_DATA_ULONG);
1900 kstat_named_init(&hiokp->opackets, "opackets",
1901 KSTAT_DATA_ULONG);
1902 kstat_named_init(&hiokp->oerrors, "oerrors",
1903 KSTAT_DATA_ULONG);
1904
1905
1906 /* MIB II kstat variables */
1907 kstat_named_init(&hiokp->rbytes, "rbytes",
1908 KSTAT_DATA_ULONG);
1909 kstat_named_init(&hiokp->obytes, "obytes",
1910 KSTAT_DATA_ULONG);
1911 kstat_named_init(&hiokp->multircv, "multircv",
1912 KSTAT_DATA_ULONG);
1913 kstat_named_init(&hiokp->multixmt, "multixmt",
1914 KSTAT_DATA_ULONG);
1915 kstat_named_init(&hiokp->brdcstrcv, "brdcstrcv",
1916 KSTAT_DATA_ULONG);
1917 kstat_named_init(&hiokp->brdcstxmt, "brdcstxmt",
1918 KSTAT_DATA_ULONG);
1919 kstat_named_init(&hiokp->norcvbuf, "norcvbuf",
1920 KSTAT_DATA_ULONG);
1921 kstat_named_init(&hiokp->noxmtbuf, "noxmtbuf",
1922 KSTAT_DATA_ULONG);
1923
1924 ksp->ks_update = vnet_hio_update_kstats;
1925 ksp->ks_private = (void *)vresp;
1926 kstat_install(ksp);
1927 return (ksp);
1928 }
1929
1930 /*
1931 * Destroy kstats.
1932 */
1933 static void
1934 vnet_hio_destroy_kstats(kstat_t *ksp)
1935 {
1936 if (ksp != NULL)
1937 kstat_delete(ksp);
1938 }
1939
1940 /*
1941 * Update the kstats.
1942 */
1943 static int
1944 vnet_hio_update_kstats(kstat_t *ksp, int rw)
1945 {
1946 vnet_t *vnetp;
1947 vnet_res_t *vresp;
1948 vnet_hio_stats_t statsp;
1949 vnet_hio_kstats_t *hiokp;
1950
1951 vresp = (vnet_res_t *)ksp->ks_private;
1952 vnetp = vresp->vnetp;
1953
1954 bzero(&statsp, sizeof (vnet_hio_stats_t));
1955
1956 READ_ENTER(&vnetp->vsw_fp_rw);
1957 if (vnetp->hio_fp == NULL) {
1958 /* not using hio resources, just return */
1959 RW_EXIT(&vnetp->vsw_fp_rw);
1960 return (0);
1961 }
1962 VNET_FDBE_REFHOLD(vnetp->hio_fp);
1963 RW_EXIT(&vnetp->vsw_fp_rw);
1964 vnet_hio_get_stats(vnetp->hio_fp, &statsp);
1965 VNET_FDBE_REFRELE(vnetp->hio_fp);
1966
1967 hiokp = (vnet_hio_kstats_t *)ksp->ks_data;
1968
1969 if (rw == KSTAT_READ) {
1970 /* Link Input/Output stats */
1971 hiokp->ipackets.value.ul = (uint32_t)statsp.ipackets;
1972 hiokp->ipackets64.value.ull = statsp.ipackets;
1973 hiokp->ierrors.value.ul = statsp.ierrors;
1974 hiokp->opackets.value.ul = (uint32_t)statsp.opackets;
1975 hiokp->opackets64.value.ull = statsp.opackets;
1976 hiokp->oerrors.value.ul = statsp.oerrors;
1977
1978 /* MIB II kstat variables */
1979 hiokp->rbytes.value.ul = (uint32_t)statsp.rbytes;
1980 hiokp->rbytes64.value.ull = statsp.rbytes;
1981 hiokp->obytes.value.ul = (uint32_t)statsp.obytes;
1982 hiokp->obytes64.value.ull = statsp.obytes;
1983 hiokp->multircv.value.ul = statsp.multircv;
1984 hiokp->multixmt.value.ul = statsp.multixmt;
1985 hiokp->brdcstrcv.value.ul = statsp.brdcstrcv;
1986 hiokp->brdcstxmt.value.ul = statsp.brdcstxmt;
1987 hiokp->norcvbuf.value.ul = statsp.norcvbuf;
1988 hiokp->noxmtbuf.value.ul = statsp.noxmtbuf;
1989 } else {
1990 return (EACCES);
1991 }
1992
1993 return (0);
1994 }
1995
1996 static void
1997 vnet_hio_get_stats(vnet_res_t *vresp, vnet_hio_stats_t *statsp)
1998 {
1999 mac_register_t *macp;
2000 mac_callbacks_t *cbp;
2001 uint64_t val;
2002 int stat;
2003
2004 /*
2005 * get the specified statistics from the underlying nxge.
2006 */
2007 macp = &vresp->macreg;
2008 cbp = macp->m_callbacks;
2009 for (stat = MAC_STAT_MIN; stat < MAC_STAT_OVERFLOWS; stat++) {
2010 if (cbp->mc_getstat(macp->m_driver, stat, &val) == 0) {
2011 switch (stat) {
2012 case MAC_STAT_IPACKETS:
2013 statsp->ipackets = val;
2014 break;
2015
2016 case MAC_STAT_IERRORS:
2017 statsp->ierrors = val;
2018 break;
2019
2020 case MAC_STAT_OPACKETS:
2021 statsp->opackets = val;
2022 break;
2023
2024 case MAC_STAT_OERRORS:
2025 statsp->oerrors = val;
2026 break;
2027
2028 case MAC_STAT_RBYTES:
2029 statsp->rbytes = val;
2030 break;
2031
2032 case MAC_STAT_OBYTES:
2033 statsp->obytes = val;
2034 break;
2035
2036 case MAC_STAT_MULTIRCV:
2037 statsp->multircv = val;
2038 break;
2039
2040 case MAC_STAT_MULTIXMT:
2041 statsp->multixmt = val;
2042 break;
2043
2044 case MAC_STAT_BRDCSTRCV:
2045 statsp->brdcstrcv = val;
2046 break;
2047
2048 case MAC_STAT_BRDCSTXMT:
2049 statsp->brdcstxmt = val;
2050 break;
2051
2052 case MAC_STAT_NOXMTBUF:
2053 statsp->noxmtbuf = val;
2054 break;
2055
2056 case MAC_STAT_NORCVBUF:
2057 statsp->norcvbuf = val;
2058 break;
2059
2060 default:
2061 /*
2062 * parameters not interested.
2063 */
2064 break;
2065 }
2066 }
2067 }
2068 }
2069
2070 static boolean_t
2071 vnet_m_capab(void *arg, mac_capab_t cap, void *cap_data)
2072 {
2073 vnet_t *vnetp = (vnet_t *)arg;
2074
2075 if (vnetp == NULL) {
2076 return (0);
2077 }
2078
2079 switch (cap) {
2080
2081 case MAC_CAPAB_RINGS: {
2082
2083 mac_capab_rings_t *cap_rings = cap_data;
2084 /*
2085 * Rings Capability Notes:
2086 * We advertise rings to make use of the rings framework in
2087 * gldv3 mac layer, to improve the performance. This is
2088 * specifically needed when a Hybrid resource (with multiple
2089 * tx/rx hardware rings) is assigned to a vnet device. We also
2090 * leverage this for the normal case when no Hybrid resource is
2091 * assigned.
2092 *
2093 * Ring Allocation:
2094 * - TX path:
2095 * We expose a pseudo ring group with 2 pseudo tx rings (as
2096 * currently HybridIO exports only 2 rings) In the normal case,
2097 * transmit traffic that comes down to the driver through the
2098 * mri_tx (vnet_tx_ring_send()) entry point goes through the
2099 * distributed switching algorithm in vnet and gets transmitted
2100 * over a port/LDC in the vgen layer to either the vswitch or a
2101 * peer vnet. If and when a Hybrid resource is assigned to the
2102 * vnet, we obtain the tx ring information of the Hybrid device
2103 * (nxge) and map the pseudo rings 1:1 to the 2 hw tx rings.
2104 * Traffic being sent over the Hybrid resource by the mac layer
2105 * gets spread across both hw rings, as they are mapped to the
2106 * 2 pseudo tx rings in vnet.
2107 *
2108 * - RX path:
2109 * We expose a pseudo ring group with 3 pseudo rx rings (static
2110 * rings) initially. The first (default) pseudo rx ring is
2111 * reserved for the resource that connects to the vswitch
2112 * service. The next 2 rings are reserved for a Hybrid resource
2113 * that may be assigned to the vnet device. If and when a
2114 * Hybrid resource is assigned to the vnet, we obtain the rx
2115 * ring information of the Hybrid device (nxge) and map these
2116 * pseudo rings 1:1 to the 2 hw rx rings. For each additional
2117 * resource that connects to a peer vnet, we dynamically
2118 * allocate a pseudo rx ring and map it to that resource, when
2119 * the resource gets added; and the pseudo rx ring is
2120 * dynamically registered with the upper mac layer. We do the
2121 * reverse and unregister the ring with the mac layer when
2122 * the resource gets removed.
2123 *
2124 * Synchronization notes:
2125 * We don't need any lock to protect members of ring structure,
2126 * specifically ringp->hw_rh, in either the TX or the RX ring,
2127 * as explained below.
2128 * - TX ring:
2129 * ring->hw_rh is initialized only when a Hybrid resource is
2130 * associated; and gets referenced only in vnet_hio_tx(). The
2131 * Hybrid resource itself is available in fdb only after tx
2132 * hwrings are found and mapped; i.e, in vio_net_resource_reg()
2133 * we call vnet_bind_rings() first and then call
2134 * vnet_start_resources() which adds an entry to fdb. For
2135 * traffic going over LDC resources, we don't reference
2136 * ring->hw_rh at all.
2137 * - RX ring:
2138 * For rings mapped to Hybrid resource ring->hw_rh is
2139 * initialized and only then do we add the rx callback for
2140 * the underlying Hybrid resource; we disable callbacks before
2141 * we unmap ring->hw_rh. For rings mapped to LDC resources, we
2142 * stop the rx callbacks (in vgen) before we remove ring->hw_rh
2143 * (vio_net_resource_unreg()).
2144 * Also, we access ring->hw_rh in vnet_rx_ring_stat().
2145 * Note that for rings mapped to Hybrid resource, though the
2146 * rings are statically registered with the mac layer, its
2147 * hardware ring mapping (ringp->hw_rh) can be torn down in
2148 * vnet_unbind_hwrings() while the kstat operation is in
2149 * progress. To protect against this, we hold a reference to
2150 * the resource in FDB; this ensures that the thread in
2151 * vio_net_resource_unreg() waits for the reference to be
2152 * dropped before unbinding the ring.
2153 *
2154 * We don't need to do this for rings mapped to LDC resources.
2155 * These rings are registered/unregistered dynamically with
2156 * the mac layer and so any attempt to unregister the ring
2157 * while kstat operation is in progress will block in
2158 * mac_group_rem_ring(). Thus implicitly protects the
2159 * resource (ringp->hw_rh) from disappearing.
2160 */
2161
2162 if (cap_rings->mr_type == MAC_RING_TYPE_RX) {
2163 cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC;
2164
2165 /*
2166 * The ring_cnt for rx grp is initialized in
2167 * vnet_ring_grp_init(). Later, the ring_cnt gets
2168 * updated dynamically whenever LDC resources are added
2169 * or removed.
2170 */
2171 cap_rings->mr_rnum = vnetp->rx_grp[0].ring_cnt;
2172 cap_rings->mr_rget = vnet_get_ring;
2173
2174 cap_rings->mr_gnum = VNET_NUM_PSEUDO_GROUPS;
2175 cap_rings->mr_gget = vnet_get_group;
2176 cap_rings->mr_gaddring = NULL;
2177 cap_rings->mr_gremring = NULL;
2178 } else {
2179 cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC;
2180
2181 /*
2182 * The ring_cnt for tx grp is initialized in
2183 * vnet_ring_grp_init() and remains constant, as we
2184 * do not support dymanic tx rings for now.
2185 */
2186 cap_rings->mr_rnum = vnetp->tx_grp[0].ring_cnt;
2187 cap_rings->mr_rget = vnet_get_ring;
2188
2189 /*
2190 * Transmit rings are not grouped; i.e, the number of
2191 * transmit ring groups advertised should be set to 0.
2192 */
2193 cap_rings->mr_gnum = 0;
2194
2195 cap_rings->mr_gget = vnet_get_group;
2196 cap_rings->mr_gaddring = NULL;
2197 cap_rings->mr_gremring = NULL;
2198 }
2199 return (B_TRUE);
2200
2201 }
2202
2203 default:
2204 break;
2205
2206 }
2207
2208 return (B_FALSE);
2209 }
2210
2211 /*
2212 * Callback funtion for MAC layer to get ring information.
2213 */
2214 static void
2215 vnet_get_ring(void *arg, mac_ring_type_t rtype, const int g_index,
2216 const int r_index, mac_ring_info_t *infop, mac_ring_handle_t r_handle)
2217 {
2218 vnet_t *vnetp = arg;
2219
2220 switch (rtype) {
2221
2222 case MAC_RING_TYPE_RX: {
2223
2224 vnet_pseudo_rx_group_t *rx_grp;
2225 vnet_pseudo_rx_ring_t *rx_ringp;
2226 mac_intr_t *mintr;
2227
2228 /* We advertised only one RX group */
2229 ASSERT(g_index == 0);
2230 rx_grp = &vnetp->rx_grp[g_index];
2231
2232 /* Check the current # of rings in the rx group */
2233 ASSERT((r_index >= 0) && (r_index < rx_grp->max_ring_cnt));
2234
2235 /* Get the ring based on the index */
2236 rx_ringp = &rx_grp->rings[r_index];
2237
2238 rx_ringp->handle = r_handle;
2239 /*
2240 * Note: we don't need to save the incoming r_index in rx_ring,
2241 * as vnet_ring_grp_init() would have initialized the index for
2242 * each ring in the array.
2243 */
2244 rx_ringp->grp = rx_grp;
2245 rx_ringp->vnetp = vnetp;
2246
2247 mintr = &infop->mri_intr;
2248 mintr->mi_handle = (mac_intr_handle_t)rx_ringp;
2249 mintr->mi_enable = (mac_intr_enable_t)vnet_ring_enable_intr;
2250 mintr->mi_disable = (mac_intr_disable_t)vnet_ring_disable_intr;
2251
2252 infop->mri_driver = (mac_ring_driver_t)rx_ringp;
2253 infop->mri_start = vnet_rx_ring_start;
2254 infop->mri_stop = vnet_rx_ring_stop;
2255 infop->mri_stat = vnet_rx_ring_stat;
2256
2257 /* Set the poll function, as this is an rx ring */
2258 infop->mri_poll = vnet_rx_poll;
2259 /*
2260 * MAC_RING_RX_ENQUEUE bit needed to be set for nxge
2261 * which was not sending packet chains in interrupt
2262 * context. For such drivers, packets are queued in
2263 * Rx soft rings so that we get a chance to switch
2264 * into a polling mode under backlog. This bug (not
2265 * sending packet chains) has now been fixed. Once
2266 * the performance impact is measured, this change
2267 * will be removed.
2268 */
2269 infop->mri_flags = (vnet_mac_rx_queuing ?
2270 MAC_RING_RX_ENQUEUE : 0);
2271 break;
2272 }
2273
2274 case MAC_RING_TYPE_TX: {
2275 vnet_pseudo_tx_group_t *tx_grp;
2276 vnet_pseudo_tx_ring_t *tx_ringp;
2277
2278 /*
2279 * No need to check grp index; mac layer passes -1 for it.
2280 */
2281 tx_grp = &vnetp->tx_grp[0];
2282
2283 /* Check the # of rings in the tx group */
2284 ASSERT((r_index >= 0) && (r_index < tx_grp->ring_cnt));
2285
2286 /* Get the ring based on the index */
2287 tx_ringp = &tx_grp->rings[r_index];
2288
2289 tx_ringp->handle = r_handle;
2290 tx_ringp->index = r_index;
2291 tx_ringp->grp = tx_grp;
2292 tx_ringp->vnetp = vnetp;
2293
2294 infop->mri_driver = (mac_ring_driver_t)tx_ringp;
2295 infop->mri_start = vnet_tx_ring_start;
2296 infop->mri_stop = vnet_tx_ring_stop;
2297 infop->mri_stat = vnet_tx_ring_stat;
2298
2299 /* Set the transmit function, as this is a tx ring */
2300 infop->mri_tx = vnet_tx_ring_send;
2301 /*
2302 * MAC_RING_TX_SERIALIZE bit needs to be set while
2303 * hybridIO is enabled to workaround tx lock
2304 * contention issues in nxge.
2305 */
2306 infop->mri_flags = (vnet_mac_tx_serialize ?
2307 MAC_RING_TX_SERIALIZE : 0);
2308 break;
2309 }
2310
2311 default:
2312 break;
2313 }
2314 }
2315
2316 /*
2317 * Callback funtion for MAC layer to get group information.
2318 */
2319 static void
2320 vnet_get_group(void *arg, mac_ring_type_t type, const int index,
2321 mac_group_info_t *infop, mac_group_handle_t handle)
2322 {
2323 vnet_t *vnetp = (vnet_t *)arg;
2324
2325 switch (type) {
2326
2327 case MAC_RING_TYPE_RX:
2328 {
2329 vnet_pseudo_rx_group_t *rx_grp;
2330
2331 /* We advertised only one RX group */
2332 ASSERT(index == 0);
2333
2334 rx_grp = &vnetp->rx_grp[index];
2335 rx_grp->handle = handle;
2336 rx_grp->index = index;
2337 rx_grp->vnetp = vnetp;
2338
2339 infop->mgi_driver = (mac_group_driver_t)rx_grp;
2340 infop->mgi_start = NULL;
2341 infop->mgi_stop = NULL;
2342 infop->mgi_addmac = vnet_addmac;
2343 infop->mgi_remmac = vnet_remmac;
2344 infop->mgi_count = rx_grp->ring_cnt;
2345
2346 break;
2347 }
2348
2349 case MAC_RING_TYPE_TX:
2350 {
2351 vnet_pseudo_tx_group_t *tx_grp;
2352
2353 /* We advertised only one TX group */
2354 ASSERT(index == 0);
2355
2356 tx_grp = &vnetp->tx_grp[index];
2357 tx_grp->handle = handle;
2358 tx_grp->index = index;
2359 tx_grp->vnetp = vnetp;
2360
2361 infop->mgi_driver = (mac_group_driver_t)tx_grp;
2362 infop->mgi_start = NULL;
2363 infop->mgi_stop = NULL;
2364 infop->mgi_addmac = NULL;
2365 infop->mgi_remmac = NULL;
2366 infop->mgi_count = VNET_NUM_PSEUDO_TXRINGS;
2367
2368 break;
2369 }
2370
2371 default:
2372 break;
2373
2374 }
2375 }
2376
2377 static int
2378 vnet_rx_ring_start(mac_ring_driver_t arg, uint64_t mr_gen_num)
2379 {
2380 vnet_pseudo_rx_ring_t *rx_ringp = (vnet_pseudo_rx_ring_t *)arg;
2381 int err;
2382
2383 /*
2384 * If this ring is mapped to a LDC resource, simply mark the state to
2385 * indicate the ring is started and return.
2386 */
2387 if ((rx_ringp->state &
2388 (VNET_RXRING_LDC_SERVICE|VNET_RXRING_LDC_GUEST)) != 0) {
2389 rx_ringp->gen_num = mr_gen_num;
2390 rx_ringp->state |= VNET_RXRING_STARTED;
2391 return (0);
2392 }
2393
2394 ASSERT((rx_ringp->state & VNET_RXRING_HYBRID) != 0);
2395
2396 /*
2397 * This must be a ring reserved for a hwring. If the hwring is not
2398 * bound yet, simply mark the state to indicate the ring is started and
2399 * return. If and when a hybrid resource is activated for this vnet
2400 * device, we will bind the hwring and start it then. If a hwring is
2401 * already bound, start it now.
2402 */
2403 if (rx_ringp->hw_rh == NULL) {
2404 rx_ringp->gen_num = mr_gen_num;
2405 rx_ringp->state |= VNET_RXRING_STARTED;
2406 return (0);
2407 }
2408
2409 err = mac_hwring_activate(rx_ringp->hw_rh);
2410 if (err == 0) {
2411 rx_ringp->gen_num = mr_gen_num;
2412 rx_ringp->state |= VNET_RXRING_STARTED;
2413 } else {
2414 err = ENXIO;
2415 }
2416
2417 return (err);
2418 }
2419
2420 static void
2421 vnet_rx_ring_stop(mac_ring_driver_t arg)
2422 {
2423 vnet_pseudo_rx_ring_t *rx_ringp = (vnet_pseudo_rx_ring_t *)arg;
2424
2425 /*
2426 * If this ring is mapped to a LDC resource, simply mark the state to
2427 * indicate the ring is now stopped and return.
2428 */
2429 if ((rx_ringp->state &
2430 (VNET_RXRING_LDC_SERVICE|VNET_RXRING_LDC_GUEST)) != 0) {
2431 rx_ringp->state &= ~VNET_RXRING_STARTED;
2432 return;
2433 }
2434
2435 ASSERT((rx_ringp->state & VNET_RXRING_HYBRID) != 0);
2436
2437 /*
2438 * This must be a ring reserved for a hwring. If the hwring is not
2439 * bound yet, simply mark the state to indicate the ring is stopped and
2440 * return. If a hwring is already bound, stop it now.
2441 */
2442 if (rx_ringp->hw_rh == NULL) {
2443 rx_ringp->state &= ~VNET_RXRING_STARTED;
2444 return;
2445 }
2446
2447 mac_hwring_quiesce(rx_ringp->hw_rh);
2448 rx_ringp->state &= ~VNET_RXRING_STARTED;
2449 }
2450
2451 static int
2452 vnet_rx_ring_stat(mac_ring_driver_t rdriver, uint_t stat, uint64_t *val)
2453 {
2454 vnet_pseudo_rx_ring_t *rx_ringp = (vnet_pseudo_rx_ring_t *)rdriver;
2455 vnet_t *vnetp = (vnet_t *)rx_ringp->vnetp;
2456 vnet_res_t *vresp;
2457 mac_register_t *macp;
2458 mac_callbacks_t *cbp;
2459
2460 /*
2461 * Refer to vnet_m_capab() function for detailed comments on ring
2462 * synchronization.
2463 */
2464 if ((rx_ringp->state & VNET_RXRING_HYBRID) != 0) {
2465 READ_ENTER(&vnetp->vsw_fp_rw);
2466 if (vnetp->hio_fp == NULL) {
2467 RW_EXIT(&vnetp->vsw_fp_rw);
2468 return (0);
2469 }
2470
2471 VNET_FDBE_REFHOLD(vnetp->hio_fp);
2472 RW_EXIT(&vnetp->vsw_fp_rw);
2473 (void) mac_hwring_getstat(rx_ringp->hw_rh, stat, val);
2474 VNET_FDBE_REFRELE(vnetp->hio_fp);
2475 return (0);
2476 }
2477
2478 ASSERT((rx_ringp->state &
2479 (VNET_RXRING_LDC_SERVICE|VNET_RXRING_LDC_GUEST)) != 0);
2480 vresp = (vnet_res_t *)rx_ringp->hw_rh;
2481 macp = &vresp->macreg;
2482 cbp = macp->m_callbacks;
2483
2484 cbp->mc_getstat(macp->m_driver, stat, val);
2485
2486 return (0);
2487 }
2488
2489 /* ARGSUSED */
2490 static int
2491 vnet_tx_ring_start(mac_ring_driver_t arg, uint64_t mr_gen_num)
2492 {
2493 vnet_pseudo_tx_ring_t *tx_ringp = (vnet_pseudo_tx_ring_t *)arg;
2494
2495 tx_ringp->state |= VNET_TXRING_STARTED;
2496 return (0);
2497 }
2498
2499 static void
2500 vnet_tx_ring_stop(mac_ring_driver_t arg)
2501 {
2502 vnet_pseudo_tx_ring_t *tx_ringp = (vnet_pseudo_tx_ring_t *)arg;
2503
2504 tx_ringp->state &= ~VNET_TXRING_STARTED;
2505 }
2506
2507 static int
2508 vnet_tx_ring_stat(mac_ring_driver_t rdriver, uint_t stat, uint64_t *val)
2509 {
2510 vnet_pseudo_tx_ring_t *tx_ringp = (vnet_pseudo_tx_ring_t *)rdriver;
2511 vnet_tx_ring_stats_t *statsp;
2512
2513 statsp = &tx_ringp->tx_ring_stats;
2514
2515 switch (stat) {
2516 case MAC_STAT_OPACKETS:
2517 *val = statsp->opackets;
2518 break;
2519
2520 case MAC_STAT_OBYTES:
2521 *val = statsp->obytes;
2522 break;
2523
2524 default:
2525 *val = 0;
2526 return (ENOTSUP);
2527 }
2528
2529 return (0);
2530 }
2531
2532 /*
2533 * Disable polling for a ring and enable its interrupt.
2534 */
2535 static int
2536 vnet_ring_enable_intr(void *arg)
2537 {
2538 vnet_pseudo_rx_ring_t *rx_ringp = (vnet_pseudo_rx_ring_t *)arg;
2539 vnet_res_t *vresp;
2540
2541 if (rx_ringp->hw_rh == NULL) {
2542 /*
2543 * Ring enable intr func is being invoked, but the ring is
2544 * not bound to any underlying resource ? This must be a ring
2545 * reserved for Hybrid resource and no such resource has been
2546 * assigned to this vnet device yet. We simply return success.
2547 */
2548 ASSERT((rx_ringp->state & VNET_RXRING_HYBRID) != 0);
2549 return (0);
2550 }
2551
2552 /*
2553 * The rx ring has been bound to either a LDC or a Hybrid resource.
2554 * Call the appropriate function to enable interrupts for the ring.
2555 */
2556 if (rx_ringp->state & VNET_RXRING_HYBRID) {
2557 return (mac_hwring_enable_intr(rx_ringp->hw_rh));
2558 } else {
2559 vresp = (vnet_res_t *)rx_ringp->hw_rh;
2560 return (vgen_enable_intr(vresp->macreg.m_driver));
2561 }
2562 }
2563
2564 /*
2565 * Enable polling for a ring and disable its interrupt.
2566 */
2567 static int
2568 vnet_ring_disable_intr(void *arg)
2569 {
2570 vnet_pseudo_rx_ring_t *rx_ringp = (vnet_pseudo_rx_ring_t *)arg;
2571 vnet_res_t *vresp;
2572
2573 if (rx_ringp->hw_rh == NULL) {
2574 /*
2575 * Ring disable intr func is being invoked, but the ring is
2576 * not bound to any underlying resource ? This must be a ring
2577 * reserved for Hybrid resource and no such resource has been
2578 * assigned to this vnet device yet. We simply return success.
2579 */
2580 ASSERT((rx_ringp->state & VNET_RXRING_HYBRID) != 0);
2581 return (0);
2582 }
2583
2584 /*
2585 * The rx ring has been bound to either a LDC or a Hybrid resource.
2586 * Call the appropriate function to disable interrupts for the ring.
2587 */
2588 if (rx_ringp->state & VNET_RXRING_HYBRID) {
2589 return (mac_hwring_disable_intr(rx_ringp->hw_rh));
2590 } else {
2591 vresp = (vnet_res_t *)rx_ringp->hw_rh;
2592 return (vgen_disable_intr(vresp->macreg.m_driver));
2593 }
2594 }
2595
2596 /*
2597 * Poll 'bytes_to_pickup' bytes of message from the rx ring.
2598 */
2599 static mblk_t *
2600 vnet_rx_poll(void *arg, int bytes_to_pickup)
2601 {
2602 vnet_pseudo_rx_ring_t *rx_ringp = (vnet_pseudo_rx_ring_t *)arg;
2603 mblk_t *mp = NULL;
2604 vnet_res_t *vresp;
2605 vnet_t *vnetp = rx_ringp->vnetp;
2606
2607 if (rx_ringp->hw_rh == NULL) {
2608 return (NULL);
2609 }
2610
2611 if (rx_ringp->state & VNET_RXRING_HYBRID) {
2612 mp = mac_hwring_poll(rx_ringp->hw_rh, bytes_to_pickup);
2613 /*
2614 * Packets received over a hybrid resource need additional
2615 * processing to remove the tag, for the pvid case. The
2616 * underlying resource is not aware of the vnet's pvid and thus
2617 * packets are received with the vlan tag in the header; unlike
2618 * packets that are received over a ldc channel in which case
2619 * the peer vnet/vsw would have already removed the tag.
2620 */
2621 if (vnetp->pvid != vnetp->default_vlan_id) {
2622 vnet_rx_frames_untag(vnetp->pvid, &mp);
2623 }
2624 } else {
2625 vresp = (vnet_res_t *)rx_ringp->hw_rh;
2626 mp = vgen_rx_poll(vresp->macreg.m_driver, bytes_to_pickup);
2627 }
2628 return (mp);
2629 }
2630
2631 /* ARGSUSED */
2632 void
2633 vnet_hio_rx_cb(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
2634 boolean_t loopback)
2635 {
2636 vnet_t *vnetp = (vnet_t *)arg;
2637 vnet_pseudo_rx_ring_t *ringp = (vnet_pseudo_rx_ring_t *)mrh;
2638
2639 /*
2640 * Packets received over a hybrid resource need additional processing
2641 * to remove the tag, for the pvid case. The underlying resource is
2642 * not aware of the vnet's pvid and thus packets are received with the
2643 * vlan tag in the header; unlike packets that are received over a ldc
2644 * channel in which case the peer vnet/vsw would have already removed
2645 * the tag.
2646 */
2647 if (vnetp->pvid != vnetp->default_vlan_id) {
2648 vnet_rx_frames_untag(vnetp->pvid, &mp);
2649 if (mp == NULL) {
2650 return;
2651 }
2652 }
2653 mac_rx_ring(vnetp->mh, ringp->handle, mp, ringp->gen_num);
2654 }
2655
2656 static int
2657 vnet_addmac(void *arg, const uint8_t *mac_addr)
2658 {
2659 vnet_pseudo_rx_group_t *rx_grp = (vnet_pseudo_rx_group_t *)arg;
2660 vnet_t *vnetp;
2661
2662 vnetp = rx_grp->vnetp;
2663
2664 if (bcmp(mac_addr, vnetp->curr_macaddr, ETHERADDRL) == 0) {
2665 return (0);
2666 }
2667
2668 cmn_err(CE_CONT, "!vnet%d: %s: Multiple macaddr unsupported\n",
2669 vnetp->instance, __func__);
2670 return (EINVAL);
2671 }
2672
2673 static int
2674 vnet_remmac(void *arg, const uint8_t *mac_addr)
2675 {
2676 vnet_pseudo_rx_group_t *rx_grp = (vnet_pseudo_rx_group_t *)arg;
2677 vnet_t *vnetp;
2678
2679 vnetp = rx_grp->vnetp;
2680
2681 if (bcmp(mac_addr, vnetp->curr_macaddr, ETHERADDRL) == 0) {
2682 return (0);
2683 }
2684
2685 cmn_err(CE_CONT, "!vnet%d: %s: Invalid macaddr: %s\n",
2686 vnetp->instance, __func__, ether_sprintf((void *)mac_addr));
2687 return (EINVAL);
2688 }
2689
2690 int
2691 vnet_hio_mac_init(vnet_t *vnetp, char *ifname)
2692 {
2693 mac_handle_t mh;
2694 mac_client_handle_t mch = NULL;
2695 mac_unicast_handle_t muh = NULL;
2696 mac_diag_t diag;
2697 mac_register_t *macp;
2698 char client_name[MAXNAMELEN];
2699 int rv;
2700 uint16_t mac_flags = MAC_UNICAST_TAG_DISABLE |
2701 MAC_UNICAST_STRIP_DISABLE | MAC_UNICAST_PRIMARY;
2702 vio_net_callbacks_t vcb;
2703 ether_addr_t rem_addr =
2704 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2705 uint32_t retries = 0;
2706
2707 if ((macp = mac_alloc(MAC_VERSION)) == NULL) {
2708 return (EAGAIN);
2709 }
2710
2711 do {
2712 rv = mac_open_by_linkname(ifname, &mh);
2713 if (rv == 0) {
2714 break;
2715 }
2716 if (rv != ENOENT || (retries++ >= vnet_mac_open_retries)) {
2717 mac_free(macp);
2718 return (rv);
2719 }
2720 drv_usecwait(vnet_mac_open_delay);
2721 } while (rv == ENOENT);
2722
2723 vnetp->hio_mh = mh;
2724
2725 (void) snprintf(client_name, MAXNAMELEN, "vnet%d-%s", vnetp->instance,
2726 ifname);
2727 rv = mac_client_open(mh, &mch, client_name, MAC_OPEN_FLAGS_EXCLUSIVE);
2728 if (rv != 0) {
2729 goto fail;
2730 }
2731 vnetp->hio_mch = mch;
2732
2733 rv = mac_unicast_add(mch, vnetp->curr_macaddr, mac_flags, &muh, 0,
2734 &diag);
2735 if (rv != 0) {
2736 goto fail;
2737 }
2738 vnetp->hio_muh = muh;
2739
2740 macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
2741 macp->m_driver = vnetp;
2742 macp->m_dip = NULL;
2743 macp->m_src_addr = NULL;
2744 macp->m_callbacks = &vnet_hio_res_callbacks;
2745 macp->m_min_sdu = 0;
2746 macp->m_max_sdu = ETHERMTU;
2747
2748 rv = vio_net_resource_reg(macp, VIO_NET_RES_HYBRID,
2749 vnetp->curr_macaddr, rem_addr, &vnetp->hio_vhp, &vcb);
2750 if (rv != 0) {
2751 goto fail;
2752 }
2753 mac_free(macp);
2754
2755 /* add the recv callback */
2756 mac_rx_set(vnetp->hio_mch, vnet_hio_rx_cb, vnetp);
2757
2758 return (0);
2759
2760 fail:
2761 mac_free(macp);
2762 vnet_hio_mac_cleanup(vnetp);
2763 return (1);
2764 }
2765
2766 void
2767 vnet_hio_mac_cleanup(vnet_t *vnetp)
2768 {
2769 if (vnetp->hio_vhp != NULL) {
2770 vio_net_resource_unreg(vnetp->hio_vhp);
2771 vnetp->hio_vhp = NULL;
2772 }
2773
2774 if (vnetp->hio_muh != NULL) {
2775 (void) mac_unicast_remove(vnetp->hio_mch, vnetp->hio_muh);
2776 vnetp->hio_muh = NULL;
2777 }
2778
2779 if (vnetp->hio_mch != NULL) {
2780 mac_client_close(vnetp->hio_mch, 0);
2781 vnetp->hio_mch = NULL;
2782 }
2783
2784 if (vnetp->hio_mh != NULL) {
2785 mac_close(vnetp->hio_mh);
2786 vnetp->hio_mh = NULL;
2787 }
2788 }
2789
2790 /* Bind pseudo rings to hwrings */
2791 static int
2792 vnet_bind_hwrings(vnet_t *vnetp)
2793 {
2794 mac_ring_handle_t hw_rh[VNET_NUM_HYBRID_RINGS];
2795 mac_perim_handle_t mph1;
2796 vnet_pseudo_rx_group_t *rx_grp;
2797 vnet_pseudo_rx_ring_t *rx_ringp;
2798 vnet_pseudo_tx_group_t *tx_grp;
2799 vnet_pseudo_tx_ring_t *tx_ringp;
2800 int hw_ring_cnt;
2801 int i;
2802 int rv;
2803
2804 mac_perim_enter_by_mh(vnetp->hio_mh, &mph1);
2805
2806 /* Get the list of the underlying RX rings. */
2807 hw_ring_cnt = mac_hwrings_get(vnetp->hio_mch, &vnetp->rx_hwgh, hw_rh,
2808 MAC_RING_TYPE_RX);
2809
2810 /* We expect the the # of hw rx rings to match VNET_NUM_HYBRID_RINGS */
2811 if (hw_ring_cnt != VNET_NUM_HYBRID_RINGS) {
2812 cmn_err(CE_WARN,
2813 "!vnet%d: vnet_bind_hwrings: bad rx hw_ring_cnt(%d)\n",
2814 vnetp->instance, hw_ring_cnt);
2815 goto fail;
2816 }
2817
2818 if (vnetp->rx_hwgh != NULL) {
2819 /*
2820 * Quiesce the HW ring and the mac srs on the ring. Note
2821 * that the HW ring will be restarted when the pseudo ring
2822 * is started. At that time all the packets will be
2823 * directly passed up to the pseudo RX ring and handled
2824 * by mac srs created over the pseudo RX ring.
2825 */
2826 mac_rx_client_quiesce(vnetp->hio_mch);
2827 mac_srs_perm_quiesce(vnetp->hio_mch, B_TRUE);
2828 }
2829
2830 /*
2831 * Bind the pseudo rings to the hwrings and start the hwrings.
2832 * Note we don't need to register these with the upper mac, as we have
2833 * statically exported these pseudo rxrings which are reserved for
2834 * rxrings of Hybrid resource.
2835 */
2836 rx_grp = &vnetp->rx_grp[0];
2837 for (i = 0; i < VNET_NUM_HYBRID_RINGS; i++) {
2838 /* Pick the rxrings reserved for Hybrid resource */
2839 rx_ringp = &rx_grp->rings[i + VNET_HYBRID_RXRING_INDEX];
2840
2841 /* Store the hw ring handle */
2842 rx_ringp->hw_rh = hw_rh[i];
2843
2844 /* Bind the pseudo ring to the underlying hwring */
2845 mac_hwring_setup(rx_ringp->hw_rh,
2846 (mac_resource_handle_t)rx_ringp, NULL);
2847
2848 /* Start the hwring if needed */
2849 if (rx_ringp->state & VNET_RXRING_STARTED) {
2850 rv = mac_hwring_activate(rx_ringp->hw_rh);
2851 if (rv != 0) {
2852 mac_hwring_teardown(rx_ringp->hw_rh);
2853 rx_ringp->hw_rh = NULL;
2854 goto fail;
2855 }
2856 }
2857 }
2858
2859 /* Get the list of the underlying TX rings. */
2860 hw_ring_cnt = mac_hwrings_get(vnetp->hio_mch, &vnetp->tx_hwgh, hw_rh,
2861 MAC_RING_TYPE_TX);
2862
2863 /* We expect the # of hw tx rings to match VNET_NUM_HYBRID_RINGS */
2864 if (hw_ring_cnt != VNET_NUM_HYBRID_RINGS) {
2865 cmn_err(CE_WARN,
2866 "!vnet%d: vnet_bind_hwrings: bad tx hw_ring_cnt(%d)\n",
2867 vnetp->instance, hw_ring_cnt);
2868 goto fail;
2869 }
2870
2871 /*
2872 * Now map the pseudo txrings to the hw txrings. Note we don't need
2873 * to register these with the upper mac, as we have statically exported
2874 * these rings. Note that these rings will continue to be used for LDC
2875 * resources to peer vnets and vswitch (shared ring).
2876 */
2877 tx_grp = &vnetp->tx_grp[0];
2878 for (i = 0; i < tx_grp->ring_cnt; i++) {
2879 tx_ringp = &tx_grp->rings[i];
2880 tx_ringp->hw_rh = hw_rh[i];
2881 tx_ringp->state |= VNET_TXRING_HYBRID;
2882 }
2883 tx_grp->tx_notify_handle =
2884 mac_client_tx_notify(vnetp->hio_mch, vnet_tx_ring_update, vnetp);
2885
2886 mac_perim_exit(mph1);
2887 return (0);
2888
2889 fail:
2890 mac_perim_exit(mph1);
2891 vnet_unbind_hwrings(vnetp);
2892 return (1);
2893 }
2894
2895 /* Unbind pseudo rings from hwrings */
2896 static void
2897 vnet_unbind_hwrings(vnet_t *vnetp)
2898 {
2899 mac_perim_handle_t mph1;
2900 vnet_pseudo_rx_ring_t *rx_ringp;
2901 vnet_pseudo_rx_group_t *rx_grp;
2902 vnet_pseudo_tx_group_t *tx_grp;
2903 vnet_pseudo_tx_ring_t *tx_ringp;
2904 int i;
2905
2906 mac_perim_enter_by_mh(vnetp->hio_mh, &mph1);
2907
2908 tx_grp = &vnetp->tx_grp[0];
2909 for (i = 0; i < VNET_NUM_HYBRID_RINGS; i++) {
2910 tx_ringp = &tx_grp->rings[i];
2911 if (tx_ringp->state & VNET_TXRING_HYBRID) {
2912 tx_ringp->state &= ~VNET_TXRING_HYBRID;
2913 tx_ringp->hw_rh = NULL;
2914 }
2915 }
2916 (void) mac_client_tx_notify(vnetp->hio_mch, NULL,
2917 tx_grp->tx_notify_handle);
2918
2919 rx_grp = &vnetp->rx_grp[0];
2920 for (i = 0; i < VNET_NUM_HYBRID_RINGS; i++) {
2921 rx_ringp = &rx_grp->rings[i + VNET_HYBRID_RXRING_INDEX];
2922 if (rx_ringp->hw_rh != NULL) {
2923 /* Stop the hwring */
2924 mac_hwring_quiesce(rx_ringp->hw_rh);
2925
2926 /* Teardown the hwring */
2927 mac_hwring_teardown(rx_ringp->hw_rh);
2928 rx_ringp->hw_rh = NULL;
2929 }
2930 }
2931
2932 if (vnetp->rx_hwgh != NULL) {
2933 vnetp->rx_hwgh = NULL;
2934 /*
2935 * First clear the permanent-quiesced flag of the RX srs then
2936 * restart the HW ring and the mac srs on the ring.
2937 */
2938 mac_srs_perm_quiesce(vnetp->hio_mch, B_FALSE);
2939 mac_rx_client_restart(vnetp->hio_mch);
2940 }
2941
2942 mac_perim_exit(mph1);
2943 }
2944
2945 /* Bind pseudo ring to a LDC resource */
2946 static int
2947 vnet_bind_vgenring(vnet_res_t *vresp)
2948 {
2949 vnet_t *vnetp;
2950 vnet_pseudo_rx_group_t *rx_grp;
2951 vnet_pseudo_rx_ring_t *rx_ringp;
2952 mac_perim_handle_t mph1;
2953 int rv;
2954 int type;
2955
2956 vnetp = vresp->vnetp;
2957 type = vresp->type;
2958 rx_grp = &vnetp->rx_grp[0];
2959
2960 if (type == VIO_NET_RES_LDC_SERVICE) {
2961 /*
2962 * Ring Index 0 is the default ring in the group and is
2963 * reserved for LDC_SERVICE in vnet_ring_grp_init(). This ring
2964 * is allocated statically and is reported to the mac layer
2965 * in vnet_m_capab(). So, all we need to do here, is save a
2966 * reference to the associated vresp.
2967 */
2968 rx_ringp = &rx_grp->rings[0];
2969 rx_ringp->hw_rh = (mac_ring_handle_t)vresp;
2970 vresp->rx_ringp = (void *)rx_ringp;
2971 return (0);
2972 }
2973 ASSERT(type == VIO_NET_RES_LDC_GUEST);
2974
2975 mac_perim_enter_by_mh(vnetp->mh, &mph1);
2976
2977 rx_ringp = vnet_alloc_pseudo_rx_ring(vnetp);
2978 if (rx_ringp == NULL) {
2979 cmn_err(CE_WARN, "!vnet%d: Failed to allocate pseudo rx ring",
2980 vnetp->instance);
2981 goto fail;
2982 }
2983
2984 /* Store the LDC resource itself as the ring handle */
2985 rx_ringp->hw_rh = (mac_ring_handle_t)vresp;
2986
2987 /*
2988 * Save a reference to the ring in the resource for lookup during
2989 * unbind. Note this is only done for LDC resources. We don't need this
2990 * in the case of a Hybrid resource (see vnet_bind_hwrings()), as its
2991 * rx rings are mapped to reserved pseudo rx rings (index 1 and 2).
2992 */
2993 vresp->rx_ringp = (void *)rx_ringp;
2994 rx_ringp->state |= VNET_RXRING_LDC_GUEST;
2995
2996 /* Register the pseudo ring with upper-mac */
2997 rv = mac_group_add_ring(rx_grp->handle, rx_ringp->index);
2998 if (rv != 0) {
2999 rx_ringp->state &= ~VNET_RXRING_LDC_GUEST;
3000 rx_ringp->hw_rh = NULL;
3001 vnet_free_pseudo_rx_ring(vnetp, rx_ringp);
3002 goto fail;
3003 }
3004
3005 mac_perim_exit(mph1);
3006 return (0);
3007 fail:
3008 mac_perim_exit(mph1);
3009 return (1);
3010 }
3011
3012 /* Unbind pseudo ring from a LDC resource */
3013 static void
3014 vnet_unbind_vgenring(vnet_res_t *vresp)
3015 {
3016 vnet_t *vnetp;
3017 vnet_pseudo_rx_group_t *rx_grp;
3018 vnet_pseudo_rx_ring_t *rx_ringp;
3019 mac_perim_handle_t mph1;
3020 int type;
3021
3022 vnetp = vresp->vnetp;
3023 type = vresp->type;
3024 rx_grp = &vnetp->rx_grp[0];
3025
3026 if (vresp->rx_ringp == NULL) {
3027 return;
3028 }
3029
3030 if (type == VIO_NET_RES_LDC_SERVICE) {
3031 /*
3032 * Ring Index 0 is the default ring in the group and is
3033 * reserved for LDC_SERVICE in vnet_ring_grp_init(). This ring
3034 * is allocated statically and is reported to the mac layer
3035 * in vnet_m_capab(). So, all we need to do here, is remove its
3036 * reference to the associated vresp.
3037 */
3038 rx_ringp = &rx_grp->rings[0];
3039 rx_ringp->hw_rh = NULL;
3040 vresp->rx_ringp = NULL;
3041 return;
3042 }
3043 ASSERT(type == VIO_NET_RES_LDC_GUEST);
3044
3045 mac_perim_enter_by_mh(vnetp->mh, &mph1);
3046
3047 rx_ringp = (vnet_pseudo_rx_ring_t *)vresp->rx_ringp;
3048 vresp->rx_ringp = NULL;
3049
3050 if (rx_ringp != NULL && (rx_ringp->state & VNET_RXRING_LDC_GUEST)) {
3051 /* Unregister the pseudo ring with upper-mac */
3052 mac_group_rem_ring(rx_grp->handle, rx_ringp->handle);
3053
3054 rx_ringp->hw_rh = NULL;
3055 rx_ringp->state &= ~VNET_RXRING_LDC_GUEST;
3056
3057 /* Free the pseudo rx ring */
3058 vnet_free_pseudo_rx_ring(vnetp, rx_ringp);
3059 }
3060
3061 mac_perim_exit(mph1);
3062 }
3063
3064 static void
3065 vnet_unbind_rings(vnet_res_t *vresp)
3066 {
3067 switch (vresp->type) {
3068
3069 case VIO_NET_RES_LDC_SERVICE:
3070 case VIO_NET_RES_LDC_GUEST:
3071 vnet_unbind_vgenring(vresp);
3072 break;
3073
3074 case VIO_NET_RES_HYBRID:
3075 vnet_unbind_hwrings(vresp->vnetp);
3076 break;
3077
3078 default:
3079 break;
3080
3081 }
3082 }
3083
3084 static int
3085 vnet_bind_rings(vnet_res_t *vresp)
3086 {
3087 int rv;
3088
3089 switch (vresp->type) {
3090
3091 case VIO_NET_RES_LDC_SERVICE:
3092 case VIO_NET_RES_LDC_GUEST:
3093 rv = vnet_bind_vgenring(vresp);
3094 break;
3095
3096 case VIO_NET_RES_HYBRID:
3097 rv = vnet_bind_hwrings(vresp->vnetp);
3098 break;
3099
3100 default:
3101 rv = 1;
3102 break;
3103
3104 }
3105
3106 return (rv);
3107 }
3108
3109 /* ARGSUSED */
3110 int
3111 vnet_hio_stat(void *arg, uint_t stat, uint64_t *val)
3112 {
3113 vnet_t *vnetp = (vnet_t *)arg;
3114
3115 *val = mac_stat_get(vnetp->hio_mh, stat);
3116 return (0);
3117 }
3118
3119 /*
3120 * The start() and stop() routines for the Hybrid resource below, are just
3121 * dummy functions. This is provided to avoid resource type specific code in
3122 * vnet_start_resources() and vnet_stop_resources(). The starting and stopping
3123 * of the Hybrid resource happens in the context of the mac_client interfaces
3124 * that are invoked in vnet_hio_mac_init() and vnet_hio_mac_cleanup().
3125 */
3126 /* ARGSUSED */
3127 static int
3128 vnet_hio_start(void *arg)
3129 {
3130 return (0);
3131 }
3132
3133 /* ARGSUSED */
3134 static void
3135 vnet_hio_stop(void *arg)
3136 {
3137 }
3138
3139 mblk_t *
3140 vnet_hio_tx(void *arg, mblk_t *mp)
3141 {
3142 vnet_pseudo_tx_ring_t *tx_ringp;
3143 mblk_t *nextp;
3144 mblk_t *ret_mp;
3145
3146 tx_ringp = (vnet_pseudo_tx_ring_t *)arg;
3147 for (;;) {
3148 nextp = mp->b_next;
3149 mp->b_next = NULL;
3150
3151 ret_mp = mac_hwring_tx(tx_ringp->hw_rh, mp);
3152 if (ret_mp != NULL) {
3153 ret_mp->b_next = nextp;
3154 mp = ret_mp;
3155 break;
3156 }
3157
3158 if ((mp = nextp) == NULL)
3159 break;
3160 }
3161 return (mp);
3162 }
3163
3164 #ifdef VNET_IOC_DEBUG
3165
3166 /*
3167 * The ioctl entry point is used only for debugging for now. The ioctl commands
3168 * can be used to force the link state of the channel connected to vsw.
3169 */
3170 static void
3171 vnet_m_ioctl(void *arg, queue_t *q, mblk_t *mp)
3172 {
3173 struct iocblk *iocp;
3174 vnet_t *vnetp;
3175
3176 iocp = (struct iocblk *)(uintptr_t)mp->b_rptr;
3177 iocp->ioc_error = 0;
3178 vnetp = (vnet_t *)arg;
3179
3180 if (vnetp == NULL) {
3181 miocnak(q, mp, 0, EINVAL);
3182 return;
3183 }
3184
3185 switch (iocp->ioc_cmd) {
3186
3187 case VNET_FORCE_LINK_DOWN:
3188 case VNET_FORCE_LINK_UP:
3189 vnet_force_link_state(vnetp, q, mp);
3190 break;
3191
3192 default:
3193 iocp->ioc_error = EINVAL;
3194 miocnak(q, mp, 0, iocp->ioc_error);
3195 break;
3196
3197 }
3198 }
3199
3200 static void
3201 vnet_force_link_state(vnet_t *vnetp, queue_t *q, mblk_t *mp)
3202 {
3203 mac_register_t *macp;
3204 mac_callbacks_t *cbp;
3205 vnet_res_t *vresp;
3206
3207 READ_ENTER(&vnetp->vsw_fp_rw);
3208
3209 vresp = vnetp->vsw_fp;
3210 if (vresp == NULL) {
3211 RW_EXIT(&vnetp->vsw_fp_rw);
3212 return;
3213 }
3214
3215 macp = &vresp->macreg;
3216 cbp = macp->m_callbacks;
3217 cbp->mc_ioctl(macp->m_driver, q, mp);
3218
3219 RW_EXIT(&vnetp->vsw_fp_rw);
3220 }
3221
3222 #else
3223
3224 static void
3225 vnet_m_ioctl(void *arg, queue_t *q, mblk_t *mp)
3226 {
3227 vnet_t *vnetp;
3228
3229 vnetp = (vnet_t *)arg;
3230
3231 if (vnetp == NULL) {
3232 miocnak(q, mp, 0, EINVAL);
3233 return;
3234 }
3235
3236 /* ioctl support only for debugging */
3237 miocnak(q, mp, 0, ENOTSUP);
3238 }
3239
3240 #endif