xref: /titanic_41/usr/src/uts/common/disp/ts.c (revision 8b6220d73c6a079b62251e38103a523c41ee541a)
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 (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2013, Joyent, Inc. All rights reserved.
25  */
26 
27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 #include <sys/types.h>
31 #include <sys/param.h>
32 #include <sys/sysmacros.h>
33 #include <sys/cred.h>
34 #include <sys/proc.h>
35 #include <sys/session.h>
36 #include <sys/strsubr.h>
37 #include <sys/signal.h>
38 #include <sys/user.h>
39 #include <sys/priocntl.h>
40 #include <sys/class.h>
41 #include <sys/disp.h>
42 #include <sys/procset.h>
43 #include <sys/debug.h>
44 #include <sys/ts.h>
45 #include <sys/tspriocntl.h>
46 #include <sys/iapriocntl.h>
47 #include <sys/kmem.h>
48 #include <sys/errno.h>
49 #include <sys/cpuvar.h>
50 #include <sys/systm.h>		/* for lbolt */
51 #include <sys/vtrace.h>
52 #include <sys/vmsystm.h>
53 #include <sys/schedctl.h>
54 #include <sys/tnf_probe.h>
55 #include <sys/atomic.h>
56 #include <sys/policy.h>
57 #include <sys/sdt.h>
58 #include <sys/cpupart.h>
59 #include <vm/rm.h>
60 #include <vm/seg_kmem.h>
61 #include <sys/modctl.h>
62 #include <sys/cpucaps.h>
63 
64 static pri_t ts_init(id_t, int, classfuncs_t **);
65 
66 static struct sclass csw = {
67 	"TS",
68 	ts_init,
69 	0
70 };
71 
72 static struct modlsched modlsched = {
73 	&mod_schedops, "time sharing sched class", &csw
74 };
75 
76 static struct modlinkage modlinkage = {
77 	MODREV_1, (void *)&modlsched, NULL
78 };
79 
80 int
_init()81 _init()
82 {
83 	return (mod_install(&modlinkage));
84 }
85 
86 int
_fini()87 _fini()
88 {
89 	return (EBUSY);		/* don't remove TS for now */
90 }
91 
92 int
_info(struct modinfo * modinfop)93 _info(struct modinfo *modinfop)
94 {
95 	return (mod_info(&modlinkage, modinfop));
96 }
97 
98 /*
99  * Class specific code for the time-sharing class
100  */
101 
102 
103 /*
104  * Extern declarations for variables defined in the ts master file
105  */
106 #define	TSMAXUPRI 60
107 
108 pri_t	ts_maxupri = TSMAXUPRI;	/* max time-sharing user priority */
109 pri_t	ts_maxumdpri;		/* maximum user mode ts priority */
110 
111 pri_t	ia_maxupri = IAMAXUPRI;	/* max interactive user priority */
112 pri_t	ia_boost = IA_BOOST;	/* boost value for interactive */
113 
114 tsdpent_t  *ts_dptbl;	/* time-sharing disp parameter table */
115 pri_t	*ts_kmdpris;	/* array of global pris used by ts procs when */
116 			/*  sleeping or running in kernel after sleep */
117 
118 static id_t ia_cid;
119 
120 int ts_sleep_promote = 1;
121 
122 #define	tsmedumdpri	(ts_maxumdpri >> 1)
123 
124 #define	TS_NEWUMDPRI(tspp) \
125 { \
126 	pri_t pri; \
127 	pri = (tspp)->ts_cpupri + (tspp)->ts_upri + (tspp)->ts_boost; \
128 	if (pri > ts_maxumdpri) \
129 		(tspp)->ts_umdpri = ts_maxumdpri; \
130 	else if (pri < 0) \
131 		(tspp)->ts_umdpri = 0; \
132 	else \
133 		(tspp)->ts_umdpri = pri; \
134 	ASSERT((tspp)->ts_umdpri >= 0 && (tspp)->ts_umdpri <= ts_maxumdpri); \
135 }
136 
137 /*
138  * The tsproc_t structures are kept in an array of circular doubly linked
139  * lists.  A hash on the thread pointer is used to determine which list
140  * each thread should be placed.  Each list has a dummy "head" which is
141  * never removed, so the list is never empty.  ts_update traverses these
142  * lists to update the priorities of threads that have been waiting on
143  * the run queue.
144  */
145 
146 #define	TS_LISTS 16		/* number of lists, must be power of 2 */
147 
148 /* hash function, argument is a thread pointer */
149 #define	TS_LIST_HASH(tp)	(((uintptr_t)(tp) >> 9) & (TS_LISTS - 1))
150 
151 /* iterate to the next list */
152 #define	TS_LIST_NEXT(i)		(((i) + 1) & (TS_LISTS - 1))
153 
154 /*
155  * Insert thread into the appropriate tsproc list.
156  */
157 #define	TS_LIST_INSERT(tspp)				\
158 {							\
159 	int index = TS_LIST_HASH(tspp->ts_tp);		\
160 	kmutex_t *lockp = &ts_list_lock[index];		\
161 	tsproc_t *headp = &ts_plisthead[index];		\
162 	mutex_enter(lockp);				\
163 	tspp->ts_next = headp->ts_next;			\
164 	tspp->ts_prev = headp;				\
165 	headp->ts_next->ts_prev = tspp;			\
166 	headp->ts_next = tspp;				\
167 	mutex_exit(lockp);				\
168 }
169 
170 /*
171  * Remove thread from tsproc list.
172  */
173 #define	TS_LIST_DELETE(tspp)				\
174 {							\
175 	int index = TS_LIST_HASH(tspp->ts_tp);		\
176 	kmutex_t *lockp = &ts_list_lock[index];		\
177 	mutex_enter(lockp);				\
178 	tspp->ts_prev->ts_next = tspp->ts_next;		\
179 	tspp->ts_next->ts_prev = tspp->ts_prev;		\
180 	mutex_exit(lockp);				\
181 }
182 
183 
184 static int	ts_admin(caddr_t, cred_t *);
185 static int	ts_enterclass(kthread_t *, id_t, void *, cred_t *, void *);
186 static int	ts_fork(kthread_t *, kthread_t *, void *);
187 static int	ts_getclinfo(void *);
188 static int	ts_getclpri(pcpri_t *);
189 static int	ts_parmsin(void *);
190 static int	ts_parmsout(void *, pc_vaparms_t *);
191 static int	ts_vaparmsin(void *, pc_vaparms_t *);
192 static int	ts_vaparmsout(void *, pc_vaparms_t *);
193 static int	ts_parmsset(kthread_t *, void *, id_t, cred_t *);
194 static void	ts_exit(kthread_t *);
195 static int	ts_donice(kthread_t *, cred_t *, int, int *);
196 static int	ts_doprio(kthread_t *, cred_t *, int, int *);
197 static void	ts_exitclass(void *);
198 static int	ts_canexit(kthread_t *, cred_t *);
199 static void	ts_forkret(kthread_t *, kthread_t *);
200 static void	ts_nullsys();
201 static void	ts_parmsget(kthread_t *, void *);
202 static void	ts_preempt(kthread_t *);
203 static void	ts_setrun(kthread_t *);
204 static void	ts_sleep(kthread_t *);
205 static pri_t	ts_swapin(kthread_t *, int);
206 static pri_t	ts_swapout(kthread_t *, int);
207 static void	ts_tick(kthread_t *);
208 static void	ts_trapret(kthread_t *);
209 static void	ts_update(void *);
210 static int	ts_update_list(int);
211 static void	ts_wakeup(kthread_t *);
212 static pri_t	ts_globpri(kthread_t *);
213 static void	ts_yield(kthread_t *);
214 extern tsdpent_t *ts_getdptbl(void);
215 extern pri_t	*ts_getkmdpris(void);
216 extern pri_t	td_getmaxumdpri(void);
217 static int	ts_alloc(void **, int);
218 static void	ts_free(void *);
219 
220 pri_t		ia_init(id_t, int, classfuncs_t **);
221 static int	ia_getclinfo(void *);
222 static int	ia_getclpri(pcpri_t *);
223 static int	ia_parmsin(void *);
224 static int	ia_vaparmsin(void *, pc_vaparms_t *);
225 static int	ia_vaparmsout(void *, pc_vaparms_t *);
226 static int	ia_parmsset(kthread_t *, void *, id_t, cred_t *);
227 static void	ia_parmsget(kthread_t *, void *);
228 static void	ia_set_process_group(pid_t, pid_t, pid_t);
229 
230 static void	ts_change_priority(kthread_t *, tsproc_t *);
231 
232 extern pri_t	ts_maxkmdpri;	/* maximum kernel mode ts priority */
233 static pri_t	ts_maxglobpri;	/* maximum global priority used by ts class */
234 static kmutex_t	ts_dptblock;	/* protects time sharing dispatch table */
235 static kmutex_t	ts_list_lock[TS_LISTS];	/* protects tsproc lists */
236 static tsproc_t	ts_plisthead[TS_LISTS];	/* dummy tsproc at head of lists */
237 
238 static gid_t	IA_gid = 0;
239 
240 static struct classfuncs ts_classfuncs = {
241 	/* class functions */
242 	ts_admin,
243 	ts_getclinfo,
244 	ts_parmsin,
245 	ts_parmsout,
246 	ts_vaparmsin,
247 	ts_vaparmsout,
248 	ts_getclpri,
249 	ts_alloc,
250 	ts_free,
251 
252 	/* thread functions */
253 	ts_enterclass,
254 	ts_exitclass,
255 	ts_canexit,
256 	ts_fork,
257 	ts_forkret,
258 	ts_parmsget,
259 	ts_parmsset,
260 	ts_nullsys,	/* stop */
261 	ts_exit,
262 	ts_nullsys,	/* active */
263 	ts_nullsys,	/* inactive */
264 	ts_swapin,
265 	ts_swapout,
266 	ts_trapret,
267 	ts_preempt,
268 	ts_setrun,
269 	ts_sleep,
270 	ts_tick,
271 	ts_wakeup,
272 	ts_donice,
273 	ts_globpri,
274 	ts_nullsys,	/* set_process_group */
275 	ts_yield,
276 	ts_doprio,
277 };
278 
279 /*
280  * ia_classfuncs is used for interactive class threads; IA threads are stored
281  * on the same class list as TS threads, and most of the class functions are
282  * identical, but a few have different enough functionality to require their
283  * own functions.
284  */
285 static struct classfuncs ia_classfuncs = {
286 	/* class functions */
287 	ts_admin,
288 	ia_getclinfo,
289 	ia_parmsin,
290 	ts_parmsout,
291 	ia_vaparmsin,
292 	ia_vaparmsout,
293 	ia_getclpri,
294 	ts_alloc,
295 	ts_free,
296 
297 	/* thread functions */
298 	ts_enterclass,
299 	ts_exitclass,
300 	ts_canexit,
301 	ts_fork,
302 	ts_forkret,
303 	ia_parmsget,
304 	ia_parmsset,
305 	ts_nullsys,	/* stop */
306 	ts_exit,
307 	ts_nullsys,	/* active */
308 	ts_nullsys,	/* inactive */
309 	ts_swapin,
310 	ts_swapout,
311 	ts_trapret,
312 	ts_preempt,
313 	ts_setrun,
314 	ts_sleep,
315 	ts_tick,
316 	ts_wakeup,
317 	ts_donice,
318 	ts_globpri,
319 	ia_set_process_group,
320 	ts_yield,
321 	ts_doprio,
322 };
323 
324 
325 /*
326  * Time sharing class initialization.  Called by dispinit() at boot time.
327  * We can ignore the clparmsz argument since we know that the smallest
328  * possible parameter buffer is big enough for us.
329  */
330 /* ARGSUSED */
331 static pri_t
ts_init(id_t cid,int clparmsz,classfuncs_t ** clfuncspp)332 ts_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp)
333 {
334 	int i;
335 	extern pri_t ts_getmaxumdpri(void);
336 
337 	ts_dptbl = ts_getdptbl();
338 	ts_kmdpris = ts_getkmdpris();
339 	ts_maxumdpri = ts_getmaxumdpri();
340 	ts_maxglobpri = MAX(ts_kmdpris[0], ts_dptbl[ts_maxumdpri].ts_globpri);
341 
342 	/*
343 	 * Initialize the tsproc lists.
344 	 */
345 	for (i = 0; i < TS_LISTS; i++) {
346 		ts_plisthead[i].ts_next = ts_plisthead[i].ts_prev =
347 		    &ts_plisthead[i];
348 	}
349 
350 	/*
351 	 * We're required to return a pointer to our classfuncs
352 	 * structure and the highest global priority value we use.
353 	 */
354 	*clfuncspp = &ts_classfuncs;
355 	return (ts_maxglobpri);
356 }
357 
358 
359 /*
360  * Interactive class scheduler initialization
361  */
362 /* ARGSUSED */
363 pri_t
ia_init(id_t cid,int clparmsz,classfuncs_t ** clfuncspp)364 ia_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp)
365 {
366 	/*
367 	 * We're required to return a pointer to our classfuncs
368 	 * structure and the highest global priority value we use.
369 	 */
370 	ia_cid = cid;
371 	*clfuncspp = &ia_classfuncs;
372 	return (ts_maxglobpri);
373 }
374 
375 
376 /*
377  * Get or reset the ts_dptbl values per the user's request.
378  */
379 static int
ts_admin(caddr_t uaddr,cred_t * reqpcredp)380 ts_admin(caddr_t uaddr, cred_t *reqpcredp)
381 {
382 	tsadmin_t	tsadmin;
383 	tsdpent_t	*tmpdpp;
384 	int		userdpsz;
385 	int		i;
386 	size_t		tsdpsz;
387 
388 	if (get_udatamodel() == DATAMODEL_NATIVE) {
389 		if (copyin(uaddr, &tsadmin, sizeof (tsadmin_t)))
390 			return (EFAULT);
391 	}
392 #ifdef _SYSCALL32_IMPL
393 	else {
394 		/* get tsadmin struct from ILP32 caller */
395 		tsadmin32_t tsadmin32;
396 		if (copyin(uaddr, &tsadmin32, sizeof (tsadmin32_t)))
397 			return (EFAULT);
398 		tsadmin.ts_dpents =
399 		    (struct tsdpent *)(uintptr_t)tsadmin32.ts_dpents;
400 		tsadmin.ts_ndpents = tsadmin32.ts_ndpents;
401 		tsadmin.ts_cmd = tsadmin32.ts_cmd;
402 	}
403 #endif /* _SYSCALL32_IMPL */
404 
405 	tsdpsz = (ts_maxumdpri + 1) * sizeof (tsdpent_t);
406 
407 	switch (tsadmin.ts_cmd) {
408 	case TS_GETDPSIZE:
409 		tsadmin.ts_ndpents = ts_maxumdpri + 1;
410 
411 		if (get_udatamodel() == DATAMODEL_NATIVE) {
412 			if (copyout(&tsadmin, uaddr, sizeof (tsadmin_t)))
413 				return (EFAULT);
414 		}
415 #ifdef _SYSCALL32_IMPL
416 		else {
417 			/* return tsadmin struct to ILP32 caller */
418 			tsadmin32_t tsadmin32;
419 			tsadmin32.ts_dpents =
420 			    (caddr32_t)(uintptr_t)tsadmin.ts_dpents;
421 			tsadmin32.ts_ndpents = tsadmin.ts_ndpents;
422 			tsadmin32.ts_cmd = tsadmin.ts_cmd;
423 			if (copyout(&tsadmin32, uaddr, sizeof (tsadmin32_t)))
424 				return (EFAULT);
425 		}
426 #endif /* _SYSCALL32_IMPL */
427 		break;
428 
429 	case TS_GETDPTBL:
430 		userdpsz = MIN(tsadmin.ts_ndpents * sizeof (tsdpent_t),
431 		    tsdpsz);
432 		if (copyout(ts_dptbl, tsadmin.ts_dpents, userdpsz))
433 			return (EFAULT);
434 
435 		tsadmin.ts_ndpents = userdpsz / sizeof (tsdpent_t);
436 
437 		if (get_udatamodel() == DATAMODEL_NATIVE) {
438 			if (copyout(&tsadmin, uaddr, sizeof (tsadmin_t)))
439 				return (EFAULT);
440 		}
441 #ifdef _SYSCALL32_IMPL
442 		else {
443 			/* return tsadmin struct to ILP32 callers */
444 			tsadmin32_t tsadmin32;
445 			tsadmin32.ts_dpents =
446 			    (caddr32_t)(uintptr_t)tsadmin.ts_dpents;
447 			tsadmin32.ts_ndpents = tsadmin.ts_ndpents;
448 			tsadmin32.ts_cmd = tsadmin.ts_cmd;
449 			if (copyout(&tsadmin32, uaddr, sizeof (tsadmin32_t)))
450 				return (EFAULT);
451 		}
452 #endif /* _SYSCALL32_IMPL */
453 		break;
454 
455 	case TS_SETDPTBL:
456 		/*
457 		 * We require that the requesting process has sufficient
458 		 * priveleges.  We also require that the table supplied by
459 		 * the user exactly match the current ts_dptbl in size.
460 		 */
461 		if (secpolicy_dispadm(reqpcredp) != 0)
462 			return (EPERM);
463 
464 		if (tsadmin.ts_ndpents * sizeof (tsdpent_t) != tsdpsz) {
465 			return (EINVAL);
466 		}
467 
468 		/*
469 		 * We read the user supplied table into a temporary buffer
470 		 * where it is validated before being copied over the
471 		 * ts_dptbl.
472 		 */
473 		tmpdpp = kmem_alloc(tsdpsz, KM_SLEEP);
474 		if (copyin((caddr_t)tsadmin.ts_dpents, (caddr_t)tmpdpp,
475 		    tsdpsz)) {
476 			kmem_free(tmpdpp, tsdpsz);
477 			return (EFAULT);
478 		}
479 		for (i = 0; i < tsadmin.ts_ndpents; i++) {
480 
481 			/*
482 			 * Validate the user supplied values.  All we are doing
483 			 * here is verifying that the values are within their
484 			 * allowable ranges and will not panic the system.  We
485 			 * make no attempt to ensure that the resulting
486 			 * configuration makes sense or results in reasonable
487 			 * performance.
488 			 */
489 			if (tmpdpp[i].ts_quantum <= 0) {
490 				kmem_free(tmpdpp, tsdpsz);
491 				return (EINVAL);
492 			}
493 			if (tmpdpp[i].ts_tqexp > ts_maxumdpri ||
494 			    tmpdpp[i].ts_tqexp < 0) {
495 				kmem_free(tmpdpp, tsdpsz);
496 				return (EINVAL);
497 			}
498 			if (tmpdpp[i].ts_slpret > ts_maxumdpri ||
499 			    tmpdpp[i].ts_slpret < 0) {
500 				kmem_free(tmpdpp, tsdpsz);
501 				return (EINVAL);
502 			}
503 			if (tmpdpp[i].ts_maxwait < 0) {
504 				kmem_free(tmpdpp, tsdpsz);
505 				return (EINVAL);
506 			}
507 			if (tmpdpp[i].ts_lwait > ts_maxumdpri ||
508 			    tmpdpp[i].ts_lwait < 0) {
509 				kmem_free(tmpdpp, tsdpsz);
510 				return (EINVAL);
511 			}
512 		}
513 
514 		/*
515 		 * Copy the user supplied values over the current ts_dptbl
516 		 * values.  The ts_globpri member is read-only so we don't
517 		 * overwrite it.
518 		 */
519 		mutex_enter(&ts_dptblock);
520 		for (i = 0; i < tsadmin.ts_ndpents; i++) {
521 			ts_dptbl[i].ts_quantum = tmpdpp[i].ts_quantum;
522 			ts_dptbl[i].ts_tqexp = tmpdpp[i].ts_tqexp;
523 			ts_dptbl[i].ts_slpret = tmpdpp[i].ts_slpret;
524 			ts_dptbl[i].ts_maxwait = tmpdpp[i].ts_maxwait;
525 			ts_dptbl[i].ts_lwait = tmpdpp[i].ts_lwait;
526 		}
527 		mutex_exit(&ts_dptblock);
528 		kmem_free(tmpdpp, tsdpsz);
529 		break;
530 
531 	default:
532 		return (EINVAL);
533 	}
534 	return (0);
535 }
536 
537 
538 /*
539  * Allocate a time-sharing class specific thread structure and
540  * initialize it with the parameters supplied. Also move the thread
541  * to specified time-sharing priority.
542  */
543 static int
ts_enterclass(kthread_t * t,id_t cid,void * parmsp,cred_t * reqpcredp,void * bufp)544 ts_enterclass(kthread_t *t, id_t cid, void *parmsp,
545 	cred_t *reqpcredp, void *bufp)
546 {
547 	tsparms_t	*tsparmsp = (tsparms_t *)parmsp;
548 	tsproc_t	*tspp;
549 	pri_t		reqtsuprilim;
550 	pri_t		reqtsupri;
551 	static uint32_t	tspexists = 0;	/* set on first occurrence of */
552 					/*   a time-sharing process */
553 
554 	tspp = (tsproc_t *)bufp;
555 	ASSERT(tspp != NULL);
556 
557 	/*
558 	 * Initialize the tsproc structure.
559 	 */
560 	tspp->ts_cpupri = tsmedumdpri;
561 	if (cid == ia_cid) {
562 		/*
563 		 * Check to make sure caller is either privileged or the
564 		 * window system.  When the window system is converted
565 		 * to using privileges, the second check can go away.
566 		 */
567 		if (reqpcredp != NULL && !groupmember(IA_gid, reqpcredp) &&
568 		    secpolicy_setpriority(reqpcredp) != 0)
569 			return (EPERM);
570 		/*
571 		 * Belongs to IA "class", so set appropriate flags.
572 		 * Mark as 'on' so it will not be a swap victim
573 		 * while forking.
574 		 */
575 		tspp->ts_flags = TSIA | TSIASET;
576 		tspp->ts_boost = ia_boost;
577 	} else {
578 		tspp->ts_flags = 0;
579 		tspp->ts_boost = 0;
580 	}
581 
582 	if (tsparmsp == NULL) {
583 		/*
584 		 * Use default values.
585 		 */
586 		tspp->ts_uprilim = tspp->ts_upri = 0;
587 		tspp->ts_nice = NZERO;
588 	} else {
589 		/*
590 		 * Use supplied values.
591 		 */
592 		if (tsparmsp->ts_uprilim == TS_NOCHANGE)
593 			reqtsuprilim = 0;
594 		else {
595 			if (tsparmsp->ts_uprilim > 0 &&
596 			    secpolicy_setpriority(reqpcredp) != 0)
597 				return (EPERM);
598 			reqtsuprilim = tsparmsp->ts_uprilim;
599 		}
600 
601 		if (tsparmsp->ts_upri == TS_NOCHANGE) {
602 			reqtsupri = reqtsuprilim;
603 		} else {
604 			if (tsparmsp->ts_upri > 0 &&
605 			    secpolicy_setpriority(reqpcredp) != 0)
606 				return (EPERM);
607 			/*
608 			 * Set the user priority to the requested value
609 			 * or the upri limit, whichever is lower.
610 			 */
611 			reqtsupri = tsparmsp->ts_upri;
612 			if (reqtsupri > reqtsuprilim)
613 				reqtsupri = reqtsuprilim;
614 		}
615 
616 
617 		tspp->ts_uprilim = reqtsuprilim;
618 		tspp->ts_upri = reqtsupri;
619 		tspp->ts_nice = NZERO - (NZERO * reqtsupri) / ts_maxupri;
620 	}
621 	TS_NEWUMDPRI(tspp);
622 
623 	tspp->ts_dispwait = 0;
624 	tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
625 	tspp->ts_tp = t;
626 	cpucaps_sc_init(&tspp->ts_caps);
627 
628 	/*
629 	 * Reset priority. Process goes to a "user mode" priority
630 	 * here regardless of whether or not it has slept since
631 	 * entering the kernel.
632 	 */
633 	thread_lock(t);			/* get dispatcher lock on thread */
634 	t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
635 	t->t_cid = cid;
636 	t->t_cldata = (void *)tspp;
637 	t->t_schedflag &= ~TS_RUNQMATCH;
638 	ts_change_priority(t, tspp);
639 	thread_unlock(t);
640 
641 	/*
642 	 * Link new structure into tsproc list.
643 	 */
644 	TS_LIST_INSERT(tspp);
645 
646 	/*
647 	 * If this is the first time-sharing thread to occur since
648 	 * boot we set up the initial call to ts_update() here.
649 	 * Use an atomic compare-and-swap since that's easier and
650 	 * faster than a mutex (but check with an ordinary load first
651 	 * since most of the time this will already be done).
652 	 */
653 	if (tspexists == 0 && atomic_cas_32(&tspexists, 0, 1) == 0)
654 		(void) timeout(ts_update, NULL, hz);
655 
656 	return (0);
657 }
658 
659 
660 /*
661  * Free tsproc structure of thread.
662  */
663 static void
ts_exitclass(void * procp)664 ts_exitclass(void *procp)
665 {
666 	tsproc_t *tspp = (tsproc_t *)procp;
667 
668 	/* Remove tsproc_t structure from list */
669 	TS_LIST_DELETE(tspp);
670 	kmem_free(tspp, sizeof (tsproc_t));
671 }
672 
673 /* ARGSUSED */
674 static int
ts_canexit(kthread_t * t,cred_t * cred)675 ts_canexit(kthread_t *t, cred_t *cred)
676 {
677 	/*
678 	 * A thread can always leave a TS/IA class
679 	 */
680 	return (0);
681 }
682 
683 static int
ts_fork(kthread_t * t,kthread_t * ct,void * bufp)684 ts_fork(kthread_t *t, kthread_t *ct, void *bufp)
685 {
686 	tsproc_t	*ptspp;		/* ptr to parent's tsproc structure */
687 	tsproc_t	*ctspp;		/* ptr to child's tsproc structure */
688 
689 	ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock));
690 
691 	ctspp = (tsproc_t *)bufp;
692 	ASSERT(ctspp != NULL);
693 	ptspp = (tsproc_t *)t->t_cldata;
694 	/*
695 	 * Initialize child's tsproc structure.
696 	 */
697 	thread_lock(t);
698 	ctspp->ts_timeleft = ts_dptbl[ptspp->ts_cpupri].ts_quantum;
699 	ctspp->ts_cpupri = ptspp->ts_cpupri;
700 	ctspp->ts_boost = ptspp->ts_boost;
701 	ctspp->ts_uprilim = ptspp->ts_uprilim;
702 	ctspp->ts_upri = ptspp->ts_upri;
703 	TS_NEWUMDPRI(ctspp);
704 	ctspp->ts_nice = ptspp->ts_nice;
705 	ctspp->ts_dispwait = 0;
706 	ctspp->ts_flags = ptspp->ts_flags & ~(TSKPRI | TSBACKQ | TSRESTORE);
707 	ctspp->ts_tp = ct;
708 	cpucaps_sc_init(&ctspp->ts_caps);
709 	thread_unlock(t);
710 
711 	/*
712 	 * Link new structure into tsproc list.
713 	 */
714 	ct->t_cldata = (void *)ctspp;
715 	TS_LIST_INSERT(ctspp);
716 	return (0);
717 }
718 
719 
720 /*
721  * Child is placed at back of dispatcher queue and parent gives
722  * up processor so that the child runs first after the fork.
723  * This allows the child immediately execing to break the multiple
724  * use of copy on write pages with no disk home. The parent will
725  * get to steal them back rather than uselessly copying them.
726  */
727 static void
ts_forkret(kthread_t * t,kthread_t * ct)728 ts_forkret(kthread_t *t, kthread_t *ct)
729 {
730 	proc_t	*pp = ttoproc(t);
731 	proc_t	*cp = ttoproc(ct);
732 	tsproc_t *tspp;
733 
734 	ASSERT(t == curthread);
735 	ASSERT(MUTEX_HELD(&pidlock));
736 
737 	/*
738 	 * Grab the child's p_lock before dropping pidlock to ensure
739 	 * the process does not disappear before we set it running.
740 	 */
741 	mutex_enter(&cp->p_lock);
742 	continuelwps(cp);
743 	mutex_exit(&cp->p_lock);
744 
745 	mutex_enter(&pp->p_lock);
746 	mutex_exit(&pidlock);
747 	continuelwps(pp);
748 
749 	thread_lock(t);
750 	tspp = (tsproc_t *)(t->t_cldata);
751 	tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp;
752 	TS_NEWUMDPRI(tspp);
753 	tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
754 	tspp->ts_dispwait = 0;
755 	t->t_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
756 	ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
757 	tspp->ts_flags &= ~TSKPRI;
758 	THREAD_TRANSITION(t);
759 	ts_setrun(t);
760 	thread_unlock(t);
761 	/*
762 	 * Safe to drop p_lock now since since it is safe to change
763 	 * the scheduling class after this point.
764 	 */
765 	mutex_exit(&pp->p_lock);
766 
767 	swtch();
768 }
769 
770 
771 /*
772  * Get information about the time-sharing class into the buffer
773  * pointed to by tsinfop. The maximum configured user priority
774  * is the only information we supply.  ts_getclinfo() is called
775  * for TS threads, and ia_getclinfo() is called for IA threads.
776  */
777 static int
ts_getclinfo(void * infop)778 ts_getclinfo(void *infop)
779 {
780 	tsinfo_t *tsinfop = (tsinfo_t *)infop;
781 	tsinfop->ts_maxupri = ts_maxupri;
782 	return (0);
783 }
784 
785 static int
ia_getclinfo(void * infop)786 ia_getclinfo(void *infop)
787 {
788 	iainfo_t *iainfop = (iainfo_t *)infop;
789 	iainfop->ia_maxupri = ia_maxupri;
790 	return (0);
791 }
792 
793 
794 /*
795  * Return the user mode scheduling priority range.
796  */
797 static int
ts_getclpri(pcpri_t * pcprip)798 ts_getclpri(pcpri_t *pcprip)
799 {
800 	pcprip->pc_clpmax = ts_maxupri;
801 	pcprip->pc_clpmin = -ts_maxupri;
802 	return (0);
803 }
804 
805 
806 static int
ia_getclpri(pcpri_t * pcprip)807 ia_getclpri(pcpri_t *pcprip)
808 {
809 	pcprip->pc_clpmax = ia_maxupri;
810 	pcprip->pc_clpmin = -ia_maxupri;
811 	return (0);
812 }
813 
814 
815 static void
ts_nullsys()816 ts_nullsys()
817 {}
818 
819 
820 /*
821  * Get the time-sharing parameters of the thread pointed to by
822  * tsprocp into the buffer pointed to by tsparmsp.  ts_parmsget()
823  * is called for TS threads, and ia_parmsget() is called for IA
824  * threads.
825  */
826 static void
ts_parmsget(kthread_t * t,void * parmsp)827 ts_parmsget(kthread_t *t, void *parmsp)
828 {
829 	tsproc_t *tspp = (tsproc_t *)t->t_cldata;
830 	tsparms_t *tsparmsp = (tsparms_t *)parmsp;
831 
832 	tsparmsp->ts_uprilim = tspp->ts_uprilim;
833 	tsparmsp->ts_upri = tspp->ts_upri;
834 }
835 
836 static void
ia_parmsget(kthread_t * t,void * parmsp)837 ia_parmsget(kthread_t *t, void *parmsp)
838 {
839 	tsproc_t *tspp = (tsproc_t *)t->t_cldata;
840 	iaparms_t *iaparmsp = (iaparms_t *)parmsp;
841 
842 	iaparmsp->ia_uprilim = tspp->ts_uprilim;
843 	iaparmsp->ia_upri = tspp->ts_upri;
844 	if (tspp->ts_flags & TSIASET)
845 		iaparmsp->ia_mode = IA_SET_INTERACTIVE;
846 	else
847 		iaparmsp->ia_mode = IA_INTERACTIVE_OFF;
848 }
849 
850 
851 /*
852  * Check the validity of the time-sharing parameters in the buffer
853  * pointed to by tsparmsp.
854  * ts_parmsin() is called for TS threads, and ia_parmsin() is called
855  * for IA threads.
856  */
857 static int
ts_parmsin(void * parmsp)858 ts_parmsin(void *parmsp)
859 {
860 	tsparms_t	*tsparmsp = (tsparms_t *)parmsp;
861 	/*
862 	 * Check validity of parameters.
863 	 */
864 	if ((tsparmsp->ts_uprilim > ts_maxupri ||
865 	    tsparmsp->ts_uprilim < -ts_maxupri) &&
866 	    tsparmsp->ts_uprilim != TS_NOCHANGE)
867 		return (EINVAL);
868 
869 	if ((tsparmsp->ts_upri > ts_maxupri ||
870 	    tsparmsp->ts_upri < -ts_maxupri) &&
871 	    tsparmsp->ts_upri != TS_NOCHANGE)
872 		return (EINVAL);
873 
874 	return (0);
875 }
876 
877 static int
ia_parmsin(void * parmsp)878 ia_parmsin(void *parmsp)
879 {
880 	iaparms_t	*iaparmsp = (iaparms_t *)parmsp;
881 
882 	if ((iaparmsp->ia_uprilim > ia_maxupri ||
883 	    iaparmsp->ia_uprilim < -ia_maxupri) &&
884 	    iaparmsp->ia_uprilim != IA_NOCHANGE) {
885 		return (EINVAL);
886 	}
887 
888 	if ((iaparmsp->ia_upri > ia_maxupri ||
889 	    iaparmsp->ia_upri < -ia_maxupri) &&
890 	    iaparmsp->ia_upri != IA_NOCHANGE) {
891 		return (EINVAL);
892 	}
893 
894 	return (0);
895 }
896 
897 
898 /*
899  * Check the validity of the time-sharing parameters in the pc_vaparms_t
900  * structure vaparmsp and put them in the buffer pointed to by tsparmsp.
901  * pc_vaparms_t contains (key, value) pairs of parameter.
902  * ts_vaparmsin() is called for TS threads, and ia_vaparmsin() is called
903  * for IA threads. ts_vaparmsin() is the variable parameter version of
904  * ts_parmsin() and ia_vaparmsin() is the variable parameter version of
905  * ia_parmsin().
906  */
907 static int
ts_vaparmsin(void * parmsp,pc_vaparms_t * vaparmsp)908 ts_vaparmsin(void *parmsp, pc_vaparms_t *vaparmsp)
909 {
910 	tsparms_t	*tsparmsp = (tsparms_t *)parmsp;
911 	int		priflag = 0;
912 	int		limflag = 0;
913 	uint_t		cnt;
914 	pc_vaparm_t	*vpp = &vaparmsp->pc_parms[0];
915 
916 
917 	/*
918 	 * TS_NOCHANGE (-32768) is outside of the range of values for
919 	 * ts_uprilim and ts_upri. If the structure tsparms_t is changed,
920 	 * TS_NOCHANGE should be replaced by a flag word (in the same manner
921 	 * as in rt.c).
922 	 */
923 	tsparmsp->ts_uprilim = TS_NOCHANGE;
924 	tsparmsp->ts_upri = TS_NOCHANGE;
925 
926 	/*
927 	 * Get the varargs parameter and check validity of parameters.
928 	 */
929 	if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
930 		return (EINVAL);
931 
932 	for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
933 
934 		switch (vpp->pc_key) {
935 		case TS_KY_UPRILIM:
936 			if (limflag++)
937 				return (EINVAL);
938 			tsparmsp->ts_uprilim = (pri_t)vpp->pc_parm;
939 			if (tsparmsp->ts_uprilim > ts_maxupri ||
940 			    tsparmsp->ts_uprilim < -ts_maxupri)
941 				return (EINVAL);
942 			break;
943 
944 		case TS_KY_UPRI:
945 			if (priflag++)
946 				return (EINVAL);
947 			tsparmsp->ts_upri = (pri_t)vpp->pc_parm;
948 			if (tsparmsp->ts_upri > ts_maxupri ||
949 			    tsparmsp->ts_upri < -ts_maxupri)
950 				return (EINVAL);
951 			break;
952 
953 		default:
954 			return (EINVAL);
955 		}
956 	}
957 
958 	if (vaparmsp->pc_vaparmscnt == 0) {
959 		/*
960 		 * Use default parameters.
961 		 */
962 		tsparmsp->ts_upri = tsparmsp->ts_uprilim = 0;
963 	}
964 
965 	return (0);
966 }
967 
968 static int
ia_vaparmsin(void * parmsp,pc_vaparms_t * vaparmsp)969 ia_vaparmsin(void *parmsp, pc_vaparms_t *vaparmsp)
970 {
971 	iaparms_t	*iaparmsp = (iaparms_t *)parmsp;
972 	int		priflag = 0;
973 	int		limflag = 0;
974 	int		mflag = 0;
975 	uint_t		cnt;
976 	pc_vaparm_t	*vpp = &vaparmsp->pc_parms[0];
977 
978 	/*
979 	 * IA_NOCHANGE (-32768) is outside of the range of values for
980 	 * ia_uprilim, ia_upri and ia_mode. If the structure iaparms_t is
981 	 * changed, IA_NOCHANGE should be replaced by a flag word (in the
982 	 * same manner as in rt.c).
983 	 */
984 	iaparmsp->ia_uprilim = IA_NOCHANGE;
985 	iaparmsp->ia_upri = IA_NOCHANGE;
986 	iaparmsp->ia_mode = IA_NOCHANGE;
987 
988 	/*
989 	 * Get the varargs parameter and check validity of parameters.
990 	 */
991 	if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
992 		return (EINVAL);
993 
994 	for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
995 
996 		switch (vpp->pc_key) {
997 		case IA_KY_UPRILIM:
998 			if (limflag++)
999 				return (EINVAL);
1000 			iaparmsp->ia_uprilim = (pri_t)vpp->pc_parm;
1001 			if (iaparmsp->ia_uprilim > ia_maxupri ||
1002 			    iaparmsp->ia_uprilim < -ia_maxupri)
1003 				return (EINVAL);
1004 			break;
1005 
1006 		case IA_KY_UPRI:
1007 			if (priflag++)
1008 				return (EINVAL);
1009 			iaparmsp->ia_upri = (pri_t)vpp->pc_parm;
1010 			if (iaparmsp->ia_upri > ia_maxupri ||
1011 			    iaparmsp->ia_upri < -ia_maxupri)
1012 				return (EINVAL);
1013 			break;
1014 
1015 		case IA_KY_MODE:
1016 			if (mflag++)
1017 				return (EINVAL);
1018 			iaparmsp->ia_mode = (int)vpp->pc_parm;
1019 			if (iaparmsp->ia_mode != IA_SET_INTERACTIVE &&
1020 			    iaparmsp->ia_mode != IA_INTERACTIVE_OFF)
1021 				return (EINVAL);
1022 			break;
1023 
1024 		default:
1025 			return (EINVAL);
1026 		}
1027 	}
1028 
1029 	if (vaparmsp->pc_vaparmscnt == 0) {
1030 		/*
1031 		 * Use default parameters.
1032 		 */
1033 		iaparmsp->ia_upri = iaparmsp->ia_uprilim = 0;
1034 		iaparmsp->ia_mode = IA_SET_INTERACTIVE;
1035 	}
1036 
1037 	return (0);
1038 }
1039 
1040 /*
1041  * Nothing to do here but return success.
1042  */
1043 /* ARGSUSED */
1044 static int
ts_parmsout(void * parmsp,pc_vaparms_t * vaparmsp)1045 ts_parmsout(void *parmsp, pc_vaparms_t *vaparmsp)
1046 {
1047 	return (0);
1048 }
1049 
1050 
1051 /*
1052  * Copy all selected time-sharing class parameters to the user.
1053  * The parameters are specified by a key.
1054  */
1055 static int
ts_vaparmsout(void * prmsp,pc_vaparms_t * vaparmsp)1056 ts_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp)
1057 {
1058 	tsparms_t	*tsprmsp = (tsparms_t *)prmsp;
1059 	int		priflag = 0;
1060 	int		limflag = 0;
1061 	uint_t		cnt;
1062 	pc_vaparm_t	*vpp = &vaparmsp->pc_parms[0];
1063 
1064 	ASSERT(MUTEX_NOT_HELD(&curproc->p_lock));
1065 
1066 	if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
1067 		return (EINVAL);
1068 
1069 	for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
1070 
1071 		switch (vpp->pc_key) {
1072 		case TS_KY_UPRILIM:
1073 			if (limflag++)
1074 				return (EINVAL);
1075 			if (copyout(&tsprmsp->ts_uprilim,
1076 			    (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
1077 				return (EFAULT);
1078 			break;
1079 
1080 		case TS_KY_UPRI:
1081 			if (priflag++)
1082 				return (EINVAL);
1083 			if (copyout(&tsprmsp->ts_upri,
1084 			    (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
1085 				return (EFAULT);
1086 			break;
1087 
1088 		default:
1089 			return (EINVAL);
1090 		}
1091 	}
1092 
1093 	return (0);
1094 }
1095 
1096 
1097 /*
1098  * Copy all selected interactive class parameters to the user.
1099  * The parameters are specified by a key.
1100  */
1101 static int
ia_vaparmsout(void * prmsp,pc_vaparms_t * vaparmsp)1102 ia_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp)
1103 {
1104 	iaparms_t	*iaprmsp = (iaparms_t *)prmsp;
1105 	int		priflag = 0;
1106 	int		limflag = 0;
1107 	int		mflag = 0;
1108 	uint_t		cnt;
1109 	pc_vaparm_t	*vpp = &vaparmsp->pc_parms[0];
1110 
1111 	ASSERT(MUTEX_NOT_HELD(&curproc->p_lock));
1112 
1113 	if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
1114 		return (EINVAL);
1115 
1116 	for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
1117 
1118 		switch (vpp->pc_key) {
1119 		case IA_KY_UPRILIM:
1120 			if (limflag++)
1121 				return (EINVAL);
1122 			if (copyout(&iaprmsp->ia_uprilim,
1123 			    (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
1124 				return (EFAULT);
1125 			break;
1126 
1127 		case IA_KY_UPRI:
1128 			if (priflag++)
1129 				return (EINVAL);
1130 			if (copyout(&iaprmsp->ia_upri,
1131 			    (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
1132 				return (EFAULT);
1133 			break;
1134 
1135 		case IA_KY_MODE:
1136 			if (mflag++)
1137 				return (EINVAL);
1138 			if (copyout(&iaprmsp->ia_mode,
1139 			    (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (int)))
1140 				return (EFAULT);
1141 			break;
1142 
1143 		default:
1144 			return (EINVAL);
1145 		}
1146 	}
1147 	return (0);
1148 }
1149 
1150 
1151 /*
1152  * Set the scheduling parameters of the thread pointed to by tsprocp
1153  * to those specified in the buffer pointed to by tsparmsp.
1154  * ts_parmsset() is called for TS threads, and ia_parmsset() is
1155  * called for IA threads.
1156  */
1157 /* ARGSUSED */
1158 static int
ts_parmsset(kthread_t * tx,void * parmsp,id_t reqpcid,cred_t * reqpcredp)1159 ts_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp)
1160 {
1161 	char		nice;
1162 	pri_t		reqtsuprilim;
1163 	pri_t		reqtsupri;
1164 	tsparms_t	*tsparmsp = (tsparms_t *)parmsp;
1165 	tsproc_t	*tspp = (tsproc_t *)tx->t_cldata;
1166 
1167 	ASSERT(MUTEX_HELD(&(ttoproc(tx))->p_lock));
1168 
1169 	if (tsparmsp->ts_uprilim == TS_NOCHANGE)
1170 		reqtsuprilim = tspp->ts_uprilim;
1171 	else
1172 		reqtsuprilim = tsparmsp->ts_uprilim;
1173 
1174 	if (tsparmsp->ts_upri == TS_NOCHANGE)
1175 		reqtsupri = tspp->ts_upri;
1176 	else
1177 		reqtsupri = tsparmsp->ts_upri;
1178 
1179 	/*
1180 	 * Make sure the user priority doesn't exceed the upri limit.
1181 	 */
1182 	if (reqtsupri > reqtsuprilim)
1183 		reqtsupri = reqtsuprilim;
1184 
1185 	/*
1186 	 * Basic permissions enforced by generic kernel code
1187 	 * for all classes require that a thread attempting
1188 	 * to change the scheduling parameters of a target
1189 	 * thread be privileged or have a real or effective
1190 	 * UID matching that of the target thread. We are not
1191 	 * called unless these basic permission checks have
1192 	 * already passed. The time-sharing class requires in
1193 	 * addition that the calling thread be privileged if it
1194 	 * is attempting to raise the upri limit above its current
1195 	 * value This may have been checked previously but if our
1196 	 * caller passed us a non-NULL credential pointer we assume
1197 	 * it hasn't and we check it here.
1198 	 */
1199 	if (reqpcredp != NULL &&
1200 	    reqtsuprilim > tspp->ts_uprilim &&
1201 	    secpolicy_raisepriority(reqpcredp) != 0)
1202 		return (EPERM);
1203 
1204 	/*
1205 	 * Set ts_nice to the nice value corresponding to the user
1206 	 * priority we are setting.  Note that setting the nice field
1207 	 * of the parameter struct won't affect upri or nice.
1208 	 */
1209 	nice = NZERO - (reqtsupri * NZERO) / ts_maxupri;
1210 	if (nice >= 2 * NZERO)
1211 		nice = 2 * NZERO - 1;
1212 
1213 	thread_lock(tx);
1214 
1215 	tspp->ts_uprilim = reqtsuprilim;
1216 	tspp->ts_upri = reqtsupri;
1217 	TS_NEWUMDPRI(tspp);
1218 	tspp->ts_nice = nice;
1219 
1220 	if ((tspp->ts_flags & TSKPRI) != 0) {
1221 		thread_unlock(tx);
1222 		return (0);
1223 	}
1224 
1225 	tspp->ts_dispwait = 0;
1226 	ts_change_priority(tx, tspp);
1227 	thread_unlock(tx);
1228 	return (0);
1229 }
1230 
1231 
1232 static int
ia_parmsset(kthread_t * tx,void * parmsp,id_t reqpcid,cred_t * reqpcredp)1233 ia_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp)
1234 {
1235 	tsproc_t	*tspp = (tsproc_t *)tx->t_cldata;
1236 	iaparms_t	*iaparmsp = (iaparms_t *)parmsp;
1237 	proc_t		*p;
1238 	pid_t		pid, pgid, sid;
1239 	pid_t		on, off;
1240 	struct stdata 	*stp;
1241 	int		sess_held;
1242 
1243 	/*
1244 	 * Handle user priority changes
1245 	 */
1246 	if (iaparmsp->ia_mode == IA_NOCHANGE)
1247 		return (ts_parmsset(tx, parmsp, reqpcid, reqpcredp));
1248 
1249 	/*
1250 	 * Check permissions for changing modes.
1251 	 */
1252 
1253 	if (reqpcredp != NULL && !groupmember(IA_gid, reqpcredp) &&
1254 	    secpolicy_raisepriority(reqpcredp) != 0) {
1255 		/*
1256 		 * Silently fail in case this is just a priocntl
1257 		 * call with upri and uprilim set to IA_NOCHANGE.
1258 		 */
1259 		return (0);
1260 	}
1261 
1262 	ASSERT(MUTEX_HELD(&pidlock));
1263 	if ((p = ttoproc(tx)) == NULL) {
1264 		return (0);
1265 	}
1266 	ASSERT(MUTEX_HELD(&p->p_lock));
1267 	if (p->p_stat == SIDL) {
1268 		return (0);
1269 	}
1270 	pid = p->p_pid;
1271 	sid = p->p_sessp->s_sid;
1272 	pgid = p->p_pgrp;
1273 	if (iaparmsp->ia_mode == IA_SET_INTERACTIVE) {
1274 		/*
1275 		 * session leaders must be turned on now so all processes
1276 		 * in the group controlling the tty will be turned on or off.
1277 		 * if the ia_mode is off for the session leader,
1278 		 * ia_set_process_group will return without setting the
1279 		 * processes in the group controlling the tty on.
1280 		 */
1281 		thread_lock(tx);
1282 		tspp->ts_flags |= TSIASET;
1283 		thread_unlock(tx);
1284 	}
1285 	mutex_enter(&p->p_sessp->s_lock);
1286 	sess_held = 1;
1287 	if ((pid == sid) && (p->p_sessp->s_vp != NULL) &&
1288 	    ((stp = p->p_sessp->s_vp->v_stream) != NULL)) {
1289 		if ((stp->sd_pgidp != NULL) && (stp->sd_sidp != NULL)) {
1290 			pgid = stp->sd_pgidp->pid_id;
1291 			sess_held = 0;
1292 			mutex_exit(&p->p_sessp->s_lock);
1293 			if (iaparmsp->ia_mode ==
1294 			    IA_SET_INTERACTIVE) {
1295 				off = 0;
1296 				on = pgid;
1297 			} else {
1298 				off = pgid;
1299 				on = 0;
1300 			}
1301 			TRACE_3(TR_FAC_IA, TR_ACTIVE_CHAIN,
1302 			    "active chain:pid %d gid %d %p",
1303 			    pid, pgid, p);
1304 			ia_set_process_group(sid, off, on);
1305 		}
1306 	}
1307 	if (sess_held)
1308 		mutex_exit(&p->p_sessp->s_lock);
1309 
1310 	thread_lock(tx);
1311 
1312 	if (iaparmsp->ia_mode == IA_SET_INTERACTIVE) {
1313 		tspp->ts_flags |= TSIASET;
1314 		tspp->ts_boost = ia_boost;
1315 	} else {
1316 		tspp->ts_flags &= ~TSIASET;
1317 		tspp->ts_boost = -ia_boost;
1318 	}
1319 	thread_unlock(tx);
1320 
1321 	return (ts_parmsset(tx, parmsp, reqpcid, reqpcredp));
1322 }
1323 
1324 static void
ts_exit(kthread_t * t)1325 ts_exit(kthread_t *t)
1326 {
1327 	tsproc_t *tspp;
1328 
1329 	if (CPUCAPS_ON()) {
1330 		/*
1331 		 * A thread could be exiting in between clock ticks,
1332 		 * so we need to calculate how much CPU time it used
1333 		 * since it was charged last time.
1334 		 *
1335 		 * CPU caps are not enforced on exiting processes - it is
1336 		 * usually desirable to exit as soon as possible to free
1337 		 * resources.
1338 		 */
1339 		thread_lock(t);
1340 		tspp = (tsproc_t *)t->t_cldata;
1341 		(void) cpucaps_charge(t, &tspp->ts_caps, CPUCAPS_CHARGE_ONLY);
1342 		thread_unlock(t);
1343 	}
1344 }
1345 
1346 /*
1347  * Return the global scheduling priority that would be assigned
1348  * to a thread entering the time-sharing class with the ts_upri.
1349  */
1350 static pri_t
ts_globpri(kthread_t * t)1351 ts_globpri(kthread_t *t)
1352 {
1353 	tsproc_t *tspp;
1354 	pri_t	tspri;
1355 
1356 	ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock));
1357 	tspp = (tsproc_t *)t->t_cldata;
1358 	tspri = tsmedumdpri + tspp->ts_upri;
1359 	if (tspri > ts_maxumdpri)
1360 		tspri = ts_maxumdpri;
1361 	else if (tspri < 0)
1362 		tspri = 0;
1363 	return (ts_dptbl[tspri].ts_globpri);
1364 }
1365 
1366 /*
1367  * Arrange for thread to be placed in appropriate location
1368  * on dispatcher queue.
1369  *
1370  * This is called with the current thread in TS_ONPROC and locked.
1371  */
1372 static void
ts_preempt(kthread_t * t)1373 ts_preempt(kthread_t *t)
1374 {
1375 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
1376 	klwp_t		*lwp = curthread->t_lwp;
1377 	pri_t		oldpri = t->t_pri;
1378 
1379 	ASSERT(t == curthread);
1380 	ASSERT(THREAD_LOCK_HELD(curthread));
1381 
1382 	/*
1383 	 * If preempted in the kernel, make sure the thread has
1384 	 * a kernel priority if needed.
1385 	 */
1386 	if (!(tspp->ts_flags & TSKPRI) && lwp != NULL && t->t_kpri_req) {
1387 		tspp->ts_flags |= TSKPRI;
1388 		THREAD_CHANGE_PRI(t, ts_kmdpris[0]);
1389 		ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
1390 		t->t_trapret = 1;		/* so ts_trapret will run */
1391 		aston(t);
1392 	}
1393 
1394 	/*
1395 	 * This thread may be placed on wait queue by CPU Caps. In this case we
1396 	 * do not need to do anything until it is removed from the wait queue.
1397 	 * Do not enforce CPU caps on threads running at a kernel priority
1398 	 */
1399 	if (CPUCAPS_ON()) {
1400 		(void) cpucaps_charge(t, &tspp->ts_caps,
1401 		    CPUCAPS_CHARGE_ENFORCE);
1402 		if (!(tspp->ts_flags & TSKPRI) && CPUCAPS_ENFORCE(t))
1403 			return;
1404 	}
1405 
1406 	/*
1407 	 * If thread got preempted in the user-land then we know
1408 	 * it isn't holding any locks.  Mark it as swappable.
1409 	 */
1410 	ASSERT(t->t_schedflag & TS_DONT_SWAP);
1411 	if (lwp != NULL && lwp->lwp_state == LWP_USER)
1412 		t->t_schedflag &= ~TS_DONT_SWAP;
1413 
1414 	/*
1415 	 * Check to see if we're doing "preemption control" here.  If
1416 	 * we are, and if the user has requested that this thread not
1417 	 * be preempted, and if preemptions haven't been put off for
1418 	 * too long, let the preemption happen here but try to make
1419 	 * sure the thread is rescheduled as soon as possible.  We do
1420 	 * this by putting it on the front of the highest priority run
1421 	 * queue in the TS class.  If the preemption has been put off
1422 	 * for too long, clear the "nopreempt" bit and let the thread
1423 	 * be preempted.
1424 	 */
1425 	if (t->t_schedctl && schedctl_get_nopreempt(t)) {
1426 		if (tspp->ts_timeleft > -SC_MAX_TICKS) {
1427 			DTRACE_SCHED1(schedctl__nopreempt, kthread_t *, t);
1428 			if (!(tspp->ts_flags & TSKPRI)) {
1429 				/*
1430 				 * If not already remembered, remember current
1431 				 * priority for restoration in ts_yield().
1432 				 */
1433 				if (!(tspp->ts_flags & TSRESTORE)) {
1434 					tspp->ts_scpri = t->t_pri;
1435 					tspp->ts_flags |= TSRESTORE;
1436 				}
1437 				THREAD_CHANGE_PRI(t, ts_maxumdpri);
1438 				t->t_schedflag |= TS_DONT_SWAP;
1439 			}
1440 			schedctl_set_yield(t, 1);
1441 			setfrontdq(t);
1442 			goto done;
1443 		} else {
1444 			if (tspp->ts_flags & TSRESTORE) {
1445 				THREAD_CHANGE_PRI(t, tspp->ts_scpri);
1446 				tspp->ts_flags &= ~TSRESTORE;
1447 			}
1448 			schedctl_set_nopreempt(t, 0);
1449 			DTRACE_SCHED1(schedctl__preempt, kthread_t *, t);
1450 			TNF_PROBE_2(schedctl_preempt, "schedctl TS ts_preempt",
1451 			    /* CSTYLED */, tnf_pid, pid, ttoproc(t)->p_pid,
1452 			    tnf_lwpid, lwpid, t->t_tid);
1453 			/*
1454 			 * Fall through and be preempted below.
1455 			 */
1456 		}
1457 	}
1458 
1459 	if ((tspp->ts_flags & (TSBACKQ|TSKPRI)) == TSBACKQ) {
1460 		tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
1461 		tspp->ts_dispwait = 0;
1462 		tspp->ts_flags &= ~TSBACKQ;
1463 		setbackdq(t);
1464 	} else if ((tspp->ts_flags & (TSBACKQ|TSKPRI)) == (TSBACKQ|TSKPRI)) {
1465 		tspp->ts_flags &= ~TSBACKQ;
1466 		setbackdq(t);
1467 	} else {
1468 		setfrontdq(t);
1469 	}
1470 
1471 done:
1472 	TRACE_2(TR_FAC_DISP, TR_PREEMPT,
1473 	    "preempt:tid %p old pri %d", t, oldpri);
1474 }
1475 
1476 static void
ts_setrun(kthread_t * t)1477 ts_setrun(kthread_t *t)
1478 {
1479 	tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
1480 
1481 	ASSERT(THREAD_LOCK_HELD(t));	/* t should be in transition */
1482 
1483 	if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
1484 		tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
1485 		TS_NEWUMDPRI(tspp);
1486 		tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
1487 		tspp->ts_dispwait = 0;
1488 		if ((tspp->ts_flags & TSKPRI) == 0) {
1489 			THREAD_CHANGE_PRI(t,
1490 			    ts_dptbl[tspp->ts_umdpri].ts_globpri);
1491 			ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
1492 		}
1493 	}
1494 
1495 	tspp->ts_flags &= ~TSBACKQ;
1496 
1497 	if (tspp->ts_flags & TSIA) {
1498 		if (tspp->ts_flags & TSIASET)
1499 			setfrontdq(t);
1500 		else
1501 			setbackdq(t);
1502 	} else {
1503 		if (t->t_disp_time != ddi_get_lbolt())
1504 			setbackdq(t);
1505 		else
1506 			setfrontdq(t);
1507 	}
1508 }
1509 
1510 
1511 /*
1512  * Prepare thread for sleep. We reset the thread priority so it will
1513  * run at the kernel priority level when it wakes up.
1514  */
1515 static void
ts_sleep(kthread_t * t)1516 ts_sleep(kthread_t *t)
1517 {
1518 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
1519 	int		flags;
1520 	pri_t		old_pri = t->t_pri;
1521 
1522 	ASSERT(t == curthread);
1523 	ASSERT(THREAD_LOCK_HELD(t));
1524 
1525 	/*
1526 	 * Account for time spent on CPU before going to sleep.
1527 	 */
1528 	(void) CPUCAPS_CHARGE(t, &tspp->ts_caps, CPUCAPS_CHARGE_ENFORCE);
1529 
1530 	flags = tspp->ts_flags;
1531 	if (t->t_kpri_req) {
1532 		tspp->ts_flags = flags | TSKPRI;
1533 		THREAD_CHANGE_PRI(t, ts_kmdpris[0]);
1534 		ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
1535 		t->t_trapret = 1;		/* so ts_trapret will run */
1536 		aston(t);
1537 	} else if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
1538 		/*
1539 		 * If thread has blocked in the kernel (as opposed to
1540 		 * being merely preempted), recompute the user mode priority.
1541 		 */
1542 		tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
1543 		TS_NEWUMDPRI(tspp);
1544 		tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
1545 		tspp->ts_dispwait = 0;
1546 
1547 		THREAD_CHANGE_PRI(curthread,
1548 		    ts_dptbl[tspp->ts_umdpri].ts_globpri);
1549 		ASSERT(curthread->t_pri >= 0 &&
1550 		    curthread->t_pri <= ts_maxglobpri);
1551 		tspp->ts_flags = flags & ~TSKPRI;
1552 
1553 		if (DISP_MUST_SURRENDER(curthread))
1554 			cpu_surrender(curthread);
1555 	} else if (flags & TSKPRI) {
1556 		THREAD_CHANGE_PRI(curthread,
1557 		    ts_dptbl[tspp->ts_umdpri].ts_globpri);
1558 		ASSERT(curthread->t_pri >= 0 &&
1559 		    curthread->t_pri <= ts_maxglobpri);
1560 		tspp->ts_flags = flags & ~TSKPRI;
1561 
1562 		if (DISP_MUST_SURRENDER(curthread))
1563 			cpu_surrender(curthread);
1564 	}
1565 	t->t_stime = ddi_get_lbolt();		/* time stamp for the swapper */
1566 	TRACE_2(TR_FAC_DISP, TR_SLEEP,
1567 	    "sleep:tid %p old pri %d", t, old_pri);
1568 }
1569 
1570 
1571 /*
1572  * Return Values:
1573  *
1574  *	-1 if the thread is loaded or is not eligible to be swapped in.
1575  *
1576  *	effective priority of the specified thread based on swapout time
1577  *		and size of process (epri >= 0 , epri <= SHRT_MAX).
1578  */
1579 /* ARGSUSED */
1580 static pri_t
ts_swapin(kthread_t * t,int flags)1581 ts_swapin(kthread_t *t, int flags)
1582 {
1583 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
1584 	long		epri = -1;
1585 	proc_t		*pp = ttoproc(t);
1586 
1587 	ASSERT(THREAD_LOCK_HELD(t));
1588 
1589 	/*
1590 	 * We know that pri_t is a short.
1591 	 * Be sure not to overrun its range.
1592 	 */
1593 	if (t->t_state == TS_RUN && (t->t_schedflag & TS_LOAD) == 0) {
1594 		time_t swapout_time;
1595 
1596 		swapout_time = (ddi_get_lbolt() - t->t_stime) / hz;
1597 		if (INHERITED(t) || (tspp->ts_flags & (TSKPRI | TSIASET)))
1598 			epri = (long)DISP_PRIO(t) + swapout_time;
1599 		else {
1600 			/*
1601 			 * Threads which have been out for a long time,
1602 			 * have high user mode priority and are associated
1603 			 * with a small address space are more deserving
1604 			 */
1605 			epri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
1606 			ASSERT(epri >= 0 && epri <= ts_maxumdpri);
1607 			epri += swapout_time - pp->p_swrss / nz(maxpgio)/2;
1608 		}
1609 		/*
1610 		 * Scale epri so SHRT_MAX/2 represents zero priority.
1611 		 */
1612 		epri += SHRT_MAX/2;
1613 		if (epri < 0)
1614 			epri = 0;
1615 		else if (epri > SHRT_MAX)
1616 			epri = SHRT_MAX;
1617 	}
1618 	return ((pri_t)epri);
1619 }
1620 
1621 /*
1622  * Return Values
1623  *	-1 if the thread isn't loaded or is not eligible to be swapped out.
1624  *
1625  *	effective priority of the specified thread based on if the swapper
1626  *		is in softswap or hardswap mode.
1627  *
1628  *		Softswap:  Return a low effective priority for threads
1629  *			   sleeping for more than maxslp secs.
1630  *
1631  *		Hardswap:  Return an effective priority such that threads
1632  *			   which have been in memory for a while and are
1633  *			   associated with a small address space are swapped
1634  *			   in before others.
1635  *
1636  *		(epri >= 0 , epri <= SHRT_MAX).
1637  */
1638 time_t	ts_minrun = 2;		/* XXX - t_pri becomes 59 within 2 secs */
1639 time_t	ts_minslp = 2;		/* min time on sleep queue for hardswap */
1640 
1641 static pri_t
ts_swapout(kthread_t * t,int flags)1642 ts_swapout(kthread_t *t, int flags)
1643 {
1644 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
1645 	long		epri = -1;
1646 	proc_t		*pp = ttoproc(t);
1647 	time_t		swapin_time;
1648 
1649 	ASSERT(THREAD_LOCK_HELD(t));
1650 
1651 	if (INHERITED(t) || (tspp->ts_flags & (TSKPRI | TSIASET)) ||
1652 	    (t->t_proc_flag & TP_LWPEXIT) ||
1653 	    (t->t_state & (TS_ZOMB | TS_FREE | TS_STOPPED |
1654 	    TS_ONPROC | TS_WAIT)) ||
1655 	    !(t->t_schedflag & TS_LOAD) || !SWAP_OK(t))
1656 		return (-1);
1657 
1658 	ASSERT(t->t_state & (TS_SLEEP | TS_RUN));
1659 
1660 	/*
1661 	 * We know that pri_t is a short.
1662 	 * Be sure not to overrun its range.
1663 	 */
1664 	swapin_time = (ddi_get_lbolt() - t->t_stime) / hz;
1665 	if (flags == SOFTSWAP) {
1666 		if (t->t_state == TS_SLEEP && swapin_time > maxslp) {
1667 			epri = 0;
1668 		} else {
1669 			return ((pri_t)epri);
1670 		}
1671 	} else {
1672 		pri_t pri;
1673 
1674 		if ((t->t_state == TS_SLEEP && swapin_time > ts_minslp) ||
1675 		    (t->t_state == TS_RUN && swapin_time > ts_minrun)) {
1676 			pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
1677 			ASSERT(pri >= 0 && pri <= ts_maxumdpri);
1678 			epri = swapin_time -
1679 			    (rm_asrss(pp->p_as) / nz(maxpgio)/2) - (long)pri;
1680 		} else {
1681 			return ((pri_t)epri);
1682 		}
1683 	}
1684 
1685 	/*
1686 	 * Scale epri so SHRT_MAX/2 represents zero priority.
1687 	 */
1688 	epri += SHRT_MAX/2;
1689 	if (epri < 0)
1690 		epri = 0;
1691 	else if (epri > SHRT_MAX)
1692 		epri = SHRT_MAX;
1693 
1694 	return ((pri_t)epri);
1695 }
1696 
1697 /*
1698  * Check for time slice expiration.  If time slice has expired
1699  * move thread to priority specified in tsdptbl for time slice expiration
1700  * and set runrun to cause preemption.
1701  */
1702 static void
ts_tick(kthread_t * t)1703 ts_tick(kthread_t *t)
1704 {
1705 	tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
1706 	klwp_t *lwp;
1707 	boolean_t call_cpu_surrender = B_FALSE;
1708 	pri_t	oldpri = t->t_pri;
1709 
1710 	ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
1711 
1712 	thread_lock(t);
1713 
1714 	/*
1715 	 * Keep track of thread's project CPU usage.  Note that projects
1716 	 * get charged even when threads are running in the kernel.
1717 	 */
1718 	if (CPUCAPS_ON()) {
1719 		call_cpu_surrender = cpucaps_charge(t, &tspp->ts_caps,
1720 		    CPUCAPS_CHARGE_ENFORCE) && !(tspp->ts_flags & TSKPRI);
1721 	}
1722 
1723 	if ((tspp->ts_flags & TSKPRI) == 0) {
1724 		if (--tspp->ts_timeleft <= 0) {
1725 			pri_t	new_pri;
1726 
1727 			/*
1728 			 * If we're doing preemption control and trying to
1729 			 * avoid preempting this thread, just note that
1730 			 * the thread should yield soon and let it keep
1731 			 * running (unless it's been a while).
1732 			 */
1733 			if (t->t_schedctl && schedctl_get_nopreempt(t)) {
1734 				if (tspp->ts_timeleft > -SC_MAX_TICKS) {
1735 					DTRACE_SCHED1(schedctl__nopreempt,
1736 					    kthread_t *, t);
1737 					schedctl_set_yield(t, 1);
1738 					thread_unlock_nopreempt(t);
1739 					return;
1740 				}
1741 
1742 				TNF_PROBE_2(schedctl_failsafe,
1743 				    "schedctl TS ts_tick", /* CSTYLED */,
1744 				    tnf_pid, pid, ttoproc(t)->p_pid,
1745 				    tnf_lwpid, lwpid, t->t_tid);
1746 			}
1747 			tspp->ts_flags &= ~TSRESTORE;
1748 			tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp;
1749 			TS_NEWUMDPRI(tspp);
1750 			tspp->ts_dispwait = 0;
1751 			new_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
1752 			ASSERT(new_pri >= 0 && new_pri <= ts_maxglobpri);
1753 			/*
1754 			 * When the priority of a thread is changed,
1755 			 * it may be necessary to adjust its position
1756 			 * on a sleep queue or dispatch queue.
1757 			 * The function thread_change_pri accomplishes
1758 			 * this.
1759 			 */
1760 			if (thread_change_pri(t, new_pri, 0)) {
1761 				if ((t->t_schedflag & TS_LOAD) &&
1762 				    (lwp = t->t_lwp) &&
1763 				    lwp->lwp_state == LWP_USER)
1764 					t->t_schedflag &= ~TS_DONT_SWAP;
1765 				tspp->ts_timeleft =
1766 				    ts_dptbl[tspp->ts_cpupri].ts_quantum;
1767 			} else {
1768 				call_cpu_surrender = B_TRUE;
1769 			}
1770 			TRACE_2(TR_FAC_DISP, TR_TICK,
1771 			    "tick:tid %p old pri %d", t, oldpri);
1772 		} else if (t->t_state == TS_ONPROC &&
1773 		    t->t_pri < t->t_disp_queue->disp_maxrunpri) {
1774 			call_cpu_surrender = B_TRUE;
1775 		}
1776 	}
1777 
1778 	if (call_cpu_surrender) {
1779 		tspp->ts_flags |= TSBACKQ;
1780 		cpu_surrender(t);
1781 	}
1782 
1783 	thread_unlock_nopreempt(t);	/* clock thread can't be preempted */
1784 }
1785 
1786 
1787 /*
1788  * If thread is currently at a kernel mode priority (has slept)
1789  * we assign it the appropriate user mode priority and time quantum
1790  * here.  If we are lowering the thread's priority below that of
1791  * other runnable threads we will normally set runrun via cpu_surrender() to
1792  * cause preemption.
1793  */
1794 static void
ts_trapret(kthread_t * t)1795 ts_trapret(kthread_t *t)
1796 {
1797 	tsproc_t	*tspp = (tsproc_t *)t->t_cldata;
1798 	cpu_t		*cp = CPU;
1799 	pri_t		old_pri = curthread->t_pri;
1800 
1801 	ASSERT(THREAD_LOCK_HELD(t));
1802 	ASSERT(t == curthread);
1803 	ASSERT(cp->cpu_dispthread == t);
1804 	ASSERT(t->t_state == TS_ONPROC);
1805 
1806 	t->t_kpri_req = 0;
1807 	if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
1808 		tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
1809 		TS_NEWUMDPRI(tspp);
1810 		tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
1811 		tspp->ts_dispwait = 0;
1812 
1813 		/*
1814 		 * If thread has blocked in the kernel (as opposed to
1815 		 * being merely preempted), recompute the user mode priority.
1816 		 */
1817 		THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
1818 		cp->cpu_dispatch_pri = DISP_PRIO(t);
1819 		ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
1820 		tspp->ts_flags &= ~TSKPRI;
1821 
1822 		if (DISP_MUST_SURRENDER(t))
1823 			cpu_surrender(t);
1824 	} else if (tspp->ts_flags & TSKPRI) {
1825 		/*
1826 		 * If thread has blocked in the kernel (as opposed to
1827 		 * being merely preempted), recompute the user mode priority.
1828 		 */
1829 		THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
1830 		cp->cpu_dispatch_pri = DISP_PRIO(t);
1831 		ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
1832 		tspp->ts_flags &= ~TSKPRI;
1833 
1834 		if (DISP_MUST_SURRENDER(t))
1835 			cpu_surrender(t);
1836 	}
1837 
1838 	/*
1839 	 * Swapout lwp if the swapper is waiting for this thread to
1840 	 * reach a safe point.
1841 	 */
1842 	if ((t->t_schedflag & TS_SWAPENQ) && !(tspp->ts_flags & TSIASET)) {
1843 		thread_unlock(t);
1844 		swapout_lwp(ttolwp(t));
1845 		thread_lock(t);
1846 	}
1847 
1848 	TRACE_2(TR_FAC_DISP, TR_TRAPRET,
1849 	    "trapret:tid %p old pri %d", t, old_pri);
1850 }
1851 
1852 
1853 /*
1854  * Update the ts_dispwait values of all time sharing threads that
1855  * are currently runnable at a user mode priority and bump the priority
1856  * if ts_dispwait exceeds ts_maxwait.  Called once per second via
1857  * timeout which we reset here.
1858  *
1859  * There are several lists of time sharing threads broken up by a hash on
1860  * the thread pointer.  Each list has its own lock.  This avoids blocking
1861  * all ts_enterclass, ts_fork, and ts_exitclass operations while ts_update
1862  * runs.  ts_update traverses each list in turn.
1863  *
1864  * If multiple threads have their priorities updated to the same value,
1865  * the system implicitly favors the one that is updated first (since it
1866  * winds up first on the run queue).  To avoid this unfairness, the
1867  * traversal of threads starts at the list indicated by a marker.  When
1868  * threads in more than one list have their priorities updated, the marker
1869  * is moved.  This changes the order the threads will be placed on the run
1870  * queue the next time ts_update is called and preserves fairness over the
1871  * long run.  The marker doesn't need to be protected by a lock since it's
1872  * only accessed by ts_update, which is inherently single-threaded (only
1873  * one instance can be running at a time).
1874  */
1875 static void
ts_update(void * arg)1876 ts_update(void *arg)
1877 {
1878 	int		i;
1879 	int		new_marker = -1;
1880 	static int	ts_update_marker;
1881 
1882 	/*
1883 	 * Start with the ts_update_marker list, then do the rest.
1884 	 */
1885 	i = ts_update_marker;
1886 	do {
1887 		/*
1888 		 * If this is the first list after the current marker to
1889 		 * have threads with priorities updated, advance the marker
1890 		 * to this list for the next time ts_update runs.
1891 		 */
1892 		if (ts_update_list(i) && new_marker == -1 &&
1893 		    i != ts_update_marker) {
1894 			new_marker = i;
1895 		}
1896 	} while ((i = TS_LIST_NEXT(i)) != ts_update_marker);
1897 
1898 	/* advance marker for next ts_update call */
1899 	if (new_marker != -1)
1900 		ts_update_marker = new_marker;
1901 
1902 	(void) timeout(ts_update, arg, hz);
1903 }
1904 
1905 /*
1906  * Updates priority for a list of threads.  Returns 1 if the priority of
1907  * one of the threads was actually updated, 0 if none were for various
1908  * reasons (thread is no longer in the TS or IA class, isn't runnable,
1909  * hasn't waited long enough, has the preemption control no-preempt bit
1910  * set, etc.)
1911  */
1912 static int
ts_update_list(int i)1913 ts_update_list(int i)
1914 {
1915 	tsproc_t *tspp;
1916 	kthread_t *tx;
1917 	int updated = 0;
1918 
1919 	mutex_enter(&ts_list_lock[i]);
1920 	for (tspp = ts_plisthead[i].ts_next; tspp != &ts_plisthead[i];
1921 	    tspp = tspp->ts_next) {
1922 		tx = tspp->ts_tp;
1923 		/*
1924 		 * Lock the thread and verify state.
1925 		 */
1926 		thread_lock(tx);
1927 		/*
1928 		 * Skip the thread if it is no longer in the TS (or IA) class.
1929 		 */
1930 		if (tx->t_clfuncs != &ts_classfuncs.thread &&
1931 		    tx->t_clfuncs != &ia_classfuncs.thread)
1932 			goto next;
1933 		tspp->ts_dispwait++;
1934 		if ((tspp->ts_flags & TSKPRI) != 0)
1935 			goto next;
1936 		if (tspp->ts_dispwait <= ts_dptbl[tspp->ts_umdpri].ts_maxwait)
1937 			goto next;
1938 		if (tx->t_schedctl && schedctl_get_nopreempt(tx))
1939 			goto next;
1940 		if (tx->t_state != TS_RUN && tx->t_state != TS_WAIT &&
1941 		    (tx->t_state != TS_SLEEP || !ts_sleep_promote)) {
1942 			/* make next syscall/trap do CL_TRAPRET */
1943 			tx->t_trapret = 1;
1944 			aston(tx);
1945 			goto next;
1946 		}
1947 		tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_lwait;
1948 		TS_NEWUMDPRI(tspp);
1949 		tspp->ts_dispwait = 0;
1950 		updated = 1;
1951 
1952 		/*
1953 		 * Only dequeue it if needs to move; otherwise it should
1954 		 * just round-robin here.
1955 		 */
1956 		if (tx->t_pri != ts_dptbl[tspp->ts_umdpri].ts_globpri) {
1957 			pri_t oldpri = tx->t_pri;
1958 			ts_change_priority(tx, tspp);
1959 			TRACE_2(TR_FAC_DISP, TR_UPDATE,
1960 			    "update:tid %p old pri %d", tx, oldpri);
1961 		}
1962 next:
1963 		thread_unlock(tx);
1964 	}
1965 	mutex_exit(&ts_list_lock[i]);
1966 
1967 	return (updated);
1968 }
1969 
1970 /*
1971  * Processes waking up go to the back of their queue.  We don't
1972  * need to assign a time quantum here because thread is still
1973  * at a kernel mode priority and the time slicing is not done
1974  * for threads running in the kernel after sleeping.  The proper
1975  * time quantum will be assigned by ts_trapret before the thread
1976  * returns to user mode.
1977  */
1978 static void
ts_wakeup(kthread_t * t)1979 ts_wakeup(kthread_t *t)
1980 {
1981 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
1982 
1983 	ASSERT(THREAD_LOCK_HELD(t));
1984 
1985 	t->t_stime = ddi_get_lbolt();		/* time stamp for the swapper */
1986 
1987 	if (tspp->ts_flags & TSKPRI) {
1988 		tspp->ts_flags &= ~TSBACKQ;
1989 		if (tspp->ts_flags & TSIASET)
1990 			setfrontdq(t);
1991 		else
1992 			setbackdq(t);
1993 	} else if (t->t_kpri_req) {
1994 		/*
1995 		 * Give thread a priority boost if we were asked.
1996 		 */
1997 		tspp->ts_flags |= TSKPRI;
1998 		THREAD_CHANGE_PRI(t, ts_kmdpris[0]);
1999 		setbackdq(t);
2000 		t->t_trapret = 1;	/* so that ts_trapret will run */
2001 		aston(t);
2002 	} else {
2003 		if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
2004 			tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
2005 			TS_NEWUMDPRI(tspp);
2006 			tspp->ts_timeleft =
2007 			    ts_dptbl[tspp->ts_cpupri].ts_quantum;
2008 			tspp->ts_dispwait = 0;
2009 			THREAD_CHANGE_PRI(t,
2010 			    ts_dptbl[tspp->ts_umdpri].ts_globpri);
2011 			ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
2012 		}
2013 
2014 		tspp->ts_flags &= ~TSBACKQ;
2015 
2016 		if (tspp->ts_flags & TSIA) {
2017 			if (tspp->ts_flags & TSIASET)
2018 				setfrontdq(t);
2019 			else
2020 				setbackdq(t);
2021 		} else {
2022 			if (t->t_disp_time != ddi_get_lbolt())
2023 				setbackdq(t);
2024 			else
2025 				setfrontdq(t);
2026 		}
2027 	}
2028 }
2029 
2030 
2031 /*
2032  * When a thread yields, put it on the back of the run queue.
2033  */
2034 static void
ts_yield(kthread_t * t)2035 ts_yield(kthread_t *t)
2036 {
2037 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
2038 
2039 	ASSERT(t == curthread);
2040 	ASSERT(THREAD_LOCK_HELD(t));
2041 
2042 	/*
2043 	 * Collect CPU usage spent before yielding
2044 	 */
2045 	(void) CPUCAPS_CHARGE(t, &tspp->ts_caps, CPUCAPS_CHARGE_ENFORCE);
2046 
2047 	/*
2048 	 * Clear the preemption control "yield" bit since the user is
2049 	 * doing a yield.
2050 	 */
2051 	if (t->t_schedctl)
2052 		schedctl_set_yield(t, 0);
2053 	/*
2054 	 * If ts_preempt() artifically increased the thread's priority
2055 	 * to avoid preemption, restore the original priority now.
2056 	 */
2057 	if (tspp->ts_flags & TSRESTORE) {
2058 		THREAD_CHANGE_PRI(t, tspp->ts_scpri);
2059 		tspp->ts_flags &= ~TSRESTORE;
2060 	}
2061 	if (tspp->ts_timeleft <= 0) {
2062 		/*
2063 		 * Time slice was artificially extended to avoid
2064 		 * preemption, so pretend we're preempting it now.
2065 		 */
2066 		DTRACE_SCHED1(schedctl__yield, int, -tspp->ts_timeleft);
2067 		tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp;
2068 		TS_NEWUMDPRI(tspp);
2069 		tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
2070 		tspp->ts_dispwait = 0;
2071 		THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
2072 		ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
2073 	}
2074 	tspp->ts_flags &= ~TSBACKQ;
2075 	setbackdq(t);
2076 }
2077 
2078 
2079 /*
2080  * Increment the nice value of the specified thread by incr and
2081  * return the new value in *retvalp.
2082  */
2083 static int
ts_donice(kthread_t * t,cred_t * cr,int incr,int * retvalp)2084 ts_donice(kthread_t *t, cred_t *cr, int incr, int *retvalp)
2085 {
2086 	int		newnice;
2087 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
2088 	tsparms_t	tsparms;
2089 
2090 	ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
2091 
2092 	/* If there's no change to priority, just return current setting */
2093 	if (incr == 0) {
2094 		if (retvalp) {
2095 			*retvalp = tspp->ts_nice - NZERO;
2096 		}
2097 		return (0);
2098 	}
2099 
2100 	if ((incr < 0 || incr > 2 * NZERO) &&
2101 	    secpolicy_raisepriority(cr) != 0)
2102 		return (EPERM);
2103 
2104 	/*
2105 	 * Specifying a nice increment greater than the upper limit of
2106 	 * 2 * NZERO - 1 will result in the thread's nice value being
2107 	 * set to the upper limit.  We check for this before computing
2108 	 * the new value because otherwise we could get overflow
2109 	 * if a privileged process specified some ridiculous increment.
2110 	 */
2111 	if (incr > 2 * NZERO - 1)
2112 		incr = 2 * NZERO - 1;
2113 
2114 	newnice = tspp->ts_nice + incr;
2115 	if (newnice >= 2 * NZERO)
2116 		newnice = 2 * NZERO - 1;
2117 	else if (newnice < 0)
2118 		newnice = 0;
2119 
2120 	tsparms.ts_uprilim = tsparms.ts_upri =
2121 	    -((newnice - NZERO) * ts_maxupri) / NZERO;
2122 	/*
2123 	 * Reset the uprilim and upri values of the thread.
2124 	 * Call ts_parmsset even if thread is interactive since we're
2125 	 * not changing mode.
2126 	 */
2127 	(void) ts_parmsset(t, (void *)&tsparms, (id_t)0, (cred_t *)NULL);
2128 
2129 	/*
2130 	 * Although ts_parmsset already reset ts_nice it may
2131 	 * not have been set to precisely the value calculated above
2132 	 * because ts_parmsset determines the nice value from the
2133 	 * user priority and we may have truncated during the integer
2134 	 * conversion from nice value to user priority and back.
2135 	 * We reset ts_nice to the value we calculated above.
2136 	 */
2137 	tspp->ts_nice = (char)newnice;
2138 
2139 	if (retvalp)
2140 		*retvalp = newnice - NZERO;
2141 	return (0);
2142 }
2143 
2144 /*
2145  * Increment the priority of the specified thread by incr and
2146  * return the new value in *retvalp.
2147  */
2148 static int
ts_doprio(kthread_t * t,cred_t * cr,int incr,int * retvalp)2149 ts_doprio(kthread_t *t, cred_t *cr, int incr, int *retvalp)
2150 {
2151 	int		newpri;
2152 	tsproc_t	*tspp = (tsproc_t *)(t->t_cldata);
2153 	tsparms_t	tsparms;
2154 
2155 	ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
2156 
2157 	/* If there's no change to the priority, just return current setting */
2158 	if (incr == 0) {
2159 		*retvalp = tspp->ts_upri;
2160 		return (0);
2161 	}
2162 
2163 	newpri = tspp->ts_upri + incr;
2164 	if (newpri > ts_maxupri || newpri < -ts_maxupri)
2165 		return (EINVAL);
2166 
2167 	*retvalp = newpri;
2168 	tsparms.ts_uprilim = tsparms.ts_upri = newpri;
2169 	/*
2170 	 * Reset the uprilim and upri values of the thread.
2171 	 * Call ts_parmsset even if thread is interactive since we're
2172 	 * not changing mode.
2173 	 */
2174 	return (ts_parmsset(t, &tsparms, 0, cr));
2175 }
2176 
2177 /*
2178  * ia_set_process_group marks foreground processes as interactive
2179  * and background processes as non-interactive iff the session
2180  * leader is interactive.  This routine is called from two places:
2181  *	strioctl:SPGRP when a new process group gets
2182  * 		control of the tty.
2183  *	ia_parmsset-when the process in question is a session leader.
2184  * ia_set_process_group assumes that pidlock is held by the caller,
2185  * either strioctl or priocntlsys.  If the caller is priocntlsys
2186  * (via ia_parmsset) then the p_lock of the session leader is held
2187  * and the code needs to be careful about acquiring other p_locks.
2188  */
2189 static void
ia_set_process_group(pid_t sid,pid_t bg_pgid,pid_t fg_pgid)2190 ia_set_process_group(pid_t sid, pid_t bg_pgid, pid_t fg_pgid)
2191 {
2192 	proc_t 		*leader, *fg, *bg;
2193 	tsproc_t	*tspp;
2194 	kthread_t	*tx;
2195 	int		plocked = 0;
2196 
2197 	ASSERT(MUTEX_HELD(&pidlock));
2198 
2199 	/*
2200 	 * see if the session leader is interactive AND
2201 	 * if it is currently "on" AND controlling a tty
2202 	 * iff it is then make the processes in the foreground
2203 	 * group interactive and the processes in the background
2204 	 * group non-interactive.
2205 	 */
2206 	if ((leader = (proc_t *)prfind(sid)) == NULL) {
2207 		return;
2208 	}
2209 	if (leader->p_stat == SIDL) {
2210 		return;
2211 	}
2212 	if ((tx = proctot(leader)) == NULL) {
2213 		return;
2214 	}
2215 	/*
2216 	 * XXX do all the threads in the leader
2217 	 */
2218 	if (tx->t_cid != ia_cid) {
2219 		return;
2220 	}
2221 	tspp = tx->t_cldata;
2222 	/*
2223 	 * session leaders that are not interactive need not have
2224 	 * any processing done for them.  They are typically shells
2225 	 * that do not have focus and are changing the process group
2226 	 * attatched to the tty, e.g. a process that is exiting
2227 	 */
2228 	mutex_enter(&leader->p_sessp->s_lock);
2229 	if (!(tspp->ts_flags & TSIASET) ||
2230 	    (leader->p_sessp->s_vp == NULL) ||
2231 	    (leader->p_sessp->s_vp->v_stream == NULL)) {
2232 		mutex_exit(&leader->p_sessp->s_lock);
2233 		return;
2234 	}
2235 	mutex_exit(&leader->p_sessp->s_lock);
2236 
2237 	/*
2238 	 * If we're already holding the leader's p_lock, we should use
2239 	 * mutex_tryenter instead of mutex_enter to avoid deadlocks from
2240 	 * lock ordering violations.
2241 	 */
2242 	if (mutex_owned(&leader->p_lock))
2243 		plocked = 1;
2244 
2245 	if (fg_pgid == 0)
2246 		goto skip;
2247 	/*
2248 	 * now look for all processes in the foreground group and
2249 	 * make them interactive
2250 	 */
2251 	for (fg = (proc_t *)pgfind(fg_pgid); fg != NULL; fg = fg->p_pglink) {
2252 		/*
2253 		 * if the process is SIDL it's begin forked, ignore it
2254 		 */
2255 		if (fg->p_stat == SIDL) {
2256 			continue;
2257 		}
2258 		/*
2259 		 * sesssion leaders must be turned on/off explicitly
2260 		 * not implicitly as happens to other members of
2261 		 * the process group.
2262 		 */
2263 		if (fg->p_pid  == fg->p_sessp->s_sid) {
2264 			continue;
2265 		}
2266 
2267 		TRACE_1(TR_FAC_IA, TR_GROUP_ON,
2268 		    "group on:proc %p", fg);
2269 
2270 		if (plocked) {
2271 			if (mutex_tryenter(&fg->p_lock) == 0)
2272 				continue;
2273 		} else {
2274 			mutex_enter(&fg->p_lock);
2275 		}
2276 
2277 		if ((tx = proctot(fg)) == NULL) {
2278 			mutex_exit(&fg->p_lock);
2279 			continue;
2280 		}
2281 		do {
2282 			thread_lock(tx);
2283 			/*
2284 			 * if this thread is not interactive continue
2285 			 */
2286 			if (tx->t_cid != ia_cid) {
2287 				thread_unlock(tx);
2288 				continue;
2289 			}
2290 			tspp = tx->t_cldata;
2291 			tspp->ts_flags |= TSIASET;
2292 			tspp->ts_boost = ia_boost;
2293 			TS_NEWUMDPRI(tspp);
2294 			if ((tspp->ts_flags & TSKPRI) != 0) {
2295 				thread_unlock(tx);
2296 				continue;
2297 			}
2298 			tspp->ts_dispwait = 0;
2299 			ts_change_priority(tx, tspp);
2300 			thread_unlock(tx);
2301 		} while ((tx = tx->t_forw) != fg->p_tlist);
2302 		mutex_exit(&fg->p_lock);
2303 	}
2304 skip:
2305 	if (bg_pgid == 0)
2306 		return;
2307 	for (bg = (proc_t *)pgfind(bg_pgid); bg != NULL; bg = bg->p_pglink) {
2308 		if (bg->p_stat == SIDL) {
2309 			continue;
2310 		}
2311 		/*
2312 		 * sesssion leaders must be turned off explicitly
2313 		 * not implicitly as happens to other members of
2314 		 * the process group.
2315 		 */
2316 		if (bg->p_pid == bg->p_sessp->s_sid) {
2317 			continue;
2318 		}
2319 
2320 		TRACE_1(TR_FAC_IA, TR_GROUP_OFF,
2321 		    "group off:proc %p", bg);
2322 
2323 		if (plocked) {
2324 			if (mutex_tryenter(&bg->p_lock) == 0)
2325 				continue;
2326 		} else {
2327 			mutex_enter(&bg->p_lock);
2328 		}
2329 
2330 		if ((tx = proctot(bg)) == NULL) {
2331 			mutex_exit(&bg->p_lock);
2332 			continue;
2333 		}
2334 		do {
2335 			thread_lock(tx);
2336 			/*
2337 			 * if this thread is not interactive continue
2338 			 */
2339 			if (tx->t_cid != ia_cid) {
2340 				thread_unlock(tx);
2341 				continue;
2342 			}
2343 			tspp = tx->t_cldata;
2344 			tspp->ts_flags &= ~TSIASET;
2345 			tspp->ts_boost = -ia_boost;
2346 			TS_NEWUMDPRI(tspp);
2347 			if ((tspp->ts_flags & TSKPRI) != 0) {
2348 				thread_unlock(tx);
2349 				continue;
2350 			}
2351 
2352 			tspp->ts_dispwait = 0;
2353 			ts_change_priority(tx, tspp);
2354 			thread_unlock(tx);
2355 		} while ((tx = tx->t_forw) != bg->p_tlist);
2356 		mutex_exit(&bg->p_lock);
2357 	}
2358 }
2359 
2360 
2361 static void
ts_change_priority(kthread_t * t,tsproc_t * tspp)2362 ts_change_priority(kthread_t *t, tsproc_t *tspp)
2363 {
2364 	pri_t	new_pri;
2365 
2366 	ASSERT(THREAD_LOCK_HELD(t));
2367 	new_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
2368 	ASSERT(new_pri >= 0 && new_pri <= ts_maxglobpri);
2369 	tspp->ts_flags &= ~TSRESTORE;
2370 	t->t_cpri = tspp->ts_upri;
2371 	if (t == curthread || t->t_state == TS_ONPROC) {
2372 		/* curthread is always onproc */
2373 		cpu_t	*cp = t->t_disp_queue->disp_cpu;
2374 		THREAD_CHANGE_PRI(t, new_pri);
2375 		if (t == cp->cpu_dispthread)
2376 			cp->cpu_dispatch_pri = DISP_PRIO(t);
2377 		if (DISP_MUST_SURRENDER(t)) {
2378 			tspp->ts_flags |= TSBACKQ;
2379 			cpu_surrender(t);
2380 		} else {
2381 			tspp->ts_timeleft =
2382 			    ts_dptbl[tspp->ts_cpupri].ts_quantum;
2383 		}
2384 	} else {
2385 		int	frontq;
2386 
2387 		frontq = (tspp->ts_flags & TSIASET) != 0;
2388 		/*
2389 		 * When the priority of a thread is changed,
2390 		 * it may be necessary to adjust its position
2391 		 * on a sleep queue or dispatch queue.
2392 		 * The function thread_change_pri accomplishes
2393 		 * this.
2394 		 */
2395 		if (thread_change_pri(t, new_pri, frontq)) {
2396 			/*
2397 			 * The thread was on a run queue. Reset
2398 			 * its CPU timeleft from the quantum
2399 			 * associated with the new priority.
2400 			 */
2401 			tspp->ts_timeleft =
2402 			    ts_dptbl[tspp->ts_cpupri].ts_quantum;
2403 		} else {
2404 			tspp->ts_flags |= TSBACKQ;
2405 		}
2406 	}
2407 }
2408 
2409 static int
ts_alloc(void ** p,int flag)2410 ts_alloc(void **p, int flag)
2411 {
2412 	void *bufp;
2413 	bufp = kmem_alloc(sizeof (tsproc_t), flag);
2414 	if (bufp == NULL) {
2415 		return (ENOMEM);
2416 	} else {
2417 		*p = bufp;
2418 		return (0);
2419 	}
2420 }
2421 
2422 static void
ts_free(void * bufp)2423 ts_free(void *bufp)
2424 {
2425 	if (bufp)
2426 		kmem_free(bufp, sizeof (tsproc_t));
2427 }
2428