/*

 * 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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

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

#include <sys/pool.h>

#include <sys/pool_impl.h>

#include <sys/pool_pset.h>

#include <sys/id_space.h>

#include <sys/mutex.h>

#include <sys/nvpair.h>

#include <sys/cpuvar.h>

#include <sys/errno.h>

#include <sys/cmn_err.h>

#include <sys/systm.h>

#include <sys/proc.h>

#include <sys/fss.h>

#include <sys/class.h>

#include <sys/exacct.h>

#include <sys/utsname.h>

#include <sys/procset.h>

#include <sys/atomic.h>

#include <sys/zone.h>

#include <sys/policy.h>

/*

 * RESOURCE POOLS

 *

 * The resource pools facility brings together process-bindable resource into

 * a common abstraction called a pool. Processor sets and other entities can

 * be configured, grouped, and labelled such that workload components can be

 * associated with a subset of a system's total resources.

 *

 * When disabled, the pools facility is "invisible".  All processes belong

 * to the same pool (pool_default), and processor sets can be managed through

 * the old pset() system call.  When enabled, processor sets can only be

 * managed via the pools facility.  New pools can be created and associated

 * with processor sets.  Processes can be bound to pools which have non-empty

 * resource sets.

 *

 * Locking: pool_lock() protects global pools state and must be called

 * before modifying the configuration, or when taking a snapshot of the

 * configuration.  If pool_lock_intr() is used, the operation may be

 * interrupted by a signal or a request.

 *

 * To prevent processes from being rebound between pools while they are

 * the middle of an operation which affects resource set bindings, such

 * operations must be surrounded by calls to pool_barrier_enter() and

 * pool_barrier_exit().  This mechanism guarantees that such processes will

 * be stopped either at the beginning or at the end of the barrier so that

 * the rebind operation can atomically bind the process and its threads

 * to new resource sets, and then let process run again.

 *

 * Lock ordering with respect to other locks is as follows:

 *

 * 	pool_lock() -> cpu_lock -> pidlock -> p_lock -> pool_barrier_lock

 *

 * Most static and global variables defined in this file are protected

 * by calling pool_lock().

 *

 * The operation that binds tasks and projects to pools is atomic.  That is,

 * either all processes in a given task or a project will be bound to a

 * new pool, or (in case of an error) they will be all left bound to the

 * old pool. Processes in a given task or a given project can only be bound to

 * different pools if they were rebound individually one by one as single

 * processes.  Threads or LWPs of the same process do not have pool bindings,

 * and are bound to the same resource sets associated with the resource pool

 * of that process.

 *

 * The following picture shows one possible pool configuration with three

 * pools and three processor sets.  Note that processor set "foo" is not

 * associated with any pools and therefore cannot have any processes

 * bound to it.  Two pools (default and foo) are associated with the

 * same processor set (default).  Also, note that processes in Task 2

 * are bound to different pools.

 *

 *

 *							       Processor Sets

 *								+---------+

 *		       +--------------+========================>| default |

 *		      a|	      |				+---------+

 *		      s|	      |				    ||

 *		      s|	      |				+---------+

 *		      o|	      |				|   foo   |

 *		      c|	      |				+---------+

 *		      i|	      |				    ||

 *		      a|	      |				+---------+

 *		      t|	      |			+------>|   bar   |

 *		      e|	      |			|	+---------+

 *                    d|              |                 |

 *                     |              |                 |

 *	       +---------+      +---------+      +---------+

 *     Pools   | default |======|   foo   |======|   bar   |

 *	       +---------+      +---------+      +---------+

 *	           @  @            @              @ @   @

 *                b|  |            |              | |   |

 *                o|  |            |              | |   |

 *                u|  +-----+      |      +-------+ |   +---+

 *                n|        |      |      |         |       |

 *            ....d|........|......|......|.........|.......|....

 *            :    |   ::   |      |      |    ::   |       |   :

 *            :  +---+ :: +---+  +---+  +---+  :: +---+   +---+ :

 *  Processes :  | p | :: | p |  | p |  | p |  :: | p |...| p | :

 *            :  +---+ :: +---+  +---+  +---+  :: +---+   +---+ :

 *            :........::......................::...............:

 *              Task 1            Task 2              Task N

 *                 |                 |                  |

 *                 |                 |                  |

 *                 |  +-----------+  |             +-----------+

 *                 +--| Project 1 |--+             | Project N |

 *                    +-----------+                +-----------+

 *

 * This is just an illustration of relationships between processes, tasks,

 * projects, pools, and processor sets. New types of resource sets will be

 * added in the future.

 */

pool_t		*pool_default;	/* default pool which always exists */

int		pool_count;	/* number of pools created on this system */

int		pool_state;	/* pools state -- enabled/disabled */

void		*pool_buf;	/* pre-commit snapshot of the pools state */

size_t		pool_bufsz;	/* size of pool_buf */

static hrtime_t	pool_pool_mod;	/* last modification time for pools */

static hrtime_t	pool_sys_mod;	/* last modification time for system */

static nvlist_t	*pool_sys_prop;	/* system properties */

static id_space_t *pool_ids;	/* pool ID space */

static list_t	pool_list;	/* doubly-linked list of pools */

static kmutex_t		pool_mutex;		/* protects pool_busy_* */

static kcondvar_t	pool_busy_cv;		/* waiting for "pool_lock" */

static kthread_t	*pool_busy_thread;	/* thread holding "pool_lock" */

static kmutex_t		pool_barrier_lock;	/* synch. with pool_barrier_* */

static kcondvar_t	pool_barrier_cv;	/* synch. with pool_barrier_* */

static int		pool_barrier_count;	/* synch. with pool_barrier_* */

/*

 * Boot-time pool initialization.

 */

void

pool_init(void)

{

	pool_ids = id_space_create("pool_ids", POOL_DEFAULT + 1, POOL_MAXID);

	/*

	 * Initialize default pool.

	 */

	pool_default = kmem_zalloc(sizeof (pool_t), KM_SLEEP);

	pool_default->pool_id = POOL_DEFAULT;

	list_create(&pool_list, sizeof (pool_t), offsetof(pool_t, pool_link));

	list_insert_head(&pool_list, pool_default);

	/*

	 * Initialize plugins for resource sets.

	 */

	pool_pset_init();

	pool_count = 1;

	p0.p_pool = pool_default;

	global_zone->zone_pool = pool_default;

	pool_default->pool_ref = 1;

}

/*

 * Synchronization routines.

 *

 * pool_lock is only called from syscall-level routines (processor_bind(),

 * pset_*(), and /dev/pool ioctls).  The pool "lock" may be held for long

 * periods of time, including across sleeping operations, so we allow its

 * acquisition to be interruptible.

 *

 * The current thread that owns the "lock" is stored in the variable

 * pool_busy_thread, both to let pool_lock_held() work and to aid debugging.

 */

void

pool_lock(void)

{

	mutex_enter(&pool_mutex);

	while (pool_busy_thread != NULL)

		cv_wait(&pool_busy_cv, &pool_mutex);

	pool_busy_thread = curthread;

	mutex_exit(&pool_mutex);

}

int

pool_lock_intr(void)

{

	mutex_enter(&pool_mutex);

	while (pool_busy_thread != NULL) {

		if (cv_wait_sig(&pool_busy_cv, &pool_mutex) == 0) {

			cv_signal(&pool_busy_cv);

			mutex_exit(&pool_mutex);

			return (1);

		}

	}

	pool_busy_thread = curthread;

	mutex_exit(&pool_mutex);

	return (0);

}

int

pool_lock_held(void)

{

	return (pool_busy_thread == curthread);

}

void

pool_unlock(void)

{

	mutex_enter(&pool_mutex);

	pool_busy_thread = NULL;

	cv_signal(&pool_busy_cv);

	mutex_exit(&pool_mutex);

}

/*

 * Routines allowing fork(), exec(), exit(), and lwp_create() to synchronize

 * with pool_do_bind().

 *

 * Calls to pool_barrier_enter() and pool_barrier_exit() must bracket all

 * operations which modify pool or pset associations.  They can be called

 * while the process is multi-threaded.  In the common case, when current

 * process is not being rebound (PBWAIT flag is not set), these functions

 * will be just incrementing and decrementing reference counts.

 */

void

pool_barrier_enter(void)

{

	proc_t *p = curproc;

	ASSERT(MUTEX_HELD(&p->p_lock));

	while (p->p_poolflag & PBWAIT)

		cv_wait(&p->p_poolcv, &p->p_lock);

	p->p_poolcnt++;

}

void

pool_barrier_exit(void)

{

	proc_t *p = curproc;

	ASSERT(MUTEX_HELD(&p->p_lock));

	ASSERT(p->p_poolcnt > 0);

	p->p_poolcnt--;

	if (p->p_poolflag & PBWAIT) {

		mutex_enter(&pool_barrier_lock);

		ASSERT(pool_barrier_count > 0);

		pool_barrier_count--;

		if (pool_barrier_count == 0)

			cv_signal(&pool_barrier_cv);

		mutex_exit(&pool_barrier_lock);

		while (p->p_poolflag & PBWAIT)

			cv_wait(&p->p_poolcv, &p->p_lock);

	}

}

/*

 * Enable pools facility.

 */

static int

pool_enable(void)

{

	int ret;

	ASSERT(pool_lock_held());

	ASSERT(pool_count == 1);

	ret = pool_pset_enable();

	if (ret != 0)

		return (ret);

	(void) nvlist_alloc(&pool_sys_prop, NV_UNIQUE_NAME, KM_SLEEP);

	(void) nvlist_add_string(pool_sys_prop, "system.name",

	    "default");

	(void) nvlist_add_string(pool_sys_prop, "system.comment", "");

	(void) nvlist_add_int64(pool_sys_prop, "system.version", 1);

	(void) nvlist_add_byte(pool_sys_prop, "system.bind-default", 1);

	(void) nvlist_alloc(&pool_default->pool_props,

	    NV_UNIQUE_NAME, KM_SLEEP);

	(void) nvlist_add_string(pool_default->pool_props,

	    "pool.name", "pool_default");

	(void) nvlist_add_string(pool_default->pool_props, "pool.comment", "");

	(void) nvlist_add_byte(pool_default->pool_props, "pool.default", 1);

	(void) nvlist_add_byte(pool_default->pool_props, "pool.active", 1);

	(void) nvlist_add_int64(pool_default->pool_props,

	    "pool.importance", 1);

	(void) nvlist_add_int64(pool_default->pool_props, "pool.sys_id",

	    pool_default->pool_id);

	pool_sys_mod = pool_pool_mod = gethrtime();

	return (ret);

}

/*

 * Disable pools facility.

 */

static int

pool_disable(void)

{

	int ret;

	ASSERT(pool_lock_held());

	if (pool_count > 1)	/* must destroy all pools first */

		return (EBUSY);

	ret = pool_pset_disable();

	if (ret != 0)

		return (ret);

	if (pool_sys_prop != NULL) {

		nvlist_free(pool_sys_prop);

		pool_sys_prop = NULL;

	}

	if (pool_default->pool_props != NULL) {

		nvlist_free(pool_default->pool_props);

		pool_default->pool_props = NULL;

	}

	return (0);

}

pool_t *

pool_lookup_pool_by_name(char *name)

{

	pool_t *pool = pool_default;

	char *p;

	ASSERT(pool_lock_held());

	for (pool = list_head(&pool_list); pool;

	    pool = list_next(&pool_list, pool)) {

		if (nvlist_lookup_string(pool->pool_props,

		    "pool.name", &p) == 0 && strcmp(name, p) == 0)

			return (pool);

	}

	return (NULL);

}

pool_t *

pool_lookup_pool_by_id(poolid_t poolid)

{

	pool_t *pool = pool_default;

	ASSERT(pool_lock_held());

	for (pool = list_head(&pool_list); pool;

	    pool = list_next(&pool_list, pool)) {

		if (pool->pool_id == poolid)

			return (pool);

	}

	return (NULL);

}

/*

 * Create new pool, associate it with default resource sets, and give

 * it a temporary name.

 */

static int

pool_pool_create(poolid_t *poolid)

{

	pool_t *pool;

	char pool_name[40];

	ASSERT(pool_lock_held());

	pool = kmem_zalloc(sizeof (pool_t), KM_SLEEP);

	pool->pool_id = *poolid = id_alloc(pool_ids);

	pool->pool_pset = pool_pset_default;

	pool_pset_default->pset_npools++;

	list_insert_tail(&pool_list, pool);

	(void) nvlist_alloc(&pool->pool_props, NV_UNIQUE_NAME, KM_SLEEP);

	(void) nvlist_add_int64(pool->pool_props, "pool.sys_id", pool->pool_id);

	(void) nvlist_add_byte(pool->pool_props, "pool.default", 0);

	pool_pool_mod = gethrtime();

	(void) snprintf(pool_name, sizeof (pool_name), "pool_%lld",

	    pool_pool_mod);

	(void) nvlist_add_string(pool->pool_props, "pool.name", pool_name);

	pool_count++;

	return (0);

}

struct destroy_zone_arg {

	pool_t *old;

	pool_t *new;

};

/*

 * Update pool pointers for zones that are currently bound to pool "old"

 * to be bound to pool "new".

 */

static int

pool_destroy_zone_cb(zone_t *zone, void *arg)

{

	struct destroy_zone_arg *dza = arg;

	ASSERT(pool_lock_held());

	ASSERT(MUTEX_HELD(&cpu_lock));

	if (zone_pool_get(zone) == dza->old)

		zone_pool_set(zone, dza->new);

	return (0);

}

/*

 * Destroy specified pool, and rebind all processes in it

 * to the default pool.

 */

static int

pool_pool_destroy(poolid_t poolid)

{

	pool_t *pool;

	int ret;

	ASSERT(pool_lock_held());

	if (poolid == POOL_DEFAULT)

		return (EINVAL);

	if ((pool = pool_lookup_pool_by_id(poolid)) == NULL)

		return (ESRCH);

	ret = pool_do_bind(pool_default, P_POOLID, poolid, POOL_BIND_ALL);

	if (ret == 0) {

		struct destroy_zone_arg dzarg;

		dzarg.old = pool;

		dzarg.new = pool_default;

		mutex_enter(&cpu_lock);

		ret = zone_walk(pool_destroy_zone_cb, &dzarg);

		mutex_exit(&cpu_lock);

		ASSERT(ret == 0);

		ASSERT(pool->pool_ref == 0);

		(void) nvlist_free(pool->pool_props);

		id_free(pool_ids, pool->pool_id);

		pool->pool_pset->pset_npools--;

		list_remove(&pool_list, pool);

		pool_count--;

		pool_pool_mod = gethrtime();

		kmem_free(pool, sizeof (pool_t));

	}

	return (ret);

}

/*

 * Create new pool or resource set.

 */

int

pool_create(int class, int subclass, id_t *id)

{

	int ret;

	ASSERT(pool_lock_held());

	if (pool_state == POOL_DISABLED)

		return (ENOTACTIVE);

	switch (class) {

	case PEC_POOL:

		ret = pool_pool_create((poolid_t *)id);

		break;

	case PEC_RES_COMP:

		switch (subclass) {

		case PREC_PSET:

			ret = pool_pset_create((psetid_t *)id);

			break;

		default:

			ret = EINVAL;

		}

		break;

	case PEC_RES_AGG:

		ret = ENOTSUP;

		break;

	default:

		ret = EINVAL;

	}

	return (ret);

}

/*

 * Destroy an existing pool or resource set.

 */

int

pool_destroy(int class, int subclass, id_t id)

{

	int ret;

	ASSERT(pool_lock_held());

	if (pool_state == POOL_DISABLED)

		return (ENOTACTIVE);

	switch (class) {

	case PEC_POOL:

		ret = pool_pool_destroy((poolid_t)id);

		break;

	case PEC_RES_COMP:

		switch (subclass) {

		case PREC_PSET:

			ret = pool_pset_destroy((psetid_t)id);

			break;

		default:

			ret = EINVAL;

		}

		break;

	case PEC_RES_AGG:

		ret = ENOTSUP;

		break;

	default:

		ret = EINVAL;

	}

	return (ret);

}

/*

 * Enable or disable pools.

 */

int