1 /*
   2  * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.jfr.consumer;
  27 
  28 import java.io.IOException;
  29 import java.util.Collection;
  30 import java.util.List;
  31 
  32 import jdk.jfr.EventType;
  33 import jdk.jfr.internal.LogLevel;
  34 import jdk.jfr.internal.LogTag;
  35 import jdk.jfr.internal.Logger;
  36 import jdk.jfr.internal.MetadataDescriptor;
  37 import jdk.jfr.internal.Type;
  38 import jdk.jfr.internal.consumer.ChunkHeader;
  39 import jdk.jfr.internal.consumer.RecordingInput;
  40 
  41 /**
  42  * Parses a chunk.
  43  *
  44  */
  45 final class ChunkParser {
  46     private static final long CONSTANT_POOL_TYPE_ID = 1;
  47     private final RecordingInput input;
  48     private final LongMap<Parser> parsers;
  49     private final ChunkHeader chunkHeader;
  50     private final long absoluteChunkEnd;
  51     private final MetadataDescriptor metadata;
  52     private final LongMap<Type> typeMap;
  53     private final TimeConverter timeConverter;
  54 
  55     public ChunkParser(RecordingInput input) throws IOException {
  56         this(new ChunkHeader(input));
  57     }
  58 
  59     private ChunkParser(ChunkHeader header) throws IOException {
  60         this.input = header.getInput();
  61         this.chunkHeader = header;
  62         this.metadata = header.readMetadata();
  63         this.absoluteChunkEnd = header.getEnd();
  64         this.timeConverter = new TimeConverter(chunkHeader, metadata.getGMTOffset());
  65 
  66         ParserFactory factory = new ParserFactory(metadata, timeConverter);
  67         LongMap<ConstantMap> constantPools = factory.getConstantPools();
  68         parsers = factory.getParsers();
  69         typeMap = factory.getTypeMap();
  70 
  71         fillConstantPools(parsers, constantPools);
  72         constantPools.forEach(ConstantMap::setIsResolving);
  73         constantPools.forEach(ConstantMap::resolve);
  74         constantPools.forEach(ConstantMap::setResolved);
  75 
  76         input.position(chunkHeader.getEventStart());
  77     }
  78 
  79     public RecordedEvent readEvent() throws IOException {
  80         while (input.position() < absoluteChunkEnd) {
  81             long pos = input.position();
  82             int size = input.readInt();
  83             if (size == 0) {
  84                 throw new IOException("Event can't have zero size");
  85             }
  86             long typeId = input.readLong();
  87             if (typeId > CONSTANT_POOL_TYPE_ID) { // also skips metadata (id=0)
  88                 Parser ep = parsers.get(typeId);
  89                 if (ep instanceof EventParser) {
  90                     return (RecordedEvent) ep.parse(input);
  91                 }
  92             }
  93             input.position(pos + size);
  94         }
  95         return null;
  96     }
  97 
  98     private void fillConstantPools(LongMap<Parser> typeParser, LongMap<ConstantMap> constantPools) throws IOException {
  99         long nextCP = chunkHeader.getAbsoluteChunkStart();
 100         long deltaToNext = chunkHeader.getConstantPoolPosition();
 101         while (deltaToNext != 0) {
 102             nextCP += deltaToNext;
 103             input.position(nextCP);
 104             final long position = nextCP;
 105             int size = input.readInt(); // size
 106             long typeId = input.readLong();
 107             if (typeId != CONSTANT_POOL_TYPE_ID) {
 108                 throw new IOException("Expected check point event (id = 1) at position " + nextCP + ", but found type id = " + typeId);
 109             }
 110             input.readLong(); // timestamp
 111             input.readLong(); // duration
 112             deltaToNext = input.readLong();
 113             final long delta = deltaToNext;
 114             boolean flush = input.readBoolean();
 115             int poolCount = input.readInt();
 116             Logger.log(LogTag.JFR_SYSTEM_PARSER, LogLevel.TRACE, () -> {
 117                 return "New constant pool: startPosition=" + position + ", size=" + size + ", deltaToNext=" + delta + ", flush=" + flush + ", poolCount=" + poolCount;
 118             });
 119 
 120             for (int i = 0; i < poolCount; i++) {
 121                 long id = input.readLong(); // type id
 122                 ConstantMap pool = constantPools.get(id);
 123                 Type type = typeMap.get(id);
 124                 if (pool == null) {
 125                     Logger.log(LogTag.JFR_SYSTEM_PARSER, LogLevel.INFO, "Found constant pool(" + id + ") that is never used");
 126                     if (type == null) {
 127                         throw new IOException("Error parsing constant pool type " + getName(id) + " at position " + input.position() + " at check point between [" + nextCP + ", " + nextCP + size + "]");
 128                     }
 129                     pool = new ConstantMap(ObjectFactory.create(type, timeConverter), type.getName());
 130                     constantPools.put(type.getId(), pool);
 131                 }
 132                 Parser parser = typeParser.get(id);
 133                 if (parser == null) {
 134                     throw new IOException("Could not find constant pool type with id = " + id);
 135                 }
 136                 try {
 137                     int count = input.readInt();
 138                     Logger.log(LogTag.JFR_SYSTEM_PARSER, LogLevel.TRACE, () -> "Constant: " + getName(id) + "[" + count + "]");
 139                     for (int j = 0; j < count; j++) {
 140                         long key = input.readLong();
 141                         Object value = parser.parse(input);
 142                         pool.put(key, value);
 143                     }
 144                 } catch (Exception e) {
 145                     throw new IOException("Error parsing constant pool type " + getName(id) + " at position " + input.position() + " at check point between [" + nextCP + ", " + nextCP + size + "]", e);
 146                 }
 147             }
 148             if (input.position() != nextCP + size) {
 149                 throw new IOException("Size of check point event doesn't match content");
 150             }
 151         }
 152     }
 153 
 154     private String getName(long id) {
 155         Type type = typeMap.get(id);
 156         return type == null ? ("unknown(" + id + ")") : type.getName();
 157     }
 158 
 159     public Collection<Type> getTypes() {
 160         return metadata.getTypes();
 161     }
 162 
 163     public List<EventType> getEventTypes() {
 164         return metadata.getEventTypes();
 165     }
 166 
 167     public boolean isLastChunk() {
 168         return chunkHeader.isLastChunk();
 169     }
 170 
 171     public ChunkParser nextChunkParser() throws IOException {
 172         return new ChunkParser(chunkHeader.nextHeader());
 173     }
 174 }