/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static pri_t fx_init(id_t, int, classfuncs_t **); static struct sclass csw = { "FX", fx_init, 0 }; static struct modlsched modlsched = { &mod_schedops, "Fixed priority sched class", &csw }; static struct modlinkage modlinkage = { MODREV_1, (void *)&modlsched, NULL }; /* * control flags (kparms->fx_cflags). */ #define FX_DOUPRILIM 0x01 /* change user priority limit */ #define FX_DOUPRI 0x02 /* change user priority */ #define FX_DOTQ 0x04 /* change FX time quantum */ #define FXMAXUPRI 60 /* maximum user priority setting */ #define FX_MAX_UNPRIV_PRI 0 /* maximum unpriviledge priority */ /* * The fxproc_t structures are kept in an array of circular doubly linked * lists. A hash on the thread pointer is used to determine which list * each fxproc structure should be placed. Each list has a dummy "head" which * is never removed, so the list is never empty. */ #define FX_LISTS 16 /* number of lists, must be power of 2 */ #define FX_LIST_HASH(tp) (((uintptr_t)(tp) >> 9) & (FX_LISTS - 1)) #define FX_LIST_INSERT(fxpp) \ { \ int index = FX_LIST_HASH(fxpp->fx_tp); \ kmutex_t *lockp = &fx_list_lock[index]; \ fxproc_t *headp = &fx_plisthead[index]; \ mutex_enter(lockp); \ fxpp->fx_next = headp->fx_next; \ fxpp->fx_prev = headp; \ headp->fx_next->fx_prev = fxpp; \ headp->fx_next = fxpp; \ mutex_exit(lockp); \ } #define FX_LIST_DELETE(fxpp) \ { \ int index = FX_LIST_HASH(fxpp->fx_tp); \ kmutex_t *lockp = &fx_list_lock[index]; \ mutex_enter(lockp); \ fxpp->fx_prev->fx_next = fxpp->fx_next; \ fxpp->fx_next->fx_prev = fxpp->fx_prev; \ mutex_exit(lockp); \ } /* * The fxproc_t structures that have a registered callback vector, * are also kept in an array of circular doubly linked lists. A hash on * the thread id (from ddi_get_kt_did()) is used to determine which list * each of such fxproc structures should be placed. Each list has a dummy * "head" which is never removed, so the list is never empty. */ #define FX_CB_LISTS 16 /* number of lists, must be power of 2 */ #define FX_CB_LIST_HASH(ktid) ((uint_t)ktid & (FX_CB_LISTS - 1)) /* Insert fxproc into callback list */ #define FX_CB_LIST_INSERT(fxpp) \ { \ int index = FX_CB_LIST_HASH(fxpp->fx_ktid); \ kmutex_t *lockp = &fx_cb_list_lock[index]; \ fxproc_t *headp = &fx_cb_plisthead[index]; \ mutex_enter(lockp); \ fxpp->fx_cb_next = headp->fx_cb_next; \ fxpp->fx_cb_prev = headp; \ headp->fx_cb_next->fx_cb_prev = fxpp; \ headp->fx_cb_next = fxpp; \ mutex_exit(lockp); \ } /* * Remove thread from callback list. */ #define FX_CB_LIST_DELETE(fxpp) \ { \ int index = FX_CB_LIST_HASH(fxpp->fx_ktid); \ kmutex_t *lockp = &fx_cb_list_lock[index]; \ mutex_enter(lockp); \ fxpp->fx_cb_prev->fx_cb_next = fxpp->fx_cb_next; \ fxpp->fx_cb_next->fx_cb_prev = fxpp->fx_cb_prev; \ mutex_exit(lockp); \ } #define FX_HAS_CB(fxpp) (fxpp->fx_callback != NULL) /* adjust x to be between 0 and fx_maxumdpri */ #define FX_ADJUST_PRI(pri) \ { \ if (pri < 0) \ pri = 0; \ else if (pri > fx_maxumdpri) \ pri = fx_maxumdpri; \ } #define FX_ADJUST_QUANTUM(q) \ { \ if (q > INT_MAX) \ q = INT_MAX; \ else if (q <= 0) \ q = FX_TQINF; \ } #define FX_ISVALID(pri, quantum) \ (((pri >= 0) || (pri == FX_CB_NOCHANGE)) && \ ((quantum >= 0) || (quantum == FX_NOCHANGE) || \ (quantum == FX_TQDEF) || (quantum == FX_TQINF))) static id_t fx_cid; /* fixed priority class ID */ static fxdpent_t *fx_dptbl; /* fixed priority disp parameter table */ static pri_t fx_maxupri = FXMAXUPRI; static pri_t fx_maxumdpri; /* max user mode fixed priority */ static pri_t fx_maxglobpri; /* maximum global priority used by fx class */ static kmutex_t fx_dptblock; /* protects fixed priority dispatch table */ static kmutex_t fx_list_lock[FX_LISTS]; /* protects fxproc lists */ static fxproc_t fx_plisthead[FX_LISTS]; /* dummy fxproc at head of lists */ static kmutex_t fx_cb_list_lock[FX_CB_LISTS]; /* protects list of fxprocs */ /* that have callbacks */ static fxproc_t fx_cb_plisthead[FX_CB_LISTS]; /* dummy fxproc at head of */ /* list of fxprocs with */ /* callbacks */ static int fx_admin(caddr_t, cred_t *); static int fx_getclinfo(void *); static int fx_parmsin(void *); static int fx_parmsout(void *, pc_vaparms_t *); static int fx_vaparmsin(void *, pc_vaparms_t *); static int fx_vaparmsout(void *, pc_vaparms_t *); static int fx_getclpri(pcpri_t *); static int fx_alloc(void **, int); static void fx_free(void *); static int fx_enterclass(kthread_t *, id_t, void *, cred_t *, void *); static void fx_exitclass(void *); static int fx_canexit(kthread_t *, cred_t *); static int fx_fork(kthread_t *, kthread_t *, void *); static void fx_forkret(kthread_t *, kthread_t *); static void fx_parmsget(kthread_t *, void *); static int fx_parmsset(kthread_t *, void *, id_t, cred_t *); static void fx_stop(kthread_t *, int, int); static void fx_exit(kthread_t *); static pri_t fx_swapin(kthread_t *, int); static pri_t fx_swapout(kthread_t *, int); static void fx_trapret(kthread_t *); static void fx_preempt(kthread_t *); static void fx_setrun(kthread_t *); static void fx_sleep(kthread_t *); static void fx_tick(kthread_t *); static void fx_wakeup(kthread_t *); static int fx_donice(kthread_t *, cred_t *, int, int *); static pri_t fx_globpri(kthread_t *); static void fx_yield(kthread_t *); static void fx_nullsys(); extern fxdpent_t *fx_getdptbl(void); static void fx_change_priority(kthread_t *, fxproc_t *); static fxproc_t *fx_list_lookup(kt_did_t); static void fx_list_release(fxproc_t *); static struct classfuncs fx_classfuncs = { /* class functions */ fx_admin, fx_getclinfo, fx_parmsin, fx_parmsout, fx_vaparmsin, fx_vaparmsout, fx_getclpri, fx_alloc, fx_free, /* thread functions */ fx_enterclass, fx_exitclass, fx_canexit, fx_fork, fx_forkret, fx_parmsget, fx_parmsset, fx_stop, fx_exit, fx_nullsys, /* active */ fx_nullsys, /* inactive */ fx_swapin, fx_swapout, fx_trapret, fx_preempt, fx_setrun, fx_sleep, fx_tick, fx_wakeup, fx_donice, fx_globpri, fx_nullsys, /* set_process_group */ fx_yield, }; int _init() { return (mod_install(&modlinkage)); } int _fini() { return (EBUSY); } int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } /* * Fixed priority class initialization. Called by dispinit() at boot time. * We can ignore the clparmsz argument since we know that the smallest * possible parameter buffer is big enough for us. */ /* ARGSUSED */ static pri_t fx_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp) { int i; extern pri_t fx_getmaxumdpri(void); fx_dptbl = fx_getdptbl(); fx_maxumdpri = fx_getmaxumdpri(); fx_maxglobpri = fx_dptbl[fx_maxumdpri].fx_globpri; fx_cid = cid; /* Record our class ID */ /* * Initialize the fxproc hash table */ for (i = 0; i < FX_LISTS; i++) { fx_plisthead[i].fx_next = fx_plisthead[i].fx_prev = &fx_plisthead[i]; } /* * Initialize the hash table for fxprocs with callbacks */ for (i = 0; i < FX_CB_LISTS; i++) { fx_cb_plisthead[i].fx_cb_next = fx_cb_plisthead[i].fx_cb_prev = &fx_cb_plisthead[i]; } /* * We're required to return a pointer to our classfuncs * structure and the highest global priority value we use. */ *clfuncspp = &fx_classfuncs; return (fx_maxglobpri); } /* * Get or reset the fx_dptbl values per the user's request. */ static int fx_admin(caddr_t uaddr, cred_t *reqpcredp) { fxadmin_t fxadmin; fxdpent_t *tmpdpp; int userdpsz; int i; size_t fxdpsz; if (get_udatamodel() == DATAMODEL_NATIVE) { if (copyin(uaddr, &fxadmin, sizeof (fxadmin_t))) return (EFAULT); } #ifdef _SYSCALL32_IMPL else { /* get fxadmin struct from ILP32 caller */ fxadmin32_t fxadmin32; if (copyin(uaddr, &fxadmin32, sizeof (fxadmin32_t))) return (EFAULT); fxadmin.fx_dpents = (struct fxdpent *)(uintptr_t)fxadmin32.fx_dpents; fxadmin.fx_ndpents = fxadmin32.fx_ndpents; fxadmin.fx_cmd = fxadmin32.fx_cmd; } #endif /* _SYSCALL32_IMPL */ fxdpsz = (fx_maxumdpri + 1) * sizeof (fxdpent_t); switch (fxadmin.fx_cmd) { case FX_GETDPSIZE: fxadmin.fx_ndpents = fx_maxumdpri + 1; if (get_udatamodel() == DATAMODEL_NATIVE) { if (copyout(&fxadmin, uaddr, sizeof (fxadmin_t))) return (EFAULT); } #ifdef _SYSCALL32_IMPL else { /* return fxadmin struct to ILP32 caller */ fxadmin32_t fxadmin32; fxadmin32.fx_dpents = (caddr32_t)(uintptr_t)fxadmin.fx_dpents; fxadmin32.fx_ndpents = fxadmin.fx_ndpents; fxadmin32.fx_cmd = fxadmin.fx_cmd; if (copyout(&fxadmin32, uaddr, sizeof (fxadmin32_t))) return (EFAULT); } #endif /* _SYSCALL32_IMPL */ break; case FX_GETDPTBL: userdpsz = MIN(fxadmin.fx_ndpents * sizeof (fxdpent_t), fxdpsz); if (copyout(fx_dptbl, fxadmin.fx_dpents, userdpsz)) return (EFAULT); fxadmin.fx_ndpents = userdpsz / sizeof (fxdpent_t); if (get_udatamodel() == DATAMODEL_NATIVE) { if (copyout(&fxadmin, uaddr, sizeof (fxadmin_t))) return (EFAULT); } #ifdef _SYSCALL32_IMPL else { /* return fxadmin struct to ILP32 callers */ fxadmin32_t fxadmin32; fxadmin32.fx_dpents = (caddr32_t)(uintptr_t)fxadmin.fx_dpents; fxadmin32.fx_ndpents = fxadmin.fx_ndpents; fxadmin32.fx_cmd = fxadmin.fx_cmd; if (copyout(&fxadmin32, uaddr, sizeof (fxadmin32_t))) return (EFAULT); } #endif /* _SYSCALL32_IMPL */ break; case FX_SETDPTBL: /* * We require that the requesting process has sufficient * privileges. We also require that the table supplied by * the user exactly match the current fx_dptbl in size. */ if (secpolicy_dispadm(reqpcredp) != 0) { return (EPERM); } if (fxadmin.fx_ndpents * sizeof (fxdpent_t) != fxdpsz) { return (EINVAL); } /* * We read the user supplied table into a temporary buffer * where it is validated before being copied over the * fx_dptbl. */ tmpdpp = kmem_alloc(fxdpsz, KM_SLEEP); if (copyin(fxadmin.fx_dpents, tmpdpp, fxdpsz)) { kmem_free(tmpdpp, fxdpsz); return (EFAULT); } for (i = 0; i < fxadmin.fx_ndpents; i++) { /* * Validate the user supplied values. All we are doing * here is verifying that the values are within their * allowable ranges and will not panic the system. We * make no attempt to ensure that the resulting * configuration makes sense or results in reasonable * performance. */ if (tmpdpp[i].fx_quantum <= 0 && tmpdpp[i].fx_quantum != FX_TQINF) { kmem_free(tmpdpp, fxdpsz); return (EINVAL); } } /* * Copy the user supplied values over the current fx_dptbl * values. The fx_globpri member is read-only so we don't * overwrite it. */ mutex_enter(&fx_dptblock); for (i = 0; i < fxadmin.fx_ndpents; i++) { fx_dptbl[i].fx_quantum = tmpdpp[i].fx_quantum; } mutex_exit(&fx_dptblock); kmem_free(tmpdpp, fxdpsz); break; default: return (EINVAL); } return (0); } /* * Allocate a fixed priority class specific thread structure and * initialize it with the parameters supplied. Also move the thread * to specified priority. */ static int fx_enterclass(kthread_t *t, id_t cid, void *parmsp, cred_t *reqpcredp, void *bufp) { fxkparms_t *fxkparmsp = (fxkparms_t *)parmsp; fxproc_t *fxpp; pri_t reqfxupri; pri_t reqfxuprilim; fxpp = (fxproc_t *)bufp; ASSERT(fxpp != NULL); /* * Initialize the fxproc structure. */ fxpp->fx_flags = 0; fxpp->fx_callback = NULL; fxpp->fx_cookie = NULL; if (fxkparmsp == NULL) { /* * Use default values. */ fxpp->fx_pri = fxpp->fx_uprilim = 0; fxpp->fx_pquantum = fx_dptbl[fxpp->fx_pri].fx_quantum; fxpp->fx_nice = NZERO; } else { /* * Use supplied values. */ if ((fxkparmsp->fx_cflags & FX_DOUPRILIM) == 0) { reqfxuprilim = 0; } else { if (fxkparmsp->fx_uprilim > FX_MAX_UNPRIV_PRI && secpolicy_setpriority(reqpcredp) != 0) return (EPERM); reqfxuprilim = fxkparmsp->fx_uprilim; FX_ADJUST_PRI(reqfxuprilim); } if ((fxkparmsp->fx_cflags & FX_DOUPRI) == 0) { reqfxupri = reqfxuprilim; } else { if (fxkparmsp->fx_upri > FX_MAX_UNPRIV_PRI && secpolicy_setpriority(reqpcredp) != 0) return (EPERM); /* * Set the user priority to the requested value * or the upri limit, whichever is lower. */ reqfxupri = fxkparmsp->fx_upri; FX_ADJUST_PRI(reqfxupri); if (reqfxupri > reqfxuprilim) reqfxupri = reqfxuprilim; } fxpp->fx_uprilim = reqfxuprilim; fxpp->fx_pri = reqfxupri; fxpp->fx_nice = NZERO - (NZERO * reqfxupri) / fx_maxupri; if (((fxkparmsp->fx_cflags & FX_DOTQ) == 0) || (fxkparmsp->fx_tqntm == FX_TQDEF)) { fxpp->fx_pquantum = fx_dptbl[fxpp->fx_pri].fx_quantum; } else { if (secpolicy_setpriority(reqpcredp) != 0) return (EPERM); if (fxkparmsp->fx_tqntm == FX_TQINF) fxpp->fx_pquantum = FX_TQINF; else { fxpp->fx_pquantum = fxkparmsp->fx_tqntm; } } } fxpp->fx_timeleft = fxpp->fx_pquantum; fxpp->fx_tp = t; thread_lock(t); /* get dispatcher lock on thread */ t->t_clfuncs = &(sclass[cid].cl_funcs->thread); t->t_cid = cid; t->t_cldata = (void *)fxpp; t->t_schedflag &= ~TS_RUNQMATCH; fx_change_priority(t, fxpp); thread_unlock(t); FX_LIST_INSERT(fxpp); return (0); } /* * The thread is exiting. */ static void fx_exit(kthread_t *t) { fxproc_t *fxpp; thread_lock(t); fxpp = (fxproc_t *)(t->t_cldata); if (FX_HAS_CB(fxpp)) { FX_CB_EXIT(FX_CALLB(fxpp), fxpp->fx_cookie); fxpp->fx_callback = NULL; fxpp->fx_cookie = NULL; thread_unlock(t); FX_CB_LIST_DELETE(fxpp); return; } thread_unlock(t); } /* * Exiting the class. Free fxproc structure of thread. */ static void fx_exitclass(void *procp) { fxproc_t *fxpp = (fxproc_t *)procp; thread_lock(fxpp->fx_tp); if (FX_HAS_CB(fxpp)) { FX_CB_EXIT(FX_CALLB(fxpp), fxpp->fx_cookie); fxpp->fx_callback = NULL; fxpp->fx_cookie = NULL; thread_unlock(fxpp->fx_tp); FX_CB_LIST_DELETE(fxpp); } else thread_unlock(fxpp->fx_tp); FX_LIST_DELETE(fxpp); kmem_free(fxpp, sizeof (fxproc_t)); } /* ARGSUSED */ static int fx_canexit(kthread_t *t, cred_t *cred) { /* * A thread can always leave the FX class */ return (0); } /* * Initialize fixed-priority class specific proc structure for a child. * callbacks are not inherited upon fork. */ static int fx_fork(kthread_t *t, kthread_t *ct, void *bufp) { fxproc_t *pfxpp; /* ptr to parent's fxproc structure */ fxproc_t *cfxpp; /* ptr to child's fxproc structure */ ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock)); cfxpp = (fxproc_t *)bufp; ASSERT(cfxpp != NULL); thread_lock(t); pfxpp = (fxproc_t *)t->t_cldata; /* * Initialize child's fxproc structure. */ cfxpp->fx_timeleft = cfxpp->fx_pquantum = pfxpp->fx_pquantum; cfxpp->fx_pri = pfxpp->fx_pri; cfxpp->fx_uprilim = pfxpp->fx_uprilim; cfxpp->fx_nice = pfxpp->fx_nice; cfxpp->fx_callback = NULL; cfxpp->fx_cookie = NULL; cfxpp->fx_flags = pfxpp->fx_flags & ~(FXBACKQ); cfxpp->fx_tp = ct; ct->t_cldata = (void *)cfxpp; thread_unlock(t); /* * Link new structure into fxproc list. */ FX_LIST_INSERT(cfxpp); return (0); } /* * Child is placed at back of dispatcher queue and parent gives * up processor so that the child runs first after the fork. * This allows the child immediately execing to break the multiple * use of copy on write pages with no disk home. The parent will * get to steal them back rather than uselessly copying them. */ static void fx_forkret(kthread_t *t, kthread_t *ct) { proc_t *pp = ttoproc(t); proc_t *cp = ttoproc(ct); fxproc_t *fxpp; ASSERT(t == curthread); ASSERT(MUTEX_HELD(&pidlock)); /* * Grab the child's p_lock before dropping pidlock to ensure * the process does not disappear before we set it running. */ mutex_enter(&cp->p_lock); mutex_exit(&pidlock); continuelwps(cp); mutex_exit(&cp->p_lock); mutex_enter(&pp->p_lock); continuelwps(pp); mutex_exit(&pp->p_lock); thread_lock(t); fxpp = (fxproc_t *)(t->t_cldata); t->t_pri = fx_dptbl[fxpp->fx_pri].fx_globpri; ASSERT(t->t_pri >= 0 && t->t_pri <= fx_maxglobpri); THREAD_TRANSITION(t); fx_setrun(t); thread_unlock(t); swtch(); } /* * Get information about the fixed-priority class into the buffer * pointed to by fxinfop. The maximum configured user priority * is the only information we supply. */ static int fx_getclinfo(void *infop) { fxinfo_t *fxinfop = (fxinfo_t *)infop; fxinfop->fx_maxupri = fx_maxupri; return (0); } /* * Return the global scheduling priority ranges for the fixed-priority * class in pcpri_t structure. */ static int fx_getclpri(pcpri_t *pcprip) { pcprip->pc_clpmax = fx_dptbl[fx_maxumdpri].fx_globpri; pcprip->pc_clpmin = fx_dptbl[0].fx_globpri; return (0); } static void fx_nullsys() {} /* * Get the fixed-priority parameters of the thread pointed to by * fxprocp into the buffer pointed to by fxparmsp. */ static void fx_parmsget(kthread_t *t, void *parmsp) { fxproc_t *fxpp = (fxproc_t *)t->t_cldata; fxkparms_t *fxkparmsp = (fxkparms_t *)parmsp; fxkparmsp->fx_upri = fxpp->fx_pri; fxkparmsp->fx_uprilim = fxpp->fx_uprilim; fxkparmsp->fx_tqntm = fxpp->fx_pquantum; } /* * Check the validity of the fixed-priority parameters in the buffer * pointed to by fxparmsp. */ static int fx_parmsin(void *parmsp) { fxparms_t *fxparmsp = (fxparms_t *)parmsp; uint_t cflags; longlong_t ticks; /* * Check validity of parameters. */ if ((fxparmsp->fx_uprilim > fx_maxupri || fxparmsp->fx_uprilim < 0) && fxparmsp->fx_uprilim != FX_NOCHANGE) return (EINVAL); if ((fxparmsp->fx_upri > fx_maxupri || fxparmsp->fx_upri < 0) && fxparmsp->fx_upri != FX_NOCHANGE) return (EINVAL); if ((fxparmsp->fx_tqsecs == 0 && fxparmsp->fx_tqnsecs == 0) || fxparmsp->fx_tqnsecs >= NANOSEC) return (EINVAL); cflags = (fxparmsp->fx_upri != FX_NOCHANGE ? FX_DOUPRI : 0); if (fxparmsp->fx_uprilim != FX_NOCHANGE) { cflags |= FX_DOUPRILIM; } if (fxparmsp->fx_tqnsecs != FX_NOCHANGE) cflags |= FX_DOTQ; /* * convert the buffer to kernel format. */ if (fxparmsp->fx_tqnsecs >= 0) { if ((ticks = SEC_TO_TICK((longlong_t)fxparmsp->fx_tqsecs) + NSEC_TO_TICK_ROUNDUP(fxparmsp->fx_tqnsecs)) > INT_MAX) return (ERANGE); ((fxkparms_t *)fxparmsp)->fx_tqntm = (int)ticks; } else { if ((fxparmsp->fx_tqnsecs != FX_NOCHANGE) && (fxparmsp->fx_tqnsecs != FX_TQINF) && (fxparmsp->fx_tqnsecs != FX_TQDEF)) return (EINVAL); ((fxkparms_t *)fxparmsp)->fx_tqntm = fxparmsp->fx_tqnsecs; } ((fxkparms_t *)fxparmsp)->fx_cflags = cflags; return (0); } /* * Check the validity of the fixed-priority parameters in the pc_vaparms_t * structure vaparmsp and put them in the buffer pointed to by fxprmsp. * pc_vaparms_t contains (key, value) pairs of parameter. */ static int fx_vaparmsin(void *prmsp, pc_vaparms_t *vaparmsp) { uint_t secs = 0; uint_t cnt; int nsecs = 0; int priflag, secflag, nsecflag, limflag; longlong_t ticks; fxkparms_t *fxprmsp = (fxkparms_t *)prmsp; pc_vaparm_t *vpp = &vaparmsp->pc_parms[0]; /* * First check the validity of parameters and convert them * from the user supplied format to the internal format. */ priflag = secflag = nsecflag = limflag = 0; fxprmsp->fx_cflags = 0; if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT) return (EINVAL); for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) { switch (vpp->pc_key) { case FX_KY_UPRILIM: if (limflag++) return (EINVAL); fxprmsp->fx_cflags |= FX_DOUPRILIM; fxprmsp->fx_uprilim = (pri_t)vpp->pc_parm; if (fxprmsp->fx_uprilim > fx_maxupri || fxprmsp->fx_uprilim < 0) return (EINVAL); break; case FX_KY_UPRI: if (priflag++) return (EINVAL); fxprmsp->fx_cflags |= FX_DOUPRI; fxprmsp->fx_upri = (pri_t)vpp->pc_parm; if (fxprmsp->fx_upri > fx_maxupri || fxprmsp->fx_upri < 0) return (EINVAL); break; case FX_KY_TQSECS: if (secflag++) return (EINVAL); fxprmsp->fx_cflags |= FX_DOTQ; secs = (uint_t)vpp->pc_parm; break; case FX_KY_TQNSECS: if (nsecflag++) return (EINVAL); fxprmsp->fx_cflags |= FX_DOTQ; nsecs = (int)vpp->pc_parm; break; default: return (EINVAL); } } if (vaparmsp->pc_vaparmscnt == 0) { /* * Use default parameters. */ fxprmsp->fx_upri = 0; fxprmsp->fx_uprilim = 0; fxprmsp->fx_tqntm = FX_TQDEF; fxprmsp->fx_cflags = FX_DOUPRI | FX_DOUPRILIM | FX_DOTQ; } else if ((fxprmsp->fx_cflags & FX_DOTQ) != 0) { if ((secs == 0 && nsecs == 0) || nsecs >= NANOSEC) return (EINVAL); if (nsecs >= 0) { if ((ticks = SEC_TO_TICK((longlong_t)secs) + NSEC_TO_TICK_ROUNDUP(nsecs)) > INT_MAX) return (ERANGE); fxprmsp->fx_tqntm = (int)ticks; } else { if (nsecs != FX_TQINF && nsecs != FX_TQDEF) return (EINVAL); fxprmsp->fx_tqntm = nsecs; } } return (0); } /* * Nothing to do here but return success. */ /* ARGSUSED */ static int fx_parmsout(void *parmsp, pc_vaparms_t *vaparmsp) { register fxkparms_t *fxkprmsp = (fxkparms_t *)parmsp; if (vaparmsp != NULL) return (0); if (fxkprmsp->fx_tqntm < 0) { /* * Quantum field set to special value (e.g. FX_TQINF) */ ((fxparms_t *)fxkprmsp)->fx_tqnsecs = fxkprmsp->fx_tqntm; ((fxparms_t *)fxkprmsp)->fx_tqsecs = 0; } else { /* Convert quantum from ticks to seconds-nanoseconds */ timestruc_t ts; TICK_TO_TIMESTRUC(fxkprmsp->fx_tqntm, &ts); ((fxparms_t *)fxkprmsp)->fx_tqsecs = ts.tv_sec; ((fxparms_t *)fxkprmsp)->fx_tqnsecs = ts.tv_nsec; } return (0); } /* * Copy all selected fixed-priority class parameters to the user. * The parameters are specified by a key. */ static int fx_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp) { fxkparms_t *fxkprmsp = (fxkparms_t *)prmsp; timestruc_t ts; uint_t cnt; uint_t secs; int nsecs; int priflag, secflag, nsecflag, limflag; pc_vaparm_t *vpp = &vaparmsp->pc_parms[0]; ASSERT(MUTEX_NOT_HELD(&curproc->p_lock)); priflag = secflag = nsecflag = limflag = 0; if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT) return (EINVAL); if (fxkprmsp->fx_tqntm < 0) { /* * Quantum field set to special value (e.g. FX_TQINF). */ secs = 0; nsecs = fxkprmsp->fx_tqntm; } else { /* * Convert quantum from ticks to seconds-nanoseconds. */ TICK_TO_TIMESTRUC(fxkprmsp->fx_tqntm, &ts); secs = ts.tv_sec; nsecs = ts.tv_nsec; } for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) { switch (vpp->pc_key) { case FX_KY_UPRILIM: if (limflag++) return (EINVAL); if (copyout(&fxkprmsp->fx_uprilim, (void *)(uintptr_t)vpp->pc_parm, sizeof (pri_t))) return (EFAULT); break; case FX_KY_UPRI: if (priflag++) return (EINVAL); if (copyout(&fxkprmsp->fx_upri, (void *)(uintptr_t)vpp->pc_parm, sizeof (pri_t))) return (EFAULT); break; case FX_KY_TQSECS: if (secflag++) return (EINVAL); if (copyout(&secs, (void *)(uintptr_t)vpp->pc_parm, sizeof (uint_t))) return (EFAULT); break; case FX_KY_TQNSECS: if (nsecflag++) return (EINVAL); if (copyout(&nsecs, (void *)(uintptr_t)vpp->pc_parm, sizeof (int))) return (EFAULT); break; default: return (EINVAL); } } return (0); } /* * Set the scheduling parameters of the thread pointed to by fxprocp * to those specified in the buffer pointed to by fxparmsp. */ /* ARGSUSED */ static int fx_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp) { char nice; pri_t reqfxuprilim; pri_t reqfxupri; fxkparms_t *fxkparmsp = (fxkparms_t *)parmsp; fxproc_t *fxpp; ASSERT(MUTEX_HELD(&(ttoproc(tx))->p_lock)); thread_lock(tx); fxpp = (fxproc_t *)tx->t_cldata; if ((fxkparmsp->fx_cflags & FX_DOUPRILIM) == 0) reqfxuprilim = fxpp->fx_uprilim; else reqfxuprilim = fxkparmsp->fx_uprilim; /* * Basic permissions enforced by generic kernel code * for all classes require that a thread attempting * to change the scheduling parameters of a target * thread be privileged or have a real or effective * UID matching that of the target thread. We are not * called unless these basic permission checks have * already passed. The fixed priority class requires in * addition that the calling thread be privileged if it * is attempting to raise the pri above its current * value This may have been checked previously but if our * caller passed us a non-NULL credential pointer we assume * it hasn't and we check it here. */ if ((reqpcredp != NULL) && (reqfxuprilim > fxpp->fx_uprilim || ((fxkparmsp->fx_cflags & FX_DOTQ) != 0)) && secpolicy_setpriority(reqpcredp) != 0) { thread_unlock(tx); return (EPERM); } FX_ADJUST_PRI(reqfxuprilim); if ((fxkparmsp->fx_cflags & FX_DOUPRI) == 0) reqfxupri = fxpp->fx_pri; else reqfxupri = fxkparmsp->fx_upri; /* * Make sure the user priority doesn't exceed the upri limit. */ if (reqfxupri > reqfxuprilim) reqfxupri = reqfxuprilim; /* * Set fx_nice to the nice value corresponding to the user * priority we are setting. Note that setting the nice field * of the parameter struct won't affect upri or nice. */ nice = NZERO - (reqfxupri * NZERO) / fx_maxupri; if (nice > NZERO) nice = NZERO; fxpp->fx_uprilim = reqfxuprilim; fxpp->fx_pri = reqfxupri; if (fxkparmsp->fx_tqntm == FX_TQINF) fxpp->fx_pquantum = FX_TQINF; else if (fxkparmsp->fx_tqntm == FX_TQDEF) fxpp->fx_pquantum = fx_dptbl[fxpp->fx_pri].fx_quantum; else if ((fxkparmsp->fx_cflags & FX_DOTQ) != 0) fxpp->fx_pquantum = fxkparmsp->fx_tqntm; fxpp->fx_nice = nice; fx_change_priority(tx, fxpp); thread_unlock(tx); return (0); } /* * Return the global scheduling priority that would be assigned * to a thread entering the fixed-priority class with the fx_upri. */ static pri_t fx_globpri(kthread_t *t) { fxproc_t *fxpp; ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock)); fxpp = (fxproc_t *)t->t_cldata; return (fx_dptbl[fxpp->fx_pri].fx_globpri); } /* * Arrange for thread to be placed in appropriate location * on dispatcher queue. * * This is called with the current thread in TS_ONPROC and locked. */ static void fx_preempt(kthread_t *t) { fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); #ifdef KSLICE extern int kslice; #endif ASSERT(t == curthread); ASSERT(THREAD_LOCK_HELD(curthread)); /* * Check to see if we're doing "preemption control" here. If * we are, and if the user has requested that this thread not * be preempted, and if preemptions haven't been put off for * too long, let the preemption happen here but try to make * sure the thread is rescheduled as soon as possible. We do * this by putting it on the front of the highest priority run * queue in the FX class. If the preemption has been put off * for too long, clear the "nopreempt" bit and let the thread * be preempted. */ if (t->t_schedctl && schedctl_get_nopreempt(t)) { if (fxpp->fx_pquantum == FX_TQINF || fxpp->fx_timeleft > -SC_MAX_TICKS) { DTRACE_SCHED1(schedctl__nopreempt, kthread_t *, t); schedctl_set_yield(t, 1); setfrontdq(t); return; } else { schedctl_set_nopreempt(t, 0); DTRACE_SCHED1(schedctl__preempt, kthread_t *, t); TNF_PROBE_2(schedctl_preempt, "schedctl FX fx_preempt", /* CSTYLED */, tnf_pid, pid, ttoproc(t)->p_pid, tnf_lwpid, lwpid, t->t_tid); /* * Fall through and be preempted below. */ } } if (FX_HAS_CB(fxpp)) { clock_t new_quantum = (clock_t)fxpp->fx_pquantum; pri_t newpri = fxpp->fx_pri; FX_CB_PREEMPT(FX_CALLB(fxpp), fxpp->fx_cookie, &new_quantum, &newpri); FX_ADJUST_QUANTUM(new_quantum); if ((int)new_quantum != fxpp->fx_pquantum) { fxpp->fx_pquantum = (int)new_quantum; fxpp->fx_timeleft = fxpp->fx_pquantum; } FX_ADJUST_PRI(newpri); fxpp->fx_pri = newpri; THREAD_CHANGE_PRI(t, fx_dptbl[fxpp->fx_pri].fx_globpri); } if ((fxpp->fx_flags & (FXBACKQ)) == FXBACKQ) { fxpp->fx_timeleft = fxpp->fx_pquantum; fxpp->fx_flags &= ~FXBACKQ; setbackdq(t); } else { #ifdef KSLICE if (kslice) setbackdq(t); else #endif setfrontdq(t); } } static void fx_setrun(kthread_t *t) { fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); ASSERT(THREAD_LOCK_HELD(t)); /* t should be in transition */ fxpp->fx_flags &= ~FXBACKQ; if (t->t_disp_time != lbolt) setbackdq(t); else setfrontdq(t); } /* * Prepare thread for sleep. We reset the thread priority so it will * run at the kernel priority level when it wakes up. */ static void fx_sleep(kthread_t *t) { fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); ASSERT(t == curthread); ASSERT(THREAD_LOCK_HELD(t)); if (FX_HAS_CB(fxpp)) { FX_CB_SLEEP(FX_CALLB(fxpp), fxpp->fx_cookie); } t->t_stime = lbolt; /* time stamp for the swapper */ } /* * Return Values: * * -1 if the thread is loaded or is not eligible to be swapped in. * * FX and RT threads are designed so that they don't swapout; however, * it is possible that while the thread is swapped out and in another class, it * can be changed to FX or RT. Since these threads should be swapped in * as soon as they're runnable, rt_swapin returns SHRT_MAX, and fx_swapin * returns SHRT_MAX - 1, so that it gives deference to any swapped out * RT threads. */ /* ARGSUSED */ static pri_t fx_swapin(kthread_t *t, int flags) { pri_t tpri = -1; ASSERT(THREAD_LOCK_HELD(t)); if (t->t_state == TS_RUN && (t->t_schedflag & TS_LOAD) == 0) { tpri = (pri_t)SHRT_MAX - 1; } return (tpri); } /* * Return Values * -1 if the thread isn't loaded or is not eligible to be swapped out. */ /* ARGSUSED */ static pri_t fx_swapout(kthread_t *t, int flags) { ASSERT(THREAD_LOCK_HELD(t)); return (-1); } /* ARGSUSED */ static void fx_stop(kthread_t *t, int why, int what) { fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); ASSERT(THREAD_LOCK_HELD(t)); if (FX_HAS_CB(fxpp)) { FX_CB_STOP(FX_CALLB(fxpp), fxpp->fx_cookie); } } /* * Check for time slice expiration. If time slice has expired * set runrun to cause preemption. */ static void fx_tick(kthread_t *t) { fxproc_t *fxpp; ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock)); thread_lock(t); fxpp = (fxproc_t *)(t->t_cldata); if (FX_HAS_CB(fxpp)) { clock_t new_quantum = (clock_t)fxpp->fx_pquantum; pri_t newpri = fxpp->fx_pri; FX_CB_TICK(FX_CALLB(fxpp), fxpp->fx_cookie, &new_quantum, &newpri); FX_ADJUST_QUANTUM(new_quantum); if ((int)new_quantum != fxpp->fx_pquantum) { fxpp->fx_pquantum = (int)new_quantum; fxpp->fx_timeleft = fxpp->fx_pquantum; } FX_ADJUST_PRI(newpri); if (newpri != fxpp->fx_pri) { fxpp->fx_pri = newpri; fx_change_priority(t, fxpp); } } if ((fxpp->fx_pquantum != FX_TQINF) && (--fxpp->fx_timeleft <= 0)) { pri_t new_pri; /* * If we're doing preemption control and trying to * avoid preempting this thread, just note that * the thread should yield soon and let it keep * running (unless it's been a while). */ if (t->t_schedctl && schedctl_get_nopreempt(t)) { if (fxpp->fx_timeleft > -SC_MAX_TICKS) { DTRACE_SCHED1(schedctl__nopreempt, kthread_t *, t); schedctl_set_yield(t, 1); thread_unlock_nopreempt(t); return; } TNF_PROBE_2(schedctl_failsafe, "schedctl FX fx_tick", /* CSTYLED */, tnf_pid, pid, ttoproc(t)->p_pid, tnf_lwpid, lwpid, t->t_tid); } new_pri = fx_dptbl[fxpp->fx_pri].fx_globpri; ASSERT(new_pri >= 0 && new_pri <= fx_maxglobpri); /* * When the priority of a thread is changed, * it may be necessary to adjust its position * on a sleep queue or dispatch queue. Even * when the priority is not changed, we need * to preserve round robin on dispatch queue. * The function thread_change_pri accomplishes * this. */ if (thread_change_pri(t, new_pri, 0)) { fxpp->fx_timeleft = fxpp->fx_pquantum; } else { fxpp->fx_flags |= FXBACKQ; cpu_surrender(t); } } else if (t->t_pri < t->t_disp_queue->disp_maxrunpri) { fxpp->fx_flags |= FXBACKQ; cpu_surrender(t); } thread_unlock_nopreempt(t); /* clock thread can't be preempted */ } static void fx_trapret(kthread_t *t) { cpu_t *cp = CPU; ASSERT(THREAD_LOCK_HELD(t)); ASSERT(t == curthread); ASSERT(cp->cpu_dispthread == t); ASSERT(t->t_state == TS_ONPROC); } /* * Processes waking up go to the back of their queue. */ static void fx_wakeup(kthread_t *t) { fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); ASSERT(THREAD_LOCK_HELD(t)); t->t_stime = lbolt; /* time stamp for the swapper */ if (FX_HAS_CB(fxpp)) { clock_t new_quantum = (clock_t)fxpp->fx_pquantum; pri_t newpri = fxpp->fx_pri; FX_CB_WAKEUP(FX_CALLB(fxpp), fxpp->fx_cookie, &new_quantum, &newpri); FX_ADJUST_QUANTUM(new_quantum); if ((int)new_quantum != fxpp->fx_pquantum) { fxpp->fx_pquantum = (int)new_quantum; fxpp->fx_timeleft = fxpp->fx_pquantum; } FX_ADJUST_PRI(newpri); if (newpri != fxpp->fx_pri) { fxpp->fx_pri = newpri; THREAD_CHANGE_PRI(t, fx_dptbl[fxpp->fx_pri].fx_globpri); } } fxpp->fx_flags &= ~FXBACKQ; if (t->t_disp_time != lbolt) setbackdq(t); else setfrontdq(t); } /* * When a thread yields, put it on the back of the run queue. */ static void fx_yield(kthread_t *t) { fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); ASSERT(t == curthread); ASSERT(THREAD_LOCK_HELD(t)); if (FX_HAS_CB(fxpp)) { clock_t new_quantum = (clock_t)fxpp->fx_pquantum; pri_t newpri = fxpp->fx_pri; FX_CB_PREEMPT(FX_CALLB(fxpp), fxpp->fx_cookie, &new_quantum, &newpri); FX_ADJUST_QUANTUM(new_quantum); if ((int)new_quantum != fxpp->fx_pquantum) { fxpp->fx_pquantum = (int)new_quantum; fxpp->fx_timeleft = fxpp->fx_pquantum; } FX_ADJUST_PRI(newpri); fxpp->fx_pri = newpri; THREAD_CHANGE_PRI(t, fx_dptbl[fxpp->fx_pri].fx_globpri); } /* * Clear the preemption control "yield" bit since the user is * doing a yield. */ if (t->t_schedctl) schedctl_set_yield(t, 0); if (fxpp->fx_timeleft <= 0) { /* * Time slice was artificially extended to avoid * preemption, so pretend we're preempting it now. */ DTRACE_SCHED1(schedctl__yield, int, -fxpp->fx_timeleft); fxpp->fx_timeleft = fxpp->fx_pquantum; THREAD_CHANGE_PRI(t, fx_dptbl[fxpp->fx_pri].fx_globpri); ASSERT(t->t_pri >= 0 && t->t_pri <= fx_maxglobpri); } fxpp->fx_flags &= ~FXBACKQ; setbackdq(t); } /* * Increment the nice value of the specified thread by incr and * return the new value in *retvalp. */ static int fx_donice(kthread_t *t, cred_t *cr, int incr, int *retvalp) { int newnice; fxproc_t *fxpp = (fxproc_t *)(t->t_cldata); fxkparms_t fxkparms; ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock)); /* If there's no change to priority, just return current setting */ if (incr == 0) { if (retvalp) { *retvalp = fxpp->fx_nice - NZERO; } return (0); } if ((incr < 0 || incr > 2 * NZERO) && secpolicy_setpriority(cr) != 0) return (EPERM); /* * Specifying a nice increment greater than the upper limit of * 2 * NZERO - 1 will result in the thread's nice value being * set to the upper limit. We check for this before computing * the new value because otherwise we could get overflow * if a privileged user specified some ridiculous increment. */ if (incr > 2 * NZERO - 1) incr = 2 * NZERO - 1; newnice = fxpp->fx_nice + incr; if (newnice > NZERO) newnice = NZERO; else if (newnice < 0) newnice = 0; fxkparms.fx_uprilim = fxkparms.fx_upri = -((newnice - NZERO) * fx_maxupri) / NZERO; fxkparms.fx_cflags = FX_DOUPRILIM | FX_DOUPRI; fxkparms.fx_tqntm = FX_TQDEF; /* * Reset the uprilim and upri values of the thread. Adjust * time quantum accordingly. */ (void) fx_parmsset(t, (void *)&fxkparms, (id_t)0, (cred_t *)NULL); /* * Although fx_parmsset already reset fx_nice it may * not have been set to precisely the value calculated above * because fx_parmsset determines the nice value from the * user priority and we may have truncated during the integer * conversion from nice value to user priority and back. * We reset fx_nice to the value we calculated above. */ fxpp->fx_nice = (char)newnice; if (retvalp) *retvalp = newnice - NZERO; return (0); } static void fx_change_priority(kthread_t *t, fxproc_t *fxpp) { pri_t new_pri; ASSERT(THREAD_LOCK_HELD(t)); new_pri = fx_dptbl[fxpp->fx_pri].fx_globpri; ASSERT(new_pri >= 0 && new_pri <= fx_maxglobpri); if (t == curthread || t->t_state == TS_ONPROC) { /* curthread is always onproc */ cpu_t *cp = t->t_disp_queue->disp_cpu; THREAD_CHANGE_PRI(t, new_pri); if (t == cp->cpu_dispthread) cp->cpu_dispatch_pri = DISP_PRIO(t); if (DISP_MUST_SURRENDER(t)) { fxpp->fx_flags |= FXBACKQ; cpu_surrender(t); } else { fxpp->fx_timeleft = fxpp->fx_pquantum; } } else { /* * When the priority of a thread is changed, * it may be necessary to adjust its position * on a sleep queue or dispatch queue. * The function thread_change_pri accomplishes * this. */ if (thread_change_pri(t, new_pri, 0)) { /* * The thread was on a run queue. Reset * its CPU timeleft from the quantum * associated with the new priority. */ fxpp->fx_timeleft = fxpp->fx_pquantum; } else { fxpp->fx_flags |= FXBACKQ; } } } static int fx_alloc(void **p, int flag) { void *bufp; bufp = kmem_alloc(sizeof (fxproc_t), flag); if (bufp == NULL) { return (ENOMEM); } else { *p = bufp; return (0); } } static void fx_free(void *bufp) { if (bufp) kmem_free(bufp, sizeof (fxproc_t)); } /* * Release the callback list mutex after successful lookup */ void fx_list_release(fxproc_t *fxpp) { int index = FX_CB_LIST_HASH(fxpp->fx_ktid); kmutex_t *lockp = &fx_cb_list_lock[index]; mutex_exit(lockp); } fxproc_t * fx_list_lookup(kt_did_t ktid) { int index = FX_CB_LIST_HASH(ktid); kmutex_t *lockp = &fx_cb_list_lock[index]; fxproc_t *fxpp; mutex_enter(lockp); for (fxpp = fx_cb_plisthead[index].fx_cb_next; fxpp != &fx_cb_plisthead[index]; fxpp = fxpp->fx_cb_next) { if (fxpp->fx_tp->t_cid == fx_cid && fxpp->fx_ktid == ktid && fxpp->fx_callback != NULL) { /* * The caller is responsible for calling * fx_list_release to drop the lock upon * successful lookup */ return (fxpp); } } mutex_exit(lockp); return ((fxproc_t *)NULL); } /* * register a callback set of routines for current thread * thread should already be in FX class */ int fx_register_callbacks(fx_callbacks_t *fx_callback, fx_cookie_t cookie, pri_t pri, clock_t quantum) { fxproc_t *fxpp; if (fx_callback == NULL) return (EINVAL); if (secpolicy_dispadm(CRED()) != 0) return (EPERM); if (FX_CB_VERSION(fx_callback) != FX_CALLB_REV) return (EINVAL); if (!FX_ISVALID(pri, quantum)) return (EINVAL); thread_lock(curthread); /* get dispatcher lock on thread */ if (curthread->t_cid != fx_cid) { thread_unlock(curthread); return (EINVAL); } fxpp = (fxproc_t *)(curthread->t_cldata); ASSERT(fxpp != NULL); if (FX_HAS_CB(fxpp)) { thread_unlock(curthread); return (EINVAL); } fxpp->fx_callback = fx_callback; fxpp->fx_cookie = cookie; if (pri != FX_CB_NOCHANGE) { fxpp->fx_pri = pri; FX_ADJUST_PRI(fxpp->fx_pri); if (quantum == FX_TQDEF) { fxpp->fx_pquantum = fx_dptbl[fxpp->fx_pri].fx_quantum; } else if (quantum == FX_TQINF) { fxpp->fx_pquantum = FX_TQINF; } else if (quantum != FX_NOCHANGE) { FX_ADJUST_QUANTUM(quantum); fxpp->fx_pquantum = quantum; } } else if (quantum != FX_NOCHANGE && quantum != FX_TQDEF) { if (quantum == FX_TQINF) fxpp->fx_pquantum = FX_TQINF; else { FX_ADJUST_QUANTUM(quantum); fxpp->fx_pquantum = quantum; } } fxpp->fx_ktid = ddi_get_kt_did(); fx_change_priority(curthread, fxpp); thread_unlock(curthread); /* * Link new structure into fxproc list. */ FX_CB_LIST_INSERT(fxpp); return (0); } /* unregister a callback set of routines for current thread */ int fx_unregister_callbacks() { fxproc_t *fxpp; if ((fxpp = fx_list_lookup(ddi_get_kt_did())) == NULL) { /* * did not have a registered callback; */ return (EINVAL); } thread_lock(fxpp->fx_tp); fxpp->fx_callback = NULL; fxpp->fx_cookie = NULL; thread_unlock(fxpp->fx_tp); fx_list_release(fxpp); FX_CB_LIST_DELETE(fxpp); return (0); } /* * modify priority and/or quantum value of a thread with callback */ int fx_modify_priority(kt_did_t ktid, clock_t quantum, pri_t pri) { fxproc_t *fxpp; if (!FX_ISVALID(pri, quantum)) return (EINVAL); if ((fxpp = fx_list_lookup(ktid)) == NULL) { /* * either thread had exited or did not have a registered * callback; */ return (ESRCH); } thread_lock(fxpp->fx_tp); if (pri != FX_CB_NOCHANGE) { fxpp->fx_pri = pri; FX_ADJUST_PRI(fxpp->fx_pri); if (quantum == FX_TQDEF) { fxpp->fx_pquantum = fx_dptbl[fxpp->fx_pri].fx_quantum; } else if (quantum == FX_TQINF) { fxpp->fx_pquantum = FX_TQINF; } else if (quantum != FX_NOCHANGE) { FX_ADJUST_QUANTUM(quantum); fxpp->fx_pquantum = quantum; } } else if (quantum != FX_NOCHANGE && quantum != FX_TQDEF) { if (quantum == FX_TQINF) { fxpp->fx_pquantum = FX_TQINF; } else { FX_ADJUST_QUANTUM(quantum); fxpp->fx_pquantum = quantum; } } fx_change_priority(fxpp->fx_tp, fxpp); thread_unlock(fxpp->fx_tp); fx_list_release(fxpp); return (0); } /* * return an iblock cookie for mutex initialization to be used in callbacks */ void * fx_get_mutex_cookie() { return ((void *)(uintptr_t)__ipltospl(DISP_LEVEL)); } /* * return maximum relative priority */ pri_t fx_get_maxpri() { return (fx_maxumdpri); }