xref: /illumos-gate/usr/src/uts/common/io/sysmsg.c (revision 6446bd46ed1b4e9f69da153665f82181ccaedad5)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 
27 /*
28  * System message redirection driver for Sun.
29  *
30  * Redirects system message output to the device designated as the underlying
31  * "hardware" console, as given by the value of sysmvp.  The implementation
32  * assumes that sysmvp denotes a STREAMS device; the assumption is justified
33  * since consoles must be capable of effecting tty semantics.
34  */
35 
36 #include <sys/types.h>
37 #include <sys/kmem.h>
38 #include <sys/open.h>
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/signal.h>
42 #include <sys/cred.h>
43 #include <sys/user.h>
44 #include <sys/proc.h>
45 #include <sys/vnode.h>
46 #include <sys/uio.h>
47 #include <sys/stat.h>
48 #include <sys/file.h>
49 #include <sys/session.h>
50 #include <sys/stream.h>
51 #include <sys/strsubr.h>
52 #include <sys/poll.h>
53 #include <sys/debug.h>
54 #include <sys/sysmsg_impl.h>
55 #include <sys/conf.h>
56 #include <sys/termios.h>
57 #include <sys/errno.h>
58 #include <sys/modctl.h>
59 #include <sys/pathname.h>
60 #include <sys/ddi.h>
61 #include <sys/sunddi.h>
62 #include <sys/consdev.h>
63 #include <sys/policy.h>
64 
65 /*
66  * internal functions
67  */
68 static int sysmopen(dev_t *, int, int, cred_t *);
69 static int sysmclose(dev_t, int, int, cred_t *);
70 static int sysmread(dev_t, struct uio *, cred_t *);
71 static int sysmwrite(dev_t, struct uio *, cred_t *);
72 static int sysmioctl(dev_t, int, intptr_t, int, cred_t *, int *);
73 static int sysmpoll(dev_t, short, int, short *, struct pollhead **);
74 static int sysm_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
75 static int sysm_attach(dev_info_t *, ddi_attach_cmd_t);
76 static int sysm_detach(dev_info_t *, ddi_detach_cmd_t);
77 static void bind_consadm_conf(char *);
78 static int checkarg(dev_t);
79 
80 static dev_info_t *sysm_dip;		/* private copy of devinfo pointer */
81 
82 static struct cb_ops sysm_cb_ops = {
83 
84 	sysmopen,		/* open */
85 	sysmclose,		/* close */
86 	nodev,			/* strategy */
87 	nodev,			/* print */
88 	nodev,			/* dump */
89 	sysmread,		/* read */
90 	sysmwrite,		/* write */
91 	sysmioctl,		/* ioctl */
92 	nodev,			/* devmap */
93 	nodev,			/* mmap */
94 	nodev,			/* segmap */
95 	sysmpoll,		/* poll */
96 	ddi_prop_op,		/* cb_prop_op */
97 	NULL,			/* streamtab  */
98 	D_NEW | D_MP,		/* Driver compatibility flag */
99 	CB_REV,			/* cb_rev */
100 	nodev,			/* aread */
101 	nodev			/* awrite */
102 };
103 
104 static struct dev_ops sysm_ops = {
105 
106 	DEVO_REV,		/* devo_rev, */
107 	0,			/* refcnt  */
108 	sysm_info,		/* info */
109 	nulldev,		/* identify */
110 	nulldev,		/* probe */
111 	sysm_attach,		/* attach */
112 	sysm_detach,		/* detach */
113 	nodev,			/* reset */
114 	&sysm_cb_ops,		/* driver operations */
115 	(struct bus_ops *)0,	/* bus operations */
116 	nulldev,		/* power */
117 	ddi_quiesce_not_needed,		/* quiesce */
118 
119 };
120 
121 /*
122  * Global variables associated with the console device:
123  */
124 
125 #define	SYS_SYSMIN	0	/* sysmsg minor number */
126 #define	SYS_MSGMIN	1	/* msglog minor number */
127 #define	SYSPATHLEN	255	/* length of device path */
128 
129 /*
130  * Private driver state:
131  */
132 
133 #define	MAXDEVS 5
134 
135 typedef struct {
136 	dev_t	dca_devt;
137 	int	dca_flags;
138 	vnode_t	*dca_vp;
139 	krwlock_t	dca_lock;
140 	char	dca_name[SYSPATHLEN];
141 } devicecache_t;
142 
143 /* list of dyn. + persist. config'ed dev's */
144 static devicecache_t sysmcache[MAXDEVS];
145 static kmutex_t	dcvp_mutex;
146 static vnode_t	*dcvp = NULL;
147 static boolean_t sysmsg_opened;
148 static boolean_t msglog_opened;
149 
150 /* flags for device cache */
151 #define	SYSM_DISABLED	0x0
152 #define	SYSM_ENABLED	0x1
153 
154 /*
155  * Module linkage information for the kernel.
156  */
157 
158 static struct modldrv modldrv = {
159 	&mod_driverops, /* Type of module.  This one is a pseudo driver */
160 	"System message redirection (fanout) driver",
161 	&sysm_ops,	/* driver ops */
162 };
163 
164 static struct modlinkage modlinkage = {
165 	MODREV_1,
166 	&modldrv,
167 	NULL
168 };
169 
170 int
171 _init(void)
172 {
173 	return (mod_install(&modlinkage));
174 }
175 
176 int
177 _fini(void)
178 {
179 	return (mod_remove(&modlinkage));
180 }
181 
182 int
183 _info(struct modinfo *modinfop)
184 {
185 	return (mod_info(&modlinkage, modinfop));
186 }
187 
188 /*
189  * DDI glue routines
190  */
191 static int
192 sysm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
193 {
194 	int i;
195 
196 	switch (cmd) {
197 	case DDI_ATTACH:
198 		ASSERT(sysm_dip == NULL);
199 
200 		if (ddi_create_minor_node(devi, "sysmsg", S_IFCHR,
201 		    SYS_SYSMIN, DDI_PSEUDO, 0) == DDI_FAILURE ||
202 		    ddi_create_minor_node(devi, "msglog", S_IFCHR,
203 		    SYS_MSGMIN, DDI_PSEUDO, 0) == DDI_FAILURE) {
204 			ddi_remove_minor_node(devi, NULL);
205 			return (DDI_FAILURE);
206 		}
207 
208 		for (i = 0; i < MAXDEVS; i++) {
209 			rw_init(&sysmcache[i].dca_lock, NULL, RW_DRIVER, NULL);
210 		}
211 
212 		sysm_dip = devi;
213 		return (DDI_SUCCESS);
214 	case DDI_SUSPEND:
215 	case DDI_PM_SUSPEND:
216 		return (DDI_SUCCESS);
217 	default:
218 		return (DDI_FAILURE);
219 	}
220 }
221 
222 static int
223 sysm_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
224 {
225 	int i;
226 
227 	switch (cmd) {
228 	case DDI_DETACH:
229 		ASSERT(sysm_dip == devi);
230 
231 		for (i = 0; i < MAXDEVS; i++)
232 			rw_destroy(&sysmcache[i].dca_lock);
233 
234 		ddi_remove_minor_node(devi, NULL);
235 		sysm_dip = NULL;
236 		return (DDI_SUCCESS);
237 
238 	case DDI_SUSPEND:
239 	case DDI_PM_SUSPEND:
240 		return (DDI_SUCCESS);
241 	default:
242 		return (DDI_FAILURE);
243 	}
244 
245 }
246 
247 /* ARGSUSED */
248 static int
249 sysm_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
250 {
251 	int rval = DDI_FAILURE;
252 	minor_t instance;
253 
254 	instance = getminor((dev_t)arg);
255 
256 	switch (infocmd) {
257 	case DDI_INFO_DEVT2DEVINFO:
258 		if (sysm_dip != NULL &&
259 		    (instance == SYS_SYSMIN || instance == SYS_MSGMIN)) {
260 			*result = sysm_dip;
261 			rval = DDI_SUCCESS;
262 		}
263 		break;
264 
265 	case DDI_INFO_DEVT2INSTANCE:
266 		if (instance == SYS_SYSMIN || instance == SYS_MSGMIN) {
267 			*result = NULL;
268 			rval = DDI_SUCCESS;
269 		}
270 		break;
271 
272 	default:
273 		break;
274 	}
275 
276 	return (rval);
277 }
278 
279 /*
280  * Parse the contents of the buffer, and bind the named
281  * devices as auxiliary consoles using our own ioctl routine.
282  *
283  * Comments begin with '#' and are terminated only by a newline
284  * Device names begin with a '/', and are terminated by a newline,
285  * space, '#' or tab.
286  */
287 static void
288 parse_buffer(char *buf, ssize_t fsize)
289 {
290 	char *ebuf = buf + fsize;
291 	char *devname = NULL;
292 	int eatcomments = 0;
293 
294 	while (buf < ebuf) {
295 		if (eatcomments) {
296 			if (*buf++ == '\n')
297 				eatcomments = 0;
298 			continue;
299 		}
300 		switch (*buf) {
301 		case '/':
302 			if (devname == NULL)
303 				devname = buf;
304 			break;
305 		case '#':
306 			eatcomments = 1;
307 			/*FALLTHROUGH*/
308 		case ' ':
309 		case '\t':
310 		case '\n':
311 			*buf = '\0';
312 			if (devname == NULL)
313 				break;
314 			(void) sysmioctl(NODEV, CIOCSETCONSOLE,
315 			    (intptr_t)devname, FNATIVE|FKIOCTL|FREAD|FWRITE,
316 			    kcred, NULL);
317 			devname = NULL;
318 			break;
319 		default:
320 			break;
321 		}
322 		buf++;
323 	}
324 }
325 
326 #define	CNSADM_BYTES_MAX	2000	/* XXX  nasty fixed size */
327 
328 static void
329 bind_consadm_conf(char *path)
330 {
331 	struct vattr vattr;
332 	vnode_t *vp;
333 	void *buf;
334 	size_t size;
335 	ssize_t resid;
336 	int err = 0;
337 
338 	if (vn_open(path, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0) != 0)
339 		return;
340 	vattr.va_mask = AT_SIZE;
341 	if ((err = VOP_GETATTR(vp, &vattr, 0, kcred, NULL)) != 0) {
342 		cmn_err(CE_WARN, "sysmsg: getattr: '%s': error %d",
343 		    path, err);
344 		goto closevp;
345 	}
346 
347 	size = vattr.va_size > CNSADM_BYTES_MAX ?
348 	    CNSADM_BYTES_MAX : (ssize_t)vattr.va_size;
349 	buf = kmem_alloc(size, KM_SLEEP);
350 
351 	if ((err = vn_rdwr(UIO_READ, vp, buf, size, (offset_t)0,
352 	    UIO_SYSSPACE, 0, (rlim64_t)0, kcred, &resid)) != 0)
353 		cmn_err(CE_WARN, "sysmsg: vn_rdwr: '%s': error %d",
354 		    path, err);
355 	else
356 		parse_buffer(buf, size - resid);
357 
358 	kmem_free(buf, size);
359 closevp:
360 	(void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, kcred, NULL);
361 	VN_RELE(vp);
362 }
363 
364 /* ARGSUSED */
365 static int
366 sysmopen(dev_t *dev, int flag, int state, cred_t *cred)
367 {
368 	int	i;
369 	vnode_t	*vp;
370 	minor_t instance;
371 	static boolean_t initialized;
372 
373 	instance = getminor(*dev);
374 
375 	if (state != OTYP_CHR || (instance != 0 && instance != 1))
376 		return (ENXIO);
377 
378 	mutex_enter(&dcvp_mutex);
379 	if ((dcvp == NULL) && (vn_open("/dev/console",
380 	    UIO_SYSSPACE, FWRITE, 0, &dcvp, 0, 0) != 0)) {
381 		mutex_exit(&dcvp_mutex);
382 		return (ENXIO);
383 	}
384 
385 	if (instance == SYS_SYSMIN)
386 		sysmsg_opened = B_TRUE;
387 	else
388 		msglog_opened = B_TRUE;
389 
390 	if (!initialized) {
391 		bind_consadm_conf("/etc/consadm.conf");
392 		initialized = B_TRUE;
393 	}
394 	mutex_exit(&dcvp_mutex);
395 
396 	for (i = 0; i < MAXDEVS; i++) {
397 		rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
398 		if ((sysmcache[i].dca_flags & SYSM_ENABLED) &&
399 		    sysmcache[i].dca_vp == NULL) {
400 			/*
401 			 * 4196476 - FTRUNC was causing E10K to return EINVAL
402 			 * on open
403 			 */
404 			flag = flag & ~FTRUNC;
405 			/*
406 			 * Open failures on the auxiliary consoles are
407 			 * not returned because we don't care if some
408 			 * subset get an error. We know the default console
409 			 * is okay, and preserve the semantics of the
410 			 * open for the default console.
411 			 * Set NONBLOCK|NDELAY in case there's no carrier.
412 			 */
413 			if (vn_open(sysmcache[i].dca_name, UIO_SYSSPACE,
414 			    flag | FNONBLOCK | FNDELAY, 0, &vp, 0, 0) == 0)
415 				sysmcache[i].dca_vp = vp;
416 		}
417 		rw_exit(&sysmcache[i].dca_lock);
418 	}
419 
420 	return (0);
421 }
422 
423 /* ARGSUSED */
424 static int
425 sysmclose(dev_t dev, int flag, int state, cred_t *cred)
426 {
427 	int	i;
428 	minor_t instance;
429 
430 	ASSERT(dcvp != NULL);
431 
432 	if (state != OTYP_CHR)
433 		return (ENXIO);
434 
435 	instance = getminor(dev);
436 
437 	mutex_enter(&dcvp_mutex);
438 	if (instance == SYS_SYSMIN)
439 		sysmsg_opened = B_FALSE;
440 	else
441 		msglog_opened = B_FALSE;
442 
443 	if (sysmsg_opened || msglog_opened) {
444 		mutex_exit(&dcvp_mutex);
445 		return (0);
446 	}
447 
448 	(void) VOP_CLOSE(dcvp, FWRITE, 1, (offset_t)0, kcred, NULL);
449 	VN_RELE(dcvp);
450 	dcvp = NULL;
451 	mutex_exit(&dcvp_mutex);
452 
453 	/*
454 	 * Close the auxiliary consoles, we're not concerned with
455 	 * passing up the errors.
456 	 */
457 	for (i = 0; i < MAXDEVS; i++) {
458 		rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
459 		if (sysmcache[i].dca_vp != NULL) {
460 			(void) VOP_CLOSE(sysmcache[i].dca_vp, flag,
461 			    1, (offset_t)0, cred, NULL);
462 			VN_RELE(sysmcache[i].dca_vp);
463 			sysmcache[i].dca_vp = NULL;
464 		}
465 		rw_exit(&sysmcache[i].dca_lock);
466 	}
467 
468 	return (0);
469 }
470 
471 /* Reads occur only on the default console */
472 
473 /* ARGSUSED */
474 static int
475 sysmread(dev_t dev, struct uio *uio, cred_t *cred)
476 {
477 	ASSERT(dcvp != NULL);
478 	return (VOP_READ(dcvp, uio, 0, cred, NULL));
479 }
480 
481 /* ARGSUSED */
482 static int
483 sysmwrite(dev_t dev, struct uio *uio, cred_t *cred)
484 {
485 	int	i = 0;
486 	iovec_t	uio_iov;
487 	struct uio	tuio;
488 
489 	ASSERT(dcvp != NULL);
490 	ASSERT(uio != NULL);
491 
492 	for (i = 0; i < MAXDEVS; i++) {
493 		rw_enter(&sysmcache[i].dca_lock, RW_READER);
494 		if (sysmcache[i].dca_vp != NULL &&
495 		    (sysmcache[i].dca_flags & SYSM_ENABLED)) {
496 			tuio = *uio;
497 			uio_iov = *(uio->uio_iov);
498 			tuio.uio_iov = &uio_iov;
499 			(void) VOP_WRITE(sysmcache[i].dca_vp, &tuio, 0, cred,
500 			    NULL);
501 		}
502 		rw_exit(&sysmcache[i].dca_lock);
503 	}
504 	return (VOP_WRITE(dcvp, uio, 0, cred, NULL));
505 }
506 
507 /* ARGSUSED */
508 static int
509 sysmioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred, int *rvalp)
510 {
511 	int	rval = 0;
512 	int	error = 0;
513 	size_t	size = 0;
514 	int	i;
515 	char	*infop;
516 	char	found = 0;
517 	dev_t	newdevt = (dev_t)NODEV;	/* because 0 == /dev/console */
518 	vnode_t	*vp;
519 
520 	switch (cmd) {
521 	case CIOCGETCONSOLE:
522 		/* Sum over the number of enabled devices */
523 		for (i = 0; i < MAXDEVS; i++) {
524 			if (sysmcache[i].dca_flags & SYSM_ENABLED)
525 				/* list is space separated, followed by NULL */
526 				size += strlen(sysmcache[i].dca_name) + 1;
527 		}
528 		if (size == 0)
529 			return (0);
530 		break;
531 	case CIOCSETCONSOLE:
532 	case CIOCRMCONSOLE:
533 		size = sizeof (sysmcache[0].dca_name);
534 		break;
535 	case CIOCTTYCONSOLE:
536 	{
537 		dev_t	d;
538 		dev32_t	d32;
539 		extern dev_t rwsconsdev, rconsdev, uconsdev;
540 		proc_t	*p;
541 
542 		if (drv_getparm(UPROCP, &p) != 0)
543 			return (ENODEV);
544 		else
545 			d = cttydev(p);
546 		/*
547 		 * If the controlling terminal is the real
548 		 * or workstation console device, map to what the
549 		 * user thinks is the console device.
550 		 */
551 		if (d == rwsconsdev || d == rconsdev)
552 			d = uconsdev;
553 		if ((flag & FMODELS) != FNATIVE) {
554 			if (!cmpldev(&d32, d))
555 				return (EOVERFLOW);
556 			if (ddi_copyout(&d32, (caddr_t)arg, sizeof (d32),
557 			    flag))
558 				return (EFAULT);
559 		} else {
560 			if (ddi_copyout(&d, (caddr_t)arg, sizeof (d), flag))
561 				return (EFAULT);
562 		}
563 		return (0);
564 	}
565 	default:
566 		/* everything else is sent to the console device */
567 		return (VOP_IOCTL(dcvp, cmd, arg, flag, cred, rvalp, NULL));
568 	}
569 
570 	if ((rval = secpolicy_console(cred)) != 0)
571 		return (EPERM);
572 
573 	infop = kmem_alloc(size, KM_SLEEP);
574 	if (flag & FKIOCTL)
575 		error = copystr((caddr_t)arg, infop, size, NULL);
576 	else
577 		error = copyinstr((caddr_t)arg, infop, size, NULL);
578 
579 	if (error) {
580 		switch (cmd) {
581 		case CIOCGETCONSOLE:
582 			/*
583 			 * If the buffer is null, then return a byte count
584 			 * to user land.
585 			 */
586 			*rvalp = size;
587 			goto err_exit;
588 		default:
589 			rval = EFAULT;
590 			goto err_exit;
591 		}
592 	}
593 
594 	if (infop[0] != '\0') {
595 		if ((rval = lookupname(infop, UIO_SYSSPACE, FOLLOW,
596 		    NULLVPP, &vp)) == 0) {
597 			if (vp->v_type != VCHR) {
598 				VN_RELE(vp);
599 				rval = EINVAL;
600 				goto err_exit;
601 			}
602 			newdevt = vp->v_rdev;
603 			VN_RELE(vp);
604 		} else
605 			goto err_exit;
606 	}
607 
608 	switch (cmd) {
609 	case CIOCGETCONSOLE:
610 		/*
611 		 * Return the list of device names that are enabled.
612 		 */
613 		for (i = 0; i < MAXDEVS; i++) {
614 			rw_enter(&sysmcache[i].dca_lock, RW_READER);
615 			if (sysmcache[i].dca_flags & SYSM_ENABLED) {
616 				if (infop[0] != '\0')
617 					(void) strcat(infop, " ");
618 				(void) strcat(infop, sysmcache[i].dca_name);
619 			}
620 			rw_exit(&sysmcache[i].dca_lock);
621 		}
622 		if (rval == 0 && copyoutstr(infop, (void *)arg, size, NULL))
623 			rval = EFAULT;
624 		break;
625 
626 	case CIOCSETCONSOLE:
627 		if ((rval = checkarg(newdevt)) != 0)
628 			break;
629 		/*
630 		 * The device does not have to be open or disabled to
631 		 * perform the set console.
632 		 */
633 		for (i = 0; i < MAXDEVS; i++) {
634 			rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
635 			if (sysmcache[i].dca_devt == newdevt &&
636 			    (sysmcache[i].dca_flags & SYSM_ENABLED)) {
637 				(void) strcpy(sysmcache[i].dca_name, infop);
638 				rval = EEXIST;
639 				rw_exit(&sysmcache[i].dca_lock);
640 				break;
641 			} else if (sysmcache[i].dca_devt == newdevt &&
642 			    sysmcache[i].dca_flags == SYSM_DISABLED) {
643 				sysmcache[i].dca_flags |= SYSM_ENABLED;
644 				(void) strcpy(sysmcache[i].dca_name, infop);
645 				rw_exit(&sysmcache[i].dca_lock);
646 				found = 1;
647 				break;
648 			} else if (sysmcache[i].dca_devt == 0) {
649 				ASSERT(sysmcache[i].dca_vp == NULL &&
650 				    sysmcache[i].dca_flags == SYSM_DISABLED);
651 				(void) strcpy(sysmcache[i].dca_name, infop);
652 				sysmcache[i].dca_flags = SYSM_ENABLED;
653 				sysmcache[i].dca_devt = newdevt;
654 				rw_exit(&sysmcache[i].dca_lock);
655 				found = 1;
656 				break;
657 			}
658 			rw_exit(&sysmcache[i].dca_lock);
659 		}
660 		if (found == 0 && rval == 0)
661 			rval = ENOENT;
662 		break;
663 
664 	case CIOCRMCONSOLE:
665 		for (i = 0; i < MAXDEVS; i++) {
666 			rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
667 			if (sysmcache[i].dca_devt == newdevt) {
668 				sysmcache[i].dca_flags = SYSM_DISABLED;
669 				sysmcache[i].dca_name[0] = '\0';
670 				rw_exit(&sysmcache[i].dca_lock);
671 				found = 1;
672 				break;
673 			}
674 			rw_exit(&sysmcache[i].dca_lock);
675 		}
676 		if (found == 0)
677 			rval = ENOENT;
678 		break;
679 
680 	default:
681 		break;
682 	}
683 
684 err_exit:
685 	kmem_free(infop, size);
686 	return (rval);
687 }
688 
689 /* As with the read, we poll only the default console */
690 
691 /* ARGSUSED */
692 static int
693 sysmpoll(dev_t dev, short events, int anyyet, short *reventsp,
694     struct pollhead **phpp)
695 {
696 	return (VOP_POLL(dcvp, events, anyyet, reventsp, phpp, NULL));
697 }
698 
699 /* Sanity check that the device is good */
700 static int
701 checkarg(dev_t devt)
702 {
703 	int rval = 0;
704 	dev_t sysmsg_dev, msglog_dev;
705 	extern dev_t rwsconsdev, rconsdev, uconsdev;
706 
707 	if (devt == rconsdev || devt == rwsconsdev || devt == uconsdev) {
708 		rval = EBUSY;
709 	} else {
710 		sysmsg_dev = makedevice(ddi_driver_major(sysm_dip), SYS_SYSMIN);
711 		msglog_dev = makedevice(ddi_driver_major(sysm_dip), SYS_MSGMIN);
712 		if (devt == sysmsg_dev || devt == msglog_dev)
713 			rval = EINVAL;
714 	}
715 
716 	return (rval);
717 }
718