org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/StreamInput.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2013 Ericsson, Ecole Polytechnique de Montreal and others
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors: Matthew Khouzam - Initial API and implementation
  10  * Contributors: Simon Marchi - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.ctf.core.trace;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.nio.MappedByteBuffer;
  18 import java.nio.channels.FileChannel;
  19 import java.nio.channels.FileChannel.MapMode;
  20 import java.util.UUID;
  21
  22 import org.eclipse.linuxtools.ctf.core.event.io.BitBuffer;
  23 import org.eclipse.linuxtools.ctf.core.event.types.ArrayDefinition;
  24 import org.eclipse.linuxtools.ctf.core.event.types.Definition;
  25 import org.eclipse.linuxtools.ctf.core.event.types.EnumDefinition;
  26 import org.eclipse.linuxtools.ctf.core.event.types.FloatDefinition;
  27 import org.eclipse.linuxtools.ctf.core.event.types.IDefinitionScope;
  28 import org.eclipse.linuxtools.ctf.core.event.types.IntegerDefinition;
  29 import org.eclipse.linuxtools.ctf.core.event.types.StringDefinition;
  30 import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
  31 import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInputPacketIndex;
  32 import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInputPacketIndexEntry;
  33
  34 /**
  35  * <b><u>StreamInput</u></b>
  36  * <p>
  37  * Represents a trace file that belongs to a certain stream.
  38  * @since 2.0
  39  */
  40 public class StreamInput implements IDefinitionScope {
  41
  42     // ------------------------------------------------------------------------
  43     // Attributes
  44     // ------------------------------------------------------------------------
  45
  46     /**
  47      * The associated Stream
  48      */
  49     private final Stream stream;
  50
  51     /**
  52      * FileChannel to the trace file
  53      */
  54     private final FileChannel fileChannel;
  55
  56     /**
  57      * Information on the file (used for debugging)
  58      */
  59     private final File file;
  60
  61     /**
  62      * The packet index of this input
  63      */
  64     private final StreamInputPacketIndex index;
  65
  66     private long timestampEnd;
  67
  68     /*
  69      * Definition of trace packet header
  70      */
  71     private StructDefinition tracePacketHeaderDef = null;
  72
  73     /*
  74      * Definition of trace stream packet context
  75      */
  76     private StructDefinition streamPacketContextDef = null;
  77
  78     /*
  79      * Total number of lost events in this stream
  80      */
  81     private long lostSoFar = 0;
  82
  83     // ------------------------------------------------------------------------
  84     // Constructors
  85     // ------------------------------------------------------------------------
  86
  87     /**
  88      * Constructs a StreamInput.
  89      *
  90      * @param stream
  91      *            The stream to which this StreamInput belongs to.
  92      * @param fileChannel
  93      *            The FileChannel to the trace file.
  94      * @param file
  95      *            Information about the trace file (for debugging purposes).
  96      */
  97     public StreamInput(Stream stream, FileChannel fileChannel, File file) {
  98         this.stream = stream;
  99         this.fileChannel = fileChannel;
 100         this.file = file;
 101         this.index = stream.getTrace().getIndex(this);
 102     }
 103
 104     // ------------------------------------------------------------------------
 105     // Getters/Setters/Predicates
 106     // ------------------------------------------------------------------------
 107
 108     /**
 109      * Gets the stream the streamInput wrapper is wrapping
 110      *
 111      * @return the stream the streamInput wrapper is wrapping
 112      */
 113     public Stream getStream() {
 114         return stream;
 115     }
 116
 117     /**
 118      * the common streamInput Index
 119      *
 120      * @return the stream input Index
 121      */
 122     StreamInputPacketIndex getIndex() {
 123         return index;
 124     }
 125
 126     /**
 127      * Gets the filechannel of the streamInput. This is a limited Java
 128      * ressource.
 129      *
 130      * @return the filechannel
 131      */
 132     public FileChannel getFileChannel() {
 133         return fileChannel;
 134     }
 135
 136     /**
 137      * Gets the filename of the streamInput file.
 138      *
 139      * @return the filename of the streaminput file.
 140      */
 141     public String getFilename() {
 142         return file.getName();
 143     }
 144
 145     /**
 146      * gets the last read timestamp of a stream. (this is not necessarily the
 147      * last time in the stream.)
 148      *
 149      * @return the last read timestamp
 150      */
 151     public long getTimestampEnd() {
 152         return timestampEnd;
 153     }
 154
 155     /**
 156      * Sets the last read timestamp of a stream. (this is not necessarily the
 157      * last time in the stream.)
 158      *
 159      * @param timestampEnd
 160      *            the last read timestamp
 161      */
 162     public void setTimestampEnd(long timestampEnd) {
 163         this.timestampEnd = timestampEnd;
 164     }
 165
 166     /**
 167      * useless for streaminputs
 168      */
 169     @Override
 170     public String getPath() {
 171         return ""; //$NON-NLS-1$
 172     }
 173
 174     // ------------------------------------------------------------------------
 175     // Operations
 176     // ------------------------------------------------------------------------
 177
 178     @Override
 179     public Definition lookupDefinition(String lookupPath) {
 180         /* TODO: lookup in different dynamic scopes is not supported yet. */
 181         return null;
 182     }
 183
 184     /**
 185      * Create the index for this trace file.
 186      */
 187     public void setupIndex() {
 188
 189         /*
 190          * The BitBuffer to extract data from the StreamInput
 191          */
 192         BitBuffer bitBuffer = new BitBuffer();
 193         bitBuffer.setByteOrder(this.getStream().getTrace().getByteOrder());
 194
 195         /*
 196          * Create the definitions we need to read the packet headers + contexts
 197          */
 198         if (getStream().getTrace().getPacketHeader() != null) {
 199             tracePacketHeaderDef = getStream().getTrace().getPacketHeader()
 200                     .createDefinition(this, "trace.packet.header"); //$NON-NLS-1$
 201         }
 202
 203         if (getStream().getPacketContextDecl() != null) {
 204             streamPacketContextDef = getStream().getPacketContextDecl()
 205                     .createDefinition(this, "stream.packet.context"); //$NON-NLS-1$
 206         }
 207
 208     }
 209
 210     /**
 211      * Adds the next packet header index entry to the index of a stream input.
 212      *
 213      * @warning slow, can corrupt data if not used properly
 214      * @return true if there are more packets to add
 215      * @throws CTFReaderException
 216      *             If there was a problem reading the packed header
 217      */
 218     public boolean addPacketHeaderIndex() throws CTFReaderException {
 219         long currentPos = 0L;
 220         if (!index.getEntries().isEmpty()) {
 221             StreamInputPacketIndexEntry pos = index.getEntries().lastElement();
 222             currentPos = computeNextOffset(pos);
 223         }
 224         long fileSize = getStreamSize();
 225         if (currentPos < fileSize) {
 226             BitBuffer bitBuffer = new BitBuffer();
 227             bitBuffer.setByteOrder(this.getStream().getTrace().getByteOrder());
 228             StreamInputPacketIndexEntry packetIndex = new StreamInputPacketIndexEntry(
 229                     currentPos);
 230             createPacketIndexEntry(fileSize, currentPos, packetIndex,
 231                     tracePacketHeaderDef, streamPacketContextDef, bitBuffer);
 232             index.addEntry(packetIndex);
 233             return true;
 234         }
 235         return false;
 236     }
 237
 238     private long getStreamSize() {
 239         return file.length();
 240     }
 241
 242     private long createPacketIndexEntry(long fileSizeBytes,
 243             long packetOffsetBytes, StreamInputPacketIndexEntry packetIndex,
 244             StructDefinition tracePacketHeaderDef,
 245             StructDefinition streamPacketContextDef, BitBuffer bitBuffer)
 246             throws CTFReaderException {
 247
 248         /* Ignoring the return value, but this call is needed to initialize the input */
 249         createPacketBitBuffer(fileSizeBytes, packetOffsetBytes, packetIndex, bitBuffer);
 250
 251         /*
 252          * Read the trace packet header if it exists.
 253          */
 254         if (tracePacketHeaderDef != null) {
 255             parseTracePacketHeader(tracePacketHeaderDef, bitBuffer);
 256         }
 257
 258         /*
 259          * Read the stream packet context if it exists.
 260          */
 261         if (streamPacketContextDef != null) {
 262             parsePacketContext(fileSizeBytes, streamPacketContextDef,
 263                     bitBuffer, packetIndex);
 264         } else {
 265             setPacketContextNull(fileSizeBytes, packetIndex);
 266         }
 267
 268         /* Basic validation */
 269         if (packetIndex.getContentSizeBits() > packetIndex.getPacketSizeBits()) {
 270             throw new CTFReaderException("Content size > packet size"); //$NON-NLS-1$
 271         }
 272
 273         if (packetIndex.getPacketSizeBits() > ((fileSizeBytes - packetIndex
 274                 .getOffsetBytes()) * 8)) {
 275             throw new CTFReaderException(
 276                     "Not enough data remaining in the file for the size of this packet"); //$NON-NLS-1$
 277         }
 278
 279         /*
 280          * Offset in the file, in bits
 281          */
 282         packetIndex.setDataOffsetBits(bitBuffer.position());
 283
 284         /*
 285          * Update the counting packet offset
 286          */
 287         return computeNextOffset(packetIndex);
 288     }
 289
 290     /**
 291      * @param packetIndex
 292      * @return
 293      */
 294     private static long computeNextOffset(
 295             StreamInputPacketIndexEntry packetIndex) {
 296         return packetIndex.getOffsetBytes()
 297                 + ((packetIndex.getPacketSizeBits() + 7) / 8);
 298     }
 299
 300     /**
 301      * @param fileSizeBytes
 302      * @param packetOffsetBytes
 303      * @param packetIndex
 304      * @param bitBuffer
 305      * @return
 306      * @throws CTFReaderException
 307      */
 308     private MappedByteBuffer createPacketBitBuffer(long fileSizeBytes,
 309             long packetOffsetBytes, StreamInputPacketIndexEntry packetIndex,
 310             BitBuffer bitBuffer) throws CTFReaderException {
 311         /*
 312          * Initial size, it should map at least the packet header + context
 313          * size.
 314          *
 315          * TODO: use a less arbitrary size.
 316          */
 317         long mapSize = 4096;
 318         /*
 319          * If there is less data remaining than what we want to map, reduce the
 320          * map size.
 321          */
 322         if ((fileSizeBytes - packetIndex.getOffsetBytes()) < mapSize) {
 323             mapSize = fileSizeBytes - packetIndex.getOffsetBytes();
 324         }
 325
 326         /*
 327          * Map the packet.
 328          */
 329         MappedByteBuffer bb;
 330
 331         try {
 332             bb = fileChannel.map(MapMode.READ_ONLY, packetOffsetBytes, mapSize);
 333         } catch (IOException e) {
 334             throw new CTFReaderException(e);
 335         }
 336         bitBuffer.setByteBuffer(bb);
 337         return bb;
 338     }
 339
 340     private void parseTracePacketHeader(StructDefinition tracePacketHeaderDef,
 341             BitBuffer bitBuffer) throws CTFReaderException {
 342         tracePacketHeaderDef.read(bitBuffer);
 343
 344         /*
 345          * Check the CTF magic number
 346          */
 347         IntegerDefinition magicDef = (IntegerDefinition) tracePacketHeaderDef
 348                 .lookupDefinition("magic"); //$NON-NLS-1$
 349         if (magicDef != null) {
 350             int magic = (int) magicDef.getValue();
 351             if (magic != Utils.CTF_MAGIC) {
 352                 throw new CTFReaderException(
 353                         "CTF magic mismatch " + Integer.toHexString(magic) + " vs " + Integer.toHexString(Utils.CTF_MAGIC)); //$NON-NLS-1$//$NON-NLS-2$
 354             }
 355
 356         }
 357
 358         /*
 359          * Check the trace UUID
 360          */
 361         ArrayDefinition uuidDef =
 362                 (ArrayDefinition) tracePacketHeaderDef.lookupDefinition("uuid"); //$NON-NLS-1$
 363         if (uuidDef != null) {
 364             byte[] uuidArray = new byte[16];
 365
 366             for (int i = 0; i < uuidArray.length; i++) {
 367                 IntegerDefinition uuidByteDef = (IntegerDefinition) uuidDef.getElem(i);
 368                 uuidArray[i] = (byte) uuidByteDef.getValue();
 369             }
 370
 371             UUID uuid = Utils.makeUUID(uuidArray);
 372
 373             if (!getStream().getTrace().getUUID().equals(uuid)) {
 374                 throw new CTFReaderException("UUID mismatch"); //$NON-NLS-1$
 375             }
 376         }
 377
 378         /*
 379          * Check that the stream id did not change
 380          */
 381         IntegerDefinition streamIDDef = (IntegerDefinition) tracePacketHeaderDef
 382                 .lookupDefinition("stream_id"); //$NON-NLS-1$
 383         if (streamIDDef != null) {
 384             long streamID = streamIDDef.getValue();
 385
 386             if (streamID != getStream().getId()) {
 387                 throw new CTFReaderException(
 388                         "Stream ID changing within a StreamInput"); //$NON-NLS-1$
 389             }
 390         }
 391     }
 392
 393     private static void setPacketContextNull(long fileSizeBytes,
 394             StreamInputPacketIndexEntry packetIndex) {
 395         /*
 396          * If there is no packet context, infer the content and packet size from
 397          * the file size (assume that there is only one packet and no padding)
 398          */
 399         packetIndex.setContentSizeBits(fileSizeBytes * 8);
 400         packetIndex.setPacketSizeBits(fileSizeBytes * 8);
 401     }
 402
 403     private void parsePacketContext(long fileSizeBytes,
 404             StructDefinition streamPacketContextDef, BitBuffer bitBuffer,
 405             StreamInputPacketIndexEntry packetIndex) {
 406         streamPacketContextDef.read(bitBuffer);
 407
 408         for (String field : streamPacketContextDef.getDeclaration()
 409                 .getFieldsList()) {
 410             Definition id = streamPacketContextDef.lookupDefinition(field);
 411             if (id instanceof IntegerDefinition) {
 412                 packetIndex.addAttribute(field,
 413                         ((IntegerDefinition) id).getValue());
 414             } else if (id instanceof FloatDefinition) {
 415                 packetIndex.addAttribute(field,
 416                         ((FloatDefinition) id).getValue());
 417             } else if (id instanceof EnumDefinition) {
 418                 packetIndex.addAttribute(field,
 419                         ((EnumDefinition) id).getValue());
 420             } else if (id instanceof StringDefinition) {
 421                 packetIndex.addAttribute(field,
 422                         ((StringDefinition) id).getValue());
 423             }
 424         }
 425
 426         Long contentSize = (Long) packetIndex.lookupAttribute("content_size"); //$NON-NLS-1$
 427         Long packetSize = (Long) packetIndex.lookupAttribute("packet_size"); //$NON-NLS-1$
 428         Long tsBegin = (Long) packetIndex.lookupAttribute("timestamp_begin"); //$NON-NLS-1$
 429         Long tsEnd = (Long) packetIndex.lookupAttribute("timestamp_end"); //$NON-NLS-1$
 430         String device = (String) packetIndex.lookupAttribute("device"); //$NON-NLS-1$
 431         // LTTng Specific
 432         Long cpuId = (Long) packetIndex.lookupAttribute("cpu_id"); //$NON-NLS-1$
 433         Long lostEvents = (Long) packetIndex.lookupAttribute("events_discarded");  //$NON-NLS-1$
 434
 435         /* Read the content size in bits */
 436         if (contentSize != null) {
 437             packetIndex.setContentSizeBits(contentSize.intValue());
 438         } else {
 439             packetIndex.setContentSizeBits((int) (fileSizeBytes * 8));
 440         }
 441
 442         /* Read the packet size in bits */
 443         if (packetSize != null) {
 444             packetIndex.setPacketSizeBits(packetSize.intValue());
 445         } else {
 446             if (packetIndex.getContentSizeBits() != 0) {
 447                 packetIndex.setPacketSizeBits(packetIndex.getContentSizeBits());
 448             } else {
 449                 packetIndex.setPacketSizeBits((int) (fileSizeBytes * 8));
 450             }
 451         }
 452
 453         /* Read the begin timestamp */
 454         if (tsBegin != null) {
 455             packetIndex.setTimestampBegin(tsBegin.longValue());
 456         }
 457
 458         /* Read the end timestamp */
 459         if (tsEnd != null) {
 460             if( tsEnd == -1 ) {
 461                 tsEnd = Long.MAX_VALUE;
 462             }
 463             packetIndex.setTimestampEnd(tsEnd.longValue());
 464             setTimestampEnd(packetIndex.getTimestampEnd());
 465         }
 466
 467         if (device != null) {
 468             packetIndex.setTarget(device);
 469         }
 470
 471         if (cpuId != null) {
 472             packetIndex.setTarget("CPU" + cpuId.toString()); //$NON-NLS-1$
 473         }
 474
 475         if (lostEvents != null) {
 476             packetIndex.setLostEvents(lostEvents - lostSoFar);
 477             this.lostSoFar = lostEvents;
 478         }
 479     }
 480
 481     @Override
 482     public int hashCode() {
 483         final int prime = 31;
 484         int result = 1;
 485         result = (prime * result) + ((file == null) ? 0 : file.hashCode());
 486         return result;
 487     }
 488
 489     @Override
 490     public boolean equals(Object obj) {
 491         if (this == obj) {
 492             return true;
 493         }
 494         if (obj == null) {
 495             return false;
 496         }
 497         if (!(obj instanceof StreamInput)) {
 498             return false;
 499         }
 500         StreamInput other = (StreamInput) obj;
 501         if (file == null) {
 502             if (other.file != null) {
 503                 return false;
 504             }
 505         } else if (!file.equals(other.file)) {
 506             return false;
 507         }
 508         return true;
 509     }
 510
 511 }