17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
59acbbeafSnn * Common Development and Distribution License (the "License").
69acbbeafSnn * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
219ac8606fSraf
227c478bd9Sstevel@tonic-gate /*
23d5493db7SPramod Batni * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
246a0b1217SPatrick Mooney * Copyright 2019 Joyent, Inc.
257c478bd9Sstevel@tonic-gate */
267c478bd9Sstevel@tonic-gate
277c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
286a0b1217SPatrick Mooney /* All Rights Reserved */
297c478bd9Sstevel@tonic-gate
307c478bd9Sstevel@tonic-gate #include <sys/types.h>
317c478bd9Sstevel@tonic-gate #include <sys/param.h>
327c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
337c478bd9Sstevel@tonic-gate #include <sys/cred.h>
347c478bd9Sstevel@tonic-gate #include <sys/proc.h>
357c478bd9Sstevel@tonic-gate #include <sys/session.h>
367c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
377c478bd9Sstevel@tonic-gate #include <sys/signal.h>
387c478bd9Sstevel@tonic-gate #include <sys/user.h>
397c478bd9Sstevel@tonic-gate #include <sys/priocntl.h>
407c478bd9Sstevel@tonic-gate #include <sys/class.h>
417c478bd9Sstevel@tonic-gate #include <sys/disp.h>
427c478bd9Sstevel@tonic-gate #include <sys/procset.h>
437c478bd9Sstevel@tonic-gate #include <sys/debug.h>
447c478bd9Sstevel@tonic-gate #include <sys/ts.h>
457c478bd9Sstevel@tonic-gate #include <sys/tspriocntl.h>
467c478bd9Sstevel@tonic-gate #include <sys/iapriocntl.h>
477c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
487c478bd9Sstevel@tonic-gate #include <sys/errno.h>
497c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
507c478bd9Sstevel@tonic-gate #include <sys/systm.h> /* for lbolt */
517c478bd9Sstevel@tonic-gate #include <sys/vtrace.h>
527c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h>
537c478bd9Sstevel@tonic-gate #include <sys/schedctl.h>
547c478bd9Sstevel@tonic-gate #include <sys/atomic.h>
557c478bd9Sstevel@tonic-gate #include <sys/policy.h>
567c478bd9Sstevel@tonic-gate #include <sys/sdt.h>
577c478bd9Sstevel@tonic-gate #include <sys/cpupart.h>
587c478bd9Sstevel@tonic-gate #include <vm/rm.h>
597c478bd9Sstevel@tonic-gate #include <vm/seg_kmem.h>
607c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
61c97ad5cdSakolb #include <sys/cpucaps.h>
627c478bd9Sstevel@tonic-gate
637c478bd9Sstevel@tonic-gate static pri_t ts_init(id_t, int, classfuncs_t **);
647c478bd9Sstevel@tonic-gate
657c478bd9Sstevel@tonic-gate static struct sclass csw = {
667c478bd9Sstevel@tonic-gate "TS",
677c478bd9Sstevel@tonic-gate ts_init,
687c478bd9Sstevel@tonic-gate 0
697c478bd9Sstevel@tonic-gate };
707c478bd9Sstevel@tonic-gate
717c478bd9Sstevel@tonic-gate static struct modlsched modlsched = {
727c478bd9Sstevel@tonic-gate &mod_schedops, "time sharing sched class", &csw
737c478bd9Sstevel@tonic-gate };
747c478bd9Sstevel@tonic-gate
757c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = {
767c478bd9Sstevel@tonic-gate MODREV_1, (void *)&modlsched, NULL
777c478bd9Sstevel@tonic-gate };
787c478bd9Sstevel@tonic-gate
797c478bd9Sstevel@tonic-gate int
_init()807c478bd9Sstevel@tonic-gate _init()
817c478bd9Sstevel@tonic-gate {
827c478bd9Sstevel@tonic-gate return (mod_install(&modlinkage));
837c478bd9Sstevel@tonic-gate }
847c478bd9Sstevel@tonic-gate
857c478bd9Sstevel@tonic-gate int
_fini()867c478bd9Sstevel@tonic-gate _fini()
877c478bd9Sstevel@tonic-gate {
887c478bd9Sstevel@tonic-gate return (EBUSY); /* don't remove TS for now */
897c478bd9Sstevel@tonic-gate }
907c478bd9Sstevel@tonic-gate
917c478bd9Sstevel@tonic-gate int
_info(struct modinfo * modinfop)927c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop)
937c478bd9Sstevel@tonic-gate {
947c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop));
957c478bd9Sstevel@tonic-gate }
967c478bd9Sstevel@tonic-gate
977c478bd9Sstevel@tonic-gate /*
987c478bd9Sstevel@tonic-gate * Class specific code for the time-sharing class
997c478bd9Sstevel@tonic-gate */
1007c478bd9Sstevel@tonic-gate
1017c478bd9Sstevel@tonic-gate
1027c478bd9Sstevel@tonic-gate /*
1037c478bd9Sstevel@tonic-gate * Extern declarations for variables defined in the ts master file
1047c478bd9Sstevel@tonic-gate */
1057c478bd9Sstevel@tonic-gate #define TSMAXUPRI 60
1067c478bd9Sstevel@tonic-gate
1077c478bd9Sstevel@tonic-gate pri_t ts_maxupri = TSMAXUPRI; /* max time-sharing user priority */
1087c478bd9Sstevel@tonic-gate pri_t ts_maxumdpri; /* maximum user mode ts priority */
1097c478bd9Sstevel@tonic-gate
1107c478bd9Sstevel@tonic-gate pri_t ia_maxupri = IAMAXUPRI; /* max interactive user priority */
1117c478bd9Sstevel@tonic-gate pri_t ia_boost = IA_BOOST; /* boost value for interactive */
1127c478bd9Sstevel@tonic-gate
1137c478bd9Sstevel@tonic-gate tsdpent_t *ts_dptbl; /* time-sharing disp parameter table */
1147c478bd9Sstevel@tonic-gate pri_t *ts_kmdpris; /* array of global pris used by ts procs when */
1157c478bd9Sstevel@tonic-gate /* sleeping or running in kernel after sleep */
1167c478bd9Sstevel@tonic-gate
1177c478bd9Sstevel@tonic-gate static id_t ia_cid;
1187c478bd9Sstevel@tonic-gate
1197c478bd9Sstevel@tonic-gate int ts_sleep_promote = 1;
1207c478bd9Sstevel@tonic-gate
1217c478bd9Sstevel@tonic-gate #define tsmedumdpri (ts_maxumdpri >> 1)
1227c478bd9Sstevel@tonic-gate
1237c478bd9Sstevel@tonic-gate #define TS_NEWUMDPRI(tspp) \
1247c478bd9Sstevel@tonic-gate { \
1257c478bd9Sstevel@tonic-gate pri_t pri; \
1267c478bd9Sstevel@tonic-gate pri = (tspp)->ts_cpupri + (tspp)->ts_upri + (tspp)->ts_boost; \
1277c478bd9Sstevel@tonic-gate if (pri > ts_maxumdpri) \
1287c478bd9Sstevel@tonic-gate (tspp)->ts_umdpri = ts_maxumdpri; \
1297c478bd9Sstevel@tonic-gate else if (pri < 0) \
1307c478bd9Sstevel@tonic-gate (tspp)->ts_umdpri = 0; \
1317c478bd9Sstevel@tonic-gate else \
1327c478bd9Sstevel@tonic-gate (tspp)->ts_umdpri = pri; \
1337c478bd9Sstevel@tonic-gate ASSERT((tspp)->ts_umdpri >= 0 && (tspp)->ts_umdpri <= ts_maxumdpri); \
1347c478bd9Sstevel@tonic-gate }
1357c478bd9Sstevel@tonic-gate
1367c478bd9Sstevel@tonic-gate /*
1377c478bd9Sstevel@tonic-gate * The tsproc_t structures are kept in an array of circular doubly linked
1387c478bd9Sstevel@tonic-gate * lists. A hash on the thread pointer is used to determine which list
1397c478bd9Sstevel@tonic-gate * each thread should be placed. Each list has a dummy "head" which is
1407c478bd9Sstevel@tonic-gate * never removed, so the list is never empty. ts_update traverses these
1417c478bd9Sstevel@tonic-gate * lists to update the priorities of threads that have been waiting on
1427c478bd9Sstevel@tonic-gate * the run queue.
1437c478bd9Sstevel@tonic-gate */
1447c478bd9Sstevel@tonic-gate
1457c478bd9Sstevel@tonic-gate #define TS_LISTS 16 /* number of lists, must be power of 2 */
1467c478bd9Sstevel@tonic-gate
1477c478bd9Sstevel@tonic-gate /* hash function, argument is a thread pointer */
1487c478bd9Sstevel@tonic-gate #define TS_LIST_HASH(tp) (((uintptr_t)(tp) >> 9) & (TS_LISTS - 1))
1497c478bd9Sstevel@tonic-gate
1507c478bd9Sstevel@tonic-gate /* iterate to the next list */
1517c478bd9Sstevel@tonic-gate #define TS_LIST_NEXT(i) (((i) + 1) & (TS_LISTS - 1))
1527c478bd9Sstevel@tonic-gate
1537c478bd9Sstevel@tonic-gate /*
1547c478bd9Sstevel@tonic-gate * Insert thread into the appropriate tsproc list.
1557c478bd9Sstevel@tonic-gate */
1567c478bd9Sstevel@tonic-gate #define TS_LIST_INSERT(tspp) \
1577c478bd9Sstevel@tonic-gate { \
1587c478bd9Sstevel@tonic-gate int index = TS_LIST_HASH(tspp->ts_tp); \
1597c478bd9Sstevel@tonic-gate kmutex_t *lockp = &ts_list_lock[index]; \
1607c478bd9Sstevel@tonic-gate tsproc_t *headp = &ts_plisthead[index]; \
1617c478bd9Sstevel@tonic-gate mutex_enter(lockp); \
1627c478bd9Sstevel@tonic-gate tspp->ts_next = headp->ts_next; \
1637c478bd9Sstevel@tonic-gate tspp->ts_prev = headp; \
1647c478bd9Sstevel@tonic-gate headp->ts_next->ts_prev = tspp; \
1657c478bd9Sstevel@tonic-gate headp->ts_next = tspp; \
1667c478bd9Sstevel@tonic-gate mutex_exit(lockp); \
1677c478bd9Sstevel@tonic-gate }
1687c478bd9Sstevel@tonic-gate
1697c478bd9Sstevel@tonic-gate /*
1707c478bd9Sstevel@tonic-gate * Remove thread from tsproc list.
1717c478bd9Sstevel@tonic-gate */
1727c478bd9Sstevel@tonic-gate #define TS_LIST_DELETE(tspp) \
1737c478bd9Sstevel@tonic-gate { \
1747c478bd9Sstevel@tonic-gate int index = TS_LIST_HASH(tspp->ts_tp); \
1757c478bd9Sstevel@tonic-gate kmutex_t *lockp = &ts_list_lock[index]; \
1767c478bd9Sstevel@tonic-gate mutex_enter(lockp); \
1777c478bd9Sstevel@tonic-gate tspp->ts_prev->ts_next = tspp->ts_next; \
1787c478bd9Sstevel@tonic-gate tspp->ts_next->ts_prev = tspp->ts_prev; \
1797c478bd9Sstevel@tonic-gate mutex_exit(lockp); \
1807c478bd9Sstevel@tonic-gate }
1817c478bd9Sstevel@tonic-gate
1827c478bd9Sstevel@tonic-gate
1837c478bd9Sstevel@tonic-gate static int ts_admin(caddr_t, cred_t *);
1847c478bd9Sstevel@tonic-gate static int ts_enterclass(kthread_t *, id_t, void *, cred_t *, void *);
1857c478bd9Sstevel@tonic-gate static int ts_fork(kthread_t *, kthread_t *, void *);
1867c478bd9Sstevel@tonic-gate static int ts_getclinfo(void *);
1877c478bd9Sstevel@tonic-gate static int ts_getclpri(pcpri_t *);
1887c478bd9Sstevel@tonic-gate static int ts_parmsin(void *);
1897c478bd9Sstevel@tonic-gate static int ts_parmsout(void *, pc_vaparms_t *);
1907c478bd9Sstevel@tonic-gate static int ts_vaparmsin(void *, pc_vaparms_t *);
1917c478bd9Sstevel@tonic-gate static int ts_vaparmsout(void *, pc_vaparms_t *);
1927c478bd9Sstevel@tonic-gate static int ts_parmsset(kthread_t *, void *, id_t, cred_t *);
193c97ad5cdSakolb static void ts_exit(kthread_t *);
1947c478bd9Sstevel@tonic-gate static int ts_donice(kthread_t *, cred_t *, int, int *);
195d4204c85Sraf static int ts_doprio(kthread_t *, cred_t *, int, int *);
1967c478bd9Sstevel@tonic-gate static void ts_exitclass(void *);
1977c478bd9Sstevel@tonic-gate static int ts_canexit(kthread_t *, cred_t *);
1987c478bd9Sstevel@tonic-gate static void ts_forkret(kthread_t *, kthread_t *);
1997c478bd9Sstevel@tonic-gate static void ts_nullsys();
2007c478bd9Sstevel@tonic-gate static void ts_parmsget(kthread_t *, void *);
2017c478bd9Sstevel@tonic-gate static void ts_preempt(kthread_t *);
2027c478bd9Sstevel@tonic-gate static void ts_setrun(kthread_t *);
2037c478bd9Sstevel@tonic-gate static void ts_sleep(kthread_t *);
2047c478bd9Sstevel@tonic-gate static pri_t ts_swapin(kthread_t *, int);
2057c478bd9Sstevel@tonic-gate static pri_t ts_swapout(kthread_t *, int);
2067c478bd9Sstevel@tonic-gate static void ts_tick(kthread_t *);
2077c478bd9Sstevel@tonic-gate static void ts_trapret(kthread_t *);
2087c478bd9Sstevel@tonic-gate static void ts_update(void *);
2097c478bd9Sstevel@tonic-gate static int ts_update_list(int);
2107c478bd9Sstevel@tonic-gate static void ts_wakeup(kthread_t *);
2117c478bd9Sstevel@tonic-gate static pri_t ts_globpri(kthread_t *);
2127c478bd9Sstevel@tonic-gate static void ts_yield(kthread_t *);
2137c478bd9Sstevel@tonic-gate extern tsdpent_t *ts_getdptbl(void);
2147c478bd9Sstevel@tonic-gate extern pri_t *ts_getkmdpris(void);
2157c478bd9Sstevel@tonic-gate extern pri_t td_getmaxumdpri(void);
2167c478bd9Sstevel@tonic-gate static int ts_alloc(void **, int);
2177c478bd9Sstevel@tonic-gate static void ts_free(void *);
2187c478bd9Sstevel@tonic-gate
2197c478bd9Sstevel@tonic-gate pri_t ia_init(id_t, int, classfuncs_t **);
2207c478bd9Sstevel@tonic-gate static int ia_getclinfo(void *);
221d4204c85Sraf static int ia_getclpri(pcpri_t *);
2227c478bd9Sstevel@tonic-gate static int ia_parmsin(void *);
2237c478bd9Sstevel@tonic-gate static int ia_vaparmsin(void *, pc_vaparms_t *);
2247c478bd9Sstevel@tonic-gate static int ia_vaparmsout(void *, pc_vaparms_t *);
2257c478bd9Sstevel@tonic-gate static int ia_parmsset(kthread_t *, void *, id_t, cred_t *);
2267c478bd9Sstevel@tonic-gate static void ia_parmsget(kthread_t *, void *);
2277c478bd9Sstevel@tonic-gate static void ia_set_process_group(pid_t, pid_t, pid_t);
2287c478bd9Sstevel@tonic-gate
2297c478bd9Sstevel@tonic-gate static void ts_change_priority(kthread_t *, tsproc_t *);
2307c478bd9Sstevel@tonic-gate
2317c478bd9Sstevel@tonic-gate static pri_t ts_maxglobpri; /* maximum global priority used by ts class */
2327c478bd9Sstevel@tonic-gate static kmutex_t ts_dptblock; /* protects time sharing dispatch table */
2337c478bd9Sstevel@tonic-gate static kmutex_t ts_list_lock[TS_LISTS]; /* protects tsproc lists */
2347c478bd9Sstevel@tonic-gate static tsproc_t ts_plisthead[TS_LISTS]; /* dummy tsproc at head of lists */
2357c478bd9Sstevel@tonic-gate
2367c478bd9Sstevel@tonic-gate static gid_t IA_gid = 0;
2377c478bd9Sstevel@tonic-gate
2387c478bd9Sstevel@tonic-gate static struct classfuncs ts_classfuncs = {
2397c478bd9Sstevel@tonic-gate /* class functions */
2407c478bd9Sstevel@tonic-gate ts_admin,
2417c478bd9Sstevel@tonic-gate ts_getclinfo,
2427c478bd9Sstevel@tonic-gate ts_parmsin,
2437c478bd9Sstevel@tonic-gate ts_parmsout,
2447c478bd9Sstevel@tonic-gate ts_vaparmsin,
2457c478bd9Sstevel@tonic-gate ts_vaparmsout,
2467c478bd9Sstevel@tonic-gate ts_getclpri,
2477c478bd9Sstevel@tonic-gate ts_alloc,
2487c478bd9Sstevel@tonic-gate ts_free,
2497c478bd9Sstevel@tonic-gate
2507c478bd9Sstevel@tonic-gate /* thread functions */
2517c478bd9Sstevel@tonic-gate ts_enterclass,
2527c478bd9Sstevel@tonic-gate ts_exitclass,
2537c478bd9Sstevel@tonic-gate ts_canexit,
2547c478bd9Sstevel@tonic-gate ts_fork,
2557c478bd9Sstevel@tonic-gate ts_forkret,
2567c478bd9Sstevel@tonic-gate ts_parmsget,
2577c478bd9Sstevel@tonic-gate ts_parmsset,
2587c478bd9Sstevel@tonic-gate ts_nullsys, /* stop */
259c97ad5cdSakolb ts_exit,
2607c478bd9Sstevel@tonic-gate ts_nullsys, /* active */
2617c478bd9Sstevel@tonic-gate ts_nullsys, /* inactive */
2627c478bd9Sstevel@tonic-gate ts_swapin,
2637c478bd9Sstevel@tonic-gate ts_swapout,
2647c478bd9Sstevel@tonic-gate ts_trapret,
2657c478bd9Sstevel@tonic-gate ts_preempt,
2667c478bd9Sstevel@tonic-gate ts_setrun,
2677c478bd9Sstevel@tonic-gate ts_sleep,
2687c478bd9Sstevel@tonic-gate ts_tick,
2697c478bd9Sstevel@tonic-gate ts_wakeup,
2707c478bd9Sstevel@tonic-gate ts_donice,
2717c478bd9Sstevel@tonic-gate ts_globpri,
2727c478bd9Sstevel@tonic-gate ts_nullsys, /* set_process_group */
2737c478bd9Sstevel@tonic-gate ts_yield,
274d4204c85Sraf ts_doprio,
2757c478bd9Sstevel@tonic-gate };
2767c478bd9Sstevel@tonic-gate
2777c478bd9Sstevel@tonic-gate /*
2787c478bd9Sstevel@tonic-gate * ia_classfuncs is used for interactive class threads; IA threads are stored
2797c478bd9Sstevel@tonic-gate * on the same class list as TS threads, and most of the class functions are
2807c478bd9Sstevel@tonic-gate * identical, but a few have different enough functionality to require their
2817c478bd9Sstevel@tonic-gate * own functions.
2827c478bd9Sstevel@tonic-gate */
2837c478bd9Sstevel@tonic-gate static struct classfuncs ia_classfuncs = {
2847c478bd9Sstevel@tonic-gate /* class functions */
2857c478bd9Sstevel@tonic-gate ts_admin,
2867c478bd9Sstevel@tonic-gate ia_getclinfo,
2877c478bd9Sstevel@tonic-gate ia_parmsin,
2887c478bd9Sstevel@tonic-gate ts_parmsout,
2897c478bd9Sstevel@tonic-gate ia_vaparmsin,
2907c478bd9Sstevel@tonic-gate ia_vaparmsout,
291d4204c85Sraf ia_getclpri,
2927c478bd9Sstevel@tonic-gate ts_alloc,
2937c478bd9Sstevel@tonic-gate ts_free,
2947c478bd9Sstevel@tonic-gate
2957c478bd9Sstevel@tonic-gate /* thread functions */
2967c478bd9Sstevel@tonic-gate ts_enterclass,
2977c478bd9Sstevel@tonic-gate ts_exitclass,
2987c478bd9Sstevel@tonic-gate ts_canexit,
2997c478bd9Sstevel@tonic-gate ts_fork,
3007c478bd9Sstevel@tonic-gate ts_forkret,
3017c478bd9Sstevel@tonic-gate ia_parmsget,
3027c478bd9Sstevel@tonic-gate ia_parmsset,
3037c478bd9Sstevel@tonic-gate ts_nullsys, /* stop */
304c97ad5cdSakolb ts_exit,
3057c478bd9Sstevel@tonic-gate ts_nullsys, /* active */
3067c478bd9Sstevel@tonic-gate ts_nullsys, /* inactive */
3077c478bd9Sstevel@tonic-gate ts_swapin,
3087c478bd9Sstevel@tonic-gate ts_swapout,
3097c478bd9Sstevel@tonic-gate ts_trapret,
3107c478bd9Sstevel@tonic-gate ts_preempt,
3117c478bd9Sstevel@tonic-gate ts_setrun,
3127c478bd9Sstevel@tonic-gate ts_sleep,
3137c478bd9Sstevel@tonic-gate ts_tick,
3147c478bd9Sstevel@tonic-gate ts_wakeup,
3157c478bd9Sstevel@tonic-gate ts_donice,
3167c478bd9Sstevel@tonic-gate ts_globpri,
3177c478bd9Sstevel@tonic-gate ia_set_process_group,
3187c478bd9Sstevel@tonic-gate ts_yield,
319d4204c85Sraf ts_doprio,
3207c478bd9Sstevel@tonic-gate };
3217c478bd9Sstevel@tonic-gate
3227c478bd9Sstevel@tonic-gate
3237c478bd9Sstevel@tonic-gate /*
3247c478bd9Sstevel@tonic-gate * Time sharing class initialization. Called by dispinit() at boot time.
3257c478bd9Sstevel@tonic-gate * We can ignore the clparmsz argument since we know that the smallest
3267c478bd9Sstevel@tonic-gate * possible parameter buffer is big enough for us.
3277c478bd9Sstevel@tonic-gate */
3287c478bd9Sstevel@tonic-gate /* ARGSUSED */
3297c478bd9Sstevel@tonic-gate static pri_t
ts_init(id_t cid,int clparmsz,classfuncs_t ** clfuncspp)3307c478bd9Sstevel@tonic-gate ts_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp)
3317c478bd9Sstevel@tonic-gate {
3327c478bd9Sstevel@tonic-gate int i;
3337c478bd9Sstevel@tonic-gate extern pri_t ts_getmaxumdpri(void);
3347c478bd9Sstevel@tonic-gate
3357c478bd9Sstevel@tonic-gate ts_dptbl = ts_getdptbl();
3367c478bd9Sstevel@tonic-gate ts_kmdpris = ts_getkmdpris();
3377c478bd9Sstevel@tonic-gate ts_maxumdpri = ts_getmaxumdpri();
3387c478bd9Sstevel@tonic-gate ts_maxglobpri = MAX(ts_kmdpris[0], ts_dptbl[ts_maxumdpri].ts_globpri);
3397c478bd9Sstevel@tonic-gate
3407c478bd9Sstevel@tonic-gate /*
3417c478bd9Sstevel@tonic-gate * Initialize the tsproc lists.
3427c478bd9Sstevel@tonic-gate */
3437c478bd9Sstevel@tonic-gate for (i = 0; i < TS_LISTS; i++) {
3447c478bd9Sstevel@tonic-gate ts_plisthead[i].ts_next = ts_plisthead[i].ts_prev =
3457c478bd9Sstevel@tonic-gate &ts_plisthead[i];
3467c478bd9Sstevel@tonic-gate }
3477c478bd9Sstevel@tonic-gate
3487c478bd9Sstevel@tonic-gate /*
3497c478bd9Sstevel@tonic-gate * We're required to return a pointer to our classfuncs
3507c478bd9Sstevel@tonic-gate * structure and the highest global priority value we use.
3517c478bd9Sstevel@tonic-gate */
3527c478bd9Sstevel@tonic-gate *clfuncspp = &ts_classfuncs;
3537c478bd9Sstevel@tonic-gate return (ts_maxglobpri);
3547c478bd9Sstevel@tonic-gate }
3557c478bd9Sstevel@tonic-gate
3567c478bd9Sstevel@tonic-gate
3577c478bd9Sstevel@tonic-gate /*
3587c478bd9Sstevel@tonic-gate * Interactive class scheduler initialization
3597c478bd9Sstevel@tonic-gate */
3607c478bd9Sstevel@tonic-gate /* ARGSUSED */
3617c478bd9Sstevel@tonic-gate pri_t
ia_init(id_t cid,int clparmsz,classfuncs_t ** clfuncspp)3627c478bd9Sstevel@tonic-gate ia_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp)
3637c478bd9Sstevel@tonic-gate {
3647c478bd9Sstevel@tonic-gate /*
3657c478bd9Sstevel@tonic-gate * We're required to return a pointer to our classfuncs
3667c478bd9Sstevel@tonic-gate * structure and the highest global priority value we use.
3677c478bd9Sstevel@tonic-gate */
3687c478bd9Sstevel@tonic-gate ia_cid = cid;
3697c478bd9Sstevel@tonic-gate *clfuncspp = &ia_classfuncs;
3707c478bd9Sstevel@tonic-gate return (ts_maxglobpri);
3717c478bd9Sstevel@tonic-gate }
3727c478bd9Sstevel@tonic-gate
3737c478bd9Sstevel@tonic-gate
3747c478bd9Sstevel@tonic-gate /*
3757c478bd9Sstevel@tonic-gate * Get or reset the ts_dptbl values per the user's request.
3767c478bd9Sstevel@tonic-gate */
3777c478bd9Sstevel@tonic-gate static int
ts_admin(caddr_t uaddr,cred_t * reqpcredp)3787c478bd9Sstevel@tonic-gate ts_admin(caddr_t uaddr, cred_t *reqpcredp)
3797c478bd9Sstevel@tonic-gate {
3807c478bd9Sstevel@tonic-gate tsadmin_t tsadmin;
3817c478bd9Sstevel@tonic-gate tsdpent_t *tmpdpp;
3827c478bd9Sstevel@tonic-gate int userdpsz;
3837c478bd9Sstevel@tonic-gate int i;
3847c478bd9Sstevel@tonic-gate size_t tsdpsz;
3857c478bd9Sstevel@tonic-gate
3867c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) {
3877c478bd9Sstevel@tonic-gate if (copyin(uaddr, &tsadmin, sizeof (tsadmin_t)))
3887c478bd9Sstevel@tonic-gate return (EFAULT);
3897c478bd9Sstevel@tonic-gate }
3907c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
3917c478bd9Sstevel@tonic-gate else {
3927c478bd9Sstevel@tonic-gate /* get tsadmin struct from ILP32 caller */
3937c478bd9Sstevel@tonic-gate tsadmin32_t tsadmin32;
3947c478bd9Sstevel@tonic-gate if (copyin(uaddr, &tsadmin32, sizeof (tsadmin32_t)))
3957c478bd9Sstevel@tonic-gate return (EFAULT);
3967c478bd9Sstevel@tonic-gate tsadmin.ts_dpents =
3977c478bd9Sstevel@tonic-gate (struct tsdpent *)(uintptr_t)tsadmin32.ts_dpents;
3987c478bd9Sstevel@tonic-gate tsadmin.ts_ndpents = tsadmin32.ts_ndpents;
3997c478bd9Sstevel@tonic-gate tsadmin.ts_cmd = tsadmin32.ts_cmd;
4007c478bd9Sstevel@tonic-gate }
4017c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */
4027c478bd9Sstevel@tonic-gate
4037c478bd9Sstevel@tonic-gate tsdpsz = (ts_maxumdpri + 1) * sizeof (tsdpent_t);
4047c478bd9Sstevel@tonic-gate
4057c478bd9Sstevel@tonic-gate switch (tsadmin.ts_cmd) {
4067c478bd9Sstevel@tonic-gate case TS_GETDPSIZE:
4077c478bd9Sstevel@tonic-gate tsadmin.ts_ndpents = ts_maxumdpri + 1;
4087c478bd9Sstevel@tonic-gate
4097c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) {
4107c478bd9Sstevel@tonic-gate if (copyout(&tsadmin, uaddr, sizeof (tsadmin_t)))
4117c478bd9Sstevel@tonic-gate return (EFAULT);
4127c478bd9Sstevel@tonic-gate }
4137c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
4147c478bd9Sstevel@tonic-gate else {
4157c478bd9Sstevel@tonic-gate /* return tsadmin struct to ILP32 caller */
4167c478bd9Sstevel@tonic-gate tsadmin32_t tsadmin32;
4177c478bd9Sstevel@tonic-gate tsadmin32.ts_dpents =
4187c478bd9Sstevel@tonic-gate (caddr32_t)(uintptr_t)tsadmin.ts_dpents;
4197c478bd9Sstevel@tonic-gate tsadmin32.ts_ndpents = tsadmin.ts_ndpents;
4207c478bd9Sstevel@tonic-gate tsadmin32.ts_cmd = tsadmin.ts_cmd;
4217c478bd9Sstevel@tonic-gate if (copyout(&tsadmin32, uaddr, sizeof (tsadmin32_t)))
4227c478bd9Sstevel@tonic-gate return (EFAULT);
4237c478bd9Sstevel@tonic-gate }
4247c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */
4257c478bd9Sstevel@tonic-gate break;
4267c478bd9Sstevel@tonic-gate
4277c478bd9Sstevel@tonic-gate case TS_GETDPTBL:
4287c478bd9Sstevel@tonic-gate userdpsz = MIN(tsadmin.ts_ndpents * sizeof (tsdpent_t),
4297c478bd9Sstevel@tonic-gate tsdpsz);
4307c478bd9Sstevel@tonic-gate if (copyout(ts_dptbl, tsadmin.ts_dpents, userdpsz))
4317c478bd9Sstevel@tonic-gate return (EFAULT);
4327c478bd9Sstevel@tonic-gate
4337c478bd9Sstevel@tonic-gate tsadmin.ts_ndpents = userdpsz / sizeof (tsdpent_t);
4347c478bd9Sstevel@tonic-gate
4357c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) {
4367c478bd9Sstevel@tonic-gate if (copyout(&tsadmin, uaddr, sizeof (tsadmin_t)))
4377c478bd9Sstevel@tonic-gate return (EFAULT);
4387c478bd9Sstevel@tonic-gate }
4397c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
4407c478bd9Sstevel@tonic-gate else {
4417c478bd9Sstevel@tonic-gate /* return tsadmin struct to ILP32 callers */
4427c478bd9Sstevel@tonic-gate tsadmin32_t tsadmin32;
4437c478bd9Sstevel@tonic-gate tsadmin32.ts_dpents =
4447c478bd9Sstevel@tonic-gate (caddr32_t)(uintptr_t)tsadmin.ts_dpents;
4457c478bd9Sstevel@tonic-gate tsadmin32.ts_ndpents = tsadmin.ts_ndpents;
4467c478bd9Sstevel@tonic-gate tsadmin32.ts_cmd = tsadmin.ts_cmd;
4477c478bd9Sstevel@tonic-gate if (copyout(&tsadmin32, uaddr, sizeof (tsadmin32_t)))
4487c478bd9Sstevel@tonic-gate return (EFAULT);
4497c478bd9Sstevel@tonic-gate }
4507c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */
4517c478bd9Sstevel@tonic-gate break;
4527c478bd9Sstevel@tonic-gate
4537c478bd9Sstevel@tonic-gate case TS_SETDPTBL:
4547c478bd9Sstevel@tonic-gate /*
4557c478bd9Sstevel@tonic-gate * We require that the requesting process has sufficient
4567c478bd9Sstevel@tonic-gate * priveleges. We also require that the table supplied by
4577c478bd9Sstevel@tonic-gate * the user exactly match the current ts_dptbl in size.
4587c478bd9Sstevel@tonic-gate */
4597c478bd9Sstevel@tonic-gate if (secpolicy_dispadm(reqpcredp) != 0)
4607c478bd9Sstevel@tonic-gate return (EPERM);
4617c478bd9Sstevel@tonic-gate
4627c478bd9Sstevel@tonic-gate if (tsadmin.ts_ndpents * sizeof (tsdpent_t) != tsdpsz) {
4637c478bd9Sstevel@tonic-gate return (EINVAL);
4647c478bd9Sstevel@tonic-gate }
4657c478bd9Sstevel@tonic-gate
4667c478bd9Sstevel@tonic-gate /*
4677c478bd9Sstevel@tonic-gate * We read the user supplied table into a temporary buffer
4687c478bd9Sstevel@tonic-gate * where it is validated before being copied over the
4697c478bd9Sstevel@tonic-gate * ts_dptbl.
4707c478bd9Sstevel@tonic-gate */
4717c478bd9Sstevel@tonic-gate tmpdpp = kmem_alloc(tsdpsz, KM_SLEEP);
4727c478bd9Sstevel@tonic-gate if (copyin((caddr_t)tsadmin.ts_dpents, (caddr_t)tmpdpp,
4737c478bd9Sstevel@tonic-gate tsdpsz)) {
4747c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
4757c478bd9Sstevel@tonic-gate return (EFAULT);
4767c478bd9Sstevel@tonic-gate }
4777c478bd9Sstevel@tonic-gate for (i = 0; i < tsadmin.ts_ndpents; i++) {
4787c478bd9Sstevel@tonic-gate
4797c478bd9Sstevel@tonic-gate /*
4807c478bd9Sstevel@tonic-gate * Validate the user supplied values. All we are doing
4817c478bd9Sstevel@tonic-gate * here is verifying that the values are within their
4827c478bd9Sstevel@tonic-gate * allowable ranges and will not panic the system. We
4837c478bd9Sstevel@tonic-gate * make no attempt to ensure that the resulting
4847c478bd9Sstevel@tonic-gate * configuration makes sense or results in reasonable
4857c478bd9Sstevel@tonic-gate * performance.
4867c478bd9Sstevel@tonic-gate */
4877c478bd9Sstevel@tonic-gate if (tmpdpp[i].ts_quantum <= 0) {
4887c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
4897c478bd9Sstevel@tonic-gate return (EINVAL);
4907c478bd9Sstevel@tonic-gate }
4917c478bd9Sstevel@tonic-gate if (tmpdpp[i].ts_tqexp > ts_maxumdpri ||
4927c478bd9Sstevel@tonic-gate tmpdpp[i].ts_tqexp < 0) {
4937c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
4947c478bd9Sstevel@tonic-gate return (EINVAL);
4957c478bd9Sstevel@tonic-gate }
4967c478bd9Sstevel@tonic-gate if (tmpdpp[i].ts_slpret > ts_maxumdpri ||
4977c478bd9Sstevel@tonic-gate tmpdpp[i].ts_slpret < 0) {
4987c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
4997c478bd9Sstevel@tonic-gate return (EINVAL);
5007c478bd9Sstevel@tonic-gate }
5017c478bd9Sstevel@tonic-gate if (tmpdpp[i].ts_maxwait < 0) {
5027c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
5037c478bd9Sstevel@tonic-gate return (EINVAL);
5047c478bd9Sstevel@tonic-gate }
5057c478bd9Sstevel@tonic-gate if (tmpdpp[i].ts_lwait > ts_maxumdpri ||
5067c478bd9Sstevel@tonic-gate tmpdpp[i].ts_lwait < 0) {
5077c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
5087c478bd9Sstevel@tonic-gate return (EINVAL);
5097c478bd9Sstevel@tonic-gate }
5107c478bd9Sstevel@tonic-gate }
5117c478bd9Sstevel@tonic-gate
5127c478bd9Sstevel@tonic-gate /*
5137c478bd9Sstevel@tonic-gate * Copy the user supplied values over the current ts_dptbl
5147c478bd9Sstevel@tonic-gate * values. The ts_globpri member is read-only so we don't
5157c478bd9Sstevel@tonic-gate * overwrite it.
5167c478bd9Sstevel@tonic-gate */
5177c478bd9Sstevel@tonic-gate mutex_enter(&ts_dptblock);
5187c478bd9Sstevel@tonic-gate for (i = 0; i < tsadmin.ts_ndpents; i++) {
5197c478bd9Sstevel@tonic-gate ts_dptbl[i].ts_quantum = tmpdpp[i].ts_quantum;
5207c478bd9Sstevel@tonic-gate ts_dptbl[i].ts_tqexp = tmpdpp[i].ts_tqexp;
5217c478bd9Sstevel@tonic-gate ts_dptbl[i].ts_slpret = tmpdpp[i].ts_slpret;
5227c478bd9Sstevel@tonic-gate ts_dptbl[i].ts_maxwait = tmpdpp[i].ts_maxwait;
5237c478bd9Sstevel@tonic-gate ts_dptbl[i].ts_lwait = tmpdpp[i].ts_lwait;
5247c478bd9Sstevel@tonic-gate }
5257c478bd9Sstevel@tonic-gate mutex_exit(&ts_dptblock);
5267c478bd9Sstevel@tonic-gate kmem_free(tmpdpp, tsdpsz);
5277c478bd9Sstevel@tonic-gate break;
5287c478bd9Sstevel@tonic-gate
5297c478bd9Sstevel@tonic-gate default:
5307c478bd9Sstevel@tonic-gate return (EINVAL);
5317c478bd9Sstevel@tonic-gate }
5327c478bd9Sstevel@tonic-gate return (0);
5337c478bd9Sstevel@tonic-gate }
5347c478bd9Sstevel@tonic-gate
5357c478bd9Sstevel@tonic-gate
5367c478bd9Sstevel@tonic-gate /*
5377c478bd9Sstevel@tonic-gate * Allocate a time-sharing class specific thread structure and
5387c478bd9Sstevel@tonic-gate * initialize it with the parameters supplied. Also move the thread
5397c478bd9Sstevel@tonic-gate * to specified time-sharing priority.
5407c478bd9Sstevel@tonic-gate */
5417c478bd9Sstevel@tonic-gate static int
ts_enterclass(kthread_t * t,id_t cid,void * parmsp,cred_t * reqpcredp,void * bufp)5426a0b1217SPatrick Mooney ts_enterclass(kthread_t *t, id_t cid, void *parmsp, cred_t *reqpcredp,
5436a0b1217SPatrick Mooney void *bufp)
5447c478bd9Sstevel@tonic-gate {
5457c478bd9Sstevel@tonic-gate tsparms_t *tsparmsp = (tsparms_t *)parmsp;
5467c478bd9Sstevel@tonic-gate tsproc_t *tspp;
5477c478bd9Sstevel@tonic-gate pri_t reqtsuprilim;
5487c478bd9Sstevel@tonic-gate pri_t reqtsupri;
5497c478bd9Sstevel@tonic-gate static uint32_t tspexists = 0; /* set on first occurrence of */
5507c478bd9Sstevel@tonic-gate /* a time-sharing process */
5517c478bd9Sstevel@tonic-gate
5527c478bd9Sstevel@tonic-gate tspp = (tsproc_t *)bufp;
5537c478bd9Sstevel@tonic-gate ASSERT(tspp != NULL);
5547c478bd9Sstevel@tonic-gate
5557c478bd9Sstevel@tonic-gate /*
5567c478bd9Sstevel@tonic-gate * Initialize the tsproc structure.
5577c478bd9Sstevel@tonic-gate */
5587c478bd9Sstevel@tonic-gate tspp->ts_cpupri = tsmedumdpri;
5597c478bd9Sstevel@tonic-gate if (cid == ia_cid) {
5607c478bd9Sstevel@tonic-gate /*
5617c478bd9Sstevel@tonic-gate * Check to make sure caller is either privileged or the
5627c478bd9Sstevel@tonic-gate * window system. When the window system is converted
5637c478bd9Sstevel@tonic-gate * to using privileges, the second check can go away.
5647c478bd9Sstevel@tonic-gate */
5657c478bd9Sstevel@tonic-gate if (reqpcredp != NULL && !groupmember(IA_gid, reqpcredp) &&
5667c478bd9Sstevel@tonic-gate secpolicy_setpriority(reqpcredp) != 0)
5677c478bd9Sstevel@tonic-gate return (EPERM);
5687c478bd9Sstevel@tonic-gate /*
5697c478bd9Sstevel@tonic-gate * Belongs to IA "class", so set appropriate flags.
5707c478bd9Sstevel@tonic-gate * Mark as 'on' so it will not be a swap victim
5717c478bd9Sstevel@tonic-gate * while forking.
5727c478bd9Sstevel@tonic-gate */
5737c478bd9Sstevel@tonic-gate tspp->ts_flags = TSIA | TSIASET;
5747c478bd9Sstevel@tonic-gate tspp->ts_boost = ia_boost;
5757c478bd9Sstevel@tonic-gate } else {
5767c478bd9Sstevel@tonic-gate tspp->ts_flags = 0;
5777c478bd9Sstevel@tonic-gate tspp->ts_boost = 0;
5787c478bd9Sstevel@tonic-gate }
5797c478bd9Sstevel@tonic-gate
5807c478bd9Sstevel@tonic-gate if (tsparmsp == NULL) {
5817c478bd9Sstevel@tonic-gate /*
5827c478bd9Sstevel@tonic-gate * Use default values.
5837c478bd9Sstevel@tonic-gate */
5847c478bd9Sstevel@tonic-gate tspp->ts_uprilim = tspp->ts_upri = 0;
5857c478bd9Sstevel@tonic-gate tspp->ts_nice = NZERO;
5867c478bd9Sstevel@tonic-gate } else {
5877c478bd9Sstevel@tonic-gate /*
5887c478bd9Sstevel@tonic-gate * Use supplied values.
5897c478bd9Sstevel@tonic-gate */
5907c478bd9Sstevel@tonic-gate if (tsparmsp->ts_uprilim == TS_NOCHANGE)
5917c478bd9Sstevel@tonic-gate reqtsuprilim = 0;
5927c478bd9Sstevel@tonic-gate else {
5937c478bd9Sstevel@tonic-gate if (tsparmsp->ts_uprilim > 0 &&
5947c478bd9Sstevel@tonic-gate secpolicy_setpriority(reqpcredp) != 0)
5957c478bd9Sstevel@tonic-gate return (EPERM);
5967c478bd9Sstevel@tonic-gate reqtsuprilim = tsparmsp->ts_uprilim;
5977c478bd9Sstevel@tonic-gate }
5987c478bd9Sstevel@tonic-gate
5997c478bd9Sstevel@tonic-gate if (tsparmsp->ts_upri == TS_NOCHANGE) {
6007c478bd9Sstevel@tonic-gate reqtsupri = reqtsuprilim;
6017c478bd9Sstevel@tonic-gate } else {
6027c478bd9Sstevel@tonic-gate if (tsparmsp->ts_upri > 0 &&
6037c478bd9Sstevel@tonic-gate secpolicy_setpriority(reqpcredp) != 0)
6047c478bd9Sstevel@tonic-gate return (EPERM);
6057c478bd9Sstevel@tonic-gate /*
6067c478bd9Sstevel@tonic-gate * Set the user priority to the requested value
6077c478bd9Sstevel@tonic-gate * or the upri limit, whichever is lower.
6087c478bd9Sstevel@tonic-gate */
6097c478bd9Sstevel@tonic-gate reqtsupri = tsparmsp->ts_upri;
6107c478bd9Sstevel@tonic-gate if (reqtsupri > reqtsuprilim)
6117c478bd9Sstevel@tonic-gate reqtsupri = reqtsuprilim;
6127c478bd9Sstevel@tonic-gate }
6137c478bd9Sstevel@tonic-gate
6147c478bd9Sstevel@tonic-gate
6157c478bd9Sstevel@tonic-gate tspp->ts_uprilim = reqtsuprilim;
6167c478bd9Sstevel@tonic-gate tspp->ts_upri = reqtsupri;
617d4204c85Sraf tspp->ts_nice = NZERO - (NZERO * reqtsupri) / ts_maxupri;
6187c478bd9Sstevel@tonic-gate }
6197c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
6207c478bd9Sstevel@tonic-gate
6217c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
6227c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
6237c478bd9Sstevel@tonic-gate tspp->ts_tp = t;
624c97ad5cdSakolb cpucaps_sc_init(&tspp->ts_caps);
6257c478bd9Sstevel@tonic-gate
6267c478bd9Sstevel@tonic-gate /*
6277c478bd9Sstevel@tonic-gate * Reset priority. Process goes to a "user mode" priority
6287c478bd9Sstevel@tonic-gate * here regardless of whether or not it has slept since
6297c478bd9Sstevel@tonic-gate * entering the kernel.
6307c478bd9Sstevel@tonic-gate */
6317c478bd9Sstevel@tonic-gate thread_lock(t); /* get dispatcher lock on thread */
6327c478bd9Sstevel@tonic-gate t->t_clfuncs = &(sclass[cid].cl_funcs->thread);
6337c478bd9Sstevel@tonic-gate t->t_cid = cid;
6347c478bd9Sstevel@tonic-gate t->t_cldata = (void *)tspp;
6357c478bd9Sstevel@tonic-gate t->t_schedflag &= ~TS_RUNQMATCH;
6367c478bd9Sstevel@tonic-gate ts_change_priority(t, tspp);
6377c478bd9Sstevel@tonic-gate thread_unlock(t);
6387c478bd9Sstevel@tonic-gate
6397c478bd9Sstevel@tonic-gate /*
6407c478bd9Sstevel@tonic-gate * Link new structure into tsproc list.
6417c478bd9Sstevel@tonic-gate */
6427c478bd9Sstevel@tonic-gate TS_LIST_INSERT(tspp);
6437c478bd9Sstevel@tonic-gate
6447c478bd9Sstevel@tonic-gate /*
6457c478bd9Sstevel@tonic-gate * If this is the first time-sharing thread to occur since
6467c478bd9Sstevel@tonic-gate * boot we set up the initial call to ts_update() here.
6477c478bd9Sstevel@tonic-gate * Use an atomic compare-and-swap since that's easier and
6487c478bd9Sstevel@tonic-gate * faster than a mutex (but check with an ordinary load first
6497c478bd9Sstevel@tonic-gate * since most of the time this will already be done).
6507c478bd9Sstevel@tonic-gate */
65175d94465SJosef 'Jeff' Sipek if (tspexists == 0 && atomic_cas_32(&tspexists, 0, 1) == 0)
6527c478bd9Sstevel@tonic-gate (void) timeout(ts_update, NULL, hz);
6537c478bd9Sstevel@tonic-gate
6547c478bd9Sstevel@tonic-gate return (0);
6557c478bd9Sstevel@tonic-gate }
6567c478bd9Sstevel@tonic-gate
6577c478bd9Sstevel@tonic-gate
6587c478bd9Sstevel@tonic-gate /*
6597c478bd9Sstevel@tonic-gate * Free tsproc structure of thread.
6607c478bd9Sstevel@tonic-gate */
6617c478bd9Sstevel@tonic-gate static void
ts_exitclass(void * procp)6627c478bd9Sstevel@tonic-gate ts_exitclass(void *procp)
6637c478bd9Sstevel@tonic-gate {
6647c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)procp;
6657c478bd9Sstevel@tonic-gate
6667c478bd9Sstevel@tonic-gate /* Remove tsproc_t structure from list */
6677c478bd9Sstevel@tonic-gate TS_LIST_DELETE(tspp);
6687c478bd9Sstevel@tonic-gate kmem_free(tspp, sizeof (tsproc_t));
6697c478bd9Sstevel@tonic-gate }
6707c478bd9Sstevel@tonic-gate
6717c478bd9Sstevel@tonic-gate /* ARGSUSED */
6727c478bd9Sstevel@tonic-gate static int
ts_canexit(kthread_t * t,cred_t * cred)6737c478bd9Sstevel@tonic-gate ts_canexit(kthread_t *t, cred_t *cred)
6747c478bd9Sstevel@tonic-gate {
6757c478bd9Sstevel@tonic-gate /*
6767c478bd9Sstevel@tonic-gate * A thread can always leave a TS/IA class
6777c478bd9Sstevel@tonic-gate */
6787c478bd9Sstevel@tonic-gate return (0);
6797c478bd9Sstevel@tonic-gate }
6807c478bd9Sstevel@tonic-gate
6817c478bd9Sstevel@tonic-gate static int
ts_fork(kthread_t * t,kthread_t * ct,void * bufp)6827c478bd9Sstevel@tonic-gate ts_fork(kthread_t *t, kthread_t *ct, void *bufp)
6837c478bd9Sstevel@tonic-gate {
6847c478bd9Sstevel@tonic-gate tsproc_t *ptspp; /* ptr to parent's tsproc structure */
6857c478bd9Sstevel@tonic-gate tsproc_t *ctspp; /* ptr to child's tsproc structure */
6867c478bd9Sstevel@tonic-gate
6877c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock));
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate ctspp = (tsproc_t *)bufp;
6907c478bd9Sstevel@tonic-gate ASSERT(ctspp != NULL);
6917c478bd9Sstevel@tonic-gate ptspp = (tsproc_t *)t->t_cldata;
6927c478bd9Sstevel@tonic-gate /*
6937c478bd9Sstevel@tonic-gate * Initialize child's tsproc structure.
6947c478bd9Sstevel@tonic-gate */
6957c478bd9Sstevel@tonic-gate thread_lock(t);
6967c478bd9Sstevel@tonic-gate ctspp->ts_timeleft = ts_dptbl[ptspp->ts_cpupri].ts_quantum;
6977c478bd9Sstevel@tonic-gate ctspp->ts_cpupri = ptspp->ts_cpupri;
6987c478bd9Sstevel@tonic-gate ctspp->ts_boost = ptspp->ts_boost;
6997c478bd9Sstevel@tonic-gate ctspp->ts_uprilim = ptspp->ts_uprilim;
7007c478bd9Sstevel@tonic-gate ctspp->ts_upri = ptspp->ts_upri;
7017c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(ctspp);
7027c478bd9Sstevel@tonic-gate ctspp->ts_nice = ptspp->ts_nice;
7037c478bd9Sstevel@tonic-gate ctspp->ts_dispwait = 0;
7046a0b1217SPatrick Mooney ctspp->ts_flags = ptspp->ts_flags & ~(TSBACKQ | TSRESTORE);
7057c478bd9Sstevel@tonic-gate ctspp->ts_tp = ct;
706c97ad5cdSakolb cpucaps_sc_init(&ctspp->ts_caps);
7077c478bd9Sstevel@tonic-gate thread_unlock(t);
7087c478bd9Sstevel@tonic-gate
7097c478bd9Sstevel@tonic-gate /*
7107c478bd9Sstevel@tonic-gate * Link new structure into tsproc list.
7117c478bd9Sstevel@tonic-gate */
7127c478bd9Sstevel@tonic-gate ct->t_cldata = (void *)ctspp;
7137c478bd9Sstevel@tonic-gate TS_LIST_INSERT(ctspp);
7147c478bd9Sstevel@tonic-gate return (0);
7157c478bd9Sstevel@tonic-gate }
7167c478bd9Sstevel@tonic-gate
7177c478bd9Sstevel@tonic-gate
7187c478bd9Sstevel@tonic-gate /*
7197c478bd9Sstevel@tonic-gate * Child is placed at back of dispatcher queue and parent gives
7207c478bd9Sstevel@tonic-gate * up processor so that the child runs first after the fork.
7217c478bd9Sstevel@tonic-gate * This allows the child immediately execing to break the multiple
7227c478bd9Sstevel@tonic-gate * use of copy on write pages with no disk home. The parent will
7237c478bd9Sstevel@tonic-gate * get to steal them back rather than uselessly copying them.
7247c478bd9Sstevel@tonic-gate */
7257c478bd9Sstevel@tonic-gate static void
ts_forkret(kthread_t * t,kthread_t * ct)7267c478bd9Sstevel@tonic-gate ts_forkret(kthread_t *t, kthread_t *ct)
7277c478bd9Sstevel@tonic-gate {
7287c478bd9Sstevel@tonic-gate proc_t *pp = ttoproc(t);
7297c478bd9Sstevel@tonic-gate proc_t *cp = ttoproc(ct);
7307c478bd9Sstevel@tonic-gate tsproc_t *tspp;
7317c478bd9Sstevel@tonic-gate
7327c478bd9Sstevel@tonic-gate ASSERT(t == curthread);
7337c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock));
7347c478bd9Sstevel@tonic-gate
7357c478bd9Sstevel@tonic-gate /*
7367c478bd9Sstevel@tonic-gate * Grab the child's p_lock before dropping pidlock to ensure
7377c478bd9Sstevel@tonic-gate * the process does not disappear before we set it running.
7387c478bd9Sstevel@tonic-gate */
7397c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
7407c478bd9Sstevel@tonic-gate continuelwps(cp);
7417c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
7427c478bd9Sstevel@tonic-gate
7437c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock);
744d5493db7SPramod Batni mutex_exit(&pidlock);
7457c478bd9Sstevel@tonic-gate continuelwps(pp);
7467c478bd9Sstevel@tonic-gate
7477c478bd9Sstevel@tonic-gate thread_lock(t);
7487c478bd9Sstevel@tonic-gate tspp = (tsproc_t *)(t->t_cldata);
7497c478bd9Sstevel@tonic-gate tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp;
7507c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
7517c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
7527c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
7537c478bd9Sstevel@tonic-gate t->t_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
7547c478bd9Sstevel@tonic-gate ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
7557c478bd9Sstevel@tonic-gate THREAD_TRANSITION(t);
7567c478bd9Sstevel@tonic-gate ts_setrun(t);
7577c478bd9Sstevel@tonic-gate thread_unlock(t);
758d5493db7SPramod Batni /*
759d5493db7SPramod Batni * Safe to drop p_lock now since since it is safe to change
760d5493db7SPramod Batni * the scheduling class after this point.
761d5493db7SPramod Batni */
762d5493db7SPramod Batni mutex_exit(&pp->p_lock);
7637c478bd9Sstevel@tonic-gate
7647c478bd9Sstevel@tonic-gate swtch();
7657c478bd9Sstevel@tonic-gate }
7667c478bd9Sstevel@tonic-gate
7677c478bd9Sstevel@tonic-gate
7687c478bd9Sstevel@tonic-gate /*
7697c478bd9Sstevel@tonic-gate * Get information about the time-sharing class into the buffer
7707c478bd9Sstevel@tonic-gate * pointed to by tsinfop. The maximum configured user priority
7717c478bd9Sstevel@tonic-gate * is the only information we supply. ts_getclinfo() is called
7727c478bd9Sstevel@tonic-gate * for TS threads, and ia_getclinfo() is called for IA threads.
7737c478bd9Sstevel@tonic-gate */
7747c478bd9Sstevel@tonic-gate static int
ts_getclinfo(void * infop)7757c478bd9Sstevel@tonic-gate ts_getclinfo(void *infop)
7767c478bd9Sstevel@tonic-gate {
7777c478bd9Sstevel@tonic-gate tsinfo_t *tsinfop = (tsinfo_t *)infop;
7787c478bd9Sstevel@tonic-gate tsinfop->ts_maxupri = ts_maxupri;
7797c478bd9Sstevel@tonic-gate return (0);
7807c478bd9Sstevel@tonic-gate }
7817c478bd9Sstevel@tonic-gate
7827c478bd9Sstevel@tonic-gate static int
ia_getclinfo(void * infop)7837c478bd9Sstevel@tonic-gate ia_getclinfo(void *infop)
7847c478bd9Sstevel@tonic-gate {
7857c478bd9Sstevel@tonic-gate iainfo_t *iainfop = (iainfo_t *)infop;
7867c478bd9Sstevel@tonic-gate iainfop->ia_maxupri = ia_maxupri;
7877c478bd9Sstevel@tonic-gate return (0);
7887c478bd9Sstevel@tonic-gate }
7897c478bd9Sstevel@tonic-gate
7907c478bd9Sstevel@tonic-gate
7917c478bd9Sstevel@tonic-gate /*
792d4204c85Sraf * Return the user mode scheduling priority range.
7937c478bd9Sstevel@tonic-gate */
7947c478bd9Sstevel@tonic-gate static int
ts_getclpri(pcpri_t * pcprip)7957c478bd9Sstevel@tonic-gate ts_getclpri(pcpri_t *pcprip)
7967c478bd9Sstevel@tonic-gate {
797d4204c85Sraf pcprip->pc_clpmax = ts_maxupri;
798d4204c85Sraf pcprip->pc_clpmin = -ts_maxupri;
799d4204c85Sraf return (0);
800d4204c85Sraf }
801d4204c85Sraf
802d4204c85Sraf
803d4204c85Sraf static int
ia_getclpri(pcpri_t * pcprip)804d4204c85Sraf ia_getclpri(pcpri_t *pcprip)
805d4204c85Sraf {
806d4204c85Sraf pcprip->pc_clpmax = ia_maxupri;
807d4204c85Sraf pcprip->pc_clpmin = -ia_maxupri;
8087c478bd9Sstevel@tonic-gate return (0);
8097c478bd9Sstevel@tonic-gate }
8107c478bd9Sstevel@tonic-gate
8117c478bd9Sstevel@tonic-gate
8127c478bd9Sstevel@tonic-gate static void
ts_nullsys()8137c478bd9Sstevel@tonic-gate ts_nullsys()
8147c478bd9Sstevel@tonic-gate {}
8157c478bd9Sstevel@tonic-gate
8167c478bd9Sstevel@tonic-gate
8177c478bd9Sstevel@tonic-gate /*
8187c478bd9Sstevel@tonic-gate * Get the time-sharing parameters of the thread pointed to by
8197c478bd9Sstevel@tonic-gate * tsprocp into the buffer pointed to by tsparmsp. ts_parmsget()
8207c478bd9Sstevel@tonic-gate * is called for TS threads, and ia_parmsget() is called for IA
8217c478bd9Sstevel@tonic-gate * threads.
8227c478bd9Sstevel@tonic-gate */
8237c478bd9Sstevel@tonic-gate static void
ts_parmsget(kthread_t * t,void * parmsp)8247c478bd9Sstevel@tonic-gate ts_parmsget(kthread_t *t, void *parmsp)
8257c478bd9Sstevel@tonic-gate {
8267c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)t->t_cldata;
8277c478bd9Sstevel@tonic-gate tsparms_t *tsparmsp = (tsparms_t *)parmsp;
8287c478bd9Sstevel@tonic-gate
8297c478bd9Sstevel@tonic-gate tsparmsp->ts_uprilim = tspp->ts_uprilim;
8307c478bd9Sstevel@tonic-gate tsparmsp->ts_upri = tspp->ts_upri;
8317c478bd9Sstevel@tonic-gate }
8327c478bd9Sstevel@tonic-gate
8337c478bd9Sstevel@tonic-gate static void
ia_parmsget(kthread_t * t,void * parmsp)8347c478bd9Sstevel@tonic-gate ia_parmsget(kthread_t *t, void *parmsp)
8357c478bd9Sstevel@tonic-gate {
8367c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)t->t_cldata;
8377c478bd9Sstevel@tonic-gate iaparms_t *iaparmsp = (iaparms_t *)parmsp;
8387c478bd9Sstevel@tonic-gate
8397c478bd9Sstevel@tonic-gate iaparmsp->ia_uprilim = tspp->ts_uprilim;
8407c478bd9Sstevel@tonic-gate iaparmsp->ia_upri = tspp->ts_upri;
8417c478bd9Sstevel@tonic-gate if (tspp->ts_flags & TSIASET)
8427c478bd9Sstevel@tonic-gate iaparmsp->ia_mode = IA_SET_INTERACTIVE;
8437c478bd9Sstevel@tonic-gate else
8447c478bd9Sstevel@tonic-gate iaparmsp->ia_mode = IA_INTERACTIVE_OFF;
8457c478bd9Sstevel@tonic-gate }
8467c478bd9Sstevel@tonic-gate
8477c478bd9Sstevel@tonic-gate
8487c478bd9Sstevel@tonic-gate /*
8497c478bd9Sstevel@tonic-gate * Check the validity of the time-sharing parameters in the buffer
8507c478bd9Sstevel@tonic-gate * pointed to by tsparmsp.
8517c478bd9Sstevel@tonic-gate * ts_parmsin() is called for TS threads, and ia_parmsin() is called
8527c478bd9Sstevel@tonic-gate * for IA threads.
8537c478bd9Sstevel@tonic-gate */
8547c478bd9Sstevel@tonic-gate static int
ts_parmsin(void * parmsp)8557c478bd9Sstevel@tonic-gate ts_parmsin(void *parmsp)
8567c478bd9Sstevel@tonic-gate {
8577c478bd9Sstevel@tonic-gate tsparms_t *tsparmsp = (tsparms_t *)parmsp;
8587c478bd9Sstevel@tonic-gate /*
8597c478bd9Sstevel@tonic-gate * Check validity of parameters.
8607c478bd9Sstevel@tonic-gate */
8617c478bd9Sstevel@tonic-gate if ((tsparmsp->ts_uprilim > ts_maxupri ||
8627c478bd9Sstevel@tonic-gate tsparmsp->ts_uprilim < -ts_maxupri) &&
8637c478bd9Sstevel@tonic-gate tsparmsp->ts_uprilim != TS_NOCHANGE)
8647c478bd9Sstevel@tonic-gate return (EINVAL);
8657c478bd9Sstevel@tonic-gate
8667c478bd9Sstevel@tonic-gate if ((tsparmsp->ts_upri > ts_maxupri ||
8677c478bd9Sstevel@tonic-gate tsparmsp->ts_upri < -ts_maxupri) &&
8687c478bd9Sstevel@tonic-gate tsparmsp->ts_upri != TS_NOCHANGE)
8697c478bd9Sstevel@tonic-gate return (EINVAL);
8707c478bd9Sstevel@tonic-gate
8717c478bd9Sstevel@tonic-gate return (0);
8727c478bd9Sstevel@tonic-gate }
8737c478bd9Sstevel@tonic-gate
8747c478bd9Sstevel@tonic-gate static int
ia_parmsin(void * parmsp)8757c478bd9Sstevel@tonic-gate ia_parmsin(void *parmsp)
8767c478bd9Sstevel@tonic-gate {
8777c478bd9Sstevel@tonic-gate iaparms_t *iaparmsp = (iaparms_t *)parmsp;
8787c478bd9Sstevel@tonic-gate
8797c478bd9Sstevel@tonic-gate if ((iaparmsp->ia_uprilim > ia_maxupri ||
8807c478bd9Sstevel@tonic-gate iaparmsp->ia_uprilim < -ia_maxupri) &&
8817c478bd9Sstevel@tonic-gate iaparmsp->ia_uprilim != IA_NOCHANGE) {
8827c478bd9Sstevel@tonic-gate return (EINVAL);
8837c478bd9Sstevel@tonic-gate }
8847c478bd9Sstevel@tonic-gate
8857c478bd9Sstevel@tonic-gate if ((iaparmsp->ia_upri > ia_maxupri ||
8867c478bd9Sstevel@tonic-gate iaparmsp->ia_upri < -ia_maxupri) &&
8877c478bd9Sstevel@tonic-gate iaparmsp->ia_upri != IA_NOCHANGE) {
8887c478bd9Sstevel@tonic-gate return (EINVAL);
8897c478bd9Sstevel@tonic-gate }
8907c478bd9Sstevel@tonic-gate
8917c478bd9Sstevel@tonic-gate return (0);
8927c478bd9Sstevel@tonic-gate }
8937c478bd9Sstevel@tonic-gate
8947c478bd9Sstevel@tonic-gate
8957c478bd9Sstevel@tonic-gate /*
8967c478bd9Sstevel@tonic-gate * Check the validity of the time-sharing parameters in the pc_vaparms_t
8977c478bd9Sstevel@tonic-gate * structure vaparmsp and put them in the buffer pointed to by tsparmsp.
8987c478bd9Sstevel@tonic-gate * pc_vaparms_t contains (key, value) pairs of parameter.
8997c478bd9Sstevel@tonic-gate * ts_vaparmsin() is called for TS threads, and ia_vaparmsin() is called
9007c478bd9Sstevel@tonic-gate * for IA threads. ts_vaparmsin() is the variable parameter version of
9017c478bd9Sstevel@tonic-gate * ts_parmsin() and ia_vaparmsin() is the variable parameter version of
9027c478bd9Sstevel@tonic-gate * ia_parmsin().
9037c478bd9Sstevel@tonic-gate */
9047c478bd9Sstevel@tonic-gate static int
ts_vaparmsin(void * parmsp,pc_vaparms_t * vaparmsp)9057c478bd9Sstevel@tonic-gate ts_vaparmsin(void *parmsp, pc_vaparms_t *vaparmsp)
9067c478bd9Sstevel@tonic-gate {
9077c478bd9Sstevel@tonic-gate tsparms_t *tsparmsp = (tsparms_t *)parmsp;
9087c478bd9Sstevel@tonic-gate int priflag = 0;
9097c478bd9Sstevel@tonic-gate int limflag = 0;
9107c478bd9Sstevel@tonic-gate uint_t cnt;
9117c478bd9Sstevel@tonic-gate pc_vaparm_t *vpp = &vaparmsp->pc_parms[0];
9127c478bd9Sstevel@tonic-gate
9137c478bd9Sstevel@tonic-gate
9147c478bd9Sstevel@tonic-gate /*
9157c478bd9Sstevel@tonic-gate * TS_NOCHANGE (-32768) is outside of the range of values for
9167c478bd9Sstevel@tonic-gate * ts_uprilim and ts_upri. If the structure tsparms_t is changed,
9177c478bd9Sstevel@tonic-gate * TS_NOCHANGE should be replaced by a flag word (in the same manner
9187c478bd9Sstevel@tonic-gate * as in rt.c).
9197c478bd9Sstevel@tonic-gate */
9207c478bd9Sstevel@tonic-gate tsparmsp->ts_uprilim = TS_NOCHANGE;
9217c478bd9Sstevel@tonic-gate tsparmsp->ts_upri = TS_NOCHANGE;
9227c478bd9Sstevel@tonic-gate
9237c478bd9Sstevel@tonic-gate /*
9247c478bd9Sstevel@tonic-gate * Get the varargs parameter and check validity of parameters.
9257c478bd9Sstevel@tonic-gate */
9267c478bd9Sstevel@tonic-gate if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
9277c478bd9Sstevel@tonic-gate return (EINVAL);
9287c478bd9Sstevel@tonic-gate
9297c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
9307c478bd9Sstevel@tonic-gate
9317c478bd9Sstevel@tonic-gate switch (vpp->pc_key) {
9327c478bd9Sstevel@tonic-gate case TS_KY_UPRILIM:
9337c478bd9Sstevel@tonic-gate if (limflag++)
9347c478bd9Sstevel@tonic-gate return (EINVAL);
9357c478bd9Sstevel@tonic-gate tsparmsp->ts_uprilim = (pri_t)vpp->pc_parm;
9367c478bd9Sstevel@tonic-gate if (tsparmsp->ts_uprilim > ts_maxupri ||
9377c478bd9Sstevel@tonic-gate tsparmsp->ts_uprilim < -ts_maxupri)
9387c478bd9Sstevel@tonic-gate return (EINVAL);
9397c478bd9Sstevel@tonic-gate break;
9407c478bd9Sstevel@tonic-gate
9417c478bd9Sstevel@tonic-gate case TS_KY_UPRI:
9427c478bd9Sstevel@tonic-gate if (priflag++)
9437c478bd9Sstevel@tonic-gate return (EINVAL);
9447c478bd9Sstevel@tonic-gate tsparmsp->ts_upri = (pri_t)vpp->pc_parm;
9457c478bd9Sstevel@tonic-gate if (tsparmsp->ts_upri > ts_maxupri ||
9467c478bd9Sstevel@tonic-gate tsparmsp->ts_upri < -ts_maxupri)
9477c478bd9Sstevel@tonic-gate return (EINVAL);
9487c478bd9Sstevel@tonic-gate break;
9497c478bd9Sstevel@tonic-gate
9507c478bd9Sstevel@tonic-gate default:
9517c478bd9Sstevel@tonic-gate return (EINVAL);
9527c478bd9Sstevel@tonic-gate }
9537c478bd9Sstevel@tonic-gate }
9547c478bd9Sstevel@tonic-gate
9557c478bd9Sstevel@tonic-gate if (vaparmsp->pc_vaparmscnt == 0) {
9567c478bd9Sstevel@tonic-gate /*
9577c478bd9Sstevel@tonic-gate * Use default parameters.
9587c478bd9Sstevel@tonic-gate */
9597c478bd9Sstevel@tonic-gate tsparmsp->ts_upri = tsparmsp->ts_uprilim = 0;
9607c478bd9Sstevel@tonic-gate }
9617c478bd9Sstevel@tonic-gate
9627c478bd9Sstevel@tonic-gate return (0);
9637c478bd9Sstevel@tonic-gate }
9647c478bd9Sstevel@tonic-gate
9657c478bd9Sstevel@tonic-gate static int
ia_vaparmsin(void * parmsp,pc_vaparms_t * vaparmsp)9667c478bd9Sstevel@tonic-gate ia_vaparmsin(void *parmsp, pc_vaparms_t *vaparmsp)
9677c478bd9Sstevel@tonic-gate {
9687c478bd9Sstevel@tonic-gate iaparms_t *iaparmsp = (iaparms_t *)parmsp;
9697c478bd9Sstevel@tonic-gate int priflag = 0;
9707c478bd9Sstevel@tonic-gate int limflag = 0;
9717c478bd9Sstevel@tonic-gate int mflag = 0;
9727c478bd9Sstevel@tonic-gate uint_t cnt;
9737c478bd9Sstevel@tonic-gate pc_vaparm_t *vpp = &vaparmsp->pc_parms[0];
9747c478bd9Sstevel@tonic-gate
9757c478bd9Sstevel@tonic-gate /*
9767c478bd9Sstevel@tonic-gate * IA_NOCHANGE (-32768) is outside of the range of values for
9777c478bd9Sstevel@tonic-gate * ia_uprilim, ia_upri and ia_mode. If the structure iaparms_t is
9787c478bd9Sstevel@tonic-gate * changed, IA_NOCHANGE should be replaced by a flag word (in the
9797c478bd9Sstevel@tonic-gate * same manner as in rt.c).
9807c478bd9Sstevel@tonic-gate */
9817c478bd9Sstevel@tonic-gate iaparmsp->ia_uprilim = IA_NOCHANGE;
9827c478bd9Sstevel@tonic-gate iaparmsp->ia_upri = IA_NOCHANGE;
9837c478bd9Sstevel@tonic-gate iaparmsp->ia_mode = IA_NOCHANGE;
9847c478bd9Sstevel@tonic-gate
9857c478bd9Sstevel@tonic-gate /*
9867c478bd9Sstevel@tonic-gate * Get the varargs parameter and check validity of parameters.
9877c478bd9Sstevel@tonic-gate */
9887c478bd9Sstevel@tonic-gate if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
9897c478bd9Sstevel@tonic-gate return (EINVAL);
9907c478bd9Sstevel@tonic-gate
9917c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
9927c478bd9Sstevel@tonic-gate
9937c478bd9Sstevel@tonic-gate switch (vpp->pc_key) {
9947c478bd9Sstevel@tonic-gate case IA_KY_UPRILIM:
9957c478bd9Sstevel@tonic-gate if (limflag++)
9967c478bd9Sstevel@tonic-gate return (EINVAL);
9977c478bd9Sstevel@tonic-gate iaparmsp->ia_uprilim = (pri_t)vpp->pc_parm;
9987c478bd9Sstevel@tonic-gate if (iaparmsp->ia_uprilim > ia_maxupri ||
9997c478bd9Sstevel@tonic-gate iaparmsp->ia_uprilim < -ia_maxupri)
10007c478bd9Sstevel@tonic-gate return (EINVAL);
10017c478bd9Sstevel@tonic-gate break;
10027c478bd9Sstevel@tonic-gate
10037c478bd9Sstevel@tonic-gate case IA_KY_UPRI:
10047c478bd9Sstevel@tonic-gate if (priflag++)
10057c478bd9Sstevel@tonic-gate return (EINVAL);
10067c478bd9Sstevel@tonic-gate iaparmsp->ia_upri = (pri_t)vpp->pc_parm;
10077c478bd9Sstevel@tonic-gate if (iaparmsp->ia_upri > ia_maxupri ||
10087c478bd9Sstevel@tonic-gate iaparmsp->ia_upri < -ia_maxupri)
10097c478bd9Sstevel@tonic-gate return (EINVAL);
10107c478bd9Sstevel@tonic-gate break;
10117c478bd9Sstevel@tonic-gate
10127c478bd9Sstevel@tonic-gate case IA_KY_MODE:
10137c478bd9Sstevel@tonic-gate if (mflag++)
10147c478bd9Sstevel@tonic-gate return (EINVAL);
10157c478bd9Sstevel@tonic-gate iaparmsp->ia_mode = (int)vpp->pc_parm;
10167c478bd9Sstevel@tonic-gate if (iaparmsp->ia_mode != IA_SET_INTERACTIVE &&
10177c478bd9Sstevel@tonic-gate iaparmsp->ia_mode != IA_INTERACTIVE_OFF)
10187c478bd9Sstevel@tonic-gate return (EINVAL);
10197c478bd9Sstevel@tonic-gate break;
10207c478bd9Sstevel@tonic-gate
10217c478bd9Sstevel@tonic-gate default:
10227c478bd9Sstevel@tonic-gate return (EINVAL);
10237c478bd9Sstevel@tonic-gate }
10247c478bd9Sstevel@tonic-gate }
10257c478bd9Sstevel@tonic-gate
10267c478bd9Sstevel@tonic-gate if (vaparmsp->pc_vaparmscnt == 0) {
10277c478bd9Sstevel@tonic-gate /*
10287c478bd9Sstevel@tonic-gate * Use default parameters.
10297c478bd9Sstevel@tonic-gate */
10307c478bd9Sstevel@tonic-gate iaparmsp->ia_upri = iaparmsp->ia_uprilim = 0;
10317c478bd9Sstevel@tonic-gate iaparmsp->ia_mode = IA_SET_INTERACTIVE;
10327c478bd9Sstevel@tonic-gate }
10337c478bd9Sstevel@tonic-gate
10347c478bd9Sstevel@tonic-gate return (0);
10357c478bd9Sstevel@tonic-gate }
10367c478bd9Sstevel@tonic-gate
10377c478bd9Sstevel@tonic-gate /*
10387c478bd9Sstevel@tonic-gate * Nothing to do here but return success.
10397c478bd9Sstevel@tonic-gate */
10407c478bd9Sstevel@tonic-gate /* ARGSUSED */
10417c478bd9Sstevel@tonic-gate static int
ts_parmsout(void * parmsp,pc_vaparms_t * vaparmsp)10427c478bd9Sstevel@tonic-gate ts_parmsout(void *parmsp, pc_vaparms_t *vaparmsp)
10437c478bd9Sstevel@tonic-gate {
10447c478bd9Sstevel@tonic-gate return (0);
10457c478bd9Sstevel@tonic-gate }
10467c478bd9Sstevel@tonic-gate
10477c478bd9Sstevel@tonic-gate
10487c478bd9Sstevel@tonic-gate /*
10497c478bd9Sstevel@tonic-gate * Copy all selected time-sharing class parameters to the user.
10507c478bd9Sstevel@tonic-gate * The parameters are specified by a key.
10517c478bd9Sstevel@tonic-gate */
10527c478bd9Sstevel@tonic-gate static int
ts_vaparmsout(void * prmsp,pc_vaparms_t * vaparmsp)10537c478bd9Sstevel@tonic-gate ts_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp)
10547c478bd9Sstevel@tonic-gate {
10557c478bd9Sstevel@tonic-gate tsparms_t *tsprmsp = (tsparms_t *)prmsp;
10567c478bd9Sstevel@tonic-gate int priflag = 0;
10577c478bd9Sstevel@tonic-gate int limflag = 0;
10587c478bd9Sstevel@tonic-gate uint_t cnt;
10597c478bd9Sstevel@tonic-gate pc_vaparm_t *vpp = &vaparmsp->pc_parms[0];
10607c478bd9Sstevel@tonic-gate
10617c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&curproc->p_lock));
10627c478bd9Sstevel@tonic-gate
10637c478bd9Sstevel@tonic-gate if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
10647c478bd9Sstevel@tonic-gate return (EINVAL);
10657c478bd9Sstevel@tonic-gate
10667c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
10677c478bd9Sstevel@tonic-gate
10687c478bd9Sstevel@tonic-gate switch (vpp->pc_key) {
10697c478bd9Sstevel@tonic-gate case TS_KY_UPRILIM:
10707c478bd9Sstevel@tonic-gate if (limflag++)
10717c478bd9Sstevel@tonic-gate return (EINVAL);
10727c478bd9Sstevel@tonic-gate if (copyout(&tsprmsp->ts_uprilim,
10737c478bd9Sstevel@tonic-gate (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
10747c478bd9Sstevel@tonic-gate return (EFAULT);
10757c478bd9Sstevel@tonic-gate break;
10767c478bd9Sstevel@tonic-gate
10777c478bd9Sstevel@tonic-gate case TS_KY_UPRI:
10787c478bd9Sstevel@tonic-gate if (priflag++)
10797c478bd9Sstevel@tonic-gate return (EINVAL);
10807c478bd9Sstevel@tonic-gate if (copyout(&tsprmsp->ts_upri,
10817c478bd9Sstevel@tonic-gate (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
10827c478bd9Sstevel@tonic-gate return (EFAULT);
10837c478bd9Sstevel@tonic-gate break;
10847c478bd9Sstevel@tonic-gate
10857c478bd9Sstevel@tonic-gate default:
10867c478bd9Sstevel@tonic-gate return (EINVAL);
10877c478bd9Sstevel@tonic-gate }
10887c478bd9Sstevel@tonic-gate }
10897c478bd9Sstevel@tonic-gate
10907c478bd9Sstevel@tonic-gate return (0);
10917c478bd9Sstevel@tonic-gate }
10927c478bd9Sstevel@tonic-gate
10937c478bd9Sstevel@tonic-gate
10947c478bd9Sstevel@tonic-gate /*
10957c478bd9Sstevel@tonic-gate * Copy all selected interactive class parameters to the user.
10967c478bd9Sstevel@tonic-gate * The parameters are specified by a key.
10977c478bd9Sstevel@tonic-gate */
10987c478bd9Sstevel@tonic-gate static int
ia_vaparmsout(void * prmsp,pc_vaparms_t * vaparmsp)10997c478bd9Sstevel@tonic-gate ia_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp)
11007c478bd9Sstevel@tonic-gate {
11017c478bd9Sstevel@tonic-gate iaparms_t *iaprmsp = (iaparms_t *)prmsp;
11027c478bd9Sstevel@tonic-gate int priflag = 0;
11037c478bd9Sstevel@tonic-gate int limflag = 0;
11047c478bd9Sstevel@tonic-gate int mflag = 0;
11057c478bd9Sstevel@tonic-gate uint_t cnt;
11067c478bd9Sstevel@tonic-gate pc_vaparm_t *vpp = &vaparmsp->pc_parms[0];
11077c478bd9Sstevel@tonic-gate
11087c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&curproc->p_lock));
11097c478bd9Sstevel@tonic-gate
11107c478bd9Sstevel@tonic-gate if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT)
11117c478bd9Sstevel@tonic-gate return (EINVAL);
11127c478bd9Sstevel@tonic-gate
11137c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) {
11147c478bd9Sstevel@tonic-gate
11157c478bd9Sstevel@tonic-gate switch (vpp->pc_key) {
11167c478bd9Sstevel@tonic-gate case IA_KY_UPRILIM:
11177c478bd9Sstevel@tonic-gate if (limflag++)
11187c478bd9Sstevel@tonic-gate return (EINVAL);
11197c478bd9Sstevel@tonic-gate if (copyout(&iaprmsp->ia_uprilim,
11207c478bd9Sstevel@tonic-gate (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
11217c478bd9Sstevel@tonic-gate return (EFAULT);
11227c478bd9Sstevel@tonic-gate break;
11237c478bd9Sstevel@tonic-gate
11247c478bd9Sstevel@tonic-gate case IA_KY_UPRI:
11257c478bd9Sstevel@tonic-gate if (priflag++)
11267c478bd9Sstevel@tonic-gate return (EINVAL);
11277c478bd9Sstevel@tonic-gate if (copyout(&iaprmsp->ia_upri,
11287c478bd9Sstevel@tonic-gate (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t)))
11297c478bd9Sstevel@tonic-gate return (EFAULT);
11307c478bd9Sstevel@tonic-gate break;
11317c478bd9Sstevel@tonic-gate
11327c478bd9Sstevel@tonic-gate case IA_KY_MODE:
11337c478bd9Sstevel@tonic-gate if (mflag++)
11347c478bd9Sstevel@tonic-gate return (EINVAL);
11357c478bd9Sstevel@tonic-gate if (copyout(&iaprmsp->ia_mode,
11367c478bd9Sstevel@tonic-gate (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (int)))
11377c478bd9Sstevel@tonic-gate return (EFAULT);
11387c478bd9Sstevel@tonic-gate break;
11397c478bd9Sstevel@tonic-gate
11407c478bd9Sstevel@tonic-gate default:
11417c478bd9Sstevel@tonic-gate return (EINVAL);
11427c478bd9Sstevel@tonic-gate }
11437c478bd9Sstevel@tonic-gate }
11447c478bd9Sstevel@tonic-gate return (0);
11457c478bd9Sstevel@tonic-gate }
11467c478bd9Sstevel@tonic-gate
11477c478bd9Sstevel@tonic-gate
11487c478bd9Sstevel@tonic-gate /*
11497c478bd9Sstevel@tonic-gate * Set the scheduling parameters of the thread pointed to by tsprocp
11507c478bd9Sstevel@tonic-gate * to those specified in the buffer pointed to by tsparmsp.
11517c478bd9Sstevel@tonic-gate * ts_parmsset() is called for TS threads, and ia_parmsset() is
11527c478bd9Sstevel@tonic-gate * called for IA threads.
11537c478bd9Sstevel@tonic-gate */
11547c478bd9Sstevel@tonic-gate /* ARGSUSED */
11557c478bd9Sstevel@tonic-gate static int
ts_parmsset(kthread_t * tx,void * parmsp,id_t reqpcid,cred_t * reqpcredp)11567c478bd9Sstevel@tonic-gate ts_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp)
11577c478bd9Sstevel@tonic-gate {
11587c478bd9Sstevel@tonic-gate char nice;
11597c478bd9Sstevel@tonic-gate pri_t reqtsuprilim;
11607c478bd9Sstevel@tonic-gate pri_t reqtsupri;
11617c478bd9Sstevel@tonic-gate tsparms_t *tsparmsp = (tsparms_t *)parmsp;
11627c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)tx->t_cldata;
11637c478bd9Sstevel@tonic-gate
11647c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&(ttoproc(tx))->p_lock));
11657c478bd9Sstevel@tonic-gate
11667c478bd9Sstevel@tonic-gate if (tsparmsp->ts_uprilim == TS_NOCHANGE)
11677c478bd9Sstevel@tonic-gate reqtsuprilim = tspp->ts_uprilim;
11687c478bd9Sstevel@tonic-gate else
11697c478bd9Sstevel@tonic-gate reqtsuprilim = tsparmsp->ts_uprilim;
11707c478bd9Sstevel@tonic-gate
11717c478bd9Sstevel@tonic-gate if (tsparmsp->ts_upri == TS_NOCHANGE)
11727c478bd9Sstevel@tonic-gate reqtsupri = tspp->ts_upri;
11737c478bd9Sstevel@tonic-gate else
11747c478bd9Sstevel@tonic-gate reqtsupri = tsparmsp->ts_upri;
11757c478bd9Sstevel@tonic-gate
11767c478bd9Sstevel@tonic-gate /*
11777c478bd9Sstevel@tonic-gate * Make sure the user priority doesn't exceed the upri limit.
11787c478bd9Sstevel@tonic-gate */
11797c478bd9Sstevel@tonic-gate if (reqtsupri > reqtsuprilim)
11807c478bd9Sstevel@tonic-gate reqtsupri = reqtsuprilim;
11817c478bd9Sstevel@tonic-gate
11827c478bd9Sstevel@tonic-gate /*
11837c478bd9Sstevel@tonic-gate * Basic permissions enforced by generic kernel code
11847c478bd9Sstevel@tonic-gate * for all classes require that a thread attempting
11857c478bd9Sstevel@tonic-gate * to change the scheduling parameters of a target
11867c478bd9Sstevel@tonic-gate * thread be privileged or have a real or effective
11877c478bd9Sstevel@tonic-gate * UID matching that of the target thread. We are not
11887c478bd9Sstevel@tonic-gate * called unless these basic permission checks have
11897c478bd9Sstevel@tonic-gate * already passed. The time-sharing class requires in
11907c478bd9Sstevel@tonic-gate * addition that the calling thread be privileged if it
11917c478bd9Sstevel@tonic-gate * is attempting to raise the upri limit above its current
11927c478bd9Sstevel@tonic-gate * value This may have been checked previously but if our
11937c478bd9Sstevel@tonic-gate * caller passed us a non-NULL credential pointer we assume
11947c478bd9Sstevel@tonic-gate * it hasn't and we check it here.
11957c478bd9Sstevel@tonic-gate */
11967c478bd9Sstevel@tonic-gate if (reqpcredp != NULL &&
11977c478bd9Sstevel@tonic-gate reqtsuprilim > tspp->ts_uprilim &&
119824d819e6SJerry Jelinek secpolicy_raisepriority(reqpcredp) != 0)
11997c478bd9Sstevel@tonic-gate return (EPERM);
12007c478bd9Sstevel@tonic-gate
12017c478bd9Sstevel@tonic-gate /*
12027c478bd9Sstevel@tonic-gate * Set ts_nice to the nice value corresponding to the user
12037c478bd9Sstevel@tonic-gate * priority we are setting. Note that setting the nice field
12047c478bd9Sstevel@tonic-gate * of the parameter struct won't affect upri or nice.
12057c478bd9Sstevel@tonic-gate */
12067c478bd9Sstevel@tonic-gate nice = NZERO - (reqtsupri * NZERO) / ts_maxupri;
12077c478bd9Sstevel@tonic-gate if (nice >= 2 * NZERO)
12087c478bd9Sstevel@tonic-gate nice = 2 * NZERO - 1;
12097c478bd9Sstevel@tonic-gate
12107c478bd9Sstevel@tonic-gate thread_lock(tx);
12117c478bd9Sstevel@tonic-gate
12127c478bd9Sstevel@tonic-gate tspp->ts_uprilim = reqtsuprilim;
12137c478bd9Sstevel@tonic-gate tspp->ts_upri = reqtsupri;
12147c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
12157c478bd9Sstevel@tonic-gate tspp->ts_nice = nice;
12167c478bd9Sstevel@tonic-gate
12177c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
12187c478bd9Sstevel@tonic-gate ts_change_priority(tx, tspp);
12197c478bd9Sstevel@tonic-gate thread_unlock(tx);
12207c478bd9Sstevel@tonic-gate return (0);
12217c478bd9Sstevel@tonic-gate }
12227c478bd9Sstevel@tonic-gate
12237c478bd9Sstevel@tonic-gate
12247c478bd9Sstevel@tonic-gate static int
ia_parmsset(kthread_t * tx,void * parmsp,id_t reqpcid,cred_t * reqpcredp)12257c478bd9Sstevel@tonic-gate ia_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp)
12267c478bd9Sstevel@tonic-gate {
12277c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)tx->t_cldata;
12287c478bd9Sstevel@tonic-gate iaparms_t *iaparmsp = (iaparms_t *)parmsp;
12297c478bd9Sstevel@tonic-gate proc_t *p;
12307c478bd9Sstevel@tonic-gate pid_t pid, pgid, sid;
12317c478bd9Sstevel@tonic-gate pid_t on, off;
12326a0b1217SPatrick Mooney struct stdata *stp;
12337c478bd9Sstevel@tonic-gate int sess_held;
12347c478bd9Sstevel@tonic-gate
12357c478bd9Sstevel@tonic-gate /*
12367c478bd9Sstevel@tonic-gate * Handle user priority changes
12377c478bd9Sstevel@tonic-gate */
12387c478bd9Sstevel@tonic-gate if (iaparmsp->ia_mode == IA_NOCHANGE)
12397c478bd9Sstevel@tonic-gate return (ts_parmsset(tx, parmsp, reqpcid, reqpcredp));
12407c478bd9Sstevel@tonic-gate
12417c478bd9Sstevel@tonic-gate /*
12427c478bd9Sstevel@tonic-gate * Check permissions for changing modes.
12437c478bd9Sstevel@tonic-gate */
12447c478bd9Sstevel@tonic-gate
12457c478bd9Sstevel@tonic-gate if (reqpcredp != NULL && !groupmember(IA_gid, reqpcredp) &&
124624d819e6SJerry Jelinek secpolicy_raisepriority(reqpcredp) != 0) {
12477c478bd9Sstevel@tonic-gate /*
12487c478bd9Sstevel@tonic-gate * Silently fail in case this is just a priocntl
12497c478bd9Sstevel@tonic-gate * call with upri and uprilim set to IA_NOCHANGE.
12507c478bd9Sstevel@tonic-gate */
12517c478bd9Sstevel@tonic-gate return (0);
12527c478bd9Sstevel@tonic-gate }
12537c478bd9Sstevel@tonic-gate
12547c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock));
12557c478bd9Sstevel@tonic-gate if ((p = ttoproc(tx)) == NULL) {
12567c478bd9Sstevel@tonic-gate return (0);
12577c478bd9Sstevel@tonic-gate }
12587c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock));
12597c478bd9Sstevel@tonic-gate if (p->p_stat == SIDL) {
12607c478bd9Sstevel@tonic-gate return (0);
12617c478bd9Sstevel@tonic-gate }
12627c478bd9Sstevel@tonic-gate pid = p->p_pid;
12637c478bd9Sstevel@tonic-gate sid = p->p_sessp->s_sid;
12647c478bd9Sstevel@tonic-gate pgid = p->p_pgrp;
12657c478bd9Sstevel@tonic-gate if (iaparmsp->ia_mode == IA_SET_INTERACTIVE) {
12667c478bd9Sstevel@tonic-gate /*
12677c478bd9Sstevel@tonic-gate * session leaders must be turned on now so all processes
12687c478bd9Sstevel@tonic-gate * in the group controlling the tty will be turned on or off.
12697c478bd9Sstevel@tonic-gate * if the ia_mode is off for the session leader,
12707c478bd9Sstevel@tonic-gate * ia_set_process_group will return without setting the
12717c478bd9Sstevel@tonic-gate * processes in the group controlling the tty on.
12727c478bd9Sstevel@tonic-gate */
12737c478bd9Sstevel@tonic-gate thread_lock(tx);
12747c478bd9Sstevel@tonic-gate tspp->ts_flags |= TSIASET;
12757c478bd9Sstevel@tonic-gate thread_unlock(tx);
12767c478bd9Sstevel@tonic-gate }
12779acbbeafSnn mutex_enter(&p->p_sessp->s_lock);
12787c478bd9Sstevel@tonic-gate sess_held = 1;
12797c478bd9Sstevel@tonic-gate if ((pid == sid) && (p->p_sessp->s_vp != NULL) &&
12807c478bd9Sstevel@tonic-gate ((stp = p->p_sessp->s_vp->v_stream) != NULL)) {
12817c478bd9Sstevel@tonic-gate if ((stp->sd_pgidp != NULL) && (stp->sd_sidp != NULL)) {
12827c478bd9Sstevel@tonic-gate pgid = stp->sd_pgidp->pid_id;
12837c478bd9Sstevel@tonic-gate sess_held = 0;
12849acbbeafSnn mutex_exit(&p->p_sessp->s_lock);
12857c478bd9Sstevel@tonic-gate if (iaparmsp->ia_mode ==
12867c478bd9Sstevel@tonic-gate IA_SET_INTERACTIVE) {
12877c478bd9Sstevel@tonic-gate off = 0;
12887c478bd9Sstevel@tonic-gate on = pgid;
12897c478bd9Sstevel@tonic-gate } else {
12907c478bd9Sstevel@tonic-gate off = pgid;
12917c478bd9Sstevel@tonic-gate on = 0;
12927c478bd9Sstevel@tonic-gate }
12937c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_IA, TR_ACTIVE_CHAIN,
12947c478bd9Sstevel@tonic-gate "active chain:pid %d gid %d %p",
12957c478bd9Sstevel@tonic-gate pid, pgid, p);
12967c478bd9Sstevel@tonic-gate ia_set_process_group(sid, off, on);
12977c478bd9Sstevel@tonic-gate }
12987c478bd9Sstevel@tonic-gate }
12997c478bd9Sstevel@tonic-gate if (sess_held)
13009acbbeafSnn mutex_exit(&p->p_sessp->s_lock);
13017c478bd9Sstevel@tonic-gate
13027c478bd9Sstevel@tonic-gate thread_lock(tx);
13037c478bd9Sstevel@tonic-gate
13047c478bd9Sstevel@tonic-gate if (iaparmsp->ia_mode == IA_SET_INTERACTIVE) {
13057c478bd9Sstevel@tonic-gate tspp->ts_flags |= TSIASET;
13067c478bd9Sstevel@tonic-gate tspp->ts_boost = ia_boost;
13077c478bd9Sstevel@tonic-gate } else {
13087c478bd9Sstevel@tonic-gate tspp->ts_flags &= ~TSIASET;
13097c478bd9Sstevel@tonic-gate tspp->ts_boost = -ia_boost;
13107c478bd9Sstevel@tonic-gate }
13117c478bd9Sstevel@tonic-gate thread_unlock(tx);
13127c478bd9Sstevel@tonic-gate
13137c478bd9Sstevel@tonic-gate return (ts_parmsset(tx, parmsp, reqpcid, reqpcredp));
13147c478bd9Sstevel@tonic-gate }
13157c478bd9Sstevel@tonic-gate
1316c97ad5cdSakolb static void
ts_exit(kthread_t * t)1317c97ad5cdSakolb ts_exit(kthread_t *t)
1318c97ad5cdSakolb {
1319c97ad5cdSakolb tsproc_t *tspp;
1320c97ad5cdSakolb
1321c97ad5cdSakolb if (CPUCAPS_ON()) {
1322c97ad5cdSakolb /*
1323c97ad5cdSakolb * A thread could be exiting in between clock ticks,
1324c97ad5cdSakolb * so we need to calculate how much CPU time it used
1325c97ad5cdSakolb * since it was charged last time.
13268c34bbb7Sakolb *
13278c34bbb7Sakolb * CPU caps are not enforced on exiting processes - it is
13288c34bbb7Sakolb * usually desirable to exit as soon as possible to free
13298c34bbb7Sakolb * resources.
1330c97ad5cdSakolb */
1331c97ad5cdSakolb thread_lock(t);
1332c97ad5cdSakolb tspp = (tsproc_t *)t->t_cldata;
1333c97ad5cdSakolb (void) cpucaps_charge(t, &tspp->ts_caps, CPUCAPS_CHARGE_ONLY);
1334c97ad5cdSakolb thread_unlock(t);
1335c97ad5cdSakolb }
1336c97ad5cdSakolb }
1337c97ad5cdSakolb
13387c478bd9Sstevel@tonic-gate /*
13397c478bd9Sstevel@tonic-gate * Return the global scheduling priority that would be assigned
13407c478bd9Sstevel@tonic-gate * to a thread entering the time-sharing class with the ts_upri.
13417c478bd9Sstevel@tonic-gate */
13427c478bd9Sstevel@tonic-gate static pri_t
ts_globpri(kthread_t * t)13437c478bd9Sstevel@tonic-gate ts_globpri(kthread_t *t)
13447c478bd9Sstevel@tonic-gate {
13457c478bd9Sstevel@tonic-gate tsproc_t *tspp;
13467c478bd9Sstevel@tonic-gate pri_t tspri;
13477c478bd9Sstevel@tonic-gate
13487c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock));
13497c478bd9Sstevel@tonic-gate tspp = (tsproc_t *)t->t_cldata;
13507c478bd9Sstevel@tonic-gate tspri = tsmedumdpri + tspp->ts_upri;
13517c478bd9Sstevel@tonic-gate if (tspri > ts_maxumdpri)
13527c478bd9Sstevel@tonic-gate tspri = ts_maxumdpri;
13537c478bd9Sstevel@tonic-gate else if (tspri < 0)
13547c478bd9Sstevel@tonic-gate tspri = 0;
13557c478bd9Sstevel@tonic-gate return (ts_dptbl[tspri].ts_globpri);
13567c478bd9Sstevel@tonic-gate }
13577c478bd9Sstevel@tonic-gate
13587c478bd9Sstevel@tonic-gate /*
13597c478bd9Sstevel@tonic-gate * Arrange for thread to be placed in appropriate location
13607c478bd9Sstevel@tonic-gate * on dispatcher queue.
13617c478bd9Sstevel@tonic-gate *
13627c478bd9Sstevel@tonic-gate * This is called with the current thread in TS_ONPROC and locked.
13637c478bd9Sstevel@tonic-gate */
13647c478bd9Sstevel@tonic-gate static void
ts_preempt(kthread_t * t)13657c478bd9Sstevel@tonic-gate ts_preempt(kthread_t *t)
13667c478bd9Sstevel@tonic-gate {
13677c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
13686a0b1217SPatrick Mooney klwp_t *lwp = ttolwp(t);
13697c478bd9Sstevel@tonic-gate pri_t oldpri = t->t_pri;
13707c478bd9Sstevel@tonic-gate
13717c478bd9Sstevel@tonic-gate ASSERT(t == curthread);
13727c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(curthread));
13737c478bd9Sstevel@tonic-gate
13747c478bd9Sstevel@tonic-gate /*
1375c97ad5cdSakolb * This thread may be placed on wait queue by CPU Caps. In this case we
1376c97ad5cdSakolb * do not need to do anything until it is removed from the wait queue.
1377c97ad5cdSakolb */
1378c97ad5cdSakolb if (CPUCAPS_ON()) {
13798c34bbb7Sakolb (void) cpucaps_charge(t, &tspp->ts_caps,
13808c34bbb7Sakolb CPUCAPS_CHARGE_ENFORCE);
13816a0b1217SPatrick Mooney if (CPUCAPS_ENFORCE(t))
1382c97ad5cdSakolb return;
1383c97ad5cdSakolb }
1384c97ad5cdSakolb
1385c97ad5cdSakolb /*
1386c97ad5cdSakolb * If thread got preempted in the user-land then we know
1387c97ad5cdSakolb * it isn't holding any locks. Mark it as swappable.
13887c478bd9Sstevel@tonic-gate */
13897c478bd9Sstevel@tonic-gate ASSERT(t->t_schedflag & TS_DONT_SWAP);
13907c478bd9Sstevel@tonic-gate if (lwp != NULL && lwp->lwp_state == LWP_USER)
13917c478bd9Sstevel@tonic-gate t->t_schedflag &= ~TS_DONT_SWAP;
13927c478bd9Sstevel@tonic-gate
13937c478bd9Sstevel@tonic-gate /*
13947c478bd9Sstevel@tonic-gate * Check to see if we're doing "preemption control" here. If
13957c478bd9Sstevel@tonic-gate * we are, and if the user has requested that this thread not
13967c478bd9Sstevel@tonic-gate * be preempted, and if preemptions haven't been put off for
13977c478bd9Sstevel@tonic-gate * too long, let the preemption happen here but try to make
13987c478bd9Sstevel@tonic-gate * sure the thread is rescheduled as soon as possible. We do
13997c478bd9Sstevel@tonic-gate * this by putting it on the front of the highest priority run
14007c478bd9Sstevel@tonic-gate * queue in the TS class. If the preemption has been put off
14017c478bd9Sstevel@tonic-gate * for too long, clear the "nopreempt" bit and let the thread
14027c478bd9Sstevel@tonic-gate * be preempted.
14037c478bd9Sstevel@tonic-gate */
14047c478bd9Sstevel@tonic-gate if (t->t_schedctl && schedctl_get_nopreempt(t)) {
14057c478bd9Sstevel@tonic-gate if (tspp->ts_timeleft > -SC_MAX_TICKS) {
14067c478bd9Sstevel@tonic-gate DTRACE_SCHED1(schedctl__nopreempt, kthread_t *, t);
14076a0b1217SPatrick Mooney /*
14086a0b1217SPatrick Mooney * If not already remembered, remember current
14096a0b1217SPatrick Mooney * priority for restoration in ts_yield().
14106a0b1217SPatrick Mooney */
14116a0b1217SPatrick Mooney if (!(tspp->ts_flags & TSRESTORE)) {
14126a0b1217SPatrick Mooney tspp->ts_scpri = t->t_pri;
14136a0b1217SPatrick Mooney tspp->ts_flags |= TSRESTORE;
14147c478bd9Sstevel@tonic-gate }
14156a0b1217SPatrick Mooney THREAD_CHANGE_PRI(t, ts_maxumdpri);
14166a0b1217SPatrick Mooney t->t_schedflag |= TS_DONT_SWAP;
14179ac8606fSraf schedctl_set_yield(t, 1);
14187c478bd9Sstevel@tonic-gate setfrontdq(t);
14197c478bd9Sstevel@tonic-gate goto done;
14207c478bd9Sstevel@tonic-gate } else {
14219ac8606fSraf if (tspp->ts_flags & TSRESTORE) {
14229ac8606fSraf THREAD_CHANGE_PRI(t, tspp->ts_scpri);
14239ac8606fSraf tspp->ts_flags &= ~TSRESTORE;
14249ac8606fSraf }
14257c478bd9Sstevel@tonic-gate schedctl_set_nopreempt(t, 0);
14267c478bd9Sstevel@tonic-gate DTRACE_SCHED1(schedctl__preempt, kthread_t *, t);
14277c478bd9Sstevel@tonic-gate /*
14287c478bd9Sstevel@tonic-gate * Fall through and be preempted below.
14297c478bd9Sstevel@tonic-gate */
14307c478bd9Sstevel@tonic-gate }
14317c478bd9Sstevel@tonic-gate }
14327c478bd9Sstevel@tonic-gate
14336a0b1217SPatrick Mooney if ((tspp->ts_flags & TSBACKQ) != 0) {
14347c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
14357c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
14367c478bd9Sstevel@tonic-gate tspp->ts_flags &= ~TSBACKQ;
14377c478bd9Sstevel@tonic-gate setbackdq(t);
14387c478bd9Sstevel@tonic-gate } else {
1439c97ad5cdSakolb setfrontdq(t);
14407c478bd9Sstevel@tonic-gate }
14417c478bd9Sstevel@tonic-gate
14427c478bd9Sstevel@tonic-gate done:
14437c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_DISP, TR_PREEMPT,
14447c478bd9Sstevel@tonic-gate "preempt:tid %p old pri %d", t, oldpri);
14457c478bd9Sstevel@tonic-gate }
14467c478bd9Sstevel@tonic-gate
14477c478bd9Sstevel@tonic-gate static void
ts_setrun(kthread_t * t)14487c478bd9Sstevel@tonic-gate ts_setrun(kthread_t *t)
14497c478bd9Sstevel@tonic-gate {
14507c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
14517c478bd9Sstevel@tonic-gate
14527c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t)); /* t should be in transition */
14537c478bd9Sstevel@tonic-gate
14547c478bd9Sstevel@tonic-gate if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
14557c478bd9Sstevel@tonic-gate tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
14567c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
14577c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
14587c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
14596a0b1217SPatrick Mooney THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
14606a0b1217SPatrick Mooney ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
14617c478bd9Sstevel@tonic-gate }
14627c478bd9Sstevel@tonic-gate
14637c478bd9Sstevel@tonic-gate tspp->ts_flags &= ~TSBACKQ;
14647c478bd9Sstevel@tonic-gate
14657c478bd9Sstevel@tonic-gate if (tspp->ts_flags & TSIA) {
14667c478bd9Sstevel@tonic-gate if (tspp->ts_flags & TSIASET)
14677c478bd9Sstevel@tonic-gate setfrontdq(t);
14687c478bd9Sstevel@tonic-gate else
14697c478bd9Sstevel@tonic-gate setbackdq(t);
14707c478bd9Sstevel@tonic-gate } else {
1471d3d50737SRafael Vanoni if (t->t_disp_time != ddi_get_lbolt())
14727c478bd9Sstevel@tonic-gate setbackdq(t);
14737c478bd9Sstevel@tonic-gate else
14747c478bd9Sstevel@tonic-gate setfrontdq(t);
14757c478bd9Sstevel@tonic-gate }
14767c478bd9Sstevel@tonic-gate }
14777c478bd9Sstevel@tonic-gate
14787c478bd9Sstevel@tonic-gate
14797c478bd9Sstevel@tonic-gate /*
14806a0b1217SPatrick Mooney * Prepare thread for sleep.
14817c478bd9Sstevel@tonic-gate */
14827c478bd9Sstevel@tonic-gate static void
ts_sleep(kthread_t * t)14837c478bd9Sstevel@tonic-gate ts_sleep(kthread_t *t)
14847c478bd9Sstevel@tonic-gate {
14857c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
14867c478bd9Sstevel@tonic-gate pri_t old_pri = t->t_pri;
14877c478bd9Sstevel@tonic-gate
14887c478bd9Sstevel@tonic-gate ASSERT(t == curthread);
14897c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
14907c478bd9Sstevel@tonic-gate
1491c97ad5cdSakolb /*
1492c97ad5cdSakolb * Account for time spent on CPU before going to sleep.
1493c97ad5cdSakolb */
14948c34bbb7Sakolb (void) CPUCAPS_CHARGE(t, &tspp->ts_caps, CPUCAPS_CHARGE_ENFORCE);
1495c97ad5cdSakolb
14966a0b1217SPatrick Mooney if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
14977c478bd9Sstevel@tonic-gate tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
14987c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
14997c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
15007c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
15017c478bd9Sstevel@tonic-gate
15027c478bd9Sstevel@tonic-gate THREAD_CHANGE_PRI(curthread,
15037c478bd9Sstevel@tonic-gate ts_dptbl[tspp->ts_umdpri].ts_globpri);
15047c478bd9Sstevel@tonic-gate ASSERT(curthread->t_pri >= 0 &&
15057c478bd9Sstevel@tonic-gate curthread->t_pri <= ts_maxglobpri);
15067c478bd9Sstevel@tonic-gate
15077c478bd9Sstevel@tonic-gate if (DISP_MUST_SURRENDER(curthread))
15087c478bd9Sstevel@tonic-gate cpu_surrender(curthread);
15097c478bd9Sstevel@tonic-gate }
1510d3d50737SRafael Vanoni t->t_stime = ddi_get_lbolt(); /* time stamp for the swapper */
15117c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_DISP, TR_SLEEP,
15127c478bd9Sstevel@tonic-gate "sleep:tid %p old pri %d", t, old_pri);
15137c478bd9Sstevel@tonic-gate }
15147c478bd9Sstevel@tonic-gate
15157c478bd9Sstevel@tonic-gate
15167c478bd9Sstevel@tonic-gate /*
15177c478bd9Sstevel@tonic-gate * Return Values:
15187c478bd9Sstevel@tonic-gate *
15197c478bd9Sstevel@tonic-gate * -1 if the thread is loaded or is not eligible to be swapped in.
15207c478bd9Sstevel@tonic-gate *
15217c478bd9Sstevel@tonic-gate * effective priority of the specified thread based on swapout time
15227c478bd9Sstevel@tonic-gate * and size of process (epri >= 0 , epri <= SHRT_MAX).
15237c478bd9Sstevel@tonic-gate */
15247c478bd9Sstevel@tonic-gate /* ARGSUSED */
15257c478bd9Sstevel@tonic-gate static pri_t
ts_swapin(kthread_t * t,int flags)15267c478bd9Sstevel@tonic-gate ts_swapin(kthread_t *t, int flags)
15277c478bd9Sstevel@tonic-gate {
15287c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
15297c478bd9Sstevel@tonic-gate long epri = -1;
15307c478bd9Sstevel@tonic-gate proc_t *pp = ttoproc(t);
15317c478bd9Sstevel@tonic-gate
15327c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
15337c478bd9Sstevel@tonic-gate
15347c478bd9Sstevel@tonic-gate /*
15357c478bd9Sstevel@tonic-gate * We know that pri_t is a short.
15367c478bd9Sstevel@tonic-gate * Be sure not to overrun its range.
15377c478bd9Sstevel@tonic-gate */
15387c478bd9Sstevel@tonic-gate if (t->t_state == TS_RUN && (t->t_schedflag & TS_LOAD) == 0) {
15397c478bd9Sstevel@tonic-gate time_t swapout_time;
15407c478bd9Sstevel@tonic-gate
1541d3d50737SRafael Vanoni swapout_time = (ddi_get_lbolt() - t->t_stime) / hz;
15426a0b1217SPatrick Mooney if (INHERITED(t) || (tspp->ts_flags & TSIASET)) {
15437c478bd9Sstevel@tonic-gate epri = (long)DISP_PRIO(t) + swapout_time;
15446a0b1217SPatrick Mooney } else {
15457c478bd9Sstevel@tonic-gate /*
15467c478bd9Sstevel@tonic-gate * Threads which have been out for a long time,
15477c478bd9Sstevel@tonic-gate * have high user mode priority and are associated
15487c478bd9Sstevel@tonic-gate * with a small address space are more deserving
15497c478bd9Sstevel@tonic-gate */
15507c478bd9Sstevel@tonic-gate epri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
15517c478bd9Sstevel@tonic-gate ASSERT(epri >= 0 && epri <= ts_maxumdpri);
15527c478bd9Sstevel@tonic-gate epri += swapout_time - pp->p_swrss / nz(maxpgio)/2;
15537c478bd9Sstevel@tonic-gate }
15547c478bd9Sstevel@tonic-gate /*
15557c478bd9Sstevel@tonic-gate * Scale epri so SHRT_MAX/2 represents zero priority.
15567c478bd9Sstevel@tonic-gate */
15577c478bd9Sstevel@tonic-gate epri += SHRT_MAX/2;
15587c478bd9Sstevel@tonic-gate if (epri < 0)
15597c478bd9Sstevel@tonic-gate epri = 0;
15607c478bd9Sstevel@tonic-gate else if (epri > SHRT_MAX)
15617c478bd9Sstevel@tonic-gate epri = SHRT_MAX;
15627c478bd9Sstevel@tonic-gate }
15637c478bd9Sstevel@tonic-gate return ((pri_t)epri);
15647c478bd9Sstevel@tonic-gate }
15657c478bd9Sstevel@tonic-gate
15667c478bd9Sstevel@tonic-gate /*
15677c478bd9Sstevel@tonic-gate * Return Values
15687c478bd9Sstevel@tonic-gate * -1 if the thread isn't loaded or is not eligible to be swapped out.
15697c478bd9Sstevel@tonic-gate *
15707c478bd9Sstevel@tonic-gate * effective priority of the specified thread based on if the swapper
15717c478bd9Sstevel@tonic-gate * is in softswap or hardswap mode.
15727c478bd9Sstevel@tonic-gate *
15737c478bd9Sstevel@tonic-gate * Softswap: Return a low effective priority for threads
15747c478bd9Sstevel@tonic-gate * sleeping for more than maxslp secs.
15757c478bd9Sstevel@tonic-gate *
15767c478bd9Sstevel@tonic-gate * Hardswap: Return an effective priority such that threads
15777c478bd9Sstevel@tonic-gate * which have been in memory for a while and are
15787c478bd9Sstevel@tonic-gate * associated with a small address space are swapped
15797c478bd9Sstevel@tonic-gate * in before others.
15807c478bd9Sstevel@tonic-gate *
15817c478bd9Sstevel@tonic-gate * (epri >= 0 , epri <= SHRT_MAX).
15827c478bd9Sstevel@tonic-gate */
15837c478bd9Sstevel@tonic-gate time_t ts_minrun = 2; /* XXX - t_pri becomes 59 within 2 secs */
15847c478bd9Sstevel@tonic-gate time_t ts_minslp = 2; /* min time on sleep queue for hardswap */
15857c478bd9Sstevel@tonic-gate
15867c478bd9Sstevel@tonic-gate static pri_t
ts_swapout(kthread_t * t,int flags)15877c478bd9Sstevel@tonic-gate ts_swapout(kthread_t *t, int flags)
15887c478bd9Sstevel@tonic-gate {
15897c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
15907c478bd9Sstevel@tonic-gate long epri = -1;
15917c478bd9Sstevel@tonic-gate proc_t *pp = ttoproc(t);
15927c478bd9Sstevel@tonic-gate time_t swapin_time;
15937c478bd9Sstevel@tonic-gate
15947c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
15957c478bd9Sstevel@tonic-gate
15966a0b1217SPatrick Mooney if (INHERITED(t) || (tspp->ts_flags & TSIASET) ||
15977c478bd9Sstevel@tonic-gate (t->t_proc_flag & TP_LWPEXIT) ||
1598c97ad5cdSakolb (t->t_state & (TS_ZOMB | TS_FREE | TS_STOPPED |
1599c97ad5cdSakolb TS_ONPROC | TS_WAIT)) ||
16007c478bd9Sstevel@tonic-gate !(t->t_schedflag & TS_LOAD) || !SWAP_OK(t))
16017c478bd9Sstevel@tonic-gate return (-1);
16027c478bd9Sstevel@tonic-gate
16037c478bd9Sstevel@tonic-gate ASSERT(t->t_state & (TS_SLEEP | TS_RUN));
16047c478bd9Sstevel@tonic-gate
16057c478bd9Sstevel@tonic-gate /*
16067c478bd9Sstevel@tonic-gate * We know that pri_t is a short.
16077c478bd9Sstevel@tonic-gate * Be sure not to overrun its range.
16087c478bd9Sstevel@tonic-gate */
1609d3d50737SRafael Vanoni swapin_time = (ddi_get_lbolt() - t->t_stime) / hz;
16107c478bd9Sstevel@tonic-gate if (flags == SOFTSWAP) {
16117c478bd9Sstevel@tonic-gate if (t->t_state == TS_SLEEP && swapin_time > maxslp) {
16127c478bd9Sstevel@tonic-gate epri = 0;
16137c478bd9Sstevel@tonic-gate } else {
16147c478bd9Sstevel@tonic-gate return ((pri_t)epri);
16157c478bd9Sstevel@tonic-gate }
16167c478bd9Sstevel@tonic-gate } else {
16177c478bd9Sstevel@tonic-gate pri_t pri;
16187c478bd9Sstevel@tonic-gate
16197c478bd9Sstevel@tonic-gate if ((t->t_state == TS_SLEEP && swapin_time > ts_minslp) ||
16207c478bd9Sstevel@tonic-gate (t->t_state == TS_RUN && swapin_time > ts_minrun)) {
16217c478bd9Sstevel@tonic-gate pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
16227c478bd9Sstevel@tonic-gate ASSERT(pri >= 0 && pri <= ts_maxumdpri);
16237c478bd9Sstevel@tonic-gate epri = swapin_time -
16247c478bd9Sstevel@tonic-gate (rm_asrss(pp->p_as) / nz(maxpgio)/2) - (long)pri;
16257c478bd9Sstevel@tonic-gate } else {
16267c478bd9Sstevel@tonic-gate return ((pri_t)epri);
16277c478bd9Sstevel@tonic-gate }
16287c478bd9Sstevel@tonic-gate }
16297c478bd9Sstevel@tonic-gate
16307c478bd9Sstevel@tonic-gate /*
16317c478bd9Sstevel@tonic-gate * Scale epri so SHRT_MAX/2 represents zero priority.
16327c478bd9Sstevel@tonic-gate */
16337c478bd9Sstevel@tonic-gate epri += SHRT_MAX/2;
16347c478bd9Sstevel@tonic-gate if (epri < 0)
16357c478bd9Sstevel@tonic-gate epri = 0;
16367c478bd9Sstevel@tonic-gate else if (epri > SHRT_MAX)
16377c478bd9Sstevel@tonic-gate epri = SHRT_MAX;
16387c478bd9Sstevel@tonic-gate
16397c478bd9Sstevel@tonic-gate return ((pri_t)epri);
16407c478bd9Sstevel@tonic-gate }
16417c478bd9Sstevel@tonic-gate
16427c478bd9Sstevel@tonic-gate /*
16437c478bd9Sstevel@tonic-gate * Check for time slice expiration. If time slice has expired
16447c478bd9Sstevel@tonic-gate * move thread to priority specified in tsdptbl for time slice expiration
16457c478bd9Sstevel@tonic-gate * and set runrun to cause preemption.
16467c478bd9Sstevel@tonic-gate */
16477c478bd9Sstevel@tonic-gate static void
ts_tick(kthread_t * t)16487c478bd9Sstevel@tonic-gate ts_tick(kthread_t *t)
16497c478bd9Sstevel@tonic-gate {
16507c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
16517c478bd9Sstevel@tonic-gate klwp_t *lwp;
1652c97ad5cdSakolb boolean_t call_cpu_surrender = B_FALSE;
16537c478bd9Sstevel@tonic-gate pri_t oldpri = t->t_pri;
16547c478bd9Sstevel@tonic-gate
16557c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
16567c478bd9Sstevel@tonic-gate
16577c478bd9Sstevel@tonic-gate thread_lock(t);
1658c97ad5cdSakolb
1659c97ad5cdSakolb /*
1660c97ad5cdSakolb * Keep track of thread's project CPU usage. Note that projects
1661c97ad5cdSakolb * get charged even when threads are running in the kernel.
1662c97ad5cdSakolb */
1663c97ad5cdSakolb if (CPUCAPS_ON()) {
1664c97ad5cdSakolb call_cpu_surrender = cpucaps_charge(t, &tspp->ts_caps,
16656a0b1217SPatrick Mooney CPUCAPS_CHARGE_ENFORCE);
1666c97ad5cdSakolb }
1667c97ad5cdSakolb
16686a0b1217SPatrick Mooney if (--tspp->ts_timeleft <= 0) {
16696a0b1217SPatrick Mooney pri_t new_pri;
16707c478bd9Sstevel@tonic-gate
16716a0b1217SPatrick Mooney /*
16726a0b1217SPatrick Mooney * If we're doing preemption control and trying to avoid
16736a0b1217SPatrick Mooney * preempting this thread, just note that the thread should
16746a0b1217SPatrick Mooney * yield soon and let it keep running (unless it's been a
16756a0b1217SPatrick Mooney * while).
16766a0b1217SPatrick Mooney */
16776a0b1217SPatrick Mooney if (t->t_schedctl && schedctl_get_nopreempt(t)) {
16786a0b1217SPatrick Mooney if (tspp->ts_timeleft > -SC_MAX_TICKS) {
16796a0b1217SPatrick Mooney DTRACE_SCHED1(schedctl__nopreempt,
16806a0b1217SPatrick Mooney kthread_t *, t);
16816a0b1217SPatrick Mooney schedctl_set_yield(t, 1);
16826a0b1217SPatrick Mooney thread_unlock_nopreempt(t);
16836a0b1217SPatrick Mooney return;
16847c478bd9Sstevel@tonic-gate }
16856a0b1217SPatrick Mooney
1686*5405159cSGordon Ross DTRACE_SCHED1(schedctl__failsafe,
1687*5405159cSGordon Ross kthread_t *, t);
16886a0b1217SPatrick Mooney }
16896a0b1217SPatrick Mooney tspp->ts_flags &= ~TSRESTORE;
16906a0b1217SPatrick Mooney tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp;
16916a0b1217SPatrick Mooney TS_NEWUMDPRI(tspp);
16926a0b1217SPatrick Mooney tspp->ts_dispwait = 0;
16936a0b1217SPatrick Mooney new_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
16946a0b1217SPatrick Mooney ASSERT(new_pri >= 0 && new_pri <= ts_maxglobpri);
16956a0b1217SPatrick Mooney /*
16966a0b1217SPatrick Mooney * When the priority of a thread is changed, it may be
16976a0b1217SPatrick Mooney * necessary to adjust its position on a sleep queue or
16986a0b1217SPatrick Mooney * dispatch queue. The function thread_change_pri accomplishes
16996a0b1217SPatrick Mooney * this.
17006a0b1217SPatrick Mooney */
17016a0b1217SPatrick Mooney if (thread_change_pri(t, new_pri, 0)) {
17026a0b1217SPatrick Mooney if ((t->t_schedflag & TS_LOAD) &&
17036a0b1217SPatrick Mooney (lwp = t->t_lwp) &&
17046a0b1217SPatrick Mooney lwp->lwp_state == LWP_USER)
17056a0b1217SPatrick Mooney t->t_schedflag &= ~TS_DONT_SWAP;
17066a0b1217SPatrick Mooney tspp->ts_timeleft =
17076a0b1217SPatrick Mooney ts_dptbl[tspp->ts_cpupri].ts_quantum;
17086a0b1217SPatrick Mooney } else {
1709c97ad5cdSakolb call_cpu_surrender = B_TRUE;
17107c478bd9Sstevel@tonic-gate }
17116a0b1217SPatrick Mooney TRACE_2(TR_FAC_DISP, TR_TICK,
17126a0b1217SPatrick Mooney "tick:tid %p old pri %d", t, oldpri);
17136a0b1217SPatrick Mooney } else if (t->t_state == TS_ONPROC &&
17146a0b1217SPatrick Mooney t->t_pri < t->t_disp_queue->disp_maxrunpri) {
17156a0b1217SPatrick Mooney call_cpu_surrender = B_TRUE;
17167c478bd9Sstevel@tonic-gate }
1717c97ad5cdSakolb
1718c97ad5cdSakolb if (call_cpu_surrender) {
1719c97ad5cdSakolb tspp->ts_flags |= TSBACKQ;
1720c97ad5cdSakolb cpu_surrender(t);
1721c97ad5cdSakolb }
1722c97ad5cdSakolb
17237c478bd9Sstevel@tonic-gate thread_unlock_nopreempt(t); /* clock thread can't be preempted */
17247c478bd9Sstevel@tonic-gate }
17257c478bd9Sstevel@tonic-gate
17267c478bd9Sstevel@tonic-gate
17277c478bd9Sstevel@tonic-gate /*
17286a0b1217SPatrick Mooney * If we are lowering the thread's priority below that of other runnable
17296a0b1217SPatrick Mooney * threads we will normally set runrun via cpu_surrender() to cause preemption.
17307c478bd9Sstevel@tonic-gate */
17317c478bd9Sstevel@tonic-gate static void
ts_trapret(kthread_t * t)17327c478bd9Sstevel@tonic-gate ts_trapret(kthread_t *t)
17337c478bd9Sstevel@tonic-gate {
17347c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)t->t_cldata;
17357c478bd9Sstevel@tonic-gate cpu_t *cp = CPU;
17367c478bd9Sstevel@tonic-gate pri_t old_pri = curthread->t_pri;
17377c478bd9Sstevel@tonic-gate
17387c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
17397c478bd9Sstevel@tonic-gate ASSERT(t == curthread);
17407c478bd9Sstevel@tonic-gate ASSERT(cp->cpu_dispthread == t);
17417c478bd9Sstevel@tonic-gate ASSERT(t->t_state == TS_ONPROC);
17427c478bd9Sstevel@tonic-gate
17437c478bd9Sstevel@tonic-gate if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
17447c478bd9Sstevel@tonic-gate tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
17457c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
17467c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
17477c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
17487c478bd9Sstevel@tonic-gate
17497c478bd9Sstevel@tonic-gate /*
17507c478bd9Sstevel@tonic-gate * If thread has blocked in the kernel (as opposed to
17517c478bd9Sstevel@tonic-gate * being merely preempted), recompute the user mode priority.
17527c478bd9Sstevel@tonic-gate */
17537c478bd9Sstevel@tonic-gate THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
17547c478bd9Sstevel@tonic-gate cp->cpu_dispatch_pri = DISP_PRIO(t);
17557c478bd9Sstevel@tonic-gate ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
17567c478bd9Sstevel@tonic-gate
17577c478bd9Sstevel@tonic-gate if (DISP_MUST_SURRENDER(t))
17587c478bd9Sstevel@tonic-gate cpu_surrender(t);
17597c478bd9Sstevel@tonic-gate }
17607c478bd9Sstevel@tonic-gate
17617c478bd9Sstevel@tonic-gate /*
17626a0b1217SPatrick Mooney * Swapout lwp if the swapper is waiting for this thread to reach a
17636a0b1217SPatrick Mooney * safe point.
17647c478bd9Sstevel@tonic-gate */
17657c478bd9Sstevel@tonic-gate if ((t->t_schedflag & TS_SWAPENQ) && !(tspp->ts_flags & TSIASET)) {
17667c478bd9Sstevel@tonic-gate thread_unlock(t);
17677c478bd9Sstevel@tonic-gate swapout_lwp(ttolwp(t));
17687c478bd9Sstevel@tonic-gate thread_lock(t);
17697c478bd9Sstevel@tonic-gate }
17707c478bd9Sstevel@tonic-gate
17717c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_DISP, TR_TRAPRET,
17727c478bd9Sstevel@tonic-gate "trapret:tid %p old pri %d", t, old_pri);
17737c478bd9Sstevel@tonic-gate }
17747c478bd9Sstevel@tonic-gate
17757c478bd9Sstevel@tonic-gate
17767c478bd9Sstevel@tonic-gate /*
17777c478bd9Sstevel@tonic-gate * Update the ts_dispwait values of all time sharing threads that
17787c478bd9Sstevel@tonic-gate * are currently runnable at a user mode priority and bump the priority
17797c478bd9Sstevel@tonic-gate * if ts_dispwait exceeds ts_maxwait. Called once per second via
17807c478bd9Sstevel@tonic-gate * timeout which we reset here.
17817c478bd9Sstevel@tonic-gate *
17827c478bd9Sstevel@tonic-gate * There are several lists of time sharing threads broken up by a hash on
17837c478bd9Sstevel@tonic-gate * the thread pointer. Each list has its own lock. This avoids blocking
17847c478bd9Sstevel@tonic-gate * all ts_enterclass, ts_fork, and ts_exitclass operations while ts_update
17857c478bd9Sstevel@tonic-gate * runs. ts_update traverses each list in turn.
17867c478bd9Sstevel@tonic-gate *
17877c478bd9Sstevel@tonic-gate * If multiple threads have their priorities updated to the same value,
17887c478bd9Sstevel@tonic-gate * the system implicitly favors the one that is updated first (since it
17897c478bd9Sstevel@tonic-gate * winds up first on the run queue). To avoid this unfairness, the
17907c478bd9Sstevel@tonic-gate * traversal of threads starts at the list indicated by a marker. When
17917c478bd9Sstevel@tonic-gate * threads in more than one list have their priorities updated, the marker
17927c478bd9Sstevel@tonic-gate * is moved. This changes the order the threads will be placed on the run
17937c478bd9Sstevel@tonic-gate * queue the next time ts_update is called and preserves fairness over the
17947c478bd9Sstevel@tonic-gate * long run. The marker doesn't need to be protected by a lock since it's
17957c478bd9Sstevel@tonic-gate * only accessed by ts_update, which is inherently single-threaded (only
17967c478bd9Sstevel@tonic-gate * one instance can be running at a time).
17977c478bd9Sstevel@tonic-gate */
17987c478bd9Sstevel@tonic-gate static void
ts_update(void * arg)17997c478bd9Sstevel@tonic-gate ts_update(void *arg)
18007c478bd9Sstevel@tonic-gate {
18017c478bd9Sstevel@tonic-gate int i;
18027c478bd9Sstevel@tonic-gate int new_marker = -1;
18037c478bd9Sstevel@tonic-gate static int ts_update_marker;
18047c478bd9Sstevel@tonic-gate
18057c478bd9Sstevel@tonic-gate /*
18067c478bd9Sstevel@tonic-gate * Start with the ts_update_marker list, then do the rest.
18077c478bd9Sstevel@tonic-gate */
18087c478bd9Sstevel@tonic-gate i = ts_update_marker;
18097c478bd9Sstevel@tonic-gate do {
18107c478bd9Sstevel@tonic-gate /*
18117c478bd9Sstevel@tonic-gate * If this is the first list after the current marker to
18127c478bd9Sstevel@tonic-gate * have threads with priorities updated, advance the marker
18137c478bd9Sstevel@tonic-gate * to this list for the next time ts_update runs.
18147c478bd9Sstevel@tonic-gate */
18157c478bd9Sstevel@tonic-gate if (ts_update_list(i) && new_marker == -1 &&
18167c478bd9Sstevel@tonic-gate i != ts_update_marker) {
18177c478bd9Sstevel@tonic-gate new_marker = i;
18187c478bd9Sstevel@tonic-gate }
18197c478bd9Sstevel@tonic-gate } while ((i = TS_LIST_NEXT(i)) != ts_update_marker);
18207c478bd9Sstevel@tonic-gate
18217c478bd9Sstevel@tonic-gate /* advance marker for next ts_update call */
18227c478bd9Sstevel@tonic-gate if (new_marker != -1)
18237c478bd9Sstevel@tonic-gate ts_update_marker = new_marker;
18247c478bd9Sstevel@tonic-gate
18257c478bd9Sstevel@tonic-gate (void) timeout(ts_update, arg, hz);
18267c478bd9Sstevel@tonic-gate }
18277c478bd9Sstevel@tonic-gate
18287c478bd9Sstevel@tonic-gate /*
18297c478bd9Sstevel@tonic-gate * Updates priority for a list of threads. Returns 1 if the priority of
18307c478bd9Sstevel@tonic-gate * one of the threads was actually updated, 0 if none were for various
18317c478bd9Sstevel@tonic-gate * reasons (thread is no longer in the TS or IA class, isn't runnable,
18327c478bd9Sstevel@tonic-gate * hasn't waited long enough, has the preemption control no-preempt bit
18337c478bd9Sstevel@tonic-gate * set, etc.)
18347c478bd9Sstevel@tonic-gate */
18357c478bd9Sstevel@tonic-gate static int
ts_update_list(int i)18367c478bd9Sstevel@tonic-gate ts_update_list(int i)
18377c478bd9Sstevel@tonic-gate {
18387c478bd9Sstevel@tonic-gate tsproc_t *tspp;
18397c478bd9Sstevel@tonic-gate kthread_t *tx;
18407c478bd9Sstevel@tonic-gate int updated = 0;
18417c478bd9Sstevel@tonic-gate
18427c478bd9Sstevel@tonic-gate mutex_enter(&ts_list_lock[i]);
18437c478bd9Sstevel@tonic-gate for (tspp = ts_plisthead[i].ts_next; tspp != &ts_plisthead[i];
18447c478bd9Sstevel@tonic-gate tspp = tspp->ts_next) {
18457c478bd9Sstevel@tonic-gate tx = tspp->ts_tp;
18467c478bd9Sstevel@tonic-gate /*
18477c478bd9Sstevel@tonic-gate * Lock the thread and verify state.
18487c478bd9Sstevel@tonic-gate */
18497c478bd9Sstevel@tonic-gate thread_lock(tx);
18507c478bd9Sstevel@tonic-gate /*
18517c478bd9Sstevel@tonic-gate * Skip the thread if it is no longer in the TS (or IA) class.
18527c478bd9Sstevel@tonic-gate */
18537c478bd9Sstevel@tonic-gate if (tx->t_clfuncs != &ts_classfuncs.thread &&
18547c478bd9Sstevel@tonic-gate tx->t_clfuncs != &ia_classfuncs.thread)
18557c478bd9Sstevel@tonic-gate goto next;
18567c478bd9Sstevel@tonic-gate tspp->ts_dispwait++;
18577c478bd9Sstevel@tonic-gate if (tspp->ts_dispwait <= ts_dptbl[tspp->ts_umdpri].ts_maxwait)
18587c478bd9Sstevel@tonic-gate goto next;
18597c478bd9Sstevel@tonic-gate if (tx->t_schedctl && schedctl_get_nopreempt(tx))
18607c478bd9Sstevel@tonic-gate goto next;
1861c97ad5cdSakolb if (tx->t_state != TS_RUN && tx->t_state != TS_WAIT &&
1862c97ad5cdSakolb (tx->t_state != TS_SLEEP || !ts_sleep_promote)) {
18637c478bd9Sstevel@tonic-gate /* make next syscall/trap do CL_TRAPRET */
18647c478bd9Sstevel@tonic-gate tx->t_trapret = 1;
18657c478bd9Sstevel@tonic-gate aston(tx);
18667c478bd9Sstevel@tonic-gate goto next;
18677c478bd9Sstevel@tonic-gate }
18687c478bd9Sstevel@tonic-gate tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_lwait;
18697c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
18707c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
18717c478bd9Sstevel@tonic-gate updated = 1;
18727c478bd9Sstevel@tonic-gate
18737c478bd9Sstevel@tonic-gate /*
18747c478bd9Sstevel@tonic-gate * Only dequeue it if needs to move; otherwise it should
18757c478bd9Sstevel@tonic-gate * just round-robin here.
18767c478bd9Sstevel@tonic-gate */
18777c478bd9Sstevel@tonic-gate if (tx->t_pri != ts_dptbl[tspp->ts_umdpri].ts_globpri) {
18787c478bd9Sstevel@tonic-gate pri_t oldpri = tx->t_pri;
18797c478bd9Sstevel@tonic-gate ts_change_priority(tx, tspp);
18807c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_DISP, TR_UPDATE,
18817c478bd9Sstevel@tonic-gate "update:tid %p old pri %d", tx, oldpri);
18827c478bd9Sstevel@tonic-gate }
18837c478bd9Sstevel@tonic-gate next:
18847c478bd9Sstevel@tonic-gate thread_unlock(tx);
18857c478bd9Sstevel@tonic-gate }
18867c478bd9Sstevel@tonic-gate mutex_exit(&ts_list_lock[i]);
18877c478bd9Sstevel@tonic-gate
18887c478bd9Sstevel@tonic-gate return (updated);
18897c478bd9Sstevel@tonic-gate }
18907c478bd9Sstevel@tonic-gate
18917c478bd9Sstevel@tonic-gate /*
18926a0b1217SPatrick Mooney * Processes waking up go to the back of their queue.
18937c478bd9Sstevel@tonic-gate */
18947c478bd9Sstevel@tonic-gate static void
ts_wakeup(kthread_t * t)18957c478bd9Sstevel@tonic-gate ts_wakeup(kthread_t *t)
18967c478bd9Sstevel@tonic-gate {
18977c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
18987c478bd9Sstevel@tonic-gate
18997c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
19007c478bd9Sstevel@tonic-gate
1901d3d50737SRafael Vanoni t->t_stime = ddi_get_lbolt(); /* time stamp for the swapper */
19027c478bd9Sstevel@tonic-gate
19036a0b1217SPatrick Mooney if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) {
19046a0b1217SPatrick Mooney tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret;
19056a0b1217SPatrick Mooney TS_NEWUMDPRI(tspp);
19066a0b1217SPatrick Mooney tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
19076a0b1217SPatrick Mooney tspp->ts_dispwait = 0;
19086a0b1217SPatrick Mooney THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
19096a0b1217SPatrick Mooney ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
19106a0b1217SPatrick Mooney }
19116a0b1217SPatrick Mooney
19126a0b1217SPatrick Mooney tspp->ts_flags &= ~TSBACKQ;
19136a0b1217SPatrick Mooney
19146a0b1217SPatrick Mooney if (tspp->ts_flags & TSIA) {
19157c478bd9Sstevel@tonic-gate if (tspp->ts_flags & TSIASET)
19167c478bd9Sstevel@tonic-gate setfrontdq(t);
19177c478bd9Sstevel@tonic-gate else
19187c478bd9Sstevel@tonic-gate setbackdq(t);
19197c478bd9Sstevel@tonic-gate } else {
19206a0b1217SPatrick Mooney if (t->t_disp_time != ddi_get_lbolt())
19216a0b1217SPatrick Mooney setbackdq(t);
19226a0b1217SPatrick Mooney else
19236a0b1217SPatrick Mooney setfrontdq(t);
19247c478bd9Sstevel@tonic-gate }
19257c478bd9Sstevel@tonic-gate }
19267c478bd9Sstevel@tonic-gate
19277c478bd9Sstevel@tonic-gate
19287c478bd9Sstevel@tonic-gate /*
19297c478bd9Sstevel@tonic-gate * When a thread yields, put it on the back of the run queue.
19307c478bd9Sstevel@tonic-gate */
19317c478bd9Sstevel@tonic-gate static void
ts_yield(kthread_t * t)19327c478bd9Sstevel@tonic-gate ts_yield(kthread_t *t)
19337c478bd9Sstevel@tonic-gate {
19347c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
19357c478bd9Sstevel@tonic-gate
19367c478bd9Sstevel@tonic-gate ASSERT(t == curthread);
19377c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
19387c478bd9Sstevel@tonic-gate
1939c97ad5cdSakolb /*
1940c97ad5cdSakolb * Collect CPU usage spent before yielding
1941c97ad5cdSakolb */
19428c34bbb7Sakolb (void) CPUCAPS_CHARGE(t, &tspp->ts_caps, CPUCAPS_CHARGE_ENFORCE);
1943c97ad5cdSakolb
19447c478bd9Sstevel@tonic-gate /*
19457c478bd9Sstevel@tonic-gate * Clear the preemption control "yield" bit since the user is
19467c478bd9Sstevel@tonic-gate * doing a yield.
19477c478bd9Sstevel@tonic-gate */
19487c478bd9Sstevel@tonic-gate if (t->t_schedctl)
19497c478bd9Sstevel@tonic-gate schedctl_set_yield(t, 0);
19509ac8606fSraf /*
19519ac8606fSraf * If ts_preempt() artifically increased the thread's priority
19529ac8606fSraf * to avoid preemption, restore the original priority now.
19539ac8606fSraf */
19549ac8606fSraf if (tspp->ts_flags & TSRESTORE) {
19559ac8606fSraf THREAD_CHANGE_PRI(t, tspp->ts_scpri);
19569ac8606fSraf tspp->ts_flags &= ~TSRESTORE;
19579ac8606fSraf }
19587c478bd9Sstevel@tonic-gate if (tspp->ts_timeleft <= 0) {
19597c478bd9Sstevel@tonic-gate /*
19607c478bd9Sstevel@tonic-gate * Time slice was artificially extended to avoid
19617c478bd9Sstevel@tonic-gate * preemption, so pretend we're preempting it now.
19627c478bd9Sstevel@tonic-gate */
19637c478bd9Sstevel@tonic-gate DTRACE_SCHED1(schedctl__yield, int, -tspp->ts_timeleft);
19647c478bd9Sstevel@tonic-gate tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp;
19657c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
19667c478bd9Sstevel@tonic-gate tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum;
19677c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
19687c478bd9Sstevel@tonic-gate THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri);
19697c478bd9Sstevel@tonic-gate ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri);
19707c478bd9Sstevel@tonic-gate }
19717c478bd9Sstevel@tonic-gate tspp->ts_flags &= ~TSBACKQ;
19727c478bd9Sstevel@tonic-gate setbackdq(t);
19737c478bd9Sstevel@tonic-gate }
19747c478bd9Sstevel@tonic-gate
19757c478bd9Sstevel@tonic-gate
19767c478bd9Sstevel@tonic-gate /*
19777c478bd9Sstevel@tonic-gate * Increment the nice value of the specified thread by incr and
19787c478bd9Sstevel@tonic-gate * return the new value in *retvalp.
19797c478bd9Sstevel@tonic-gate */
19807c478bd9Sstevel@tonic-gate static int
ts_donice(kthread_t * t,cred_t * cr,int incr,int * retvalp)19817c478bd9Sstevel@tonic-gate ts_donice(kthread_t *t, cred_t *cr, int incr, int *retvalp)
19827c478bd9Sstevel@tonic-gate {
19837c478bd9Sstevel@tonic-gate int newnice;
19847c478bd9Sstevel@tonic-gate tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
19857c478bd9Sstevel@tonic-gate tsparms_t tsparms;
19867c478bd9Sstevel@tonic-gate
19877c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
19887c478bd9Sstevel@tonic-gate
19897c478bd9Sstevel@tonic-gate /* If there's no change to priority, just return current setting */
19907c478bd9Sstevel@tonic-gate if (incr == 0) {
19917c478bd9Sstevel@tonic-gate if (retvalp) {
19927c478bd9Sstevel@tonic-gate *retvalp = tspp->ts_nice - NZERO;
19937c478bd9Sstevel@tonic-gate }
19947c478bd9Sstevel@tonic-gate return (0);
19957c478bd9Sstevel@tonic-gate }
19967c478bd9Sstevel@tonic-gate
19977c478bd9Sstevel@tonic-gate if ((incr < 0 || incr > 2 * NZERO) &&
199824d819e6SJerry Jelinek secpolicy_raisepriority(cr) != 0)
19997c478bd9Sstevel@tonic-gate return (EPERM);
20007c478bd9Sstevel@tonic-gate
20017c478bd9Sstevel@tonic-gate /*
20027c478bd9Sstevel@tonic-gate * Specifying a nice increment greater than the upper limit of
20037c478bd9Sstevel@tonic-gate * 2 * NZERO - 1 will result in the thread's nice value being
20047c478bd9Sstevel@tonic-gate * set to the upper limit. We check for this before computing
20057c478bd9Sstevel@tonic-gate * the new value because otherwise we could get overflow
20067c478bd9Sstevel@tonic-gate * if a privileged process specified some ridiculous increment.
20077c478bd9Sstevel@tonic-gate */
20087c478bd9Sstevel@tonic-gate if (incr > 2 * NZERO - 1)
20097c478bd9Sstevel@tonic-gate incr = 2 * NZERO - 1;
20107c478bd9Sstevel@tonic-gate
20117c478bd9Sstevel@tonic-gate newnice = tspp->ts_nice + incr;
20127c478bd9Sstevel@tonic-gate if (newnice >= 2 * NZERO)
20137c478bd9Sstevel@tonic-gate newnice = 2 * NZERO - 1;
20147c478bd9Sstevel@tonic-gate else if (newnice < 0)
20157c478bd9Sstevel@tonic-gate newnice = 0;
20167c478bd9Sstevel@tonic-gate
20177c478bd9Sstevel@tonic-gate tsparms.ts_uprilim = tsparms.ts_upri =
2018d4204c85Sraf -((newnice - NZERO) * ts_maxupri) / NZERO;
20197c478bd9Sstevel@tonic-gate /*
20207c478bd9Sstevel@tonic-gate * Reset the uprilim and upri values of the thread.
20217c478bd9Sstevel@tonic-gate * Call ts_parmsset even if thread is interactive since we're
20227c478bd9Sstevel@tonic-gate * not changing mode.
20237c478bd9Sstevel@tonic-gate */
20247c478bd9Sstevel@tonic-gate (void) ts_parmsset(t, (void *)&tsparms, (id_t)0, (cred_t *)NULL);
20257c478bd9Sstevel@tonic-gate
20267c478bd9Sstevel@tonic-gate /*
20277c478bd9Sstevel@tonic-gate * Although ts_parmsset already reset ts_nice it may
20287c478bd9Sstevel@tonic-gate * not have been set to precisely the value calculated above
20297c478bd9Sstevel@tonic-gate * because ts_parmsset determines the nice value from the
20307c478bd9Sstevel@tonic-gate * user priority and we may have truncated during the integer
20317c478bd9Sstevel@tonic-gate * conversion from nice value to user priority and back.
20327c478bd9Sstevel@tonic-gate * We reset ts_nice to the value we calculated above.
20337c478bd9Sstevel@tonic-gate */
20347c478bd9Sstevel@tonic-gate tspp->ts_nice = (char)newnice;
20357c478bd9Sstevel@tonic-gate
20367c478bd9Sstevel@tonic-gate if (retvalp)
20377c478bd9Sstevel@tonic-gate *retvalp = newnice - NZERO;
20387c478bd9Sstevel@tonic-gate return (0);
20397c478bd9Sstevel@tonic-gate }
20407c478bd9Sstevel@tonic-gate
2041d4204c85Sraf /*
2042d4204c85Sraf * Increment the priority of the specified thread by incr and
2043d4204c85Sraf * return the new value in *retvalp.
2044d4204c85Sraf */
2045d4204c85Sraf static int
ts_doprio(kthread_t * t,cred_t * cr,int incr,int * retvalp)2046d4204c85Sraf ts_doprio(kthread_t *t, cred_t *cr, int incr, int *retvalp)
2047d4204c85Sraf {
2048d4204c85Sraf int newpri;
2049d4204c85Sraf tsproc_t *tspp = (tsproc_t *)(t->t_cldata);
2050d4204c85Sraf tsparms_t tsparms;
2051d4204c85Sraf
2052d4204c85Sraf ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
2053d4204c85Sraf
2054d4204c85Sraf /* If there's no change to the priority, just return current setting */
2055d4204c85Sraf if (incr == 0) {
2056d4204c85Sraf *retvalp = tspp->ts_upri;
2057d4204c85Sraf return (0);
2058d4204c85Sraf }
2059d4204c85Sraf
2060d4204c85Sraf newpri = tspp->ts_upri + incr;
2061d4204c85Sraf if (newpri > ts_maxupri || newpri < -ts_maxupri)
2062d4204c85Sraf return (EINVAL);
2063d4204c85Sraf
2064d4204c85Sraf *retvalp = newpri;
2065d4204c85Sraf tsparms.ts_uprilim = tsparms.ts_upri = newpri;
2066d4204c85Sraf /*
2067d4204c85Sraf * Reset the uprilim and upri values of the thread.
2068d4204c85Sraf * Call ts_parmsset even if thread is interactive since we're
2069d4204c85Sraf * not changing mode.
2070d4204c85Sraf */
2071d4204c85Sraf return (ts_parmsset(t, &tsparms, 0, cr));
2072d4204c85Sraf }
20737c478bd9Sstevel@tonic-gate
20747c478bd9Sstevel@tonic-gate /*
20757c478bd9Sstevel@tonic-gate * ia_set_process_group marks foreground processes as interactive
20767c478bd9Sstevel@tonic-gate * and background processes as non-interactive iff the session
20777c478bd9Sstevel@tonic-gate * leader is interactive. This routine is called from two places:
20787c478bd9Sstevel@tonic-gate * strioctl:SPGRP when a new process group gets
20796a0b1217SPatrick Mooney * control of the tty.
20807c478bd9Sstevel@tonic-gate * ia_parmsset-when the process in question is a session leader.
20817c478bd9Sstevel@tonic-gate * ia_set_process_group assumes that pidlock is held by the caller,
20827c478bd9Sstevel@tonic-gate * either strioctl or priocntlsys. If the caller is priocntlsys
20837c478bd9Sstevel@tonic-gate * (via ia_parmsset) then the p_lock of the session leader is held
20847c478bd9Sstevel@tonic-gate * and the code needs to be careful about acquiring other p_locks.
20857c478bd9Sstevel@tonic-gate */
20867c478bd9Sstevel@tonic-gate static void
ia_set_process_group(pid_t sid,pid_t bg_pgid,pid_t fg_pgid)20877c478bd9Sstevel@tonic-gate ia_set_process_group(pid_t sid, pid_t bg_pgid, pid_t fg_pgid)
20887c478bd9Sstevel@tonic-gate {
20896a0b1217SPatrick Mooney proc_t *leader, *fg, *bg;
20907c478bd9Sstevel@tonic-gate tsproc_t *tspp;
20917c478bd9Sstevel@tonic-gate kthread_t *tx;
20927c478bd9Sstevel@tonic-gate int plocked = 0;
20937c478bd9Sstevel@tonic-gate
20947c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock));
20957c478bd9Sstevel@tonic-gate
20967c478bd9Sstevel@tonic-gate /*
20977c478bd9Sstevel@tonic-gate * see if the session leader is interactive AND
20987c478bd9Sstevel@tonic-gate * if it is currently "on" AND controlling a tty
20997c478bd9Sstevel@tonic-gate * iff it is then make the processes in the foreground
21007c478bd9Sstevel@tonic-gate * group interactive and the processes in the background
21017c478bd9Sstevel@tonic-gate * group non-interactive.
21027c478bd9Sstevel@tonic-gate */
21037c478bd9Sstevel@tonic-gate if ((leader = (proc_t *)prfind(sid)) == NULL) {
21047c478bd9Sstevel@tonic-gate return;
21057c478bd9Sstevel@tonic-gate }
21067c478bd9Sstevel@tonic-gate if (leader->p_stat == SIDL) {
21077c478bd9Sstevel@tonic-gate return;
21087c478bd9Sstevel@tonic-gate }
21097c478bd9Sstevel@tonic-gate if ((tx = proctot(leader)) == NULL) {
21107c478bd9Sstevel@tonic-gate return;
21117c478bd9Sstevel@tonic-gate }
21127c478bd9Sstevel@tonic-gate /*
21137c478bd9Sstevel@tonic-gate * XXX do all the threads in the leader
21147c478bd9Sstevel@tonic-gate */
21157c478bd9Sstevel@tonic-gate if (tx->t_cid != ia_cid) {
21167c478bd9Sstevel@tonic-gate return;
21177c478bd9Sstevel@tonic-gate }
21187c478bd9Sstevel@tonic-gate tspp = tx->t_cldata;
21197c478bd9Sstevel@tonic-gate /*
21207c478bd9Sstevel@tonic-gate * session leaders that are not interactive need not have
21217c478bd9Sstevel@tonic-gate * any processing done for them. They are typically shells
21227c478bd9Sstevel@tonic-gate * that do not have focus and are changing the process group
21237c478bd9Sstevel@tonic-gate * attatched to the tty, e.g. a process that is exiting
21247c478bd9Sstevel@tonic-gate */
21259acbbeafSnn mutex_enter(&leader->p_sessp->s_lock);
21267c478bd9Sstevel@tonic-gate if (!(tspp->ts_flags & TSIASET) ||
21277c478bd9Sstevel@tonic-gate (leader->p_sessp->s_vp == NULL) ||
21287c478bd9Sstevel@tonic-gate (leader->p_sessp->s_vp->v_stream == NULL)) {
21299acbbeafSnn mutex_exit(&leader->p_sessp->s_lock);
21307c478bd9Sstevel@tonic-gate return;
21317c478bd9Sstevel@tonic-gate }
21329acbbeafSnn mutex_exit(&leader->p_sessp->s_lock);
21337c478bd9Sstevel@tonic-gate
21347c478bd9Sstevel@tonic-gate /*
21357c478bd9Sstevel@tonic-gate * If we're already holding the leader's p_lock, we should use
21367c478bd9Sstevel@tonic-gate * mutex_tryenter instead of mutex_enter to avoid deadlocks from
21377c478bd9Sstevel@tonic-gate * lock ordering violations.
21387c478bd9Sstevel@tonic-gate */
21397c478bd9Sstevel@tonic-gate if (mutex_owned(&leader->p_lock))
21407c478bd9Sstevel@tonic-gate plocked = 1;
21417c478bd9Sstevel@tonic-gate
21427c478bd9Sstevel@tonic-gate if (fg_pgid == 0)
21437c478bd9Sstevel@tonic-gate goto skip;
21447c478bd9Sstevel@tonic-gate /*
21457c478bd9Sstevel@tonic-gate * now look for all processes in the foreground group and
21467c478bd9Sstevel@tonic-gate * make them interactive
21477c478bd9Sstevel@tonic-gate */
21487c478bd9Sstevel@tonic-gate for (fg = (proc_t *)pgfind(fg_pgid); fg != NULL; fg = fg->p_pglink) {
21497c478bd9Sstevel@tonic-gate /*
21507c478bd9Sstevel@tonic-gate * if the process is SIDL it's begin forked, ignore it
21517c478bd9Sstevel@tonic-gate */
21527c478bd9Sstevel@tonic-gate if (fg->p_stat == SIDL) {
21537c478bd9Sstevel@tonic-gate continue;
21547c478bd9Sstevel@tonic-gate }
21557c478bd9Sstevel@tonic-gate /*
21567c478bd9Sstevel@tonic-gate * sesssion leaders must be turned on/off explicitly
21577c478bd9Sstevel@tonic-gate * not implicitly as happens to other members of
21587c478bd9Sstevel@tonic-gate * the process group.
21597c478bd9Sstevel@tonic-gate */
21607c478bd9Sstevel@tonic-gate if (fg->p_pid == fg->p_sessp->s_sid) {
21617c478bd9Sstevel@tonic-gate continue;
21627c478bd9Sstevel@tonic-gate }
21637c478bd9Sstevel@tonic-gate
21647c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_IA, TR_GROUP_ON,
21657c478bd9Sstevel@tonic-gate "group on:proc %p", fg);
21667c478bd9Sstevel@tonic-gate
21677c478bd9Sstevel@tonic-gate if (plocked) {
21687c478bd9Sstevel@tonic-gate if (mutex_tryenter(&fg->p_lock) == 0)
21697c478bd9Sstevel@tonic-gate continue;
21707c478bd9Sstevel@tonic-gate } else {
21717c478bd9Sstevel@tonic-gate mutex_enter(&fg->p_lock);
21727c478bd9Sstevel@tonic-gate }
21737c478bd9Sstevel@tonic-gate
21747c478bd9Sstevel@tonic-gate if ((tx = proctot(fg)) == NULL) {
21757c478bd9Sstevel@tonic-gate mutex_exit(&fg->p_lock);
21767c478bd9Sstevel@tonic-gate continue;
21777c478bd9Sstevel@tonic-gate }
21787c478bd9Sstevel@tonic-gate do {
21797c478bd9Sstevel@tonic-gate thread_lock(tx);
21807c478bd9Sstevel@tonic-gate /*
21817c478bd9Sstevel@tonic-gate * if this thread is not interactive continue
21827c478bd9Sstevel@tonic-gate */
21837c478bd9Sstevel@tonic-gate if (tx->t_cid != ia_cid) {
21847c478bd9Sstevel@tonic-gate thread_unlock(tx);
21857c478bd9Sstevel@tonic-gate continue;
21867c478bd9Sstevel@tonic-gate }
21877c478bd9Sstevel@tonic-gate tspp = tx->t_cldata;
21887c478bd9Sstevel@tonic-gate tspp->ts_flags |= TSIASET;
21897c478bd9Sstevel@tonic-gate tspp->ts_boost = ia_boost;
21907c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
21917c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
21927c478bd9Sstevel@tonic-gate ts_change_priority(tx, tspp);
21937c478bd9Sstevel@tonic-gate thread_unlock(tx);
21947c478bd9Sstevel@tonic-gate } while ((tx = tx->t_forw) != fg->p_tlist);
21957c478bd9Sstevel@tonic-gate mutex_exit(&fg->p_lock);
21967c478bd9Sstevel@tonic-gate }
21977c478bd9Sstevel@tonic-gate skip:
21987c478bd9Sstevel@tonic-gate if (bg_pgid == 0)
21997c478bd9Sstevel@tonic-gate return;
22007c478bd9Sstevel@tonic-gate for (bg = (proc_t *)pgfind(bg_pgid); bg != NULL; bg = bg->p_pglink) {
22017c478bd9Sstevel@tonic-gate if (bg->p_stat == SIDL) {
22027c478bd9Sstevel@tonic-gate continue;
22037c478bd9Sstevel@tonic-gate }
22047c478bd9Sstevel@tonic-gate /*
22057c478bd9Sstevel@tonic-gate * sesssion leaders must be turned off explicitly
22067c478bd9Sstevel@tonic-gate * not implicitly as happens to other members of
22077c478bd9Sstevel@tonic-gate * the process group.
22087c478bd9Sstevel@tonic-gate */
22097c478bd9Sstevel@tonic-gate if (bg->p_pid == bg->p_sessp->s_sid) {
22107c478bd9Sstevel@tonic-gate continue;
22117c478bd9Sstevel@tonic-gate }
22127c478bd9Sstevel@tonic-gate
22137c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_IA, TR_GROUP_OFF,
22147c478bd9Sstevel@tonic-gate "group off:proc %p", bg);
22157c478bd9Sstevel@tonic-gate
22167c478bd9Sstevel@tonic-gate if (plocked) {
22177c478bd9Sstevel@tonic-gate if (mutex_tryenter(&bg->p_lock) == 0)
22187c478bd9Sstevel@tonic-gate continue;
22197c478bd9Sstevel@tonic-gate } else {
22207c478bd9Sstevel@tonic-gate mutex_enter(&bg->p_lock);
22217c478bd9Sstevel@tonic-gate }
22227c478bd9Sstevel@tonic-gate
22237c478bd9Sstevel@tonic-gate if ((tx = proctot(bg)) == NULL) {
22247c478bd9Sstevel@tonic-gate mutex_exit(&bg->p_lock);
22257c478bd9Sstevel@tonic-gate continue;
22267c478bd9Sstevel@tonic-gate }
22277c478bd9Sstevel@tonic-gate do {
22287c478bd9Sstevel@tonic-gate thread_lock(tx);
22297c478bd9Sstevel@tonic-gate /*
22307c478bd9Sstevel@tonic-gate * if this thread is not interactive continue
22317c478bd9Sstevel@tonic-gate */
22327c478bd9Sstevel@tonic-gate if (tx->t_cid != ia_cid) {
22337c478bd9Sstevel@tonic-gate thread_unlock(tx);
22347c478bd9Sstevel@tonic-gate continue;
22357c478bd9Sstevel@tonic-gate }
22367c478bd9Sstevel@tonic-gate tspp = tx->t_cldata;
22377c478bd9Sstevel@tonic-gate tspp->ts_flags &= ~TSIASET;
22387c478bd9Sstevel@tonic-gate tspp->ts_boost = -ia_boost;
22397c478bd9Sstevel@tonic-gate TS_NEWUMDPRI(tspp);
22407c478bd9Sstevel@tonic-gate
22417c478bd9Sstevel@tonic-gate tspp->ts_dispwait = 0;
22427c478bd9Sstevel@tonic-gate ts_change_priority(tx, tspp);
22437c478bd9Sstevel@tonic-gate thread_unlock(tx);
22447c478bd9Sstevel@tonic-gate } while ((tx = tx->t_forw) != bg->p_tlist);
22457c478bd9Sstevel@tonic-gate mutex_exit(&bg->p_lock);
22467c478bd9Sstevel@tonic-gate }
22477c478bd9Sstevel@tonic-gate }
22487c478bd9Sstevel@tonic-gate
22497c478bd9Sstevel@tonic-gate
22507c478bd9Sstevel@tonic-gate static void
ts_change_priority(kthread_t * t,tsproc_t * tspp)22517c478bd9Sstevel@tonic-gate ts_change_priority(kthread_t *t, tsproc_t *tspp)
22527c478bd9Sstevel@tonic-gate {
22537c478bd9Sstevel@tonic-gate pri_t new_pri;
22547c478bd9Sstevel@tonic-gate
22557c478bd9Sstevel@tonic-gate ASSERT(THREAD_LOCK_HELD(t));
22567c478bd9Sstevel@tonic-gate new_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri;
22577c478bd9Sstevel@tonic-gate ASSERT(new_pri >= 0 && new_pri <= ts_maxglobpri);
22589ac8606fSraf tspp->ts_flags &= ~TSRESTORE;
2259d4204c85Sraf t->t_cpri = tspp->ts_upri;
22607c478bd9Sstevel@tonic-gate if (t == curthread || t->t_state == TS_ONPROC) {
22617c478bd9Sstevel@tonic-gate /* curthread is always onproc */
22627c478bd9Sstevel@tonic-gate cpu_t *cp = t->t_disp_queue->disp_cpu;
22637c478bd9Sstevel@tonic-gate THREAD_CHANGE_PRI(t, new_pri);
22647c478bd9Sstevel@tonic-gate if (t == cp->cpu_dispthread)
22657c478bd9Sstevel@tonic-gate cp->cpu_dispatch_pri = DISP_PRIO(t);
22667c478bd9Sstevel@tonic-gate if (DISP_MUST_SURRENDER(t)) {
22677c478bd9Sstevel@tonic-gate tspp->ts_flags |= TSBACKQ;
22687c478bd9Sstevel@tonic-gate cpu_surrender(t);
22697c478bd9Sstevel@tonic-gate } else {
22707c478bd9Sstevel@tonic-gate tspp->ts_timeleft =
22717c478bd9Sstevel@tonic-gate ts_dptbl[tspp->ts_cpupri].ts_quantum;
22727c478bd9Sstevel@tonic-gate }
22737c478bd9Sstevel@tonic-gate } else {
22747c478bd9Sstevel@tonic-gate int frontq;
22757c478bd9Sstevel@tonic-gate
22767c478bd9Sstevel@tonic-gate frontq = (tspp->ts_flags & TSIASET) != 0;
22777c478bd9Sstevel@tonic-gate /*
22787c478bd9Sstevel@tonic-gate * When the priority of a thread is changed,
22797c478bd9Sstevel@tonic-gate * it may be necessary to adjust its position
22807c478bd9Sstevel@tonic-gate * on a sleep queue or dispatch queue.
22817c478bd9Sstevel@tonic-gate * The function thread_change_pri accomplishes
22827c478bd9Sstevel@tonic-gate * this.
22837c478bd9Sstevel@tonic-gate */
22847c478bd9Sstevel@tonic-gate if (thread_change_pri(t, new_pri, frontq)) {
22857c478bd9Sstevel@tonic-gate /*
22867c478bd9Sstevel@tonic-gate * The thread was on a run queue. Reset
22877c478bd9Sstevel@tonic-gate * its CPU timeleft from the quantum
22887c478bd9Sstevel@tonic-gate * associated with the new priority.
22897c478bd9Sstevel@tonic-gate */
22907c478bd9Sstevel@tonic-gate tspp->ts_timeleft =
22917c478bd9Sstevel@tonic-gate ts_dptbl[tspp->ts_cpupri].ts_quantum;
22927c478bd9Sstevel@tonic-gate } else {
22937c478bd9Sstevel@tonic-gate tspp->ts_flags |= TSBACKQ;
22947c478bd9Sstevel@tonic-gate }
22957c478bd9Sstevel@tonic-gate }
22967c478bd9Sstevel@tonic-gate }
22977c478bd9Sstevel@tonic-gate
22987c478bd9Sstevel@tonic-gate static int
ts_alloc(void ** p,int flag)22997c478bd9Sstevel@tonic-gate ts_alloc(void **p, int flag)
23007c478bd9Sstevel@tonic-gate {
23017c478bd9Sstevel@tonic-gate void *bufp;
23027c478bd9Sstevel@tonic-gate bufp = kmem_alloc(sizeof (tsproc_t), flag);
23037c478bd9Sstevel@tonic-gate if (bufp == NULL) {
23047c478bd9Sstevel@tonic-gate return (ENOMEM);
23057c478bd9Sstevel@tonic-gate } else {
23067c478bd9Sstevel@tonic-gate *p = bufp;
23077c478bd9Sstevel@tonic-gate return (0);
23087c478bd9Sstevel@tonic-gate }
23097c478bd9Sstevel@tonic-gate }
23107c478bd9Sstevel@tonic-gate
23117c478bd9Sstevel@tonic-gate static void
ts_free(void * bufp)23127c478bd9Sstevel@tonic-gate ts_free(void *bufp)
23137c478bd9Sstevel@tonic-gate {
23147c478bd9Sstevel@tonic-gate if (bufp)
23157c478bd9Sstevel@tonic-gate kmem_free(bufp, sizeof (tsproc_t));
23167c478bd9Sstevel@tonic-gate }
2317