xref: /illumos-gate/usr/src/uts/common/io/ptms_conf.c (revision 8459c777fc1aaabb2f7dad05de1313aa169417cd)
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  * This file contains global data and code shared between master and slave parts
28  * of the pseudo-terminal driver.
29  *
30  * Pseudo terminals (or pt's for short) are allocated dynamically.
31  * pt's are put in the global ptms_slots array indexed by minor numbers.
32  *
33  * The slots array is initially small (of the size NPTY_MIN). When more pt's are
34  * needed than the slot array size, the larger slot array is allocated and all
35  * opened pt's move to the new one.
36  *
37  * Resource allocation:
38  *
39  *	pt_ttys structures are allocated via pt_ttys_alloc, which uses
40  *		kmem_cache_alloc().
41  *	Minor number space is allocated via vmem_alloc() interface.
42  *	ptms_slots arrays are allocated via kmem_alloc().
43  *
44  *   Minors are started from 1 instead of 0 because vmem_alloc returns 0 in case
45  *   of failure. Also, in anticipation of removing clone device interface to
46  *   pseudo-terminal subsystem, minor 0 should not be used. (Potential future
47  *   development).
48  *
49  *   After the table slot size reaches pt_maxdelta, we stop 2^N extension
50  *   algorithm and start extending the slot table size by pt_maxdelta.
51  *
52  *   Device entries /dev/pts directory are created dynamically by the
53  *   /dev filesystem. We no longer call ddi_create_minor_node() on
54  *   behalf of the slave driver. The /dev filesystem creates /dev/pts
55  *   nodes based on the pt_ttys array.
56  *
57  * Synchronization:
58  *
59  *   All global data synchronization between ptm/pts is done via global
60  *   ptms_lock mutex which is implicitly initialized by declaring it global.
61  *
62  *   Individual fields of pt_ttys structure (except ptm_rdq, pts_rdq and
63  *   pt_nullmsg) are protected by pt_ttys.pt_lock mutex.
64  *
65  *   PT_ENTER_READ/PT_ENTER_WRITE are reference counter based read-write locks
66  *   which allow reader locks to be reacquired by the same thread (usual
67  *   reader/writer locks can't be used for that purpose since it is illegal for
68  *   a thread to acquire a lock it already holds, even as a reader). The sole
69  *   purpose of these macros is to guarantee that the peer queue will not
70  *   disappear (due to closing peer) while it is used. It is safe to use
71  *   PT_ENTER_READ/PT_EXIT_READ brackets across calls like putq/putnext (since
72  *   they are not real locks but reference counts).
73  *
74  *   PT_ENTER_WRITE/PT_EXIT_WRITE brackets are used ONLY in master/slave
75  *   open/close paths to modify ptm_rdq and pts_rdq fields. These fields should
76  *   be set to appropriate queues *after* qprocson() is called during open (to
77  *   prevent peer from accessing the queue with incomplete plumbing) and set to
78  *   NULL before qprocsoff() is called during close. Put and service procedures
79  *   use PT_ENTER_READ/PT_EXIT_READ to prevent peer closes.
80  *
81  *   The pt_nullmsg field is only used in open/close routines and is also
82  *   protected by PT_ENTER_WRITE/PT_EXIT_WRITE brackets to avoid extra mutex
83  *   holds.
84  *
85  * Lock Ordering:
86  *
87  *   If both ptms_lock and per-pty lock should be held, ptms_lock should always
88  *   be entered first, followed by per-pty lock.
89  *
90  * Global functions:
91  *
92  * void ptms_init(void);
93  *
94  *	Called by pts/ptm _init entry points. It performes one-time
95  * 	initialization needed for both pts and ptm. This initialization is done
96  * 	here and not in ptms_initspace because all these data structures are not
97  *	needed if pseudo-terminals are not used in the system.
98  *
99  * struct pt_ttys *pt_ttys_alloc(void);
100  *
101  *	Allocate new minor number and pseudo-terminal entry. May sleep.
102  *	New minor number is recorded in pt_minor field of the entry returned.
103  *	This routine also initializes pt_minor and pt_state fields of the new
104  *	pseudo-terminal and puts a pointer to it into ptms_slots array.
105  *
106  * struct pt_ttys *ptms_minor2ptty(minor_t minor)
107  *
108  *	Find pt_ttys structure by minor number.
109  *	Returns NULL when minor is out of range.
110  *
111  * int ptms_minor_valid(minor_t minor, uid_t *ruid, gid_t *rgid)
112  *
113  *	Check if minor refers to an allocated pty in the current zone.
114  *	Returns
115  *		 0 if not allocated or not for this zone.
116  *		 1 if an allocated pty in the current zone.
117  *	Also returns owner of pty.
118  *
119  * int ptms_minor_exists(minor_t minor)
120  *	Check if minor refers to an allocated pty (in any zone)
121  *	Returns
122  *		0 if not an allocated pty
123  *		1 if an allocated pty
124  *
125  * void ptms_set_owner(minor_t minor, uid_t ruid, gid_t rgid)
126  *
127  *	Sets the owner associated with a pty.
128  *
129  * void ptms_close(struct pt_ttys *pt, uint_t flags_to_clear);
130  *
131  *	Clear flags_to_clear in pt and if no one owns it (PTMOPEN/PTSOPEN not
132  * 	set) free pt entry and corresponding slot.
133  *
134  * Tuneables and configuration:
135  *
136  *	pt_cnt: minimum number of pseudo-terminals in the system. The system
137  *		should provide at least this number of ptys (provided sufficient
138  * 		memory is available). It is different from the older semantics
139  *		of pt_cnt meaning maximum number of ptys.
140  *		Set to 0 by default.
141  *
142  *	pt_max_pty: Maximum number of pseudo-terminals in the system. The system
143  *		should not allocate more ptys than pt_max_pty (although, it may
144  * 		impose stricter maximum). Zero value means no user-defined
145  * 		maximum. This is intended to be used as "denial-of-service"
146  *		protection.
147  *		Set to 0 by default.
148  *
149  *         Both pt_cnt and pt_max_pty may be modified during system lifetime
150  *         with their semantics preserved.
151  *
152  *	pt_init_cnt: Initial size of ptms_slots array. Set to NPTY_INITIAL.
153  *
154  *	pt_ptyofmem: Approximate percentage of system memory that may be
155  *		occupied by pty data structures. Initially set to NPTY_PERCENT.
156  *		This variable is used once during initialization to estimate
157  * 		maximum number of ptys in the system. The actual maximum is
158  *		determined as minimum of pt_max_pty and calculated value.
159  *
160  *	pt_maxdelta: Maximum extension chunk of the slot table.
161  */
162 
163 
164 
165 #include <sys/types.h>
166 #include <sys/param.h>
167 #include <sys/termios.h>
168 #include <sys/stream.h>
169 #include <sys/stropts.h>
170 #include <sys/kmem.h>
171 #include <sys/ptms.h>
172 #include <sys/stat.h>
173 #include <sys/sunddi.h>
174 #include <sys/ddi.h>
175 #include <sys/bitmap.h>
176 #include <sys/sysmacros.h>
177 #include <sys/ddi_impldefs.h>
178 #include <sys/zone.h>
179 #ifdef DEBUG
180 #include <sys/strlog.h>
181 #endif
182 
183 
184 /* Initial number of ptms slots */
185 #define	NPTY_INITIAL 16
186 
187 #define	NPTY_PERCENT 5
188 
189 /* Maximum increment of the slot table size */
190 #define	PTY_MAXDELTA 128
191 
192 /*
193  * Tuneable variables.
194  */
195 uint_t	pt_cnt = 0;			/* Minimum number of ptys */
196 size_t 	pt_max_pty = 0;			/* Maximum number of ptys */
197 uint_t	pt_init_cnt = NPTY_INITIAL;	/* Initial number of ptms slots */
198 uint_t	pt_pctofmem = NPTY_PERCENT;	/* Percent of memory to use for ptys */
199 uint_t	pt_maxdelta = PTY_MAXDELTA;	/* Max increment for slot table size */
200 
201 /* Other global variables */
202 
203 kmutex_t ptms_lock;			/* Global data access lock */
204 
205 /*
206  * Slot array and its management variables
207  */
208 static struct pt_ttys **ptms_slots = NULL; /* Slots for actual pt structures */
209 static size_t ptms_nslots = 0;		/* Size of slot array */
210 static size_t ptms_ptymax = 0;		/* Maximum number of ptys */
211 static size_t ptms_inuse = 0;		/* # of ptys currently allocated */
212 
213 dev_info_t 	*pts_dip = NULL;	/* set if slave is attached */
214 
215 static struct kmem_cache *ptms_cache = NULL;	/* pty cache */
216 
217 static vmem_t *ptms_minor_arena = NULL; /* Arena for device minors */
218 
219 static uint_t ptms_roundup(uint_t);
220 static int ptms_constructor(void *, void *, int);
221 static void ptms_destructor(void *, void *);
222 static minor_t ptms_grow(void);
223 
224 /*
225  * Total size occupied by one pty. Each pty master/slave pair consumes one
226  * pointer for ptms_slots array, one pt_ttys structure and one empty message
227  * preallocated for pts close.
228  */
229 
230 #define	PTY_SIZE (sizeof (struct pt_ttys) + \
231     sizeof (struct pt_ttys *) + \
232     sizeof (dblk_t))
233 
234 #ifdef DEBUG
235 int ptms_debug = 0;
236 #define	PTMOD_ID 5
237 #endif
238 
239 /*
240  * Clear all bits of x except the highest bit
241  */
242 #define	truncate(x) 	((x) <= 2 ? (x) : (1 << (highbit(x) - 1)))
243 
244 /*
245  * Roundup the number to the nearest power of 2
246  */
247 static uint_t
248 ptms_roundup(uint_t x)
249 {
250 	uint_t p = truncate(x);	/* x with non-high bits stripped */
251 
252 	/*
253 	 * If x is a power of 2, return x, otherwise roundup.
254 	 */
255 	return (p == x ? p : (p * 2));
256 }
257 
258 /*
259  * Allocate ptms_slots array and kmem cache for pt_ttys. This initialization is
260  * only called once during system lifetime. Called from ptm or pts _init
261  * routine.
262  */
263 void
264 ptms_init(void)
265 {
266 	mutex_enter(&ptms_lock);
267 
268 	if (ptms_slots == NULL) {
269 		ptms_slots = kmem_zalloc(pt_init_cnt *
270 		    sizeof (struct pt_ttys *), KM_SLEEP);
271 
272 		ptms_cache = kmem_cache_create("pty_map",
273 		    sizeof (struct pt_ttys), 0, ptms_constructor,
274 		    ptms_destructor, NULL, NULL, NULL, 0);
275 
276 		ptms_nslots = pt_init_cnt;
277 
278 		/* Allocate integer space for minor numbers */
279 		ptms_minor_arena = vmem_create("ptms_minor", (void *)1,
280 		    ptms_nslots, 1, NULL, NULL, NULL, 0,
281 		    VM_SLEEP | VMC_IDENTIFIER);
282 
283 		/*
284 		 * Calculate available number of ptys - how many ptys can we
285 		 * allocate in pt_pctofmem % of available memory. The value is
286 		 * rounded up to the nearest power of 2.
287 		 */
288 		ptms_ptymax = ptms_roundup((pt_pctofmem * kmem_maxavail()) /
289 		    (100 * PTY_SIZE));
290 	}
291 	mutex_exit(&ptms_lock);
292 }
293 
294 /*
295  * This routine attaches the pts dip.
296  */
297 int
298 ptms_attach_slave(void)
299 {
300 	if (pts_dip == NULL && i_ddi_attach_pseudo_node("pts") == NULL)
301 		return (-1);
302 
303 	ASSERT(pts_dip);
304 	return (0);
305 }
306 
307 /*
308  * Called from /dev fs. Checks if dip is attached,
309  * and if it is, returns its major number.
310  */
311 major_t
312 ptms_slave_attached(void)
313 {
314 	major_t maj = DDI_MAJOR_T_NONE;
315 
316 	mutex_enter(&ptms_lock);
317 	if (pts_dip)
318 		maj = ddi_driver_major(pts_dip);
319 	mutex_exit(&ptms_lock);
320 
321 	return (maj);
322 }
323 
324 /*
325  * Allocate new minor number and pseudo-terminal entry. Returns the new entry or
326  * NULL if no memory or maximum number of entries reached.
327  */
328 struct pt_ttys *
329 pt_ttys_alloc(void)
330 {
331 	minor_t dminor;
332 	struct pt_ttys *pt = NULL;
333 
334 	mutex_enter(&ptms_lock);
335 
336 	/*
337 	 * Always try to allocate new pty when pt_cnt minimum limit is not
338 	 * achieved. If it is achieved, the maximum is determined by either
339 	 * user-specified value (if it is non-zero) or our memory estimations -
340 	 * whatever is less.
341 	 */
342 	if (ptms_inuse >= pt_cnt) {
343 		/*
344 		 * When system achieved required minimum of ptys, check for the
345 		 *   denial of service limits.
346 		 *
347 		 * Since pt_max_pty may be zero, the formula below is used to
348 		 * avoid conditional expression. It will equal to pt_max_pty if
349 		 * it is not zero and ptms_ptymax otherwise.
350 		 */
351 		size_t user_max = (pt_max_pty == 0 ? ptms_ptymax : pt_max_pty);
352 
353 		/* Do not try to allocate more than allowed */
354 		if (ptms_inuse >= min(ptms_ptymax, user_max)) {
355 			mutex_exit(&ptms_lock);
356 			return (NULL);
357 		}
358 	}
359 	ptms_inuse++;
360 
361 	/*
362 	 * Allocate new minor number. If this fails, all slots are busy and
363 	 * we need to grow the hash.
364 	 */
365 	dminor = (minor_t)(uintptr_t)
366 	    vmem_alloc(ptms_minor_arena, 1, VM_NOSLEEP);
367 
368 	if (dminor == 0) {
369 		/* Grow the cache and retry allocation */
370 		dminor = ptms_grow();
371 	}
372 
373 	if (dminor == 0) {
374 		/* Not enough memory now */
375 		ptms_inuse--;
376 		mutex_exit(&ptms_lock);
377 		return (NULL);
378 	}
379 
380 	pt = kmem_cache_alloc(ptms_cache, KM_NOSLEEP);
381 	if (pt == NULL) {
382 		/* Not enough memory - this entry can't be used now. */
383 		vmem_free(ptms_minor_arena, (void *)(uintptr_t)dminor, 1);
384 		ptms_inuse--;
385 	} else {
386 		pt->pt_minor = dminor;
387 		pt->pt_pid = curproc->p_pid;	/* For debugging */
388 		pt->pt_state = (PTMOPEN | PTLOCK);
389 		pt->pt_zoneid = getzoneid();
390 		pt->pt_ruid = 0; /* we don't know uid/gid yet. Report as root */
391 		pt->pt_rgid = 0;
392 		ASSERT(ptms_slots[dminor - 1] == NULL);
393 		ptms_slots[dminor - 1] = pt;
394 	}
395 
396 	mutex_exit(&ptms_lock);
397 	return (pt);
398 }
399 
400 /*
401  * Get pt_ttys structure by minor number.
402  * Returns NULL when minor is out of range.
403  */
404 struct pt_ttys *
405 ptms_minor2ptty(minor_t dminor)
406 {
407 	struct pt_ttys *pt = NULL;
408 
409 	ASSERT(mutex_owned(&ptms_lock));
410 	if ((dminor >= 1) && (dminor <= ptms_nslots) && ptms_slots != NULL)
411 		pt = ptms_slots[dminor - 1];
412 
413 	return (pt);
414 }
415 
416 /*
417  * Invoked in response to chown on /dev/pts nodes to change the
418  * permission on a pty
419  */
420 void
421 ptms_set_owner(minor_t dminor, uid_t ruid, gid_t rgid)
422 {
423 	struct pt_ttys *pt;
424 
425 	ASSERT(ruid >= 0);
426 	ASSERT(rgid >= 0);
427 
428 	if (ruid < 0 || rgid < 0)
429 		return;
430 
431 	/*
432 	 * /dev/pts/0 is not used, but some applications may check it. There
433 	 * is no pty backing it - so we have nothing to do.
434 	 */
435 	if (dminor == 0)
436 		return;
437 
438 	mutex_enter(&ptms_lock);
439 	pt = ptms_minor2ptty(dminor);
440 	if (pt != NULL && pt->pt_zoneid == getzoneid()) {
441 		pt->pt_ruid = ruid;
442 		pt->pt_rgid = rgid;
443 	}
444 	mutex_exit(&ptms_lock);
445 }
446 
447 /*
448  * Given a ptm/pts minor number
449  * returns:
450  *	1 if the pty is allocated to the current zone.
451  *	0 otherwise
452  *
453  * If the pty is allocated to the current zone, it also returns the owner.
454  */
455 int
456 ptms_minor_valid(minor_t dminor, uid_t *ruid, gid_t *rgid)
457 {
458 	struct pt_ttys *pt;
459 	int ret;
460 
461 	ASSERT(ruid);
462 	ASSERT(rgid);
463 
464 	*ruid = (uid_t)-1;
465 	*rgid = (gid_t)-1;
466 
467 	/*
468 	 * /dev/pts/0 is not used, but some applications may check it, so create
469 	 * it also. Report the owner as root. It belongs to all zones.
470 	 */
471 	if (dminor == 0) {
472 		*ruid = 0;
473 		*rgid = 0;
474 		return (1);
475 	}
476 
477 	ret = 0;
478 	mutex_enter(&ptms_lock);
479 	pt = ptms_minor2ptty(dminor);
480 	if (pt != NULL) {
481 		ASSERT(pt->pt_ruid >= 0);
482 		ASSERT(pt->pt_rgid >= 0);
483 		if (pt->pt_zoneid == getzoneid()) {
484 			ret = 1;
485 			*ruid = pt->pt_ruid;
486 			*rgid = pt->pt_rgid;
487 		}
488 	}
489 	mutex_exit(&ptms_lock);
490 
491 	return (ret);
492 }
493 
494 /*
495  * Given a ptm/pts minor number
496  * returns:
497  *	0 if the pty is not allocated
498  *	1 if the pty is allocated
499  */
500 int
501 ptms_minor_exists(minor_t dminor)
502 {
503 	int ret;
504 
505 	mutex_enter(&ptms_lock);
506 	ret = ptms_minor2ptty(dminor) ? 1 : 0;
507 	mutex_exit(&ptms_lock);
508 
509 	return (ret);
510 }
511 
512 /*
513  * Close the pt and clear flags_to_clear.
514  * If pt device is not opened by someone else, free it and clear its slot.
515  */
516 void
517 ptms_close(struct pt_ttys *pt, uint_t flags_to_clear)
518 {
519 	uint_t flags;
520 
521 	ASSERT(MUTEX_NOT_HELD(&ptms_lock));
522 	ASSERT(pt != NULL);
523 
524 	mutex_enter(&ptms_lock);
525 
526 	mutex_enter(&pt->pt_lock);
527 	pt->pt_state &= ~flags_to_clear;
528 	flags = pt->pt_state;
529 	mutex_exit(&pt->pt_lock);
530 
531 	if (! (flags & (PTMOPEN | PTSOPEN))) {
532 		/* No one owns the entry - free it */
533 
534 		ASSERT(pt->ptm_rdq == NULL);
535 		ASSERT(pt->pts_rdq == NULL);
536 		ASSERT(pt->pt_nullmsg == NULL);
537 		ASSERT(pt->pt_refcnt == 0);
538 		ASSERT(pt->pt_minor <= ptms_nslots);
539 		ASSERT(ptms_slots[pt->pt_minor - 1] == pt);
540 		ASSERT(ptms_inuse > 0);
541 
542 		ptms_inuse--;
543 
544 		pt->pt_pid = 0;
545 
546 		ptms_slots[pt->pt_minor - 1] = NULL;
547 		/* Return minor number to the pool of minors */
548 		vmem_free(ptms_minor_arena, (void *)(uintptr_t)pt->pt_minor, 1);
549 		/* Return pt to the cache */
550 		kmem_cache_free(ptms_cache, pt);
551 	}
552 	mutex_exit(&ptms_lock);
553 }
554 
555 /*
556  * Allocate another slot table twice as large as the original one (limited to
557  * global maximum). Migrate all pt to the new slot table and free the original
558  * one. Create more /devices entries for new devices.
559  */
560 static minor_t
561 ptms_grow()
562 {
563 	minor_t old_size = ptms_nslots;
564 	minor_t delta = MIN(pt_maxdelta, old_size);
565 	minor_t new_size = old_size + delta;
566 	struct pt_ttys **ptms_old = ptms_slots;
567 	struct pt_ttys **ptms_new;
568 	void  *vaddr;			/* vmem_add return value */
569 
570 	ASSERT(MUTEX_HELD(&ptms_lock));
571 
572 	DDBG("ptmopen(%d): need to grow\n", (int)ptms_inuse);
573 
574 	/* Allocate new ptms array */
575 	ptms_new = kmem_zalloc(new_size * sizeof (struct pt_ttys *),
576 	    KM_NOSLEEP);
577 	if (ptms_new == NULL)
578 		return ((minor_t)0);
579 
580 	/* Increase clone index space */
581 	vaddr = vmem_add(ptms_minor_arena, (void *)(uintptr_t)(old_size + 1),
582 	    new_size - old_size, VM_NOSLEEP);
583 
584 	if (vaddr == NULL) {
585 		kmem_free(ptms_new, new_size * sizeof (struct pt_ttys *));
586 		return ((minor_t)0);
587 	}
588 
589 	/* Migrate pt entries to a new location */
590 	ptms_nslots = new_size;
591 	bcopy(ptms_old, ptms_new, old_size * sizeof (struct pt_ttys *));
592 	ptms_slots = ptms_new;
593 	kmem_free(ptms_old, old_size * sizeof (struct pt_ttys *));
594 
595 	/* Allocate minor number and return it */
596 	return ((minor_t)(uintptr_t)
597 	    vmem_alloc(ptms_minor_arena, 1, VM_NOSLEEP));
598 }
599 
600 /*ARGSUSED*/
601 static int
602 ptms_constructor(void *maddr, void *arg, int kmflags)
603 {
604 	struct pt_ttys *pt = maddr;
605 
606 	pt->pts_rdq = NULL;
607 	pt->ptm_rdq = NULL;
608 	pt->pt_nullmsg = NULL;
609 	pt->pt_pid = 0;
610 	pt->pt_minor = 0;
611 	pt->pt_refcnt = 0;
612 	pt->pt_state = 0;
613 	pt->pt_zoneid = GLOBAL_ZONEID;
614 
615 	cv_init(&pt->pt_cv, NULL, CV_DEFAULT, NULL);
616 	mutex_init(&pt->pt_lock, NULL, MUTEX_DEFAULT, NULL);
617 	return (0);
618 }
619 
620 /*ARGSUSED*/
621 static void
622 ptms_destructor(void *maddr, void *arg)
623 {
624 	struct pt_ttys *pt = maddr;
625 
626 	ASSERT(pt->pt_refcnt == 0);
627 	ASSERT(pt->pt_state == 0);
628 	ASSERT(pt->ptm_rdq == NULL);
629 	ASSERT(pt->pts_rdq == NULL);
630 
631 	mutex_destroy(&pt->pt_lock);
632 	cv_destroy(&pt->pt_cv);
633 }
634 
635 #ifdef DEBUG
636 void
637 ptms_log(char *str, uint_t arg)
638 {
639 	if (ptms_debug) {
640 		if (ptms_debug & 2)
641 			cmn_err(CE_CONT, str, arg);
642 		if (ptms_debug & 4)
643 			(void) strlog(PTMOD_ID, -1, 0, SL_TRACE | SL_ERROR,
644 			    str, arg);
645 		else
646 			(void) strlog(PTMOD_ID, -1, 0, SL_TRACE, str, arg);
647 	}
648 }
649 
650 void
651 ptms_logp(char *str, uintptr_t arg)
652 {
653 	if (ptms_debug) {
654 		if (ptms_debug & 2)
655 			cmn_err(CE_CONT, str, arg);
656 		if (ptms_debug & 4)
657 			(void) strlog(PTMOD_ID, -1, 0, SL_TRACE | SL_ERROR,
658 			    str, arg);
659 		else
660 			(void) strlog(PTMOD_ID, -1, 0, SL_TRACE, str, arg);
661 	}
662 }
663 #endif
664