/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2019 Joyent, Inc.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/var.h>
#include <sys/thread.h>
#include <sys/cpuvar.h>
#include <sys/kstat.h>
#include <sys/uadmin.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/cmn_err.h>
#include <sys/procset.h>
#include <sys/processor.h>
#include <sys/debug.h>
#include <sys/policy.h>
#include <sys/smt.h>

/*
 * CPU state diagram
 *
 *                  P_SPARE
 * P_POWEROFF <---> P_OFFLINE <---> P_ONLINE <---> P_NOINTR
 *                  P_FAULTED
 *                  P_DISABLED
 */
int
p_online_internal_locked(processorid_t cpun, int new_status, int *old_status)
{
	cpu_t	*cp;
	int	status;
	int	error = 0;
	int	flags = 0;

	ASSERT(MUTEX_HELD(&cpu_lock));

	if (cpun == P_ALL_SIBLINGS) {
		if (new_status != P_DISABLED) {
			error = EINVAL;
			goto out;
		}

		return (smt_disable());
	}

	if ((cp = cpu_get(cpun)) == NULL) {
		error = EINVAL;
		goto out;
	}

	if (new_status & P_FORCED)
		flags = CPU_FORCED;
	*old_status = status = cpu_get_state(cp); /* get processor status */
	new_status &= ~P_FORCED;

	/*
	 * Perform credentials check.
	 */
	switch (new_status) {
	case P_STATUS:
		goto out;
	case P_ONLINE:
	case P_OFFLINE:
	case P_NOINTR:
	case P_FAULTED:
	case P_SPARE:
		if (secpolicy_ponline(CRED()) != 0)
			error = EPERM;
		break;
	case P_DISABLED:
	default:
		error = EINVAL;
		break;
	}

	if (error)
		goto out;

	/*
	 * return 0 if the CPU is already in the desired new state.
	 */
	if (status == new_status)
		goto out;

	switch (new_status) {
	case P_ONLINE:
		switch (status) {
		case P_POWEROFF:
			/*
			 * If CPU is powered off, power it on.
			 */
			if (error = cpu_poweron(cp))
				break;
			ASSERT(cpu_get_state(cp) == P_OFFLINE);
			/* FALLTHROUGH */
		case P_DISABLED:
		case P_OFFLINE:
		case P_FAULTED:
		case P_SPARE:
			/*
			 * If CPU is in one of the offline states,
			 * bring it online.
			 */
			error = cpu_online(cp, flags);
			break;
		case P_NOINTR:
			cpu_intr_enable(cp);
			break;
		}
		break;

	case P_OFFLINE:
		switch (status) {
		case P_NOINTR:
			/*
			 * Before we take the CPU offline, we first enable I/O
			 * interrupts.
			 */
			cpu_intr_enable(cp);
			/* FALLTHROUGH */
		case P_ONLINE:
		case P_DISABLED:
		case P_FAULTED:
		case P_SPARE:
			/*
			 * CPU is online, or in a special offline state.
			 * Take it offline.
			 */
			error = cpu_offline(cp, flags);
			break;
		case P_POWEROFF:
			/*
			 * If CPU is powered off, power it on.
			 */
			error = cpu_poweron(cp);
			break;
		}
		break;

	case P_NOINTR:
		switch (status) {
		case P_POWEROFF:
			/*
			 * if CPU is powered off, power it on.
			 */
			if (error = cpu_poweron(cp))
				break;
			ASSERT(cpu_get_state(cp) == P_OFFLINE);
			/* FALLTHROUGH */
		case P_DISABLED:
		case P_OFFLINE:
		case P_FAULTED:
		case P_SPARE:
			/*
			 * First, bring the CPU online.
			 */
			if (error = cpu_online(cp, flags))
				break;
			/* FALLTHROUGH */
		case P_ONLINE:
			/*
			 * CPU is now online.  Try to disable interrupts.
			 */
			error = cpu_intr_disable(cp);
			break;
		}
		break;

	case P_FAULTED:
		switch (status) {
		case P_POWEROFF:
			/*
			 * If CPU is powered off, power it on.
			 */
			if (error = cpu_poweron(cp))
				break;
			ASSERT(cpu_get_state(cp) == P_OFFLINE);
			/*FALLTHROUGH*/
		case P_DISABLED:
		case P_OFFLINE:
		case P_ONLINE:
		case P_NOINTR:
		case P_SPARE:
			/*
			 * Mark this CPU as faulted.
			 */
			error = cpu_faulted(cp, flags);
			break;
		}
		break;

	case P_SPARE:
		switch (status) {
		case P_POWEROFF:
			/*
			 * If CPU is powered off, power it on.
			 */
			if (error = cpu_poweron(cp))
				break;
			ASSERT(cpu_get_state(cp) == P_OFFLINE);
			/*FALLTHROUGH*/
		case P_DISABLED:
		case P_OFFLINE:
		case P_FAULTED:
		case P_ONLINE:
		case P_NOINTR:
			/*
			 * Mark this CPU as a spare.
			 */
			error = cpu_spare(cp, flags);
			break;
		}
		break;
	}
out:
	return (error);
}

int
p_online_internal(processorid_t cpun, int new_status, int *old_status)
{
	int rc;

	mutex_enter(&cpu_lock);		/* protects CPU states */
	rc = p_online_internal_locked(cpun, new_status, old_status);
	mutex_exit(&cpu_lock);

	return (rc);
}

/*
 * p_online(2) - get/change processor operational status.
 *
 *   As noted in os/cpu.c, the P_ONLINE and other state constants are for use
 *   only in this system call path and other paths conveying CPU state to
 *   userland.  In general, other kernel consumers should be using the accessor
 *   functions in uts/common/os/cpu.c.
 */
int
p_online(processorid_t cpun, int new_status)
{
	int ret;
	int old_status;

	ret = p_online_internal(cpun, new_status, &old_status);
	if (ret != 0)
		return (set_errno(ret));
	return (old_status);
}