xref: /illumos-gate/usr/src/uts/sun4v/io/vcc.c (revision bbf215553c7233fbab8a0afdf1fac74c44781867)
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 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright (c) 2014, Joyent, Inc. All rights reserved.
29  */
30 
31 #include <sys/types.h>
32 #include <sys/file.h>
33 #include <sys/errno.h>
34 #include <sys/uio.h>
35 #include <sys/open.h>
36 #include <sys/cred.h>
37 #include <sys/kmem.h>
38 #include <sys/conf.h>
39 #include <sys/cmn_err.h>
40 #include <sys/ksynch.h>
41 #include <sys/modctl.h>
42 #include <sys/stat.h> /* needed for S_IFBLK and S_IFCHR */
43 #include <sys/debug.h>
44 #include <sys/promif.h>
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47 #include <sys/cyclic.h>
48 #include <sys/termio.h>
49 #include <sys/intr.h>
50 #include <sys/ivintr.h>
51 #include <sys/note.h>
52 #include <sys/stat.h>
53 #include <sys/fcntl.h>
54 #include <sys/sysmacros.h>
55 
56 #include <sys/ldc.h>
57 #include <sys/mdeg.h>
58 #include <sys/vcc_impl.h>
59 
60 #define	VCC_LDC_RETRIES		5
61 #define	VCC_LDC_DELAY		1000 /* usec */
62 
63 /*
64  * Function prototypes.
65  */
66 
67 /* DDI entrypoints */
68 static int	vcc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
69 static int	vcc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
70 static int	vcc_open(dev_t *devp, int flag, int otyp, cred_t *cred);
71 static int	vcc_close(dev_t dev, int flag, int otyp, cred_t *cred);
72 static int	vcc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
73 			cred_t *credp, int *rvalp);
74 static int	vcc_read(dev_t dev, struct uio *uiop, cred_t *credp);
75 static int	vcc_write(dev_t dev, struct uio *uiop, cred_t *credp);
76 static int	vcc_chpoll(dev_t dev, short events, int anyyet,
77 			short *reventsp, struct pollhead **phpp);
78 static int	vcc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
79 			void *arg, void **resultp);
80 
81 /* callback functions */
82 static uint_t	vcc_ldc_cb(uint64_t event, caddr_t arg);
83 static int	vcc_mdeg_cb(void *cb_argp, mdeg_result_t *resp);
84 
85 /* Internal functions */
86 static int	i_vcc_ldc_init(vcc_t *vccp, vcc_port_t *vport);
87 static int	i_vcc_add_port(vcc_t *vccp, char *group_name, uint64_t tcp_port,
88 			uint_t portno, char *domain_name);
89 static int	i_vcc_config_port(vcc_t *vccp, uint_t portno, uint64_t ldc_id);
90 static int	i_vcc_reset_events(vcc_t *vccp);
91 static int	i_vcc_cons_tbl(vcc_t *vccp, uint_t num_ports,
92 			caddr_t buf, int mode);
93 static int	i_vcc_del_cons_ok(vcc_t *vccp, caddr_t buf, int mode);
94 static int	i_vcc_close_port(vcc_port_t *vport);
95 static int	i_vcc_write_ldc(vcc_port_t *vport, vcc_msg_t *buf);
96 static int	i_vcc_read_ldc(vcc_port_t *vport, char *data_buf, size_t *sz);
97 
98 static void *vcc_ssp;
99 
100 static struct cb_ops vcc_cb_ops = {
101 	vcc_open,	    /* open */
102 	vcc_close,	    /* close */
103 	nodev,		    /* strategy */
104 	nodev,		    /* print */
105 	nodev,		    /* dump */
106 	vcc_read,	    /* read */
107 	vcc_write,	    /* write */
108 	vcc_ioctl,	    /* ioctl */
109 	nodev,		    /* devmap */
110 	nodev,		    /* mmap */
111 	ddi_segmap,	    /* segmap */
112 	vcc_chpoll,	    /* chpoll */
113 	ddi_prop_op,	    /* prop_op */
114 	NULL,		    /* stream */
115 	D_NEW | D_MP	    /* flags */
116 };
117 
118 
119 static struct dev_ops vcc_ops = {
120 	DEVO_REV,		/* rev */
121 	0,			/* ref count */
122 	vcc_getinfo,		/* getinfo */
123 	nulldev,		/* identify */
124 	nulldev,		/* probe */
125 	vcc_attach,		/* attach */
126 	vcc_detach,		/* detach */
127 	nodev,			/* reset */
128 	&vcc_cb_ops,		/* cb_ops */
129 	(struct bus_ops *)NULL,	/* bus_ops */
130 	NULL,			/* power */
131 	ddi_quiesce_not_needed,		/* quiesce */
132 };
133 
134 extern struct mod_ops mod_driverops;
135 
136 #define	    VCC_CHANNEL_ENDPOINT	"channel-endpoint"
137 #define	    VCC_ID_PROP		"id"
138 
139 /*
140  * This is the string displayed by modinfo(8).
141  */
142 static char vcc_ident[] = "sun4v Virtual Console Concentrator Driver";
143 
144 static struct modldrv md = {
145 	&mod_driverops, 	/* Type - it is a driver */
146 	vcc_ident,		/* Name of the module */
147 	&vcc_ops,		/* driver specfic opts */
148 };
149 
150 static struct modlinkage ml = {
151 	MODREV_1,
152 	&md,
153 	NULL
154 };
155 
156 /*
157  * Matching criteria passed to the MDEG to register interest
158  * in changes to 'virtual-device-port' nodes identified by their
159  * 'id' property.
160  */
161 static md_prop_match_t vcc_port_prop_match[] = {
162 	{ MDET_PROP_VAL,	    "id"   },
163 	{ MDET_LIST_END,	    NULL    }
164 };
165 
166 static mdeg_node_match_t vcc_port_match = {"virtual-device-port",
167 					vcc_port_prop_match};
168 
169 /*
170  * Specification of an MD node passed to the MDEG to filter any
171  * 'virtual-device-port' nodes that do not belong to the specified node.
172  * This template is copied for each vldc instance and filled in with
173  * the appropriate 'cfg-handle' value before being passed to the MDEG.
174  */
175 static mdeg_prop_spec_t vcc_prop_template[] = {
176 	{ MDET_PROP_STR,    "name",	"virtual-console-concentrator"	},
177 	{ MDET_PROP_VAL,    "cfg-handle",	NULL	},
178 	{ MDET_LIST_END,    NULL,		NULL	}
179 };
180 
181 #define	VCC_SET_MDEG_PROP_INST(specp, val) (specp)[1].ps_val = (val);
182 
183 
184 #ifdef DEBUG
185 
186 /*
187  * Print debug messages
188  *
189  * set vldcdbg to 0xf to enable all messages
190  *
191  * 0x8 - Errors
192  * 0x4 - Warnings
193  * 0x2 - All debug messages (most verbose)
194  * 0x1 - Minimal debug messages
195  */
196 
197 int vccdbg = 0x8;
198 
199 static void
vccdebug(const char * fmt,...)200 vccdebug(const char *fmt, ...)
201 {
202 	char buf[512];
203 	va_list ap;
204 
205 	va_start(ap, fmt);
206 	(void) vsprintf(buf, fmt, ap);
207 	va_end(ap);
208 
209 	cmn_err(CE_CONT, "%s\n", buf);
210 }
211 
212 #define	D1		\
213 if (vccdbg & 0x01)	\
214 	vccdebug
215 
216 #define	D2		\
217 if (vccdbg & 0x02)	\
218 	vccdebug
219 
220 #define	DWARN		\
221 if (vccdbg & 0x04)	\
222 	vccdebug
223 
224 #else
225 
226 #define	D1
227 #define	D2
228 #define	DWARN
229 
230 #endif
231 
232 /* _init(9E): initialize the loadable module */
233 int
_init(void)234 _init(void)
235 {
236 	int error;
237 
238 	/* init the soft state structure */
239 	error = ddi_soft_state_init(&vcc_ssp, sizeof (vcc_t), 1);
240 	if (error != 0) {
241 		return (error);
242 	}
243 
244 	/* Link the driver into the system */
245 	error = mod_install(&ml);
246 
247 	return (error);
248 
249 }
250 
251 /* _info(9E): return information about the loadable module */
252 int
_info(struct modinfo * modinfop)253 _info(struct modinfo *modinfop)
254 {
255 	/* Report status of the dynamically loadable driver module */
256 	return (mod_info(&ml, modinfop));
257 }
258 
259 /* _fini(9E): prepare the module for unloading. */
260 int
_fini(void)261 _fini(void)
262 {
263 	int error;
264 
265 	/* Unlink the driver module from the system */
266 	if ((error = mod_remove(&ml)) == 0) {
267 		/*
268 		 * We have successfully "removed" the driver.
269 		 * destroy soft state
270 		 */
271 		ddi_soft_state_fini(&vcc_ssp);
272 	}
273 
274 	return (error);
275 }
276 
277 /* getinfo(9E) */
278 static int
vcc_getinfo(dev_info_t * dip,ddi_info_cmd_t cmd,void * arg,void ** resultp)279 vcc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,  void *arg, void **resultp)
280 {
281 	_NOTE(ARGUNUSED(dip))
282 
283 	int	instance = VCCINST(getminor((dev_t)arg));
284 	vcc_t	*vccp = NULL;
285 
286 	switch (cmd) {
287 
288 	case DDI_INFO_DEVT2DEVINFO:
289 		if ((vccp = ddi_get_soft_state(vcc_ssp, instance)) == NULL) {
290 			*resultp = NULL;
291 			return (DDI_FAILURE);
292 		}
293 		*resultp = vccp->dip;
294 		return (DDI_SUCCESS);
295 
296 	case DDI_INFO_DEVT2INSTANCE:
297 		*resultp = (void *)(uintptr_t)instance;
298 		return (DDI_SUCCESS);
299 
300 	default:
301 		*resultp = NULL;
302 		return (DDI_FAILURE);
303 	}
304 }
305 
306 /*
307  * There are two cases that need special blocking. One of them is to block
308  * a minor node without a port and another is to block application other
309  * than vntsd.
310  *
311  * A minor node can exist in the file system without associated with a port
312  * because when a port is deleted, ddi_remove_minor does not unlink it.
313  * Clients might try to open a minor node even after the corresponding port
314  * node has been removed.  To identify and block these calls,
315  * we need to validate the association between a port and its minor node.
316  *
317  * An application other than vntsd can access a console port as long
318  * as vntsd is not using the port. A port opened by an application other
319  * than vntsd will be closed when vntsd wants to use the port.
320  * However, other application could use same file descriptor
321  * access vcc cb_ops. So we need to identify and block caller other
322  * than vntsd, when vntsd is using the port.
323  */
324 static int
i_vcc_can_use_port(vcc_minor_t * minorp,vcc_port_t * vport)325 i_vcc_can_use_port(vcc_minor_t *minorp, vcc_port_t *vport)
326 {
327 	if (vport->minorp != minorp) {
328 		/* port config changed */
329 		return (ENXIO);
330 	}
331 
332 	if (vport->valid_pid == VCC_NO_PID_BLOCKING) {
333 		/* no blocking needed */
334 		return (0);
335 	}
336 
337 	if (vport->valid_pid != ddi_get_pid()) {
338 		return (EIO);
339 	}
340 
341 	return (0);
342 }
343 
344 
345 /* Syncronization between thread using cv_wait */
346 static int
i_vcc_wait_port_status(vcc_port_t * vport,kcondvar_t * cv,uint32_t status)347 i_vcc_wait_port_status(vcc_port_t *vport, kcondvar_t *cv, uint32_t status)
348 {
349 
350 	int	    rv;
351 
352 	ASSERT(mutex_owned(&vport->lock));
353 
354 	for (; ; ) {
355 
356 		if ((vport->status & VCC_PORT_AVAIL) == 0) {
357 			/* port has been deleted */
358 			D1("i_vcc_wait_port_status: port%d deleted\n",
359 			    vport->number);
360 			return (EIO);
361 		}
362 
363 		if ((vport->status & VCC_PORT_OPEN) == 0) {
364 			D1("i_vcc_wait_port_status: port%d is closed \n",
365 			    vport->number);
366 			return (EIO);
367 		}
368 
369 		if (vport->status & VCC_PORT_LDC_LINK_DOWN) {
370 			return (EIO);
371 		}
372 
373 		if ((vport->valid_pid != VCC_NO_PID_BLOCKING) &&
374 		    (vport->valid_pid != ddi_get_pid())) {
375 			return (EIO);
376 		}
377 
378 		if ((vport->status & status) == status) {
379 			return (0);
380 		}
381 
382 		if (!ddi_can_receive_sig()) {
383 			return (EIO);
384 		}
385 
386 		rv = cv_wait_sig(cv, &vport->lock);
387 		if (rv == 0) {
388 			D1("i_vcc_wait_port_status: port%d get intr \n",
389 			    vport->number);
390 			/* got signal */
391 			return (EINTR);
392 		}
393 	}
394 
395 }
396 
397 /* Syncronization between threads, signal state change */
398 static void
i_vcc_set_port_status(vcc_port_t * vport,kcondvar_t * cv,uint32_t status)399 i_vcc_set_port_status(vcc_port_t *vport, kcondvar_t *cv, uint32_t status)
400 {
401 
402 	mutex_enter(&vport->lock);
403 	vport->status |= status;
404 	cv_broadcast(cv);
405 	mutex_exit(&vport->lock);
406 }
407 
408 /* initialize a ldc channel */
409 static int
i_vcc_ldc_init(vcc_t * vccp,vcc_port_t * vport)410 i_vcc_ldc_init(vcc_t *vccp, vcc_port_t *vport)
411 {
412 	ldc_attr_t 	attr;
413 	int		rv = EIO;
414 
415 	ASSERT(mutex_owned(&vport->lock));
416 	ASSERT(vport->ldc_id != VCC_INVALID_CHANNEL);
417 
418 	/* initialize the channel */
419 	attr.devclass = LDC_DEV_SERIAL;
420 	attr.instance = ddi_get_instance(vccp->dip);
421 	attr.mtu = VCC_MTU_SZ;
422 	attr.mode = LDC_MODE_RAW;
423 
424 	if ((rv = ldc_init(vport->ldc_id, &attr, &(vport->ldc_handle))) != 0) {
425 		cmn_err(CE_CONT, "i_vcc_ldc_init: port %d ldc channel %ld"
426 		    " failed ldc_init %d \n", vport->number, vport->ldc_id, rv);
427 		vport->ldc_id = VCC_INVALID_CHANNEL;
428 		return (rv);
429 	}
430 
431 	/* register it */
432 	if ((rv = ldc_reg_callback(vport->ldc_handle, vcc_ldc_cb,
433 	    (caddr_t)vport)) != 0) {
434 		cmn_err(CE_CONT, "i_vcc_ldc_init: port@%d ldc_register_cb"
435 		    "failed\n", vport->number);
436 		(void) ldc_fini(vport->ldc_handle);
437 		vport->ldc_id = VCC_INVALID_CHANNEL;
438 		return (rv);
439 	}
440 
441 	/* open and bring channel up */
442 	if ((rv = ldc_open(vport->ldc_handle)) != 0) {
443 		cmn_err(CE_CONT, "i_vcc_ldc_init: port@%d inv channel 0x%lx\n",
444 		    vport->number, vport->ldc_id);
445 		(void) ldc_unreg_callback(vport->ldc_handle);
446 		(void) ldc_fini(vport->ldc_handle);
447 		vport->ldc_id = VCC_INVALID_CHANNEL;
448 		return (rv);
449 	}
450 
451 	/* init the channel status */
452 	if ((rv = ldc_status(vport->ldc_handle, &vport->ldc_status)) != 0) {
453 		cmn_err(CE_CONT, "i_vcc_ldc_init: port@%d ldc_status failed\n",
454 		    vport->number);
455 		(void) ldc_close(vport->ldc_handle);
456 		(void) ldc_unreg_callback(vport->ldc_handle);
457 		(void) ldc_fini(vport->ldc_handle);
458 		vport->ldc_id = VCC_INVALID_CHANNEL;
459 		return (rv);
460 	}
461 
462 	return (0);
463 }
464 
465 /*  release a ldc channel */
466 static void
i_vcc_ldc_fini(vcc_port_t * vport)467 i_vcc_ldc_fini(vcc_port_t *vport)
468 {
469 	int 		rv = EIO;
470 	vcc_msg_t	buf;
471 	size_t		sz;
472 	int		retry = 0;
473 
474 	D1("i_vcc_ldc_fini: port@%lld, ldc_id%%llx\n", vport->number,
475 	    vport->ldc_id);
476 
477 	ASSERT(mutex_owned(&vport->lock));
478 
479 	/* wait for write available */
480 	rv = i_vcc_wait_port_status(vport, &vport->write_cv,
481 	    VCC_PORT_USE_WRITE_LDC);
482 
483 	if (rv == 0) {
484 		vport->status &= ~VCC_PORT_USE_WRITE_LDC;
485 
486 		/* send a HUP message */
487 		buf.type = LDC_CONSOLE_CTRL;
488 		buf.ctrl_msg = LDC_CONSOLE_HUP;
489 		buf.size = 0;
490 
491 		/*
492 		 * ignore write error since we still want to clean up
493 		 * ldc channel.
494 		 */
495 		(void) i_vcc_write_ldc(vport, &buf);
496 
497 		mutex_exit(&vport->lock);
498 		i_vcc_set_port_status(vport, &vport->write_cv,
499 		    VCC_PORT_USE_WRITE_LDC);
500 		mutex_enter(&vport->lock);
501 	}
502 
503 	/* flush ldc channel */
504 	rv = i_vcc_wait_port_status(vport, &vport->read_cv,
505 	    VCC_PORT_USE_READ_LDC);
506 
507 	if (rv == 0) {
508 		vport->status &= ~VCC_PORT_USE_READ_LDC;
509 		do {
510 			sz = sizeof (buf);
511 			rv = i_vcc_read_ldc(vport, (char *)&buf, &sz);
512 		} while (rv == 0 && sz > 0);
513 
514 		vport->status |= VCC_PORT_USE_READ_LDC;
515 
516 	}
517 
518 	/*
519 	 * ignore read error since we still want to clean up
520 	 * ldc channel.
521 	 */
522 
523 	(void) ldc_set_cb_mode(vport->ldc_handle, LDC_CB_DISABLE);
524 
525 	/* close LDC channel - retry on EAGAIN */
526 	while ((rv = ldc_close(vport->ldc_handle)) == EAGAIN) {
527 
528 		if (++retry > VCC_LDC_RETRIES) {
529 			cmn_err(CE_CONT, "i_vcc_ldc_fini: cannot close channel"
530 			    " %ld\n", vport->ldc_id);
531 			break;
532 		}
533 
534 		drv_usecwait(VCC_LDC_DELAY);
535 	}
536 
537 	if (rv == 0) {
538 		(void) ldc_unreg_callback(vport->ldc_handle);
539 		(void) ldc_fini(vport->ldc_handle);
540 	} else {
541 		/*
542 		 * Closing the LDC channel has failed. Ideally we should
543 		 * fail here but there is no Zeus level infrastructure
544 		 * to handle this. The MD has already been changed and
545 		 * we have to do the close. So we try to do as much
546 		 * clean up as we can.
547 		 */
548 		while (ldc_unreg_callback(vport->ldc_handle) == EAGAIN)
549 			drv_usecwait(VCC_LDC_DELAY);
550 	}
551 
552 }
553 
554 /* read data from ldc channel */
555 
556 static int
i_vcc_read_ldc(vcc_port_t * vport,char * data_buf,size_t * sz)557 i_vcc_read_ldc(vcc_port_t *vport, char *data_buf, size_t *sz)
558 {
559 
560 	int		rv;
561 	size_t		size;
562 	size_t		space_left = *sz;
563 	vcc_msg_t  	buf;
564 	int 		i;
565 
566 
567 
568 
569 	/* make sure holding read lock */
570 	ASSERT((vport->status & VCC_PORT_USE_READ_LDC) == 0);
571 	ASSERT(space_left >= VCC_MTU_SZ);
572 
573 	*sz = 0;
574 	while (space_left >= VCC_MTU_SZ)  {
575 		size = sizeof (buf);
576 
577 		rv = ldc_read(vport->ldc_handle, (caddr_t)&buf, &size);
578 
579 		if (rv) {
580 			return (rv);
581 		}
582 
583 
584 		/*
585 		 * FIXME: ldc_read should not reaturn 0 with
586 		 * either size == 0, buf.size == 0 or size < VCC_HDR_SZ
587 		 */
588 		if (size == 0) {
589 			if (*sz > 0) {
590 				return (0);
591 			}
592 			return (EAGAIN);
593 		}
594 
595 		if (size < VCC_HDR_SZ) {
596 			return (EIO);
597 		}
598 
599 		/*
600 		 * only data is expected from console - otherwise
601 		 * return error
602 		 */
603 		if (buf.type != LDC_CONSOLE_DATA) {
604 			return (EIO);
605 		}
606 
607 		if (buf.size == 0) {
608 			if (*sz > 0) {
609 				return (0);
610 			}
611 			return (EAGAIN);
612 		}
613 
614 		/* copy  data */
615 		for (i = 0; i < buf.size; i++, (*sz)++) {
616 			data_buf[*sz] = buf.data[i];
617 		}
618 
619 		space_left -= buf.size;
620 	}
621 
622 	return (0);
623 }
624 
625 /* callback from ldc */
626 static uint_t
vcc_ldc_cb(uint64_t event,caddr_t arg)627 vcc_ldc_cb(uint64_t event, caddr_t arg)
628 {
629 
630 	vcc_port_t  *vport = (vcc_port_t *)arg;
631 	boolean_t   hasdata;
632 
633 	/*
634 	 * do not need to hold lock because if ldc calls back, the
635 	 * ldc_handle must be valid.
636 	 */
637 	D2("vcc_ldc_cb: callback invoked port=%d events=%llx\n",
638 	    vport->number, event);
639 
640 	/* check event from ldc */
641 	if (event & LDC_EVT_WRITE) {
642 		/* channel has space for write */
643 
644 		i_vcc_set_port_status(vport, &vport->write_cv,
645 		    VCC_PORT_LDC_WRITE_READY);
646 		return (LDC_SUCCESS);
647 	}
648 
649 	if (event & LDC_EVT_READ) {
650 
651 		/* channel has data for read */
652 		(void) ldc_chkq(vport->ldc_handle, &hasdata);
653 		if (!hasdata) {
654 			/* data already read */
655 			return (LDC_SUCCESS);
656 		}
657 
658 		i_vcc_set_port_status(vport, &vport->read_cv,
659 		    VCC_PORT_LDC_DATA_READY);
660 		return (LDC_SUCCESS);
661 	}
662 
663 	if (event & LDC_EVT_DOWN) {
664 		/* channel is down */
665 		i_vcc_set_port_status(vport, &vport->write_cv,
666 		    VCC_PORT_LDC_LINK_DOWN);
667 		cv_broadcast(&vport->read_cv);
668 
669 	}
670 
671 	return (LDC_SUCCESS);
672 
673 }
674 
675 
676 /* configure a vcc port with ldc channel */
677 static int
i_vcc_config_port(vcc_t * vccp,uint_t portno,uint64_t ldc_id)678 i_vcc_config_port(vcc_t *vccp, uint_t portno, uint64_t ldc_id)
679 {
680 	int 		rv = EIO;
681 	vcc_port_t 	*vport;
682 
683 	if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
684 		cmn_err(CE_CONT, "i_vcc_config_port: invalid port number %d\n",
685 		    portno);
686 		return (EINVAL);
687 	}
688 
689 	vport = &(vccp->port[portno]);
690 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
691 		cmn_err(CE_CONT, "i_vcc_config_port: port@%d does not exist\n",
692 		    portno);
693 		return (EINVAL);
694 	}
695 
696 
697 	if (vport->ldc_id != VCC_INVALID_CHANNEL) {
698 		cmn_err(CE_CONT, "i_vcc_config_port: port@%d channel already"
699 		    "configured\n", portno);
700 		return (EINVAL);
701 	}
702 
703 	mutex_enter(&vport->lock);
704 
705 	/* store the ldc ID */
706 	vport->ldc_id = ldc_id;
707 	/* check if someone has already opened this port */
708 	if (vport->status & VCC_PORT_OPEN) {
709 
710 		if ((rv = i_vcc_ldc_init(vccp, vport)) != 0) {
711 			mutex_exit(&vport->lock);
712 			return (rv);
713 		}
714 
715 		/* mark port as ready */
716 		vport->status |= VCC_PORT_LDC_CHANNEL_READY;
717 		cv_broadcast(&vport->read_cv);
718 		cv_broadcast(&vport->write_cv);
719 	}
720 
721 	mutex_exit(&vport->lock);
722 
723 	D1("i_vcc_config_port: port@%d ldc=%d, domain=%s",
724 	    vport->number, vport->ldc_id, vport->minorp->domain_name);
725 
726 	return (0);
727 }
728 
729 /* add a vcc console port */
730 static int
i_vcc_add_port(vcc_t * vccp,char * group_name,uint64_t tcp_port,uint_t portno,char * domain_name)731 i_vcc_add_port(vcc_t *vccp, char *group_name, uint64_t tcp_port,
732     uint_t portno, char *domain_name)
733 {
734 	int 		instance;
735 	int		rv = MDEG_FAILURE;
736 	minor_t 	minor;
737 	vcc_port_t 	*vport;
738 	uint_t		minor_idx;
739 	char		name[MAXPATHLEN];
740 
741 	if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
742 		DWARN("i_vcc_add_port: invalid port number %d\n", portno);
743 		return (MDEG_FAILURE);
744 	}
745 
746 	vport = &(vccp->port[portno]);
747 	if (vport->status & VCC_PORT_AVAIL) {
748 		/* this port already exists */
749 		cmn_err(CE_CONT, "i_vcc_add_port: invalid port - port@%d "
750 		    "exists\n", portno);
751 		return (MDEG_FAILURE);
752 	}
753 
754 	vport->number = portno;
755 	vport->ldc_id = VCC_INVALID_CHANNEL;
756 
757 	if (domain_name == NULL) {
758 		cmn_err(CE_CONT, "i_vcc_add_port: invalid domain name\n");
759 		return (MDEG_FAILURE);
760 	}
761 
762 	if (group_name == NULL) {
763 		cmn_err(CE_CONT, "i_vcc_add_port: invalid group name\n");
764 		return (MDEG_FAILURE);
765 	}
766 
767 	/* look up minor number */
768 	for (minor_idx = 0; minor_idx < vccp->minors_assigned; minor_idx++) {
769 		if (strcmp(vccp->minor_tbl[minor_idx].domain_name,
770 		    domain_name) == 0) {
771 			/* found previous assigned minor number */
772 			break;
773 		}
774 	}
775 
776 	if (minor_idx == vccp->minors_assigned) {
777 		/* end of lookup - assign new minor number */
778 		if (minor_idx == VCC_MAX_PORTS) {
779 			cmn_err(CE_CONT, "i_vcc_add_port:"
780 			    "too many minornodes (%d)\n",
781 			    minor_idx);
782 			return (MDEG_FAILURE);
783 		}
784 
785 		(void) strlcpy(vccp->minor_tbl[minor_idx].domain_name,
786 		    domain_name, MAXPATHLEN);
787 
788 		vccp->minors_assigned++;
789 	}
790 
791 	vport->minorp = &vccp->minor_tbl[minor_idx];
792 	vccp->minor_tbl[minor_idx].portno = portno;
793 
794 	(void) strlcpy(vport->group_name, group_name, MAXPATHLEN);
795 
796 	vport->tcp_port = tcp_port;
797 	D1("i_vcc_add_port:@%d domain=%s, group=%s, tcp=%lld",
798 	    vport->number, vport->minorp->domain_name,
799 	    vport->group_name, vport->tcp_port);
800 
801 
802 	/*
803 	 * Create a minor node. The minor number is
804 	 * (instance << VCC_INST_SHIFT) | minor_idx
805 	 */
806 	instance = ddi_get_instance(vccp->dip);
807 
808 	minor = (instance << VCC_INST_SHIFT) | (minor_idx);
809 
810 	(void) snprintf(name, MAXPATHLEN - 1, "%s%s", VCC_MINOR_NAME_PREFIX,
811 	    domain_name);
812 
813 	rv = ddi_create_minor_node(vccp->dip, name, S_IFCHR, minor,
814 	    DDI_NT_SERIAL, 0);
815 
816 	if (rv != DDI_SUCCESS) {
817 		vccp->minors_assigned--;
818 		return (MDEG_FAILURE);
819 	}
820 
821 	mutex_enter(&vport->lock);
822 	vport->status = VCC_PORT_AVAIL | VCC_PORT_ADDED;
823 	mutex_exit(&vport->lock);
824 
825 
826 	return (MDEG_SUCCESS);
827 }
828 
829 /* delete a port */
830 static int
i_vcc_delete_port(vcc_t * vccp,vcc_port_t * vport)831 i_vcc_delete_port(vcc_t *vccp, vcc_port_t *vport)
832 {
833 
834 	char	name[MAXPATHLEN];
835 	int	rv;
836 
837 
838 	ASSERT(mutex_owned(&vport->lock));
839 
840 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
841 		D1("vcc_del_port port already deleted \n");
842 		return (0);
843 	}
844 
845 	if (vport->status & VCC_PORT_OPEN) {
846 		/* do not block mdeg callback */
847 		vport->valid_pid = VCC_NO_PID_BLOCKING;
848 		rv = i_vcc_close_port(vport);
849 	}
850 
851 	/* remove minor node */
852 	(void) snprintf(name, MAXPATHLEN-1, "%s%s", VCC_MINOR_NAME_PREFIX,
853 	    vport->minorp->domain_name);
854 
855 	ddi_remove_minor_node(vccp->dip, name);
856 
857 	/* let read and write thread know */
858 	cv_broadcast(&vport->read_cv);
859 	cv_broadcast(&vport->write_cv);
860 	vport->status = 0;
861 	return (rv);
862 
863 
864 }
865 
866 /* register callback to MDEG */
867 static int
i_vcc_mdeg_register(vcc_t * vccp,int instance)868 i_vcc_mdeg_register(vcc_t *vccp, int instance)
869 {
870 	mdeg_prop_spec_t	*pspecp;
871 	mdeg_node_spec_t	*ispecp;
872 	mdeg_handle_t		mdeg_hdl;
873 	int			sz;
874 	int			rv;
875 
876 	/*
877 	 * Allocate and initialize a per-instance copy
878 	 * of the global property spec array that will
879 	 * uniquely identify this vcc instance.
880 	 */
881 	sz = sizeof (vcc_prop_template);
882 	pspecp = kmem_alloc(sz, KM_SLEEP);
883 
884 	bcopy(vcc_prop_template, pspecp, sz);
885 
886 	VCC_SET_MDEG_PROP_INST(pspecp, instance);
887 
888 	/* initialize the complete prop spec structure */
889 	ispecp = kmem_zalloc(sizeof (mdeg_node_spec_t), KM_SLEEP);
890 	ispecp->namep = "virtual-device";
891 	ispecp->specp = pspecp;
892 
893 	/* perform the registration */
894 	rv = mdeg_register(ispecp, &vcc_port_match, vcc_mdeg_cb,
895 	    vccp, &mdeg_hdl);
896 
897 	if (rv != MDEG_SUCCESS) {
898 		cmn_err(CE_CONT, "i_vcc_mdeg_register:"
899 		    "mdeg_register failed (%d)\n", rv);
900 		kmem_free(ispecp, sizeof (mdeg_node_spec_t));
901 		kmem_free(pspecp, sz);
902 		return (DDI_FAILURE);
903 	}
904 
905 	/* save off data that will be needed later */
906 	vccp->md_ispecp = (void *)ispecp;
907 	vccp->mdeg_hdl = mdeg_hdl;
908 
909 	return (0);
910 }
911 
912 /* destroy all mutex from port table */
913 static void
i_vcc_cleanup_port_table(vcc_t * vccp)914 i_vcc_cleanup_port_table(vcc_t *vccp)
915 {
916 	int i;
917 	vcc_port_t *vport;
918 
919 	for (i = 0; i < VCC_MAX_PORTS; i++) {
920 		vport = &(vccp->port[i]);
921 		mutex_destroy(&vport->lock);
922 		cv_destroy(&vport->read_cv);
923 		cv_destroy(&vport->write_cv);
924 	}
925 }
926 
927 /*
928  * attach(9E): attach a device to the system.
929  * called once for each instance of the device on the system.
930  */
931 static int
vcc_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)932 vcc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
933 {
934 	int 		i, instance, inst;
935 	int 		rv = DDI_FAILURE;
936 	vcc_t		*vccp;
937 	minor_t 	minor;
938 	vcc_port_t	*vport;
939 
940 	switch (cmd) {
941 
942 	case DDI_ATTACH:
943 
944 		instance = ddi_get_instance(dip);
945 		if (ddi_soft_state_zalloc(vcc_ssp, instance) != DDI_SUCCESS)
946 			return (DDI_FAILURE);
947 
948 		vccp = ddi_get_soft_state(vcc_ssp, instance);
949 		if (vccp == NULL) {
950 			ddi_soft_state_free(vccp, instance);
951 			return (ENXIO);
952 		}
953 
954 		D1("vcc_attach: DDI_ATTACH instance=%d\n", instance);
955 
956 		/* initialize the mutex */
957 		mutex_init(&vccp->lock, NULL, MUTEX_DRIVER, NULL);
958 
959 		mutex_enter(&vccp->lock);
960 
961 		vccp->dip = dip;
962 
963 		for (i = 0; i < VCC_MAX_PORTS; i++) {
964 			vport = &(vccp->port[i]);
965 			mutex_init(&vport->lock, NULL, MUTEX_DRIVER, NULL);
966 			cv_init(&vport->read_cv, NULL, CV_DRIVER, NULL);
967 			cv_init(&vport->write_cv, NULL, CV_DRIVER, NULL);
968 			vport->valid_pid = VCC_NO_PID_BLOCKING;
969 		}
970 
971 		vport = &vccp->port[VCC_CONTROL_PORT];
972 		mutex_enter(&vport->lock);
973 
974 		vport->minorp = &vccp->minor_tbl[VCC_CONTROL_MINOR_IDX];
975 		vport->status |= VCC_PORT_AVAIL;
976 
977 		/* create a minor node for vcc control */
978 		minor = (instance << VCC_INST_SHIFT) | VCC_CONTROL_MINOR_IDX;
979 
980 		vccp->minor_tbl[VCC_CONTROL_PORT].portno =
981 		    VCC_CONTROL_MINOR_IDX;
982 
983 
984 		rv = ddi_create_minor_node(vccp->dip, "ctl", S_IFCHR, minor,
985 		    DDI_NT_SERIAL, 0);
986 
987 		mutex_exit(&vport->lock);
988 
989 		if (rv != DDI_SUCCESS) {
990 			cmn_err(CE_CONT, "vcc_attach: error"
991 			    "creating control minor node\n");
992 
993 			i_vcc_cleanup_port_table(vccp);
994 
995 			mutex_exit(&vccp->lock);
996 			/* clean up soft state */
997 			ddi_soft_state_free(vccp, instance);
998 
999 			return (DDI_FAILURE);
1000 		}
1001 
1002 		/* get the instance number by reading 'reg' property */
1003 		inst = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1004 		    "reg", -1);
1005 		if (inst == -1) {
1006 			cmn_err(CE_CONT, "vcc_attach: vcc%d has no "
1007 			    "'reg' property\n",
1008 			    ddi_get_instance(dip));
1009 
1010 			i_vcc_cleanup_port_table(vccp);
1011 
1012 			/* remove minor */
1013 			ddi_remove_minor_node(vccp->dip, NULL);
1014 
1015 			/* clean up soft state */
1016 			mutex_exit(&vccp->lock);
1017 			ddi_soft_state_free(vccp, instance);
1018 
1019 			return (DDI_FAILURE);
1020 		}
1021 
1022 		/*
1023 		 * Mdeg might invoke callback in the same call sequence
1024 		 * if there is a domain port at the time of registration.
1025 		 * Since the callback also grabs vcc->lock mutex, to avoid
1026 		 * mutex reentry error, release the lock before registration
1027 		 */
1028 		mutex_exit(&vccp->lock);
1029 
1030 		/* register for notifications from Zeus */
1031 		rv = i_vcc_mdeg_register(vccp, inst);
1032 		if (rv != MDEG_SUCCESS) {
1033 			cmn_err(CE_CONT, "vcc_attach: error register to MD\n");
1034 
1035 			i_vcc_cleanup_port_table(vccp);
1036 
1037 			/* remove minor */
1038 			ddi_remove_minor_node(vccp->dip, NULL);
1039 
1040 			/* clean up soft state */
1041 			ddi_soft_state_free(vccp, instance);
1042 
1043 			return (DDI_FAILURE);
1044 		}
1045 
1046 		return (DDI_SUCCESS);
1047 
1048 	case DDI_RESUME:
1049 
1050 		return (DDI_SUCCESS);
1051 
1052 	default:
1053 
1054 		return (DDI_FAILURE);
1055 	}
1056 }
1057 
1058 /*
1059  * detach(9E): detach a device from the system.
1060  */
1061 static int
vcc_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)1062 vcc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1063 {
1064 	int		    i, instance;
1065 	vcc_t		    *vccp;
1066 	mdeg_node_spec_t    *ispecp;
1067 	vcc_port_t	    *vport;
1068 
1069 	switch (cmd) {
1070 
1071 	case DDI_DETACH:
1072 
1073 		instance = ddi_get_instance(dip);
1074 		vccp = ddi_get_soft_state(vcc_ssp, instance);
1075 		if (vccp == NULL)
1076 			return (ENXIO);
1077 
1078 		D1("vcc_detach: DDI_DETACH instance=%d\n", instance);
1079 
1080 		mutex_enter(&vccp->lock);
1081 
1082 		/* unregister from MD event generator */
1083 
1084 		ASSERT(vccp->mdeg_hdl);
1085 		(void) mdeg_unregister(vccp->mdeg_hdl);
1086 
1087 		ispecp = (mdeg_node_spec_t *)vccp->md_ispecp;
1088 		ASSERT(ispecp);
1089 
1090 		kmem_free(ispecp->specp, sizeof (vcc_prop_template));
1091 		kmem_free(ispecp, sizeof (mdeg_node_spec_t));
1092 
1093 		/* remove minor nodes */
1094 		ddi_remove_minor_node(vccp->dip, NULL);
1095 		mutex_exit(&vccp->lock);
1096 
1097 		for (i = 0; i < VCC_MAX_PORTS; i++) {
1098 
1099 			vport = &vccp->port[i];
1100 			mutex_enter(&vport->lock);
1101 			if (i == VCC_CONTROL_PORT) {
1102 				if (vport->status & VCC_PORT_OPEN) {
1103 					(void) i_vcc_close_port(vport);
1104 				}
1105 			}
1106 
1107 			if ((vccp->port[i].status & VCC_PORT_AVAIL) &&
1108 			    (i != VCC_CONTROL_PORT)) {
1109 				D1("vcc_detach: removing port port@%d\n", i);
1110 				(void) i_vcc_delete_port(vccp, vport);
1111 			}
1112 			mutex_exit(&vport->lock);
1113 			cv_destroy(&vport->read_cv);
1114 			cv_destroy(&vport->write_cv);
1115 			mutex_destroy(&vport->lock);
1116 		}
1117 
1118 
1119 
1120 		/* destroy mutex and free the soft state */
1121 		mutex_destroy(&vccp->lock);
1122 		ddi_soft_state_free(vcc_ssp, instance);
1123 
1124 		return (DDI_SUCCESS);
1125 
1126 	case DDI_SUSPEND:
1127 
1128 		return (DDI_SUCCESS);
1129 
1130 	default:
1131 
1132 		return (DDI_FAILURE);
1133 	}
1134 }
1135 
1136 /* cb_open */
1137 static int
vcc_open(dev_t * devp,int flag,int otyp,cred_t * cred)1138 vcc_open(dev_t *devp, int flag, int otyp, cred_t *cred)
1139 {
1140 	_NOTE(ARGUNUSED(otyp, cred))
1141 
1142 	int	    instance;
1143 	int	    rv = EIO;
1144 	minor_t	    minor;
1145 	uint_t	    portno;
1146 	vcc_t	    *vccp;
1147 	vcc_port_t  *vport;
1148 
1149 	minor = getminor(*devp);
1150 	instance = VCCINST(minor);
1151 
1152 	vccp = ddi_get_soft_state(vcc_ssp, instance);
1153 	if (vccp == NULL) {
1154 		return (ENXIO);
1155 	}
1156 
1157 	portno = VCCPORT(vccp, minor);
1158 
1159 	vport = &(vccp->port[portno]);
1160 
1161 	mutex_enter(&vport->lock);
1162 
1163 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
1164 		/* port may be removed */
1165 		mutex_exit(&vport->lock);
1166 		return (ENXIO);
1167 	}
1168 
1169 	if (vport->status & VCC_PORT_OPEN) {
1170 		/* only one open per port */
1171 		cmn_err(CE_CONT, "vcc_open: virtual-console-concentrator@%d:%d "
1172 		    "is already open\n", instance, portno);
1173 		mutex_exit(&vport->lock);
1174 		return (EAGAIN);
1175 	}
1176 
1177 	/* check minor no and pid */
1178 	if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
1179 	    vport)) != 0) {
1180 		mutex_exit(&vport->lock);
1181 		return (rv);
1182 	}
1183 
1184 	if (portno == VCC_CONTROL_PORT) {
1185 		vport->status |= VCC_PORT_OPEN;
1186 		mutex_exit(&vport->lock);
1187 		return (0);
1188 	}
1189 
1190 	/*
1191 	 * the port may just be added by mdeg callback and may
1192 	 * not be configured yet.
1193 	 */
1194 	if (vport->ldc_id == VCC_INVALID_CHANNEL) {
1195 		mutex_exit(&vport->lock);
1196 		return (ENXIO);
1197 	}
1198 
1199 
1200 	/* check if channel has been initialized */
1201 	if ((vport->status & VCC_PORT_LDC_CHANNEL_READY) == 0) {
1202 		rv = i_vcc_ldc_init(vccp, vport);
1203 		if (rv) {
1204 			mutex_exit(&vport->lock);
1205 			return (EIO);
1206 		}
1207 
1208 		/* mark port as ready */
1209 		vport->status |= VCC_PORT_LDC_CHANNEL_READY;
1210 	}
1211 
1212 	vport->status |= VCC_PORT_USE_READ_LDC | VCC_PORT_USE_WRITE_LDC|
1213 	    VCC_PORT_TERM_RD|VCC_PORT_TERM_WR|VCC_PORT_OPEN;
1214 
1215 	if ((flag & O_NONBLOCK) || (flag & O_NDELAY)) {
1216 		vport->status |= VCC_PORT_NONBLOCK;
1217 	}
1218 
1219 	mutex_exit(&vport->lock);
1220 
1221 	return (0);
1222 }
1223 
1224 /* close port */
1225 static int
i_vcc_close_port(vcc_port_t * vport)1226 i_vcc_close_port(vcc_port_t *vport)
1227 {
1228 
1229 	if ((vport->status & VCC_PORT_OPEN) == 0) {
1230 		return (0);
1231 	}
1232 
1233 	ASSERT(mutex_owned(&vport->lock));
1234 
1235 	if (vport->status & VCC_PORT_LDC_CHANNEL_READY) {
1236 		/* clean up ldc channel */
1237 		i_vcc_ldc_fini(vport);
1238 		vport->status &= ~VCC_PORT_LDC_CHANNEL_READY;
1239 	}
1240 
1241 	/* reset  rd/wr suspends  */
1242 	vport->status |= VCC_PORT_TERM_RD | VCC_PORT_TERM_WR;
1243 	vport->status &= ~VCC_PORT_NONBLOCK;
1244 	vport->status &= ~VCC_PORT_OPEN;
1245 	vport->valid_pid = VCC_NO_PID_BLOCKING;
1246 
1247 	/* signal any blocked read and write thread */
1248 	cv_broadcast(&vport->read_cv);
1249 	cv_broadcast(&vport->write_cv);
1250 
1251 	return (0);
1252 }
1253 
1254 /* cb_close */
1255 static int
vcc_close(dev_t dev,int flag,int otyp,cred_t * cred)1256 vcc_close(dev_t dev, int flag, int otyp, cred_t *cred)
1257 {
1258 	_NOTE(ARGUNUSED(flag, otyp, cred))
1259 
1260 	int	    instance;
1261 	minor_t	    minor;
1262 	int	    rv = EIO;
1263 	uint_t	    portno;
1264 	vcc_t	    *vccp;
1265 	vcc_port_t  *vport;
1266 
1267 	minor = getminor(dev);
1268 
1269 	instance = VCCINST(minor);
1270 	vccp = ddi_get_soft_state(vcc_ssp, instance);
1271 	if (vccp == NULL) {
1272 		return (ENXIO);
1273 	}
1274 
1275 	portno = VCCPORT(vccp, minor);
1276 
1277 	D1("vcc_close: closing virtual-console-concentrator@%d:%d\n",
1278 	    instance, portno);
1279 	vport = &(vccp->port[portno]);
1280 
1281 
1282 	/*
1283 	 * needs lock to provent i_vcc_delete_port, which is called by
1284 	 * the mdeg callback, from closing port.
1285 	 */
1286 	mutex_enter(&vport->lock);
1287 
1288 	if ((vport->status & VCC_PORT_OPEN) == 0) {
1289 		mutex_exit(&vport->lock);
1290 		return (0);
1291 	}
1292 
1293 	if (portno == VCC_CONTROL_PORT) {
1294 		/*
1295 		 * vntsd closes control port before it exits. There
1296 		 * could be events still pending for vntsd.
1297 		 */
1298 		mutex_exit(&vport->lock);
1299 		rv = i_vcc_reset_events(vccp);
1300 		return (0);
1301 	}
1302 
1303 
1304 	/* check minor no and pid */
1305 	if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
1306 	    vport)) != 0) {
1307 		mutex_exit(&vport->lock);
1308 		return (rv);
1309 	}
1310 
1311 	rv = i_vcc_close_port(vport);
1312 	mutex_exit(&vport->lock);
1313 
1314 	return (rv);
1315 }
1316 
1317 /*
1318  * ioctl VCC_CONS_TBL - vntsd allocates buffer according to return of
1319  * VCC_NUM_PORTS. However, when vntsd requests for the console table, console
1320  * ports could be deleted or added. parameter num_ports is number of structures
1321  * that vntsd allocated for the table. If there are more ports than
1322  * num_ports, set up to wakeup vntsd to add ports.
1323  * If there less ports than num_ports, fill (-1) for cons_no to tell vntsd.
1324  */
1325 static int
i_vcc_cons_tbl(vcc_t * vccp,uint_t num_ports,caddr_t buf,int mode)1326 i_vcc_cons_tbl(vcc_t *vccp, uint_t num_ports, caddr_t buf, int mode)
1327 {
1328 	vcc_console_t	cons;
1329 	int		i;
1330 	vcc_port_t	*vport;
1331 	boolean_t	notify_vntsd = B_FALSE;
1332 	char pathname[MAXPATHLEN];
1333 
1334 
1335 	(void) ddi_pathname(vccp->dip, pathname);
1336 	for (i = 0; i < VCC_MAX_PORTS; i++) {
1337 
1338 		vport = &vccp->port[i];
1339 
1340 		if (i == VCC_CONTROL_PORT) {
1341 			continue;
1342 		}
1343 
1344 		if ((vport->status & VCC_PORT_AVAIL) == 0) {
1345 			continue;
1346 		}
1347 
1348 		/* a port exists before vntsd becomes online */
1349 		mutex_enter(&vport->lock);
1350 
1351 		if (num_ports == 0) {
1352 			/* more ports than vntsd's buffer can hold */
1353 			vport->status |= VCC_PORT_ADDED;
1354 			notify_vntsd = B_TRUE;
1355 			mutex_exit(&vport->lock);
1356 			continue;
1357 		}
1358 
1359 		bzero(&cons, sizeof (vcc_console_t));
1360 
1361 		/* construct console buffer */
1362 		cons.cons_no = vport->number;
1363 		cons.tcp_port = vport->tcp_port;
1364 		(void) memcpy(cons.domain_name,
1365 		    vport->minorp->domain_name, MAXPATHLEN);
1366 
1367 		(void) memcpy(cons.group_name, vport->group_name,
1368 		    MAXPATHLEN);
1369 		vport->status &= ~VCC_PORT_ADDED;
1370 		mutex_exit(&vport->lock);
1371 
1372 		(void) snprintf(cons.dev_name, MAXPATHLEN-1, "%s:%s%s",
1373 		    pathname, VCC_MINOR_NAME_PREFIX, cons.domain_name);
1374 
1375 		/* copy out data */
1376 		if (ddi_copyout(&cons, (void *)buf,
1377 		    sizeof (vcc_console_t), mode)) {
1378 			mutex_exit(&vport->lock);
1379 			return (EFAULT);
1380 		}
1381 		buf += sizeof (vcc_console_t);
1382 
1383 		num_ports--;
1384 
1385 	}
1386 
1387 	if (num_ports == 0) {
1388 		/* vntsd's buffer is full */
1389 
1390 		if (notify_vntsd) {
1391 			/* more ports need to notify vntsd */
1392 			vport = &vccp->port[VCC_CONTROL_PORT];
1393 			mutex_enter(&vport->lock);
1394 			vport->pollevent |= VCC_POLL_ADD_PORT;
1395 			mutex_exit(&vport->lock);
1396 		}
1397 
1398 		return (0);
1399 	}
1400 
1401 	/* less ports than vntsd expected */
1402 	bzero(&cons, sizeof (vcc_console_t));
1403 	cons.cons_no = -1;
1404 
1405 	while (num_ports > 0) {
1406 		/* fill vntsd buffer with no console */
1407 		if (ddi_copyout(&cons, (void *)buf,
1408 		    sizeof (vcc_console_t), mode) != 0) {
1409 			mutex_exit(&vport->lock);
1410 			return (EFAULT);
1411 		}
1412 		D1("i_vcc_cons_tbl: a port is  deleted\n");
1413 		buf += sizeof (vcc_console_t) +MAXPATHLEN;
1414 		num_ports--;
1415 	}
1416 
1417 	return (0);
1418 }
1419 
1420 
1421 /* turn off event flag if there is no more change */
1422 static void
i_vcc_turn_off_event(vcc_t * vccp,uint32_t port_status,uint32_t event)1423 i_vcc_turn_off_event(vcc_t *vccp, uint32_t port_status, uint32_t event)
1424 {
1425 
1426 	vcc_port_t *vport;
1427 	int i;
1428 
1429 	for (i = 0; i < VCC_MAX_PORTS; i++) {
1430 
1431 		vport = &(vccp->port[i]);
1432 
1433 		if ((vport->status & VCC_PORT_AVAIL) == 0) {
1434 			continue;
1435 		}
1436 
1437 
1438 		if (vport->status & port_status) {
1439 			/* more port changes status */
1440 			return;
1441 		}
1442 
1443 	}
1444 
1445 	/* no more changed port  */
1446 	vport = &vccp->port[VCC_CONTROL_PORT];
1447 
1448 	/* turn off event */
1449 	mutex_enter(&vport->lock);
1450 	vport->pollevent &= ~event;
1451 	mutex_exit(&vport->lock);
1452 }
1453 
1454 /* ioctl VCC_CONS_INFO */
1455 static int
i_vcc_cons_info(vcc_t * vccp,caddr_t buf,int mode)1456 i_vcc_cons_info(vcc_t *vccp, caddr_t buf, int mode)
1457 {
1458 	vcc_console_t	cons;
1459 	uint_t		portno;
1460 	vcc_port_t	*vport;
1461 	char pathname[MAXPATHLEN];
1462 
1463 	/* read in portno */
1464 	if (ddi_copyin((void*)buf, &portno, sizeof (uint_t), mode)) {
1465 		return (EFAULT);
1466 	}
1467 
1468 	D1("i_vcc_cons_info@%d:\n", portno);
1469 
1470 	if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
1471 		return (EINVAL);
1472 	}
1473 
1474 	vport = &vccp->port[portno];
1475 
1476 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
1477 		return (EINVAL);
1478 	}
1479 
1480 	mutex_enter(&vport->lock);
1481 	vport->status &= ~VCC_PORT_ADDED;
1482 
1483 	/* construct configruation data  */
1484 	bzero(&cons, sizeof (vcc_console_t));
1485 
1486 	cons.cons_no = vport->number;
1487 	cons.tcp_port = vport->tcp_port;
1488 
1489 	(void) memcpy(cons.domain_name, vport->minorp->domain_name, MAXPATHLEN);
1490 
1491 	(void) memcpy(cons.group_name, vport->group_name, MAXPATHLEN);
1492 
1493 	mutex_exit(&vport->lock);
1494 
1495 	(void) ddi_pathname(vccp->dip, pathname),
1496 
1497 	    /* copy device name */
1498 	    (void) snprintf(cons.dev_name, MAXPATHLEN-1, "%s:%s%s",
1499 	    pathname, VCC_MINOR_NAME_PREFIX, cons.domain_name);
1500 	/* copy data */
1501 	if (ddi_copyout(&cons, (void *)buf,
1502 	    sizeof (vcc_console_t), mode) != 0) {
1503 		mutex_exit(&vport->lock);
1504 		return (EFAULT);
1505 	}
1506 
1507 	D1("i_vcc_cons_info@%d:domain:%s serv:%s tcp@%lld %s\n",
1508 	    cons.cons_no, cons.domain_name,
1509 	    cons.group_name, cons.tcp_port, cons.dev_name);
1510 
1511 	i_vcc_turn_off_event(vccp, VCC_PORT_ADDED, VCC_POLL_ADD_PORT);
1512 
1513 	return (0);
1514 }
1515 
1516 
1517 /* response to vntsd inquiry ioctl call */
1518 static int
i_vcc_inquiry(vcc_t * vccp,caddr_t buf,int mode)1519 i_vcc_inquiry(vcc_t *vccp, caddr_t buf, int mode)
1520 {
1521 	vcc_port_t	*vport;
1522 	uint_t		i;
1523 	vcc_response_t	msg;
1524 
1525 	vport = &(vccp->port[VCC_CONTROL_PORT]);
1526 
1527 	if ((vport->pollevent & VCC_POLL_ADD_PORT) == 0) {
1528 		return (EINVAL);
1529 	}
1530 
1531 	/* an added port */
1532 
1533 	D1("i_vcc_inquiry\n");
1534 
1535 	for (i = 0; i < VCC_MAX_PORTS; i++) {
1536 		if ((vccp->port[i].status & VCC_PORT_AVAIL) == 0) {
1537 			continue;
1538 		}
1539 
1540 		if (vccp->port[i].status & VCC_PORT_ADDED) {
1541 			/* port added */
1542 			msg.reason = VCC_CONS_ADDED;
1543 			msg.cons_no = i;
1544 
1545 			if (ddi_copyout((void *)&msg, (void *)buf,
1546 			    sizeof (msg), mode) == -1) {
1547 				cmn_err(CE_CONT, "i_vcc_find_changed_port:"
1548 				    "ddi_copyout"
1549 				    " failed\n");
1550 				return (EFAULT);
1551 			}
1552 			return (0);
1553 		}
1554 	}
1555 
1556 	/* the added port was deleted before vntsd wakes up */
1557 	msg.reason = VCC_CONS_MISS_ADDED;
1558 
1559 	if (ddi_copyout((void *)&msg, (void *)buf,
1560 	    sizeof (msg), mode) == -1) {
1561 		cmn_err(CE_CONT, "i_vcc_find_changed_port: ddi_copyout"
1562 		    " failed\n");
1563 		return (EFAULT);
1564 	}
1565 
1566 	return (0);
1567 }
1568 
1569 /* clean up events after vntsd exits */
1570 static int
i_vcc_reset_events(vcc_t * vccp)1571 i_vcc_reset_events(vcc_t *vccp)
1572 {
1573 	uint_t	    i;
1574 	vcc_port_t  *vport;
1575 
1576 	for (i = 0; i < VCC_MAX_PORTS; i++) {
1577 		vport = &(vccp->port[i]);
1578 
1579 		if ((vport->status & VCC_PORT_AVAIL) == 0) {
1580 			continue;
1581 		}
1582 
1583 		ASSERT(!mutex_owned(&vport->lock));
1584 
1585 		if (i == VCC_CONTROL_PORT) {
1586 			/* close control port */
1587 			mutex_enter(&vport->lock);
1588 			vport->status &= ~VCC_PORT_OPEN;
1589 
1590 			/* clean up poll events */
1591 			vport->pollevent = 0;
1592 			vport->pollflag = 0;
1593 			mutex_exit(&vport->lock);
1594 			continue;
1595 		}
1596 		if (vport->status & VCC_PORT_ADDED) {
1597 			/* pending added port event to vntsd */
1598 			mutex_enter(&vport->lock);
1599 			vport->status &= ~VCC_PORT_ADDED;
1600 			mutex_exit(&vport->lock);
1601 		}
1602 
1603 	}
1604 
1605 	vport = &vccp->port[VCC_CONTROL_PORT];
1606 
1607 	return (0);
1608 }
1609 
1610 /* ioctl VCC_FORCE_CLOSE */
1611 static int
i_vcc_force_close(vcc_t * vccp,caddr_t buf,int mode)1612 i_vcc_force_close(vcc_t *vccp, caddr_t buf, int mode)
1613 {
1614 	uint_t		portno;
1615 	vcc_port_t	*vport;
1616 	int		rv;
1617 
1618 	/* read in portno */
1619 	if (ddi_copyin((void*)buf, &portno, sizeof (uint_t), mode)) {
1620 		return (EFAULT);
1621 	}
1622 
1623 	D1("i_vcc_force_close@%d:\n", portno);
1624 
1625 	if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
1626 		return (EINVAL);
1627 	}
1628 
1629 	vport = &vccp->port[portno];
1630 
1631 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
1632 		return (EINVAL);
1633 	}
1634 
1635 	mutex_enter(&vport->lock);
1636 
1637 	rv = i_vcc_close_port(vport);
1638 
1639 	/* block callers other than vntsd */
1640 	vport->valid_pid = ddi_get_pid();
1641 
1642 	mutex_exit(&vport->lock);
1643 	return (rv);
1644 
1645 }
1646 
1647 /* ioctl VCC_CONS_STATUS */
1648 static int
i_vcc_cons_status(vcc_t * vccp,caddr_t buf,int mode)1649 i_vcc_cons_status(vcc_t *vccp, caddr_t buf, int mode)
1650 {
1651 	vcc_console_t	console;
1652 	vcc_port_t	*vport;
1653 
1654 	/* read in portno */
1655 	if (ddi_copyin((void*)buf, &console, sizeof (console), mode)) {
1656 		return (EFAULT);
1657 	}
1658 
1659 	D1("i_vcc_cons_status@%d:\n", console.cons_no);
1660 
1661 	if ((console.cons_no >= VCC_MAX_PORTS) ||
1662 	    (console.cons_no == VCC_CONTROL_PORT)) {
1663 		return (EINVAL);
1664 	}
1665 
1666 
1667 	vport = &vccp->port[console.cons_no];
1668 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
1669 		console.cons_no = -1;
1670 	} else  if (strncmp(console.domain_name, vport->minorp->domain_name,
1671 	    MAXPATHLEN)) {
1672 		console.cons_no = -1;
1673 	} else if (strncmp(console.group_name, vport->group_name,
1674 	    MAXPATHLEN)) {
1675 		console.cons_no = -1;
1676 	} else if (console.tcp_port != vport->tcp_port) {
1677 		console.cons_no = -1;
1678 	} else if (vport->ldc_id == VCC_INVALID_CHANNEL) {
1679 		console.cons_no = -1;
1680 	}
1681 
1682 	D1("i_vcc_cons_status@%d: %s %s %llx\n", console.cons_no,
1683 	    console.group_name, console.domain_name, console.tcp_port);
1684 	if (ddi_copyout(&console, (void *)buf, sizeof (console), mode) == -1) {
1685 		cmn_err(CE_CONT, "i_vcc_cons_status ddi_copyout failed\n");
1686 		return (EFAULT);
1687 	}
1688 
1689 	return (0);
1690 }
1691 
1692 /* cb_ioctl handler for vcc control port */
1693 static int
i_vcc_ctrl_ioctl(vcc_t * vccp,int cmd,void * arg,int mode)1694 i_vcc_ctrl_ioctl(vcc_t *vccp, int cmd, void* arg, int mode)
1695 {
1696 
1697 	static uint_t	num_ports;
1698 
1699 
1700 	switch (cmd) {
1701 
1702 	case VCC_NUM_CONSOLE:
1703 
1704 		mutex_enter(&vccp->lock);
1705 		num_ports = vccp->num_ports;
1706 		mutex_exit(&vccp->lock);
1707 		/* number of consoles */
1708 
1709 		return (ddi_copyout((void *)&num_ports, arg,
1710 		    sizeof (int), mode));
1711 	case VCC_CONS_TBL:
1712 
1713 		/* console config table */
1714 		return (i_vcc_cons_tbl(vccp, num_ports, (caddr_t)arg, mode));
1715 
1716 	case VCC_INQUIRY:
1717 
1718 		/* reason for wakeup */
1719 		return (i_vcc_inquiry(vccp, (caddr_t)arg, mode));
1720 
1721 	case VCC_CONS_INFO:
1722 		/* a console config */
1723 		return (i_vcc_cons_info(vccp, (caddr_t)arg, mode));
1724 
1725 	case VCC_FORCE_CLOSE:
1726 		/* force to close a console */
1727 		return (i_vcc_force_close(vccp, (caddr_t)arg, mode));
1728 
1729 	case VCC_CONS_STATUS:
1730 		/* console status */
1731 		return (i_vcc_cons_status(vccp, (caddr_t)arg, mode));
1732 
1733 	default:
1734 
1735 		/* unknown command */
1736 		return (ENODEV);
1737 	}
1738 
1739 
1740 }
1741 
1742 /* write data to ldc. may block if channel has no space for write */
1743 static int
i_vcc_write_ldc(vcc_port_t * vport,vcc_msg_t * buf)1744 i_vcc_write_ldc(vcc_port_t *vport, vcc_msg_t *buf)
1745 {
1746 	int	rv = EIO;
1747 	size_t	size;
1748 
1749 	ASSERT(mutex_owned(&vport->lock));
1750 	ASSERT((vport->status & VCC_PORT_USE_WRITE_LDC) == 0);
1751 
1752 	for (; ; ) {
1753 
1754 		size = VCC_HDR_SZ + buf->size;
1755 		rv = ldc_write(vport->ldc_handle, (caddr_t)buf, &size);
1756 
1757 		D1("i_vcc_write_ldc: port@%d: err=%d %d bytes\n",
1758 		    vport->number, rv, size);
1759 
1760 		if (rv == 0) {
1761 			return (rv);
1762 		}
1763 
1764 		if (rv != EWOULDBLOCK) {
1765 			return (EIO);
1766 		}
1767 
1768 		if (vport->status & VCC_PORT_NONBLOCK) {
1769 			return (EAGAIN);
1770 		}
1771 
1772 		/*  block util ldc has more space */
1773 
1774 		rv = i_vcc_wait_port_status(vport, &vport->write_cv,
1775 		    VCC_PORT_LDC_WRITE_READY);
1776 
1777 		if (rv) {
1778 			return (rv);
1779 		}
1780 
1781 		vport->status &= ~VCC_PORT_LDC_WRITE_READY;
1782 
1783 	}
1784 
1785 }
1786 
1787 
1788 
1789 /* cb_ioctl handler for port ioctl */
1790 static int
i_vcc_port_ioctl(vcc_t * vccp,minor_t minor,int portno,int cmd,void * arg,int mode)1791 i_vcc_port_ioctl(vcc_t *vccp, minor_t minor, int portno, int cmd, void *arg,
1792     int mode)
1793 {
1794 
1795 	vcc_port_t	*vport;
1796 	struct termios	term;
1797 	vcc_msg_t	buf;
1798 	int		rv;
1799 
1800 	D1("i_vcc_port_ioctl@%d cmd %d\n", portno, cmd);
1801 
1802 	vport = &(vccp->port[portno]);
1803 
1804 	if ((vport->status & VCC_PORT_AVAIL) == 0) {
1805 		return (EIO);
1806 	}
1807 
1808 
1809 	switch (cmd) {
1810 
1811 	/* terminal support */
1812 	case TCGETA:
1813 	case TCGETS:
1814 
1815 		mutex_enter(&vport->lock);
1816 
1817 		/* check minor no and pid */
1818 		if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
1819 		    vport)) != 0) {
1820 			mutex_exit(&vport->lock);
1821 			return (rv);
1822 		}
1823 
1824 		(void) memcpy(&term, &vport->term, sizeof (term));
1825 		mutex_exit(&vport->lock);
1826 
1827 		return (ddi_copyout(&term, arg, sizeof (term), mode));
1828 
1829 	case TCSETS:
1830 	case TCSETA:
1831 	case TCSETAW:
1832 	case TCSETAF:
1833 
1834 		if (ddi_copyin(arg, &term, sizeof (term), mode) != 0) {
1835 			return (EFAULT);
1836 		}
1837 
1838 		mutex_enter(&vport->lock);
1839 
1840 		/* check minor no and pid */
1841 		if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
1842 		    vport)) != 0) {
1843 			mutex_exit(&vport->lock);
1844 			return (rv);
1845 		}
1846 
1847 		(void) memcpy(&vport->term, &term, sizeof (term));
1848 		mutex_exit(&vport->lock);
1849 		return (0);
1850 
1851 
1852 	case TCSBRK:
1853 
1854 		/* send break to console */
1855 		mutex_enter(&vport->lock);
1856 
1857 		/* check minor no and pid */
1858 		if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
1859 		    vport)) != 0) {
1860 			mutex_exit(&vport->lock);
1861 			return (rv);
1862 		}
1863 
1864 		/* wait for write available */
1865 		rv = i_vcc_wait_port_status(vport, &vport->write_cv,
1866 		    VCC_PORT_LDC_CHANNEL_READY| VCC_PORT_USE_WRITE_LDC);
1867 		if (rv) {
1868 			mutex_exit(&vport->lock);
1869 			return (rv);
1870 		}
1871 
1872 		vport->status &= ~VCC_PORT_USE_WRITE_LDC;
1873 
1874 		buf.type = LDC_CONSOLE_CTRL;
1875 		buf.ctrl_msg = LDC_CONSOLE_BREAK;
1876 		buf.size = 0;
1877 
1878 		rv = i_vcc_write_ldc(vport, &buf);
1879 
1880 		mutex_exit(&vport->lock);
1881 
1882 		i_vcc_set_port_status(vport, &vport->write_cv,
1883 		    VCC_PORT_USE_WRITE_LDC);
1884 		return (0);
1885 
1886 	case TCXONC:
1887 		/* suspend read or write */
1888 		if (ddi_copyin(arg, &cmd, sizeof (int), mode) != 0) {
1889 			return (EFAULT);
1890 		}
1891 
1892 		mutex_enter(&vport->lock);
1893 
1894 		/* check minor no and pid */
1895 		if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
1896 		    vport)) != 0) {
1897 			mutex_exit(&vport->lock);
1898 			return (rv);
1899 		}
1900 
1901 
1902 		switch (cmd) {
1903 
1904 		case 0:
1905 			/* suspend read */
1906 			vport->status &= ~VCC_PORT_TERM_RD;
1907 			break;
1908 
1909 		case 1:
1910 			/* resume read */
1911 			vport->status |= VCC_PORT_TERM_RD;
1912 			cv_broadcast(&vport->read_cv);
1913 			break;
1914 
1915 		case 2:
1916 			/* suspend write */
1917 			vport->status &= ~VCC_PORT_TERM_WR;
1918 			break;
1919 
1920 		case 3:
1921 			/* resume write */
1922 			vport->status |= VCC_PORT_TERM_WR;
1923 			cv_broadcast(&vport->write_cv);
1924 			break;
1925 
1926 		default:
1927 			mutex_exit(&vport->lock);
1928 			return (EINVAL);
1929 		}
1930 
1931 		mutex_exit(&vport->lock);
1932 		return (0);
1933 
1934 	case TCFLSH:
1935 		return (0);
1936 
1937 	default:
1938 		return (EINVAL);
1939 	}
1940 
1941 }
1942 
1943 /* cb_ioctl */
1944 static int
vcc_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)1945 vcc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
1946     cred_t *credp, int *rvalp)
1947 {
1948 	_NOTE(ARGUNUSED(credp, rvalp))
1949 
1950 	int instance;
1951 	minor_t minor;
1952 	int portno;
1953 	vcc_t *vccp;
1954 
1955 	minor = getminor(dev);
1956 
1957 	instance = VCCINST(minor);
1958 
1959 	vccp = ddi_get_soft_state(vcc_ssp, instance);
1960 	if (vccp == NULL) {
1961 		return (ENXIO);
1962 	}
1963 
1964 	portno = VCCPORT(vccp, minor);
1965 
1966 	D1("vcc_ioctl: virtual-console-concentrator@%d:%d\n", instance, portno);
1967 
1968 	if (portno >= VCC_MAX_PORTS) {
1969 		cmn_err(CE_CONT, "vcc_ioctl:virtual-console-concentrator@%d"
1970 		    " invalid portno\n", portno);
1971 		return (EINVAL);
1972 	}
1973 
1974 	D1("vcc_ioctl: virtual-console-concentrator@%d:%d ioctl cmd=%d\n",
1975 	    instance, portno, cmd);
1976 
1977 	if (portno == VCC_CONTROL_PORT) {
1978 		/* control ioctl */
1979 		return (i_vcc_ctrl_ioctl(vccp, cmd, (void *)arg, mode));
1980 	}
1981 
1982 	/* data port ioctl */
1983 	return (i_vcc_port_ioctl(vccp, minor, portno, cmd, (void *)arg, mode));
1984 }
1985 
1986 /* cb_read */
1987 static int
vcc_read(dev_t dev,struct uio * uiop,cred_t * credp)1988 vcc_read(dev_t dev, struct uio *uiop, cred_t *credp)
1989 {
1990 	_NOTE(ARGUNUSED(credp))
1991 
1992 	int	    instance;
1993 	minor_t	    minor;
1994 	uint_t	    portno;
1995 	vcc_t	    *vccp;
1996 	vcc_port_t  *vport;
1997 	int	    rv = EIO;	/* by default fail ! */
1998 	char 		*buf;
1999 	size_t		uio_size;
2000 	size_t		size;
2001 
2002 	minor = getminor(dev);
2003 
2004 	instance = VCCINST(minor);
2005 
2006 	vccp = ddi_get_soft_state(vcc_ssp, instance);
2007 	if (vccp == NULL) {
2008 		return (ENXIO);
2009 	}
2010 
2011 	portno = VCCPORT(vccp, minor);
2012 
2013 	/* no read for control port */
2014 	if (portno == VCC_CONTROL_PORT) {
2015 		return (EIO);
2016 	}
2017 
2018 	/* temp buf to hold ldc data */
2019 	uio_size = uiop->uio_resid;
2020 
2021 	if (uio_size < VCC_MTU_SZ) {
2022 		return (EINVAL);
2023 	}
2024 
2025 	vport = &(vccp->port[portno]);
2026 
2027 	mutex_enter(&vport->lock);
2028 
2029 	/* check minor no and pid */
2030 	if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
2031 	    vport)) != 0) {
2032 		mutex_exit(&vport->lock);
2033 		return (rv);
2034 	}
2035 
2036 	rv = i_vcc_wait_port_status(vport, &vport->read_cv,
2037 	    VCC_PORT_TERM_RD|VCC_PORT_LDC_CHANNEL_READY|
2038 	    VCC_PORT_USE_READ_LDC);
2039 	if (rv) {
2040 		mutex_exit(&vport->lock);
2041 		return (rv);
2042 	}
2043 
2044 	buf = kmem_alloc(uio_size, KM_SLEEP);
2045 
2046 	vport->status &= ~VCC_PORT_USE_READ_LDC;
2047 
2048 	for (; ; ) {
2049 
2050 		size = uio_size;
2051 		rv = i_vcc_read_ldc(vport, buf, &size);
2052 
2053 
2054 		if (rv == EAGAIN) {
2055 			/* should block? */
2056 			if (vport->status & VCC_PORT_NONBLOCK) {
2057 				break;
2058 			}
2059 
2060 		} else if (rv) {
2061 			/* error */
2062 			break;
2063 		}
2064 
2065 		if (size > 0) {
2066 			/* got data */
2067 			break;
2068 		}
2069 
2070 		/* wait for data from ldc */
2071 		vport->status &= ~VCC_PORT_LDC_DATA_READY;
2072 
2073 		mutex_exit(&vport->lock);
2074 		i_vcc_set_port_status(vport, &vport->read_cv,
2075 		    VCC_PORT_USE_READ_LDC);
2076 		mutex_enter(&vport->lock);
2077 
2078 		rv = i_vcc_wait_port_status(vport, &vport->read_cv,
2079 		    VCC_PORT_TERM_RD|VCC_PORT_LDC_CHANNEL_READY|
2080 		    VCC_PORT_USE_READ_LDC| VCC_PORT_LDC_DATA_READY);
2081 		if (rv) {
2082 			break;
2083 		}
2084 
2085 		vport->status &= ~VCC_PORT_USE_READ_LDC;
2086 	}
2087 
2088 	mutex_exit(&vport->lock);
2089 
2090 	if ((rv == 0) && (size > 0)) {
2091 		/* data is in buf */
2092 		rv = uiomove(buf, size, UIO_READ, uiop);
2093 	}
2094 
2095 	kmem_free(buf, uio_size);
2096 	i_vcc_set_port_status(vport, &vport->read_cv, VCC_PORT_USE_READ_LDC);
2097 
2098 	return (rv);
2099 }
2100 
2101 
2102 /* cb_write */
2103 static int
vcc_write(dev_t dev,struct uio * uiop,cred_t * credp)2104 vcc_write(dev_t dev, struct uio *uiop, cred_t *credp)
2105 {
2106 	_NOTE(ARGUNUSED(credp))
2107 
2108 	int	    instance;
2109 	minor_t	    minor;
2110 	size_t	    size;
2111 	size_t	    bytes;
2112 	uint_t	    portno;
2113 	vcc_t	    *vccp;
2114 
2115 	vcc_port_t  *vport;
2116 	int	    rv = EIO;
2117 
2118 	vcc_msg_t	buf;
2119 
2120 	minor = getminor(dev);
2121 
2122 	instance = VCCINST(minor);
2123 
2124 	vccp = ddi_get_soft_state(vcc_ssp, instance);
2125 	if (vccp == NULL) {
2126 		return (ENXIO);
2127 	}
2128 
2129 	portno = VCCPORT(vccp, minor);
2130 
2131 	/* no write for control port */
2132 	if (portno == VCC_CONTROL_PORT) {
2133 		return (EIO);
2134 	}
2135 	vport = &(vccp->port[portno]);
2136 
2137 	/*
2138 	 * check if the channel has been configured,
2139 	 * if write has been suspend and grab write lock.
2140 	 */
2141 	mutex_enter(&vport->lock);
2142 
2143 	/* check minor no and pid */
2144 	if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
2145 	    vport)) != 0) {
2146 		mutex_exit(&vport->lock);
2147 		return (rv);
2148 	}
2149 
2150 	rv = i_vcc_wait_port_status(vport, &vport->write_cv,
2151 	    VCC_PORT_TERM_WR|VCC_PORT_LDC_CHANNEL_READY|
2152 	    VCC_PORT_USE_WRITE_LDC);
2153 	if (rv) {
2154 		mutex_exit(&vport->lock);
2155 		return (rv);
2156 	}
2157 
2158 	vport->status &= ~VCC_PORT_USE_WRITE_LDC;
2159 	mutex_exit(&vport->lock);
2160 	size = uiop->uio_resid;
2161 
2162 	D2("vcc_write: virtual-console-concentrator@%d:%d writing %d bytes\n",
2163 	    instance, portno, size);
2164 
2165 
2166 
2167 	buf.type = LDC_CONSOLE_DATA;
2168 
2169 	while (size) {
2170 
2171 		bytes = MIN(size, VCC_MTU_SZ);
2172 		/* move data */
2173 		rv = uiomove(&(buf.data), bytes, UIO_WRITE, uiop);
2174 
2175 		if (rv) {
2176 			break;
2177 		}
2178 
2179 		/* write to ldc */
2180 		buf.size = bytes;
2181 
2182 		mutex_enter(&vport->lock);
2183 
2184 		/* check minor no and pid */
2185 		if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
2186 		    vport)) != 0) {
2187 			mutex_exit(&vport->lock);
2188 			return (rv);
2189 		}
2190 
2191 		rv = i_vcc_write_ldc(vport, &buf);
2192 
2193 		mutex_exit(&vport->lock);
2194 
2195 		if (rv) {
2196 			break;
2197 		}
2198 
2199 		size -= bytes;
2200 
2201 	}
2202 
2203 	i_vcc_set_port_status(vport, &vport->write_cv, VCC_PORT_USE_WRITE_LDC);
2204 	return (rv);
2205 }
2206 
2207 /* mdeg callback for a removed port */
2208 static int
i_vcc_md_remove_port(md_t * mdp,mde_cookie_t mdep,vcc_t * vccp)2209 i_vcc_md_remove_port(md_t *mdp, mde_cookie_t mdep, vcc_t *vccp)
2210 {
2211 	uint64_t  portno;	/* md requires 64bit for port number */
2212 	int rv = MDEG_FAILURE;
2213 	vcc_port_t *vport;
2214 
2215 	if (md_get_prop_val(mdp, mdep, "id", &portno)) {
2216 		cmn_err(CE_CONT, "vcc_mdeg_cb: port has no 'id' property\n");
2217 		return (MDEG_FAILURE);
2218 	}
2219 
2220 	if ((portno >= VCC_MAX_PORTS) || (portno < 0)) {
2221 		cmn_err(CE_CONT, "i_vcc_md_remove_port@%ld invalid port no\n",
2222 		    portno);
2223 		return (MDEG_FAILURE);
2224 	}
2225 
2226 	if (portno == VCC_CONTROL_PORT) {
2227 		cmn_err(CE_CONT, "i_vcc_md_remove_port@%ld can not remove"
2228 		    "control port\n",
2229 		    portno);
2230 		return (MDEG_FAILURE);
2231 	}
2232 
2233 	vport = &(vccp->port[portno]);
2234 
2235 	/* delete the port */
2236 	mutex_enter(&vport->lock);
2237 	rv = i_vcc_delete_port(vccp, vport);
2238 	mutex_exit(&vport->lock);
2239 
2240 	mutex_enter(&vccp->lock);
2241 	vccp->num_ports--;
2242 	mutex_exit(&vccp->lock);
2243 
2244 	return (rv ? MDEG_FAILURE : MDEG_SUCCESS);
2245 }
2246 
2247 static int
i_vcc_get_ldc_id(md_t * md,mde_cookie_t mdep,uint64_t * ldc_id)2248 i_vcc_get_ldc_id(md_t *md, mde_cookie_t mdep, uint64_t *ldc_id)
2249 {
2250 	int		num_nodes;
2251 	size_t		size;
2252 	mde_cookie_t	*channel;
2253 	int		num_channels;
2254 
2255 
2256 	if ((num_nodes = md_node_count(md)) <= 0) {
2257 		cmn_err(CE_CONT, "i_vcc_get_ldc_channel_id:"
2258 		    "  Invalid node count in Machine Description subtree");
2259 		return (-1);
2260 	}
2261 	size = num_nodes*(sizeof (*channel));
2262 	channel = kmem_zalloc(size, KM_SLEEP);
2263 	ASSERT(channel != NULL);	/* because KM_SLEEP */
2264 
2265 
2266 	/* Look for channel endpoint child(ren) of the vdisk MD node */
2267 	if ((num_channels = md_scan_dag(md, mdep,
2268 	    md_find_name(md, "channel-endpoint"),
2269 	    md_find_name(md, "fwd"), channel)) <= 0) {
2270 		cmn_err(CE_CONT, "i_vcc_get_ldc_id:  No 'channel-endpoint'"
2271 		    " found for vcc");
2272 		kmem_free(channel, size);
2273 		return (-1);
2274 	}
2275 
2276 	/* Get the "id" value for the first channel endpoint node */
2277 	if (md_get_prop_val(md, channel[0], "id", ldc_id) != 0) {
2278 		cmn_err(CE_CONT, "i_vcc_get_ldc:  No id property found "
2279 		    "for channel-endpoint of vcc");
2280 		kmem_free(channel, size);
2281 		return (-1);
2282 	}
2283 
2284 	if (num_channels > 1) {
2285 		cmn_err(CE_CONT, "i_vcc_get_ldc:  Warning:  Using ID of first"
2286 		    " of multiple channels for this vcc");
2287 	}
2288 
2289 	kmem_free(channel, size);
2290 	return (0);
2291 }
2292 /* mdeg callback for an added port  */
2293 static int
i_vcc_md_add_port(md_t * mdp,mde_cookie_t mdep,vcc_t * vccp)2294 i_vcc_md_add_port(md_t *mdp, mde_cookie_t mdep, vcc_t *vccp)
2295 {
2296 	uint64_t	portno;		/* md requires 64 bit */
2297 	char		*domain_name;
2298 	char		*group_name;
2299 	uint64_t	ldc_id;
2300 	uint64_t	tcp_port;
2301 	vcc_port_t	*vport;
2302 
2303 	/* read in the port's reg property */
2304 	if (md_get_prop_val(mdp, mdep, "id", &portno)) {
2305 		cmn_err(CE_CONT, "i_vcc_md_add_port_: port has no 'id' "
2306 		    "property\n");
2307 		return (MDEG_FAILURE);
2308 	}
2309 
2310 	/* read in the port's "vcc-doman-name" property */
2311 	if (md_get_prop_str(mdp, mdep, "vcc-domain-name", &domain_name)) {
2312 		cmn_err(CE_CONT, "i_vcc_md_add_port: port%ld has "
2313 		    "no 'vcc-domain-name' property\n", portno);
2314 		return (MDEG_FAILURE);
2315 	}
2316 
2317 
2318 	/* read in the port's "vcc-group-name" property */
2319 	if (md_get_prop_str(mdp, mdep, "vcc-group-name", &group_name)) {
2320 		cmn_err(CE_CONT, "i_vcc_md_add_port: port%ld has no "
2321 		    "'vcc-group-name'property\n", portno);
2322 		return (MDEG_FAILURE);
2323 	}
2324 
2325 
2326 	/* read in the port's "vcc-tcp-port" property */
2327 	if (md_get_prop_val(mdp, mdep, "vcc-tcp-port", &tcp_port)) {
2328 		cmn_err(CE_CONT, "i_vcc_md_add_port: port%ld has no"
2329 		    "'vcc-tcp-port' property\n", portno);
2330 		return (MDEG_FAILURE);
2331 	}
2332 
2333 	D1("i_vcc_md_add_port: port@%d domain-name=%s group-name=%s"
2334 	    " tcp-port=%lld\n", portno, domain_name, group_name, tcp_port);
2335 
2336 	/* add the port */
2337 	if (i_vcc_add_port(vccp, group_name, tcp_port, portno, domain_name)) {
2338 		return (MDEG_FAILURE);
2339 	}
2340 
2341 	vport = &vccp->port[portno];
2342 	if (i_vcc_get_ldc_id(mdp, mdep, &ldc_id)) {
2343 		mutex_enter(&vport->lock);
2344 		(void) i_vcc_delete_port(vccp, vport);
2345 		mutex_exit(&vport->lock);
2346 		return (MDEG_FAILURE);
2347 	}
2348 
2349 	/* configure the port */
2350 	if (i_vcc_config_port(vccp, portno, ldc_id)) {
2351 		mutex_enter(&vport->lock);
2352 		(void) i_vcc_delete_port(vccp, vport);
2353 		mutex_exit(&vport->lock);
2354 		return (MDEG_FAILURE);
2355 	}
2356 
2357 	mutex_enter(&vccp->lock);
2358 	vccp->num_ports++;
2359 	mutex_exit(&vccp->lock);
2360 
2361 	vport = &vccp->port[VCC_CONTROL_PORT];
2362 
2363 	if (vport->pollflag & VCC_POLL_CONFIG) {
2364 		/* wakeup vntsd */
2365 		mutex_enter(&vport->lock);
2366 		vport->pollevent |= VCC_POLL_ADD_PORT;
2367 		mutex_exit(&vport->lock);
2368 		pollwakeup(&vport->poll, POLLIN);
2369 	}
2370 
2371 	return (MDEG_SUCCESS);
2372 }
2373 
2374 /* mdeg callback */
2375 static int
vcc_mdeg_cb(void * cb_argp,mdeg_result_t * resp)2376 vcc_mdeg_cb(void *cb_argp, mdeg_result_t *resp)
2377 {
2378 	int	idx;
2379 	vcc_t 	*vccp;
2380 	int	rv;
2381 
2382 	vccp = (vcc_t *)cb_argp;
2383 	ASSERT(vccp);
2384 
2385 	if (resp == NULL) {
2386 		return (MDEG_FAILURE);
2387 	}
2388 
2389 	/* added port */
2390 	D1("vcc_mdeg_cb: added %d port(s)\n", resp->added.nelem);
2391 
2392 	for (idx = 0; idx < resp->added.nelem; idx++) {
2393 		rv = i_vcc_md_add_port(resp->added.mdp,
2394 		    resp->added.mdep[idx], vccp);
2395 
2396 		if (rv !=  MDEG_SUCCESS) {
2397 			return (rv);
2398 		}
2399 	}
2400 
2401 	/* removed port */
2402 	D1("vcc_mdeg_cb: removed %d port(s)\n", resp->removed.nelem);
2403 
2404 	for (idx = 0; idx < resp->removed.nelem; idx++) {
2405 		rv = i_vcc_md_remove_port(resp->removed.mdp,
2406 		    resp->removed.mdep[idx], vccp);
2407 
2408 		if (rv !=  MDEG_SUCCESS) {
2409 			return (rv);
2410 		}
2411 
2412 	}
2413 
2414 	/*
2415 	 * XXX - Currently no support for updating already active
2416 	 * ports. So, ignore the match_curr and match_prev arrays
2417 	 * for now.
2418 	 */
2419 
2420 	return (MDEG_SUCCESS);
2421 }
2422 
2423 
2424 /* cb_chpoll */
2425 static int
vcc_chpoll(dev_t dev,short events,int anyyet,short * reventsp,struct pollhead ** phpp)2426 vcc_chpoll(dev_t dev, short events, int anyyet,  short *reventsp,
2427     struct pollhead **phpp)
2428 {
2429 	int	    instance;
2430 	minor_t	    minor;
2431 	uint_t	    portno;
2432 	vcc_t	    *vccp;
2433 	vcc_port_t  *vport;
2434 
2435 	minor = getminor(dev);
2436 
2437 	instance = VCCINST(minor);
2438 
2439 	vccp = ddi_get_soft_state(vcc_ssp, instance);
2440 	if (vccp == NULL) {
2441 		return (ENXIO);
2442 	}
2443 
2444 	portno = VCCPORT(vccp, minor);
2445 
2446 	vport = &(vccp->port[portno]);
2447 
2448 	D1("vcc_chpoll: virtual-console-concentrator@%d events 0x%x\n",
2449 	    portno, events);
2450 
2451 	*reventsp = 0;
2452 
2453 	if (portno != VCC_CONTROL_PORT) {
2454 		return (ENXIO);
2455 	}
2456 
2457 	/* poll for config change */
2458 	if (vport->pollevent) {
2459 		*reventsp |= (events & POLLIN);
2460 	}
2461 
2462 	if ((((*reventsp) == 0) && (!anyyet)) || (events & POLLET)) {
2463 		*phpp = &vport->poll;
2464 		if (events & POLLIN) {
2465 			mutex_enter(&vport->lock);
2466 			vport->pollflag |= VCC_POLL_CONFIG;
2467 			mutex_exit(&vport->lock);
2468 		} else {
2469 			return (ENXIO);
2470 		}
2471 	}
2472 
2473 	D1("vcc_chpoll: virtual-console-concentrator@%d:%d ev=0x%x, "
2474 	    "rev=0x%x pev=0x%x, flag=0x%x\n",
2475 	    instance, portno, events, (*reventsp),
2476 	    vport->pollevent, vport->pollflag);
2477 
2478 
2479 	return (0);
2480 }
2481