/* * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.management.counter.perf; import sun.management.counter.*;import java.nio.*; class Prologue {    // these constants should match their #define counterparts in vmdata.hpp    private final static byte PERFDATA_BIG_ENDIAN    = 0;    private final static byte PERFDATA_LITTLE_ENDIAN = 1;    private final static int  PERFDATA_MAGIC         = 0xcafec0c0;     private class PrologueFieldOffset {        private final static int SIZEOF_BYTE = 1;        private final static int SIZEOF_INT  = 4;        private final static int SIZEOF_LONG = 8;         private final static int MAGIC_SIZE            = SIZEOF_INT;        private final static int BYTE_ORDER_SIZE       = SIZEOF_BYTE;        private final static int MAJOR_SIZE            = SIZEOF_BYTE;        private final static int MINOR_SIZE            = SIZEOF_BYTE;        private final static int ACCESSIBLE_SIZE       = SIZEOF_BYTE;        private final static int USED_SIZE             = SIZEOF_INT;        private final static int OVERFLOW_SIZE         = SIZEOF_INT;        private final static int MOD_TIMESTAMP_SIZE    = SIZEOF_LONG;        private final static int ENTRY_OFFSET_SIZE     = SIZEOF_INT;        private final static int NUM_ENTRIES_SIZE      = SIZEOF_INT;         // these constants must match the field offsets and sizes        // in the PerfDataPrologue structure in perfMemory.hpp        final static int MAGIC          = 0;        final static int BYTE_ORDER     = MAGIC + MAGIC_SIZE;        final static int MAJOR_VERSION  = BYTE_ORDER + BYTE_ORDER_SIZE;        final static int MINOR_VERSION  = MAJOR_VERSION + MAJOR_SIZE;        final static int ACCESSIBLE     = MINOR_VERSION + MINOR_SIZE;        final static int USED           = ACCESSIBLE + ACCESSIBLE_SIZE;        final static int OVERFLOW       = USED + USED_SIZE;        final static int MOD_TIMESTAMP  = OVERFLOW + OVERFLOW_SIZE;        final static int ENTRY_OFFSET   = MOD_TIMESTAMP + MOD_TIMESTAMP_SIZE;        final static int NUM_ENTRIES    = ENTRY_OFFSET + ENTRY_OFFSET_SIZE;        final static int PROLOGUE_2_0_SIZE = NUM_ENTRIES + NUM_ENTRIES_SIZE;    }      private ByteBuffer header;    private int magic;     Prologue(ByteBuffer b) {        this.header = b.duplicate();         // the magic number is always stored in big-endian format        // save and restore the buffer's initial byte order around        // the fetch of the data.        header.order(ByteOrder.BIG_ENDIAN);        header.position(PrologueFieldOffset.MAGIC);        magic = header.getInt();         // the magic number is always stored in big-endian format        if (magic != PERFDATA_MAGIC) {            throw new InstrumentationException("Bad Magic: " +                                               Integer.toHexString(getMagic()));        }          // set the buffer's byte order according to the value of its        // byte order field.        header.order(getByteOrder());         // Check version        int major = getMajorVersion();        int minor = getMinorVersion();         if (major < 2) {            throw new InstrumentationException("Unsupported version: " +                                               major + "." + minor);        }         // Currently, only support 2.0 version.        header.limit(PrologueFieldOffset.PROLOGUE_2_0_SIZE);    }     public int getMagic() {        return magic;    }     public int getMajorVersion() {        header.position(PrologueFieldOffset.MAJOR_VERSION);        return (int)header.get();    }     public int getMinorVersion() {        header.position(PrologueFieldOffset.MINOR_VERSION);        return (int)header.get();    }     public ByteOrder getByteOrder() {        header.position(PrologueFieldOffset.BYTE_ORDER);         byte byte_order = header.get();        if (byte_order == PERFDATA_BIG_ENDIAN) {            return ByteOrder.BIG_ENDIAN;        }        else {            return ByteOrder.LITTLE_ENDIAN;        }    }     public int getEntryOffset() {        header.position(PrologueFieldOffset.ENTRY_OFFSET);        return header.getInt();    }     // The following fields are updated asynchronously    // while they are accessed by these methods.    public int getUsed() {        header.position(PrologueFieldOffset.USED);        return header.getInt();    }     public int getOverflow() {        header.position(PrologueFieldOffset.OVERFLOW);        return header.getInt();    }     public long getModificationTimeStamp() {        header.position(PrologueFieldOffset.MOD_TIMESTAMP);        return header.getLong();    }     public int getNumEntries() {        header.position(PrologueFieldOffset.NUM_ENTRIES);        return header.getInt();    }     public boolean isAccessible() {        header.position(PrologueFieldOffset.ACCESSIBLE);        byte b = header.get();        return (b == 0 ? false : true);    }}