/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "synonyms.h"
#include "thr_uberdata.h"
#include <sched.h>
#include <sys/tspriocntl.h>
#include <sys/rtpriocntl.h>
#include <sys/fxpriocntl.h>

/*
 * The following array is used for caching information
 * for priocntl scheduling classes.
 */
static pcclass_t sched_class[] = {
	{0, SCHED_OTHER, 0, 0, {-1, "TS",  0}},
	{0, SCHED_FIFO,	 0, 0, {-1, "RT",  0}},
	{0, SCHED_RR,	 0, 0, {-1, "RT",  0}},
	{0, SCHED_SYS,	 0, 0, {0,  "SYS", 0}},
	{0, SCHED_IA,	 0, 0, {-1, "IA",  0}},
	{0, SCHED_FSS,	 0, 0, {-1, "FSS", 0}},
	{0, SCHED_FX,	 0, 0, {-1, "FX",  0}},
	/*
	 * Allow unknown (to us) scheduling classes.
	 * The kernel allows space for exactly 10 scheduling classes
	 * (see the definitions of 'sclass' and 'nclass' in the kernel).
	 * We need that number of available slots here.
	 * If the kernel space is changed, this has to change too.
	 */
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
	{0, -1,		 0, 0, {-1, "",	   0}},
};

#define	NPOLICY	(sizeof (sched_class) / sizeof (pcclass_t))

#if _SCHED_NEXT != SCHED_FX + 1
#error "fatal: _SCHED_NEXT != SCHED_FX + 1"
#endif

static mutex_t class_lock = DEFAULTMUTEX;	/* protects sched_class[] */

/*
 * Helper function for get_info_by_policy(), below.
 * Don't let a manufactured policy number duplicate
 * the class of one of our base policy numbers.
 */
static int
is_base_class(const char *clname)
{
	const pcclass_t	*pccp;
	int		policy;

	for (policy = 0, pccp = sched_class;
	    policy < _SCHED_NEXT;
	    policy++, pccp++) {
		if (strcmp(clname, pccp->pcc_info.pc_clname) == 0)
			return (1);
	}
	return (0);
}

/*
 * Cache priocntl information on scheduling class by policy.
 */
const pcclass_t *
get_info_by_policy(int policy)
{
	pcclass_t *pccp = &sched_class[policy];
	pcpri_t pcpri;
	pri_t prio;
	int base = 0;

	if ((uint_t)policy >= NPOLICY || pccp->pcc_state < 0) {
		errno = EINVAL;
		return (NULL);
	}

	if (pccp->pcc_state > 0)
		return (pccp);

	lmutex_lock(&class_lock);

	/* get class info (the system class is known to have class-id == 0) */
	if (pccp->pcc_policy == -1) {
		/* policy number not defined in <sched.h> */
		ASSERT(policy >= _SCHED_NEXT);
		pccp->pcc_info.pc_cid = policy - _SCHED_NEXT;
		if (_private_priocntl(0, 0, PC_GETCLINFO, &pccp->pcc_info)
		    == -1 ||
		    (base = is_base_class(pccp->pcc_info.pc_clname)) != 0) {
			pccp->pcc_info.pc_clname[0] = '\0';
			pccp->pcc_info.pc_cid = -1;
			/*
			 * If we duplicated a base class, permanently
			 * disable this policy entry.  Else allow for
			 * dynamic loading of scheduling classes.
			 */
			if (base) {
				_membar_producer();
				pccp->pcc_state = -1;
			}
			errno = EINVAL;
			lmutex_unlock(&class_lock);
			return (NULL);
		}
		pccp->pcc_policy = policy;
	} else if (policy != SCHED_SYS &&
	    _private_priocntl(0, 0, PC_GETCID, &pccp->pcc_info) == -1) {
		_membar_producer();
		pccp->pcc_state = -1;
		errno = EINVAL;
		lmutex_unlock(&class_lock);
		return (NULL);
	}

	switch (policy) {
	case SCHED_OTHER:
		prio = ((tsinfo_t *)pccp->pcc_info.pc_clinfo)->ts_maxupri;
		pccp->pcc_primin = -prio;
		pccp->pcc_primax = prio;
		break;
	case SCHED_FIFO:
	case SCHED_RR:
		prio = ((rtinfo_t *)pccp->pcc_info.pc_clinfo)->rt_maxpri;
		pccp->pcc_primin = 0;
		pccp->pcc_primax = prio;
		break;
	default:
		/*
		 * All other policy numbers, including policy numbers
		 * not defined in <sched.h>.
		 */
		pcpri.pc_cid = pccp->pcc_info.pc_cid;
		if (_private_priocntl(0, 0, PC_GETPRIRANGE, &pcpri) == 0) {
			pccp->pcc_primin = pcpri.pc_clpmin;
			pccp->pcc_primax = pcpri.pc_clpmax;
		}
		break;
	}

	_membar_producer();
	pccp->pcc_state = 1;
	lmutex_unlock(&class_lock);
	return (pccp);
}

const pcclass_t *
get_info_by_class(id_t classid)
{
	pcinfo_t	pcinfo;
	pcclass_t	*pccp;
	int		policy;

	if (classid < 0) {
		errno = EINVAL;
		return (NULL);
	}

	/* determine if we already know this classid */
	for (policy = 0, pccp = sched_class;
	    policy < NPOLICY;
	    policy++, pccp++) {
		if (pccp->pcc_state > 0 && pccp->pcc_info.pc_cid == classid)
			return (pccp);
	}

	pcinfo.pc_cid = classid;
	if (_private_priocntl(0, 0, PC_GETCLINFO, &pcinfo) == -1) {
		if (classid == 0)	/* no kernel info for sys class */
			return (get_info_by_policy(SCHED_SYS));
		return (NULL);
	}

	for (policy = 0, pccp = sched_class;
	    policy < NPOLICY;
	    policy++, pccp++) {
		if (pccp->pcc_state == 0 &&
		    strcmp(pcinfo.pc_clname, pccp->pcc_info.pc_clname) == 0)
			return (get_info_by_policy(pccp->pcc_policy));
	}

	/*
	 * We have encountered an unknown (to us) scheduling class.
	 * Manufacture a policy number for it.  Hopefully we still
	 * have room in the sched_class[] table.
	 */
	policy = _SCHED_NEXT + classid;
	if (policy >= NPOLICY) {
		errno = EINVAL;
		return (NULL);
	}
	lmutex_lock(&class_lock);
	pccp = &sched_class[policy];
	pccp->pcc_policy = policy;
	(void) strlcpy(pccp->pcc_info.pc_clname, pcinfo.pc_clname, PC_CLNMSZ);
	lmutex_unlock(&class_lock);
	return (get_info_by_policy(pccp->pcc_policy));
}

/*
 * Helper function: get process or lwp current scheduling policy.
 */
static const pcclass_t *
get_parms(idtype_t idtype, id_t id, pcparms_t *pcparmp)
{
	pcparmp->pc_cid = PC_CLNULL;
	if (_private_priocntl(idtype, id, PC_GETPARMS, pcparmp) == -1)
		return (NULL);
	return (get_info_by_class(pcparmp->pc_cid));
}

/*
 * Helper function for setprio() and setparam(), below.
 */
static int
set_priority(idtype_t idtype, id_t id, int policy, int prio,
    pcparms_t *pcparmp, int settq)
{
	int rv;

	switch (policy) {
	case SCHED_OTHER:
	{
		tsparms_t *tsp = (tsparms_t *)pcparmp->pc_clparms;
		tsp->ts_uprilim = prio;
		tsp->ts_upri = prio;
		break;
	}
	case SCHED_FIFO:
	case SCHED_RR:
	{
		rtparms_t *rtp = (rtparms_t *)pcparmp->pc_clparms;
		rtp->rt_tqnsecs = settq?
		    (policy == SCHED_FIFO? RT_TQINF : RT_TQDEF) :
		    RT_NOCHANGE;
		rtp->rt_pri = prio;
		break;
	}
	default:
	{
		/*
		 * Class-independent method for setting the priority.
		 */
		pcprio_t pcprio;

		pcprio.pc_op = PC_SETPRIO;
		pcprio.pc_cid = pcparmp->pc_cid;
		pcprio.pc_val = prio;
		do {
			rv = _private_priocntl(idtype, id, PC_DOPRIO, &pcprio);
		} while (rv == -1 && errno == ENOMEM);
		return (rv);
	}
	}

	do {
		rv = _private_priocntl(idtype, id, PC_SETPARMS, pcparmp);
	} while (rv == -1 && errno == ENOMEM);
	return (rv);
}

/*
 * Utility function, private to libc, used by sched_setparam()
 * and posix_spawn().  Because it is called by the vfork() child of
 * posix_spawn(), we must not call any functions exported from libc.
 */
id_t
setprio(idtype_t idtype, id_t id, int prio, int *policyp)
{
	pcparms_t	pcparm;
	int		policy;
	const pcclass_t	*pccp;

	if ((pccp = get_parms(idtype, id, &pcparm)) == NULL)
		return (-1);
	if (prio < pccp->pcc_primin || prio > pccp->pcc_primax) {
		errno = EINVAL;
		return (-1);
	}

	policy = pccp->pcc_policy;
	if (policyp != NULL &&
	    (policy == SCHED_FIFO || policy == SCHED_RR)) {
		rtparms_t *rtp = (rtparms_t *)pcparm.pc_clparms;
		policy = (rtp->rt_tqnsecs == RT_TQINF? SCHED_FIFO : SCHED_RR);
	}

	if (set_priority(idtype, id, policy, prio, &pcparm, 0) == -1)
		return (-1);
	if (policyp != NULL)
		*policyp = policy;
	return (pccp->pcc_info.pc_cid);
}

int
sched_setparam(pid_t pid, const struct sched_param *param)
{
	if (pid < 0) {
		errno = ESRCH;
		return (-1);
	}
	if (pid == 0)
		pid = P_MYID;

	if (setprio(P_PID, pid, param->sched_priority, NULL) == -1)
		return (-1);
	return (0);
}

id_t
getparam(idtype_t idtype, id_t id, int *policyp, struct sched_param *param)
{
	pcparms_t pcparm;
	const pcclass_t *pccp;
	int policy;
	int priority;

	if ((pccp = get_parms(idtype, id, &pcparm)) == NULL)
		return (-1);

	switch (policy = pccp->pcc_policy) {
	case SCHED_OTHER:
	{
		tsparms_t *tsp = (tsparms_t *)pcparm.pc_clparms;
		priority = tsp->ts_upri;
		break;
	}
	case SCHED_FIFO:
	case SCHED_RR:
	{
		rtparms_t *rtp = (rtparms_t *)pcparm.pc_clparms;
		priority = rtp->rt_pri;
		policy = (rtp->rt_tqnsecs == RT_TQINF? SCHED_FIFO : SCHED_RR);
		break;
	}
	default:
	{
		/*
		 * Class-independent method for getting the priority.
		 */
		pcprio_t pcprio;

		pcprio.pc_op = PC_GETPRIO;
		pcprio.pc_cid = 0;
		pcprio.pc_val = 0;
		if (_private_priocntl(idtype, id, PC_DOPRIO, &pcprio) == 0)
			priority = pcprio.pc_val;
		else
			priority = 0;
		break;
	}
	}

	*policyp = policy;
	(void) memset(param, 0, sizeof (*param));
	param->sched_priority = priority;

	return (pcparm.pc_cid);
}

int
sched_getparam(pid_t pid, struct sched_param *param)
{
	int policy;

	if (pid < 0) {
		errno = ESRCH;
		return (-1);
	}
	if (pid == 0)
		pid = P_MYID;

	if (getparam(P_PID, pid, &policy, param) == -1)
		return (-1);
	return (0);
}

/*
 * Utility function, private to libc, used by sched_setscheduler()
 * and posix_spawn().  Because it is called by the vfork() child of
 * posix_spawn(), we must not call any functions exported from libc.
 */
id_t
setparam(idtype_t idtype, id_t id, int policy, int prio)
{
	pcparms_t	pcparm;
	const pcclass_t	*pccp;

	if (policy == SCHED_SYS ||
	    (pccp = get_info_by_policy(policy)) == NULL ||
	    prio < pccp->pcc_primin || prio > pccp->pcc_primax) {
		errno = EINVAL;
		return (-1);
	}

	pcparm.pc_cid = pccp->pcc_info.pc_cid;
	if (set_priority(idtype, id, policy, prio, &pcparm, 1) == -1)
		return (-1);
	return (pccp->pcc_info.pc_cid);
}

int
sched_setscheduler(pid_t pid, int policy, const struct sched_param *param)
{
	pri_t		prio = param->sched_priority;
	int		oldpolicy;

	if ((oldpolicy = sched_getscheduler(pid)) < 0)
		return (-1);

	if (pid == 0)
		pid = P_MYID;

	if (setparam(P_PID, pid, policy, prio) == -1)
		return (-1);

	return (oldpolicy);
}

int
sched_getscheduler(pid_t pid)
{
	pcparms_t	pcparm;
	const pcclass_t	*pccp;
	int		policy;

	if (pid < 0) {
		errno = ESRCH;
		return (-1);
	}
	if (pid == 0)
		pid = P_MYID;

	if ((pccp = get_parms(P_PID, pid, &pcparm)) == NULL)
		return (-1);

	if ((policy = pccp->pcc_policy) == SCHED_FIFO || policy == SCHED_RR) {
		policy =
		    (((rtparms_t *)pcparm.pc_clparms)->rt_tqnsecs == RT_TQINF?
		    SCHED_FIFO : SCHED_RR);
	}

	return (policy);
}

int
sched_yield(void)
{
	thr_yield();
	return (0);
}

int
sched_get_priority_max(int policy)
{
	const pcclass_t *pccp;

	if ((pccp = get_info_by_policy(policy)) != NULL)
		return (pccp->pcc_primax);
	errno = EINVAL;
	return (-1);
}

int
sched_get_priority_min(int policy)
{
	const pcclass_t *pccp;

	if ((pccp = get_info_by_policy(policy)) != NULL)
		return (pccp->pcc_primin);
	errno = EINVAL;
	return (-1);
}

int
sched_rr_get_interval(pid_t pid, timespec_t *interval)
{
	pcparms_t pcparm;
	const pcclass_t *pccp;

	if (pid < 0) {
		errno = ESRCH;
		return (-1);
	}
	if (pid == 0)
		pid = P_MYID;

	if ((pccp = get_parms(P_PID, pid, &pcparm)) == NULL)
		return (-1);

	/*
	 * At the moment, we have no class-independent method to fetch
	 * the process/lwp time quantum.  Since SUSv3 does not restrict
	 * this operation to the real-time class, we return an indefinite
	 * quantum (tv_sec == 0 and tv_nsec == 0) for scheduling policies
	 * for which this information isn't available.
	 */
	interval->tv_sec = 0;
	interval->tv_nsec = 0;

	switch (pccp->pcc_policy) {
	case SCHED_FIFO:
	case SCHED_RR:
		{
			rtparms_t *rtp = (rtparms_t *)pcparm.pc_clparms;
			if (rtp->rt_tqnsecs != RT_TQINF) {
				interval->tv_sec = rtp->rt_tqsecs;
				interval->tv_nsec = rtp->rt_tqnsecs;
			}
		}
		break;
	case SCHED_FX:
		{
			fxparms_t *fxp = (fxparms_t *)pcparm.pc_clparms;
			if (fxp->fx_tqnsecs != FX_TQINF) {
				interval->tv_sec = fxp->fx_tqsecs;
				interval->tv_nsec = fxp->fx_tqnsecs;
			}
		}
		break;
	}

	return (0);
}

/*
 * Initialize or update ul_policy, ul_cid, and ul_pri.
 */
void
update_sched(ulwp_t *self)
{
	volatile sc_shared_t *scp;
	pcparms_t pcparm;
	pcprio_t pcprio;
	const pcclass_t *pccp;
	int priority;
	int policy;

	ASSERT(self == curthread);

	enter_critical(self);

	if ((scp = self->ul_schedctl) == NULL &&
	    (scp = setup_schedctl()) == NULL) {		/* can't happen? */
		if (self->ul_policy < 0) {
			self->ul_cid = 0;
			self->ul_pri = 0;
			_membar_producer();
			self->ul_policy = SCHED_OTHER;
		}
		exit_critical(self);
		return;
	}

	if (self->ul_policy >= 0 &&
	    self->ul_cid == scp->sc_cid &&
	    (self->ul_pri == scp->sc_cpri ||
	    (self->ul_epri > 0 && self->ul_epri == scp->sc_cpri))) {
		exit_critical(self);
		return;
	}

	pccp = get_parms(P_LWPID, P_MYID, &pcparm);
	if (pccp == NULL) {		/* can't happen? */
		self->ul_cid = scp->sc_cid;
		self->ul_pri = scp->sc_cpri;
		_membar_producer();
		self->ul_policy = SCHED_OTHER;
		exit_critical(self);
		return;
	}

	switch (policy = pccp->pcc_policy) {
	case SCHED_OTHER:
		priority = ((tsparms_t *)pcparm.pc_clparms)->ts_upri;
		break;
	case SCHED_FIFO:
	case SCHED_RR:
		priority = ((rtparms_t *)pcparm.pc_clparms)->rt_pri;
		policy =
		    ((rtparms_t *)pcparm.pc_clparms)->rt_tqnsecs == RT_TQINF?
		    SCHED_FIFO : SCHED_RR;
		break;
	default:
		/*
		 * Class-independent method for getting the priority.
		 */
		pcprio.pc_op = PC_GETPRIO;
		pcprio.pc_cid = 0;
		pcprio.pc_val = 0;
		if (_private_priocntl(P_LWPID, P_MYID, PC_DOPRIO, &pcprio) == 0)
			priority = pcprio.pc_val;
		else
			priority = 0;
	}

	self->ul_cid = pcparm.pc_cid;
	self->ul_pri = priority;
	_membar_producer();
	self->ul_policy = policy;

	exit_critical(self);
}