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