poold - zygaena/hammerhead

root / base / usr / src / cmd / pools / poold
poold Plain Text 18822 lines 494.1 KB
#
# 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 2009 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# Copyright (c) 2018, Joyent, Inc.
# Copyright 2020 Peter Tribble
#

PROG =		poold
OBJS =		poold.o
SRCS =		$(OBJS:%.o=%.c)

MANIFEST=	poold.xml
SVCMETHOD=	svc-poold

include $(SRC)/cmd/Makefile.cmd
include $(SRC)/cmd/Makefile.cmd.64

JAVA_SUBDIRS =	com/sun/solaris/service/exception \
		com/sun/solaris/service/kstat \
		com/sun/solaris/service/locality \
		com/sun/solaris/service/logging \
		com/sun/solaris/service/pools \
		com/sun/solaris/service/timer \
		com/sun/solaris/domain/pools

SUBDIRS =	libjkstat \
		libjlgrp \
		libjpool \
		libjsyslog

ROOTMANIFESTDIR=	$(ROOTSVCSYSTEM)

all :		TARGET = all
install :	TARGET = install
clean :	TARGET = clean
clobber :	TARGET = clobber
msg :		TARGET = msg

$(ROOTMANIFEST):	FILEMODE= 444
JARFILE =	JPool.jar

JAVA_LIB_PATH =	$(JAVA_ROOT)/jre/lib/$(MACH64)/server
$(BLD_JAVA_11)JAVA_LIB_PATH =	$(JAVA_ROOT)/lib/server
LIBPOOL_PATH = $(ROOTLIB64)

# JAVA_SUBDIRS and PACKAGEDOCS must be synchronized to ensure
# javadoc documentation is generated for all packages.

PACKAGEDOCS =	com.sun.solaris.service.exception \
		com.sun.solaris.service.kstat \
		com.sun.solaris.service.locality \
		com.sun.solaris.service.logging \
		com.sun.solaris.service.pools \
		com.sun.solaris.service.timer \
		com.sun.solaris.domain.pools
DOCDIR =	doc
ROOTUSRLIBDRP = $(ROOTLIB)/pool
INCS =		-I../common \
		-I$(JAVA_ROOT)/include \
		-I$(JAVA_ROOT)/include/solaris
LDLIBS +=	-lpool -L$(JAVA_LIB_PATH) -ljvm
# runpath should point to runtime JAVA_HOME
LDFLAGS +=	-R$(JAVA_LIB_PATH)

# not linted
SMATCH=off

CPPFLAGS +=	$(INCS)
ROOTCMDDIR =	$(ROOT)/usr/lib/pool

CLOBBERFILES +=	$(JARFILE)

#
# Definitions for message catalogue
#
POFILES =	$(OBJS:.o=.po)

#
# Definitions for Java installs
#

JFILES =	poold.properties $(JARFILE)
ROOTJAVA =	$(JFILES:%=$(ROOTUSRLIBDRP)/%)

$(ROOTJAVA) :	FILEMODE = 444

all:	$(PROG) $(JAVA_SUBDIRS) $(JARFILE) \
		    .WAIT $(SUBDIRS)

clean :	$(JAVA_SUBDIRS) $(SUBDIRS) clean_local
clean_local:
	$(RM) $(OBJS)

clobber : $(JAVA_SUBDIRS) $(SUBDIRS) clobber_local
clobber_local: clean_local
	$(RM) $(CLOBBERFILES)

msg: $(POFILES)

install: $(ROOTCMD) $(JAVA_SUBDIRS) $(JARFILE) \
		    .WAIT $(SUBDIRS) $(ROOTJAVA) $(ROOTMANIFEST) \
		    $(ROOTSVCMETHOD)

check:	$(CHKMANIFEST)

$(JAVA_SUBDIRS): FRC
	@cd $@; pwd; $(MAKE) $(TARGET)
	if [ "$(TARGET)" != "clean" ] && [ "$(TARGET)" != "clobber" ]; \
	then \
		if [ ! -f $(JARFILE) ]; \
		then \
			$(JAR) -cf $(JARFILE) $@/*class; \
		else \
			$(JAR) -uf $(JARFILE) $@/*class; \
		fi \
	fi

$(SUBDIRS): FRC
	@cd $@; pwd; $(MAKE) $(TARGET)

doc:	all
	$(JAVADOC) -private -classpath $(JARFILE): -sourcepath . \
	    -source 7 -d $(DOCDIR) $(PACKAGEDOCS)

$(PROG):	$(OBJS)
	$(LINK.c) -o $(PROG) $(OBJS) $(LDLIBS)
	$(POST_PROCESS)

$(ROOTUSRLIBDRP)/%: %
	$(INS.file)

FRC:

include $(SRC)/cmd/Makefile.targ
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 *ident	"%Z%%M%	%I%	%E% SMI"
 *
 */

package com.sun.solaris.domain.pools;

/**
 * The <code>DRM</code> interface specifies the contract between
 * poold and higher level partitioning agents.
 *
 * <code>Poold</code> is designed to operate indepedently or as a
 * member of a hierarchy of co-operating resource managers. In order
 * to promote interaction and minimise implementation dependencies,
 * the use of a common protocol which may be implemented in multiple
 * languages is advocated. The protocol is provisionally named the
 * "Distributed Resource Management" (DRM) protocol.
 *
 * This interface specifies how an implementation of the protocol
 * would be implemented in Java.
 *
 * @see LogDRM
 */

interface DRM {
	/**
	 * Connect to a higher level partitioning agent.
	 *
	 * @param version The version of the protocol.
	 * @param url The location of the agent.
	 * @throws Exception If the connect fails.
	 */
	public void connect(int version, String url) throws Exception;

	/**
	 * Disconnect from a higher level partitioning agent.
	 *
	 * @throws Exception If the client is not connected.
	 */
	public void disconnect() throws Exception;

	/**
	 * Request resources via a higher level partitioning agent.
	 *
	 * @throws Exception If the request fails.
	 */
	public void request() throws Exception;

	/**
	 * Offer resources via a higher level partitioning agent.
	 *
	 * @throws Exception If the offer fails.
	 */
	public void offer() throws Exception;

	/**
	 * Cancel a previous offer or request.
	 *
	 * @throws Exception If the cancel fails.
	 */
	public void cancel() throws Exception;
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;

import com.sun.solaris.service.logging.*;
import com.sun.solaris.service.pools.*;

/**
 * This class maintains history about previous decisions.  It can be
 * used to ratify that a decision made on the basis of observed behavior
 * over a limited time was historically shown to not degrade
 * performance.  The class maintains historical data in a history file.
 * The format of this data is project-private and very likely to change
 * as the implementation improves.
 */
public final class DecisionHistory implements Serializable {
	/**
	 * The number of samples which a decision will be remembered.
	 */
	public static final int DECISION_LIFETIME = 256;

	/**
	 * Map of values of historical decisions.
	 */
	private HashMap decisions = new HashMap();

	/**
	 * Map of resources to be monitored for improvement in
	 * utilization to the corresponding decision.  Maps Resources to
	 * their decision's key string.
	 */
	private transient HashMap resourcesAwaitingImprovement = new HashMap();

	/**
	 * List of decisions, in order of creation, to manage expiry.
	 */
	private transient LinkedList decisionList = new LinkedList();

	/**
	 * Constructor.
	 */
	public DecisionHistory()
	{
	}

	/**
	 * Record a decision that's been made regarding a processor.
	 * Such a decision is a (cpuid, from-pset-name, to-pset-name,
	 * (from-pset-composition), (to-pset-composition),
	 * original-utilization-class) tuple.
	 */
	public void recordProcessorMove(ComponentMove move,
	    double startingUtilization, int sampleCount) throws PoolsException
	{
		Decision decision = Decision.forMove(move, startingUtilization);
		decision.setStartingSampleCount(sampleCount);
		Object o = decisions.put(decision.getKey(), decision);
		Poold.OPT_LOG.log(Severity.DEBUG, "recorded decision (" +
		    decision + ")" + (o == null ? "" : " (displaced " + o +
		    ")"));

		/*
		 * Remember the most-recently-made decision regarding a
		 * resource until the next utilization sample is taken,
		 * so the next solve() may then reocrd the improvement.
		 * If another decision is made regarding this resource,
		 * the previous ones are forgotten, and their
		 * improvement fields are left 0.
		 */
		resourcesAwaitingImprovement.put(move.getTo(),
		    decision.getKey());
		decisionList.add(decision);
	}

	private void recordImprovementWithUtilization(Resource resource,
	    double utilization)
	{
		String decisionKey = (String)resourcesAwaitingImprovement.get(
		    resource);

		if (decisionKey != null) {
			Decision decision = (Decision)decisions.get(
			    decisionKey);
			if (decision != null) {
				decision.setImprovementWithNewUtilization(
				    utilization);
				Poold.OPT_LOG.log(Severity.DEBUG, resource +
				    " improvement measured for decision " +
				    decision.describe());
			}
		}
	}

	/**
	 * A Decision boils down to a tuple describing the resource
	 * configuration involved before and after a particular resource
	 * is moved.  We use a textual representation to describe the
	 * decision, by value, to avoid holding references to any of the
	 * actual resources involved.
	 */
	private static abstract class Decision implements Serializable {
		/**
		 * Utilization of the resource before the move was made.
		 */
		private double startingUtilization = 0.0;

		/**
		 * Improvement in utilization (-1..1) after the move was
		 * made, if the determination is made.
		 */
		private double improvement = 0.0;

		/**
		 * Number of times this decision has been reexamined.
		 */
		private int usage = 0;

		/**
		 * Monitor's sample count when the decision was made,
		 * used to expire this decision after DECISION_LIFETIME
		 * samples.
		 */
		private int startingSampleCount;

		/**
		 * Decision's creation time.
		 */
		private Date date;

		/**
		 * Returns a String key for this Decision.
		 */
		public abstract String getKey();

		/**
		 * Returns a Decision corresponding to a given Move.
		 * @return a Decision corresponding to a given Move.
		 * @throws InvalidArgumentException if there is no
		 * Decision type corresponding to the move.
		 */
		public static final Decision forMove(Move move,
		    double startingUtilization)
		{
			if (move instanceof ComponentMove)
				return (new ComponentMoveDecision(
				    (ComponentMove)move, startingUtilization));
			else
				return (null);
		}

		private Decision()
		{
			date = new Date();
		}

		/**
		 * Invoked after construction, sets the utilization
		 * corresponding to the affected resource before the move
		 * was made.
		 */
		public final void setStartingUtilization(
		    double startingUtilization)
		{
			this.startingUtilization = startingUtilization;
		}

		/**
		 * Invoked after construction, sets the sampleCount from
		 * the monitor, used to expire this decision after
		 * DECISION_LIFETIME samples.
		 */
		public void setStartingSampleCount(int sampleCount)
		{
			this.startingSampleCount = sampleCount;
		}

		/**
		 * sampleCount accessor.
		 */
		public int getStartingSampleCount()
		{
			return (startingSampleCount);
		}

		/**
		 * Stores the improvement, computed in a
		 * subclass-specific way.
		 */
		abstract public void setImprovementWithNewUtilization(
		    double newUtilization);

		/**
		 * Allow subclasses to record the improvement.
		 */
		protected void setImprovement(double improvement)
		{
			this.improvement = improvement;
		}

		/**
		 * Returns the improvement in utilization measured by
		 * the monitor after the move is made.
		 */
		public final double getImprovement()
		{
			return (improvement);
		}

		/**
		 * Returns the utilization corresponding to the affected
		 * resource before the move was made.
		 */
		public final double getStartingUtilization()
		{
			return (startingUtilization);
		}

		public abstract int hashCode();
		public abstract boolean equals(Object o);
		public abstract String toString();

		private static final long serialVersionUID = 0x7860687;

		/**
		 * Number of times this decision has been reexamined.
		 */
		public final int getUsage()
		{
			return (usage);
		}

		private final void incrementUsage()
		{
			usage++;
		}

		/**
		 * Returns the time this decision was created.
		 */
		public final Date getDate()
		{
			return date;
		}

		/**
		 * Formatter for printing creation date.
		 */
		private static SimpleDateFormat dateFormatter;

		/**
		 * Format for printing creation date.
		 */
		private final static String dateFormat = "MMM d kk:mm:ss";

		/**
		 * Returns a more comprehensive textual representation
		 * of this devision than toString().
		 */
		public final String describe()
		{
			if (dateFormatter == null)
				dateFormatter = new SimpleDateFormat(
				    dateFormat);
			return (toString() + " made at " +
			    dateFormatter.format(getDate()) +
			    " with improvement " + getImprovement() +
			    " used " + getUsage() + " times");
		}
	}

	/**
	 * A Decision affecting the transfer of one CPU between
	 * processor sets.
	 */
	private static final class ComponentMoveDecision extends Decision {
		/**
		 * The CPU Id of the involved CPU.
		 */
		private String cpuid;

		/**
		 * The name of the donating processor set.
		 */
		private String fromPsetName;

		/**
		 * The name of the receiving processor set.
		 */
		private String toPsetName;

		/**
		 * The string representation of the list of CPU IDs
		 * composing the donating set.
		 */
		private String fromPsetComposition;

		/**
		 * The string representation of the list of CPU IDs
		 * composing the receiving set.
		 */
		private String toPsetComposition;

		/**
		 * The number of CPUs in the receiving set, after the
		 * move is made.
		 */
		private int toPsetSize;

		/**
		 * A Decision-subclass-specific utilization group.
		 */
		private String utilizationClass;

		/**
		 * Constructs a ComponentMoveDecision based on the
		 * ComponentMove.
		 * @throws IllegalArgumentException if the ComponentMove
		 * can't be interpreted.
		 */
		public ComponentMoveDecision(ComponentMove move,
		    double startingUtilization) throws IllegalArgumentException
		{
			try {
				cpuid = move.getComponents().toString();
				fromPsetName = move.getFrom().toString();
				toPsetName = move.getTo().toString();
				fromPsetComposition = move.getFrom()
				    .getComponents(null).toString();
				toPsetComposition = move.getTo()
				    .getComponents(null).toString();
				toPsetSize = move.getTo().getComponents(null)
				    .size();
				utilizationClass = computeUtilizationClass(
				    startingUtilization);
				setStartingUtilization(startingUtilization);
			} catch (PoolsException pe) {
				throw(IllegalArgumentException)(
				    new IllegalArgumentException().initCause(
				    pe));
			}
		}

		public String getKey()
		{
			StringBuffer sb = new StringBuffer();

			sb.append(cpuid);
			sb.append(", ");
			sb.append(fromPsetName);
			sb.append(", ");
			sb.append(toPsetName);

			return (sb.toString());
		}

		public void setImprovementWithNewUtilization(
		    double newUtilization)
		{
			double sizeRatio = (double)(toPsetSize - 1) /
			    toPsetSize;
			double expectedUtilization = sizeRatio *
			    getStartingUtilization();

			Poold.OPT_LOG.log(Severity.DEBUG,
			    "pset improvement calculation expected " +
			    expectedUtilization + ", got " + newUtilization);
			setImprovement(newUtilization - expectedUtilization);
		}

		public int hashCode() {
			return (((((cpuid.hashCode() ^
			    fromPsetName.hashCode()) ^ toPsetName.hashCode()) ^
			    fromPsetComposition.hashCode()) ^
			    toPsetComposition.hashCode()) ^
			    utilizationClass.hashCode());
		}

		public boolean equals(Object o) {
			if (!(o instanceof ComponentMoveDecision))
				return false;
			else {
				ComponentMoveDecision cmd =
				    (ComponentMoveDecision)o;
				return (cpuid.equals(cmd.cpuid) &&
				    fromPsetName.equals(cmd.fromPsetName) &&
				    toPsetName.equals(cmd.toPsetName) &&
				    fromPsetComposition.equals(
				    cmd.fromPsetComposition) &&
				    toPsetComposition.equals(
				    cmd.toPsetComposition) &&
				    utilizationClass.equals(
				    cmd.utilizationClass));
			}
		}

		/**
		 * Returns the group that this decision's utilization
		 * falls into.  Presently, there is only one group, but
		 * ostensibly decisions will later be grouped (e.g.
		 * into control-zone-wide groups).
		 */
		private String computeUtilizationClass(
		    double startingUtilization)
		{
			return "I";
		}

		public String toString()
		{
			StringBuffer sb = new StringBuffer();

			sb.append(cpuid.toString());
			sb.append(", ");
			sb.append(fromPsetName.toString());
			sb.append(", ");
			sb.append(toPsetName.toString());
			sb.append(", ");
			sb.append(fromPsetComposition.toString());
			sb.append(", ");
			sb.append(toPsetComposition.toString());
			sb.append(", ");
			sb.append(utilizationClass.toString());

			return (sb.toString());
		}

		private static final long serialVersionUID = 0xf7860687;
	}

	/**
	 * Vetoes a Move only if there is a prior decision that showed a
	 * degradation in resource utilization.
	 */
	public boolean veto(Move m, double utilization)
	{
		Decision current = Decision.forMove(m, utilization);
		Decision past;

		if (current != null) {
			past = (Decision)decisions.get(current.getKey());
			if (past != null)
				past.incrementUsage();
			if (past != null && past.getImprovement() < 0.0) {
				Poold.OPT_LOG.log(Severity.DEBUG, m +
				    " vetoed by decision " + past.describe());
				return true;
			}
		}

		return false;
	}

	private static final long serialVersionUID = 0xf7860687;

	/**
	 * Synchronize the decision history with the persistent version.
	 */
	public static DecisionHistory loadFromFile(String path)
	    throws IOException, ClassNotFoundException
	{
		return (load(new FileInputStream(path)));
	}

	/**
	 * Synchronize the persistent decision history with the present
	 * history.
	 */
	public void syncToFile(String path) throws IOException
	{
		FileOutputStream fos = new FileOutputStream(path);
		sync(fos);
		fos.close();
	}

	/**
	 * Synchronize the decision history with the persistent version,
	 * from the given stream.
	 */
	public static DecisionHistory load(InputStream is)
	    throws IOException, ClassNotFoundException
	{
		ObjectInputStream ois = new ObjectInputStream(is);

		DecisionHistory dh = (DecisionHistory)ois.readObject();
		return (dh);
	}

	/**
	 * Serialize the persistent decision history to the given
	 * stream.
	 */
	public void sync(OutputStream os) throws IOException
	{
		new ObjectOutputStream(os).writeObject(this);
	}

	public String toString()
	{
		StringBuffer sb = new StringBuffer();

		sb.append(decisions.keySet().size() + " decisions {");
		Iterator it = decisions.keySet().iterator();
		while (it.hasNext()) {
			String dk = (String)it.next();
			Decision d = (Decision)decisions.get(dk);

			sb.append("\t(");
			sb.append(d.describe());
			sb.append(")\n");
		}
		sb.append("}");

		return (sb.toString());
	}

	/**
	 * Measures the improvement in utilization of any resource for
	 * which a decision was recently made.
	 */
	public void expireAndMeasureImprovements(Monitor mon)
	{
		/*
		 * Measure the improvement in resources involved in
		 * recent decisions.
		 */
		if (mon.isValid()) {
			for (Iterator it = resourcesAwaitingImprovement.
			    keySet().iterator(); it.hasNext(); ) {
				Resource res = (Resource)it.next();
				try {
					double utilization = mon.
					    getUtilization(res);
					recordImprovementWithUtilization(res,
					    utilization);
				} catch (StaleMonitorException sme) {
					/*
					 * We can't access the utilization, so
					 * remove the decision.
					 */
					String decisionKey = (String)
					    resourcesAwaitingImprovement.
					    get(res);
					if (decisionKey != null)
						decisions.remove(decisionKey);
				}
				it.remove();
			}
		}

		/*
		 * Expire decisions which have outlived
		 * DECISION_LIFETIME samples.
		 */
		int cutoff = mon.getSampleCount() - DECISION_LIFETIME;
		if (cutoff > 0) {
			Decision decision;
			ListIterator it = decisionList.listIterator(0);
			while (it.hasNext()) {
				decision = (Decision)it.next();
				int sc = decision.getStartingSampleCount();
				if (sc < cutoff) {
					if (sc > 0) {
						Poold.OPT_LOG.log(
						    Severity.DEBUG,
						    "expiring decision (" +
						    decision + ")");
						it.remove();
						decisions.remove(
						    decision.getKey());
					}
				} else
					break;
			}
		}
	}

	private void readObject(ObjectInputStream s)
	    throws IOException, ClassNotFoundException
	{
		s.defaultReadObject();

		resourcesAwaitingImprovement = new HashMap();
		decisionList = new LinkedList();
		for (Iterator it = decisions.keySet().iterator();
		    it.hasNext(); ) {
			String decisionKey = (String)it.next();
			Decision decision = (Decision)decisions.get(
			    decisionKey);
			decision.setStartingSampleCount(0);
			decisionList.add(decision);
		}
	}
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.util.regex.*;

/**
 * This class provides the base implementation of an Expression. All
 * types of Expression must inherit from this class.
 *
 * An objective is always specified in terms of an expression. The
 * only recognized expressions are those known by this class. An
 * expression is create using the valueOf() factory method, which is
 * why Expressions must be known to this class.
 */
abstract class Expression
{
	/**
	 * Expression importance
	 */
	private long imp = -1;

	/**
	 * Expression name
	 */
	private String name;

	/**
	 * Sole constructor.  (For invocation by subclass constructors)
	 */
	protected Expression(long imp, String name)
	{
		this.imp = imp;
		this.name = name;
	}

	/**
	 * Return the name of the expression.
	 */
	String getName()
	{
		return (this.name);
	}

	/**
	 * Return the importance of the expression.
	 */
	long getImportance()
	{
		return (imp);
	}

	/**
	 * Returns the supplied string as an expression.
	 *
	 * This utility function attempts to identify the supplied
	 * string as an expression. It tries in turn each of the known
	 * sub-classes until finally, if none can be recognized, an
	 * exception is thrown. This function is not immune to
	 * mistakenly mis-classifying an expression. It is the
	 * responsibility of the concrete Exrpession classes to ensure
	 * that syntactic integrity is maintained with respect to
	 * potential cases of mistaken identity.
	 *
	 * @param raw The candidate expression
	 * @throws IllegalArgumentException If no valid expression can
	 * be found
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		Expression exp = null;
		/*
		 * TODO It would be better if subclasses registered,
		 * but this hard coded list will do until such a time
		 */
		if ((exp = KVOpExpression.valueOf(raw)) == null)
			if ((exp = KVExpression.valueOf(raw)) == null)
				exp = KExpression.valueOf(raw);
		if (exp == null)
			throw new IllegalArgumentException(
			    "unrecognized expression: " + raw);
		return (exp);
	}

	/**
	 * Ensure that the supplied importance is a valid value.
	 *
	 * @param imps String representation of the importance.
	 *
	 * @throws IllegalArgumentException if the importance is not
	 * valid.
	 */
	protected static long validateImportance(String imps)
	    throws IllegalArgumentException
	{
		long imp;

		try {
			imp = Long.parseLong(imps);
		} catch (NumberFormatException nfe) {
			throw new IllegalArgumentException("importance value " +
			    imps + " is not legal");
		}

		if (imp < 0)
			throw new IllegalArgumentException("importance value " +
			    imps + " is not legal (must be positive)");
		return (imp);
	}

	/**
	 * Ensure that the supplied keyword is a member of the
	 * supplied keys.
	 *
	 * @param keys Array of valid key strings.
	 * @param key Key sought.
	 *
	 * @throws IllegalArgumentException if the sought key is not
	 * a member of the keys array.
	 */
	protected static void validateKeyword(String keys[], String key)
	    throws IllegalArgumentException
	{
		for (int i = 0; i < keys.length; i++) {
			if (keys[i].compareTo(key) == 0)
				return;
		}
		throw new IllegalArgumentException("keyword " + key +
		    " is not recognized");
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. The definition of contradiction is left down to
	 * each implementing sub-class.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public abstract boolean contradicts(Expression o);
}

/**
 * This class implements the functionality for a key-value-operator
 * expression.
 *
 * The general form of this expression is defined in the pattern
 * member. A simplified rendition of which is:
 *
 * [[imp]:] <key> <op> <value>
 *
 * key is a string which identifies the expression
 * op is the operator for the expression ( < | > | ~)
 * value is the value of the expression
 *
 * For example:
 *
 * 10: utilization < 80
 */
final class KVOpExpression extends Expression
{
	/**
	 * The operator for this expression.
	 */
	private char op;

	/**
	 * The value of this expression.
	 */
	private int val;

	/**
	 * The pattern used to recognize this type of expression.
	 */
	private static final Pattern pattern = Pattern.compile(
	    "\\s*((\\d+)\\s*:)?\\s*(\\w+)\\s*([~<>])\\s*(\\d+)\\s*");

	/**
	 * The array of valid keys for this type of expression.
	 */
	private static final String keys[] = { "utilization" };

	/**
	 * A greater than operator.
	 */
	static final char GT = '>';

	/**
	 * A less than operator.
	 */
	static final char LT = '<';

	/**
	 * A near to operator.
	 */
	static final char NT = '~';

	/**
	 * Private constructor used in the valueOf() factory method.
	 *
	 * @param imp The importance of this expression.
	 * @param name The name of this expression.
	 * @param op The operator of this expression.
	 * @param val The value of this expression.
	 */
	private KVOpExpression(long imp, String name, String op, int val)
	{
		super(imp, name);
		this.op = op.charAt(0);
		this.val = val;
	}

	/**
	 * Create and return an expression from the input string.
	 *
	 * Determine if the input string matches the syntax defined by
	 * this expression. If the expression cannot be matched, an
	 * exception will be thrown.
	 *
	 * @param raw Candidate expression string.
	 *
	 * @throws IllegalArgumentExpression if the string is not a
	 * valid expression of this type.
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		KVOpExpression exp = null;
		Matcher m = pattern.matcher(raw);

		if (m.matches()) {
			long imp = 1;
			int val = Integer.parseInt(m.group(5));

			if (m.group(2) != null)
				imp = validateImportance(m.group(2));

			validateKeyword(keys, m.group(3));
			if (val > 100 || val < 0)
				throw new IllegalArgumentException(
				    "expression value " + val +
				    " is outside the legal range (0-100)");
			exp = new KVOpExpression(imp, m.group(3),
			    m.group(4), val);
		}
		return (exp);
	}

	/**
	 * Return the operator for this expression.
	 */
	char getOp()
	{
		return (op);
	}

	/**
	 * Return the value of this expression.
	 */
	int getValue()
	{
		return (val);
	}

	/**
	 * Return a string representation of this expresssion.
	 */
	public String toString()
	{
		return ("(" + getImportance() + ", " + getName() + ", '" + op +
		    "', " + val + ")");
	}

	/**
	 * Indicates whether some other KVOpExpression is "equal to
	 * this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof KVOpExpression))
			return (false);
		KVOpExpression other = (KVOpExpression) o;
		if (getName().compareTo(other.getName()) != 0 ||
		    op != other.getOp() || val != other.getValue())
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getName().hashCode() + (int) op + val);
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. If the supplied expression is not of the same
	 * type, then it cannot contradict it. If the names are
	 * different then there can be no contradiction.
	 *
	 * Contradiction occurs if the operator is the same or if they
	 * aren't the same and the operator is < or > and the values
	 * aren't simultanteously achievable.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public boolean contradicts(Expression o)
	{
		if (!(o instanceof KVOpExpression))
			return (false);
		KVOpExpression other = (KVOpExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		if (getOp() != other.getOp()) {
			if (getOp() != NT && other.getOp() != NT) {
				if (getOp() == GT) {
					if (getValue() < other.getValue())
						return (false);
				} else {
					if (getValue() > other.getValue())
						return (false);
				}
			} else
				return (false);
		}
		return (true);
	}
}

/**
 * This class implements the functionality for a key-value expression.
 *
 * The general form of this expression is defined in the pattern
 * member. A simplified rendition of which is:
 *
 * [[imp]:] <key> <value>
 *
 * key is a string which identifies the expression
 * value is the value of the expression
 *
 * For example:
 *
 * 10: locality tight
 */
final class KVExpression extends Expression
{
	/**
	 * The value of this expression.
	 */
	private String val;

	/**
	 * The pattern used to recognize this type of expression.
	 */
	private static final Pattern pattern = Pattern.compile(
	    "\\s*((\\d+)\\s*:)?\\s*(\\w+)\\s+(tight|loose|none)\\s*");

	/**
	 * The array of valid keys for this type of expression.
	 */
	private static final String keys[] = { "locality" };

	/**
	 * Private constructor used in the valueOf() factory method.
	 *
	 * @param imp The importance of this expression.
	 * @param name The name of this expression.
	 * @param val The value of this expression.
	 */
	private KVExpression(long imp, String name, String val)
	{
		super(imp, name);
		this.val = val;
	}

	/**
	 * Create and return an expression from the input string.
	 *
	 * Determine if the input string matches the syntax defined by
	 * this expression. If the expression cannot be matched, an
	 * exception will be thrown.
	 *
	 * @param raw Candidate expression string.
	 *
	 * @throws IllegalArgumentExpression if the string is not a
	 * valid expression of this type.
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		KVExpression exp = null;
		Matcher m = pattern.matcher(raw);

		if (m.matches()) {
			long imp = 1;

			if (m.group(2) != null)
				imp = validateImportance(m.group(2));

			validateKeyword(keys, m.group(3));
			exp = new KVExpression(imp, m.group(3), m.group(4));
		}
		return (exp);
	}

	/**
	 * Return the value of this expression.
	 */
	String getValue()
	{
		return (val);
	}

	/**
	 * Return a string representation of this expresssion.
	 */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append("(");
		buf.append(getImportance());
		buf.append(", ");
		buf.append(getName());
		buf.append(", ");
		buf.append(val);
		buf.append(")");

		return (buf.toString());
	}

	/**
	 * Indicates whether some other KVExpression is "equal to
	 * this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof KVExpression))
			return (false);
		KVExpression other = (KVExpression) o;
		if (getName().compareTo(other.getName()) != 0 ||
		    val.compareTo(other.getValue()) != 0)
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getName().hashCode() + val.hashCode());
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. If the supplied expression is not of the same
	 * type, then it cannot contradict it. If the names are
	 * different then there can be no contradiction.
	 *
	 * Contradiction occurs if the value is different.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public boolean contradicts(Expression o)
	{
		if (!(o instanceof KVExpression))
			return (false);
		KVExpression other = (KVExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		if (val.compareTo(other.getValue()) == 0)
			return (false);
		return (true);
	}
}

/**
 * This class implements the functionality for a key expression.
 *
 * The general form of this expression is defined in the pattern
 * member. A simplified rendition of which is:
 *
 * [[imp]:] <key>
 *
 * key is a string which identifies the expression
 *
 * For example:
 *
 * 10: wt-load
 */
final class KExpression extends Expression
{
	/**
	 * The pattern used to recognize this type of expression.
	 */
	private static final Pattern pattern = Pattern.compile(
	    "\\s*((\\d+)\\s*:)?\\s*([\\w-]+)\\s*");

	/**
	 * The array of valid keys for this type of expression.
	 */
	private static final String keys[] = { "wt-load" };

	/**
	 * Private constructor used in the valueOf() factory method.
	 *
	 * @param imp The importance of this expression.
	 * @param name The name of this expression.
	 */
	private KExpression(long imp, String name)
	{
		super(imp, name);
	}

	/**
	 * Create and return an expression from the input string.
	 *
	 * Determine if the input string matches the syntax defined by
	 * this expression. If the expression cannot be matched, an
	 * exception will be thrown.
	 *
	 * @param raw Candidate expression string.
	 *
	 * @throws IllegalArgumentExpression if the string is not a
	 * valid expression of this type.
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		KExpression exp = null;
		Matcher m = pattern.matcher(raw);

		if (m.matches()) {
			long imp = 1;

			if (m.group(2) != null)
				imp = validateImportance(m.group(2));

			validateKeyword(keys, m.group(3));
			exp = new KExpression(imp, m.group(3));
		}
		return (exp);
	}

	/**
	 * Return a string representation of this expresssion.
	 */
	public String toString()
	{
		return ("(" + getImportance() + ", " + getName() + ")");
	}

	/**
	 * Indicates whether some other KExpression is "equal to
	 * this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof KExpression))
			return (false);
		KExpression other = (KExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getName().hashCode());
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. If the supplied expression is not of the same
	 * type, then it cannot contradict it. If the names are
	 * different then there can be no contradiction.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public boolean contradicts(Expression o)
	{
		if (!(o instanceof KExpression))
			return (false);
		KExpression other = (KExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		return (true);
	}
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 *ident	"%Z%%M%	%I%	%E% SMI"
 *
 */

package com.sun.solaris.domain.pools;

import java.util.*;
import java.util.logging.*;

import com.sun.solaris.service.logging.Severity;
import com.sun.solaris.service.pools.*;

/**
 * The <code>LogDRM</code> class implements the Distributed Resource
 * Management (DRM) protocol as a logger.
 *
 * All actions are logged using the logging facilities offered by
 * <code>Poold</code>.
 */
class LogDRM implements DRM
{
	/**
	 * Supported protocol version.
	 */
	private final int version = 1;

	/**
	 * Location of higher level resource manager.
	 */
	private String url;

	/**
	 * Connect to a higher level partitioning agent.
	 *
	 * @param requested The requested version of the protocol.
	 * @param url The location of the agent.
	 * @throws Exception If the connect fails.
	 */
	public void connect(int requested, String url) throws Exception
	{
		if (requested > version) {
			Poold.CONF_LOG.log(Severity.NOTICE,
			    "Requested protocol version (" + requested +
			    ") not supported");
			return;
		}
		this.url = url;
		Poold.CONF_LOG.log(Severity.INFO, "DRM protocol version:" +
		    version + ", server: " + url);
	}


	/**
	 * Disconnect from a higher level partitioning agent.
	 *
	 * @throws Exception If the client is not connected.
	 */
	public void disconnect() throws Exception
	{
		Poold.CONF_LOG.log(Severity.INFO, "Disconnected from " + url);
	}


	/**
	 * Request resources via a higher level partitioning agent.
	 *
	 * TODO: Define request parameters.
	 *
	 * @throws Exception If the request fails.
	 */
	public void request() throws Exception
	{
		Poold.MON_LOG.log(Severity.INFO, "Requesting additional " +
		    "resources ");
	}


	/**
	 * Offer resources via a higher level partitioning agent.
	 *
	 * TODO: Define offer parameters.
	 *
	 * @throws Exception If the offer fails.
	 */
	public void offer() throws Exception
	{
		Poold.MON_LOG.log(Severity.INFO, "Requesting additional " +
		    "resources ");
	}

	/**
	 * Canel a previous offer or request.
	 *
	 * TODO: Define cancel parameters.
	 *
	 * @throws Exception If the cancel fails.
	 */
	public void cancel() throws Exception
	{
		Poold.MON_LOG.log(Severity.INFO, "Requesting additional " +
		    "resources ");
	}
}
#
# 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 2010 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/domain/pools/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold

SOURCE =	Move.java \
		Expression.java \
		Statistic.java \
		StatisticList.java \
		Monitor.java \
		Objective.java \
		ResourceMonitor.java \
		SystemMonitor.java \
		Solver.java \
		SystemSolver.java \
		DecisionHistory.java \
		DRM.java \
		LogDRM.java \
		Poold.java

all install: $(SOURCE:.java=.class)

# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *.class

include $(SRC)/cmd/Makefile.targ
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 *ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.util.Map;

import com.sun.solaris.service.pools.Configuration;
import com.sun.solaris.service.pools.Resource;
import com.sun.solaris.service.pools.PoolsException;

/**
 * A monitoring class. The user of this interface can retrieve
 * monitoring information related to the configuration which is
 * examined.
 */

public interface Monitor {
	/**
	 * Initialize the monitoring object using details from the
	 * supplied configuration.
	 *
	 * @param conf The configuration to be monitored.
	 * @throws PoolsException If the initialize fails.
	 * @throws StaleMonitorException If the resource monitors
	 * cannot be accessed.
	 */
	public void initialize(Configuration conf) throws PoolsException,
	    StaleMonitorException;

	/**
	 * Return the next sample.
	 *
	 * This call is a blocking call. The sample will only be
	 * returned after pausing the invoking thread for the "sample
	 * interval".
	 *
	 * @throws StaleMonitorException If the sample fails.
	 * @throws PoolsException If there is an error manipulating the
	 * pools configuration.
	 * @throws InterruptedException If the thread is interrupted
	 * while waiting for the sampling time to arrive.  The caller
	 * may wish to check other conditions before possibly
	 * reinitiating the sample.
	 */
	public void getNext() throws StaleMonitorException, PoolsException,
	    InterruptedException;

	/**
	 * Return the number of samples taken.  This is the number of
	 * successful calls to <code>getNext()</code>.
	 */
	public int getSampleCount();

	/**
	 * Return the utilization for supplied resource.
	 *
	 * @param res The resource to be examined.
	 *
	 * @throws StaleMonitorException if the resource cannot be accessed.
	 */
	public double getUtilization(Resource res) throws StaleMonitorException;
	public boolean isValid();
	public ResourceMonitor get(Resource res) throws StaleMonitorException;
}

/**
 * Indicates that a monitor must be re-initialized. This can occur
 * for a number of reasons, including:
 *
 * <ul>
 * <li><p>
 * Resources created, modified, destroyed whilst sampling
 * </ul>
 */
class StaleMonitorException extends Exception {
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.util.*;

import com.sun.solaris.service.pools.*;

/**
 * This class represents a move of resources between two resource
 * sets. It is designed to be extended by classes which implement
 * different types of moves.
 */
abstract class Move
{
	/**
	 * Source resource set
	 */
	private Resource from;

	/**
	 * Destination resource set
	 */
	private Resource to;

	/**
	 * Sole constructor.  (For invocation by subclass constructors)
	 *
	 * @param from The source of the move
	 * @param to The destination of the move
	 */
	protected Move(Resource from, Resource to)
	{
		this.from = from;
		this.to = to;
	}

	/**
	 * Return the source of this move.
	 */
	Resource getFrom()
	{
		return (from);
	}

	/**
	 * Return the destination of this move.
	 */
	Resource getTo()
	{
		return (to);
	}

	/**
	 * Apply this move to the resources described.
	 *
	 * @throws PoolsException If the move fails for any reason.
	 */
	abstract void apply() throws PoolsException;

	/**
	 * Return the quantity of moved resource.
	 */
	abstract long getQty();
}

/**
 * This class represents a move of component resources between two
 * resource sets. A component of a resource set is a uniquely
 * identifiable component, such as a processor.
 */
final class ComponentMove extends Move
{
	/**
	 * List of components being moved.
	 */
	private List compList;

	/**
	 * Constructor
	 *
	 * @param from The source of the move
	 * @param to The destination of the move
	 * @param comp The component which is to be moved
	 */
	ComponentMove(Resource from, Resource to, Component comp)
	{
		super(from, to);
		compList = new ArrayList();
		compList.add(comp);
	}

	/**
	 * Return a list of the components that comprise this move.
	 *
	 * The members of the list are guaranteed to be Component
	 * objects.
	 */
	List getComponents()
	{
		return ((List) ((ArrayList) compList).clone());
	}

	/**
	 * Apply the move to the configuration to which the resources
	 * belong.
	 *
	 * @throws PoolsException if the transfer of resource fails.
	 */
	void apply() throws PoolsException
	{
		getTo().transfer(getFrom(), compList);
	}

	/**
	 * Return the quantity of resource which is participating in
	 * this move.
	 */
	long getQty()
	{
		return (compList.size());
	}

	/**
	 * Converts the <code>ComponentMove</code> to a
	 * <code>String</code> of the form:
	 */
	public String toString()
	{
		return ("from " + getFrom().toString() + " to " +
		    getTo().toString() + " components " + compList);
	}
}

/**
 * This class represents a move of commodity resources between two
 * resource sets. Such a resource cannot be uniquely identified in the
 * resource abstraction and is thus different to a move consisting of
 * uniquely identifiable resource components.
 */
class QuantityMove extends Move
{
	/**
	 * The resource quantity of the move.
	 */
	private long qty;

	/**
	 * Construct a quantity move using the supplied details.
	 *
	 * @param from The source of the resources.
	 * @param to The destination of the resources.
	 * @param qty The quantity of the resources.
	 *
	 * @throws IllegalArgumentException if the qty is negative.
	 */
	QuantityMove(Resource from, Resource to, long qty)
	{
		super(from, to);
		if (qty < 0)
			throw new IllegalArgumentException(
			    "The resource quantity supplied (" + qty +
			    ") is illegal.");
		this.qty = qty;
	}

	/**
	 * Apply the move to the configuration to which the resources
	 * belong.
	 *
	 * @throws PoolsException if the transfer of resource fails.
	 */
	void apply() throws PoolsException
	{
		getTo().transfer(getFrom(), qty);
	}

	/**
	 * Return the quantity of resource which is participating in
	 * this move.
	 */
	long getQty()
	{
		return (qty);
	}

	/**
	 * Return a string representation of the move.
	 */
	public String toString()
	{
		return ("from " + getFrom().toString() + " to " +
		    getTo().toString() + " quantity " + qty);
	}
}
/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

package com.sun.solaris.domain.pools;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.text.DecimalFormat;
import java.util.*;
import java.util.logging.*;

import com.sun.solaris.service.logging.Severity;
import com.sun.solaris.service.locality.*;
import com.sun.solaris.service.pools.*;


/**
 * An objective interface. All classes which wish to contribute to the
 * Objective Function (OF hence) calculation must implement this
 * interface. This interface defines a strategy which can be used to
 * make a contribution to the Objective Function calculation.
 *
 * The OF calculation (which is implemented by <code>Poold</code>)
 * consists of determining all possible resource moves across all
 * resources. Once all moves are known, all registered objectives
 * (i.e. instances of this interface) are called and asked to value
 * the move.
 *
 * Note, the output of this method is constrained to be between -1 and
 * 1, representing minimum and maximum desirability of this move in
 * terms of this objective. This is enforced by <code>Poold</code> and
 * an <code>IllegalOFValueException</code> will be thrown if this
 * constraint is broken.
 */
interface Objective
{
	/**
	 * Return the contribution of this objective. The contribution
	 * is constrainted to be a value between -1 and +1 to ensure
	 * that no objective can make a disproportionate contribution
	 * to the total result.
	 *
	 * The more desirable this move appears in terms of this
	 * objective, the closer to +1 will be the value. A value of 0
	 * indicates that the move is neutral in terms of the
	 * objective. A negative value indicates that the move is
	 * undesirable.
	 *
	 * @param conf The configuration which is being examined
	 * @param move The move under consideration
	 * @param elem The element to which the objective applies
	 *
	 * @throws PoolsException if there is an error manipulating
	 * the configuration
	 */
	public double calculate(Configuration conf, Move move, Element elem)
	    throws PoolsException;

	/**
	 * Set the objective's expression to the supplied parameter.
	 *
	 * @param exp An expression for this objective.
	 */
	public void setExpression(Expression exp);

	/**
	 * Get the objective's expression.
	 */
	public Expression getExpression();
}

/**
 * This interface must be implemented by all Objectives which are
 * workload dependent. The examine method is used by a Solver to
 * determine if the objective is still being satisfied.
 */
interface WorkloadDependentObjective extends Objective
{
	/**
	 * This method returns true if the Objective is no longer
	 * satisfied. If the objective is still satisfied, then return
	 * false.
	 *
	 * @param conf The configuration to be examined
	 * @param solver The solving interface used to get utilization
	 * information
	 * @param elem The element to which the objective belongs
	 *
	 * @throws PoolsException if there is an error examining the
	 * pool configuration
	 * @throws StaleMonitorException if there is an error accessing
	 * the element's ResourceMonitor
	 */
	public boolean examine(Configuration conf, Solver solver,
	    Element elem) throws PoolsException, StaleMonitorException;
}

/**
 * This class provides a skeletal implementation of the
 * <code>Objective</code> interface to minimize the effort required
 * to implement this interface.
 *
 * To implement an objective, the programmer need only to extend this
 * class and add the name of the class into the appropriate element
 * objectives property in the <code>poold.properties</code> file.
 */
abstract class AbstractObjective implements Objective
{
	abstract public double calculate(Configuration conf, Move move,
	    Element elem) throws PoolsException;

	/**
	 * The objectives which are recognized by this class
	 */
	private static Map objectives;

	/**
	 * The expression associated with this objective
	 */
	private Expression exp;

	/**
	 * Set the objective's expression to the supplied parameter.
	 *
	 * @param exp An expression for this objective.
	 */
	public void setExpression(Expression exp)
	{
		this.exp = exp;
	}

	/**
	 * Get the objective's expression.
	 */
	public Expression getExpression()
	{
		return (exp);
	}

	/**
	 * A factory method which returns a created objective which is
	 * associated with the supplied expression. The type and the
	 * expression are used to identify valid types of objectives
	 * to which this expression may be applied. If an acceptable
	 * objective cannot be found for the supplied type, then an
	 * <code>IllegalArgumentException</code> will be thrown.
	 *
	 * @param type The element type for which an objective must be
	 * found
	 * @param exp The expression which will be associated with the
	 * objective
	 *
	 * @throws IllegalArgumentExcetion if the supplied expression
	 * cannot be associated with an objective of the supplied type
	 */
	public static Objective getInstance(String type, Expression exp)
	    throws IllegalArgumentException
	{
		Objective ret = null;
		Map typeObjs = null;

		initMapIfNecessary();
		typeObjs = (Map)objectives.get(type);
		if (typeObjs != null) {
			Class objClass = (Class)typeObjs.get(exp.getName());
			if (objClass != null) {
				try {
					ret = (Objective) objClass.
					    newInstance();
				} catch (Exception e) {
					Poold.utility.die(Poold.OPT_LOG, e,
					    true);
				}
				ret.setExpression(exp);
			}
		}
		if (ret == null)
			throw new IllegalArgumentException(
			    "unrecognized objective name for " + type + ": " +
			    exp.toString());
		return (ret);
	}

	/**
	 * Return a string representation of this objective.
	 */
	public String toString()
	{
		return (exp.toString());
	}

	/**
	 * Initialize the implementation map the first time it's
	 * called.
	 */
	private static void initMapIfNecessary()
	{
		/*
		 * Setup the objectives map for the known classes
		 */
		if (objectives == null) {
			objectives = new HashMap();
			Properties props = new Properties();
			try {
				props.load(
				    new FileInputStream(
				    Poold.POOLD_PROPERTIES_PATH));
			} catch (IOException ioe) {
				Poold.utility.die(Poold.CONF_LOG, ioe);
			}
			registerObjectives(props, objectives, "system");
			registerObjectives(props, objectives, "pset");
		}
	}

	/**
	 * Add the objectives contained in the supplied properties to
	 * the set of valid objectives. The objectives are updated
	 * with objectives of the supplied type contained in the
	 * properties.
	 *
	 * @param props The properties containing the objectives
	 * @param objectives The objectives to be updated
	 * @param type The type of objectives to be added
	 */
	private static void registerObjectives(Properties props,
	    Map objectives, String type)
	{
		Map typeObjs = new HashMap();
		String objs = props.getProperty(type + ".objectives");
		String objNames[] = objs.split(",");
		for (int i = 0; i < objNames.length; i++) {
			String objName = objNames[i].trim();
			try {
				Class clazz = Class.forName(objName);
				Field field = clazz.getDeclaredField("name");
				String key = (String) field.get(null);
				typeObjs.put(key, clazz);
			} catch (ClassNotFoundException cnfe) {
				Poold.utility.die(Poold.CONF_LOG, cnfe);
			} catch (NoSuchFieldException nsfe) {
				Poold.utility.die(Poold.CONF_LOG, nsfe);
			} catch (IllegalAccessException iae) {
				Poold.utility.die(Poold.CONF_LOG, iae);
			}
		}
		objectives.put(type, typeObjs);
	}

	/**
	 * Indicates whether some other Objective is "equal to this
	 * one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof Objective))
			return (false);
		Objective other = (Objective) o;

		return (getExpression().equals(other.getExpression()));
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getExpression().hashCode());
	}
}


/**
 * The <code>WeightedLoadObjective</code> class implements a Weighted
 * Load Objective for <code>Poold</code>.
 *
 * The goal is to allocate more resources to those resource partitions
 * which are heavily loaded. The weighting is determined from the
 * objective importance and the pool.importance.
 */
final class WeightedLoadObjective extends AbstractObjective
    implements WorkloadDependentObjective
{
	/**
	 * The name of the class.
	 */
	static final String name = "wt-load";

	/**
	 * The map of calculations made during examination.
	 */
	Map calcMap;

	/**
	 * Determine whether an objective is satisfied. If the
	 * objective is still satisfied, return false; otherwise
	 * return true.
	 *
	 * This objective examination determines if all resource sets
	 * are allocated the share of resources that their utilization
	 * would indicate they should be. This attempts to ensure that
	 * highly utilized resource sets recieve the greater
	 * proportion of available resources.
	 *
	 * @param conf The configuration to be examined
	 * @param solver The solving interface used to get utilization
	 * information
	 * @param elem The element to which the objective belongs
	 *
	 * @throws PoolsException if there is an error examining the
	 * pool configuration
	 * @throws StaleMonitorException if there is an error accessing
	 * the element's ResourceMonitor
	 */
	public boolean examine(Configuration conf, Solver solver,
	    Element elem) throws PoolsException, StaleMonitorException
	{
		Monitor mon = solver.getMonitor();
		Value val = new Value("type", "pset");
		List valueList = new LinkedList();
		calcMap = new HashMap();
		valueList.add(val);

		List resList = conf.getResources(valueList);
		val.close();
		Iterator itRes = resList.iterator();

		Calculation.totalUtil = 0;
		Calculation.resQ = 0;

		while (itRes.hasNext()) {
			Resource res = (Resource) itRes.next();
			List CPUs = res.getComponents(null);

			try {
				Calculation calc = new Calculation(res, CPUs,
				    mon.getUtilization(res),
				    res.getLongProperty("pset.min"),
				    res.getLongProperty("pset.max"));
				calcMap.put(res, calc);
			} catch (StaleMonitorException sme) {
				Poold.MON_LOG.log(Severity.INFO,
				    res.toString() +
				    " not participating in " + toString() +
				    " calculatation as it has no " +
				    "available statistics.");
			}
		}
		Iterator itCalc = calcMap.values().iterator();
		while (itCalc.hasNext()) {
			Calculation calc = (Calculation) itCalc.next();
			if (calc.getShare() != calc.comp.size() &&
			    calc.getShare() >= calc.min) {
				Poold.MON_LOG.log(Severity.INFO,
				    elem.toString() +
				    " utilization objective not satisfied " +
				    toString() + " with desired share " +
				    calc.getShare() + " and actual share " +
				    calc.comp.size());
				return (true);
			}
		}
		return (false);
	}

	/**
	 * Holds data about weighted load calculations. This class is
	 * basically a structure which holds information specific to a
	 * weighted-load calculation
	 */
	static class Calculation {
		/**
		 * The resource on which this calculation is based.
		 */
		Resource res;

		/**
		 * The list of component resources held by this resource.
		 */
		List comp;

		/**
		 * The utilization of this resource.
		 */
		double util;

		/**
		 * The minimum value of this resource's size.
		 */
		long min;

		/**
		 * The maximum value of this resource's size.
		 */
		long max;

		/**
		 * The total utilization of all instances of this class.
		 */
		static double totalUtil;

		/**
		 * The total quantity of resource for all instances of
		 * this class.
		 */
		static int resQ;

		/**
		 * Constructor. The class is immutable and holds
		 * information specific to a set of calculations about
		 * load.
		 *
		 * @param res The resource set
		 * @param comp The resource components
		 * @param util The resource utilization
		 * @param min The minimum qty of resource for this set
		 * @param max The maximum qty of resource for this set
		 */
		public Calculation(Resource res, List comp, double util,
		    long min, long max)
		{
			this.res = res;
			this.comp = comp;
			this.min = min;
			this.max = max;
			this.util = (util / 100) * comp.size();
			Calculation.totalUtil += this.util;
			Calculation.resQ += comp.size();
		}

		/**
		 * Return the share of the total resource for this
		 * resource.
		 */
		long getShare()
		{
			if (util == 0)
				return (0);
			return (Math.round((util / totalUtil) * resQ));
		}

		public String toString()
		{
			StringBuffer buf = new StringBuffer();
			buf.append("res: " + res.toString());
			buf.append(" components: " + comp.toString());
			buf.append(" min: " + min);
			buf.append(" max: " + max);
			buf.append(" util: " + util);
			buf.append(" total resource: " + resQ);
			buf.append(" total utilization: " + totalUtil);
			buf.append(" share: " + getShare());
			return (buf.toString());
		}
	}

	/**
	 * Calculates the value of a configuration in terms of this
	 * objective.
	 *
	 * In the examination step, calculations of each resource's
	 * current and desired share were made. The moves can thus be
	 * assessed in terms of their impact upon the desired
	 * share. The current difference from desired is already
	 * known, so each move will serve to reduce or increase that
	 * difference. Moves that increase the difference have a
	 * negative score, those that reduce it have a positive
	 * score. All scores are normalized to return a value between
	 * -1 and 1.
	 *
	 * @param conf Configuration to be scored.
	 * @param move Move to be scored.
	 * @param elem The element to which the objective applies
	 * @throws PoolsException If an there is an error in execution.
	 */
	public double calculate(Configuration conf, Move move, Element elem)
	    throws PoolsException
	{
		double ret = 0;

		Poold.OPT_LOG.log(Severity.DEBUG,
		    "Calculating objective type: " + name);
		/*
		 * There shouldn't be any empty moves, but if there
		 * are they are rated at 0.
		 */
		if (move.getQty() == 0)
			return (0);

		/*
		 * Find the calculations that represent the source and
		 * target of the move.
		 */
		Calculation src = (Calculation) calcMap.get(move.getFrom());
		Calculation tgt = (Calculation) calcMap.get(move.getTo());

		/*
		 * Use the calculation details to determine the "gap"
		 * i.e. number of discrete resources (for a processor
		 * set these are CPUs), between the desired quantity in
		 * the set which the calculations represent. Do this
		 * both before and after the proposed move.
		 *
		 * The maximum possible improvement is equal to the
		 * total number of resources for each set participating
		 * in the calculation. Since there are two sets we
		 * know the maximum possible improvement is resQ * 2.
		 *
		 * Divide the aggregated change in gap across participating
		 * sets by the maximum possible improvement to obtain
		 * a value which scores the move and which is normalised
		 * between -1 <= ret <= 1.
		 */
		long oldGap = Math.abs(src.getShare() -
		    src.comp.size());
		long newGap = Math.abs(src.getShare() -
		    (src.comp.size() - move.getQty()));
		ret = oldGap - newGap;
		oldGap = Math.abs(tgt.getShare() -
		    tgt.comp.size());
		newGap = Math.abs(tgt.getShare() -
		    (tgt.comp.size() + move.getQty()));
		ret += oldGap - newGap;
		ret /= ((double) Calculation.resQ * 2);

		Poold.MON_LOG.log(Severity.DEBUG, "ret: " + ret);
		return (ret);
	}
}

    /*
     * The following LGroupData and Resulttuple and PSETData classes
     * are used for the purposes of calculating and storing
     * results sets for the LocalityObjective calculate method.
     */

    /*
     * To store data for a Localitygroup.
     *
     * The lgroup is the LocalityGroup.
     * The numcpu is the number of cpu in the LocalityGroup.
     * The factor is a value required in calculating the LocalityGroup quotient.
     *
     * The value of factor will always be a finite number
     * because the LocalityGroup will never be empty.
     */
    final class LGroupData
    {
            private LocalityGroup lgroup;
            private int numcpu = 0;
            private double factor;

            LGroupData(LocalityGroup l) {
                lgroup = l;
                int numcpuinlgroup = lgroup.getCPUIDs().length;
                factor = 2.0 / ((numcpuinlgroup * numcpuinlgroup)
                        + numcpuinlgroup);
            }

            int getNumcpu() {
                return numcpu;
            }

            double getFactor() {
                return factor;
            }

            void incNumcpu() {
                numcpu++;
            }
    }

    /*
     * Stores the results of caclulated locality quotients for a PSET.
     *
     * The AsIsResult is the quotient without any move.
     * The FromResult is the quotient when a cpu is taken from it.
     * The To result is the quotient when a cpu is added to it.
     */
    final class ResultTuple
    {
            private double AsIsResult = 0;
            private double FromResult = 0;
            private double ToResult = 0;

            ResultTuple(double a, double f, double t) {
                setAsIsResult(a);
                setFromResult(f);
                setToResult(t);
            }

            double getAsIsResult() {
                return AsIsResult;
            }

            double getFromResult() {
                return FromResult;
            }

            double getToResult() {
                return ToResult;
            }

            void setAsIsResult(double asis) {
                AsIsResult = asis;
            }

            void setFromResult(double from) {
                FromResult = from;
            }

            void setToResult(double to) {
                ToResult = to;
            }
    }

    /*
     * The PSETData class enables storage and population of the data
     * required for the LocalityObjective calculate() method.
     *
     * The lgroupdata HashMap stores LGroupData objects
     * for each LGroup in the pset.
     * The results HashMap stores resultsTuple objects for each LGroup.
     * The countLgroups() method populates the lgroupdata HashMap.
     * The calcQ() method calculates the quotient for any given
     * value of intersection and lgroup size.
     * The calcResults() method populates the results HashMap.
     */
    final class PSETData
    {
            private Resource pset;
            private Map<LocalityGroup, LGroupData> lgroupdata
                 = new HashMap<LocalityGroup, LGroupData>();
            private Map<LocalityGroup, ResultTuple> results
                 = new HashMap<LocalityGroup, ResultTuple>();
            double AsIsTotal = 0;
            int numlg = 0;

            double getAsIsTotal() {
                return AsIsTotal;
            }

            Map<LocalityGroup, ResultTuple> getResults() {
                return results;
            }

            /*
             * Count the number of cpu in each locality group in this pset
             * and count the number of locality groups in this pset.
             *
             * @param allCPUData Map of all cpu and their LocalityGroup.
             *
             * @throws new PoolsException if no lgroups found, i.e numlg = 0;
             */
            private void countLgroups(Map allCPUData)
                    throws PoolsException
            {
                List cpuList = pset.getComponents(null);
                Iterator cpuIt = cpuList.iterator();
                while (cpuIt.hasNext()) {
                    Component currentCPU = (Component) cpuIt.next();
                    int cpuid = (int) currentCPU.getLongProperty("cpu.sys_id");
                    if (allCPUData.containsKey(Integer.valueOf(cpuid))) {
                        LocalityGroup lg =
                            (LocalityGroup) allCPUData.get(
                            Integer.valueOf(cpuid));
                        if (lgroupdata.containsKey(lg)) {
                            LGroupData cpulgp = (LGroupData) lgroupdata.get(lg);
                            cpulgp.incNumcpu();
                        }
                    }
                }
                Set groups = lgroupdata.keySet();
                Iterator groupsIt = groups.iterator();
                while (groupsIt.hasNext()) {
                    LocalityGroup lg = (LocalityGroup) groupsIt.next();
                    LGroupData cpulgp = (LGroupData) lgroupdata.get(lg);
                    if (cpulgp.getNumcpu() > 0) {
                        numlg++;
                    }
                }
                if (numlg == 0) {
                    throw new PoolsException();
                }
            }

            /**
             * Calculate the final quotient with the given
             * factor and intersection values.
             *
             * @param factor double value of factor for this move.
             * @param intersection int value of intersection for this move.
             */
	    private double calcQ(double factor, int intersection)
            {
                double q = factor * ((intersection * intersection)
                        + intersection) / 2.0;
                return (q);
            }

            /*
             * Calulate results for all locality groups for this pset.
             *
             * The logic considers all cases of pset populations;
             * i) pset is empty; ii) pset has only one cpu;
             * iii) pset more than one  cpu.
             * numlg is never zero so we need not try and catch that here.
             */
            private void calcqA()
                    throws PoolsException
            {
                Set allgroups = (Set) results.keySet();
                Iterator groupIt = (Iterator) allgroups.iterator();
                while (groupIt.hasNext()) {
                    LocalityGroup lgroup = (LocalityGroup) groupIt.next();
                    if (lgroupdata.containsKey(lgroup)) {
                        LGroupData cpulgp =
                                (LGroupData) lgroupdata.get(lgroup);
                        ResultTuple rst = (ResultTuple) results.get(lgroup);
                        if (cpulgp.getNumcpu() == 0) {
                            double toresult =
                                    (AsIsTotal + rst.getToResult())/(numlg + 1);
                            rst.setToResult(toresult);
                        }
                        if (cpulgp.getNumcpu() == 1) {
                            double fromresult =
                                    (AsIsTotal + rst.getFromResult())
                                    /(numlg - 1);
                            rst.setFromResult(fromresult);
                        }
                        if (cpulgp.getNumcpu() > 1) {
                            double toresult = (AsIsTotal
                                    - rst.getAsIsResult()
                                    + rst.getToResult())/(numlg);
                            rst.setToResult(toresult);
                            double fromresult = (AsIsTotal
                                    - rst.getAsIsResult()
                                    + rst.getFromResult())/(numlg);
                            rst.setFromResult(fromresult);
                        }
                        results.put(lgroup, rst);
                    }
                }
            }

            /*
             * Populates the results map for each locality group.
             *
             * numlg is never zero so do not need to try and catch it.
             *
             * @param allLGroups Set of all Locality groups in this config.
             */
            private void calcResults(Set allLGroups)
                    throws PoolsException
            {
                Iterator groupIt = (Iterator) allLGroups.iterator();
                while (groupIt.hasNext()) {
                    int intersection = 0;
                    double factor = 0;
                    LocalityGroup lgroup = (LocalityGroup) groupIt.next();
                    if (lgroup.getCPUIDs().length != 0) {
                        if (lgroupdata.containsKey(lgroup)) {
                            LGroupData cpulgp =
                                    (LGroupData)lgroupdata.get(lgroup);
                            intersection = cpulgp.getNumcpu();
                            factor = cpulgp.getFactor();
                        }
                        ResultTuple thisresult = new ResultTuple(
                            calcQ(factor, intersection),
                            calcQ(factor, intersection-1),
                            calcQ(factor, intersection+1));
                        AsIsTotal += thisresult.getAsIsResult();
                        results.put(lgroup, thisresult);
                    }
                }
                calcqA();
                AsIsTotal /= numlg;
            }

            /*
             * Constructor for PSETData.
             *
             * @param allLGroups Set of all Locality groups in this config.
             * @param allCPUData Map of all cpu and their locality group.
             * @param p Resource (pset) for which the calculations are made.
             *
             * @throws PoolsException if accessing the supplied resource
             * fails.
             */
            PSETData(Set allLGroups, Map allCPUData, Resource p)
                    throws PoolsException
            {
                pset = p;
                Iterator groupIt = (Iterator) allLGroups.iterator();
                while (groupIt.hasNext()) {
                    LocalityGroup lgroup = (LocalityGroup) groupIt.next();
                    if (lgroup.getCPUIDs().length != 0) {
                        LGroupData cpulgp = new LGroupData(lgroup);
                        lgroupdata.put(lgroup, cpulgp);
                    }
                }
                countLgroups(allCPUData);
                calcResults(allLGroups);
            }
        }

/**
 * A locality based objective which will assess moves in terms of
 * their impact on the locality of the sets of resources which are
 * impacted.
 *
 * The objective will assess moves with respect to the type of
 * locality specified in the objective:
 *
 * <ul>
 * <li><p>
 * tight - resource locality is sought
 * <li><p>
 * loose - resource locality is avoided
 * <li><p>
 * none - resource locality has no impact
 * </ul>
 */
final class LocalityObjective extends AbstractObjective
{
	/*
	 * The name of the class.
	 */
	static final String name = "locality";

	/*
	 * The locality domain used to describe locality for this
	 * objective.
	 */
	private LocalityDomain ldom;

        /*
         * The set of LocalityGroups in this ldom.
         */
        private Set allLGroups;

        /*
         * Map of all cpu id and their locality groups
         */
        private Map<Integer, LocalityGroup> allCPUData
                = new HashMap<Integer, LocalityGroup>();

        /*
         * Method to populate the allCPUData cpu locality map.
         */
        private void getCPUData()
	{
            allLGroups = ldom.getGroups();
            Iterator LGroupIt = allLGroups.iterator();
            while (LGroupIt.hasNext()) {
                LocalityGroup lg = (LocalityGroup) LGroupIt.next();
                int cpu_ids[] = lg.getCPUIDs();
                for (int i = 0; i < cpu_ids.length; i++) {
                    allCPUData.put(Integer.valueOf(cpu_ids[i]), lg);
                }
            }

	}

        /*
         * Map to store all PSET LocalityGroup quotient results.
         */
        private Map<Resource, PSETData> allPSETData
                = new HashMap<Resource, PSETData>();

	/**
	 * Prepare the calculation for this objective for the resource to
	 * which it applies.
	 *
	 * @param ldom LocalityDomain containing these resources.
	 * @param res Resource to which this objective is applied.
	 *
	 * @throws PoolsException if accessing the supplied resource
	 * fails.
	 */
	public void prepare(LocalityDomain ldom, Resource res)
	    throws PoolsException
	{
		this.ldom = ldom;
	}

	/*
	 * Calculates the value of a configuration in terms of this
	 * objective.
	 *
	 * Firstly check to see if it is possible to short-cut the
	 * calculation. If not, then start to examine the disposition
	 * of CPUs and locality groups in relation to the processor
	 * set being evaluated. The objective scores moves in terms of
	 * their impact upon the quotient of cpus contained in each
	 * locality group.
	 *
	 * Moves which involve a cpu in the same locality group are equivalent.
	 * i.e for a given pset, the quotient calculation is the same
	 * for a move involving cpu x in localitygroup Z,
	 * as the calculation for cpu y in localitygroup Z,
	 * So we store the quotient calculation of the PSET
	 * i) as it is; ii) a cpu is added; iii) a cpu is removed;
	 *
	 * For each move we encounter, we store the quotient caclulations
	 * on a pset basis, holding a map of results for each pset we evaluate.
	 * The map contains results for each locality group in the system.
	 * The results contains the quotient value for a move of a cpu
	 * to, from and without any move.
	 *
	 * For a given configuration, for each cpu we make one JNI call
	 * to getLongProperty() (which is the most expensive call in this code)
	 * so the time spent in calculate() scales linearly with number of cpu.
	 *
	 * @param conf Configuration to be scored.
	 * @param move Move to be scored.
	 * @param elem The element to which the objective applies
	 * @throws Exception If an there is an error in execution.
	 */
	public double calculate(Configuration conf, Move move, Element elem)
	    throws PoolsException
	{
		KVExpression kve = (KVExpression) getExpression();
		double ret = 0;
		double qA = 0;
		double qB = 0;
		Resource pset = (Resource) elem;
		ComponentMove cm = (ComponentMove) move;
		Poold.MON_LOG.log(Severity.DEBUG,
		    "Calculating objective type: " + name + " for: " + elem);

		/*
		 * If we are set to "none" then we don't care which
		 * configuration so just return 0.
		 */
		if (kve.getValue().compareTo("none") == 0)
			return (ret);
		/*
		 * If the maximum latency is 0, we don't care about
		 * latency.
		 */
		if (ldom.getMaxLatency() == 0)
			return (ret);
		/*
		 * If this element doesn't participate in the move, we
		 * should return 0.
		 */
		if (elem.equals(move.getFrom()) == false &&
		    elem.equals(move.getTo()) == false)
			return (ret);

                /*
                 * Populate the map of cpu - locality data if it is empty.
                 */
                if (allCPUData.isEmpty()) {
                    getCPUData();
                }

                /*
                 * Lookup in the pset results map if the pset entry exists.
                 * If this pset entry exists then use it otherwise add it.
                 */
                PSETData psetlg;

                if (allPSETData.containsKey(pset))
                    psetlg = (PSETData) allPSETData.get(pset);
                else {
                    psetlg = new PSETData(allLGroups, allCPUData, pset);
                    allPSETData.put(pset, psetlg);
                }

                /*
                 * Check the locality group of the cpu involved in this move.
                 * If it is a cpu from a locality group we have already seen,
                 * then we can retrieve the results from the pset results map.
                 */
                List cpulist = (List) cm.getComponents();
                Component cpu = (Component) cpulist.get(0);
		int cpuid = (int) cpu.getLongProperty("cpu.sys_id");
                LocalityGroup lgroup =
                        (LocalityGroup) allCPUData.get(Integer.valueOf(cpuid));
                HashMap allresults = (HashMap) psetlg.getResults();
                ResultTuple result = (ResultTuple) allresults.get(lgroup);

                qB = psetlg.getAsIsTotal();
                if (elem.equals(move.getFrom()))
                    qA = result.getFromResult();
                else
                    qA = result.getToResult();

		ret = qA - qB;

                /*
                 * We return the value based on what locality objective
                 * we want to achieve - tight or loose. The calculations
                 * are based on tightness, so the value is reversed if the
                 * objective specified "loose" locality.
                 */
		if (kve.getValue().compareTo("loose") == 0)
                    ret = 0 - ret;
                Poold.MON_LOG.log(Severity.DEBUG, "ret: " + ret);
		return (ret);
	}
}
/**
 * A resource set utilization based objective which will assess moves
 * in terms of their (likely) impact on the future performance of a
 * resource set with respect to it's specified utilization objective.
 *
 * The utilization objective must be specified in terms of a
 * KVOpExpression, see the class definition for information about the
 * form of these expressions. The objective can be examined in terms
 * of it's compliance with the aid of a monitoring object. The actual
 * assessment of compliance is indicated by the associated monitoring
 * object, with this class simply acting as a co-ordinator of the
 * relevant information.
 */
final class UtilizationObjective extends AbstractObjective
    implements WorkloadDependentObjective
{
	/**
	 * The name of the class.
	 */
	static final String name = "utilization";

	/**
	 * Short run detection.
	 */
	private List zoneList = new LinkedList();

	/**
	 * Format for printing utilization.
	 */
	private static final DecimalFormat uf = new DecimalFormat("0.00");

	/**
	 * Solver used to calculate delta, i.e. gap, between target and
	 * actual utilization values.
	 */
	private Solver gapSolver;

	/**
	 * Determine whether an objective is satisfied. If the
	 * objective is still satisfied, return false; otherwise
	 * return true.
	 *
	 * The assessment of control is made by the monitoring class
	 * using the supplied Expression and resource.
	 *
	 * @param conf The configuration to be examined
	 * @param solver The solving interface used to get utilization
	 * information
	 * @param elem The element to which the objective belongs
	 *
	 * @throws PoolsException if there is an error examining the
	 * pool configuration
	 * @throws StaleMonitorException if there is an error accessing
	 * the element's ResourceMonitor
	 */
	public boolean examine(Configuration conf, Solver solver,
	    Element elem) throws PoolsException, StaleMonitorException
	{
		KVOpExpression kve = (KVOpExpression) getExpression();
		ResourceMonitor mon;

		/*
		 * If there is no resource monitor, then we cannot
		 * make an assessment of the objective's achievability.
		 * Log a message to make clear that this objective is
		 * not being assessed and then indicate that
		 * the objective has been achieved.
		 */
		try {
			mon = solver.getMonitor().get((Resource)elem);
		} catch (StaleMonitorException sme) {
			Poold.MON_LOG.log(Severity.INFO,
			    elem.toString() +
			    " utilization objective not measured " +
			    toString() + " as there are no available " +
			    "statistics.");
			return (false);
		}
		gapSolver = solver;

		double val = solver.getMonitor().getUtilization((Resource)elem);

		StatisticList sl = (StatisticList) mon.get("utilization");
		int zone = sl.getZone(kve, val);

		if (zoneList.size() == 9) {
			zoneList.remove(0);
		}
		zoneList.add(Integer.valueOf(sl.getZoneMean(val)));

		/*
		 * Evaluate whether or not this objective is under
		 * control.
		 */
		if ((zone & StatisticOperations.ZONEZ) ==
		    StatisticOperations.ZONEZ) {
			/*
			 * If the objective is GT or LT, then don't
			 * return true as long as the objective is
			 * satisfied.
			 */
			if (kve.getOp() == KVOpExpression.LT &&
			    (zone & StatisticOperations.ZONET) ==
			    StatisticOperations.ZONELT)
				return (false);

			if (kve.getOp() == KVOpExpression.GT &&
			    (zone & StatisticOperations.ZONET) ==
			    StatisticOperations.ZONEGT)
				return (false);
			Poold.MON_LOG.log(Severity.INFO,
			    elem.toString() +
			    " utilization objective not satisfied " +
			    toString() + " with utilization " + uf.format(val) +
			    " (control zone bounds exceeded)");
			return (true);
		}
		/*
		 * Check if our statistics need to be recalculated.
		 */
		checkShort(mon, elem, val);
		return (false);
	}

	/**
	 * Calculates the value of a configuration in terms of this
	 * objective.
	 *
	 * Every set must be classified with a control zone when this
	 * function is called. The move can be assessed in terms of
	 * the control violation type. zone violations which are minor
	 * are offered a lower contribution than more significant
	 * violations.
	 *
	 * @param conf Configuration to be scored.
	 * @param move Move to be scored.
	 * @param elem The element to which the objective applies
	 * @throws Exception If an there is an error in execution.
	 */
	public double calculate(Configuration conf, Move move, Element elem)
	    throws PoolsException
	{
		KVOpExpression kve = (KVOpExpression) getExpression();
		double ret;

		/*
		 * If the move is from the examined element, then
		 * check to see if the recipient has any
		 * objectives. If not, score the move poorly since we
		 * should never want to transfer resources to a
		 * recipient with no objectives. If there are
		 * objectives, then return the delta between target
		 * performance and actual performance for this
		 * element.
		 *
		 * If the move is to the examined element, then check
		 * to see if the donor has any objectives. If not,
		 * score the move highly, since we want to favour
		 * those resources with objectives. If there are
		 * objectives, return the delta between actual and
		 * target performance.
		 *
		 * If the element is neither the recipient or the
		 * donor of this proposed move, then score the move
		 * neutrally as 0.
		 */
		try {
			double val, gap;
			StatisticList sl;

			if (elem.equals(move.getFrom())) {
				val = gapSolver.getMonitor().
				    getUtilization(move.getFrom());
				sl = (StatisticList) gapSolver.getMonitor().
				    get(move.getFrom()).get("utilization");
				gap = sl.getGap(kve, val) / 100;

				if (gapSolver.getObjectives(move.getTo()) ==
				    null) {
					/*
					 * Moving to a resource with
					 * no objectives should always
					 * be viewed unfavourably. The
					 * degree of favourability is
					 * thus bound between 0 and
					 * -1. If the source gap is
					 * negative, then subtract it
					 * from -1 to get the
					 * score. If positive,
					 * just return -1.
					 */
					    if (gap < 0) {
						    ret = -1 - gap;
					    } else {
						    ret = -1;
					    }
				} else {
					ret = 0 - gap;
				}
			} else if (elem.equals(move.getTo())) {
				val = gapSolver.getMonitor().
				    getUtilization(move.getTo());
				sl = (StatisticList) gapSolver.getMonitor().
				    get(move.getTo()).get("utilization");
				gap = sl.getGap(kve, val) / 100;

				if (gapSolver.getObjectives(move.getFrom()) ==
				    null) {
					/*
					 * Moving from a resource with
					 * no objectives should always
					 * be viewed favourably. The
					 * degree of favourability is
					 * thus bound between 0 and
					 * 1. If the destination gap
					 * is negative, then add to 1
					 * to get the score. If
					 * positive, just return 1.
					 */
					if (gap < 0) {
						ret = 0 - gap;
					} else {
						ret = 1;
					}
				} else {
					ret = 0 + gap;
				}
			} else {
				ret = 0;
			}
		} catch (StaleMonitorException sme) {
			/*
			 * We should always find a monitor,
			 * but if we can't then just assume
			 * this is a neutral move and return
			 * 0.
			 */
			ret = 0;
		}
		Poold.MON_LOG.log(Severity.DEBUG, "ret: " + ret);
		return (ret);
	}

	/**
	 * Check whether or not a set's statistics are still useful
	 * for making decision..
	 *
	 * Each set is controlled in terms of the zones of control
	 * based in terms of standard deviations from a mean. If the
	 * utilization of the set is not fluctuating normally around a
	 * mean, these checks will cause the accumulated statistics to
	 * be discarded and control suspended until a new sufficient
	 * set of data is accumulated.
	 *
	 * @param mon Resource monitor to examine.
	 * @param elem Element to which the resource monitor belongs.
	 * @param val Latest monitored value.
	 */
	private void checkShort(ResourceMonitor mon, Element elem, double val)
	{
		boolean checkOne = true;
		int checkOnePos = 0;
		boolean doCheckOne = false;

		Iterator itZones = zoneList.iterator();
		while (itZones.hasNext()) {
			int zone = ((Integer) itZones.next()).intValue();
			if (doCheckOne) {
				if (checkOne) {
					if ((zone & StatisticOperations.ZONET)
					    != checkOnePos) {
						checkOne = false;
					}
				}
			} else {
				if (zoneList.size() >= 9) {
					checkOnePos = zone &
					    StatisticOperations.ZONET;
					doCheckOne = true;
				}
			}
		}
		if (zoneList.size() >= 9 && checkOne) {
			Poold.MON_LOG.log(Severity.INFO,
			    elem.toString() +
			    " utilization objective statistics reinitialized " +
			    toString() + " with utilization " + uf.format(val) +
			    " (nine points on same side of mean)");
			mon.resetData("utilization");
			zoneList.clear();
		}
	}
}
/*
 * 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.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.io.*;
import java.util.*;
import java.util.logging.*;
import java.text.DecimalFormat;
import java.util.concurrent.atomic.*;

import com.sun.solaris.service.locality.*;
import com.sun.solaris.service.logging.*;
import com.sun.solaris.service.pools.*;
import com.sun.solaris.service.exception.*;

/*
 * poold overview
 * ----- --------
 *
 * poold manipulates system resources in accordance with administrator
 * specified constraints and objectives. The "goal" of the application
 * is to maximise the efficiency of available resources within these
 * parameters.
 *
 * Constraints are specified as follows:
 *
 * On a resource set:
 *
 *	- min Is the minimum amount of resource a set should
 *	receive. poold will never elect to move resource so that a set
 *	falls below its minimum value. It is possible for a set to
 *	fall below its minimum as a consequence of administrative
 *	intervention, in which case poold will endeavour to bring a
 *	set back to its minimum level at the earliest opportunity.
 *
 *	- max Is the maximum amount of resource a set should
 *	recieve. poold will never elect to move resource so that a set
 *	rises above its maximum value. It is possible for a set to
 *	rise above its maximum as a consequence of administrative
 *	intervention, in which case poold will endeavour to bring a
 *	set back to its maximum level at the earliest opportunity.
 *
 * On a resource component:
 *
 *	- cpu.pinned Is an indication that a CPU should be ignored by
 *	poold for purposes of reallocation. A pinned CPU will never be
 *	moved by poold from one set to another.
 *
 * In addition to constraints, an administrator may also specify
 * objectives. Currently three types of objectives are supported:
 *
 *	- system.wt-load Is an objective set across an entire
 *	configuration. It attempts to ensure that resource is shared
 *	in accordance with current consumption. Those partitions which
 *	are most heavily utilized are give more resource in an attempt
 *	to lower their utilization levels.
 *
 *	- set.locality Is a locality objective which attempts to
 *	minimize or maximize resource locality for a set.
 *
 *	- set.utilization Is a utilization based objective which an
 *	administrator may use to explicitly dictate the utilization
 *	levels which should be achieved for a set.
 *
 * When executing, poold uses information about the current pools
 * configuration; monitored resource utilization and specified
 * constraints and objectives to determine if a move of resources is
 * likely to lead to an increase in objective satisfaction.
 *
 * Candidate moves are generated by observing resource constraints.
 * These moves are evaluated and scored in terms of their contribution
 * to objective satisfaction (note: objectives are weighted according
 * to their importance) and ranked accordingly. If a move can be
 * identified that delivers an improvement, the move is made. Data is
 * collected about past moves and recorded as "Decision History",
 * before the move is made this data is consulted and if the move is
 * expected not to yield an improvement, it may be cancelled. This
 * refinement is designed to improve the quality of decision making by
 * reflecting upon the past performance of decisions as well as the
 * contribution to objective satisfaction.
 *
 * poold structure
 * ----- ---------
 *
 * The common package name begins with:
 *
 * com.sun.solaris
 *
 * The software is divided into two main functional areas:
 *
 *	service
 *
 *	These packages collaborate to provide services to poold
 *	(typically, they use JNI to access exising
 *	functionality). They are not designed to be extended. For more
 *	details on these classes examine the source files in each
 *	directory.
 *
 *	exception	Stack trace formatter
 *	kstat		Interface to Solaris kstat facility
 *	locality	Interface to Solaris lgrp facility
 *	logging		Interface to Solaris syslog facility
 *	pools		Interface to Solaris libpool facility
 *	timer		High resolution timestamps
 *
 *	domain:
 *
 *	These package reflect problem domain concepts and are
 *	responsible for application logic related to these
 *	concepts.
 *
 *	pools		Dynamic Resource Pools specific functionality.
 *
 * This code block will continue to explain in more detail how poold
 * is organized.
 *
 * poold provides the following basic facilities:
 *
 * Monitoring:
 *
 * Basic statistic access is provided by the
 * com.sun.solaris.service.kstat package. The following interfaces and
 * classes collaborate to provide higher level statistic and
 * monitoring facilities to the application:
 *
 *	INTERFACES
 *
 *	AggregateStatistic
 *	Monitor
 *	Statistic
 *	StatisticListener
 *
 *	CLASSES
 *
 *	AbstractStatistic
 *	DoubleStatistic
 *	LongStatistic
 *	ResourceMonitor
 *	StatisticEvent
 *	StatisticList
 *	StatisticOperations
 *	SystemMonitor
 *	UnsignedInt64Statistic
 *
 * Logging:
 *
 * Logging services are provided by the com.sun.solaris.logging
 * package. In addition, the following class implements Poold's
 * specific logging requirements.
 *
 *	CLASSES
 *
 *	Poold
 *
 * Optimization:
 *
 * lgrp service are provided by the com.sun.solaris.service.lgrp
 * package. pools services are provided by the
 * com.sun.solaris.service.pools package. In addition, optimization is
 * implemented in the following Interfaces and Classes:
 *
 *	INTERFACES
 *
 *	Objective
 *	Solver
 *	WorkloadDependentObjective
 *
 *	CLASSES
 *
 *	AbstractObjective
 *	ComponentMove
 *	DecisionHistory
 *	Expression
 *	KExpression
 *	KVEpression
 *	KVOpExpression
 *	LocalityObjective
 *	Move
 *	Poold
 *	QuantityMove
 *	SystemSolver
 *	UtilizationObjective
 *	WeightedLoadObjective
 *
 * Configuration:
 *
 * pools services are provided by the com.sun.solaris.service.pools
 * package, this is used to read poold configuration details from a
 * libpool configuration. In addition, configuration is implemented in
 * the following Classes:
 *
 *	CLASSES
 *
 *	AbstractObjective
 *	Expression
 *	Poold
 *	SystemSolver
 *
 * (NB: Some classes were mentioned in multiple categories where there
 * responsbilities overlap. Inner classes are not listed as their
 * responsibilities can be clearly inferred from their context.)
 *
 * For more details on any of the packages, classes or interfaces
 * mentioned above, look at the documentation associated with each
 * class.
 */

/**
 * The <code>Poold</code> class implements a dynamic resource
 * allocation system for Solaris.
 *
 * <code>Poold</code> is a monitoring daemon, designed to evaluate
 * user specified objectives, monitor workload behaviour and
 * dynamically assign resources in order to satisfy the evaluated
 * objectives. For more details see:
 *
 * <a href="http://sac.eng.sun.com/PSARC/2002/287/">PSARC/2002/287</a>
 */
final class Poold
{
	/**
	 * The configuration which is manipulated.
	 */
	private Configuration conf;

	/**
	 * The monitoring interface.
	 */
	private Monitor monitor;

	/**
	 * The interface to higher level resource managers.
	 */
	private DRM drm;

	/**
	 * The interface to the configuration solver.
	 */
	private Solver solver;

	/**
	 * Default path to the logging properties file.
	 */
	public static final String POOLD_PROPERTIES_PATH =
	    "/usr/lib/pool/poold.properties";

	/**
	 * Logger for records which aren't produced in the Monitoring,
	 * Configuration, or Optimization states.  This logger is the
	 * parent to the loggers used in those states.
	 */
	public static final Logger BASE_LOG = Logger.getLogger(
	    "com.sun.solaris.domain.pools.poold");

	/**
	 * Logger for records produced in the Configuration state.
	 */
	public static final Logger CONF_LOG = Logger.getLogger(
	    "com.sun.solaris.domain.pools.poold.Configuration");

	/**
	 * Logger for records produced in the Monitoring state.
	 */
	public static final Logger MON_LOG = Logger.getLogger(
	    "com.sun.solaris.domain.pools.poold.Monitoring");

	/**
	 * Logger for records produced in the Optimization state.
	 */
	public static final Logger OPT_LOG = Logger.getLogger(
	    "com.sun.solaris.domain.pools.poold.Optimization");

	/**
	 * Singleton instance of Poold.
	 */
	private static Poold instance;

	/**
	 * The main sampling and solving thread.
	 */
	private Thread mainThread;

	/**
	 * Process exit code indicating a failure.
	 */
	private static final int E_PO_FAILURE = 2;

	/**
	 * Keep track of whether initialize() has been invoked, to
	 * output the "starting" message on the first.
	 */
	private AtomicBoolean firstInitialization = new AtomicBoolean(true);

	/**
	 * Flags whether poold should run or exit.
	 */
	private AtomicBoolean shouldRun = new AtomicBoolean(true);

	private static class logHelper {
		/**
		 * Default logfile location
		 */
		public static final String DEF_LOG_LOC = "/var/log/pool/poold";

		/**
		 * Log location indicating <code>syslog</code>, as
		 * opposed to a file, should be used.
		 */
		public static final String SYSLOG_LOG_LOC = "SYSLOG";

		/**
		 * Default Log severity (if not overridden)
		 */
		public static final Severity DEF_SEVERITY = Severity.INFO;

		/**
		 * Name of configuration property, log location.
		 */
		public static final String PROPERTY_NAME_LOG_LOC =
		    "system.poold.log-location";

		/**
		 * Name of configuration property, log level.
		 */
		public static final String PROPERTY_NAME_LOG_LEVEL =
		    "system.poold.log-level";

		/**
		 * Location of logfile -- an absolute filename, or
		 * "SYSLOG".
		 */
		private static String location;

		/**
		 * Logfile handler, responsible for taking log messages
		 * and exporting them.
		 */
		private static Handler handler;

		/**
		 * Logfile severity, log messages below this severity are
		 * ignored.
		 */
		private static Severity severity;

		/**
		 * Flag recording whether preinitialization has occurred.
		 */
		private static boolean preinitialized = false;

		/**
		 * Flag recording whether the logging Severity has been
		 * overridden with the -l command-line option, which
		 * means the console is the only thing being logged to,
		 * and the configuration's logging properties are
		 * ignored.
		 */
		private static boolean usingConsole;

		/**
		 * Indicates whether logging semantics should be changed
		 * to facilitate debugging.
		 */
		private static final boolean loggingDebugging = false;

		/**
		 * Do the pre-initialization initialization:  install
		 * loggers for reporting errors during initialization.
		 *
		 * @param consoleSeverity If non-null, indicates that
		 * the configuration property-controlled logging behavior
		 * is to be overridden (the <code>-l</code> option was
		 * specified), and messages are to be logged only to the
		 * console, with (at most) the given maximum severity.
		 */
		private static void preinitialize(Severity consoleSeverity) {
			if (preinitialized)
				return;

			/*
			 * Read logging properties affecting the
			 * FileHandler and ConsoleHandler from
			 * <code>poold.properties</code>.
			 */
			Properties props = new Properties();
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			try {
				props.load(
				    new FileInputStream(POOLD_PROPERTIES_PATH));
				props.store(bos, "");
				LogManager.getLogManager().readConfiguration(
				    new ByteArrayInputStream(
				    bos.toByteArray()));
			} catch (IOException ioe) {
				Poold.MON_LOG.log(Severity.WARNING, "could not "
				    + "read logging properties from "
				    + "poold.properties: " + ioe);
			}

			if (consoleSeverity == null || loggingDebugging) {
				/*
				 * Log messages to /var/log/pool/poold,
				 * the default location, until the pools
				 * configuration properties are read and
				 * applied, which may change the logging
				 * file and severity.
				 *
				 * Under normal circumstances, it's
				 * expected that NO INFO-level messages
				 * will be emitted until that time; this
				 * is only a measure to ensure that
				 * unanticipated errors are reported in
				 * some log.
				 */
				location = SYSLOG_LOG_LOC;
				handler = SyslogHandler.getInstance("poold",
				    Facility.DAEMON);
				severity = DEF_SEVERITY;
				handler.setLevel(severity);
				BASE_LOG.addHandler(handler);
			}

			if (consoleSeverity != null) {
				/*
				 * If -l is specified, log to the
				 * console.  Unless loggingDebug is
				 * true, this will also mean that the
				 * logging properties are ignored.
				 *
				 * Determine if the user has specified
				 * the use of a ConsoleHandler through
				 * poold.properties.
				 */
				Logger root = Logger.getLogger("");
				Handler[] handler = root.getHandlers();
				ConsoleHandler ch = null;
				for (int i = 0; i < handler.length && ch ==
				    null; i++)
					if (handler[i]
					    instanceof ConsoleHandler)
						ch = (ConsoleHandler)handler[i];
				/*
				 * If none was previously, install a
				 * ConsoleHandler.
				 */
				if (ch == null) {
					ch = new ConsoleHandler();

					ch.setFormatter(
					    new SysloglikeFormatter());
					ch.setLevel(consoleSeverity);
					root.addHandler(ch);
				}
				severity = consoleSeverity;
				BASE_LOG.log(Severity.DEBUG,
				    "logging with level " + severity);

				/**
				 * Allow logging properties to be
				 * effective if loggingDebugging is not
				 * set.
				 */
				if (!loggingDebugging)
					usingConsole = true;
			}
			preinitialized = true;
		}

		/**
		 * Configure loggers based on the logging-related
		 * configuration properties.  Outputs a description of
		 * any changes to the configuration logger.
		 *
		 * @throws ConfigurationException if there is an error
		 * applying libpool configuration properties to
		 * <code>poold</code>
		 */
		public static void initializeWithConfiguration(
		    Configuration conf) throws ConfigurationException
		{
			String newLogLocation;
			Severity newLogSeverity;
			String newLogSeverityName = null;

			/*
			 * Set the log location as specified by the
			 * configuration's system properties.
			 */
			try {
				newLogLocation = conf.getStringProperty(
				    PROPERTY_NAME_LOG_LOC);
			} catch (PoolsException e) {
				newLogLocation = DEF_LOG_LOC;
			}

			try {
				newLogSeverityName = conf.getStringProperty(
				    PROPERTY_NAME_LOG_LEVEL);
				newLogSeverity = Severity.getSeverityWithName(
				    newLogSeverityName);
				assert(newLogSeverity != null);
			} catch (PoolsException e) {
				newLogSeverity = DEF_SEVERITY;
			} catch (IllegalArgumentException e) {
				throw(ConfigurationException)
				    (new ConfigurationException(
				    "invalid " + PROPERTY_NAME_LOG_LEVEL +
				    "value: " + newLogSeverityName)
				    .initCause(e));
			}

			Handler newLogHandler = null;

			/*
			 * (Re)install the logger for the poold class
			 * hierarchy.  This means that only poold
			 * messages are controlled by the pools
			 * configuration properties/command-line
			 * options.
			 */

			/*
			 * The logfile is always re-opened, in case the
			 * cause for reinitialization is due to SIGHUP
			 * following a log rotation.
			 */
			if (handler != null) {
				BASE_LOG.removeHandler(handler);
				handler.close();
				handler = null;
			}

			if (newLogLocation.toUpperCase().equals(
			    SYSLOG_LOG_LOC.toUpperCase()))
				newLogHandler =
				    SyslogHandler.getInstance("poold",
				    Facility.DAEMON);
			else {
				if (!newLogLocation.startsWith("/"))
					throw
					    new ConfigurationException(
						PROPERTY_NAME_LOG_LOC +
						" value is not an" +
						" absolute path");
				try {
					newLogHandler =
					    new FileHandler(
					    newLogLocation, 0, 1, true);
					newLogHandler.setFormatter(
					    new SysloglikeFormatter());
				} catch (java.io.IOException ioe) {
					Poold.utility.die(
					    Poold.CONF_LOG,
					    new PooldException(
					    newLogLocation +
					    ": can't write")
					    .initCause(ioe), false);
				}
			}

			if (!severity.equals(newLogSeverity) ||
			    !location.equals(newLogLocation))
				CONF_LOG.log(Severity.DEBUG,
				    "logging with level " + severity);

			severity = newLogSeverity;
			handler = newLogHandler;
			location = newLogLocation;

			handler.setLevel(severity);
			BASE_LOG.addHandler(handler);
		}

		/**
		 * Configure the loggers based on the pool's logging
		 * properties, or, if the -l option was specified on the
		 * command line, continue to use the console.
		 */
		public static void initialize(Configuration conf)
		    throws ConfigurationException
		{
			if (usingConsole)
				return;
			else
				initializeWithConfiguration(conf);
		}

		/**
		 * Return the current logging level.
		 */
		public static Severity getSeverity()
		{
			return (severity);
		}

		public static void close()
		{
			if (handler != null) {
				BASE_LOG.removeHandler(handler);
				handler.close();
			}
		}
	}

	/**
	 * Constructor
	 *
	 * Only one poold instance should be running per system.
	 *
	 * @param consoleSeverity If non-null, indicates that the
	 * configuration property-controlled logging behavior is to be
	 * overridden (the <code>-l</code> option was specified), and
	 * messages are to be logged only to the console, with (at most)
	 * the given maximum severity.
	 */
	private Poold(Severity consoleSeverity)
	{
		/*
		 * Establish loggers for recording errors during
		 * initialization.  Under normal circumstances, no
		 * messages will be emitted; this is only a measure to
		 * make sure that unanticipated errors are reported in
		 * some log, or the console, if the -l option is used.
		 */
		logHelper.preinitialize(consoleSeverity);

		/*
		 * Try opening the configuration read-write in hopes the
		 * ability will be possessed henceforth.
		 */
		try {
			conf = new Configuration(PoolInternal.
			    pool_dynamic_location(), PoolInternal.PO_RDWR);
			conf.close();
		} catch (PoolsException pe) {
			Poold.utility.die(CONF_LOG, new PooldException(
			    "cannot open dynamic pools configuration " +
			     "read-write (" + pe.getMessage() + ")")
			     .initCause(pe), false);
		}

		try {
			conf = new Configuration(PoolInternal.
			    pool_dynamic_location(), PoolInternal.PO_RDONLY);
		} catch (PoolsException pe) {
			Poold.utility.die(CONF_LOG, pe);
		}

		/*
		 * Create the required sub-components:
		 * - a monitoring object
		 * - a DRM implementer
		 * - a solver
		 */
		monitor = new SystemMonitor();
		drm = new LogDRM();
		solver = new SystemSolver(monitor);
	}

	/**
	 * Returns a reference to the singleton <code>Poold</code>,
	 * constructing one if necessary.
	 *
	 * @param consoleSeverity If non-null, indicates that the
	 * configuration property-controlled logging behavior is to be
	 * overridden (the <code>-l</code> option was specified), and
	 * messages are to be logged only to the console, with (at most)
	 * the given maximum severity.
	 * @throws IllegalArgumentException if the given console
	 * severity doesn't match that of an existing instance.
	 */
	public static Poold getInstanceWithConsoleLogging(
	    Severity consoleSeverity)
	{
		if (instance == null)
			return (instance = new Poold(consoleSeverity));
		else
			if (logHelper.usingConsole == false &&
			    consoleSeverity == null || consoleSeverity !=
			    null && logHelper.getSeverity().equals(
			    consoleSeverity))
				return (instance);
			else
				throw new IllegalArgumentException();
	}

	/**
	 * Initializes <code>Poold</code> for operation at startup or
	 * in response to a detected libpool configuration change.
	 */
	private void initialize()
	{
		try {
			logHelper.initialize(conf);
			if (firstInitialization.get())
				CONF_LOG.log(Severity.INFO, "starting");
			/*
			 * When a system is extremely busy, it may
			 * prove difficult to initialize poold. Just
			 * keep trying until we succeed.
			 */
			boolean busy = true;
			while (busy && shouldRun.get()) {
				busy = false;
				try {
					monitor.initialize(conf);
					CONF_LOG.log(Severity.DEBUG,
					    "configuring solver...");
					solver.initialize(conf);
					CONF_LOG.log(Severity.INFO,
					    "configuration complete");
				} catch (PoolsException pe) {
					CONF_LOG.log(Severity.INFO,
					    "The system is too busy to " +
					    "initialize, attempting " +
					    "initialization again");
					/*
					 * pause for a while before
					 * re-attempting the
					 * initialization.
					 */
					try {
						Thread.sleep(50);
					} catch (InterruptedException ie) {
						/*
						 * Safe to ignore this
						 * exception as we
						 * will simply try
						 * again sooner.
						 */
					}
					busy = true;
				} catch (StaleMonitorException sme) {
					CONF_LOG.log(Severity.INFO,
					    "The system is too busy to " +
					    "initialize, attempting " +
					    "initialization again");
					/*
					 * pause for a while before
					 * re-attempting the
					 * initialization.
					 */
					try {
						Thread.sleep(50);
					} catch (InterruptedException ie) {
						/*
						 * Safe to ignore this
						 * exception as we
						 * will simply try
						 * again sooner.
						 */
					}
					busy = true;
				}
			}
			if (firstInitialization.get())
				firstInitialization.set(false);
		} catch (ConfigurationException ce) {
			Poold.utility.die(CONF_LOG, ce);
		}
	}

	/**
	 * Execute <code>Poold</code> indefinitely. This method is
	 * invoked after <code>Poold</code> completes
	 * configuration. It will continue to execute until
	 * <code>Poold</code> is terminated.
	 *
	 * @throws Exception If an there is an error in execution.
	 */
	private void execute() throws Exception
	{
		int changed = 0;
		boolean confRequired = false;

		while (shouldRun.get()) {
			try {
				changed = conf.update();
				assert(!confRequired || confRequired &&
				    changed != 0);
				if (changed != 0) {
					CONF_LOG.log(Severity.DEBUG,
					    "configuration change detected");
					if (!confRequired)
						CONF_LOG.log(Severity.INFO,
						    "configuration changed " +
						    "externally");
					CONF_LOG.log(Severity.INFO,
					    "reconfiguring...");
				}
				confRequired = false;
			} catch (PoolsException pe) {
				Poold.utility.die(CONF_LOG, pe);
			}
			if (changed != 0)
				initialize();

			boolean gotNext = false;
			while (shouldRun.get() && !gotNext) {
				try {
					monitor.getNext();
					gotNext = true;

					/*
					 * All workload-dependent
					 * objectives must now be
					 * checked for violations.  The
					 * solver holds all objectives
					 * and it makes the decision
					 * about whether a
					 * reconfiguration is required.
					 */
					if (solver.examine(monitor)) {
						MON_LOG.log(Severity.INFO,
						    "reconfiguration required");
						confRequired = solver.solve();
					} else {
						MON_LOG.log(Severity.INFO,
						    "all evaluated objectives"
						    + " satisfied");
					}
				} catch (StaleMonitorException e) {
					/*
					 * Later, assert that every
					 * cause of the
					 * StaleMonitorException is
					 * handled by the above
					 * conf.update().
					 */
					confRequired = true;
				} catch (InterruptedException ie) {
					Poold.MON_LOG.log(Severity.INFO,
					    "interrupted");
					break;
				}
			}
			if (!shouldRun.get())
				break;
			System.runFinalization();
		}
		Poold.BASE_LOG.log(Severity.NOTICE, "exiting");
	}

	/**
	 * Cleanup any resources when the application terminates.
	 */
	private void cleanup()
	{
		conf.close();
		logHelper.close();
                instance = null;
	}

	/**
	 * Invoke <code>Poold</code>. This main function is provided
	 * so that <code>poold</code> can be executed.  Execution will
	 * continue indefinitely unless there is an error, in which case
	 * when execute() terminates.
	 */
	public void run()
	{
		mainThread = Thread.currentThread();

		Runtime.getRuntime().addShutdownHook(new Thread() {
			public void run() {
				try {
					cleanup();
				} catch (Throwable t) {
				}
			}
		});

		try {
			initialize();
			execute();
		} catch (Throwable t) {
			Poold.utility.die(BASE_LOG, t);
		}
	}

	/**
	 * Stops <code>Poold</code>.  Sets a flag indicating that run()
	 * should break out of the monitor/solve loop and clean up.
	 */
	public void shutdown() {
		/*
		 * Flag that the main thread should break out of the
		 * sample/solve loop as soon as possible.
		 */
		shouldRun.set(false);

		/*
		 * Interrupt the main thread, which will cause the
		 * monitor to break out of its sleep if it's waiting for
		 * the sample time to arrive, and cause the sample/solve
		 * loop condition to be evaluated sooner.  But make some
		 * effort not to cause an InterruptedIOException if
		 * we're not even through initialization yet; we'll get
		 * around to shutting down soon enough.
		 */
		if (!firstInitialization.get() && mainThread != null)
			mainThread.interrupt();
	}

	public static void main(String args[]) throws IllegalArgumentException
	{
		Severity severity = null;

		if (args.length > 0) {
			if (args[0].compareTo("-l") == 0 && args.length == 2) {
				severity = (Severity) Severity.parse(args[1]);
			} else
				throw new IllegalArgumentException(
				    "usage: poold [-l level]");
		}
		Poold p = getInstanceWithConsoleLogging(severity);
		p.run();
	}

	/**
	 * The <code>utility</code> class provides various
	 * <code>Poold</code> related static utility methods that
	 * don't naturally reside on any class.
	 */
	static class utility {
		/**
		 * Outputs a near-final message corresponding
		 * to an exception (or other throwable) to the named
		 * logger before causing the VM to exit.  The message
		 * will have ERROR severity unless an instance of
		 * PoolsException is given, in which case the message
		 * will adopt the PoolsException's severity.  Similarly,
		 * if the PoolsException specifies an exit code, it will
		 * be used; otherwise the default of
		 * <code>E_PO_FAILURE</code> will be used.
		 *
		 * @param logger Logger used to log the message
		 * @param t The cause.  A stack trace will be affixed to
		 * the message.
		 */
		public static void die(Logger logger, Throwable t)
		{
			die(logger, t, true);
		}

		/**
		 * Outputs a near-final message corresponding
		 * to an exception (or other throwable) to the named
		 * logger before causing the VM to exit.  The message
		 * will have ERROR severity unless an instance of
		 * PoolsException is given, in which case the message
		 * will adopt the PoolsException's severity.  Similarly,
		 * if the PoolsException specifies an exit code, it will
		 * be used; otherwise the default of
		 * <code>E_PO_FAILURE</code> will be used.
		 *
		 * @param logger Logger used to log the message
		 * @param t The cause.
		 * @param showStackTrace If true, a stack trace will be
		 * affixed to the message.
		 */
		public static void die(Logger logger, Throwable t,
		    boolean showStackTrace)
		{
			try {
				Severity severity;
				/*
				 * Configure the message's exception and
				 * severity.
				 */
				LogRecord record;
				if (t instanceof PooldException)
					record = new LogRecord(
					    ((PooldException)t).getSeverity(),
					    t.getMessage());
				else
					record = new LogRecord(Severity.ERR,
					    t.getMessage());
				if (record.getMessage() == null)
					record.setMessage("exception " +
					    t.getClass().getName());
				if (showStackTrace)
					record.setThrown(t);

				record.setLoggerName(logger.getName());
				logger.log(record);

				if (logHelper.handler != null)
					logHelper.handler.flush();
				if (t instanceof PooldException)
					System.exit(((PooldException)t)
					    .getExitCode());
				else
					System.exit(E_PO_FAILURE);
			} catch (Exception e) {
				SuccinctStackTraceFormatter.printStackTrace(e);
				System.exit(-1);
			}
		}

		/**
		 * Outputs a warning-level message to the named logger.
		 *
		 * @param logger Logger used to log the message
		 * @param t The cause.
		 * @param showStackTrace If true, a stack trace will be
		 * affixed to the message.
		 */
		public static void warn(Logger logger, Throwable t,
		    boolean showStackTrace)
		{
			try {
				Severity severity;
				/*
				 * Configure the message's exception and
				 * severity.
				 */
				LogRecord record;
				if (t instanceof PooldException)
					record = new LogRecord(
					    ((PooldException)t).getSeverity(),
					    t.getMessage());
				else
					record = new LogRecord(Severity.WARNING,
					    t.getMessage());
				if (record.getMessage() == null)
					record.setMessage("exception " +
					    t.getClass().getName());
				if (showStackTrace)
					record.setThrown(t);

				record.setLoggerName(logger.getName());
				logger.log(record);

				if (logHelper.handler != null)
					logHelper.handler.flush();
			} catch (Exception e) {
				SuccinctStackTraceFormatter.printStackTrace(e);
				System.exit(-1);
			}
		}
	}
}

class ConfigurationException extends Exception
{
	public ConfigurationException(String message)
	{
		super(message);
	}
}

class IllegalOFValueException extends RuntimeException
{
	public IllegalOFValueException(String message)
	{
		super(message);
	}
}

class PooldException extends Exception {
	/**
	 * The exit code which the virtual machine should exit at if
	 * this exception cannot be handled.
	 */
	private int exitCode;

	/**
	 * The severity of this message.  See <code>Severity</code>.
	 */
	private Severity severity;

	/**
	 * Constructs a message with default exit code and
	 * <code>System.ERR</code> severity.
	 */
	public PooldException(String message)
	{
		this(message, 1, Severity.ERR);
	}

	/**
	 * Constructs a message with given exit code and
	 * <code>System.ERR</code> severity.
	 */
	public PooldException(String message, int exitCode)
	{
		this(message, exitCode, Severity.ERR);
	}

	/**
	 * Constructs a message with a given exit code and severity.
	 */
	public PooldException(String message, int exitCode, Severity severity)
	{
		super(message);
		this.exitCode = exitCode;
		this.severity = severity;
	}

	/**
	 * The exit code which the virtual machine should exit at if
	 * this exception cannot be handled.
	 */
	public int getExitCode()
	{
		return (exitCode);
	}

	public Severity getSeverity()
	{
		return (severity);
	}
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.math.BigInteger;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Iterator;
import com.sun.solaris.service.pools.Component;
import com.sun.solaris.service.pools.Resource;
import com.sun.solaris.service.pools.PoolsException;
import com.sun.solaris.service.pools.UnsignedInt64;

/**
 * This represents a monitored resource and the techniques used to
 * monitor the resource.
 */
class ResourceMonitor extends HashMap
{
	/**
	 * The monitored resource.
	 */
	private Resource target;

	/**
	 * The size of the statistic buffer.
	 */
	private final int maxSize;

	/**
	 * Cached list of components to be monitored.
	 */
	private LinkedList compList;

	/**
	 * Constructor. No monitor target and a default buffer size of
	 * 50.
	 */
	public ResourceMonitor()
	{
		this(null, 50);
	}

	/**
	 * Constructor.
	 *
	 * @param target The resource to be monitored.
	 * @param maxSize The maximum number of samples to be held.
	 */
	public ResourceMonitor(Resource target, int maxSize)
	{
		super();
		this.target = target;
		this.maxSize = maxSize;
		compList = new LinkedList();

	}

	/**
	 * Initialize the resource monitor with it's list of
	 * components. Components which are off-line or powered-off
	 * cannot be monitored, so they should be removed from the
	 * list of components.
	 *
	 * @throws PoolsException if there is an error accessing the
	 * pool elements.
	 */
	public void initialize() throws PoolsException
	{
		compList.clear();
		List candidates = target.getComponents(null);
		Iterator candIt = candidates.iterator();
		while (candIt.hasNext()) {
			Component comp = (Component) candIt.next();
			String status = comp.getStringProperty("cpu.status");
			if (status.compareTo("off-line") != 0 &&
			    status.compareTo("powered-off") != 0)
				compList.add(comp);
		}
	}

	/**
	 * Get the list of components which are actively monitored by
	 * this resource.
	 */
	public List getComponents()
	{
		return ((List) compList.clone());
	}

	/**
	 * Return the maximum number of samples this monitor will
	 * hold.
	 */
	public int getMaxSampleSize()
	{
		return (maxSize);
	}

	/**
	 * Return the object which is being monitored.
	 */
	public Resource getMonitored()
	{
		return (target);
	}

	/**
	 * Set the resource to be monitored. A resource target can
	 * only be set once, if you attempt to modify it then an
	 * IllegalArgumentException is thrown.
	 *
	 * @param target The resource to be monitored.
	 * @throws IllegalArgumentException if the target has already
	 * been set.
	 */
	public void setResource(Resource target)
	{
		if (this.target != null)
			this.target = target;
		else
			throw new IllegalArgumentException("Once the target " +
			    "of a ResourceMonitor is set, it cannot be " +
			    "changed.");
	}

	/**
	 * Return the name of the monitored object.
	 *
	 * @throws PoolsException if there is an error accessing the
	 * pool element.
	 */
	public String getName() throws PoolsException
	{
		String type = target.getStringProperty("type");
		return (target.getStringProperty(type + ".name"));
	}

	/**
	 * Update the derived statistics.
	 */
	public void updateDerived()
	{
		StatisticList util = (StatisticList) get("utilization");
		AggregateStatistic stat = calcDerivedStatistic("utilization");
		if (stat != null)
			util.add(stat);
	}

	/**
	 * Get a derived statistic.
	 *
	 * @param name The name of the statistic to get.
	 */
	public AggregateStatistic getDerivedStatistic(String name)
	{
		return ((AggregateStatistic)((StatisticList)get(name)).
		    getLast());
	}

	/**
	 * Return the latest value of a derived statistic.
	 *
	 * @param name is the name of the derived statistic to be
	 * returned.
	 */
	private AggregateStatistic calcDerivedStatistic(String name)
	{
		/*
		 * The only statistic which can be obtained from this
		 * resource monitor is utilization. A utilization
		 * statistic actually represents a complex
		 * manipulation of several lower level
		 * statistics. This manipulation is performed here
		 * until a good interface can be thought through which
		 * best captures this abstraction.
		 */
		if (name.compareTo("utilization") != 0)
			throw new IllegalArgumentException("No such derived "
			    + "statistic: " + name);
		/*
		 * This statistic is based on lower level
		 * monotonically increasing numbers. The statistic can
		 * thus only be derived as an observation of the
		 * change in value over time of these values.
		 */

		StatisticList first = (StatisticList) get("idle");

		switch (first.size()) {
		case 0:
		case 1:
			return (null);
		default:
			BigInteger total = new BigInteger("0");
			double utilV = 0.0;
			double idleV = 0.0;
			LinkedList keys = new LinkedList(keySet());
			keys.remove("utilization");
			for (int i = 0; i < keys.size(); i++) {
				StatisticList sl = (StatisticList) get(keys.
				    get(i));
				AggregateStatistic sv1 = (AggregateStatistic)
				    sl.getLast();
				AggregateStatistic sv2 = (AggregateStatistic)
				    sl.get(sl.size() - 2);
				if (sl.getName().compareTo("idle") == 0)
					idleV = ((UnsignedInt64) sv1.
					    subtract(sv2).getValue()).
					    doubleValue();
				total = total.add((UnsignedInt64) sv1.
				    subtract(sv2).getValue());
			}
			utilV = 100 * ((total.doubleValue() - idleV) /
			    total.doubleValue());
			return (new DoubleStatistic(Double.valueOf(utilV),
				((AggregateStatistic)first.get(first.size() -
				2)).getStart(), ((AggregateStatistic)first.
				getLast()).getEnd()));
		}
	}

	void resetData(String name)
	{
		StatisticList sl = (StatisticList) get(name);
		sl.clear();
	}
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 *ident	"%Z%%M%	%I%	%E% SMI"
 *
 */

package com.sun.solaris.domain.pools;

import java.util.Set;

import com.sun.solaris.service.pools.Configuration;
import com.sun.solaris.service.pools.Element;
import com.sun.solaris.service.pools.PoolsException;

/**
 * This interface specifies the contract between poold and the poold
 * allocation algorithms.
 */

public interface Solver {
	/**
	 * Initialize the solver.
	 *
	 * @param conf The configuration to be manipulated.
	 * @throws PoolsException If the initialization fails.
	 */
	public void initialize(Configuration conf) throws PoolsException;

	/**
	 * Evaluate whether a workload based reconfiguration is
	 * required.
	 *
	 * @param mon The monitor to be used during examination.
	 * @throws PoolsException If the examination fails.
	 * @throws StaleMonitorException If the monitor is stale.
	 */
	public boolean examine(Monitor mon) throws PoolsException,
	    StaleMonitorException;

	/**
	 * Allocate resources. Return true if a change was made.
	 *
	 * @throws Exception If the solve fails.
	 */
	public boolean solve() throws Exception;

	/**
	 * Return true if all examined resources are capable of
	 * providing statistically valid data.
	 *
	 * If any of the monitored resources have not accumulated
	 * enough data to be statistically significant, then this
	 * monitor is not ready to be used to obtain data for all
	 * resources. In this case, false is returned.
	 *
	 */
	public boolean isValid();

	/**
	 * Return a reference to the monitor which this solver is
	 * using to provide statistics about the configuration which
	 * is to be solved.
	 */
	public Monitor getMonitor();

	/**
	 * Return the set of objectives associated with the supplied
	 * element.
	 *
	 * @param elem Retrieve objectives for this element.
	 */
	public Set getObjectives(Element elem);
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.math.BigInteger;
import java.util.Date;
import java.util.Iterator;
import java.text.*;

import com.sun.solaris.service.pools.UnsignedInt64;

/**
 * Contains the information relating to a specific statistic for an
 * object. The Statistic has no notion of the source of the data, it
 * is simply a repository for holding statistical information.
 */
interface Statistic
{
	/**
	 * Return the start of the sample period for which the
	 * statistic is representative.
	 */
	public Date getStart();

	/**
	 * Return the end of the sample period for which the
	 * statistic is representative.
	 */
	public Date getEnd();

	/**
	 * Get the value of this statistic.
	 */
	public Object getValue();

	/**
	 * Get the value of this statistic as a Long.
	 */
	public Long getLongValue();

	/**
	 * Get the value of this statistic as a Double.
	 */
	public Double getDoubleValue();

	/**
	 * Get the value of this statistic as a UnsignedInt64.
	 */
	public UnsignedInt64 getUnsignedInt64Value();
}

/**
 * An interface for Statistics which may be aggregated.
 */
interface AggregateStatistic extends Statistic
{
	/**
	 * Add the supplied statistic to this.
	 *
	 * @param o The other statistic.
	 */
	public AggregateStatistic add(AggregateStatistic o);

	/**
	 * Subtract the supplied statistic from this.
	 *
	 * @param o The other statistic.
	 */
	public AggregateStatistic subtract(AggregateStatistic o);

	/**
	 * Produce the aggregate of all objects in the supplied
	 * iterator (which must be of the same type) whose start and
	 * end dates lie within the supplied ranges. If either start
	 * or end is null, then that bound is not applied. i.e. if no
	 * start date is supplied, then start checking is disabled.
	 *
	 * @param start The start date for qualification in the snapshot.
	 * @param end The end date for qualification in the snapshot.
	 * @throws IllegalArgumentException If the iterator is empty.
	 */
	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException;
}

/**
 * A basic Statistic implementation which makes it easy to derive
 * concrete statistic types. This is an immutable class, the state is
 * set when the object is constructed and cannot be later changed.
 */
abstract class AbstractStatistic implements Statistic
{
	/**
	 * The value of the statistic.
	 */
	private final Object value;

	/**
	 * The start of the interval during which the statistic was
	 * captured.
	 */
	private final Date start;

	/**
	 * The end of the interval during which the statistic was
	 * captured.
	 */
	private final Date end;

	/**
	 * Formatter for the sample start time, used by toString().
	 */
	private static final DateFormat df = new SimpleDateFormat("kk:mm:ss");

	/**
	 * Constructor. This is provided as a mechanism to allow
	 * inherited classes to correctly initialize their state.
	 *
	 * @param value The value of this statistic.
	 */
	protected AbstractStatistic(Object value)
	{
		this(value, null, null);
	}

	/**
	 * Constructor. This is provided as a mechanism to allow
	 * inherited classes to correctly initialize their state.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the sample period which this
	 * statistic represents.
	 * @param end The end of the sample period which this
	 * statistic represents.
	 */
	protected AbstractStatistic(Object value, Date start, Date end)
	{
		this.value = value;
		this.start = start;
		this.end = end;
	}

	/**
	 * Return the start of the sample period for which the
	 * statistic is representative.
	 */
	public Date getStart()
	{
		return (start);
	}


	/**
	 * Return the end of the sample period for which the
	 * statistic is representative.
	 */
	public Date getEnd()
	{
		return (end);
	}

	/**
	 * Get the value of this statistic.
	 */
	public Object getValue()
	{
		return (value);
	}

	public abstract Long getLongValue();
	public abstract Double getDoubleValue();
	public abstract UnsignedInt64 getUnsignedInt64Value();

	/**
	 * Return the string representation of this statistic.
	 */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append(value);
		if (start != null && end != null) {
			buf.append(" from ");
			buf.append(df.format(start));
			buf.append(" to ");
			buf.append(df.format(end));
		}
		return (buf.toString());
	}
}

/**
 * A statistic of type Double.
 */
final class DoubleStatistic extends AbstractStatistic
    implements AggregateStatistic
{

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 */
	public DoubleStatistic(Double value)
	{
		super(value);
	}

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the interval over which this
	 * statistic is representative.
	 * @param end The end of the interval over which this
	 * statistic is representative.
	 */
	public DoubleStatistic(Double value, Date start, Date end)
	{
		super(value, start, end);
	}

	public Double getDoubleValue()
	{
		return ((Double) getValue());
	}

	public Long getLongValue()
	{
		return (Long.valueOf(((Double) getValue()).longValue()));
	}

	public UnsignedInt64 getUnsignedInt64Value()
	{
		return (new UnsignedInt64(Long.toString(((Double) getValue()).
					      longValue())));
	}

	public AggregateStatistic add(AggregateStatistic o)
	{
		Double v1 = getDoubleValue();
		Double v2 = o.getDoubleValue();

		return (new DoubleStatistic(Double.valueOf(v1.doubleValue() +
					    v2.doubleValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic subtract(AggregateStatistic o)
	{
		Double v1 = getDoubleValue();
		Double v2 = o.getDoubleValue();

		return (new DoubleStatistic(Double.valueOf(v1.doubleValue() -
					    v2.doubleValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException
	{
		double total = 0;
		int count = 0;
		Date first = start, last = end;

		while (it.hasNext()) {
			DoubleStatistic s = (DoubleStatistic) it.next();
			if (start != null) {
				if (s.getStart().compareTo(start) < 0)
					continue;
			}
			if (first == null)
				first = s.getStart();
			if (end != null) {
				if (s.getEnd().compareTo(end) > 0)
					continue;
			}
			last = s.getEnd();
			total += s.getDoubleValue().doubleValue();
			count++;
		}
		if (count == 0)
			throw new IllegalArgumentException("Cannot derive a " +
			    "snapshot from an empty iterator");
		return (new DoubleStatistic(Double.valueOf(total / count),
			first, last));
	}
}

/**
 * A statistic of type Long.
 */
final class LongStatistic extends AbstractStatistic
    implements AggregateStatistic
{

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the interval over which this
	 * statistic is representative.
	 * @param end The end of the interval over which this
	 * statistic is representative.
	 */
	public LongStatistic(Long value, Date start, Date end)
	{
		super(value, start, end);
	}

	public Double getDoubleValue()
	{
		return (Double.valueOf(((Long) getValue()).longValue()));
	}

	public Long getLongValue()
	{
		return ((Long) getValue());
	}

	public UnsignedInt64 getUnsignedInt64Value()
	{
		return (new UnsignedInt64(Long.toString(((Long) getValue()).
					      longValue())));
	}

	public AggregateStatistic add(AggregateStatistic o)
	{
		Long v1 = getLongValue();
		Long v2 = o.getLongValue();

		return (new LongStatistic(Long.valueOf(v1.longValue() +
					    v2.longValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic subtract(AggregateStatistic o)
	{
		Long v1 = getLongValue();
		Long v2 = o.getLongValue();

		return (new LongStatistic(Long.valueOf(v1.longValue() -
					    v2.longValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException
	{
		long total = 0;
		int count = 0;
		Date first = start, last = end;
		while (it.hasNext()) {
			LongStatistic s = (LongStatistic) it.next();
			if (start != null) {
				if (s.getStart().compareTo(start) < 0)
					continue;
			}
			if (first == null)
				first = s.getStart();
			if (end != null) {
				if (s.getEnd().compareTo(end) > 0)
					continue;
			}
			last = s.getEnd();
			total += s.getLongValue().longValue();
			count++;
		}
		if (count == 0)
			throw new IllegalArgumentException("Cannot derive a " +
			    "snapshot from an empty iterator");
		return (new LongStatistic(Long.valueOf(total / count), first,
			last));
	}
}

/**
 * A statistic of type UnsignedInt64.
 */
final class UnsignedInt64Statistic extends AbstractStatistic
    implements AggregateStatistic
{

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the interval over which this
	 * statistic is representative.
	 * @param end The end of the interval over which this
	 * statistic is representative.
	 */
	public UnsignedInt64Statistic(UnsignedInt64 value, Date start,
	    Date end)
	{
		super(value, start, end);
	}

	public Double getDoubleValue()
	{
		return (Double.valueOf(
		    ((UnsignedInt64) getValue()).longValue()));
	}

	public Long getLongValue()
	{
		return (Long.valueOf(((UnsignedInt64) getValue()).longValue()));
	}

	public UnsignedInt64 getUnsignedInt64Value()
	{
		return ((UnsignedInt64) getValue());
	}

	public AggregateStatistic add(AggregateStatistic o)
	{
		UnsignedInt64 v1 = getUnsignedInt64Value();
		UnsignedInt64 v2 = o.getUnsignedInt64Value();

		return (new UnsignedInt64Statistic(
		    new UnsignedInt64(v1.add(v2)),
		        getStart(), getEnd()));
	}

	public AggregateStatistic subtract(AggregateStatistic o)
	{
		UnsignedInt64 v1 = getUnsignedInt64Value();
		UnsignedInt64 v2 =  o.getUnsignedInt64Value();

		return (new UnsignedInt64Statistic(
		    new UnsignedInt64(v1.subtract(v2)),
		        getStart(), getEnd()));
	}

	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException
	{
		BigInteger total = new BigInteger("0");
		int count = 0;
		Date first = start, last = end;
		while (it.hasNext()) {
			UnsignedInt64Statistic s = (UnsignedInt64Statistic)
			    it.next();
			if (start != null) {
				if (s.getStart().compareTo(start) < 0)
					continue;
			}
			if (first == null)
				first = s.getStart();

			if (end != null) {
				if (s.getEnd().compareTo(end) > 0)
					continue;
			}
			last = s.getEnd();
			total = total.add(s.getUnsignedInt64Value());
			count++;
		}
		if (count == 0)
			throw new IllegalArgumentException("Cannot derive a " +
			    "snapshot from an empty iterator");
		return (new UnsignedInt64Statistic(
		    new UnsignedInt64(total.divide(new BigInteger(
	            Integer.toString(count)))), first, last));
	}
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;


import java.util.*;
import java.text.DecimalFormat;

import com.sun.solaris.service.logging.*;

/**
 * Contains information about statistics. An instance must only
 * contain Statistics of the same type.
 */
class StatisticList extends LinkedList
{
	/**
	 * The name of the statistic.
	 */
	private final String name;

	/**
	 * The maximum number of samples to be stored.
	 */
	private final int maxSize;

	/**
	 * The list of StatisticListeners.
	 */
	private List listeners;

	/**
	 * Statistically assess utilization.
	 */
	private StatisticOperations statisticOperations;

	/**
	 * Constructor.
	 */
	public StatisticList()
	{
		this("default", 10);
	}

	/**
	 * Constructor. Statistics will not be held for this set.
	 *
	 * @param name is the name of the contained statistics
	 * @param size is the maximum number of statistics to hold
	 */
	public StatisticList(String name, int size)
	{
		this(name, size, false);
	}

	/**
	 * Constructor.
	 *
	 * @param name is the name of the contained statistics
	 * @param size is the maximum number of statistics to hold
	 * @param doStats indicates whether or not statistics should
	 * be calculated for the data.
	 */
	public StatisticList(String name, int size, boolean doStats)
	    throws IllegalArgumentException
	{
		super();
		this.name = name;
		if (size < 1)
			throw new IllegalArgumentException("Size must be > 0");
		this.maxSize = size;
		listeners = new LinkedList();
		if (doStats) {
			statisticOperations = new StatisticOperations(this);
			addStatisticListener(statisticOperations);
		}
	}

	/**
	 * Return the name of the Statistics being sampled.
	 */
	public String getName()
	{
		return (name);
	}

	/**
	 * Return a "snapshot" which is the aggregation of all
	 * statistic records.
	 *
	 * @throws NoSuchElementException if there is an error
	 * accessing a list member.
	 */
	public AggregateStatistic getSnapshot()
	    throws NoSuchElementException
	{
		return (getSnapshotForInterval(iterator(), null, null));
	}

	/**
	 * Return a "snapshot" of the data using the supplied
	 * iterator.
	 *
	 * @param it An iterator over the contained elements to be
	 * used as the basis for the snapshot.
	 * @throws NoSuchElementException if there is an error
	 * accessing a list member.
	 */
	private AggregateStatistic getSnapshot(Iterator it)
	    throws NoSuchElementException
	{
		return (getSnapshotForInterval(it, null, null));
	}

	/**
	 * Returns the aggregated value for the StatisticList only
	 * including samples which satisfy the start and end criteria.
	 *
	 * @param start start time or null if unspecified.
	 * @param end end time or null if unspecified.
	 * @throws NoSuchElementException if there is an error
	 * accessing a list member.
	 */
	public AggregateStatistic getSnapshotForInterval(Date start,
	    Date end) throws NoSuchElementException

	{
		return (getSnapshotForInterval(iterator(), start, end));
	}

	/**
	 * Returns the aggregated value for the StatisticList only
	 * including samples which satisfy the start and end criteria.
	 *
	 * @param it An iterator over the contained elements to be
	 * used as the basis for the snapshot.
	 * @param start start time or null if unspecified.
	 * @param end end time or null if unspecified.
	 * @throws NoSuchElementException if there is an error
	 * accessing a list member.
	 */
	private AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end)
	{
		AggregateStatistic f = (AggregateStatistic) getFirst();
		return (f.getSnapshotForInterval(it, start, end));
	}

	/**
	 * Add the supplied object to the list. If the list is full,
	 * remove the first entry before adding the new entry.
	 *
	 * @param o Object to add to the list.
	 */
	public boolean add(Object o)
	{
		boolean ret;
		if (size() == maxSize)
			removeFirst();
		ret = super.add(o);
		if (ret)
			notifyStatisticAdd((AggregateStatistic) o);
		return (ret);
	}

	/**
	 * Remove the supplied object from the list.
	 *
	 * @param o Object to remove from the list.
	 */
	public boolean remove(Object o)
	{
		boolean ret;
		ret = super.remove(o);
		if (ret)
			notifyStatisticRemove((AggregateStatistic) o);
		return (ret);
	}

	/**
	 * Removes and returns the first element from this list.
	 *
	 * @return the first element from this list.
	 * @throws	  NoSuchElementException if this list is empty.
	 */
	public Object removeFirst() {
		Object first = getFirst();
		remove(first);
		return (first);
	}

	/**
	 * Add a listener for StatisticEvents.
	 *
	 * @param l Listener to add.
	 */
	public void addStatisticListener(StatisticListener l) {
		listeners.add(l);
	}

	/**
	 * Remove a listener for StatisticEvents.
	 *
	 * @param l Listener to remove.
	 */
	public void removeStatisticListener(StatisticListener l) {
		listeners.remove(l);
	}

	/**
	 * Notify all StatisticEvent listeners of a new Add event.
	 *
	 * @param s Event payload.
	 */
	private void notifyStatisticAdd(AggregateStatistic s)
	{
		StatisticEvent e = new StatisticEvent(this,
		    StatisticEvent.ADD, s);

		Iterator listIt = listeners.iterator();

		while (listIt.hasNext()) {

			StatisticListener l = (StatisticListener)listIt.next();
			l.onStatisticAdd(e);
		}
	}

	/**
	 * Notify all StatisticEvent listeners of a new Remove event.
	 *
	 * @param s Event payload.
	 */
	private void notifyStatisticRemove(AggregateStatistic s)
	{
		StatisticEvent e = new StatisticEvent(this,
		    StatisticEvent.REMOVE, s);

		Iterator listIt = listeners.iterator();

		while (listIt.hasNext()) {

			StatisticListener l = (StatisticListener)listIt.next();
			l.onStatisticRemove(e);
		}
	}

	/**
	 * Return true if the contents of the instance are
	 * statistically valid.
	 */
	boolean isValid()
	{
		return (statisticOperations.isValid());
	}

	/**
	 * Return the zone of control to which the supplied val
	 * belongs based on the target details in the supplied
	 * objective expression.
	 *
	 * @param kve Objective expression used to determine zone
	 * details.
	 * @param val The value to be assessed.
	 */
	int getZone(KVOpExpression kve, double val)
	{
		return (statisticOperations.getZone(kve, val));
	}

	/**
	 * Return the zone of control to which the supplied val
	 * belongs based on the mean of the sampled data.
	 *
	 * @param val The value to be assessed.
	 */
	int getZoneMean(double val)
	{
		return (statisticOperations.getZoneMean(val));
	}

	/**
	 * Return the difference (gap) between the target utilization
	 * expressed in the supplied objective expression and the
	 * supplied value.
	 *
	 * @param kve Objective expression used to determine target
	 * utilization details.
	 * @param val The value to be assessed.
	 */
	double getGap(KVOpExpression kve, double val)
	{
		return (statisticOperations.getGap(kve, val));
	}

	/**
	 * Clear all the data from the StatisticList and reset all the
	 * statistic counters.
	 */
	public void clear()
	{
		if (statisticOperations != null) {
			removeStatisticListener(statisticOperations);
			statisticOperations = new StatisticOperations(this);
			addStatisticListener(statisticOperations);
		}
		super.clear();
	}

	/**
	 * Return a string which describes the zones for this set of
	 * data.
	 *
	 * @param kve The expression containing objectives.
	 * @param val The value to be assessed against objectives.
	 */
	public String toZoneString(KVOpExpression kve, double val)
	{
		return (statisticOperations.toZoneString(kve, val));
	}
}

/**
 * Event class which describes modifications (Add, Remove) to a
 * StatisticList instance.
 */
final class StatisticEvent extends EventObject
{
	/**
	 * Identifier for an ADD event.
	 */
	public static final int ADD = 0x1;

	/**
	 * Identifier for a REMOVE event.
	 */
	public static final int REMOVE = 0x2;

	/**
	 * The target of the event.
	 */
	private final AggregateStatistic target;

	/**
	 * The identifier of this event.
	 */
	private final int id;

	/**
	 * Constructor.
	 *
	 * @param source The source of the event.
	 * @param id The type of the event.
	 * @param target The target of the event.
	 */
	public StatisticEvent(Object source, int id, AggregateStatistic target)
	{
		super(source);
		this.id = id;
		this.target = target;
	}

	/**
	 * Return the target of the event.
	 */
	public AggregateStatistic getTarget()
	{
		return (target);
	}

	/**
	 * Return the ID (type) of the event.
	 */
	public int getID()
	{
		return (id);
	}

	/**
	 * Return the source of the event. This is a typesafe
	 * alternative to using getSource().
	 */
	public StatisticList getStatisticList()
	{
		return ((StatisticList) source);
	}

}

/**
 * The listener interface for receiving statistic events. The class
 * that is interested in processing a statistic event implements this
 * interface, and the object created with that class is registered
 * with a component, using the component's addStatisticListener
 * method. When the statistic event occurs, the relevant method in the
 * listener object is invoked, and the StatisticEvent is passed to it.
 */
interface StatisticListener extends EventListener
{
	/**
	 * Invoked when a statistic is added to the source
	 * StatisticList.
	 *
	 * @param e The event.
	 */
	public void onStatisticAdd(StatisticEvent e);

	/**
	 * Invoked when a statistic is removed from the source
	 * StatisticList.
	 *
	 * @param e The event.
	 */
	public void onStatisticRemove(StatisticEvent e);
}

/**
 * This class performs statistical calculations on a source
 * StatisticList. Zones are regions in a set of samples which are set
 * to be at 1, 2 and 3 standard deviations from the mean. ZONEC is
 * closest to the center, with ZONEZ representing the region beyond
 * ZONEA.
 */
class StatisticOperations implements StatisticListener
{
	/**
	 * Control zone C.
	 */
	public static final int ZONEC = 0x00010;

	/**
	 * Control zone B.
	 */
	public static final int ZONEB = 0x00100;

	/**
	 * Control zone A.
	 */
	public static final int ZONEA = 0x01000;

	/**
	 * Control zone Z.
	 */
	public static final int ZONEZ = 0x10000;

	/**
	 * Direction from mean (used to test ZONELT and ZONEGT).
	 */
	public static final int ZONET = 0x00001;

	/**
	 * Less than the mean.
	 */
	public static final int ZONELT = 0x00000;

	/**
	 * Greater than the mean.
	 */
	public static final int ZONEGT = 0x00001;

	/**
	 * The raw statistical data.
	 */
	private final StatisticList statistics;

	/**
	 * The mean of the samples.
	 */
	private double mean;

	/**
	 * The standard deviation of the samples.
	 */
	private double sd;

	/**
	 * The total of the samples.
	 */
	private AggregateStatistic total;

	/**
	 * Constructs a new StatisticOperations object for working on
	 * the given statistic, whose values are in the given
	 * (modifiable) data set.
	 *
	 * @param statistics The statistics to operate on.
	 */
	public StatisticOperations(StatisticList statistics)
	{
		this.statistics = statistics;
		total = new DoubleStatistic(Double.valueOf(0.0));
	}

	/**
	 * Calculate the standard deviation for the data held in the
	 * associated StatisticsList.
	 */
	private void calc_sd()
	{
		Iterator it;

		sd = 0;
		it = statistics.iterator();
		while (it.hasNext()) {
			Double val = (Double)((DoubleStatistic)
			    ((AggregateStatistic)it.next())).getValue();

			sd += java.lang.Math.pow(val.doubleValue() - mean, 2);
		}
		sd /= statistics.size();
		sd = java.lang.Math.sqrt(sd);
	}

	/**
	 * Return a string which describes the zones for this set of
	 * data.
	 *
	 * @param kve The expression containing objectives.
	 * @param val The value to be assessed against objectives.
	 */
	public String toZoneString(KVOpExpression kve, double val)
	{
		if (isValid()) {
			DecimalFormat f = new DecimalFormat("00.00");
			double target = kve.getValue();

			if (kve.getOp() == KVOpExpression.LT) {
				target -= 3 * sd;
			} else if (kve.getOp() == KVOpExpression.GT) {
				target += 3 * sd;
			}
			StringBuffer buf = new StringBuffer();
			buf.append(kve.toString());
			buf.append("\nsample = " + statistics.size());
			buf.append("\n\ttarget: " + f.format(target));
			buf.append("\n\tvalue: " + f.format(val));
			buf.append("\n\tsd: " + f.format(sd));
			buf.append("\n\tZones:");
			buf.append("\n\t\tC:" + f.format(target - sd));
			buf.append("-" + f.format(target + sd));
			buf.append("\n\t\tB:" + f.format(target - 2 * sd));
			buf.append("-" + f.format(target + 2 * sd));
			buf.append("\n\t\tA:" + f.format(target - 3 * sd));
			buf.append("-" + f.format(target + 3 * sd));
			return (buf.toString());
		} else {
			return ("Still sampling...");
		}
	}


	/**
	 * Return a string which describes this instance.
	 */
	public String toString()
	{
		DecimalFormat f = new DecimalFormat("00.00");

		if (isValid()) {
			return ("sample = " + statistics.size() +
			    "\n\tmean: " + f.format(mean) +
			    "\n\tsd: " + f.format(sd) +
			    "\n\tZones:" +
			    "\n\t\tC:" + f.format(mean - sd) +
			    "-" + f.format(mean + sd) +
			    "\n\t\tB:" + f.format(mean - 2 * sd) +
			    "-" + f.format(mean + 2 * sd) +
			    "\n\t\tA:" + f.format(mean - 3 * sd) +
			    "-" + f.format(mean + 3 * sd));
		} else {
			return ("Still sampling...");
		}
	}

	/**
	 * Return true if the data is normally distributed. This
	 * method currently just returns true if the sample size is >=
	 * 5. It could be extended to use a test of normality, for
	 * instance "Pearson's Chi-Squared Test" or "Shapiro-Wilks W
	 * Test".
	 */
	public boolean isValid()
	{
		if (statistics.size() >= 5)
			return (true);
		return (false);
	}

	/**
	 * Calculate the statistical values for the associated
	 * samples. This method should be called when the sample
	 * population changes.
	 */
	private final void process()
	{
		mean = ((Double)((DoubleStatistic)total).getValue()).
		    doubleValue() / statistics.size();
		calc_sd();
	}

	/**
	 * Return the control zone for the supplied value using the
	 * information derived from the monitored statistics and the
	 * objective expressed in the supplied objective expression.
	 *
	 * @param kve The target utilization expression.
	 * @param val The value to be evaluated.
	 */
	public int getZone(KVOpExpression kve, double val)
	{
		if (!isValid())
			return (StatisticOperations.ZONEC);

		double target = kve.getValue();

		if (kve.getOp() == KVOpExpression.LT) {
			target -= 3 * sd;
		} else if (kve.getOp() == KVOpExpression.GT) {
			target += 3 * sd;
		}

		return (getZone(target, val));
	}

	/**
	 * Return the control zone for the supplied value using the
	 * information derived from the monitored statistics.
	 *
	 * @param val The value to be evaluated.
	 */
	public int getZoneMean(double val)
	{
		if (!isValid())
			return (StatisticOperations.ZONEC);

		return (getZone(mean, val));
	}

	/**
	 * Return the control zone for the supplied value using the
	 * information derived from the supplied target.
	 *
	 * @param val The value to be evaluated.
	 */
	private int getZone(double target, double val)
	{
		if (!isValid())
			return (StatisticOperations.ZONEC);

		return ((val < target - 3 * sd) ?
		    ZONEZ | ZONELT : (val > target + 3 * sd) ?
		    ZONEZ | ZONEGT : (val < target - 2 * sd) ?
		    ZONEA | ZONELT : (val > target + 2 * sd) ?
		    ZONEA | ZONEGT : (val < target - sd) ?
		    ZONEB | ZONELT : (val > target + sd) ?
		    ZONEB | ZONEGT : (val < target) ?
		    ZONEC | ZONELT : ZONEC | ZONEGT);
	}

	/**
	 * Return the difference (gap) between the target utilization
	 * expressed in the supplied objective expression and the
	 * supplied value.
	 *
	 * @param kve Objective expression used to determine target
	 * utilization details.
	 * @param val The value to be assessed.
	 */
	public double getGap(KVOpExpression kve, double val)
	{
		if (!isValid())
			return (0.0);

		double target = kve.getValue();

		if (kve.getOp() == KVOpExpression.LT) {
			target -= 3 * sd;
		} else if (kve.getOp() == KVOpExpression.GT) {
			target += 3 * sd;
		}
		if (val - target < -100)
			return (-100);
		else if (val - target > 100)
			return (100);
		else
			return (val - target);
	}

	/**
	 * Event handler for added statistics.
	 *
	 * @param e The event.
	 */
	public void onStatisticAdd(StatisticEvent e)
	{
		total = total.add(e.getTarget());
		process();

	}

	/**
	 * Event handler for removed statistics.
	 *
	 * @param e The event.
	 */
	public void onStatisticRemove(StatisticEvent e)
	{
		total = total.subtract(e.getTarget());
		process();
	}
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.util.logging.*;

import com.sun.solaris.service.kstat.*;
import com.sun.solaris.service.logging.Severity;
import com.sun.solaris.domain.pools.*;
import com.sun.solaris.service.pools.*;
import com.sun.solaris.service.timer.*;

/**
 * Regularly samples the objective-related utilization statistics of
 * the resource in the pool with the given configuration.
 */
class SystemMonitor implements Monitor
{
	/**
	 * The pool configuration with resources to be monitored.
	 */
	private Configuration conf;

	/**
	 * The map of monitored resources.The map is keyed by
	 * resource, with the values being the monitorable instances.
	 */
	private Map monitored;

	/**
	 * Default sample interval (milliseconds).
	 */
	public static final int DEF_SAMPLE_INT = 15000;

	/**
	 * Sample interval (milliseconds, default 15000).
	 */
	private int interval;

	/**
	 * Sample interval property name.
	 */
	static final String SAMPLE_INTERVAL_PROP_NAME =
	    "system.poold.monitor-interval";

	/**
	 * Kstat interface for raw data
	 */
	private KstatCtl kc;

	/**
	 * Raw statistics which are sampled each interval.
	 */
	private final String stats[] = { "idle", "kernel", "wait", "user" };

	/**
	 * Timer regulating sampling frequency.
	 */
	private RecurringEventTimer timer;

	/**
	 * The number of samples taken.
	 */
	private int sampleCount = 0;

	/**
	 * Time the last sample was taken.
	 */
	private Date lastSampleTime = null;

	/**
	 * Constructs a new monitor which is not associated with a
	 * specific configuration.
	 */
	public SystemMonitor()
	{
		this(null);
	}

	/**
	 * Constructs a new Monitor for monitoring the resources in the
	 * given configuration using the given statistic source.
	 *
	 * @param conf The configuration which is monitored.
	 */
	public SystemMonitor(Configuration conf)
	{
		this.conf = conf;
		monitored = new HashMap();
		kc = new KstatCtl();
	}

	/**
	 * Initialize the monitor with the configuration which is to
	 * be monitored.
	 *
	 * @param conf The configuration which is monitored.
	 *
	 * @throws PoolsException if manipulating the configuration
	 * fails.
	 * @throws StaleMonitorException if the resource monitors
	 * cannot be set.
	 */
	public void initialize(Configuration conf) throws PoolsException,
	    StaleMonitorException
	{
		Poold.CONF_LOG.log(Severity.DEBUG, "initializing");
		this.conf = conf;
		try {
			kc.chainUpdate();
		} catch (KstatChainUpdateException kcue) {
			Poold.utility.die(Poold.CONF_LOG, kcue);
		}

		try {
			interval = (int)conf.getLongProperty(
			    SAMPLE_INTERVAL_PROP_NAME);
		} catch (PoolsException pe) {
			interval = DEF_SAMPLE_INT;
		}
		timer = new SimpleRecurringEventTimer(interval);

		setResourceMonitors("pset");
	}

	/**
	 * Add all resources of the supplied type in the monitored
	 * configuration to the set of monitored resources. Remove
	 * redundant monitors for resources which no longer exist.
	 * Don't monitor resource sets which are empty.
	 *
	 * @param type The type of the resources to be added
	 */
	private void setResourceMonitors(String type) throws PoolsException,
	    StaleMonitorException
	{
		Value val = new Value("type", type);

		List valueList = new LinkedList();
		valueList.add(val);
		Iterator resIt = conf.getResources(valueList).iterator();
		val.close();
		HashSet oldKeys = new HashSet(monitored.keySet());
		while (resIt.hasNext()) {
			Resource res = (Resource)resIt.next();
			ResourceMonitor mon = null;
			boolean activeComponents = false;

			List compList = res.getComponents(null);
			Iterator compIt = compList.iterator();
			while (compIt.hasNext()) {
				Component comp = (Component) compIt.next();
				String status = comp.getStringProperty(
				    "cpu.status");
				if (status.compareTo("off-line") != 0 &&
			    	    status.compareTo("powered-off") != 0) {
					activeComponents = true;
					break;
				}
			}
			if (activeComponents == false)
				continue;

			if (monitored.containsKey(res)) {
				mon = get(res);
				for (int i = 0; i < stats.length; i++)
					mon.resetData(stats[i]);
			} else {
				mon = new ResourceMonitor(res, 50);
				for (int i = 0; i < stats.length; i++) {
					StatisticList sl = new StatisticList(
					    stats[i], 2);
					mon.put(stats[i], sl);
				}
				mon.put("utilization", new StatisticList(
				    "utilization", mon.getMaxSampleSize(),
				    true));
				monitored.put(res, mon);
			}
			mon.initialize();
			oldKeys.remove(res);
		}
		monitored.keySet().removeAll(oldKeys);
	}

	/**
	 * Get the next sample. Before obtaining the sample, the call
	 * will block for the interval which was specified when this
	 * monitor was initialized.
	 *
	 * @throws StaleMonitorException if a statistic cannot be obtained.
	 * @throws PoolsException if there is an error manipulating the
	 * pools configuration.
	 * @throws InterruptedException if the thread is interrupted
	 * while waiting for the sampling time to arrive.  The caller
	 * may wish to check other conditions before possibly
	 * reinitiating the sample.
	 */
	public void getNext() throws StaleMonitorException, PoolsException,
	    InterruptedException
	{
		Poold.MON_LOG.log(Severity.DEBUG, "waiting sampling interval");

		Date start = lastSampleTime;
		if (start == null)
			start = new Date();

		timer.waitUntilNextFiring();
		Date end = new Date();

		Poold.MON_LOG.log(Severity.DEBUG, "sampling");
		Iterator itMon = monitored.values().iterator();
		while (itMon.hasNext()) {
			ResourceMonitor mon = (ResourceMonitor) itMon.next();
			List compList = mon.getComponents();
			Iterator itComp = compList.iterator();
			BigInteger statsv[] = new BigInteger[4];
			while (itComp.hasNext()) {
				Component cpu = (Component) itComp.next();
				Kstat kstat = kc.lookup("cpu",
				    (int) cpu.getLongProperty("cpu.sys_id"),
				    "sys");
				if (kstat == null)
					throw new StaleMonitorException();
				UnsignedInt64 value;
				try {
					kstat.read();
					for (int i = 0; i < stats.length; i++) {
						value = (UnsignedInt64) kstat.
						    getValue("cpu_ticks_" +
						    stats[i]);
						if (value == null)
							throw new
							StaleMonitorException();
						if (statsv[i] == null)
							statsv[i] = value;
						else
							statsv[i] = statsv[i].
							    add(value);
					}
				} catch (KstatException ke) {
					StaleMonitorException sme =
					    new StaleMonitorException();
					sme.initCause(ke);
					Poold.MON_LOG.log(Severity.DEBUG,
					    "configuration necessary due to "
					    + ke);
					throw(sme);
				}
			}
			if (compList.isEmpty() == false) {
				for (int i = 0; i < stats.length; i++) {
					StatisticList sl;
					sl = (StatisticList) mon.get(stats[i]);
					sl.add(new UnsignedInt64Statistic(
					    new UnsignedInt64(statsv[i].
					    divide(new BigInteger(
					    Integer.toString(
					    compList.size())))),
					    start, end));
				}
			}
			mon.updateDerived();
		}

		sampleCount++;
		lastSampleTime = end;
	}

	/**
	 * Return the number of samples taken.  This is the number of
	 * successful calls to <code>getNext()</code>.
	 */
	public int getSampleCount()
	{
		return (sampleCount);
	}

	/**
	 * Return the utilization of the supplied resource. The
	 * utilization is represented as a percentage between 0
	 * and 100.
	 *
	 * @param res A reference to a configuration resource.
	 */
	public double getUtilization(Resource res) throws StaleMonitorException
	{
		ResourceMonitor mon = get(res);
		DoubleStatistic util = null;
		try {
			util = (DoubleStatistic)mon.getDerivedStatistic(
			    "utilization");
		} catch (NoSuchElementException nsee) {
			util = new DoubleStatistic(Double.valueOf(0));
		}
		Poold.MON_LOG.log(Severity.DEBUG,
		    res + " utilization " + util.toString());
		return (((Double)util.getValue()).doubleValue());
	}

	/**
	 * Return true if the system contains enough sampled data for
	 * monitoring to be worthwhile.
	 */
	public boolean isValid()
	{
		Iterator itMon = monitored.values().iterator();
		while (itMon.hasNext()) {
			ResourceMonitor mon = (ResourceMonitor) itMon.next();

			Iterator itSL = mon.values().iterator();
			while (itSL.hasNext()) {
				StatisticList sl = (StatisticList) itSL.next();
				if (sl.getName().compareTo("utilization") ==
				    0) {
					if (sl.isValid() == false)
						return (false);
				}
			}
		}
		return (true);
	}

	/**
	 * Return the ResourceMonitor for the supplied Resource
	 *
	 * @throws StaleMonitorException if the ResourceMonitor cannot be found.
	*/
	public ResourceMonitor get(Resource res) throws StaleMonitorException
	{
		ResourceMonitor rm = (ResourceMonitor)monitored.get(res);

		if (rm == null)
			throw new StaleMonitorException();
		return (rm);
	}
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
import java.util.regex.*;
import java.text.DecimalFormat;

import com.sun.solaris.service.locality.*;
import com.sun.solaris.service.logging.*;
import com.sun.solaris.service.pools.*;
import com.sun.solaris.service.exception.*;

/**
 * The <code>SystemSolver</code> class implements a dynamic resource
 * allocation solver. The Solver takes a configuration and "solves"
 * the resource allocation problem.
 *
 * This class operates upon a configuration which is suppplied during
 * initialization. Its responsibilities include:
 * <ul>
 * <li><p>
 * Maintaining decision history
 * <li><p>
 * Maintaining information about the locality domain
 * <li><p>
 * Maintaining a map of all elements and their associated set of objectives
 * <li><p>
 * Identifying objective expressions with a configuration
 * </ul>
 */
class SystemSolver implements Solver {
	/**
	 * The default location of this history file.
	 */
	public static final String DH_FILE_DEF_PATH =
	    "/var/adm/pool/history";

	/**
	 * The property overriding the default decision history path.
	 */
	public static final String DH_FILE_PROP_NAME =
	    "system.poold.history-file";

	/**
	 * The LocalityDomain extracted from the configuration.
	 */
	private LocalityDomain ldom;

	/**
	 * The objective map used to link all elements with their set
	 * of objectives.
	 */
	private Map objMap;

	/**
	 * The pattern used to identify objective expressions.
	 */
	private static final Pattern p0 = Pattern.compile(";");

	/**
	 * The configuration for which this solver is "solving".
	 */
	private Configuration conf;

	/**
	 * Monitor providing statistics for this solver.
	 */
	private final Monitor monitor;

	/**
	 * The decision history maintainer.
	 */
	private DecisionHistory dh;

	/**
	 * The path to the decision history file.
	 */
	private String dhPath;

	/**
	 * The number of CPUs on the system.
	 */
	private int cpuCount;

	/**
	 * The number of locality triggered examinations made.
	 */
	private int examineCount;

	/**
	 * Constructs a solver which initialises a decision history
	 * maintainer.  The decision history is be used during operation
	 * to veto historically-poor decisions output from the objective
	 * function.
	 */
	SystemSolver(Monitor monitor)
	{
		/*
		 * Create a HashMap to store all objectives.
		 */
		objMap = new HashMap();
		this.monitor = monitor;
	}

	/**
	 * Initialize the solver for operation upon the supplied
	 * configuration. Possible objective expressions set upon
	 * target elements are identified and stored in an objective
	 * map which associates elements with the set of their
	 * objectives.
	 *
	 * @param conf The configuration to be manipulated.
	 * @throws PoolsException If the initialization fails.
	 */
	public void initialize(Configuration conf) throws PoolsException
	{
		String oString = null;
		String exps[];

		this.conf = conf;
		/*
		 * Count the CPUs in the system, this is used to
		 * control locality objective processing in the
		 * examine() method.
		 */
		cpuCount = conf.getComponents(null).size();
		examineCount = 0;
		/*
		 * Remove any old objectives
		 */
		objMap.clear();

		/*
		 * Extract any configuration objectives
		 */
		try {
			oString = conf.getStringProperty(
			    "system.poold.objectives");
			if (oString.length() > 0) {
				Set oSet = new HashSet();
				objMap.put(conf, oSet);
				Poold.CONF_LOG.log(Severity.DEBUG,
				    "adding configuration objective " +
				    oString);
				exps = p0.split(oString);
				for (int i = 0; i < exps.length; i++) {
					try {
						Expression exp =
						    Expression.valueOf(
						    exps[i]);
						addObjective(oSet, "system",
						    exp);
					} catch (IllegalArgumentException iae) {
						Poold.utility.warn(
						    Poold.CONF_LOG, iae, false);
					}
				}
			}
		} catch (PoolsException pe) {
			/*
			 * Ignore as this means there is no objective
			 * property
			 */
		}
		/*
		 * Now extract all pset objectives
		 */
		Value typeProp = new Value("type", "pset");
		List valueList = new LinkedList();
		valueList.add(typeProp);
		Iterator resIt = conf.getResources(valueList).iterator();
		typeProp.close();
		while (resIt.hasNext()) {
			Resource resource = (Resource)resIt.next();

			try {
				oString = resource.getStringProperty(
				    "pset.poold.objectives");
				if (oString.length() > 0) {
					Set oSet = new HashSet();
					objMap.put(resource, oSet);
					Poold.CONF_LOG.log(Severity.DEBUG,
					    "adding " +
					    resource.getStringProperty(
					    "pset.name") +
					    " objective \"" + oString + "\"");
					exps = p0.split(oString);
					for (int i = 0; i < exps.length; i++) {
						Expression exp = null;
						try {
							exp = Expression.
							    valueOf(exps[i]);
							addObjective(oSet,
							    "pset", exp);
						} catch
						    (IllegalArgumentException e)
						{
							Poold.utility.warn(
							    Poold.CONF_LOG, e,
							    false);
						}
					}
				}
			} catch (PoolsException pe) {
				continue;
			}
		}
		Poold.CONF_LOG.log(Severity.DEBUG, "objective map: " +
		    objMap.toString());

		/*
		 * Capture the LocalityDomain details.
		 */
		if (ldom != null) {
			ldom.close();
		}
		try {
			ldom = new LocalityDomain(LocalityDomain.LGRP_VIEW_OS);
		} catch (Exception e) {
			Poold.utility.die(Poold.OPT_LOG, e);
		}

		/*
		 * Load or create the decision history.
		 */
		String newDhPath;
		try {
			newDhPath = conf.getStringProperty(
			    DH_FILE_PROP_NAME);
		} catch (PoolsException pe) {
			newDhPath = DH_FILE_DEF_PATH;
		}

		if (!newDhPath.equals(dhPath)) {
			try {
				dh = DecisionHistory.loadFromFile(newDhPath);
				Poold.CONF_LOG.log(Severity.DEBUG,
				    "loaded history file " + newDhPath);
			} catch (Exception e) {
				if (!(e instanceof FileNotFoundException)) {
					Poold.CONF_LOG.log(Severity.WARNING,
					    newDhPath +
					    ": contents unusable; ignoring");
					Poold.CONF_LOG.log(Severity.DEBUG,
					    newDhPath + ": contents unusable",
					    e);
				}
				/*
				 * Use current DecisionHistory instead,
				 * if any.
				 */
				if (dh == null)
					dh = new DecisionHistory();
			}

			/*
			 * Try using the new path.
			 */
			try {
				dh.syncToFile(newDhPath);
			} catch (Exception e) {
				Poold.utility.die(Poold.CONF_LOG,
				    new PooldException(newDhPath +
				    ": couldn't synchronize history file")
				    .initCause(e), false);
			}
			dhPath = newDhPath;
		}
	}

	/**
	 * Determine if the given resource has non-workload-dependent
	 * objectives.
	 * @param elem The element to examine.
	 */
	private boolean hasNonWorkloadDependentObjectives(Element elem)
	{
		Set elemObj = (Set)objMap.get(elem);

		/*
		 * This code relies upon the fact that an element with
		 * no objectives will not have an empty set, but rather
		 * no value in the objMap.
		 */

		if (elemObj == null)
			return (false);

		Iterator elemObjIt = elemObj.iterator();
		while (elemObjIt.hasNext())
			if (elemObjIt.next() instanceof
			    WorkloadDependentObjective)
				return (false);

		return (true);
	}

	/**
	 * Determine if the given resource has workload-dependent
	 * objectives.
	 * @param elem The element to examine.
	 */
	private boolean hasWorkloadDependentObjectives(Element elem)
	{
		Set elemObj = (Set)objMap.get(elem);

		/*
		 * This code relies upon the fact that an element with
		 * no objectives will not have an empty set, but rather
		 * no value in the objMap.
		 */

		if (elemObj == null)
			return (false);

		Iterator elemObjIt = elemObj.iterator();
		while (elemObjIt.hasNext())
			if (elemObjIt.next() instanceof
			    WorkloadDependentObjective)
				return (true);

		return (false);
	}

	/**
	 * Return true if the monitored configuration should be
	 * reconfigured. All workload-dependent objectives are
	 * examined to determine if the configuration is still
	 * satisfying all specified objectives on all elements. If any
	 * objectives are failing, then this method will return true.
	 *
	 * @param mon The monitoring object used to assess objective
	 * compliance.
	 */
	public boolean examine(Monitor mon) throws PoolsException,
	    StaleMonitorException
	{
		/*
		 * Take advantage of the guaranteed-valid monitor data
		 * for measuring the improvement of any past decisions.
		 */
		dh.expireAndMeasureImprovements(mon);

		Iterator objIt = objMap.keySet().iterator();
		boolean ret = false;
		boolean hasLocalityObjectives = false;
		boolean isMonitorValid = true;

		/*
		 * All objectives are examined, even though failure
		 * could be detected earlier. This is because logging
		 * of all objectives is required and the information
		 * about failure can be stored and used during
		 * solving.
		 */
		while (objIt.hasNext()) {
			Element elem = (Element) objIt.next();
			Set elemObj = (Set) objMap.get(elem);
			Iterator elemObjIt = elemObj.iterator();
			while (elemObjIt.hasNext()) {
				Objective obj = (Objective) elemObjIt.next();
				Poold.OPT_LOG.log(Severity.DEBUG,
				    "checking objective " + obj);
				if (obj instanceof WorkloadDependentObjective) {
					if (isValid()) {
						/*
						 * If any objectives
						 * are violated, then
						 * we must
						 * reconfigure, so
						 * check them all in
						 * turn.
						 */
					ret = ((WorkloadDependentObjective)
					    obj).examine(conf, this, elem) ||
					    ret;
					} else
						isMonitorValid = false;
				}
			}

			/*
			 * Check if this is the first element, seen in
			 * this pass, that has locality objectives.
			 */
			if (!hasLocalityObjectives &&
			    hasNonWorkloadDependentObjectives(elem))
				hasLocalityObjectives = true;
		}
		if (isMonitorValid == false) {
			Poold.MON_LOG.log(Severity.INFO,
			    "not evaluating workload-dependent objectives " +
			    "until sufficient statistics are collected");
		}
		/*
		 * If we don't have locality objectives, we don't force
		 * the reexamination.  This is controlled by
		 * hasLocalityObjectives.
		 *
		 * So that we don't continually trigger
		 * reconfiguration examinations for locality
		 * objectives we stop forcing recalculations when we
		 * reach cpuCount / 2. This should be enough moves to
		 * get good locality for those configurations which
		 * have no WorkloadDependentObjectives.
		 */
		return (ret || (hasLocalityObjectives && (examineCount++ <
		    cpuCount / 2)));
	}

	/**
	 * Reallocate resources in a configuration to achieve user
	 * specified objectives. Return true if the configuration has
	 * been updated, false otherwise.
	 *
	 * This method should only be invoked if a previous
	 * examination of the configuration which is monitored
	 * indicates that objectives are failing. The monitored
	 * configuration is re-opened for editing, locking that
	 * configuration for the duration of this operation.
	 *
	 * @throws Exception If the solve fails.
	 */
	public boolean solve() throws Exception
	{
		boolean madeMove = false;
		/*
		 * All solving operations must be done in an
		 * "editable" context, so create a new modifiable
		 * configuration which is at the same location as the
		 * monitored configuration
		 */
		Configuration rwConf = new Configuration(conf.getLocation(),
		    PoolInternal.PO_RDWR);

		try {
			/*
			 * Build a resource set importance map for use
			 * when propagating pool importance to each
			 * possible solution. Use the same logic as
			 * libpool and let a resource take the highest
			 * importance value from all pools associated
			 * with the set.
			 */
			Map resImp = new HashMap();
			List poolList = rwConf.getPools(null);
			Iterator itPool = poolList.iterator();
			while (itPool.hasNext()) {
				Pool pool = (Pool) itPool.next();
				long newImp = pool.
				    getLongProperty("pool.importance");
				List resList = pool.getResources(null);
				Iterator itRes = resList.iterator();
				while (itRes.hasNext()) {
					Resource res = (Resource) itRes.next();
					if (resImp.containsKey(res)) {
						Long imp = (Long) resImp.
						    get(res);
						if (newImp > imp.longValue())
							resImp.put(res,
							    Long.valueOf(
							    newImp));
					} else
						resImp.put(res,
						    Long.valueOf(newImp));
				}
			}
			/*
			 * Consider all possible alternative
			 * configurations.  This list is generated as a
			 * series of moves.  Administrative constraints
			 * are applied to the moves to prune the list of
			 * possible configurations.
			 */
			Value val = new Value("type", "pset");
			List valueList = new LinkedList();
			valueList.add(val);


			List resList = rwConf.getResources(valueList);
			val.close();
			List donors = getDonors(resList);
			List receivers = getRecipients(resList);
			Poold.OPT_LOG.log(Severity.DEBUG, "donors: " +
			    donors);
			Poold.OPT_LOG.log(Severity.DEBUG, "receivers: " +
			    receivers);
			Iterator itDonor = donors.iterator();
			List moves = new ArrayList();
			while (itDonor.hasNext()) {
				Resource donor = (Resource) itDonor.next();
				List processors = getProcessors(donor);
				Poold.OPT_LOG.log(Severity.DEBUG,
				    "donor processors: " + processors);
				Iterator itProcessor = processors.iterator();
				while (itProcessor.hasNext()) {
					Component cpu = (Component) itProcessor.
					    next();
					Iterator itReceiver = receivers.
					    iterator();
					while (itReceiver.hasNext()) {
						Resource receiver =
						    (Resource) itReceiver.
						    next();
						/*
						 * Can't move to yourself
						 */
						if (receiver == donor)
							continue;
						moves.add(new ComponentMove(
						      donor, receiver, cpu));
					}
				}
			}
			Poold.OPT_LOG.log(Severity.DEBUG,
			    "potential moves: " + moves);
			/*
			 * Now that we have our alternative configurations,
			 * score each configuration by applying all objectives
			 * to each configuration. Hold the scores in the
			 * score set.
			 */
			HashSet scores = new HashSet();
			Iterator itMoves = moves.iterator();
			while (itMoves.hasNext()) {
				double totalContrib = 0;
				Move move = (Move) itMoves.next();
				Iterator objIt = objMap.keySet().iterator();
				while (objIt.hasNext()) {
					Element elem = (Element) objIt.next();
					Set elemObj = (Set) objMap.get(elem);
					Iterator elemObjIt = elemObj.iterator();
					while (elemObjIt.hasNext()) {
						Objective obj =
						    (Objective)elemObjIt.next();
						if (obj instanceof
						    LocalityObjective)
							((LocalityObjective)obj)
							    .prepare(ldom,
							    (Resource)elem);
						/*
						 * If the monitor is
						 * invalid, do not
						 * process
						 * WorkloadDependentObjectives
						 * since they have an
						 * implicit dependency
						 * on the monitor
						 * data.
						 */
						if (obj instanceof
						    WorkloadDependentObjective)
							if (!isValid())
								continue;
						double contrib = obj.calculate(
						    rwConf, move, elem);
						if (contrib < -1 || contrib > 1)
							throw new
							IllegalOFValueException(
						        "x: " + contrib +
							" is invalid, legal " +
							"range is -1 <= x <= " +
							"1");
						/*
						 * Modify the basic
						 * score by the
						 * importance of the
						 * objective and (if
						 * appropriate) the
						 * importance of an
						 * associated pool.
						 */
						if (resImp.containsKey(elem)) {
							contrib *= ((Long)
							    resImp.get(elem)).
							    longValue();
						}

						totalContrib += contrib *
						    obj.getExpression().
						    getImportance();
					}
				}
				Poold.OPT_LOG.log(Severity.DEBUG,
				    "scored move (" + move + ") " +
				    totalContrib);
				scores.add(new ScoreMove(move, totalContrib));
			}
			if (scores.size() != 0) {
				/*
				 * Try to find a move to apply which
				 * yields a positive contribution.
				 */
				Object scoresArray[] = scores.toArray();
				Arrays.sort(scoresArray,
				    Collections.reverseOrder());
				if ((madeMove = processMoves(rwConf,
				    scoresArray, false)) == false)
					madeMove = processMoves(rwConf,
					    scoresArray, true);
			} else
				Poold.OPT_LOG.log(Severity.INFO,
				    "no moves found");
			rwConf.close();
			Poold.OPT_LOG.log(Severity.DEBUG,
			    "synchronizing decision history");
			dh.syncToFile(dhPath);
		} catch (Exception ex) {
			rwConf.close();
			throw ex;
		}
		return (madeMove);
	}

	/*
	 * Process the supplied array of scored moves, trying to find
	 * a move to apply. Return true if a move could be applied,
	 * false otherwise.
	 *
	 * @param conf The configuration to be modified.
	 * @param scores The areay of scored moves to be tried.
	 * @param ignoreDH Ignore Decision History details.
	 */
	private boolean processMoves(Configuration rwConf, Object scores[],
	    boolean ignoreDH) throws PoolsException, StaleMonitorException
	{
		boolean madeMove = false;

		for (int i = 0; i < scores.length; i++) {
			ScoreMove move = (ScoreMove) scores[i];
			if (move.getScore() <= 0) {
				if (ignoreDH)
					Poold.OPT_LOG.log(Severity.INFO,
					    move + " not applied as " +
					    "benefit not significant");
				break;
			}
			if ((madeMove = applyMove(rwConf, move, ignoreDH)) ==
			    true)
				break;
		}
		return (madeMove);
	}

	/*
	 * Attempt to apply the supplied move to the
	 * configuration. Return true if the move could be applied,
	 * false otherwise.
	 *
	 * @param conf The configuration to be modified.
	 * @param move The move to be applied.
	 * @param ignoreDH Ignore Decision History details.
	 */
	private boolean applyMove(Configuration conf, ScoreMove move,
	    boolean ignoreDH)
	    throws PoolsException, StaleMonitorException
	{
		boolean madeMove = false;
		boolean wdpInvolved = false;
		double utilization = 0.0;

		Poold.OPT_LOG.log(Severity.DEBUG, "selected " + move);
		if (hasWorkloadDependentObjectives(move.getMove().getTo()) ||
		    hasWorkloadDependentObjectives(conf)) {
			Poold.OPT_LOG.log(Severity.DEBUG,
			    "Attempting to retrieve utilization for:" + move
			    .getMove().getTo());
			utilization = monitor.getUtilization(move
			    .getMove().getTo());
			wdpInvolved = true;
		}

		/*
		 * Unless a move can be vetoed (i.e. decision history
		 * is effective and there are is a workload-dependent
		 * involved), the move should alwways be applied.
		 */
		if (ignoreDH || !wdpInvolved || !dh.veto(move.getMove(),
		    utilization)) {
			Poold.OPT_LOG.log(Severity.INFO,
			    "applying move " + move.getMove());
			move.getMove().apply();
			ResourceMonitor mon = getMonitor().get(move.getMove().
			    getFrom());
			mon.resetData("utilization");
			mon = getMonitor().get(move.getMove().getTo());
			mon.resetData("utilization");
			try {
				Poold.OPT_LOG.log(Severity.DEBUG,
				    "committing configuration");
				conf.commit(0);
				try {
					if (move.getMove() instanceof
					    ComponentMove)
						if (wdpInvolved)
							dh.recordProcessorMove(
							    (ComponentMove)move
							    .getMove(),
							    utilization,
							    monitor
							    .getSampleCount());
						else
							Poold.OPT_LOG.log(
							    Severity.DEBUG,
							    "decision not " +
							    "recorded due to " +
							    "lack of workload-"
							    + "dependent " +
							    "objectives");
				} catch (Exception e) {
					Poold.OPT_LOG.log(Severity.INFO,
					    "couldn't update " +
					    "decision history (" +
					    e.toString() + ")");
				}
				madeMove = true;
			} catch (PoolsException pe) {
				conf.rollback();
				Poold.OPT_LOG.log(Severity.INFO,
				    "move failed, possibly due to a " +
				    "bound process in a 1-processor " +
				    "set");
			}
		} else {
			/*
			 * Move was vetoed.
			 */
			if (!ignoreDH && wdpInvolved)
				Poold.OPT_LOG.log(Severity.INFO,
				    move.getMove() + " not applied due to " +
				    "poor past results");
		}
		return (madeMove);
	}

	/**
	 * Add an objective based on the supplied expression to the
	 * supplied set of objectives.
	 *
	 * @param oSet Set of objectives to be extended
	 * @param type Type of element to which the expression is applied
	 * @param exp Expression to be used in the objective
	 * @throws IllegalArgumentException If a duplicate objective
	 * is identified or an invalid expression is supplied for this
	 * type of element
	 */
	private void addObjective(Set oSet, String type, Expression exp)
	    throws IllegalArgumentException
	{
		Objective o = AbstractObjective.getInstance(type, exp);
		Poold.CONF_LOG.log(Severity.DEBUG, "parsed objective " + o);
		/*
		 * Check the set of objectives and find contradictions.
		 */
		Iterator itObjs = oSet.iterator();
		while (itObjs.hasNext()) {
			Objective other = (Objective) itObjs.next();
			if (o.getExpression().contradicts(
			    other.getExpression()))
				throw new IllegalArgumentException(
				    "contradictory objectives:" + other +
				    ", " + o);
		}

		if (oSet.add(o) != true)
			throw new IllegalArgumentException(
			    "duplicate objective:" + o);
	}

	/**
	 * Return a list of resource sets prepared to receive
	 * resources
	 *
	 * The list consists of all resource setss (of the supplied
	 * type) whose size is < their max constraint.
	 *
	 * @param resList The list of all resource sets from which
	 * recipients will be chosen
	 * @throws PoolsException if there is an error manipulation
	 * the pool resources
	 */
	private List getRecipients(List resList) throws PoolsException
	{
		List recipientList = new ArrayList();
		long size, max;
		for (int i = 0; i < resList.size(); i++) {
			Resource res;
			res = (Resource)resList.get(i);
			String type = res.getStringProperty("type");
			size = res.getLongProperty(type+".size");
			max = res.getLongProperty(type+".max");
			if (size < max)
				recipientList.add(res);
		}
		return (recipientList);
	}

	/**
	 * Return a list of resource sets prepared to donate resources
	 *
	 * The list consists of all resource sets (of the supplied
	 * type) whose size (minus the number of pinned resources
	 * where applicable) is > their min constraint.
	 *
	 * @param resList The list of all resource sets from which
	 * recipients will be chosen
	 * @throws PoolsException if there is an error manipulation
	 * the pool resources
	 */
	private List getDonors(List resList) throws PoolsException
	{
		List donorList = new ArrayList();
		long size, min;
		for (int i = 0; i < resList.size(); i++) {
			Value bValue;
			Resource res;
			List pinned;
			ArrayList valueList = new ArrayList();

			res = (Resource)resList.get(i);
			String type = res.getStringProperty("type");
			size = res.getLongProperty(type+".size");
			bValue = new Value("cpu.pinned", true);
			valueList.add(bValue);
			pinned = res.getComponents(valueList);
			bValue.close();
			min = res.getLongProperty(type+".min");
			if (pinned.size() > min)
				size -= pinned.size() - min;
			if (size > min)
				donorList.add(res);
		}
		return (donorList);
	}

	/**
	 * Return a list of Processors for the supplied resource.
	 *
	 * The list consists of all Processors (excluding the pinned
	 * Processors) in the set.
	 *
	 * @param set The resource for which Processors should be found
	 * @throws PoolsException if there is an error manipulation
	 * the pool resources
	 */
	private List getProcessors(Resource set) throws PoolsException
	{
		Iterator it = set.getComponents(null).iterator();
		List ret = new ArrayList();

		while (it.hasNext()) {
			Component cpu = (Component) it.next();
			try
			{
				if (cpu.getBoolProperty("cpu.pinned") == false)
					ret.add(cpu);
			} catch (PoolsException pe)
			{
				ret.add(cpu);
			}
		}
		return (ret);
	}

	/**
	 * Return true if the solver is capable of working with
	 * statistically valid data.
	 */
	public boolean isValid()
	{
		return (monitor.isValid());
	}

	/**
	 * Return the monitor used by this solver.
	 */
	public Monitor getMonitor()
	{
		return (monitor);
	}

	/**
	 * Return the set of objectives associated with the supplied
	 * element.
	 *
	 * @param elem Retrieve objectives for this element.
	 */
	public Set getObjectives(Element elem)
	{
		return ((Set)objMap.get(elem));
	}

	/**
	 * Holds details about the score of a proposed configuration
	 * move. Each move must be scored so that they can ranked in
	 * terms of increasing desirability
	 */
	static class ScoreMove implements Comparable {
		/**
		 * The move which is being scored.
		 */
		private final Move m;

		/**
		 * The score of the move.
		 */
		private final double score;

		/**
		 * Score formatter.
		 */
		private static final DecimalFormat scoreFormat =
		    new DecimalFormat("0.00");

		/**
		 * Constructor.
		 *
		 * @param m The move under consideration.
		 * @param score The score of the move.
		 */
		public ScoreMove(Move m, double score)
		{
			this.m = m;
			this.score = score;
		}

		public int compareTo(Object o)
		{
			ScoreMove other = (ScoreMove) o;

			return ((score < other.getScore()) ? -1 :
			    (score > other.getScore()) ? 1 : 0);
		}

		public String toString()
		{
			return ("move (" + m + ") score "
			    + scoreFormat.format(score));
		}

		/**
		 * Return the score.
		 */
		double getScore()
		{
			return (score);
		}

		/**
		 * Return the move.
		 */
		Move getMove()
		{
			return (m);
		}
	}
}
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

Provides classes for automated resource management in Solaris. 


<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2002/287/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation, please see:
<ul>
  <li><a href="http://taxman.eng/projects/dynamic-resource-pools/">Dynamic Resource Pools Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

</body>
</html>
#
# 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 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/service/exception/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold

SOURCE =	SuccinctStackTraceFormatter.java

all install: $(SOURCE:.java=.class)

# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *class

include $(SRC)/cmd/Makefile.targ
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* ident	"%Z%%M%	%I%	%E% SMI" */

package com.sun.solaris.service.exception;

import java.io.*;

/**
 * Formats a stack trace in a single line.  The format is meant to
 * convey the stack trace as a sequence of class names and line numbers,
 * with the topmost frame first, suitable for logging.  Beware, the
 * format may evolve.
 */
public class SuccinctStackTraceFormatter {
	/**
	 * Formats a Throwable and adds an optional description string.
	 * The string should be suitable to precede the top stack
	 * element, and include any punctuation that should
	 * differentiate it from the element.
	 */
	public static String formatWithDescription(Throwable t,
	    String description)
	{
		StringBuffer s = new StringBuffer();

		s.append("(");

		if (description != null)
			s.append(description);

		s.append(t.getClass().getName());
		s.append(", ");
		StackTraceElement[] trace = t.getStackTrace();
		for (int i = 0; i < trace.length; i++) {
			appendStackTraceElement(i > 0 ? trace[i - 1] : null,
			    trace[i], s);
			if (i != trace.length - 1)
				s.append(", ");
		}
		s.append(")");

		if (t.getCause() != null) {
			s.append(" caused by ");
			s.append(format(t.getCause()));
		}

		return (s.toString());
	}

	/**
	 * Formats a Throwable's stack trace.  The format is meant to be
	 * a single line of output, conveying the stack trace as a
	 * sequence of class names and line numbers, with the topmost
	 * frame first, suitable for logging.  If two adjacent stack
	 * trace elements share some portion of a class name, the
	 * bottommost element may have the common part replaced with an
	 * ampersand.
	 */
	public static String format(Throwable t)
	{
		return (formatWithDescription(t, null));
	}

	/**
	 * Formats a stack trace element as per <code>format()</code>.
	 */
	private static void appendStackTraceElement(StackTraceElement last,
	    StackTraceElement e, StringBuffer s)
	{
		/*
		 * This could grab more of a common class name.  (See
		 * SuccinctStackTraceFormatter.format())
		 */
		if (last == null || !last.getClassName().equals(
		    e.getClassName())) {
			s.append(e.getClassName());
			s.append(".");
		} else
			s.append("&.");

		s.append(e.getMethodName());
		if (e.getLineNumber() > 0) {
			s.append(":");
			s.append(e.getLineNumber());
		}
		if (e.isNativeMethod()) {
			s.append(":");
			s.append("native");
		}
	}

	public static void printStackTrace(Throwable t)
	{
		printStackTrace(t, System.err);
	}

	public static void printStackTrace(Throwable t, PrintStream out)
	{
		out.print(t);
		out.print(" at ");
		out.print(format(t));
	}

	public static final void main(String args[])
	{
		SuccinctStackTraceFormatter.printStackTrace(big());
	}

	public static final Throwable big() {
		return new Throwable().initCause(little());
	}

	public static final Throwable little() {
		return new Throwable();
	}

}
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

Provides service-related exceptions and classes for generating or
interpreting them.

<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2002/287/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation,
please see:
<ul>
  <li><a href="http://taxman.eng/projects/dynamic-resource-pools/">Dynamic Resource Pools Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

</body>
</html>
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.kstat;

import com.sun.solaris.service.pools.*;

/**
 * Wraps <code>libkstat(3lib)</code>.  See
 * <code>/usr/include/sys/kstat.h</code> for details.
 */
public final class Kstat {
	/**
	 * Pointer to native <code>kstat_ctl_t</code>.
	 */
	private long kctl;

	/**
	 * Pointer to native <code>kstat_t</code>.
	 */
	private long ksp;

	Kstat(long kctl, long ksp)
	{
		this.kctl = kctl;
		this.ksp = ksp;
	}

	/**
	 * Returns the kstat's <code>ks_snaptime</code> field.
	 */
	public native HRTime getSnapTime();

	/**
	 * Returns the kstat's <code>ks_crtime</code> field.
	 */
	public native HRTime getCreationTime();

	/**
	 * Returns the named value -- the value of the named kstat, or
	 * field in a raw kstat, as applicable, and available.  Returns
	 * <i>null</i> if no such named kstat or field is available.
	 *
	 * @throws KstatTypeNotSupportedException if the raw kstat is not
	 * understood.  (Presenstly, none are.)
	 */
	public native Object getValue(String name)
	    throws KstatTypeNotSupportedException;

	/**
	 * Invokes <code>kstat_read(3kstat)</code> for tho underlying kstat.
	 * Throws KstatException if the native function returns an error.
	 */
	public native void read() throws KstatReadException;
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.kstat;

/**
 * Indicates a that <code>kstat_chain_update(3KSTAT)</code> failed for the
 * given KstatCtl.
 */
public class KstatChainUpdateException extends KstatException {
	/**
	 * The offending KstatCtl.
	 */
	private KstatCtl kstatCtl;

	public KstatChainUpdateException(KstatCtl kctl)
	{
		this.kstatCtl = kstatCtl;
	}

	/**
	 * Returns the offending KstatCtl.
	 */
	public KstatCtl getKstatCtl()
	{
		return (kstatCtl);
	}
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.kstat;

/**
 * <code>kstat</code> controlling object.  Allows kstats to be looked up
 * so they can later be sampled.
 */
public final class KstatCtl
{
	static {
		System.loadLibrary("jkstat");
		KstatCtl.init();
	}

	/**
	 * Pointer to a <code>kstat_ctl_t</code>.
	 */
	private long kctl;

	/**
	 * Invokes <code>kstat_open(3KSTAT)</code>.  The returned object
	 * should be explicitly finalized when it's no longer needed.
	 */
	public KstatCtl()
	{
		kctl = open();
		assert(kctl != 0);
	}

	/**
	 * Calls <code>kstat_close(3KSTAT)</code>.
	 */
	public void finalize()
	{
		close(kctl);
		kctl = 0;
	}

	/**
	 * Invokes <code>kstat_open(3KSTAT)</code>.
	 */
	private native long open();

	/**
	 * Invokes <code>kstat_close(3KSTAT)</code>.
	 */
	private native int close(long kctl);

	/**
	 * Invokes <code>kstat_lookup(3KSTAT)</code> and returns a Kstat
	 * for any result, or null if none is found.
	 */
	public native Kstat lookup(String module, int instance, String name);

	/**
	 * Invokes <code>kstat_chain_update(3KSTAT)</code>.
	 *
	 * @throws KstatChainUpdateException if the native function
	 * returns -1.
	 */
	public native void chainUpdate() throws KstatChainUpdateException;

	/**
	 * Initialize cached class, method, and field IDs.
	 */
	private static native void init();
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.kstat;

/**
 * Abstract base class from which kstat-related exceptions are
 * descended.
 */
public abstract class KstatException extends Exception {
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.kstat;

/**
 * Indicates a that <code>kstat_read</code> failed for the given Kstat.
 */
public class KstatReadException extends KstatException {
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.kstat;

/**
 * Indicates a that <code>Kstat.getValue()</code> was invoked for a raw
 * kstat whose structure is not understood.
 */
public class KstatTypeNotSupportedException extends KstatException {
}
#
# 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 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/service/kstat/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold

SOURCE =	Kstat.java \
		KstatChainUpdateException.java \
		KstatCtl.java \
		KstatException.java \
		KstatReadException.java \
		KstatTypeNotSupportedException.java

all install: $(SOURCE:.java=.class)

# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *class

include $(SRC)/cmd/Makefile.targ
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

kstat(9S) interfaces.

<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2002/287/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation,
please see:
<ul>
  <li><a href="http://taxman.eng/projects/dynamic-resource-pools/">Dynamic Resource Pools Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

</body>
</html>
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 *
 */

package com.sun.solaris.service.locality;

import java.util.*;

import com.sun.solaris.service.pools.*;

/**
 * A representation of the Locality Groups for a single Solaris
 * instance.
 */
public class LocalityDomain
{
	/**
	 * Obtain a Locality Group snapshot based on the view
	 * available to the caller.
	 */
	public static final int LGRP_VIEW_CALLER = 0;

	/**
	 * Obtain a Locality Group snapshot based on the view
	 * of the Operating System.
	 */
	public static final int LGRP_VIEW_OS = 1;

        static
	{
                System.loadLibrary("jlgrp");
        }

	/**
	 * The view used to create this LocalityDomain.
	 */
	private int view;

	/**
	 * The cookie which represents the snapshot of locality
	 * information held by the lgrp library.
	 */
	private long cookie;

	/**
	 * The root LocalityGroup for the LocalityDomain
	 */
	private LocalityGroup root;

	/**
	 * Cached value of maxLatency.
	 */
	private final int maxLatency;

	/**
	 * String representation of often used property.
	 */
	private final static String CPU_SYS_ID = "cpu.sys_id";

	/**
	 * Constructor.
	 *
	 * @param view to use when creating the LocalityDomain.
         * @throws Exception if there is a problem initializing the
         * lgrp snapshot.
	 */
	public LocalityDomain(int view) throws Exception
	{
		this.view = view;
		cookie = jl_init(view);
		root = jl_root();
		/*
		 * The maxLatency calculation is expensive and is used
		 * every time a locality objective is examined. Since
		 * it will never change over the lifetime of a
		 * LocalityDomain, we calculate it once in the
		 * constructor and cache for future use.
		 */
		maxLatency = calcMaxLatency();
	}

        /**
         * Reclaim the resource allocated by the C proxy.
         *
         * @throws Throwable if there is a problem reclaiming the reosurces.
         */
        protected void finalize() throws Throwable
        {
                try
                {
			close();
                }
                finally
                {
                        super.finalize();
                }
        }

	/**
	 * Return the "root" LocalityGroup.
	 */
	public LocalityGroup getRoot()
	{
		return (root);
	}

	/**
	 * Close this LocalityDomain. Resources are reclaimed in the C
	 * proxy and this LocalityDomain should never be used
	 * again. None of the LocalityGroups which are referenced from
	 * this LocalityDomain should be used after this method is
	 * invoked. NB: jl_fini returns a success indicator which is
	 * ignored as we are closing this domain.
	 */
	public void close()
	{
		if (cookie != 0) {
			jl_fini();
			cookie = 0;
			root = null;
		}
	}

	/**
	 * Return a string representation of this instance.
	 */
	public String toString()
	{
		return (root.toString());
	}

	/**
	 * Return the groups in this domain to which the supplied cpus
	 * belong, excluding the supplied set of groups.
	 *
	 * @param exclude Set of groups to be excluded.
	 * @param cpus List of cpus
	 *
	 * @throws PoolsException if there is an error accessing the
	 * cpu details.
	 */
	public Set foreignGroups(Set exclude, List cpus) throws PoolsException
	{
		Iterator cpuIt = cpus.iterator();
		Set result = new HashSet();
		while (cpuIt.hasNext()) {
			Component comp = (Component) cpuIt.next();
			int id = (int) comp.getLongProperty(CPU_SYS_ID);
			LocalityGroup group = getGroup(id);
			if (group != null && exclude.contains(group) == false)
				result.add(group);
		}
		return (result);
	}

	/**
	 * Return the locality group which contains the majority of
	 * the cpus in the supplied list. If more than one group
	 * satisfies this criteria, then the choice of group is
	 * deterministic but unspecified.
	 *
	 * @param cpus List of cpus to be examined.
	 *
	 * @throws PoolsException if there is an error accessing the
	 * cpu details.
	 */
	public LocalityGroup getRepresentativeGroup(List cpus)
	    throws PoolsException
	{
		Iterator cpuIt = cpus.iterator();
		Map grps = new HashMap();
		while (cpuIt.hasNext()) {
			Component comp = (Component) cpuIt.next();
			int id = (int) comp.getLongProperty(CPU_SYS_ID);
			LocalityGroup group = getGroup(id);
			Integer score = (Integer) grps.get(group);
			if (score != null) {
				int iscore = score.intValue() + 1;
				grps.put(group, Integer.valueOf(iscore));
			} else {
				grps.put(group, Integer.valueOf(1));
			}
		}
		Iterator groupIt = grps.keySet().iterator();
		LocalityGroup centre = null;
		Integer highest = Integer.valueOf(0);
		while (groupIt.hasNext()) {
			LocalityGroup cand = (LocalityGroup) groupIt.next();
			Integer value = (Integer) grps.get(cand);
			if (value.intValue() > highest.intValue()) {
				highest = value;
				centre = cand;
			}
		}
		return (centre);
	}

	/**
	 * Return the maximum latency between the groups in this
	 * domain.
	 *
	 */
	private int calcMaxLatency()
	{
		int max = 0;

		Set groups = getGroups();
		Iterator outer = groups.iterator();
		while (outer.hasNext()) {
			Iterator inner = groups.iterator();
			LocalityGroup g1 = (LocalityGroup) outer.next();
			while (inner.hasNext()) {
				LocalityGroup g2 = (LocalityGroup) inner.next();
				int latency = g1.getLatency(g2);
				if (latency > max)
					max = latency;
			}
		}
		return (max);
	}

	/**
	 * Return the maximum possible latency between all locality
	 * groups in this domain.
	 */
	public int getMaxLatency()
	{
		return (maxLatency);
	}

	/**
	 * Return the set of all LocalityGroups for this LocalityDomain.
	 */
	public Set getGroups()
	{
		Set groups = new HashSet();
		groups.add(root);
		getGroups(root, groups);
		return (groups);
	}

	/**
	 * Add all the descendent LocalityGroups for the supplied
	 * group into the supplied set.
	 *
	 * @param group is the group whose descendents are processed.
	 * @param descendents the set to add descendents of group.
	 */
	private void getGroups(LocalityGroup group, Set descendents)
	{
		Set children = group.getChildren();

		if (! children.isEmpty()) {
			Iterator itChild = children.iterator();
			while (itChild.hasNext()) {
				LocalityGroup child = (LocalityGroup) itChild.
				    next();
				getGroups(child, descendents);
			}
			descendents.addAll(children);
		}
	}

	/**
	 * Return the LocalityGroup containing the supplied CPU
	 * id. Search all LocalityGroups starting at the root group.
	 *
	 * @param cpuid is the sys-id of the CPU to search for.
	 */
	public LocalityGroup getGroup(int cpuid)
	{
		LocalityGroup answer = getGroup(root, cpuid);
		return (getGroup(root, cpuid));
	}

	/**
	 * Return the LocalityGroup containing the supplied CPU
	 * id. Search LocalityGroups starting at the supplied group.
	 *
	 * @param group is the group to start searching from.
	 * @param cpuid is the sys-id of the CPU to search for.
	 */
	private LocalityGroup getGroup(LocalityGroup group, int cpuid)
	{
		Set children = group.getChildren();

		if (children.isEmpty()) {
			int cpus[] = group.getCPUIDs();


			for (int i = 0; i < cpus.length; i++)
				if (cpus[i] == cpuid) {
					return (group);
				}
		} else {
			Iterator itGroup = children.iterator();
			while (itGroup.hasNext()) {
				LocalityGroup owner;
				LocalityGroup child = (LocalityGroup) itGroup.
				    next();
				if ((owner = getGroup(child, cpuid)) != null)
					return (owner);
			}
		}
		return (null);
	}

	/**
	 * Initialise the LocalityDomain with an lgrp snapshot.
	 *
	 * @param view is the type of snapshot to obtain.
	 */
	private native long jl_init(int view) throws Exception;

	/**
	 * Release the lgrp snapshot.
	 */
	private native int jl_fini();

	/**
	 * Find the root LocalityGroup.
	 */
	private native LocalityGroup jl_root();

}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 *
 */

package com.sun.solaris.service.locality;

import java.util.*;

import com.sun.solaris.service.pools.*;

/**
 * A representation of an individual Locality Group. A Locality Group
 * resides within a Locality Domain.
 */
public class LocalityGroup
{
	/**
	 * The locality domain which contains this group.
	 */
	private LocalityDomain domain;

	/**
	 * The C proxy id for this instance.
	 */
	private long id;

	/**
	 * The parent group of this instance.
	 */
	private LocalityGroup parent;

	/**
	 * The array of CPU IDs which are assigned to this instance.
	 */
	private int cpu_ids[];

	/**
	 * The child groups of this instance.
	 */
	private Set children;

	/**
	 * Constructor.
	 *
	 * @param domain is the domain to which this instance belongs.
	 * @param id is the id of this instance.
	 * @param parent is the parent of this instance.
	 */
	public LocalityGroup(LocalityDomain domain, long id,
	    LocalityGroup parent)
	{
		this.domain = domain;
		this.id = id;
		this.parent = parent;
		this.cpu_ids = jl_cpus();
		long nativeChildren[] = jl_children();
		children = new HashSet();
		for (int i = 0; i < nativeChildren.length; i++)
			children.add(new LocalityGroup(domain,
				     nativeChildren[i], this));
	}

	/**
	 * Return a string representation of this instance.
	 */
	public String toString()
	{
		StringBuffer sb = new StringBuffer().append("locality group ")
		    .append(id)
		    .append(" with cpus [");

		String sep = "";
		for (int i = 0; i < cpu_ids.length; i++) {
			sb.append(sep);
			sb.append(cpu_ids[i]);
			sep = " ";
		}
		sb.append("]");

		return (sb.toString());
	}

	/**
	 * Return the set of child locality groups for this instance.
	 */
	public Set getChildren()
	{
		return (children);
	}

	/**
	 * Return the array of CPU IDs which belong to this locality
	 * group.
	 */
	public int[] getCPUIDs()
	{
		return (cpu_ids);
	}

	/**
	 * Return the locality group ID.
	 */
	long getID()
	{
		return (id);
	}

	/**
	 * Return the latency of the supplied group with respect to
	 * this group.
	 *
	 * @param other is another locality group belonging to the
	 * same LocalityDomain.
	 */
	public int getLatency(LocalityGroup other)
	{
		return (jl_latency(id, other.getID()));
	}

	/**
	 * Return the number of Latency Groups to which these cpus
	 * belong which are not part of this group.
	 *
	 * @param cpus List of cpus to be examined.
	 *
	 * @throws PoolsException if there is an error accessing the
	 * cpu details.
	 */
	public int countForeignGroups(List cpus) throws PoolsException
	{
		Set groups = new HashSet();
		Iterator cpuIt = cpus.iterator();

		while (cpuIt.hasNext()) {
			Component comp = (Component) cpuIt.next();
			int id = (int) comp.getLongProperty("cpu.sys_id");
			for (int i = 0; i < cpu_ids.length; i++) {
				if (cpu_ids[i] == id) {
					LocalityGroup other = domain.
					    getGroup(id);
					if (other != this &&
					    groups.contains(other) == false)
						groups.add(other);
				}
			}
		}
		return (groups.size());
	}

	public Set contains(List cpus) throws PoolsException
	{
		Set contained = new HashSet();
		Iterator cpuIt = cpus.iterator();
		int set_cpus[] = getCPUIDs();

		while (cpuIt.hasNext()) {
			Component comp = (Component) cpuIt.next();
			for (int i = 0; i < set_cpus.length; i++) {
				if (set_cpus[i] == (int)comp.getLongProperty(
					"cpu.sys_id")) {
					contained.add(comp);
					break;
				}
			}
		}
		return (contained);
	}

	/**
	 * Return an array containing the child locality group IDs.
	 */
	private native long[] jl_children();

	/**
	 * Return an array of CPU IDs within this locality group.
	 */
	private native int[] jl_cpus();

	/**
	 * Return the latency between the two supplied lgrp IDs.
	 *
	 * @param id1 is the first id.
	 * @param id2 is the second id.
	 */
	private native int jl_latency(long id1, long id2);
}
#
# 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 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/service/locality/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold

SOURCE =	LocalityDomain.java \
		LocalityGroup.java

all install: $(SOURCE:.java=.class)


# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *class

include $(SRC)/cmd/Makefile.targ
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

Provides classes for manipulating Solaris Locality Groups. 


<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2003/034/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation, please see:
<ul>
  <li><a href="http://lgrp.eng/">Memory Hierarchy Aware Solaris Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

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

/* ident	"%Z%%M%	%I%	%E% SMI" */

package com.sun.solaris.service.logging;

/**
 * <code>syslog(3C)</code> facility levels defined in
 * <code>sys/syslog.h</code>.
 */
public class Facility {
	/**
	 * LOG_KERN from <code>sys/syslog.h</code>
	 */
	private static final int LOG_KERN = 0 << 3;

	/**
	 * LOG_USER from <code>sys/syslog.h</code>
	 */
	private static final int LOG_USER = 1 << 3;

	/**
	 * LOG_MAIL from <code>sys/syslog.h</code>
	 */
	private static final int LOG_MAIL = 2 << 3;

	/**
	 * LOG_DAEMON from <code>sys/syslog.h</code>
	 */
	private static final int LOG_DAEMON = 3 << 3;

	/**
	 * LOG_AUTH from <code>sys/syslog.h</code>
	 */
	private static final int LOG_AUTH = 4 << 3;

	/**
	 * LOG_SYSLOG from <code>sys/syslog.h</code>
	 */
	private static final int LOG_SYSLOG = 5 << 3;

	/**
	 * LOG_LPR from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LPR = 6 << 3;

	/**
	 * LOG_NEWS from <code>sys/syslog.h</code>
	 */
	private static final int LOG_NEWS = 7 << 3;

	/**
	 * LOG_UUCP from <code>sys/syslog.h</code>
	 */
	private static final int LOG_UUCP = 8 << 3;

	/**
	 * LOG_CRON from <code>sys/syslog.h</code>
	 */
	private static final int LOG_CRON = 15 << 3;

	/**
	 * LOG_LOCAL0 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL0 = 16 << 3;

	/**
	 * LOG_LOCAL1 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL1 = 17 << 3;

	/**
	 * LOG_LOCAL2 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL2 = 18 << 3;

	/**
	 * LOG_LOCAL3 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL3 = 19 << 3;

	/**
	 * LOG_LOCAL4 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL4 = 20 << 3;

	/**
	 * LOG_LOCAL5 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL5 = 21 << 3;

	/**
	 * LOG_LOCAL6 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL6 = 22 << 3;

	/**
	 * LOG_LOCAL7 from <code>sys/syslog.h</code>
	 */
	private static final int LOG_LOCAL7 = 23 << 3;

	/**
	 * LOG_KERN <code>syslog(3C)</code> facility
	 */
	public static final Facility KERN = new Facility(LOG_KERN, "KERN");

	/**
	 * LOG_USER <code>syslog(3C)</code> facility
	 */
	public static final Facility USER = new Facility(LOG_USER, "USER");

	/**
	 * LOG_MAIL <code>syslog(3C)</code> facility
	 */
	public static final Facility MAIL = new Facility(LOG_MAIL, "MAIL");

	/**
	 * LOG_DAEMON <code>syslog(3C)</code> facility
	 */
	public static final Facility DAEMON = new Facility(LOG_DAEMON,
	    "DAEMON");

	/**
	 * LOG_AUTH <code>syslog(3C)</code> facility
	 */
	public static final Facility AUTH = new Facility(LOG_AUTH, "AUTH");

	/**
	 * LOG_SYSLOG <code>syslog(3C)</code> facility
	 */
	public static final Facility SYSLOG = new Facility(LOG_SYSLOG,
	    "SYSLOG");

	/**
	 * LOG_LPR <code>syslog(3C)</code> facility
	 */
	public static final Facility LPR = new Facility(LOG_LPR, "LPR");

	/**
	 * LOG_NEWS <code>syslog(3C)</code> facility
	 */
	public static final Facility NEWS = new Facility(LOG_NEWS, "NEWS");

	/**
	 * LOG_UUCP <code>syslog(3C)</code> facility
	 */
	public static final Facility UUCP = new Facility(LOG_UUCP, "UUCP");

	/**
	 * LOG_CRON <code>syslog(3C)</code> facility
	 */
	public static final Facility CRON = new Facility(LOG_CRON, "CRON");

	/**
	 * LOG_LOCAL0 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL0 = new Facility(LOG_LOCAL0,
	    "LOCAL0");

	/**
	 * LOG_LOCAL1 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL1 = new Facility(LOG_LOCAL1,
	    "LOCAL1");

	/**
	 * LOG_LOCAL2 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL2 = new Facility(LOG_LOCAL2,
	    "LOCAL2");

	/**
	 * LOG_LOCAL3 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL3 = new Facility(LOG_LOCAL3,
	    "LOCAL3");

	/**
	 * LOG_LOCAL4 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL4 = new Facility(LOG_LOCAL4,
	    "LOCAL4");

	/**
	 * LOG_LOCAL5 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL5 = new Facility(LOG_LOCAL5,
	    "LOCAL5");

	/**
	 * LOG_LOCAL6 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL6 = new Facility(LOG_LOCAL6,
	    "LOCAL6");

	/**
	 * LOG_LOCAL7 <code>syslog(3C)</code> facility
	 */
	public static final Facility LOCAL7 = new Facility(LOG_LOCAL7,
	    "LOCAL7");

	/**
	 * Native facility of this instance.
	 */
	private int facility;

	/**
	 * Name of this facility.
	 */
	private String string;

	private Facility(int facility, String string)
	{
		this.facility = facility;
		this.string = string;
	}

	/**
	 * Returns the native <code>syslog(3C)</code> facility.
	 */
	public int getNative()
	{
		return (facility);
	}

	public boolean equals(Object o)
	{
		Facility f = (Facility)o;

		return (getNative() == f.getNative());
	}

	public String toString()
	{
		return (string);
	}
}
#
# 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 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/service/logging/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold

SOURCE =	Facility.java \
		Severity.java \
		SyslogHandler.java \
		SysloglikeFormatter.java

all install: $(SOURCE:.java=.class)

# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *class

include $(SRC)/cmd/Makefile.targ
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* ident	"%Z%%M%	%I%	%E% SMI" */

package com.sun.solaris.service.logging;

import java.util.*;
import java.util.logging.*;

/**
 * <code>syslog(3C)</code> severity levels defined in
 * <code>sys/syslog.h</code>.
 */
public final class Severity extends Level {
	/**
	 * LOG_EMERG from <code>sys/syslog.h</code>
	 */
	private static final int LOG_EMERG = 0;

	/**
	 * LOG_ALERT from <code>sys/syslog.h</code>
	 */
	private static final int LOG_ALERT = 1;

	/**
	 * LOG_CRIT from <code>sys/syslog.h</code>
	 */
	private static final int LOG_CRIT = 2;

	/**
	 * LOG_ERR from <code>sys/syslog.h</code>
	 */
	private static final int LOG_ERR = 3;

	/**
	 * LOG_WARNING from <code>sys/syslog.h</code>
	 */
	private static final int LOG_WARNING = 4;

	/**
	 * LOG_NOTICE from <code>sys/syslog.h</code>
	 */
	private static final int LOG_NOTICE = 5;

	/**
	 * LOG_INFO from <code>sys/syslog.h</code>
	 */
	private static final int LOG_INFO = 6;

	/**
	 * LOG_DEBUG from <code>sys/syslog.h</code>
	 */
	private static final int LOG_DEBUG = 7;

	/**
	 * Maps static instances by name.
	 */
	private static final HashMap severityMap = new HashMap();

	/**
	 * LOG_EMERG
	 */
	public static final Severity EMERG = new Severity(LOG_EMERG,
	    Level.SEVERE.intValue() - 1, "EMERG");

	/**
	 * LOG_ALERT
	 */
	public static final Severity ALERT = new Severity(LOG_ALERT,
	    Level.SEVERE.intValue() - 2, "ALERT");

	/**
	 * LOG_CRIT
	 */
	public static final Severity CRIT = new Severity(LOG_CRIT,
	    Level.SEVERE.intValue() - 3, "CRIT");

	/**
	 * LOG_ERR
	 */
	public static final Severity ERR = new Severity(LOG_ERR,
	    Level.SEVERE.intValue() - 4, "ERR");

	/**
	 * LOG_WARNING
	 */
	public static final Severity WARNING = new Severity(LOG_WARNING,
	    Level.WARNING.intValue() - 1, "WARNING");

	/**
	 * LOG_NOTICE
	 */
	public static final Severity NOTICE = new Severity(LOG_NOTICE,
	    Level.INFO.intValue() - 1, "NOTICE");

	/**
	 * LOG_INFO
	 */
	public static final Severity INFO = new Severity(LOG_INFO,
	    Level.INFO.intValue() - 2, "INFO");

	/**
	 * LOG_DEBUG
	 */
	public static final Severity DEBUG = new Severity(LOG_DEBUG,
	    Level.FINE.intValue() - 1, "DEBUG");

	/**
	 * Add aliases.
	 */
	static {
		severityMap.put("WARN", Severity.WARNING);
		severityMap.put("ERROR", Severity.ERR);
	}

	/**
	 * Disallowed overidden constant Level
	 */
	private static final Level SEVERE = null;

	/**
	 * Disallowed overidden constant Level
	 */
	private static final Level CONFIG = null;

	/**
	 * Disallowed overidden constant Level
	 */
	private static final Level FINE = null;

	/**
	 * Disallowed overidden constant Level
	 */
	private static final Level FINER = null;

	/**
	 * Disallowed overidden constant Level
	 */
	private static final Level FINEST = null;

	/**
	 * See getNative().
	 */
	private int severity;

	/**
	 * Constructs a Severity with the given native severity, Java
	 * logging level, and name.
	 */
	private Severity(int severity, int level, String name)
	{
		super(name, level);
		this.severity = severity;

		Object displaced = severityMap.put(name, this);
		assert (displaced == null);
	}

	/**
	 * Returns the Severity closest in meaning to the given Level.
	 * This is meant to be used by SyslogHandler to determine a
	 * proper Severity for Records which only specify a Level.
	 *
	 * <ul>
	 * <li>Level.SEVERE or higher becomes Severity.ERR
	 * <li>Level.WARNING becomes Severity.WARNING
	 * <li>Level.INFO becomes Severity.INFO
	 * <li>Level.FINE becomes Severity.DEBUG
	 * </ul>
	 *
	 * If the level is below Level.FINE, i.e. the level is too low
	 * for syslog, then null is returned.
	 */
	public static Severity severityForLevel(Level l)
	{
		if (l instanceof Severity)
			return (Severity)l;
		else {
			if (l.intValue() >= Level.SEVERE.intValue())
				return (ERR);
			if (l.intValue() >= Level.WARNING.intValue())
				return (WARNING);
			if (l.intValue() >= Level.INFO.intValue())
				return (INFO);
			if (l.intValue() >= Level.CONFIG.intValue())
				return (INFO);
			if (l.intValue() >= Level.FINE.intValue())
				return (DEBUG);
			return (null);
		}
	}

	/**
	 * Returns the native <code>syslog(3C)</code> severity.
	 */
	public int getNative()
	{
		return (severity);
	}

	/**
	 * Returns the Severity object with the given name, interpreted
	 * case-insensitively.
	 *
	 * @throws IllegalArgumentException if the name isn't of a known
	 * severity.
	 */
	public static Level parse(String name)
	{
		Severity severity = (Severity)severityMap.get(
		    name.toUpperCase());

		if (severity == null)
			throw new IllegalArgumentException();
		else
			return (severity);
	}

	/**
	 * Returns the Severity object with the given name, interpreted
	 * case-insensitively.
	 *
	 * @throws IllegalArgumentException if the name isn't of a known
	 * severity.
	 */
	public static Severity getSeverityWithName(String name)
	{
		return ((Severity)parse(name));
	}
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* ident	"%Z%%M%	%I%	%E% SMI" */

package com.sun.solaris.service.logging;

import java.text.*;
import java.util.*;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.LogRecord;

import com.sun.solaris.service.exception.SuccinctStackTraceFormatter;

/**
 * This handler outputs LogRecords with <code>syslog(3C)</code> to the
 * given facility with a severity translated by Level with a fixed
 * table.  Formatters are not used.
 *
 * Multiple SyslogHandlers may not be in concurrent use in one virtual
 * machine.
 */
public final class SyslogHandler extends Handler {
	/**
	 * <code>syslog(3C)</code> ident string, prepended to every
	 * message.
	 */
	private String ident;

	/**
	 * <code>syslog</code> facility to be logged to.
	 */
	private Facility facility;

	/**
	 * Records the instance of this singleton.
	 */
	private static SyslogHandler instance = null;

	/**
	 * Flag whether stack traces should be output when a record's
	 * <code>thrown</code> field is set.  They will be formatted in
	 * a single line by <code>SuccinctStackTraceFormatter</code>,
	 * which does not include the Throwable's description, since
	 * it's presumably described by the log message).  Default
	 * <code>true</code>.
	 */
	private static boolean useStackTraces = true;

	/**
	 * Default logging option value.  Sets no options.  (Corresponds
	 * to the <code>logopt</code> argument to openlog(3c).)
	 */
	private static final int DEF_LOGOPT = 0;

	/**
	 * Flag to set whether log records should indicate the record's
	 * logger.  (default false)
	 */
	private boolean useLoggerName = false;

	/**
	 * Flag to set whether log records should indicate the last
	 * component of the record's logger name, if useLoggerName isn't
	 * set.  (default true)
	 */
	private boolean useShortLoggerName = true;

	static {
		System.loadLibrary("jsyslog");
	}

	private SyslogHandler(String ident, Facility facility)
	{
		if (ident == null || facility == null)
			throw new IllegalArgumentException();

		this.ident = ident;
		this.facility = facility;

		openlog(ident, DEF_LOGOPT, facility.getNative());
		instance = this;
	}

	/**
	 * Return this virtual machine's instance of SyslogHandler,
	 * creating one which logs with the given identity to the given
	 * facility if necessary, unless an instance with a different
	 * identity or facility is already open, in which case an
	 * IllegalArgumentException is thrown.
	 *
	 * @throws IllegalArgumentException if the requested identity or
	 * facility differs from a previously-created instance.
	 */
	public static SyslogHandler getInstance(String ident,
	   Facility facility)
	{
		if (instance != null) {
			if (!instance.ident.equals(ident) ||
			    !instance.facility.equals(facility))
				throw new IllegalArgumentException();
			else
				return (instance);
		} else
			return (instance = new SyslogHandler(ident, facility));
	}

	public void finalize()
	{
		try {
			close();
		} catch (Exception e) {
			// superclass-defined exceptions do not apply
		}
	}

	public String toString()
	{
		return ("SyslogHandler(" + ident + ", " + facility.toString() +
		    ")");
	}

	/**
	 * Calls <code>syslog(3C)</code>.
	 */
	private static native void syslog(int severity, String message);

	/**
	 * Calls <code>openlog(3C)</code>.
	 */
	private static native void openlog(String ident, int logopt,
	    int facility);

	/**
	 * Calls <code>closelog(3C)</code>.
	 */
	private static native void closelog();

	/**
	 * Publishes the given record with its associated Severity (or
	 * infers its severity with Severity.severityForLevel(), if
	 * another type of Level is used), if the result is non-null.
	 */
	public void publish(LogRecord record)
	{
		Severity severity;

		if (record.getLevel() instanceof Severity)
			severity = (Severity)record.getLevel();
		else
			severity = Severity.severityForLevel(record
			    .getLevel());

		if (getLevel().intValue() > severity.intValue())
			return;

		/*
		 * If the severity is null, the message isn't meant to
		 * be sent to syslog.
		 */
		if (severity == null)
			return;

		StringBuffer message = new StringBuffer();
		String loggerName = record.getLoggerName();
		if (useLoggerName) {
			if (loggerName != null) {
				message.append("(");
				message.append(record.getLoggerName());
				message.append(") ");
			}
		} else if (useShortLoggerName) {
			if (loggerName != null) {
				message.append("(");
				int lastDot = loggerName.lastIndexOf('.');
				if (lastDot >= 0)
					loggerName = loggerName.substring(
					    lastDot + 1);
				message.append(loggerName);
				message.append(") ");
			}
		}

		message.append(record.getMessage());

		/*
		 * If the Severity is null, it's not meant to be logged
		 * via syslog.
		 */
		if (record.getThrown() != null && useStackTraces == true) {
			/*
			 * Format the stack trace as one line and tack
			 * it onto the message.
			 */
			message.append(" ");
			message.append(SuccinctStackTraceFormatter
			    .formatWithDescription(record.getThrown(),
			    "with tracing information: ").toString());
		}
		syslog(severity.getNative(), message.toString());
	}

	public void flush()
	{
	}

	public void close() throws SecurityException
	{
		if (instance != null) {
			closelog();
			instance = null;
		}
	}

	/**
	 * Formatters may not be used with SyslogHandler.
	 *
	 * @throws IllegalArgumentException if the use of one is
	 * attempted.
	 */
	public void setFormatter(Formatter formatter)
	{
		throw new IllegalArgumentException();
	}

	/**
	 * Returns the <code>syslog(3C)</code> ident string, which is
	 * prepended to every message.
	 */
	public String getIdent()
	{
		return (ident);
	}

	/**
	 * Returns the <code>syslog</code> facility to be logged to.
	 */
	public Facility getFacility()
	{
		return (facility);
	}

}
/*
 * 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.
 */

/* ident	"%Z%%M%	%I%	%E% SMI" */

package com.sun.solaris.service.logging;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.*;
import java.util.*;
import java.util.logging.Formatter;
import java.util.logging.LogRecord;

import com.sun.solaris.service.exception.SuccinctStackTraceFormatter;

/**
 * Formats a LogRecord in a human-readable, <code>syslog</code>-like
 * format, and is intended for use with non-syslog handlers, such as
 * FileHandler.
 *
 * Multi-line messages are automatically indented by four spaces to make
 * subsequent lines easier to differentiate from new records.
 */
public class SysloglikeFormatter extends Formatter {
	/**
	 * The date set for each published Record.
	 */
	private Date date = new Date();

	/**
	 * Format string for published dates.
	 */
	private final static String dateFormat =
	    "MMM d kk:mm:ss";

	/**
	 * For published dates, the formatter.
	 */
	private DateFormat dateFormatter;

	/**
	 * For published dates, the argument to date formatter.
	 */
	private Object args[] = { date };

	/**
	 * Line separator string.
	 */
	private String lineSeparator =
		System.getProperty("line.separator");

	/**
	 * Flag to set whether log records should indicate the name of
	 * the class generating the record, if possible.  (default
	 * false)
	 */
	private boolean useClassName = false;

	/**
	 * Flag to set whether log records should indicate the record's
	 * logger, if useClassName isn't set and the class name was
	 * available.  (default false)
	 */
	private boolean useLoggerName = false;

	/**
	 * Flag to set whether log records should indicate the last
	 * component of the record's logger name, if useLoggerName isn't
	 * set.  (default true)
	 */
	private boolean useShortLoggerName = true;

	/**
	 * Flag to set whether log records should indicate the method
	 * used to invoke the logger, if available.  (default false)
	 */
	private boolean useMethodName = false;

	/**
	 * Flag to set whether each record should be split into two
	 * lines such that the severity and message are on a line by
	 * themselves.  (default false)
	 */
	private boolean useTwoLineStyle = false;

	/**
	 * Format the given LogRecord.
	 * @param record the log record to be formatted.
	 * @return a formatted log record.
	 */
	public synchronized String format(LogRecord record)
	{
		StringBuffer sb = new StringBuffer();

		date.setTime(record.getMillis());
		StringBuffer text = new StringBuffer();
		if (dateFormatter == null)
			dateFormatter = new SimpleDateFormat(dateFormat);
		sb.append(dateFormatter.format(date));

		if (record.getSourceClassName() != null && useClassName) {
			sb.append(" ");
			sb.append(record.getSourceClassName());
		} else if (useLoggerName) {
			if (record.getLoggerName() != null) {
				sb.append(" ");
				sb.append(record.getLoggerName());
			}
		} else if (useShortLoggerName) {
			String loggerName = record.getLoggerName();

			if (loggerName != null) {
				sb.append(" ");
				int lastDot = loggerName.lastIndexOf('.');
				if (lastDot >= 0)
					loggerName = loggerName.substring(
					    lastDot + 1);
				sb.append(loggerName);
			}
		}

		if (record.getSourceMethodName() != null && useMethodName) {
			sb.append(" ");
			sb.append(record.getSourceMethodName());
		}
		if (useTwoLineStyle)
			sb.append(lineSeparator);
		else
			sb.append(" ");

		String message = formatMessage(record);
		message = message.replaceAll("\n", lineSeparator + "    ");

		sb.append(record.getLevel()).toString();
		sb.append(": ");
		sb.append(message);
		if (record.getThrown() != null) {
			sb.append(" ");
			sb.append(SuccinctStackTraceFormatter
			    .formatWithDescription(record.getThrown(),
			    "with tracing information: ").toString());
		}
		sb.append(lineSeparator);

		return sb.toString();
	}
}
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

Extends the logging API for use with syslog(3C).

<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2002/287/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation,
please see:
<ul>
  <li><a href="http://taxman.eng/projects/dynamic-resource-pools/">Dynamic Resource Pools Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

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

package com.sun.solaris.service.pools;

/**
 * The <code>Component</code> class represents a configuration
 * resource component.
 */
public class Component extends Element
{
	/**
	 * The type of the component.
	 */
	private final String type;

	/**
	 * The system id of the component.
	 */
	private final long sys_id;

	/**
	 * The key of the component.
	 */
	private final String key;

	/**
	 * Constructor
	 *
	 * @param conf The configuration to which this component belongs
	 * @param comp The pointer to the native component
	 * @throws PoolsException If accessing the proxy fails.
	 */
	Component(Configuration conf, long comp) throws PoolsException
	{
		_conf = conf;
		Value val = getProperty("type", comp);
		type = val.getString();
		val.close();
		val = getProperty(type + ".sys_id", comp);
		sys_id = val.getLong();
		val.close();
		key = type + "." + sys_id;
	}

	/**
	 * Return the pointer to the component represented by this object.
	 *
	 * @return conf the pointer to the component represented by this object
	 * @throws PoolsException If the component cannot be located.
	 */
	long getComponent() throws PoolsException
	{
		return (_conf.checkComponent(type, sys_id));
	}

	/**
	 * Returns a descriptive string which describes the component.
	 *
	 * @param deep Whether the information should contain information about
	 * all contained elements.
	 * @throws PoolsException If the component cannot be located.
	 * @return a descriptive string which describes the component.
	 */
	public String getInformation(int deep) throws PoolsException
	{
		return (PoolInternal.pool_component_info(_conf.getConf(),
			getComponent(), deep));
	}

        /**
         * Returns a string representation of this component.
         *
         * @return  a string representation of this component.
         */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append(type);
		buf.append(" ");
		buf.append(sys_id);
		return (buf.toString());
	}

	/**
	 * Indicates whether some other Component is "equal to this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof Component))
			return (false);
		Component other = (Component) o;
		if (type.compareTo(other.getType()) != 0 ||
		    sys_id != other.getSysId())
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (type.hashCode() + (int) sys_id);
	}

	/**
	 * Return the pointer to this component as an element.
	 *
	 * @return The pointer to the native component which this object wraps.
	 * @throws PoolsException If there is an error converting the native
	 * component pointer to a native elem pointer.
	 */
	protected long getElem() throws PoolsException
	{
		long elem;

		if ((elem = PoolInternal.pool_component_to_elem(_conf.getConf(),
		    getComponent())) == 0)
			throw new PoolsException();
		return (elem);
	}

	/**
	 * Return the type of the component
	 */
	String getType()
	{
		return (type);
	}

	/**
	 * Return the system id of the component.
	 */
	long getSysId()
	{
		return (sys_id);
	}

	/**
	 * Return the key of the component.
	 */
	String getKey()
	{
		return (key);
	}
}
/*
 * 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.
 *
 */

package com.sun.solaris.service.pools;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

/**
 * The <code>Configuration</code> class represents a pools configuration.
 */
public class Configuration extends Element
{
	/**
	 * Indicates whether the configuration represents a usable
	 * configuration.
	 */
	private boolean _valid = false;

	/**
	 * A reference to the native libpool object represented by
	 * this instance.
	 */
	private long _this;

	/**
	 * The name of this instance.
	 */
	private String name;

	/**
	 * The cache of elements known to this configuration.
	 */
	private Map elements;

	/**
	 * The key of the configuration.
	 */
	private String key;

	/**
	 * Constructor
	 * @param location The location of the configuration.
	 * @param perms The OR'd permissions used when opening this
	 * configuration.
	 * @exception PoolsException The error message generated by
	 * libpool.
	 */
	public Configuration(String location, int perms) throws PoolsException
	{
		if (((_this = PoolInternal.pool_conf_alloc())) == 0)
			throw new PoolsException();
		_conf = this;
		open(location, perms);
		elements = new HashMap();
	}

        /**
         * Reclaim the memory allocated for this configuration by the C
	 * proxy.
         *
         * @throws Throwable If freeing this configuration fails.
         */
	protected void finalize() throws Throwable
	{
		try
		{
			close();
			if (_this != 0) {
				PoolInternal.pool_conf_free(_this);
				_this = 0;
			}
		}
		finally
		{
			super.finalize();
		}
	}

	/**
	 * Returns a pointer to the native configuration, wrapped by this
	 * instance.
	 *
	 * @return the configuration pointer.
	 */
	final long getConf()
	{
		return (_this);
	}

	/**
	 * Opens the configuration at the supplied location and with the
	 * supplied permissions.
	 *
	 * @throws PoolsException if there is an error opening the
	 * configuration.
	 */
	public void open(String location, int perms) throws PoolsException
	{
		if (_valid == false) {
			if (PoolInternal.pool_conf_open(getConf(), location,
				perms) != PoolInternal.PO_SUCCESS) {
				throw new PoolsException();
			}
			_valid = true;
			name = getStringProperty("system.name");
			key = "system." + name;
		}
	}

	/**
	 * Closes the configuration.
	 *
	 */
	public void close()
	{
		if (_valid == true) {
			elements.clear();
			PoolInternal.pool_conf_close(getConf());
			name = key = null;
		}
		_valid = false;
	}

	/**
	 * Returns the location of the configuration.
	 *
	 * @return the location of the configuration.
	 */
	public String getLocation()
	{
		return (PoolInternal.pool_conf_location(getConf()));
	}

	/**
	 * Returns the status of the configuration.
	 *
	 * @return the status of the configuration.
	 */
	public int status()
	{
		return (PoolInternal.pool_conf_status(getConf()));
	}

	/**
	 * Remove the configuration.
	 *
	 * @throws PoolsException If the removal fails.
	 */
	public void remove() throws PoolsException
	{
		if (PoolInternal.pool_conf_remove(getConf()) !=
		    PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Rollback the configuration, undoing any changes which have been
	 * made since the last commit or (if there are no commits) since the
	 * configuration was opened.
	 *
	 * @throws PoolsException If the rollback fails.
	 */
	public void rollback() throws PoolsException
	{
		if (PoolInternal.pool_conf_rollback(getConf()) !=
		    PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Commit the configuration, making any changes since the configuration
	 * was last committed (or opened if there have been no prior commits)
	 * permanent.
	 *
	 * @throws PoolsException If the commit fails.
	 */
	public void commit(int active) throws PoolsException
	{
		if (PoolInternal.pool_conf_commit(getConf(), active) !=
		    PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Export the configuration, storing the current state of the
	 * configuration at the supplied location in the supplied format.
	 *
	 * @param location The location of the export.
	 * @param format The format of the export.
	 * @throws PoolsException If the export fails.
	 */
	public void export(String location, int format) throws PoolsException
	{
		if (PoolInternal.pool_conf_export(getConf(), location, format)
		    != PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Validate the configuration, ensuring that the current state of the
	 * configuration satisfies the supplied validation level.
	 *
	 * @param level The desired level of validation.
	 * @throws PoolsException If the validation fails.
	 */
	public void validate(int level) throws PoolsException
	{
		if (PoolInternal.pool_conf_validate(getConf(), level)
		    != PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Update the configuration, ensuring that the current state of the
	 * configuration reflects that of the kernel.
	 *
	 * @throws PoolsException If the update fails.
	 * @return a bitmap of the changed types.
	 */
	public int update() throws PoolsException
	{
		return (PoolInternal.pool_conf_update(getConf()));
	}

	/**
	 * Create a pool with the supplied name.
	 *
	 * @param name The name of the PoolInternal.
	 * @throws PoolsException If the pool creation fails.
	 * @return a pool with the supplied name.
	 */
	public Pool createPool(String name) throws PoolsException
	{
		long aPool;

		if ((aPool = PoolInternal.pool_create(getConf(), name)) == 0) {
			throw new PoolsException();
		}
		Pool p = new Pool(this, aPool);
		elements.put(p.getKey(), p);
		return (p);
	}

	/**
	 * Destroy the supplied PoolInternal.
	 *
	 * @param aPool The pool to be destroyed.
	 * @throws PoolsException If the pool cannot be located.
	 */
	public void destroyPool(Pool aPool) throws PoolsException
	{
		elements.remove(aPool.getKey());
		PoolInternal.pool_destroy(getConf(), aPool.getPool());
	}

	/**
	 * Get the pool with the supplied name.
	 *
	 * @param name The name of the pool to be found.
	 * @throws PoolsException If the pool cannot be located.
	 * @return a pool with the supplied name.
	 */
	public Pool getPool(String name) throws PoolsException
	{
		long aPool;

		if ((aPool = PoolInternal.pool_get_pool(getConf(), name)) ==
		    0) {
			throw new PoolsException();
		}
		if (elements.containsKey("PoolInternal." + name))
			return ((Pool) elements.get("PoolInternal." + name));
		else {
			Pool p = new Pool(this, aPool);
			elements.put(p.getKey(), p);
			return (p);
		}
	}

	/**
	 * Get the proxy for the pool with the supplied name.
	 *
	 * @param name The name of the pool to be found.
	 * @throws PoolsException If the pool cannot be located.
	 * @return the proxy for the pool with the supplied name.
	 */
	long checkPool(String name) throws PoolsException
	{
		long aPool;

		if ((aPool = PoolInternal.pool_get_pool(getConf(), name)) ==
		    0) {
			throw new PoolsException();
		}
		return (aPool);
	}

	/**
	 * Get a list of pools which match the supplied selection criteria
	 * in values.
	 *
	 * @param values A list of values to be used to qualify the search.
	 * @throws PoolsException If there is an error executing the query.
	 * @return a list of pools which match the supplied criteria
	 */
	public List getPools(List values) throws PoolsException
	{
		List pools;

		if ((pools = PoolInternal.pool_query_pools(getConf(), values))
		    == null) {
			if (PoolInternal.pool_error() ==
			    PoolInternal.POE_INVALID_SEARCH)
				return new ArrayList();
			else
				throw new PoolsException();
		}
		ArrayList aList = new ArrayList(pools.size());
		for (int i = 0; i < pools.size(); i++)
			aList.add(new Pool(this,
			    ((Long)pools.get(i)).longValue()));
		return (aList);
	}

	/**
	 * Create a resource with the supplied type and name.
	 *
	 * @param type The type of the resource.
	 * @param name The name of the resource.
	 * @throws PoolsException If the resource creation fails.
	 * @return a resource of the supplied type and name.
	 */
	public Resource createResource(String type, String name)
	    throws PoolsException
	{
		long aResource;

		if ((aResource = PoolInternal.pool_resource_create(getConf(),
			 type, name)) == 0) {
			throw new PoolsException();
		}
		Resource res = new Resource(this, aResource);
		elements.put(res.getKey(), res);
		return (res);
	}

	/**
	 * Destroy the supplied resource.
	 *
	 * @param res The resource to be destroyed.
	 * @throws PoolsException If the resource cannot be located.
	 */
	public void destroyResource(Resource res) throws PoolsException
	{
		elements.remove(res.getKey());
		PoolInternal.pool_resource_destroy(getConf(),
		    res.getResource());
	}

	/**
	 * Get the resource with the supplied name.
	 *
	 * @param type The type of the resource to be found.
	 * @param name The name of the resource to be found.
	 * @throws PoolsException If the resource cannot be located.
	 * @return a resource with the supplied name.
	 */
	public Resource getResource(String type, String name)
	    throws PoolsException
	{
		long res;

		if ((res = PoolInternal.pool_get_resource(getConf(), type,
			 name)) == 0) {
			throw new PoolsException();
		}
		if (elements.containsKey(type + "." + name))
			return ((Resource) elements.get(type + "." + name));
		else {
			Resource r = new Resource(this, res);
			elements.put(r.getKey(), r);
			return (r);
		}
	}

	/**
	 * Get the proxy for the resource with the supplied type and
	 * name.
	 *
	 * @param type The type of the resource to be found.
	 * @param name The name of the resource to be found.
	 * @throws PoolsException If the resource cannot be located.
	 * @return the proxy for the resource with the supplied name.
	 */
	long checkResource(String type, String name) throws PoolsException
	{
		long res;

		if ((res = PoolInternal.pool_get_resource(getConf(), type,
			 name)) == 0) {
			throw new PoolsException();
		}
		return (res);
	}

	/**
	 * Get a list of resources which match the supplied selection criteria
	 * in values.
	 *
	 * @param values A list of values to be used to qualify the search.
	 * @throws PoolsException If there is an error executing the query.
	 * @return a list of resources which match the supplied criteria
	 */
	public List getResources(List values) throws PoolsException
	{
		List resources;

		if ((resources = PoolInternal.pool_query_resources(getConf(),
		    values)) == null) {
			if (PoolInternal.pool_error() ==
			    PoolInternal.POE_INVALID_SEARCH)
				return new ArrayList();
			else
				throw new PoolsException();
		}
		ArrayList aList = new ArrayList(resources.size());
		for (int i = 0; i < resources.size(); i++)
			aList.add(new Resource(this,
			    ((Long)resources.get(i)).longValue()));
		return (aList);
	}

	/**
	 * Get the component with the supplied name.
	 *
	 * @param type The type of the component to be found.
	 * @param sys_id The sys_id of the component to be found.
	 * @throws PoolsException If the component cannot be located.
	 * @return a component with the supplied name.
	 */
	public Component getComponent(String type, long sys_id)
	    throws PoolsException
	{
		List props = new ArrayList();
		Value ptype = new Value("type", type);
		Value psys_id = new Value(type + ".sys_id", sys_id);

		props.add(ptype);
		props.add(psys_id);
		List comps = getComponents(props);
		ptype.close();
		psys_id.close();
		if (comps.size() != 1)
			throw new PoolsException();
		return ((Component) comps.get(0));
	}

	/**
	 * Get the component proxy with the supplied type and sys_id.
	 *
	 * @param type The type of the component to be found.
	 * @param sys_id The sys_id of the component to be found.
	 * @throws PoolsException If the component cannot be located.
	 * @return a component with the supplied name.
	 */
	long checkComponent(String type, long sys_id)
	    throws PoolsException
	{
		List props = new ArrayList();
		Value ptype = new Value("type", type);
		Value psys_id = new Value(type + ".sys_id", sys_id);

		props.add(ptype);
		props.add(psys_id);
		List comps = checkComponents(props);
		ptype.close();
		psys_id.close();
		if (comps.size() != 1)
			throw new PoolsException();
		return (((Long)comps.get(0)).longValue());
	}

	/**
	 * Get a list of components which match the supplied selection criteria
	 * in values.
	 *
	 * @param values A list of values to be used to qualify the search.
	 * @throws PoolsException If there is an error executing the query.
	 * @return a list of components which match the supplied criteria
	 */
	public List getComponents(List values) throws PoolsException
	{
		List components;

		if ((components = PoolInternal.pool_query_components(getConf(),
		    values)) == null) {
			if (PoolInternal.pool_error() ==
			    PoolInternal.POE_INVALID_SEARCH)
				return new ArrayList();
			else
				throw new PoolsException();
		}
		ArrayList aList = new ArrayList(components.size());
		for (int i = 0; i < components.size(); i++) {
			/*
			 * Extract type information
			 */
			Value typeVal = new Value(name);

			if (PoolInternal.pool_get_property(getConf(),
			    ((Long)components.get(i)).longValue(), "type",
			    typeVal.getValue()) == PoolInternal.POC_INVAL)
				throw new PoolsException();
			if (typeVal == null)
				throw new PoolsException();
			String type = typeVal.getString();
			typeVal.close();

			Value idValue = new Value(name);

			if (PoolInternal.pool_get_property(getConf(),
			    ((Long)components.get(i)).longValue(),
			    type + ".sys_id", idValue.getValue()) ==
			    PoolInternal.POC_INVAL)
				throw new PoolsException();
			if (idValue == null)
				throw new PoolsException();
			long sys_id = idValue.getLong();
			idValue.close();

			if (elements.containsKey(type + "." + sys_id))
				aList.add((Component)elements.get(type + "." +
					  sys_id));
			else
				aList.add(new Component(this, ((Long)components.
							get(i)).longValue()));
		}
		return (aList);

	}

	/**
	 * Get a list of component proxies which match the supplied
	 * selection criteria in values.
	 *
	 * @param values A list of values to be used to qualify the search.
	 * @throws PoolsException If there is an error executing the query.
	 * @return a list of component proxies which match the
	 * supplied criteria
	 */
	List checkComponents(List values) throws PoolsException
	{
		List components;

		if ((components = PoolInternal.pool_query_components(getConf(),
		    values)) == null) {
			if (PoolInternal.pool_error() ==
			    PoolInternal.POE_INVALID_SEARCH)
				return new ArrayList();
			else
				throw new PoolsException();
		}
		return (components);
	}
	/**
	 * Returns a descriptive string which describes the configuration.
	 *
	 * @param deep Whether the information should contain information about
	 * all contained elements.
	 * @return a descriptive string which describes the configuration.
	 */
	public String getInformation(int deep)
	{
		return (PoolInternal.pool_conf_info(_conf.getConf(), deep));
	}

        /**
         * Returns a string representation of this configuration.
         *
         * @return  a string representation of this configuration.
         */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append("system: ");
		buf.append(name);
		return (buf.toString());
	}

	/**
	 * Indicates whether some other Configuration is "equal to this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof Configuration))
			return (false);
		Configuration other = (Configuration) o;
		if (name.compareTo(other.getName()) != 0)
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return name.hashCode();
	}

	/**
	 * Return the pointer to this configuration as an element.
	 *
	 * @return The pointer to the native configuration which this object
	 * wraps.
	 * @throws PoolsException If there is an error converting the native
	 * configuration pointer to a native elem pointer.
	 */
	protected long getElem() throws PoolsException
	{
		long elem;

		if ((elem = PoolInternal.pool_conf_to_elem(getConf())) == 0)
			throw new PoolsException();
		return (elem);
	}

	/**
	 * Return the name of the configuration.
	 */
	String getName()
	{
		return (name);
	}

	/**
	 * Return the key of the configuration.
	 */
	String getKey()
	{
		return (key);
	}
}
/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

package com.sun.solaris.service.pools;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Arrays;

/**
 * The <code>Element</code> class represents a pools configuration
 * element.  The class is an abstract, base class for concrete
 * implementation elements, such as pool and resource.
 */
public abstract class Element implements Property, PropertyWalk
{
	/**
	 * The configuration to which this element belongs.
	 */
	protected Configuration _conf;

        /**
         * Returns a string representation of this element.
         *
         * @return  a string representation of this element.
         */
	public String toString()
	{
		try {
			return (getInformation(1));
		} catch (PoolsException pe) {
			return (pe.toString());
		}
	}

	/**
	 * Returns a descriptive string which describes the element.
	 *
	 * @param deep Whether the information should contain information about
	 * all contained elements.
	 * @throws PoolsException If the element cannot be located.
	 * @return a descriptive string which describes the element.
	 */
	public abstract String getInformation(int deep) throws PoolsException;

	/**
	 * A list of properties that are chosen to be cached.
	 */
	private static final List cachedProperties
			= Arrays.asList(new String[] {"cpu.sys_id",
			"pool.default", "pool.sys_id", "pset.default",
			"pset.sys_id", "pset.type", "pset.units"});

        /**
         * hashmap of property values that are determined readonly
         */
        private HashMap readOnlyValues = new HashMap();

	/**
	 * Get the property with the supplied name.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If there is an error accessing the property.
	 * @return a value containing the property details.
	 */
        private Value getProperty(String name) throws PoolsException
	{
            if (readOnlyValues.containsKey(name)) {
                Value value = (Value) readOnlyValues.get(name);
                return (value);
            } else {
                Value value = new Value(name);
                if (PoolInternal.pool_get_property(_conf.getConf(), getElem(),
                        name, value.getValue()) == PoolInternal.POC_INVAL) {
                    throw new PoolsException();
                } else {
                    if (cachedProperties.contains(name)) {
                        value.lock();
                        readOnlyValues.put(name, value);
                    }
                    return (value);
                }
            }
        }

	/**
	 * Get the property with the supplied name using the supplied
	 * proxy.
	 *
	 * @param name The name of the property to be retrieved.
	 * @param proxy The proxy item used to retrieve the property.
	 * @throws PoolsException If there is an error accessing the property.
	 * @return a value containing the property details.
	 */
        protected Value getProperty(String name, long proxy)
	    throws PoolsException
	{
            if (readOnlyValues.containsKey(name)) {
                Value value = (Value) readOnlyValues.get(name);
                return (value);
            } else {
                Value value = new Value(name);
                if (PoolInternal.pool_get_property(_conf.getConf(), proxy, name,
                        value.getValue()) == PoolInternal.POC_INVAL) {
                    throw new PoolsException();
                } else {
                    if (cachedProperties.contains(name)) {
                        value.lock();
                        readOnlyValues.put(name, value);
                    }
                    return (value);
                }
            }
        }

	/**
	 * Put the supplied value as an element property with the supplied
	 * name.
	 *
	 * @param name The name of the property to be updated.
	 * @param value The value of the property to be updated.
	 * @throws PoolsException If there is an error accessing the property.
	 */
        public void putProperty(String name, Value value) throws PoolsException
	{
		if (PoolInternal.pool_put_property(_conf.getConf(), getElem(),
			name, value.getValue()) != PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Remove the element property with the supplied name.
	 *
	 * @param name The name of the property to be removed.
	 * @throws PoolsException If there is an error removing the property.
	 */
        public void rmProperty(String name) throws PoolsException
	{
		if (PoolInternal.pool_rm_property(_conf.getConf(), getElem(),
			name) != PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Get a String property.
	 *
	 * If the type of the property does not match, i.e. it's not a
	 * String, or the element does not have such a property then a
	 * PoolsException is thrown.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If getting the String property fails.
	 */
	public String getStringProperty(String name) throws PoolsException
	{
		Value val = getProperty(name);

		if (val != null) {
			String ret = val.getString();
			val.close();
			return (ret);
		}
		throw new PoolsException();
	}

	/**
	 * Get a long property.
	 *
	 * If the type of the property does not match, i.e. it's not a
	 * long, or the element does not have such a property then a
	 * PoolsException is thrown.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If getting the long property fails.
	 */
	public long getLongProperty(String name) throws PoolsException
	{
		Value val = getProperty(name);

		if (val != null) {
			long ret = val.getLong();
			val.close();
			return (ret);
		}
		throw new PoolsException();
	}

	/**
	 * Get a double property.
	 *
	 * If the type of the property does not match, i.e. it's not a
	 * double, or the element does not have such a property then a
	 * PoolsException is thrown.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If getting the double property fails.
	 */
	public double getDoubleProperty(String name) throws PoolsException
	{
		Value val = getProperty(name);

		if (val != null) {
			double ret = val.getDouble();
			val.close();
			return (ret);
		}
		throw new PoolsException();
	}

	/**
	 * Get a boolean property.
	 *
	 * If the type of the property does not match, i.e. it's not a
	 * boolean, or the element does not have such a property then
	 * a PoolsException is thrown.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If getting the boolean property fails.
	 */
	public boolean getBoolProperty(String name) throws PoolsException
	{
		Value val = getProperty(name);

		if (val != null) {
			boolean ret = val.getBool();
			val.close();
			return (ret);
		}
		throw new PoolsException();
	}

	/**
	 * Walk all properties of the invoking object.
	 *
	 * @param elem The element to whom the property belongs.
	 * @param val The value representing the current element.
	 * @param user User supplied data, provided when the walk is invoked.
	 * @throws PoolsException If there is an error walking the property.
	 * @return 0 to continue the walk, anything else to terminate it.
	 */
	public int walk(Element elem, Value val, Object user)
	    throws PoolsException
	{
		System.out.println("Property name: " + val.getName() +
		    ", value: "+val.toString());
		val.close();
		return (0);
	}

	/**
	 * Return the pointer to this subtype as an element.
	 *
	 * @return The pointer to the native subtype which this object wraps.
	 * @throws PoolsException If there is an error converting the native
	 * subtype pointer to a native elem pointer.
	 */
	protected abstract long getElem() throws PoolsException;

	/**
	 * Walk all the properties of this element.
	 *
	 * @param handler The object which will receive the callbacks.
	 * @param user Data supplied by the user for use in the callback.
	 * @return 0 for a successful walk, else 1.
	 * @throws PoolsException If there is an error during the walk.
	 */
	public int walkProperties(PropertyWalk handler, Object user)
	    throws PoolsException
	{
		return (walkProps(_conf.getConf(), getElem(), handler, user));
	}

	/**
	 * Walk the properties of the supplied element using the
	 * supplied handler.
	 *
	 * @param conf native reference to the configuration in which
	 * the element belongs.
	 * @param elem native reference to the element whose
	 * properties are to be walked.
	 * @param handler a method to be invoked with each property of
	 * the elem.
	 * @param user a user parameter which is passed to handler on
	 * each invocation.
	 * @throws PoolsException if there is an error accessing the
	 * element properties.
	 */
	private native int walkProps(long conf, long elem,
	    PropertyWalk handler, Object user) throws PoolsException;

	/**
	 * Return the key of the element.
	 */
	abstract String getKey();
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.pools;

import java.math.BigInteger;
import java.lang.Comparable;

/**
 * hrtime_t-like (see gethrtime(3C)) uptime-based time value (i.e., resilient
 * to changes to the host's clock) for comparison of timestamps of sampled
 * data.
 */
public class HRTime implements Comparable {
	/**
	 * The native <code>hrtime_t</code> value.
	 */
	private UnsignedInt64 value;

	/**
	 * Constructor.
	 */
	public HRTime()
	{
		this.value = timestamp();
	}

	/**
	 * Constructs a new HRTime with the value of the given
	 * UnsignedInt64.
	 *
	 * @param value The timestamp to be used.
	 */
	public HRTime(UnsignedInt64 value)
	{
		this.value = value;
	}

	/**
	 * Computes the difference between this time and another, older,
	 * time.
	 *
	 * @param older the time from which to compute the delta.
	 * @throws IllegalArgumentException if the given time is not
	 * earlier than this one.
	 */
	public HRTime deltaFrom(HRTime older)
	{
		if (older.compareTo(value) > 0)
			throw(new IllegalArgumentException());
		else
			return (new HRTime(new UnsignedInt64(value
			    .subtract(older.getValue()))));
	}

	/**
	 * Returns this HRTime's value.
	 */
	public UnsignedInt64 getValue()
	{
		return (value);
	}

	/**
	 * Return a string representation of this instance.
	 */
	public String toString()
	{
		return (value.toString());
	}

	public int compareTo(Object o) {
		HRTime other = (HRTime) o;

		return (value.compareTo(other.getValue()));
	}

	/**
	 * Return the current timestamp.
	 */
	private native UnsignedInt64 timestamp();
}
#
# 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 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/service/pools/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold


SOURCE =	PoolInternal.java \
		Component.java \
		Configuration.java \
		Element.java \
		HRTime.java \
		Property.java \
		PropertyWalk.java \
		Pool.java \
		PoolsException.java \
		Resource.java \
		UnsignedInt64.java \
		Value.java

all install: $(SOURCE:.java=.class)

# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *class

include $(SRC)/cmd/Makefile.targ
/*
 * 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.
 *
 */

package com.sun.solaris.service.pools;

import java.util.List;
import java.util.ArrayList;

/**
 * The <code>Pool</code> class represents a Resource Pool.
 */
public class Pool extends Element {

	/**
	 * The name of this instance.
	 */
	private final String name;
	/**
	 * The key of the pool.
	 */
	private final String key;

	/**
	 * Constructor
	 * @param conf The configuration to which this pool belongs.
	 * @param pool The pointer to the native pool which this object wraps.
	 * @throws PoolsException If accessing the proxy fails.
	 */
	Pool(Configuration conf, long pool) throws PoolsException
	{
		_conf = conf;
		Value val = getProperty("pool.name", pool);
		name = val.getString();
		val.close();
		key = "pool." + name;
	}

        /**
         * Returns a pointer to the native pool represented by this
         * pool object.
	 *
	 * @throws PoolsException If the pool cannot be located.
         * @return a pointer to the native pool represented by this
         * pool object.
	 */
	long getPool() throws PoolsException
	{
		return (_conf.checkPool(name));
	}

        /**
         * Associate this pool with the supplied resource.
         *
         * @param res A resource in the same configuration as this pool.
	 * @throws PoolsException If there is an error whilst associating the
	 * resource with the pool.
         */
	public void associate(Resource res) throws PoolsException
	{
		if (PoolInternal.pool_associate(_conf.getConf(), getPool(),
		    res.getResource()) != PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

        /**
         * Dissociate this pool from the supplied resource.
         *
         * @param res A resource in the same configuration as this pool.
	 * @throws PoolsException If there is an error whilst dissociating the
	 * resource from the pool.
         */
	public void dissociate(Resource res) throws PoolsException
	{
		if (PoolInternal.pool_dissociate(_conf.getConf(), getPool(),
		    res.getResource()) != PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Get a list of resources which match the supplied selection criteria
	 * in values. Only resources which are associated with this pool are
	 * searched.
	 *
	 * @param values A list of values to be used to qualify the search.
	 * @throws PoolsException If there is an error executing the query.
	 * @return a list of resources which match the supplied criteria
	 */
	public List getResources(List values) throws PoolsException
	{
		List resources;

		if ((resources = PoolInternal.pool_query_pool_resources(
			 _conf.getConf(), getPool(), values)) == null) {
			if (PoolInternal.pool_error() ==
			    PoolInternal.POE_INVALID_SEARCH)
				return new ArrayList();
			else
				throw new PoolsException();
		}
		ArrayList aList = new ArrayList(resources.size());
		for (int i = 0; i < resources.size(); i++)
			aList.add(new Resource(_conf,
			    ((Long)resources.get(i)).longValue()));
		return (aList);
	}

	/**
	 * Returns a descriptive string which describes the pool.
	 *
	 * @param deep Whether the information should contain information about
	 * all contained elements.
	 * @throws PoolsException If the pool cannot be located.
	 * @return a descriptive string which describes the pool.
	 */
	public String getInformation(int deep) throws PoolsException
	{
		return (PoolInternal.pool_info(_conf.getConf(), getPool(),
			    deep));
	}

        /**
         * Returns a string representation of this pool.
         *
         * @return  a string representation of this pool.
         */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append("pool: ");
		buf.append(name);
		return (buf.toString());
	}

	/**
	 * Indicates whether some other Pool is "equal to this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof Pool))
			return (false);
		Pool other = (Pool) o;
		if (name.compareTo(other.getName()) != 0)
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (name.hashCode());
	}

	/**
	 * Return the pointer to this pool as an element.
	 *
	 * @return The pointer to the native pool which this object wraps.
	 * @throws PoolsException If there is an error converting the native
	 * pool pointer to a native elem pointer.
	 */
	protected long getElem() throws PoolsException
	{
		long elem;

		if ((elem = PoolInternal.pool_to_elem(_conf.getConf(),
		    getPool())) == 0)
			throw new PoolsException();
		return (elem);
	}

	/**
	 * Return the name of the pool.
	 */
	String getName()
	{
		return (name);
	}

	/**
	 * Return the key of the pool.
	 */
	String getKey()
	{
		return (key);
	}
}
/*
 * 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.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.pools;

/**
 * A thin layer over the libpool(3LIB) interface so that Java can be
 * used to manipulate resource pools. For more information on this
 * facility refer to the manpage and the developer documentation.
 *
 * Most of the functionality in this class is not intended to be
 * exposed to users of the package. The other classes in the package
 * provide appropriate Java abstractions for using this functionality.
 *
 * Refer to the package documentation and the documentation of the
 * other publicly visible classes for more details.
 */
public class PoolInternal {
	static {
		System.loadLibrary("jpool");
		PoolInternal.init();
	}

	final static native void init();
	final static native long pool_version(long ver);
	final static native int get_POX_NATIVE();
	final static native int get_POX_TEXT();
	final static native int get_POC_INVAL();
	final static native int get_POC_UINT();
	final static native int get_POC_INT();
	final static native int get_POC_DOUBLE();
	final static native int get_POC_BOOL();
	final static native int get_POC_STRING();
	final static native int get_POV_NONE();
	final static native int get_POV_LOOSE();
	final static native int get_POV_STRICT();
	final static native int get_POV_RUNTIME();
	final static native int get_POF_INVALID();
	final static native int get_POF_VALID();
	final static native int get_POF_DESTROY();
	public final static native int pool_error();
	public final static native String pool_strerror(int error);
	public final static native String pool_strerror_sys();
	public final static native int pool_resource_type_list(long types,
	    long numtypes);
	public final static native int pool_get_status();
	public final static native int pool_set_status(int state);
	final static native long pool_conf_alloc();
	final static native void pool_conf_free(long conf);
	final static native int pool_conf_status(long conf);
	final static native int pool_conf_close(long conf);
	final static native int pool_conf_remove(long conf);
	final static native int pool_conf_open(long conf, String location,
	    int oflags);
	final static native int pool_conf_rollback(long conf);
	final static native int pool_conf_commit(long conf, int active);
	final static native int pool_conf_export(long conf, String location,
	    int fmt);
	final static native int pool_conf_validate(long conf, int level);
	final static native int pool_conf_update(long conf);
	final static native long pool_get_pool(long conf, String name);
	final static native java.util.List pool_query_pools(long conf,
	    java.util.List props);
	final static native long pool_get_resource(long conf, String type,
	    String name);
	final static native java.util.List pool_query_resources(long conf,
	    java.util.List props);
	final static native java.util.List pool_query_components(long conf,
	    java.util.List props);
	final static native String pool_conf_location(long conf);
	final static native String pool_conf_info(long conf, int deep);
	final static native long pool_resource_create(long conf,
	    String type, String name);
	final static native int pool_resource_destroy(long conf, long res);
	final static native int pool_resource_transfer(long conf,
	    long src, long tgt, long size);
	final static native int pool_resource_xtransfer(long conf,
	    long src, long tgt, java.util.List components);
	final static native java.util.List pool_query_resource_components(
	    long conf, long res, java.util.List props);
	final static native String pool_resource_info(long conf, long res,
	    int deep);
	final static native long pool_create(long conf, String name);
	final static native int pool_destroy(long conf, long pool);
	final static native int pool_associate(long conf, long pool,
	    long res);
	final static native int pool_dissociate(long conf, long pool,
	    long res);
	final static native String pool_info(long conf, long pool, int deep);
	final static native java.util.List pool_query_pool_resources(
	    long conf, long pool, java.util.List props);
	final static native long pool_get_owning_resource(long conf,
	    long comp);
	final static native String pool_component_info(long conf,
	    long comp, int deep);
	final static native int pool_get_property(long conf, long elem,
	    String name, long val);
	final static native int pool_put_property(long conf, long elem,
	    String name, long val);
	final static native int pool_rm_property(long conf, long elem,
	    String name);
	final static native int pool_walk_properties(long conf, long elem,
	    long user, long callback);
	final static native long pool_conf_to_elem(long conf);
	final static native long pool_to_elem(long conf, long pool);
	final static native long pool_resource_to_elem(long conf, long res);
	final static native long pool_component_to_elem(long conf, long comp);
	final static native int pool_value_get_uint64(long pv, long result);
	final static native int pool_value_get_int64(long pv, long result);
	final static native int pool_value_get_double(long pv, long result);
	final static native int pool_value_get_bool(long pv, long result);
	final static native int pool_value_get_string(long pv, long result);
	final static native int pool_value_get_type(long pv);
	final static native void pool_value_set_uint64(long pv, long val);
	final static native void pool_value_set_int64(long pv, long val);
	final static native void pool_value_set_double(long pv, double val);
	final static native void pool_value_set_bool(long pv, short val);
	final static native int pool_value_set_string(long pv, String val);
	final static native String pool_value_get_name(long pv);
	final static native int pool_value_set_name(long pv, String val);
	final static native long pool_value_alloc();
	final static native void pool_value_free(long pv);
	public final static native String pool_static_location();
	public final static native String pool_dynamic_location();
	public final static native int pool_set_binding(String name,
	    int idtype, int id);
	public final static native String pool_get_binding(int pid);
	public final static native String pool_get_resource_binding(
	    String type, int pid);
	final static native int pool_walk_pools(long conf, long user,
	    long callback);
	final static native int pool_walk_resources(long conf, long pool,
	    long user, long callback);
	final static native int pool_walk_components(long conf, long res,
	    long user, long callback);
	/*
	 * enums and constants
	 */
	public final static int POOL_VER_CURRENT = 1;
	public final static int POOL_VER_NONE = 0;
	public final static int PO_TRUE = 1;
	public final static int PO_FALSE = 0;
	public final static int PO_SUCCESS = 0;
	public final static int PO_FAIL = -1;
	public final static int POE_OK = 0;
	public final static int POE_BAD_PROP_TYPE = 1;
	public final static int POE_INVALID_CONF = 2;
	public final static int POE_NOTSUP = 3;
	public final static int POE_INVALID_SEARCH = 4;
	public final static int POE_BADPARAM = 5;
	public final static int POE_PUTPROP = 6;
	public final static int POE_DATASTORE = 7;
	public final static int POE_SYSTEM = 8;
	public final static int POE_ACCESS = 9;
	public final static int PO_RDONLY = 0x0;
	public final static int PO_RDWR = 0x1;
	public final static int PO_CREAT = 0x2;
	public final static int PO_DISCO = 0x4;
	public final static int PO_UPDATE = 0x8;
	public final static String POA_IMPORTANCE = "importance based";
	public final static String POA_SURPLUS_TO_DEFAULT =
	    "surplus to default";
	public final static int POU_SYSTEM = 0x1;
	public final static int POU_POOL = 0x2;
	public final static int POU_PSET = 0x4;
	public final static int POU_CPU = 0x8;
	public final static int POX_NATIVE = get_POX_NATIVE();
	public final static int POX_TEXT = get_POX_TEXT();
	public final static int POC_INVAL = get_POC_INVAL();
	public final static int POC_UINT = get_POC_UINT();
	public final static int POC_INT = get_POC_INT();
	public final static int POC_DOUBLE = get_POC_DOUBLE();
	public final static int POC_BOOL = get_POC_BOOL();
	public final static int POC_STRING = get_POC_STRING();
	public final static int POV_NONE = get_POV_NONE();
	public final static int POV_LOOSE = get_POV_LOOSE();
	public final static int POV_STRICT = get_POV_STRICT();
	public final static int POV_RUNTIME = get_POV_RUNTIME();
	public final static int POF_INVALID = get_POF_INVALID();
	public final static int POF_VALID = get_POF_VALID();
	public final static int POF_DESTROY = get_POF_DESTROY();
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.pools;

/**
 * The <code>PoolsException</code> class represents a pools error.  It
 * is used to report any errors in native code.  See
 * <code>errno(3C)</code> for information on the system (POE_SYSTEM)
 * error codes.
 */
public class PoolsException extends Exception {
	/**
	 * EPERM.
	 */
	public static final int EPERM = 1;

	/**
	 * ENOENT.
	 */
	public static final int ENOENT = 2;

	/**
	 * ESRCH.
	 */
	public static final int ESRCH = 3;

	/**
	 * EINTR.
	 */
	public static final int EINTR = 4;

	/**
	 * EIO.
	 */
	public static final int EIO = 5;

	/**
	 * ENXIO.
	 */
	public static final int ENXIO = 6;

	/**
	 * E2BIG.
	 */
	public static final int E2BIG = 7;

	/**
	 * ENOEXEC.
	 */
	public static final int ENOEXEC = 8;

	/**
	 * EBADF.
	 */
	public static final int EBADF = 9;

	/**
	 * ECHILD.
	 */
	public static final int ECHILD = 10;

	/**
	 * EAGAIN.
	 */
	public static final int EAGAIN = 11;

	/**
	 * ENOMEM.
	 */
	public static final int ENOMEM = 12;

	/**
	 * EACCES.
	 */
	public static final int EACCES = 13;

	/**
	 * EFAULT.
	 */
	public static final int EFAULT = 14;

	/**
	 * ENOTBLK.
	 */
	public static final int ENOTBLK = 15;

	/**
	 * EBUSY.
	 */
	public static final int EBUSY = 16;

	/**
	 * EEXIST.
	 */
	public static final int EEXIST = 17;

	/**
	 * EXDEV.
	 */
	public static final int EXDEV = 18;

	/**
	 * ENODEV.
	 */
	public static final int ENODEV = 19;

	/**
	 * ENOTDIR.
	 */
	public static final int ENOTDIR = 20;

	/**
	 * EISDIR.
	 */
	public static final int EISDIR = 21;

	/**
	 * EINVAL.
	 */
	public static final int EINVAL = 22;

	/**
	 * ENFILE.
	 */
	public static final int ENFILE = 23;

	/**
	 * EMFILE.
	 */
	public static final int EMFILE = 24;

	/**
	 * ENOTTY.
	 */
	public static final int ENOTTY = 25;

	/**
	 * ETXTBSY.
	 */
	public static final int ETXTBSY = 26;

	/**
	 * EFBIG.
	 */
	public static final int EFBIG = 27;

	/**
	 * ENOSPC.
	 */
	public static final int ENOSPC = 28;

	/**
	 * ESPIPE.
	 */
	public static final int ESPIPE = 29;

	/**
	 * EROFS.
	 */
	public static final int EROFS = 30;

	/**
	 * EMLINK.
	 */
	public static final int EMLINK = 31;

	/**
	 * EPIPE.
	 */
	public static final int EPIPE = 32;

	/**
	 * EDOM.
	 */
	public static final int EDOM = 33;

	/**
	 * ERANGE.
	 */
	public static final int ERANGE = 34;

	/**
	 * ENOMSG.
	 */
	public static final int ENOMSG = 35;

	/**
	 * EIDRM.
	 */
	public static final int EIDRM = 36;

	/**
	 * ECHRNG.
	 */
	public static final int ECHRNG = 37;

	/**
	 * EL2NSYNC.
	 */
	public static final int EL2NSYNC = 38;

	/**
	 * EL3HLT.
	 */
	public static final int EL3HLT = 39;

	/**
	 * EL3RST.
	 */
	public static final int EL3RST = 40;

	/**
	 * ELNRNG.
	 */
	public static final int ELNRNG = 41;

	/**
	 * EUNATCH.
	 */
	public static final int EUNATCH = 42;

	/**
	 * ENOCSI.
	 */
	public static final int ENOCSI = 43;

	/**
	 * EL2HLT.
	 */
	public static final int EL2HLT = 44;

	/**
	 * EDEADLK.
	 */
	public static final int EDEADLK = 45;

	/**
	 * ENOLCK.
	 */
	public static final int ENOLCK = 46;

	/**
	 * ECANCELED.
	 */
	public static final int ECANCELED = 47;

	/**
	 * ENOTSUP.
	 */
	public static final int ENOTSUP = 48;

	/**
	 * EDQUOT.
	 */
	public static final int EDQUOT = 49;

	/**
	 * EBADE.
	 */
	public static final int EBADE = 50;

	/**
	 * EBADR.
	 */
	public static final int EBADR = 51;

	/**
	 * EXFULL.
	 */
	public static final int EXFULL = 52;

	/**
	 * ENOANO.
	 */
	public static final int ENOANO = 53;

	/**
	 * EBADRQC.
	 */
	public static final int EBADRQC = 54;

	/**
	 * EBADSLT.
	 */
	public static final int EBADSLT = 55;

	/**
	 * EDEADLOCK.
	 */
	public static final int EDEADLOCK = 56;

	/**
	 * EBFONT.
	 */
	public static final int EBFONT = 57;

	/**
	 * EOWNERDEAD.
	 */
	public static final int EOWNERDEAD = 58;

	/**
	 * ENOTRECOVERABLE.
	 */
	public static final int ENOTRECOVERABLE = 59;

	/**
	 * ENOSTR.
	 */
	public static final int ENOSTR = 60;

	/**
	 * ENODATA.
	 */
	public static final int ENODATA = 61;

	/**
	 * ETIME.
	 */
	public static final int ETIME = 62;

	/**
	 * ENOSR.
	 */
	public static final int ENOSR = 63;

	/**
	 * ENONET.
	 */
	public static final int ENONET = 64;

	/**
	 * ENOPKG.
	 */
	public static final int ENOPKG = 65;

	/**
	 * EREMOTE.
	 */
	public static final int EREMOTE = 66;

	/**
	 * ENOLINK.
	 */
	public static final int ENOLINK = 67;

	/**
	 * EADV.
	 */
	public static final int EADV = 68;

	/**
	 * ESRMNT.
	 */
	public static final int ESRMNT = 69;

	/**
	 * ECOMM.
	 */
	public static final int ECOMM = 70;

	/**
	 * EPROTO.
	 */
	public static final int EPROTO = 71;

	/**
	 * ELOCKUNMAPPED.
	 */
	public static final int ELOCKUNMAPPED = 72;

	/**
	 * ENOTACTIVE.
	 */
	public static final int ENOTACTIVE = 73;

	/**
	 * EMULTIHOP.
	 */
	public static final int EMULTIHOP = 74;

	/**
	 * EBADMSG.
	 */
	public static final int EBADMSG = 77;

	/**
	 * ENAMETOOLONG.
	 */
	public static final int ENAMETOOLONG = 78;

	/**
	 * EOVERFLOW.
	 */
	public static final int EOVERFLOW = 79;

	/**
	 * ENOTUNIQ.
	 */
	public static final int ENOTUNIQ = 80;

	/**
	 * EBADFD.
	 */
	public static final int EBADFD = 81;

	/**
	 * EREMCHG.
	 */
	public static final int EREMCHG = 82;

	/**
	 * ELIBACC.
	 */
	public static final int ELIBACC = 83;

	/**
	 * ELIBBAD.
	 */
	public static final int ELIBBAD = 84;

	/**
	 * ELIBSCN.
	 */
	public static final int ELIBSCN = 85;

	/**
	 * ELIBMAX.
	 */
	public static final int ELIBMAX = 86;

	/**
	 * ELIBEXEC.
	 */
	public static final int ELIBEXEC = 87;

	/**
	 * EILSEQ.
	 */
	public static final int EILSEQ = 88;

	/**
	 * ENOSYS.
	 */
	public static final int ENOSYS = 89;

	/**
	 * ELOOP.
	 */
	public static final int ELOOP = 90;

	/**
	 * ERESTART.
	 */
	public static final int ERESTART = 91;

	/**
	 * ESTRPIPE.
	 */
	public static final int ESTRPIPE = 92;

	/**
	 * ENOTEMPTY.
	 */
	public static final int ENOTEMPTY = 93;

	/**
	 * EUSERS.
	 */
	public static final int EUSERS = 94;

	/**
	 * ENOTSOCK.
	 */
	public static final int ENOTSOCK = 95;

	/**
	 * EDESTADDRREQ.
	 */
	public static final int EDESTADDRREQ = 96;

	/**
	 * EMSGSIZE.
	 */
	public static final int EMSGSIZE = 97;

	/**
	 * EPROTOTYPE.
	 */
	public static final int EPROTOTYPE = 98;

	/**
	 * ENOPROTOOPT.
	 */
	public static final int ENOPROTOOPT = 99;

	/**
	 * EPROTONOSUPPORT.
	 */
	public static final int EPROTONOSUPPORT = 120;

	/**
	 * ESOCKTNOSUPPORT.
	 */
	public static final int ESOCKTNOSUPPORT = 121;

	/**
	 * EOPNOTSUPP.
	 */
	public static final int EOPNOTSUPP = 122;

	/**
	 * EPFNOSUPPORT.
	 */
	public static final int EPFNOSUPPORT = 123;

	/**
	 * EAFNOSUPPORT.
	 */
	public static final int EAFNOSUPPORT = 124;

	/**
	 * EADDRINUSE.
	 */
	public static final int EADDRINUSE = 125;

	/**
	 * EADDRNOTAVAIL.
	 */
	public static final int EADDRNOTAVAIL = 126;

	/**
	 * ENETDOWN.
	 */
	public static final int ENETDOWN = 127;

	/**
	 * ENETUNREACH.
	 */
	public static final int ENETUNREACH = 128;

	/**
	 * ENETRESET.
	 */
	public static final int ENETRESET = 129;

	/**
	 * ECONNABORTED.
	 */
	public static final int ECONNABORTED = 130;

	/**
	 * ECONNRESET.
	 */
	public static final int ECONNRESET = 131;

	/**
	 * ENOBUFS.
	 */
	public static final int ENOBUFS = 132;

	/**
	 * EISCONN.
	 */
	public static final int EISCONN = 133;

	/**
	 * ENOTCONN.
	 */
	public static final int ENOTCONN = 134;

	/**
	 * ESHUTDOWN.
	 */
	public static final int ESHUTDOWN = 143;

	/**
	 * ETOOMANYREFS.
	 */
	public static final int ETOOMANYREFS = 144;

	/**
	 * ETIMEDOUT.
	 */
	public static final int ETIMEDOUT = 145;

	/**
	 * ECONNREFUSED.
	 */
	public static final int ECONNREFUSED = 146;

	/**
	 * EHOSTDOWN.
	 */
	public static final int EHOSTDOWN = 147;

	/**
	 * EHOSTUNREACH.
	 */
	public static final int EHOSTUNREACH = 148;

	/**
	 * EALREADY.
	 */
	public static final int EALREADY = 149;

	/**
	 * EINPROGRESS.
	 */
	public static final int EINPROGRESS = 150;

	/**
	 * ESTALE.
	 */
	public static final int ESTALE = 151;

	private final int errorCode = PoolInternal.pool_error();

	/**
	 * Constructor.
	 */
	public PoolsException()
	{
		super(description(PoolInternal.pool_error()));
	}

	private static String description(int errorCode)
	{
		StringBuffer sb = new StringBuffer(PoolInternal.pool_strerror(
		    errorCode));
		if (errorCode == PoolInternal.POE_SYSTEM)
			sb.append(": " + PoolInternal.pool_strerror_sys());
		return (sb.toString());
	}

	/**
	 * Returns the native pool error code.
	 *
	 * @return the native pool error code.
	 */
	public int getCode()
	{
		return (errorCode);
	}

	/**
	 * Returns <code>errno</code>, if the pool error is
	 * <code>POE_SYSTEM</code>.
	 */
	public native int getErrno();
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

package com.sun.solaris.service.pools;

/**
 * The <code>Property</code> interface specifies the contract between
 * a pools configuration element and its properties. This interface
 * must be implemented by all pools configuration elements to ensure that
 * properties can be manipulated.
 */

public interface Property {
	/**
	 * Get a property with the supplied name.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If there is an error accessing the property.
	 */
	public boolean getBoolProperty(String name) throws PoolsException;

	/**
	 * Get a property with the supplied name.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If there is an error accessing the property.
	 */
	public double getDoubleProperty(String name) throws PoolsException;

	/**
	 * Get a property with the supplied name.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If there is an error accessing the property.
	 */
	public long getLongProperty(String name) throws PoolsException;

	/**
	 * Get a property with the supplied name.
	 *
	 * @param name The name of the property to be retrieved.
	 * @throws PoolsException If there is an error accessing the property.
	 */
	public String getStringProperty(String name) throws PoolsException;

	/**
	 * Put the supplied value as a property with the supplied name.
	 *
	 * @param name The name of the property to be updated.
	 * @param value The value of the property to be updated.
	 * @throws PoolsException If there is an error accessing the property.
	 */
	public void putProperty(String name, Value value) throws PoolsException;

	/**
	 * Remove the property with the supplied name.
	 *
	 * @param name The name of the property to be removed.
	 * @throws PoolsException If there is an error removing the property.
	 */
	public void rmProperty(String name) throws PoolsException;
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

package com.sun.solaris.service.pools;

import java.util.List;
import java.util.ArrayList;

/**
 * The <code>PropertyWalk</code> interface specifies the contract
 * between a pools configuration element and clients which are
 * interested in enumerating the properties of the element.
 */

public interface PropertyWalk {
	/**
	 * Walk all properties of the invoking object, calling the
	 *
	 * @param elem The element to whom the property belongs.
	 * @param val The value representing the current element.
	 * @param user User supplied data, provided when the walk is invoked.
	 * @throws PoolsException If there is an error walking the property.
	 * @return 0 to continue the walk, anything else to terminate it.
	 */
	public int walk(Element elem, Value val, Object user)
	    throws PoolsException;
}
/*
 * 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.
 */

package com.sun.solaris.service.pools;

import java.util.List;
import java.util.ArrayList;

/**
 * The <code>Resource</code> class represents a resource.
 */
public class Resource extends Element
{
	/**
	 * The type of the resource.
	 */
	private final String type;
	/**
	 * The system id of the resource.
	 */
	private final String name;
	/**
	 * The key of the resource.
	 */
	private final String key;

	/**
	 * Constructor
	 * @param conf The configuration to which this pool belongs.
	 * @param resource The pointer to the native resource which
	 * this object wraps.
	 * @throws PoolsException If accessing the proxy fails.
	 */
	Resource(Configuration conf, long resource) throws PoolsException
	{
		_conf = conf;
		Value val = getProperty("type", resource);
		type = val.getString();
		val.close();
		val = getProperty(type + ".name", resource);
		name = val.getString();
		val.close();
		key = type + "." + name;
	}

        /**
         * Returns a pointer to the native resource represented by this resource
	 * object.
         *
	 * @throws PoolsException If the pool cannot be located.
         * @return a pointer to the native resource represented by this
	 * resource object.
         */
	long getResource() throws PoolsException
	{
		return (_conf.checkResource(type, name));
	}

        /**
         * Transfer the requested quantity of resource from the donor to this
	 * resource.
         *
         * @param donor A donating resource.
         * @param qty Amount of resource to be donated.
	 * @throws PoolsException If there is an error whilst donating the
	 * resource.
         */
	public void transfer(Resource donor, long qty) throws PoolsException
	{
		if (PoolInternal.pool_resource_transfer(_conf.getConf(),
		    donor.getResource(), getResource(), qty) !=
		    PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

        /**
         * Transfer the specified resource components from the donor to this
	 * resource.
         *
         * @param donor A donating resource.
         * @param components A list of resource components to be donated.
	 * @throws PoolsException If there is an error whilst donating the
	 * resource components.
         */
	public void transfer(Resource donor, List components)
	    throws PoolsException
	{
		if (PoolInternal.pool_resource_xtransfer(_conf.getConf(),
		    donor.getResource(), getResource(), components) !=
		    PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Get a list of components which match the supplied selection
	 * criteria in values.  Only components which are controlled by
	 * this resource are searched.
	 *
	 * @param values A list of values to be used to qualify the search.
	 * @throws PoolsException If there is an error executing the query.
	 * @return a list of components which match the supplied criteria
	 */
	public List getComponents(List values) throws PoolsException
	{
		List components;

		if ((components = PoolInternal.pool_query_resource_components(
		    _conf.getConf(), getResource(), values)) == null) {
			if (PoolInternal.pool_error() ==
			    PoolInternal.POE_INVALID_SEARCH)
				return new ArrayList();
			else
				throw new PoolsException();
		}
		ArrayList aList = new ArrayList(components.size());
		for (int i = 0; i < components.size(); i++)
			aList.add(new Component(_conf,
			    ((Long)components.get(i)).longValue()));
		return (aList);
	}

	/**
	 * Returns a descriptive string which describes the resource.
	 *
	 * @param deep Whether the information should contain information about
	 * all contained elements.
	 * @throws PoolsException If the resource cannot be located.
	 * @return a descriptive string which describes the resource.
	 */
	public String getInformation(int deep) throws PoolsException
	{
		return (PoolInternal.pool_resource_info(_conf.getConf(),
			getResource(), deep));
	}

        /**
         * Returns a string representation of this resource.
         *
         * @return  a string representation of this resource.
         */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append(type);
		buf.append(" ");
		buf.append(name);
		return (buf.toString());
	}

	/**
	 * Indicates whether some other Resource is "equal to this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof Resource))
			return (false);
		Resource other = (Resource) o;
		if (type.compareTo(other.getType()) != 0 ||
		    name.compareTo(other.getName()) != 0)
			return (false);
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (type.hashCode() + name.hashCode());
	}

	/**
	 * Return the pointer to this resource as an element.
	 *
	 * @return The pointer to the native resource which this object wraps.
	 * @throws PoolsException If there is an error converting the native
	 * resource pointer to a native elem pointer.
	 */
	protected long getElem() throws PoolsException
	{
		long elem;

		if ((elem = PoolInternal.pool_resource_to_elem(_conf.getConf(),
		    getResource())) == 0)
			throw new PoolsException();
		return (elem);
	}

	/**
	 * Return the type of the resource
	 */
	String getType()
	{
		return (type);
	}

	/**
	 * Return the name of the resource.
	 */
	String getName()
	{
		return (name);
	}

	/**
	 * Return the key of the resource.
	 */
	String getKey()
	{
		return (key);
	}
}
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.pools;

import java.math.BigInteger;

public class UnsignedInt64 extends BigInteger {
	/**
	 * The minimum value is 0.
	 */
	public final static BigInteger MIN_VALUE = new BigInteger("0");

	/**
	 * The maximum value is 18446744073709551615.
	 */
	public final static BigInteger MAX_VALUE = new BigInteger(
	    "18446744073709551615");

	/**
	 * Constructs a UnsignedInt64 with the same value as the given
	 * string, interpreted in base 10.
	 *
	 * @throws NumberFormatException if the given value is outside
	 * the representable range.
	 */
	public UnsignedInt64(String string) throws NumberFormatException
	{
		super(string);
		validate(this);
	}

	/**
	 * Constructs a UnsignedInt64 with the same value as the given
	 * string, interpreted in the given base.
	 *
	 * @throws NumberFormatException if the given value is outside
	 * the representable range.
	 */
	public UnsignedInt64(String string, int radix)
	    throws NumberFormatException
	{
		super(string, radix);
		validate(this);
	}

	/**
	 * Constructs a UnsignedInt64 with the same value as the given
	 * byte array, interpreted as a two's-complement number in
	 * big-endian byte order (the most significant byte has the
	 * lowest index).
	 *
	 * @throws NumberFormatException if the given value is outside
	 * the representable range.
	 */
	public UnsignedInt64(byte[] bytes) throws NumberFormatException
	{
		super(bytes);
		validate(this);
	}

	/**
	 * Constructs an UnsignedInt64 with the same value as the given
	 * BigInteger.
	 *
	 * @throws NumberFormatException if the given value is outside
	 * the representable range.
	 */
	public UnsignedInt64(BigInteger value) throws NumberFormatException
	{
		super(value.toByteArray());
		validate(this);
	}

	/**
	 * Check that the supplied parameter is a valid value for an
	 * UnsignedInt64.
	 *
	 * @param v A BigInteger to be checked if it's value is legal
	 * as an UnsignedInt64.
	 * @throws NumberFormatException if the given value is outside
	 * the representable range.
	 */
	private void validate(BigInteger v)
	{
		if (v.compareTo(MIN_VALUE) < 0 || v.compareTo(MAX_VALUE) > 0)
			throw(new NumberFormatException());
	}
}
/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

package com.sun.solaris.service.pools;

/**
 * The <code>Value</code> class represents a pools value.
 */
public class Value {

	private long _this;

	/**
	 * Constructor. Only for use from native code.
	 * @param pointer A pointer to a C value.
	 */
	private Value(long pointer)
	{
		_this = pointer;
	}

	/**
	 * Constructor
	 * @param name The name of the value.
	 * @throws PoolsException If there is an error whilst
	 * allocating the value.
	 */
	public Value(String name) throws PoolsException
	{
		if ((_this = PoolInternal.pool_value_alloc()) == 0)
			throw new PoolsException();
		setName(name);
	}

	/**
	 * Constructor
	 * @param name The name of the value.
	 * @param value The value of the value.
	 * @throws PoolsException If there is an error whilst
	 * allocating the value.
	 */
	public Value(String name, long value) throws PoolsException
	{
		this(name);
		setValue(value);
	}

	/**
	 * Constructor
	 * @param name The name of the value.
	 * @param value The value of the value.
	 * @param s Indicates if the value is signed or not.
	 * @throws PoolsException If there is an error whilst
	 * allocating the value.
	 */
	public Value(String name, long value, boolean s) throws PoolsException
	{
		this(name);
		setValue(value, s);
	}

	/**
	 * Constructor
	 * @param name The name of the value.
	 * @param value The value of the value.
	 * @throws PoolsException If there is an error whilst
	 * allocating the value.
	 */
	public Value(String name, String value) throws PoolsException
	{
		this(name);
		setValue(value);
	}

	/**
	 * Constructor
	 * @param name The name of the value.
	 * @param value The value of the value.
	 * @throws PoolsException If there is an error whilst
	 * allocating the value.
	 */
	public Value(String name, boolean value) throws PoolsException
	{
		this(name);
		setValue(value);
	}

	/**
	 * Constructor
	 * @param name The name of the value.
	 * @param value The value of the value.
	 * @throws PoolsException If there is an error whilst
	 * allocating the value.
	 */
	public Value(String name, double value) throws PoolsException
	{
		this(name);
		setValue(value);
	}


	private boolean _locked = false;

	/**
	 * Check whether the value is locked or not
	 * @return returns the value of _locked
	 */
	public boolean islocked() throws PoolsException
        {
                return (_locked);
        }

	/**
	 * Lock the value
	 */
	public void lock() throws PoolsException
	{
		_locked = true;
	}

	/**
	 * Unlock the value
	 */
	public void unlock() throws PoolsException
	{
		_locked = false;
	}

	/**
	 * Explicitly reclaim the memory (if not locked)
	 * allocated for this value by the C proxy.
	 */
	public void close()
	{
		if (_locked == false) {
			if (_this != 0) {
				PoolInternal.pool_value_free(_this);
				_this = 0;
			}
		}
	}

	/**
	 * Reclaim the memory allocated for this value by the C
	 * proxy.
	 *
	 * @throws Throwable If freeing this configuration fails.
	 */
	protected void finalize() throws Throwable
	{
		try
		{
			unlock();
			close();
		}
		finally
		{
			super.finalize();
		}
	}

	/**
	 * Name this value.
	 *
	 * @param name The name to set for this value.
	 */
	public void setName(String name)
	{
		PoolInternal.pool_value_set_name(_this, name);
	}

	/**
	 * Set this value to take the supplied signed long value.
	 *
	 * @param value The value to which this value should be set.
	 */
	public void setValue(long value)
	{
		PoolInternal.pool_value_set_int64(_this, value);
	}

	/**
	 * Set this value to take the supplied long value.
	 *
	 * @param value The value to which this value should be set.
	 * @param s Is the value signed or unsigned.
	 */
	public void setValue(long value, boolean s)
	{
		if (s)
			setValue(value);
		PoolInternal.pool_value_set_uint64(_this, value);
	}

	/**
	 * Set this value to take the supplied string value.
	 *
	 * @param value The value to which this value should be set.
	 * @throws PoolsException If the setting of the value fails.
	 */
	public void setValue(String value) throws PoolsException
	{
		if (PoolInternal.pool_value_set_string(_this, value) !=
		    PoolInternal.PO_SUCCESS)
			throw new PoolsException();
	}

	/**
	 * Set this value to take the supplied boolean value.
	 *
	 * @param value The value to which this value should be set.
	 */
	public void setValue(boolean value)
	{
		if (value == true)
			PoolInternal.pool_value_set_bool(_this, (short)1);
		else
			PoolInternal.pool_value_set_bool(_this, (short)0);
	}

	/**
	 * Set this value to take the supplied double value.
	 *
	 * @param value The value to which this value should be set.
	 */
	public void setValue(double value)
	{
		PoolInternal.pool_value_set_double(_this, value);
	}

	/**
	 * Returns the name of the value.
	 *
	 * @return the name of the value.
	 */
	public String getName()
	{
		return (PoolInternal.pool_value_get_name(_this));
	}

	/**
	 * Returns the pointer to the native value represented by this
	 * object.
	 *
	 * @return the pointer to the native value represented by this
	 * object.
	 */
	public long getValue()
	{
		return (_this);
	}

	/**
	 * Returns the type of this object.
	 *
	 * @return the type of this object.
	 */
	public int getType()
	{
		return (PoolInternal.pool_value_get_type(_this));
	}

	/**
	 * Returns a string representation of this value.
	 *
	 * @return a string representation of this value.
	 */
	public String toString()
	{
		int type = PoolInternal.pool_value_get_type(_this);

		try {
			if (type == PoolInternal.POC_INT ||
			    type == PoolInternal.POC_UINT)
				return (String.valueOf(getLong()));
			if (type == PoolInternal.POC_STRING)
				return getString();
			if (type == PoolInternal.POC_BOOL)
				return (String.valueOf(getBool()));
			if (type == PoolInternal.POC_DOUBLE)
				return (String.valueOf(getDouble()));
		}
		catch (PoolsException pe) {
			return pe.toString();
		}
		return "";	/* Stop the compiler complaining */
	}

        /**
         * Returns the value as a UnsignedInt64.
         *
         * @return the value as a UnsignedInt64.
         * @throws PoolsException if the value is not an
         * UnsignedInt64.
         */
	public final UnsignedInt64 getUnsignedInt64() throws PoolsException
	{
		return (getUnsignedInt64Value(_this));
	}

        /**
         * Returns the value as a long.
         *
         * @return the value as a long.
         * @throws PoolsException if the value is not a long.
         */
	public final long getLong() throws PoolsException
	{
		return (getLongValue(_this));
	}

        /**
         * Returns the value as a String.
         *
         * @return the value as a String.
         * @throws PoolsException if the value is not a String.
         */
	public final String getString() throws PoolsException
	{
		return (getStringValue(_this));
	}

        /**
         * Returns the value as a boolean.
         *
         * @return the value as a boolean.
         * @throws PoolsException if the value is not a boolean.
         */
	public final boolean getBool() throws PoolsException
	{
		return (getBoolValue(_this));
	}

        /**
         * Returns the value as a double.
         *
         * @return the value as a double.
         * @throws PoolsException if the value is not a double.
         */
	public final double getDouble() throws PoolsException
	{
		return (getDoubleValue(_this));
	}

        /**
         * Returns the value as a UnsignedInt64.
         *
         * @param pointer the native value to be accessed.
         * @return the value as a UnsignedInt64.
         */
	private final static native UnsignedInt64 getUnsignedInt64Value(
	    long pointer);

        /**
         * Returns the value as a long.
         *
         * @param pointer the native value to be accessed.
         * @return the value as a long.
         */
	private final static native long getLongValue(long pointer);

        /**
         * Returns the value as a String.
         *
         * @param pointer the native value to be accessed.
         * @return the value as a String.
         */
	private final static native String getStringValue(long pointer);

        /**
         * Returns the value as a boolean.
         *
         * @param pointer the native value to be accessed.
         * @return the value as a boolean.
         */
	private final static native boolean getBoolValue(long pointer);

        /**
         * Returns the value as a double.
         *
         * @param pointer the native value to be accessed.
         * @return the value as a double.
         */
	private final static native double getDoubleValue(long pointer);
}
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

Provides classes for manipulating Solaris Resource Pools. 


<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2000/136/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation, please see:
<ul>
  <li><a href="http://taxman.eng/projects/administrative-support-processor-sets/">Resource Pools Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

</body>
</html>
#
# 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 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# cmd/pools/poold/com/sun/solaris/service/logging/Makefile

include $(SRC)/cmd/Makefile.cmd

CLASSPATH =	$(SRC)/cmd/pools/poold

SOURCE =	RecurringEventTimer.java \
		SimpleRecurringEventTimer.java

all install: $(SOURCE:.java=.class)

# Since more than one class file can be generated from a java source
# file, any failure causes all class files to be removed.

.FAILED: clean

clean:
	$(RM) *class

include $(SRC)/cmd/Makefile.targ
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.timer;

/**
 * An interface for for a timer for handling a recurring event at a
 * uniform period.
 */
public interface RecurringEventTimer
{
	public void waitUntilNextFiring() throws InterruptedException;
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.service.timer;

/**
 * A recurring event timer.  Like all Java time consumers, which rely on
 * wall time, adjustments to the time of day will adversely affect the
 * accuracy of the period.
 */
public class SimpleRecurringEventTimer implements RecurringEventTimer
{
	/**
	 * Next time the event is to occur.
	 */
	private long nextFiring;

	/**
	 * Period between recurrences of the event, in milliseconds.
	 */
	private long period;

	/**
	 * Multiplier to convert seconds to milliseconds.
	 */
	public static final int SEC = 1000;

	/**
	 * Establishes a timer which will fire every 'period'
	 * milliseconds starting from now.
	 */
	public SimpleRecurringEventTimer(long period)
	{
		this.period = period;
		nextFiring = System.currentTimeMillis() + period;
	}

	/**
	 * Cause the current thread to wait until at least the time of
	 * the next event, as near as possible, unless interrupted.
	 *
	 * @throws InterruptedException if the thread is interrupted
	 * while waiting for the next firing.  Subsequent calls to this
	 * method will wait for the same firing.
	 */
	public void waitUntilNextFiring() throws InterruptedException
	{
		long delta;

		while ((delta = nextFiring - System.currentTimeMillis()) > 0)
			Thread.sleep(delta);

		nextFiring += period;
	}
}
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
    Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    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
    ident	"%Z%%M%	%I%	%E% SMI"
-->
</head>
<body bgcolor="white">

Provides classes implementing timers suitable for use by a daemon.

<h2>Package Specification</h2>

<ul>
  <li><a href="http://sac.eng.sun.com/arc/PSARC/2002/287/">PSARC Case Directory</a>
</ul>

<h2>Related Documentation</h2>

For overviews, tutorials, examples, guides, and tool documentation,
please see:
<ul>
  <li><a href="http://taxman.eng/projects/dynamic-resource-pools/">Dynamic Resource Pools Project Page</a>
</ul>

<!-- Put @see and @since tags down here. -->

</body>
</html>
#
# 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.
#
# Copyright 2020 Peter Tribble
#

include $(SRC)/lib/Makefile.lib

SUBDIRS = $(MACH64)

all :		TARGET = all
clean :	TARGET = clean
clobber :	TARGET = clobber
install :	TARGET = install

all install: $(SUBDIRS)

clean clobber:		$(SUBDIRS)

$(SUBDIRS):	FRC
	@cd $@; pwd; $(MAKE) $(TARGET)

FRC:

include $(SRC)/lib/Makefile.targ
include $(SRC)/Makefile.msg.targ
#
# 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.
#
# Copyright (c) 2018, Joyent, Inc.

LIBRARY =	libjkstat.a
VERS =		.1

OBJECTS =	jkstat.o

include $(SRC)/lib/Makefile.lib

INCS =	-I$(JAVA_ROOT)/include \
	-I$(JAVA_ROOT)/include/solaris

LIBS =		$(DYNLIB)
LDLIBS +=	-lkstat
ROOTLIBDIR =	$(ROOT)/usr/lib/pool

CFLAGS +=	$(CCVERBOSE)
CPPFLAGS +=	-D_REENTRANT -D_FILE_OFFSET_BITS=64 $(INCS)

# not linted
SMATCH=off

all: $(LIBS)

lint: lintcheck

include $(SRC)/lib/Makefile.targ
#
# This file and its contents are supplied under the terms of the
# Common Development and Distribution License ("CDDL"), version 1.0.
# You may only use this file in accordance with the terms of version
# 1.0 of the CDDL.
#
# A full copy of the text of the CDDL should have accompanied this
# source.  A copy of the CDDL is also available via the Internet at
# http://www.illumos.org/license/CDDL.
#

#
# Copyright 2017 Alexander Pyhalov
#

include ../Makefile.com
include $(SRC)/Makefile.master.64

install: all $(ROOTLIBS) $(ROOTLINKS)
/*
 * 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.
 */

#include <stddef.h>
#include <kstat.h>

#include "jkstat.h"

/*
 * Class descriptors
 */
#define	DOUBLE_CLASS_DESC	"java/lang/Double"
#define	LONG_CLASS_DESC		"java/lang/Long"
#define	UI64_CLASS_DESC		"com/sun/solaris/service/pools/UnsignedInt64"
#define	HRTIME_CLASS_DESC	"com/sun/solaris/service/pools/HRTime"
#define	KSTAT_CLASS_DESC	"com/sun/solaris/service/kstat/Kstat"
#define	KSTATCTL_CLASS_DESC	"com/sun/solaris/service/kstat/KstatCtl"
#define	KSTAT_READ_EX_CLASS_DESC \
	"com/sun/solaris/service/kstat/KstatReadException"
#define	KSTAT_TNS_EX_CLASS_DESC	\
	"com/sun/solaris/service/kstat/KstatTypeNotSupportedException"
#define	THROWABLE_CLASS_DESC	"java/lang/Throwable"

#define	CLASS_FIELD_DESC(class_desc)	"L" class_desc ";"

/*
 * Cached class, method, and field IDs.
 */
static jclass doubleclass;
static jclass hrtimeclass;
static jclass kstatclass;
static jclass kstatctlclass;
static jclass longclass;
static jclass ui64class;
static jfieldID kstat_kctl_fieldid;
static jfieldID kstat_ksp_fieldid;
static jfieldID kstatctl_kctl_fieldid;
static jmethodID doublecons_mid;
static jmethodID hrtimecons_mid;
static jmethodID kstatcons_mid;
static jmethodID longcons_mid;
static jmethodID ui64cons_mid;

static jobject
makeUnsignedInt64(JNIEnv *env, uint64_t value)
{
	jobject valueObj;
	jobject byteArray;
	jbyte *bytes;
	int i;

	if (!(byteArray = (*env)->NewByteArray(env, 9)))
		return (NULL); /* OutOfMemoryError thrown */
	if (!(bytes = (*env)->GetByteArrayElements(env, byteArray, NULL)))
		return (NULL); /* OutOfMemoryError thrown */

	/*
	 * Interpret the uint64_t as a 9-byte big-endian signed quantity
	 * suitable for constructing an UnsignedInt64 or BigInteger.
	 */
	for (i = 8; i >= 1; i--) {
		bytes[i] = value & 0xff;
		value >>= 8;
	}
	bytes[0] = 0;
	(*env)->ReleaseByteArrayElements(env, byteArray, bytes, 0);

	if (!(valueObj = (*env)->NewObject(env, ui64class, ui64cons_mid,
	    byteArray)))
		return (NULL); /* exception thrown */

	return (valueObj);
}

/*
 * Return a Long object with the given value.
 */
static jobject
makeLong(JNIEnv *env, jlong value)
{
	jobject valueObj;

	if (!(valueObj = (*env)->NewObject(env, longclass, longcons_mid,
	    value)))
		return (NULL); /* exception thrown */

	return (valueObj);
}

/*
 * Return a Double object with the given value.
 */
static jobject
makeDouble(JNIEnv *env, jdouble value)
{
	jobject valueObj;

	if (!(valueObj = (*env)->NewObject(env, doubleclass, doublecons_mid,
	    value)))
		return (NULL); /* exception thrown */

	return (valueObj);
}

/*
 * Returns the kctl_t * from kstat_open(3kstat).
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_kstat_KstatCtl_open(JNIEnv *env, jobject obj)
{
	return ((jlong)(uintptr_t)kstat_open());
}

/*
 * Invokes kstat_close(3kstat).
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_kstat_KstatCtl_close(JNIEnv *env, jobject obj,
    jlong kctl)
{
	if (kctl)
		return (kstat_close((kstat_ctl_t *)(uintptr_t)kctl));
	else
		return (0);
}

/*
 * Invoke kstat_read(3kstat) for the given Kstat object.
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_kstat_Kstat_read(
    JNIEnv *env, jobject obj)
{
	kstat_ctl_t *kctl =
	    ((kstat_ctl_t *)(uintptr_t)(*env)->GetLongField(env, obj,
	    kstat_kctl_fieldid));
	kstat_t *ksp = ((kstat_t *)(uintptr_t)(*env)->GetLongField(env, obj,
	    kstat_ksp_fieldid));
	kid_t kid;

	if (!ksp || !kctl)
		return; /* exception thronw */

	kid = kstat_read((kstat_ctl_t *)kctl, (kstat_t *)ksp, NULL);
	if (kid == -1) {
		jclass e;
		if (!(e = (*env)->FindClass(env, KSTAT_READ_EX_CLASS_DESC)))
			return; /* exception thrown */

		(*env)->Throw(env, (*env)->NewObject(env, e,
		    (*env)->GetStaticMethodID(env, e, "<init>",
		    "()" CLASS_FIELD_DESC(THROWABLE_CLASS_DESC))));
	}
}

/*
 * Return a Kstat object corresponding to the result of
 * kstat_lookup(3kstat).
 */
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_kstat_KstatCtl_lookup(JNIEnv *env, jobject obj,
    jstring moduleObj, jint instance, jstring nameObj)
{
	const char *module = NULL;
	const char *name = NULL;
	kstat_ctl_t *kctl;
	kstat_t *ksp;
	jobject kstatObject = NULL;

	if (moduleObj == NULL || nameObj == NULL)
		return (NULL);

	if (!(module = (*env)->GetStringUTFChars(env, moduleObj, NULL)))
		goto done; /* exception thrown */
	if (!(name = (*env)->GetStringUTFChars(env, nameObj, NULL)))
		goto done; /* exception thrown */

	kctl = (kstat_ctl_t *)(uintptr_t)(*env)->GetLongField(env, obj,
	    kstatctl_kctl_fieldid);
	ksp = kstat_lookup(kctl, (char *)module, instance, (char *)name);
	if (ksp)
		kstatObject = (*env)->NewObject(env, kstatclass, kstatcons_mid,
		    (jlong)(uintptr_t)kctl, (jlong)(uintptr_t)ksp);

done:
	if (name)
		(*env)->ReleaseStringUTFChars(env, nameObj, name);
	if (module)
		(*env)->ReleaseStringUTFChars(env, moduleObj, module);

	return (kstatObject);
}

/*
 * Returns the named value -- the value of the named kstat, or field in
 * a raw kstat, as applicable, and available.  Returns <i>null</i> if no
 * such named kstat or field is available.
 *
 * Throws KstatTypeNotSupportedException if the raw kstat is not
 * understood.  (Presently, none are.)
 */
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_kstat_Kstat_getValue(JNIEnv *env, jobject obj,
    jstring nameObj)
{
	kstat_t *ksp = ((kstat_t *)(uintptr_t)(*env)->GetLongField(env, obj,
	    kstat_ksp_fieldid));
	jobject valueObj = NULL;
	kstat_named_t *ksnp;
	const char *name;
	jclass exceptionClass;

	if (!nameObj)
		return (NULL);

	if (!(name = (*env)->GetStringUTFChars(env, nameObj, NULL)))
		return (NULL); /* exception thrown */

	if (!(exceptionClass = (*env)->FindClass(env,
	    KSTAT_TNS_EX_CLASS_DESC))) {
		(*env)->ReleaseStringUTFChars(env, nameObj, name);
		return (NULL); /* exception thrown */
	}

	switch (ksp->ks_type) {
	case KSTAT_TYPE_NAMED:
		ksnp = kstat_data_lookup(ksp, (char *)name);
		if (ksnp == NULL)
			break;
		switch (ksnp->data_type) {
		case KSTAT_DATA_CHAR:
			valueObj = makeLong(env, ksnp->value.c[0]);
			break;
		case KSTAT_DATA_INT32:
			valueObj = makeLong(env, ksnp->value.i32);
			break;
		case KSTAT_DATA_UINT32:
			valueObj = makeLong(env, ksnp->value.ui32);
			break;
		case KSTAT_DATA_INT64:
			valueObj = makeLong(env, ksnp->value.i64);
			break;
		case KSTAT_DATA_UINT64:
			valueObj = makeUnsignedInt64(env, ksnp->value.ui64);
			break;
		case KSTAT_DATA_STRING:
			valueObj = (*env)->NewStringUTF(env,
			    KSTAT_NAMED_STR_PTR(ksnp));
			break;
		case KSTAT_DATA_FLOAT:
			valueObj = makeDouble(env, ksnp->value.f);
			break;
		case KSTAT_DATA_DOUBLE:
			valueObj = makeDouble(env, ksnp->value.d);
			break;
		default:
			goto fail;
		}
		break;
	default:
		goto fail;
	}

	(*env)->ReleaseStringUTFChars(env, nameObj, name);
	return (valueObj);

fail:
	(*env)->ReleaseStringUTFChars(env, nameObj, name);
	(*env)->Throw(env, (*env)->NewObject(env, exceptionClass,
	    (*env)->GetStaticMethodID(env, exceptionClass, "<init>",
	    "()" CLASS_FIELD_DESC(THROWABLE_CLASS_DESC))));

	return (valueObj);
}

/*
 * Given a Kstat object, return, as an HRTime object, its kstat_t's
 * field at the given offset.
 */
static jobject
ksobj_get_hrtime(JNIEnv *env, jobject obj, offset_t ksfieldoff)
{
	kstat_t *ksp = ((kstat_t *)(uintptr_t)(*env)->GetLongField(env, obj,
	    kstat_ksp_fieldid));

	if (!ksp)
		return (NULL); /* exception thrown */

	return ((*env)->NewObject(env, hrtimeclass, hrtimecons_mid,
	    makeUnsignedInt64(env, *((hrtime_t *)ksp + ksfieldoff *
	    sizeof (hrtime_t)))));
}

/*
 * Given a Kstat object, return as an HRTime object its ks_snaptime
 * field.
 */
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_kstat_Kstat_getSnapTime(JNIEnv *env, jobject obj)
{
	return (ksobj_get_hrtime(env, obj, offsetof(kstat_t, ks_snaptime)));
}

/*
 * Given a Kstat object, return as an HRTime object its ks_crtime
 * field.
 */
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_kstat_Kstat_getCreationTime(JNIEnv *env,
    jobject obj)
{
	return (ksobj_get_hrtime(env, obj, offsetof(kstat_t, ks_crtime)));
}

/*
 * Invoke kstat_chain_update(3kstat) for the kstat chain corresponding
 * to the given KstatCtl object.
 */
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_kstat_KstatCtl_chainUpdate(JNIEnv *env,
    jobject obj)
{
	kstat_ctl_t *kctl;

	kctl = (kstat_ctl_t *)(uintptr_t)(*env)->GetLongField(env, obj,
	    kstatctl_kctl_fieldid);

	(void) kstat_chain_update(kctl);
}

/*
 * Cache class, method, and field IDs.
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_kstat_KstatCtl_init(JNIEnv *env, jclass clazz)
{
	jclass doubleclass_lref;
	jclass hrtimeclass_lref;
	jclass kstatclass_lref;
	jclass kstatctlclass_lref;
	jclass longclass_lref;
	jclass ui64class_lref;

	if (!(doubleclass_lref = (*env)->FindClass(env, DOUBLE_CLASS_DESC)))
		return; /* exception thrown */
	if (!(doubleclass = (*env)->NewGlobalRef(env, doubleclass_lref)))
		return; /* exception thrown */
	if (!(doublecons_mid = (*env)->GetMethodID(env, doubleclass, "<init>",
	    "(D)V")))
		return; /* exception thrown */

	if (!(hrtimeclass_lref = (*env)->FindClass(env, HRTIME_CLASS_DESC)))
		return; /* exception thrown */
	if (!(hrtimeclass = (*env)->NewGlobalRef(env, hrtimeclass_lref)))
		return; /* exception thrown */
	if (!(hrtimecons_mid = (*env)->GetMethodID(env, hrtimeclass, "<init>",
	    "(" CLASS_FIELD_DESC(UI64_CLASS_DESC) ")V")))
		return; /* exception thrown */

	if (!(kstatclass_lref = (*env)->FindClass(env, KSTAT_CLASS_DESC)))
		return; /* exception thrown */
	if (!(kstatclass = (*env)->NewGlobalRef(env, kstatclass_lref)))
		return; /* exception thrown */
	if (!(kstatcons_mid = (*env)->GetMethodID(env, kstatclass, "<init>",
	    "(JJ)V")))
		return; /* exception thrown */
	if (!(kstat_kctl_fieldid = (*env)->GetFieldID(env, kstatclass, "kctl",
	    "J")))
		return; /* exception thrown */
	if (!(kstat_ksp_fieldid = (*env)->GetFieldID(env, kstatclass, "ksp",
	    "J")))
		return; /* exception thrown */

	if (!(kstatctlclass_lref = (*env)->FindClass(env, KSTATCTL_CLASS_DESC)))
		return; /* exception thrown */
	if (!(kstatctlclass = (*env)->NewGlobalRef(env, kstatctlclass_lref)))
		return; /* exception thrown */
	if (!(kstatctl_kctl_fieldid = (*env)->GetFieldID(env, kstatctlclass,
	    "kctl", "J")))
		return; /* exception thrown */

	if (!(longclass_lref = (*env)->FindClass(env, LONG_CLASS_DESC)))
		return; /* exception thrown */
	if (!(longclass = (*env)->NewGlobalRef(env, longclass_lref)))
		return; /* exception thrown */
	if (!(longcons_mid = (*env)->GetMethodID(env, longclass, "<init>",
	    "(J)V")))
		return; /* exception thrown */

	if (!(ui64class_lref = (*env)->FindClass(env, UI64_CLASS_DESC)))
		return; /* exception thrown */
	if (!(ui64class = (*env)->NewGlobalRef(env, ui64class_lref)))
		return; /* exception thrown */
	ui64cons_mid = (*env)->GetMethodID(env, ui64class, "<init>", "([B)V");
}
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_sun_solaris_service_kstat_Kstat */

#ifndef _Included_com_sun_solaris_service_kstat_Kstat
#define _Included_com_sun_solaris_service_kstat_Kstat
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_sun_solaris_service_kstat_Kstat
 * Method:    getSnapTime
 * Signature: ()Lcom/sun/solaris/service/pools/HRTime;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_kstat_Kstat_getSnapTime
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_kstat_Kstat
 * Method:    getCreationTime
 * Signature: ()Lcom/sun/solaris/service/pools/HRTime;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_kstat_Kstat_getCreationTime
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_kstat_Kstat
 * Method:    getValue
 * Signature: (Ljava/lang/String;)Ljava/lang/Object;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_kstat_Kstat_getValue
  (JNIEnv *, jobject, jstring);

/*
 * Class:     com_sun_solaris_service_kstat_Kstat
 * Method:    read
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_kstat_Kstat_read
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
/* Header for class com_sun_solaris_service_kstat_KstatCtl */

#ifndef _Included_com_sun_solaris_service_kstat_KstatCtl
#define _Included_com_sun_solaris_service_kstat_KstatCtl
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_sun_solaris_service_kstat_KstatCtl
 * Method:    open
 * Signature: ()J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_kstat_KstatCtl_open
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_kstat_KstatCtl
 * Method:    close
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_kstat_KstatCtl_close
  (JNIEnv *, jobject, jlong);

/*
 * Class:     com_sun_solaris_service_kstat_KstatCtl
 * Method:    lookup
 * Signature: (Ljava/lang/String;ILjava/lang/String;)Lcom/sun/solaris/service/kstat/Kstat;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_kstat_KstatCtl_lookup
  (JNIEnv *, jobject, jstring, jint, jstring);

/*
 * Class:     com_sun_solaris_service_kstat_KstatCtl
 * Method:    chainUpdate
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_kstat_KstatCtl_chainUpdate
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_kstat_KstatCtl
 * Method:    init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_kstat_KstatCtl_init
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif
#
# 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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
#

#
# MAPFILE HEADER START
#
# WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
# Object versioning must comply with the rules detailed in
#
#	usr/src/lib/README.mapfiles
#
# You should not be making modifications here until you've read the most current
# copy of that file. If you need help, contact a gatekeeper for guidance.
#
# MAPFILE HEADER END
#

$mapfile_version 2

SYMBOL_VERSION SUNWprivate_1.1 {
    global:
	Java_com_sun_solaris_service_kstat_KstatCtl_chainUpdate;
	Java_com_sun_solaris_service_kstat_KstatCtl_close;
	Java_com_sun_solaris_service_kstat_KstatCtl_init;
	Java_com_sun_solaris_service_kstat_KstatCtl_lookup;
	Java_com_sun_solaris_service_kstat_KstatCtl_open;
	Java_com_sun_solaris_service_kstat_Kstat_getCreationTime;
	Java_com_sun_solaris_service_kstat_Kstat_getSnapTime;
	Java_com_sun_solaris_service_kstat_Kstat_getValue;
	Java_com_sun_solaris_service_kstat_Kstat_read;
    local:
	*;
};
#
# 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.
#
# Copyright 2020 Peter Tribble
#

include $(SRC)/lib/Makefile.lib

SUBDIRS = $(MACH64)

all :		TARGET = all
clean :	TARGET = clean
clobber :	TARGET = clobber
install :	TARGET = install

all install: $(SUBDIRS)

clean clobber:		$(SUBDIRS)

$(SUBDIRS):	FRC
	@cd $@; pwd; $(MAKE) $(TARGET)

FRC:

include $(SRC)/lib/Makefile.targ
include $(SRC)/Makefile.msg.targ
#
# 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.
#
# Copyright (c) 2018, Joyent, Inc.

LIBRARY =	libjlgrp.a
VERS =		.1

OBJECTS =	jlgrp.o

include $(SRC)/lib/Makefile.lib

INCS =	-I$(JAVA_ROOT)/include \
	-I$(JAVA_ROOT)/include/solaris

LIBS =		$(DYNLIB)
LDLIBS +=	-llgrp -lc
ROOTLIBDIR =	$(ROOT)/usr/lib/pool

CFLAGS +=	$(CCVERBOSE)
CPPFLAGS +=	-D_REENTRANT -D_FILE_OFFSET_BITS=64 $(INCS)

# not linted
SMATCH=off

all: $(LIBS)

lint: lintcheck

include $(SRC)/lib/Makefile.targ
#
# This file and its contents are supplied under the terms of the
# Common Development and Distribution License ("CDDL"), version 1.0.
# You may only use this file in accordance with the terms of version
# 1.0 of the CDDL.
#
# A full copy of the text of the CDDL should have accompanied this
# source.  A copy of the CDDL is also available via the Internet at
# http://www.illumos.org/license/CDDL.
#

#
# Copyright 2017 Alexander Pyhalov
#

include ../Makefile.com
include $(SRC)/Makefile.master.64

install: all $(ROOTLIBS) $(ROOTLINKS)
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <sys/lgrp_user.h>

#include "jlgrp.h"

static lgrp_cookie_t getCookie(JNIEnv *, jclass, jobject);
static void throwException(JNIEnv *, const char *, const char *);

/*
 * Return the output of the getCookie() method executed on the
 * supplied instance.
 */
lgrp_cookie_t
getCookie(JNIEnv *env, jclass clazz, jobject obj)
{
	jfieldID fid;

	fid = (*env)->GetFieldID(env, clazz, "cookie", "J");
	return ((lgrp_cookie_t)(*env)->GetLongField(env, obj, fid));
}

/*
 * Throw an exception of the specified class with the specified message.
 */
void
throwException(JNIEnv *env, const char *class, const char *msg)
{
	jclass clazz;

	clazz = (*env)->FindClass(env, class);

	(*env)->ThrowNew(env, clazz, msg);
}

/*
 * Obtain an lgrp cookie for an lgrp snapshot which contains details
 * about available resources that the operating system knows about.
 *
 * If the call fails, then throw an exception which indicates that the
 * snapshot could not be obtained.
 */
/*ARGSUSED1*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_locality_LocalityDomain_jl_1init(JNIEnv *env,
    jobject obj, jint view)
{
	lgrp_cookie_t cookie;

	if ((cookie = lgrp_init(view)) == LGRP_COOKIE_NONE) {
		throwException(env, "java/lang/Exception",
		    "Could not obtain latency group cookie");
	}

	return ((jlong)cookie);
}

/*
 * Release the snapshot in use by this instance. It is assumed that
 * the cookie is held in the "cookie" field of the invoking instance
 */
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_locality_LocalityDomain_jl_1fini(JNIEnv *env,
    jobject obj)
{
	jclass clazz;

	clazz = (*env)->GetObjectClass(env, obj);
	return ((jint)lgrp_fini(getCookie(env, clazz, obj)));
}

/*
 * Create a new LocalityGroup object which acts as a proxy for the
 * root LocalityGroup.
 */
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_locality_LocalityDomain_jl_1root(JNIEnv *env,
    jobject obj)
{
	jclass clazz;
	jmethodID mid;
	jlong root;
	jobject lgrp;

	clazz = (*env)->GetObjectClass(env, obj);

	root = (jlong) lgrp_root(getCookie(env, clazz, obj));

	clazz = (*env)->FindClass(env, "com/sun/solaris/service/locality/"
	    "LocalityGroup");
	mid = (*env)->GetMethodID(env, clazz, "<init>", "(Lcom/sun/solaris/"
	    "service/locality/LocalityDomain;JLcom/sun/solaris/service/"
	    "locality/LocalityGroup;)V");
	lgrp = (*env)->NewObject(env, clazz, mid, obj, root, NULL);
	return (lgrp);
}

/*
 * Return a new array containing all of the child LocalityGroup ids
 * for the supplied instance.
 */
JNIEXPORT jlongArray JNICALL
Java_com_sun_solaris_service_locality_LocalityGroup_jl_1children(JNIEnv *env,
    jobject obj)
{
	jclass clazz;
	jfieldID fid;
	lgrp_cookie_t cookie;
	jlong id;
	jsize nchild0, nchild;
	jlongArray children;
	int i;
	lgrp_id_t *native_child;
	jlong *java_child;
	jobject domain;

	clazz = (*env)->GetObjectClass(env, obj);
	fid = (*env)->GetFieldID(env, clazz, "domain",
	    "Lcom/sun/solaris/service/locality/LocalityDomain;");
	domain = (*env)->GetObjectField(env, obj, fid);

	cookie = getCookie(env, (*env)->GetObjectClass(env, domain), domain);
	fid = (*env)->GetFieldID(env, clazz, "id", "J");
	id = (*env)->GetLongField(env, obj, fid);
retry:
	nchild0 = (jsize)lgrp_children(cookie, (lgrp_id_t)id, NULL, 0);
	children = (*env)->NewLongArray(env, nchild0);
	if ((native_child = calloc(nchild0, sizeof (lgrp_id_t))) == NULL) {
		throwException(env, "java/lang/Exception",
		    "Could not allocate memory for native_child array");
		return (NULL);
	}
	nchild = lgrp_children(cookie, (lgrp_id_t)id, native_child, nchild0);
	if (nchild != nchild0) {
		free(native_child);
		goto retry;
	}

	if ((java_child = calloc(nchild, sizeof (jlong))) == NULL) {
		throwException(env, "java/lang/Exception",
		    "Could not allocate memory for java_child array");
		free(native_child);
		return (NULL);
	}

	for (i = 0; i < nchild; i++)
		java_child[i] = (jlong) native_child[i];
	(*env)->SetLongArrayRegion(env, children, 0, nchild, java_child);
	free(native_child);
	free(java_child);
	return (children);
}

/*
 * Return a new array containing all of the cpus contained directly
 * within the LocalityGroup identified by the supplied instance.
 */
JNIEXPORT jintArray JNICALL
Java_com_sun_solaris_service_locality_LocalityGroup_jl_1cpus(JNIEnv *env,
    jobject obj)
{
	jclass clazz;
	jfieldID fid;
	lgrp_cookie_t cookie;
	jlong id;
	jsize ncpus0, ncpus;
	jintArray cpus;
	int i;
	processorid_t *native_cpus;
	jint *java_cpus;
	jobject domain;

	clazz = (*env)->GetObjectClass(env, obj);
	fid = (*env)->GetFieldID(env, clazz, "domain",
	    "Lcom/sun/solaris/service/locality/LocalityDomain;");
	domain = (*env)->GetObjectField(env, obj, fid);

	cookie = getCookie(env, (*env)->GetObjectClass(env, domain), domain);

	fid = (*env)->GetFieldID(env, clazz, "id", "J");
	id = (*env)->GetLongField(env, obj, fid);
retry:
	ncpus0 = (jsize)lgrp_cpus((lgrp_cookie_t)cookie, (lgrp_id_t)id,
	    NULL, 0, LGRP_CONTENT_DIRECT);
	cpus = (*env)->NewIntArray(env, ncpus0);
	if ((native_cpus = calloc(ncpus0, sizeof (processorid_t))) == NULL) {
		throwException(env, "java/lang/Exception",
		    "Could not allocate memory for native_cpus array");
		return (NULL);
	}
	ncpus = (jsize)lgrp_cpus((lgrp_cookie_t)cookie, (lgrp_id_t)id,
	    native_cpus, ncpus0, LGRP_CONTENT_DIRECT);
	if (ncpus != ncpus0) {
		free(native_cpus);
		goto retry;
	}

	if ((java_cpus = calloc(ncpus, sizeof (jint))) == NULL) {
		free(native_cpus);
		throwException(env, "java/lang/Exception",
		    "Could not allocate memory for java_cpus array");
		return (NULL);
	}

	for (i = 0; i < ncpus; i++)
		java_cpus[i] = (jint)native_cpus[i];
	(*env)->SetIntArrayRegion(env, cpus, 0, ncpus, java_cpus);
	free(native_cpus);
	free(java_cpus);
	return (cpus);
}

/*
 * Return the latency between two supplied latency group IDs.
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_locality_LocalityGroup_jl_1latency(JNIEnv *env,
    jobject obj, jlong from, jlong to)
{
	return ((jint) lgrp_latency((lgrp_id_t)from, (lgrp_id_t)to));
}
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_sun_solaris_service_locality_LocalityDomain */

#ifndef _Included_com_sun_solaris_service_locality_LocalityDomain
#define _Included_com_sun_solaris_service_locality_LocalityDomain
#ifdef __cplusplus
extern "C" {
#endif
#undef com_sun_solaris_service_locality_LocalityDomain_LGRP_VIEW_CALLER
#define com_sun_solaris_service_locality_LocalityDomain_LGRP_VIEW_CALLER 0L
#undef com_sun_solaris_service_locality_LocalityDomain_LGRP_VIEW_OS
#define com_sun_solaris_service_locality_LocalityDomain_LGRP_VIEW_OS 1L
/*
 * Class:     com_sun_solaris_service_locality_LocalityDomain
 * Method:    jl_init
 * Signature: (I)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_locality_LocalityDomain_jl_1init
  (JNIEnv *, jobject, jint);

/*
 * Class:     com_sun_solaris_service_locality_LocalityDomain
 * Method:    jl_fini
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_locality_LocalityDomain_jl_1fini
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_locality_LocalityDomain
 * Method:    jl_root
 * Signature: ()Lcom/sun/solaris/service/locality/LocalityGroup;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_locality_LocalityDomain_jl_1root
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
/* Header for class com_sun_solaris_service_locality_LocalityGroup */

#ifndef _Included_com_sun_solaris_service_locality_LocalityGroup
#define _Included_com_sun_solaris_service_locality_LocalityGroup
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_sun_solaris_service_locality_LocalityGroup
 * Method:    jl_children
 * Signature: ()[J
 */
JNIEXPORT jlongArray JNICALL Java_com_sun_solaris_service_locality_LocalityGroup_jl_1children
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_locality_LocalityGroup
 * Method:    jl_cpus
 * Signature: ()[I
 */
JNIEXPORT jintArray JNICALL Java_com_sun_solaris_service_locality_LocalityGroup_jl_1cpus
  (JNIEnv *, jobject);

/*
 * Class:     com_sun_solaris_service_locality_LocalityGroup
 * Method:    jl_latency
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_locality_LocalityGroup_jl_1latency
  (JNIEnv *, jobject, jlong, jlong);

#ifdef __cplusplus
}
#endif
#endif
#
# 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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
#

#
# MAPFILE HEADER START
#
# WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
# Object versioning must comply with the rules detailed in
#
#	usr/src/lib/README.mapfiles
#
# You should not be making modifications here until you've read the most current
# copy of that file. If you need help, contact a gatekeeper for guidance.
#
# MAPFILE HEADER END
#

$mapfile_version 2

SYMBOL_VERSION SUNWprivate_1.1 {
    global:
	Java_com_sun_solaris_service_locality_LocalityDomain_jl_1fini;
	Java_com_sun_solaris_service_locality_LocalityDomain_jl_1init;
	Java_com_sun_solaris_service_locality_LocalityDomain_jl_1root;
	Java_com_sun_solaris_service_locality_LocalityGroup_jl_1children;
	Java_com_sun_solaris_service_locality_LocalityGroup_jl_1cpus;
	Java_com_sun_solaris_service_locality_LocalityGroup_jl_1latency;
    local:
	*;
};
#
# 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.
#
# Copyright 2020 Peter Tribble
#

include $(SRC)/lib/Makefile.lib

SUBDIRS = $(MACH64)

all :		TARGET = all
clean :	TARGET = clean
clobber :	TARGET = clobber
install :	TARGET = install

all install: $(SUBDIRS)

clean clobber:		$(SUBDIRS)

$(SUBDIRS):	FRC
	@cd $@; pwd; $(MAKE) $(TARGET)

FRC:

include $(SRC)/lib/Makefile.targ
include $(SRC)/Makefile.msg.targ
#
# 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.
#
# Copyright (c) 2018, Joyent, Inc.

LIBRARY =	libjpool.a
VERS =		.1

OBJECTS =	jpool.o

include $(SRC)/lib/Makefile.lib

INCS =	-I$(JAVA_ROOT)/include \
	-I$(JAVA_ROOT)/include/solaris

LIBS =		$(DYNLIB)
LDLIBS +=	-lpool -lc
ROOTLIBDIR =	$(ROOT)/usr/lib/pool

CFLAGS +=	$(CCVERBOSE)
CPPFLAGS +=	-D_REENTRANT -D_FILE_OFFSET_BITS=64 $(INCS)

# not linted
SMATCH=off

all: $(LIBS)

lint: lintcheck

include $(SRC)/lib/Makefile.targ
#
# This file and its contents are supplied under the terms of the
# Common Development and Distribution License ("CDDL"), version 1.0.
# You may only use this file in accordance with the terms of version
# 1.0 of the CDDL.
#
# A full copy of the text of the CDDL should have accompanied this
# source.  A copy of the CDDL is also available via the Internet at
# http://www.illumos.org/license/CDDL.
#

#
# Copyright 2017 Alexander Pyhalov
#

include ../Makefile.com
include $(SRC)/Makefile.master.64

install: all $(ROOTLIBS) $(ROOTLINKS)
/*
 * 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.
 */

#include <errno.h>
#include <jni.h>
#include <pool.h>
#include <stdlib.h>
#include <string.h>

#include <sys/time.h>

#include "jpool.h"

struct pool_callback {
	jobject	pc_user;
	jobject	pc_handler;
	jobject	pc_elem;
	JNIEnv	*pc_env;
};

static void throwException(JNIEnv *, const char *, const char *);
static void throw_pe(JNIEnv *);
static jobject makeUnsignedInt64(JNIEnv *, uint64_t);
static int pool_property_walker(pool_conf_t *, pool_elem_t *p, const char *,
    pool_value_t *, void *);
static jobject copyArray(JNIEnv *, void **);

/*
 * Cached class, method, and field IDs.
 */
static jclass ui64class;
static jmethodID ui64cons_mid;

/*
 * Throw an exception of the specified class with the specified message.
 */
void
throwException(JNIEnv *env, const char *class, const char *msg)
{
	jclass clazz;

	clazz = (*env)->FindClass(env, class);

	(*env)->ThrowNew(env, clazz, msg);
}

/*
 * Throw a PoolsException.
 */
void
throw_pe(JNIEnv *jenv)
{
	jclass clazz;
	jmethodID mid;
	jthrowable throwObj;

	clazz = (*jenv)->FindClass(jenv,
	    "com/sun/solaris/service/pools/PoolsException");
	mid = (*jenv)->GetMethodID(jenv, clazz, "<init>", "()V");
	throwObj = (*jenv)->NewObject(jenv, clazz, mid);
	(*jenv)->Throw(jenv, throwObj);
}

/*
 * Return an instance of an UnsignedInt64 class which encapsulates the
 * supplied value.
 */
jobject
makeUnsignedInt64(JNIEnv *env, uint64_t value)
{
	jobject valueObj;
	jobject byteArray;
	jbyte *bytes;
	int i;

	if (!(byteArray = (*env)->NewByteArray(env, 9)))
		return (NULL); /* OutOfMemoryError thrown */
	if (!(bytes = (*env)->GetByteArrayElements(env, byteArray, NULL)))
		return (NULL); /* OutOfMemoryError thrown */

	/*
	 * Interpret the uint64_t as a 9-byte big-endian signed quantity
	 * suitable for constructing an UnsignedInt64 or BigInteger.
	 */
	for (i = 8; i >= 1; i--) {
		bytes[i] = value & 0xff;
		value >>= 8;
	}
	bytes[0] = 0;
	(*env)->ReleaseByteArrayElements(env, byteArray, bytes, 0);

	if (!(valueObj = (*env)->NewObject(env, ui64class, ui64cons_mid,
	    byteArray)))
		return (NULL); /* exception thrown */

	return (valueObj);
}

/*
 * Create an array list and then copy the native array into it
 */
jobject
copyArray(JNIEnv *jenv, void **nativeArray)
{
	int i;
	jobject jresult = NULL;

	if (nativeArray != NULL) {
		jclass ALclazz;
		jmethodID ALinit, ALadd;
		jclass Lclazz;
		jmethodID Linit;

		ALclazz = (*jenv)->FindClass(jenv,
		    "java/util/ArrayList");
		ALinit = (*jenv)->GetMethodID(jenv,
		    ALclazz, "<init>", "()V");
		ALadd = (*jenv)->GetMethodID(jenv,
		    ALclazz, "add", "(Ljava/lang/Object;)Z");
		jresult = (*jenv)->NewObject(jenv, ALclazz, ALinit);
		Lclazz = (*jenv)->FindClass(jenv, "java/lang/Long");
		Linit = (*jenv)->GetMethodID(jenv,
		    Lclazz, "<init>", "(J)V");
		for (i = 0; nativeArray[i] != NULL; i++) {
			jobject L;
			/* Build longs and add them */
			L = (*jenv)->NewObject(jenv,
			    Lclazz, Linit, (jlong)(uintptr_t)nativeArray[i]);
			(*jenv)->CallBooleanMethod(jenv,
			    jresult, ALadd, L);
		}
		free(nativeArray);
	}
	return (jresult);
}

/*
 * pool_version(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1version(JNIEnv *jenv,
    jclass jcls, jlong jver)
{
	return ((jlong)pool_version((uint_t)jver));
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1NATIVE(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POX_NATIVE);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1TEXT(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POX_TEXT);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INVAL(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POC_INVAL);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1UINT(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POC_UINT);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INT(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POC_INT);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1DOUBLE(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POC_DOUBLE);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1BOOL(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POC_BOOL);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1STRING(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POC_STRING);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1NONE(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POV_NONE);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1LOOSE(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POV_LOOSE);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1STRICT(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POV_STRICT);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1RUNTIME(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POV_RUNTIME);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1INVALID(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POF_INVALID);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1VALID(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POF_VALID);
}

/*
 * native constant accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1DESTROY(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)POF_DESTROY);
}

/*
 * pool_error(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1error(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)pool_error());
}

/*
 * pool_strerror(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror(JNIEnv *jenv,
    jclass jcls, jint jperr)
{
	jstring jresult = NULL;
	char *result;

	result = (char *)pool_strerror((int)jperr);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	return (jresult);
}

/*
 * strerror(3c) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror_1sys(JNIEnv *
    jenv, jclass jcls)
{
	jstring jresult = NULL;
	char *result;

	result = (char *)strerror(errno);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	return (jresult);
}

/*
 * errno(3c) accessor
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolsException_getErrno(JNIEnv *jenv,
    jclass jcls)
{
	return ((jint)errno);
}

/*
 * pool_resource_type_list(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1type_1list(
    JNIEnv *jenv, jclass jcls, jlong jreslist, jlong jnumres)
{
	char **reslist = (char **)(uintptr_t)jreslist;
	uint_t *numres = (uint_t *)(uintptr_t)jnumres;

	return ((jint)pool_resource_type_list((char const **)reslist, numres));
}

/*
 * pool_get_status(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1status(JNIEnv *jenv,
    jclass jcls)
{
	int status;
	int err;

	err = pool_get_status(&status);
	if (err == -1)
		return ((jint)PO_FAIL);
	else
		return ((jint)status);
}

/*
 * pool_set_status(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1status(JNIEnv *jenv,
    jclass jcls, jint jstate)
{
	return ((jint)pool_set_status((int)jstate));
}

/*
 * pool_conf_alloc(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1alloc(JNIEnv *jenv,
    jclass jcls)
{
	return ((jlong)(uintptr_t)pool_conf_alloc());
}

/*
 * pool_conf_free(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1free(JNIEnv *jenv,
    jclass jcls, jlong jconf)
{
	pool_conf_free((pool_conf_t *)(uintptr_t)jconf);
}

/*
 * pool_conf_status(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1status(JNIEnv *jenv,
    jclass jcls, jlong jconf)
{
	return ((jint)pool_conf_status((pool_conf_t *)(uintptr_t)jconf));
}

/*
 * pool_conf_close(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1close(JNIEnv *jenv,
    jclass jcls, jlong jconf)
{
	return ((jint)pool_conf_close((pool_conf_t *)(uintptr_t)jconf));
}

/*
 * pool_conf_remove(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1remove(JNIEnv *jenv,
    jclass jcls, jlong jconf)
{
	return ((jint)pool_conf_remove((pool_conf_t *)(uintptr_t)jconf));
}

/*
 * pool_conf_open(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1open(JNIEnv *jenv,
    jclass jcls, jlong jconf, jstring jlocation, jint jflags)
{
	const char *location;
	int result;

	location = (jlocation) ? (*jenv)->GetStringUTFChars(jenv,
	    jlocation, 0) : NULL;
	result = (int)pool_conf_open((pool_conf_t *)(uintptr_t)jconf, location,
	    (int)jflags);

	if (location)
		(*jenv)->ReleaseStringUTFChars(jenv, jlocation, location);
	return ((jint)result);
}

/*
 * pool_conf_rollback(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1rollback(
    JNIEnv *jenv, jclass jcls, jlong jconf)
{
	return ((jint)pool_conf_rollback((pool_conf_t *)(uintptr_t)jconf));
}

/*
 * pool_conf_commit(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1commit(JNIEnv *jenv,
    jclass jcls, jlong jconf, jint jactive)
{
	return ((jint)pool_conf_commit(
	    (pool_conf_t *)(uintptr_t)jconf, (int)jactive));
}

/*
 * pool_conf_export(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1export(JNIEnv *jenv,
    jclass jcls, jlong jconf, jstring jlocation, jint jformat)
{
	const char *location;
	int result;

	location = (jlocation) ? (*jenv)->GetStringUTFChars(jenv,
	    jlocation, 0) : NULL;
	result = (int)pool_conf_export((pool_conf_t *)(uintptr_t)jconf,
	    location, (pool_export_format_t)jformat);

	if (location)
		(*jenv)->ReleaseStringUTFChars(jenv, jlocation, location);
	return ((jint)result);
}

/*
 * pool_conf_validate(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1validate(
    JNIEnv *jenv, jclass jcls, jlong jconf, jint jlevel)
{
	return ((jint)pool_conf_validate((pool_conf_t *)(uintptr_t)jconf,
	    (pool_valid_level_t)jlevel));
}

/*
 * pool_conf_update(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1update(JNIEnv *jenv,
    jclass jcls, jlong jconf)
{
	int changed;
	int result;

	result = pool_conf_update((pool_conf_t *)(uintptr_t)jconf, &changed);

	if (result != PO_SUCCESS) {
		throw_pe(jenv);
	}

	return ((jint)changed);
}

/*
 * pool_get_pool(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1pool(JNIEnv *jenv,
    jclass jcls, jlong jconf, jstring jname)
{
	const char *name;
	pool_t *result;

	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) :
	    NULL;
	result = (pool_t *)pool_get_pool((pool_conf_t *)(uintptr_t)jconf, name);

	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jlong)(uintptr_t)result);
}

/*
 * pool_query_pools(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pools(JNIEnv *jenv,
    jclass jcls, jlong jconf, jobject jprops)
{
	pool_value_t **props;
	pool_t **result;
	jclass Lclazz;
	jmethodID Lsize;
	jint size;
	uint_t nelem;
	int i;


	/*
	 * Initialize the target parameter for case when input is null
	 */
	props = NULL;
	if (jprops != NULL) {
		Lclazz = (*jenv)->GetObjectClass(jenv, jprops);
		Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I");
		size = (*jenv)->CallIntMethod(jenv, jprops, Lsize);

		if (size != 0) {
			jmethodID Lget;

			Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get",
			    "(I)Ljava/lang/Object;");
			/*
			 * Allocate space for the props array
			 */

			if ((props = calloc(size + 1, sizeof (pool_value_t *)))
			    == NULL) {
				throwException(jenv, "java/lang/Exception",
				    "Could not allocate props array");
				return (NULL);
			}
			/*
			 * Copy in the array
			 */
			for (i = 0; i < size; i++) {
				jobject aVal;
				jclass Vclazz;
				jfieldID Vthis;
				jlong this;

				aVal = (*jenv)->CallObjectMethod(jenv, jprops,
				    Lget, (jint) i);
				Vclazz = (*jenv)->GetObjectClass(jenv, aVal);
				Vthis = (*jenv)->GetFieldID(jenv, Vclazz,
				    "_this", "J");
				this = (*jenv)->GetLongField(jenv, aVal, Vthis);
				props[i] = (pool_value_t *)(uintptr_t)this;
			}
		}
	}
	result = pool_query_pools((pool_conf_t *)(uintptr_t)jconf, &nelem,
	    props);
	free(props);
	return (copyArray(jenv, (void **)result));
}

/*
 * pool_get_resource(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource(
    JNIEnv *jenv, jclass jcls, jlong jconf, jstring jtype, jstring jname)
{
	const char *type;
	const char *name;
	pool_resource_t *result;

	type = (jtype) ? (*jenv)->GetStringUTFChars(jenv, jtype, 0) :
	    NULL;
	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) :
	    NULL;
	result = pool_get_resource((pool_conf_t *)(uintptr_t)jconf, type, name);

	if (type)
		(*jenv)->ReleaseStringUTFChars(jenv, jtype, type);
	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jlong)(uintptr_t)result);
}

/*
 * pool_query_resources(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resources(
    JNIEnv *jenv, jclass jcls, jlong jconf, jobject jprops)
{
	pool_value_t **props;
	pool_resource_t **result;
	jclass Lclazz;
	jmethodID Lsize;
	jint size;
	uint_t nelem;
	int i;

	/*
	 * Initialize the target parameter for case when input is null
	 */
	props = NULL;
	if (jprops != NULL) {
		Lclazz = (*jenv)->GetObjectClass(jenv, jprops);
		Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I");
		size = (*jenv)->CallIntMethod(jenv, jprops, Lsize);

		if (size != 0) {
			jmethodID Lget;

			Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get",
			    "(I)Ljava/lang/Object;");
			/*
			 * Allocate space for the props array
			 */
			if ((props = calloc(size + 1, sizeof (pool_value_t *)))
			    == NULL) {
				throwException(jenv, "java/lang/Exception",
				    "Could not allocate props array");
				return (NULL);
			}
			/*
			 * Copy in the array
			 */
			for (i = 0; i < size; i++) {
				jobject aVal;
				jclass Vclazz;
				jfieldID Vthis;
				jlong this;


				aVal = (*jenv)->CallObjectMethod(jenv, jprops,
				    Lget, (jint) i);
				Vclazz = (*jenv)->GetObjectClass(jenv, aVal);
				Vthis = (*jenv)->GetFieldID(jenv, Vclazz,
				    "_this", "J");
				this = (*jenv)->GetLongField(jenv, aVal, Vthis);
				props[i] = (pool_value_t *)(uintptr_t)this;
			}
		}
	}
	result = pool_query_resources((pool_conf_t *)(uintptr_t)jconf, &nelem,
	    props);
	free(props);
	return (copyArray(jenv, (void *)result));
}

/*
 * pool_query_components(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1components(
    JNIEnv *jenv, jclass jcls, jlong jconf, jobject jprops)
{
	pool_value_t **props;
	pool_component_t **result;
	jclass Lclazz;
	jmethodID Lsize;
	jint size;
	uint_t nelem;
	int i;

	/*
	 * Initialize the target parameter for case when input is null
	 */
	props = NULL;
	if (jprops != NULL) {
		Lclazz = (*jenv)->GetObjectClass(jenv, jprops);
		Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I");
		size = (*jenv)->CallIntMethod(jenv, jprops, Lsize);

		if (size != 0) {
			jmethodID Lget;

			Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get",
			    "(I)Ljava/lang/Object;");
			/*
			 * Allocate space for the props array
			 */

			if ((props = calloc(size + 1, sizeof (pool_value_t *)))
			    == NULL) {
				throwException(jenv, "java/lang/Exception",
				    "Could not allocate props array");
				return (NULL);
			}
			/*
			 * Copy in the array
			 */
			for (i = 0; i < size; i++) {
				jobject aVal;
				jclass Vclazz;
				jfieldID Vthis;
				jlong this;

				aVal = (*jenv)->CallObjectMethod(jenv, jprops,
				    Lget, (jint) i);
				Vclazz = (*jenv)->GetObjectClass(jenv, aVal);
				Vthis = (*jenv)->GetFieldID(jenv, Vclazz,
				    "_this", "J");
				this = (*jenv)->GetLongField(jenv, aVal, Vthis);
				props[i] = (pool_value_t *)(uintptr_t)this;
			}
		}
	}
	result = pool_query_components((pool_conf_t *)(uintptr_t)jconf, &nelem,
	    props);
	free(props);
	return (copyArray(jenv, (void **)result));
}

/*
 * pool_conf_location(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1location(
    JNIEnv *jenv, jclass jcls, jlong jconf)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_conf_location((pool_conf_t *)(uintptr_t)jconf);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	return (jresult);
}

/*
 * pool_conf_info(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1info(JNIEnv *jenv,
    jclass jcls, jlong jconf, jint jflags)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_conf_info((pool_conf_t *)(uintptr_t)jconf, (int)jflags);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	free((void *)result);
	return (jresult);
}

/*
 * pool_resource_create(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1create(
    JNIEnv *jenv, jclass jcls, jlong jconf, jstring jtype, jstring jname)
{
	const char *type;
	const char *name;
	pool_resource_t *result;

	type = (jtype) ? (*jenv)->GetStringUTFChars(jenv, jtype, 0) :
	    NULL;
	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) :
	    NULL;
	result =
	    pool_resource_create((pool_conf_t *)(uintptr_t)jconf, type, name);

	if (type)
		(*jenv)->ReleaseStringUTFChars(jenv, jtype, type);
	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jlong)(uintptr_t)result);
}

/*
 * pool_resource_destroy(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1destroy(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource)
{
	return ((jint)pool_resource_destroy((pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jresource));
}

/*
 * pool_resource_transfer(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1transfer(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jsource, jlong jtarget,
    jlong jsize)
{
	return (pool_resource_transfer((pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jsource,
	    (pool_resource_t *)(uintptr_t)jtarget,
	    (uint64_t)jsize));
}

/*
 * pool_resource_xtransfer(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1xtransfer(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jsource, jlong jtarget,
    jobject jcomponents)
{
	pool_component_t **components;
	int result;
	jclass Lclazz;
	jmethodID Lsize;
	jint size;

	/*
	 * Initialize the target parameter for case when input is null
	 */
	components = NULL;
	if (jcomponents != NULL) {
		Lclazz = (*jenv)->GetObjectClass(jenv, jcomponents);
		Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I");
		size = (*jenv)->CallIntMethod(jenv, jcomponents, Lsize);

		if (size != 0) {
			jmethodID Lget;
			int i;

			Lget = (*jenv)->GetMethodID(jenv,
			    Lclazz, "get", "(I)Ljava/lang/Object;");
			/* Allocate space for the components array */

			if ((components = calloc(size + 1,
			    sizeof (pool_component_t *))) == NULL) {
				throwException(jenv, "java/lang/Exception",
				    "Could not allocate component array");
				return (0);
			}
			/*
			 * Copy in the array
			 */
			for (i = 0; i < size; i++) {
				jobject aVal;
				jclass Vclazz;
				jlong this;
				jmethodID Vthis;

				aVal = (*jenv)->CallObjectMethod(jenv,
				    jcomponents, Lget, (jint) i);
				Vclazz = (*jenv)->GetObjectClass(jenv,
				    aVal);
				Vthis = (*jenv)->GetMethodID(jenv,
				    Vclazz, "getComponent", "()J");
				this = (*jenv)->CallLongMethod(jenv,
				    aVal, Vthis);
				components[i] =
				    (pool_component_t *)(uintptr_t)this;
			}
		}
	}
	result = (int)pool_resource_xtransfer((pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jsource,
	    (pool_resource_t *)(uintptr_t)jtarget,
	    components);
	free(components);

	return ((jint)result);
}

/*
 * pool_query_resource_components(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resource_\
1components(JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource,
    jobject jprops)
{
	pool_value_t **props;
	pool_component_t **result;
	jclass Lclazz;
	jmethodID Lsize;
	uint_t nelem;
	jint size;

	/*
	 * Initialize the target parameter for case when input is null
	 */
	props = NULL;
	if (jprops != NULL) {
		Lclazz = (*jenv)->GetObjectClass(jenv, jprops);
		Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I");
		size = (*jenv)->CallIntMethod(jenv, jprops, Lsize);

		if (size != 0) {
			jmethodID Lget;
			int i;

			Lget = (*jenv)->GetMethodID(jenv, Lclazz, "get",
			    "(I)Ljava/lang/Object;");
			/*
			 * Allocate space for the props array
			 */
			if ((props = calloc(size + 1, sizeof (pool_value_t *)))
			    == NULL) {
				throwException(jenv, "java/lang/Exception",
				    "Could not allocate props array");
				return (NULL);
			}
			/*
			 * Copy in the array
			 */
			for (i = 0; i < size; i++) {
				jobject aVal;
				jclass Vclazz;
				jfieldID Vthis;
				jlong this;

				aVal = (*jenv)->CallObjectMethod(jenv, jprops,
				    Lget, (jint) i);
				Vclazz = (*jenv)->GetObjectClass(jenv, aVal);
				Vthis = (*jenv)->GetFieldID(jenv, Vclazz,
				    "_this", "J");
				this = (*jenv)->GetLongField(jenv, aVal, Vthis);
				props[i] = (pool_value_t *)(uintptr_t)this;
			}
		}
	}
	result = pool_query_resource_components(
	    (pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jresource, &nelem, props);
	free(props);
	return (copyArray(jenv, (void **)result));
}

/*
 * pool_resource_info(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1info(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource, jint jflags)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_resource_info((pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jresource, (int)jflags);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	free((void *)result);
	return (jresult);
}

/*
 * pool_create(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1create(JNIEnv *jenv,
    jclass jcls, jlong jconf, jstring jname)
{
	const char *name;
	pool_t *result;

	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) :
	    NULL;
	result = pool_create((pool_conf_t *)(uintptr_t)jconf, name);

	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jlong)(uintptr_t)result);
}

/*
 * pool_destroy(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1destroy(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jpool)
{
	return ((jint)pool_destroy((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool));
}

/*
 * pool_associate(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1associate(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jpool, jlong jresource)
{
	return ((jint)pool_associate((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool,
	    (pool_resource_t *)(uintptr_t)jresource));
}

/*
 * pool_dissociate(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1dissociate(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jpool, jlong jresource)
{
	return ((jint)pool_dissociate((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool,
	    (pool_resource_t *)(uintptr_t)jresource));
}

/*
 * pool_info(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1info(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jpool, jint jflags)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_info((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool, (int)jflags);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	free((void *)result);
	return (jresult);
}

/*
 * pool_query_pool_resources(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pool_1resources(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jpool, jobject jprops)
{
	pool_value_t **props;
	pool_resource_t **result;
	jclass Lclazz;
	jmethodID Lsize;
	uint_t nelem;
	jint size;

	/*
	 * Initialize the target parameter for case when input is null
	 */
	props = NULL;
	if (jprops != NULL) {
		Lclazz = (*jenv)->GetObjectClass(jenv, jprops);
		Lsize = (*jenv)->GetMethodID(jenv, Lclazz, "size", "()I");
		size = (*jenv)->CallIntMethod(jenv, jprops, Lsize);

		if (size != 0) {
			jmethodID Lget;
			int i;

			Lget = (*jenv)->GetMethodID(jenv,
			    Lclazz, "get", "(I)Ljava/lang/Object;");
			/*
			 * Allocate space for the props array
			 */

			if ((props = calloc(size + 1, sizeof (pool_value_t *)))
			    == NULL) {
				throwException(jenv, "java/lang/Exception",
				    "Could not allocate props array");
				return (NULL);
			}
			/*
			 * Copy in the array
			 */
			for (i = 0; i < size; i++) {
				jobject aVal;
				jclass Vclazz;
				jfieldID Vthis;
				jlong this;

				aVal = (*jenv)->CallObjectMethod(jenv, jprops,
				    Lget, (jint) i);
				Vclazz = (*jenv)->GetObjectClass(jenv, aVal);
				Vthis = (*jenv)->GetFieldID(jenv, Vclazz,
				    "_this", "J");
				this = (*jenv)->GetLongField(jenv, aVal, Vthis);
				props[i] = (pool_value_t *)(uintptr_t)this;
			}
		}
	}
	result = pool_query_pool_resources((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool, &nelem, props);
	free(props);
	return (copyArray(jenv, (void **)result));
}

/*
 * pool_get_owning_resource(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1owning_1resource(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jcomponent)
{
	return ((jlong)(uintptr_t)pool_get_owning_resource(
	    (pool_conf_t *)(uintptr_t)jconf,
	    (pool_component_t *)(uintptr_t)jcomponent));
}

/*
 * pool_component_info(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1info(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jcomponent, jint jflags)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_component_info((pool_conf_t *)(uintptr_t)jconf,
	    (pool_component_t *)(uintptr_t)jcomponent, (int)jflags);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	free((void *)result);
	return (jresult);
}

/*
 * pool_get_property(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1property(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jelem, jstring jname,
    jlong jproperty)
{
	const char *name;
	int result;

	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) :
	    NULL;
	result = pool_get_property((pool_conf_t *)(uintptr_t)jconf,
	    (pool_elem_t *)(uintptr_t)jelem, name,
	    (pool_value_t *)(uintptr_t)jproperty);

	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jint)result);
}

/*
 * pool_put_property(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1put_1property(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jelem, jstring jname,
    jlong jvalue)
{
	const char *name;
	int result;

	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : NULL;
	result = (int)pool_put_property((pool_conf_t *)(uintptr_t)jconf,
	    (pool_elem_t *)(uintptr_t)jelem, name,
	    (pool_value_t *)(uintptr_t)jvalue);

	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jint)result);
}

/*
 * pool_rm_property(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1rm_1property(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jelem, jstring jname)
{
	const char *name;
	int result;

	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : NULL;
	result = pool_rm_property((pool_conf_t *)(uintptr_t)jconf,
	    (pool_elem_t *)(uintptr_t)jelem, name);

	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jint)result);
}

/*
 * pool_walk_properties(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1properties(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jelem, jlong jarg,
    jlong jcallback)
{
	int result;

	result = (int)pool_walk_properties((pool_conf_t *)(uintptr_t)jconf,
	    (pool_elem_t *)(uintptr_t)jelem, (void *)(uintptr_t)jarg,
	    (int (*)(pool_conf_t *, pool_elem_t *, char const *,
	    pool_value_t *, void *))(uintptr_t)jcallback);

	return ((jint)result);
}

/*
 * pool_conf_to_elem(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1to_1elem(
    JNIEnv *jenv, jclass jcls, jlong jconf)
{
	return ((jlong)(uintptr_t)pool_conf_to_elem(
	    (pool_conf_t *)(uintptr_t)jconf));
}

/*
 * pool_to_elem(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1to_1elem(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jpool)
{
	return ((jlong)(uintptr_t)pool_to_elem((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool));
}

/*
 * pool_resource_to_elem(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1to_1elem(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource)
{
	return ((jlong)(uintptr_t)pool_resource_to_elem(
	    (pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jresource));
}

/*
 * pool_component_to_elem(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1to_1elem(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jcomponent)
{
	return ((jlong)(uintptr_t)pool_component_to_elem(
	    (pool_conf_t *)(uintptr_t)jconf,
	    (pool_component_t *)(uintptr_t)jcomponent));
}

/*
 * pool_value_get_type(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1type(
    JNIEnv *jenv, jclass jcls, jlong jvalue)
{
	return ((jint)pool_value_get_type((pool_value_t *)(uintptr_t)jvalue));
}

/*
 * pool_value_set_uint64(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1uint64(
    JNIEnv *jenv, jclass jcls, jlong jvalue, jlong jui64)
{
	pool_value_set_uint64(
	    (pool_value_t *)(uintptr_t)jvalue, (uint64_t)jui64);
}

/*
 * pool_value_set_int64(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1int64(
    JNIEnv *jenv, jclass jcls, jlong jvalue, jlong ji64)
{
	pool_value_set_int64((pool_value_t *)(uintptr_t)jvalue, (int64_t)ji64);
}

/*
 * pool_value_set_double(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1double(
    JNIEnv *jenv, jclass jcls, jlong jvalue, jdouble jd)
{
	pool_value_set_double((pool_value_t *)(uintptr_t)jvalue, (double)jd);
}

/*
 * pool_value_set_bool(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1bool(
    JNIEnv *jenv, jclass jcls, jlong jvalue, jshort jb)
{
	pool_value_set_bool((pool_value_t *)(uintptr_t)jvalue, (uchar_t)jb);
}

/*
 * pool_value_set_string(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1string(
    JNIEnv * jenv, jclass jcls, jlong jvalue, jstring jstr)
{
	const char *str;
	int result;

	str = (jstr) ? (*jenv)->GetStringUTFChars(jenv, jstr, 0) : NULL;
	result = pool_value_set_string((pool_value_t *)(uintptr_t)jvalue, str);

	if (str)
		(*jenv)->ReleaseStringUTFChars(jenv, jstr, str);
	return ((jint)result);
}

/*
 * pool_value_get_name(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1name(
    JNIEnv *jenv, jclass jcls, jlong jvalue)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_value_get_name((pool_value_t *)(uintptr_t)jvalue);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	return (jresult);
}

/*
 * pool_value_set_name(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1name(
    JNIEnv *jenv, jclass jcls, jlong jvalue, jstring jname)
{
	const char *name;
	int result;

	name = (jname) ? (*jenv)->GetStringUTFChars(jenv, jname, 0) : NULL;
	result = pool_value_set_name((pool_value_t *)(uintptr_t)jvalue, name);

	if (name)
		(*jenv)->ReleaseStringUTFChars(jenv, jname, name);
	return ((jint)result);
}

/*
 * pool_value_alloc(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1alloc(JNIEnv *jenv,
    jclass jcls)
{
	return ((jlong)(uintptr_t)pool_value_alloc());
}

/*
 * pool_value_free(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1free(JNIEnv *jenv,
    jclass jcls, jlong jvalue)
{
	pool_value_free((pool_value_t *)(uintptr_t)jvalue);
}

/*
 * pool_static_location(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1static_1location(
    JNIEnv *jenv, jclass jcls)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_static_location();

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	return (jresult);
}

/*
 * pool_dynamic_location(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1dynamic_1location(JNIEnv *
    jenv, jclass jcls)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_dynamic_location();

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	return (jresult);
}

/*
 * pool_set_binding(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1binding(JNIEnv *jenv,
    jclass jcls, jstring jpool, jint jidtype, jint jpid)
{
	const char *pool;
	int result;

	pool = (jpool) ? (*jenv)->GetStringUTFChars(jenv, jpool, 0) : NULL;
	result = (int)pool_set_binding(pool, (idtype_t)jidtype, (id_t)jpid);

	if (pool)
		(*jenv)->ReleaseStringUTFChars(jenv, jpool, pool);
	return ((jint)result);
}

/*
 * pool_get_binding(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1binding(JNIEnv *jenv,
    jclass jcls, jint jpid)
{
	jstring jresult = NULL;
	const char *result;

	result = pool_get_binding((pid_t)jpid);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	free((void *)result);
	return (jresult);
}

/*
 * pool_get_resource_binding(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource_1binding(
    JNIEnv *jenv, jclass jcls, jstring jtype, jint jpid)
{
	jstring jresult = NULL;
	const char *type;
	const char *result;

	type = (jtype) ? (*jenv)->GetStringUTFChars(jenv, jtype, 0) : NULL;
	result = pool_get_resource_binding(type, (pid_t)jpid);

	if (result)
		jresult = (*jenv)->NewStringUTF(jenv, result);
	free((void *)result);
	if (type)
		(*jenv)->ReleaseStringUTFChars(jenv, jtype, type);
	return (jresult);
}

/*
 * pool_walk_pools(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1pools(JNIEnv *jenv,
    jclass jcls, jlong jconf, jlong jarg, jlong jcallback)
{
	int result;

	result = pool_walk_pools((pool_conf_t *)(uintptr_t)jconf,
	    (void *)(uintptr_t)jarg,
	    (int (*)(pool_conf_t *, pool_t *, void *))(uintptr_t)jcallback);
	return ((jint)result);
}

/*
 * pool_walk_resources(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1resources(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jpool, jlong jarg,
    jlong jcallback)
{
	int result;

	result = pool_walk_resources((pool_conf_t *)(uintptr_t)jconf,
	    (pool_t *)(uintptr_t)jpool, (void *)(uintptr_t)jarg,
	    (int (*)(pool_conf_t *, pool_resource_t *, void *))
	    (uintptr_t)jcallback);
	return ((jint)result);
}

/*
 * pool_walk_components(3pool) wrapper
 */
/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1components(
    JNIEnv *jenv, jclass jcls, jlong jconf, jlong jresource, jlong jarg,
    jlong jcallback)
{
	int result;

	result = pool_walk_components((pool_conf_t *)(uintptr_t)jconf,
	    (pool_resource_t *)(uintptr_t)jresource, (void *)(uintptr_t)jarg,
	    (int (*)(pool_conf_t *, pool_component_t *, void *))
	    (uintptr_t)jcallback);
	return ((jint)result);
}

/*ARGSUSED*/
JNIEXPORT jint JNICALL
Java_com_sun_solaris_service_pools_Element_walkProps(JNIEnv *env,
    jobject obj, jlong conf, jlong elem, jobject handler, jobject userobj)
{
	struct pool_callback pc;

	pc.pc_user = userobj;
	pc.pc_handler = handler;
	pc.pc_elem = obj;
	pc.pc_env = env;
	return (pool_walk_properties((pool_conf_t *)*(void**)&conf,
	    (pool_elem_t *)*(void**)&elem, (void *)&pc, pool_property_walker));
}

/*ARGSUSED*/
static int
pool_property_walker(pool_conf_t *conf, pool_elem_t *pe, const char *name,
    pool_value_t *pv, void *user)
{
	jclass clazz, vclazz;
	jmethodID mgetwalk, mvcon;
	struct pool_callback *pc = (struct pool_callback *)user;
	jobject valueObj;
	pool_value_t *pv_new;
	uint64_t uval;
	int64_t ival;
	double dval;
	uchar_t bval;
	const char *sval;

	/*
	 * Since we intend to embed our value into a Java Value object
	 * and then reclaim the value when the object is garbage
	 * collected we must create a new pool value and then pass this
	 * to the constructor.  We must not use the pool value which is
	 * passed to us.
	 */

	if ((pv_new = pool_value_alloc()) == NULL)
		return (PO_FAIL);
	switch (pool_value_get_type(pv)) {
	case POC_UINT:
		(void) pool_value_get_uint64(pv, &uval);
		(void) pool_value_set_uint64(pv_new, uval);
		break;
	case POC_INT:
		(void) pool_value_get_int64(pv, &ival);
		(void) pool_value_set_int64(pv_new, ival);
		break;
	case POC_DOUBLE:
		(void) pool_value_get_double(pv, &dval);
		(void) pool_value_set_double(pv_new, dval);
		break;
	case POC_BOOL:
		(void) pool_value_get_bool(pv, &bval);
		(void) pool_value_set_bool(pv_new, bval);
		break;
	case POC_STRING:
		(void) pool_value_get_string(pv, &sval);
		(void) pool_value_set_string(pv_new, sval);
		break;
	default:
		pool_value_free(pv_new);
		return (PO_FAIL);
	}
	if (pool_value_set_name(pv_new, name) != PO_SUCCESS ||
	    (vclazz = (*pc->pc_env)->FindClass(pc->pc_env,
	    "com/sun/solaris/service/pools/Value")) == NULL ||
	    (mvcon = (*pc->pc_env)->GetMethodID(pc->pc_env, vclazz,
	    "<init>", "(J)V")) == NULL ||
	    (valueObj = (*pc->pc_env)->NewObject(pc->pc_env, vclazz, mvcon,
	    pv_new)) == NULL ||
	    (clazz = (*pc->pc_env)->GetObjectClass(pc->pc_env, pc->pc_handler))
	    == NULL ||
	    (mgetwalk = (*pc->pc_env)->GetMethodID(pc->pc_env,
	    clazz, "walk",
	    "(Lcom/sun/solaris/service/pools/Element;Lcom/sun/solaris/"
	    "service/pools/Value;Ljava/lang/Object;)I")) == NULL)
		return (PO_FAIL);
	return ((*pc->pc_env)->CallIntMethod(pc->pc_env,
	    pc->pc_handler, mgetwalk, pc->pc_elem, valueObj, pc->pc_user));
}

/*ARGSUSED*/
JNIEXPORT jlong JNICALL
Java_com_sun_solaris_service_pools_Value_getLongValue(JNIEnv *jenv,
    jclass class, jlong pointer)
{
	int64_t arg2;
	int result;

	result =
	    pool_value_get_int64((pool_value_t *)(uintptr_t)pointer, &arg2);

	if (result != PO_SUCCESS) { /* it could be a uint64 */
		result =
		    pool_value_get_uint64((pool_value_t *)(uintptr_t)pointer,
		    (uint64_t *)&arg2);
		if (result != PO_SUCCESS) {
			throw_pe(jenv);
		}
		/*
		 * Unfortunately, Java has no unsigned types, so we lose some
		 * precision by forcing the top bit clear
		 */
		arg2 &= 0x7fffffffffffffffULL;
	}
	return ((jlong)arg2);
}

/*ARGSUSED*/
JNIEXPORT jstring JNICALL
Java_com_sun_solaris_service_pools_Value_getStringValue(JNIEnv *jenv,
    jclass class, jlong pointer)
{
	const char *arg2;
	int result;

	result =
	    pool_value_get_string((pool_value_t *)(uintptr_t)pointer, &arg2);
	if (result != PO_SUCCESS)
		throw_pe(jenv);
	return ((*jenv)->NewStringUTF(jenv, arg2));
}

/*ARGSUSED*/
JNIEXPORT jboolean JNICALL
Java_com_sun_solaris_service_pools_Value_getBoolValue(JNIEnv *jenv,
    jclass class, jlong pointer)
{
	uchar_t arg2;
	int result;

	result = pool_value_get_bool((pool_value_t *)(uintptr_t)pointer, &arg2);

	if (result != PO_SUCCESS) {
		throw_pe(jenv);
	}
	if (arg2 == PO_TRUE)
		return (JNI_TRUE);
	else
		return (JNI_FALSE);
}

/*ARGSUSED*/
JNIEXPORT jdouble JNICALL
Java_com_sun_solaris_service_pools_Value_getDoubleValue(JNIEnv *jenv,
    jclass class, jlong pointer)
{
	double arg2;
	int result;

	result =
	    pool_value_get_double((pool_value_t *)(uintptr_t)pointer, &arg2);

	if (result != PO_SUCCESS) {
		throw_pe(jenv);
	}
	return ((jdouble)arg2);
}

/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_Value_getUnsignedInt64Value(JNIEnv *jenv,
    jclass class, jlong pointer)
{
	uint64_t arg2;
	int result;

	result =
	    pool_value_get_uint64((pool_value_t *)(uintptr_t)pointer, &arg2);

	if (result != PO_SUCCESS) {
		throw_pe(jenv);
	}
	return (makeUnsignedInt64(jenv, arg2));
}

/*ARGSUSED*/
JNIEXPORT jobject JNICALL
Java_com_sun_solaris_service_pools_HRTime_timestamp(JNIEnv *env, jobject obj)
{
	return (makeUnsignedInt64(env, gethrtime()));
}

/*
 * Cache class, method, and field IDs.
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_pools_PoolInternal_init(JNIEnv *env, jclass clazz)
{
	jclass ui64class_lref;

	if (!(ui64class_lref = (*env)->FindClass(env,
	    "com/sun/solaris/service/pools/UnsignedInt64")))
		return; /* exception thrown */
	if (!(ui64class = (*env)->NewGlobalRef(env, ui64class_lref)))
		return; /* exception thrown */
	ui64cons_mid = (*env)->GetMethodID(env, ui64class, "<init>", "([B)V");
}
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_sun_solaris_service_pools_PoolInternal */

#ifndef _Included_com_sun_solaris_service_pools_PoolInternal
#define _Included_com_sun_solaris_service_pools_PoolInternal
#ifdef __cplusplus
extern "C" {
#endif
#undef com_sun_solaris_service_pools_PoolInternal_POOL_VER_CURRENT
#define com_sun_solaris_service_pools_PoolInternal_POOL_VER_CURRENT 1L
#undef com_sun_solaris_service_pools_PoolInternal_POOL_VER_NONE
#define com_sun_solaris_service_pools_PoolInternal_POOL_VER_NONE 0L
#undef com_sun_solaris_service_pools_PoolInternal_PO_TRUE
#define com_sun_solaris_service_pools_PoolInternal_PO_TRUE 1L
#undef com_sun_solaris_service_pools_PoolInternal_PO_FALSE
#define com_sun_solaris_service_pools_PoolInternal_PO_FALSE 0L
#undef com_sun_solaris_service_pools_PoolInternal_PO_SUCCESS
#define com_sun_solaris_service_pools_PoolInternal_PO_SUCCESS 0L
#undef com_sun_solaris_service_pools_PoolInternal_PO_FAIL
#define com_sun_solaris_service_pools_PoolInternal_PO_FAIL -1L
#undef com_sun_solaris_service_pools_PoolInternal_POE_OK
#define com_sun_solaris_service_pools_PoolInternal_POE_OK 0L
#undef com_sun_solaris_service_pools_PoolInternal_POE_BAD_PROP_TYPE
#define com_sun_solaris_service_pools_PoolInternal_POE_BAD_PROP_TYPE 1L
#undef com_sun_solaris_service_pools_PoolInternal_POE_INVALID_CONF
#define com_sun_solaris_service_pools_PoolInternal_POE_INVALID_CONF 2L
#undef com_sun_solaris_service_pools_PoolInternal_POE_NOTSUP
#define com_sun_solaris_service_pools_PoolInternal_POE_NOTSUP 3L
#undef com_sun_solaris_service_pools_PoolInternal_POE_INVALID_SEARCH
#define com_sun_solaris_service_pools_PoolInternal_POE_INVALID_SEARCH 4L
#undef com_sun_solaris_service_pools_PoolInternal_POE_BADPARAM
#define com_sun_solaris_service_pools_PoolInternal_POE_BADPARAM 5L
#undef com_sun_solaris_service_pools_PoolInternal_POE_PUTPROP
#define com_sun_solaris_service_pools_PoolInternal_POE_PUTPROP 6L
#undef com_sun_solaris_service_pools_PoolInternal_POE_DATASTORE
#define com_sun_solaris_service_pools_PoolInternal_POE_DATASTORE 7L
#undef com_sun_solaris_service_pools_PoolInternal_POE_SYSTEM
#define com_sun_solaris_service_pools_PoolInternal_POE_SYSTEM 8L
#undef com_sun_solaris_service_pools_PoolInternal_POE_ACCESS
#define com_sun_solaris_service_pools_PoolInternal_POE_ACCESS 9L
#undef com_sun_solaris_service_pools_PoolInternal_PO_RDONLY
#define com_sun_solaris_service_pools_PoolInternal_PO_RDONLY 0L
#undef com_sun_solaris_service_pools_PoolInternal_PO_RDWR
#define com_sun_solaris_service_pools_PoolInternal_PO_RDWR 1L
#undef com_sun_solaris_service_pools_PoolInternal_PO_CREAT
#define com_sun_solaris_service_pools_PoolInternal_PO_CREAT 2L
#undef com_sun_solaris_service_pools_PoolInternal_PO_DISCO
#define com_sun_solaris_service_pools_PoolInternal_PO_DISCO 4L
#undef com_sun_solaris_service_pools_PoolInternal_PO_UPDATE
#define com_sun_solaris_service_pools_PoolInternal_PO_UPDATE 8L
#undef com_sun_solaris_service_pools_PoolInternal_POU_SYSTEM
#define com_sun_solaris_service_pools_PoolInternal_POU_SYSTEM 1L
#undef com_sun_solaris_service_pools_PoolInternal_POU_POOL
#define com_sun_solaris_service_pools_PoolInternal_POU_POOL 2L
#undef com_sun_solaris_service_pools_PoolInternal_POU_PSET
#define com_sun_solaris_service_pools_PoolInternal_POU_PSET 4L
#undef com_sun_solaris_service_pools_PoolInternal_POU_CPU
#define com_sun_solaris_service_pools_PoolInternal_POU_CPU 8L
/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_init
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_version
 * Signature: (J)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1version
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POX_NATIVE
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1NATIVE
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POX_TEXT
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1TEXT
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POC_INVAL
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INVAL
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POC_UINT
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1UINT
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POC_INT
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INT
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POC_DOUBLE
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1DOUBLE
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POC_BOOL
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1BOOL
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POC_STRING
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1STRING
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POV_NONE
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1NONE
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POV_LOOSE
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1LOOSE
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POV_STRICT
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1STRICT
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POV_RUNTIME
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1RUNTIME
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POF_INVALID
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1INVALID
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POF_VALID
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1VALID
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    get_POF_DESTROY
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1DESTROY
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_error
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1error
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_strerror
 * Signature: (I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror
  (JNIEnv *, jclass, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_strerror_sys
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror_1sys
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_type_list
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1type_1list
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_status
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1status
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_set_status
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1status
  (JNIEnv *, jclass, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_alloc
 * Signature: ()J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1alloc
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_free
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1free
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_status
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1status
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_close
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1close
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_remove
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1remove
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_open
 * Signature: (JLjava/lang/String;I)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1open
  (JNIEnv *, jclass, jlong, jstring, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_rollback
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1rollback
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_commit
 * Signature: (JI)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1commit
  (JNIEnv *, jclass, jlong, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_export
 * Signature: (JLjava/lang/String;I)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1export
  (JNIEnv *, jclass, jlong, jstring, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_validate
 * Signature: (JI)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1validate
  (JNIEnv *, jclass, jlong, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_update
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1update
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_pool
 * Signature: (JLjava/lang/String;)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1pool
  (JNIEnv *, jclass, jlong, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_query_pools
 * Signature: (JLjava/util/List;)Ljava/util/List;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pools
  (JNIEnv *, jclass, jlong, jobject);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_resource
 * Signature: (JLjava/lang/String;Ljava/lang/String;)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource
  (JNIEnv *, jclass, jlong, jstring, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_query_resources
 * Signature: (JLjava/util/List;)Ljava/util/List;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resources
  (JNIEnv *, jclass, jlong, jobject);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_query_components
 * Signature: (JLjava/util/List;)Ljava/util/List;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1components
  (JNIEnv *, jclass, jlong, jobject);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_location
 * Signature: (J)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1location
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_info
 * Signature: (JI)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1info
  (JNIEnv *, jclass, jlong, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_create
 * Signature: (JLjava/lang/String;Ljava/lang/String;)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1create
  (JNIEnv *, jclass, jlong, jstring, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_destroy
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1destroy
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_transfer
 * Signature: (JJJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1transfer
  (JNIEnv *, jclass, jlong, jlong, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_xtransfer
 * Signature: (JJJLjava/util/List;)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1xtransfer
  (JNIEnv *, jclass, jlong, jlong, jlong, jobject);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_query_resource_components
 * Signature: (JJLjava/util/List;)Ljava/util/List;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resource_1components
  (JNIEnv *, jclass, jlong, jlong, jobject);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_info
 * Signature: (JJI)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1info
  (JNIEnv *, jclass, jlong, jlong, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_create
 * Signature: (JLjava/lang/String;)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1create
  (JNIEnv *, jclass, jlong, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_destroy
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1destroy
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_associate
 * Signature: (JJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1associate
  (JNIEnv *, jclass, jlong, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_dissociate
 * Signature: (JJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1dissociate
  (JNIEnv *, jclass, jlong, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_info
 * Signature: (JJI)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1info
  (JNIEnv *, jclass, jlong, jlong, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_query_pool_resources
 * Signature: (JJLjava/util/List;)Ljava/util/List;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pool_1resources
  (JNIEnv *, jclass, jlong, jlong, jobject);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_owning_resource
 * Signature: (JJ)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1owning_1resource
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_component_info
 * Signature: (JJI)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1info
  (JNIEnv *, jclass, jlong, jlong, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_property
 * Signature: (JJLjava/lang/String;J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1property
  (JNIEnv *, jclass, jlong, jlong, jstring, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_put_property
 * Signature: (JJLjava/lang/String;J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1put_1property
  (JNIEnv *, jclass, jlong, jlong, jstring, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_rm_property
 * Signature: (JJLjava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1rm_1property
  (JNIEnv *, jclass, jlong, jlong, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_walk_properties
 * Signature: (JJJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1properties
  (JNIEnv *, jclass, jlong, jlong, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_conf_to_elem
 * Signature: (J)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1to_1elem
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_to_elem
 * Signature: (JJ)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1to_1elem
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_resource_to_elem
 * Signature: (JJ)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1to_1elem
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_component_to_elem
 * Signature: (JJ)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1to_1elem
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_uint64
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1uint64
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_int64
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1int64
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_double
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1double
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_bool
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1bool
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_string
 * Signature: (JJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1string
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_type
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1type
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_set_uint64
 * Signature: (JJ)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1uint64
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_set_int64
 * Signature: (JJ)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1int64
  (JNIEnv *, jclass, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_set_double
 * Signature: (JD)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1double
  (JNIEnv *, jclass, jlong, jdouble);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_set_bool
 * Signature: (JS)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1bool
  (JNIEnv *, jclass, jlong, jshort);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_set_string
 * Signature: (JLjava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1string
  (JNIEnv *, jclass, jlong, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_get_name
 * Signature: (J)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1name
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_set_name
 * Signature: (JLjava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1name
  (JNIEnv *, jclass, jlong, jstring);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_alloc
 * Signature: ()J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1alloc
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_value_free
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1free
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_static_location
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1static_1location
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_dynamic_location
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1dynamic_1location
  (JNIEnv *, jclass);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_set_binding
 * Signature: (Ljava/lang/String;II)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1binding
  (JNIEnv *, jclass, jstring, jint, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_binding
 * Signature: (I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1binding
  (JNIEnv *, jclass, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_get_resource_binding
 * Signature: (Ljava/lang/String;I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource_1binding
  (JNIEnv *, jclass, jstring, jint);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_walk_pools
 * Signature: (JJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1pools
  (JNIEnv *, jclass, jlong, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_walk_resources
 * Signature: (JJJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1resources
  (JNIEnv *, jclass, jlong, jlong, jlong, jlong);

/*
 * Class:     com_sun_solaris_service_pools_PoolInternal
 * Method:    pool_walk_components
 * Signature: (JJJJ)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1components
  (JNIEnv *, jclass, jlong, jlong, jlong, jlong);

#ifdef __cplusplus
}
#endif
#endif
/* Header for class com_sun_solaris_service_pools_Element */

#ifndef _Included_com_sun_solaris_service_pools_Element
#define _Included_com_sun_solaris_service_pools_Element
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_sun_solaris_service_pools_Element
 * Method:    walkProps
 * Signature: (JJLcom/sun/solaris/service/pools/PropertyWalk;Ljava/lang/Object;)I
 */
JNIEXPORT jint JNICALL Java_com_sun_solaris_service_pools_Element_walkProps
  (JNIEnv *, jobject, jlong, jlong, jobject, jobject);

#ifdef __cplusplus
}
#endif
#endif
/* Header for class com_sun_solaris_service_pools_Value */

#ifndef _Included_com_sun_solaris_service_pools_Value
#define _Included_com_sun_solaris_service_pools_Value
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_sun_solaris_service_pools_Value
 * Method:    getUnsignedInt64Value
 * Signature: (J)Lcom/sun/solaris/service/pools/UnsignedInt64;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_Value_getUnsignedInt64Value
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_Value
 * Method:    getLongValue
 * Signature: (J)J
 */
JNIEXPORT jlong JNICALL Java_com_sun_solaris_service_pools_Value_getLongValue
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_Value
 * Method:    getStringValue
 * Signature: (J)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_sun_solaris_service_pools_Value_getStringValue
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_Value
 * Method:    getBoolValue
 * Signature: (J)Z
 */
JNIEXPORT jboolean JNICALL Java_com_sun_solaris_service_pools_Value_getBoolValue
  (JNIEnv *, jclass, jlong);

/*
 * Class:     com_sun_solaris_service_pools_Value
 * Method:    getDoubleValue
 * Signature: (J)D
 */
JNIEXPORT jdouble JNICALL Java_com_sun_solaris_service_pools_Value_getDoubleValue
  (JNIEnv *, jclass, jlong);

#ifdef __cplusplus
}
#endif
#endif
/* Header for class com_sun_solaris_service_pools_HRTime */

#ifndef _Included_com_sun_solaris_service_pools_HRTime
#define _Included_com_sun_solaris_service_pools_HRTime
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_sun_solaris_service_pools_HRTime
 * Method:    timestamp
 * Signature: ()Lcom/sun/solaris/service/pools/UnsignedInt64;
 */
JNIEXPORT jobject JNICALL Java_com_sun_solaris_service_pools_HRTime_timestamp
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
#
# 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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
#

#
# MAPFILE HEADER START
#
# WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
# Object versioning must comply with the rules detailed in
#
#	usr/src/lib/README.mapfiles
#
# You should not be making modifications here until you've read the most current
# copy of that file. If you need help, contact a gatekeeper for guidance.
#
# MAPFILE HEADER END
#

$mapfile_version 2

SYMBOL_VERSION SUNWprivate_1.1 {
    global:
	Java_com_sun_solaris_service_pools_Element_walkProps;
	Java_com_sun_solaris_service_pools_HRTime_timestamp;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1BOOL;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1DOUBLE;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INT;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1INVAL;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1STRING;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POC_1UINT;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1DESTROY;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1INVALID;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POF_1VALID;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1LOOSE;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1NONE;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1RUNTIME;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POV_1STRICT;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1NATIVE;
	Java_com_sun_solaris_service_pools_PoolInternal_get_1POX_1TEXT;
	Java_com_sun_solaris_service_pools_PoolInternal_init;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1associate;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1info;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1component_1to_1elem;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1alloc;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1close;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1commit;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1export;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1free;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1info;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1location;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1open;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1remove;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1rollback;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1status;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1to_1elem;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1update;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1conf_1validate;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1create;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1destroy;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1dissociate;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1dynamic_1location;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1error;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1binding;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1owning_1resource;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1pool;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1property;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1resource_1binding;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1get_1status;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1info;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1put_1property;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1components;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pool_1resources;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1pools;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resource_1components;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1query_1resources;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1create;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1destroy;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1info;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1to_1elem;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1transfer;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1type_1list;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1resource_1xtransfer;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1rm_1property;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1binding;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1set_1status;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1static_1location;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1strerror_1sys;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1to_1elem;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1alloc;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1free;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1name;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1get_1type;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1bool;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1double;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1int64;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1name;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1string;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1value_1set_1uint64;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1version;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1components;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1pools;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1properties;
	Java_com_sun_solaris_service_pools_PoolInternal_pool_1walk_1resources;
	Java_com_sun_solaris_service_pools_PoolsException_getErrno;
	Java_com_sun_solaris_service_pools_Value_getBoolValue;
	Java_com_sun_solaris_service_pools_Value_getDoubleValue;
	Java_com_sun_solaris_service_pools_Value_getLongValue;
	Java_com_sun_solaris_service_pools_Value_getStringValue;
	Java_com_sun_solaris_service_pools_Value_getUnsignedInt64Value;
    local:
	*;
};
#
# 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.
#
# Copyright 2020 Peter Tribble
#

include $(SRC)/lib/Makefile.lib

SUBDIRS = $(MACH64)

all :		TARGET = all
clean :	TARGET = clean
clobber :	TARGET = clobber
install :	TARGET = install

all install: $(SUBDIRS)

clean clobber:		$(SUBDIRS)

$(SUBDIRS):	FRC
	@cd $@; pwd; $(MAKE) $(TARGET)

FRC:

include $(SRC)/lib/Makefile.targ
include $(SRC)/Makefile.msg.targ
#
# 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.
#
# Copyright (c) 2018, Joyent, Inc.

LIBRARY =	libjsyslog.a
VERS =		.1

OBJECTS =	jsyslog.o

include $(SRC)/lib/Makefile.lib

INCS =	-I$(JAVA_ROOT)/include \
	-I$(JAVA_ROOT)/include/solaris

LIBS =		$(DYNLIB)
LDLIBS +=	-lc
ROOTLIBDIR =	$(ROOT)/usr/lib/pool

CFLAGS +=	$(CCVERBOSE)
CPPFLAGS +=	-D_REENTRANT -D_FILE_OFFSET_BITS=64 $(INCS)

# not linted
SMATCH=off

all: $(LIBS)

lint: lintcheck

include $(SRC)/lib/Makefile.targ
#
# This file and its contents are supplied under the terms of the
# Common Development and Distribution License ("CDDL"), version 1.0.
# You may only use this file in accordance with the terms of version
# 1.0 of the CDDL.
#
# A full copy of the text of the CDDL should have accompanied this
# source.  A copy of the CDDL is also available via the Internet at
# http://www.illumos.org/license/CDDL.
#

#
# Copyright 2017 Alexander Pyhalov
#

include ../Makefile.com
include $(SRC)/Makefile.master.64

install: all $(ROOTLIBS) $(ROOTLINKS)
/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stddef.h>
#include <assert.h>
#include <string.h>
#include <syslog.h>

#include "jsyslog.h"

#define	ILL_ARG_EX_CLASS_DESC	"java/lang/IllegalArgumentException"
#define	THROWABLE_CLASS_DESC	"java/lang/Throwable"

#define	CLASS_FIELD_DESC(class_desc)	"L" class_desc ";"

/*
 * syslog(3c) ident string
 */
static char jsyslog_ident[32];

/*
 * Log the given message with the given severity.
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_logging_SyslogHandler_syslog(JNIEnv *env,
    jclass clazz, jint severity, jstring messageObj)
{
	const char *message;

	if (messageObj == NULL) {
		jclass exceptionClass;

		if (!(exceptionClass = (*env)->FindClass(env,
		    ILL_ARG_EX_CLASS_DESC)))
			return; /* exception thrown */
		(*env)->Throw(env, (*env)->NewObject(env, exceptionClass,
		    (*env)->GetStaticMethodID(env, exceptionClass, "<init>",
		    "()" CLASS_FIELD_DESC(THROWABLE_CLASS_DESC))));
		return;
	}

	if (!(message = (*env)->GetStringUTFChars(env, messageObj, NULL)))
		return; /* exception thrown */
	syslog(severity, "%s", message);
	(*env)->ReleaseStringUTFChars(env, messageObj, message);
}

/*
 * Invoke openlog(3c).
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_logging_SyslogHandler_openlog(JNIEnv *env,
    jclass clazz, jstring identObj, jint logopt, jint facility)
{
	const char *ident;

	if (identObj == NULL) {
		jclass exceptionClass;

		if (!(exceptionClass = (*env)->FindClass(env,
		    ILL_ARG_EX_CLASS_DESC)))
			return; /* exception thrown */
		(*env)->Throw(env, (*env)->NewObject(env, exceptionClass,
		    (*env)->GetStaticMethodID(env, exceptionClass, "<init>",
		    "()" CLASS_FIELD_DESC(THROWABLE_CLASS_DESC))));
		return;
	}

	if (!(ident = (*env)->GetStringUTFChars(env, identObj, NULL)))
		return; /* exception thrown */
	(void) strlcpy(jsyslog_ident, ident, sizeof (jsyslog_ident));
	openlog(jsyslog_ident, logopt, facility);

	(*env)->ReleaseStringUTFChars(env, identObj, ident);
}

/*
 * Invoke closelog(3c).
 */
/*ARGSUSED*/
JNIEXPORT void JNICALL
Java_com_sun_solaris_service_logging_SyslogHandler_closelog(JNIEnv *env,
    jclass clazz)
{
	closelog();
}
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_sun_solaris_service_logging_SyslogHandler */

#ifndef _Included_com_sun_solaris_service_logging_SyslogHandler
#define _Included_com_sun_solaris_service_logging_SyslogHandler
#ifdef __cplusplus
extern "C" {
#endif
#undef com_sun_solaris_service_logging_SyslogHandler_DEF_LOGOPT
#define com_sun_solaris_service_logging_SyslogHandler_DEF_LOGOPT 0L
/*
 * Class:     com_sun_solaris_service_logging_SyslogHandler
 * Method:    syslog
 * Signature: (ILjava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_logging_SyslogHandler_syslog
  (JNIEnv *, jclass, jint, jstring);

/*
 * Class:     com_sun_solaris_service_logging_SyslogHandler
 * Method:    openlog
 * Signature: (Ljava/lang/String;II)V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_logging_SyslogHandler_openlog
  (JNIEnv *, jclass, jstring, jint, jint);

/*
 * Class:     com_sun_solaris_service_logging_SyslogHandler
 * Method:    closelog
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_sun_solaris_service_logging_SyslogHandler_closelog
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif
#
# 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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
#

#
# MAPFILE HEADER START
#
# WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
# Object versioning must comply with the rules detailed in
#
#	usr/src/lib/README.mapfiles
#
# You should not be making modifications here until you've read the most current
# copy of that file. If you need help, contact a gatekeeper for guidance.
#
# MAPFILE HEADER END
#

$mapfile_version 2

SYMBOL_VERSION SUNWprivate_1.1 {
    global:
	Java_com_sun_solaris_service_logging_SyslogHandler_closelog;
	Java_com_sun_solaris_service_logging_SyslogHandler_openlog;
	Java_com_sun_solaris_service_logging_SyslogHandler_syslog;
    local:
	*;
};
/*
 * 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.
 */

/*
 * poold - dynamically adjust pool configuration according to load.
 */
#include <errno.h>
#include <jni.h>
#include <libintl.h>
#include <limits.h>
#include <link.h>
#include <locale.h>
#include <poll.h>
#include <pool.h>
#include <priv.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ucontext.h>
#include "utils.h"

#define	POOLD_DEF_CLASSPATH	"/usr/lib/pool/JPool.jar"
#define	POOLD_DEF_LIBPATH	"/usr/lib/pool"
#define	SMF_SVC_INSTANCE	"svc:/system/pools/dynamic:default"

#define	CLASS_FIELD_DESC(class_desc)	"L" class_desc ";"

#define	LEVEL_CLASS_DESC	"java/util/logging/Level"
#define	POOLD_CLASS_DESC	"com/sun/solaris/domain/pools/Poold"
#define	SEVERITY_CLASS_DESC	"com/sun/solaris/service/logging/Severity"
#define	STRING_CLASS_DESC	"java/lang/String"
#define	SYSTEM_CLASS_DESC	"java/lang/System"
#define	LOGGER_CLASS_DESC	"java/util/logging/Logger"

extern char *optarg;

static const char *pname;

static enum {
	LD_TERMINAL = 1,
	LD_SYSLOG,
	LD_JAVA
} log_dest = LD_SYSLOG;

static const char PNAME_FMT[] = "%s: ";
static const char ERRNO_FMT[] = ": %s";

static pthread_mutex_t jvm_lock = PTHREAD_MUTEX_INITIALIZER;
static JavaVM *jvm;		/* protected by jvm_lock */
static int instance_running;	/* protected by jvm_lock */
static int lflag;		/* specifies poold logging mode */

static jmethodID log_mid;
static jobject severity_err;
static jobject severity_notice;
static jobject base_log;
static jclass poold_class;
static jobject poold_instance;

static sigset_t hdl_set;

static void pu_notice(const char *fmt, ...);
static void pu_die(const char *fmt, ...) __NORETURN;

static void
usage(void)
{
	(void) fprintf(stderr, gettext("Usage:\t%s [-l <level>]\n"), pname);

	exit(E_USAGE);
}

static void
check_thread_attached(JNIEnv **env)
{
	int ret;

	ret = (*jvm)->GetEnv(jvm, (void **)env, JNI_VERSION_1_4);
	if (*env == NULL) {
		if (ret == JNI_EVERSION) {
			/*
			 * Avoid recursively calling
			 * check_thread_attached()
			 */
			if (log_dest == LD_JAVA)
				log_dest = LD_TERMINAL;
			pu_notice(gettext("incorrect JNI version"));
			exit(E_ERROR);
		}
		if ((*jvm)->AttachCurrentThreadAsDaemon(jvm, (void **)env,
		    NULL) != 0) {
			/*
			 * Avoid recursively calling
			 * check_thread_attached()
			 */
			if (log_dest == LD_JAVA)
				log_dest = LD_TERMINAL;
			pu_notice(gettext("thread attach failed"));
			exit(E_ERROR);
		}
	}
}

/*
 * Output a message to the designated logging destination.
 *
 * severity - Specified the severity level when using LD_JAVA logging
 * fmt - specified the format of the output message
 * alist - varargs used in the output message
 */
static void
pu_output(int severity, const char *fmt, va_list alist)
{
	int err = errno;
	char line[255] = "";
	jobject jseverity;
	jobject jline;
	JNIEnv *env = NULL;

	if (pname != NULL && log_dest == LD_TERMINAL)
		(void) snprintf(line, sizeof (line), gettext(PNAME_FMT), pname);

	(void) vsnprintf(line + strlen(line), sizeof (line) - strlen(line),
	    fmt, alist);

	if (line[strlen(line) - 1] != '\n')
		(void) snprintf(line + strlen(line), sizeof (line) -
		    strlen(line), gettext(ERRNO_FMT), strerror(err));
	else
		line[strlen(line) - 1] = 0;

	switch (log_dest) {
	case LD_TERMINAL:
		(void) fprintf(stderr, "%s\n", line);
		(void) fflush(stderr);
		break;
	case LD_SYSLOG:
		syslog(LOG_ERR, "%s", line);
		break;
	case LD_JAVA:
		if (severity == LOG_ERR)
			jseverity = severity_err;
		else
			jseverity = severity_notice;

		if (jvm) {
			check_thread_attached(&env);
			if ((jline = (*env)->NewStringUTF(env, line)) != NULL)
				(*env)->CallVoidMethod(env, base_log, log_mid,
				    jseverity, jline);
		}
	}
}

/*
 * Notify the user with the supplied message.
 */
/*PRINTFLIKE1*/
static void
pu_notice(const char *fmt, ...)
{
	va_list alist;

	va_start(alist, fmt);
	pu_output(LOG_NOTICE, fmt, alist);
	va_end(alist);
}

/*
 * Stop the application executing inside the JVM. Always ensure that jvm_lock
 * is held before invoking this function.
 */
static void
halt_application(void)
{
	JNIEnv *env = NULL;
	jmethodID poold_shutdown_mid;

	if (jvm && instance_running) {
		check_thread_attached(&env);
		if ((poold_shutdown_mid = (*env)->GetMethodID(
		    env, poold_class, "shutdown", "()V")) != NULL) {
			(*env)->CallVoidMethod(env, poold_instance,
			    poold_shutdown_mid);
		} else {
			if (lflag && (*env)->ExceptionOccurred(env)) {
				(*env)->ExceptionDescribe(env);
				pu_notice("could not invoke proper shutdown\n");
			}
		}
		instance_running = 0;
	}
}

/*
 * Warn the user with the supplied error message, halt the application,
 * destroy the JVM and then exit the process.
 */
/*PRINTFLIKE1*/
static void
pu_die(const char *fmt, ...)
{
	va_list alist;

	va_start(alist, fmt);
	pu_output(LOG_ERR, fmt, alist);
	va_end(alist);
	halt_application();
	if (jvm) {
		(*jvm)->DestroyJavaVM(jvm);
		jvm = NULL;
	}
	exit(E_ERROR);
}

/*
 * Warn the user with the supplied error message and halt the
 * application. This function is very similar to pu_die(). However,
 * this function is designed to be called from the signal handling
 * routine (handle_sig()) where although we wish to let the user know
 * that an error has occurred, we do not wish to destroy the JVM or
 * exit the process.
 */
/*PRINTFLIKE1*/
static void
pu_terminate(const char *fmt, ...)
{
	va_list alist;

	va_start(alist, fmt);
	pu_output(LOG_ERR, fmt, alist);
	va_end(alist);
	halt_application();
}

/*
 * If SIGHUP is invoked, we should just re-initialize poold. Since
 * there is no easy way to determine when it's safe to re-initialzie
 * poold, simply update a dummy property on the system element to
 * force pool_conf_update() to detect a change.
 *
 * Both SIGTERM and SIGINT are interpreted as instructions to
 * shutdown.
 */
/*ARGSUSED*/
static void *
handle_sig(void *arg)
{
	pool_conf_t *conf = NULL;
	pool_elem_t *pe;
	pool_value_t *val;
	const char *err_desc;
	int keep_handling = 1;

	while (keep_handling) {
		int sig;
		char buf[SIG2STR_MAX];

		if ((sig = sigwait(&hdl_set)) < 0) {
			/*
			 * We used forkall() previously to ensure that
			 * all threads started by the JVM are
			 * duplicated in the child. Since forkall()
			 * can cause blocking system calls to be
			 * interrupted, check to see if the errno is
			 * EINTR and if it is wait again.
			 */
			if (errno == EINTR)
				continue;
			(void) pthread_mutex_lock(&jvm_lock);
			pu_terminate("unexpected error: %d\n", errno);
			keep_handling = 0;
		} else
			(void) pthread_mutex_lock(&jvm_lock);
		(void) sig2str(sig, buf);
		switch (sig) {
		case SIGHUP:
			if ((conf = pool_conf_alloc()) == NULL) {
				err_desc = pool_strerror(pool_error());
				goto destroy;
			}
			if (pool_conf_open(conf, pool_dynamic_location(),
			    PO_RDWR) != 0) {
				err_desc = pool_strerror(pool_error());
				goto destroy;
			}

			if ((val = pool_value_alloc()) == NULL) {
				err_desc = pool_strerror(pool_error());
				goto destroy;
			}
			pe = pool_conf_to_elem(conf);
			pool_value_set_bool(val, 1);
			if (pool_put_property(conf, pe, "system.poold.sighup",
			    val) != PO_SUCCESS) {
				err_desc = pool_strerror(pool_error());
				pool_value_free(val);
				goto destroy;
			}
			pool_value_free(val);
			(void) pool_rm_property(conf, pe,
			    "system.poold.sighup");
			if (pool_conf_commit(conf, 0) != PO_SUCCESS) {
				err_desc = pool_strerror(pool_error());
				goto destroy;
			}
			(void) pool_conf_close(conf);
			pool_conf_free(conf);
			break;
destroy:
			if (conf) {
				(void) pool_conf_close(conf);
				pool_conf_free(conf);
			}
			pu_terminate(err_desc);
			keep_handling = 0;
			break;
		case SIGINT:
		case SIGTERM:
		default:
			pu_terminate("terminating due to signal: SIG%s\n", buf);
			keep_handling = 0;
			break;
		}
		(void) pthread_mutex_unlock(&jvm_lock);
	}
	pthread_exit(NULL);
	/*NOTREACHED*/
	return (NULL);
}

/*
 * Return the name of the process
 */
static const char *
pu_getpname(const char *arg0)
{
	char *p;

	/*
	 * Guard against '/' at end of command invocation.
	 */
	for (;;) {
		p = strrchr(arg0, '/');
		if (p == NULL) {
			pname = arg0;
			break;
		} else {
			if (*(p + 1) == '\0') {
				*p = '\0';
				continue;
			}

			pname = p + 1;
			break;
		}
	}

	return (pname);
}

int
main(int argc, char *argv[])
{
	int c;
	char log_severity[16] = "";
	JavaVMInitArgs vm_args;
	JavaVMOption vm_opts[5];
	int nopts = 0;
	const char *classpath;
	const char *libpath;
	size_t len;
	const char *err_desc;
	JNIEnv *env;
	jmethodID poold_getinstancewcl_mid;
	jmethodID poold_run_mid;
	jobject log_severity_string = NULL;
	jobject log_severity_obj = NULL;
	jclass severity_class;
	jmethodID severity_cons_mid;
	jfieldID base_log_fid;
	pthread_t hdl_thread;
	FILE *p;

	(void) pthread_mutex_lock(&jvm_lock);
	pname = pu_getpname(argv[0]);
	openlog(pname, 0, LOG_DAEMON);
	(void) chdir("/");

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)		/* Should be defined with cc -D. */
#define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it wasn't. */
#endif
	(void) textdomain(TEXT_DOMAIN);

	opterr = 0;
	while ((c = getopt(argc, argv, "l:P")) != EOF) {
		switch (c) {
		case 'l':	/* -l option */
			lflag++;
			(void) strlcpy(log_severity, optarg,
			    sizeof (log_severity));
			log_dest = LD_TERMINAL;
			break;
		default:
			usage();
			/*NOTREACHED*/
		}
	}

	/*
	 * Check permission
	 */
	if (!priv_ineffect(PRIV_SYS_RES_CONFIG))
		pu_die(gettext(ERR_PRIVILEGE), PRIV_SYS_RES_CONFIG);

	/*
	 * In order to avoid problems with arbitrary thread selection
	 * when handling asynchronous signals, dedicate a thread to
	 * look after these signals.
	 */
	if (sigemptyset(&hdl_set) < 0 ||
	    sigaddset(&hdl_set, SIGHUP) < 0 ||
	    sigaddset(&hdl_set, SIGTERM) < 0 ||
	    sigaddset(&hdl_set, SIGINT) < 0 ||
	    pthread_sigmask(SIG_BLOCK, &hdl_set, NULL) ||
	    pthread_create(&hdl_thread, NULL, handle_sig, NULL))
		pu_die(gettext("can't install signal handler"));

	/*
	 * If the -l flag is supplied, terminate the SMF service and
	 * run interactively from the command line.
	 */
	if (lflag) {
		char *cmd = "/sbin/svcadm disable -st " SMF_SVC_INSTANCE;

		if (getenv("SMF_FMRI") != NULL)
			pu_die("-l option illegal: %s\n", SMF_SVC_INSTANCE);
		/*
		 * Since disabling a service isn't synchronous, use the
		 * synchronous option from svcadm to achieve synchronous
		 * behaviour.
		 * This is not very satisfactory, but since this is only
		 * for use in debugging scenarios, it will do until there
		 * is a C API to synchronously shutdown a service in SMF.
		 */
		if ((p = popen(cmd, "w")) == NULL || pclose(p) != 0)
			pu_die("could not temporarily disable service: %s\n",
			    SMF_SVC_INSTANCE);
	} else {
		/*
		 * Check if we are running as a SMF service. If we
		 * aren't, terminate this process after enabling the
		 * service.
		 */
		if (getenv("SMF_FMRI") == NULL) {
			char *cmd = "/sbin/svcadm enable -s " \
			    SMF_SVC_INSTANCE;
			if ((p = popen(cmd, "w")) == NULL || pclose(p) != 0)
				pu_die("could not enable "
				    "service: %s\n", SMF_SVC_INSTANCE);
			return (E_PO_SUCCESS);
		}
	}

	/*
	 * Establish the classpath and LD_LIBRARY_PATH for native
	 * methods, and get the interpreter going.
	 */
	if ((classpath = getenv("POOLD_CLASSPATH")) == NULL) {
		classpath = POOLD_DEF_CLASSPATH;
	} else {
		const char *cur = classpath;

		/*
		 * Check the components to make sure they're absolute
		 * paths.
		 */
		while (cur != NULL && *cur) {
			if (*cur != '/')
				pu_die(gettext(
				    "POOLD_CLASSPATH must contain absolute "
				    "components\n"));
			cur = strchr(cur + 1, ':');
		}
	}
	vm_opts[nopts].optionString = malloc(len = strlen(classpath) +
	    strlen("-Djava.class.path=") + 1);
	(void) strlcpy(vm_opts[nopts].optionString, "-Djava.class.path=", len);
	(void) strlcat(vm_opts[nopts++].optionString, classpath, len);

	if ((libpath = getenv("POOLD_LD_LIBRARY_PATH")) == NULL)
		libpath = POOLD_DEF_LIBPATH;
	vm_opts[nopts].optionString = malloc(len = strlen(libpath) +
	    strlen("-Djava.library.path=") + 1);
	(void) strlcpy(vm_opts[nopts].optionString, "-Djava.library.path=",
	    len);
	(void) strlcat(vm_opts[nopts++].optionString, libpath, len);

	vm_opts[nopts++].optionString = "-Xrs";
	vm_opts[nopts++].optionString = "-enableassertions";

	vm_args.options = vm_opts;
	vm_args.nOptions = nopts;
	vm_args.ignoreUnrecognized = JNI_FALSE;
	vm_args.version = 0x00010002;

	if (JNI_CreateJavaVM(&jvm, (void **)&env, &vm_args) < 0)
		pu_die(gettext("can't create Java VM"));

	/*
	 * Locate the Poold class and construct an instance.  A side
	 * effect of this is that the poold instance's logHelper will be
	 * initialized, establishing loggers for logging errors from
	 * this point on.  (Note, in the event of an unanticipated
	 * exception, poold will invoke die() itself.)
	 */
	err_desc = gettext("JVM-related error initializing poold\n");
	if ((poold_class = (*env)->FindClass(env, POOLD_CLASS_DESC)) == NULL)
		goto destroy;
	if ((poold_getinstancewcl_mid = (*env)->GetStaticMethodID(env,
	    poold_class, "getInstanceWithConsoleLogging", "("
	    CLASS_FIELD_DESC(SEVERITY_CLASS_DESC) ")"
	    CLASS_FIELD_DESC(POOLD_CLASS_DESC))) == NULL)
		goto destroy;
	if ((poold_run_mid = (*env)->GetMethodID(env, poold_class, "run",
	    "()V")) == NULL)
		goto destroy;
	if ((severity_class = (*env)->FindClass(env, SEVERITY_CLASS_DESC))
	    == NULL)
		goto destroy;
	if ((severity_cons_mid = (*env)->GetStaticMethodID(env, severity_class,
	    "getSeverityWithName", "(" CLASS_FIELD_DESC(STRING_CLASS_DESC) ")"
	    CLASS_FIELD_DESC(SEVERITY_CLASS_DESC))) == NULL)
		goto destroy;

	/*
	 * -l <level> was specified, indicating that messages are to be
	 * logged to the console only.
	 */
	if (strlen(log_severity) > 0) {
		if ((log_severity_string = (*env)->NewStringUTF(env,
		    log_severity)) == NULL)
			goto destroy;
		if ((log_severity_obj = (*env)->CallStaticObjectMethod(env,
		    severity_class, severity_cons_mid, log_severity_string)) ==
		    NULL) {
			err_desc = gettext("invalid level specified\n");
			goto destroy;
		}
	} else
		log_severity_obj = NULL;

	if ((poold_instance = (*env)->CallStaticObjectMethod(env, poold_class,
	    poold_getinstancewcl_mid, log_severity_obj)) == NULL)
		goto destroy;

	/*
	 * Grab a global reference to poold for use in our signal
	 * handlers.
	 */
	poold_instance = (*env)->NewGlobalRef(env, poold_instance);

	/*
	 * Ready LD_JAVA logging.
	 */
	err_desc = gettext("cannot initialize logging\n");
	if ((log_severity_string = (*env)->NewStringUTF(env, "err")) == NULL)
		goto destroy;
	if (!(severity_err = (*env)->CallStaticObjectMethod(env, severity_class,
	    severity_cons_mid, log_severity_string)))
		goto destroy;
	if (!(severity_err = (*env)->NewGlobalRef(env, severity_err)))
		goto destroy;

	if ((log_severity_string = (*env)->NewStringUTF(env, "notice")) == NULL)
		goto destroy;
	if (!(severity_notice = (*env)->CallStaticObjectMethod(env,
	    severity_class, severity_cons_mid, log_severity_string)))
		goto destroy;
	if (!(severity_notice = (*env)->NewGlobalRef(env, severity_notice)))
		goto destroy;

	if (!(base_log_fid = (*env)->GetStaticFieldID(env, poold_class,
	    "BASE_LOG", CLASS_FIELD_DESC(LOGGER_CLASS_DESC))))
		goto destroy;
	if (!(base_log = (*env)->GetStaticObjectField(env, poold_class,
	    base_log_fid)))
		goto destroy;
	if (!(base_log = (*env)->NewGlobalRef(env, base_log)))
		goto destroy;
	if (!(log_mid = (*env)->GetMethodID(env, (*env)->GetObjectClass(env,
	    base_log), "log", "(" CLASS_FIELD_DESC(LEVEL_CLASS_DESC)
	    CLASS_FIELD_DESC(STRING_CLASS_DESC) ")V")))
		goto destroy;
	log_dest = LD_JAVA;

	/*
	 * If invoked directly and -l is specified, forking is not
	 * desired.
	 */
	if (!lflag)
		switch (forkall()) {
		case 0:
			(void) setsid();
			(void) fclose(stdin);
			(void) fclose(stdout);
			(void) fclose(stderr);
			break;
		case -1:
			pu_die(gettext("cannot fork"));
			/*NOTREACHED*/
		default:
			return (E_PO_SUCCESS);
		}

	instance_running = 1;
	(void) pthread_mutex_unlock(&jvm_lock);

	(*env)->CallVoidMethod(env, poold_instance, poold_run_mid);

	(void) pthread_mutex_lock(&jvm_lock);
	if ((*env)->ExceptionOccurred(env)) {
		goto destroy;
	}
	if (jvm) {
		(*jvm)->DestroyJavaVM(jvm);
		jvm = NULL;
	}
	(void) pthread_mutex_unlock(&jvm_lock);
	return (E_PO_SUCCESS);

destroy:
	if (lflag && (*env)->ExceptionOccurred(env))
		(*env)->ExceptionDescribe(env);
	pu_die(err_desc);
}
#
# Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# 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
#

#
# NOTICE:  This file contains default settings for poold(8).  Do not
# edit this file.  Its format and contents are subject to change in
# future releases of Solaris.

# Objective Classes

system.objectives= com.sun.solaris.domain.pools.WeightedLoadObjective
pset.objectives= com.sun.solaris.domain.pools.LocalityObjective, com.sun.solaris.domain.pools.UtilizationObjective

# poold-specific logging properties (replacing default logging.properties)
.level= ALL

# Set defaults for all logfiles (poold and API-generated) which are suitable
# for management by logadm(8).
java.util.logging.FileHandler.limit = 0
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.append = true

# Change defaults for API-generated logfiles.
java.util.logging.FileHandler.pattern = /var/log/pool/java%u.log
java.util.logging.FileHandler.formatter = com.sun.solaris.service.logging.SysloglikeFormatter
<?xml version="1.0"?>
<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
<!--
    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 2005 Sun Microsystems, Inc.  All rights reserved.
    Use is subject to license terms.

    NOTE:  This service manifest is not editable; its contents will
    be overwritten by package or patch operations, including
    operating system upgrade.  Make customizations in a different
    file.
-->

<service_bundle type='manifest' name='SUNWpoolr:poold'>

<service
	name='system/pools/dynamic'
	type='service'
	version='1'>

	<create_default_instance enabled='false' />

	<single_instance />

	<dependency
		name='var'
		type='service'
		grouping='require_all'
		restart_on='none'>
		<service_fmri value='svc:/system/filesystem/local' />
	</dependency>

	<!-- Resource Pools service must be active. -->
	<!-- poold detects changes to the Resource Pools configuration,
	     so restart_on is set to 'none'. -->
	<dependency
		name='pools'
		type='service'
		grouping='require_all'
		restart_on='none'>
		<service_fmri value='svc:/system/pools:default' />
	</dependency>

	<exec_method
		type='method'
		name='start'
		exec='/lib/svc/method/svc-poold %m'
		timeout_seconds='60'>
		<method_context working_directory='/'>
			<method_credential user='root' group='root' />
		</method_context>
	</exec_method>

	<exec_method
		type='method'
		name='stop'
		exec=':kill'
		timeout_seconds='60'>
		<method_context working_directory='/'>
			<method_credential user='root' group='root' />
		</method_context>
	</exec_method>

	<exec_method
		type='method'
		name='refresh'
		exec=':kill -HUP'
		timeout_seconds='60'>
		<method_context working_directory='/'>
			<method_credential user='root' group='root' />
		</method_context>
	</exec_method>

	<stability value='Unstable' />

	<template>
		<common_name>
			<loctext xml:lang='C'>
			dynamic resource pools
			</loctext>
		</common_name>
		<documentation>
			<manpage title='poold' section='8' manpath='/usr/share/man' />
		</documentation>
	</template>
</service>

</service_bundle>
#!/sbin/sh
#
# 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.
#
# ident	"%Z%%M%	%I%	%E% SMI"
#
# Method script for the pools service.
#

. /lib/svc/share/smf_include.sh

if [ ! -x /usr/lib/pool/poold ]; then
	echo "/usr/lib/pool/poold not found or not executable"
	exit $SMF_EXIT_ERR_FATAL
fi

if smf_is_nonglobalzone; then
	echo "poold cannot be run in non-global zones"
	exit $SMF_EXIT_ERR_FATAL
fi

case "$1" in
'start')
	/usr/lib/pool/poold
	err=$?
	if [ $err -ne 0 ]; then
		echo "poold failed to start: error $err"
		exit $SMF_EXIT_ERR_FATAL
	fi
	;;
*)
	echo "Usage: $0 { start }"
	exit $SMF_EXIT_ERR_FATAL
	;;
esac

exit $SMF_EXIT_OK