private object ReadType(CtfStruct strct, object[] result, CtfMetadataType type)
{
Align(type.Align);
switch (type.CtfType)
{
case CtfTypes.Array:
CtfArray array = (CtfArray)type;
int len = array.GetLength(strct, result);
object[] ret = new object[len];
for (int j = 0; j < len; j++)
{
ret[j] = ReadType(null, null, array.Type);
}
return(ret);
case CtfTypes.Enum:
return(ReadType(strct, result, ((CtfEnum)type).Type));
case CtfTypes.Float:
CtfFloat flt = (CtfFloat)type;
ReadBits(flt.Exp + flt.Mant);
return(0f); // TODO: Not implemented.
case CtfTypes.Integer:
CtfInteger ctfInt = (CtfInteger)type;
return(ReadInteger(ctfInt));
case CtfTypes.String:
bool ascii = ((CtfString)type).IsAscii;
return(ReadString(ascii));
case CtfTypes.Struct:
return(ReadStruct((CtfStruct)type));
case CtfTypes.Variant:
CtfVariant var = (CtfVariant)type;
int i = strct.GetFieldIndex(var.Switch);
CtfField field = strct.Fields[i];
CtfEnum enumType = (CtfEnum)field.Type;
int value = strct.GetFieldValue <int>(result, i);
string name = enumType.GetName(value);
field = var.Union.Where(f => f.Name == name).Single();
return(ReadType(strct, result, field.Type));
default:
throw new InvalidOperationException();
}
}
public static T ReadInt <T>(CtfMetadataType type, byte[] buffer, int bitOffset) where T : IConvertible
{
if (type.CtfType == CtfTypes.Enum)
{
type = ((CtfEnum)type).Type;
}
CtfInteger intType = (CtfInteger)type;
object result = intType.Read(buffer, bitOffset);
object converted = ((IConvertible)result).ToType(typeof(T), null);
return((T)converted);
}
public IEnumerable <CtfEventHeader> EnumerateEventHeaders()
{
CtfStruct header = _streamDefinition.EventHeader;
CtfEnum id = (CtfEnum)header.GetField("id").Type;
CtfVariant v = (CtfVariant)header.GetField("v").Type;
CtfStruct extended = (CtfStruct)v.GetVariant("extended").Type;
CtfInteger extendedId = (CtfInteger)extended.GetField("id").Type;
CtfInteger extendedTimestamp = (CtfInteger)extended.GetField("timestamp").Type;
CtfInteger compactTimestamp = (CtfInteger)((CtfStruct)v.GetVariant("compact").Type).GetField("timestamp").Type;
CtfInteger pid = null;
CtfInteger tid = null;
CtfArray processName = null;
string lastProcessName = "";
int processLen = 0;
CtfStruct eventContext = _streamDefinition.EventContext;
if (eventContext != null)
{
pid = (CtfInteger)eventContext.GetField("_vpid")?.Type;
tid = (CtfInteger)eventContext.GetField("_vtid")?.Type;
processName = (CtfArray)eventContext.GetField("_procname")?.Type;
// We only handle ascii process names, which seems to be the only thing lttng provides.
if (processName != null)
{
processLen = int.Parse(processName.Index);
Debug.Assert(processName.Type.GetSize() == 8);
if (processName.Type.GetSize() != 8)
{
processName = null;
}
}
}
uint extendedIdValue = (uint)id.GetValue("extended").End;
ulong lowMask = 0, highMask = 0, overflowBit = 0;
ulong lastTimestamp = 0;
while (!_eof)
{
if (_readHeader)
{
throw new InvalidOperationException("Must read an events data before reading the header again.");
}
_header.Clear();
ResetBuffer();
ReadStruct(header);
if (_eof)
{
break;
}
ulong timestamp;
uint event_id = CtfInteger.ReadInt <uint>(id.Type, _buffer, id.BitOffset);
if (event_id == extendedIdValue)
{
event_id = CtfInteger.ReadInt <uint>(extendedId, _buffer, extendedId.BitOffset);
timestamp = CtfInteger.ReadInt <ulong>(extendedTimestamp, _buffer, extendedTimestamp.BitOffset);
}
else
{
if (overflowBit == 0)
{
overflowBit = (1ul << compactTimestamp.Size);
lowMask = overflowBit - 1;
highMask = ~lowMask;
}
ulong uint27timestamp = CtfInteger.ReadInt <ulong>(compactTimestamp, _buffer, compactTimestamp.BitOffset);
ulong prevLowerBits = lastTimestamp & lowMask;
if (prevLowerBits < uint27timestamp)
{
timestamp = (lastTimestamp & highMask) | uint27timestamp;
}
else
{
timestamp = (lastTimestamp & highMask) | uint27timestamp;
timestamp += overflowBit;
}
}
lastTimestamp = timestamp;
CtfEvent evt = _streamDefinition.Events[(int)event_id];
_header.Event = evt;
_header.Timestamp = timestamp;
if (eventContext != null)
{
ReadStruct(eventContext);
if (pid != null)
{
_header.Pid = CtfInteger.ReadInt <int>(pid, _buffer, pid.BitOffset);
}
if (tid != null)
{
_header.Tid = CtfInteger.ReadInt <int>(tid, _buffer, tid.BitOffset);
}
bool matches = true;
int processNameOffset = processName.BitOffset >> 3;
if (_buffer[processNameOffset] == 0)
{
lastProcessName = string.Empty;
}
else
{
int len = 0;
for (; len < processLen && _buffer[processNameOffset + len] != 0; len++)
{
if (len >= lastProcessName.Length)
{
matches = false;
}
else
{
matches &= lastProcessName[len] == _buffer[processNameOffset + len];
}
}
if (!matches || len != lastProcessName.Length)
{
lastProcessName = Encoding.UTF8.GetString(_buffer, processName.BitOffset >> 3, len);
}
}
_header.ProcessName = lastProcessName;
}
_readHeader = true;
yield return(_header);
}
}
public void ReadTypeIntoBuffer(CtfStruct context, CtfMetadataType type)
{
Align(type.Align);
type.BitOffset = _bitOffset;
if (type.CtfType == CtfTypes.Enum)
{
type = ((CtfEnum)type).Type;
type.BitOffset = _bitOffset;
}
else if (type.CtfType != CtfTypes.Struct && type.CtfType != CtfTypes.Variant)
{
int size = type.GetSize();
if (size != CtfEvent.SizeIndeterminate)
{
ReadBits(size);
return;
}
}
switch (type.CtfType)
{
case CtfTypes.Array:
CtfArray array = (CtfArray)type;
var indexType = context.GetField(array.Index).Type;
int len = CtfInteger.ReadInt <int>(indexType, _buffer, indexType.BitOffset);
int elemSize = array.Type.GetSize();
if (elemSize == CtfEvent.SizeIndeterminate)
{
for (int j = 0; j < len; j++)
{
ReadTypeIntoBuffer(null, array.Type);
}
}
else
{
for (int j = 0; j < len; j++)
{
Align(type.Align);
ReadBits(elemSize);
}
}
break;
case CtfTypes.Float:
CtfFloat flt = (CtfFloat)type;
ReadBits(flt.Exp + flt.Mant);
break;
case CtfTypes.Integer:
CtfInteger ctfInt = (CtfInteger)type;
ReadBits(ctfInt.Size);
break;
case CtfTypes.String:
Debug.Assert((_bitOffset % 8) == 0);
int startOffset = _bitOffset >> 3;
int offset = startOffset;
ReadBits(8);
bool ascii = ((CtfString)type).IsAscii;
if (ascii)
{
while (_buffer[offset++] != 0)
{
ReadBits(8);
}
}
else
{
byte b = _buffer[offset];
while (b != 0)
{
switch (b)
{
default:
break;
case 0xc:
case 0xd:
ReadBits(8);
break;
case 0xe:
ReadBits(16);
break;
case 0xf:
ReadBits(24);
break;
}
offset = ReadBits(8) >> 3;
b = _buffer[offset];
}
}
int bufferLen = (_bitOffset >> 3) - startOffset;
Encoding encoding = ascii ? Encoding.ASCII : Encoding.UTF8;
byte[] newArr = Encoding.Convert(encoding, Encoding.Unicode, _buffer, startOffset, bufferLen);
((CtfString)type).Length = bufferLen;
if (_buffer.Length < _bufferLength + newArr.Length)
{
byte[] buffer = ReallocateBuffer(_bufferLength + newArr.Length);
System.Buffer.BlockCopy(buffer, 0, _buffer, 0, _bufferLength);
}
System.Buffer.BlockCopy(newArr, 0, _buffer, startOffset, newArr.Length);
_bufferLength = startOffset + newArr.Length;
_bitOffset = _bufferLength * 8;
break;
case CtfTypes.Struct:
ReadStruct((CtfStruct)type);
break;
case CtfTypes.Variant:
CtfVariant var = (CtfVariant)type;
CtfField field = context.GetField(var.Switch);
CtfEnum enumType = (CtfEnum)field.Type;
int value = CtfInteger.ReadInt <int>(enumType, _buffer, enumType.BitOffset);
string name = enumType.GetName(value);
field = var.GetVariant(name);
ReadTypeIntoBuffer(null, field.Type);
break;
default:
throw new InvalidOperationException();
}
}
private CtfMetadataDeclaration ParseOneDeclaration(string metadata, int index, out int end)
{
end = -1;
int open = metadata.IndexOf('{', index);
if (open == -1)
{
return(null);
}
int start = metadata.Substring(0, open).LastIndexOf('\n') + 1;
if (start == 0)
{
return(null);
}
CtfDeclarationTypes directive = CtfDeclarationTypes.Unknown;
string[] directiveElements = metadata.Substring(start, open - start).Trim().Split(' ');
string directiveString = directiveElements[0];
string name = null;
switch (directiveString)
{
case "trace":
directive = CtfDeclarationTypes.Trace;
break;
case "typealias":
directive = CtfDeclarationTypes.TypeAlias;
int closeBrace = FindCloseBrace(metadata, open) + 1;
CtfPropertyBag bag = GetPropertyBag(metadata, open, closeBrace);
CtfMetadataType t = null;
switch (directiveElements[1])
{
case "integer":
t = new CtfInteger(bag);
break;
default:
throw new IOException();
}
int colonEquals = metadata.IndexOf(":=", closeBrace) + 2;
int semi = colonEquals;
while (metadata[++semi] != ';')
{
;
}
name = metadata.Substring(colonEquals, semi - colonEquals).Trim();
end = semi + 1;
return(new CtfMetadataDeclaration(CtfDeclarationTypes.TypeAlias, t, name, directiveElements[1]));
case "env":
directive = CtfDeclarationTypes.Environment;
break;
case "clock":
directive = CtfDeclarationTypes.Clock;
break;
case "struct":
directive = CtfDeclarationTypes.Struct;
name = directiveElements[1];
break;
case "stream":
directive = CtfDeclarationTypes.Stream;
break;
case "event":
directive = CtfDeclarationTypes.Event;
break;
default:
break;
}
int close = FindCloseBrace(metadata, open);
int curr = close;
while (metadata[curr++] != ';')
{
;
}
int nameStart = metadata.IndexOf(":=", close);
if (name == null && nameStart != -1 && nameStart < curr)
{
nameStart += 2; // move past :=
name = metadata.Substring(nameStart, curr - nameStart - 1).Trim();
}
Debug.Assert(metadata[open] == '{');
Debug.Assert(metadata[close] == '}');
end = curr;
if (directive == CtfDeclarationTypes.Struct)
{
CtfPropertyBag bag = null;
Match match = s_align.Match(metadata, close, end - close);
if (match.Success)
{
bag = new CtfPropertyBag();
bag.AddValue("align", match.Groups[1].ToString());
}
CtfField[] fields = ParseStructFields(metadata, open, close).ToArray();
return(new CtfMetadataDeclaration(directive, bag, fields, name, metadata.Substring(index, curr - index)));
}
else
{
CtfPropertyBag properties = GetPropertyBag(metadata, open, close);
return(new CtfMetadataDeclaration(directive, properties, name, metadata.Substring(index, curr - index)));
}
}
private CtfMetadataType ParseOneType(string statement, out int index)
{
CtfMetadataType type = null;
Match match;
if ((match = s_integer.Match(statement)).Success)
{
Group group = match.Groups[1];
CtfPropertyBag bag = GetPropertyBag(group.ToString());
type = new CtfInteger(bag);
index = group.Index + group.Length;
}
else if ((match = s_struct.Match(statement)).Success)
{
var group = match.Groups[1];
if (group.ToString() != "{")
{
throw new InvalidOperationException();
}
int open = group.Index;
int close = FindCloseBrace(statement, open);
CtfField[] fields = ParseStructFields(statement, open, close).ToArray();
type = new CtfStruct(null, fields);
index = close + 1;
}
else if ((match = s_float.Match(statement)).Success)
{
int open = match.Index + match.Length - 1;
int close = FindCloseBrace(statement, open);
CtfPropertyBag bag = GetPropertyBag(statement, open, close);
type = new CtfFloat(bag);
index = close + 1;
}
else if ((match = s_variant.Match(statement)).Success)
{
string switchVariable = match.Groups[1].ToString();
int open = statement.IndexOf('{');
int close = FindCloseBrace(statement, open);
if (close == -1)
{
throw new InvalidOperationException();
}
CtfField[] fields = ParseStructFields(statement, open, close).ToArray();
type = new CtfVariant(switchVariable, fields);
index = close + 1;
}
else if ((match = s_variable.Match(statement)).Success)
{
var typeGroup = match.Groups[1];
string typeName = typeGroup.ToString().Trim();
if (typeName == "string")
{
type = new CtfString();
}
else
{
type = new CtfUnresolvedType(typeName);
}
index = typeGroup.Index + typeGroup.Length;
}
else if ((match = s_enum.Match(statement)).Success)
{
var groups = match.Groups;
string typeName = groups[1].ToString().Trim();
int open = statement.IndexOf('{');
int close = FindCloseBrace(statement, open);
if (close == -1)
{
throw new InvalidOperationException();
}
CtfNamedRange[] ranges = ParseNamedRanges(statement, open + 1, close).ToArray();
// TODO: Can enums just be an inline defined integer?
type = new CtfEnum(new CtfUnresolvedType(typeName), ranges);
index = close + 1;
}
else
{
// TODO: Floating point
index = 0;
return(null);
}
return(type);
}
public IEnumerable <CtfEventHeader> EnumerateEventHeaders()
{
CtfStruct header = _streamDefinition.EventHeader;
CtfVariant v = (CtfVariant)header.GetField("v").Type;
CtfStruct extended = (CtfStruct)v.GetVariant("extended").Type;
CtfStruct compact = (CtfStruct)v.GetVariant("compact").Type;
ulong lowMask = 0, highMask = 0, overflowBit = 0;
ulong lastTimestamp = 0;
StringBuilder processName = new StringBuilder();
while (!_eof)
{
if (_readHeader)
{
throw new InvalidOperationException("Must read an events data before reading the header again.");
}
_header.Clear();
ResetBuffer();
object[] result = ReadStruct(header);
if (_eof)
{
break;
}
ulong timestamp;
CtfEnum en = (CtfEnum)header.GetField("id").Type;
uint event_id = header.GetFieldValue <uint>(result, "id");
result = header.GetFieldValue <object[]>(result, "v");
if (en.GetName((int)event_id) == "extended")
{
event_id = extended.GetFieldValue <uint>(result, "id");
timestamp = extended.GetFieldValue <ulong>(result, "timestamp");
}
else
{
if (overflowBit == 0)
{
CtfInteger compactTimestamp = (CtfInteger)compact.GetField("timestamp").Type;
overflowBit = (1ul << compactTimestamp.Size);
lowMask = overflowBit - 1;
highMask = ~lowMask;
}
ulong uint27timestamp = compact.GetFieldValue <ulong>(result, "timestamp");
ulong prevLowerBits = lastTimestamp & lowMask;
if (prevLowerBits < uint27timestamp)
{
timestamp = (lastTimestamp & highMask) | uint27timestamp;
}
else
{
timestamp = (lastTimestamp & highMask) | uint27timestamp;
timestamp += overflowBit;
}
}
lastTimestamp = timestamp;
CtfEvent evt = _streamDefinition.Events[(int)event_id];
_header.Event = evt;
_header.Timestamp = timestamp;
CtfStruct eventContext = _streamDefinition.EventContext;
if (eventContext != null)
{
result = ReadStruct(eventContext);
_header.Pid = eventContext.GetFieldValue <int>(result, "_vpid");
_header.Tid = eventContext.GetFieldValue <int>(result, "_vtid");
int procnameIndex = eventContext.GetFieldIndex("_procname");
object[] procname = (object[])(result[procnameIndex]);
processName.Clear();
for (int i = 0; i < 17; i++)
{
sbyte b = (sbyte)procname[i];
if (b == 0)
{
break;
}
processName.Append((char)b);
}
_header.ProcessName = processName.ToString();
}
_readHeader = true;
yield return(_header);
}
}
private object ReadInteger(CtfInteger ctfInt)
{
if (ctfInt.Size > 64)
{
throw new NotImplementedException();
}
Align(ctfInt.Align);
int bitOffset = ReadBits(ctfInt.Size);
int byteOffset = bitOffset / 8;
bool fastPath = (_bitOffset % 8) == 0 && (ctfInt.Size % 8) == 0;
if (fastPath)
{
if (ctfInt.Size == 32)
{
if (ctfInt.Signed)
{
return(BitConverter.ToInt32(_buffer, byteOffset));
}
return(BitConverter.ToUInt32(_buffer, byteOffset));
}
if (ctfInt.Size == 8)
{
if (ctfInt.Signed)
{
return((sbyte)_buffer[byteOffset]);
}
return(_buffer[byteOffset]);
}
if (ctfInt.Size == 64)
{
if (ctfInt.Signed)
{
return(BitConverter.ToInt64(_buffer, byteOffset));
}
return(BitConverter.ToUInt64(_buffer, byteOffset));
}
Debug.Assert(ctfInt.Size == 16);
if (ctfInt.Signed)
{
return(BitConverter.ToInt16(_buffer, byteOffset));
}
return(BitConverter.ToUInt16(_buffer, byteOffset));
}
// Sloooow path for misaligned integers
int bits = ctfInt.Size;
ulong value = 0;
int byteLen = IntHelpers.AlignUp(bits, 8) / 8;
for (int i = 0; i < byteLen; i++)
{
value = unchecked ((value << 8) | _buffer[byteOffset + byteLen - i - 1]);
}
value >>= bitOffset;
value &= (ulong)((1 << bits) - 1);
if (ctfInt.Signed)
{
ulong signBit = (1u << (bits - 1));
if ((value & signBit) != 0)
{
value |= ulong.MaxValue << bits;
}
}
if (ctfInt.Size > 32)
{
if (ctfInt.Signed)
{
return((long)value);
}
return(value);
}
if (ctfInt.Size > 16)
{
if (ctfInt.Signed)
{
return((int)value);
}
return((uint)value);
}
if (ctfInt.Size > 8)
{
if (ctfInt.Signed)
{
return((short)value);
}
return((ushort)value);
}
if (ctfInt.Signed)
{
return((sbyte)value);
}
return((byte)value);
}
public override object Read(byte[] buffer)
{
int value = CtfInteger.ReadInt <int>(Type, buffer, BitOffset);
return(GetName(value));
}
