+ * A control string is a Java string that contains a
+ * control specification. The control specification
+ * starts at the first percent sign (%) in the string,
+ * provided that this percent sign
+ *
+ * The format is composed of zero or more directives
+ * defined as follows:
+ *
+ * The results are undefined if there are insufficient
+ * arguments for the format. Usually an unchecked
+ * exception will be thrown. If the format is
+ * exhausted while arguments remain, the excess
+ * arguments are evaluated but are otherwise ignored.
+ * In format strings containing the % form of
+ * conversion specifications, each argument in the
+ * argument list is used exactly once.
+ *
+ * The following table lists escape sequences and
+ * associated actions on display devices capable of
+ * the action.
+ *
+ * Each conversion specification is introduced by
+ * the percent sign character (%). After the character
+ * %, the following appear in sequence:
+ *
+ * Zero or more flags (in any order), which modify the
+ * meaning of the conversion specification.
+ *
+ * An optional minimum field width. If the converted
+ * value has fewer characters than the field width, it
+ * will be padded with spaces by default on the left;
+ * t will be padded on the right, if the left-
+ * adjustment flag (-), described below, is given to
+ * the field width. The field width takes the form
+ * of a decimal integer. If the conversion character
+ * is s, the field width is the the minimum number of
+ * characters to be printed.
+ *
+ * An optional precision that gives the minumum number
+ * of digits to appear for the d, i, o, x or X
+ * conversions (the field is padded with leading
+ * zeros); the number of digits to appear after the
+ * radix character for the e, E, and f conversions,
+ * the maximum number of significant digits for the g
+ * and G conversions; or the maximum number of
+ * characters to be written from a string is s and S
+ * conversions. The precision takes the form of an
+ * optional decimal digit string, where a null digit
+ * string is treated as 0. If a precision appears
+ * with a c conversion character the precision is
+ * ignored.
+ *
+ *
+ * An optional h specifies that a following d, i, o,
+ * x, or X conversion character applies to a type
+ * short argument (the argument will be promoted
+ * according to the integral promotions and its value
+ * converted to type short before printing).
+ *
+ * An optional l (ell) specifies that a following
+ * d, i, o, x, or X conversion character applies to a
+ * type long argument.
+ *
+ * A field width or precision may be indicated by an
+ * asterisk (*) instead of a digit string. In this
+ * case, an integer argument supplised the field width
+ * precision. The argument that is actually converted
+ * is not fetched until the conversion letter is seen,
+ * so the the arguments specifying field width or
+ * precision must appear before the argument (if any)
+ * to be converted. If the precision argument is
+ * negative, it will be changed to zero. A negative
+ * field width argument is taken as a - flag, followed
+ * by a positive field width.
+ *
+ * The format can contain either numbered argument
+ * specifications (that is, %n$ and
+ * *m$), or unnumbered argument
+ * specifications (that is % and *), but normally not
+ * both. The only exception to this is that %% can
+ * be mixed with the %n$ form. The
+ * results of mixing numbered and unnumbered argument
+ * specifications in a format string are undefined.
+ *
+ *
+ * Each conversion character results in fetching zero
+ * or more arguments. The results are undefined if
+ * there are insufficient arguments for the format.
+ * Usually, an unchecked exception will be thrown.
+ * If the format is exhausted while arguments remain,
+ * the excess arguments are ignored.
+ *
+ *
+ * If a conversion specification does not match one of
+ * the above forms, an IllegalArgumentException is
+ * thrown and the instance of PrintfFormat is not
+ * created.
+ *
+ * If a floating point value is the internal
+ * representation for infinity, the output is
+ * [+]Infinity, where Infinity is either Infinity or
+ * Inf, depending on the desired output string length.
+ * Printing of the sign follows the rules described
+ * above.
+ *
+ * If a floating point value is the internal
+ * representation for "not-a-number," the output is
+ * [+]NaN. Printing of the sign follows the rules
+ * described above.
+ *
+ * In no case does a non-existent or small field width
+ * cause truncation of a field; if the result of a
+ * conversion is wider than the field width, the field
+ * is simply expanded to contain the conversion result.
+ *
+ *
+ * The behavior is like printf. One exception is that
+ * the minimum number of exponent digits is 3 instead
+ * of 2 for e and E formats when the optional L is used
+ * before the e, E, g, or G conversion character. The
+ * optional L does not imply conversion to a long long
+ * double.
+ *
+ * The biggest divergence from the C printf
+ * specification is in the use of 16 bit characters.
+ * This allows the handling of characters beyond the
+ * small ASCII character set and allows the utility to
+ * interoperate correctly with the rest of the Java
+ * runtime environment.
+ *
+ * Omissions from the C printf specification are
+ * numerous. All the known omissions are present
+ * because Java never uses bytes to represent
+ * characters and does not have pointers:
+ *
+ * Most of this specification is quoted from the Unix
+ * man page for the sprintf utility.
+ *
+ * @author Allan Jacobs
+ * @version 1
+ * Release 1: Initial release.
+ * Release 2: Asterisk field widths and precisions
+ * %n$ and *m$
+ * Bug fixes
+ * g format fix (2 digits in e form corrupt)
+ * rounding in f format implemented
+ * round up when digit not printed is 5
+ * formatting of -0.0f
+ * round up/down when last digits are 50000...
+ */
+public class PrintfFormat {
+ /**
+ * Constructs an array of control specifications
+ * possibly preceded, separated, or followed by
+ * ordinary strings. Control strings begin with
+ * unpaired percent signs. A pair of successive
+ * percent signs designates a single percent sign in
+ * the format.
+ * @param fmtArg Control string.
+ * @exception IllegalArgumentException if the control
+ * string is null, zero length, or otherwise
+ * malformed.
+ */
+ public PrintfFormat(String fmtArg)
+ throws IllegalArgumentException {
+ this(Locale.getDefault(),fmtArg);
+ }
+ /**
+ * Constructs an array of control specifications
+ * possibly preceded, separated, or followed by
+ * ordinary strings. Control strings begin with
+ * unpaired percent signs. A pair of successive
+ * percent signs designates a single percent sign in
+ * the format.
+ * @param fmtArg Control string.
+ * @exception IllegalArgumentException if the control
+ * string is null, zero length, or otherwise
+ * malformed.
+ */
+ public PrintfFormat(Locale locale,String fmtArg)
+ throws IllegalArgumentException {
+ dfs = new DecimalFormatSymbols(locale);
+ int ePos=0;
+ ConversionSpecification sFmt=null;
+ String unCS = this.nonControl(fmtArg,0);
+ if (unCS!=null) {
+ sFmt = new ConversionSpecification();
+ sFmt.setLiteral(unCS);
+ vFmt.addElement(sFmt);
+ }
+ while(cPos!=-1 && cPosstart and ending at either the end
+ * of the String s, the next unpaired
+ * percent sign, or at the end of the String if the
+ * last character is a percent sign.
+ * @param s Control string.
+ * @param start Position in the string
+ * s to begin looking for the start
+ * of a control string.
+ * @return the substring from the start position
+ * to the beginning of the control string.
+ */
+ private String nonControl(String s,int start) {
+ cPos=s.indexOf("%",start);
+ if (cPos==-1) cPos=s.length();
+ return s.substring(start,cPos);
+ }
+ /**
+ * Format an array of objects. Byte, Short,
+ * Integer, Long, Float, Double, and Character
+ * arguments are treated as wrappers for primitive
+ * types.
+ * @param o The array of objects to format.
+ * @return The formatted String.
+ */
+ public String sprintf(Object[] o) {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ int i=0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ else {
+ if (cs.isPositionalSpecification()) {
+ i=cs.getArgumentPosition()-1;
+ if (cs.isPositionalFieldWidth()) {
+ int ifw=cs.getArgumentPositionForFieldWidth()-1;
+ cs.setFieldWidthWithArg(((Integer)o[ifw]).intValue());
+ }
+ if (cs.isPositionalPrecision()) {
+ int ipr=cs.getArgumentPositionForPrecision()-1;
+ cs.setPrecisionWithArg(((Integer)o[ipr]).intValue());
+ }
+ }
+ else {
+ if (cs.isVariableFieldWidth()) {
+ cs.setFieldWidthWithArg(((Integer)o[i]).intValue());
+ i++;
+ }
+ if (cs.isVariablePrecision()) {
+ cs.setPrecisionWithArg(((Integer)o[i]).intValue());
+ i++;
+ }
+ }
+ if (o[i] instanceof Byte)
+ sb.append(cs.internalsprintf(
+ ((Byte)o[i]).byteValue()));
+ else if (o[i] instanceof Short)
+ sb.append(cs.internalsprintf(
+ ((Short)o[i]).shortValue()));
+ else if (o[i] instanceof Integer)
+ sb.append(cs.internalsprintf(
+ ((Integer)o[i]).intValue()));
+ else if (o[i] instanceof Long)
+ sb.append(cs.internalsprintf(
+ ((Long)o[i]).longValue()));
+ else if (o[i] instanceof Float)
+ sb.append(cs.internalsprintf(
+ ((Float)o[i]).floatValue()));
+ else if (o[i] instanceof Double)
+ sb.append(cs.internalsprintf(
+ ((Double)o[i]).doubleValue()));
+ else if (o[i] instanceof Character)
+ sb.append(cs.internalsprintf(
+ ((Character)o[i]).charValue()));
+ else if (o[i] instanceof String)
+ sb.append(cs.internalsprintf(
+ (String)o[i]));
+ else
+ sb.append(cs.internalsprintf(
+ o[i]));
+ if (!cs.isPositionalSpecification())
+ i++;
+ }
+ }
+ return sb.toString();
+ }
+ /**
+ * Format nothing. Just use the control string.
+ * @return the formatted String.
+ */
+ public String sprintf() {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ }
+ return sb.toString();
+ }
+ /**
+ * Format an int.
+ * @param x The int to format.
+ * @return The formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is f, e, E, g, G, s,
+ * or S.
+ */
+ public String sprintf(int x)
+ throws IllegalArgumentException {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ else sb.append(cs.internalsprintf(x));
+ }
+ return sb.toString();
+ }
+ /**
+ * Format an long.
+ * @param x The long to format.
+ * @return The formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is f, e, E, g, G, s,
+ * or S.
+ */
+ public String sprintf(long x)
+ throws IllegalArgumentException {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ else sb.append(cs.internalsprintf(x));
+ }
+ return sb.toString();
+ }
+ /**
+ * Format a double.
+ * @param x The double to format.
+ * @return The formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is c, C, s, S,
+ * d, d, x, X, or o.
+ */
+ public String sprintf(double x)
+ throws IllegalArgumentException {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ else sb.append(cs.internalsprintf(x));
+ }
+ return sb.toString();
+ }
+ /**
+ * Format a String.
+ * @param x The String to format.
+ * @return The formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is neither s nor S.
+ */
+ public String sprintf(String x)
+ throws IllegalArgumentException {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ else sb.append(cs.internalsprintf(x));
+ }
+ return sb.toString();
+ }
+ /**
+ * Format an Object. Convert wrapper types to
+ * their primitive equivalents and call the
+ * appropriate internal formatting method. Convert
+ * Strings using an internal formatting method for
+ * Strings. Otherwise use the default formatter
+ * (use toString).
+ * @param x the Object to format.
+ * @return the formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is inappropriate for
+ * formatting an unwrapped value.
+ */
+ public String sprintf(Object x)
+ throws IllegalArgumentException {
+ Enumeration e = vFmt.elements();
+ ConversionSpecification cs = null;
+ char c = 0;
+ StringBuffer sb=new StringBuffer();
+ while (e.hasMoreElements()) {
+ cs = (ConversionSpecification)
+ e.nextElement();
+ c = cs.getConversionCharacter();
+ if (c=='\0') sb.append(cs.getLiteral());
+ else if (c=='%') sb.append("%");
+ else {
+ if (x instanceof Byte)
+ sb.append(cs.internalsprintf(
+ ((Byte)x).byteValue()));
+ else if (x instanceof Short)
+ sb.append(cs.internalsprintf(
+ ((Short)x).shortValue()));
+ else if (x instanceof Integer)
+ sb.append(cs.internalsprintf(
+ ((Integer)x).intValue()));
+ else if (x instanceof Long)
+ sb.append(cs.internalsprintf(
+ ((Long)x).longValue()));
+ else if (x instanceof Float)
+ sb.append(cs.internalsprintf(
+ ((Float)x).floatValue()));
+ else if (x instanceof Double)
+ sb.append(cs.internalsprintf(
+ ((Double)x).doubleValue()));
+ else if (x instanceof Character)
+ sb.append(cs.internalsprintf(
+ ((Character)x).charValue()));
+ else if (x instanceof String)
+ sb.append(cs.internalsprintf(
+ (String)x));
+ else
+ sb.append(cs.internalsprintf(x));
+ }
+ }
+ return sb.toString();
+ }
+ /**
+ *
+ * ConversionSpecification allows the formatting of
+ * a single primitive or object embedded within a
+ * string. The formatting is controlled by a
+ * format string. Only one Java primitive or
+ * object can be formatted at a time.
+ *
+ * A format string is a Java string that contains
+ * a control string. The control string starts at
+ * the first percent sign (%) in the string,
+ * provided that this percent sign
+ *
+ *- is not escaped protected by a matching % or
+ * is not an escape % character,
+ *
- is not at the end of the format string, and
+ *
- precedes a sequence of characters that parses
+ * as a valid control string.
+ *
+ *
+ * A control string takes the form:
+ *
% ['-+ #0]* [0..9]* { . [0..9]* }+
+ * { [hlL] }+ [idfgGoxXeEcs]
+ *
+ *
+ * The behavior is like printf. One (hopefully the
+ * only) exception is that the minimum number of
+ * exponent digits is 3 instead of 2 for e and E
+ * formats when the optional L is used before the
+ * e, E, g, or G conversion character. The
+ * optional L does not imply conversion to a long
+ * long double.
+ */
+ private class ConversionSpecification {
+ /**
+ * Constructor. Used to prepare an instance
+ * to hold a literal, not a control string.
+ */
+ ConversionSpecification() { }
+ /**
+ * Constructor for a conversion specification.
+ * The argument must begin with a % and end
+ * with the conversion character for the
+ * conversion specification.
+ * @param fmtArg String specifying the
+ * conversion specification.
+ * @exception IllegalArgumentException if the
+ * input string is null, zero length, or
+ * otherwise malformed.
+ */
+ ConversionSpecification(String fmtArg)
+ throws IllegalArgumentException {
+ if (fmtArg==null)
+ throw new NullPointerException();
+ if (fmtArg.length()==0)
+ throw new IllegalArgumentException(
+ "Control strings must have positive"+
+ " lengths.");
+ if (fmtArg.charAt(0)=='%') {
+ fmt = fmtArg;
+ pos=1;
+ setArgPosition();
+ setFlagCharacters();
+ setFieldWidth();
+ setPrecision();
+ setOptionalHL();
+ if (setConversionCharacter()) {
+ if (pos==fmtArg.length()) {
+ if(leadingZeros&&leftJustify)
+ leadingZeros=false;
+ if(precisionSet&&leadingZeros){
+ if(conversionCharacter=='d'
+ ||conversionCharacter=='i'
+ ||conversionCharacter=='o'
+ ||conversionCharacter=='x')
+ {
+ leadingZeros=false;
+ }
+ }
+ }
+ else
+ throw new IllegalArgumentException(
+ "Malformed conversion specification="+
+ fmtArg);
+ }
+ else
+ throw new IllegalArgumentException(
+ "Malformed conversion specification="+
+ fmtArg);
+ }
+ else
+ throw new IllegalArgumentException(
+ "Control strings must begin with %.");
+ }
+ /**
+ * Set the String for this instance.
+ * @param s the String to store.
+ */
+ void setLiteral(String s) {
+ fmt = s;
+ }
+ /**
+ * Get the String for this instance. Translate
+ * any escape sequences.
+ *
+ * @return s the stored String.
+ */
+ String getLiteral() {
+ StringBuffer sb=new StringBuffer();
+ int i=0;
+ while (itrue if the conversion
+ * uses an * field width; otherwise
+ * false.
+ */
+ boolean isVariableFieldWidth() {
+ return variableFieldWidth;
+ }
+ /**
+ * Set the field width with an argument. A
+ * negative field width is taken as a - flag
+ * followed by a positive field width.
+ * @param fw the field width.
+ */
+ void setFieldWidthWithArg(int fw) {
+ if (fw<0) leftJustify = true;
+ fieldWidthSet = true;
+ fieldWidth = Math.abs(fw);
+ }
+ /**
+ * Check whether the specifier has a variable
+ * precision that is going to be set by an
+ * argument.
+ * @return true if the conversion
+ * uses an * precision; otherwise
+ * false.
+ */
+ boolean isVariablePrecision() {
+ return variablePrecision;
+ }
+ /**
+ * Set the precision with an argument. A
+ * negative precision will be changed to zero.
+ * @param pr the precision.
+ */
+ void setPrecisionWithArg(int pr) {
+ precisionSet = true;
+ precision = Math.max(pr,0);
+ }
+ /**
+ * Format an int argument using this conversion
+ * specification.
+ * @param s the int to format.
+ * @return the formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is f, e, E, g, or G.
+ */
+ String internalsprintf(int s)
+ throws IllegalArgumentException {
+ String s2 = "";
+ switch(conversionCharacter) {
+ case 'd':
+ case 'i':
+ if (optionalh)
+ s2 = printDFormat((short)s);
+ else if (optionall)
+ s2 = printDFormat((long)s);
+ else
+ s2 = printDFormat(s);
+ break;
+ case 'x':
+ case 'X':
+ if (optionalh)
+ s2 = printXFormat((short)s);
+ else if (optionall)
+ s2 = printXFormat((long)s);
+ else
+ s2 = printXFormat(s);
+ break;
+ case 'o':
+ if (optionalh)
+ s2 = printOFormat((short)s);
+ else if (optionall)
+ s2 = printOFormat((long)s);
+ else
+ s2 = printOFormat(s);
+ break;
+ case 'c':
+ case 'C':
+ s2 = printCFormat((char)s);
+ break;
+ default:
+ throw new IllegalArgumentException(
+ "Cannot format a int with a format using a "+
+ conversionCharacter+
+ " conversion character.");
+ }
+ return s2;
+ }
+ /**
+ * Format a long argument using this conversion
+ * specification.
+ * @param s the long to format.
+ * @return the formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is f, e, E, g, or G.
+ */
+ String internalsprintf(long s)
+ throws IllegalArgumentException {
+ String s2 = "";
+ switch(conversionCharacter) {
+ case 'd':
+ case 'i':
+ if (optionalh)
+ s2 = printDFormat((short)s);
+ else if (optionall)
+ s2 = printDFormat(s);
+ else
+ s2 = printDFormat((int)s);
+ break;
+ case 'x':
+ case 'X':
+ if (optionalh)
+ s2 = printXFormat((short)s);
+ else if (optionall)
+ s2 = printXFormat(s);
+ else
+ s2 = printXFormat((int)s);
+ break;
+ case 'o':
+ if (optionalh)
+ s2 = printOFormat((short)s);
+ else if (optionall)
+ s2 = printOFormat(s);
+ else
+ s2 = printOFormat((int)s);
+ break;
+ case 'c':
+ case 'C':
+ s2 = printCFormat((char)s);
+ break;
+ default:
+ throw new IllegalArgumentException(
+ "Cannot format a long with a format using a "+
+ conversionCharacter+" conversion character.");
+ }
+ return s2;
+ }
+ /**
+ * Format a double argument using this conversion
+ * specification.
+ * @param s the double to format.
+ * @return the formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is c, C, s, S, i, d,
+ * x, X, or o.
+ */
+ String internalsprintf(double s)
+ throws IllegalArgumentException {
+ String s2 = "";
+ switch(conversionCharacter) {
+ case 'f':
+ s2 = printFFormat(s);
+ break;
+ case 'E':
+ case 'e':
+ s2 = printEFormat(s);
+ break;
+ case 'G':
+ case 'g':
+ s2 = printGFormat(s);
+ break;
+ default:
+ throw new IllegalArgumentException("Cannot "+
+ "format a double with a format using a "+
+ conversionCharacter+" conversion character.");
+ }
+ return s2;
+ }
+ /**
+ * Format a String argument using this conversion
+ * specification.
+ * @param s the String to format.
+ * @return the formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is neither s nor S.
+ */
+ String internalsprintf(String s)
+ throws IllegalArgumentException {
+ String s2 = "";
+ if(conversionCharacter=='s'
+ || conversionCharacter=='S')
+ s2 = printSFormat(s);
+ else
+ throw new IllegalArgumentException("Cannot "+
+ "format a String with a format using a "+
+ conversionCharacter+" conversion character.");
+ return s2;
+ }
+ /**
+ * Format an Object argument using this conversion
+ * specification.
+ * @param s the Object to format.
+ * @return the formatted String.
+ * @exception IllegalArgumentException if the
+ * conversion character is neither s nor S.
+ */
+ String internalsprintf(Object s) {
+ if (s == null) {
+ return "";
+ }
+
+ String s2 = "";
+ if(conversionCharacter=='s'
+ || conversionCharacter=='S')
+ s2 = printSFormat(s.toString());
+ else
+ throw new IllegalArgumentException(
+ "Cannot format a String with a format using"+
+ " a "+conversionCharacter+
+ " conversion character.");
+ return s2;
+ }
+ /**
+ * For f format, the flag character '-', means that
+ * the output should be left justified within the
+ * field. The default is to pad with blanks on the
+ * left. '+' character means that the conversion
+ * will always begin with a sign (+ or -). The
+ * blank flag character means that a non-negative
+ * input will be preceded with a blank. If both
+ * a '+' and a ' ' are specified, the blank flag
+ * is ignored. The '0' flag character implies that
+ * padding to the field width will be done with
+ * zeros instead of blanks.
+ *
+ * The field width is treated as the minimum number
+ * of characters to be printed. The default is to
+ * add no padding. Padding is with blanks by
+ * default.
+ *
+ * The precision, if set, is the number of digits
+ * to appear after the radix character. Padding is
+ * with trailing 0s.
+ */
+ private char[] fFormatDigits(double x) {
+ // int defaultDigits=6;
+ String sx;
+ int i,j,k;
+ int n1In,n2In;
+ int expon=0;
+ boolean minusSign=false;
+ if (x>0.0)
+ sx = Double.toString(x);
+ else if (x<0.0) {
+ sx = Double.toString(-x);
+ minusSign=true;
+ }
+ else {
+ sx = Double.toString(x);
+ if (sx.charAt(0)=='-') {
+ minusSign=true;
+ sx=sx.substring(1);
+ }
+ }
+ int ePos = sx.indexOf('E');
+ int rPos = sx.indexOf('.');
+ if (rPos!=-1) n1In=rPos;
+ else if (ePos!=-1) n1In=ePos;
+ else n1In=sx.length();
+ if (rPos!=-1) {
+ if (ePos!=-1) n2In = ePos-rPos-1;
+ else n2In = sx.length()-rPos-1;
+ }
+ else
+ n2In = 0;
+ if (ePos!=-1) {
+ int ie=ePos+1;
+ expon=0;
+ if (sx.charAt(ie)=='-') {
+ for (++ie; ie0) {
+ ca6 = new char[ca5.length+nThousands+lead];
+ ca6[0]=ca5[0];
+ for (i=lead,k=lead; i0 && (dp-i)%3==0) {
+ // ca6[k]=',';
+ ca6[k]=dfs.getGroupingSeparator();
+ ca6[k+1]=ca5[i];
+ k+=2;
+ }
+ else {
+ ca6[k]=ca5[i]; k++;
+ }
+ }
+ for (; i0.0)
+ sx = Double.toString(x);
+ else if (x<0.0) {
+ sx = Double.toString(-x);
+ minusSign=true;
+ }
+ else {
+ sx = Double.toString(x);
+ if (sx.charAt(0)=='-') {
+ minusSign=true;
+ sx=sx.substring(1);
+ }
+ }
+ ePos = sx.indexOf('E');
+ if (ePos==-1) ePos = sx.indexOf('e');
+ rPos = sx.indexOf('.');
+ if (rPos!=-1) n1In=rPos;
+ else if (ePos!=-1) n1In=ePos;
+ else n1In=sx.length();
+ if (rPos!=-1) {
+ if (ePos!=-1) n2In = ePos-rPos-1;
+ else n2In = sx.length()-rPos-1;
+ }
+ else
+ n2In = 0;
+ if (ePos!=-1) {
+ int ie=ePos+1;
+ expon=0;
+ if (sx.charAt(ie)=='-') {
+ for (++ie; ie=100) {
+ switch(expon/100) {
+ case 1: ca2[i]='1'; break;
+ case 2: ca2[i]='2'; break;
+ case 3: ca2[i]='3'; break;
+ case 4: ca2[i]='4'; break;
+ case 5: ca2[i]='5'; break;
+ case 6: ca2[i]='6'; break;
+ case 7: ca2[i]='7'; break;
+ case 8: ca2[i]='8'; break;
+ case 9: ca2[i]='9'; break;
+ }
+ i++;
+ }
+ switch((expon%100)/10) {
+ case 0: ca2[i]='0'; break;
+ case 1: ca2[i]='1'; break;
+ case 2: ca2[i]='2'; break;
+ case 3: ca2[i]='3'; break;
+ case 4: ca2[i]='4'; break;
+ case 5: ca2[i]='5'; break;
+ case 6: ca2[i]='6'; break;
+ case 7: ca2[i]='7'; break;
+ case 8: ca2[i]='8'; break;
+ case 9: ca2[i]='9'; break;
+ }
+ i++;
+ switch(expon%10) {
+ case 0: ca2[i]='0'; break;
+ case 1: ca2[i]='1'; break;
+ case 2: ca2[i]='2'; break;
+ case 3: ca2[i]='3'; break;
+ case 4: ca2[i]='4'; break;
+ case 5: ca2[i]='5'; break;
+ case 6: ca2[i]='6'; break;
+ case 7: ca2[i]='7'; break;
+ case 8: ca2[i]='8'; break;
+ case 9: ca2[i]='9'; break;
+ }
+ int nZeros=0;
+ if (!leftJustify && leadingZeros) {
+ int xThousands=0;
+ if (thousands) {
+ int xlead=0;
+ if (ca2[0]=='+'||ca2[0]=='-'||ca2[0]==' ')
+ xlead=1;
+ int xdp=xlead;
+ for (; xdp0) {
+ ca4 = new char[ca3.length+nThousands+lead];
+ ca4[0]=ca3[0];
+ for (i=lead,k=lead; i0 && (dp-i)%3==0) {
+ // ca4[k]=',';
+ ca4[k]=dfs.getGroupingSeparator();
+ ca4[k+1]=ca3[i];
+ k+=2;
+ }
+ else {
+ ca4[k]=ca3[i]; k++;
+ }
+ }
+ for (; itrue if the truncation forces
+ * a round that will change the print
+ */
+ private boolean checkForCarry(char[] ca1,int icarry) {
+ boolean carry=false;
+ if (icarry0) {
+ carry=(ca1[icarry-1]=='1'||ca1[icarry-1]=='3'
+ ||ca1[icarry-1]=='5'||ca1[icarry-1]=='7'
+ ||ca1[icarry-1]=='9');
+ }
+ }
+ }
+ return carry;
+ }
+ /**
+ * Start the symbolic carry process. The process
+ * is not quite finished because the symbolic
+ * carry may change the length of the string and
+ * change the exponent (in e format).
+ * @param cLast index of the last digit changed
+ * by the round
+ * @param cFirst index of the first digit allowed
+ * to be changed by this phase of the round
+ * @return true if the carry forces
+ * a round that will change the print still
+ * more
+ */
+ private boolean startSymbolicCarry(
+ char[] ca,int cLast,int cFirst) {
+ boolean carry=true;
+ for (int i=cLast; carry && i>=cFirst; i--) {
+ carry = false;
+ switch(ca[i]) {
+ case '0': ca[i]='1'; break;
+ case '1': ca[i]='2'; break;
+ case '2': ca[i]='3'; break;
+ case '3': ca[i]='4'; break;
+ case '4': ca[i]='5'; break;
+ case '5': ca[i]='6'; break;
+ case '6': ca[i]='7'; break;
+ case '7': ca[i]='8'; break;
+ case '8': ca[i]='9'; break;
+ case '9': ca[i]='0'; carry=true; break;
+ }
+ }
+ return carry;
+ }
+ /**
+ * An intermediate routine on the way to creating
+ * an e format String. The method decides whether
+ * the input double value is an infinity,
+ * not-a-number, or a finite double and formats
+ * each type of input appropriately.
+ * @param x the double value to be formatted.
+ * @param eChar an 'e' or 'E' to use in the
+ * converted double value.
+ * @return the converted double value.
+ */
+ private String eFormatString(double x,char eChar) {
+ boolean noDigits=false;
+ char[] ca4,ca5;
+ if (Double.isInfinite(x)) {
+ if (x==Double.POSITIVE_INFINITY) {
+ if (leadingSign) ca4 = "+Inf".toCharArray();
+ else if (leadingSpace)
+ ca4 = " Inf".toCharArray();
+ else ca4 = "Inf".toCharArray();
+ }
+ else
+ ca4 = "-Inf".toCharArray();
+ noDigits = true;
+ }
+ else if (Double.isNaN(x)) {
+ if (leadingSign) ca4 = "+NaN".toCharArray();
+ else if (leadingSpace)
+ ca4 = " NaN".toCharArray();
+ else ca4 = "NaN".toCharArray();
+ noDigits = true;
+ }
+ else
+ ca4 = eFormatDigits(x,eChar);
+ ca5 = applyFloatPadding(ca4,false);
+ return new String(ca5);
+ }
+ /**
+ * Apply zero or blank, left or right padding.
+ * @param ca4 array of characters before padding is
+ * finished
+ * @param noDigits NaN or signed Inf
+ * @return a padded array of characters
+ */
+ private char[] applyFloatPadding(
+ char[] ca4,boolean noDigits) {
+ char[] ca5 = ca4;
+ if (fieldWidthSet) {
+ int i,j,nBlanks;
+ if (leftJustify) {
+ nBlanks = fieldWidth-ca4.length;
+ if (nBlanks > 0) {
+ ca5 = new char[ca4.length+nBlanks];
+ for (i=0; i 0) {
+ ca5 = new char[ca4.length+nBlanks];
+ for (i=0; i 0) {
+ ca5 = new char[ca4.length+nBlanks];
+ i=0; j=0;
+ if (ca4[0]=='-') { ca5[0]='-'; i++; j++; }
+ for (int k=0; k=-4 && expon=0; i--)
+ if (sy.charAt(i)!='0') break;
+ if (i>=0 && sy.charAt(i)=='.') i--;
+ if (i==-1) sz="0";
+ else if (!Character.isDigit(sy.charAt(i)))
+ sz=sy.substring(0,i+1)+"0";
+ else sz=sy.substring(0,i+1);
+ if (expon>=-4 && expon=-4 && expon=0) ret = " "+ret;
+ ca4 = ret.toCharArray();
+ }
+ // Pad with blanks or zeros.
+ ca5 = applyFloatPadding(ca4,false);
+ precision=savePrecision;
+ return new String(ca5);
+ }
+ /**
+ * Format method for the d conversion specifer and
+ * short argument.
+ *
+ * For d format, the flag character '-', means that
+ * the output should be left justified within the
+ * field. The default is to pad with blanks on the
+ * left. A '+' character means that the conversion
+ * will always begin with a sign (+ or -). The
+ * blank flag character means that a non-negative
+ * input will be preceded with a blank. If both a
+ * '+' and a ' ' are specified, the blank flag is
+ * ignored. The '0' flag character implies that
+ * padding to the field width will be done with
+ * zeros instead of blanks.
+ *
+ * The field width is treated as the minimum number
+ * of characters to be printed. The default is to
+ * add no padding. Padding is with blanks by
+ * default.
+ *
+ * The precision, if set, is the minimum number of
+ * digits to appear. Padding is with leading 0s.
+ * @param x the short to format.
+ * @return the formatted String.
+ */
+ private String printDFormat(short x) {
+ return printDFormat(Short.toString(x));
+ }
+ /**
+ * Format method for the d conversion character and
+ * long argument.
+ *
+ * For d format, the flag character '-', means that
+ * the output should be left justified within the
+ * field. The default is to pad with blanks on the
+ * left. A '+' character means that the conversion
+ * will always begin with a sign (+ or -). The
+ * blank flag character means that a non-negative
+ * input will be preceded with a blank. If both a
+ * '+' and a ' ' are specified, the blank flag is
+ * ignored. The '0' flag character implies that
+ * padding to the field width will be done with
+ * zeros instead of blanks.
+ *
+ * The field width is treated as the minimum number
+ * of characters to be printed. The default is to
+ * add no padding. Padding is with blanks by
+ * default.
+ *
+ * The precision, if set, is the minimum number of
+ * digits to appear. Padding is with leading 0s.
+ * @param x the long to format.
+ * @return the formatted String.
+ */
+ private String printDFormat(long x) {
+ return printDFormat(Long.toString(x));
+ }
+ /**
+ * Format method for the d conversion character and
+ * int argument.
+ *
+ * For d format, the flag character '-', means that
+ * the output should be left justified within the
+ * field. The default is to pad with blanks on the
+ * left. A '+' character means that the conversion
+ * will always begin with a sign (+ or -). The
+ * blank flag character means that a non-negative
+ * input will be preceded with a blank. If both a
+ * '+' and a ' ' are specified, the blank flag is
+ * ignored. The '0' flag character implies that
+ * padding to the field width will be done with
+ * zeros instead of blanks.
+ *
+ * The field width is treated as the minimum number
+ * of characters to be printed. The default is to
+ * add no padding. Padding is with blanks by
+ * default.
+ *
+ * The precision, if set, is the minimum number of
+ * digits to appear. Padding is with leading 0s.
+ * @param x the int to format.
+ * @return the formatted String.
+ */
+ private String printDFormat(int x) {
+ return printDFormat(Integer.toString(x));
+ }
+ /**
+ * Utility method for formatting using the d
+ * conversion character.
+ * @param sx the String to format, the result of
+ * converting a short, int, or long to a
+ * String.
+ * @return the formatted String.
+ */
+ private String printDFormat(String sx) {
+ int nLeadingZeros=0;
+ int nBlanks=0,n=0;
+ int i=0,jFirst=0;
+ boolean neg = sx.charAt(0)=='-';
+ if (sx.equals("0")&&precisionSet&&precision==0)
+ sx="";
+ if (!neg) {
+ if (precisionSet && sx.length() < precision)
+ nLeadingZeros = precision-sx.length();
+ }
+ else {
+ if (precisionSet&&(sx.length()-1)precision)
+ nPrint=precision;
+ if (!fieldWidthSet) width = nPrint;
+ int n=0;
+ if (width>nPrint) n+=width-nPrint;
+ if (nPrint>=x.length()) n+= x.length();
+ else n+= nPrint;
+ char[] ca = new char[n];
+ int i=0;
+ if (leftJustify) {
+ if (nPrint>=x.length()) {
+ char[] csx = x.toCharArray();
+ for (i=0; i=x.length()) {
+ char[] csx = x.toCharArray();
+ for (int j=0; jtrue if the conversion
+ * character is there, and
+ * false otherwise.
+ */
+ private boolean setConversionCharacter() {
+ /* idfgGoxXeEcs */
+ boolean ret = false;
+ conversionCharacter='\0';
+ if (pos < fmt.length()) {
+ char c = fmt.charAt(pos);
+ if (c=='i'||c=='d'||c=='f'||c=='g'||c=='G'
+ || c=='o' || c=='x' || c=='X' || c=='e'
+ || c=='E' || c=='c' || c=='s' || c=='%') {
+ conversionCharacter = c;
+ pos++;
+ ret = true;
+ }
+ }
+ return ret;
+ }
+ /**
+ * Check for an h, l, or L in a format. An L is
+ * used to control the minimum number of digits
+ * in an exponent when using floating point
+ * formats. An l or h is used to control
+ * conversion of the input to a long or short,
+ * respectively, before formatting. If any of
+ * these is present, store them.
+ */
+ private void setOptionalHL() {
+ optionalh=false;
+ optionall=false;
+ optionalL=false;
+ if (pos < fmt.length()) {
+ char c = fmt.charAt(pos);
+ if (c=='h') { optionalh=true; pos++; }
+ else if (c=='l') { optionall=true; pos++; }
+ else if (c=='L') { optionalL=true; pos++; }
+ }
+ }
+ /**
+ * Set the precision.
+ */
+ private void setPrecision() {
+ int firstPos = pos;
+ precisionSet = false;
+ if (pos firstPos+1) {
+ String sz = fmt.substring(firstPos+1,pos);
+ precision = Integer.parseInt(sz);
+ precisionSet = true;
+ }
+ }
+ }
+ }
+ /**
+ * Set the field width.
+ */
+ private void setFieldWidth() {
+ int firstPos = pos;
+ fieldWidth = 0;
+ fieldWidthSet = false;
+ if ((pos < fmt.length())
+ && (fmt.charAt(pos)=='*')) {
+ pos++;
+ if (!setFieldWidthArgPosition()) {
+ variableFieldWidth = true;
+ fieldWidthSet = true;
+ }
+ }
+ else {
+ while (pos < fmt.length()) {
+ char c = fmt.charAt(pos);
+ if (Character.isDigit(c)) pos++;
+ else break;
+ }
+ if (firstPosn in %n$ forms.
+ */
+ private void setArgPosition() {
+ int xPos;
+ for (xPos=pos; xPospos && xPosn in *n$ forms.
+ */
+ private boolean setFieldWidthArgPosition() {
+ boolean ret=false;
+ int xPos;
+ for (xPos=pos; xPospos && xPosn in *n$ forms.
+ */
+ private boolean setPrecisionArgPosition() {
+ boolean ret=false;
+ int xPos;
+ for (xPos=pos; xPospos && xPosget_name();
+
+my $ccname = $Config{ccname};
+
+my $define = {
+ gcc => '-Wall -Werror',
+ cc_r => '-qhalt=w',
+}->{$ccname} || '';
+
+WriteMakefile(
+ 'NAME' => 'Sigar',
+ 'VERSION_FROM' => 'Sigar.pm',
+ 'LIBS' => ["-L$installdir/lib -lsigar-$archname"],
+ 'INC' => "-I$installdir/include",
+ 'DEFINE' => $define,
+ 'depend' => { 'Sigar.c' => 'Sigar_generated.xs' },
+);
diff --git a/bindings/perl/Sigar.pm b/bindings/perl/Sigar.pm
new file mode 100644
index 00000000..cb0ce9e3
--- /dev/null
+++ b/bindings/perl/Sigar.pm
@@ -0,0 +1,24 @@
+package Sigar;
+
+use 5.003;
+use strict;
+use vars qw($VERSION @ISA);
+
+$VERSION = '0.01';
+
+eval {
+ require XSLoader;
+};
+
+if ($@) {
+ #$] < 5.6
+ require DynaLoader;
+ @ISA = qw(DynaLoader);
+ __PACKAGE__->bootstrap($VERSION);
+}
+else {
+ XSLoader::load(__PACKAGE__, $VERSION);
+}
+
+1;
+__END__
diff --git a/bindings/perl/Sigar.xs b/bindings/perl/Sigar.xs
new file mode 100644
index 00000000..cd864ed0
--- /dev/null
+++ b/bindings/perl/Sigar.xs
@@ -0,0 +1,350 @@
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include "sigar.h"
+#include "sigar_fileinfo.h"
+
+typedef sigar_t * Sigar;
+
+/* generated list */
+typedef sigar_uptime_t * Sigar__Uptime;
+typedef sigar_mem_t * Sigar__Mem;
+typedef sigar_proc_cred_t * Sigar__ProcCred;
+typedef sigar_proc_fd_t * Sigar__ProcFd;
+typedef sigar_dir_stat_t * Sigar__DirStat;
+typedef sigar_proc_cred_name_t * Sigar__ProcCredName;
+typedef sigar_file_attrs_t * Sigar__FileAttrs;
+typedef sigar_cpu_t * Sigar__Cpu;
+typedef sigar_cpu_info_t * Sigar__CpuInfo;
+typedef sigar_net_interface_config_t * Sigar__NetInterfaceConfig;
+typedef sigar_swap_t * Sigar__Swap;
+typedef sigar_proc_state_t * Sigar__ProcState;
+typedef sigar_net_connection_t * Sigar__NetConnection;
+typedef sigar_proc_exe_t * Sigar__ProcExe;
+typedef sigar_proc_time_t * Sigar__ProcTime;
+typedef sigar_proc_mem_t * Sigar__ProcMem;
+typedef sigar_file_system_t * Sigar__FileSystem;
+typedef sigar_file_system_usage_t * Sigar__FileSystemUsage;
+typedef sigar_proc_stat_t * Sigar__ProcStat;
+typedef sigar_net_route_t * Sigar__NetRoute;
+typedef sigar_net_interface_stat_t * Sigar__NetInterfaceStat;
+
+/* Perl < 5.6 */
+#ifndef aTHX_
+#define aTHX_
+#endif
+
+#define SIGAR_CROAK(sigar, msg) \
+ Perl_croak(aTHX_ msg " %s", sigar_strerror(sigar, status))
+
+static SV *convert_2svav(char *data, unsigned long number,
+ int size, const char *classname)
+{
+ AV *av = newAV();
+ unsigned long i;
+
+ for (i=0; iklen == klen) &&
+ (strEQ(get->key, key)))
+ {
+ get->val = newSVpv(val, vlen);
+ return !SIGAR_OK; /* foundit; stop iterating */
+ }
+
+ return SIGAR_OK;
+}
+
+MODULE = Sigar PACKAGE = Sigar
+
+PROTOTYPES: disable
+
+INCLUDE: Sigar_generated.xs
+
+MODULE = Sigar PACKAGE = Sigar PREFIX = sigar_
+
+Sigar
+new(classname)
+ char *classname
+
+ PREINIT:
+ int status;
+
+ CODE:
+ if ((status = sigar_open(&RETVAL)) != SIGAR_OK) {
+ classname = classname; /* -Wall */
+ SIGAR_CROAK(RETVAL, "open");
+ }
+
+ OUTPUT:
+ RETVAL
+
+void
+DESTROY(sigar)
+ Sigar sigar
+
+ CODE:
+ (void)sigar_close(sigar);
+
+char *
+sigar_fqdn(sigar)
+ Sigar sigar
+
+ PREINIT:
+ char fqdn[SIGAR_FQDN_LEN];
+
+ CODE:
+ sigar_fqdn_get(sigar, fqdn, sizeof(fqdn));
+ RETVAL = fqdn;
+
+ OUTPUT:
+ RETVAL
+
+SV *
+loadavg(sigar)
+ Sigar sigar
+
+ PREINIT:
+ sigar_loadavg_t loadavg;
+ int status;
+ unsigned long i;
+ AV *av;
+
+ CODE:
+ status = sigar_loadavg_get(sigar, &loadavg);
+
+ if (status != SIGAR_OK) {
+ SIGAR_CROAK(sigar, "loadavg");
+ }
+
+ av = newAV();
+ av_extend(av, 2);
+
+ for (i=0; i<3; i++) {
+ av_push(av, newSVnv(loadavg.loadavg[i]));
+ }
+
+ RETVAL = newRV_noinc((SV*)av);
+
+ OUTPUT:
+ RETVAL
+
+SV *
+file_system_list(sigar)
+ Sigar sigar
+
+ PREINIT:
+ sigar_file_system_list_t fslist;
+ int status;
+
+ CODE:
+ status = sigar_file_system_list_get(sigar, &fslist);
+
+ if (status != SIGAR_OK) {
+ SIGAR_CROAK(sigar, "fslist");
+ }
+
+ RETVAL = convert_2svav((char *)&fslist.data[0],
+ fslist.number,
+ sizeof(*fslist.data),
+ "Sigar::FileSystem");
+
+ sigar_file_system_list_destroy(sigar, &fslist);
+
+ OUTPUT:
+ RETVAL
+
+SV *
+cpu_infos(sigar)
+ Sigar sigar
+
+ PREINIT:
+ sigar_cpu_infos_t cpu_infos;
+ int status;
+
+ CODE:
+ status = sigar_cpu_infos_get(sigar, &cpu_infos);
+
+ if (status != SIGAR_OK) {
+ SIGAR_CROAK(sigar, "cpu_infos");
+ }
+
+ RETVAL = convert_2svav((char *)&cpu_infos.data[0],
+ cpu_infos.number,
+ sizeof(*cpu_infos.data),
+ "Sigar::CpuInfo");
+
+ sigar_cpu_infos_destroy(sigar, &cpu_infos);
+
+ OUTPUT:
+ RETVAL
+
+SV *
+proc_list(sigar)
+ Sigar sigar
+
+ PREINIT:
+ sigar_proc_list_t proclist;
+ int status;
+ unsigned long i;
+ AV *av;
+
+ CODE:
+ status = sigar_proc_list_get(sigar, &proclist);
+
+ if (status != SIGAR_OK) {
+ SIGAR_CROAK(sigar, "proc_list");
+ }
+
+ av = newAV();
+ av_extend(av, proclist.number - 1);
+
+ for (i=0; icpu_infos;
+
+my $num = scalar @$infos;
+
+print "$num total CPUs..\n";
+
+for my $info (@$infos) {
+ print "Vendor........" . $info->vendor . "\n";
+ print "Model........." . $info->model . "\n";
+ print "Mhz..........." . $info->mhz . "\n";
+ print "Cache size...." . $info->cache_size . "\n";
+}
diff --git a/bindings/perl/examples/df.pl b/bindings/perl/examples/df.pl
new file mode 100755
index 00000000..d1a2aaf8
--- /dev/null
+++ b/bindings/perl/examples/df.pl
@@ -0,0 +1,38 @@
+#!/usr/bin/perl
+
+use strict;
+use Sigar;
+
+my $sigar = new Sigar;
+
+my $fslist = $sigar->file_system_list;
+
+print "Filesytem\tSize\tUsed\tAvail\tUse%\tMounted on\tType\n";
+
+for my $fs (@$fslist) {
+ my $dirname = $fs->dir_name;
+ my $usage = $sigar->filesystemusage($dirname);
+
+ my $total = $usage->total;
+ my $used = $total - $usage->free;
+ my $avail = $usage->avail;
+ my $pct = $usage->use_percent * 100;
+ my $usePct;
+
+ if ($pct == 0) {
+ $usePct = "-"
+ }
+ else {
+ $usePct = $pct . '%';
+ }
+
+ print
+ $fs->dev_name . "\t" .
+ $total . "\t" .
+ $used . "\t" .
+ $avail . "\t" .
+ $usePct . "\t" .
+ $dirname . "\t" .
+ $fs->sys_type_name . "/" . $fs->type_name . "\n";
+
+}
diff --git a/bindings/perl/examples/free.pl b/bindings/perl/examples/free.pl
new file mode 100755
index 00000000..86ed2fdf
--- /dev/null
+++ b/bindings/perl/examples/free.pl
@@ -0,0 +1,24 @@
+#!/usr/bin/perl
+
+use strict;
+use Sigar;
+
+my $sigar = new Sigar;
+
+my $mem = $sigar->mem;
+
+my $swap = $sigar->swap;
+
+print "\tTotal\tUsed\tFree\n";
+
+print "Mem: " .
+ ($mem->total / 1024) . "\t" .
+ ($mem->used / 1024) . "\t" .
+ ($mem->free / 1024) . "\n";
+
+print "Swap: " .
+ ($swap->total / 1024) . "\t" .
+ ($swap->used / 1024) . "\t" .
+ ($swap->free / 1024) . "\n";
+
+print "RAM: " . $mem->ram . "MB\n";
diff --git a/bindings/perl/lib/Sigar/ArchName.pm b/bindings/perl/lib/Sigar/ArchName.pm
new file mode 100644
index 00000000..14749fac
--- /dev/null
+++ b/bindings/perl/lib/Sigar/ArchName.pm
@@ -0,0 +1,41 @@
+package Sigar::ArchName;
+
+use strict;
+use Config;
+
+sub get_name {
+ my $os = lc $^O;
+ my $vers = $Config{osvers};
+ my $arch = $Config{archname};
+
+ if ($os =~ /win32/) {
+ return 'x86-winnt';
+ }
+ elsif ($os =~ /linux/) {
+ return 'x86-linux';
+ }
+ elsif ($os =~ /hpux/) {
+ if ($vers =~ /11\./) {
+ return 'hppa2.0-hp-hpux-11.x';
+ }
+ }
+ elsif ($os =~ /aix/) {
+ return 'powerpc-ibm-aix-4.3.x';
+ }
+ elsif ($os =~ /solaris/) {
+ if ($arch =~ /sun4/) {
+ return 'sparc-sun-solaris-2.x';
+ }
+ elsif ($arch =~ /.86/) {
+ return 'x86-sun-solaris-2.x';
+ }
+ }
+ elsif ($os =~ /darwin/) {
+ return 'powerpc-apple-darwin';
+ }
+
+ die "Unsupported platform";
+}
+
+1;
+__END__
diff --git a/bindings/perl/t/load.t b/bindings/perl/t/load.t
new file mode 100644
index 00000000..3c17d7c6
--- /dev/null
+++ b/bindings/perl/t/load.t
@@ -0,0 +1,12 @@
+use strict;
+use Test;
+
+use Sigar ();
+
+BEGIN {
+ plan tests => 1;
+}
+
+my $sigar = new Sigar;
+
+ok $sigar;
diff --git a/bindings/perl/typemap b/bindings/perl/typemap
new file mode 100644
index 00000000..0317ee42
--- /dev/null
+++ b/bindings/perl/typemap
@@ -0,0 +1,27 @@
+Sigar T_PTROBJ
+sigar_pid_t T_UV
+const char * T_PV
+UV T_UV
+
+#generated list
+Sigar::Uptime T_PTROBJ
+Sigar::Mem T_PTROBJ
+Sigar::ProcCred T_PTROBJ
+Sigar::ProcFd T_PTROBJ
+Sigar::DirStat T_PTROBJ
+Sigar::ProcCredName T_PTROBJ
+Sigar::FileAttrs T_PTROBJ
+Sigar::Cpu T_PTROBJ
+Sigar::CpuInfo T_PTROBJ
+Sigar::NetInterfaceConfig T_PTROBJ
+Sigar::Swap T_PTROBJ
+Sigar::ProcState T_PTROBJ
+Sigar::NetConnection T_PTROBJ
+Sigar::ProcExe T_PTROBJ
+Sigar::ProcTime T_PTROBJ
+Sigar::ProcMem T_PTROBJ
+Sigar::FileSystem T_PTROBJ
+Sigar::FileSystemUsage T_PTROBJ
+Sigar::ProcStat T_PTROBJ
+Sigar::NetRoute T_PTROBJ
+Sigar::NetInterfaceStat T_PTROBJ
diff --git a/examples/sigfreed.c b/examples/sigfreed.c
new file mode 100644
index 00000000..5c662f5f
--- /dev/null
+++ b/examples/sigfreed.c
@@ -0,0 +1,45 @@
+#include
+#include
+
+#include "sigar.h"
+
+int main(int argc, char *argv[]){
+ sigar_swap_t swapinfo;
+ sigar_mem_t meminfo;
+ sigar_t *sig;
+ int err;
+
+ if(sigar_open(&sig) != SIGAR_OK){
+ fprintf(stderr, "Error opening sigar context!\n");
+ return -1;
+ }
+
+ if((err = sigar_mem_get(sig, &meminfo)) != SIGAR_OK ||
+ (err = sigar_swap_get(sig, &swapinfo)) != SIGAR_OK)
+ {
+ fprintf(stderr, "Failed to get memory info: %s\n",
+ strerror(err));
+ sigar_close(sig);
+ return -1;
+ }
+
+ fprintf(stdout, "%18s %10s %10s %10s %10s %10s\n",
+ "total", "used", "free", "shared", "buffers", "cached");
+ fprintf(stdout, "Mem: %10ld %10ld %10ld %10ld %10ld %10ld\n",
+ meminfo.total / 1024,
+ meminfo.used / 1024,
+ meminfo.free / 1024,
+ meminfo.shared / 1024,
+ meminfo.buffer / 1024,
+ meminfo.cached / 1024);
+ fprintf(stdout, "-/+ buffers/cache: %10ld %10d\n",
+ (meminfo.used - meminfo.buffer - meminfo.cached) / 1024,
+ (meminfo.free + meminfo.buffer + meminfo.cached) / 1024);
+ fprintf(stdout, "Swap: %10ld %10ld %10ld\n",
+ swapinfo.total / 1024,
+ swapinfo.used / 1024,
+ swapinfo.free / 1024);
+
+ sigar_close(sig);
+ return 0;
+}
diff --git a/examples/sigps.c b/examples/sigps.c
new file mode 100644
index 00000000..e5312626
--- /dev/null
+++ b/examples/sigps.c
@@ -0,0 +1,15 @@
+#include
+
+#include "sigar.h"
+
+int main(int argc, char *argv[]){
+ sigar_t *sig;
+
+ if(sigar_open(&sig) != SIGAR_OK){
+ fprintf(stderr, "Error opening sigar context!\n");
+ return -1;
+ }
+
+ sigar_close(sig);
+ return 0;
+}
diff --git a/exp/README b/exp/README
new file mode 100644
index 00000000..8e1c8a02
--- /dev/null
+++ b/exp/README
@@ -0,0 +1,2 @@
+this directory contains some experiments that are not in the codebase yet.
+may or may not move forward, but would prefer not to loose these stuffs.
diff --git a/exp/dump_kstats.c b/exp/dump_kstats.c
new file mode 100644
index 00000000..12b3f4a3
--- /dev/null
+++ b/exp/dump_kstats.c
@@ -0,0 +1,24 @@
+#include
+#include
+
+/* gcc -lkstat -o dump_kstats dump_kstats.c */
+
+static const char *kstat_type_names[] = {
+ "raw", "named", "intr", "io", "timer"
+};
+
+int main(int argc, char **argv) {
+ kstat_ctl_t *kc = kstat_open();
+ kstat_t *kp;
+
+ for (kp = kc->kc_chain; kp != 0; kp = kp->ks_next) {
+ if (strncmp(kp->ks_name, "kstat_", 6) == 0) {
+ continue;
+ }
+ fprintf(stdout, "%-5s %s\n",
+ kstat_type_names[kp->ks_type],
+ kp->ks_name);
+ }
+
+ kstat_close(kc);
+}
diff --git a/exp/linux_pid_portmap.c b/exp/linux_pid_portmap.c
new file mode 100644
index 00000000..d501404e
--- /dev/null
+++ b/exp/linux_pid_portmap.c
@@ -0,0 +1,211 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * eam can provide per-process measurements, but at the moment requires
+ * a pid. something we cannot store in the database. however, we could
+ * store a service port in the database (e.g. 8009 for tomcat ajp) and
+ * figure out the pid given that.
+ *
+ * it is possible via /proc/net/tcp and /proc/$pid/fd/
+ * to map a tcp port to one (or more if forked) process id(s).
+ * caveats: expensive to scan /proc/$pid/fd
+ * must own process or be root to read /proc/$pid/fd
+ * brutal to provide similar functionality on other platforms,
+ * tho possible (see lsof).
+ */
+
+static char *sigar_skip_token(char *p)
+{
+ while (isspace(*p)) p++;
+ while (*p && !isspace(*p)) p++;
+ return p;
+}
+
+static char *sigar_skip_multiple_token(char *p, int count)
+{
+ int i;
+
+ for (i = 0; i < count; i++) {
+ p = sigar_skip_token(p);
+ }
+
+ return p;
+}
+
+static int get_process_ppid(char *pid, char *buf, int buflen)
+{
+ FILE *fp;
+ char buffer[1024], *ptr, *ptr2;
+ sprintf(buffer, "/proc/%s/stat", pid);
+
+ if (!(fp = fopen(buffer, "r"))) {
+ return errno;
+ }
+
+ ptr = fgets(buffer, sizeof(buffer), fp);
+ fclose(fp);
+
+ ptr = sigar_skip_multiple_token(ptr, 3);
+
+ while (isspace(*ptr)) {
+ ++ptr;
+ }
+
+ ptr2 = strchr(ptr, ' ');
+ *ptr2 = '\0';
+
+ strncpy(buf, ptr2, buflen);
+ buf[buflen] = '\0';
+
+ return 0;
+}
+
+typedef struct {
+ int port;
+ int inode;
+ int uid;
+ int pid;
+ char name[1024];
+} portmap_t;
+
+static int portmap_lookup_inode(portmap_t *map) {
+ FILE *fp;
+ char buffer[8192], *ptr;
+ int inode = 0;
+
+ if ((fp = fopen("/proc/net/tcp", "r")) < 0) {
+ return -1;
+ }
+
+ fgets(buffer, sizeof(buffer), fp); /* skip header */
+
+ while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
+ ptr = sigar_skip_token(ptr);
+
+ if ((ptr = strchr(ptr, ':'))) {
+ unsigned long port = strtoul(++ptr, &ptr, 16);
+
+ if (!(map->port == (port & 0xffff))) {
+ continue;
+ }
+ }
+
+ ptr = sigar_skip_multiple_token(ptr, 5);
+ map->uid = strtoul(ptr, &ptr, 10);
+
+ ptr = sigar_skip_token(ptr);
+
+ inode = map->inode = strtoul(ptr, &ptr, 10);
+
+ break;
+ }
+
+ fclose(fp);
+
+ return inode ? 0 : ENOENT;
+}
+
+static int portmap_lookup_pid(portmap_t *map, char *pid) {
+ DIR *dirp;
+ struct dirent *dp;
+ char fname[1024], dname[1024];
+
+ map->pid = -1;
+
+ sprintf(dname, "/proc/%s/fd", pid);
+
+ if (!(dirp = opendir(dname))) {
+ return errno;
+ }
+
+ while ((dp = readdir(dirp))) {
+ struct stat statbuf;
+
+ if (!isdigit(*dp->d_name)) {
+ continue;
+ }
+
+ sprintf(fname, "%s/%s", dname, dp->d_name);
+ //printf("check %s\n", fname);
+ if (stat(fname, &statbuf)) {
+ continue;
+ }
+
+ if (statbuf.st_ino == map->inode) {
+ map->pid = atoi(pid);
+ break;
+ }
+ }
+
+ closedir(dirp);
+
+ return map->pid == -1 ? ENOENT : 0;
+}
+
+static int portmap_lookup_pid_scan(portmap_t *map) {
+ DIR *dirp;
+ struct dirent *dp;
+
+ char dname[1024];
+
+ if (!(dirp = opendir("/proc"))) {
+ return -1;
+ }
+
+ map->pid = -1;
+
+ while ((dp = readdir(dirp))) {
+ struct stat statbuf;
+
+ if (!isdigit(*dp->d_name)) {
+ continue;
+ }
+
+ sprintf(dname, "/proc/%s", dp->d_name);
+ if (stat(dname, &statbuf)) {
+ continue;
+ }
+
+ if (!(statbuf.st_uid == map->uid)) {
+ continue;
+ }
+
+ if (portmap_lookup_pid(map, dp->d_name) == 0) {
+#if 0
+ char *pid = dp->d_name;
+ char ppid[16];
+ get_process_ppid(pid, ppid, sizeof(ppid));
+#endif
+ //break;
+ printf("%s has inode %d\n", dp->d_name, map->inode);
+ }
+ }
+
+ closedir(dirp);
+
+ return map->pid == -1 ? ENOENT : 0;
+}
+
+int main(int argc, char **argv) {
+ portmap_t map;
+
+ if (argc != 2) {
+ printf("usage: %s port\n", argv[0]);
+ }
+
+ map.port = atoi(argv[1]);
+
+ if (portmap_lookup_inode(&map) == 0) {
+ if (portmap_lookup_pid_scan(&map) == 0) {
+ printf("inode=%d, pid=%d\n", map.inode, map.pid);
+ }
+ }
+
+ return 1;
+}
diff --git a/exp/proc/cpuinfo_DB b/exp/proc/cpuinfo_DB
new file mode 100644
index 00000000..8def6f8f
--- /dev/null
+++ b/exp/proc/cpuinfo_DB
@@ -0,0 +1,84 @@
+processor : 0
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.80GHz
+stepping : 7
+cpu MHz : 2787.455
+cache size : 512 KB
+physical id : 0
+siblings : 2
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 5557.45
+
+processor : 1
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.80GHz
+stepping : 7
+cpu MHz : 2787.455
+cache size : 512 KB
+physical id : 0
+siblings : 2
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 5570.56
+
+processor : 2
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.80GHz
+stepping : 7
+cpu MHz : 2787.455
+cache size : 512 KB
+physical id : 3
+siblings : 2
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 5570.56
+
+processor : 3
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.80GHz
+stepping : 7
+cpu MHz : 2787.455
+cache size : 512 KB
+physical id : 3
+siblings : 2
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 5570.56
+
diff --git a/exp/proc/cpuinfo_EV b/exp/proc/cpuinfo_EV
new file mode 100644
index 00000000..f3cca2c3
--- /dev/null
+++ b/exp/proc/cpuinfo_EV
@@ -0,0 +1,84 @@
+processor : 0
+vendor_id : GenuineIntel
+cpu family : 6
+model : 10
+model name : Pentium III (Cascades)
+stepping : 1
+cpu MHz : 699.331
+cache size : 1024 KB
+physical id : 0
+siblings : 1
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 mmx fxsr sse
+bogomips : 1395.91
+
+processor : 1
+vendor_id : GenuineIntel
+cpu family : 6
+model : 10
+model name : Pentium III (Cascades)
+stepping : 1
+cpu MHz : 699.331
+cache size : 1024 KB
+physical id : 0
+siblings : 1
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 mmx fxsr sse
+bogomips : 1395.91
+
+processor : 2
+vendor_id : GenuineIntel
+cpu family : 6
+model : 10
+model name : Pentium III (Cascades)
+stepping : 1
+cpu MHz : 699.331
+cache size : 1024 KB
+physical id : 0
+siblings : 1
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 mmx fxsr sse
+bogomips : 1395.91
+
+processor : 3
+vendor_id : GenuineIntel
+cpu family : 6
+model : 10
+model name : Pentium III (Cascades)
+stepping : 1
+cpu MHz : 699.331
+cache size : 1024 KB
+physical id : 0
+siblings : 1
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 mmx fxsr sse
+bogomips : 1395.91
+
diff --git a/exp/proc/cpuinfo_hawk b/exp/proc/cpuinfo_hawk
new file mode 100644
index 00000000..ac778d98
--- /dev/null
+++ b/exp/proc/cpuinfo_hawk
@@ -0,0 +1,88 @@
+processor : 0
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.40GHz
+stepping : 7
+cpu MHz : 2392.082
+cache size : 512 KB
+physical id : 0
+siblings : 2
+runqueue : 0
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 4771.02
+
+processor : 1
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.40GHz
+stepping : 7
+cpu MHz : 2392.082
+cache size : 512 KB
+physical id : 3
+siblings : 2
+runqueue : 1
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 4771.02
+
+processor : 2
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.40GHz
+stepping : 7
+cpu MHz : 2392.082
+cache size : 512 KB
+physical id : 0
+siblings : 2
+runqueue : 0
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 4771.02
+
+processor : 3
+vendor_id : GenuineIntel
+cpu family : 15
+model : 2
+model name : Intel(R) Xeon(TM) CPU 2.40GHz
+stepping : 7
+cpu MHz : 2392.082
+cache size : 512 KB
+physical id : 3
+siblings : 2
+runqueue : 1
+fdiv_bug : no
+hlt_bug : no
+f00f_bug : no
+coma_bug : no
+fpu : yes
+fpu_exception : yes
+cpuid level : 2
+wp : yes
+flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
+bogomips : 4771.02
+
diff --git a/exp/proc/stat_DB b/exp/proc/stat_DB
new file mode 100644
index 00000000..07b91767
--- /dev/null
+++ b/exp/proc/stat_DB
@@ -0,0 +1,18 @@
+cpu 35136407 290023172 43449938 374366755
+cpu0 11428264 67278276 12035936 1168743416
+cpu1 5905554 81357812 9496308 1162726218
+cpu2 11675543 74058184 12357744 1161394421
+cpu3 6127046 67328900 9559950 1176469996
+page 1313466877 1018279755
+swap 2502992 5804383
+intr 836975522 1259485892 143 0 0 665 0 102 0 2 0 189299694 1917217665 393
+0 1849 1765936413 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+disk_io: (2,0):(66,66,84,0,0)
+ctxt 4284712155
+btime 1074702658
+processes 33854757
diff --git a/include/sigar.h b/include/sigar.h
new file mode 100644
index 00000000..187ba8c4
--- /dev/null
+++ b/include/sigar.h
@@ -0,0 +1,489 @@
+#ifndef SIGAR_H
+#define SIGAR_H
+
+/* System Information Gatherer And Reporter */
+
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(WIN32)
+
+typedef unsigned __int64 sigar_uint64_t;
+
+#elif ULONG_MAX > 4294967295UL
+
+typedef unsigned long sigar_uint64_t;
+
+#else
+
+typedef unsigned long long sigar_uint64_t;
+
+#endif
+
+#define SIGAR_OK 0
+#define SIGAR_START_ERROR 20000
+#define SIGAR_ENOTIMPL (SIGAR_START_ERROR + 1)
+#define SIGAR_OS_START_ERROR (SIGAR_START_ERROR*2)
+
+#ifdef WIN32
+# define SIGAR_DECLARE(type) \
+ __declspec(dllexport) type __stdcall
+#else
+# define SIGAR_DECLARE(type) type
+#endif
+
+#if defined(PATH_MAX)
+# define SIGAR_PATH_MAX PATH_MAX
+#elif defined(MAXPATHLEN)
+# define SIGAR_PATH_MAX MAXPATHLEN
+#else
+# define SIGAR_PATH_MAX 8192
+#endif
+
+#ifdef WIN32
+typedef sigar_uint64_t sigar_pid_t;
+typedef unsigned long sigar_uid_t;
+typedef unsigned long sigar_gid_t;
+#else
+#include
+typedef pid_t sigar_pid_t;
+typedef uid_t sigar_uid_t;
+typedef gid_t sigar_gid_t;
+#endif
+
+typedef struct sigar_t sigar_t;
+
+SIGAR_DECLARE(int) sigar_open(sigar_t **sigar);
+
+SIGAR_DECLARE(int) sigar_close(sigar_t *sigar);
+
+SIGAR_DECLARE(sigar_pid_t) sigar_pid_get(sigar_t *sigar);
+
+SIGAR_DECLARE(int) sigar_proc_kill(sigar_pid_t pid, int signum);
+
+SIGAR_DECLARE(char *) sigar_strerror(sigar_t *sigar, int err);
+
+/* system memory info */
+
+typedef struct {
+ sigar_uint64_t
+ ram,
+ total,
+ used,
+ free,
+ shared,
+ buffer,
+ cached;
+} sigar_mem_t;
+
+SIGAR_DECLARE(int) sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem);
+
+typedef struct {
+ sigar_uint64_t
+ total,
+ used,
+ free;
+} sigar_swap_t;
+
+SIGAR_DECLARE(int) sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap);
+
+typedef struct {
+ sigar_uint64_t
+ user,
+ sys,
+ nice,
+ idle,
+ total;
+} sigar_cpu_t;
+
+SIGAR_DECLARE(int) sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu);
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ sigar_cpu_t *data;
+} sigar_cpu_list_t;
+
+SIGAR_DECLARE(int) sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist);
+
+SIGAR_DECLARE(int) sigar_cpu_list_destroy(sigar_t *sigar,
+ sigar_cpu_list_t *cpulist);
+
+typedef struct {
+ char vendor[128];
+ char model[128];
+ int mhz;
+ sigar_uint64_t cache_size;
+} sigar_cpu_info_t;
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ sigar_cpu_info_t *data;
+} sigar_cpu_infos_t;
+
+SIGAR_DECLARE(int) sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos);
+
+SIGAR_DECLARE(int) sigar_cpu_infos_destroy(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos);
+
+typedef struct {
+ double uptime;
+ double idletime;
+} sigar_uptime_t;
+
+SIGAR_DECLARE(int) sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime);
+
+SIGAR_DECLARE(int) sigar_uptime_string(sigar_t *sigar,
+ sigar_uptime_t *uptime,
+ char *buffer,
+ int buflen);
+
+SIGAR_DECLARE(char *) sigar_format_size(sigar_uint64_t size, char *buf);
+
+typedef struct {
+ double loadavg[3];
+} sigar_loadavg_t;
+
+SIGAR_DECLARE(int) sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg);
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ sigar_pid_t *data;
+} sigar_proc_list_t;
+
+SIGAR_DECLARE(int) sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist);
+
+SIGAR_DECLARE(int) sigar_proc_list_destroy(sigar_t *sigar,
+ sigar_proc_list_t *proclist);
+
+typedef struct {
+ sigar_uint64_t total;
+} sigar_proc_stat_t;
+
+SIGAR_DECLARE(int) sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat);
+
+typedef struct {
+ sigar_uint64_t
+ size,
+ vsize,
+ resident,
+ share,
+ rss;
+} sigar_proc_mem_t;
+
+SIGAR_DECLARE(int) sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem);
+
+typedef struct {
+ sigar_uid_t uid;
+ sigar_gid_t gid;
+ sigar_uid_t euid;
+ sigar_gid_t egid;
+} sigar_proc_cred_t;
+
+SIGAR_DECLARE(int) sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred);
+
+#define SIGAR_CRED_NAME_MAX 512
+
+typedef struct {
+ char user[SIGAR_CRED_NAME_MAX];
+ char group[SIGAR_CRED_NAME_MAX];
+} sigar_proc_cred_name_t;
+
+SIGAR_DECLARE(int)
+sigar_proc_cred_name_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_name_t *proccredname);
+
+typedef struct {
+ sigar_uint64_t
+ start_time,
+ utime,
+ stime;
+} sigar_proc_time_t;
+
+SIGAR_DECLARE(int) sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime);
+
+#define SIGAR_PROC_NAME_LEN 128
+
+typedef struct {
+ char name[SIGAR_PROC_NAME_LEN];
+ char state;
+ sigar_pid_t ppid;
+ int tty;
+ int priority;
+ int nice;
+} sigar_proc_state_t;
+
+SIGAR_DECLARE(int) sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate);
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ char **data;
+} sigar_proc_args_t;
+
+SIGAR_DECLARE(int) sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs);
+
+SIGAR_DECLARE(int) sigar_proc_args_destroy(sigar_t *sigar,
+ sigar_proc_args_t *procargs);
+
+typedef struct {
+ void *data; /* user data */
+
+ enum {
+ SIGAR_PROC_ENV_ALL,
+ SIGAR_PROC_ENV_KEY
+ } type;
+
+ /* used for SIGAR_PROC_ENV_KEY */
+ const char *key;
+ int klen;
+
+ int (*env_getter)(void *, const char *, int, char *, int);
+} sigar_proc_env_t;
+
+SIGAR_DECLARE(int) sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv);
+
+typedef struct {
+ sigar_uint64_t total;
+ /* XXX - which are files, sockets, etc. */
+} sigar_proc_fd_t;
+
+SIGAR_DECLARE(int) sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd);
+
+typedef struct {
+ char name[SIGAR_PATH_MAX+1];
+ char cwd[SIGAR_PATH_MAX+1];
+ char root[SIGAR_PATH_MAX+1];
+} sigar_proc_exe_t;
+
+SIGAR_DECLARE(int) sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe);
+
+typedef enum {
+ SIGAR_FSTYPE_UNKNOWN,
+ SIGAR_FSTYPE_NONE,
+ SIGAR_FSTYPE_LOCAL_DISK,
+ SIGAR_FSTYPE_NETWORK,
+ SIGAR_FSTYPE_RAM_DISK,
+ SIGAR_FSTYPE_CDROM,
+ SIGAR_FSTYPE_SWAP,
+ SIGAR_FSTYPE_MAX
+} sigar_file_system_type_e;
+
+#define SIGAR_FS_NAME_LEN 64
+
+typedef struct {
+ char dir_name[SIGAR_FS_NAME_LEN];
+ char dev_name[SIGAR_FS_NAME_LEN];
+ char type_name[SIGAR_FS_NAME_LEN]; /* e.g. "local" */
+ char sys_type_name[SIGAR_FS_NAME_LEN]; /* e.g. "ext3" */
+ sigar_file_system_type_e type;
+ unsigned long flags;
+} sigar_file_system_t;
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ sigar_file_system_t *data;
+} sigar_file_system_list_t;
+
+SIGAR_DECLARE(int)
+sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist);
+
+SIGAR_DECLARE(int)
+sigar_file_system_list_destroy(sigar_t *sigar,
+ sigar_file_system_list_t *fslist);
+
+typedef struct {
+ sigar_uint64_t
+ total,
+ free,
+ avail,
+ files,
+ free_files;
+ double use_percent;
+} sigar_file_system_usage_t;
+
+SIGAR_DECLARE(int)
+sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage);
+
+typedef struct {
+ sigar_uint64_t
+ destination,
+ gateway,
+ flags,
+ refcnt,
+ use,
+ metric,
+ mask,
+ mtu,
+ window,
+ irtt;
+ char ifname[16];
+} sigar_net_route_t;
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ sigar_net_route_t *data;
+} sigar_net_route_list_t;
+
+SIGAR_DECLARE(int) sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist);
+
+SIGAR_DECLARE(int) sigar_net_route_list_destroy(sigar_t *sigar,
+ sigar_net_route_list_t *routelist);
+
+/*
+ * platforms define most of these "standard" flags,
+ * but of course, with different values in some cases.
+ */
+#define SIGAR_IFF_UP 0x1
+#define SIGAR_IFF_BROADCAST 0x2
+#define SIGAR_IFF_DEBUG 0x4
+#define SIGAR_IFF_LOOPBACK 0x8
+#define SIGAR_IFF_POINTOPOINT 0x10
+#define SIGAR_IFF_NOTRAILERS 0x20
+#define SIGAR_IFF_RUNNING 0x40
+#define SIGAR_IFF_NOARP 0x80
+#define SIGAR_IFF_PROMISC 0x100
+#define SIGAR_IFF_ALLMULTI 0x200
+#define SIGAR_IFF_MULTICAST 0x800
+
+#define SIGAR_NULL_HWADDR "00:00:00:00:00:00"
+
+typedef struct {
+ char name[16];
+ char hwaddr[64];
+ sigar_uint64_t
+ address,
+ destination,
+ broadcast,
+ netmask,
+ flags,
+ mtu,
+ metric;
+} sigar_net_interface_config_t;
+
+SIGAR_DECLARE(int)
+sigar_net_interface_config_get(sigar_t *sigar,
+ const char *name,
+ sigar_net_interface_config_t *ifconfig);
+
+typedef struct {
+ sigar_uint64_t
+ /* received */
+ rx_packets,
+ rx_bytes,
+ rx_errors,
+ rx_dropped,
+ rx_overruns,
+ rx_frame,
+ /* transmitted */
+ tx_packets,
+ tx_bytes,
+ tx_errors,
+ tx_dropped,
+ tx_overruns,
+ tx_collisions,
+ tx_carrier;
+} sigar_net_interface_stat_t;
+
+SIGAR_DECLARE(int)
+sigar_net_interface_stat_get(sigar_t *sigar,
+ const char *name,
+ sigar_net_interface_stat_t *ifstat);
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ char **data;
+} sigar_net_interface_list_t;
+
+SIGAR_DECLARE(int)
+sigar_net_interface_list_get(sigar_t *sigar,
+ sigar_net_interface_list_t *iflist);
+
+SIGAR_DECLARE(int)
+sigar_net_interface_list_destroy(sigar_t *sigar,
+ sigar_net_interface_list_t *iflist);
+
+#define SIGAR_NETCONN_CLIENT 0x01
+#define SIGAR_NETCONN_SERVER 0x02
+
+#define SIGAR_NETCONN_TCP 0x10
+#define SIGAR_NETCONN_UDP 0x20
+#define SIGAR_NETCONN_RAW 0x40
+#define SIGAR_NETCONN_UNIX 0x80
+
+#ifndef INET6_ADDRSTRLEN
+# define INET6_ADDRSTRLEN 46
+#endif
+
+typedef struct {
+ unsigned long local_port;
+ char local_address[INET6_ADDRSTRLEN];
+ unsigned long remote_port;
+ char remote_address[INET6_ADDRSTRLEN];
+ sigar_uid_t uid;
+ unsigned long inode;
+ int type;
+} sigar_net_connection_t;
+
+typedef struct {
+ unsigned long number;
+ unsigned long size;
+ sigar_net_connection_t *data;
+} sigar_net_connection_list_t;
+
+SIGAR_DECLARE(int)
+sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags);
+
+SIGAR_DECLARE(int)
+sigar_net_connection_list_destroy(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist);
+
+SIGAR_DECLARE(const char *)sigar_net_connection_type_get(int type);
+
+SIGAR_DECLARE(int) sigar_proc_port_get(sigar_t *sigar, unsigned long port,
+ sigar_pid_t *pid);
+
+#define SIGAR_INET_ADDR_LEN (3 * 4 + 3 + 1)
+
+SIGAR_DECLARE(int) sigar_inet_ntoa(sigar_t *sigar,
+ sigar_uint64_t address,
+ char *addr_str);
+
+#define SIGAR_FQDN_LEN 512
+
+SIGAR_DECLARE(int) sigar_fqdn_get(sigar_t *sigar, char *name, int namelen);
+
+SIGAR_DECLARE(char *) sigar_password_get(const char *prompt);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/sigar_fileinfo.h b/include/sigar_fileinfo.h
new file mode 100644
index 00000000..0e379f5b
--- /dev/null
+++ b/include/sigar_fileinfo.h
@@ -0,0 +1,134 @@
+/* ====================================================================
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2000-2003 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Apache" and "Apache Software Foundation" must
+ * not be used to endorse or promote products derived from this
+ * software without prior written permission. For written
+ * permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * nor may "Apache" appear in their name, without prior written
+ * permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * .
+ */
+
+#include "sigar.h"
+
+typedef enum {
+ SIGAR_FILETYPE_NOFILE = 0, /**< no file type determined */
+ SIGAR_FILETYPE_REG, /**< a regular file */
+ SIGAR_FILETYPE_DIR, /**< a directory */
+ SIGAR_FILETYPE_CHR, /**< a character device */
+ SIGAR_FILETYPE_BLK, /**< a block device */
+ SIGAR_FILETYPE_PIPE, /**< a FIFO / pipe */
+ SIGAR_FILETYPE_LNK, /**< a symbolic link */
+ SIGAR_FILETYPE_SOCK, /**< a [unix domain] socket */
+ SIGAR_FILETYPE_UNKFILE /**< a file of some other unknown type */
+} sigar_file_type_e;
+
+#define SIGAR_UREAD 0x0400 /**< Read by user */
+#define SIGAR_UWRITE 0x0200 /**< Write by user */
+#define SIGAR_UEXECUTE 0x0100 /**< Execute by user */
+
+#define SIGAR_GREAD 0x0040 /**< Read by group */
+#define SIGAR_GWRITE 0x0020 /**< Write by group */
+#define SIGAR_GEXECUTE 0x0010 /**< Execute by group */
+
+#define SIGAR_WREAD 0x0004 /**< Read by others */
+#define SIGAR_WWRITE 0x0002 /**< Write by others */
+#define SIGAR_WEXECUTE 0x0001 /**< Execute by others */
+
+typedef struct {
+ /** The access permissions of the file. Mimics Unix access rights. */
+ sigar_uint64_t permissions;
+ sigar_file_type_e type;
+ /** The user id that owns the file */
+ sigar_uid_t uid;
+ /** The group id that owns the file */
+ sigar_gid_t gid;
+ /** The inode of the file. */
+ sigar_uint64_t inode;
+ /** The id of the device the file is on. */
+ sigar_uint64_t device;
+ /** The number of hard links to the file. */
+ sigar_uint64_t nlink;
+ /** The size of the file */
+ sigar_uint64_t size;
+ /** The time the file was last accessed */
+ sigar_uint64_t atime;
+ /** The time the file was last modified */
+ sigar_uint64_t mtime;
+ /** The time the file was last changed */
+ sigar_uint64_t ctime;
+} sigar_file_attrs_t;
+
+typedef struct {
+ sigar_uint64_t total;
+ sigar_uint64_t files;
+ sigar_uint64_t subdirs;
+ sigar_uint64_t symlinks;
+ sigar_uint64_t chrdevs;
+ sigar_uint64_t blkdevs;
+ sigar_uint64_t sockets;
+} sigar_dir_stat_t;
+
+SIGAR_DECLARE(const char *)
+sigar_file_attrs_type_string_get(sigar_file_type_e type);
+
+SIGAR_DECLARE(int) sigar_file_attrs_get(sigar_t *sigar,
+ const char *file,
+ sigar_file_attrs_t *fileattrs);
+
+SIGAR_DECLARE(int) sigar_link_attrs_get(sigar_t *sigar,
+ const char *file,
+ sigar_file_attrs_t *fileattrs);
+
+SIGAR_DECLARE(int)sigar_file_attrs_mode_get(sigar_uint64_t permissions);
+
+SIGAR_DECLARE(char *)
+sigar_file_attrs_permissions_string_get(sigar_uint64_t permissions,
+ char *str);
+
+SIGAR_DECLARE(int) sigar_dir_stat_get(sigar_t *sigar,
+ const char *dir,
+ sigar_dir_stat_t *dirstats);
diff --git a/include/sigar_getline.h b/include/sigar_getline.h
new file mode 100644
index 00000000..f5bbc7c4
--- /dev/null
+++ b/include/sigar_getline.h
@@ -0,0 +1,18 @@
+#ifndef SIGAR_GETLINE_H
+#define SIGAR_GETLINE_H
+
+#include "sigar.h"
+
+typedef int (*sigar_getline_completer_t)(char *, int, int *);
+
+SIGAR_DECLARE(char *) sigar_getline(char *prompt);
+SIGAR_DECLARE(void) sigar_getline_setwidth(int width);
+SIGAR_DECLARE(void) sigar_getline_redraw(void);
+SIGAR_DECLARE(void) sigar_getline_reset(void);
+SIGAR_DECLARE(void) sigar_getline_windowchanged();
+SIGAR_DECLARE(void) sigar_getline_histinit(char *file);
+SIGAR_DECLARE(void) sigar_getline_histadd(char *buf);
+SIGAR_DECLARE(int) sigar_getline_eof();
+SIGAR_DECLARE(void) sigar_getline_completer_set(sigar_getline_completer_t func);
+
+#endif /* SIGAR_GETLINE_H */
diff --git a/include/sigar_log.h b/include/sigar_log.h
new file mode 100644
index 00000000..d7bd0d79
--- /dev/null
+++ b/include/sigar_log.h
@@ -0,0 +1,49 @@
+#ifndef SIGAR_LOG_H
+#define SIGAR_LOG_H
+
+#include
+
+#define SIGAR_LOG_FATAL 0
+#define SIGAR_LOG_ERROR 1
+#define SIGAR_LOG_WARN 2
+#define SIGAR_LOG_INFO 3
+#define SIGAR_LOG_DEBUG 4
+#define SIGAR_LOG_TRACE 5
+
+#define SIGAR_LOG_IS_FATAL(sigar) \
+ (sigar->log_level >= SIGAR_LOG_FATAL)
+
+#define SIGAR_LOG_IS_ERROR(sigar) \
+ (sigar->log_level >= SIGAR_LOG_ERROR)
+
+#define SIGAR_LOG_IS_WARN(sigar) \
+ (sigar->log_level >= SIGAR_LOG_WARN)
+
+#define SIGAR_LOG_IS_INFO(sigar) \
+ (sigar->log_level >= SIGAR_LOG_INFO)
+
+#define SIGAR_LOG_IS_DEBUG(sigar) \
+ (sigar->log_level >= SIGAR_LOG_DEBUG)
+
+#define SIGAR_LOG_IS_TRACE(sigar) \
+ (sigar->log_level >= SIGAR_LOG_TRACE)
+
+typedef void (*sigar_log_impl_t)(sigar_t *, void *, int, char *);
+
+SIGAR_DECLARE(void) sigar_log_printf(sigar_t *sigar, int level,
+ const char *format, ...);
+
+SIGAR_DECLARE(void) sigar_log(sigar_t *sigar, int level, char *message);
+
+SIGAR_DECLARE(void) sigar_log_impl_set(sigar_t *sigar, void *data,
+ sigar_log_impl_t impl);
+
+SIGAR_DECLARE(void) sigar_log_impl_file(sigar_t *sigar, void *data,
+ int level, char *message);
+
+SIGAR_DECLARE(int) sigar_log_level_get(sigar_t *sigar);
+
+SIGAR_DECLARE(void) sigar_log_level_set(sigar_t *sigar, int level);
+
+
+#endif /* SIGAR_LOG_H */
diff --git a/include/sigar_private.h b/include/sigar_private.h
new file mode 100644
index 00000000..f56c724e
--- /dev/null
+++ b/include/sigar_private.h
@@ -0,0 +1,193 @@
+#ifndef SIGAR_PRIVATE_DOT_H
+#define SIGAR_PRIVATE_DOT_H
+
+#include "sigar_log.h"
+
+#include
+#include
+#include
+
+#ifndef WIN32
+#include
+#include
+#endif
+
+/* common to all os sigar_t's */
+/* XXX: this is ugly; but don't want the same stuffs
+ * duplicated on 4 platforms and am too lazy to change
+ * sigar_t to the way it was originally where sigar_t was
+ * common and contained a sigar_os_t.
+ * feel free trav ;-)
+ */
+#define SIGAR_T_BASE \
+ int log_level; \
+ void *log_data; \
+ sigar_log_impl_t log_impl; \
+ unsigned int ncpu; \
+ unsigned long version; \
+ unsigned long boot_time; \
+ int ticks; \
+ sigar_pid_t pid; \
+ char errbuf[256]; \
+ char *ifconf_buf; \
+ int ifconf_len
+
+#if defined(WIN32)
+# define SIGAR_INLINE __inline
+#elif defined(__GNUC__)
+# define SIGAR_INLINE inline
+#else
+# define SIGAR_INLINE
+#endif
+
+#define SIGAR_ZERO(s) \
+ memset(s, '\0', sizeof(*(s)))
+
+#define SIGAR_STRNCPY(dest, src, len) \
+ strncpy(dest, src, len); \
+ dest[len-1] = '\0'
+
+/* we use fixed size buffers pretty much everywhere */
+/* this is strncpy + ensured \0 terminator */
+#define SIGAR_SSTRCPY(dest, src) \
+ SIGAR_STRNCPY(dest, src, sizeof(dest))
+
+#ifndef strEQ
+#define strEQ(s1, s2) (strcmp(s1, s2) == 0)
+#endif
+
+#ifndef strnEQ
+#define strnEQ(s1, s2, n) (strncmp(s1, s2, n) == 0)
+#endif
+
+#define SIGAR_LAST_PROC_EXPIRE 2
+
+#define SIGAR_FS_MAX 10
+
+#define SIGAR_CPU_INFO_MAX 4
+
+#define SIGAR_CPU_LIST_MAX 4
+
+#define SIGAR_PROC_LIST_MAX 256
+
+#define SIGAR_PROC_ARGS_MAX 12
+
+#define SIGAR_NET_ROUTE_LIST_MAX 6
+
+#define SIGAR_NET_IFLIST_MAX 20
+
+#define SIGAR_NET_CONNLIST_MAX 20
+
+int sigar_os_open(sigar_t **sigar);
+
+int sigar_os_close(sigar_t *sigar);
+
+char *sigar_os_error_string(int err);
+
+int sigar_proc_list_create(sigar_proc_list_t *proclist);
+
+int sigar_proc_list_grow(sigar_proc_list_t *proclist);
+
+#define SIGAR_PROC_LIST_GROW(proclist) \
+ if (proclist->number >= proclist->size) { \
+ sigar_proc_list_grow(proclist); \
+ }
+
+int sigar_proc_args_create(sigar_proc_args_t *procargs);
+
+int sigar_proc_args_grow(sigar_proc_args_t *procargs);
+
+#define SIGAR_PROC_ARGS_GROW(procargs) \
+ if (procargs->number >= procargs->size) { \
+ sigar_proc_args_grow(procargs); \
+ }
+
+int sigar_file_system_list_create(sigar_file_system_list_t *fslist);
+
+int sigar_file_system_list_grow(sigar_file_system_list_t *fslist);
+
+#define SIGAR_FILE_SYSTEM_LIST_GROW(fslist) \
+ if (fslist->number >= fslist->size) { \
+ sigar_file_system_list_grow(fslist); \
+ }
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp);
+
+/* os plugins that set fsp->type call fs_type_get directly */
+#define sigar_fs_type_init(fsp) \
+ fsp->type = SIGAR_FSTYPE_UNKNOWN; \
+ sigar_fs_type_get(fsp)
+
+void sigar_fs_type_get(sigar_file_system_t *fsp);
+
+int sigar_cpu_infos_create(sigar_cpu_infos_t *cpu_infos);
+
+int sigar_cpu_infos_grow(sigar_cpu_infos_t *cpu_infos);
+
+#define SIGAR_CPU_INFOS_GROW(cpu_infos) \
+ if (cpu_infos->number >= cpu_infos->size) { \
+ sigar_cpu_infos_grow(cpu_infos); \
+ }
+
+int sigar_cpu_list_create(sigar_cpu_list_t *cpulist);
+
+int sigar_cpu_list_grow(sigar_cpu_list_t *cpulist);
+
+#define SIGAR_CPU_LIST_GROW(cpulist) \
+ if (cpulist->number >= cpulist->size) { \
+ sigar_cpu_list_grow(cpulist); \
+ }
+
+int sigar_net_route_list_create(sigar_net_route_list_t *routelist);
+
+int sigar_net_route_list_grow(sigar_net_route_list_t *net_routelist);
+
+#define SIGAR_NET_ROUTE_LIST_GROW(routelist) \
+ if (routelist->number >= routelist->size) { \
+ sigar_net_route_list_grow(routelist); \
+ }
+
+int sigar_net_interface_list_create(sigar_net_interface_list_t *iflist);
+
+int sigar_net_interface_list_grow(sigar_net_interface_list_t *iflist);
+
+#define SIGAR_NET_IFLIST_GROW(iflist) \
+ if (iflist->number >= iflist->size) { \
+ sigar_net_interface_list_grow(iflist); \
+ }
+
+int sigar_net_connection_list_create(sigar_net_connection_list_t *connlist);
+
+int sigar_net_connection_list_grow(sigar_net_connection_list_t *connlist);
+
+#define SIGAR_NET_CONNLIST_GROW(connlist) \
+ if (connlist->number >= connlist->size) { \
+ sigar_net_connection_list_grow(connlist); \
+ }
+
+void sigar_hwaddr_format(char *buff, unsigned char *ptr);
+
+#define sigar_hwaddr_set_null(ifconfig) \
+ memcpy(ifconfig->hwaddr, SIGAR_NULL_HWADDR, sizeof(SIGAR_NULL_HWADDR))
+
+int sigar_user_id_get(sigar_t *sigar, const char *name, int *uid);
+
+int sigar_user_name_get(sigar_t *sigar, int uid, char *buf, int buflen);
+
+int sigar_group_name_get(sigar_t *sigar, int gid, char *buf, int buflen);
+
+#define SIGAR_PROC_ENV_KEY_LOOKUP() \
+ if ((procenv->type == SIGAR_PROC_ENV_KEY) && \
+ (pid == sigar->pid)) \
+ { \
+ char *value = getenv(procenv->key); \
+ if (value != NULL) { \
+ procenv->env_getter(procenv->data, \
+ procenv->key, \
+ procenv->klen, \
+ value, strlen(value)); \
+ } \
+ return SIGAR_OK; \
+ }
+
+#endif
diff --git a/include/sigar_util.h b/include/sigar_util.h
new file mode 100644
index 00000000..a979e2f3
--- /dev/null
+++ b/include/sigar_util.h
@@ -0,0 +1,70 @@
+#ifndef SIGAR_UTIL_H
+#define SIGAR_UTIL_H
+
+/* most of this is crap for dealing with linux /proc */
+#define UITOA_BUFFER_SIZE \
+ (sizeof(int) * 3 + 1)
+
+#define SSTRLEN(s) \
+ (sizeof(s)-1)
+
+#define sigar_strtoul(ptr) \
+ strtoul(ptr, &ptr, 10)
+
+#define sigar_isspace(c) \
+ (isspace(((unsigned char)(c))))
+
+#define sigar_isdigit(c) \
+ (isdigit(((unsigned char)(c))))
+
+#define sigar_isalpha(c) \
+ (isalpha(((unsigned char)(c))))
+
+#define PROC_FS_ROOT "/proc/"
+
+char *sigar_uitoa(char *buf, unsigned int n, int *len);
+
+SIGAR_INLINE char *sigar_skip_line(char *buffer, int buflen);
+
+SIGAR_INLINE char *sigar_skip_token(char *p);
+
+SIGAR_INLINE char *sigar_skip_multiple_token(char *p, int count);
+
+int sigar_file2str(const char *fname, char *buffer, int buflen);
+
+int sigar_proc_file2str(char *buffer, int buflen,
+ sigar_pid_t pid,
+ const char *fname,
+ int fname_len);
+
+#define SIGAR_PROC_FILE2STR(buffer, pid, fname) \
+ sigar_proc_file2str(buffer, sizeof(buffer), \
+ pid, fname, SSTRLEN(fname))
+
+#define SIGAR_PROC_FILENAME(buffer, pid, fname) \
+ sigar_proc_filename(buffer, sizeof(buffer), \
+ pid, fname, SSTRLEN(fname))
+
+#define SIGAR_SKIP_SPACE(ptr) \
+ while (sigar_isspace(*ptr)) ++ptr
+
+char *sigar_proc_filename(char *buffer, int buflen,
+ sigar_pid_t pid,
+ const char *fname, int fname_len);
+
+int sigar_proc_list_procfs_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist);
+
+int sigar_proc_fd_count(sigar_t *sigar, sigar_pid_t pid,
+ sigar_uint64_t *total);
+
+/* generic util functions for all platforms */
+
+int sigar_proc_count(sigar_t *sigar, sigar_uint64_t *total);
+
+int sigar_mem_calc_ram(sigar_t *sigar, sigar_mem_t *mem);
+
+double sigar_file_system_usage_calc_used(sigar_t *sigar,
+ sigar_file_system_usage_t *fs);
+
+#endif /* SIGAR_UTIL_H */
diff --git a/src/os/aix/aix_sigar.c b/src/os/aix/aix_sigar.c
new file mode 100644
index 00000000..dfbec4e7
--- /dev/null
+++ b/src/os/aix/aix_sigar.c
@@ -0,0 +1,1161 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+
+#include "user_v5.h"
+#include "utmp_v5.h"
+
+#define FIXED_TO_DOUBLE(x) (((double)x) / 65536.0)
+
+/* these offsets wont change so just lookup them up during open */
+static int get_koffsets(sigar_t *sigar)
+{
+ int i;
+ /* see man knlist and nlist.h */
+ struct nlist klist[] = {
+ {"avenrun", 0, 0, 0, 0, 0}, /* KOFFSET_LOADAVG */
+ {"v", 0, 0, 0, 0, 0}, /* KOFFSET_VAR */
+ {"sysinfo", 0, 0, 0, 0, 0}, /* KOFFSET_SYSINFO */
+ {"ifnet", 0, 0, 0, 0, 0}, /* KOFFSET_IFNET */
+ {"vmminfo", 0, 0, 0, 0, 0}, /* KOFFSET_VMINFO */
+ {"cpuinfo", 0, 0, 0, 0, 0}, /* KOFFSET_CPUINFO */
+ {NULL, 0, 0, 0, 0, 0}
+ };
+
+ if (knlist(klist,
+ sizeof(klist) / sizeof(klist[0]),
+ sizeof(klist[0])) != 0)
+ {
+ return errno;
+ }
+
+ for (i=0; ikoffsets[i] = klist[i].n_value;
+ }
+
+ return SIGAR_OK;
+}
+
+static int kread(sigar_t *sigar, void *data, int size, long offset)
+{
+ if (sigar->kmem < 0) {
+ return SIGAR_EPERM_KMEM;
+ }
+
+ if (lseek(sigar->kmem, offset, SEEK_SET) != offset) {
+ return errno;
+ }
+
+ if (read(sigar->kmem, data, size) != size) {
+ return errno;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_os_open(sigar_t **sigar)
+{
+ int status, i;
+ void *dlhandle;
+ int kmem = -1;
+ vminfo_func_t vminfo = NULL;
+
+ if ((dlhandle = dlopen("/unix", RTLD_NOW))) {
+ vminfo = (vminfo_func_t)dlsym(dlhandle, "vmgetinfo");
+
+ dlclose(dlhandle);
+ }
+
+ kmem = open("/dev/kmem", O_RDONLY);
+
+ *sigar = malloc(sizeof(**sigar));
+
+ (*sigar)->getvminfo = vminfo;
+ (*sigar)->getprocfd = NULL; /*XXX*/
+ (*sigar)->kmem = kmem;
+ (*sigar)->pagesize = 0;
+ (*sigar)->boot_time = 0;
+ (*sigar)->last_pid = -1;
+ (*sigar)->pinfo = NULL;
+ (*sigar)->cpuinfo = NULL;
+ (*sigar)->cpuinfo_size = 0;
+ SIGAR_ZERO(&(*sigar)->swaps);
+
+ i = getpagesize();
+ while ((i >>= 1) > 0) {
+ (*sigar)->pagesize++;
+ }
+
+ if (kmem > 0) {
+ if ((status = get_koffsets(*sigar)) != SIGAR_OK) {
+ free(*sigar);
+ return status;
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+static void swaps_free(swaps_t *swaps);
+
+int sigar_os_close(sigar_t *sigar)
+{
+ swaps_free(&sigar->swaps);
+ if (sigar->kmem > 0) {
+ close(sigar->kmem);
+ }
+ if (sigar->pinfo) {
+ free(sigar->pinfo);
+ }
+ if (sigar->cpuinfo) {
+ free(sigar->cpuinfo);
+ }
+ free(sigar);
+ return SIGAR_OK;
+}
+
+char *sigar_os_error_string(int err)
+{
+ switch (err) {
+ case SIGAR_EPERM_KMEM:
+ return "Failed to open /dev/kmem for reading";
+ default:
+ return NULL;
+ }
+}
+
+#define PAGESHIFT(v) \
+ ((v) << sigar->pagesize)
+
+int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+ struct vminfo vm;
+
+#if 0
+ /* XXX: wtf, this is supposed to be a modern way
+ * to get the same values below. yet it works on 4.3.3
+ * but not 5.1
+ */
+ if (!sigar->getvminfo) {
+ return EPERM;
+ }
+
+ if (sigar->getvminfo(&vm, VMINFO, sizeof(vm)) != 0) {
+ return errno;
+ }
+
+#else
+ int status;
+
+ status = kread(sigar, &vm, sizeof(vm),
+ sigar->koffsets[KOFFSET_VMINFO]);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+#endif
+
+ mem->total = PAGESHIFT(vm.memsizepgs); /* lsattr -El sys0 -a realmem */
+ mem->free = PAGESHIFT(vm.numfrb);
+ mem->used = mem->total - mem->free;
+
+ mem->shared = -1;
+ mem->buffer = -1;
+ mem->cached = -1;
+
+ sigar_mem_calc_ram(sigar, mem);
+
+ return SIGAR_OK;
+}
+
+static void swaps_free(swaps_t *swaps)
+{
+ if (swaps->num) {
+ int i;
+
+ for (i=0; inum; i++) {
+ free(swaps->devs[i]);
+ }
+
+ free(swaps->devs);
+
+ swaps->num = 0;
+ }
+}
+
+/*
+ * there is no public api for parsing this file.
+ * well, there is something, but its super ugly and requires
+ * linking 2 static libraries (libodm and something else)
+ * maybe will switch to that if it can add value elsewhere too.
+ */
+#define SWAPSPACES "/etc/swapspaces"
+
+static int swaps_get(swaps_t *swaps)
+{
+ FILE *fp;
+ char buf[512];
+ char *ptr;
+ struct stat statbuf;
+
+ if (stat(SWAPSPACES, &statbuf) < 0) {
+ return errno;
+ }
+
+ /* only re-parse if file has changed */
+ if (swaps->mtime == statbuf.st_mtime) {
+ return 0;
+ }
+
+ swaps->mtime = statbuf.st_mtime;
+
+ /* easier to just start from scratch */
+ swaps_free(swaps);
+
+ if (!(fp = fopen(SWAPSPACES, "r"))) {
+ return errno;
+ }
+
+ while ((ptr = fgets(buf, sizeof(buf), fp))) {
+ if (!isalpha(*ptr)) {
+ continue;
+ }
+
+ if (strchr(ptr, ':')) {
+ int len;
+
+ ptr = fgets(buf, sizeof(buf), fp);
+
+ while (isspace(*ptr)) {
+ ++ptr;
+ }
+
+ if (strncmp(ptr, "dev", 3)) {
+ continue;
+ }
+ ptr += 3;
+ while (isspace(*ptr) || (*ptr == '=')) {
+ ++ptr;
+ }
+
+ len = strlen(ptr);
+ ptr[len-1] = '\0'; /* -1 == chomp \n */
+
+ swaps->devs = realloc(swaps->devs, swaps->num+1 * sizeof(char *));
+ swaps->devs[swaps->num] = malloc(len);
+ memcpy(swaps->devs[swaps->num], ptr, len);
+
+ swaps->num++;
+ }
+ }
+
+ fclose(fp);
+
+ return 0;
+}
+
+/*
+ * documented in aix tech ref,
+ * but this prototype is not in any friggin header file.
+ * struct pginfo is in sys/vminfo.h
+ */
+
+int swapqry(char *path, struct pginfo *info);
+
+int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+ int status, i;
+
+ if ((status = swaps_get(&sigar->swaps)) != SIGAR_OK) {
+ return status;
+ }
+
+ swap->total = swap->free = 0;
+
+ for (i=0; iswaps.num; i++) {
+ struct pginfo info;
+
+ status = swapqry(sigar->swaps.devs[i], &info);
+
+ if (status != 0) {
+ return errno;
+ }
+
+ swap->total += PAGESHIFT(info.size); /* lsps -a */
+ swap->free += PAGESHIFT(info.free);
+ }
+
+ swap->used = swap->total - swap->free;
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+ int i, status;
+ struct sysinfo data;
+
+ status = kread(sigar, &data, sizeof(data),
+ sigar->koffsets[KOFFSET_SYSINFO]);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ cpu->user = data.cpu[CPU_USER];
+ cpu->nice = -1; /* N/A */
+ cpu->sys = data.cpu[CPU_KERNEL];
+ cpu->idle = data.cpu[CPU_IDLE];
+ cpu->total = 0;
+
+ for (i=0; itotal += data.cpu[i];
+ }
+
+ return SIGAR_OK;
+}
+
+/*
+ * other possible metrics we could add:
+ * struct cpuinfo {
+ * long cpu[CPU_NTIMES];
+ * long pswitch;
+ * long syscall;
+ * long sysread;
+ * long syswrite;
+ * long sysfork;
+ * long sysexec;
+ * long readch;
+ * long writech;
+ * long iget;
+ * long namei;
+ * long dirblk;
+ * long msg;
+ * long sema;
+ * long bread;
+ * long bwrite;
+ * long lread;
+ * long lwrite;
+ * long phread;
+ * long phwrite;
+ * };
+ */
+
+int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ int status, i, j;
+ int ncpu = _system_configuration.ncpus; /* this can change */
+ int size = ncpu * sizeof(struct cpuinfo);
+
+ if (sigar->cpuinfo_size < size) {
+ sigar->cpuinfo = realloc(sigar->cpuinfo, size);
+ }
+
+ status = kread(sigar, sigar->cpuinfo, size,
+ sigar->koffsets[KOFFSET_CPUINFO]);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ sigar_cpu_list_create(cpulist);
+
+ for (i=0; idata[cpulist->number++];
+
+ info = &sigar->cpuinfo[i];
+ cpu->user = info->cpu[CPU_USER];
+ cpu->nice = 0; /* N/A */
+ cpu->sys = info->cpu[CPU_KERNEL];
+ cpu->idle = info->cpu[CPU_IDLE];
+ cpu->total = 0;
+
+ for (j=0; jtotal += info->cpu[j];
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+static int boot_time_v4(int fd, time_t *time)
+{
+ struct utmp data;
+
+ do {
+ if (read(fd, &data, sizeof(data)) != sizeof(data)) {
+ return errno;
+ }
+ } while (data.ut_type != BOOT_TIME);
+
+ *time = data.ut_time;
+
+ return SIGAR_OK;
+}
+
+static int boot_time_v5(int fd, time_t *time)
+{
+ struct utmp_v5 data;
+
+ do {
+ if (read(fd, &data, sizeof(data)) != sizeof(data)) {
+ return errno;
+ }
+ } while (data.ut_type != BOOT_TIME);
+
+ *time = data.ut_time;
+
+ return SIGAR_OK;
+}
+
+static int boot_time(time_t *time)
+{
+ struct utmp_v5 data_v5;
+ int utmp, status;
+
+ if ((utmp = open(UTMP_FILE, O_RDONLY)) < 0) {
+ return errno;
+ }
+
+ if ((status = boot_time_v4(utmp, time)) != SIGAR_OK) {
+ lseek(utmp, 0, SEEK_SET);
+ status = boot_time_v5(utmp, time);
+ }
+
+ close(utmp);
+
+ return status;
+}
+
+int sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ if (sigar->boot_time == 0) {
+ int status;
+ time_t time;
+
+ if ((status = boot_time(&time)) != SIGAR_OK) {
+ return status;
+ }
+
+ sigar->boot_time = time;
+ }
+
+ uptime->uptime = time(NULL) - sigar->boot_time;
+ uptime->idletime = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ int status, i;
+ int data[3];
+
+ status = kread(sigar, &data, sizeof(data),
+ sigar->koffsets[KOFFSET_LOADAVG]);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ for (i=0; i<3; i++) {
+ loadavg->loadavg[i] = FIXED_TO_DOUBLE(data[i]);
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+ pid_t pid = 0;
+ struct procsinfo info;
+
+ sigar_proc_list_create(proclist);
+
+ for (;;) {
+ int num = getprocs(&info, sizeof(info),
+ NULL, 0, &pid, 1);
+
+ if (num == 0) {
+ break;
+ }
+
+ SIGAR_PROC_LIST_GROW(proclist);
+
+ proclist->data[proclist->number++] = info.pi_pid;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+static int sigar_getprocs(sigar_t *sigar, sigar_pid_t pid)
+{
+ int status, num;
+ time_t timenow = time(NULL);
+
+ if (sigar->pinfo == NULL) {
+ sigar->pinfo = malloc(sizeof(*sigar->pinfo));
+ }
+
+ if (sigar->last_pid == pid) {
+ if ((timenow - sigar->last_getprocs) < SIGAR_LAST_PROC_EXPIRE) {
+ return SIGAR_OK;
+ }
+ }
+
+ sigar->last_pid = pid;
+ sigar->last_getprocs = timenow;
+
+ num = getprocs(sigar->pinfo, sizeof(*sigar->pinfo),
+ NULL, 0, &pid, 1);
+
+ if (num != 1) {
+ return ESRCH;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ int status = sigar_getprocs(sigar, pid);
+ struct procsinfo *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ procmem->size = PAGESHIFT(pinfo->pi_size);
+ procmem->vsize = PAGESHIFT(pinfo->pi_dvm);
+ procmem->share = PAGESHIFT(pinfo->pi_sdsize);
+ procmem->rss = PAGESHIFT(pinfo->pi_drss + pinfo->pi_trss);
+ procmem->resident = -1; /* N/A */
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ int status = sigar_getprocs(sigar, pid);
+ struct procsinfo *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proccred->uid = pinfo->pi_cred.cr_ruid;
+ proccred->euid = pinfo->pi_cred.cr_uid;
+ if (proccred->uid == -1) {
+ /*
+ * aix 5.2 has a process named 'jfsz'
+ * where uid is '-1', getpwuid returns EPERM
+ */
+ proccred->uid = proccred->euid = 0;
+ }
+ proccred->gid = pinfo->pi_cred.cr_rgid;
+ proccred->egid = pinfo->pi_cred.cr_gid;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ int status = sigar_getprocs(sigar, pid);
+ struct procsinfo *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proctime->start_time = pinfo->pi_start;
+ proctime->start_time *= 1000; /* convert to ms */
+ proctime->utime = pinfo->pi_utime;
+ proctime->stime = pinfo->pi_stime;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ int status = sigar_getprocs(sigar, pid);
+ struct procsinfo *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ SIGAR_SSTRCPY(procstate->name, pinfo->pi_comm);
+ procstate->ppid = pinfo->pi_ppid;
+ procstate->nice = pinfo->pi_nice;
+ procstate->tty = pinfo->pi_ttyd;
+ procstate->priority = -1; /* XXX getthrds() */
+
+ switch (pinfo->pi_state) {
+ case SACTIVE:
+ procstate->state = 'R';
+ break;
+ case SIDL:
+ procstate->state = 'D';
+ break;
+ case SSTOP:
+ procstate->state = 'S';
+ break;
+ case SZOMB:
+ procstate->state = 'Z';
+ break;
+ case SSWAP:
+ procstate->state = 'S';
+ break;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ /* XXX if buffer is not large enough args are truncated */
+ char buffer[8192], *ptr;
+ struct procinfo pinfo;
+
+ pinfo.pi_pid = pid;
+
+ if (getargs(&pinfo, sizeof(pinfo),
+ buffer, sizeof(buffer)) != 0)
+ {
+ return errno;
+ }
+
+ sigar_proc_args_create(procargs);
+
+ ptr = buffer;
+
+ while (*ptr) {
+ int alen = strlen(ptr)+1;
+ char *arg = malloc(alen);
+
+ SIGAR_PROC_ARGS_GROW(procargs);
+ memcpy(arg, ptr, alen);
+
+ procargs->data[procargs->number++] = arg;
+
+ ptr += alen;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ /* XXX if buffer is not large enough args are truncated */
+ char buffer[8192], *ptr;
+ struct procinfo pinfo;
+
+ pinfo.pi_pid = pid;
+
+ if (getevars(&pinfo, sizeof(pinfo),
+ buffer, sizeof(buffer)) != 0)
+ {
+ return errno;
+ }
+
+ ptr = buffer;
+
+ while (*ptr) {
+ char *val = strchr(ptr, '=');
+ int klen, vlen, status;
+ char key[128]; /* XXX is there a max key size? */
+
+ if (val == NULL) {
+ /* not key=val format */
+ procenv->env_getter(procenv->data, ptr, strlen(ptr), NULL, 0);
+ break;
+ }
+
+ klen = val - ptr;
+ SIGAR_SSTRCPY(key, ptr);
+ key[klen] = '\0';
+ ++val;
+
+ vlen = strlen(val);
+ status = procenv->env_getter(procenv->data,
+ key, klen, val, vlen);
+
+ if (status != SIGAR_OK) {
+ /* not an error; just stop iterating */
+ break;
+ }
+
+ ptr += (klen + 1 + vlen + 1);
+ }
+
+ return SIGAR_OK;
+}
+
+/*
+ * V[45]_sigar_proc_fd_get routines are exactly
+ * the same except for sizeof(uinfo).
+ */
+static int V5_sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ int i;
+ struct procinfo pinfo;
+ struct user_v5 uinfo; /* V5 */
+
+ procfd->total = 0;
+ pinfo.pi_pid = pid;
+
+ if (getuser(&pinfo, sizeof(pinfo),
+ &uinfo, sizeof(uinfo)) != 0) {
+ if (errno == EINVAL) {
+ return SIGAR_ENOTIMPL;
+ }
+ return errno;
+ }
+
+ /* see sys/user.h */
+ for (i=0; itotal++;
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+static int V4_sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ int i;
+ struct procinfo pinfo;
+ struct user uinfo; /* V4 */
+
+ procfd->total = 0;
+ pinfo.pi_pid = pid;
+
+ if (getuser(&pinfo, sizeof(pinfo),
+ &uinfo, sizeof(uinfo)) != 0) {
+ if (errno == EINVAL) {
+ return errno;
+ }
+ }
+
+ /* see sys/user.h */
+ for (i=0; itotal++;
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ if (sigar->getprocfd == NULL) {
+ /*
+ * XXX should determine aix version in sigar_os_open
+ * and set function pointer there. for now try v4
+ * first, if that fails try v5. only costs 1 extra
+ * call to getuser on v5 for the lifetime of the
+ * sigar.
+ */
+ int status = V4_sigar_proc_fd_get(sigar, pid, procfd);
+
+ if (status == SIGAR_OK) {
+ sigar->getprocfd = V4_sigar_proc_fd_get;
+ return SIGAR_OK;
+ }
+
+ sigar->getprocfd = V5_sigar_proc_fd_get;
+ }
+
+ return sigar->getprocfd(sigar, pid, procfd);
+}
+
+int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ return fsp->type;
+}
+
+/* another one documented in aix tech ref
+ * with no friggin prototype in any header file.
+ */
+int mntctl(int command, int size, char *buffer);
+
+int sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ int i, size, num;
+ char *buf, *mntlist;
+
+ /* get required size */
+ if (mntctl(MCTL_QUERY, sizeof(size), (char *)&size) < 0) {
+ return errno;
+ }
+
+ mntlist = buf = malloc(size);
+
+ if ((num = mntctl(MCTL_QUERY, size, buf)) < 0) {
+ free(buf);
+ return errno;
+ }
+
+ sigar_file_system_list_create(fslist);
+
+ for (i=0; ivmt_length;
+
+ SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
+
+ fsp = &fslist->data[fslist->number++];
+
+ switch (ent->vmt_gfstype) {
+ case MNT_AIX:
+ typename = "aix";
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ break;
+ case MNT_JFS:
+ typename = "jfs";
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ break;
+ case MNT_NFS:
+ case MNT_NFS3:
+ typename = "nfs";
+ fsp->type = SIGAR_FSTYPE_NETWORK;
+ break;
+ case MNT_CDROM:
+ fsp->type = SIGAR_FSTYPE_CDROM;
+ break;
+ case MNT_SFS:
+ case MNT_CACHEFS:
+ case MNT_AUTOFS:
+ default:
+ if (ent->vmt_flags & MNT_REMOTE) {
+ fsp->type = SIGAR_FSTYPE_NETWORK;
+ }
+ else {
+ fsp->type = SIGAR_FSTYPE_NONE;
+ }
+ }
+
+ SIGAR_SSTRCPY(fsp->dir_name, vmt2dataptr(ent, VMT_STUB));
+
+ devname = vmt2dataptr(ent, VMT_OBJECT);
+
+ if (fsp->type == SIGAR_FSTYPE_NETWORK) {
+ char *hostname = vmt2dataptr(ent, VMT_HOSTNAME);
+#if 0
+ /* XXX: these do not seem reliable */
+ int hostname_len = vmt2datasize(ent, VMT_HOSTNAME)-1; /* -1 == skip '\0' */
+ int devname_len = vmt2datasize(ent, VMT_OBJECT); /* includes '\0' */
+#else
+ int hostname_len = strlen(hostname);
+ int devname_len = strlen(devname) + 1;
+#endif
+ int total_len = hostname_len + devname_len + 1; /* 1 == strlen(":") */
+
+ if (total_len > sizeof(fsp->dev_name)) {
+ /* justincase - prevent overflow. chances: slim..none */
+ SIGAR_SSTRCPY(fsp->dev_name, devname);
+ }
+ else {
+ /* sprintf(fsp->devname, "%s:%s", hostname, devname) */
+ char *ptr = fsp->dev_name;
+
+ memcpy(ptr, hostname, hostname_len);
+ ptr += hostname_len;
+
+ *ptr++ = ':';
+
+ memcpy(ptr, devname, devname_len);
+ }
+ }
+ else {
+ SIGAR_SSTRCPY(fsp->dev_name, devname);
+ }
+
+ /* we set fsp->type, just looking up sigar.c:fstype_names[type] */
+ sigar_fs_type_get(fsp);
+
+ if (typename == NULL) {
+ typename = fsp->type_name;
+ }
+
+ SIGAR_SSTRCPY(fsp->sys_type_name, typename);
+ }
+
+ free(buf);
+
+ return SIGAR_OK;
+}
+
+/* XXX this is exactly the same as linux and hpux, solaris is darn close */
+
+#define SIGAR_FS_BLOCKS_TO_BYTES(buf, f) \
+ ((buf.f * (buf.f_bsize / 512)) >> 1)
+
+int sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ struct statfs buf;
+
+ if (statfs((char *)dirname, &buf) != 0) {
+ return errno;
+ }
+
+ fsusage->total = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_blocks);
+ fsusage->free = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bfree);
+ fsusage->avail = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bavail);
+ fsusage->files = buf.f_files;
+ fsusage->free_files = buf.f_ffree;
+ fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ int i;
+ int ncpu = _system_configuration.ncpus; /* this can change */
+
+ /*XXX should only do this once*/
+ sigar_cpu_infos_create(cpu_infos);
+
+ for (i=0; idata[cpu_infos->number++];
+
+ info->cache_size = _system_configuration.L2_cache_size / 1024;
+
+ switch (info->cache_size) {
+ case 1024:
+ info->mhz = 333;
+ break;
+ case 4096:
+ info->mhz = 400;
+ break;
+ case 8192:
+ info->mhz = 450;
+ break;
+ default:
+ info->mhz = -1;
+ break;
+ }
+
+ switch (_system_configuration.architecture) {
+ case POWER_RS:
+ arch = "Power Classic";
+ break;
+ case POWER_PC:
+ arch = "Power PC";
+ break;
+ case IA64:
+ arch = "IA64";
+ break;
+ default:
+ arch = "unknown";
+ break;
+ }
+
+ if (*arch == 'P') {
+ SIGAR_SSTRCPY(info->vendor, "IBM");
+
+ switch (_system_configuration.implementation) {
+ case POWER_RS1:
+ model = "RS1";
+ break;
+ case POWER_RSC:
+ model = "RSC";
+ break;
+ case POWER_RS2:
+ model = "RS2";
+ break;
+ case POWER_601:
+ model = "601";
+ break;
+ case POWER_603:
+ model = "603";
+ break;
+ case POWER_604:
+ model = "604";
+ break;
+ case POWER_620:
+ model = "620";
+ break;
+ case POWER_630:
+ model = "630";
+ break;
+ case POWER_A35:
+ model = "A35";
+ break;
+ case POWER_RS64II:
+ model = "RS64II";
+ break;
+ case POWER_RS64III:
+ model = "RS64III";
+ break;
+ default:
+ model = "unknown";
+ break;
+ }
+ }
+ else if (*arch == 'I') {
+ SIGAR_SSTRCPY(info->vendor, "Intel");
+
+ switch (_system_configuration.implementation) {
+ case IA64_M1:
+ model = "M1";
+ break;
+ case IA64_M2:
+ model = "M2";
+ break;
+ default:
+ model = "unknown";
+ break;
+ }
+ }
+ else {
+ SIGAR_SSTRCPY(info->vendor, "Unknown");
+ model = "unknown";
+ break;
+ }
+
+ snprintf(info->model, sizeof(info->model),
+ "%s %s", arch, model);
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+{
+ sigar_net_route_t *route;
+
+ sigar_net_route_list_create(routelist);
+
+ return SIGAR_OK;
+}
+
+int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ int status;
+ struct ifnet data;
+ caddr_t offset = 0;
+ char if_name[32];
+
+ status = kread(sigar, &offset, sizeof(offset),
+ sigar->koffsets[KOFFSET_IFNET]);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ for (; offset; offset = (caddr_t)data.if_next) {
+ status = kread(sigar, &data, sizeof(data), (long)offset);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ status = kread(sigar, if_name, sizeof(if_name),
+ (long)&data.if_name[0]);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ /* XXX if_name is 'en' or 'lo', not 'en0' or 'lo0' */
+ if (!strnEQ(if_name, name, strlen(if_name))) {
+ continue;
+ }
+
+ ifstat->rx_bytes = data.if_ibytes;
+ ifstat->rx_packets = data.if_ipackets;
+ ifstat->rx_errors = data.if_ierrors;
+ ifstat->rx_dropped = data.if_iqdrops;
+ ifstat->rx_overruns = -1;
+ ifstat->rx_frame = -1;
+
+ ifstat->tx_bytes = data.if_obytes;
+ ifstat->tx_packets = data.if_opackets;
+ ifstat->tx_errors = data.if_oerrors;
+ ifstat->tx_dropped = -1;
+ ifstat->tx_overruns = -1;
+ ifstat->tx_collisions = data.if_collisions;
+ ifstat->tx_carrier = -1;
+
+ return SIGAR_OK;
+ }
+
+ return ENXIO;
+}
+
+int sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags)
+{
+ return SIGAR_ENOTIMPL;
+}
diff --git a/src/os/aix/sigar_os.h b/src/os/aix/sigar_os.h
new file mode 100644
index 00000000..f09e1210
--- /dev/null
+++ b/src/os/aix/sigar_os.h
@@ -0,0 +1,49 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#include
+#include
+#include
+#include
+
+enum {
+ KOFFSET_LOADAVG,
+ KOFFSET_VAR,
+ KOFFSET_SYSINFO,
+ KOFFSET_IFNET,
+ KOFFSET_VMINFO,
+ KOFFSET_CPUINFO,
+ KOFFSET_MAX
+};
+
+typedef struct {
+ time_t mtime;
+ int num;
+ char **devs;
+} swaps_t;
+
+typedef int (*vminfo_func_t) (void *, int, int);
+
+typedef int (*proc_fd_func_t) (sigar_t *, sigar_pid_t, sigar_proc_fd_t *);
+
+struct sigar_t {
+ SIGAR_T_BASE;
+ int kmem;
+ /* offsets for seeking on kmem */
+ long koffsets[KOFFSET_MAX];
+ vminfo_func_t getvminfo;
+ proc_fd_func_t getprocfd;
+ int pagesize;
+ swaps_t swaps;
+ time_t last_getprocs;
+ sigar_pid_t last_pid;
+ struct procsinfo *pinfo;
+ struct cpuinfo *cpuinfo;
+ int cpuinfo_size;
+};
+
+#define HAVE_STRERROR_R
+
+#define SIGAR_EPERM_KMEM (SIGAR_OS_START_ERROR+1)
+
+#endif /* SIGAR_OS_H */
diff --git a/src/os/aix/user_v5.h b/src/os/aix/user_v5.h
new file mode 100644
index 00000000..5652bc0b
--- /dev/null
+++ b/src/os/aix/user_v5.h
@@ -0,0 +1,312 @@
+/*
+ * struct user is not binary compatible
+ * between 4.3 and 5.x
+ * this structure is taken from 5.1 sys/user.h
+ * and defines from sys/user.h and sys/types.h
+ * we compile this on v5.
+ * XXX: will not compile 5.x if we want to compile
+ * on 5.x would need to create a struct user_v4
+ * to maintain bincompt.
+ */
+
+#define V5_NISIG 3 /* v4 == 2 */
+
+#define SIGMAX64 255
+#define SIGMAX32 63
+#ifdef __64BIT__
+#define V5_SIGMAX SIGMAX64
+#else
+#define V5_SIGMAX SIGMAX32
+#endif
+
+#define NSIG64 (SIGMAX64+1)
+#define NSIG32 (SIGMAX32+1)
+#ifdef __64BIT__
+#define V5_NSIG NSIG64
+#else
+#define V5_NSIG NSIG32
+#endif
+
+#define WLM_TAG_LENGTH 30
+#define U_FD_LCK_CNT 16
+
+typedef vmhandle_t vmlpghandle_t;
+
+typedef struct {
+#ifdef _ALL_SOURCE
+ unsigned int losigs, hisigs;
+#else
+ unsigned int __losigs, __hisigs;
+#endif
+} sigset32_t;
+
+struct user_v5 {
+
+ /* swappable process context */
+ unsigned long long U_chk_paddr; /* address of checkpnt_pending var */
+ struct saioq_head *U_saioq_head;/* anchor for async socket queue */
+ uid_t U_sv_sgid; /* set group identifier at exec time */
+ int U_num_pmsegs;/* number of PM segments */
+ vmhandle_t *U_pm_segs; /* PM segments */
+ vmhandle_t U_pm_space; /* space for first PM segment */
+ vmhandle_t U_text_vmh; /* text seg vmhandle for memusage */
+ unsigned long long U_cancel_func;/* cancelation user entry point */
+ unsigned long long U_cancel_toc;/* cancelation user entry point */
+ struct proc *U_procp; /* pointer to proc structure */
+ Simple_lock U_handy_lock; /* self preservation lock */
+
+#ifdef __64BIT_KERNEL
+#ifdef _POWER
+ /* U_segs32 must be pinned and must not cross a page boundary */
+ void *U_segs32_raddr; /* real addr of U_segs32 */
+ vmhandle_t U_segs32[NSEGS]; /* shadow of first 4Gb for resume() */
+#endif /* _POWER */
+#endif /* __64BIT_KERNEL */
+
+ /* signal management */
+ void (*U_signal[NSIG32+V5_NISIG])(int);/* disposition of sigs */
+ sigset32_t U_sigmask[NSIG32+V5_NISIG]; /* sig's to be blocked */
+#ifdef __64BIT_KERNEL
+ uint U_sigflags[V5_NSIG+V5_NISIG];
+#else
+ ushort U_sigflags[NSIG64+V5_NISIG];/* ushort-save space for now*/
+#endif /* __64BIT_KERNEL */
+
+ /* user-mode address space mapping */
+#ifndef __64BIT_KERNEL
+ adspace_t U_adspace; /* user-mode address space */
+ struct segstate U_segst[NSEGS]; /* info on use of each segment */
+#else
+#ifdef _POWER
+ void * U_uastrtp; /* strt addr for V_USERACC */
+ vmsize_t U_uasize; /* size of the V_USERACC buf */
+#endif /* _POWER */
+ struct asalloc U_snode; /* segment node allocation */
+ struct asalloc U_unode; /* uadspace node allocation */
+ struct uadnode U_adspace32[NADNODES]; /* usr adspace 32bit process */
+ struct segnode U_segnode[NSEGNODES]; /* segnode for 32bit processes */
+#endif /* __64BIT_KERNEL */
+ struct vmmlock U_adspace_lock;
+ int U_vmmflags; /* vmm process state flags */
+
+ /* auditing stuff */
+ int U_auditstatus; /* auditing RESUME or SUSPEND */
+
+ /* address map (mmap) */
+ char *U_map;
+
+ /* current exec file information */
+ char U_comm[MAXCOMLEN+1]; /* basename of exec file */
+
+ int U_ncargs; /* ARGMAX value during exec */
+
+ /*
+ * Program model information, 64bit and 32bit, small and large data.
+ * The 'max' values are the maximums allowed by the model, which
+ * may be smaller than the current resource limits.
+ * These fields are filled in during exec.
+ *
+ * There is no U_stksize field. The stack is allowed whatever it can
+ * get, subject to resource limits, model limits (possibly set from
+ * the a.out header during exec), and, in 32-bit mode, the PRIVSEG
+ * data break address. The get_stack_size routine will return the
+ * current maximum effective size of the stack.
+ *
+ * Other fields:
+ * U_breakhiwater: the high water mark for the break value
+ * U_minbreak: the smallest permitted break value
+ * U_min_mmap: If non-zero, smallest address allowed for mmap()
+ * or shmat() at a user-specified address.
+ */
+ unsigned long long U_tstart; /* start of text */
+ unsigned long long U_tsize; /* text size (bytes) */
+ unsigned long long U_datastart; /* start of data */
+ unsigned long long U_datasize; /* Current data size (bytes) */
+
+ /* DABR watchpoint information */
+ unsigned long long U_wp_dabr; /* DABR value for ptrace watchpoint */
+ unsigned long long U_wp_value; /* current value at watched address */
+
+ /* System call table information */
+ void *U_svc_table; /* svc table address */
+ int U_max_svcnum; /* max allowed svc number for process */
+
+ /* CHANGES FROM HERE ON DO NOT AFFECT ASSEMBLER CODE
+ (see ml/POWER/32user.m4) */
+
+ char U_pad2[32];
+
+ unsigned long long U_datamax; /* Maximum data size (bytes) */
+ unsigned long long U_minbreak; /* minimum/initial break address */
+ unsigned long long U_breakhiwater; /* Largest break address so far */
+ unsigned long long U_min_mmap; /* Minimum shmat/mmap address allowed */
+
+ uint U_brkseg; /* segment number of U_breakhiwater */
+ uint U_stkseg; /* Lowest segment number of stack */
+
+ unsigned long long U_stkstart; /* stack start (grows downwards) */
+ unsigned long long U_stkmax; /* stack max (bytes) */
+
+ /*
+ * The following macros compute some commonly required values
+ * about the addressing model.
+ *
+ * U_BIGDATA Tells you whether the 32-bit large data model
+ * is in effect.
+ * U_PDATASIZE Is the current data size for a 32-bit process
+ * in the private segment (hence the P).
+ * Note - this is always the PRIVSEG data size; with
+ * the large data model, the general data size is
+ * separate, as data begins in the BDATASEG.
+ * U_PDATABRK Is the current data break address of a 32-bit process
+ * in the private segment (see above).
+ * U_DATABRK Is the general data break address in all cases.
+ * U_DSIZE Is for compatibility only. Use it to fill in fields
+ * that previously were copies of U_dsize, which is now
+ * obsolete.
+ */
+
+ unsigned int U_sdsize; /* Size of data for privately loaded
+ modules, if the bigdata model is
+ being used. */
+ short U_lock; /* process/text locking flags */
+ char U_64bit; /* 0 if 32-bit process, 0x1 if 64-bit */
+ char U_emul; /* emulation type (UW7, etc.) */
+
+ /* user identification and authorization */
+ Simple_lock U_cr_lock; /* credentials lock */
+ struct ucred * volatile U_cred; /* user credentials (uid, gid, etc) */
+
+ uinfo_t U_uinfo; /* usrinfo() buffer */
+ int U_compatibility;/* compatibility/user mode bit masks */
+
+ /* defines for u.u_compatibility bit mask */
+
+ struct sem_undo *U_semundo; /* semaphore undo struct pointer */
+
+ /* accounting and profiling data */
+ time_t U_start;
+ time_t U_ticks;
+ struct profdata U_prof;
+ short U_acflag; /* accounting flag */
+ struct trusage64 U_ru; /* this process resource usage value */
+ struct trusage64 U_cru; /* accumulated children's resources */
+ /*
+ * The kernel uses U_ru & U_cru to keep track of the time used by
+ * the process and its children.
+ * Even though the ru_utime & ru_stime fields within U_ru & U_cru are
+ * struct timeval, their granularity within the kernel is nanoseconds,
+ * not microseconds. This is the granularity returned by getprocs().
+ * Other syscalls and library functions convert this to microseconds.
+ */
+
+ char U_pthru; /* pthread rusage tracking */
+
+ /* virtualized resource usage values */
+ struct trusage64 U_vru;
+ struct trusage64 U_vcru;
+
+ /* resource limits and counters */
+ unsigned long U_fsblimit; /* fs limit in 512 byte-blks */
+
+#if defined(_KERNSYS) || defined(__64BIT_KERNEL)
+ /* rlimit32 structure is exposed to only 32/64 kernel
+ * and 64bit kernel extensions
+ */
+ struct rlimit32 U_rlimit[RLIM_NLIMITS]; /* 32-bit resource limits */
+#else
+ struct rlimit U_rlimit[RLIM_NLIMITS]; /* 32-bit resource limits */
+#endif
+ struct rlimit64 U_saved_rlimit[RLIM_NLIMITS]; /* saved 64-bit limits */
+ /*
+ * To maximize compatibility with old kernel code, a 32-bit
+ * representation of each resource limit is maintained in U_rlimit.
+ * Should the limit require a 64-bit representation, the U_rlimit
+ * value is set to RLIM_INFINITY, with actual 64-bit limit being
+ * stored in U_saved_rlimit. These flags indicate what
+ * the real situation is:
+ *
+ * RLFLAG_SML => limit correctly represented in 32-bit U_rlimit
+ * RLFLAG_INF => limit is infinite
+ * RLFLAG_MAX => limit is in 64_bit U_saved_rlimit.rlim_max
+ * RLFLAG_CUR => limit is in 64_bit U_saved_rlimit.rlim_cur
+ *
+ * These flags are for use by the getrlimit/setrlimit routines only.
+ * Kernel code desiring a 64-bit limit must go through kgetrlimit.
+ */
+ struct {
+ uchar rlim_cur; /* how to determine rlim_cur */
+ uchar rlim_max; /* how to determine rlim_max */
+ } U_rlimit_flag[RLIM_NLIMITS];
+
+ unsigned long long U_ioch; /* I/O character count */
+
+ /* timers */
+ Simple_lock U_timer_lock;
+ struct trb *U_timer[NTIMERS]; /* per process timers */
+
+ /* controlling tty info */
+ pid_t *U_ttysid; /* ptr to session leader id in tty */
+ pid_t *U_ttyp; /* ptr to controlling tty pgrp field */
+ dev_t U_ttyd; /* controlling tty dev */
+ long U_ttympx; /* mpx value for controlling tty */
+ unsigned *U_ttys; /* pointer to t_state in tty struct */
+ int32long64_t U_ttyid; /* tty id */
+ int (*U_ttyf)(); /* tty query function pointer */
+
+ struct upfbuf *U_message; /* uprintf buffer pointer */
+ struct trb * U_trb; /* trb for user scheduler */
+ struct pvthread *U_chktv; /* pointer to adv handler pvthread */
+
+ /* file system state */
+ vmid_t U_pn_segno; /* sid of chkpt/restart pathname seg*/
+ Simple_lock U_pnseg_lock; /* lock of chkpt/restart pathname seg*/
+ struct vnode *U_cdir; /* current directory of process */
+ struct vnode *U_rdir; /* root directory of process */
+ short U_cmask; /* mask for file creation */
+ Simple_lock U_fso_lock; /* other file system fields lock */
+ long U_lockflag; /* process has done file locks */
+ long U_fdevent; /* fd lock event list */
+
+ long long U_irss; /* accumulator for memory integral */
+ struct pinu_block *U_pinu_block;/* list of control structs for pinu */
+ tid_t U_ulocks; /* event list for user locks */
+ int32long64_t U_rmmap; /* anchor of rmmap list */
+
+ unsigned long long U_loader[84]; /* loader area */
+ Simple_lock U_aio_susp_lock; /* aio lock used in aio_suspend */
+ unsigned int U_fdfree[2]; /* file descriptor management */
+
+ unsigned int U_cannot_chpt; /* process unable to checkpoint */
+ unsigned int U_maxofile; /* maximum u_ofile index in use */
+ unsigned int U_freefile; /* first available u_ofile index */
+
+ /* WLM data */
+ dev64_t U_dev; /* device of exec'ed file */
+ ino64_t U_ino; /* inode */
+ uint_t U_gen; /* generation number */
+
+ char U_tag[WLM_TAG_LENGTH+1]; /* WLM tag: user settable string */
+
+ /* structures added for VMM checkpoint/restart support */
+ struct ckpt_ipcid *U_ckptshm; /* ptr to shmid blocks for checkpoint */
+ struct ckpt_ipcid *U_ckptsem; /* ptr to semid blocks for checkpoint */
+ struct ckpt_ipcid *U_ckptmsg; /* ptr to msgid blocks for checkpoint */
+ struct _mmapent *U_mapent; /* ptr to mmap entry structure used for restart */
+ ut_error_t U_ckpterr; /* u_error saved during ckpt processing */
+
+#ifdef __64BIT_KERNEL
+ char cacheline_pad[128]; /* keep 1st cacheline alligned */
+#else
+ vmlpghandle_t U_lpgsegs32[NSEGS]; /* lgpg handles for 32bit processes */
+ char cacheline_pad[64]; /* keep 1st cacheline alligned */
+#endif /* __64BIT_KERNEL */
+ struct { /* file descriptor lock cacheline */
+ Simple_lock u_fd_slock;
+ char cache_pad[128 - sizeof(Simple_lock)];
+ } U_fd_slcks[U_FD_LCK_CNT];
+
+ /* from here on the data is pageable. */
+
+ struct ufd U_ufd[OPEN_MAX];/* User's file descriptor table */
+};
diff --git a/src/os/aix/utmp_v5.h b/src/os/aix/utmp_v5.h
new file mode 100644
index 00000000..7341fea6
--- /dev/null
+++ b/src/os/aix/utmp_v5.h
@@ -0,0 +1,36 @@
+/*
+ * struct utmp is not binary compatible
+ * between 4.3 and 5.x
+ * this structure is taken from 5.1 utmp.h
+ * we compile this on v4.3.
+ * XXX: will not compile 5.x if we want to compile
+ * on 5.x would need to create a struct user_v4
+ * to maintain bincompt.
+ */
+
+struct utmp_v5 {
+ char ut_user[256] ; /* User login name */
+ char ut_id[14] ; /* /etc/inittab id */
+ char ut_line[64] ; /* device name (console, lnxx) */
+ pid_t ut_pid ; /* process id */
+ short ut_type ; /* type of entry */
+#if !defined(__64BIT__) && !defined(__ia64)
+ int __time_t_space; /* for 32vs64-bit time_t PPC */
+#endif
+ time_t ut_time ; /* time entry was made */
+#if !defined(__64BIT__) && defined(__ia64)
+ int __time_t_space; /* for 32vs64-bit time_t IA64 */
+#endif
+ struct exit_status_v5
+ {
+ short e_termination ; /* Process termination status */
+ short e_exit ; /* Process exit status */
+ }
+ ut_exit ; /* The exit status of a process
+ * marked as DEAD_PROCESS.
+ */
+ char ut_host[256] ; /* host name */
+ int __dbl_word_pad; /* for double word alignment */
+ int __reservedA[2];
+ int __reservedV[6];
+};
diff --git a/src/os/darwin/darwin_sigar.c b/src/os/darwin/darwin_sigar.c
new file mode 100644
index 00000000..d829b3e3
--- /dev/null
+++ b/src/os/darwin/darwin_sigar.c
@@ -0,0 +1,854 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_util.h"
+#include "sigar_os.h"
+
+#ifdef DARWIN
+#include
+#include
+#include
+#else
+#include
+#include
+#include
+#endif
+
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+#define NMIB(mib) (sizeof(mib)/sizeof(mib[0]))
+
+int sigar_os_open(sigar_t **sigar)
+{
+ int mib[2];
+ int ncpu;
+ size_t len;
+ struct timeval boottime;
+
+ len = sizeof(ncpu);
+ mib[0] = CTL_HW;
+ mib[1] = HW_NCPU;
+ if (sysctl(mib, NMIB(mib), &ncpu, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ len = sizeof(boottime);
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_BOOTTIME;
+ if (sysctl(mib, NMIB(mib), &boottime, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ *sigar = malloc(sizeof(**sigar));
+
+#ifdef DARWIN
+ (*sigar)->mach_port = mach_host_self();
+#endif
+
+ (*sigar)->ncpu = ncpu;
+
+ (*sigar)->boot_time = boottime.tv_sec; /* XXX seems off a bit */
+
+ (*sigar)->last_pid = -1;
+
+ (*sigar)->pinfo = NULL;
+
+ return SIGAR_OK;
+}
+
+int sigar_os_close(sigar_t *sigar)
+{
+ if (sigar->pinfo) {
+ free(sigar->pinfo);
+ }
+ free(sigar);
+ return SIGAR_OK;
+}
+
+char *sigar_os_error_string(int err)
+{
+ return NULL;
+}
+
+int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+#ifdef DARWIN
+ vm_statistics_data_t vmstat;
+ kern_return_t status;
+ mach_msg_type_number_t count = sizeof(vmstat) / sizeof(integer_t);
+#endif
+ int mib[2];
+ int totmem;
+ size_t len = sizeof(totmem);
+
+ mib[0] = CTL_HW;
+
+ mib[1] = HW_PAGESIZE;
+ if (sysctl(mib, NMIB(mib), &sigar->pagesize, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ mib[1] = HW_PHYSMEM;
+ if (sysctl(mib, NMIB(mib), &totmem, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ mem->total = totmem;
+
+ sigar_mem_calc_ram(sigar, mem);
+
+#ifdef DARWIN
+ status = host_statistics(sigar->mach_port, HOST_VM_INFO,
+ (host_info_t)&vmstat, &count);
+
+ if (status != KERN_SUCCESS) {
+ return errno;
+ }
+
+ mem->free = vmstat.free_count * sigar->pagesize;
+#else
+ mem->free = 1; /*XXX*/
+#endif
+
+ mem->used = mem->total - mem->free;
+ mem->shared = -1; /*XXX*/
+ mem->buffer = -1;
+ mem->cached = -1;
+
+ return SIGAR_OK;
+}
+
+#define SIGAR_FS_BLOCKS_TO_BYTES(buf, f) \
+ ((buf.f * (buf.f_bsize / 512)) >> 1)
+
+#define VM_DIR "/private/var/vm"
+#define SWAPFILE "swapfile"
+
+int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+#ifdef DARWIN
+ DIR *dirp;
+ struct dirent *ent;
+ char swapfile[SSTRLEN(VM_DIR) + SSTRLEN("/") + SSTRLEN(SWAPFILE) + 12];
+ struct stat swapstat;
+ struct statfs vmfs;
+
+ swap->used = swap->total = swap->free = 0;
+
+ if (!(dirp = opendir(VM_DIR))) {
+ return errno;
+ }
+
+ /* looking for "swapfile0", "swapfile1", etc. */
+ while ((ent = readdir(dirp))) {
+ char *ptr = swapfile;
+
+ if ((ent->d_namlen < SSTRLEN(SWAPFILE)+1) || /* n/a, see comment above */
+ (ent->d_namlen > SSTRLEN(SWAPFILE)+11)) /* ensure no overflow */
+ {
+ continue;
+ }
+
+ if (!strnEQ(ent->d_name, SWAPFILE, SSTRLEN(SWAPFILE))) {
+ continue;
+ }
+
+ /* sprintf(swapfile, "%s/%s", VM_DIR, ent->d_name) */
+
+ memcpy(ptr, VM_DIR, SSTRLEN(VM_DIR));
+ ptr += SSTRLEN(VM_DIR);
+
+ *ptr++ = '/';
+
+ memcpy(ptr, ent->d_name, ent->d_namlen+1);
+
+ if (stat(swapfile, &swapstat) < 0) {
+ continue;
+ }
+
+ swap->used += swapstat.st_size;
+ }
+
+ closedir(dirp);
+
+ if (statfs(VM_DIR, &vmfs) < 0) {
+ return errno;
+ }
+
+ swap->total = SIGAR_FS_BLOCKS_TO_BYTES(vmfs, f_bfree) + swap->used;
+
+ swap->free = swap->total - swap->used;
+
+#else
+ /*XXX*/
+ swap->total = 0;
+ swap->used = 0;
+ swap->free = 0;
+#endif
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+#ifdef DARWIN
+ kern_return_t status;
+ mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
+ host_cpu_load_info_data_t cpuload;
+
+ status = host_statistics(sigar->mach_port, HOST_CPU_LOAD_INFO,
+ (host_info_t)&cpuload, &count);
+
+ if (status != KERN_SUCCESS) {
+ return errno;
+ }
+
+ cpu->user = cpuload.cpu_ticks[CPU_STATE_USER];
+ cpu->sys = cpuload.cpu_ticks[CPU_STATE_SYSTEM];
+ cpu->idle = cpuload.cpu_ticks[CPU_STATE_IDLE];
+ cpu->nice = cpuload.cpu_ticks[CPU_STATE_NICE];
+
+ cpu->total = cpu->user + cpu->nice + cpu->sys + cpu->idle;
+
+
+#else
+ /*XXX*/
+ cpu->user = 0;
+ cpu->nice = 0;
+ cpu->sys = 0;
+ cpu->idle = 0;
+
+ cpu->total = cpu->user + cpu->nice + cpu->sys + cpu->idle;
+#endif
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ uptime->uptime = time(NULL) - sigar->boot_time;
+
+ uptime->idletime = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ getloadavg(loadavg->loadavg, 3);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+#ifdef DARWIN
+ int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0 };
+ int i, num;
+ size_t len;
+ struct kinfo_proc *proc;
+
+ if (sysctl(mib, NMIB(mib), NULL, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ proc = malloc(len);
+
+ if (sysctl(mib, NMIB(mib), proc, &len, NULL, 0) < 0) {
+ free(proc);
+ return errno;
+ }
+
+ num = len/sizeof(*proc);
+ proclist->number = 0;
+ proclist->size = num;
+ proclist->data = malloc(sizeof(*(proclist->data)) * num);
+
+ for (i=0; idata[proclist->number++] = proc[i].kp_proc.p_pid;
+ }
+
+ free(proc);
+
+ return SIGAR_OK;
+#else
+ /*XXX above compiles on freebsd but no workie */
+ return sigar_proc_list_procfs_get(sigar, proclist);
+#endif
+}
+
+int sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+static int sigar_get_pinfo(sigar_t *sigar, sigar_pid_t pid)
+{
+ int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, 0 };
+ size_t len = sizeof(*sigar->pinfo);
+ time_t timenow = time(NULL);
+ mib[3] = pid;
+
+ if (sigar->pinfo == NULL) {
+ sigar->pinfo = malloc(len);
+ }
+
+ if (sigar->last_pid == pid) {
+ if ((timenow - sigar->last_getprocs) < SIGAR_LAST_PROC_EXPIRE) {
+ return SIGAR_OK;
+ }
+ }
+
+ sigar->last_pid = pid;
+ sigar->last_getprocs = timenow;
+
+ if (sysctl(mib, NMIB(mib), sigar->pinfo, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ mach_port_t task, self = mach_task_self();
+ kern_return_t status;
+ task_basic_info_data_t info;
+ mach_msg_type_number_t type = TASK_BASIC_INFO_COUNT;
+
+ status = task_for_pid(self, pid, &task);
+
+ if (status != KERN_SUCCESS) {
+ return errno;
+ }
+
+ status = task_info(task, TASK_BASIC_INFO, &info, &type);
+
+ if (task != self) {
+ mach_port_deallocate(self, task);
+ }
+
+ procmem->vsize = info.virtual_size;
+ procmem->resident = info.resident_size;
+
+ /*XXX*/
+ procmem->size = 1; /* 1 == let ant test pass for now */
+ procmem->rss = -1;
+ procmem->share = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ int status = sigar_get_pinfo(sigar, pid);
+ struct kinfo_proc *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proccred->uid = pinfo->kp_eproc.e_pcred.p_ruid;
+ proccred->gid = pinfo->kp_eproc.e_pcred.p_rgid;
+ proccred->euid = pinfo->kp_eproc.e_pcred.p_svuid;
+ proccred->egid = pinfo->kp_eproc.e_pcred.p_svgid;
+
+ return SIGAR_OK;
+}
+
+static int get_proc_times(sigar_pid_t pid, sigar_proc_time_t *time)
+{
+ unsigned int count;
+ time_value_t utime = {0, 0}, stime = {0, 0};
+ task_basic_info_data_t ti;
+ task_thread_times_info_data_t tti;
+ task_port_t task, self = mach_task_self();
+ kern_return_t status;
+
+ status = task_for_pid(self, pid, &task);
+ if (status != KERN_SUCCESS) {
+ return errno;
+ }
+
+ count = TASK_BASIC_INFO_COUNT;
+ status = task_info(task, TASK_BASIC_INFO,
+ (task_info_t)&ti, &count);
+ if (status != KERN_SUCCESS) {
+ if (task != self) {
+ mach_port_deallocate(self, task);
+ }
+ return errno;
+ }
+
+ count = TASK_THREAD_TIMES_INFO_COUNT;
+ status = task_info(task, TASK_THREAD_TIMES_INFO,
+ (task_info_t)&tti, &count);
+ if (status != KERN_SUCCESS) {
+ if (task != self) {
+ mach_port_deallocate(self, task);
+ }
+ return errno;
+ }
+
+ time_value_add(&utime, &ti.user_time);
+ time_value_add(&stime, &ti.system_time);
+ time_value_add(&utime, &tti.user_time);
+ time_value_add(&stime, &tti.system_time);
+
+ time->utime = utime.seconds;
+ time->stime = stime.seconds;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ int status = sigar_get_pinfo(sigar, pid);
+ struct kinfo_proc *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ if ((status = get_proc_times(pid, proctime)) != SIGAR_OK) {
+ return status;
+ }
+
+#ifdef DARWIN
+ proctime->start_time = pinfo->kp_proc.p_starttime.tv_sec;
+#else
+ proctime->start_time = 1;/*XXX*/
+#endif
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ int status = sigar_get_pinfo(sigar, pid);
+ struct kinfo_proc *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ SIGAR_SSTRCPY(procstate->name, pinfo->kp_proc.p_comm);
+ procstate->ppid = pinfo->kp_eproc.e_ppid;
+ procstate->priority = pinfo->kp_proc.p_priority;
+ procstate->nice = pinfo->kp_proc.p_nice;
+ procstate->tty = -1; /*XXX*/
+
+ switch (pinfo->kp_proc.p_stat) {
+ case SIDL:
+ procstate->state = 'D';
+ break;
+ case SRUN:
+ procstate->state = 'R';
+ break;
+ case SSLEEP:
+ procstate->state = 'S';
+ break;
+ case SSTOP:
+ procstate->state = 'T';
+ break;
+ case SZOMB:
+ procstate->state = 'Z';
+ break;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ char *type = fsp->sys_type_name;
+
+ /* see sys/disklabel.h */
+ switch (*type) {
+ case 'h':
+ if (strEQ(type, "hfs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ case 'u':
+ if (strEQ(type, "ufs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ }
+
+ return fsp->type;
+}
+
+int sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ struct statfs *fs;
+ int num, i;
+ long len;
+
+ if ((num = getfsstat(NULL, 0, MNT_NOWAIT)) < 0) {
+ return errno;
+ }
+
+ len = sizeof(*fs) * num;
+ fs = malloc(len);
+
+ if ((num = getfsstat(fs, len, MNT_NOWAIT)) < 0) {
+ return errno;
+ }
+
+ sigar_file_system_list_create(fslist);
+
+ for (i=0; idata[fslist->number++];
+
+ SIGAR_SSTRCPY(fsp->dir_name, fs[i].f_mntonname);
+ SIGAR_SSTRCPY(fsp->dev_name, fs[i].f_mntfromname);
+ SIGAR_SSTRCPY(fsp->sys_type_name, fs[i].f_fstypename);
+ sigar_fs_type_init(fsp);
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ struct statfs buf;
+
+ if (statfs(dirname, &buf) < 0) {
+ return errno;
+ }
+
+ fsusage->total = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_blocks);
+ fsusage->free = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bfree);
+ fsusage->avail = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bavail);
+ fsusage->files = buf.f_files;
+ fsusage->free_files = buf.f_files;
+ fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ int i;
+
+ sigar_cpu_infos_create(cpu_infos);
+
+ for (i=0; incpu; i++) {
+ sigar_cpu_info_t *info;
+
+ SIGAR_CPU_INFOS_GROW(cpu_infos);
+
+ info = &cpu_infos->data[cpu_infos->number++];
+
+ SIGAR_SSTRCPY(info->vendor, "Apple");
+ SIGAR_SSTRCPY(info->model, "powerpc");
+
+ info->mhz = -1; /*XXX*/
+ info->cache_size = -1;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+{
+ sigar_net_route_t *route;
+
+ sigar_net_route_list_create(routelist);
+
+ return SIGAR_OK;
+}
+
+typedef enum {
+ IFMSG_ITER_LIST,
+ IFMSG_ITER_GET
+} ifmsg_iter_e;
+
+typedef struct {
+ const char *name;
+ ifmsg_iter_e type;
+ union {
+ sigar_net_interface_list_t *iflist;
+ struct if_msghdr *ifm;
+ } data;
+} ifmsg_iter_t;
+
+static int sigar_ifmsg_init(sigar_t *sigar)
+{
+ int mib[] = { CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_IFLIST, 0 };
+ size_t len;
+
+ if (sysctl(mib, NMIB(mib), NULL, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ if (sigar->ifconf_len < len) {
+ sigar->ifconf_buf = realloc(sigar->ifconf_buf, len);
+ sigar->ifconf_len = len;
+ }
+
+ if (sysctl(mib, NMIB(mib), sigar->ifconf_buf, &len, NULL, 0) < 0) {
+ return errno;
+ }
+
+ return SIGAR_OK;
+}
+
+static int sigar_ifmsg_iter(sigar_t *sigar, ifmsg_iter_t *iter)
+{
+ char *end = sigar->ifconf_buf + sigar->ifconf_len;
+ char *ptr = sigar->ifconf_buf;
+
+ if (iter->type == IFMSG_ITER_LIST) {
+ sigar_net_interface_list_create(iter->data.iflist);
+ }
+
+ while (ptr < end) {
+ char *name;
+ struct sockaddr_dl *sdl;
+ struct if_msghdr *ifm = (struct if_msghdr *)ptr;
+
+ if (ifm->ifm_type != RTM_IFINFO) {
+ break;
+ }
+
+ ptr += ifm->ifm_msglen;
+
+ while (ptr < end) {
+ struct if_msghdr *next = (struct if_msghdr *)ptr;
+
+ if (next->ifm_type != RTM_NEWADDR) {
+ break;
+ }
+
+ ptr += next->ifm_msglen;
+ }
+
+ sdl = (struct sockaddr_dl *)(ifm + 1);
+ if (sdl->sdl_family != AF_LINK) {
+ continue;
+ }
+
+ switch (iter->type) {
+ case IFMSG_ITER_LIST:
+ SIGAR_NET_IFLIST_GROW(iter->data.iflist);
+
+ name = malloc(sdl->sdl_nlen+1);
+ memcpy(name, sdl->sdl_data, sdl->sdl_nlen+1);
+
+ iter->data.iflist->data[iter->data.iflist->number++] = name;
+ break;
+
+ case IFMSG_ITER_GET:
+ if (strEQ(iter->name, sdl->sdl_data)) {
+ iter->data.ifm = ifm;
+ return SIGAR_OK;
+ }
+ }
+ }
+
+ switch (iter->type) {
+ case IFMSG_ITER_LIST:
+ return SIGAR_OK;
+
+ case IFMSG_ITER_GET:
+ default:
+ return ENXIO;
+ }
+}
+
+int sigar_net_interface_list_get(sigar_t *sigar,
+ sigar_net_interface_list_t *iflist)
+{
+ int status;
+ ifmsg_iter_t iter;
+
+ if ((status = sigar_ifmsg_init(sigar)) != SIGAR_OK) {
+ return status;
+ }
+
+ iter.type = IFMSG_ITER_LIST;
+ iter.data.iflist = iflist;
+
+ return sigar_ifmsg_iter(sigar, &iter);
+}
+
+int sigar_net_interface_config_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_config_t *ifconfig)
+{
+ int sock;
+ int status;
+ ifmsg_iter_t iter;
+ struct if_msghdr *ifm;
+ struct sockaddr_dl *sdl;
+ struct ifreq ifr;
+
+ if (sigar->ifconf_len == 0) {
+ if ((status = sigar_ifmsg_init(sigar)) != SIGAR_OK) {
+ return status;
+ }
+ }
+
+ iter.type = IFMSG_ITER_GET;
+ iter.name = name;
+
+ if ((status = sigar_ifmsg_iter(sigar, &iter)) != SIGAR_OK) {
+ return status;
+ }
+
+ if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+ return errno;
+ }
+
+ ifm = iter.data.ifm;
+
+ SIGAR_SSTRCPY(ifconfig->name, name);
+
+ sdl = (struct sockaddr_dl *)(ifm + 1);
+ sigar_hwaddr_format(ifconfig->hwaddr,
+ (unsigned char *)LLADDR(sdl));
+
+ ifconfig->flags = ifm->ifm_flags;
+ ifconfig->mtu = ifm->ifm_data.ifi_mtu;
+ ifconfig->metric = ifm->ifm_data.ifi_metric;
+
+ SIGAR_SSTRCPY(ifr.ifr_name, name);
+
+#define ifr_s_addr(ifr) \
+ ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr
+
+ if (!ioctl(sock, SIOCGIFADDR, &ifr)) {
+ ifconfig->address = ifr_s_addr(ifr);
+ }
+
+ if (!ioctl(sock, SIOCGIFNETMASK, &ifr)) {
+ ifconfig->netmask = ifr_s_addr(ifr);
+ }
+
+ if (ifconfig->flags & IFF_LOOPBACK) {
+ ifconfig->destination = ifconfig->address;
+ ifconfig->broadcast = 0;
+ }
+ else {
+ if (!ioctl(sock, SIOCGIFDSTADDR, &ifr)) {
+ ifconfig->destination = ifr_s_addr(ifr);
+ }
+
+ if (!ioctl(sock, SIOCGIFBRDADDR, &ifr)) {
+ ifconfig->broadcast = ifr_s_addr(ifr);
+ }
+ }
+
+ close(sock);
+
+ return SIGAR_OK;
+}
+
+int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ int status;
+ ifmsg_iter_t iter;
+ struct if_msghdr *ifm;
+
+ if (sigar->ifconf_len == 0) {
+ if ((status = sigar_ifmsg_init(sigar)) != SIGAR_OK) {
+ return status;
+ }
+ }
+
+ iter.type = IFMSG_ITER_GET;
+ iter.name = name;
+
+ if ((status = sigar_ifmsg_iter(sigar, &iter)) != SIGAR_OK) {
+ return status;
+ }
+
+ ifm = iter.data.ifm;
+
+ ifstat->rx_bytes = ifm->ifm_data.ifi_ibytes;
+ ifstat->rx_packets = ifm->ifm_data.ifi_ipackets;
+ ifstat->rx_errors = ifm->ifm_data.ifi_ierrors;
+ ifstat->rx_dropped = ifm->ifm_data.ifi_iqdrops;
+ ifstat->rx_overruns = -1;
+ ifstat->rx_frame = -1;
+
+ ifstat->tx_bytes = ifm->ifm_data.ifi_obytes;
+ ifstat->tx_packets = ifm->ifm_data.ifi_opackets;
+ ifstat->tx_errors = ifm->ifm_data.ifi_oerrors;
+ ifstat->tx_collisions = ifm->ifm_data.ifi_collisions;
+ ifstat->tx_dropped = -1;
+ ifstat->tx_overruns = -1;
+ ifstat->tx_carrier = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags)
+{
+ return SIGAR_ENOTIMPL;
+}
diff --git a/src/os/darwin/sigar_os.h b/src/os/darwin/sigar_os.h
new file mode 100644
index 00000000..ce272732
--- /dev/null
+++ b/src/os/darwin/sigar_os.h
@@ -0,0 +1,22 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#ifdef DARWIN
+#include
+#include
+#endif
+
+#include
+
+struct sigar_t {
+ SIGAR_T_BASE;
+ int pagesize;
+ time_t last_getprocs;
+ sigar_pid_t last_pid;
+ struct kinfo_proc *pinfo;
+#ifdef DARWIN
+ mach_port_t mach_port;
+#endif
+};
+
+#endif /* SIGAR_OS_H */
diff --git a/src/os/freebsd/README b/src/os/freebsd/README
new file mode 100644
index 00000000..9ad60159
--- /dev/null
+++ b/src/os/freebsd/README
@@ -0,0 +1,3 @@
+see ../darwin/
+yes, darwin/macosx is based on freebsd (or something like that), but
+sigar was ported to darwin/macosx first so the sources live there.
diff --git a/src/os/hpux/dlpi.c b/src/os/hpux/dlpi.c
new file mode 100644
index 00000000..a489fdab
--- /dev/null
+++ b/src/os/hpux/dlpi.c
@@ -0,0 +1,266 @@
+/*
+ * talk to Data Link Provider Interface aka /dev/dlpi
+ * see: http://docs.hp.com/hpux/onlinedocs/B2355-90139/B2355-90139.html
+ */
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define DLBUF_SIZE 8192
+
+#define ERRBUF_SIZE 1024
+
+static int send_req(int fd, char *ptr, int len, char *what, char *ebuf)
+{
+ struct strbuf ctl;
+ int flags = 0;
+
+ ctl.maxlen = 0;
+ ctl.len = len;
+ ctl.buf = ptr;
+
+ if (putmsg(fd, &ctl, (struct strbuf *) NULL, flags) < 0) {
+ snprintf(ebuf, ERRBUF_SIZE, "send_req: putmsg \"%s\": %s",
+ what, strerror(errno));
+ return -1;
+ }
+
+ return 0;
+}
+
+static int recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf)
+{
+ union DL_primitives *dlp;
+ struct strbuf ctl;
+ int flags = 0;
+
+ ctl.maxlen = DLBUF_SIZE;
+ ctl.len = 0;
+ ctl.buf = bufp;
+
+ if (getmsg(fd, &ctl, (struct strbuf*)NULL, &flags) < 0) {
+ snprintf(ebuf, ERRBUF_SIZE, "recv_ack: %s getmsg: %s",
+ what, strerror(errno));
+ return -1;
+ }
+
+ dlp = (union DL_primitives *)ctl.buf;
+ switch (dlp->dl_primitive) {
+ case DL_INFO_ACK:
+ case DL_BIND_ACK:
+ case DL_OK_ACK:
+ case DL_HP_PPA_ACK:
+ case DL_HP_INFO_ACK:
+ case DL_GET_STATISTICS_ACK:
+ break;
+
+ case DL_ERROR_ACK:
+ switch (dlp->error_ack.dl_errno) {
+
+ case DL_SYSERR:
+ snprintf(ebuf, ERRBUF_SIZE, "recv_ack: %s: system error - %s",
+ what, strerror(dlp->error_ack.dl_unix_errno));
+ break;
+
+ default:
+ snprintf(ebuf, ERRBUF_SIZE, "recv_ack: %s: dl error - %d",
+ what, dlp->error_ack.dl_errno);
+ break;
+ }
+ return -1;
+ default:
+ snprintf(ebuf, ERRBUF_SIZE,
+ "recv_ack: %s: unexpected primitive ack %d",
+ what, dlp->dl_primitive);
+ return -1;
+ }
+
+ if (ctl.len < size) {
+ snprintf(ebuf, ERRBUF_SIZE,
+ "recv_ack: %s: ack too small (%d < %d)",
+ what, ctl.len, size);
+ return -1;
+ }
+
+ return ctl.len;
+}
+
+static int dl_attach_req(int fd, uint32_t ppa, char *ebuf)
+{
+ dl_attach_req_t req;
+
+ req.dl_primitive = DL_ATTACH_REQ;
+ req.dl_ppa = ppa;
+
+ return send_req(fd, (char *)&req, sizeof(req), "attach", ebuf);
+}
+
+static int dl_bind_req(int fd, uint32_t sap, char *ebuf)
+{
+ dl_bind_req_t req;
+
+ memset((char *)&req, 0, sizeof(req));
+ req.dl_primitive = DL_BIND_REQ;
+
+ req.dl_max_conind = 1;
+ /* 22 == INSAP, see HP-UX DLPI Programmer's Guide */
+ req.dl_sap = 22;
+ req.dl_service_mode = DL_HP_RAWDLS;
+ req.dl_service_mode = DL_CODLS;
+
+ return send_req(fd, (char *)&req, sizeof(req), "bind", ebuf);
+}
+
+static int dl_bind_ack(int fd, char *bufp, char *ebuf)
+{
+ return recv_ack(fd, DL_BIND_ACK_SIZE, "bind", bufp, ebuf);
+}
+
+static int dl_ok_ack(int fd, const char *what, char *bufp, char *ebuf)
+{
+ return recv_ack(fd, DL_OK_ACK_SIZE, what, bufp, ebuf);
+}
+
+static int dl_info_req(int fd, char *ebuf)
+{
+ dl_info_req_t req;
+
+ req.dl_primitive = DL_INFO_REQ;
+
+ return send_req(fd, (char *)&req, sizeof(req), "info", ebuf);
+}
+
+static int dl_info_ack(int fd, char *bufp, char *ebuf)
+{
+ return recv_ack(fd, DL_INFO_ACK_SIZE, "info", bufp, ebuf);
+}
+
+static int dl_hp_info_req(int fd, char *ebuf)
+{
+ dl_hp_info_req_t req;
+
+ req.dl_primitive = DL_HP_INFO_REQ;
+
+ return send_req(fd, (char *)&req, sizeof(req), "hpinfo", ebuf);
+}
+
+static int dl_hp_info_ack(int fd, char *bufp, char *ebuf)
+{
+ return recv_ack(fd, DL_HP_INFO_ACK_SIZE, "hpinfo", bufp, ebuf);
+}
+
+static int dl_stats_req(int fd, char *ebuf)
+{
+ dl_get_statistics_req_t req;
+
+ req.dl_primitive = DL_GET_STATISTICS_REQ;
+
+ return send_req(fd, (char *)&req, sizeof(req), "stats", ebuf);
+}
+
+static int dl_stats_ack(int fd, char *bufp, char *ebuf)
+{
+ return recv_ack(fd, DL_GET_STATISTICS_ACK_SIZE, "stats", bufp, ebuf);
+}
+
+static int dl_open(int ppa, char *ebuf)
+{
+ char *dev = "/dev/dlpi";
+ int fd = -1;
+ dl_info_ack_t *infop;
+ uint32_t buf[DLBUF_SIZE];
+ char dname[128];
+
+ if ((fd = open(dev, O_RDWR)) < 0) {
+ snprintf(ebuf, sizeof(ebuf),
+ "failed to open %s: %s", dev, strerror(errno));
+ return -1;
+ }
+
+ if (dl_info_req(fd, ebuf) < 0 ||
+ dl_info_ack(fd, (char *)buf, ebuf) < 0) {
+ return -1;
+ }
+
+ infop = &((union DL_primitives *)buf)->info_ack;
+
+ if (infop->dl_provider_style == DL_STYLE2 &&
+ (dl_attach_req(fd, ppa, ebuf) < 0 ||
+ dl_ok_ack(fd, "attach", (char *)buf, ebuf) < 0))
+ {
+ return -1;
+ }
+
+ if (dl_bind_req(fd, 0, ebuf) < 0 ||
+ dl_bind_ack(fd, (char *)buf, ebuf) < 0)
+ {
+ return -1;
+ }
+
+ return fd;
+}
+
+static int dl_get_hp_info(int fd, char *bufp, char *ebuf)
+{
+ dl_hp_info_ack_t *ip;
+
+ if ((dl_hp_info_req(fd, ebuf) < 0) ||
+ (dl_hp_info_ack(fd, bufp, ebuf) < 0)) {
+ return -1;
+ }
+
+ ip = (dl_hp_info_ack_t *)bufp;
+ if (ip->dl_primitive != DL_HP_INFO_ACK) {
+ return -1;
+ }
+
+ return 0;
+}
+
+static int dl_get_stats(int fd, char *bufp, char *ebuf)
+{
+ dl_get_statistics_ack_t *ip;
+
+ if ((dl_stats_req(fd, ebuf) < 0) ||
+ (dl_stats_ack(fd, bufp, ebuf) < 0)) {
+ return -1;
+ }
+
+ ip = (dl_get_statistics_ack_t *)bufp;
+ if (ip->dl_primitive != DL_GET_STATISTICS_ACK) {
+ return -1;
+ }
+
+ return 0;
+}
+
+int hpux_get_mib_ifentry(int ppa, mib_ifEntry *mib)
+{
+ int fd, status=0;
+ char ebuf[ERRBUF_SIZE];
+ uint32_t buf[DLBUF_SIZE];
+
+ if ((fd = dl_open(ppa, ebuf)) < 0) {
+ return errno;
+ }
+
+ if (dl_get_stats(fd, (char *)buf, ebuf) >= 0) {
+ dl_get_statistics_ack_t *st = (dl_get_statistics_ack_t *)buf;
+ memcpy(mib, (u_char *)buf + st->dl_stat_offset, sizeof(*mib));
+ }
+ else {
+ status = errno;
+ }
+
+ close(fd);
+ return status;
+}
diff --git a/src/os/hpux/hpux_sigar.c b/src/os/hpux/hpux_sigar.c
new file mode 100644
index 00000000..252bda43
--- /dev/null
+++ b/src/os/hpux/hpux_sigar.c
@@ -0,0 +1,709 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+
+#include
+#include
+
+int sigar_os_open(sigar_t **sigar)
+{
+ *sigar = malloc(sizeof(**sigar));
+
+ /* does not change while system is running */
+ pstat_getstatic(&(*sigar)->pstatic,
+ sizeof((*sigar)->pstatic),
+ 1, 0);
+
+ (*sigar)->proctab = NULL;
+
+ (*sigar)->ticks = sysconf(_SC_CLK_TCK);
+
+ (*sigar)->last_pid = -1;
+
+ (*sigar)->pinfo = NULL;
+
+ return SIGAR_OK;
+
+}
+
+int sigar_os_close(sigar_t *sigar)
+{
+ if (sigar->proctab) {
+ free(sigar->proctab);
+ }
+ if (sigar->pinfo) {
+ free(sigar->pinfo);
+ }
+ free(sigar);
+ return SIGAR_OK;
+}
+
+char *sigar_os_error_string(int err)
+{
+ return NULL;
+}
+
+int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+ struct pst_dynamic stats;
+ sigar_uint64_t pagesize = sigar->pstatic.page_size;
+
+ mem->total = sigar->pstatic.physical_memory * pagesize;
+
+ sigar_mem_calc_ram(sigar, mem);
+
+ pstat_getdynamic(&stats, sizeof(stats), 1, 0);
+
+ mem->free = stats.psd_free * pagesize;
+ mem->used = mem->total - mem->free;
+
+ /*XXX*/
+ mem->shared = mem->buffer = mem->cached = 0;
+
+ return SIGAR_OK;
+}
+
+int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+ struct pst_swapinfo swapinfo;
+ int i=0;
+
+ swap->total = swap->free = 0;
+
+ while (pstat_getswap(&swapinfo, sizeof(swapinfo), 1, i++) > 0) {
+ swapinfo.pss_nfpgs *= 4; /* nfpgs is in 512 byte blocks */
+
+ if (swapinfo.pss_nblksenabled == 0) {
+ swapinfo.pss_nblksenabled = swapinfo.pss_nfpgs;
+ }
+
+ swap->total += swapinfo.pss_nblksenabled;
+ swap->free += swapinfo.pss_nfpgs;
+ }
+
+ swap->used = swap->total - swap->free;
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+ int i;
+ struct pst_dynamic stats;
+
+ pstat_getdynamic(&stats, sizeof(stats), 1, 0);
+ sigar->ncpu = stats.psd_proc_cnt;
+
+ cpu->user = stats.psd_cpu_time[CP_USER];
+ cpu->sys = stats.psd_cpu_time[CP_SYS] + stats.psd_cpu_time[CP_SSYS];
+ cpu->nice = stats.psd_cpu_time[CP_NICE];
+ cpu->idle = stats.psd_cpu_time[CP_IDLE];
+
+ cpu->total = 0;
+
+ /* states above plus CP_BLOCK, CP_SWAIT, etc. (see sys/dk.h) */
+ for (i=0; itotal += stats.psd_cpu_time[i];
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ int i;
+ struct pst_dynamic stats;
+
+ pstat_getdynamic(&stats, sizeof(stats), 1, 0);
+ sigar->ncpu = stats.psd_proc_cnt;
+
+ sigar_cpu_list_create(cpulist);
+
+ for (i=0; incpu; i++) {
+ int j;
+ sigar_cpu_t *cpu;
+ struct pst_processor proc;
+
+ if (pstat_getprocessor(&proc, sizeof(proc), 1, i) < 0) {
+ continue;
+ }
+
+ SIGAR_CPU_LIST_GROW(cpulist);
+
+ cpu = &cpulist->data[cpulist->number++];
+
+ cpu->user = proc.psp_cpu_time[CP_USER];
+ cpu->sys = proc.psp_cpu_time[CP_SYS] + proc.psp_cpu_time[CP_SSYS];
+ cpu->nice = proc.psp_cpu_time[CP_NICE];
+ cpu->idle = proc.psp_cpu_time[CP_IDLE];
+
+ cpu->total = 0;
+
+ for (j=0; jtotal += proc.psp_cpu_time[j];
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ uptime->uptime = time(NULL) - sigar->pstatic.boot_time;
+ uptime->idletime = 0; /*XXX*/;
+
+ return SIGAR_OK;
+}
+
+int sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ struct pst_dynamic stats;
+
+ pstat_getdynamic(&stats, sizeof(stats), 1, 0);
+
+ loadavg->loadavg[0] = stats.psd_avg_1_min;
+ loadavg->loadavg[1] = stats.psd_avg_5_min;
+ loadavg->loadavg[2] = stats.psd_avg_15_min;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+ int n;
+
+ if (!sigar->proctab) {
+ /* malloc this only once per-sigar_t as the size will not change */
+ sigar->proctab = malloc(sizeof(*sigar->proctab) *
+ sigar->pstatic.max_proc);
+ }
+
+ n = pstat_getproc(sigar->proctab, sizeof(*sigar->proctab),
+ sigar->pstatic.max_proc, 0);
+
+ proclist->number = 0;
+ proclist->size = n;
+ proclist->data = malloc(sizeof(*(proclist->data)) * n);
+
+ for (n=0; nsize; n++) {
+ proclist->data[proclist->number++] =
+ sigar->proctab[n].pst_pid;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+static int sigar_pstat_getproc(sigar_t *sigar, sigar_pid_t pid)
+{
+ int status, num;
+ time_t timenow = time(NULL);
+
+ if (sigar->pinfo == NULL) {
+ sigar->pinfo = malloc(sizeof(*sigar->pinfo));
+ }
+
+ if (sigar->last_pid == pid) {
+ if ((timenow - sigar->last_getprocs) < SIGAR_LAST_PROC_EXPIRE) {
+ return SIGAR_OK;
+ }
+ }
+
+ sigar->last_pid = pid;
+ sigar->last_getprocs = timenow;
+
+ if (pstat_getproc(sigar->pinfo,
+ sizeof(*sigar->pinfo),
+ 0, pid) == -1)
+ {
+ return ESRCH;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ int pagesize = sigar->pstatic.page_size;
+ int status = sigar_pstat_getproc(sigar, pid);
+ struct pst_status *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ procmem->size =
+ pinfo->pst_tsize + /* text */
+ pinfo->pst_dsize + /* data */
+ pinfo->pst_ssize; /* stack */
+
+ procmem->size *= pagesize;
+
+ procmem->vsize =
+ pinfo->pst_vtsize + /* text */
+ pinfo->pst_vdsize + /* data */
+ pinfo->pst_vssize; /* stack */
+
+ procmem->vsize *= pagesize;
+
+ procmem->rss = pinfo->pst_rssize * pagesize;
+
+ procmem->share = pinfo->pst_shmsize * pagesize;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ int status = sigar_pstat_getproc(sigar, pid);
+ struct pst_status *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proccred->uid = pinfo->pst_uid;
+ proccred->gid = pinfo->pst_gid;
+ proccred->euid = pinfo->pst_euid;
+ proccred->egid = pinfo->pst_egid;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ int status = sigar_pstat_getproc(sigar, pid);
+ struct pst_status *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proctime->start_time = pinfo->pst_start;
+ proctime->start_time *= 1000;
+ proctime->utime = pinfo->pst_utime;
+ proctime->stime = pinfo->pst_stime;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ int status = sigar_pstat_getproc(sigar, pid);
+ struct pst_status *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+
+ SIGAR_SSTRCPY(procstate->name, pinfo->pst_ucomm);
+ procstate->ppid = pinfo->pst_ppid;
+ procstate->tty = makedev(pinfo->pst_term.psd_major,
+ pinfo->pst_term.psd_minor);
+ procstate->priority = pinfo->pst_pri;
+ procstate->nice = pinfo->pst_nice;
+
+ switch (pinfo->pst_stat) {
+ case PS_SLEEP:
+ procstate->state = 'S';
+ break;
+ case PS_RUN:
+ procstate->state = 'R';
+ break;
+ case PS_STOP:
+ procstate->state = 'T';
+ break;
+ case PS_ZOMBIE:
+ procstate->state = 'Z';
+ break;
+ case PS_IDLE:
+ procstate->state = 'D';
+ break;
+ }
+
+ return SIGAR_OK;
+}
+
+/* XXX: could be useful elsewhere */
+static char *sigar_getword(char **line, char stop)
+{
+ char *pos = *line;
+ int len;
+ char *res;
+
+ while ((*pos != stop) && *pos) {
+ ++pos;
+ }
+
+ len = pos - *line;
+ res = (char *)malloc(len + 1);
+ memcpy(res, *line, len);
+ res[len] = 0;
+
+ if (stop) {
+ while (*pos == stop) {
+ ++pos;
+ }
+ }
+
+ *line = pos;
+
+ return res;
+}
+
+/*
+ * XXX: pst_cmd is only 64 chars of the command args.
+ * according to HP forums there isn't a way to get them
+ * all if > 64
+ */
+int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ char *args, *arg;
+ struct pst_status status;
+
+ if (pstat_getproc(&status, sizeof(status), 0, pid) == -1) {
+ return ESRCH;
+ }
+
+ args = status.pst_cmd;
+ sigar_proc_args_create(procargs);
+
+ while (*args && (arg = sigar_getword(&args, ' '))) {
+ SIGAR_PROC_ARGS_GROW(procargs);
+ procargs->data[procargs->number++] = arg;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ struct pst_status status;
+ int idx, i, n;
+ struct pst_fileinfo psf[16];
+
+ procfd->total = 0;
+
+ if (pstat_getproc(&status, sizeof(status), 0, pid) == -1) {
+ return ESRCH;
+ }
+
+ /* man pstat_getfile for index splaination */
+ idx = (status.pst_idx << 16) | (0 & 0xffff);
+
+ while ((n = pstat_getfile(psf, sizeof(psf[0]),
+ sizeof(psf)/sizeof(psf[0]),
+ idx)) > 0)
+ {
+ procfd->total += n;
+ idx = psf[n-1].psf_idx + 1;
+ }
+
+ if (n == -1) {
+ return errno;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+#include
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ char *type = fsp->sys_type_name;
+
+ switch (*type) {
+ case 'h':
+ if (strEQ(type, "hfs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ case 'v':
+ if (strEQ(type, "vxfs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ case 'c':
+ if (strEQ(type, "cdfs")) {
+ fsp->type = SIGAR_FSTYPE_CDROM;
+ }
+ break;
+ }
+
+ return fsp->type;
+}
+
+int sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ struct mntent ent;
+ char buf[1025];
+
+ FILE *fp;
+ sigar_file_system_t *fsp;
+
+ if (!(fp = setmntent(MNT_CHECKLIST, "r"))) {
+ return errno;
+ }
+
+ sigar_file_system_list_create(fslist);
+
+ while (getmntent_r(fp, &ent, buf, sizeof(buf)) == 0) {
+ if ((*(ent.mnt_type) == 's') &&
+ strEQ(ent.mnt_type, "swap"))
+ {
+ /*
+ * in this case, devname == "...", for
+ * which statfs chokes on. so skip it.
+ * also notice hpux df command has no swap info.
+ */
+ continue;
+ }
+
+ SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
+
+ fsp = &fslist->data[fslist->number++];
+
+ SIGAR_SSTRCPY(fsp->dir_name, ent.mnt_dir);
+ SIGAR_SSTRCPY(fsp->dev_name, ent.mnt_fsname);
+ SIGAR_SSTRCPY(fsp->sys_type_name, ent.mnt_type);
+ sigar_fs_type_init(fsp);
+ }
+
+ endmntent(fp);
+
+ return SIGAR_OK;
+}
+
+/* XXX this is exactly the same as linux and solaris is darn close */
+#include
+
+#define SIGAR_FS_BLOCKS_TO_BYTES(buf, f) \
+ ((buf.f * (buf.f_bsize / 512)) >> 1)
+
+int sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ struct statfs buf;
+
+ if (statfs(dirname, &buf) != 0) {
+ return errno;
+ }
+
+ fsusage->total = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_blocks);
+ fsusage->free = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bfree);
+ fsusage->avail = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bavail);
+ fsusage->files = buf.f_files;
+ fsusage->free_files = buf.f_ffree;
+ fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ int i;
+ struct pst_dynamic stats;
+
+ pstat_getdynamic(&stats, sizeof(stats), 1, 0);
+ sigar->ncpu = stats.psd_proc_cnt;
+
+ sigar_cpu_infos_create(cpu_infos);
+
+ for (i=0; incpu; i++) {
+ sigar_cpu_info_t *info;
+ struct pst_processor proc;
+
+ if (pstat_getprocessor(&proc, sizeof(proc), 1, i) < 0) {
+ perror("pstat_getprocessor");
+ continue;
+ }
+
+ SIGAR_CPU_INFOS_GROW(cpu_infos);
+
+ info = &cpu_infos->data[cpu_infos->number++];
+
+ SIGAR_SSTRCPY(info->vendor, "HP"); /*XXX*/
+ SIGAR_SSTRCPY(info->model, "PA RISC"); /*XXX*/
+ info->mhz = sigar->ticks * proc.psp_iticksperclktick / 1000000;
+ info->cache_size = -1; /*XXX*/
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+{
+ int fd, count, i;
+ unsigned int len;
+ struct nmparms parms;
+ mib_ipRouteEnt *routes;
+ sigar_net_route_t *route;
+
+ if ((fd = open_mib("/dev/ip", O_RDWR, 0, 0)) < 0) {
+ return errno;
+ }
+
+ len = sizeof(count);
+ parms.objid = ID_ipRouteNumEnt;
+ parms.buffer = &count;
+ parms.len = &len;
+
+ if (get_mib_info(fd, &parms) < 0) {
+ return errno;
+ }
+
+ len = count * sizeof(*routes);
+ routes = malloc(len);
+
+ parms.objid = ID_ipRouteTable;
+ parms.buffer = routes;
+ parms.len = &len;
+
+ if (get_mib_info(fd, &parms) < 0) {
+ free(routes);
+ return errno;
+ }
+
+ routelist->size = routelist->number = 0;
+
+ sigar_net_route_list_create(routelist);
+
+ for (i=0; idata[routelist->number++];
+ SIGAR_ZERO(route); /* XXX: other fields */
+
+ route->destination = ent->Dest;
+ route->mask = ent->Mask;
+ route->gateway = ent->NextHop;
+ }
+
+ free(routes);
+ close_mib(fd);
+
+ return SIGAR_OK;
+}
+
+static int get_mib_ifstat(sigar_t *sigar,
+ const char *name,
+ mib_ifEntry *mib)
+{
+ int fd, count, i;
+ unsigned int len;
+ nmapi_phystat *stat;
+ struct nmparms parms;
+
+ if ((fd = open_mib("/dev/ip", O_RDWR, 0, 0)) < 0) {
+ return errno;
+ }
+
+ len = sizeof(count);
+ parms.objid = ID_ifNumber;
+ parms.buffer = &count;
+ parms.len = &len;
+
+ if (get_mib_info(fd, &parms) < 0) {
+ return errno;
+ }
+
+ len = sizeof(nmapi_phystat) * count;
+
+ if (sigar->ifconf_len < len) {
+ sigar->ifconf_buf = realloc(sigar->ifconf_buf, len);
+ sigar->ifconf_len = len;
+ }
+
+ if (get_physical_stat(sigar->ifconf_buf, &len) < 0) {
+ close_mib(fd);
+ return errno;
+ }
+
+ for (i=0, stat = (nmapi_phystat *)sigar->ifconf_buf;
+ inm_device, name)) {
+ memcpy(mib, &stat->if_entry, sizeof(*mib));
+ close_mib(fd);
+ return SIGAR_OK;
+ }
+ }
+
+ close_mib(fd);
+ return ENXIO;
+}
+
+int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ int status;
+ mib_ifEntry mib;
+
+ status = get_mib_ifstat(sigar, name, &mib);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ ifstat->rx_bytes = mib.ifInOctets;
+ ifstat->rx_packets = mib.ifInUcastPkts + mib.ifInNUcastPkts;
+ ifstat->rx_errors = mib.ifInErrors;
+ ifstat->rx_dropped = mib.ifInDiscards;
+ ifstat->rx_overruns = 0; /*XXX*/
+ ifstat->rx_frame = 0; /*XXX*/
+
+ ifstat->tx_bytes = mib.ifOutOctets;
+ ifstat->tx_packets = mib.ifOutUcastPkts + mib.ifOutNUcastPkts;
+ ifstat->tx_errors = mib.ifOutErrors;
+ ifstat->tx_dropped = mib.ifOutDiscards;
+ ifstat->tx_overruns = 0; /*XXX*/
+ ifstat->tx_collisions = 0; /*XXX*/
+ ifstat->tx_carrier = 0; /*XXX*/
+
+ return SIGAR_OK;
+}
+
+int sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags)
+{
+ return SIGAR_ENOTIMPL;
+}
diff --git a/src/os/hpux/sigar_os.h b/src/os/hpux/sigar_os.h
new file mode 100644
index 00000000..179af452
--- /dev/null
+++ b/src/os/hpux/sigar_os.h
@@ -0,0 +1,20 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#include
+#include
+#include
+#include
+
+struct sigar_t {
+ SIGAR_T_BASE;
+ struct pst_static pstatic;
+ struct pst_status *proctab;
+ time_t last_getprocs;
+ sigar_pid_t last_pid;
+ struct pst_status *pinfo;
+};
+
+int hpux_get_mib_ifentry(int ppa, mib_ifEntry *mib);
+
+#endif /* SIGAR_OS_H */
diff --git a/src/os/linux/linux_sigar.c b/src/os/linux/linux_sigar.c
new file mode 100644
index 00000000..c91bdf1f
--- /dev/null
+++ b/src/os/linux/linux_sigar.c
@@ -0,0 +1,1548 @@
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+
+#include /* for PAGE_SHIFT */
+
+#define pageshift(x) ((x) << PAGE_SHIFT)
+
+#define PROC_MEMINFO PROC_FS_ROOT "meminfo"
+#define PROC_STAT PROC_FS_ROOT "stat"
+#define PROC_UPTIME PROC_FS_ROOT "uptime"
+#define PROC_LOADAVG PROC_FS_ROOT "loadavg"
+
+#define PROC_PSTAT "/stat"
+#define PROC_PSTATUS "/status"
+
+/*
+ * could also parse /proc/cpuinfo
+ * but there is less to parse this way.
+ */
+#define PROC_CPU "/proc/1/cpu"
+
+static void get_ncpu(sigar_t *sigar)
+{
+ struct stat sb;
+ FILE *fp;
+
+ sigar->ncpu = 0;
+
+ if (stat(PROC_CPU, &sb) < 0) {
+ /* file does not exist unless ncpu > 1 */
+ sigar->ncpu = 1;
+ }
+ else {
+ char buffer[BUFSIZ], *ptr;
+ if ((fp = fopen(PROC_CPU, "r"))) {
+ while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
+ if (strnEQ(ptr, "cpu", 3) &&
+ isdigit(ptr[3]))
+ {
+ ++sigar->ncpu;
+ }
+ }
+ fclose(fp);
+ }
+ }
+}
+
+/*
+ * /proc/self/stat fields:
+ * 1 - pid
+ * 2 - comm
+ * 3 - state
+ * 4 - ppid
+ * 5 - pgrp
+ * 6 - session
+ * 7 - tty_nr
+ * 8 - tpgid
+ * 9 - flags
+ * 10 - minflt
+ * 11 - cminflt
+ * 12 - majflt
+ * 13 - cmajflt
+ * 14 - utime
+ * 14 - stime
+ * 15 - cutime
+ * 16 - cstime
+ * 17 - priority
+ * 18 - nice
+ * 19 - 0 (removed field)
+ * 20 - itrealvalue
+ * 21 - starttime
+ * 22 - vsize
+ * 23 - rss
+ * 24 - rlim
+ * 25 - startcode
+ * 26 - endcode
+ * 27 - startstack
+ * 28 - kstkesp
+ * 29 - kstkeip
+ * 30 - signal
+ * 31 - blocked
+ * 32 - sigignore
+ * 33 - sigcache
+ * 34 - wchan
+ * 35 - nswap
+ * 36 - cnswap
+ * 37 - exit_signal <-- looking for this.
+ * 38 - processor
+ * ... more for newer RH
+ */
+
+#define PROC_SIGNAL_IX 38
+
+static int get_proc_signal_offset(void)
+{
+ char buffer[BUFSIZ], *ptr=buffer;
+ int fields = 0;
+ int status = sigar_file2str("/proc/self/stat",
+ buffer, sizeof(buffer));
+
+ if (status != SIGAR_OK) {
+ return 1;
+ }
+
+ while (*ptr) {
+ if (*ptr++ == ' ') {
+ fields++;
+ }
+ }
+
+ return (fields - PROC_SIGNAL_IX) + 1;
+}
+
+sigar_pid_t sigar_pid_get(sigar_t *sigar)
+{
+ /* XXX cannot safely cache getpid unless using nptl */
+ /* we can however, cache it for optimizations in the
+ * case of proc_env_get for example.
+ */
+ sigar->pid = getpid();
+ return sigar->pid;
+}
+
+int sigar_os_open(sigar_t **sigar)
+{
+ char buffer[BUFSIZ], *ptr;
+ int status = sigar_file2str(PROC_STAT, buffer, sizeof(buffer));
+
+ *sigar = malloc(sizeof(**sigar));
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ ptr = strstr(buffer, "\nbtime");
+ ptr = sigar_skip_token(ptr);
+ (*sigar)->boot_time = sigar_strtoul(ptr);
+
+ (*sigar)->ticks = 100; /* HZ */
+
+ (*sigar)->ram = -1;
+
+ (*sigar)->proc_signal_offset = -1;
+
+ get_ncpu(*sigar);
+
+ (*sigar)->last_proc_stat.pid = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_os_close(sigar_t *sigar)
+{
+ free(sigar);
+ return SIGAR_OK;
+}
+
+char *sigar_os_error_string(int err)
+{
+ return NULL;
+}
+
+static int get_ram(sigar_t *sigar, sigar_mem_t *mem)
+{
+ char buffer[BUFSIZ], *ptr;
+ FILE *fp;
+ int total = 0;
+
+ if (sigar->ram > 0) {
+ /* return cached value */
+ mem->ram = sigar->ram;
+ return SIGAR_OK;
+ }
+
+ if (sigar->ram == 0) {
+ return ENOENT;
+ }
+
+ /*
+ * Memory Type Range Registers
+ * write-back registers add up to the total.
+ */
+ if (!(fp = fopen("/proc/mtrr", "r"))) {
+ return errno;
+ }
+
+ while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
+ if (!(ptr = strstr(ptr, "size="))) {
+ continue;
+ }
+
+ if (!strstr(ptr, "write-back")) {
+ continue;
+ }
+
+ ptr += 5;
+ while (sigar_isspace(*ptr)) {
+ ++ptr;
+ }
+
+ total += atoi(ptr);
+ }
+
+ fclose(fp);
+
+ if (total == 0) {
+ return ENOENT;
+ }
+
+ mem->ram = sigar->ram = total;
+
+ return SIGAR_OK;
+}
+
+int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+ char buffer[BUFSIZ];
+ char *ptr;
+
+ int status = sigar_file2str(PROC_MEMINFO,
+ buffer, sizeof(buffer));
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ ptr = sigar_skip_line(buffer, sizeof(buffer));
+ ptr = sigar_skip_token(ptr); /* "Mem:" */
+
+ mem->total = sigar_strtoul(ptr);
+ mem->used = sigar_strtoul(ptr);
+ mem->free = sigar_strtoul(ptr);
+ mem->shared = sigar_strtoul(ptr);
+ mem->buffer = sigar_strtoul(ptr);
+ mem->cached = sigar_strtoul(ptr);
+
+ if (get_ram(sigar, mem) != SIGAR_OK) {
+ /* XXX other options on failure? */
+ sigar_mem_calc_ram(sigar, mem);
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+ char buffer[BUFSIZ];
+ char *ptr;
+
+ /* XXX: we open/parse the same file here as sigar_mem_get */
+ int status = sigar_file2str(PROC_MEMINFO,
+ buffer, sizeof(buffer));
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ ptr = sigar_skip_line(buffer, sizeof(buffer));
+ ptr = sigar_skip_line(ptr, 0);
+ ptr = sigar_skip_token(ptr); /* "Swap:" */
+
+ swap->total = sigar_strtoul(ptr);
+ swap->used = sigar_strtoul(ptr);
+ swap->free = sigar_strtoul(ptr);
+
+ return SIGAR_OK;
+}
+
+static void get_cpu_metrics(sigar_cpu_t *cpu, char *line)
+{
+ char *ptr = sigar_skip_token(line); /* "cpu%d" */
+
+ cpu->user = sigar_strtoul(ptr);
+ cpu->nice = sigar_strtoul(ptr);
+ cpu->sys = sigar_strtoul(ptr);
+ cpu->idle = sigar_strtoul(ptr);
+
+ cpu->total = cpu->user + cpu->nice + cpu->sys + cpu->idle;
+}
+
+int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+ char buffer[BUFSIZ];
+ int status = sigar_file2str(PROC_STAT, buffer, sizeof(buffer));
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ get_cpu_metrics(cpu, buffer);
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ FILE *fp;
+ char buffer[BUFSIZ], *ptr;
+
+ if (!(fp = fopen(PROC_STAT, "r"))) {
+ return errno;
+ }
+
+ /* skip first line */
+ (void)fgets(buffer, sizeof(buffer), fp);
+
+ sigar_cpu_list_create(cpulist);
+
+ /* XXX: merge times of logical processors if hyperthreading */
+ while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
+ sigar_cpu_t *cpu;
+
+ if (!strnEQ(ptr, "cpu", 3)) {
+ break;
+ }
+
+ SIGAR_CPU_LIST_GROW(cpulist);
+ cpu = &cpulist->data[cpulist->number++];
+
+ get_cpu_metrics(cpu, ptr);
+ }
+
+ fclose(fp);
+
+ return SIGAR_OK;
+}
+
+int sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ char buffer[BUFSIZ], *ptr = buffer;
+ int status = sigar_file2str(PROC_UPTIME, buffer, sizeof(buffer));
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ uptime->uptime = strtod(buffer, &ptr);
+ uptime->idletime = strtod(ptr, &ptr);
+
+ return SIGAR_OK;
+}
+
+int sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ char buffer[BUFSIZ], *ptr = buffer;
+ int status = sigar_file2str(PROC_LOADAVG, buffer, sizeof(buffer));
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ loadavg->loadavg[0] = strtod(buffer, &ptr);
+ loadavg->loadavg[1] = strtod(ptr, &ptr);
+ loadavg->loadavg[2] = strtod(ptr, &ptr);
+
+ return SIGAR_OK;
+}
+
+/*
+ * seems the easiest/fastest way to tell if a process listed in /proc
+ * is a thread is to check the "exit signal" flag in /proc/num/stat.
+ * any value other than SIGCHLD seems to be a thread. this make hulk mad.
+ * redhat's procps patch (named "threadbadhack.pat") does not use
+ * this flag to filter out threads. instead does much more expensive
+ * comparisions. their patch also bubbles up thread cpu times to the main
+ * process. functionality we currently lack.
+ * when nptl is in use, this is not the case and all threads spawned from
+ * a process have the same pid. however, it seems both old-style linux
+ * threads and nptl threads can be run on the same machine.
+ * there is also the "Tgid" field in /proc/self/status which could be used
+ * to detect threads, but this is not available in older kernels.
+ */
+static SIGAR_INLINE int proc_isthread(sigar_t *sigar, char *pidstr, int len)
+{
+ char buffer[BUFSIZ], *ptr=buffer;
+ int fd, n, offset=sigar->proc_signal_offset;
+
+ /* sprintf(buffer, "/proc/%s/stat", pidstr) */
+ memcpy(ptr, PROC_FS_ROOT, SSTRLEN(PROC_FS_ROOT));
+ ptr += SSTRLEN(PROC_FS_ROOT);
+
+ memcpy(ptr, pidstr, len);
+ ptr += len;
+
+ memcpy(ptr, PROC_PSTAT, SSTRLEN(PROC_PSTAT));
+ ptr += SSTRLEN(PROC_PSTAT);
+
+ *ptr = '\0';
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ /* unlikely if pid was from readdir proc */
+ return 0;
+ }
+
+ n = read(fd, buffer, sizeof(buffer));
+ close(fd);
+
+ if (n < 0) {
+ return 0; /* chances: slim..none */
+ }
+
+ buffer[n--] = '\0';
+
+ /* exit_signal is the second to last field so we look backwards.
+ * XXX if newer kernels drop more turds in this file we'll need
+ * to go the other way. luckily linux has no real api for this shit.
+ */
+
+ /* skip trailing crap */
+ while ((n > 0) && !isdigit(buffer[n--])) ;
+
+ while (offset-- > 0) {
+ /* skip last field */
+ while ((n > 0) && isdigit(buffer[n--])) ;
+
+ /* skip whitespace */
+ while ((n > 0) && !isdigit(buffer[n--])) ;
+ }
+
+ if (n < 3) {
+ return 0; /* hulk smashed /proc? */
+ }
+
+ ptr = &buffer[n];
+ /*
+ * '17' == SIGCHLD == real process.
+ * '33' and '0' are threads
+ */
+ if ((*ptr++ == '1') &&
+ (*ptr++ == '7') &&
+ (*ptr++ == ' '))
+ {
+ return 0;
+ }
+
+ return 1;
+}
+
+int sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+ DIR *dirp = opendir("/proc");
+ struct dirent *ent, dbuf;
+
+ if (!dirp) {
+ return errno;
+ }
+
+ if (sigar->proc_signal_offset == -1) {
+ sigar->proc_signal_offset = get_proc_signal_offset();
+ }
+
+ sigar_proc_list_create(proclist);
+
+ while (readdir_r(dirp, &dbuf, &ent) == 0) {
+ if (!ent) {
+ break;
+ }
+
+ if (!sigar_isdigit(*ent->d_name)) {
+ continue;
+ }
+
+ if (proc_isthread(sigar, ent->d_name, strlen(ent->d_name)))
+ {
+ continue;
+ }
+
+ /* XXX: more sanity checking */
+
+ SIGAR_PROC_LIST_GROW(proclist);
+
+ proclist->data[proclist->number++] =
+ strtoul(ent->d_name, NULL, 10);
+ }
+
+ closedir(dirp);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+static int proc_stat_read(sigar_t *sigar, sigar_pid_t pid)
+{
+ char buffer[BUFSIZ], *ptr=buffer, *tmp;
+ unsigned int len;
+ linux_proc_stat_t *pstat = &sigar->last_proc_stat;
+ int status;
+
+ time_t timenow = time(NULL);
+
+ /*
+ * short-lived cache read/parse of last /proc/pid/stat
+ * as this info is spread out across a few functions.
+ */
+ if (pstat->pid == pid) {
+ if ((timenow - pstat->mtime) < SIGAR_LAST_PROC_EXPIRE) {
+ return SIGAR_OK;
+ }
+ }
+
+ pstat->pid = pid;
+ pstat->mtime = timenow;
+
+ status = SIGAR_PROC_FILE2STR(buffer, pid, PROC_PSTAT);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ ptr = strchr(ptr, '(')+1;
+
+ tmp = strrchr(ptr, ')');
+ len = tmp-ptr;
+
+ if (len >= sizeof(pstat->name)) {
+ len = sizeof(pstat->name)-1;
+ }
+
+ memcpy(pstat->name, ptr, len);
+ pstat->name[len] = '\0';
+ ptr = tmp+1;
+
+ SIGAR_SKIP_SPACE(ptr);
+ pstat->state = *ptr++;
+ SIGAR_SKIP_SPACE(ptr);
+
+ pstat->ppid = sigar_strtoul(ptr);
+ ptr = sigar_skip_token(ptr); /* pgrp */
+ ptr = sigar_skip_token(ptr); /* session */
+ pstat->tty = sigar_strtoul(ptr);
+ ptr = sigar_skip_token(ptr); /* tty pgrp */
+
+ ptr = sigar_skip_token(ptr); /* flags */
+ ptr = sigar_skip_token(ptr); /* min flt */
+ ptr = sigar_skip_token(ptr); /* cmin flt */
+ ptr = sigar_skip_token(ptr); /* maj flt */
+ ptr = sigar_skip_token(ptr); /* cmaj flt */
+
+ pstat->utime = sigar_strtoul(ptr) / sigar->ticks;
+ pstat->stime = sigar_strtoul(ptr) / sigar->ticks;
+
+ ptr = sigar_skip_token(ptr); /* cutime */
+ ptr = sigar_skip_token(ptr); /* cstime */
+
+ pstat->priority = sigar_strtoul(ptr);
+ pstat->nice = sigar_strtoul(ptr);
+
+ ptr = sigar_skip_token(ptr); /* timeout */
+ ptr = sigar_skip_token(ptr); /* it_real_value */
+
+ pstat->start_time = sigar_strtoul(ptr);
+ pstat->start_time /= sigar->ticks;
+ pstat->start_time += sigar->boot_time; /* seconds */
+ pstat->start_time *= 1000; /* milliseconds */
+
+ pstat->vsize = sigar_strtoul(ptr);
+ pstat->rss = pageshift(sigar_strtoul(ptr));
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ char buffer[BUFSIZ], *ptr=buffer;
+ int status = proc_stat_read(sigar, pid);
+ linux_proc_stat_t *pstat = &sigar->last_proc_stat;
+
+ procmem->vsize = pstat->vsize;
+ procmem->rss = pstat->rss;
+
+ status = SIGAR_PROC_FILE2STR(buffer, pid, "/statm");
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ procmem->size = pageshift(sigar_strtoul(ptr));
+ procmem->resident = pageshift(sigar_strtoul(ptr));
+ procmem->share = pageshift(sigar_strtoul(ptr));
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ char buffer[BUFSIZ], *ptr;
+ int status = SIGAR_PROC_FILE2STR(buffer, pid, PROC_PSTATUS);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ ptr = strstr(buffer, "\nUid:");
+ ptr = sigar_skip_token(ptr);
+
+ proccred->uid = sigar_strtoul(ptr);
+ proccred->euid = sigar_strtoul(ptr);
+
+ ptr = strstr(ptr, "\nGid:");
+ ptr = sigar_skip_token(ptr);
+
+ proccred->gid = sigar_strtoul(ptr);
+ proccred->egid = sigar_strtoul(ptr);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ int status = proc_stat_read(sigar, pid);
+ linux_proc_stat_t *pstat = &sigar->last_proc_stat;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proctime->utime = pstat->utime;
+ proctime->stime = pstat->stime;
+ proctime->start_time = pstat->start_time;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ int status = proc_stat_read(sigar, pid);
+ linux_proc_stat_t *pstat = &sigar->last_proc_stat;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ memcpy(procstate->name, pstat->name, sizeof(procstate->name));
+ procstate->state = pstat->state;
+
+ procstate->ppid = pstat->ppid;
+ procstate->tty = pstat->tty;
+ procstate->priority = pstat->priority;
+ procstate->nice = pstat->nice;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ char buffer[BUFSIZ], *buf=NULL, *ptr;
+ int fd, len, total=0;
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/cmdline");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ if (errno == ENOENT) {
+ return ESRCH;
+ }
+ return errno;
+ }
+
+ buffer[0] = '\0';
+
+ /* XXX: possible to get rid of some mallocs here.
+ * but, unlikely this will be called often so it
+ * might not even matter much.
+ */
+ while ((len = read(fd, buffer, sizeof(buffer)-1)) > 0) {
+ if (len == 0) {
+ break;
+ }
+ if (buf) {
+ buf = realloc(buf, total+len);
+ }
+ else {
+ buf = malloc(len+1);
+ }
+ memcpy(buf+total, buffer, len);
+ total += len;
+ }
+
+ close(fd);
+
+ sigar_proc_args_create(procargs);
+
+ //e.g. /proc/2/cmdline
+ if (total == 0) {
+ procargs->number = 0;
+ return SIGAR_OK;
+ }
+
+ buf[total] = '\0';
+ ptr = buf;
+
+ while (*ptr) {
+ int alen = strlen(ptr)+1;
+ char *arg = malloc(alen);
+
+ SIGAR_PROC_ARGS_GROW(procargs);
+ memcpy(arg, ptr, alen);
+
+ procargs->data[procargs->number++] = arg;
+
+ ptr += alen;
+ }
+
+ free(buf);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ int fd;
+ char buffer[ARG_MAX]; /* XXX: ARG_MAX == 130k */
+ char name[BUFSIZ];
+ size_t len;
+ char *ptr, *end;
+
+ /* optimize if pid == $$ and type == ENV_KEY */
+ SIGAR_PROC_ENV_KEY_LOOKUP();
+
+ (void)SIGAR_PROC_FILENAME(name, pid, "/environ");
+
+ if ((fd = open(name, O_RDONLY)) < 0) {
+ if (errno == ENOENT) {
+ return ESRCH;
+ }
+ return errno;
+ }
+
+ len = read(fd, buffer, sizeof(buffer));
+
+ close(fd);
+
+ buffer[len] = '\0';
+ ptr = buffer;
+
+ end = buffer + len;
+ while (ptr < end) {
+ char *val = strchr(ptr, '=');
+ int klen, vlen, status;
+ char key[128]; /* XXX is there a max key size? */
+
+ if (val == NULL) {
+ /* not key=val format */
+ break;
+ }
+
+ klen = val - ptr;
+ SIGAR_SSTRCPY(key, ptr);
+ key[klen] = '\0';
+ ++val;
+
+ vlen = strlen(val);
+ status = procenv->env_getter(procenv->data,
+ key, klen, val, vlen);
+
+ if (status != SIGAR_OK) {
+ /* not an error; just stop iterating */
+ break;
+ }
+
+ ptr += (klen + 1 + vlen + 1);
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ int status =
+ sigar_proc_fd_count(sigar, pid, &procfd->total);
+
+ return status;
+}
+
+int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ int len;
+ char name[BUFSIZ];
+
+ (void)SIGAR_PROC_FILENAME(name, pid, "/cwd");
+
+ if ((len = readlink(name, procexe->cwd,
+ sizeof(procexe->cwd)-1)) < 0)
+ {
+ return errno;
+ }
+
+ procexe->cwd[len] = '\0';
+
+ (void)SIGAR_PROC_FILENAME(name, pid, "/exe");
+
+ if ((len = readlink(name, procexe->name,
+ sizeof(procexe->name)-1)) < 0)
+ {
+ return errno;
+ }
+
+ procexe->name[len] = '\0';
+
+ (void)SIGAR_PROC_FILENAME(name, pid, "/root");
+
+ if ((len = readlink(name, procexe->root,
+ sizeof(procexe->root)-1)) < 0)
+ {
+ return errno;
+ }
+
+ procexe->root[len] = '\0';
+
+ return SIGAR_OK;
+}
+
+#include
+#include
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ char *type = fsp->sys_type_name;
+
+ switch (*type) {
+ case 'e':
+ if (strnEQ(type, "ext", 3)) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ case 'h':
+ if (strEQ(type, "hpfs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ case 'r':
+ if (strEQ(type, "reiserfs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ case 'x':
+ if (strEQ(type, "xfs") || strEQ(type, "xiafs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ }
+
+ return fsp->type;
+}
+
+int sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ struct mntent ent;
+ char buf[1025]; /* buffer for strings within ent */
+ FILE *fp;
+ sigar_file_system_t *fsp;
+
+ if (!(fp = setmntent(MOUNTED, "r"))) {
+ return errno;
+ }
+
+ sigar_file_system_list_create(fslist);
+
+ while (getmntent_r(fp, &ent, buf, sizeof(buf))) {
+ SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
+
+ fsp = &fslist->data[fslist->number++];
+
+ SIGAR_SSTRCPY(fsp->dir_name, ent.mnt_dir);
+ SIGAR_SSTRCPY(fsp->dev_name, ent.mnt_fsname);
+ SIGAR_SSTRCPY(fsp->sys_type_name, ent.mnt_type);
+ sigar_fs_type_get(fsp);
+ }
+
+ endmntent(fp);
+
+ return SIGAR_OK;
+}
+
+#include
+
+#define SIGAR_FS_BLOCKS_TO_BYTES(buf, f) \
+ ((buf.f * (buf.f_bsize / 512)) >> 1)
+
+int sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ struct statfs buf;
+
+ if (statfs(dirname, &buf) != 0) {
+ return errno;
+ }
+
+ fsusage->total = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_blocks);
+ fsusage->free = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bfree);
+ fsusage->avail = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bavail);
+ fsusage->files = buf.f_files;
+ fsusage->free_files = buf.f_ffree;
+ fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
+
+ return SIGAR_OK;
+}
+
+static SIGAR_INLINE char *cpu_info_strval(char *ptr)
+{
+ if ((ptr = strchr(ptr, ':'))) {
+ ptr++;
+ while (isspace (*ptr)) ptr++;
+ return ptr;
+ }
+ return NULL;
+}
+
+static SIGAR_INLINE void cpu_info_strcpy(char *ptr, char *buf, int len)
+{
+ int slen;
+ ptr = cpu_info_strval(ptr);
+ if (!ptr) {
+ return;
+ }
+ slen = strlen(ptr);
+ strncpy(buf, ptr, len);
+ buf[len] = '\0';
+ if (slen < len) {
+ buf[slen-1] = '\0'; /* rid \n */
+ }
+}
+
+static int get_cpu_info(sigar_cpu_info_t *info, FILE *fp, int *id)
+{
+ char buffer[BUFSIZ], *ptr;
+
+ int found = 0, siblings = 0;
+
+ *id = -1;
+
+ while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
+ switch (*ptr) {
+ case 'p': /* processor : 0 */
+ if (strnEQ(ptr, "processor", 9)) {
+ found = 1;
+ }
+ else if (strnEQ(ptr, "physical id", 11)) {
+ ptr = cpu_info_strval(ptr);
+ *id = atoi(ptr);
+ }
+ break;
+ case 'v':
+ if (strnEQ(ptr, "vendor_id", 9)) {
+ cpu_info_strcpy(ptr, info->vendor, sizeof(info->vendor));
+ }
+ break;
+ case 'm':
+ if (strnEQ(ptr, "model name", 10)) {
+ cpu_info_strcpy(ptr, info->model, sizeof(info->model));
+ }
+ break;
+ case 'c':
+ if (strnEQ(ptr, "cpu MHz", 7)) {
+ ptr = cpu_info_strval(ptr);
+ info->mhz = atoi(ptr);
+ }
+ else if (strnEQ(ptr, "cache size", 10)) {
+ ptr = cpu_info_strval(ptr);
+ info->cache_size = sigar_strtoul(ptr);
+ }
+ break;
+ case 's':
+ /* this is horseshit. why doesn't linux have a real api
+ * like every other operation system. if siblings == 1
+ * then hyperthreading is disabled, so we shouldn't fold
+ * the dups based on physical id attribute.
+ */
+ if (strnEQ(ptr, "siblings", 8)) {
+ ptr = cpu_info_strval(ptr);
+ siblings = atoi(ptr);
+ if (siblings == 1) {
+ *id = -1;
+ }
+ }
+ break;
+ case 't':
+ /* same as siblings, renamed in new kernels */
+ if (strnEQ(ptr, "threads", 7)) {
+ ptr = cpu_info_strval(ptr);
+ siblings = atoi(ptr);
+ if (siblings == 1) {
+ *id = -1;
+ }
+ }
+ break;
+ /* lone \n means end of info for this processor */
+ case '\n':
+ return found;
+ }
+ }
+
+ return found;
+}
+
+int sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ FILE *fp;
+ int id;
+ int cpu_id[36], cpu_ix=0;
+ /* in the event that a box has > 36 cpus */
+ int cpu_id_max = sizeof(cpu_id)/sizeof(int);
+
+ if (!(fp = fopen("/proc/cpuinfo", "r"))) {
+ return errno;
+ }
+
+ sigar_cpu_infos_create(cpu_infos);
+ memset(&cpu_id[0], -1, sizeof(cpu_id));
+
+ while (get_cpu_info(&cpu_infos->data[cpu_infos->number], fp, &id)) {
+ if (id >= 0) {
+ int i, fold=0;
+ for (i=0; (inumber;
+ SIGAR_CPU_INFOS_GROW(cpu_infos);
+ }
+
+ fclose(fp);
+
+ return SIGAR_OK;
+}
+
+static unsigned int hex2int(const char *x)
+{
+ int i, ch;
+ unsigned int j;
+
+ for (i=0, j=0; i<8; i++) {
+ ch = x[i];
+ j <<= 4;
+ if (isdigit(ch)) {
+ j |= ch - '0';
+ }
+ else if (isupper(ch)) {
+ j |= ch - ('A' - 10);
+ }
+ else {
+ j |= ch - ('a' - 10);
+ }
+ }
+
+ return j;
+}
+
+#define ROUTE_FMT "%16s %128s %128s %X %lld %lld %lld %128s %lld %lld %lld\n"
+#define RTF_UP 0x0001
+
+int sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+{
+ FILE *fp;
+ char buffer[1024];
+ char net_addr[128], gate_addr[128], mask_addr[128];
+ int flags;
+ sigar_net_route_t *route;
+
+ routelist->size = routelist->number = 0;
+
+ if (!(fp = fopen("/proc/net/route", "r"))) {
+ return errno;
+ }
+
+ sigar_net_route_list_create(routelist);
+
+ (void)fgets(buffer, sizeof(buffer), fp); /* skip header */
+ while (fgets(buffer, sizeof(buffer), fp)) {
+ int num;
+
+ SIGAR_NET_ROUTE_LIST_GROW(routelist);
+ route = &routelist->data[routelist->number++];
+
+ /* XXX rid sscanf */
+ num = sscanf(buffer, ROUTE_FMT,
+ route->ifname, net_addr, gate_addr,
+ &flags, &route->refcnt, &route->use,
+ &route->metric, mask_addr,
+ &route->mtu, &route->window, &route->irtt);
+
+ if ((num < 10) || !(flags & RTF_UP)) {
+ --routelist->number;
+ continue;
+ }
+
+ route->flags = flags;
+ route->destination = hex2int(net_addr);
+ route->gateway = hex2int(gate_addr);
+ route->mask = hex2int(mask_addr);
+ }
+
+ fclose(fp);
+
+ return SIGAR_OK;
+}
+
+int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ int found = 0;
+ char buffer[BUFSIZ];
+ FILE *fp = fopen("/proc/net/dev", "r");
+
+ if (!fp) {
+ return errno;
+ }
+
+ /* skip header */
+ fgets(buffer, sizeof(buffer), fp);
+ fgets(buffer, sizeof(buffer), fp);
+
+ while (fgets(buffer, sizeof(buffer), fp)) {
+ char *ptr, *dev;
+
+ dev = buffer;
+ while (isspace(*dev)) {
+ dev++;
+ }
+
+ if (!(ptr = strchr(dev, ':'))) {
+ continue;
+ }
+
+ *ptr++ = 0;
+
+ if (!strEQ(dev, name)) {
+ continue;
+ }
+
+ found = 1;
+ ifstat->rx_bytes = sigar_strtoul(ptr);
+ ifstat->rx_packets = sigar_strtoul(ptr);
+ ifstat->rx_errors = sigar_strtoul(ptr);
+ ifstat->rx_dropped = sigar_strtoul(ptr);
+ ifstat->rx_overruns = sigar_strtoul(ptr);
+ ifstat->rx_frame = sigar_strtoul(ptr);
+
+ /* skip: compressed multicast */
+ ptr = sigar_skip_multiple_token(ptr, 2);
+
+ ifstat->tx_bytes = sigar_strtoul(ptr);
+ ifstat->tx_packets = sigar_strtoul(ptr);
+ ifstat->tx_errors = sigar_strtoul(ptr);
+ ifstat->tx_dropped = sigar_strtoul(ptr);
+ ifstat->tx_overruns = sigar_strtoul(ptr);
+ ifstat->tx_collisions = sigar_strtoul(ptr);
+ ifstat->tx_carrier = sigar_strtoul(ptr);
+ break;
+ }
+
+ fclose(fp);
+
+ return found ? SIGAR_OK : ENXIO;
+}
+
+static SIGAR_INLINE int ip_format(char *buffer, int buflen, char *ptr)
+{
+ int alen = strlen(ptr);
+
+ if (alen > 8) {
+ struct in6_addr addr;
+ int i;
+ for (i=0; i<=3; i++, ptr+=8) {
+ addr.s6_addr32[i] = hex2int(ptr);
+ }
+ if (!inet_ntop(AF_INET6, &addr, buffer, buflen)) {
+ return errno;
+ }
+ }
+ else {
+ struct in_addr addr;
+ addr.s_addr = hex2int(ptr);
+ if (!inet_ntop(AF_INET, &addr, buffer, buflen)) {
+ return errno;
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+typedef struct {
+ sigar_net_connection_list_t *connlist;
+ sigar_net_connection_t *conn;
+ unsigned long port;
+} net_conn_getter_t;
+
+#define CONN_GET_DONE -2
+
+static int proc_net_read(net_conn_getter_t *getter,
+ const char *fname,
+ int flags, int type)
+{
+ FILE *fp;
+ char buffer[8192], *ptr;
+
+ if (!(fp = fopen(fname, "r"))) {
+ return errno;
+ }
+
+ fgets(buffer, sizeof(buffer), fp); /* skip header */
+
+ while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
+ sigar_net_connection_t conn;
+ char *port = NULL;
+ char *laddr, *raddr;
+ int status;
+
+ ptr = sigar_skip_token(ptr); /* skip number */
+ while (isspace(*ptr)) {
+ ptr++;
+ }
+
+ port = strchr(ptr, ':');
+ *port = '\0';
+ ++port;
+
+ conn.local_port = (strtoul(port, &port, 16) & 0xffff);
+ laddr = ptr;
+
+ ptr = port;
+ while (isspace(*ptr)) {
+ ptr++;
+ }
+
+ port = strchr(ptr, ':');
+ *port = '\0';
+ ++port;
+
+ conn.remote_port = (strtoul(port, &port, 16) & 0xffff);
+ raddr = ptr;
+
+ ptr = port;
+ while (isspace(*ptr)) {
+ ptr++;
+ }
+
+ if (!((conn.remote_port && (flags & SIGAR_NETCONN_CLIENT)) ||
+ (!conn.remote_port && (flags & SIGAR_NETCONN_SERVER))))
+ {
+ continue;
+ }
+
+ conn.type = type;
+
+ status = ip_format(conn.local_address,
+ sizeof(conn.local_address),
+ laddr);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ status = ip_format(conn.remote_address,
+ sizeof(conn.remote_address),
+ raddr);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ /* XXX state, rx/tx queue info would be useful */
+ ptr = sigar_skip_multiple_token(ptr, 4);
+ conn.uid = sigar_strtoul(ptr);
+
+ ptr = sigar_skip_token(ptr);
+
+ conn.inode = sigar_strtoul(ptr);
+
+ if (getter->connlist) {
+ SIGAR_NET_CONNLIST_GROW(getter->connlist);
+ memcpy(&getter->connlist->data[getter->connlist->number++],
+ &conn, sizeof(conn));
+ }
+ else {
+ if ((getter->port == conn.local_port) &&
+ (conn.remote_port == 0))
+ {
+ memcpy(getter->conn, &conn, sizeof(conn));
+ fclose(fp);
+ return CONN_GET_DONE;
+ }
+ }
+ }
+
+ fclose(fp);
+
+ return SIGAR_OK;
+}
+
+static int net_conn_get(sigar_t *sigar,
+ net_conn_getter_t *getter,
+ int flags)
+{
+ int status;
+
+ if (flags & SIGAR_NETCONN_TCP) {
+ status = proc_net_read(getter,
+ "/proc/net/tcp",
+ flags, SIGAR_NETCONN_TCP);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ status = proc_net_read(getter,
+ "/proc/net/tcp6",
+ flags, SIGAR_NETCONN_TCP);
+
+ if (!((status == SIGAR_OK) || (status == ENOENT))) {
+ return status;
+ }
+ }
+
+ if (flags & SIGAR_NETCONN_UDP) {
+ status = proc_net_read(getter,
+ "/proc/net/udp",
+ flags, SIGAR_NETCONN_UDP);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ status = proc_net_read(getter,
+ "/proc/net/udp6",
+ flags, SIGAR_NETCONN_UDP);
+
+ if (!((status == SIGAR_OK) || (status == ENOENT))) {
+ return status;
+ }
+ }
+
+ if (flags & SIGAR_NETCONN_RAW) {
+ status = proc_net_read(getter,
+ "/proc/net/raw",
+ flags, SIGAR_NETCONN_RAW);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ status = proc_net_read(getter,
+ "/proc/net/raw6",
+ flags, SIGAR_NETCONN_RAW);
+
+ if (!((status == SIGAR_OK) || (status == ENOENT))) {
+ return status;
+ }
+ }
+
+ /* XXX /proc/net/unix */
+
+ return SIGAR_OK;
+}
+
+int sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags)
+{
+ int status;
+ net_conn_getter_t getter;
+
+ sigar_net_connection_list_create(connlist);
+
+ getter.conn = NULL;
+ getter.connlist = connlist;
+
+ status = net_conn_get(sigar, &getter, flags);
+
+ if (status != SIGAR_OK) {
+ sigar_net_connection_list_destroy(sigar, connlist);
+ }
+
+ return status;
+}
+
+static int sigar_net_connection_get(sigar_t *sigar,
+ sigar_net_connection_t *netconn,
+ unsigned long port,
+ int flags)
+{
+ int status;
+ net_conn_getter_t getter;
+
+ getter.conn = netconn;
+ getter.connlist = NULL;
+ getter.port = port;
+
+ status = net_conn_get(sigar, &getter, flags);
+
+ if (status == CONN_GET_DONE) {
+ return SIGAR_OK;
+ }
+
+ return status;
+}
+
+int sigar_proc_port_get(sigar_t *sigar, unsigned long port, sigar_pid_t *pid)
+{
+ int status;
+ sigar_net_connection_t netconn;
+ DIR *dirp;
+ struct dirent *ent, dbuf;
+
+ SIGAR_ZERO(&netconn);
+ *pid = 0;
+
+ status = sigar_net_connection_get(sigar, &netconn, port,
+ SIGAR_NETCONN_SERVER|
+ SIGAR_NETCONN_TCP|SIGAR_NETCONN_UDP);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ if (netconn.local_port != port) {
+ return SIGAR_OK; /* XXX or ENOENT? */
+ }
+
+ if (!(dirp = opendir("/proc"))) {
+ return errno;
+ }
+
+ while (readdir_r(dirp, &dbuf, &ent) == 0) {
+ DIR *fd_dirp;
+ struct dirent *fd_ent, fd_dbuf;
+ struct stat sb;
+ char fd_name[BUFSIZ], pid_name[BUFSIZ];
+ int len, slen;
+
+ if (ent == NULL) {
+ break;
+ }
+
+ if (!sigar_isdigit(*ent->d_name)) {
+ continue;
+ }
+
+ /* sprintf(pid_name, "/proc/%s", ent->d_name) */
+ memcpy(&pid_name[0], PROC_FS_ROOT, SSTRLEN(PROC_FS_ROOT));
+ len = SSTRLEN(PROC_FS_ROOT);
+ pid_name[len++] = '/';
+
+ slen = strlen(ent->d_name);
+ memcpy(&pid_name[len], ent->d_name, slen);
+ len += slen;
+ pid_name[len] = '\0';
+
+ if (stat(pid_name, &sb) < 0) {
+ continue;
+ }
+ if (sb.st_uid != netconn.uid) {
+ continue;
+ }
+
+ /* sprintf(fd_name, "%s/fd", pid_name) */
+ memcpy(&fd_name[0], pid_name, len);
+ memcpy(&fd_name[len], "/fd", 3);
+ fd_name[len+=3] = '\0';
+
+ if (!(fd_dirp = opendir(fd_name))) {
+ continue;
+ }
+
+ while (readdir_r(fd_dirp, &fd_dbuf, &fd_ent) == 0) {
+ char fd_ent_name[BUFSIZ];
+
+ if (fd_ent == NULL) {
+ break;
+ }
+
+ if (!sigar_isdigit(*fd_ent->d_name)) {
+ continue;
+ }
+
+ /* sprintf(fd_ent_name, "%s/%s", fd_name, fd_ent->d_name) */
+ slen = strlen(fd_ent->d_name);
+ memcpy(&fd_ent_name[0], fd_name, len);
+ fd_ent_name[len] = '/';
+ memcpy(&fd_ent_name[len+1], fd_ent->d_name, slen);
+ fd_ent_name[len+1+slen] = '\0';
+
+ if (stat(fd_ent_name, &sb) < 0) {
+ continue;
+ }
+
+ if (sb.st_ino == netconn.inode) {
+ closedir(fd_dirp);
+ closedir(dirp);
+ *pid = strtoul(ent->d_name, NULL, 10);
+ return SIGAR_OK;
+ }
+
+ }
+
+ closedir(fd_dirp);
+ }
+
+ closedir(dirp);
+
+ return SIGAR_OK;
+}
diff --git a/src/os/linux/sigar_os.h b/src/os/linux/sigar_os.h
new file mode 100644
index 00000000..c5ad9f23
--- /dev/null
+++ b/src/os/linux/sigar_os.h
@@ -0,0 +1,47 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+
+typedef struct {
+ sigar_pid_t pid;
+ time_t mtime;
+ sigar_uint64_t vsize;
+ sigar_uint64_t rss;
+ sigar_uint64_t ppid;
+ int tty;
+ int priority;
+ int nice;
+ sigar_uint64_t start_time;
+ sigar_uint64_t utime;
+ sigar_uint64_t stime;
+ char name[SIGAR_PROC_NAME_LEN];
+ char state;
+} linux_proc_stat_t;
+
+struct sigar_t {
+ SIGAR_T_BASE;
+ int ram;
+ int proc_signal_offset;
+ linux_proc_stat_t last_proc_stat;
+};
+
+#define HAVE_STRERROR_R
+#define HAVE_STRERROR_R_GLIBC
+#define HAVE_READDIR_R
+#define HAVE_GETPWNAM_R
+#define HAVE_GETPWUID_R
+#define HAVE_GETGRGID_R
+
+#endif /* SIGAR_OS_H */
diff --git a/src/os/solaris/hmekstat.h b/src/os/solaris/hmekstat.h
new file mode 100644
index 00000000..a3872b32
--- /dev/null
+++ b/src/os/solaris/hmekstat.h
@@ -0,0 +1,77 @@
+/*
+ * from sys/hme.h, private to _KERNEL.
+ * we should be ok provided ksp->ks_data_size == sizeof(struct hmekstat)
+ * else will need to fallback to using kstat_data_lookup.
+ */
+
+struct hmekstat {
+ struct kstat_named hk_ipackets; /* packets received */
+ struct kstat_named hk_ierrors; /* input errors */
+ struct kstat_named hk_opackets; /* packets transmitted */
+ struct kstat_named hk_oerrors; /* output errors */
+ struct kstat_named hk_coll; /* collisions encountered */
+ struct kstat_named hk_defer; /* slots deferred */
+ struct kstat_named hk_fram; /* framing errors */
+ struct kstat_named hk_crc; /* crc errors */
+ struct kstat_named hk_sqerr; /* SQE test errors */
+ struct kstat_named hk_cvc; /* code violation errors */
+ struct kstat_named hk_lenerr; /* rx len errors */
+ struct kstat_named hk_ifspeed; /* interface speed */
+ struct kstat_named hk_buff; /* buff errors */
+ struct kstat_named hk_oflo; /* overflow errors */
+ struct kstat_named hk_uflo; /* underflow errors */
+ struct kstat_named hk_missed; /* missed/dropped packets */
+ struct kstat_named hk_tlcol; /* late collisions */
+ struct kstat_named hk_trtry; /* retry errors */
+ struct kstat_named hk_fstcol; /* first collisions */
+ struct kstat_named hk_tnocar; /* no carrier */
+ struct kstat_named hk_inits; /* initialization */
+ struct kstat_named hk_nocanput; /* nocanput errors */
+ struct kstat_named hk_allocbfail; /* allocb failures */
+ struct kstat_named hk_runt; /* runt errors */
+ struct kstat_named hk_jab; /* jabber errors */
+ struct kstat_named hk_babl; /* runt errors */
+ struct kstat_named hk_tmder; /* tmd errors */
+ struct kstat_named hk_txlaterr; /* tx late errors */
+ struct kstat_named hk_rxlaterr; /* rx late errors */
+ struct kstat_named hk_slvparerr; /* slave parity errors */
+ struct kstat_named hk_txparerr; /* tx parity errors */
+ struct kstat_named hk_rxparerr; /* rx parity errors */
+ struct kstat_named hk_slverrack; /* slave error acks */
+ struct kstat_named hk_txerrack; /* tx error acks */
+ struct kstat_named hk_rxerrack; /* rx error acks */
+ struct kstat_named hk_txtagerr; /* tx tag error */
+ struct kstat_named hk_rxtagerr; /* rx tag error */
+ struct kstat_named hk_eoperr; /* eop error */
+ struct kstat_named hk_notmds; /* tmd errors */
+ struct kstat_named hk_notbufs; /* tx buf errors */
+ struct kstat_named hk_norbufs; /* rx buf errors */
+ struct kstat_named hk_clsn; /* clsn errors */
+
+ /*
+ * required by kstat for MIB II objects(RFC 1213)
+ */
+ struct kstat_named hk_rcvbytes; /* # octets received */
+ /* MIB - ifInOctets */
+ struct kstat_named hk_xmtbytes; /* # octets transmitted */
+ /* MIB - ifOutOctets */
+ struct kstat_named hk_multircv; /* # multicast packets */
+ /* delivered to upper layer */
+ /* MIB - ifInNUcastPkts */
+ struct kstat_named hk_multixmt; /* # multicast packets */
+ /* requested to be sent */
+ /* MIB - ifOutNUcastPkts */
+ struct kstat_named hk_brdcstrcv; /* # broadcast packets */
+ /* delivered to upper layer */
+ /* MIB - ifInNUcastPkts */
+ struct kstat_named hk_brdcstxmt; /* # broadcast packets */
+ /* requested to be sent */
+ /* MIB - ifOutNUcastPkts */
+ struct kstat_named hk_norcvbuf; /* # rcv packets discarded */
+ /* MIB - ifInDiscards */
+ struct kstat_named hk_noxmtbuf; /* # xmt packets discarded */
+ /* MIB - ifOutDiscards */
+
+ struct kstat_named hk_phyfail; /* phy failures */
+ struct kstat_named hk_link_up; /* Link Status */
+};
diff --git a/src/os/solaris/kstats.c b/src/os/solaris/kstats.c
new file mode 100644
index 00000000..095265cb
--- /dev/null
+++ b/src/os/solaris/kstats.c
@@ -0,0 +1,255 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+
+int sigar_get_multi_kstats(sigar_t *sigar,
+ kstat_list_t *kl,
+ const char *name,
+ kstat_t **retval)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ int i = 0;
+ int dev;
+
+ name += kl->nlen; /* e.g. "hme0" + 3 */
+ dev = atoi(name);
+
+ if ((kl->num == 0) || (kstat_chain_update(kc) > 0)) {
+ while ((ksp = kstat_lookup(kc, kl->name, i, NULL))) {
+ if (i+1 > kl->num) {
+ kl->num = i+1;
+ kl->ks = realloc(kl->ks, kl->num);
+ }
+ kl->ks[i] = ksp;
+ i++;
+ }
+ }
+
+ if (dev >= kl->num) {
+ return ENXIO;
+ }
+
+ *retval = kl->ks[dev];
+
+ return SIGAR_OK;
+}
+
+int sigar_get_kstats(sigar_t *sigar)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ unsigned int i, ncpu = sysconf(_SC_NPROCESSORS_CONF);
+
+ ksp = kstat_lookup(kc, "unix", -1, "vminfo");
+ sigar->ks.vminfo = ksp;
+
+ if (ksp) {
+ kstat_read(kc, ksp, &sigar->vminfo);
+
+ if (!sigar->vminfo_snaptime) {
+ sigar->vminfo_snaptime = ksp->ks_snaptime;
+ }
+ }
+
+ if (ncpu != sigar->ncpu) {
+ if (!sigar->ks.lcpu) {
+ /* init */
+ sigar->ks.lcpu = ncpu;
+ sigar->ks.cpu = malloc(sizeof(*(sigar->ks.cpu)) * ncpu);
+ sigar->ks.cpuid = malloc(sizeof(*(sigar->ks.cpuid)) * ncpu);
+ }
+ else {
+ if (ncpu > sigar->ks.lcpu) {
+ /* one or more cpus have been added */
+ sigar->ks.cpu = realloc(sigar->ks.cpu,
+ sizeof(*(sigar->ks.cpu)) * ncpu);
+ sigar->ks.cpuid = realloc(sigar->ks.cpuid,
+ sizeof(*(sigar->ks.cpuid)) * ncpu);
+ sigar->ks.lcpu = ncpu;
+ }
+ /* else or more cpus have been removed */
+ }
+
+ sigar->ncpu = ncpu;
+
+ for (i=0, ksp=kc->kc_chain; iks_next) {
+ char *id;
+
+ if (!ksp) {
+ break;
+ }
+ if (strncmp(ksp->ks_name, "cpu_stat", 8)) {
+ continue;
+ }
+
+ /* from man p_online:
+ * ``Processor numbers are integers,
+ * greater than or equal to 0,
+ * and are defined by the hardware platform.
+ * Processor numbers are not necessarily contiguous,
+ * but "not too sparse."``
+ * so we maintain our own mapping in ks.cpuid[]
+ */
+ id = ksp->ks_name;
+ while (!sigar_isdigit(*id)) {
+ id++;
+ }
+
+ sigar->ks.cpu[i] = ksp;
+ sigar->ks.cpuid[i] = atoi(id);
+
+ i++;
+ }
+ }
+
+ sigar->ks.system = kstat_lookup(kc, "unix", -1, "system_misc");
+ sigar->ks.syspages = kstat_lookup(kc, "unix", -1, "system_pages");
+ sigar->ks.mempages = kstat_lookup(kc, "bunyip", -1, "mempages");
+
+ return SIGAR_OK;
+}
+
+/*
+ * bincompat is not possible with certain kstat data structures between
+ * solaris 2.6, 2.7, 2.8, etc. alternative is to use kstat_data_lookup()
+ * which means everytime we want a stat, must do a linear search
+ * of ksp->ks_data. eek. so we meet half way and do the search for
+ * each key once per sigar_t instance. once the initial search has
+ * been done, we have a table of offsets to quickly access the stats via
+ * ksp->ks_data + offset. this gives us bincompat without the overhead
+ * of many kstat_data_lookup calls.
+ */
+static SIGAR_INLINE int kstat_named_offset(kstat_t *ksp, const char *name)
+{
+ unsigned int i;
+ kstat_named_t *kn;
+
+ for (i=0, kn=ksp->ks_data;
+ iks_ndata;
+ i++, kn++)
+ {
+ if (strEQ(kn->name, name)) {
+ return i;
+ }
+ }
+
+ return -2; /* not found */
+}
+
+static char *kstat_keys_lo[] = {
+ "ipackets", /* RX_PACKETS */
+ "opackets", /* TX_PACKETS */
+ NULL
+};
+
+static char *kstat_keys_hme[] = {
+ "ipackets", /* RX_PACKETS */
+ "rbytes", /* RX_BYTES */
+ "ierrors", /* RX_ERRORS */
+ "missed", /* RX_DROPPED */
+ "oflo", /* RX_OVERRUNS */
+ "framing", /* RX_FRAME */
+ "opackets", /* TX_PACKETS */
+ "obytes", /* TX_BYTES */
+ "oerrors", /* TX_ERRORS */
+ "missed", /* TX_DROPPED */
+ "oflo", /* TX_OVERRUNS */
+ "collisions", /* TX_COLLISIONS */
+ "nocarrier", /* TX_CARRIER */
+ NULL
+};
+
+static char *kstat_keys_dmfe[] = {
+ "ipackets", /* RX_PACKETS */
+ "rbytes", /* RX_BYTES */
+ "ierrors", /* RX_ERRORS */
+ "missed", /* RX_DROPPED */
+ "oflo", /* RX_OVERRUNS */
+ "framing", /* RX_FRAME */
+ "opackets", /* TX_PACKETS */
+ "obytes", /* TX_BYTES */
+ "oerrors", /* TX_ERRORS */
+ "missed", /* TX_DROPPED */
+ "oflo", /* TX_OVERRUNS */
+ "collisions", /* TX_COLLISIONS */
+ "nocarrier", /* TX_CARRIER */
+ NULL
+};
+
+static char *kstat_keys_ge[] = {
+ "ipackets", /* RX_PACKETS */
+ "rbytes", /* RX_BYTES */
+ "ierrors", /* RX_ERRORS */
+ "drop", /* RX_DROPPED */
+ "toolong_errors", /* RX_OVERRUNS */
+ "framing", /* RX_FRAME */
+ "opackets", /* TX_PACKETS */
+ "obytes", /* TX_BYTES */
+ "oerrors", /* TX_ERRORS */
+ "drop", /* TX_DROPPED */
+ "toolong_errors", /* TX_OVERRUNS */
+ "collisions", /* TX_COLLISIONS */
+ "nocarrier", /* TX_CARRIER */
+ NULL
+};
+
+static char *kstat_keys_eri[] = {
+ "ipackets", /* RX_PACKETS */
+ "rbytes", /* RX_BYTES */
+ "ierrors", /* RX_ERRORS */
+ "drop", /* RX_DROPPED */
+ "rx_overflow", /* RX_OVERRUNS */
+ "parity_error", /* RX_FRAME */
+ "opackets", /* TX_PACKETS */
+ "obytes", /* TX_BYTES */
+ "oerrors", /* TX_ERRORS */
+ "drop", /* TX_DROPPED */
+ "rx_overflow", /* TX_OVERRUNS */
+ "collisions", /* TX_COLLISIONS */
+ "nocarrier", /* TX_CARRIER */
+ NULL
+};
+
+static char *kstat_keys_system[] = {
+ "boot_time",
+ "avenrun_1min",
+ "avenrun_5min",
+ "avenrun_15min",
+ NULL
+};
+
+static char *kstat_keys_mempages[] = {
+ "pages_anon",
+ "pages_exec",
+ "pages_vnode",
+ NULL
+};
+
+static char *kstat_keys_syspages[] = {
+ "pagesfree",
+ NULL
+};
+
+static char **kstat_keys[] = {
+ kstat_keys_lo,
+ kstat_keys_hme,
+ kstat_keys_dmfe,
+ kstat_keys_ge,
+ kstat_keys_eri,
+ kstat_keys_system,
+ kstat_keys_mempages,
+ kstat_keys_syspages,
+};
+
+void sigar_koffsets_lookup(kstat_t *ksp, int *offsets, int kidx)
+{
+ int i;
+ char **keys = kstat_keys[kidx];
+
+ for (i=0; keys[i]; i++) {
+ offsets[i] = kstat_named_offset(ksp, keys[i]);
+ }
+}
+
diff --git a/src/os/solaris/procfs.c b/src/os/solaris/procfs.c
new file mode 100644
index 00000000..85ca248e
--- /dev/null
+++ b/src/os/solaris/procfs.c
@@ -0,0 +1,101 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+
+#define my_pread(fd, ptr, type, offset) \
+ (pread(fd, ptr, sizeof(type), offset) == sizeof(type))
+
+int sigar_proc_psinfo_get(sigar_t *sigar, sigar_pid_t pid)
+{
+ int fd, retval = SIGAR_OK;
+ char buffer[BUFSIZ];
+ time_t timenow = time(NULL);
+
+ if (sigar->pinfo == NULL) {
+ sigar->pinfo = malloc(sizeof(*sigar->pinfo));
+ }
+
+ if (sigar->last_pid == pid) {
+ if ((timenow - sigar->last_getprocs) < SIGAR_LAST_PROC_EXPIRE) {
+ return SIGAR_OK;
+ }
+ }
+
+ sigar->last_pid = pid;
+ sigar->last_getprocs = timenow;
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/psinfo");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ return ESRCH;
+ }
+
+ if (!my_pread(fd, sigar->pinfo, psinfo_t, 0)) {
+ retval = errno;
+ }
+
+ close(fd);
+
+ return retval;
+}
+
+int sigar_proc_usage_get(sigar_t *sigar, prusage_t *prusage, sigar_pid_t pid)
+{
+ int fd, retval = SIGAR_OK;
+ char buffer[BUFSIZ];
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/usage");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ return ESRCH;
+ }
+
+ if (!my_pread(fd, prusage, prusage_t, 0)) {
+ retval = errno;
+ }
+
+ close(fd);
+
+ return retval;
+}
+
+int sigar_get_cred_get(sigar_t *sigar, prcred_t *prcred, sigar_pid_t pid)
+{
+ int fd, retval = SIGAR_OK;
+ char buffer[BUFSIZ];
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/cred");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ return ESRCH;
+ }
+
+ if (!my_pread(fd, prcred, prcred_t, 0)) {
+ retval = errno;
+ }
+
+ close(fd);
+
+ return retval;
+}
+
+int sigar_get_proc_status(sigar_t *sigar, pstatus_t *pstatus, sigar_pid_t pid)
+{
+ int fd, retval = SIGAR_OK;
+ char buffer[BUFSIZ];
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/status");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ return ESRCH;
+ }
+
+ if (!my_pread(fd, pstatus, pstatus_t, 0)) {
+ retval = errno;
+ }
+
+ close(fd);
+
+ return retval;
+}
diff --git a/src/os/solaris/sigar_os.h b/src/os/solaris/sigar_os.h
new file mode 100644
index 00000000..08b6a3d5
--- /dev/null
+++ b/src/os/solaris/sigar_os.h
@@ -0,0 +1,249 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+typedef unsigned long long int u_int64_t;
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+/* avoid -Wall warning since solaris doesnt have a prototype for this */
+int getdomainname(char *, int);
+
+typedef struct {
+ kstat_t **ks;
+ int num;
+ char *name;
+ int nlen;
+} kstat_list_t;
+
+int sigar_get_kstats(sigar_t *sigar);
+
+int sigar_get_multi_kstats(sigar_t *sigar,
+ kstat_list_t *kl,
+ const char *name,
+ kstat_t **retval);
+
+void sigar_koffsets_lookup(kstat_t *ksp, int *offsets, int kidx);
+
+int sigar_proc_psinfo_get(sigar_t *sigar, sigar_pid_t pid);
+
+int sigar_proc_usage_get(sigar_t *sigar, prusage_t *prusage, sigar_pid_t pid);
+
+int sigar_get_cred_get(sigar_t *sigar, prcred_t *prcred, sigar_pid_t pid);
+
+int sigar_get_proc_status(sigar_t *sigar, pstatus_t *pstatus, sigar_pid_t pid);
+
+#define CPU_ONLINE(n) \
+ (p_online(n, P_STATUS) == P_ONLINE)
+
+/* loopback interface only has these two metrics */
+typedef enum {
+ KSTAT_LO_RX_PACKETS,
+ KSTAT_LO_TX_PACKETS,
+ KSTAT_LO_MAX
+} kstat_lo_off_e;
+
+/* hme, ge and dmfe network devices provide
+ * the same metrics, but in some cases with
+ * different names and in all cases, the
+ * offsets are different.
+ */
+typedef enum {
+ KSTAT_HME_RX_PACKETS,
+ KSTAT_HME_RX_BYTES,
+ KSTAT_HME_RX_ERRORS,
+ KSTAT_HME_RX_DROPPED,
+ KSTAT_HME_RX_OVERRUNS,
+ KSTAT_HME_RX_FRAME,
+ KSTAT_HME_TX_PACKETS,
+ KSTAT_HME_TX_BYTES,
+ KSTAT_HME_TX_ERRORS,
+ KSTAT_HME_TX_DROPPED,
+ KSTAT_HME_TX_OVERRUNS,
+ KSTAT_HME_TX_COLLISIONS,
+ KSTAT_HME_TX_CARRIER,
+ KSTAT_HME_MAX
+} kstat_hme_off_e;
+
+typedef enum {
+ KSTAT_DMFE_RX_PACKETS,
+ KSTAT_DMFE_RX_BYTES,
+ KSTAT_DMFE_RX_ERRORS,
+ KSTAT_DMFE_RX_DROPPED,
+ KSTAT_DMFE_RX_OVERRUNS,
+ KSTAT_DMFE_RX_FRAME,
+ KSTAT_DMFE_TX_PACKETS,
+ KSTAT_DMFE_TX_BYTES,
+ KSTAT_DMFE_TX_ERRORS,
+ KSTAT_DMFE_TX_DROPPED,
+ KSTAT_DMFE_TX_OVERRUNS,
+ KSTAT_DMFE_TX_COLLISIONS,
+ KSTAT_DMFE_TX_CARRIER,
+ KSTAT_DMFE_MAX
+} kstat_dmfe_off_e;
+
+typedef enum {
+ KSTAT_GE_RX_PACKETS,
+ KSTAT_GE_RX_BYTES,
+ KSTAT_GE_RX_ERRORS,
+ KSTAT_GE_RX_DROPPED,
+ KSTAT_GE_RX_OVERRUNS,
+ KSTAT_GE_RX_FRAME,
+ KSTAT_GE_TX_PACKETS,
+ KSTAT_GE_TX_BYTES,
+ KSTAT_GE_TX_ERRORS,
+ KSTAT_GE_TX_DROPPED,
+ KSTAT_GE_TX_OVERRUNS,
+ KSTAT_GE_TX_COLLISIONS,
+ KSTAT_GE_TX_CARRIER,
+ KSTAT_GE_MAX
+} kstat_ge_off_e;
+
+typedef enum {
+ KSTAT_ERI_RX_PACKETS,
+ KSTAT_ERI_RX_BYTES,
+ KSTAT_ERI_RX_ERRORS,
+ KSTAT_ERI_RX_DROPPED,
+ KSTAT_ERI_RX_OVERRUNS,
+ KSTAT_ERI_RX_FRAME,
+ KSTAT_ERI_TX_PACKETS,
+ KSTAT_ERI_TX_BYTES,
+ KSTAT_ERI_TX_ERRORS,
+ KSTAT_ERI_TX_DROPPED,
+ KSTAT_ERI_TX_OVERRUNS,
+ KSTAT_ERI_TX_COLLISIONS,
+ KSTAT_ERI_TX_CARRIER,
+ KSTAT_ERI_MAX
+} kstat_eri_off_e;
+
+typedef enum {
+ KSTAT_SYSTEM_BOOT_TIME,
+ KSTAT_SYSTEM_LOADAVG_1,
+ KSTAT_SYSTEM_LOADAVG_2,
+ KSTAT_SYSTEM_LOADAVG_3,
+ KSTAT_SYSTEM_MAX
+} kstat_system_off_e;
+
+typedef enum {
+ KSTAT_MEMPAGES_ANON,
+ KSTAT_MEMPAGES_EXEC,
+ KSTAT_MEMPAGES_VNODE,
+ KSTAT_MEMPAGES_MAX
+} kstat_mempages_off_e;
+
+typedef enum {
+ KSTAT_SYSPAGES_FREE,
+ KSTAT_SYSPAGES_MAX
+} kstat_syspages_off_e;
+
+enum {
+ KSTAT_KEYS_lo,
+ KSTAT_KEYS_hme,
+ KSTAT_KEYS_dmfe,
+ KSTAT_KEYS_ge,
+ KSTAT_KEYS_eri,
+ KSTAT_KEYS_system,
+ KSTAT_KEYS_mempages,
+ KSTAT_KEYS_syspages,
+} kstat_keys_e;
+
+struct sigar_t {
+ SIGAR_T_BASE;
+
+ kstat_ctl_t *kc;
+
+ /* kstat_lookup() as needed */
+ struct {
+ kstat_t *vminfo;
+ kstat_t **cpu;
+ processorid_t *cpuid;
+ unsigned int lcpu; /* number malloced slots in the cpu array above */
+ kstat_t *system;
+ kstat_t *syspages;
+ kstat_t *mempages;
+ kstat_list_t hme;
+ kstat_list_t dmfe;
+ kstat_list_t ge;
+ kstat_list_t eri;
+ kstat_list_t lo;
+ } ks;
+
+ struct {
+ int lo[KSTAT_LO_MAX];
+ int hme[KSTAT_HME_MAX];
+ int dmfe[KSTAT_DMFE_MAX];
+ int ge[KSTAT_GE_MAX];
+ int eri[KSTAT_ERI_MAX];
+ int system[KSTAT_SYSTEM_MAX];
+ int mempages[KSTAT_MEMPAGES_MAX];
+ int syspages[KSTAT_SYSPAGES_MAX];
+ } koffsets;
+
+ vminfo_t vminfo;
+ hrtime_t vminfo_snaptime;
+
+ int pagesize;
+
+ time_t last_getprocs;
+ sigar_pid_t last_pid;
+ psinfo_t *pinfo;
+ sigar_cpu_list_t cpulist;
+};
+
+#define kSTAT_uint(v, type) \
+ ((sigar->koffsets.type[v] == -2) ? 0 : \
+ ((kstat_named_t *)ksp->ks_data + sigar->koffsets.type[v])->value.ui32)
+
+#define kSYSTEM(v) kSTAT_uint(v, system)
+
+#define kMEMPAGES(v) kSTAT_uint(v, mempages)
+
+#define kSYSPAGES(v) kSTAT_uint(v, syspages)
+
+#define sigar_koffsets_init(sigar, ksp, type) \
+ if (sigar->koffsets.type[0] == -1) \
+ sigar_koffsets_lookup(ksp, sigar->koffsets.type, KSTAT_KEYS_##type)
+
+#define sigar_koffsets_init_lo(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, lo)
+
+#define sigar_koffsets_init_hme(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, hme)
+
+#define sigar_koffsets_init_dmfe(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, dmfe)
+
+#define sigar_koffsets_init_ge(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, ge)
+
+#define sigar_koffsets_init_eri(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, eri)
+
+#define sigar_koffsets_init_system(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, system)
+
+#define sigar_koffsets_init_mempages(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, mempages)
+
+#define sigar_koffsets_init_syspages(sigar, ksp) \
+ sigar_koffsets_init(sigar, ksp, syspages)
+
+#define HAVE_READDIR_R
+#define HAVE_GETPWNAM_R
+#define HAVE_GETPWUID_R
+
+#endif /* SIGAR_OS_H */
+
diff --git a/src/os/solaris/solaris_sigar.c b/src/os/solaris/solaris_sigar.c
new file mode 100644
index 00000000..5bd58295
--- /dev/null
+++ b/src/os/solaris/solaris_sigar.c
@@ -0,0 +1,1110 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+
+#include
+#include
+
+#define KSTAT_LIST_INIT(sigar, dev) \
+ sigar->koffsets.dev[0] = -1; \
+ sigar->ks.dev.num = 0; \
+ sigar->ks.dev.ks = NULL; \
+ sigar->ks.dev.name = #dev; \
+ sigar->ks.dev.nlen = strlen(#dev)
+
+int sigar_os_open(sigar_t **sig)
+{
+ kstat_ctl_t *kc;
+ kstat_t *ksp;
+ sigar_t *sigar;
+ int i, status;
+
+ sigar = malloc(sizeof(*sigar));
+ *sig = sigar;
+
+ sigar->pagesize = 0;
+ i = sysconf(_SC_PAGESIZE);
+ while ((i >>= 1) > 0) {
+ sigar->pagesize++;
+ }
+
+ sigar->ticks = sysconf(_SC_CLK_TCK);
+ sigar->kc = kc = kstat_open();
+
+ if (!kc) {
+ return errno;
+ }
+
+ sigar->ncpu = 0;
+ sigar->ks.cpu = NULL;
+ sigar->ks.cpuid = NULL;
+ sigar->ks.lcpu = 0;
+
+ KSTAT_LIST_INIT(sigar, lo);
+ KSTAT_LIST_INIT(sigar, hme);
+ KSTAT_LIST_INIT(sigar, dmfe);
+ KSTAT_LIST_INIT(sigar, ge);
+ KSTAT_LIST_INIT(sigar, eri);
+
+ sigar->vminfo_snaptime = 0;
+
+ sigar->koffsets.system[0] = -1;
+ sigar->koffsets.mempages[0] = -1;
+ sigar->koffsets.syspages[0] = -1;
+
+ if ((status = sigar_get_kstats(sigar)) != SIGAR_OK) {
+ fprintf(stderr, "status=%d\n", status);
+ }
+
+ sigar->boot_time = 0;
+
+ if ((ksp = sigar->ks.system) &&
+ (kstat_read(kc, ksp, NULL) >= 0))
+ {
+ sigar_koffsets_init_system(sigar, ksp);
+
+ sigar->boot_time = kSYSTEM(KSTAT_SYSTEM_BOOT_TIME);
+ }
+
+ sigar->last_pid = -1;
+ sigar->pinfo = NULL;
+
+ return SIGAR_OK;
+}
+
+int sigar_os_close(sigar_t *sigar)
+{
+ kstat_close(sigar->kc);
+
+ if (sigar->ks.lo.num) {
+ free(sigar->ks.lo.ks);
+ }
+ if (sigar->ks.hme.num) {
+ free(sigar->ks.hme.ks);
+ }
+ if (sigar->ks.dmfe.num) {
+ free(sigar->ks.dmfe.ks);
+ }
+ if (sigar->ks.ge.num) {
+ free(sigar->ks.ge.ks);
+ }
+ if (sigar->ks.eri.num) {
+ free(sigar->ks.eri.ks);
+ }
+ if (sigar->ks.lcpu) {
+ free(sigar->ks.cpu);
+ free(sigar->ks.cpuid);
+ }
+ if (sigar->pinfo) {
+ free(sigar->pinfo);
+ }
+ free(sigar);
+ return SIGAR_OK;
+}
+
+char *sigar_os_error_string(int err)
+{
+ return NULL;
+}
+
+static SIGAR_INLINE int sigar_kstat_update(sigar_t *sigar)
+{
+ switch (kstat_chain_update(sigar->kc)) {
+ case 0:
+ break;
+ case -1:
+ return -1; /* shouldn't happen */
+ default:
+ sigar_get_kstats(sigar);
+ }
+
+ return SIGAR_OK;
+}
+
+#define KPAGE_SHIFT(v) \
+ ((v) << sigar->pagesize)
+
+int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+
+ SIGAR_ZERO(mem);
+
+ /* XXX: is mem hot swappable or can we just do this during open ? */
+ mem->total = KPAGE_SHIFT((sigar_uint64_t)sysconf(_SC_PHYS_PAGES));
+
+ sigar_mem_calc_ram(sigar, mem);
+
+ sigar_kstat_update(sigar);
+
+ if ((ksp = sigar->ks.syspages) && kstat_read(kc, ksp, NULL) >= 0) {
+ sigar_koffsets_init_syspages(sigar, ksp);
+
+ mem->free = KPAGE_SHIFT(kSYSPAGES(KSTAT_SYSPAGES_FREE));
+
+ mem->used = mem->total - mem->free;
+ }
+
+ if ((ksp = sigar->ks.mempages) && kstat_read(kc, ksp, NULL) >= 0) {
+ sigar_koffsets_init_mempages(sigar, ksp);
+
+ mem->shared = KPAGE_SHIFT(kMEMPAGES(KSTAT_MEMPAGES_EXEC));
+
+ mem->buffer = KPAGE_SHIFT(kMEMPAGES(KSTAT_MEMPAGES_VNODE));
+
+ mem->cached = -1; /*XXX*/
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+#if defined(SIGAR_SWAP_KSTAT)
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ vminfo_t vminfo;
+
+ sigar_kstat_update(sigar);
+
+ if ((ksp = sigar->ks.vminfo) && kstat_read(kc, ksp, &vminfo) >= 0) {
+ /* XXX: need some adjustments here */
+ swap->total = vminfo.swap_resv + vminfo.swap_avail;
+ swap->used = vminfo.swap_alloc;
+ swap->free = swap->total - swap->used;
+ return SIGAR_OK;
+ }
+
+ return -1;
+#elif defined(SIGAR_SWAP_SC_LIST)
+ unsigned int i;
+ size_t num;
+ swaptbl_t *stab;
+ char path[256];
+
+ swap->total = swap->used = swap->free = 0;
+
+ num = swapctl(SC_GETNSWP, 0);
+
+ switch (num) {
+ case 0:
+ return SIGAR_OK;
+ case -1:
+ return errno;
+ default:
+ break;
+ }
+
+ stab = malloc((num * sizeof(swapent_t)) + sizeof(swaptbl_t));
+
+ for (i=0; iswt_ent[i].ste_path = &path[0]; /* ignored */
+ }
+
+ stab->swt_n = num;
+ num = swapctl(SC_LIST, stab);
+
+ for (i=0; itotal += stab->swt_ent[i].ste_pages;
+ swap->free += stab->swt_ent[i].ste_free;
+ }
+
+ free(stab);
+
+ swap->total <<= sigar->pagesize;
+ swap->free <<= sigar->pagesize;
+ swap->used = swap->total - swap->free;
+
+ return SIGAR_OK;
+#else
+ struct anoninfo anon;
+
+ /* XXX vm/anon.h says:
+ * "The swap data can be aquired more efficiently through the
+ * kstats interface."
+ * but cannot find anything that explains howto convert those numbers.
+ */
+
+ if (swapctl(SC_AINFO, &anon) == -1) {
+ return errno;
+ }
+
+ swap->total = anon.ani_max;
+ swap->used = anon.ani_resv;
+ swap->free = anon.ani_max - anon.ani_resv;
+
+ swap->total <<= sigar->pagesize;
+ swap->free <<= sigar->pagesize;
+ swap->used <<= sigar->pagesize;
+
+ return SIGAR_OK;
+#endif
+}
+
+int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+ int status, i;
+
+ status = sigar_cpu_list_get(sigar, &sigar->cpulist);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ SIGAR_ZERO(cpu);
+
+ for (i=0; icpulist.number; i++) {
+ sigar_cpu_t *xcpu = &sigar->cpulist.data[i];
+
+ cpu->user += xcpu->user;
+ cpu->sys += xcpu->sys;
+ cpu->idle += xcpu->idle;
+ cpu->nice += xcpu->nice;
+ cpu->total += xcpu->total;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ ulong cpuinfo[CPU_STATES];
+ unsigned int i, n;
+ sigar_kstat_update(sigar);
+
+ if (cpulist != &sigar->cpulist) {
+ sigar_cpu_list_create(cpulist);
+ }
+
+ for (i=0; incpu; i++) {
+ sigar_cpu_t *cpu;
+ char *buf;
+
+ if (!CPU_ONLINE(sigar->ks.cpuid[i])) {
+ continue;
+ }
+ if (!((ksp = sigar->ks.cpu[i]) &&
+ (kstat_read(kc, ksp, NULL) >= 0)))
+ {
+ continue; /* XXX: shouldnot happen */
+ }
+
+ /*
+ * cpu_stat_t is not binary compatible between solaris versions.
+ * since cpu_stat is a 'raw' kstat and not 'named' we cannot
+ * use name based lookups as we do for others.
+ * the start of the cpu_stat_t structure is binary compatible,
+ * which looks like so:
+ * typedef struct cpu_stat {
+ * kmutex_t cpu_stat_lock;
+ * cpu_sysinfo_t cpu_sysinfo;
+ * ...
+ * typedef struct cpu_sysinfo {
+ * ulong cpu[CPU_STATES];
+ * ...
+ * we just copy the piece we need below:
+ */
+ buf = ksp->ks_data;
+ buf += sizeof(kmutex_t);
+ memcpy(&cpuinfo[0], buf, sizeof(cpuinfo));
+
+ SIGAR_CPU_LIST_GROW(cpulist);
+
+ cpu = &cpulist->data[cpulist->number++];
+
+ cpu->user = cpuinfo[CPU_USER];
+ cpu->sys = cpuinfo[CPU_KERNEL];
+ cpu->idle = cpuinfo[CPU_IDLE];
+ cpu->nice = 0; /* no cpu->nice */
+ cpu->total = 0;
+
+ for (n=0; ntotal += cpuinfo[n];
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ uptime->idletime = 0; /*XXX*/
+
+ if (sigar->boot_time) {
+ uptime->uptime = time(NULL) - sigar->boot_time;
+ }
+ else {
+ uptime->uptime = 0; /* XXX: shouldn't happen */
+ }
+
+ return SIGAR_OK;
+}
+
+static int loadavg_keys[] = {
+ KSTAT_SYSTEM_LOADAVG_1,
+ KSTAT_SYSTEM_LOADAVG_2,
+ KSTAT_SYSTEM_LOADAVG_3
+};
+
+int sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ kstat_t *ksp;
+ int i;
+
+ sigar_kstat_update(sigar);
+
+ if (!(ksp = sigar->ks.system)) {
+ return -1;
+ }
+
+ if (kstat_read(sigar->kc, ksp, NULL) < 0) {
+ return -1;
+ }
+
+ sigar_koffsets_init_system(sigar, ksp);
+
+ for (i=0; i<3; i++) {
+ loadavg->loadavg[i] = (double)kSYSTEM(loadavg_keys[i]) / FSCALE;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+ return sigar_proc_list_procfs_get(sigar, proclist);
+}
+
+int sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ int status = sigar_proc_psinfo_get(sigar, pid);
+ psinfo_t *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ procmem->size = pinfo->pr_size << 10;
+ procmem->rss = pinfo->pr_rssize << 10;
+ procmem->resident = procmem->rss; /*XXX*/
+ procmem->vsize = procmem->size; /*XXX*/
+ procmem->share = 0; /*XXX*/
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ int status = sigar_proc_psinfo_get(sigar, pid);
+ psinfo_t *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ proccred->uid = pinfo->pr_uid;
+ proccred->gid = pinfo->pr_gid;
+ proccred->euid = pinfo->pr_euid;
+ proccred->egid = pinfo->pr_egid;
+
+ return SIGAR_OK;
+}
+
+#define PRTIME_2SIGAR(t) \
+ (t.tv_sec + t.tv_nsec / NANOSEC)
+
+int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ prusage_t usage;
+ int status;
+
+ if ((status = sigar_proc_usage_get(sigar, &usage, pid)) != SIGAR_OK) {
+ return status;
+ }
+
+ proctime->start_time = usage.pr_create.tv_sec + sigar->boot_time;
+ proctime->start_time *= 1000;
+
+ proctime->utime = PRTIME_2SIGAR(usage.pr_utime);
+ proctime->stime = PRTIME_2SIGAR(usage.pr_stime);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ int status = sigar_proc_psinfo_get(sigar, pid);
+ psinfo_t *pinfo = sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ SIGAR_SSTRCPY(procstate->name, pinfo->pr_fname);
+ procstate->ppid = pinfo->pr_ppid;
+ procstate->tty = pinfo->pr_ttydev;
+ procstate->priority = pinfo->pr_lwp.pr_pri;
+ procstate->nice = pinfo->pr_lwp.pr_nice - NZERO;
+
+ switch (pinfo->pr_lwp.pr_state) {
+ case SONPROC:
+ case SRUN:
+ procstate->state = 'R';
+ break;
+ case SZOMB:
+ procstate->state = 'Z';
+ break;
+ case SSLEEP:
+ procstate->state = 'S';
+ break;
+ case SSTOP:
+ procstate->state = 'T';
+ break;
+ case SIDL:
+ procstate->state = 'D';
+ break;
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ psinfo_t *pinfo;
+ int fd, status;
+ char buffer[BUFSIZ];
+ char *argvb[56];
+ char *arg, **argvp = argvb;
+
+ int n;
+ size_t nread = 0;
+ unsigned int argv_size;
+
+ if ((status = sigar_proc_psinfo_get(sigar, pid)) != SIGAR_OK) {
+ return status;
+ }
+ pinfo = sigar->pinfo;
+
+ argv_size = sizeof(*argvp) * pinfo->pr_argc;
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/as");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ return ESRCH;
+ }
+
+ if (argv_size > sizeof(argvb)) {
+ argvp = malloc(argv_size);
+ }
+
+ if ((nread = pread(fd, argvp, argv_size, pinfo->pr_argv)) <= 0) {
+ close(fd);
+ return errno;
+ }
+
+ procargs->number = 0;
+ procargs->size = pinfo->pr_argc;
+ procargs->data =
+ (char **)malloc(sizeof(*(procargs->data)) *
+ procargs->size);
+
+ arg = buffer;
+
+ for (n = 0; n < pinfo->pr_argc; n++) {
+ int alen;
+ char *arg;
+
+ if ((nread = pread(fd, buffer, sizeof(buffer), (off_t)argvp[n])) <= 0) {
+ close(fd);
+ return errno;
+ }
+
+ alen = strlen(buffer)+1;
+ arg = malloc(alen);
+ memcpy(arg, buffer, alen);
+
+ procargs->data[procargs->number++] = arg;
+ }
+
+ if (argvp != argvb) {
+ free(argvp);
+ }
+
+ close(fd);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ psinfo_t *pinfo;
+ int fd, status;
+ char buffer[BUFSIZ], *offsets[512];
+ size_t nread;
+ int n=0, max=sizeof(offsets)/sizeof(char *);
+
+ if ((status = sigar_proc_psinfo_get(sigar, pid)) != SIGAR_OK) {
+ return status;
+ }
+ pinfo = sigar->pinfo;
+
+ (void)SIGAR_PROC_FILENAME(buffer, pid, "/as");
+
+ if ((fd = open(buffer, O_RDONLY)) < 0) {
+ return ESRCH;
+ }
+
+ if ((nread = pread(fd, offsets, sizeof(offsets),
+ pinfo->pr_envp)) <= 0)
+ {
+ close(fd);
+ return errno;
+ }
+
+ while ((n < max) && offsets[n]) {
+ char *val;
+ int klen, vlen, status;
+ char key[128]; /* XXX is there a max key size? */
+
+ if ((nread = pread(fd, buffer, sizeof(buffer),
+ (off_t)offsets[n++])) <= 0)
+ {
+ close(fd);
+ return errno;
+ }
+
+ val = strchr(buffer, '=');
+
+ if (val == NULL) {
+ break; /*XXX*/
+ }
+
+ klen = val - buffer;
+ SIGAR_SSTRCPY(key, buffer);
+ key[klen] = '\0';
+ ++val;
+
+ vlen = strlen(val);
+
+ status = procenv->env_getter(procenv->data,
+ key, klen, val, vlen);
+
+ if (status != SIGAR_OK) {
+ /* not an error; just stop iterating */
+ break;
+ }
+ }
+
+ close(fd);
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ int status =
+ sigar_proc_fd_count(sigar, pid, &procfd->total);
+
+ return status;
+}
+
+int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+#include
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ char *type = fsp->sys_type_name;
+
+ switch (*type) {
+ case 'u':
+ if (strEQ(type, "ufs")) {
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ }
+ break;
+ /* XXX */
+ }
+
+ return fsp->type;
+}
+
+int sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ struct mnttab ent;
+ sigar_file_system_t *fsp;
+ FILE *fp = fopen(MNTTAB, "r");
+
+ if (!fp) {
+ return errno;
+ }
+
+ sigar_file_system_list_create(fslist);
+
+ while (getmntent(fp, &ent) == 0) {
+ SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
+
+ fsp = &fslist->data[fslist->number++];
+
+ SIGAR_SSTRCPY(fsp->dir_name, ent.mnt_mountp);
+ SIGAR_SSTRCPY(fsp->dev_name, ent.mnt_special);
+ SIGAR_SSTRCPY(fsp->sys_type_name, ent.mnt_fstype);
+ sigar_fs_type_init(fsp);
+ }
+
+ fclose(fp);
+
+ return SIGAR_OK;
+}
+
+#include
+
+#define SIGAR_FS_BLOCKS_TO_BYTES(buf, f) \
+ ((buf.f * (buf.f_frsize / 512)) >> 1)
+
+int sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ struct statvfs buf;
+
+ if (statvfs(dirname, &buf) != 0) {
+ return errno;
+ }
+
+ fsusage->total = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_blocks);
+ fsusage->free = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bfree);
+ fsusage->avail = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bavail);
+ fsusage->files = buf.f_files;
+ fsusage->free_files = buf.f_files;
+ fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ processor_info_t stats;
+ unsigned int i;
+ int status;
+
+ sigar_kstat_update(sigar); /* for sigar->ncpu */
+
+ /*
+ * stats we care about will be the same for each
+ * online processor, so just grab the first.
+ */
+ for (i=0; incpu; i++) {
+ processorid_t id = sigar->ks.cpuid[i];
+
+ if ((status = processor_info(id, &stats)) < 0) {
+ continue;
+ }
+ else {
+ status = SIGAR_OK;
+ break;
+ }
+ }
+
+ if (status != SIGAR_OK) {
+ /* should never happen */
+ return ENOENT;
+ }
+
+ sigar_cpu_infos_create(cpu_infos);
+
+ for (i=0; incpu; i++) {
+ sigar_cpu_info_t *info;
+
+ SIGAR_CPU_INFOS_GROW(cpu_infos);
+
+ info = &cpu_infos->data[cpu_infos->number++];
+
+ SIGAR_SSTRCPY(info->vendor, "Sun Microsystems"); /*XXX?*/
+ SIGAR_SSTRCPY(info->model, stats.pi_processor_type);
+ info->mhz = stats.pi_clock;
+ info->cache_size = -1; /*XXX*/
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+
+{
+ return SIGAR_ENOTIMPL;
+}
+
+#define kHME(v) kSTAT_uint(v, hme)
+
+static int sigar_net_ifstat_get_hme(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ int status;
+
+ status = sigar_get_multi_kstats(sigar, &sigar->ks.hme,
+ name, &ksp);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ kstat_read(kc, ksp, NULL);
+
+ sigar_koffsets_init_hme(sigar, ksp);
+
+ ifstat->rx_packets = kHME(KSTAT_HME_RX_PACKETS);
+ ifstat->rx_bytes = kHME(KSTAT_HME_RX_BYTES);
+ ifstat->rx_errors = kHME(KSTAT_HME_RX_ERRORS);
+ ifstat->rx_dropped = kHME(KSTAT_HME_RX_DROPPED); /*XXX*/
+ ifstat->rx_overruns = kHME(KSTAT_HME_RX_OVERRUNS); /*XXX*/
+ ifstat->rx_frame = kHME(KSTAT_HME_RX_FRAME);
+
+ ifstat->tx_packets = kHME(KSTAT_HME_TX_PACKETS);
+ ifstat->tx_bytes = kHME(KSTAT_HME_TX_BYTES);
+ ifstat->tx_errors = kHME(KSTAT_HME_TX_ERRORS);
+ ifstat->tx_dropped = kHME(KSTAT_HME_TX_DROPPED); /*XXX*/
+ ifstat->tx_overruns = kHME(KSTAT_HME_TX_OVERRUNS); /*XXX*/
+ ifstat->tx_collisions = kHME(KSTAT_HME_TX_COLLISIONS);
+ ifstat->tx_carrier = kHME(KSTAT_HME_TX_CARRIER);
+
+ return SIGAR_OK;
+}
+
+#define kDMFE(v) kSTAT_uint(v, dmfe)
+
+static int sigar_net_ifstat_get_dmfe(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ int status;
+
+ status = sigar_get_multi_kstats(sigar, &sigar->ks.dmfe,
+ name, &ksp);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ kstat_read(kc, ksp, NULL);
+
+ sigar_koffsets_init_dmfe(sigar, ksp);
+
+ ifstat->rx_packets = kDMFE(KSTAT_DMFE_RX_PACKETS);
+ ifstat->rx_bytes = kDMFE(KSTAT_DMFE_RX_BYTES);
+ ifstat->rx_errors = kDMFE(KSTAT_DMFE_RX_ERRORS);
+ ifstat->rx_dropped = kDMFE(KSTAT_DMFE_RX_DROPPED); /*XXX*/
+ ifstat->rx_overruns = kDMFE(KSTAT_DMFE_RX_OVERRUNS); /*XXX*/
+ ifstat->rx_frame = kDMFE(KSTAT_DMFE_RX_FRAME);
+
+ ifstat->tx_packets = kDMFE(KSTAT_DMFE_TX_PACKETS);
+ ifstat->tx_bytes = kDMFE(KSTAT_DMFE_TX_BYTES);
+ ifstat->tx_errors = kDMFE(KSTAT_DMFE_TX_ERRORS);
+ ifstat->tx_dropped = kDMFE(KSTAT_DMFE_TX_DROPPED); /*XXX*/
+ ifstat->tx_overruns = kDMFE(KSTAT_DMFE_TX_OVERRUNS); /*XXX*/
+ ifstat->tx_collisions = kDMFE(KSTAT_DMFE_TX_COLLISIONS);
+ ifstat->tx_carrier = kDMFE(KSTAT_DMFE_TX_CARRIER);
+
+ return SIGAR_OK;
+}
+
+#define kGE(v) kSTAT_uint(v, ge)
+
+static int sigar_net_ifstat_get_ge(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ int status;
+
+ status = sigar_get_multi_kstats(sigar, &sigar->ks.ge,
+ name, &ksp);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ kstat_read(kc, ksp, NULL);
+
+ sigar_koffsets_init_ge(sigar, ksp);
+
+ ifstat->rx_packets = kGE(KSTAT_GE_RX_PACKETS);
+ ifstat->rx_bytes = kGE(KSTAT_GE_RX_BYTES);
+ ifstat->rx_errors = kGE(KSTAT_GE_RX_ERRORS);
+ ifstat->rx_dropped = kGE(KSTAT_GE_RX_DROPPED); /*XXX*/
+ ifstat->rx_overruns = kGE(KSTAT_GE_RX_OVERRUNS); /*XXX*/
+ ifstat->rx_frame = kGE(KSTAT_GE_RX_FRAME);
+
+ ifstat->tx_packets = kGE(KSTAT_GE_TX_PACKETS);
+ ifstat->tx_bytes = kGE(KSTAT_GE_TX_BYTES);
+ ifstat->tx_errors = kGE(KSTAT_GE_TX_ERRORS);
+ ifstat->tx_dropped = kGE(KSTAT_GE_TX_DROPPED); /*XXX*/
+ ifstat->tx_overruns = kGE(KSTAT_GE_TX_OVERRUNS); /*XXX*/
+ ifstat->tx_collisions = kGE(KSTAT_GE_TX_COLLISIONS);
+ ifstat->tx_carrier = kGE(KSTAT_GE_TX_CARRIER);
+
+ return SIGAR_OK;
+}
+
+#define kERI(v) kSTAT_uint(v, eri)
+
+static int sigar_net_ifstat_get_eri(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ int status;
+
+ status = sigar_get_multi_kstats(sigar, &sigar->ks.eri,
+ name, &ksp);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ kstat_read(kc, ksp, NULL);
+
+ sigar_koffsets_init_eri(sigar, ksp);
+
+ ifstat->rx_packets = kERI(KSTAT_ERI_RX_PACKETS);
+ ifstat->rx_bytes = kERI(KSTAT_ERI_RX_BYTES);
+ ifstat->rx_errors = kERI(KSTAT_ERI_RX_ERRORS);
+ ifstat->rx_dropped = kERI(KSTAT_ERI_RX_DROPPED); /*XXX*/
+ ifstat->rx_overruns = kERI(KSTAT_ERI_RX_OVERRUNS); /*XXX*/
+ ifstat->rx_frame = kERI(KSTAT_ERI_RX_FRAME);
+
+ ifstat->tx_packets = kERI(KSTAT_ERI_TX_PACKETS);
+ ifstat->tx_bytes = kERI(KSTAT_ERI_TX_BYTES);
+ ifstat->tx_errors = kERI(KSTAT_ERI_TX_ERRORS);
+ ifstat->tx_dropped = kERI(KSTAT_ERI_TX_DROPPED); /*XXX*/
+ ifstat->tx_overruns = kERI(KSTAT_ERI_TX_OVERRUNS); /*XXX*/
+ ifstat->tx_collisions = kERI(KSTAT_ERI_TX_COLLISIONS);
+ ifstat->tx_carrier = kERI(KSTAT_ERI_TX_CARRIER);
+
+ return SIGAR_OK;
+}
+
+#define kLO(v) kSTAT_uint(v, lo)
+
+#define jLO aHO
+
+static int sigar_net_ifstat_get_lo(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ int status;
+
+ status = sigar_get_multi_kstats(sigar, &sigar->ks.lo,
+ name, &ksp);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ kstat_read(kc, ksp, NULL);
+
+ sigar_koffsets_init_lo(sigar, ksp);
+
+ ifstat->rx_packets = kLO(KSTAT_LO_RX_PACKETS);
+ ifstat->rx_bytes = -1;
+ ifstat->rx_errors = -1;
+ ifstat->rx_dropped = -1;
+ ifstat->rx_overruns = -1;
+ ifstat->rx_frame = -1;
+
+ ifstat->tx_packets = kLO(KSTAT_LO_TX_PACKETS);
+ ifstat->tx_bytes = -1;
+ ifstat->tx_errors = -1;
+ ifstat->tx_dropped = -1;
+ ifstat->tx_overruns = -1;
+ ifstat->tx_collisions = -1;
+ ifstat->tx_carrier = -1;
+
+ return SIGAR_OK;
+}
+
+static int sigar_net_ifstat_get_any(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ kstat_ctl_t *kc = sigar->kc;
+ kstat_t *ksp;
+ kstat_named_t *data;
+ char dev[64], *ptr=dev;
+ int num, i;
+
+ kstat_chain_update(kc);
+ strncpy(dev, name, sizeof(dev)-1);
+ dev[sizeof(dev)-1] = '\0';
+
+ while (!sigar_isdigit(*ptr) && (*ptr != '\0')) {
+ ptr++;
+ }
+
+ if (*ptr == '\0') {
+ return ENXIO;
+ }
+
+ /* iprb0 -> dev="iprb", num=0 */
+ num = atoi(ptr);
+ *ptr = '\0';
+
+ if (!(ksp = kstat_lookup(kc, dev, num, NULL))) {
+ return ENXIO;
+ }
+
+ if (kstat_read(kc, ksp, NULL) < 0) {
+ return ENOENT;
+ }
+
+ SIGAR_ZERO(ifstat);
+
+ data = (kstat_named_t *)ksp->ks_data;
+ for (i=0; iks_ndata; i++) {
+ sigar_uint64_t value = data[i].value.ui32;
+
+ ptr = data[i].name;
+
+ switch (*ptr) {
+ case 'c':
+ if (strEQ(ptr, "collisions")) {
+ ifstat->tx_collisions = value;
+ }
+ break;
+ case 'd':
+ if (strEQ(ptr, "drop")) {
+ ifstat->rx_dropped = value;
+ ifstat->tx_dropped = value;
+ }
+ break;
+ case 'i':
+ if (strEQ(ptr, "ipackets")) {
+ ifstat->rx_packets = value;
+ }
+ else if (strEQ(ptr, "ierrors")) {
+ ifstat->rx_errors = value;
+ }
+ break;
+ case 'f':
+ if (strEQ(ptr, "framing")) {
+ ifstat->rx_frame = value;
+ }
+ break;
+ case 'm':
+ if (strEQ(ptr, "missed")) {
+ ifstat->rx_dropped = value;
+ ifstat->tx_dropped = value;
+ }
+ break;
+ case 'n':
+ if (strEQ(ptr, "nocarrier")) {
+ ifstat->tx_carrier = value;
+ }
+ break;
+ case 'o':
+ if (strEQ(ptr, "obytes")) {
+ ifstat->tx_bytes = value;
+ }
+ else if (strEQ(ptr, "oerrors")) {
+ ifstat->tx_errors = value;
+ }
+ else if (strEQ(ptr, "oflo")) {
+ ifstat->tx_overruns = value;
+ }
+ else if (strEQ(ptr, "opackets")) {
+ ifstat->tx_packets = value;
+ }
+ else if (strEQ(ptr, "toolong_errors")) {
+ ifstat->tx_overruns = value;
+ }
+ break;
+ case 'r':
+ if (strEQ(ptr, "rbytes")) {
+ ifstat->rx_bytes = value;
+ }
+ else if (strEQ(ptr, "rx_overflow")) {
+ ifstat->rx_overruns = value;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ switch (*name) {
+ case 'd':
+ if (strnEQ(name, "dmfe", 4)) {
+ return sigar_net_ifstat_get_dmfe(sigar, name, ifstat);
+ }
+ break;
+ case 'e':
+ if (strnEQ(name, "eri", 3)) {
+ return sigar_net_ifstat_get_eri(sigar, name, ifstat);
+ }
+ break;
+ case 'g':
+ if (strnEQ(name, "ge", 2)) {
+ return sigar_net_ifstat_get_ge(sigar, name, ifstat);
+ }
+ break;
+ case 'h':
+ if (strnEQ(name, "hme", 3)) {
+ return sigar_net_ifstat_get_hme(sigar, name, ifstat);
+ }
+ break;
+ case 'l':
+ if (strnEQ(name, "lo", 2)) {
+ return sigar_net_ifstat_get_lo(sigar, name, ifstat);
+ }
+ break;
+ default:
+ return sigar_net_ifstat_get_any(sigar, name, ifstat);
+ }
+
+ return ENXIO;
+}
+
+int sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags)
+{
+ return SIGAR_ENOTIMPL;
+}
diff --git a/src/os/stub/sigar_os.h b/src/os/stub/sigar_os.h
new file mode 100644
index 00000000..068fc3c6
--- /dev/null
+++ b/src/os/stub/sigar_os.h
@@ -0,0 +1,8 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+struct sigar_t {
+ SIGAR_T_BASE;
+};
+
+#endif /* SIGAR_OS_H */
diff --git a/src/os/stub/stub_sigar.c b/src/os/stub/stub_sigar.c
new file mode 100644
index 00000000..f5ec0c83
--- /dev/null
+++ b/src/os/stub/stub_sigar.c
@@ -0,0 +1,248 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+
+int sigar_os_open(sigar_t **sigar)
+{
+ *sigar = malloc(sizeof(**sigar));
+
+ return SIGAR_OK;
+}
+
+int sigar_os_close(sigar_t *sigar)
+{
+ free(sigar);
+ return SIGAR_OK;
+}
+
+char *sigar_os_error_string(int err)
+{
+ return NULL;
+}
+
+int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+ mem->total = -1;
+ mem->ram = -1;
+ mem->used = -1;
+ mem->free = -1;
+ mem->shared = -1;
+ mem->buffer = -1;
+ mem->cached = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+ swap->total = -1;
+ swap->used = -1;
+ swap->free = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+ cpu->user = -1;
+ cpu->nice = -1;
+ cpu->sys = -1;
+ cpu->idle = -1;
+
+ cpu->total = cpu->user + cpu->nice + cpu->sys + cpu->idle;
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ uptime->uptime = -1;
+ uptime->idletime = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ loadavg->loadavg[0] = -1;
+ loadavg->loadavg[1] = -1;
+ loadavg->loadavg[2] = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ procmem->size = -1;
+ procmem->vsize = -1;
+ procmem->share = -1;
+ procmem->rss = -1;
+ procmem->resident = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ proccred->uid = -1;
+ proccred->gid = -1;
+ proccred->euid = -1;
+ proccred->egid = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ proctime->start_time = -1;
+ proctime->utime = -1;
+ proctime->stime = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ SIGAR_SSTRCPY(procstate->name, "java");
+ procstate->ppid = -1;
+ procstate->priority = -1;
+ procstate->nice = -1;
+ procstate->tty = -1;
+ procstate->state = 'R';
+
+ return SIGAR_OK;
+}
+
+int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ procfd->total = -1;
+ return SIGAR_OK;
+}
+
+int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ fsp->type = SIGAR_FSTYPE_UNKNOWN;
+
+ return SIGAR_OK;
+}
+
+int sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ sigar_file_system_list_create(fslist);
+
+ return SIGAR_OK;
+}
+
+int sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ fsusage->total = -1;
+ fsusage->free = -1;
+ fsusage->avail = -1;
+ fsusage->files = -1;
+ fsusage->free_files = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ sigar_cpu_info_t *info;
+
+ sigar_cpu_infos_create(cpu_infos);
+
+ info = &cpu_infos->data[cpu_infos->number++];
+
+ SIGAR_SSTRCPY(info->vendor, "vendor");
+ SIGAR_SSTRCPY(info->model, "model");
+ info->mhz = -1;
+ info->cache_size = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+{
+ sigar_net_route_t *route;
+
+ sigar_net_route_list_create(routelist);
+
+ return SIGAR_OK;
+}
+
+int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
+ sigar_net_interface_stat_t *ifstat)
+{
+ ifstat->rx_bytes = -1;
+ ifstat->rx_packets = -1;
+ ifstat->rx_errors = -1;
+ ifstat->rx_dropped = -1;
+ ifstat->rx_overruns = -1;
+ ifstat->rx_frame = -1;
+
+ ifstat->tx_bytes = -1;
+ ifstat->tx_packets = -1;
+ ifstat->tx_errors = -1;
+ ifstat->tx_dropped = -1;
+ ifstat->tx_overruns = -1;
+ ifstat->tx_collisions = -1;
+ ifstat->tx_carrier = -1;
+
+ return SIGAR_OK;
+}
+
+int sigar_net_connection_list_get(sigar_t *sigar,
+ sigar_net_connection_list_t *connlist,
+ int flags)
+{
+ return SIGAR_ENOTIMPL;
+}
diff --git a/src/os/win32/build-cpu.bat b/src/os/win32/build-cpu.bat
new file mode 100755
index 00000000..9f813e9e
--- /dev/null
+++ b/src/os/win32/build-cpu.bat
@@ -0,0 +1,2 @@
+@echo off
+cl -I..\..\..\include -I. -DWIN32 -DCPU_MAIN cpu.c /link ADVAPI32.LIB
diff --git a/src/os/win32/counter_names.txt b/src/os/win32/counter_names.txt
new file mode 100644
index 00000000..b125b043
--- /dev/null
+++ b/src/os/win32/counter_names.txt
@@ -0,0 +1,820 @@
+#counter names from registry key
+#SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib
+0 UNDEFINED
+1 1847
+2 System
+4 Memory
+6 % Processor Time
+10 File Read Operations/sec
+12 File Write Operations/sec
+14 File Control Operations/sec
+16 File Read Bytes/sec
+18 File Write Bytes/sec
+20 File Control Bytes/sec
+24 Available Bytes
+26 Committed Bytes
+28 Page Faults/sec
+30 Commit Limit
+32 Write Copies/sec
+34 Transition Faults/sec
+36 Cache Faults/sec
+38 Demand Zero Faults/sec
+40 Pages/sec
+42 Page Reads/sec
+44 Processor Queue Length
+46 Thread State
+48 Pages Output/sec
+50 Page Writes/sec
+52 Browser
+54 Announcements Server/sec
+56 Pool Paged Bytes
+58 Pool Nonpaged Bytes
+60 Pool Paged Allocs
+64 Pool Nonpaged Allocs
+66 Pool Paged Resident Bytes
+68 System Code Total Bytes
+70 System Code Resident Bytes
+72 System Driver Total Bytes
+74 System Driver Resident Bytes
+76 System Cache Resident Bytes
+78 Announcements Domain/sec
+80 Election Packets/sec
+82 Mailslot Writes/sec
+84 Server List Requests/sec
+86 Cache
+88 Data Maps/sec
+90 Sync Data Maps/sec
+92 Async Data Maps/sec
+94 Data Map Hits %
+96 Data Map Pins/sec
+98 Pin Reads/sec
+100 Sync Pin Reads/sec
+102 Async Pin Reads/sec
+104 Pin Read Hits %
+106 Copy Reads/sec
+108 Sync Copy Reads/sec
+110 Async Copy Reads/sec
+112 Copy Read Hits %
+114 MDL Reads/sec
+116 Sync MDL Reads/sec
+118 Async MDL Reads/sec
+120 MDL Read Hits %
+122 Read Aheads/sec
+124 Fast Reads/sec
+126 Sync Fast Reads/sec
+128 Async Fast Reads/sec
+130 Fast Read Resource Misses/sec
+132 Fast Read Not Possibles/sec
+134 Lazy Write Flushes/sec
+136 Lazy Write Pages/sec
+138 Data Flushes/sec
+140 Data Flush Pages/sec
+142 % User Time
+144 % Privileged Time
+146 Context Switches/sec
+148 Interrupts/sec
+150 System Calls/sec
+152 Level 1 TLB Fills/sec
+154 Level 2 TLB Fills/sec
+156 Enumerations Server/sec
+158 Enumerations Domain/sec
+160 Enumerations Other/sec
+162 Missed Server Announcements
+164 Missed Mailslot Datagrams
+166 Missed Server List Requests
+168 Server Announce Allocations Failed/sec
+170 Mailslot Allocations Failed
+172 Virtual Bytes Peak
+174 Virtual Bytes
+178 Working Set Peak
+180 Working Set
+182 Page File Bytes Peak
+184 Page File Bytes
+186 Private Bytes
+188 Announcements Total/sec
+190 Enumerations Total/sec
+198 Current Disk Queue Length
+200 % Disk Time
+202 % Disk Read Time
+204 % Disk Write Time
+206 Avg. Disk sec/Transfer
+208 Avg. Disk sec/Read
+210 Avg. Disk sec/Write
+212 Disk Transfers/sec
+214 Disk Reads/sec
+216 Disk Writes/sec
+218 Disk Bytes/sec
+220 Disk Read Bytes/sec
+222 Disk Write Bytes/sec
+224 Avg. Disk Bytes/Transfer
+226 Avg. Disk Bytes/Read
+228 Avg. Disk Bytes/Write
+230 Process
+232 Thread
+234 PhysicalDisk
+236 LogicalDisk
+238 Processor
+240 % Total Processor Time
+242 % Total User Time
+244 % Total Privileged Time
+246 Total Interrupts/sec
+248 Processes
+250 Threads
+252 Events
+254 Semaphores
+256 Mutexes
+258 Sections
+260 Objects
+262 Redirector
+264 Bytes Received/sec
+266 Packets Received/sec
+268 Read Bytes Paging/sec
+270 Read Bytes Non-Paging/sec
+272 Read Bytes Cache/sec
+274 Read Bytes Network/sec
+276 Bytes Transmitted/sec
+278 Packets Transmitted/sec
+280 Write Bytes Paging/sec
+282 Write Bytes Non-Paging/sec
+284 Write Bytes Cache/sec
+286 Write Bytes Network/sec
+288 Read Operations/sec
+290 Read Operations Random/sec
+292 Read Packets/sec
+294 Reads Large/sec
+296 Read Packets Small/sec
+298 Write Operations/sec
+300 Write Operations Random/sec
+302 Write Packets/sec
+304 Writes Large/sec
+306 Write Packets Small/sec
+308 Reads Denied/sec
+310 Writes Denied/sec
+312 Network Errors/sec
+314 Server Sessions
+316 Server Reconnects
+318 Connects Core
+320 Connects Lan Manager 2.0
+322 Connects Lan Manager 2.1
+324 Connects Windows NT
+326 Server Disconnects
+328 Server Sessions Hung
+330 Server
+336 Thread Wait Reason
+340 Sessions Timed Out
+342 Sessions Errored Out
+344 Sessions Logged Off
+346 Sessions Forced Off
+348 Errors Logon
+350 Errors Access Permissions
+352 Errors Granted Access
+354 Errors System
+356 Blocking Requests Rejected
+358 Work Item Shortages
+360 Files Opened Total
+362 Files Open
+366 File Directory Searches
+370 Pool Nonpaged Failures
+372 Pool Nonpaged Peak
+376 Pool Paged Failures
+378 Pool Paged Peak
+388 Bytes Total/sec
+392 Current Commands
+398 NWLink NetBIOS
+400 Packets/sec
+404 Context Blocks Queued/sec
+406 File Data Operations/sec
+408 % Free Space
+410 Free Megabytes
+412 Connections Open
+414 Connections No Retries
+416 Connections With Retries
+418 Disconnects Local
+420 Disconnects Remote
+422 Failures Link
+424 Failures Adapter
+426 Connection Session Timeouts
+428 Connections Canceled
+430 Failures Resource Remote
+432 Failures Resource Local
+434 Failures Not Found
+436 Failures No Listen
+438 Datagrams/sec
+440 Datagram Bytes/sec
+442 Datagrams Sent/sec
+444 Datagram Bytes Sent/sec
+446 Datagrams Received/sec
+448 Datagram Bytes Received/sec
+452 Packets Sent/sec
+456 Frames/sec
+458 Frame Bytes/sec
+460 Frames Sent/sec
+462 Frame Bytes Sent/sec
+464 Frames Received/sec
+466 Frame Bytes Received/sec
+468 Frames Re-Sent/sec
+470 Frame Bytes Re-Sent/sec
+472 Frames Rejected/sec
+474 Frame Bytes Rejected/sec
+476 Expirations Response
+478 Expirations Ack
+480 Window Send Maximum
+482 Window Send Average
+484 Piggyback Ack Queued/sec
+486 Piggyback Ack Timeouts
+488 NWLink IPX
+490 NWLink SPX
+492 NetBEUI
+494 NetBEUI Resource
+496 Used Maximum
+498 Used Average
+500 Times Exhausted
+502 NBT Connection
+506 Bytes Sent/sec
+508 Total Bytes/sec
+510 Network Interface
+512 Bytes/sec
+520 Current Bandwidth
+524 Packets Received Unicast/sec
+526 Packets Received Non-Unicast/sec
+528 Packets Received Discarded
+530 Packets Received Errors
+532 Packets Received Unknown
+536 Packets Sent Unicast/sec
+538 Packets Sent Non-Unicast/sec
+540 Packets Outbound Discarded
+542 Packets Outbound Errors
+544 Output Queue Length
+546 IP
+552 Datagrams Received Header Errors
+554 Datagrams Received Address Errors
+556 Datagrams Forwarded/sec
+558 Datagrams Received Unknown Protocol
+560 Datagrams Received Discarded
+562 Datagrams Received Delivered/sec
+566 Datagrams Outbound Discarded
+568 Datagrams Outbound No Route
+570 Fragments Received/sec
+572 Fragments Re-assembled/sec
+574 Fragment Re-assembly Failures
+576 Fragmented Datagrams/sec
+578 Fragmentation Failures
+580 Fragments Created/sec
+582 ICMP
+584 Messages/sec
+586 Messages Received/sec
+588 Messages Received Errors
+590 Received Dest. Unreachable
+592 Received Time Exceeded
+594 Received Parameter Problem
+596 Received Source Quench
+598 Received Redirect/sec
+600 Received Echo/sec
+602 Received Echo Reply/sec
+604 Received Timestamp/sec
+606 Received Timestamp Reply/sec
+608 Received Address Mask
+610 Received Address Mask Reply
+612 Messages Sent/sec
+614 Messages Outbound Errors
+616 Sent Destination Unreachable
+618 Sent Time Exceeded
+620 Sent Parameter Problem
+622 Sent Source Quench
+624 Sent Redirect/sec
+626 Sent Echo/sec
+628 Sent Echo Reply/sec
+630 Sent Timestamp/sec
+632 Sent Timestamp Reply/sec
+634 Sent Address Mask
+636 Sent Address Mask Reply
+638 TCP
+640 Segments/sec
+642 Connections Established
+644 Connections Active
+646 Connections Passive
+648 Connection Failures
+650 Connections Reset
+652 Segments Received/sec
+654 Segments Sent/sec
+656 Segments Retransmitted/sec
+658 UDP
+660 % Total DPC Time
+662 % Total Interrupt Time
+664 Datagrams No Port/sec
+666 Datagrams Received Errors
+670 Disk Storage Unit
+672 Allocation Failures
+674 System Up Time
+676 System Handle Count
+678 Free System Page Table Entries
+680 Thread Count
+682 Priority Base
+684 Elapsed Time
+686 Alignment Fixups/sec
+688 Exception Dispatches/sec
+690 Floating Emulations/sec
+692 Logon/sec
+694 Priority Current
+696 % DPC Time
+698 % Interrupt Time
+700 Paging File
+702 % Usage
+704 % Usage Peak
+706 Start Address
+708 User PC
+710 Mapped Space No Access
+712 Mapped Space Read Only
+714 Mapped Space Read/Write
+716 Mapped Space Write Copy
+718 Mapped Space Executable
+720 Mapped Space Exec Read Only
+722 Mapped Space Exec Read/Write
+724 Mapped Space Exec Write Copy
+726 Reserved Space No Access
+728 Reserved Space Read Only
+730 Reserved Space Read/Write
+732 Reserved Space Write Copy
+734 Reserved Space Executable
+736 Reserved Space Exec Read Only
+738 Reserved Space Exec Read/Write
+740 Image
+742 Reserved Space Exec Write Copy
+744 Unassigned Space No Access
+746 Unassigned Space Read Only
+748 Unassigned Space Read/Write
+750 Unassigned Space Write Copy
+752 Unassigned Space Executable
+754 Unassigned Space Exec Read Only
+756 Unassigned Space Exec Read/Write
+758 Unassigned Space Exec Write Copy
+760 Image Space No Access
+762 Image Space Read Only
+764 Image Space Read/Write
+766 Image Space Write Copy
+768 Image Space Executable
+770 Image Space Exec Read Only
+772 Image Space Exec Read/Write
+774 Image Space Exec Write Copy
+776 Bytes Image Reserved
+778 Bytes Image Free
+780 Bytes Reserved
+782 Bytes Free
+784 ID Process
+786 Process Address Space
+788 No Access
+790 Read Only
+792 Read/Write
+794 Write Copy
+796 Executable
+798 Exec Read Only
+800 Exec Read/Write
+802 Exec Write Copy
+804 ID Thread
+806 Mailslot Receives Failed
+808 Mailslot Writes Failed
+810 Mailslot Opens Failed/sec
+812 Duplicate Master Announcements
+814 Illegal Datagrams/sec
+816 Thread Details
+818 Cache Bytes
+820 Cache Bytes Peak
+822 Pages Input/sec
+870 RAS Port
+872 Bytes Transmitted
+874 Bytes Received
+876 Frames Transmitted
+878 Frames Received.
+880 Percent Compression Out
+882 Percent Compression In
+884 CRC Errors
+886 Timeout Errors
+888 Serial Overrun Errors
+890 Alignment Errors
+892 Buffer Overrun Errors
+894 Total Errors
+896 Bytes Transmitted/Sec
+898 Bytes Received/Sec
+900 Frames Transmitted/Sec
+902 Frames Received/Sec
+904 Total Errors/Sec
+906 RAS Total
+908 Total Connections
+920 WINS Server
+922 Unique Registrations/sec
+924 Group Registrations/sec
+926 Total Number of Registrations/sec
+928 Unique Renewals/sec
+930 Group Renewals/sec
+932 Total Number of Renewals/sec
+934 Releases/sec
+936 Queries/sec
+938 Unique Conflicts/sec
+940 Group Conflicts/sec
+942 Total Number of Conflicts/sec
+944 Successful Releases/sec
+946 Failed Releases/sec
+948 Successful Queries/sec
+950 Failed Queries/sec
+952 Handle Count
+1000 MacFile Server
+1002 Max Paged Memory
+1004 Current Paged Memory
+1006 Max NonPaged Memory
+1008 Current NonPaged memory
+1010 Current Sessions
+1012 Maximum Sessions
+1014 Current Files Open
+1016 Maximum Files Open
+1018 Failed Logons
+1020 Data Read/sec
+1022 Data Written/sec
+1024 Data Received/sec
+1026 Data Transmitted/sec
+1028 Current Queue Length
+1030 Maximum Queue Length
+1032 Current Threads
+1034 Maximum Threads
+1050 AppleTalk
+1052 Packets In/sec
+1054 Packets Out/sec
+1056 Bytes In/sec
+1058 Bytes Out/sec
+1060 Average Time/DDP Packet
+1062 DDP Packets/sec
+1064 Average Time/AARP Packet
+1066 AARP Packets/sec
+1068 Average Time/ATP Packet
+1070 ATP Packets/sec
+1072 Average Time/NBP Packet
+1074 NBP Packets/sec
+1076 Average Time/ZIP Packet
+1078 ZIP Packets/sec
+1080 Average Time/RTMP Packet
+1082 RTMP Packets/sec
+1084 ATP Retries Local
+1086 ATP Response Timouts
+1088 ATP XO Response/Sec
+1090 ATP ALO Response/Sec
+1092 ATP Recvd Release/Sec
+1094 Current NonPaged Pool
+1096 Packets Routed In/Sec
+1098 Packets dropped
+1100 ATP Retries Remote
+1102 Packets Routed Out/Sec
+1110 Network Segment
+1112 Total frames received/second
+1114 Total bytes received/second
+1116 Broadcast frames received/second
+1118 Multicast frames received/second
+1120 % Network utilization
+1124 % Broadcast Frames
+1126 % Multicast Frames
+1150 Telephony
+1152 Lines
+1154 Telephone Devices
+1156 Active Lines
+1158 Active Telephones
+1160 Outgoing Calls/sec
+1162 Incoming Calls/sec
+1164 Client Apps
+1166 Current Outgoing Calls
+1168 Current Incoming Calls
+1228 Gateway Service For NetWare
+1230 Client Service For NetWare
+1232 Packet Burst Read NCP Count/sec
+1234 Packet Burst Read Timeouts/sec
+1236 Packet Burst Write NCP Count/sec
+1238 Packet Burst Write Timeouts/sec
+1240 Packet Burst IO/sec
+1242 Connect NetWare 2.x
+1244 Connect NetWare 3.x
+1246 Connect NetWare 4.x
+1260 Logon Total
+1300 Server Work Queues
+1302 Queue Length
+1304 Active Threads
+1306 Available Threads
+1308 Available Work Items
+1310 Borrowed Work Items
+1312 Work Item Shortages
+1314 Current Clients
+1320 Bytes Transferred/sec
+1324 Read Bytes/sec
+1328 Write Bytes/sec
+1332 Total Operations/sec
+1334 DPCs Queued/sec
+1336 DPC Rate
+1342 Total DPCs Queued/sec
+1344 Total DPC Rate
+1350 % Registry Quota In Use
+1360 VL Memory
+1362 VLM % Virtual Size In Use
+1364 VLM Virtual Size
+1366 VLM Virtual Size Peak
+1368 VLM Virtual Size Available
+1370 VLM Commit Charge
+1372 VLM Commit Charge Peak
+1374 System VLM Commit Charge
+1376 System VLM Commit Charge Peak
+1378 System VLM Shared Commit Charge
+1380 Available KBytes
+1382 Available MBytes
+1400 Avg. Disk Queue Length
+1402 Avg. Disk Read Queue Length
+1404 Avg. Disk Write Queue Length
+1406 % Committed Bytes In Use
+1408 Full Image
+1410 Creating Process ID
+1412 IO Read Operations/sec
+1414 IO Write Operations/sec
+1416 IO Data Operations/sec
+1418 IO Other Operations/sec
+1420 IO Read Bytes/sec
+1422 IO Write Bytes/sec
+1424 IO Data Bytes/sec
+1426 IO Other Bytes/sec
+1450 Print Queue
+1452 Total Jobs Printed
+1454 Bytes Printed/sec
+1456 Total Pages Printed
+1458 Jobs
+1460 References
+1462 Max References
+1464 Jobs Spooling
+1466 Max Jobs Spooling
+1468 Out of Paper Errors
+1470 Not Ready Errors
+1472 Job Errors
+1474 Enumerate Network Printer Calls
+1476 Add Network Printer Calls
+1478 Working Set - Private
+1480 Working Set - Shared
+1482 % Idle Time
+1484 Split IO/Sec
+1500 Job Object
+1502 Current % Processor Time
+1504 Current % User Mode Time
+1506 Current % Kernel Mode Time
+1508 This Period mSec - Processor
+1510 This Period mSec - User Mode
+1512 This Period mSec - Kernel Mode
+1514 Pages/Sec
+1516 Process Count - Total
+1518 Process Count - Active
+1520 Process Count - Terminated
+1522 Total mSec - Processor
+1524 Total mSec - User Mode
+1526 Total mSec - Kernel Mode
+1548 Job Object Details
+1746 % Idle Time
+1748 % C1 Time
+1750 % C2 Time
+1752 % C3 Time
+1754 C1 Transitions/sec
+1756 C2 Transitions/sec
+1758 C3 Transitions/sec
+1760 Heap
+1762 Committed Bytes
+1764 Reserved Bytes
+1766 Virtual Bytes
+1768 Free Bytes
+1770 Free List Length
+1772 Avg. alloc rate
+1774 Avg. free rate
+1776 Uncommitted Ranges Length
+1778 Allocs - Frees
+1780 Cached Allocs/sec
+1782 Cached Frees/sec
+1784 Allocs <1K/sec
+1786 Frees <1K/sec
+1788 Allocs 1-8K/sec
+1790 Frees 1-8K/sec
+1792 Allocs over 8K/sec
+1794 Frees over 8K/sec
+1796 Total Allocs/sec
+1798 Total Frees/sec
+1800 Blocks in Heap Cache
+1802 Largest Cache Depth
+1804 % Fragmentation
+1806 % VAFragmentation
+1808 Heap Lock contention
+1846 End Marker
+1848 RSVP Service
+1850 Network Interfaces
+1852 Network sockets
+1854 Timers
+1856 RSVP sessions
+1858 QoS clients
+1860 QoS-enabled senders
+1862 QoS-enabled receivers
+1864 Failed QoS requests
+1866 Failed QoS sends
+1868 QoS notifications
+1870 Bytes in QoS notifications
+1872 RSVP Interfaces
+1874 Signaling bytes received
+1876 Signaling bytes sent
+1878 PATH messages received
+1880 RESV messages received
+1882 PATH ERR messages received
+1884 RESV ERR messages received
+1886 PATH TEAR messages received
+1888 RESV TEAR messages received
+1890 RESV CONFIRM messages received
+1892 PATH messages sent
+1894 RESV messages sent
+1896 PATH ERR messages sent
+1898 RESV ERR messages sent
+1900 PATH TEAR messages sent
+1902 RESV TEAR messages sent
+1904 RESV CONFIRM messages sent
+1906 Resource control failures
+1908 Policy control failures
+1910 General failures
+1912 Blocked RESVs
+1914 RESV state block timeouts
+1916 PATH state block timeouts
+1918 Send messages errors - Big messages
+1920 Receive messages errors - Big messages
+1922 Send messages errors - No memory
+1924 Receive messages errors - No memory
+1926 Number of incoming messages dropped
+1928 Number of outgoing messages dropped
+1930 Number of active flows
+1932 Reserved bandwidth
+1934 Maximum admitted bandwidth
+1936 PSched Flow
+1938 PSched Pipe
+1940 Packets dropped
+1942 Packets scheduled
+1944 Packets transmitted
+1946 Average packets in shaper
+1948 Max packets in shaper
+1950 Average packets in sequencer
+1952 Max packets in sequencer
+1954 Bytes scheduled
+1956 Bytes transmitted
+1958 Bytes transmitted/sec
+1960 Bytes scheduled/sec
+1962 Packets transmitted/sec
+1964 Packets scheduled/sec
+1966 Packets dropped/sec
+1968 Nonconforming packets scheduled
+1970 Nonconforming packets scheduled/sec
+1972 Nonconforming packets transmitted
+1974 Nonconforming packets transmitted/sec
+1976 Maximum Packets in netcard
+1978 Average Packets in netcard
+1980 Out of packets
+1982 Flows opened
+1984 Flows closed
+1986 Flows rejected
+1988 Flows modified
+1990 Flow mods rejected
+1992 Max simultaneous flows
+1994 Nonconforming packets scheduled
+1996 Nonconforming packets scheduled/sec
+1998 Nonconforming packets transmitted
+2000 Nonconforming packets transmitted/sec
+2002 Average packets in shaper
+2004 Max packets in shaper
+2006 Average packets in sequencer
+2008 Max packets in sequencer
+2010 Max packets in netcard
+2012 Average packets in netcard
+2014 RAS Port
+2016 Bytes Transmitted
+2018 Bytes Received
+2020 Frames Transmitted
+2022 Frames Received
+2024 Percent Compression Out
+2026 Percent Compression In
+2028 CRC Errors
+2030 Timeout Errors
+2032 Serial Overrun Errors
+2034 Alignment Errors
+2036 Buffer Overrun Errors
+2038 Total Errors
+2040 Bytes Transmitted/Sec
+2042 Bytes Received/Sec
+2044 Frames Transmitted/Sec
+2046 Frames Received/Sec
+2048 Total Errors/Sec
+2050 RAS Total
+2052 Total Connections
+2054 Terminal Services Session
+2056 Input WdBytes
+2058 Input WdFrames
+2060 Input WaitForOutBuf
+2062 Input Frames
+2064 Input Bytes
+2066 Input Compressed Bytes
+2068 Input Compress Flushes
+2070 Input Errors
+2072 Input Timeouts
+2074 Input Async Frame Error
+2076 Input Async Overrun
+2078 Input Async Overflow
+2080 Input Async Parity Error
+2082 Input Transport Errors
+2084 Output WdBytes
+2086 Output WdFrames
+2088 Output WaitForOutBuf
+2090 Output Frames
+2092 Output Bytes
+2094 Output Compressed Bytes
+2096 Output Compress Flushes
+2098 Output Errors
+2100 Output Timeouts
+2102 Output Async Frame Error
+2104 Output Async Overrun
+2106 Output Async Overflow
+2108 Output Async Parity Error
+2110 Output Transport Errors
+2112 Total WdBytes
+2114 Total WdFrames
+2116 Total WaitForOutBuf
+2118 Total Frames
+2120 Total Bytes
+2122 Total Compressed Bytes
+2124 Total Compress Flushes
+2126 Total Errors
+2128 Total Timeouts
+2130 Total Async Frame Error
+2132 Total Async Overrun
+2134 Total Async Overflow
+2136 Total Async Parity Error
+2138 Total Transport Errors
+2140 Total Protocol Cache Reads
+2142 Total Protocol Cache Hits
+2144 Total Protocol Cache Hit Ratio
+2146 Protocol Bitmap Cache Reads
+2148 Protocol Bitmap Cache Hits
+2150 Protocol Bitmap Cache Hit Ratio
+2152 Protocol Glyph Cache Reads
+2154 Protocol Glyph Cache Hits
+2156 Protocol Glyph Cache Hit Ratio
+2158 Protocol Brush Cache Reads
+2160 Protocol Brush Cache Hits
+2162 Protocol Brush Cache Hit Ratio
+2164 Protocol Save Screen Bitmap Cache Reads
+2166 Protocol Save Screen Bitmap Cache Hits
+2168 Protocol Save Screen Bitmap Cache Hit Ratio
+2170 Input Compression Ratio
+2172 Output Compression Ratio
+2174 Total Compression Ratio
+2176 Terminal Services
+2178 Total Sessions
+2180 Active Sessions
+2182 Inactive Sessions
+2184 Distributed Transaction Coordinator
+2186 Active Transactions
+2188 Committed Transactions
+2190 Aborted Transactions
+2192 In Doubt Transactions
+2194 Active Transactions Maximum
+2196 Force Committed Transactions
+2198 Force Aborted Transactions
+2200 Response Time -- Minimum
+2202 Response Time -- Average
+2204 Response Time -- Maximum
+2206 Transactions/sec
+2208 Committed Transactions/sec
+2210 Aborted Transactions/sec
+2212 Indexing Service
+2214 Word lists
+2216 Saved indexes
+2218 Index size (MB)
+2220 Files to be indexed
+2222 Unique keys
+2224 Running queries
+2226 Merge progress
+2228 # documents indexed
+2230 Total # documents
+2232 Total # of queries
+2234 Deferred for indexing
+2236 Indexing Service Filter
+2238 Total indexing speed (MB/hr)
+2240 Binding time (msec)
+2242 Indexing speed (MB/hr)
+2244 Http Indexing Service
+2246 Cache items
+2248 % Cache hits
+2250 Total cache accesses 1
+2252 % Cache misses
+2254 Total cache accesses 2
+2256 Active queries
+2258 Total queries
+2260 Queries per minute
+2262 Current requests queued
+2264 Total requests rejected
+2266 WMI Objects
+2268 HiPerf Classes
+2270 HiPerf Validity
+2272 BatteryStatus
+2274 ChargeRate
+2276 DischargeRate
+2278 RemainingCapacity
+2280 Tag
+2282 Voltage
diff --git a/src/os/win32/cpu.c b/src/os/win32/cpu.c
new file mode 100644
index 00000000..89e228f9
--- /dev/null
+++ b/src/os/win32/cpu.c
@@ -0,0 +1,354 @@
+/*
+ * code in this file derived from:
+ * http://www.intel.com/cd/ids/developer/asmo-na/eng/technologies/20438.htm
+ * license grants use of the source code.
+ */
+static unsigned int HTSupported(void);
+static unsigned char LogicalProcPerPhysicalProc(unsigned int);
+static unsigned char GetAPIC_ID(unsigned int);
+static unsigned char CPUCount(unsigned char *, unsigned char *);
+
+// EDX[28] Bit 28 is set if HT is supported
+#define HT_BIT 0x10000000
+
+// EAX[11:8] Bit 8-11 contains family processor ID.
+#define FAMILY_ID 0x0F00
+
+#define PENTIUM4_ID 0x0F00
+
+// EAX[23:20] Bit 20-23 contains extended family processor ID
+#define EXT_FAMILY_ID 0x0F00000
+
+
+// EBX[23:16] Bit 16-23 in ebx contains the number of logical
+// processors per physical processor when execute cpuid with
+// eax set to 1
+#define NUM_LOGICAL_BITS 0x00FF0000
+
+// EBX[31:24] Bits 24-31 (8 bits) return the 8-bit unique
+// initial APIC ID for the processor this code is running on.
+// Default value = 0xff if HT is not supported
+#define INITIAL_APIC_ID_BITS 0xFF000000
+
+// Status Flag
+#define HT_NOT_CAPABLE 0
+#define HT_ENABLED 1
+#define HT_DISABLED 2
+#define HT_SUPPORTED_NOT_ENABLED 3
+#define HT_CANNOT_DETECT 4
+
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+
+static unsigned int HTSupported(void)
+{
+ unsigned int
+ Regedx = 0,
+ Regeax = 0,
+ VendorId[3] = {0, 0, 0};
+
+ __try {
+ __asm {
+ xor eax, eax // call cpuid with eax = 0
+ cpuid // Get vendor id string
+ mov VendorId, ebx
+ mov VendorId + 4, edx
+ mov VendorId + 8, ecx
+
+ mov eax, 1 // call cpuid with eax = 1
+ cpuid
+ mov Regeax, eax // eax contains family processor type
+ mov Regedx, edx // edx has info about the availability of hyper-Threading
+ }
+ }
+ __except (EXCEPTION_EXECUTE_HANDLER) {
+ return 0; // cpuid is unavailable
+ }
+
+ if (((Regeax & FAMILY_ID) == PENTIUM4_ID) ||
+ (Regeax & EXT_FAMILY_ID))
+ {
+ if ((VendorId[0] == 'uneG') &&
+ (VendorId[1] == 'Ieni') &&
+ (VendorId[2] == 'letn'))
+ {
+ // Genuine Intel with hyper-Threading technology
+ return Regedx & HT_BIT;
+ }
+ }
+
+ return 0; // Not genuine Intel processor
+}
+
+static unsigned char LogicalProcPerPhysicalProc(unsigned int ht_supported)
+{
+ unsigned int Regebx = 0;
+ if (!ht_supported) {
+ return (unsigned char) 1; // HT not supported
+ }
+
+ // Logical processor = 1
+ __asm {
+ mov eax, 1
+ cpuid
+ mov Regebx, ebx
+ }
+
+ return (unsigned char) ((Regebx & NUM_LOGICAL_BITS) >> 16);
+}
+
+static unsigned char GetAPIC_ID(unsigned int ht_supported)
+{
+ unsigned int Regebx = 0;
+ if (!ht_supported) {
+ return (unsigned char) -1;
+ }
+
+ // Logical processor = 1
+ __asm {
+ mov eax, 1
+ cpuid
+ mov Regebx, ebx
+ }
+
+ return (unsigned char) ((Regebx & INITIAL_APIC_ID_BITS) >> 24);
+}
+
+static unsigned char CPUCount(unsigned char *LogicalNum,
+ unsigned char *PhysicalNum)
+{
+ unsigned int ht_supported = HTSupported();
+ unsigned char StatusFlag = 0;
+ SYSTEM_INFO info;
+
+ *PhysicalNum = 0;
+ *LogicalNum = 0;
+ info.dwNumberOfProcessors = 0;
+ GetSystemInfo(&info);
+
+ // Number of physical processors in a non-Intel system
+ // or in a 32-bit Intel system with Hyper-Threading technology disabled
+ *PhysicalNum = (unsigned char) info.dwNumberOfProcessors;
+
+ if (ht_supported) {
+ unsigned char HT_Enabled = 0;
+
+ *LogicalNum = LogicalProcPerPhysicalProc(ht_supported);
+
+ if (*LogicalNum >= 1) { // >1 Doesn't mean HT is enabled in the BIOS
+ HANDLE hCurrentProcessHandle;
+ DWORD dwProcessAffinity;
+ DWORD dwSystemAffinity;
+ DWORD dwAffinityMask;
+
+ // Calculate the appropriate shifts and mask based on the
+ // number of logical processors.
+
+ unsigned char i = 1,
+ PHY_ID_MASK = 0xFF,
+ PHY_ID_SHIFT = 0;
+
+ while (i < *LogicalNum) {
+ i *= 2;
+ PHY_ID_MASK <<= 1;
+ PHY_ID_SHIFT++;
+ }
+
+ hCurrentProcessHandle = GetCurrentProcess();
+
+ GetProcessAffinityMask(hCurrentProcessHandle,
+ &dwProcessAffinity,
+ &dwSystemAffinity);
+
+ // Check if available process affinity mask is equal to the
+ // available system affinity mask
+ if (dwProcessAffinity != dwSystemAffinity) {
+ StatusFlag = HT_CANNOT_DETECT;
+ // *PhysicalNum = (unsigned char)-1;
+ return StatusFlag;
+ }
+
+ dwAffinityMask = 1;
+
+ while (dwAffinityMask != 0 && dwAffinityMask <= dwProcessAffinity) {
+ // Check if this CPU is available
+ if (dwAffinityMask & dwProcessAffinity) {
+ if (SetProcessAffinityMask(hCurrentProcessHandle,
+ dwAffinityMask))
+ {
+ unsigned char APIC_ID,
+ LOG_ID,
+ PHY_ID;
+
+ Sleep(0); // Give OS time to switch CPU
+
+ APIC_ID = GetAPIC_ID(ht_supported);
+ LOG_ID = APIC_ID & ~PHY_ID_MASK;
+ PHY_ID = APIC_ID >> PHY_ID_SHIFT;
+
+ if (LOG_ID != 0) {
+ HT_Enabled = 1;
+ }
+ }
+ }
+
+ dwAffinityMask = dwAffinityMask << 1;
+ }
+
+ // Reset the processor affinity
+ SetProcessAffinityMask(hCurrentProcessHandle, dwProcessAffinity);
+
+ if (*LogicalNum == 1) { // Normal P4 : HT is disabled in hardware
+ StatusFlag = HT_DISABLED;
+ }
+ else {
+ if (HT_Enabled) {
+ // Total physical processors in a Hyper-Threading enabled system.
+ *PhysicalNum /= (*LogicalNum);
+ StatusFlag = HT_ENABLED;
+ }
+ else {
+ StatusFlag = HT_SUPPORTED_NOT_ENABLED;
+ }
+ }
+ }
+
+ }
+ else {
+ // Processors do not have Hyper-Threading technology
+ StatusFlag = HT_NOT_CAPABLE;
+ *LogicalNum = 1;
+ }
+
+ return StatusFlag;
+}
+
+unsigned int sigar_cpu_count(sigar_t *sigar)
+{
+ unsigned char
+ status,
+ LogicalNum = 0,
+ PhysicalNum = 0;
+
+ if (sigar->ncpu != 0) {
+ return sigar->ncpu;
+ }
+
+ status = CPUCount(&LogicalNum, &PhysicalNum);
+
+ sigar->ncpu = (unsigned int)PhysicalNum;
+
+ if (status == HT_ENABLED) {
+ sigar->ht_enabled = 1;
+ }
+ else {
+ sigar->ht_enabled = 0;
+ }
+
+ return sigar->ncpu;
+}
+
+/* this function is not part of the intel derived code */
+
+int sigar_cpu_info_get(sigar_t *sigar, sigar_cpu_info_t *info)
+{
+ HKEY key, cpu;
+ int i = 0;
+ TCHAR id[MAX_PATH + 1];
+ LPBYTE value;
+ DWORD size = 0, rc;
+
+ RegOpenKey(HKEY_LOCAL_MACHINE,
+ "HARDWARE\\DESCRIPTION\\System\\CentralProcessor", &key);
+
+ //just lookup the first id, then assume all cpus are the same.
+ rc = RegEnumKey(key, 0, id, sizeof(id));
+ if (rc != ERROR_SUCCESS) {
+ return rc;
+ }
+
+ rc = RegOpenKey(key, id, &cpu);
+ if (rc != ERROR_SUCCESS) {
+ return rc;
+ }
+
+ size = sizeof(info->vendor);
+ if (RegQueryValueEx(cpu, "VendorIdentifier", NULL, NULL,
+ (LPVOID)&info->vendor, &size))
+ {
+ SIGAR_SSTRCPY(info->vendor, "Intel");
+ }
+
+ size = sizeof(info->model);
+ if (RegQueryValueEx(cpu, "Identifier", NULL, NULL,
+ (LPVOID)&info->model, &size))
+ {
+ SIGAR_SSTRCPY(info->vendor, "x86");
+ }
+
+ size = sizeof(info->mhz); // == sizeof(DWORD)
+ if (RegQueryValueEx(cpu, "~MHz", NULL, NULL,
+ (LPVOID)&info->mhz, &size))
+ {
+ info->mhz = -1;
+ }
+
+ info->cache_size = -1; //XXX
+
+ return SIGAR_OK;
+}
+
+#ifdef CPU_MAIN
+void main(void)
+{
+ // Number of logical CPU per ONE PHYSICAL CPU
+ unsigned char LogicalNum = 0,
+ PhysicalNum = 0, // Total number of physical processor
+ HTStatusFlag = 0;
+
+ sigar_cpu_info_t info;
+
+ sigar_cpu_info_get(NULL, &info);
+
+ printf("Vendor............%s\n", info.vendor);
+ printf("Model.............%s\n", info.model);
+ printf("Mhz...............%d\n", info.mhz);
+
+ HTStatusFlag = CPUCount(&LogicalNum, &PhysicalNum);
+
+ switch(HTStatusFlag)
+ {
+ case HT_NOT_CAPABLE:
+ printf("Hyper-threading...not capable\n");
+ break;
+
+ case HT_DISABLED:
+ printf("Hyper-threading...disabled\n");
+ break;
+
+ case HT_ENABLED:
+ printf("Hyper-threading...enabled\n");
+ break;
+
+ case HT_SUPPORTED_NOT_ENABLED:
+ printf("Hyper-threading...capable but not enabled\n");
+ break;
+
+ case HT_CANNOT_DETECT:
+ printf("Hyper-threading...cannot be detected\n");
+ break;
+ }
+
+ printf("Logical ratio.....%d/1\n",
+ LogicalNum);
+
+ if (PhysicalNum != (unsigned char)-1) {
+ printf("Physical CPUs.....%d\n", PhysicalNum);
+ }
+ else {
+ printf("Can't determine number of physical processors\n");
+ printf("Make sure to enable ALL processors\n");
+ }
+}
+#endif
diff --git a/src/os/win32/peb.c b/src/os/win32/peb.c
new file mode 100644
index 00000000..5b57cf4f
--- /dev/null
+++ b/src/os/win32/peb.c
@@ -0,0 +1,72 @@
+/*
+ * functions for getting info from the Process Environment Block
+ */
+#define UNICODE
+#define _UNICODE
+
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_os.h"
+
+#define START_ADDRESS (LPVOID)0x00020498
+
+static int sigar_peb_get(sigar_t *sigar, HANDLE proc, DWORD *base)
+{
+ MEMORY_BASIC_INFORMATION mbi;
+ DWORD bytes;
+
+ if (!sigar->peb) {
+ sigar->peb = malloc(sigar->pagesize);
+ }
+
+ if (!VirtualQueryEx(proc, START_ADDRESS, &mbi, sizeof(mbi))) {
+ return GetLastError();
+ }
+
+ if (!ReadProcessMemory(proc, mbi.BaseAddress, sigar->peb,
+ sigar->pagesize, &bytes))
+ {
+ return GetLastError();
+ }
+
+ *base = (DWORD)mbi.BaseAddress;
+
+ return SIGAR_OK;
+}
+
+//point scratch to PATH env var
+#define PEB_PATH(scratch, base) \
+ scratch = sigar->peb + ((DWORD)START_ADDRESS - base)
+
+//point scratch to EXE (assumes PEB_PATH)
+#define PEB_EXE(scratch) \
+ scratch = scratch + (wcslen((LPWSTR)scratch) + 1) * sizeof(WCHAR)
+
+int sigar_proc_exe_name_get(sigar_t *sigar, HANDLE proc, char *name)
+{
+ int status;
+ LPBYTE scratch;
+ DWORD base;
+ WCHAR buf[MAX_PATH];
+
+ if ((status = sigar_peb_get(sigar, proc, &base)) != SIGAR_OK) {
+ return status;
+ }
+
+ //skip env PATH
+ PEB_PATH(scratch, base);
+
+ PEB_EXE(scratch);
+
+ //seems common, reason unknown.
+ if (*scratch == '\0') {
+ scratch += sizeof(WCHAR);
+ }
+
+ wcsncpy(buf, (LPWSTR)scratch, MAX_PATH);
+ buf[MAX_PATH-1] = L'\0';
+
+ SIGAR_W2A(buf, name, MAX_PATH);
+
+ return SIGAR_OK;
+}
diff --git a/src/os/win32/sigar_os.h b/src/os/win32/sigar_os.h
new file mode 100644
index 00000000..57e61103
--- /dev/null
+++ b/src/os/win32/sigar_os.h
@@ -0,0 +1,125 @@
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#define WIN32_LEAN_AND_MEAN
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define INT64_C(val) val##i64
+
+/* see apr/include/arch/win32/atime.h */
+#define EPOCH_DELTA INT64_C(11644473600000000)
+
+static __inline sigar_uint64_t FileTimeToTime(FILETIME *ft)
+{
+ sigar_uint64_t time;
+ time = ft->dwHighDateTime;
+ time = time << 32;
+ time |= ft->dwLowDateTime;
+ time /= 10;
+ time -= EPOCH_DELTA;
+ return time;
+}
+
+/* XXX: support CP_UTF8 ? */
+
+#define SIGAR_A2W(lpa, lpw, bytes) \
+ (lpw[0] = 0, MultiByteToWideChar(CP_ACP, 0, \
+ lpa, -1, lpw, (bytes/sizeof(WCHAR))))
+
+#define SIGAR_W2A(lpw, lpa, chars) \
+ (lpa[0] = '\0', WideCharToMultiByte(CP_ACP, 0, \
+ lpw, -1, (LPSTR)lpa, chars, \
+ NULL, NULL))
+
+#include
+
+/* undocumented structures */
+typedef struct {
+ DWORD dwState;
+ DWORD dwLocalAddr;
+ DWORD dwLocalPort;
+ DWORD dwRemoteAddr;
+ DWORD dwRemotePort;
+ DWORD dwProcessId;
+} MIB_TCPEXROW, *PMIB_TCPEXROW;
+
+typedef struct {
+ DWORD dwNumEntries;
+ MIB_TCPEXROW table[ANY_SIZE];
+} MIB_TCPEXTABLE, *PMIB_TCPEXTABLE;
+
+typedef struct {
+ DWORD dwLocalAddr;
+ DWORD dwLocalPort;
+ DWORD dwProcessId;
+} MIB_UDPEXROW, *PMIB_UDPEXROW;
+
+typedef struct {
+ DWORD dwNumEntries;
+ MIB_UDPEXROW table[ANY_SIZE];
+} MIB_UDPEXTABLE, *PMIB_UDPEXTABLE;
+
+/* end undocumented structures */
+
+typedef DWORD (CALLBACK *LPGETIPFORWARDTABLE)(PMIB_IPFORWARDTABLE, PULONG, BOOL);
+
+typedef DWORD (CALLBACK *LPGETIFTABLE)(PMIB_IFTABLE, PULONG, BOOL);
+
+typedef DWORD (CALLBACK *LPGETTCPTABLE)(PMIB_TCPTABLE, PDWORD, BOOL);
+
+typedef DWORD (CALLBACK *LPGETUDPTABLE)(PMIB_UDPTABLE, PDWORD, BOOL);
+
+typedef DWORD (CALLBACK *LPGETTCPEXTABLE)(PMIB_TCPEXTABLE *, BOOL, HANDLE,
+ DWORD, DWORD);
+
+typedef struct {
+ sigar_pid_t pid;
+ int ppid;
+ int priority;
+ time_t mtime;
+ sigar_uint64_t vsize;
+ sigar_uint64_t size;
+ char name[SIGAR_PROC_NAME_LEN];
+ char state;
+ sigar_uint64_t handles;
+} sigar_win32_pinfo_t;
+
+struct sigar_t {
+ SIGAR_T_BASE;
+ char *machine;
+ int using_wide;
+ long pagesize;
+ HKEY handle;
+ char *perfbuf;
+ DWORD perfbuf_size;
+ HINSTANCE ip_handle;
+ LPGETIFTABLE get_if_table;
+ LPGETIPFORWARDTABLE get_ipforward_table;
+ LPGETTCPTABLE get_tcp_table;
+ LPGETTCPEXTABLE get_tcpx_table;
+ LPGETUDPTABLE get_udp_table;
+ sigar_win32_pinfo_t pinfo;
+ WORD ws_version;
+ int ws_error;
+ LPBYTE peb; //scratch pad for getting peb info
+ int ht_enabled;
+};
+
+int sigar_wsa_init(sigar_t *sigar);
+
+int sigar_proc_exe_name_get(sigar_t *sigar, HANDLE proc, char *name);
+
+unsigned int sigar_cpu_count(sigar_t *sigar);
+
+int sigar_cpu_info_get(sigar_t *sigar, sigar_cpu_info_t *info);
+
+#endif /* SIGAR_OS_H */
diff --git a/src/os/win32/sigar_pdh.h b/src/os/win32/sigar_pdh.h
new file mode 100644
index 00000000..42a746a1
--- /dev/null
+++ b/src/os/win32/sigar_pdh.h
@@ -0,0 +1,31 @@
+#ifndef SIGAR_PDH_H
+#define SIGAR_PDH_H
+
+/* performance data helpers */
+
+#define PdhFirstObject(block) \
+ ((PERF_OBJECT_TYPE *)((BYTE *) block + block->HeaderLength))
+
+#define PdhNextObject(object) \
+ ((PERF_OBJECT_TYPE *)((BYTE *) object + object->TotalByteLength))
+
+#define PdhFirstCounter(object) \
+ ((PERF_COUNTER_DEFINITION *)((BYTE *) object + object->HeaderLength))
+
+#define PdhNextCounter(counter) \
+ ((PERF_COUNTER_DEFINITION *)((BYTE *) counter + counter->ByteLength))
+
+#define PdhGetCounterBlock(inst) \
+ ((PERF_COUNTER_BLOCK *)((BYTE *) inst + inst->ByteLength))
+
+#define PdhFirstInstance(object) \
+ ((PERF_INSTANCE_DEFINITION *)((BYTE *) object + object->DefinitionLength))
+
+#define PdhNextInstance(inst) \
+ ((PERF_INSTANCE_DEFINITION *)((BYTE *)inst + inst->ByteLength + \
+ PdhGetCounterBlock(inst)->ByteLength))
+
+#define PdhInstanceName(inst) \
+ ((wchar_t *)((BYTE *)inst + inst->NameOffset))
+
+#endif /* SIGAR_PDH_H */
diff --git a/src/os/win32/win32_sigar.c b/src/os/win32/win32_sigar.c
new file mode 100644
index 00000000..8604dea3
--- /dev/null
+++ b/src/os/win32/win32_sigar.c
@@ -0,0 +1,1833 @@
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_pdh.h"
+#include "sigar_os.h"
+#include "sigar_util.h"
+#include
+
+#define USING_WIDE_S(s) (s)->using_wide
+#define USING_WIDE() USING_WIDE_S(sigar)
+
+#define PERFBUF_SIZE 8192
+
+#define PERF_TITLE_PROC 230
+#define PERF_TITLE_PROC_KEY "230"
+#define PERF_TITLE_CPU_KEY "238"
+
+#define PERF_TITLE_CPU_USER 142
+#define PERF_TITLE_CPU_IDLE 1746
+#define PERF_TITLE_CPU_SYS 144
+
+typedef enum {
+ PERF_IX_CPU_USER,
+ PERF_IX_CPU_IDLE,
+ PERF_IX_CPU_SYS,
+ PERF_IX_CPU_MAX
+} perf_cpu_offsets_t;
+
+#define PERF_TITLE_CPUTIME 6
+#define PERF_TITLE_MEM_VSIZE 174
+#define PERF_TITLE_MEM_SIZE 180
+#define PERF_TITLE_MEM_PRIV 186
+#define PERF_TITLE_THREAD_CNT 680
+#define PERF_TITLE_HANDLE_CNT 952
+#define PERF_TITLE_PID 784
+#define PERF_TITLE_PPID 1410
+#define PERF_TITLE_PRIORITY 682
+#define PERF_TITLE_START_TIME 684
+
+typedef enum {
+ PERF_IX_CPUTIME,
+ PERF_IX_MEM_VSIZE,
+ PERF_IX_MEM_SIZE,
+ PERF_IX_MEM_PRIV,
+ PERF_IX_THREAD_CNT,
+ PERF_IX_HANDLE_CNT,
+ PERF_IX_PID,
+ PERF_IX_PPID,
+ PERF_IX_PRIORITY,
+ PERF_IX_START_TIME,
+ PERF_IX_MAX
+} perf_proc_offsets_t;
+
+/*
+ * diff is:
+ * ExW -> ExA
+ * wcounter -> counter
+ */
+#define MyRegQueryValue() \
+ (USING_WIDE() ? \
+ RegQueryValueExW(sigar->handle, \
+ wcounter_key, NULL, &type, \
+ sigar->perfbuf, \
+ &sigar->perfbuf_size) : \
+ RegQueryValueExA(sigar->handle, \
+ counter_key, NULL, &type, \
+ sigar->perfbuf, \
+ &sigar->perfbuf_size))
+
+#define PERF_VAL(ix) \
+ perf_offsets[ix] ? \
+ *((DWORD *)((BYTE *)counter_block + perf_offsets[ix])) : 0
+
+static PERF_OBJECT_TYPE *get_perf_object(sigar_t *sigar, char *counter_key)
+{
+ DWORD retval, type;
+ WCHAR wcounter_key[MAX_PATH+1];
+ PERF_DATA_BLOCK *block;
+
+ if (!sigar->perfbuf) {
+ sigar->perfbuf = (char *)malloc(PERFBUF_SIZE);
+ sigar->perfbuf_size = PERFBUF_SIZE;
+ }
+
+ if (USING_WIDE()) {
+ SIGAR_A2W(counter_key, wcounter_key, sizeof(wcounter_key));
+ }
+
+ while ((retval = MyRegQueryValue()) != ERROR_SUCCESS) {
+ if (retval == ERROR_MORE_DATA) {
+ sigar->perfbuf_size += PERFBUF_SIZE;
+
+ sigar->perfbuf = (char *)realloc(sigar->perfbuf,
+ sigar->perfbuf_size);
+ }
+ else {
+ printf("RegQueryValueEx failed: %d\n", retval);
+ return NULL;
+ }
+ }
+
+ block = (PERF_DATA_BLOCK *)sigar->perfbuf;
+
+ return PdhFirstObject(block);
+}
+
+static void get_sysinfo(sigar_t *sigar)
+{
+ SYSTEM_INFO sysinfo;
+
+ GetSystemInfo(&sysinfo);
+
+ sigar->ncpu = sysinfo.dwNumberOfProcessors;
+ sigar->pagesize = sysinfo.dwPageSize;
+}
+
+/* for C# bindings */
+SIGAR_DECLARE(sigar_t *) sigar_new(void)
+{
+ sigar_t *sigar;
+ if (sigar_open(&sigar) != SIGAR_OK) {
+ return NULL;
+ }
+ return sigar;
+}
+
+int sigar_os_open(sigar_t **sigar)
+{
+ LONG result;
+ HINSTANCE h;
+
+ *sigar = malloc(sizeof(**sigar));
+ (*sigar)->machine = ""; /* local machine */
+ (*sigar)->using_wide = 0; /*XXX*/
+
+ (*sigar)->perfbuf = NULL;
+ (*sigar)->perfbuf_size = 0;
+
+ if (USING_WIDE_S(*sigar)) {
+ WCHAR wmachine[MAX_PATH+1];
+
+ SIGAR_A2W((*sigar)->machine, wmachine, sizeof(wmachine));
+
+ result = RegConnectRegistryW(wmachine,
+ HKEY_PERFORMANCE_DATA,
+ &(*sigar)->handle);
+ }
+ else {
+ result = RegConnectRegistryA((*sigar)->machine,
+ HKEY_PERFORMANCE_DATA,
+ &(*sigar)->handle);
+ }
+
+ get_sysinfo(*sigar);
+
+ if ((h = LoadLibrary("iphlpapi.dll"))) {
+ (*sigar)->get_if_table =
+ (LPGETIFTABLE)GetProcAddress(h, "GetIfTable");
+ (*sigar)->get_ipforward_table =
+ (LPGETIPFORWARDTABLE)GetProcAddress(h, "GetIpForwardTable");
+ (*sigar)->get_tcp_table =
+ (LPGETTCPTABLE)GetProcAddress(h, "GetTcpTable");
+ (*sigar)->get_tcpx_table =
+ (LPGETTCPEXTABLE)GetProcAddress(h,
+ "AllocateAndGet"
+ "TcpExTableFromStack");
+ (*sigar)->get_udp_table =
+ (LPGETUDPTABLE)GetProcAddress(h, "GetUdpTable");
+ }
+ else {
+ (*sigar)->get_if_table = NULL;
+ (*sigar)->get_ipforward_table = NULL;
+ }
+
+ (*sigar)->ip_handle = h;
+ (*sigar)->pinfo.pid = -1;
+ (*sigar)->ws_version = 0;
+ (*sigar)->ncpu = 0;
+ (*sigar)->peb = NULL;
+
+ return result;
+}
+
+int sigar_os_close(sigar_t *sigar)
+{
+ int retval;
+
+ if (sigar->perfbuf) {
+ free(sigar->perfbuf);
+ }
+
+ retval = RegCloseKey(sigar->handle);
+
+ if (sigar->ip_handle) {
+ FreeLibrary(sigar->ip_handle);
+ }
+
+ if (sigar->ws_version != 0) {
+ WSACleanup();
+ }
+
+ if (sigar->peb) {
+ free(sigar->peb);
+ }
+
+ free(sigar);
+
+ return retval;
+}
+
+char *sigar_os_error_string(int err)
+{
+ return NULL;
+}
+
+int sigar_wsa_init(sigar_t *sigar)
+{
+ if (sigar->ws_version == 0) {
+ WSADATA data;
+
+ if (WSAStartup(MAKEWORD(2, 0), &data)) {
+ sigar->ws_error = WSAGetLastError();
+ WSACleanup();
+ return sigar->ws_error;
+ }
+
+ sigar->ws_version = data.wVersion;
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
+{
+ MEMORYSTATUS memstat;
+
+ GlobalMemoryStatus(&memstat);
+
+ mem->total = memstat.dwTotalPhys;
+ mem->free = memstat.dwAvailPhys;
+ mem->shared = memstat.dwTotalVirtual - memstat.dwAvailVirtual;
+ mem->used = mem->total - mem->free;
+
+ sigar_mem_calc_ram(sigar, mem);
+
+ /*XXX*/
+ mem->buffer = 0;
+ mem->cached = 0;
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
+{
+ MEMORYSTATUS memstat;
+
+ GlobalMemoryStatus(&memstat);
+
+ swap->total = memstat.dwTotalPageFile;
+ swap->free = memstat.dwAvailPageFile;
+ swap->used = swap->total - swap->free;
+
+ return SIGAR_OK;
+}
+
+static PERF_INSTANCE_DEFINITION *get_cpu_instance(sigar_t *sigar,
+ DWORD *perf_offsets,
+ DWORD *num)
+{
+ PERF_OBJECT_TYPE *object = get_perf_object(sigar, "238");
+ PERF_INSTANCE_DEFINITION *inst;
+ PERF_COUNTER_DEFINITION *counter;
+ DWORD i;
+
+ if (!object) {
+ return NULL;
+ }
+
+ for (i=0, counter = PdhFirstCounter(object);
+ iNumCounters;
+ i++, counter = PdhNextCounter(counter))
+ {
+ DWORD offset = counter->CounterOffset;
+
+ switch (counter->CounterNameTitleIndex) {
+ case PERF_TITLE_CPU_SYS:
+ perf_offsets[PERF_IX_CPU_SYS] = offset;
+ break;
+ case PERF_TITLE_CPU_USER:
+ perf_offsets[PERF_IX_CPU_USER] = offset;
+ break;
+ case PERF_TITLE_CPU_IDLE:
+ perf_offsets[PERF_IX_CPU_IDLE] = offset;
+ break;
+ }
+ }
+
+ if (num) {
+ *num = object->NumInstances;
+ }
+
+ return PdhFirstInstance(object);
+}
+
+SIGAR_DECLARE(int) sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
+{
+ PERF_INSTANCE_DEFINITION *inst;
+ PERF_COUNTER_BLOCK *counter_block;
+ DWORD perf_offsets[PERF_IX_CPU_MAX];
+
+ SIGAR_ZERO(cpu);
+ memset(&perf_offsets, 0, sizeof(perf_offsets));
+
+ inst = get_cpu_instance(sigar, (DWORD*)&perf_offsets, 0);
+
+ if (!inst) {
+ return GetLastError();
+ }
+
+ /* first instance is total, rest are per-cpu */
+ counter_block = PdhGetCounterBlock(inst);
+
+ cpu->sys = PERF_VAL(PERF_IX_CPU_SYS);
+ cpu->user = PERF_VAL(PERF_IX_CPU_USER);
+ cpu->idle = PERF_VAL(PERF_IX_CPU_IDLE);
+ cpu->nice = 0; /* no nice here */
+
+ cpu->total = cpu->sys + cpu->user + cpu->idle;
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
+{
+ int status, i, j, hthread=0;
+ PERF_INSTANCE_DEFINITION *inst;
+ DWORD perf_offsets[PERF_IX_CPU_MAX], num;
+
+ memset(&perf_offsets, 0, sizeof(perf_offsets));
+
+ /* first instance is total, rest are per-cpu */
+ inst = get_cpu_instance(sigar, (DWORD*)&perf_offsets, &num);
+ --num;
+
+ if (!inst) {
+ return GetLastError();
+ }
+
+ sigar_cpu_count(sigar);
+ sigar_cpu_list_create(cpulist);
+
+ /*
+ * if hyper-threading was detected and ncpu is less than
+ * the number of counter instances, assume there is a counter
+ * for each logical processor.
+ * XXX assuming this is correct until have something to test on.
+ */
+ if (sigar->ht_enabled && ((sigar->ncpu * 2) == num)) {
+ hthread = 1;
+ }
+
+ for (i=0; idata[cpulist->number-1];
+ }
+ else {
+ SIGAR_CPU_LIST_GROW(cpulist);
+ cpu = &cpulist->data[cpulist->number++];
+ SIGAR_ZERO(cpu);
+ }
+
+ inst = PdhNextInstance(inst);
+ counter_block = PdhGetCounterBlock(inst);
+
+ cpu->sys += PERF_VAL(PERF_IX_CPU_SYS);
+ cpu->user += PERF_VAL(PERF_IX_CPU_USER);
+ cpu->idle += PERF_VAL(PERF_IX_CPU_IDLE);
+ cpu->nice = 0; /* no nice here */
+
+ cpu->total += cpu->sys + cpu->user + cpu->idle;
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_uptime_get(sigar_t *sigar,
+ sigar_uptime_t *uptime)
+{
+ uptime->idletime = 0;
+ uptime->uptime = GetTickCount() / 1000;
+ return SIGAR_OK;
+}
+
+/*
+ * there is no api for this info.
+ * closest i've seen is enumerating the entire process table
+ * and calculating an average based on process times.
+ */
+SIGAR_DECLARE(int) sigar_loadavg_get(sigar_t *sigar,
+ sigar_loadavg_t *loadavg)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+#define get_process_object(sigar) \
+ get_perf_object(sigar, PERF_TITLE_PROC_KEY)
+
+SIGAR_DECLARE(int) sigar_proc_list_get(sigar_t *sigar,
+ sigar_proc_list_t *proclist)
+{
+ PERF_OBJECT_TYPE *object;
+ PERF_INSTANCE_DEFINITION *inst;
+ PERF_COUNTER_DEFINITION *counter;
+ DWORD i;
+ DWORD perf_offsets[PERF_IX_MAX];
+
+ perf_offsets[PERF_IX_PID] = 0;
+
+ object = get_process_object(sigar);
+
+ if (!object) {
+ return GetLastError();
+ }
+
+ sigar_proc_list_create(proclist);
+
+ /*
+ * note we assume here:
+ * block->NumObjectTypes == 1
+ * object->ObjectNameTitleIndex == PERF_TITLE_PROC
+ *
+ * which should always be the case.
+ */
+
+ for (i=0, counter = PdhFirstCounter(object);
+ iNumCounters;
+ i++, counter = PdhNextCounter(counter))
+ {
+ DWORD offset = counter->CounterOffset;
+
+ switch (counter->CounterNameTitleIndex) {
+ case PERF_TITLE_PID:
+ perf_offsets[PERF_IX_PID] = offset;
+ break;
+ }
+ }
+
+ for (i=0, inst = PdhFirstInstance(object);
+ iNumInstances;
+ i++, inst = PdhNextInstance(inst))
+ {
+ PERF_COUNTER_BLOCK *counter_block = PdhGetCounterBlock(inst);
+ SIGAR_PROC_LIST_GROW(proclist);
+
+ proclist->data[proclist->number++] =
+ PERF_VAL(PERF_IX_PID);
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_proc_stat_get(sigar_t *sigar,
+ sigar_proc_stat_t *procstat)
+{
+ int status = /* XXX optimize */
+ sigar_proc_count(sigar, &procstat->total);
+
+ return status;
+}
+
+#define PROCESS_DAC (PROCESS_QUERY_INFORMATION|PROCESS_VM_READ)
+
+static HANDLE open_process(sigar_pid_t pid)
+{
+ return OpenProcess(PROCESS_DAC, 0, (DWORD)pid);
+}
+
+SIGAR_DECLARE(int) sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_mem_t *procmem)
+{
+ int status = get_proc_info(sigar, pid);
+ sigar_win32_pinfo_t *pinfo = &sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ procmem->vsize = pinfo->vsize;
+ procmem->size = pinfo->size;
+ procmem->resident = -1;
+ procmem->share = -1;
+ procmem->rss = -1;
+
+ return SIGAR_OK;
+}
+
+#define TOKEN_DAC (STANDARD_RIGHTS_READ | READ_CONTROL | TOKEN_QUERY)
+
+SIGAR_DECLARE(int)
+sigar_proc_cred_name_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_name_t *proccredname)
+{
+ HANDLE proc, token;
+ DWORD len;
+ int success;
+ TOKEN_USER *user = NULL;
+ TOKEN_PRIMARY_GROUP *group = NULL;
+ SID_NAME_USE type;
+ char domain[SIGAR_CRED_NAME_MAX];
+
+ /* XXX cache lookup */
+
+ if (!(proc = open_process(pid))) {
+ return GetLastError();
+ }
+
+ if (!OpenProcessToken(proc, TOKEN_DAC, &token)) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ CloseHandle(proc);
+
+ success =
+ !GetTokenInformation(token, TokenUser, NULL, 0, &len) &&
+ (GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
+ (user = malloc(len)) &&
+ GetTokenInformation(token, TokenUser, user, len, &len);
+
+ if (success) {
+ DWORD domain_len = sizeof(domain);
+ DWORD user_len = sizeof(proccredname->user);
+
+ success = LookupAccountSid(NULL, user->User.Sid,
+ proccredname->user, &user_len,
+ domain, &domain_len, &type);
+ }
+
+ if (user != NULL) {
+ free(user);
+ }
+ if (!success) {
+ CloseHandle(token);
+ return GetLastError();
+ }
+
+ success =
+ !GetTokenInformation(token, TokenPrimaryGroup, NULL, 0, &len) &&
+ (GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
+ (group = malloc(len)) &&
+ GetTokenInformation(token, TokenPrimaryGroup, group, len, &len);
+
+ if (success) {
+ DWORD domain_len = sizeof(domain);
+ DWORD group_len = sizeof(proccredname->group);
+
+ success = LookupAccountSid(NULL, group->PrimaryGroup,
+ proccredname->group, &group_len,
+ domain, &domain_len, &type);
+ }
+
+ if (group != NULL) {
+ free(group);
+ }
+
+ CloseHandle(token);
+
+ if (!success) {
+ return GetLastError();
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_cred_t *proccred)
+{
+ return SIGAR_ENOTIMPL;
+}
+
+#define FILETIME2SEC(ft) \
+ (((ft.dwHighDateTime << 32) | ft.dwLowDateTime) / 10000000)
+
+SIGAR_DECLARE(int) sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_time_t *proctime)
+{
+ HANDLE proc = open_process(pid);
+ FILETIME start_time, exit_time, system_time, user_time;
+
+ if (!proc) {
+ return GetLastError();
+ }
+
+ if (!GetProcessTimes(proc,
+ &start_time, &exit_time,
+ &system_time, &user_time))
+ {
+ return GetLastError();
+ }
+
+ CloseHandle(proc);
+
+ if (start_time.dwHighDateTime) {
+ proctime->start_time = FileTimeToTime(&start_time) / 1000;
+ }
+ else {
+ proctime->start_time = 0;
+ }
+
+ proctime->utime = FILETIME2SEC(user_time);
+ proctime->stime = FILETIME2SEC(system_time);
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_state_t *procstate)
+{
+ int status = get_proc_info(sigar, pid);
+ sigar_win32_pinfo_t *pinfo = &sigar->pinfo;
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ memcpy(procstate->name, pinfo->name, sizeof(procstate->name));
+ procstate->state = pinfo->state;
+ procstate->ppid = pinfo->ppid;
+ procstate->priority = pinfo->priority;
+ procstate->nice = -1;
+ procstate->tty = -1;
+
+ return SIGAR_OK;
+}
+
+static int get_proc_info(sigar_t *sigar, sigar_pid_t pid)
+{
+ PERF_OBJECT_TYPE *object;
+ PERF_INSTANCE_DEFINITION *inst;
+ PERF_COUNTER_DEFINITION *counter;
+ DWORD i;
+ DWORD perf_offsets[PERF_IX_MAX];
+ sigar_win32_pinfo_t *pinfo = &sigar->pinfo;
+ time_t timenow = time(NULL);
+
+ if (pinfo->pid == pid) {
+ if ((timenow - pinfo->mtime) < SIGAR_LAST_PROC_EXPIRE) {
+ return SIGAR_OK;
+ }
+ }
+
+ pinfo->pid = pid;
+ pinfo->mtime = timenow;
+
+ memset(&perf_offsets, 0, sizeof(perf_offsets));
+
+ object = get_process_object(sigar);
+
+ /*
+ * note we assume here:
+ * block->NumObjectTypes == 1
+ * object->ObjectNameTitleIndex == PERF_TITLE_PROC
+ *
+ * which should always be the case.
+ */
+
+ for (i=0, counter = PdhFirstCounter(object);
+ iNumCounters;
+ i++, counter = PdhNextCounter(counter))
+ {
+ DWORD offset = counter->CounterOffset;
+
+ switch (counter->CounterNameTitleIndex) {
+ case PERF_TITLE_CPUTIME:
+ perf_offsets[PERF_IX_CPUTIME] = offset;
+ break;
+ case PERF_TITLE_MEM_VSIZE:
+ perf_offsets[PERF_IX_MEM_VSIZE] = offset;
+ break;
+ case PERF_TITLE_MEM_SIZE:
+ perf_offsets[PERF_IX_MEM_SIZE] = offset;
+ break;
+ case PERF_TITLE_MEM_PRIV:
+ perf_offsets[PERF_IX_MEM_PRIV] = offset;
+ break;
+ case PERF_TITLE_THREAD_CNT:
+ perf_offsets[PERF_IX_THREAD_CNT] = offset;
+ break;
+ case PERF_TITLE_HANDLE_CNT:
+ perf_offsets[PERF_IX_HANDLE_CNT] = offset;
+ break;
+ case PERF_TITLE_PID:
+ perf_offsets[PERF_IX_PID] = offset;
+ break;
+ case PERF_TITLE_PPID:
+ perf_offsets[PERF_IX_PPID] = offset;
+ break;
+ case PERF_TITLE_PRIORITY:
+ perf_offsets[PERF_IX_PRIORITY] = offset;
+ break;
+ case PERF_TITLE_START_TIME:
+ perf_offsets[PERF_IX_START_TIME] = offset;
+ break;
+ }
+ }
+
+ for (i=0, inst = PdhFirstInstance(object);
+ iNumInstances;
+ i++, inst = PdhNextInstance(inst))
+ {
+ PERF_COUNTER_BLOCK *counter_block = PdhGetCounterBlock(inst);
+ sigar_pid_t this_pid = PERF_VAL(PERF_IX_PID);
+
+ if (this_pid != pid) {
+ continue;
+ }
+
+ pinfo->state = 'R'; /* XXX? */
+ SIGAR_W2A(PdhInstanceName(inst),
+ pinfo->name, sizeof(pinfo->name));
+
+ pinfo->size = PERF_VAL(PERF_IX_MEM_SIZE);
+ pinfo->vsize = PERF_VAL(PERF_IX_MEM_VSIZE);
+ pinfo->ppid = PERF_VAL(PERF_IX_PPID);
+ pinfo->priority = PERF_VAL(PERF_IX_PRIORITY);
+ pinfo->handles = PERF_VAL(PERF_IX_HANDLE_CNT);
+
+ return SIGAR_OK;
+ }
+
+ return -1; /*XXX*/
+}
+
+static char *getarg(char **line)
+{
+ char *str = *line, *end;
+ char *res;
+ int len;
+
+ while (*str && isspace(*str)) {
+ ++str;
+ }
+
+ if (!*str) {
+ *line = str;
+ return NULL;
+ }
+
+ if (*str == '"') {
+ end = str + 1;
+
+ while (*end && (*end != '"')) {
+ ++end;
+ }
+
+ len = end - str - 1;
+ res = malloc(len+1);
+ memcpy(res, str+1, len);
+ res[len] = '\0';
+ end++;
+ }
+ else {
+ end = str;
+ while (*end && !isspace(*end)) {
+ ++end;
+ }
+
+ len = end - str;
+ res = malloc(len+1);
+ memcpy(res, str, len);
+ res[len] = '\0';
+ }
+
+ while (*end && isspace(*end)) {
+ ++end;
+ }
+
+ *line = end;
+
+ return res;
+}
+
+/*
+ * this is ugly, but there is no alternative.
+ * we spawn a remote thread within the process
+ * to call GetCommandLine() and parse it ourselves.
+ */
+static int sigar_remote_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ FARPROC rcmdline, fstrlen;
+ HANDLE proc, thread, kdll;
+ PVOID data=NULL;
+ char *cmdline;
+ DWORD rv, thrid, bytes, datalen=0;
+
+ if (!(kdll = GetModuleHandle("kernel32.dll"))) {
+ return GetLastError();
+ }
+
+ if (!(rcmdline = GetProcAddress(kdll, "GetCommandLineA"))) {
+ return GetLastError();
+ }
+
+ if (!(fstrlen = GetProcAddress(kdll, "lstrlenA"))) {
+ return GetLastError();
+ }
+
+ if (!(proc = OpenProcess(MAXIMUM_ALLOWED, 0, (DWORD)pid))) {
+ return GetLastError();
+ }
+
+ thread = CreateRemoteThread(proc, NULL, 0,
+ (LPTHREAD_START_ROUTINE)rcmdline,
+ 0, 0, &thrid);
+ if (!thread) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ WaitForSingleObject(thread, INFINITE);
+ GetExitCodeThread(thread, (LPDWORD)(&data));
+ CloseHandle(thread);
+
+ if (!data) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ thread = CreateRemoteThread(proc, NULL, 0,
+ (LPTHREAD_START_ROUTINE)fstrlen,
+ data, 0, &thrid);
+ if (!thread) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ WaitForSingleObject(thread, INFINITE);
+ GetExitCodeThread(thread, &datalen);
+ CloseHandle(thread);
+
+ if (!datalen) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ cmdline = HeapAlloc(GetProcessHeap(),
+ HEAP_ZERO_MEMORY,
+ datalen);
+
+ if (!cmdline) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ if (ReadProcessMemory(proc, data, cmdline,
+ datalen+1, &bytes))
+ {
+ char *arg, *ptr = cmdline;
+
+ sigar_proc_args_create(procargs);
+
+ while (*ptr && (arg = getarg(&ptr))) {
+ SIGAR_PROC_ARGS_GROW(procargs);
+ procargs->data[procargs->number++] = arg;
+ }
+
+ HeapFree(GetProcessHeap(), 0, cmdline);
+ }
+ else {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ CloseHandle(proc);
+ return SIGAR_OK;
+}
+
+static int sigar_local_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ LPTSTR cmdline = GetCommandLine();
+ char *arg, *ptr = cmdline;
+
+ sigar_proc_args_create(procargs);
+
+ while (*ptr && (arg = getarg(&ptr))) {
+ SIGAR_PROC_ARGS_GROW(procargs);
+ procargs->data[procargs->number++] = arg;
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_args_t *procargs)
+{
+ if (pid == sigar->pid) {
+ return sigar_local_proc_args_get(sigar, pid, procargs);
+ }
+ else {
+ return sigar_remote_proc_args_get(sigar, pid, procargs);
+ }
+}
+
+static int sigar_local_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ UCHAR *ptr, *env;
+
+ env = ptr = (UCHAR*)GetEnvironmentStrings();
+
+ while (*ptr) {
+ char *val;
+ int klen, vlen, status;
+ char key[128]; /* XXX is there a max key size? */
+
+ if (*ptr == '=') {
+ ptr += strlen(ptr)+1;
+ continue;
+ }
+
+ val = strchr(ptr, '=');
+
+ if (val == NULL) {
+ break; /*XXX*/
+ }
+
+ klen = val - ptr;
+ SIGAR_SSTRCPY(key, ptr);
+ key[klen] = '\0';
+ ++val;
+
+ vlen = strlen(val);
+
+ status = procenv->env_getter(procenv->data,
+ key, klen, val, vlen);
+
+ if (status != SIGAR_OK) {
+ /* not an error; just stop iterating */
+ break;
+ }
+
+ ptr += klen + 1 + vlen + 1;
+ }
+
+ FreeEnvironmentStrings(env);
+
+ return SIGAR_OK;
+}
+
+static int sigar_remote_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ FARPROC rgetenv, fstrlen;
+ HANDLE proc, thread, kdll;
+ PVOID data=NULL;
+ const char *key;
+ char *value;
+ DWORD rv, thrid, bytes, datalen=0, size;
+ LPVOID addr;
+
+ if (!(kdll = GetModuleHandle("msvcrt.dll"))) {
+ return GetLastError();
+ }
+
+ if (!(rgetenv = GetProcAddress(kdll, "getenv"))) {
+ return GetLastError();
+ }
+
+ if (!(kdll = GetModuleHandle("kernel32.dll"))) {
+ return GetLastError();
+ }
+
+ if (!(fstrlen = GetProcAddress(kdll, "lstrlenA"))) {
+ return GetLastError();
+ }
+
+ if (!(proc = OpenProcess(MAXIMUM_ALLOWED, 0, (DWORD)pid))) {
+ return GetLastError();
+ }
+
+ key = procenv->key;
+ size = procenv->klen+1;
+ addr = VirtualAllocEx(proc, NULL, size,
+ MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+ if (!addr) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ if (!WriteProcessMemory(proc, addr, (char*)&key[0], size, 0)) {
+ VirtualFreeEx(proc, addr, size, 0);
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ thread = CreateRemoteThread(proc, NULL, 0,
+ (LPTHREAD_START_ROUTINE)rgetenv,
+ addr, 0, &thrid);
+ if (!thread) {
+ VirtualFreeEx(proc, addr, size, 0);
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ WaitForSingleObject(thread, INFINITE);
+ GetExitCodeThread(thread, (LPDWORD)(&data));
+ CloseHandle(thread);
+ VirtualFreeEx(proc, addr, size, 0);
+
+ if (!data) {
+ CloseHandle(proc);
+ return SIGAR_OK;
+ }
+
+ thread = CreateRemoteThread(proc, NULL, 0,
+ (LPTHREAD_START_ROUTINE)fstrlen,
+ data, 0, &thrid);
+ if (!thread) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ WaitForSingleObject(thread, INFINITE);
+ GetExitCodeThread(thread, &datalen);
+ CloseHandle(thread);
+
+ if (!datalen) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ value = HeapAlloc(GetProcessHeap(),
+ HEAP_ZERO_MEMORY,
+ datalen);
+
+ if (!value) {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ if (ReadProcessMemory(proc, data, value,
+ datalen+1, &bytes))
+ {
+ procenv->env_getter(procenv->data,
+ key, strlen(key),
+ value, bytes-1);
+
+ HeapFree(GetProcessHeap(), 0, value);
+ }
+ else {
+ CloseHandle(proc);
+ return GetLastError();
+ }
+
+ CloseHandle(proc);
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_env_t *procenv)
+{
+ if (pid == sigar->pid) {
+ if (procenv->type == SIGAR_PROC_ENV_KEY) {
+ char value[32767]; /* max size from msdn docs */
+ DWORD retval =
+ GetEnvironmentVariable(procenv->key, value, sizeof(value));
+
+ if (retval == 0) {
+ if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
+ return SIGAR_OK;
+ }
+ return GetLastError();
+ }
+ else if (retval > sizeof(value)) {
+ /* XXX shouldnt happen */
+ return GetLastError();
+ }
+
+ procenv->env_getter(procenv->data,
+ procenv->key, procenv->klen,
+ value, retval);
+ return SIGAR_OK;
+ }
+ else {
+ return sigar_local_proc_env_get(sigar, pid, procenv);
+ }
+ }
+ else {
+ if (procenv->type == SIGAR_PROC_ENV_KEY) {
+ return sigar_remote_proc_env_get(sigar, pid, procenv);
+ }
+ else {
+ return SIGAR_ENOTIMPL;
+ }
+ }
+}
+
+SIGAR_DECLARE(int) sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_fd_t *procfd)
+{
+ int status;
+ sigar_win32_pinfo_t *pinfo = &sigar->pinfo;
+
+ pinfo->pid = -1; /* force update */
+ if ((status = get_proc_info(sigar, pid)) != SIGAR_OK) {
+ return status;
+ }
+
+ procfd->total = pinfo->handles;
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
+ sigar_proc_exe_t *procexe)
+{
+ int status = SIGAR_OK;
+ HANDLE proc = open_process(pid);
+
+ if (!proc) {
+ return GetLastError();
+ }
+
+ procexe->cwd[0] = '\0';
+ procexe->root[0] = '\0';
+
+ status = sigar_proc_exe_name_get(sigar, proc, procexe->name);
+
+ return status;
+}
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp)
+{
+ return fsp->type;
+}
+
+SIGAR_DECLARE(int) sigar_file_system_list_get(sigar_t *sigar,
+ sigar_file_system_list_t *fslist)
+{
+ sigar_file_system_t *fsp;
+ char name[256];
+ char *ptr = name;
+ /* XXX: hmm, Find{First,Next}Volume not available in my sdk */
+ DWORD len = GetLogicalDriveStringsA(sizeof(name), name);
+
+ if (len == 0) {
+ return GetLastError();
+ }
+
+ sigar_file_system_list_create(fslist);
+
+ while (*ptr) {
+ DWORD flags, serialnum=0;
+ char fsname[1024];
+ UINT type;
+
+ fsname[0] = '\0';
+
+ GetVolumeInformation(ptr, NULL, 0, &serialnum, NULL,
+ &flags, fsname, sizeof(fsname));
+
+ type = GetDriveType(ptr);
+
+ if (!serialnum && (type == DRIVE_FIXED)) {
+ ptr += strlen(ptr)+1;
+ continue; /* ignore unformatted partitions */
+ }
+
+ SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
+
+ fsp = &fslist->data[fslist->number++];
+
+ SIGAR_SSTRCPY(fsp->dir_name, ptr);
+ SIGAR_SSTRCPY(fsp->dev_name, ptr);
+
+ switch (type) {
+ case DRIVE_FIXED:
+ fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
+ break;
+ case DRIVE_REMOTE:
+ fsp->type = SIGAR_FSTYPE_NETWORK;
+ break;
+ case DRIVE_CDROM:
+ fsp->type = SIGAR_FSTYPE_CDROM;
+ break;
+ case DRIVE_RAMDISK:
+ fsp->type = SIGAR_FSTYPE_RAM_DISK;
+ break;
+ case DRIVE_REMOVABLE:
+ /* XXX */
+ default:
+ fsp->type = SIGAR_FSTYPE_NONE;
+ break;
+ }
+
+ /* we set fsp->type, just looking up sigar.c:fstype_names[type] */
+ sigar_fs_type_get(fsp);
+
+ if (*fsname == '\0') {
+ SIGAR_SSTRCPY(fsp->sys_type_name, fsp->type_name);
+ }
+ else {
+ SIGAR_SSTRCPY(fsp->sys_type_name, fsname); /* CDFS, NTFS, etc */
+ }
+
+ ptr += strlen(ptr)+1;
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int)
+sigar_file_system_usage_get(sigar_t *sigar,
+ const char *dirname,
+ sigar_file_system_usage_t *fsusage)
+{
+ BOOL retval;
+ ULARGE_INTEGER avail, total, free;
+
+ /* prevent dialog box if A:\ drive is empty */
+ UINT errmode = SetErrorMode(SEM_FAILCRITICALERRORS);
+
+ retval = GetDiskFreeSpaceEx(dirname,
+ &avail, &total, &free);
+
+ /* restore previous error mode */
+ SetErrorMode(errmode);
+
+ if (!retval) {
+ return GetLastError();
+ }
+
+ fsusage->total = total.QuadPart / 1024;
+ fsusage->free = free.QuadPart / 1024;
+ fsusage->avail = avail.QuadPart / 1024;
+
+ fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
+
+ /* XXX */
+ fsusage->files = 0;
+ fsusage->free_files = 0;
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_cpu_infos_get(sigar_t *sigar,
+ sigar_cpu_infos_t *cpu_infos)
+{
+ int i, status;
+ sigar_cpu_info_t *info;
+
+ sigar_cpu_count(sigar);
+
+ sigar_cpu_infos_create(cpu_infos);
+
+ info = &cpu_infos->data[cpu_infos->number++];
+
+ status = sigar_cpu_info_get(sigar, info);
+
+ if (status != SIGAR_OK) {
+ return status;
+ }
+
+ if (sigar->ncpu > 1) {
+ for (i=1; incpu; i++) {
+ SIGAR_CPU_INFOS_GROW(cpu_infos);
+
+ memcpy(&cpu_infos->data[cpu_infos->number++],
+ info, sizeof(*info));
+ }
+ }
+
+ return SIGAR_OK;
+}
+
+SIGAR_DECLARE(int) sigar_net_route_list_get(sigar_t *sigar,
+ sigar_net_route_list_t *routelist)
+{
+ char *buffer = NULL;
+ ULONG bufsize = 0;
+ DWORD rc, i;
+ MIB_IPFORWARDTABLE *ipt;
+ sigar_net_route_t *route;
+
+ if (!sigar->get_ipforward_table) {
+ return SIGAR_ENOTIMPL;
+ }
+
+ rc = (*(sigar->get_ipforward_table))((PMIB_IPFORWARDTABLE)buffer,
+ &bufsize, FALSE);
+ if (rc != ERROR_INSUFFICIENT_BUFFER) {
+ return GetLastError();
+ }
+
+ buffer = malloc(bufsize);
+ rc = (*(sigar->get_ipforward_table))((PMIB_IPFORWARDTABLE)buffer,
+ &bufsize, FALSE);
+ if (rc != NO_ERROR) {
+ free(buffer);
+ return GetLastError();
+ }
+
+ sigar_net_route_list_create(routelist);
+ routelist->size = routelist->number = 0;
+
+ ipt = (MIB_IPFORWARDTABLE *)buffer;
+
+ for (i=0; i